text stringlengths 8 4.13M |
|---|
extern crate gotham;
#[macro_use]
extern crate gotham_derive;
extern crate hyper;
extern crate futures;
extern crate mime;
extern crate serde;
#[macro_use]
extern crate serde_derive;
extern crate serde_json;
mod api;
mod todo;
/// Start a server and call the `Handler` we've defined above for each `Request` we receive.
pub fn main() {
let addr = "127.0.0.1:7878";
println!("Listening for requests at http://{}", addr);
gotham::start(addr, || Ok(api::router::build_router()))
}
|
use yew::prelude::*;
use yew_functional::*;
#[function_component(RiStickyNotes)]
pub fn ri_stick_notes() -> Html {
html! {
<svg xmlns="http://www.w3.org/2000/svg" width="1.2em" height="1.2em" preserveAspectRatio="xMidYMid meet" viewBox="0 0 24 24" style="vertical-align: middle; transform: translateY(-5%);"><path d="M21 15l-6 5.996L4.002 21A.998.998 0 0 1 3 20.007V3.993C3 3.445 3.445 3 3.993 3h16.014c.548 0 .993.456.993 1.002V15zM19 5H5v14h8v-5a1 1 0 0 1 .883-.993L14 13l5-.001V5zm-.829 9.999L15 15v3.169l3.171-3.17z" fill="currentColor"></path></svg>
}
}
|
use std::collections::HashMap;
use std::env;
use std::path::PathBuf;
use build_util::{
compile_shader,
compile_shaders,
copy_directory_rec,
};
fn main() {
let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
// Copy shaders over
let mut shader_dest_dir = manifest_dir.clone();
shader_dest_dir.push("shaders");
if !shader_dest_dir.exists() {
std::fs::create_dir(&shader_dest_dir).expect("Failed to create shader target directory.");
}
let mut shader_dir = manifest_dir.clone();
shader_dir.pop();
shader_dir.pop();
shader_dir.push("engine");
shader_dir.push("shaders");
compile_shaders(
&shader_dir,
&shader_dest_dir,
true,
false,
&HashMap::new(),
|_| true,
);
let mut fsr_shader_dir = manifest_dir.clone();
fsr_shader_dir.pop();
fsr_shader_dir.pop();
fsr_shader_dir.push("vendor");
fsr_shader_dir.push("fsr2");
fsr_shader_dir.push("FidelityFX-FSR2");
fsr_shader_dir.push("src");
fsr_shader_dir.push("ffx-fsr2-api");
fsr_shader_dir.push("shaders");
let mut map = HashMap::new();
map.insert("FFX_GPU".to_string(), "1".to_string());
map.insert("FFX_GLSL".to_string(), "1".to_string());
map.insert(
"FFX_FSR2_OPTION_LOW_RESOLUTION_MOTION_VECTORS".to_string(),
"1".to_string(),
);
map.insert(
"FFX_FSR2_OPTION_HDR_COLOR_INPUT".to_string(),
"1".to_string(),
);
compile_shaders(&fsr_shader_dir, &shader_dest_dir, true, false, &map, |f| {
f.extension()
.and_then(|ext| ext.to_str())
.map(|ext| ext == "glsl")
.unwrap_or_default()
});
let mut accumulate_sharpen_path = fsr_shader_dir.clone();
accumulate_sharpen_path.push("ffx_fsr2_accumulate_pass.glsl");
let mut accumulate_sharpen_compiled_path = shader_dest_dir.clone();
accumulate_sharpen_compiled_path.push("ffx_fsr2_accumulate_sharpen_pass.spv");
map.insert(
"FFX_FSR2_OPTION_APPLY_SHARPENING".to_string(),
"1".to_string(),
);
compile_shader(
&accumulate_sharpen_path,
&accumulate_sharpen_compiled_path,
true,
&map,
);
let mut assets_dest_dir = manifest_dir.clone();
assets_dest_dir.push("assets");
if !assets_dest_dir.exists() {
std::fs::create_dir(&assets_dest_dir).expect("Failed to create shader target directory.");
}
let mut assets_dir = manifest_dir.clone();
assets_dir.pop();
assets_dir.pop();
assets_dir.push("engine");
assets_dir.push("assets");
copy_directory_rec(&assets_dir, &assets_dest_dir, &(|_| true));
// Copy SDL2.dll
let target = env::var("TARGET").unwrap();
if target.contains("pc-windows") {
let mut lib_dir = manifest_dir.clone();
let mut dll_dir = manifest_dir.clone();
if target.contains("msvc") {
lib_dir.push("msvc");
dll_dir.push("msvc");
} else {
lib_dir.push("gnu-mingw");
dll_dir.push("gnu-mingw");
}
lib_dir.push("lib");
dll_dir.push("dll");
println!("cargo:rustc-link-search=all={}", lib_dir.display());
for entry in std::fs::read_dir(dll_dir).expect("Can't read DLL dir") {
let entry_path = entry.expect("Invalid fs entry").path();
let file_name_result = entry_path.file_name();
let mut new_file_path = manifest_dir.clone();
if let Some(file_name) = file_name_result {
let file_name = file_name.to_str().unwrap();
if file_name.ends_with(".dll") {
new_file_path.push(file_name);
std::fs::copy(&entry_path, &new_file_path).expect("Can't copy from DLL dir");
}
}
}
}
}
|
//! Text diffing utilities.
use std::borrow::Cow;
use std::cmp::Reverse;
use std::collections::BinaryHeap;
use std::time::{Duration, Instant};
mod abstraction;
#[cfg(feature = "inline")]
mod inline;
mod utils;
pub use self::abstraction::{DiffableStr, DiffableStrRef};
#[cfg(feature = "inline")]
pub use self::inline::InlineChange;
use self::utils::{upper_seq_ratio, QuickSeqRatio};
use crate::algorithms::IdentifyDistinct;
use crate::iter::{AllChangesIter, ChangesIter};
use crate::udiff::UnifiedDiff;
use crate::{capture_diff_deadline, get_diff_ratio, group_diff_ops, Algorithm, DiffOp};
#[derive(Debug, Clone, Copy)]
enum Deadline {
Absolute(Instant),
Relative(Duration),
}
impl Deadline {
fn into_instant(self) -> Instant {
match self {
Deadline::Absolute(instant) => instant,
Deadline::Relative(duration) => Instant::now() + duration,
}
}
}
/// A builder type config for more complex uses of [`TextDiff`].
///
/// Requires the `text` feature.
#[derive(Clone, Debug, Default)]
pub struct TextDiffConfig {
algorithm: Algorithm,
newline_terminated: Option<bool>,
deadline: Option<Deadline>,
}
impl TextDiffConfig {
/// Changes the algorithm.
///
/// The default algorithm is [`Algorithm::Myers`].
pub fn algorithm(&mut self, alg: Algorithm) -> &mut Self {
self.algorithm = alg;
self
}
/// Sets a deadline for the diff operation.
///
/// By default a diff will take as long as it takes. For certain diff
/// algorithms like Myer's and Patience a maximum running time can be
/// defined after which the algorithm gives up and approximates.
pub fn deadline(&mut self, deadline: Instant) -> &mut Self {
self.deadline = Some(Deadline::Absolute(deadline));
self
}
/// Sets a timeout for thediff operation.
///
/// This is like [`deadline`](Self::deadline) but accepts a duration.
pub fn timeout(&mut self, timeout: Duration) -> &mut Self {
self.deadline = Some(Deadline::Relative(timeout));
self
}
/// Changes the newline termination flag.
///
/// The default is automatic based on input. This flag controls the
/// behavior of [`TextDiff::iter_changes`] and unified diff generation
/// with regards to newlines. When the flag is set to `false` (which
/// is the default) then newlines are added. Otherwise the newlines
/// from the source sequences are reused.
pub fn newline_terminated(&mut self, yes: bool) -> &mut Self {
self.newline_terminated = Some(yes);
self
}
/// Creates a diff of lines.
///
/// This splits the text `old` and `new` into lines preserving newlines
/// in the input. Line diffs are very common and because of that enjoy
/// special handling in similar. When a line diff is created with this
/// method the `newline_terminated` flag is flipped to `true` and will
/// influence the behavior of unified diff generation.
///
/// ```rust
/// use similar::{TextDiff, ChangeTag};
///
/// let diff = TextDiff::configure().diff_lines("a\nb\nc", "a\nb\nC");
/// let changes: Vec<_> = diff
/// .iter_all_changes()
/// .map(|x| (x.tag(), x.value()))
/// .collect();
///
/// assert_eq!(changes, vec![
/// (ChangeTag::Equal, "a\n"),
/// (ChangeTag::Equal, "b\n"),
/// (ChangeTag::Delete, "c"),
/// (ChangeTag::Insert, "C"),
/// ]);
/// ```
pub fn diff_lines<'old, 'new, 'bufs, T: DiffableStrRef + ?Sized>(
&self,
old: &'old T,
new: &'new T,
) -> TextDiff<'old, 'new, 'bufs, T::Output> {
self.diff(
Cow::Owned(old.as_diffable_str().tokenize_lines()),
Cow::Owned(new.as_diffable_str().tokenize_lines()),
true,
)
}
/// Creates a diff of words.
///
/// This splits the text into words and whitespace.
///
/// Note on word diffs: because the text differ will tokenize the strings
/// into small segments it can be inconvenient to work with the results
/// depending on the use case. You might also want to combine word level
/// diffs with the [`TextDiffRemapper`](crate::utils::TextDiffRemapper)
/// which lets you remap the diffs back to the original input strings.
///
/// ```rust
/// use similar::{TextDiff, ChangeTag};
///
/// let diff = TextDiff::configure().diff_words("foo bar baz", "foo BAR baz");
/// let changes: Vec<_> = diff
/// .iter_all_changes()
/// .map(|x| (x.tag(), x.value()))
/// .collect();
///
/// assert_eq!(changes, vec![
/// (ChangeTag::Equal, "foo"),
/// (ChangeTag::Equal, " "),
/// (ChangeTag::Delete, "bar"),
/// (ChangeTag::Insert, "BAR"),
/// (ChangeTag::Equal, " "),
/// (ChangeTag::Equal, "baz"),
/// ]);
/// ```
pub fn diff_words<'old, 'new, 'bufs, T: DiffableStrRef + ?Sized>(
&self,
old: &'old T,
new: &'new T,
) -> TextDiff<'old, 'new, 'bufs, T::Output> {
self.diff(
Cow::Owned(old.as_diffable_str().tokenize_words()),
Cow::Owned(new.as_diffable_str().tokenize_words()),
false,
)
}
/// Creates a diff of characters.
///
/// Note on character diffs: because the text differ will tokenize the strings
/// into small segments it can be inconvenient to work with the results
/// depending on the use case. You might also want to combine word level
/// diffs with the [`TextDiffRemapper`](crate::utils::TextDiffRemapper)
/// which lets you remap the diffs back to the original input strings.
///
/// ```rust
/// use similar::{TextDiff, ChangeTag};
///
/// let diff = TextDiff::configure().diff_chars("abcdef", "abcDDf");
/// let changes: Vec<_> = diff
/// .iter_all_changes()
/// .map(|x| (x.tag(), x.value()))
/// .collect();
///
/// assert_eq!(changes, vec![
/// (ChangeTag::Equal, "a"),
/// (ChangeTag::Equal, "b"),
/// (ChangeTag::Equal, "c"),
/// (ChangeTag::Delete, "d"),
/// (ChangeTag::Delete, "e"),
/// (ChangeTag::Insert, "D"),
/// (ChangeTag::Insert, "D"),
/// (ChangeTag::Equal, "f"),
/// ]);
/// ```
pub fn diff_chars<'old, 'new, 'bufs, T: DiffableStrRef + ?Sized>(
&self,
old: &'old T,
new: &'new T,
) -> TextDiff<'old, 'new, 'bufs, T::Output> {
self.diff(
Cow::Owned(old.as_diffable_str().tokenize_chars()),
Cow::Owned(new.as_diffable_str().tokenize_chars()),
false,
)
}
/// Creates a diff of unicode words.
///
/// This splits the text into words according to unicode rules. This is
/// generally recommended over [`TextDiffConfig::diff_words`] but
/// requires a dependency.
///
/// This requires the `unicode` feature.
///
/// Note on word diffs: because the text differ will tokenize the strings
/// into small segments it can be inconvenient to work with the results
/// depending on the use case. You might also want to combine word level
/// diffs with the [`TextDiffRemapper`](crate::utils::TextDiffRemapper)
/// which lets you remap the diffs back to the original input strings.
///
/// ```rust
/// use similar::{TextDiff, ChangeTag};
///
/// let diff = TextDiff::configure().diff_unicode_words("ah(be)ce", "ah(ah)ce");
/// let changes: Vec<_> = diff
/// .iter_all_changes()
/// .map(|x| (x.tag(), x.value()))
/// .collect();
///
/// assert_eq!(changes, vec![
/// (ChangeTag::Equal, "ah"),
/// (ChangeTag::Equal, "("),
/// (ChangeTag::Delete, "be"),
/// (ChangeTag::Insert, "ah"),
/// (ChangeTag::Equal, ")"),
/// (ChangeTag::Equal, "ce"),
/// ]);
/// ```
#[cfg(feature = "unicode")]
pub fn diff_unicode_words<'old, 'new, 'bufs, T: DiffableStrRef + ?Sized>(
&self,
old: &'old T,
new: &'new T,
) -> TextDiff<'old, 'new, 'bufs, T::Output> {
self.diff(
Cow::Owned(old.as_diffable_str().tokenize_unicode_words()),
Cow::Owned(new.as_diffable_str().tokenize_unicode_words()),
false,
)
}
/// Creates a diff of graphemes.
///
/// This requires the `unicode` feature.
///
/// Note on grapheme diffs: because the text differ will tokenize the strings
/// into small segments it can be inconvenient to work with the results
/// depending on the use case. You might also want to combine word level
/// diffs with the [`TextDiffRemapper`](crate::utils::TextDiffRemapper)
/// which lets you remap the diffs back to the original input strings.
///
/// ```rust
/// use similar::{TextDiff, ChangeTag};
///
/// let diff = TextDiff::configure().diff_graphemes("💩🇦🇹🦠", "💩🇦🇱❄️");
/// let changes: Vec<_> = diff
/// .iter_all_changes()
/// .map(|x| (x.tag(), x.value()))
/// .collect();
///
/// assert_eq!(changes, vec![
/// (ChangeTag::Equal, "💩"),
/// (ChangeTag::Delete, "🇦🇹"),
/// (ChangeTag::Delete, "🦠"),
/// (ChangeTag::Insert, "🇦🇱"),
/// (ChangeTag::Insert, "❄️"),
/// ]);
/// ```
#[cfg(feature = "unicode")]
pub fn diff_graphemes<'old, 'new, 'bufs, T: DiffableStrRef + ?Sized>(
&self,
old: &'old T,
new: &'new T,
) -> TextDiff<'old, 'new, 'bufs, T::Output> {
self.diff(
Cow::Owned(old.as_diffable_str().tokenize_graphemes()),
Cow::Owned(new.as_diffable_str().tokenize_graphemes()),
false,
)
}
/// Creates a diff of arbitrary slices.
///
/// ```rust
/// use similar::{TextDiff, ChangeTag};
///
/// let old = &["foo", "bar", "baz"];
/// let new = &["foo", "BAR", "baz"];
/// let diff = TextDiff::configure().diff_slices(old, new);
/// let changes: Vec<_> = diff
/// .iter_all_changes()
/// .map(|x| (x.tag(), x.value()))
/// .collect();
///
/// assert_eq!(changes, vec![
/// (ChangeTag::Equal, "foo"),
/// (ChangeTag::Delete, "bar"),
/// (ChangeTag::Insert, "BAR"),
/// (ChangeTag::Equal, "baz"),
/// ]);
/// ```
pub fn diff_slices<'old, 'new, 'bufs, T: DiffableStr + ?Sized>(
&self,
old: &'bufs [&'old T],
new: &'bufs [&'new T],
) -> TextDiff<'old, 'new, 'bufs, T> {
self.diff(Cow::Borrowed(old), Cow::Borrowed(new), false)
}
fn diff<'old, 'new, 'bufs, T: DiffableStr + ?Sized>(
&self,
old: Cow<'bufs, [&'old T]>,
new: Cow<'bufs, [&'new T]>,
newline_terminated: bool,
) -> TextDiff<'old, 'new, 'bufs, T> {
let deadline = self.deadline.map(|x| x.into_instant());
let ops = if old.len() > 100 || new.len() > 100 {
let ih = IdentifyDistinct::<u32>::new(&old[..], 0..old.len(), &new[..], 0..new.len());
capture_diff_deadline(
self.algorithm,
ih.old_lookup(),
ih.old_range(),
ih.new_lookup(),
ih.new_range(),
deadline,
)
} else {
capture_diff_deadline(
self.algorithm,
&old[..],
0..old.len(),
&new[..],
0..new.len(),
deadline,
)
};
TextDiff {
old,
new,
ops,
newline_terminated: self.newline_terminated.unwrap_or(newline_terminated),
algorithm: self.algorithm,
}
}
}
/// Captures diff op codes for textual diffs.
///
/// The exact diff behavior is depending on the underlying [`DiffableStr`].
/// For instance diffs on bytes and strings are slightly different. You can
/// create a text diff from constructors such as [`TextDiff::from_lines`] or
/// the [`TextDiffConfig`] created by [`TextDiff::configure`].
///
/// Requires the `text` feature.
pub struct TextDiff<'old, 'new, 'bufs, T: DiffableStr + ?Sized> {
old: Cow<'bufs, [&'old T]>,
new: Cow<'bufs, [&'new T]>,
ops: Vec<DiffOp>,
newline_terminated: bool,
algorithm: Algorithm,
}
impl<'old, 'new, 'bufs> TextDiff<'old, 'new, 'bufs, str> {
/// Configures a text differ before diffing.
pub fn configure() -> TextDiffConfig {
TextDiffConfig::default()
}
/// Creates a diff of lines.
///
/// For more information see [`TextDiffConfig::diff_lines`].
pub fn from_lines<T: DiffableStrRef + ?Sized>(
old: &'old T,
new: &'new T,
) -> TextDiff<'old, 'new, 'bufs, T::Output> {
TextDiff::configure().diff_lines(old, new)
}
/// Creates a diff of words.
///
/// For more information see [`TextDiffConfig::diff_words`].
pub fn from_words<T: DiffableStrRef + ?Sized>(
old: &'old T,
new: &'new T,
) -> TextDiff<'old, 'new, 'bufs, T::Output> {
TextDiff::configure().diff_words(old, new)
}
/// Creates a diff of chars.
///
/// For more information see [`TextDiffConfig::diff_chars`].
pub fn from_chars<T: DiffableStrRef + ?Sized>(
old: &'old T,
new: &'new T,
) -> TextDiff<'old, 'new, 'bufs, T::Output> {
TextDiff::configure().diff_chars(old, new)
}
/// Creates a diff of unicode words.
///
/// For more information see [`TextDiffConfig::diff_unicode_words`].
///
/// This requires the `unicode` feature.
#[cfg(feature = "unicode")]
pub fn from_unicode_words<T: DiffableStrRef + ?Sized>(
old: &'old T,
new: &'new T,
) -> TextDiff<'old, 'new, 'bufs, T::Output> {
TextDiff::configure().diff_unicode_words(old, new)
}
/// Creates a diff of graphemes.
///
/// For more information see [`TextDiffConfig::diff_graphemes`].
///
/// This requires the `unicode` feature.
#[cfg(feature = "unicode")]
pub fn from_graphemes<T: DiffableStrRef + ?Sized>(
old: &'old T,
new: &'new T,
) -> TextDiff<'old, 'new, 'bufs, T::Output> {
TextDiff::configure().diff_graphemes(old, new)
}
}
impl<'old, 'new, 'bufs, T: DiffableStr + ?Sized + 'old + 'new> TextDiff<'old, 'new, 'bufs, T> {
/// Creates a diff of arbitrary slices.
///
/// For more information see [`TextDiffConfig::diff_slices`].
pub fn from_slices(
old: &'bufs [&'old T],
new: &'bufs [&'new T],
) -> TextDiff<'old, 'new, 'bufs, T> {
TextDiff::configure().diff_slices(old, new)
}
/// The name of the algorithm that created the diff.
pub fn algorithm(&self) -> Algorithm {
self.algorithm
}
/// Returns `true` if items in the slice are newline terminated.
///
/// This flag is used by the unified diff writer to determine if extra
/// newlines have to be added.
pub fn newline_terminated(&self) -> bool {
self.newline_terminated
}
/// Returns all old slices.
pub fn old_slices(&self) -> &[&'old T] {
&self.old
}
/// Returns all new slices.
pub fn new_slices(&self) -> &[&'new T] {
&self.new
}
/// Return a measure of the sequences' similarity in the range `0..=1`.
///
/// A ratio of `1.0` means the two sequences are a complete match, a
/// ratio of `0.0` would indicate completely distinct sequences.
///
/// ```rust
/// # use similar::TextDiff;
/// let diff = TextDiff::from_chars("abcd", "bcde");
/// assert_eq!(diff.ratio(), 0.75);
/// ```
pub fn ratio(&self) -> f32 {
get_diff_ratio(self.ops(), self.old.len(), self.new.len())
}
/// Iterates over the changes the op expands to.
///
/// This method is a convenient way to automatically resolve the different
/// ways in which a change could be encoded (insert/delete vs replace), look
/// up the value from the appropriate slice and also handle correct index
/// handling.
pub fn iter_changes<'x, 'slf>(
&'slf self,
op: &DiffOp,
) -> ChangesIter<'slf, [&'x T], [&'x T], &'x T>
where
'x: 'slf,
'old: 'x,
'new: 'x,
{
op.iter_changes(self.old_slices(), self.new_slices())
}
/// Returns the captured diff ops.
pub fn ops(&self) -> &[DiffOp] {
&self.ops
}
/// Isolate change clusters by eliminating ranges with no changes.
///
/// This is equivalent to calling [`group_diff_ops`] on [`TextDiff::ops`].
pub fn grouped_ops(&self, n: usize) -> Vec<Vec<DiffOp>> {
group_diff_ops(self.ops().to_vec(), n)
}
/// Flattens out the diff into all changes.
///
/// This is a shortcut for combining [`TextDiff::ops`] with
/// [`TextDiff::iter_changes`].
pub fn iter_all_changes<'x, 'slf>(&'slf self) -> AllChangesIter<'slf, 'x, T>
where
'x: 'slf + 'old + 'new,
'old: 'x,
'new: 'x,
{
AllChangesIter::new(&self.old[..], &self.new[..], self.ops())
}
/// Utility to return a unified diff formatter.
pub fn unified_diff<'diff>(&'diff self) -> UnifiedDiff<'diff, 'old, 'new, 'bufs, T> {
UnifiedDiff::from_text_diff(self)
}
/// Iterates over the changes the op expands to with inline emphasis.
///
/// This is very similar to [`TextDiff::iter_changes`] but it performs a second
/// level diff on adjacent line replacements. The exact behavior of
/// this function with regards to how it detects those inline changes
/// is currently not defined and will likely change over time.
///
/// As of similar 1.2.0 the behavior of this function changes depending on
/// if the `unicode` feature is enabled or not. It will prefer unicode word
/// splitting over word splitting depending on the feature flag.
///
/// Requires the `inline` feature.
#[cfg(feature = "inline")]
pub fn iter_inline_changes<'slf>(
&'slf self,
op: &DiffOp,
) -> impl Iterator<Item = InlineChange<'slf, T>> + '_
where
'slf: 'old + 'new,
{
inline::iter_inline_changes(self, op)
}
}
/// Use the text differ to find `n` close matches.
///
/// `cutoff` defines the threshold which needs to be reached for a word
/// to be considered similar. See [`TextDiff::ratio`] for more information.
///
/// ```
/// # use similar::get_close_matches;
/// let matches = get_close_matches(
/// "appel",
/// &["ape", "apple", "peach", "puppy"][..],
/// 3,
/// 0.6
/// );
/// assert_eq!(matches, vec!["apple", "ape"]);
/// ```
///
/// Requires the `text` feature.
pub fn get_close_matches<'a, T: DiffableStr + ?Sized>(
word: &T,
possibilities: &[&'a T],
n: usize,
cutoff: f32,
) -> Vec<&'a T> {
let mut matches = BinaryHeap::new();
let seq1 = word.tokenize_chars();
let quick_ratio = QuickSeqRatio::new(&seq1);
for &possibility in possibilities {
let seq2 = possibility.tokenize_chars();
if upper_seq_ratio(&seq1, &seq2) < cutoff || quick_ratio.calc(&seq2) < cutoff {
continue;
}
let diff = TextDiff::from_slices(&seq1, &seq2);
let ratio = diff.ratio();
if ratio >= cutoff {
// we're putting the word itself in reverse in so that matches with
// the same ratio are ordered lexicographically.
matches.push(((ratio * std::u32::MAX as f32) as u32, Reverse(possibility)));
}
}
let mut rv = vec![];
for _ in 0..n {
if let Some((_, elt)) = matches.pop() {
rv.push(elt.0);
} else {
break;
}
}
rv
}
#[test]
fn test_captured_ops() {
let diff = TextDiff::from_lines(
"Hello World\nsome stuff here\nsome more stuff here\n",
"Hello World\nsome amazing stuff here\nsome more stuff here\n",
);
insta::assert_debug_snapshot!(&diff.ops());
}
#[test]
fn test_captured_word_ops() {
let diff = TextDiff::from_words(
"Hello World\nsome stuff here\nsome more stuff here\n",
"Hello World\nsome amazing stuff here\nsome more stuff here\n",
);
let changes = diff
.ops()
.iter()
.flat_map(|op| diff.iter_changes(op))
.collect::<Vec<_>>();
insta::assert_debug_snapshot!(&changes);
}
#[test]
fn test_unified_diff() {
let diff = TextDiff::from_lines(
"Hello World\nsome stuff here\nsome more stuff here\n",
"Hello World\nsome amazing stuff here\nsome more stuff here\n",
);
assert_eq!(diff.newline_terminated(), true);
insta::assert_snapshot!(&diff
.unified_diff()
.context_radius(3)
.header("old", "new")
.to_string());
}
#[test]
fn test_line_ops() {
let a = "Hello World\nsome stuff here\nsome more stuff here\n";
let b = "Hello World\nsome amazing stuff here\nsome more stuff here\n";
let diff = TextDiff::from_lines(a, b);
assert_eq!(diff.newline_terminated(), true);
let changes = diff
.ops()
.iter()
.flat_map(|op| diff.iter_changes(op))
.collect::<Vec<_>>();
insta::assert_debug_snapshot!(&changes);
#[cfg(feature = "bytes")]
{
let byte_diff = TextDiff::from_lines(a.as_bytes(), b.as_bytes());
let byte_changes = byte_diff
.ops()
.iter()
.flat_map(|op| byte_diff.iter_changes(op))
.collect::<Vec<_>>();
for (change, byte_change) in changes.iter().zip(byte_changes.iter()) {
assert_eq!(change.to_string_lossy(), byte_change.to_string_lossy());
}
}
}
#[test]
fn test_virtual_newlines() {
let diff = TextDiff::from_lines("a\nb", "a\nc\n");
assert_eq!(diff.newline_terminated(), true);
let changes = diff
.ops()
.iter()
.flat_map(|op| diff.iter_changes(op))
.collect::<Vec<_>>();
insta::assert_debug_snapshot!(&changes);
}
#[test]
fn test_char_diff() {
let diff = TextDiff::from_chars("Hello World", "Hallo Welt");
insta::assert_debug_snapshot!(diff.ops());
#[cfg(feature = "bytes")]
{
let byte_diff = TextDiff::from_chars("Hello World".as_bytes(), "Hallo Welt".as_bytes());
assert_eq!(diff.ops(), byte_diff.ops());
}
}
#[test]
fn test_ratio() {
let diff = TextDiff::from_chars("abcd", "bcde");
assert_eq!(diff.ratio(), 0.75);
let diff = TextDiff::from_chars("", "");
assert_eq!(diff.ratio(), 1.0);
}
#[test]
fn test_get_close_matches() {
let matches = get_close_matches("appel", &["ape", "apple", "peach", "puppy"][..], 3, 0.6);
assert_eq!(matches, vec!["apple", "ape"]);
let matches = get_close_matches(
"hulo",
&[
"hi", "hulu", "hali", "hoho", "amaz", "zulo", "blah", "hopp", "uulo", "aulo",
][..],
5,
0.7,
);
assert_eq!(matches, vec!["aulo", "hulu", "uulo", "zulo"]);
}
#[test]
fn test_lifetimes_on_iter() {
use crate::Change;
fn diff_lines<'x, T>(old: &'x T, new: &'x T) -> Vec<Change<&'x T::Output>>
where
T: DiffableStrRef + ?Sized,
{
TextDiff::from_lines(old, new).iter_all_changes().collect()
}
let a = "1\n2\n3\n".to_string();
let b = "1\n99\n3\n".to_string();
let changes = diff_lines(&a, &b);
insta::assert_debug_snapshot!(&changes);
}
#[test]
#[cfg(feature = "serde")]
fn test_serde() {
let diff = TextDiff::from_lines(
"Hello World\nsome stuff here\nsome more stuff here\n\nAha stuff here\nand more stuff",
"Stuff\nHello World\nsome amazing stuff here\nsome more stuff here\n",
);
let changes = diff
.ops()
.iter()
.flat_map(|op| diff.iter_changes(op))
.collect::<Vec<_>>();
let json = serde_json::to_string_pretty(&changes).unwrap();
insta::assert_snapshot!(&json);
}
#[test]
#[cfg(feature = "serde")]
fn test_serde_ops() {
let diff = TextDiff::from_lines(
"Hello World\nsome stuff here\nsome more stuff here\n\nAha stuff here\nand more stuff",
"Stuff\nHello World\nsome amazing stuff here\nsome more stuff here\n",
);
let changes = diff.ops();
let json = serde_json::to_string_pretty(&changes).unwrap();
insta::assert_snapshot!(&json);
}
#[test]
fn test_regression_issue_37() {
let config = TextDiffConfig::default();
let diff = config.diff_lines("\u{18}\n\n", "\n\n\r");
let mut output = diff.unified_diff();
assert_eq!(
output.context_radius(0).to_string(),
"@@ -1 +1,0 @@\n-\u{18}\n@@ -2,0 +2,2 @@\n+\n+\r"
);
}
|
#[derive(Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Debug)]
pub enum Attribute {
/// Determines unarmed damage and is directly added to damage with weapons
Strength,
/// Determines maximum hitpoints
Constitution,
/// Determines maximum stamina
Endurance,
/// Determines the amount of available actions
Swiftness,
}
impl AsRef<Attribute> for Attribute {
fn as_ref(&self) -> &Self {
self
}
}
|
use std::fmt;
pub mod unit;
pub struct Temperature {
pub temperature: f64,
pub unit: unit::Unit,
}
impl Temperature {
fn in_kelvin(&self) -> Temperature {
let k = match self.unit {
unit::Unit::F => Temperature::f_to_k(self.temperature),
unit::Unit::C => Temperature::c_to_k(self.temperature),
unit::Unit::K => self.temperature,
};
Temperature {
temperature: k,
unit: unit::Unit::K,
}
}
fn kelvin_to_unit(&self, target_unit: unit::Unit) -> Temperature {
if self.unit != unit::Unit::K {
panic!("Called 'kelvin_to_unit' on non-kelvin Temperature");
}
let new_temp = match target_unit {
unit::Unit::F => Temperature::k_to_f(self.temperature),
unit::Unit::C => Temperature::k_to_c(self.temperature),
unit::Unit::K => self.temperature,
};
Temperature {
temperature: new_temp,
unit: target_unit,
}
}
fn f_to_k(f: f64) -> f64 {
(f - 32.) * 5./9. + 273.15
}
fn c_to_k(c: f64) -> f64 {
c + 273.15
}
fn k_to_f(k: f64) -> f64 {
(k - 273.15) * 9./5. + 32.
}
fn k_to_c(k: f64) -> f64 {
k - 273.15
}
pub fn in_unit(&self, target_unit: unit::Unit) -> Temperature {
self.in_kelvin().kelvin_to_unit(target_unit)
}
}
impl fmt::Display for Temperature {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{:.2}{}", self.temperature, self.unit)
}
}
|
#![doc(html_root_url = "https://docs.coruscant.rs/coruscant_nbt/")]
// #![warn(missing_docs)]
//! Coruscant-NBT serialize & deserialize library
#[cfg(any(feature = "gzip", feature = "zlib"))]
pub use flate2::Compression;
#[doc(inline)]
pub use error::{Error, Result};
#[doc(inline)]
pub use root::Root;
#[doc(inline)]
pub use ser::{to_string_transcript, to_vec, to_writer, Serializer};
#[cfg(feature = "gzip")]
#[doc(inline)]
pub use {de::from_gzip_reader, ser::to_gzip_writer};
#[cfg(feature = "zlib")]
#[doc(inline)]
pub use {de::from_zlib_reader, ser::to_zlib_writer};
#[doc(inline)]
pub use de::{from_reader, from_slice, Deserializer};
#[doc(inline)]
pub use value::{to_value, Value};
#[doc(inline)]
pub use map::Map;
#[doc(inline)]
pub use as_nbt_array::serialize as as_nbt_array;
#[macro_use]
mod macros;
mod consts;
pub mod de;
pub mod error;
pub mod map;
mod read;
pub mod root;
pub mod ser;
pub mod value;
mod as_nbt_array;
|
use super::{
Irreducible, Reciprocal, UFracAdd, UFracAddOp, UFracDiv, UFracDivOp, UFracMul, UFracMulOp,
UFracSub, UFracSubOp, UFraction,
};
use crate::{
common::*,
control::Same,
numeric::{Gcd, GcdOp},
};
use typenum::U1;
// unsigned fraction type
pub struct UFrac<Numerators, Denominators>(PhantomData<(Numerators, Denominators)>)
where
Numerators: Unsigned,
Denominators: Unsigned + NonZero;
impl<N, D> UFraction for UFrac<N, D>
where
N: Unsigned,
D: Unsigned + NonZero,
{
fn new() -> Self {
UFrac(PhantomData)
}
}
// non-zero trait
impl<N, D> NonZero for UFrac<N, D>
where
N: Unsigned + NonZero,
D: Unsigned + NonZero,
{
}
impl<N, D> Irreducible for UFrac<N, D>
where
(): Same<GcdOp<N, D>, U1, ()> + Gcd<N, D>,
N: Unsigned,
D: Unsigned + NonZero,
{
}
// sum
impl<N, D, Rhs> Add<Rhs> for UFrac<N, D>
where
(): UFracAdd<Self, Rhs>,
N: Unsigned,
D: Unsigned + NonZero,
Rhs: UFraction,
{
type Output = UFracAddOp<Self, Rhs>;
fn add(self, _rhs: Rhs) -> Self::Output {
Self::Output::new()
}
}
// subtraction of unsigned fractions
impl<N, D, Rhs> Sub<Rhs> for UFrac<N, D>
where
(): UFracSub<Self, Rhs>,
N: Unsigned,
D: Unsigned + NonZero,
Rhs: UFraction,
{
type Output = UFracSubOp<Self, Rhs>;
fn sub(self, _rhs: Rhs) -> Self::Output {
Self::Output::new()
}
}
// product of unsigned fractions
impl<N, D, Rhs> Mul<Rhs> for UFrac<N, D>
where
(): UFracMul<Self, Rhs>,
N: Unsigned,
D: Unsigned + NonZero,
Rhs: UFraction,
{
type Output = UFracMulOp<Self, Rhs>;
fn mul(self, _rhs: Rhs) -> Self::Output {
Self::Output::new()
}
}
// division of unsigned fractions
impl<NL, DL, NR, DR> Div<UFrac<NR, DR>> for UFrac<NL, DL>
where
(): UFracDiv<UFrac<NL, DL>, UFrac<NR, DR>> + Reciprocal<UFrac<NR, DR>>,
NL: Unsigned,
DL: Unsigned + NonZero,
NR: Unsigned + NonZero,
DR: Unsigned + NonZero,
{
type Output = UFracDivOp<UFrac<NL, DL>, UFrac<NR, DR>>;
fn div(self, _rhs: UFrac<NR, DR>) -> Self::Output {
Self::Output::new()
}
}
|
// auto generated, do not modify.
// created: Mon Feb 22 23:57:02 2016
// src-file: /QtGui/qopenglframebufferobject.h
// dst-file: /src/gui/qopenglframebufferobject.rs
//
// header block begin =>
#![feature(libc)]
#![feature(core)]
#![feature(collections)]
extern crate libc;
use self::libc::*;
// <= header block end
// main block begin =>
// <= main block end
// use block begin =>
use std::ops::Deref;
use super::super::core::qsize::*; // 771
// use super::qopenglframebufferobject::QOpenGLFramebufferObjectFormat; // 773
use super::qimage::*; // 773
use super::super::core::qrect::*; // 771
// <= use block end
// ext block begin =>
// #[link(name = "Qt5Core")]
// #[link(name = "Qt5Gui")]
// #[link(name = "Qt5Widgets")]
// #[link(name = "QtInline")]
extern {
fn QOpenGLFramebufferObjectFormat_Class_Size() -> c_int;
// proto: void QOpenGLFramebufferObjectFormat::~QOpenGLFramebufferObjectFormat();
fn C_ZN30QOpenGLFramebufferObjectFormatD2Ev(qthis: u64 /* *mut c_void*/);
// proto: void QOpenGLFramebufferObjectFormat::setTextureTarget(GLenum target);
fn C_ZN30QOpenGLFramebufferObjectFormat16setTextureTargetEj(qthis: u64 /* *mut c_void*/, arg0: c_uint);
// proto: void QOpenGLFramebufferObjectFormat::setInternalTextureFormat(GLenum internalTextureFormat);
fn C_ZN30QOpenGLFramebufferObjectFormat24setInternalTextureFormatEj(qthis: u64 /* *mut c_void*/, arg0: c_uint);
// proto: void QOpenGLFramebufferObjectFormat::QOpenGLFramebufferObjectFormat(const QOpenGLFramebufferObjectFormat & other);
fn C_ZN30QOpenGLFramebufferObjectFormatC2ERKS_(arg0: *mut c_void) -> u64;
// proto: bool QOpenGLFramebufferObjectFormat::mipmap();
fn C_ZNK30QOpenGLFramebufferObjectFormat6mipmapEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: GLenum QOpenGLFramebufferObjectFormat::textureTarget();
fn C_ZNK30QOpenGLFramebufferObjectFormat13textureTargetEv(qthis: u64 /* *mut c_void*/) -> c_uint;
// proto: void QOpenGLFramebufferObjectFormat::setSamples(int samples);
fn C_ZN30QOpenGLFramebufferObjectFormat10setSamplesEi(qthis: u64 /* *mut c_void*/, arg0: c_int);
// proto: void QOpenGLFramebufferObjectFormat::QOpenGLFramebufferObjectFormat();
fn C_ZN30QOpenGLFramebufferObjectFormatC2Ev() -> u64;
// proto: void QOpenGLFramebufferObjectFormat::setMipmap(bool enabled);
fn C_ZN30QOpenGLFramebufferObjectFormat9setMipmapEb(qthis: u64 /* *mut c_void*/, arg0: c_char);
// proto: GLenum QOpenGLFramebufferObjectFormat::internalTextureFormat();
fn C_ZNK30QOpenGLFramebufferObjectFormat21internalTextureFormatEv(qthis: u64 /* *mut c_void*/) -> c_uint;
// proto: int QOpenGLFramebufferObjectFormat::samples();
fn C_ZNK30QOpenGLFramebufferObjectFormat7samplesEv(qthis: u64 /* *mut c_void*/) -> c_int;
fn QOpenGLFramebufferObject_Class_Size() -> c_int;
// proto: bool QOpenGLFramebufferObject::isValid();
fn C_ZNK24QOpenGLFramebufferObject7isValidEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: GLuint QOpenGLFramebufferObject::takeTexture();
fn C_ZN24QOpenGLFramebufferObject11takeTextureEv(qthis: u64 /* *mut c_void*/) -> c_uint;
// proto: void QOpenGLFramebufferObject::QOpenGLFramebufferObject(const QSize & size, const QOpenGLFramebufferObjectFormat & format);
fn C_ZN24QOpenGLFramebufferObjectC2ERK5QSizeRK30QOpenGLFramebufferObjectFormat(arg0: *mut c_void, arg1: *mut c_void) -> u64;
// proto: static bool QOpenGLFramebufferObject::bindDefault();
fn C_ZN24QOpenGLFramebufferObject11bindDefaultEv() -> c_char;
// proto: static bool QOpenGLFramebufferObject::hasOpenGLFramebufferBlit();
fn C_ZN24QOpenGLFramebufferObject24hasOpenGLFramebufferBlitEv() -> c_char;
// proto: GLuint QOpenGLFramebufferObject::texture();
fn C_ZNK24QOpenGLFramebufferObject7textureEv(qthis: u64 /* *mut c_void*/) -> c_uint;
// proto: void QOpenGLFramebufferObject::QOpenGLFramebufferObject(const QSize & size, GLenum target);
fn C_ZN24QOpenGLFramebufferObjectC2ERK5QSizej(arg0: *mut c_void, arg1: c_uint) -> u64;
// proto: bool QOpenGLFramebufferObject::release();
fn C_ZN24QOpenGLFramebufferObject7releaseEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: static bool QOpenGLFramebufferObject::hasOpenGLFramebufferObjects();
fn C_ZN24QOpenGLFramebufferObject27hasOpenGLFramebufferObjectsEv() -> c_char;
// proto: QImage QOpenGLFramebufferObject::toImage(bool flipped);
fn C_ZNK24QOpenGLFramebufferObject7toImageEb(qthis: u64 /* *mut c_void*/, arg0: c_char) -> *mut c_void;
// proto: GLuint QOpenGLFramebufferObject::handle();
fn C_ZNK24QOpenGLFramebufferObject6handleEv(qthis: u64 /* *mut c_void*/) -> c_uint;
// proto: int QOpenGLFramebufferObject::height();
fn C_ZNK24QOpenGLFramebufferObject6heightEv(qthis: u64 /* *mut c_void*/) -> c_int;
// proto: static void QOpenGLFramebufferObject::blitFramebuffer(QOpenGLFramebufferObject * target, QOpenGLFramebufferObject * source, GLbitfield buffers, GLenum filter);
fn C_ZN24QOpenGLFramebufferObject15blitFramebufferEPS_S0_jj(arg0: *mut c_void, arg1: *mut c_void, arg2: c_uint, arg3: c_uint);
// proto: void QOpenGLFramebufferObject::QOpenGLFramebufferObject(int width, int height, const QOpenGLFramebufferObjectFormat & format);
fn C_ZN24QOpenGLFramebufferObjectC2EiiRK30QOpenGLFramebufferObjectFormat(arg0: c_int, arg1: c_int, arg2: *mut c_void) -> u64;
// proto: static void QOpenGLFramebufferObject::blitFramebuffer(QOpenGLFramebufferObject * target, const QRect & targetRect, QOpenGLFramebufferObject * source, const QRect & sourceRect, GLbitfield buffers, GLenum filter);
fn C_ZN24QOpenGLFramebufferObject15blitFramebufferEPS_RK5QRectS0_S3_jj(arg0: *mut c_void, arg1: *mut c_void, arg2: *mut c_void, arg3: *mut c_void, arg4: c_uint, arg5: c_uint);
// proto: QImage QOpenGLFramebufferObject::toImage();
fn C_ZNK24QOpenGLFramebufferObject7toImageEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: QSize QOpenGLFramebufferObject::size();
fn C_ZNK24QOpenGLFramebufferObject4sizeEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: void QOpenGLFramebufferObject::~QOpenGLFramebufferObject();
fn C_ZN24QOpenGLFramebufferObjectD2Ev(qthis: u64 /* *mut c_void*/);
// proto: QOpenGLFramebufferObjectFormat QOpenGLFramebufferObject::format();
fn C_ZNK24QOpenGLFramebufferObject6formatEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: bool QOpenGLFramebufferObject::bind();
fn C_ZN24QOpenGLFramebufferObject4bindEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: bool QOpenGLFramebufferObject::isBound();
fn C_ZNK24QOpenGLFramebufferObject7isBoundEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: int QOpenGLFramebufferObject::width();
fn C_ZNK24QOpenGLFramebufferObject5widthEv(qthis: u64 /* *mut c_void*/) -> c_int;
// proto: void QOpenGLFramebufferObject::QOpenGLFramebufferObject(int width, int height, GLenum target);
fn C_ZN24QOpenGLFramebufferObjectC2Eiij(arg0: c_int, arg1: c_int, arg2: c_uint) -> u64;
} // <= ext block end
// body block begin =>
// class sizeof(QOpenGLFramebufferObjectFormat)=8
#[derive(Default)]
pub struct QOpenGLFramebufferObjectFormat {
// qbase: None,
pub qclsinst: u64 /* *mut c_void*/,
}
// class sizeof(QOpenGLFramebufferObject)=1
#[derive(Default)]
pub struct QOpenGLFramebufferObject {
// qbase: None,
pub qclsinst: u64 /* *mut c_void*/,
}
impl /*struct*/ QOpenGLFramebufferObjectFormat {
pub fn inheritFrom(qthis: u64 /* *mut c_void*/) -> QOpenGLFramebufferObjectFormat {
return QOpenGLFramebufferObjectFormat{qclsinst: qthis, ..Default::default()};
}
}
// proto: void QOpenGLFramebufferObjectFormat::~QOpenGLFramebufferObjectFormat();
impl /*struct*/ QOpenGLFramebufferObjectFormat {
pub fn free<RetType, T: QOpenGLFramebufferObjectFormat_free<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.free(self);
// return 1;
}
}
pub trait QOpenGLFramebufferObjectFormat_free<RetType> {
fn free(self , rsthis: & QOpenGLFramebufferObjectFormat) -> RetType;
}
// proto: void QOpenGLFramebufferObjectFormat::~QOpenGLFramebufferObjectFormat();
impl<'a> /*trait*/ QOpenGLFramebufferObjectFormat_free<()> for () {
fn free(self , rsthis: & QOpenGLFramebufferObjectFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN30QOpenGLFramebufferObjectFormatD2Ev()};
unsafe {C_ZN30QOpenGLFramebufferObjectFormatD2Ev(rsthis.qclsinst)};
// return 1;
}
}
// proto: void QOpenGLFramebufferObjectFormat::setTextureTarget(GLenum target);
impl /*struct*/ QOpenGLFramebufferObjectFormat {
pub fn setTextureTarget<RetType, T: QOpenGLFramebufferObjectFormat_setTextureTarget<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setTextureTarget(self);
// return 1;
}
}
pub trait QOpenGLFramebufferObjectFormat_setTextureTarget<RetType> {
fn setTextureTarget(self , rsthis: & QOpenGLFramebufferObjectFormat) -> RetType;
}
// proto: void QOpenGLFramebufferObjectFormat::setTextureTarget(GLenum target);
impl<'a> /*trait*/ QOpenGLFramebufferObjectFormat_setTextureTarget<()> for (u32) {
fn setTextureTarget(self , rsthis: & QOpenGLFramebufferObjectFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN30QOpenGLFramebufferObjectFormat16setTextureTargetEj()};
let arg0 = self as c_uint;
unsafe {C_ZN30QOpenGLFramebufferObjectFormat16setTextureTargetEj(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QOpenGLFramebufferObjectFormat::setInternalTextureFormat(GLenum internalTextureFormat);
impl /*struct*/ QOpenGLFramebufferObjectFormat {
pub fn setInternalTextureFormat<RetType, T: QOpenGLFramebufferObjectFormat_setInternalTextureFormat<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setInternalTextureFormat(self);
// return 1;
}
}
pub trait QOpenGLFramebufferObjectFormat_setInternalTextureFormat<RetType> {
fn setInternalTextureFormat(self , rsthis: & QOpenGLFramebufferObjectFormat) -> RetType;
}
// proto: void QOpenGLFramebufferObjectFormat::setInternalTextureFormat(GLenum internalTextureFormat);
impl<'a> /*trait*/ QOpenGLFramebufferObjectFormat_setInternalTextureFormat<()> for (u32) {
fn setInternalTextureFormat(self , rsthis: & QOpenGLFramebufferObjectFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN30QOpenGLFramebufferObjectFormat24setInternalTextureFormatEj()};
let arg0 = self as c_uint;
unsafe {C_ZN30QOpenGLFramebufferObjectFormat24setInternalTextureFormatEj(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QOpenGLFramebufferObjectFormat::QOpenGLFramebufferObjectFormat(const QOpenGLFramebufferObjectFormat & other);
impl /*struct*/ QOpenGLFramebufferObjectFormat {
pub fn new<T: QOpenGLFramebufferObjectFormat_new>(value: T) -> QOpenGLFramebufferObjectFormat {
let rsthis = value.new();
return rsthis;
// return 1;
}
}
pub trait QOpenGLFramebufferObjectFormat_new {
fn new(self) -> QOpenGLFramebufferObjectFormat;
}
// proto: void QOpenGLFramebufferObjectFormat::QOpenGLFramebufferObjectFormat(const QOpenGLFramebufferObjectFormat & other);
impl<'a> /*trait*/ QOpenGLFramebufferObjectFormat_new for (&'a QOpenGLFramebufferObjectFormat) {
fn new(self) -> QOpenGLFramebufferObjectFormat {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN30QOpenGLFramebufferObjectFormatC2ERKS_()};
let ctysz: c_int = unsafe{QOpenGLFramebufferObjectFormat_Class_Size()};
let qthis_ph: u64 = unsafe{calloc(1, ctysz as usize)} as u64;
let arg0 = self.qclsinst as *mut c_void;
let qthis: u64 = unsafe {C_ZN30QOpenGLFramebufferObjectFormatC2ERKS_(arg0)};
let rsthis = QOpenGLFramebufferObjectFormat{qclsinst: qthis, ..Default::default()};
return rsthis;
// return 1;
}
}
// proto: bool QOpenGLFramebufferObjectFormat::mipmap();
impl /*struct*/ QOpenGLFramebufferObjectFormat {
pub fn mipmap<RetType, T: QOpenGLFramebufferObjectFormat_mipmap<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.mipmap(self);
// return 1;
}
}
pub trait QOpenGLFramebufferObjectFormat_mipmap<RetType> {
fn mipmap(self , rsthis: & QOpenGLFramebufferObjectFormat) -> RetType;
}
// proto: bool QOpenGLFramebufferObjectFormat::mipmap();
impl<'a> /*trait*/ QOpenGLFramebufferObjectFormat_mipmap<i8> for () {
fn mipmap(self , rsthis: & QOpenGLFramebufferObjectFormat) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK30QOpenGLFramebufferObjectFormat6mipmapEv()};
let mut ret = unsafe {C_ZNK30QOpenGLFramebufferObjectFormat6mipmapEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
// proto: GLenum QOpenGLFramebufferObjectFormat::textureTarget();
impl /*struct*/ QOpenGLFramebufferObjectFormat {
pub fn textureTarget<RetType, T: QOpenGLFramebufferObjectFormat_textureTarget<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.textureTarget(self);
// return 1;
}
}
pub trait QOpenGLFramebufferObjectFormat_textureTarget<RetType> {
fn textureTarget(self , rsthis: & QOpenGLFramebufferObjectFormat) -> RetType;
}
// proto: GLenum QOpenGLFramebufferObjectFormat::textureTarget();
impl<'a> /*trait*/ QOpenGLFramebufferObjectFormat_textureTarget<u32> for () {
fn textureTarget(self , rsthis: & QOpenGLFramebufferObjectFormat) -> u32 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK30QOpenGLFramebufferObjectFormat13textureTargetEv()};
let mut ret = unsafe {C_ZNK30QOpenGLFramebufferObjectFormat13textureTargetEv(rsthis.qclsinst)};
return ret as u32; // 1
// return 1;
}
}
// proto: void QOpenGLFramebufferObjectFormat::setSamples(int samples);
impl /*struct*/ QOpenGLFramebufferObjectFormat {
pub fn setSamples<RetType, T: QOpenGLFramebufferObjectFormat_setSamples<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setSamples(self);
// return 1;
}
}
pub trait QOpenGLFramebufferObjectFormat_setSamples<RetType> {
fn setSamples(self , rsthis: & QOpenGLFramebufferObjectFormat) -> RetType;
}
// proto: void QOpenGLFramebufferObjectFormat::setSamples(int samples);
impl<'a> /*trait*/ QOpenGLFramebufferObjectFormat_setSamples<()> for (i32) {
fn setSamples(self , rsthis: & QOpenGLFramebufferObjectFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN30QOpenGLFramebufferObjectFormat10setSamplesEi()};
let arg0 = self as c_int;
unsafe {C_ZN30QOpenGLFramebufferObjectFormat10setSamplesEi(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QOpenGLFramebufferObjectFormat::QOpenGLFramebufferObjectFormat();
impl<'a> /*trait*/ QOpenGLFramebufferObjectFormat_new for () {
fn new(self) -> QOpenGLFramebufferObjectFormat {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN30QOpenGLFramebufferObjectFormatC2Ev()};
let ctysz: c_int = unsafe{QOpenGLFramebufferObjectFormat_Class_Size()};
let qthis_ph: u64 = unsafe{calloc(1, ctysz as usize)} as u64;
let qthis: u64 = unsafe {C_ZN30QOpenGLFramebufferObjectFormatC2Ev()};
let rsthis = QOpenGLFramebufferObjectFormat{qclsinst: qthis, ..Default::default()};
return rsthis;
// return 1;
}
}
// proto: void QOpenGLFramebufferObjectFormat::setMipmap(bool enabled);
impl /*struct*/ QOpenGLFramebufferObjectFormat {
pub fn setMipmap<RetType, T: QOpenGLFramebufferObjectFormat_setMipmap<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setMipmap(self);
// return 1;
}
}
pub trait QOpenGLFramebufferObjectFormat_setMipmap<RetType> {
fn setMipmap(self , rsthis: & QOpenGLFramebufferObjectFormat) -> RetType;
}
// proto: void QOpenGLFramebufferObjectFormat::setMipmap(bool enabled);
impl<'a> /*trait*/ QOpenGLFramebufferObjectFormat_setMipmap<()> for (i8) {
fn setMipmap(self , rsthis: & QOpenGLFramebufferObjectFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN30QOpenGLFramebufferObjectFormat9setMipmapEb()};
let arg0 = self as c_char;
unsafe {C_ZN30QOpenGLFramebufferObjectFormat9setMipmapEb(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: GLenum QOpenGLFramebufferObjectFormat::internalTextureFormat();
impl /*struct*/ QOpenGLFramebufferObjectFormat {
pub fn internalTextureFormat<RetType, T: QOpenGLFramebufferObjectFormat_internalTextureFormat<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.internalTextureFormat(self);
// return 1;
}
}
pub trait QOpenGLFramebufferObjectFormat_internalTextureFormat<RetType> {
fn internalTextureFormat(self , rsthis: & QOpenGLFramebufferObjectFormat) -> RetType;
}
// proto: GLenum QOpenGLFramebufferObjectFormat::internalTextureFormat();
impl<'a> /*trait*/ QOpenGLFramebufferObjectFormat_internalTextureFormat<u32> for () {
fn internalTextureFormat(self , rsthis: & QOpenGLFramebufferObjectFormat) -> u32 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK30QOpenGLFramebufferObjectFormat21internalTextureFormatEv()};
let mut ret = unsafe {C_ZNK30QOpenGLFramebufferObjectFormat21internalTextureFormatEv(rsthis.qclsinst)};
return ret as u32; // 1
// return 1;
}
}
// proto: int QOpenGLFramebufferObjectFormat::samples();
impl /*struct*/ QOpenGLFramebufferObjectFormat {
pub fn samples<RetType, T: QOpenGLFramebufferObjectFormat_samples<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.samples(self);
// return 1;
}
}
pub trait QOpenGLFramebufferObjectFormat_samples<RetType> {
fn samples(self , rsthis: & QOpenGLFramebufferObjectFormat) -> RetType;
}
// proto: int QOpenGLFramebufferObjectFormat::samples();
impl<'a> /*trait*/ QOpenGLFramebufferObjectFormat_samples<i32> for () {
fn samples(self , rsthis: & QOpenGLFramebufferObjectFormat) -> i32 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK30QOpenGLFramebufferObjectFormat7samplesEv()};
let mut ret = unsafe {C_ZNK30QOpenGLFramebufferObjectFormat7samplesEv(rsthis.qclsinst)};
return ret as i32; // 1
// return 1;
}
}
impl /*struct*/ QOpenGLFramebufferObject {
pub fn inheritFrom(qthis: u64 /* *mut c_void*/) -> QOpenGLFramebufferObject {
return QOpenGLFramebufferObject{qclsinst: qthis, ..Default::default()};
}
}
// proto: bool QOpenGLFramebufferObject::isValid();
impl /*struct*/ QOpenGLFramebufferObject {
pub fn isValid<RetType, T: QOpenGLFramebufferObject_isValid<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.isValid(self);
// return 1;
}
}
pub trait QOpenGLFramebufferObject_isValid<RetType> {
fn isValid(self , rsthis: & QOpenGLFramebufferObject) -> RetType;
}
// proto: bool QOpenGLFramebufferObject::isValid();
impl<'a> /*trait*/ QOpenGLFramebufferObject_isValid<i8> for () {
fn isValid(self , rsthis: & QOpenGLFramebufferObject) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK24QOpenGLFramebufferObject7isValidEv()};
let mut ret = unsafe {C_ZNK24QOpenGLFramebufferObject7isValidEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
// proto: GLuint QOpenGLFramebufferObject::takeTexture();
impl /*struct*/ QOpenGLFramebufferObject {
pub fn takeTexture<RetType, T: QOpenGLFramebufferObject_takeTexture<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.takeTexture(self);
// return 1;
}
}
pub trait QOpenGLFramebufferObject_takeTexture<RetType> {
fn takeTexture(self , rsthis: & QOpenGLFramebufferObject) -> RetType;
}
// proto: GLuint QOpenGLFramebufferObject::takeTexture();
impl<'a> /*trait*/ QOpenGLFramebufferObject_takeTexture<u32> for () {
fn takeTexture(self , rsthis: & QOpenGLFramebufferObject) -> u32 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN24QOpenGLFramebufferObject11takeTextureEv()};
let mut ret = unsafe {C_ZN24QOpenGLFramebufferObject11takeTextureEv(rsthis.qclsinst)};
return ret as u32; // 1
// return 1;
}
}
// proto: void QOpenGLFramebufferObject::QOpenGLFramebufferObject(const QSize & size, const QOpenGLFramebufferObjectFormat & format);
impl /*struct*/ QOpenGLFramebufferObject {
pub fn new<T: QOpenGLFramebufferObject_new>(value: T) -> QOpenGLFramebufferObject {
let rsthis = value.new();
return rsthis;
// return 1;
}
}
pub trait QOpenGLFramebufferObject_new {
fn new(self) -> QOpenGLFramebufferObject;
}
// proto: void QOpenGLFramebufferObject::QOpenGLFramebufferObject(const QSize & size, const QOpenGLFramebufferObjectFormat & format);
impl<'a> /*trait*/ QOpenGLFramebufferObject_new for (&'a QSize, &'a QOpenGLFramebufferObjectFormat) {
fn new(self) -> QOpenGLFramebufferObject {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN24QOpenGLFramebufferObjectC2ERK5QSizeRK30QOpenGLFramebufferObjectFormat()};
let ctysz: c_int = unsafe{QOpenGLFramebufferObject_Class_Size()};
let qthis_ph: u64 = unsafe{calloc(1, ctysz as usize)} as u64;
let arg0 = self.0.qclsinst as *mut c_void;
let arg1 = self.1.qclsinst as *mut c_void;
let qthis: u64 = unsafe {C_ZN24QOpenGLFramebufferObjectC2ERK5QSizeRK30QOpenGLFramebufferObjectFormat(arg0, arg1)};
let rsthis = QOpenGLFramebufferObject{qclsinst: qthis, ..Default::default()};
return rsthis;
// return 1;
}
}
// proto: static bool QOpenGLFramebufferObject::bindDefault();
impl /*struct*/ QOpenGLFramebufferObject {
pub fn bindDefault_s<RetType, T: QOpenGLFramebufferObject_bindDefault_s<RetType>>( overload_args: T) -> RetType {
return overload_args.bindDefault_s();
// return 1;
}
}
pub trait QOpenGLFramebufferObject_bindDefault_s<RetType> {
fn bindDefault_s(self ) -> RetType;
}
// proto: static bool QOpenGLFramebufferObject::bindDefault();
impl<'a> /*trait*/ QOpenGLFramebufferObject_bindDefault_s<i8> for () {
fn bindDefault_s(self ) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN24QOpenGLFramebufferObject11bindDefaultEv()};
let mut ret = unsafe {C_ZN24QOpenGLFramebufferObject11bindDefaultEv()};
return ret as i8; // 1
// return 1;
}
}
// proto: static bool QOpenGLFramebufferObject::hasOpenGLFramebufferBlit();
impl /*struct*/ QOpenGLFramebufferObject {
pub fn hasOpenGLFramebufferBlit_s<RetType, T: QOpenGLFramebufferObject_hasOpenGLFramebufferBlit_s<RetType>>( overload_args: T) -> RetType {
return overload_args.hasOpenGLFramebufferBlit_s();
// return 1;
}
}
pub trait QOpenGLFramebufferObject_hasOpenGLFramebufferBlit_s<RetType> {
fn hasOpenGLFramebufferBlit_s(self ) -> RetType;
}
// proto: static bool QOpenGLFramebufferObject::hasOpenGLFramebufferBlit();
impl<'a> /*trait*/ QOpenGLFramebufferObject_hasOpenGLFramebufferBlit_s<i8> for () {
fn hasOpenGLFramebufferBlit_s(self ) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN24QOpenGLFramebufferObject24hasOpenGLFramebufferBlitEv()};
let mut ret = unsafe {C_ZN24QOpenGLFramebufferObject24hasOpenGLFramebufferBlitEv()};
return ret as i8; // 1
// return 1;
}
}
// proto: GLuint QOpenGLFramebufferObject::texture();
impl /*struct*/ QOpenGLFramebufferObject {
pub fn texture<RetType, T: QOpenGLFramebufferObject_texture<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.texture(self);
// return 1;
}
}
pub trait QOpenGLFramebufferObject_texture<RetType> {
fn texture(self , rsthis: & QOpenGLFramebufferObject) -> RetType;
}
// proto: GLuint QOpenGLFramebufferObject::texture();
impl<'a> /*trait*/ QOpenGLFramebufferObject_texture<u32> for () {
fn texture(self , rsthis: & QOpenGLFramebufferObject) -> u32 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK24QOpenGLFramebufferObject7textureEv()};
let mut ret = unsafe {C_ZNK24QOpenGLFramebufferObject7textureEv(rsthis.qclsinst)};
return ret as u32; // 1
// return 1;
}
}
// proto: void QOpenGLFramebufferObject::QOpenGLFramebufferObject(const QSize & size, GLenum target);
impl<'a> /*trait*/ QOpenGLFramebufferObject_new for (&'a QSize, Option<u32>) {
fn new(self) -> QOpenGLFramebufferObject {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN24QOpenGLFramebufferObjectC2ERK5QSizej()};
let ctysz: c_int = unsafe{QOpenGLFramebufferObject_Class_Size()};
let qthis_ph: u64 = unsafe{calloc(1, ctysz as usize)} as u64;
let arg0 = self.0.qclsinst as *mut c_void;
let arg1 = (if self.1.is_none() {0 as u32} else {self.1.unwrap()}) as c_uint;
let qthis: u64 = unsafe {C_ZN24QOpenGLFramebufferObjectC2ERK5QSizej(arg0, arg1)};
let rsthis = QOpenGLFramebufferObject{qclsinst: qthis, ..Default::default()};
return rsthis;
// return 1;
}
}
// proto: bool QOpenGLFramebufferObject::release();
impl /*struct*/ QOpenGLFramebufferObject {
pub fn release<RetType, T: QOpenGLFramebufferObject_release<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.release(self);
// return 1;
}
}
pub trait QOpenGLFramebufferObject_release<RetType> {
fn release(self , rsthis: & QOpenGLFramebufferObject) -> RetType;
}
// proto: bool QOpenGLFramebufferObject::release();
impl<'a> /*trait*/ QOpenGLFramebufferObject_release<i8> for () {
fn release(self , rsthis: & QOpenGLFramebufferObject) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN24QOpenGLFramebufferObject7releaseEv()};
let mut ret = unsafe {C_ZN24QOpenGLFramebufferObject7releaseEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
// proto: static bool QOpenGLFramebufferObject::hasOpenGLFramebufferObjects();
impl /*struct*/ QOpenGLFramebufferObject {
pub fn hasOpenGLFramebufferObjects_s<RetType, T: QOpenGLFramebufferObject_hasOpenGLFramebufferObjects_s<RetType>>( overload_args: T) -> RetType {
return overload_args.hasOpenGLFramebufferObjects_s();
// return 1;
}
}
pub trait QOpenGLFramebufferObject_hasOpenGLFramebufferObjects_s<RetType> {
fn hasOpenGLFramebufferObjects_s(self ) -> RetType;
}
// proto: static bool QOpenGLFramebufferObject::hasOpenGLFramebufferObjects();
impl<'a> /*trait*/ QOpenGLFramebufferObject_hasOpenGLFramebufferObjects_s<i8> for () {
fn hasOpenGLFramebufferObjects_s(self ) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN24QOpenGLFramebufferObject27hasOpenGLFramebufferObjectsEv()};
let mut ret = unsafe {C_ZN24QOpenGLFramebufferObject27hasOpenGLFramebufferObjectsEv()};
return ret as i8; // 1
// return 1;
}
}
// proto: QImage QOpenGLFramebufferObject::toImage(bool flipped);
impl /*struct*/ QOpenGLFramebufferObject {
pub fn toImage<RetType, T: QOpenGLFramebufferObject_toImage<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.toImage(self);
// return 1;
}
}
pub trait QOpenGLFramebufferObject_toImage<RetType> {
fn toImage(self , rsthis: & QOpenGLFramebufferObject) -> RetType;
}
// proto: QImage QOpenGLFramebufferObject::toImage(bool flipped);
impl<'a> /*trait*/ QOpenGLFramebufferObject_toImage<QImage> for (i8) {
fn toImage(self , rsthis: & QOpenGLFramebufferObject) -> QImage {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK24QOpenGLFramebufferObject7toImageEb()};
let arg0 = self as c_char;
let mut ret = unsafe {C_ZNK24QOpenGLFramebufferObject7toImageEb(rsthis.qclsinst, arg0)};
let mut ret1 = QImage::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: GLuint QOpenGLFramebufferObject::handle();
impl /*struct*/ QOpenGLFramebufferObject {
pub fn handle<RetType, T: QOpenGLFramebufferObject_handle<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.handle(self);
// return 1;
}
}
pub trait QOpenGLFramebufferObject_handle<RetType> {
fn handle(self , rsthis: & QOpenGLFramebufferObject) -> RetType;
}
// proto: GLuint QOpenGLFramebufferObject::handle();
impl<'a> /*trait*/ QOpenGLFramebufferObject_handle<u32> for () {
fn handle(self , rsthis: & QOpenGLFramebufferObject) -> u32 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK24QOpenGLFramebufferObject6handleEv()};
let mut ret = unsafe {C_ZNK24QOpenGLFramebufferObject6handleEv(rsthis.qclsinst)};
return ret as u32; // 1
// return 1;
}
}
// proto: int QOpenGLFramebufferObject::height();
impl /*struct*/ QOpenGLFramebufferObject {
pub fn height<RetType, T: QOpenGLFramebufferObject_height<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.height(self);
// return 1;
}
}
pub trait QOpenGLFramebufferObject_height<RetType> {
fn height(self , rsthis: & QOpenGLFramebufferObject) -> RetType;
}
// proto: int QOpenGLFramebufferObject::height();
impl<'a> /*trait*/ QOpenGLFramebufferObject_height<i32> for () {
fn height(self , rsthis: & QOpenGLFramebufferObject) -> i32 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK24QOpenGLFramebufferObject6heightEv()};
let mut ret = unsafe {C_ZNK24QOpenGLFramebufferObject6heightEv(rsthis.qclsinst)};
return ret as i32; // 1
// return 1;
}
}
// proto: static void QOpenGLFramebufferObject::blitFramebuffer(QOpenGLFramebufferObject * target, QOpenGLFramebufferObject * source, GLbitfield buffers, GLenum filter);
impl /*struct*/ QOpenGLFramebufferObject {
pub fn blitFramebuffer_s<RetType, T: QOpenGLFramebufferObject_blitFramebuffer_s<RetType>>( overload_args: T) -> RetType {
return overload_args.blitFramebuffer_s();
// return 1;
}
}
pub trait QOpenGLFramebufferObject_blitFramebuffer_s<RetType> {
fn blitFramebuffer_s(self ) -> RetType;
}
// proto: static void QOpenGLFramebufferObject::blitFramebuffer(QOpenGLFramebufferObject * target, QOpenGLFramebufferObject * source, GLbitfield buffers, GLenum filter);
impl<'a> /*trait*/ QOpenGLFramebufferObject_blitFramebuffer_s<()> for (&'a QOpenGLFramebufferObject, &'a QOpenGLFramebufferObject, Option<u32>, Option<u32>) {
fn blitFramebuffer_s(self ) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN24QOpenGLFramebufferObject15blitFramebufferEPS_S0_jj()};
let arg0 = self.0.qclsinst as *mut c_void;
let arg1 = self.1.qclsinst as *mut c_void;
let arg2 = (if self.2.is_none() {0 as u32} else {self.2.unwrap()}) as c_uint;
let arg3 = (if self.3.is_none() {0 as u32} else {self.3.unwrap()}) as c_uint;
unsafe {C_ZN24QOpenGLFramebufferObject15blitFramebufferEPS_S0_jj(arg0, arg1, arg2, arg3)};
// return 1;
}
}
// proto: void QOpenGLFramebufferObject::QOpenGLFramebufferObject(int width, int height, const QOpenGLFramebufferObjectFormat & format);
impl<'a> /*trait*/ QOpenGLFramebufferObject_new for (i32, i32, &'a QOpenGLFramebufferObjectFormat) {
fn new(self) -> QOpenGLFramebufferObject {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN24QOpenGLFramebufferObjectC2EiiRK30QOpenGLFramebufferObjectFormat()};
let ctysz: c_int = unsafe{QOpenGLFramebufferObject_Class_Size()};
let qthis_ph: u64 = unsafe{calloc(1, ctysz as usize)} as u64;
let arg0 = self.0 as c_int;
let arg1 = self.1 as c_int;
let arg2 = self.2.qclsinst as *mut c_void;
let qthis: u64 = unsafe {C_ZN24QOpenGLFramebufferObjectC2EiiRK30QOpenGLFramebufferObjectFormat(arg0, arg1, arg2)};
let rsthis = QOpenGLFramebufferObject{qclsinst: qthis, ..Default::default()};
return rsthis;
// return 1;
}
}
// proto: static void QOpenGLFramebufferObject::blitFramebuffer(QOpenGLFramebufferObject * target, const QRect & targetRect, QOpenGLFramebufferObject * source, const QRect & sourceRect, GLbitfield buffers, GLenum filter);
impl<'a> /*trait*/ QOpenGLFramebufferObject_blitFramebuffer_s<()> for (&'a QOpenGLFramebufferObject, &'a QRect, &'a QOpenGLFramebufferObject, &'a QRect, Option<u32>, Option<u32>) {
fn blitFramebuffer_s(self ) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN24QOpenGLFramebufferObject15blitFramebufferEPS_RK5QRectS0_S3_jj()};
let arg0 = self.0.qclsinst as *mut c_void;
let arg1 = self.1.qclsinst as *mut c_void;
let arg2 = self.2.qclsinst as *mut c_void;
let arg3 = self.3.qclsinst as *mut c_void;
let arg4 = (if self.4.is_none() {0 as u32} else {self.4.unwrap()}) as c_uint;
let arg5 = (if self.5.is_none() {0 as u32} else {self.5.unwrap()}) as c_uint;
unsafe {C_ZN24QOpenGLFramebufferObject15blitFramebufferEPS_RK5QRectS0_S3_jj(arg0, arg1, arg2, arg3, arg4, arg5)};
// return 1;
}
}
// proto: QImage QOpenGLFramebufferObject::toImage();
impl<'a> /*trait*/ QOpenGLFramebufferObject_toImage<QImage> for () {
fn toImage(self , rsthis: & QOpenGLFramebufferObject) -> QImage {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK24QOpenGLFramebufferObject7toImageEv()};
let mut ret = unsafe {C_ZNK24QOpenGLFramebufferObject7toImageEv(rsthis.qclsinst)};
let mut ret1 = QImage::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: QSize QOpenGLFramebufferObject::size();
impl /*struct*/ QOpenGLFramebufferObject {
pub fn size<RetType, T: QOpenGLFramebufferObject_size<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.size(self);
// return 1;
}
}
pub trait QOpenGLFramebufferObject_size<RetType> {
fn size(self , rsthis: & QOpenGLFramebufferObject) -> RetType;
}
// proto: QSize QOpenGLFramebufferObject::size();
impl<'a> /*trait*/ QOpenGLFramebufferObject_size<QSize> for () {
fn size(self , rsthis: & QOpenGLFramebufferObject) -> QSize {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK24QOpenGLFramebufferObject4sizeEv()};
let mut ret = unsafe {C_ZNK24QOpenGLFramebufferObject4sizeEv(rsthis.qclsinst)};
let mut ret1 = QSize::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: void QOpenGLFramebufferObject::~QOpenGLFramebufferObject();
impl /*struct*/ QOpenGLFramebufferObject {
pub fn free<RetType, T: QOpenGLFramebufferObject_free<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.free(self);
// return 1;
}
}
pub trait QOpenGLFramebufferObject_free<RetType> {
fn free(self , rsthis: & QOpenGLFramebufferObject) -> RetType;
}
// proto: void QOpenGLFramebufferObject::~QOpenGLFramebufferObject();
impl<'a> /*trait*/ QOpenGLFramebufferObject_free<()> for () {
fn free(self , rsthis: & QOpenGLFramebufferObject) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN24QOpenGLFramebufferObjectD2Ev()};
unsafe {C_ZN24QOpenGLFramebufferObjectD2Ev(rsthis.qclsinst)};
// return 1;
}
}
// proto: QOpenGLFramebufferObjectFormat QOpenGLFramebufferObject::format();
impl /*struct*/ QOpenGLFramebufferObject {
pub fn format<RetType, T: QOpenGLFramebufferObject_format<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.format(self);
// return 1;
}
}
pub trait QOpenGLFramebufferObject_format<RetType> {
fn format(self , rsthis: & QOpenGLFramebufferObject) -> RetType;
}
// proto: QOpenGLFramebufferObjectFormat QOpenGLFramebufferObject::format();
impl<'a> /*trait*/ QOpenGLFramebufferObject_format<QOpenGLFramebufferObjectFormat> for () {
fn format(self , rsthis: & QOpenGLFramebufferObject) -> QOpenGLFramebufferObjectFormat {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK24QOpenGLFramebufferObject6formatEv()};
let mut ret = unsafe {C_ZNK24QOpenGLFramebufferObject6formatEv(rsthis.qclsinst)};
let mut ret1 = QOpenGLFramebufferObjectFormat::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: bool QOpenGLFramebufferObject::bind();
impl /*struct*/ QOpenGLFramebufferObject {
pub fn bind<RetType, T: QOpenGLFramebufferObject_bind<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.bind(self);
// return 1;
}
}
pub trait QOpenGLFramebufferObject_bind<RetType> {
fn bind(self , rsthis: & QOpenGLFramebufferObject) -> RetType;
}
// proto: bool QOpenGLFramebufferObject::bind();
impl<'a> /*trait*/ QOpenGLFramebufferObject_bind<i8> for () {
fn bind(self , rsthis: & QOpenGLFramebufferObject) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN24QOpenGLFramebufferObject4bindEv()};
let mut ret = unsafe {C_ZN24QOpenGLFramebufferObject4bindEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
// proto: bool QOpenGLFramebufferObject::isBound();
impl /*struct*/ QOpenGLFramebufferObject {
pub fn isBound<RetType, T: QOpenGLFramebufferObject_isBound<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.isBound(self);
// return 1;
}
}
pub trait QOpenGLFramebufferObject_isBound<RetType> {
fn isBound(self , rsthis: & QOpenGLFramebufferObject) -> RetType;
}
// proto: bool QOpenGLFramebufferObject::isBound();
impl<'a> /*trait*/ QOpenGLFramebufferObject_isBound<i8> for () {
fn isBound(self , rsthis: & QOpenGLFramebufferObject) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK24QOpenGLFramebufferObject7isBoundEv()};
let mut ret = unsafe {C_ZNK24QOpenGLFramebufferObject7isBoundEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
// proto: int QOpenGLFramebufferObject::width();
impl /*struct*/ QOpenGLFramebufferObject {
pub fn width<RetType, T: QOpenGLFramebufferObject_width<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.width(self);
// return 1;
}
}
pub trait QOpenGLFramebufferObject_width<RetType> {
fn width(self , rsthis: & QOpenGLFramebufferObject) -> RetType;
}
// proto: int QOpenGLFramebufferObject::width();
impl<'a> /*trait*/ QOpenGLFramebufferObject_width<i32> for () {
fn width(self , rsthis: & QOpenGLFramebufferObject) -> i32 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK24QOpenGLFramebufferObject5widthEv()};
let mut ret = unsafe {C_ZNK24QOpenGLFramebufferObject5widthEv(rsthis.qclsinst)};
return ret as i32; // 1
// return 1;
}
}
// proto: void QOpenGLFramebufferObject::QOpenGLFramebufferObject(int width, int height, GLenum target);
impl<'a> /*trait*/ QOpenGLFramebufferObject_new for (i32, i32, Option<u32>) {
fn new(self) -> QOpenGLFramebufferObject {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN24QOpenGLFramebufferObjectC2Eiij()};
let ctysz: c_int = unsafe{QOpenGLFramebufferObject_Class_Size()};
let qthis_ph: u64 = unsafe{calloc(1, ctysz as usize)} as u64;
let arg0 = self.0 as c_int;
let arg1 = self.1 as c_int;
let arg2 = (if self.2.is_none() {0 as u32} else {self.2.unwrap()}) as c_uint;
let qthis: u64 = unsafe {C_ZN24QOpenGLFramebufferObjectC2Eiij(arg0, arg1, arg2)};
let rsthis = QOpenGLFramebufferObject{qclsinst: qthis, ..Default::default()};
return rsthis;
// return 1;
}
}
// <= body block end
|
#![feature(decl_macro, proc_macro_hygiene)]
#[macro_use] extern crate log;
pub mod item;
pub mod order_mgr;
pub mod clock;
pub mod api;
pub mod http_server;
mod table_orders;
|
#![allow(clippy::let_unit_value)]
use std::collections::HashSet;
use std::ops::RangeBounds;
use fuzzcheck::mutators::integer_within_range::I8WithinRangeMutator;
use fuzzcheck::mutators::testing_utilities::test_mutator;
use fuzzcheck::Mutator;
fn test_arbitrary_for_int_range_mutator(range: impl RangeBounds<i8> + IntoIterator<Item = i8> + Clone) {
let m = I8WithinRangeMutator::new(range.clone());
for _ in 0..1000 {
let x = m.random_arbitrary(100.0).0;
assert!(range.contains(&x), "{}", x);
}
let mut step = 0;
let mut all_generated = HashSet::new();
while let Some((x, _)) = m.ordered_arbitrary(&mut step, 100.0) {
let is_new = all_generated.insert(x);
assert!(is_new);
}
for x in range {
assert!(all_generated.contains(&x));
}
}
#[test]
fn test_arbitrary_constrained_signed_integer_8() {
test_arbitrary_for_int_range_mutator(-128..12);
test_arbitrary_for_int_range_mutator(5..10);
test_arbitrary_for_int_range_mutator(0..=0);
test_arbitrary_for_int_range_mutator(-128..=127);
test_arbitrary_for_int_range_mutator(-100..50);
}
#[test]
fn test_mutate_constrained_signed_integer_8() {
let mutator = I8WithinRangeMutator::new(-128..127);
test_mutator(mutator, 1000., 1000., false, true, 100, 100);
let mutator = I8WithinRangeMutator::new(-128..=127);
let mut x = 0;
let mut x_cache = mutator.validate_value(&x).unwrap();
let mut x_step = mutator.default_mutation_step(&x, &x_cache);
let mut set = HashSet::new();
for _ in 0..256 {
let (t, _c) = mutator
.ordered_mutate(
&mut x,
&mut x_cache,
&mut x_step,
&fuzzcheck::subvalue_provider::EmptySubValueProvider,
100.0,
)
.unwrap();
set.insert(x);
mutator.unmutate(&mut x, &mut x_cache, t);
}
let mut set = set.into_iter().collect::<Vec<_>>();
set.sort_unstable();
println!("{} {set:?}", set.len());
let mutator = I8WithinRangeMutator::new(-12..17);
let mut x = 0;
let mut x_cache = mutator.validate_value(&x).unwrap();
let mut x_step = mutator.default_mutation_step(&x, &x_cache);
let mut set = HashSet::new();
for _ in 0..(12 + 16) {
let (t, _c) = mutator
.ordered_mutate(
&mut x,
&mut x_cache,
&mut x_step,
&fuzzcheck::subvalue_provider::EmptySubValueProvider,
100.0,
)
.unwrap();
set.insert(x);
mutator.unmutate(&mut x, &mut x_cache, t);
}
let mut set = set.into_iter().collect::<Vec<_>>();
set.sort_unstable();
println!("{} {set:?}", set.len());
}
|
use crate::BLOCK_224_256_LEN as BLOCK_LEN;
use crate::PAD_AND_LENGTH_224_256_LEN as PAD_AND_LENGTH_LEN;
use crate::STATE_224_256_LEN as STATE_LEN;
use crate::WORD_224_256_LEN as WORD_LEN;
use crate::{inner_full_pad, inner_pad, process_block_224_256, zero_block};
use crate::{Error, Hash, Sha2};
/// Digest length in bytes (224-bits)
pub const DIGEST_LEN: usize = 28;
// Initial state words
const INITIAL_STATE: [u32; STATE_LEN] = [
0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4,
];
/// Implementation of the SHA-256 transform
pub struct Sha224 {
state: [u32; STATE_LEN],
block: [u8; BLOCK_LEN],
index: usize,
bit_index: usize,
total_len: u64,
hash: Hash,
}
impl Sha2 for Sha224 {
type Block = [u8; BLOCK_LEN];
type Digest = [u8; DIGEST_LEN];
type State = [u32; STATE_LEN];
/// Create a newly initialized SHA-256 transform
fn new() -> Self {
Self {
state: INITIAL_STATE,
block: [0_u8; BLOCK_LEN],
index: 0,
bit_index: 0,
total_len: 0,
hash: Hash::Sha224,
}
}
fn encode_state(&self) -> Self::Digest {
let mut res = [0_u8; DIGEST_LEN];
for (i, word) in self.state.iter().enumerate() {
if i * WORD_LEN == DIGEST_LEN {
break;
};
res[i * WORD_LEN..(i + 1) * WORD_LEN].copy_from_slice(word.to_be_bytes().as_ref());
}
res
}
fn process_block(&mut self) {
process_block_224_256(&mut self.state, &mut self.block, &mut self.index);
}
fn pad(&mut self) -> Result<(), Error> {
inner_pad(
&mut self.block,
self.index,
self.bit_index,
self.total_len as u128,
&self.hash,
)
}
fn full_pad(&mut self) {
inner_full_pad(&mut self.block, self.total_len as u128, &self.hash);
}
fn index(&self) -> usize {
self.index
}
fn increment_index(&mut self) {
self.index += 1;
}
fn bit_index(&self) -> usize {
self.bit_index
}
fn set_bit_index(&mut self, index: usize) {
self.bit_index = index;
}
fn total_len(&self) -> u128 {
self.total_len as u128
}
fn increment_total_len(&mut self, len: usize) -> Result<(), Error> {
let len = len as u64;
if len + self.total_len > u64::MAX {
return Err(Error::InvalidLength);
}
// increase the total length of the message
self.total_len += len;
Ok(())
}
fn hash(&self) -> &Hash {
&self.hash
}
fn initial_state(&mut self) {
self.state.copy_from_slice(INITIAL_STATE.as_ref());
}
fn block_mut(&mut self) -> &mut [u8] {
&mut self.block
}
fn zero_block(&mut self) {
zero_block(&mut self.block);
}
fn reset_counters(&mut self) {
self.index = 0;
self.bit_index = 0;
self.total_len = 0;
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn rfc_vector1() {
let input = b"abc";
let expected = [
0x23, 0x09, 0x7d, 0x22, 0x34, 0x05, 0xd8, 0x22, 0x86, 0x42, 0xa4, 0x77, 0xbd, 0xa2,
0x55, 0xb3, 0x2a, 0xad, 0xbc, 0xe4, 0xbd, 0xa0, 0xb3, 0xf7, 0xe3, 0x6c, 0x9d, 0xa7,
];
let mut sha = Sha224::new();
sha.input(input.as_ref()).unwrap();
let digest = sha.finalize().unwrap();
assert_eq!(digest, expected);
}
#[test]
fn rfc_vector2() {
let input = b"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
let expected = [
0x75, 0x38, 0x8b, 0x16, 0x51, 0x27, 0x76, 0xcc, 0x5d, 0xba, 0x5d, 0xa1, 0xfd, 0x89,
0x01, 0x50, 0xb0, 0xc6, 0x45, 0x5c, 0xb4, 0xf5, 0x8b, 0x19, 0x52, 0x52, 0x25, 0x25,
];
let mut sha = Sha224::new();
sha.input(input.as_ref()).unwrap();
let digest = sha.finalize().unwrap();
assert_eq!(digest, expected);
}
#[test]
fn rfc_vector3() {
let input = b"a";
let expected = [
0x20, 0x79, 0x46, 0x55, 0x98, 0x0c, 0x91, 0xd8, 0xbb, 0xb4, 0xc1, 0xea, 0x97, 0x61,
0x8a, 0x4b, 0xf0, 0x3f, 0x42, 0x58, 0x19, 0x48, 0xb2, 0xee, 0x4e, 0xe7, 0xad, 0x67,
];
let mut sha = Sha224::new();
for _i in 0..1_000_000 {
sha.input(input.as_ref()).unwrap();
}
let digest = sha.finalize().unwrap();
assert_eq!(digest, expected);
}
#[test]
fn rfc_vector4() {
let input = b"0123456701234567012345670123456701234567012345670123456701234567";
let expected = [
0x56, 0x7f, 0x69, 0xf1, 0x68, 0xcd, 0x78, 0x44, 0xe6, 0x52, 0x59, 0xce, 0x65, 0x8f,
0xe7, 0xaa, 0xdf, 0xa2, 0x52, 0x16, 0xe6, 0x8e, 0xca, 0x0e, 0xb7, 0xab, 0x82, 0x62,
];
let mut sha = Sha224::new();
for _i in 0..10 {
sha.input(input.as_ref()).unwrap();
}
let digest = sha.finalize().unwrap();
assert_eq!(digest, expected);
}
// FIXME: skip vector 5, 7, and 9 since the `final_bits` API is unimplemented
#[test]
fn rfc_vector5() {
let input = [];
let expected = [
0xe3, 0xb0, 0x48, 0x55, 0x2c, 0x3c, 0x38, 0x7b, 0xca, 0xb3, 0x7f, 0x6e, 0xb0, 0x6b,
0xb7, 0x9b, 0x96, 0xa4, 0xae, 0xe5, 0xff, 0x27, 0xf5, 0x15, 0x31, 0xa9, 0x55, 0x1c,
];
let mut sha = Sha224::new();
sha.input(input.as_ref()).unwrap();
let digest = sha.final_bits(0x68, 5).unwrap();
assert_eq!(digest, expected);
}
#[test]
fn rfc_vector6() {
let input = b"\x07";
let expected = [
0x00, 0xec, 0xd5, 0xf1, 0x38, 0x42, 0x2b, 0x8a, 0xd7, 0x4c, 0x97, 0x99, 0xfd, 0x82,
0x6c, 0x53, 0x1b, 0xad, 0x2f, 0xca, 0xbc, 0x74, 0x50, 0xbe, 0xe2, 0xaa, 0x8c, 0x2a,
];
let mut sha = Sha224::new();
sha.input(input.as_ref()).unwrap();
let digest = sha.finalize().unwrap();
assert_eq!(digest, expected);
}
#[test]
fn rfc_vector7() {
let input = b"\xf0\x70\x06\xf2\x5a\x0b\xea\x68\xcd\x76\xa2\x95\x87\xc2\x8d";
let expected = [
0x1b, 0x01, 0xdb, 0x6c, 0xb4, 0xa9, 0xe4, 0x3d, 0xed, 0x15, 0x16, 0xbe, 0xb3, 0xdb,
0x0b, 0x87, 0xb6, 0xd1, 0xea, 0x43, 0x18, 0x74, 0x62, 0xc6, 0x08, 0x13, 0x71, 0x50,
];
let mut sha = Sha224::new();
sha.input(input.as_ref()).unwrap();
let digest = sha.final_bits(0xa0, 3).unwrap();
assert_eq!(digest, expected);
}
#[test]
fn rfc_vector8() {
let input = b"\x18\x80\x40\x05\xdd\x4f\xbd\x15\x56\x29\x9d\x6f\x9d\x93\xdf\x62";
let expected = [
0xdf, 0x90, 0xd7, 0x8a, 0xa7, 0x88, 0x21, 0xc9, 0x9b, 0x40, 0xba, 0x4c, 0x96, 0x69,
0x21, 0xac, 0xcd, 0x8f, 0xfb, 0x1e, 0x98, 0xac, 0x38, 0x8e, 0x56, 0x19, 0x1d, 0xb1,
];
let mut sha = Sha224::new();
sha.input(input.as_ref()).unwrap();
let digest = sha.finalize().unwrap();
assert_eq!(digest, expected);
}
#[test]
fn rfc_vector9() {
let input = [
0xa2, 0xbe, 0x6e, 0x46, 0x32, 0x81, 0x09, 0x02, 0x94, 0xd9, 0xce, 0x94, 0x82, 0x65,
0x69, 0x42, 0x3a, 0x3a, 0x30, 0x5e, 0xd5, 0xe2, 0x11, 0x6c, 0xd4, 0xa4, 0xc9, 0x87,
0xfc, 0x06, 0x57, 0x00, 0x64, 0x91, 0xb1, 0x49, 0xcc, 0xd4, 0xb5, 0x11, 0x30, 0xac,
0x62, 0xb1, 0x9d, 0xc2, 0x48, 0xc7, 0x44, 0x54, 0x3d, 0x20, 0xcd, 0x39, 0x52, 0xdc,
0xed, 0x1f, 0x06, 0xcc, 0x3b, 0x18, 0xb9, 0x1f, 0x3f, 0x55, 0x63, 0x3e, 0xcc, 0x30,
0x85, 0xf4, 0x90, 0x70, 0x60, 0xd2,
];
let expected = [
0x54, 0xbe, 0xa6, 0xea, 0xb8, 0x19, 0x5a, 0x2e, 0xb0, 0xa7, 0x90, 0x6a, 0x4b, 0x4a,
0x87, 0x66, 0x66, 0x30, 0x0e, 0xef, 0xbd, 0x1f, 0x3b, 0x84, 0x74, 0xf9, 0xcd, 0x57,
];
let mut sha = Sha224::new();
sha.input(input.as_ref()).unwrap();
let digest = sha.final_bits(0xe0, 3).unwrap();
assert_eq!(digest, expected);
}
#[test]
fn rfc_vector10() {
let input = [
0x55, 0xb2, 0x10, 0x07, 0x9c, 0x61, 0xb5, 0x3a, 0xdd, 0x52, 0x06, 0x22, 0xd1, 0xac,
0x97, 0xd5, 0xcd, 0xbe, 0x8c, 0xb3, 0x3a, 0xa0, 0xae, 0x34, 0x45, 0x17, 0xbe, 0xe4,
0xd7, 0xba, 0x09, 0xab, 0xc8, 0x53, 0x3c, 0x52, 0x50, 0x88, 0x7a, 0x43, 0xbe, 0xbb,
0xac, 0x90, 0x6c, 0x2e, 0x18, 0x37, 0xf2, 0x6b, 0x36, 0xa5, 0x9a, 0xe3, 0xbe, 0x78,
0x14, 0xd5, 0x06, 0x89, 0x6b, 0x71, 0x8b, 0x2a, 0x38, 0x3e, 0xcd, 0xac, 0x16, 0xb9,
0x61, 0x25, 0x55, 0x3f, 0x41, 0x6f, 0xf3, 0x2c, 0x66, 0x74, 0xc7, 0x45, 0x99, 0xa9,
0x00, 0x53, 0x86, 0xd9, 0xce, 0x11, 0x12, 0x24, 0x5f, 0x48, 0xee, 0x47, 0x0d, 0x39,
0x6c, 0x1e, 0xd6, 0x3b, 0x92, 0x67, 0x0c, 0xa5, 0x6e, 0xc8, 0x4d, 0xee, 0xa8, 0x14,
0xb6, 0x13, 0x5e, 0xca, 0x54, 0x39, 0x2b, 0xde, 0xdb, 0x94, 0x89, 0xbc, 0x9b, 0x87,
0x5a, 0x8b, 0xaf, 0x0d, 0xc1, 0xae, 0x78, 0x57, 0x36, 0x91, 0x4a, 0xb7, 0xda, 0xa2,
0x64, 0xbc, 0x07, 0x9d, 0x26, 0x9f, 0x2c, 0x0d, 0x7e, 0xdd, 0xd8, 0x10, 0xa4, 0x26,
0x14, 0x5a, 0x07, 0x76, 0xf6, 0x7c, 0x87, 0x82, 0x73,
];
let expected = [
0x0b, 0x31, 0x89, 0x4e, 0xc8, 0x93, 0x7a, 0xd9, 0xb9, 0x1b, 0xdf, 0xbc, 0xba, 0x29,
0x4d, 0x9a, 0xde, 0xfa, 0xa1, 0x8e, 0x09, 0x30, 0x5e, 0x9f, 0x20, 0xd5, 0xc3, 0xa4,
];
let mut sha = Sha224::new();
sha.input(input.as_ref()).unwrap();
let digest = sha.finalize().unwrap();
assert_eq!(digest, expected);
}
}
|
#![allow(unused_variables, non_upper_case_globals, non_snake_case, unused_unsafe, non_camel_case_types, dead_code, clippy::all)]
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct OPERATION_END_PARAMETERS {
pub Version: u32,
pub OperationId: u32,
pub Flags: OPERATION_END_PARAMETERS_FLAGS,
}
impl OPERATION_END_PARAMETERS {}
impl ::core::default::Default for OPERATION_END_PARAMETERS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for OPERATION_END_PARAMETERS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("OPERATION_END_PARAMETERS").field("Version", &self.Version).field("OperationId", &self.OperationId).field("Flags", &self.Flags).finish()
}
}
impl ::core::cmp::PartialEq for OPERATION_END_PARAMETERS {
fn eq(&self, other: &Self) -> bool {
self.Version == other.Version && self.OperationId == other.OperationId && self.Flags == other.Flags
}
}
impl ::core::cmp::Eq for OPERATION_END_PARAMETERS {}
unsafe impl ::windows::core::Abi for OPERATION_END_PARAMETERS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct OPERATION_END_PARAMETERS_FLAGS(pub u32);
pub const OPERATION_END_DISCARD: OPERATION_END_PARAMETERS_FLAGS = OPERATION_END_PARAMETERS_FLAGS(1u32);
impl ::core::convert::From<u32> for OPERATION_END_PARAMETERS_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for OPERATION_END_PARAMETERS_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for OPERATION_END_PARAMETERS_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for OPERATION_END_PARAMETERS_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for OPERATION_END_PARAMETERS_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for OPERATION_END_PARAMETERS_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for OPERATION_END_PARAMETERS_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct OPERATION_START_FLAGS(pub u32);
pub const OPERATION_START_TRACE_CURRENT_THREAD: OPERATION_START_FLAGS = OPERATION_START_FLAGS(1u32);
impl ::core::convert::From<u32> for OPERATION_START_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for OPERATION_START_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for OPERATION_START_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for OPERATION_START_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for OPERATION_START_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for OPERATION_START_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for OPERATION_START_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct OPERATION_START_PARAMETERS {
pub Version: u32,
pub OperationId: u32,
pub Flags: OPERATION_START_FLAGS,
}
impl OPERATION_START_PARAMETERS {}
impl ::core::default::Default for OPERATION_START_PARAMETERS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for OPERATION_START_PARAMETERS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("OPERATION_START_PARAMETERS").field("Version", &self.Version).field("OperationId", &self.OperationId).field("Flags", &self.Flags).finish()
}
}
impl ::core::cmp::PartialEq for OPERATION_START_PARAMETERS {
fn eq(&self, other: &Self) -> bool {
self.Version == other.Version && self.OperationId == other.OperationId && self.Flags == other.Flags
}
}
impl ::core::cmp::Eq for OPERATION_START_PARAMETERS {}
unsafe impl ::windows::core::Abi for OPERATION_START_PARAMETERS {
type Abi = Self;
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn OperationEnd(operationendparams: *const OPERATION_END_PARAMETERS) -> super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn OperationEnd(operationendparams: *const OPERATION_END_PARAMETERS) -> super::super::Foundation::BOOL;
}
::core::mem::transmute(OperationEnd(::core::mem::transmute(operationendparams)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn OperationStart(operationstartparams: *const OPERATION_START_PARAMETERS) -> super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn OperationStart(operationstartparams: *const OPERATION_START_PARAMETERS) -> super::super::Foundation::BOOL;
}
::core::mem::transmute(OperationStart(::core::mem::transmute(operationstartparams)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
|
#[doc = "Reader of register CR2"]
pub type R = crate::R<u32, super::CR2>;
#[doc = "Writer for register CR2"]
pub type W = crate::W<u32, super::CR2>;
#[doc = "Register CR2 `reset()`'s with value 0"]
impl crate::ResetValue for super::CR2 {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0
}
}
#[doc = "Reader of field `TAMP1NOER`"]
pub type TAMP1NOER_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TAMP1NOER`"]
pub struct TAMP1NOER_W<'a> {
w: &'a mut W,
}
impl<'a> TAMP1NOER_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !0x01) | ((value as u32) & 0x01);
self.w
}
}
#[doc = "Reader of field `TAMP2NOER`"]
pub type TAMP2NOER_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TAMP2NOER`"]
pub struct TAMP2NOER_W<'a> {
w: &'a mut W,
}
impl<'a> TAMP2NOER_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 1)) | (((value as u32) & 0x01) << 1);
self.w
}
}
#[doc = "Reader of field `TAMP3NOER`"]
pub type TAMP3NOER_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TAMP3NOER`"]
pub struct TAMP3NOER_W<'a> {
w: &'a mut W,
}
impl<'a> TAMP3NOER_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 2)) | (((value as u32) & 0x01) << 2);
self.w
}
}
#[doc = "Reader of field `TAMP4NOER`"]
pub type TAMP4NOER_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TAMP4NOER`"]
pub struct TAMP4NOER_W<'a> {
w: &'a mut W,
}
impl<'a> TAMP4NOER_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 3)) | (((value as u32) & 0x01) << 3);
self.w
}
}
#[doc = "Reader of field `TAMP5NOER`"]
pub type TAMP5NOER_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TAMP5NOER`"]
pub struct TAMP5NOER_W<'a> {
w: &'a mut W,
}
impl<'a> TAMP5NOER_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 4)) | (((value as u32) & 0x01) << 4);
self.w
}
}
#[doc = "Reader of field `TAMP6NOER`"]
pub type TAMP6NOER_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TAMP6NOER`"]
pub struct TAMP6NOER_W<'a> {
w: &'a mut W,
}
impl<'a> TAMP6NOER_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 5)) | (((value as u32) & 0x01) << 5);
self.w
}
}
#[doc = "Reader of field `TAMP7NOER`"]
pub type TAMP7NOER_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TAMP7NOER`"]
pub struct TAMP7NOER_W<'a> {
w: &'a mut W,
}
impl<'a> TAMP7NOER_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 6)) | (((value as u32) & 0x01) << 6);
self.w
}
}
#[doc = "Reader of field `TAMP8NOER`"]
pub type TAMP8NOER_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TAMP8NOER`"]
pub struct TAMP8NOER_W<'a> {
w: &'a mut W,
}
impl<'a> TAMP8NOER_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 7)) | (((value as u32) & 0x01) << 7);
self.w
}
}
#[doc = "Reader of field `TAMP1MSK`"]
pub type TAMP1MSK_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TAMP1MSK`"]
pub struct TAMP1MSK_W<'a> {
w: &'a mut W,
}
impl<'a> TAMP1MSK_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 16)) | (((value as u32) & 0x01) << 16);
self.w
}
}
#[doc = "Reader of field `TAMP2MSK`"]
pub type TAMP2MSK_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TAMP2MSK`"]
pub struct TAMP2MSK_W<'a> {
w: &'a mut W,
}
impl<'a> TAMP2MSK_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 17)) | (((value as u32) & 0x01) << 17);
self.w
}
}
#[doc = "Reader of field `TAMP3MSK`"]
pub type TAMP3MSK_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TAMP3MSK`"]
pub struct TAMP3MSK_W<'a> {
w: &'a mut W,
}
impl<'a> TAMP3MSK_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 18)) | (((value as u32) & 0x01) << 18);
self.w
}
}
#[doc = "Reader of field `BKERASE`"]
pub type BKERASE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `BKERASE`"]
pub struct BKERASE_W<'a> {
w: &'a mut W,
}
impl<'a> BKERASE_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 23)) | (((value as u32) & 0x01) << 23);
self.w
}
}
#[doc = "Reader of field `TAMP1TRG`"]
pub type TAMP1TRG_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TAMP1TRG`"]
pub struct TAMP1TRG_W<'a> {
w: &'a mut W,
}
impl<'a> TAMP1TRG_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 24)) | (((value as u32) & 0x01) << 24);
self.w
}
}
#[doc = "Reader of field `TAMP2TRG`"]
pub type TAMP2TRG_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TAMP2TRG`"]
pub struct TAMP2TRG_W<'a> {
w: &'a mut W,
}
impl<'a> TAMP2TRG_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 25)) | (((value as u32) & 0x01) << 25);
self.w
}
}
#[doc = "Reader of field `TAMP3TRG`"]
pub type TAMP3TRG_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TAMP3TRG`"]
pub struct TAMP3TRG_W<'a> {
w: &'a mut W,
}
impl<'a> TAMP3TRG_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 26)) | (((value as u32) & 0x01) << 26);
self.w
}
}
#[doc = "Reader of field `TAMP4TRG`"]
pub type TAMP4TRG_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TAMP4TRG`"]
pub struct TAMP4TRG_W<'a> {
w: &'a mut W,
}
impl<'a> TAMP4TRG_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 27)) | (((value as u32) & 0x01) << 27);
self.w
}
}
#[doc = "Reader of field `TAMP5TRG`"]
pub type TAMP5TRG_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TAMP5TRG`"]
pub struct TAMP5TRG_W<'a> {
w: &'a mut W,
}
impl<'a> TAMP5TRG_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 28)) | (((value as u32) & 0x01) << 28);
self.w
}
}
#[doc = "Reader of field `TAMP6TRG`"]
pub type TAMP6TRG_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TAMP6TRG`"]
pub struct TAMP6TRG_W<'a> {
w: &'a mut W,
}
impl<'a> TAMP6TRG_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 29)) | (((value as u32) & 0x01) << 29);
self.w
}
}
#[doc = "Reader of field `TAMP7TRG`"]
pub type TAMP7TRG_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TAMP7TRG`"]
pub struct TAMP7TRG_W<'a> {
w: &'a mut W,
}
impl<'a> TAMP7TRG_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 30)) | (((value as u32) & 0x01) << 30);
self.w
}
}
#[doc = "Reader of field `TAMP8TRG`"]
pub type TAMP8TRG_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TAMP8TRG`"]
pub struct TAMP8TRG_W<'a> {
w: &'a mut W,
}
impl<'a> TAMP8TRG_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 31)) | (((value as u32) & 0x01) << 31);
self.w
}
}
impl R {
#[doc = "Bit 0 - TAMP1NOER"]
#[inline(always)]
pub fn tamp1noer(&self) -> TAMP1NOER_R {
TAMP1NOER_R::new((self.bits & 0x01) != 0)
}
#[doc = "Bit 1 - TAMP2NOER"]
#[inline(always)]
pub fn tamp2noer(&self) -> TAMP2NOER_R {
TAMP2NOER_R::new(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 2 - TAMP3NOER"]
#[inline(always)]
pub fn tamp3noer(&self) -> TAMP3NOER_R {
TAMP3NOER_R::new(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bit 3 - TAMP4NOER"]
#[inline(always)]
pub fn tamp4noer(&self) -> TAMP4NOER_R {
TAMP4NOER_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 4 - TAMP5NOER"]
#[inline(always)]
pub fn tamp5noer(&self) -> TAMP5NOER_R {
TAMP5NOER_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 5 - TAMP6NOER"]
#[inline(always)]
pub fn tamp6noer(&self) -> TAMP6NOER_R {
TAMP6NOER_R::new(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bit 6 - TAMP7NOER"]
#[inline(always)]
pub fn tamp7noer(&self) -> TAMP7NOER_R {
TAMP7NOER_R::new(((self.bits >> 6) & 0x01) != 0)
}
#[doc = "Bit 7 - TAMP8NOER"]
#[inline(always)]
pub fn tamp8noer(&self) -> TAMP8NOER_R {
TAMP8NOER_R::new(((self.bits >> 7) & 0x01) != 0)
}
#[doc = "Bit 16 - TAMP1MSK"]
#[inline(always)]
pub fn tamp1msk(&self) -> TAMP1MSK_R {
TAMP1MSK_R::new(((self.bits >> 16) & 0x01) != 0)
}
#[doc = "Bit 17 - TAMP2MSK"]
#[inline(always)]
pub fn tamp2msk(&self) -> TAMP2MSK_R {
TAMP2MSK_R::new(((self.bits >> 17) & 0x01) != 0)
}
#[doc = "Bit 18 - TAMP3MSK"]
#[inline(always)]
pub fn tamp3msk(&self) -> TAMP3MSK_R {
TAMP3MSK_R::new(((self.bits >> 18) & 0x01) != 0)
}
#[doc = "Bit 23 - BKERASE"]
#[inline(always)]
pub fn bkerase(&self) -> BKERASE_R {
BKERASE_R::new(((self.bits >> 23) & 0x01) != 0)
}
#[doc = "Bit 24 - TAMP1TRG"]
#[inline(always)]
pub fn tamp1trg(&self) -> TAMP1TRG_R {
TAMP1TRG_R::new(((self.bits >> 24) & 0x01) != 0)
}
#[doc = "Bit 25 - TAMP2TRG"]
#[inline(always)]
pub fn tamp2trg(&self) -> TAMP2TRG_R {
TAMP2TRG_R::new(((self.bits >> 25) & 0x01) != 0)
}
#[doc = "Bit 26 - TAMP3TRG"]
#[inline(always)]
pub fn tamp3trg(&self) -> TAMP3TRG_R {
TAMP3TRG_R::new(((self.bits >> 26) & 0x01) != 0)
}
#[doc = "Bit 27 - TAMP4TRG"]
#[inline(always)]
pub fn tamp4trg(&self) -> TAMP4TRG_R {
TAMP4TRG_R::new(((self.bits >> 27) & 0x01) != 0)
}
#[doc = "Bit 28 - TAMP5TRG"]
#[inline(always)]
pub fn tamp5trg(&self) -> TAMP5TRG_R {
TAMP5TRG_R::new(((self.bits >> 28) & 0x01) != 0)
}
#[doc = "Bit 29 - TAMP6TRG"]
#[inline(always)]
pub fn tamp6trg(&self) -> TAMP6TRG_R {
TAMP6TRG_R::new(((self.bits >> 29) & 0x01) != 0)
}
#[doc = "Bit 30 - TAMP7TRG"]
#[inline(always)]
pub fn tamp7trg(&self) -> TAMP7TRG_R {
TAMP7TRG_R::new(((self.bits >> 30) & 0x01) != 0)
}
#[doc = "Bit 31 - TAMP8TRG"]
#[inline(always)]
pub fn tamp8trg(&self) -> TAMP8TRG_R {
TAMP8TRG_R::new(((self.bits >> 31) & 0x01) != 0)
}
}
impl W {
#[doc = "Bit 0 - TAMP1NOER"]
#[inline(always)]
pub fn tamp1noer(&mut self) -> TAMP1NOER_W {
TAMP1NOER_W { w: self }
}
#[doc = "Bit 1 - TAMP2NOER"]
#[inline(always)]
pub fn tamp2noer(&mut self) -> TAMP2NOER_W {
TAMP2NOER_W { w: self }
}
#[doc = "Bit 2 - TAMP3NOER"]
#[inline(always)]
pub fn tamp3noer(&mut self) -> TAMP3NOER_W {
TAMP3NOER_W { w: self }
}
#[doc = "Bit 3 - TAMP4NOER"]
#[inline(always)]
pub fn tamp4noer(&mut self) -> TAMP4NOER_W {
TAMP4NOER_W { w: self }
}
#[doc = "Bit 4 - TAMP5NOER"]
#[inline(always)]
pub fn tamp5noer(&mut self) -> TAMP5NOER_W {
TAMP5NOER_W { w: self }
}
#[doc = "Bit 5 - TAMP6NOER"]
#[inline(always)]
pub fn tamp6noer(&mut self) -> TAMP6NOER_W {
TAMP6NOER_W { w: self }
}
#[doc = "Bit 6 - TAMP7NOER"]
#[inline(always)]
pub fn tamp7noer(&mut self) -> TAMP7NOER_W {
TAMP7NOER_W { w: self }
}
#[doc = "Bit 7 - TAMP8NOER"]
#[inline(always)]
pub fn tamp8noer(&mut self) -> TAMP8NOER_W {
TAMP8NOER_W { w: self }
}
#[doc = "Bit 16 - TAMP1MSK"]
#[inline(always)]
pub fn tamp1msk(&mut self) -> TAMP1MSK_W {
TAMP1MSK_W { w: self }
}
#[doc = "Bit 17 - TAMP2MSK"]
#[inline(always)]
pub fn tamp2msk(&mut self) -> TAMP2MSK_W {
TAMP2MSK_W { w: self }
}
#[doc = "Bit 18 - TAMP3MSK"]
#[inline(always)]
pub fn tamp3msk(&mut self) -> TAMP3MSK_W {
TAMP3MSK_W { w: self }
}
#[doc = "Bit 23 - BKERASE"]
#[inline(always)]
pub fn bkerase(&mut self) -> BKERASE_W {
BKERASE_W { w: self }
}
#[doc = "Bit 24 - TAMP1TRG"]
#[inline(always)]
pub fn tamp1trg(&mut self) -> TAMP1TRG_W {
TAMP1TRG_W { w: self }
}
#[doc = "Bit 25 - TAMP2TRG"]
#[inline(always)]
pub fn tamp2trg(&mut self) -> TAMP2TRG_W {
TAMP2TRG_W { w: self }
}
#[doc = "Bit 26 - TAMP3TRG"]
#[inline(always)]
pub fn tamp3trg(&mut self) -> TAMP3TRG_W {
TAMP3TRG_W { w: self }
}
#[doc = "Bit 27 - TAMP4TRG"]
#[inline(always)]
pub fn tamp4trg(&mut self) -> TAMP4TRG_W {
TAMP4TRG_W { w: self }
}
#[doc = "Bit 28 - TAMP5TRG"]
#[inline(always)]
pub fn tamp5trg(&mut self) -> TAMP5TRG_W {
TAMP5TRG_W { w: self }
}
#[doc = "Bit 29 - TAMP6TRG"]
#[inline(always)]
pub fn tamp6trg(&mut self) -> TAMP6TRG_W {
TAMP6TRG_W { w: self }
}
#[doc = "Bit 30 - TAMP7TRG"]
#[inline(always)]
pub fn tamp7trg(&mut self) -> TAMP7TRG_W {
TAMP7TRG_W { w: self }
}
#[doc = "Bit 31 - TAMP8TRG"]
#[inline(always)]
pub fn tamp8trg(&mut self) -> TAMP8TRG_W {
TAMP8TRG_W { w: self }
}
}
|
use std::{collections::HashMap, sync::Arc};
use async_trait::async_trait;
use chrono::NaiveDateTime;
use dataloader::{cached::Loader, BatchFn};
use diesel::prelude::*;
use futures::executor::block_on;
use oorandom::Rand32;
use crate::{
db::SqlitePool,
external_id::ExternalId,
graphql_schema::RequestContext,
schema::{albums, artists, genres, playlists, playlists_tracks, prngs, tracks, users},
};
#[derive(Clone)]
pub struct AlbumBatcher {
pub pool: Arc<SqlitePool>,
}
#[async_trait]
impl BatchFn<i32, Album> for AlbumBatcher {
async fn load(&self, keys: &[i32]) -> HashMap<i32, Album> {
let conn = self.pool.get().unwrap();
let albums = albums::table
.filter(albums::id.eq_any(keys))
.load::<Album>(&conn)
.unwrap();
{
let mut album_hashmap = HashMap::new();
for album in albums {
album_hashmap.insert(album.id, album);
}
album_hashmap
}
}
}
pub type AlbumLoader = Loader<i32, Album, AlbumBatcher>;
#[derive(Clone)]
pub struct ArtistBatcher {
pub pool: Arc<SqlitePool>,
}
#[async_trait]
impl BatchFn<i32, Artist> for ArtistBatcher {
async fn load(&self, keys: &[i32]) -> HashMap<i32, Artist> {
let conn = self.pool.get().unwrap();
let artists = artists::table
.filter(artists::id.eq_any(keys))
.load::<Artist>(&conn)
.unwrap();
{
let mut artist_hashmap = HashMap::new();
for artist in artists {
artist_hashmap.insert(artist.id, artist);
}
artist_hashmap
}
}
}
pub type ArtistLoader = Loader<i32, Artist, ArtistBatcher>;
#[derive(Clone)]
pub struct GenreBatcher {
pub pool: Arc<SqlitePool>,
}
#[async_trait]
impl BatchFn<i32, Genre> for GenreBatcher {
async fn load(&self, keys: &[i32]) -> HashMap<i32, Genre> {
let conn = self.pool.get().unwrap();
let genres = genres::table
.filter(genres::id.eq_any(keys))
.load::<Genre>(&conn)
.unwrap();
{
let mut genre_hashmap = HashMap::new();
for genre in genres {
genre_hashmap.insert(genre.id, genre);
}
genre_hashmap
}
}
}
pub type GenreLoader = Loader<i32, Genre, GenreBatcher>;
#[derive(Identifiable, Queryable, Clone)]
pub struct Album {
pub id: i32,
pub created_at: NaiveDateTime,
pub name: String,
}
#[juniper::object(Context = RequestContext)]
impl Album {
pub fn id(&self) -> juniper::ID {
ExternalId::from(self.id).0
}
pub fn created_at(&self) -> NaiveDateTime {
self.created_at
}
pub fn name(&self) -> &str {
&self.name[..]
}
pub fn tracks(&self, context: &RequestContext) -> juniper::FieldResult<Vec<Track>> {
let conn = context.pool.get()?;
Ok(Track::belonging_to(self).load::<Track>(&conn)?)
}
}
#[derive(Insertable)]
#[table_name = "albums"]
pub struct NewAlbum {
pub id: i32,
pub name: String,
}
#[derive(AsChangeset, juniper::GraphQLInputObject)]
#[changeset_options(treat_none_as_null = "true")]
#[table_name = "albums"]
pub struct AlbumInput {
pub name: String,
}
#[derive(Identifiable, Queryable, Clone)]
pub struct Artist {
pub id: i32,
pub created_at: NaiveDateTime,
pub name: String,
}
#[juniper::object(Context = RequestContext)]
impl Artist {
pub fn id(&self) -> juniper::ID {
ExternalId::from(self.id).0
}
pub fn created_at(&self) -> NaiveDateTime {
self.created_at
}
pub fn name(&self) -> &str {
&self.name[..]
}
pub fn albums(&self, context: &RequestContext) -> juniper::FieldResult<Vec<Album>> {
let conn = context.pool.get()?;
let album_ids: Vec<i32> = Track::belonging_to(self)
.select(tracks::album_id)
.distinct()
.filter(tracks::album_id.is_not_null())
.load::<Option<i32>>(&conn)?
.into_iter()
.flatten()
.collect();
Ok(albums::table
.filter(albums::id.eq_any(album_ids))
.load::<Album>(&conn)?)
}
pub fn tracks(&self, context: &RequestContext) -> juniper::FieldResult<Vec<Track>> {
let conn = context.pool.get()?;
Ok(Track::belonging_to(self).load::<Track>(&conn)?)
}
}
#[derive(Insertable)]
#[table_name = "artists"]
pub struct NewArtist {
pub id: i32,
pub name: String,
}
#[derive(AsChangeset, juniper::GraphQLInputObject)]
#[changeset_options(treat_none_as_null = "true")]
#[table_name = "artists"]
pub struct ArtistInput {
pub name: String,
}
#[derive(Identifiable, Queryable, Clone)]
pub struct Genre {
pub id: i32,
pub created_at: NaiveDateTime,
pub name: String,
}
#[juniper::object(Context = RequestContext)]
impl Genre {
pub fn id(&self) -> juniper::ID {
ExternalId::from(self.id).0
}
pub fn created_at(&self) -> NaiveDateTime {
self.created_at
}
pub fn name(&self) -> &str {
&self.name[..]
}
pub fn tracks(&self, context: &RequestContext) -> juniper::FieldResult<Vec<Track>> {
let conn = context.pool.get()?;
Ok(Track::belonging_to(self).load::<Track>(&conn)?)
}
}
#[derive(Insertable)]
#[table_name = "genres"]
pub struct NewGenre {
pub id: i32,
pub name: String,
}
#[derive(AsChangeset, juniper::GraphQLInputObject)]
#[changeset_options(treat_none_as_null = "true")]
#[table_name = "genres"]
pub struct GenreInput {
pub name: String,
}
#[derive(Identifiable, Associations, Queryable)]
#[belongs_to(Album)]
#[belongs_to(Artist)]
#[belongs_to(Genre)]
pub struct Track {
pub id: i32,
pub created_at: NaiveDateTime,
pub name: String,
pub duration: i32,
pub album_id: Option<i32>,
pub artist_id: Option<i32>,
pub genre_id: Option<i32>,
pub track_number: Option<i32>,
}
#[juniper::object(Context = RequestContext)]
impl Track {
pub fn id(&self) -> juniper::ID {
ExternalId::from(self.id).0
}
pub fn created_at(&self) -> NaiveDateTime {
self.created_at
}
pub fn name(&self) -> &str {
&self.name[..]
}
pub fn duration(&self) -> i32 {
self.duration
}
pub fn album(&self, context: &RequestContext) -> juniper::FieldResult<Option<Album>> {
if let Some(album_id) = self.album_id {
Ok(Some(block_on(context.album_loader.load(album_id))))
} else {
Ok(None)
}
}
pub fn artist(&self, context: &RequestContext) -> juniper::FieldResult<Option<Artist>> {
if let Some(artist_id) = self.artist_id {
Ok(Some(block_on(context.artist_loader.load(artist_id))))
} else {
Ok(None)
}
}
pub fn genre(&self, context: &RequestContext) -> juniper::FieldResult<Option<Genre>> {
let conn = context.pool.get()?;
if let Some(genre_id) = self.genre_id {
Ok(Some(block_on(context.genre_loader.load(genre_id))))
} else {
Ok(None)
}
}
pub fn track_number(&self) -> Option<i32> {
self.track_number
}
}
#[derive(Insertable)]
#[table_name = "tracks"]
pub struct NewTrack {
pub id: i32,
pub name: String,
pub duration: i32,
pub album_id: Option<i32>,
pub artist_id: Option<i32>,
pub genre_id: Option<i32>,
pub track_number: Option<i32>,
}
#[derive(juniper::GraphQLInputObject)]
pub struct TrackInput {
pub name: String,
pub album_id: Option<juniper::ID>,
pub artist_id: Option<juniper::ID>,
pub genre_id: Option<juniper::ID>,
pub track_number: Option<i32>,
}
#[derive(AsChangeset)]
#[changeset_options(treat_none_as_null = "true")]
#[table_name = "tracks"]
pub struct TrackChangeset {
pub name: String,
pub album_id: Option<i32>,
pub artist_id: Option<i32>,
pub genre_id: Option<i32>,
pub track_number: Option<i32>,
}
#[derive(Identifiable, Queryable)]
pub struct Playlist {
pub id: i32,
pub created_at: NaiveDateTime,
pub name: String,
}
#[juniper::object(Context = RequestContext)]
impl Playlist {
pub fn id(&self) -> juniper::ID {
ExternalId::from(self.id).0
}
pub fn created_at(&self) -> NaiveDateTime {
self.created_at
}
pub fn name(&self) -> &str {
&self.name[..]
}
pub fn tracks(&self, context: &RequestContext) -> juniper::FieldResult<Vec<Track>> {
let conn = context.pool.get()?;
Ok(PlaylistTrack::belonging_to(self)
.inner_join(tracks::table)
.select(tracks::all_columns)
.order_by(playlists_tracks::position.asc())
.load::<Track>(&conn)?)
}
}
#[derive(Insertable)]
#[table_name = "playlists"]
pub struct NewPlaylist {
pub id: i32,
pub name: String,
}
#[derive(AsChangeset, juniper::GraphQLInputObject)]
#[changeset_options(treat_none_as_null = "true")]
#[table_name = "playlists"]
pub struct PlaylistInput {
pub name: String,
}
#[derive(Identifiable, Associations, Queryable)]
#[belongs_to(Playlist)]
#[belongs_to(Track)]
#[table_name = "playlists_tracks"]
pub struct PlaylistTrack {
pub id: i32,
pub created_at: NaiveDateTime,
pub playlist_id: i32,
pub track_id: i32,
pub position: i32,
}
#[derive(Insertable)]
#[table_name = "playlists_tracks"]
pub struct NewPlaylistTrack {
pub track_id: i32,
pub position: Option<i32>,
}
#[derive(juniper::GraphQLInputObject)]
pub struct PlaylistTrackInput {
#[graphql(name = "id")]
pub track_id: juniper::ID,
pub position: Option<i32>,
}
#[derive(juniper::GraphQLInputObject)]
pub struct PlaylistTrackOrderInput {
pub range_start: i32,
pub range_length: Option<i32>,
pub insert_before: i32,
}
#[derive(Identifiable, Queryable)]
#[primary_key(username)]
pub struct User {
pub username: String,
pub password: Vec<u8>,
}
#[derive(juniper::GraphQLInputObject)]
pub struct UserInput {
pub password: String,
}
#[derive(AsChangeset)]
#[changeset_options(treat_none_as_null = "true")]
#[table_name = "users"]
pub struct UserChangeset {
pub password: Vec<u8>,
}
#[derive(AsChangeset, Identifiable, Insertable, Queryable)]
pub struct Prng {
pub id: i32,
pub state: i64,
pub inc: i64,
}
impl From<Rand32> for Prng {
fn from(rand32: Rand32) -> Self {
let (state, inc) = rand32.state();
Prng {
id: 1,
state: i64::from_le_bytes(state.to_le_bytes()),
inc: i64::from_le_bytes(inc.to_le_bytes()),
}
}
}
impl From<Prng> for Rand32 {
fn from(prng: Prng) -> Self {
let state = u64::from_le_bytes(prng.state.to_le_bytes());
let inc = u64::from_le_bytes(prng.inc.to_le_bytes());
let state = (state, inc);
Rand32::from_state(state)
}
}
|
// See LICENSE file for copyright and license details.
use core::types::{MInt};
use visualizer::types::{WorldPos, MFloat};
use visualizer::mesh::MeshId;
use std::collections::hashmap::HashMap;
// TODO: why scene knows about other systems?
pub const MAX_UNIT_NODE_ID: NodeId = NodeId{id: 1000};
pub const MIN_MARKER_NODE_ID: NodeId = NodeId{id: MAX_UNIT_NODE_ID.id + 1};
pub const MAX_MARKER_NODE_ID: NodeId = NodeId{id: MAX_UNIT_NODE_ID.id * 2};
pub const SHELL_NODE_ID: NodeId = NodeId{id: MAX_MARKER_NODE_ID.id + 1};
pub const SELECTION_NODE_ID: NodeId = NodeId{id: SHELL_NODE_ID.id + 1};
#[deriving(PartialOrd, Ord, PartialEq, Eq, Hash)]
pub struct NodeId{pub id: MInt}
pub struct SceneNode {
pub pos: WorldPos,
pub rot: MFloat,
pub mesh_id: Option<MeshId>,
pub children: Vec<SceneNode>,
}
pub struct Scene {
pub nodes: HashMap<NodeId, SceneNode>,
}
impl Scene {
pub fn new() -> Scene {
Scene {
nodes: HashMap::new(),
}
}
}
// vim: set tabstop=4 shiftwidth=4 softtabstop=4 expandtab:
|
// Copyright 2013 The CGMath Developers. For a full listing of the authors,
// refer to the AUTHORS file at the top-level directory of this distribution.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//! Axis-aligned bounding boxes
use std::fmt;
use std::num::{zero, one};
use std::iter::{FromIterator, Iterator};
use std::default::Default;
use serialize::{Encodable};
use cgmath::{Point, Point2, Point3};
use cgmath::{Vector, Vector2, Vector3};
use cgmath::BaseNum;
use cgmath::ApproxEq;
use {Max, Min, Center, Merge, Intersects, CheckRange2, CheckRange3};
pub trait Aabb
<
S: BaseNum,
V: Vector<S>,
P: Point<S, V>
> {
fn new(p1: P, p2: P) -> Self;
fn aabb_min<'a>(&'a self) -> &'a P;
fn aabb_max<'a>(&'a self) -> &'a P;
#[inline] fn dim(&self) -> V { self.aabb_max().sub_p(self.aabb_min()) }
#[inline] fn volume(&self) -> S { self.dim().comp_mul() }
// Tests whether a point is cointained in the box, inclusive for min corner
// and exclusive for the max corner.
fn contains(&self, p: &P) -> bool;
// Returns a new AABB that is grown to include the given point.
fn grow(&self, p: &P) -> Self {
let min = self.aabb_min().min(p);
let max = self.aabb_max().max(p);
Aabb::new(min, max)
}
// Returns a new AABB that has its points translated by the given vector.
fn add_v(&self, v: &V) -> Self {
Aabb::new(self.aabb_min().add_v(v), self.aabb_max().add_v(v))
}
fn mul_s(&self, s: S) -> Self {
Aabb::new(self.aabb_min().mul_s(s.clone()), self.aabb_max().mul_s(s.clone()))
}
fn mul_v(&self, v: &V) -> Self {
let min : P = Point::from_vec(&self.aabb_min().to_vec().mul_v(v));
let max : P = Point::from_vec(&self.aabb_max().to_vec().mul_v(v));
Aabb::new(min, max)
}
}
#[deriving(PartialEq, Clone, Encodable, Decodable)]
pub struct Aabb2<S> {
pub min: Point2<S>,
pub max: Point2<S>,
}
impl<S: BaseNum> Aabb2<S> {
/// Construct a new axis-aligned bounding box from two points.
#[inline]
pub fn new(p1: Point2<S>, p2: Point2<S>) -> Aabb2<S> {
Aabb2 {
min: Point2::new(p1.x.partial_min(p2.x),
p1.y.partial_min(p2.y)),
max: Point2::new(p1.x.partial_max(p2.x),
p1.y.partial_max(p2.y)),
}
}
}
impl<S: BaseNum> Aabb<S, Vector2<S>, Point2<S>> for Aabb2<S> {
fn new(p1: Point2<S>, p2: Point2<S>) -> Aabb2<S> { Aabb2::new(p1, p2) }
#[inline] fn aabb_min<'a>(&'a self) -> &'a Point2<S> { &self.min }
#[inline] fn aabb_max<'a>(&'a self) -> &'a Point2<S> { &self.max }
#[inline]
fn contains(&self, p: &Point2<S>) -> bool {
let v_min = p.sub_p(self.aabb_min());
let v_max = self.aabb_max().sub_p(p);
v_min.x >= zero() && v_min.y >= zero() &&
v_max.x > zero() && v_max.y > zero()
}
}
impl<S: fmt::Show+BaseNum> fmt::Show for Aabb2<S> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "[{} - {}]", self.min, self.max)
}
}
impl<S: BaseNum> FromIterator<Point2<S>> for Aabb2<S> {
fn from_iter<T: Iterator<Point2<S>>>(iterator: T) -> Aabb2<S> {
let mut iterator = iterator;
let (mut max, mut min) = match iterator.next() {
Some(m) => (Point2::new(m.x, m.y), Point2::new(m.x, m.y)),
None => return Aabb2::new(Point2::new(zero(), zero()),
Point2::new(zero(), zero())),
};
for point in iterator {
max.x = max.x.partial_max(point.x);
max.y = max.y.partial_max(point.y);
min.x = min.x.partial_min(point.x);
min.y = min.y.partial_min(point.y);
}
Aabb2 {
min: min,
max: max
}
}
}
#[deriving(Clone, PartialEq, Encodable, Decodable)]
pub struct Aabb3<S> {
pub min: Point3<S>,
pub max: Point3<S>,
}
impl<S: BaseNum> Aabb3<S> {
/// Construct a new axis-aligned bounding box from two points.
#[inline]
pub fn new(p1: Point3<S>, p2: Point3<S>) -> Aabb3<S> {
Aabb3 {
min: Point3::new(p1.x.partial_min(p2.x),
p1.y.partial_min(p2.y),
p1.z.partial_min(p2.z)),
max: Point3::new(p1.x.partial_max(p2.x),
p1.y.partial_max(p2.y),
p1.z.partial_max(p2.z)),
}
}
}
impl<S: BaseNum> Aabb<S, Vector3<S>, Point3<S>> for Aabb3<S> {
fn new(p1: Point3<S>, p2: Point3<S>) -> Aabb3<S> { Aabb3::new(p1, p2) }
#[inline] fn aabb_min<'a>(&'a self) -> &'a Point3<S> { &self.min }
#[inline] fn aabb_max<'a>(&'a self) -> &'a Point3<S> { &self.max }
#[inline]
fn contains(&self, p: &Point3<S>) -> bool {
let v_min = p.sub_p(self.aabb_min());
let v_max = self.aabb_max().sub_p(p);
v_min.x >= zero() && v_min.y >= zero() && v_min.z >= zero() &&
v_max.x > zero() && v_max.y > zero() && v_max.z > zero()
}
}
impl<S: fmt::Show+BaseNum> fmt::Show for Aabb3<S> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "[{} - {}]", self.min, self.max)
}
}
impl<S: BaseNum> FromIterator<Point3<S>> for Aabb3<S> {
fn from_iter<T: Iterator<Point3<S>>>(iterator: T) -> Aabb3<S> {
let mut iterator = iterator;
let (mut max, mut min) = match iterator.next() {
Some(m) => (Point3::new(m.x, m.y, m.z), Point3::new(m.x, m.y, m.z)),
None => return Aabb3::new(Point3::new(zero(), zero(), zero()),
Point3::new(zero(), zero(), zero())),
};
for point in iterator {
max.x = max.x.partial_max(point.x);
max.y = max.y.partial_max(point.y);
max.z = max.z.partial_max(point.z);
min.x = min.x.partial_min(point.x);
min.y = min.y.partial_min(point.y);
min.z = min.z.partial_min(point.z);
}
Aabb3 {
min: min,
max: max
}
}
}
impl<S: Float+ApproxEq<S>> CheckRange2<S> for Aabb3<S> {
fn check_x(&self, center: S, _: S) -> (bool, bool) {
(self.min.x <= center,
self.max.x > center)
}
fn check_y(&self, center: S, _: S) -> (bool, bool) {
(self.min.y <= center,
self.max.y > center)
}
}
impl<S: Float+ApproxEq<S>> CheckRange3<S> for Aabb3<S> {
fn check_z(&self, center: S, _: S) -> (bool, bool) {
(self.min.z <= center,
self.max.z > center)
}
}
impl<S: BaseNum> Intersects<Aabb2<S>> for Aabb2<S> {
fn intersect(&self, other: &Aabb2<S>) -> bool {
!(self.max.x < other.min.x ||
self.max.y < other.min.y ||
self.min.x > other.max.x ||
self.min.y > other.max.y)
}
}
impl<S: BaseNum> Intersects<Aabb3<S>> for Aabb3<S> {
fn intersect(&self, other: &Aabb3<S>) -> bool {
!(self.max.x < other.min.x ||
self.max.y < other.min.y ||
self.max.z < other.min.z ||
self.min.x > other.max.x ||
self.min.y > other.max.y ||
self.min.z > other.max.z)
}
}
impl<S: BaseNum> Center<Point2<S>> for Aabb2<S> {
fn center(&self) -> Point2<S> {
let two = one::<S>() + one::<S>();
self.aabb_min().add_v(&self.dim().div_s(two))
}
}
impl<S: BaseNum> Center<Point3<S>> for Aabb3<S> {
fn center(&self) -> Point3<S> {
let two = one::<S>() + one::<S>();
self.aabb_min().add_v(&self.dim().div_s(two))
}
}
impl<S: BaseNum> Max<Point2<S>> for Aabb2<S> {
fn max(&self) -> Point2<S> {
self.max.clone()
}
}
impl<S: BaseNum> Max<Point3<S>> for Aabb3<S> {
fn max(&self) -> Point3<S> {
self.max.clone()
}
}
impl<S: BaseNum> Min<Point2<S>> for Aabb2<S> {
fn min(&self) -> Point2<S> {
self.max.clone()
}
}
impl<S: BaseNum> Min<Point3<S>> for Aabb3<S> {
fn min(&self) -> Point3<S> {
self.min.clone()
}
}
impl<S: BaseNum> Merge for Aabb2<S> {
fn merge(&self, other: &Aabb2<S>) -> Aabb2<S> {
let max = Point2::new(self.max.x.partial_max(other.max.x),
self.max.y.partial_max(other.max.y));
let min = Point2::new(self.min.x.partial_min(other.min.x),
self.min.y.partial_min(other.min.y));
Aabb2 {
min: min,
max: max
}
}
}
impl<S: BaseNum> Merge for Aabb3<S> {
fn merge(&self, other: &Aabb3<S>) -> Aabb3<S> {
let max = Point3::new(self.max.x.partial_max(other.max.x),
self.max.y.partial_max(other.max.y),
self.max.z.partial_max(other.max.z));
let min = Point3::new(self.min.x.partial_min(other.min.x),
self.min.y.partial_min(other.min.y),
self.min.z.partial_min(other.min.z));
Aabb3 {
min: min,
max: max
}
}
}
impl<S: BaseNum> Default for Aabb3<S> {
fn default() -> Aabb3<S> {
Aabb3 {
min: Point::origin(),
max: Point::origin()
}
}
}
impl<S: BaseNum> Default for Aabb2<S> {
fn default() -> Aabb2<S> {
Aabb2 {
min: Point::origin(),
max: Point::origin()
}
}
} |
use quicksilver::{
Result,
geom::{Rectangle, Circle, Vector, Shape},
graphics::{Background::Col, Color},
lifecycle::{Settings, State, Window, run},
input::Key,
lifecycle::Event,
};
use nalgebra as na;
use na::{Vector2, Isometry2, zero};
use ncollide2d::{
shape::{ShapeHandle, Ball, Cuboid},
world::CollisionObjectHandle,
events::ContactEvent,
};
use nphysics2d::{
world::World,
object::{RigidBodyDesc, ColliderDesc, BodyStatus, Body},
material::{MaterialHandle, BasicMaterial},
algebra::Velocity2,
};
use ncollide2d::world::CollisionGroups;
use laminar::{
Packet,
Socket
};
use crossbeam::channel::Sender;
use byteorder::{ByteOrder, LittleEndian, BigEndian, WriteBytesExt, ReadBytesExt};
struct PlatformPlay {
view: Rectangle,
ball: Circle,
world: World<f32>,
}
impl State for PlatformPlay {
fn new() -> Result<PlatformPlay> {
let rect_c = Rectangle::new((400., 20.), (40., 10.));
let mut world = World::new();
world.set_gravity(Vector2::new(0., 9.));
let rect = ShapeHandle::new(Cuboid::new(Vector2::new(10., 300.)));
let rect2 = ShapeHandle::new(Cuboid::new(Vector2::new(10., 300.)));
let rect3 = ShapeHandle::new(Cuboid::new(Vector2::new(400., 10.)));
let rect4 = ShapeHandle::new(Cuboid::new(Vector2::new(400., 10.)));
let parent_handle = RigidBodyDesc::new();
let parent_handle2 = RigidBodyDesc::new();
let wall_group = MaterialHandle::new(BasicMaterial::new(0.7, 0.4));
let handle_box = ColliderDesc::new(rect)
.position(Isometry2::new(Vector2::new(0.0, -300.0), 0.))
.material(wall_group.clone());
let handle_box2 = ColliderDesc::new(rect2)
.position(Isometry2::new(Vector2::new(800.0, -300.0), 0.))
.material(wall_group.clone());
let handle_box23 = ColliderDesc::new(rect3)
.position(Isometry2::new(Vector2::new(400.0, 0.0), 0.))
.material(wall_group.clone());
let handle_box4 = ColliderDesc::new(rect4)
.position(Isometry2::new(Vector2::new(400.0, -600.0), 0.))
.material(wall_group.clone());
let shape = ShapeHandle::new(Ball::new(10.));
let collider = ColliderDesc::new(shape)
.position(Isometry2::new(Vector2::new(400.0, -300.0), 0.))
.name("ball".to_owned())
.material(wall_group.clone())
.density(0.001)
.user_data(10);
parent_handle2
.collider(&collider)
.build(&mut world);
parent_handle.collider(&handle_box)
.name("Walls".to_owned())
.gravity_enabled(false)
.collider(&handle_box2)
.collider(&handle_box23)
.collider(&handle_box4)
.build(&mut world);
let platform = RigidBodyDesc::new()
.gravity_enabled(false)
.name("Pl body".to_string());
let pl_shape = ShapeHandle::new(Cuboid::new(Vector2::new(20., 5.)));
let pl_collider = ColliderDesc::new(pl_shape)
.material(MaterialHandle::new(BasicMaterial::new(1.5, 0.4)))
.name("pl1".to_owned())
.density(10.)
.position(Isometry2::new(Vector2::new(415., -15.), 0.));
let mut body_p = platform.collider(&pl_collider).build(&mut world);
body_p.set_translations_kinematic(Vector2::new(false, true));
let ball = Circle::new((400., 300.), 10.);
/////
let scene = PlatformPlay {
view: rect_c,
ball,
world,
};
Ok(scene)
}
fn update(&mut self, _window: &mut Window) -> Result<()> {
let mut chandle = CollisionObjectHandle(1);
for collider in self.world.colliders() {
if collider.name() == "ball" {
self.ball.pos.x = collider.position().translation.vector.data[0];
self.ball.pos.y = -collider.position().translation.vector.data[1];
}
if collider.name() == "pl1" {
chandle = collider.handle();
}
}
let mut body_handle = None;
for b in self.world.bodies_with_name("Pl body") {
body_handle = Some(b.handle());
}
let body = &mut if let Some(handle) = body_handle {
Some(self.world.rigid_body_mut(handle).unwrap())
} else {
None
};
if _window.keyboard()[Key::Left].is_down() {
if let Some(b) = body {
b.set_velocity(Velocity2::linear(-120., zero()));
}
}
if _window.keyboard()[Key::Right].is_down() {
if let Some(b) = body {
b.set_velocity(Velocity2::linear(120., zero()));
}
}
let body = self.world.collider(chandle).unwrap();
let body_pos: &Isometry2<f32> = body.position();
self.view.pos.x = body_pos.translation.vector.data[0] - 20.;
// if _window.keyboard()[Key::Down].is_down() {
// self.world.set_gravity(Vector2::new(-1., -1.));
// }
// if _window.keyboard()[Key::Up].is_down() {
// self.world.set_gravity(Vector2::new(1., 1.));
// }
Ok(())
}
fn draw(&mut self, window: &mut Window) -> Result<()> {
window.clear(Color::WHITE)?;
self.world.step();
window.draw(&self.view, Col(Color::BLACK));
window.draw(&self.ball, Col(Color::BLUE));
window.draw(&Rectangle::new((0., 0.), (10., 600.)), Col(Color::BLACK));
window.draw(&Rectangle::new((790., 0.0), (10., 800.)), Col(Color::BLACK));
window.draw(&Rectangle::new((0.0, 0.0), (800., 10.)), Col(Color::BLACK));
window.draw(&Rectangle::new((0.0, 590.0), (800., 10.)), Col(Color::BLACK));
Ok(())
}
}
fn main() {
// use nphysics_testbed2d::Testbed;
// let geom: PlatformPlay = PlatformPlay::new().unwrap();
// let mut test = Testbed::new(geom.world);
// test.run();
run::<PlatformPlay>("Draw Geometry", Vector::new(800, 600),
Settings::default());
} |
use bevy::math::*;
#[derive(Debug, Default, Copy, Clone)]
pub struct Momentum {
pub thrust: f32,
pub max_rotation: f32,
pub inertia: Vec2,
}
#[derive(Debug, Default, Copy, Clone)]
pub struct Destination {
pub d: Vec3
}
impl EquationsOfMotion for Momentum {
fn max_rotation(&self) -> f32 {
self.max_rotation
}
fn inertia(&self) -> Vec2 {
self.inertia
}
fn thrust(&self) -> f32 {
self.thrust
}
}
pub trait EquationsOfMotion {
fn max_rotation(&self) -> f32;
fn inertia(&self) -> Vec2;
fn thrust(&self) -> f32;
fn distance(&self, a: &Vec3, b: &Vec3) -> f32 {
self.hypot(&[b[0] - a[0], b[1] - a[1], b[2] - a[2]])
}
fn hypot(&self, vector: &[f32]) -> f32 {
let mut y: f32 = 0_f32;
for i in 0..vector.len() {
y += vector[i].powi(2);
}
y.sqrt()
}
fn ticks_to_turn(&self, angle: f32) -> f32 {
angle.abs() / self.max_rotation()
}
fn ticks_to_stop(&self) -> f32 {
self.inertia().length().abs() / self.thrust()
}
fn ticks_to_turn_and_stop(&self, angle: f32) -> f32 {
self.ticks_to_turn(angle) + self.ticks_to_stop()
}
fn ticks_to_dest(&self, current: Vec3, dest: Vec3) -> f32 {
self.distance(¤t, &dest) / self.inertia().length().abs()
}
fn ticks_to_point_of_no_return(&self, current: Vec3, dest: Vec3) -> f32 {
let angle = current.angle_between(dest);
self.ticks_to_dest(current, dest) - self.ticks_to_turn_and_stop(angle)
}
fn intercept(&self, current: Vec3, target: Vec3, target_momentum: &Momentum) -> Vec2 {
let ticks_to_target = self.ticks_to_dest(current, target);
ticks_to_target * target_momentum.inertia
}
fn turn_to(&self, current: Vec3, dest: Vec3) -> (Vec3, f32) {
let angle = current.angle_between(dest);
// let max = self.max_rotation();
let cross = current.cross(dest).normalize();
// if angle.abs() < max {
(cross, angle)
// } else {
// (cross, max)
// }
}
}
pub trait QuatMath {
fn from_to_vec3(from: Vec3, to: Vec3) -> Quat;
fn default_to_vec3(to: Vec3) -> Quat;
}
impl QuatMath for Quat {
fn from_to_vec3(from: Vec3, to: Vec3) -> Quat {
let from_vec = from.normalize();
let to_vec = to.normalize();
let dot = from_vec.dot(to_vec);
if dot >= 1.0 {
return Quat::identity();
}
if dot < 1e-6_f32 - 1.0 {
let mut axis = Vec3::unit_x().cross(from);
if axis.length() == 0.0 {
axis = Vec3::unit_y().cross(from);
}
return Quat::from_axis_angle(axis.normalize(), std::f32::consts::PI);
}
let angle = dot.acos();
Quat::from_axis_angle(from_vec.cross(to_vec).normalize(), angle).normalize()
}
fn default_to_vec3(forward: Vec3) -> Quat {
Quat::from_to_vec3(Vec3::unit_y(), forward)
}
}
|
extern crate clap;
extern crate olc_pixel_game_engine;
extern crate rand;
use crate::olc_pixel_game_engine as olc;
// Screen constants
const SCREEN_WIDTH: i32 = 200;
const SCREEN_HEIGHT: i32 = 200;
const SCREEN_SCALE: i32 = 4;
// How long to wait between updates
const UPDATE_TIME: f32 = 1.0 / 15.0; // 15 FPS
// Key bindings
const KEY_STEP: olc::Key = olc::Key::S;
const KEY_STEP_TOGGLE: olc::Key = olc::Key::SPACE;
const KEY_RESET: olc::Key = olc::Key::R;
const KEY_EMPTY: olc::Key = olc::Key::E;
/* ##########################################
# The main application structure. #
# Handles events and drawing to the screen. #
########################################## */
struct Application {
game: GameOfLife,
update_counter: f32,
update_delta: f32,
step: bool, // Whether program should run automatically or be manually stepped
}
impl Application {
fn new(game: GameOfLife) -> Self {
Application {
game: game,
update_counter: 0.0,
update_delta: UPDATE_TIME,
step: false,
}
}
}
impl olc::Application for Application {
// Called on application creation and destruction respectively
fn on_user_create(&mut self) -> Result<(), olc::Error> { Ok(()) }
fn on_user_destroy(&mut self) -> Result<(), olc::Error> { Ok(()) }
// Called every frame
fn on_user_update(&mut self, elapsed_time: f32) -> Result<(), olc::Error> {
// Handle frame advance
if self.step {
// Advance frame on keypress
if olc::get_key(KEY_STEP).pressed {
self.game.update();
}
} else {
// Limit to defined updates per second
self.update_counter += elapsed_time;
if self.update_counter >= self.update_delta {
self.game.update();
self.update_counter = 0.0;
}
}
// Input handling
if olc::get_key(KEY_EMPTY).pressed {
// Reset with empty state
self.game.empty_state();
self.step = true;
} else if olc::get_key(KEY_RESET).pressed {
// Reset with random state
self.game.randomize_state();
} else if olc::get_key(KEY_STEP_TOGGLE).pressed {
// Toggle step mode
self.step = !self.step;
self.update_counter = 0.0;
}
// Click to toggle a cell
if olc::get_mouse(0).pressed {
let x = olc::get_mouse_x() as usize;
let y = olc::get_mouse_y() as usize;
self.game.state[x][y] = !self.game.state[x][y];
}
self.game.draw();
return Ok(());
}
}
/* ################################################
# Conway's Game of Life #
# Handles updating and drawing of the game state. #
################################################ */
struct GameOfLife {
state: Vec<Vec<bool>>,
state_width: usize,
state_height: usize,
live_threshold: u8,
die_threshold_lower: u8,
die_threshold_upper: u8,
}
impl GameOfLife {
// Create a new game structure with a given width and height
fn new(width: usize, height: usize) -> Self {
return GameOfLife {
state: vec![vec![false; height]; width],
state_width: width,
state_height: height,
live_threshold: 3,
die_threshold_lower: 2,
die_threshold_upper: 3,
};
}
// Update the game state
fn update(&mut self) {
let mut new_state = self.state.clone();
for y in 0..self.state_height {
for x in 0..self.state_width {
let neighbors = self.cell_get_neighbors(x as i32, y as i32);
if self.state[x][y]
&& (neighbors < self.die_threshold_lower
|| neighbors > self.die_threshold_upper) {
// Kill cell if above or below bounds
new_state[x][y] = false;
} else if !self.state[x][y] && neighbors == self.live_threshold {
// Create cell if neighbors are exactly at threshold
new_state[x][y] = true;
}
}
}
self.state = new_state;
}
// Draw the game state to the screen
fn draw(&self) {
olc::clear(olc::BLACK);
for y in 0..self.state_height {
for x in 0..self.state_width {
if self.state[x][y] {
olc::draw(x as i32, y as i32, olc::WHITE);
}
}
}
}
// Get the number of living neighbors of the specified cell
fn cell_get_neighbors(&self, x: i32, y: i32) -> u8 {
let mut total = 0;
for yofs in -1..=1 {
for xofs in -1..=1 {
let x2 = (x + xofs) as usize;
let y2 = (y + yofs) as usize;
if (0..self.state_width).contains(&x2) // x bounds check
&& (0..self.state_height).contains(&y2) // y bounds check
&& (xofs != 0 || yofs != 0) // Don't count center cell
&& self.state[x2][y2] {
total += 1;
}
}
}
return total;
}
// Reset to an empty state
fn empty_state(&mut self) {
self.state = vec![vec![false; self.state_height]; self.state_width];
}
// Set each bit of the state randomly
fn randomize_state(&mut self) {
self.state = vec![vec![false; self.state_height]; self.state_width];
for y in 0..self.state_height {
for x in 0..self.state_width {
// Randomly set each cell to true or false
self.state[x][y] = rand::random();
}
}
}
}
// Utility function to get a command line arg or return a default value
fn parse_arg<T: std::str::FromStr>(arg_matches: &clap::ArgMatches, arg: &str, default: T) -> T {
if let Some(string) = &arg_matches.value_of(arg) {
if let Ok(n) = string.parse::<T>() {
return n;
} else {
eprintln!("ERROR: Couldn't parse value for argument `{}`", arg);
std::process::exit(1);
}
} else {
return default;
}
}
fn main() {
// Handle command line args
let args = clap::App::new("RustLife")
.version("0.1.0")
.about("A Rust implementation of Conway's Game of Life")
.arg(clap::Arg::with_name("width")
.short("W")
.long("width")
.value_name("WIDTH")
.help("Sets the simulation space's width")
.takes_value(true))
.arg(clap::Arg::with_name("height")
.short("H")
.long("height")
.value_name("HEIGHT")
.help("Sets the simulation space's height")
.takes_value(true))
.arg(clap::Arg::with_name("scale")
.short("S")
.long("scale")
.value_name("SCALE")
.help("Sets the display scale, i.e. how many pixels each cell should take up on the \
screen")
.takes_value(true))
.arg(clap::Arg::with_name("start-paused")
.long("start-paused")
.help("Whether to start the simulation paused"))
.get_matches();
// Set screen parameters
let screen_width = parse_arg(&args, "width", SCREEN_WIDTH);
let screen_height = parse_arg(&args, "height", SCREEN_HEIGHT);
let screen_scale = parse_arg(&args, "scale", SCREEN_SCALE);
// Initialize the application
let mut game = GameOfLife::new(screen_width as usize, screen_height as usize);
game.randomize_state();
let mut application = Application::new(game);
// Start in step mode if specified on the command line
if args.is_present("start-paused") {
application.step = true;
}
// Start the application
olc::start_with_full_screen_and_vsync(
"RustLife",
&mut application,
screen_width,
screen_height,
screen_scale,
screen_scale,
false,
true
).unwrap();
}
|
use criterion::{
criterion_group, criterion_main, measurement::WallTime, BenchmarkGroup, BenchmarkId, Criterion,
};
use std::time::Duration;
use ray_tracing::RunConfig;
fn get_config() -> RunConfig<'static> {
let mut config = RunConfig::default();
config.quiet = true;
config.img_config.aspect_ratio = 3.0 / 2.0;
config.img_config.width = 150;
config.img_config.samples_per_pixel = 10;
config.img_config.max_depth = 10;
config.scene_config.small_sphere_count = 50;
config
}
fn set_up_group(group: &mut BenchmarkGroup<WallTime>) {
group.warm_up_time(Duration::from_secs(5)).sample_size(50);
}
pub fn samples_per_pixel(c: &mut Criterion) {
let mut config = get_config();
let mut group = c.benchmark_group("samples_per_pixel");
set_up_group(&mut group);
config.img_config.samples_per_pixel = 1;
group.bench_with_input(BenchmarkId::from_parameter(1), &config, |b, c| {
b.iter(|| ray_tracing::run(&c))
});
for i in (10..=100).step_by(20) {
config.img_config.samples_per_pixel = i;
group.bench_with_input(BenchmarkId::from_parameter(i), &config, |b, c| {
b.iter(|| ray_tracing::run(&c))
});
}
group.finish();
}
pub fn ray_depth(c: &mut Criterion) {
let mut config = get_config();
let mut group = c.benchmark_group("ray_depth");
set_up_group(&mut group);
config.img_config.max_depth = 1;
group.bench_with_input(BenchmarkId::from_parameter(1), &config, |b, c| {
b.iter(|| ray_tracing::run(&c))
});
for i in (5..=50).step_by(5) {
config.img_config.max_depth = i;
group.bench_with_input(BenchmarkId::from_parameter(i), &config, |b, c| {
b.iter(|| ray_tracing::run(&c))
});
}
group.finish();
}
pub fn img_width(c: &mut Criterion) {
let mut config = get_config();
config.img_config.samples_per_pixel = 10;
config.img_config.max_depth = 10;
let mut group = c.benchmark_group("img_width");
set_up_group(&mut group);
for i in (50..=500).step_by(50) {
config.img_config.width = i;
group.bench_with_input(BenchmarkId::from_parameter(i), &config, |b, c| {
b.iter(|| ray_tracing::run(&c))
});
}
group.finish();
}
pub fn sphere_count(c: &mut Criterion) {
let mut config = get_config();
config.img_config.samples_per_pixel = 10;
config.img_config.max_depth = 10;
let mut group = c.benchmark_group("sphere_count");
set_up_group(&mut group);
for i in (50..=400).step_by(50) {
config.scene_config.small_sphere_count = i;
group.bench_with_input(BenchmarkId::from_parameter(i), &config, |b, c| {
b.iter(|| ray_tracing::run(&c))
});
}
group.finish();
}
pub fn materials(c: &mut Criterion) {
let mut config = get_config();
let mut group = c.benchmark_group("materials");
set_up_group(&mut group);
for i in (0..=100).step_by(10) {
let leading_prob = i as f64 / 100.0;
let other_probs = (1.0 - leading_prob) / 2.0;
config.scene_config.diffuse_prob = leading_prob;
config.scene_config.metal_prob = other_probs;
group.bench_with_input(BenchmarkId::new("Diffuse", i), &config, |b, c| {
b.iter(|| ray_tracing::run(&c))
});
config.scene_config.metal_prob = leading_prob;
config.scene_config.diffuse_prob = other_probs;
group.bench_with_input(BenchmarkId::new("Metal", i), &config, |b, c| {
b.iter(|| ray_tracing::run(&c))
});
config.scene_config.diffuse_prob = other_probs;
config.scene_config.metal_prob = other_probs;
group.bench_with_input(BenchmarkId::new("Glass", i), &config, |b, c| {
b.iter(|| ray_tracing::run(&c))
});
}
group.finish();
}
pub fn bvh(c: &mut Criterion) {
let mut config = get_config();
config.img_config.samples_per_pixel = 10;
config.img_config.max_depth = 10;
let mut group = c.benchmark_group("bvh");
set_up_group(&mut group);
for i in (50..=500).step_by(50) {
config.scene_config.small_sphere_count = i;
config.use_bvh = true;
group.bench_with_input(BenchmarkId::new("bvh", i), &config, |b, c| {
b.iter(|| ray_tracing::run(&c))
});
config.use_bvh = false;
group.bench_with_input(BenchmarkId::new("plain", i), &config, |b, c| {
b.iter(|| ray_tracing::run(&c))
});
}
group.finish();
}
criterion_group!(
benches,
samples_per_pixel,
ray_depth,
img_width,
sphere_count,
materials,
bvh,
);
criterion_main!(benches);
|
use queen_shell::{cli, shell::StdShell};
use std::sync::Arc;
fn main() {
let shell = Arc::new(StdShell::new());
futures_lite::future::block_on(cli(shell)).unwrap();
}
|
use crate::commands::classified::block::run_block;
use crate::commands::WholeStreamCommand;
use crate::context::CommandRegistry;
use crate::prelude::*;
use futures::stream::once;
use nu_errors::ShellError;
use nu_protocol::{hir::Block, ReturnSuccess, Signature, SyntaxShape};
pub struct Each;
#[derive(Deserialize)]
pub struct EachArgs {
block: Block,
}
impl WholeStreamCommand for Each {
fn name(&self) -> &str {
"each"
}
fn signature(&self) -> Signature {
Signature::build("each").required(
"block",
SyntaxShape::Block,
"the block to run on each row",
)
}
fn usage(&self) -> &str {
"Run a block on each row of the table."
}
fn run(
&self,
args: CommandArgs,
registry: &CommandRegistry,
) -> Result<OutputStream, ShellError> {
Ok(args.process_raw(registry, each)?.run())
}
}
fn each(
each_args: EachArgs,
context: RunnableContext,
raw_args: RawCommandArgs,
) -> Result<OutputStream, ShellError> {
let block = each_args.block;
let scope = raw_args.call_info.scope.clone();
let registry = context.registry.clone();
let mut input_stream = context.input;
let stream = async_stream! {
while let Some(input) = input_stream.next().await {
let mut context = Context::from_raw(&raw_args, ®istry);
let input_clone = input.clone();
let input_stream = once(async { Ok(input) }).to_input_stream();
let result = run_block(
&block,
&mut context,
input_stream,
&scope.clone().set_it(input_clone),
).await;
match result {
Ok(mut stream) => {
let errors = context.get_errors();
if let Some(error) = errors.first() {
yield Err(error.clone());
}
while let Some(result) = stream.next().await {
yield Ok(ReturnSuccess::Value(result));
}
}
Err(e) => {
yield Err(e);
}
}
}
};
Ok(stream.to_output_stream())
}
|
use std::thread;
use std::time::Duration;
use crate::erlang::system_time_0::result;
use crate::test::with_process;
#[test]
fn increases_after_2_native_time_units() {
with_process(|process| {
let first = result(process);
thread::sleep(Duration::from_millis(2));
let second = result(process);
assert!(first < second);
});
}
|
extern crate rand;
use std::ops::BitXor;
use std::ops::Rem;
use rand::Rng;
use go::VIRT_LEN;
use go::VIRT_SIZE;
use go::GoGame;
use go::Vertex;
use go::Stone;
use go::stone;
#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
pub struct PosHash(u64);
impl BitXor for PosHash {
type Output = PosHash;
fn bitxor(self, rhs: PosHash) -> PosHash {
PosHash(self.0 ^ rhs.0)
}
}
impl PosHash {
pub const None: PosHash = PosHash(0);
pub fn new(h: u64) -> PosHash {
PosHash(h)
}
pub fn as_index(self) -> usize {
self.0 as usize
}
}
pub struct BoardHasher {
// Zobrist hashing for tracking super-ko and debugging normal ko checking.
vertex_hashes: Vec<PosHash>,
}
impl BoardHasher {
pub fn new() -> BoardHasher {
let mut rng = rand::thread_rng();
let mut vertex_hashes = vec![PosHash(0); 3 * VIRT_LEN];
let size = VIRT_SIZE as usize;
for col in 0 .. size {
for row in 0 .. size {
vertex_hashes[0 * VIRT_LEN + col + row * size] = PosHash(rng.gen()); // EMPTY
vertex_hashes[1 * VIRT_LEN + col + row * size] = PosHash(rng.gen()); // BLACK
vertex_hashes[2 * VIRT_LEN + col + row * size] = PosHash(rng.gen()); // WHITE
}
}
return BoardHasher{
vertex_hashes: vertex_hashes,
};
}
pub fn hash(&self, game: &GoGame) -> PosHash {
let mut hash = PosHash(0);
for col in 0 .. game.size {
for row in 0 .. game.size {
let v = Vertex::new(row as i16, col as i16);
hash = hash ^ self.hash_for(v, game.stone_at(v));
}
}
return hash;
}
// Calculates zobrist hash for a vertex. Used for super-ko detection.
fn hash_for(&self, vertex: Vertex, stone: Stone) -> PosHash {
let offset = match stone {
stone::EMPTY => 0,
stone::BLACK => 1,
stone::WHITE => 2,
stone::BORDER => 3,
_ => panic!("unknown stone"),
};
return self.vertex_hashes[offset * VIRT_LEN + vertex.as_index()];
}
}
|
use itertools::Itertools;
fn main() {
for len in &[2, 3] {
let winner = std::fs::read_to_string("input")
.unwrap()
.trim()
.lines()
.map(|s| s.parse::<usize>().unwrap())
.combinations(*len)
.find(|comb| comb.iter().sum::<usize>() == 2020)
.unwrap();
dbg!(winner.iter().product::<usize>());
}
}
|
use std::fmt::Debug;
use crate::context::Context;
use crate::event::Event;
use crate::util::Id;
pub mod manager;
pub mod network;
pub trait Layer: Debug + Send + Sync {
fn get_id(&self) -> Id;
fn on_add(&mut self, context: &Context);
fn on_remove(&mut self, context: &Context);
fn filter_gather_events(&mut self, context: &Context, incoming_events: Vec<Box<dyn Event>>) -> Vec<Box<dyn Event>>;
}
pub trait AsLayer {
fn as_boxed_layer(self: Box<Self>) -> Box<dyn Layer>;
}
// XXX Consider a solution like the event derive stuff
#[typetag::serde(tag = "layer")]
pub trait NetworkLayer: AsLayer + Layer {
fn boxed_clone(&self) -> Box<dyn NetworkLayer>;
}
impl Clone for Box<dyn NetworkLayer> {
fn clone(&self) -> Self {
self.boxed_clone()
}
}
impl<T: 'static + NetworkLayer> AsLayer for T {
fn as_boxed_layer(self: Box<Self>) -> Box<dyn Layer> {
self
}
}
impl From<Box<dyn NetworkLayer>> for Box<dyn Layer> {
fn from(network_layer: Box<dyn NetworkLayer>) -> Self {
network_layer.as_boxed_layer()
}
} |
#[macro_use]
extern crate criterion;
use criterion::Criterion;
use std::time::Duration;
fn c() -> Criterion {
Criterion::default()
.sample_size(10) // must be >= 10 for Criterion v0.3
.warm_up_time(Duration::from_secs(1))
.with_plots()
}
fn git_hash() -> String {
use std::process::Command;
let output = Command::new("git")
.args(&["rev-parse", "--short", "HEAD"])
.output()
.unwrap();
String::from(String::from_utf8(output.stdout).unwrap().trim())
}
mod succinct_bit_vector {
use criterion::{BatchSize, Criterion};
use succinct_rs::{BitString, SuccinctBitVectorBuilder};
const NS: [u64; 5] = [1 << 16, 1 << 17, 1 << 18, 1 << 19, 1 << 20];
pub fn builder_from_length_benchmark(_: &mut Criterion) {
super::c().bench_function_over_inputs(
&format!(
"[{}] SuccinctBitVectorBuilder::from_length(N).build()",
super::git_hash()
),
|b, &&n| b.iter(|| SuccinctBitVectorBuilder::from_length(n).build()),
&NS,
);
}
pub fn builder_from_bit_string_benchmark(_: &mut Criterion) {
super::c().bench_function_over_inputs(
&format!(
"[{}] SuccinctBitVectorBuilder::from_bit_string(\"00...(repeated N-times)\").build()",
super::git_hash()
),
|b, &&n| {
b.iter_batched(
|| {
let s = String::from_utf8(vec!['0' as u8; n as usize]).unwrap();
BitString::new(&s)
},
|bs| SuccinctBitVectorBuilder::from_bit_string(bs).build(),
BatchSize::SmallInput,
)
},
&NS,
);
}
pub fn rank_benchmark(_: &mut Criterion) {
let times = 1_000_000;
super::c().bench_function_over_inputs(
&format!(
"[{}] SuccinctBitVector::rank(N) {} times",
super::git_hash(),
times
),
move |b, &&n| {
b.iter_batched(
|| SuccinctBitVectorBuilder::from_length(n).build(),
|bv| {
// iter_batched() does not properly time `routine` time when `setup` time is far longer than `routine` time.
// Tested function takes too short compared to build(). So loop many times.
for _ in 0..times {
assert_eq!(bv.rank(n - 1), 0);
}
},
BatchSize::SmallInput,
)
},
&NS,
);
}
pub fn select_benchmark(_: &mut Criterion) {
let times = 1_000;
super::c().bench_function_over_inputs(
&format!(
"[{}] SuccinctBitVector::select(N) {} times",
super::git_hash(),
times
),
move |b, &&n| {
b.iter_batched(
|| {
let mut builder = SuccinctBitVectorBuilder::from_length(n);
for i in 0..n {
builder.set_bit(i);
}
builder.build()
},
|bv| {
// iter_batched() does not properly time `routine` time when `setup` time is far longer than `routine` time.
// Tested function takes too short compared to build(). So loop many times.
for _ in 0..times {
assert_eq!(bv.select(n - 1), Some(n - 2));
}
},
BatchSize::SmallInput,
)
},
&NS,
);
}
pub fn rank0_benchmark(_: &mut Criterion) {
let times = 1_000_000;
super::c().bench_function_over_inputs(
&format!(
"[{}] SuccinctBitVector::rank0(N) {} times",
super::git_hash(),
times
),
move |b, &&n| {
b.iter_batched(
|| SuccinctBitVectorBuilder::from_length(n).build(),
|bv| {
// iter_batched() does not properly time `routine` time when `setup` time is far longer than `routine` time.
// Tested function takes too short compared to build(). So loop many times.
for _ in 0..times {
assert_eq!(bv.rank0(n - 1), n);
}
},
BatchSize::SmallInput,
)
},
&NS,
);
}
pub fn select0_benchmark(_: &mut Criterion) {
let times = 1_000;
super::c().bench_function_over_inputs(
&format!(
"[{}] SuccinctBitVector::select0(N) {} times",
super::git_hash(),
times
),
move |b, &&n| {
b.iter_batched(
|| SuccinctBitVectorBuilder::from_length(n).build(),
|bv| {
// iter_batched() does not properly time `routine` time when `setup` time is far longer than `routine` time.
// Tested function takes too short compared to build(). So loop many times.
for _ in 0..times {
assert_eq!(bv.select0(n - 1), Some(n - 2));
}
},
BatchSize::SmallInput,
)
},
&NS,
);
}
}
mod louds {
use criterion::{BatchSize, Criterion};
use succinct_rs::{BitString, LoudsBuilder, LoudsIndex, LoudsNodeNum};
const NS: [u64; 5] = [1 << 11, 1 << 12, 1 << 13, 1 << 14, 1 << 15];
fn generate_binary_tree_lbs(n_nodes: u64) -> BitString {
assert!(
NS.iter().any(|n| n - 1 == n_nodes),
"Only 2^m - 1 nodes (complete binary tree) is supported"
);
let mut s = String::from("10");
// Nodes
for _ in 1..=(n_nodes / 2) {
s = format!("{}{}", s, "110");
}
// Leaves
for _ in (n_nodes / 2 + 1)..=(n_nodes) {
s = format!("{}{}", s, "0");
}
BitString::new(&s)
}
pub fn builder_from_bit_string_benchmark(_: &mut Criterion) {
let times = 10;
super::c().bench_function_over_inputs(
&format!(
"[{}] LoudsBuilder::from_bit_string(\"...(bin tree of N nodes)\").build() {} times",
super::git_hash(),
times,
),
move |b, &&n| {
b.iter_batched(
|| {
let bs = generate_binary_tree_lbs(n - 1);
LoudsBuilder::from_bit_string(bs)
},
|builder| {
for _ in 0..times {
builder.build();
}
},
BatchSize::SmallInput,
)
},
&NS,
);
}
pub fn node_num_to_index_benchmark(_: &mut Criterion) {
let times = 10_000;
super::c().bench_function_over_inputs(
&format!(
"[{}] Louds(N)::node_num_to_index() {} times",
super::git_hash(),
times,
),
move |b, &&n| {
b.iter_batched(
|| {
let bs = generate_binary_tree_lbs(n - 1);
LoudsBuilder::from_bit_string(bs).build()
},
|louds| {
// iter_batched() does not properly time `routine` time when `setup` time is far longer than `routine` time.
// Tested function takes too short compared to build(). So loop many times.
for _ in 0..times {
let _ = louds.node_num_to_index(&LoudsNodeNum::new(n - 1));
}
},
BatchSize::SmallInput,
)
},
&NS,
);
}
pub fn index_to_node_num_benchmark(_: &mut Criterion) {
let times = 10_000;
super::c().bench_function_over_inputs(
&format!(
"[{}] Louds(N)::index_to_node_num() {} times",
super::git_hash(),
times,
),
move |b, &&n| {
b.iter_batched(
|| {
let bs = generate_binary_tree_lbs(n - 1);
LoudsBuilder::from_bit_string(bs).build()
},
|louds| {
// iter_batched() does not properly time `routine` time when `setup` time is far longer than `routine` time.
// Tested function takes too short compared to build(). So loop many times.
for _ in 0..times {
let _ = louds.index_to_node_num(&LoudsIndex::new(n / 2 + 1));
}
},
BatchSize::SmallInput,
)
},
&NS,
);
}
pub fn parent_to_children_benchmark(_: &mut Criterion) {
let times = 10_000;
super::c().bench_function_over_inputs(
&format!(
"[{}] Louds(N)::parent_to_children() {} times",
super::git_hash(),
times,
),
move |b, &&n| {
b.iter_batched(
|| {
let bs = generate_binary_tree_lbs(n - 1);
LoudsBuilder::from_bit_string(bs).build()
},
|louds| {
// iter_batched() does not properly time `routine` time when `setup` time is far longer than `routine` time.
// Tested function takes too short compared to build(). So loop many times.
for _ in 0..times {
let _ = louds.parent_to_children(&LoudsNodeNum::new(n - 1));
}
},
BatchSize::SmallInput,
)
},
&NS,
);
}
pub fn child_to_parent_benchmark(_: &mut Criterion) {
let times = 10_000;
super::c().bench_function_over_inputs(
&format!(
"[{}] Louds(N)::child_to_parent() {} times",
super::git_hash(),
times,
),
move |b, &&n| {
b.iter_batched(
|| {
let bs = generate_binary_tree_lbs(n - 1);
LoudsBuilder::from_bit_string(bs).build()
},
|louds| {
// iter_batched() does not properly time `routine` time when `setup` time is far longer than `routine` time.
// Tested function takes too short compared to build(). So loop many times.
for _ in 0..times {
let _ = louds.child_to_parent(&LoudsIndex::new(n / 2 + 1));
}
},
BatchSize::SmallInput,
)
},
&NS,
);
}
}
criterion_group!(
benches,
succinct_bit_vector::builder_from_length_benchmark,
succinct_bit_vector::builder_from_bit_string_benchmark,
succinct_bit_vector::rank_benchmark,
succinct_bit_vector::select_benchmark,
succinct_bit_vector::rank0_benchmark,
succinct_bit_vector::select0_benchmark,
louds::builder_from_bit_string_benchmark,
louds::node_num_to_index_benchmark,
louds::index_to_node_num_benchmark,
louds::parent_to_children_benchmark,
louds::child_to_parent_benchmark,
);
criterion_main!(benches);
|
#![cfg_attr(not(feature = "std"), no_std)]
pub mod arkworks;
pub use arkworks::*;
|
use game_lib::bevy::prelude::*;
#[derive(Debug, Reflect)]
pub struct CameraState {
pub main_camera: Entity,
pub ui_camera: Entity,
}
|
mod accessibility_tests;
mod audio_tests;
mod device_tests;
mod display_tests;
mod do_not_disturb_tests;
mod fakes;
mod input_tests;
mod intl_tests;
mod light_sensor_tests;
mod privacy_tests;
mod setui_tests;
mod setup_tests;
mod system_tests;
|
pub const VERTEX_SHADER_SRC: &str = r#"
#version 140
uniform mat4 view_matrix;
in vec2 position;
void main() {
gl_Position = view_matrix * vec4(position, 0.0, 1.0);
}
"#;
pub const FRAGMENT_SHADER_SRC: &str = r#"
#version 140
uniform mat4 view_matrix;
out vec4 color;
void main() {
// have color change with position!
color = view_matrix * vec4(1.0, 0.0, 0.0, 1.0);
}
"#;
|
use cryptanalysis::freq_analysis;
use encoding::hex;
use std::fs;
fn main() {
println!("🔓 Challenge 4");
let ct_hex = fs::read_to_string("challenges/data/chal4.txt").unwrap();
for line in ct_hex.lines() {
let pt = freq_analysis::break_single_byte_xor(&hex::hexstr_to_bytes(&line).unwrap());
if !pt.is_empty() && pt.chars().all(|c| c.is_alphanumeric() || c.is_whitespace()) {
println!("Decrypted line: {}", pt);
}
}
}
|
use super::{HdbResponse, PreparedStatement, ResultSet};
use crate::conn::AmConnCore;
use crate::protocol::parts::{
ClientContext, ClientContextId, CommandInfo, ConnOptId, OptionValue, ServerError,
};
use crate::protocol::{Part, Request, RequestType, ServerUsage, HOLD_CURSORS_OVER_COMMIT};
#[cfg(feature = "dist_tx")]
use crate::xa_impl::sync_new_resource_manager;
use crate::{HdbError, HdbResult, IntoConnectParams};
#[cfg(feature = "dist_tx")]
use dist_tx::sync::rm::ResourceManager;
/// A synchronous connection to the database.
#[derive(Clone, Debug)]
pub struct Connection {
am_conn_core: AmConnCore,
}
impl Connection {
/// Factory method for authenticated connections.
///
/// # Example
///
/// ```rust,no_run
/// use hdbconnect::Connection;
/// let conn = Connection::new("hdbsql://my_user:my_passwd@the_host:2222").unwrap();
/// ```
///
/// # Errors
///
/// Several variants of `HdbError` can occur.
pub fn new<P: IntoConnectParams>(p: P) -> HdbResult<Self> {
Ok(Self {
am_conn_core: AmConnCore::try_new_sync(p.into_connect_params()?)?,
})
}
/// Executes a statement on the database.
///
/// This generic method can handle all kinds of calls,
/// and thus has the most generic return type.
/// In many cases it will be more convenient to use
/// one of the dedicated methods `query()`, `dml()`, `exec()` below, which
/// internally convert the `HdbResponse` to the
/// respective adequate simple result type.
///
/// # Example
///
/// ```rust,no_run
/// # use hdbconnect::{Connection, HdbResponse, HdbResult, IntoConnectParams};
/// # fn main() -> HdbResult<()> {
/// # let params = "hdbsql://my_user:my_passwd@the_host:2222"
/// # .into_connect_params()
/// # .unwrap();
/// # let connection = Connection::new(params).unwrap();
/// # let statement_string = "";
/// let mut response = connection.statement(&statement_string)?; // HdbResponse
/// # Ok(())
/// # }
/// ```
///
/// # Errors
///
/// Several variants of `HdbError` can occur.
pub fn statement<S: AsRef<str>>(&self, stmt: S) -> HdbResult<HdbResponse> {
self.execute(stmt.as_ref(), None)
}
/// Executes a statement and expects a single `ResultSet`.
///
/// Should be used for query statements (like "SELECT ...") which return a single resultset.
///
/// # Example
///
/// ```rust,no_run
/// # use hdbconnect::{Connection, HdbResult, IntoConnectParams, ResultSet};
/// # fn main() -> HdbResult<()> {
/// # let params = "hdbsql://my_user:my_passwd@the_host:2222"
/// # .into_connect_params()
/// # .unwrap();
/// # let connection = Connection::new(params).unwrap();
/// # let statement_string = "";
/// let mut rs = connection.query(&statement_string)?; // ResultSet
/// # Ok(())
/// # }
/// ```
///
/// # Errors
///
/// Several variants of `HdbError` can occur.
pub fn query<S: AsRef<str>>(&self, stmt: S) -> HdbResult<ResultSet> {
self.statement(stmt)?.into_resultset()
}
/// Executes a statement and expects a single number of affected rows.
///
/// Should be used for DML statements only, i.e., INSERT, UPDATE, DELETE, UPSERT.
///
/// # Example
///
/// ```rust,no_run
/// # use hdbconnect::{Connection, HdbResult, IntoConnectParams, ResultSet};
/// # fn main() -> HdbResult<()> {
/// # let params = "hdbsql://my_user:my_passwd@the_host:2222"
/// # .into_connect_params()
/// # .unwrap();
/// # let connection = Connection::new(params).unwrap();
/// # let statement_string = "";
/// let count = connection.dml(&statement_string)?; //usize
/// # Ok(())
/// # }
/// ```
///
/// # Errors
///
/// Several variants of `HdbError` can occur.
pub fn dml<S: AsRef<str>>(&self, stmt: S) -> HdbResult<usize> {
let vec = &(self.statement(stmt)?.into_affected_rows()?);
match vec.len() {
1 => Ok(vec[0]),
_ => Err(HdbError::Usage("number of affected-rows-counts <> 1")),
}
}
/// Executes a statement and expects a plain success.
///
/// Should be used for SQL commands like "ALTER SYSTEM ...".
///
/// # Example
///
/// ```rust,no_run
/// # use hdbconnect::{Connection, HdbResult, IntoConnectParams, ResultSet};
/// # fn main() -> HdbResult<()> {
/// # let params = "hdbsql://my_user:my_passwd@the_host:2222"
/// # .into_connect_params()
/// # .unwrap();
/// # let connection = Connection::new(params).unwrap();
/// # let statement_string = "";
/// connection.exec(&statement_string)?;
/// # Ok(())
/// # }
/// ```
///
/// # Errors
///
/// Several variants of `HdbError` can occur.
pub fn exec<S: AsRef<str>>(&self, stmt: S) -> HdbResult<()> {
self.statement(stmt)?.into_success()
}
/// Prepares a statement and returns a handle (a `PreparedStatement`) to it.
///
/// Note that the `PreparedStatement` keeps using the same database connection as
/// this `Connection`.
///
/// # Example
///
/// ```rust,no_run
/// # use hdbconnect::{Connection, HdbResult, IntoConnectParams};
/// # fn main() -> HdbResult<()> {
/// # let params = "hdbsql://my_user:my_passwd@the_host:2222"
/// # .into_connect_params()
/// # .unwrap();
/// # let connection = Connection::new(params).unwrap();
/// let query_string = "select * from phrases where ID = ? and text = ?";
/// let statement = connection.prepare(query_string)?; //PreparedStatement
/// # Ok(())
/// # }
/// ```
///
/// # Errors
///
/// Several variants of `HdbError` can occur.
pub fn prepare<S: AsRef<str>>(&self, stmt: S) -> HdbResult<PreparedStatement> {
PreparedStatement::try_new(self.am_conn_core.clone(), stmt.as_ref())
}
/// Prepares a statement and executes it a single time.
///
/// # Errors
///
/// Several variants of `HdbError` can occur.
pub fn prepare_and_execute<S, T>(&self, stmt: S, input: &T) -> HdbResult<HdbResponse>
where
S: AsRef<str>,
T: serde::ser::Serialize,
{
let mut stmt = PreparedStatement::try_new(self.am_conn_core.clone(), stmt.as_ref())?;
stmt.execute(input)
}
/// Commits the current transaction.
///
/// # Errors
///
/// Several variants of `HdbError` can occur.
pub fn commit(&self) -> HdbResult<()> {
self.statement("commit")?.into_success()
}
/// Rolls back the current transaction.
///
/// # Errors
///
/// Several variants of `HdbError` can occur.
pub fn rollback(&self) -> HdbResult<()> {
self.statement("rollback")?.into_success()
}
/// Creates a new connection object with the same settings and
/// authentication.
///
/// # Errors
///
/// Several variants of `HdbError` can occur.
pub fn spawn(&self) -> HdbResult<Self> {
let am_conn_core = self.am_conn_core.sync_lock()?;
let other = Self::new(am_conn_core.connect_params())?;
other.set_auto_commit(am_conn_core.is_auto_commit())?;
other.set_fetch_size(am_conn_core.get_fetch_size())?;
other.set_lob_read_length(am_conn_core.lob_read_length())?;
Ok(other)
}
/// Utility method to fire a couple of statements, ignoring errors and
/// return values.
///
/// # Errors
///
/// Several variants of `HdbError` can occur.
pub fn multiple_statements_ignore_err<S: AsRef<str>>(&self, stmts: Vec<S>) {
for s in stmts {
trace!("multiple_statements_ignore_err: firing \"{}\"", s.as_ref());
let result = self.statement(s);
match result {
Ok(_) => {}
Err(e) => debug!("Error intentionally ignored: {:?}", e),
}
}
}
/// Utility method to fire a couple of statements, ignoring their return
/// values; the method returns with the first error, or with `()`.
///
/// # Errors
///
/// Several variants of `HdbError` can occur.
pub fn multiple_statements<S: AsRef<str>>(&self, stmts: Vec<S>) -> HdbResult<()> {
for s in stmts {
self.statement(s)?;
}
Ok(())
}
/// Returns warnings that were returned from the server since the last call
/// to this method.
///
/// # Errors
///
/// Only `HdbError::Poison` can occur.
pub fn pop_warnings(&self) -> HdbResult<Option<Vec<ServerError>>> {
Ok(self.am_conn_core.sync_lock()?.pop_warnings())
}
/// Sets the connection's auto-commit behavior for future calls.
///
/// # Errors
///
/// Only `HdbError::Poison` can occur.
pub fn set_auto_commit(&self, ac: bool) -> HdbResult<()> {
self.am_conn_core.sync_lock()?.set_auto_commit(ac);
Ok(())
}
/// Returns the connection's auto-commit behavior.
///
/// # Errors
///
/// Only `HdbError::POóison` can occur.
pub fn is_auto_commit(&self) -> HdbResult<bool> {
Ok(self.am_conn_core.sync_lock()?.is_auto_commit())
}
/// Configures the connection's fetch size for future calls.
///
/// # Errors
///
/// Only `HdbError::Poison` can occur.
pub fn set_fetch_size(&self, fetch_size: u32) -> HdbResult<()> {
self.am_conn_core.sync_lock()?.set_fetch_size(fetch_size);
Ok(())
}
/// Returns the connection's lob read length.
///
/// # Errors
///
/// Only `HdbError::Poison` can occur.
pub fn lob_read_length(&self) -> HdbResult<u32> {
Ok(self.am_conn_core.sync_lock()?.lob_read_length())
}
/// Configures the connection's lob read length for future calls.
///
/// # Errors
///
/// Only `HdbError::Poison` can occur.
pub fn set_lob_read_length(&self, l: u32) -> HdbResult<()> {
self.am_conn_core.sync_lock()?.set_lob_read_length(l);
Ok(())
}
/// Configures the connection's lob write length for future calls.
///
/// The intention of the parameter is to allow reducing the number of roundtrips
/// to the database.
/// Values smaller than rust's buffer size (8k) will have little effect, since
/// each read() call to the Read impl in a `HdbValue::LOBSTREAM` will cause at most one
/// write roundtrip to the database.
///
/// # Errors
///
/// Only `HdbError::Poison` can occur.
pub fn get_lob_write_length(&self) -> HdbResult<usize> {
Ok(self.am_conn_core.sync_lock()?.get_lob_write_length())
}
/// Configures the connection's lob write length for future calls.
///
/// # Errors
///
/// Only `HdbError::Poison` can occur.
pub fn set_lob_write_length(&self, l: usize) -> HdbResult<()> {
self.am_conn_core.sync_lock()?.set_lob_write_length(l);
Ok(())
}
/// Returns the ID of the connection.
///
/// The ID is set by the server. Can be handy for logging.
///
/// # Errors
///
/// Only `HdbError::Poison` can occur.
pub fn id(&self) -> HdbResult<i32> {
self.am_conn_core
.sync_lock()?
.connect_options()
.get_connection_id()
}
/// Provides information about the the server-side resource consumption that
/// is related to this Connection object.
///
/// # Errors
///
/// Only `HdbError::Poison` can occur.
pub fn server_usage(&self) -> HdbResult<ServerUsage> {
Ok(self.am_conn_core.sync_lock()?.server_usage())
}
#[doc(hidden)]
pub fn data_format_version_2(&self) -> HdbResult<i32> {
self.am_conn_core
.sync_lock()?
.connect_options()
.get_dataformat_version2()
}
#[doc(hidden)]
pub fn dump_connect_options(&self) -> HdbResult<String> {
Ok(self.am_conn_core.sync_lock()?.dump_connect_options())
}
#[doc(hidden)]
pub fn dump_client_info(&self) -> HdbResult<String> {
Ok(self.am_conn_core.sync_lock()?.dump_client_info())
}
/// Returns the number of roundtrips to the database that
/// have been done through this connection.
///
/// # Errors
///
/// Only `HdbError::Poison` can occur.
pub fn get_call_count(&self) -> HdbResult<i32> {
Ok(self.am_conn_core.sync_lock()?.last_seq_number())
}
/// Sets client information into a session variable on the server.
///
/// Example:
///
/// ```rust,no_run
/// # use hdbconnect::{Connection,HdbResult};
/// # fn foo() -> HdbResult<()> {
/// # let connection = Connection::new("hdbsql://my_user:my_passwd@the_host:2222")?;
/// connection.set_application("MyApp, built in rust")?;
/// # Ok(()) }
/// ```
///
/// # Errors
///
/// Only `HdbError::Poison` can occur.
pub fn set_application<S: AsRef<str>>(&self, application: S) -> HdbResult<()> {
self.am_conn_core.sync_lock()?.set_application(application);
Ok(())
}
/// Sets client information into a session variable on the server.
///
/// Example:
///
/// ```rust,no_run
/// # use hdbconnect::{Connection,HdbResult};
/// # fn foo() -> HdbResult<()> {
/// # let connection = Connection::new("hdbsql://my_user:my_passwd@the_host:2222")?;
/// connection.set_application_user("K2209657")?;
/// # Ok(()) }
/// ```
///
/// # Errors
///
/// Only `HdbError::Poison` can occur.
pub fn set_application_user<S: AsRef<str>>(&self, appl_user: S) -> HdbResult<()> {
self.am_conn_core
.sync_lock()?
.set_application_user(appl_user.as_ref());
Ok(())
}
/// Sets client information into a session variable on the server.
///
/// Example:
///
/// ```rust,no_run
/// # use hdbconnect::{Connection,HdbResult};
/// # fn foo() -> HdbResult<()> {
/// # let connection = Connection::new("hdbsql://my_user:my_passwd@the_host:2222")?;
/// connection.set_application_version("5.3.23")?;
/// # Ok(()) }
/// ```
///
/// # Errors
///
/// Only `HdbError::Poison` can occur.
pub fn set_application_version<S: AsRef<str>>(&self, version: S) -> HdbResult<()> {
self.am_conn_core
.sync_lock()?
.set_application_version(version.as_ref());
Ok(())
}
/// Sets client information into a session variable on the server.
///
/// Example:
///
/// ```rust,no_run
/// # use hdbconnect::{Connection,HdbResult};
/// # fn foo() -> HdbResult<()> {
/// # let connection = Connection::new("hdbsql://my_user:my_passwd@the_host:2222")?;
/// connection.set_application_source("update_customer.rs")?;
/// # Ok(()) }
/// ```
///
/// # Errors
///
/// Only `HdbError::Poison` can occur.
pub fn set_application_source<S: AsRef<str>>(&self, source: S) -> HdbResult<()> {
self.am_conn_core
.sync_lock()?
.set_application_source(source.as_ref());
Ok(())
}
/// Returns an implementation of `dist_tx::rm::ResourceManager` that is
/// based on this connection.
#[cfg(feature = "dist_tx")]
#[must_use]
pub fn get_resource_manager(&self) -> Box<dyn ResourceManager> {
Box::new(sync_new_resource_manager(self.am_conn_core.clone()))
}
/// Tools like debuggers can provide additional information while stepping through a source.
///
/// # Errors
///
/// Several variants of `HdbError` can occur.
pub fn execute_with_debuginfo<S: AsRef<str>>(
&self,
stmt: S,
module: S,
line: i32,
) -> HdbResult<HdbResponse> {
self.execute(stmt, Some(CommandInfo::new(line, module.as_ref())))
}
/// (MDC) Database name.
///
/// # Errors
///
/// Errors are unlikely to occur.
///
/// - `HdbError::ImplDetailed` if the database name was not provided by the database server.
/// - `HdbError::Poison` if the shared mutex of the inner connection object is poisened.
pub fn get_database_name(&self) -> HdbResult<String> {
self.am_conn_core
.sync_lock()?
.connect_options()
.get_database_name()
.map(ToOwned::to_owned)
}
/// The system id is set by the server with the SAPSYSTEMNAME of the
/// connected instance (for tracing and supportability purposes).
///
/// # Errors
///
/// Errors are unlikely to occur.
///
/// - `HdbError::ImplDetailed` if the system id was not provided by the database server.
/// - `HdbError::Poison` if the shared mutex of the inner connection object is poisened.
pub fn get_system_id(&self) -> HdbResult<String> {
self.am_conn_core
.sync_lock()?
.connect_options()
.get_system_id()
.map(ToOwned::to_owned)
}
/// Returns the information that is given to the server as client context.
/// # Errors
///
/// Only `HdbError::Poison` can occur.
pub fn client_info(&self) -> HdbResult<Vec<(String, String)>> {
let mut result = Vec::<(String, String)>::with_capacity(7);
let mut cc = ClientContext::new();
for k in &[
ClientContextId::ClientType,
ClientContextId::ClientVersion,
ClientContextId::ClientApplicationProgramm,
] {
if let Some((k, OptionValue::STRING(s))) = cc.remove_entry(k) {
result.push((k.to_string(), s));
}
}
let conn_core = self.am_conn_core.sync_lock()?;
let conn_opts = conn_core.connect_options();
if let Ok(OptionValue::STRING(s)) = conn_opts.get(&ConnOptId::OSUser) {
result.push((format!("{:?}", ConnOptId::OSUser), s.clone()));
}
if let Ok(OptionValue::INT(i)) = conn_opts.get(&ConnOptId::ConnectionID) {
result.push((format!("{:?}", ConnOptId::ConnectionID), i.to_string()));
}
Ok(result)
}
/// Returns a connect url (excluding the password) that reflects the options that were
/// used to establish this connection.
///
/// # Errors
///
/// Only `HdbError::Poison` can occur.
pub fn connect_string(&self) -> HdbResult<String> {
Ok(self.am_conn_core.sync_lock()?.connect_string())
}
/// HANA Full version string.
///
/// # Errors
///
/// Errors are unlikely to occur.
///
/// - `HdbError::ImplDetailed` if the version string was not provided by the database server.
/// - `HdbError::Poison` if the shared mutex of the inner connection object is poisened.
pub fn get_full_version_string(&self) -> HdbResult<String> {
self.am_conn_core
.sync_lock()?
.connect_options()
.get_full_version_string()
.map(ToOwned::to_owned)
}
fn execute<S>(&self, stmt: S, o_command_info: Option<CommandInfo>) -> HdbResult<HdbResponse>
where
S: AsRef<str>,
{
debug!(
"connection[{:?}]::execute()",
self.am_conn_core
.sync_lock()?
.connect_options()
.get_connection_id()
);
let mut request = Request::new(RequestType::ExecuteDirect, HOLD_CURSORS_OVER_COMMIT);
{
let conn_core = self.am_conn_core.sync_lock()?;
let fetch_size = conn_core.get_fetch_size();
request.push(Part::FetchSize(fetch_size));
if let Some(command_info) = o_command_info {
request.push(Part::CommandInfo(command_info));
}
request.push(Part::Command(stmt.as_ref()));
}
let (internal_return_values, replytype) = self
.am_conn_core
.sync_send(request)?
.sync_into_internal_return_values(&self.am_conn_core, None)?;
HdbResponse::try_new(internal_return_values, replytype)
}
}
|
mod aabb;
mod aarect;
mod bvh;
#[allow(clippy::float_cmp)]
mod camera;
mod color;
mod hittable;
mod hittablelist;
mod material;
mod ray;
mod rtweekend;
mod texture;
mod vec3;
use aarect::XYRect;
use bvh::BVHNode;
use camera::Camera;
use color::{ray_color, write_color};
use hittable::Sphere;
use hittablelist::HitTableList;
use image::{GenericImageView, ImageBuffer, RgbImage};
use indicatif::ProgressBar;
use material::{Dielectric, DiffuseLight, FrostedGlass, Lambertian, Metal};
use rtweekend::random_double;
use std::sync::{mpsc::channel, Arc};
use texture::{CheckerTexture, ConstTexture};
use threadpool::ThreadPool;
use vec3::{randomvec, Color, Point3, Vec3};
pub fn simple_light() -> HitTableList {
let mut world = HitTableList::new();
let checker = Arc::new(CheckerTexture::new(
Color::new(0.2, 0.3, 0.1),
Color::new(0.9, 0.9, 0.9),
));
world.add(Arc::new(Sphere::new(
Point3::new(0.0, -1000.0, 0.0),
1000.0,
Arc::new(Lambertian {
albedo: checker.clone(),
}),
)));
world.add(Arc::new(Sphere::new(
Point3::new(0.0, 2.0, 0.0),
2.0,
Arc::new(Lambertian { albedo: checker }),
)));
let difflight = Arc::new(DiffuseLight::new(Color::new(4.0, 0.0, 4.0)));
world.add(Arc::new(XYRect::new(3.0, 5.0, 1.0, 3.0, -2.0, difflight)));
world
}
pub fn check(world: &HitTableList, center: &Point3) -> bool {
for object in &world.objects {
let dis = object.distance(center);
if dis < center.y {
return false;
}
}
true
}
pub fn read_image() -> HitTableList {
let mut world = HitTableList::new();
let image1 = image::open("src/1.png").unwrap();
for a in 0..image1.width() {
for b in 0..image1.height() {
let pixel_color = image1.get_pixel(a, b);
if pixel_color != image::Rgba([255_u8, 255_u8, 255_u8, 255]) {
let albedo = Vec3::new(11.0, 23.0, 70.0) / 255.0;
let sphere_material = Arc::new(Lambertian::new(albedo));
world.add(Arc::new(Sphere::new(
Vec3::new(a as f64 / 20.0, (image1.height() - b) as f64 / 10.0, 0.0),
0.05,
sphere_material,
)));
}
}
}
let image2 = image::open("src/2.png").unwrap();
for a in 0..image2.width() {
for b in 0..image2.height() {
let pixel_color = image2.get_pixel(a, b);
if pixel_color != image::Rgba([255_u8, 255_u8, 255_u8, 255]) {
let albedo = Vec3::new(11.0, 23.0, 70.0) / 255.0;
let sphere_material = Arc::new(Lambertian::new(albedo));
world.add(Arc::new(Sphere::new(
Vec3::new(
a as f64 / 20.0,
(image2.height() - b) as f64 / 10.0 + 2.0,
-10.0,
),
0.05,
sphere_material,
)));
}
}
}
let albedo = randomvec().elemul(randomvec());
// let fuzz = random_double(0.0, 0.5);
let fuzz = 0.0;
let sphere_material1 = Arc::new(Metal::new(&albedo, fuzz));
world.add(Arc::new(Sphere::new(
Point3::new(-3.5, 3.0, 0.0),
3.0,
sphere_material1,
)));
let sphere_material2 = Arc::new(Dielectric::new(1.5));
world.add(Arc::new(Sphere::new(
Point3::new(-3.5, 5.0, -10.0),
3.0,
sphere_material2,
)));
let sphere_material3 = Arc::new(FrostedGlass::new(1.5, 0.3));
world.add(Arc::new(Sphere::new(
Point3::new(0.0, -15.0, 0.0),
15.0,
Arc::new(DiffuseLight {
emit: Arc::new(ConstTexture {
color_value: Color::ones() * 3.0,
}),
}),
)));
world.add(Arc::new(Sphere::new(
Point3::new(0.0, -1000.0, 0.0),
1000.0,
sphere_material3,
)));
world
}
pub fn random_scene() -> HitTableList {
let mut world = HitTableList::new();
let checker = Arc::new(CheckerTexture::new(
Color::new(0.2, 0.3, 0.1),
Color::new(0.9, 0.9, 0.9),
));
world.add(Arc::new(Sphere::new(
Point3::new(0.0, -1000.0, 0.0),
1000.0,
Arc::new(Lambertian { albedo: checker }),
)));
let material_1 = Arc::new(CheckerTexture::new(
Color::new(254.0, 67.0, 101.0) / 255.0 * 1.7,
Color::new(249.0, 205.0, 173.0) / 255.0 * 1.7,
));
world.add(Arc::new(Sphere::new(
Point3::new(0.0, 1.0, 0.0),
1.0,
Arc::new(DiffuseLight { emit: material_1 }),
)));
for a in -15..15 {
for b in -15..15 {
let choose_mat = random_double(0.0, 1.0);
let center = Point3::new(
a as f64 + 0.9 * random_double(0.0, 1.0),
random_double(0.05, 0.5),
b as f64 + 0.9 * random_double(0.0, 1.0),
);
if !check(&world, ¢er) {
continue;
}
if (center - Point3::new(4.0, 0.2, 0.0)).length() > 0.9 {
if choose_mat < 0.2 {
// let difflight = randomvec().elemul(randomvec()) * 2.0;
// let sphere_material = Arc::new(DiffuseLight::new(difflight));
// world.add(Arc::new(Sphere::new(center, center.y, sphere_material)));
} else if choose_mat < 0.5 {
let sphere_material1 = Arc::new(FrostedGlass::new(1.5, choose_mat));
world.add(Arc::new(Sphere::new(center, center.y, sphere_material1)));
let difflight = randomvec().elemul(randomvec()) * 2.0;
let sphere_material2 = Arc::new(DiffuseLight::new(difflight));
world.add(Arc::new(Sphere::new(
center,
center.y * 0.5,
sphere_material2,
)));
} else if choose_mat < 0.6 {
let albedo = randomvec().elemul(randomvec());
let sphere_material = Arc::new(Lambertian::new(albedo));
world.add(Arc::new(Sphere::new(center, center.y, sphere_material)));
} else if choose_mat < 0.8 {
let albedo = randomvec().elemul(randomvec());
let fuzz = random_double(0.0, 0.5);
let sphere_material = Arc::new(Metal::new(&albedo, fuzz));
world.add(Arc::new(Sphere::new(center, center.y, sphere_material)));
} else {
let sphere_material = Arc::new(Dielectric::new(1.5));
world.add(Arc::new(Sphere::new(center, center.y, sphere_material)));
}
}
}
}
world
}
pub fn is_ci() -> bool {
option_env!("CI").unwrap_or_default() == "true"
}
fn main() {
// get environment variable CI, which is true for GitHub Action
let is_ci = is_ci();
// jobs: split image into how many parts
// workers: maximum allowed concurrent running threads
let (n_jobs, n_workers): (usize, usize) = if is_ci { (32, 2) } else { (16, 4) };
println!(
"CI: {}, using {} jobs and {} workers",
is_ci, n_jobs, n_workers
);
// image
let aspect_ratio = 16.0 / 9.0;
let image_width = 1600;
let image_height = (image_width as f64 / aspect_ratio) as u32;
let samples_per_pixel = 200;
let max_depth = 50;
// World
// let mut world = random_scene();
let mut world = read_image();
let length = world.objects.len();
let world = BVHNode::new(&mut world.objects, 0, length, 0.0, 0.1);
let background = Color::new(0.0, 0.0, 0.0);
// Camera
let lookfrom = Point3::new(10.0, 10.0, 16.0);
let lookat = Point3::new(0.0, 4.0, -3.0);
let vup = Vec3::new(0.0, 1.0, 0.0);
let dist_to_focus = 15.0;
let aperture = 0.0;
let cam = Camera::new(
lookfrom,
lookat,
vup,
60.0,
aspect_ratio,
aperture,
dist_to_focus,
);
// create a channel to send objects between threads
let (tx, rx) = channel();
let pool = ThreadPool::new(n_workers);
let bar = ProgressBar::new(n_jobs as u64);
for i in 0..n_jobs {
let tx = tx.clone();
let world_ptr = world.clone();
pool.execute(move || {
// here, we render some of the rows of image in one thread
let row_begin = image_height as usize * i / n_jobs;
let row_end = image_height as usize * (i + 1) / n_jobs;
let render_height = row_end - row_begin;
let mut img: RgbImage = ImageBuffer::new(image_width, render_height as u32);
for x in 0..image_width {
// img_y is the row in partial rendered image
// y is real position in final image
for (img_y, y) in (row_begin..row_end).enumerate() {
let y = y as u32;
let mut pixel_color = Color::zero();
for _s in 0..samples_per_pixel {
let u = (x as f64 + random_double(0.0, 1.0)) / (image_width - 1) as f64;
let v = ((image_height - y) as f64 + random_double(0.0, 1.0))
/ (image_height - 1) as f64;
let r = cam.get_ray(u, v);
pixel_color += ray_color(&r, &background, &world_ptr, max_depth);
}
write_color(&mut img, x, img_y as u32, &pixel_color, samples_per_pixel);
}
}
// send row range and rendered image to main thread
tx.send((row_begin..row_end, img))
.expect("failed to send result");
});
}
let mut result: RgbImage = ImageBuffer::new(image_width, image_height);
for (rows, data) in rx.iter().take(n_jobs) {
// idx is the corrsponding row in partial-rendered image
for (idx, row) in rows.enumerate() {
for col in 0..image_width {
let row = row as u32;
let idx = idx as u32;
*result.get_pixel_mut(col, row) = *data.get_pixel(col, idx);
}
}
bar.inc(1);
}
bar.finish();
/* Main Loop without Multithreading
for x in 0..image_width {
for y in 0..image_height {
let mut pixel_color = Color::zero();
for _s in 0..samples_per_pixel {
let u = (x as f64 + random_double(0.0, 1.0)) / (image_width - 1) as f64;
let v = ((image_height - y) as f64 + random_double(0.0, 1.0))
/ (image_height - 1) as f64;
let r = cam.get_ray(u, v);
pixel_color += ray_color(&r, &background, &world, max_depth);
}
write_color(&mut img, x, y, &pixel_color, samples_per_pixel);
}
bar.inc(1);
} */
// Save
result.save("output/test.png").unwrap();
}
|
#![allow(unused_variables, non_upper_case_globals, non_snake_case, unused_unsafe, non_camel_case_types, dead_code, clippy::all)]
pub const AACMFTEncoder: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x93af0c51_2275_45d2_a35b_f2ba21caed00);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct AEC_INPUT_STREAM(pub i32);
pub const AEC_CAPTURE_STREAM: AEC_INPUT_STREAM = AEC_INPUT_STREAM(0i32);
pub const AEC_REFERENCE_STREAM: AEC_INPUT_STREAM = AEC_INPUT_STREAM(1i32);
impl ::core::convert::From<i32> for AEC_INPUT_STREAM {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for AEC_INPUT_STREAM {
type Abi = Self;
}
pub const AEC_MAX_SYSTEM_MODES: u32 = 6u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct AEC_SYSTEM_MODE(pub i32);
pub const SINGLE_CHANNEL_AEC: AEC_SYSTEM_MODE = AEC_SYSTEM_MODE(0i32);
pub const ADAPTIVE_ARRAY_ONLY: AEC_SYSTEM_MODE = AEC_SYSTEM_MODE(1i32);
pub const OPTIBEAM_ARRAY_ONLY: AEC_SYSTEM_MODE = AEC_SYSTEM_MODE(2i32);
pub const ADAPTIVE_ARRAY_AND_AEC: AEC_SYSTEM_MODE = AEC_SYSTEM_MODE(3i32);
pub const OPTIBEAM_ARRAY_AND_AEC: AEC_SYSTEM_MODE = AEC_SYSTEM_MODE(4i32);
pub const SINGLE_CHANNEL_NSAGC: AEC_SYSTEM_MODE = AEC_SYSTEM_MODE(5i32);
pub const MODE_NOT_SET: AEC_SYSTEM_MODE = AEC_SYSTEM_MODE(6i32);
impl ::core::convert::From<i32> for AEC_SYSTEM_MODE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for AEC_SYSTEM_MODE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct AEC_VAD_MODE(pub i32);
pub const AEC_VAD_DISABLED: AEC_VAD_MODE = AEC_VAD_MODE(0i32);
pub const AEC_VAD_NORMAL: AEC_VAD_MODE = AEC_VAD_MODE(1i32);
pub const AEC_VAD_FOR_AGC: AEC_VAD_MODE = AEC_VAD_MODE(2i32);
pub const AEC_VAD_FOR_SILENCE_SUPPRESSION: AEC_VAD_MODE = AEC_VAD_MODE(3i32);
impl ::core::convert::From<i32> for AEC_VAD_MODE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for AEC_VAD_MODE {
type Abi = Self;
}
pub const ALawCodecWrapper: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x36cb6e0c_78c1_42b2_9943_846262f31786);
pub const AM_MEDIA_TYPE_REPRESENTATION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe2e42ad2_132c_491e_a268_3c7c2dca181f);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct ASF_FLAT_PICTURE {
pub bPictureType: u8,
pub dwDataLen: u32,
}
impl ASF_FLAT_PICTURE {}
impl ::core::default::Default for ASF_FLAT_PICTURE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for ASF_FLAT_PICTURE {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for ASF_FLAT_PICTURE {}
unsafe impl ::windows::core::Abi for ASF_FLAT_PICTURE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct ASF_FLAT_SYNCHRONISED_LYRICS {
pub bTimeStampFormat: u8,
pub bContentType: u8,
pub dwLyricsLen: u32,
}
impl ASF_FLAT_SYNCHRONISED_LYRICS {}
impl ::core::default::Default for ASF_FLAT_SYNCHRONISED_LYRICS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for ASF_FLAT_SYNCHRONISED_LYRICS {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for ASF_FLAT_SYNCHRONISED_LYRICS {}
unsafe impl ::windows::core::Abi for ASF_FLAT_SYNCHRONISED_LYRICS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct ASF_INDEX_DESCRIPTOR {
pub Identifier: ASF_INDEX_IDENTIFIER,
pub cPerEntryBytes: u16,
pub szDescription: [u16; 32],
pub dwInterval: u32,
}
impl ASF_INDEX_DESCRIPTOR {}
impl ::core::default::Default for ASF_INDEX_DESCRIPTOR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for ASF_INDEX_DESCRIPTOR {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("ASF_INDEX_DESCRIPTOR").field("Identifier", &self.Identifier).field("cPerEntryBytes", &self.cPerEntryBytes).field("szDescription", &self.szDescription).field("dwInterval", &self.dwInterval).finish()
}
}
impl ::core::cmp::PartialEq for ASF_INDEX_DESCRIPTOR {
fn eq(&self, other: &Self) -> bool {
self.Identifier == other.Identifier && self.cPerEntryBytes == other.cPerEntryBytes && self.szDescription == other.szDescription && self.dwInterval == other.dwInterval
}
}
impl ::core::cmp::Eq for ASF_INDEX_DESCRIPTOR {}
unsafe impl ::windows::core::Abi for ASF_INDEX_DESCRIPTOR {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct ASF_INDEX_IDENTIFIER {
pub guidIndexType: ::windows::core::GUID,
pub wStreamNumber: u16,
}
impl ASF_INDEX_IDENTIFIER {}
impl ::core::default::Default for ASF_INDEX_IDENTIFIER {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for ASF_INDEX_IDENTIFIER {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("ASF_INDEX_IDENTIFIER").field("guidIndexType", &self.guidIndexType).field("wStreamNumber", &self.wStreamNumber).finish()
}
}
impl ::core::cmp::PartialEq for ASF_INDEX_IDENTIFIER {
fn eq(&self, other: &Self) -> bool {
self.guidIndexType == other.guidIndexType && self.wStreamNumber == other.wStreamNumber
}
}
impl ::core::cmp::Eq for ASF_INDEX_IDENTIFIER {}
unsafe impl ::windows::core::Abi for ASF_INDEX_IDENTIFIER {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct ASF_MUX_STATISTICS {
pub cFramesWritten: u32,
pub cFramesDropped: u32,
}
impl ASF_MUX_STATISTICS {}
impl ::core::default::Default for ASF_MUX_STATISTICS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for ASF_MUX_STATISTICS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("ASF_MUX_STATISTICS").field("cFramesWritten", &self.cFramesWritten).field("cFramesDropped", &self.cFramesDropped).finish()
}
}
impl ::core::cmp::PartialEq for ASF_MUX_STATISTICS {
fn eq(&self, other: &Self) -> bool {
self.cFramesWritten == other.cFramesWritten && self.cFramesDropped == other.cFramesDropped
}
}
impl ::core::cmp::Eq for ASF_MUX_STATISTICS {}
unsafe impl ::windows::core::Abi for ASF_MUX_STATISTICS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct ASF_SELECTION_STATUS(pub i32);
pub const ASF_STATUS_NOTSELECTED: ASF_SELECTION_STATUS = ASF_SELECTION_STATUS(0i32);
pub const ASF_STATUS_CLEANPOINTSONLY: ASF_SELECTION_STATUS = ASF_SELECTION_STATUS(1i32);
pub const ASF_STATUS_ALLDATAUNITS: ASF_SELECTION_STATUS = ASF_SELECTION_STATUS(2i32);
impl ::core::convert::From<i32> for ASF_SELECTION_STATUS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for ASF_SELECTION_STATUS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct ASF_STATUSFLAGS(pub i32);
pub const ASF_STATUSFLAGS_INCOMPLETE: ASF_STATUSFLAGS = ASF_STATUSFLAGS(1i32);
pub const ASF_STATUSFLAGS_NONFATAL_ERROR: ASF_STATUSFLAGS = ASF_STATUSFLAGS(2i32);
impl ::core::convert::From<i32> for ASF_STATUSFLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for ASF_STATUSFLAGS {
type Abi = Self;
}
pub const AVENC_H263V_LEVELCOUNT: u32 = 8u32;
pub const AVENC_H264V_LEVELCOUNT: u32 = 16u32;
pub const AVENC_H264V_MAX_MBBITS: u32 = 3200u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct AecQualityMetrics_Struct {
pub i64Timestamp: i64,
pub ConvergenceFlag: u8,
pub MicClippedFlag: u8,
pub MicSilenceFlag: u8,
pub PstvFeadbackFlag: u8,
pub SpkClippedFlag: u8,
pub SpkMuteFlag: u8,
pub GlitchFlag: u8,
pub DoubleTalkFlag: u8,
pub uGlitchCount: u32,
pub uMicClipCount: u32,
pub fDuration: f32,
pub fTSVariance: f32,
pub fTSDriftRate: f32,
pub fVoiceLevel: f32,
pub fNoiseLevel: f32,
pub fERLE: f32,
pub fAvgERLE: f32,
pub dwReserved: u32,
}
impl AecQualityMetrics_Struct {}
impl ::core::default::Default for AecQualityMetrics_Struct {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for AecQualityMetrics_Struct {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("AecQualityMetrics_Struct")
.field("i64Timestamp", &self.i64Timestamp)
.field("ConvergenceFlag", &self.ConvergenceFlag)
.field("MicClippedFlag", &self.MicClippedFlag)
.field("MicSilenceFlag", &self.MicSilenceFlag)
.field("PstvFeadbackFlag", &self.PstvFeadbackFlag)
.field("SpkClippedFlag", &self.SpkClippedFlag)
.field("SpkMuteFlag", &self.SpkMuteFlag)
.field("GlitchFlag", &self.GlitchFlag)
.field("DoubleTalkFlag", &self.DoubleTalkFlag)
.field("uGlitchCount", &self.uGlitchCount)
.field("uMicClipCount", &self.uMicClipCount)
.field("fDuration", &self.fDuration)
.field("fTSVariance", &self.fTSVariance)
.field("fTSDriftRate", &self.fTSDriftRate)
.field("fVoiceLevel", &self.fVoiceLevel)
.field("fNoiseLevel", &self.fNoiseLevel)
.field("fERLE", &self.fERLE)
.field("fAvgERLE", &self.fAvgERLE)
.field("dwReserved", &self.dwReserved)
.finish()
}
}
impl ::core::cmp::PartialEq for AecQualityMetrics_Struct {
fn eq(&self, other: &Self) -> bool {
self.i64Timestamp == other.i64Timestamp
&& self.ConvergenceFlag == other.ConvergenceFlag
&& self.MicClippedFlag == other.MicClippedFlag
&& self.MicSilenceFlag == other.MicSilenceFlag
&& self.PstvFeadbackFlag == other.PstvFeadbackFlag
&& self.SpkClippedFlag == other.SpkClippedFlag
&& self.SpkMuteFlag == other.SpkMuteFlag
&& self.GlitchFlag == other.GlitchFlag
&& self.DoubleTalkFlag == other.DoubleTalkFlag
&& self.uGlitchCount == other.uGlitchCount
&& self.uMicClipCount == other.uMicClipCount
&& self.fDuration == other.fDuration
&& self.fTSVariance == other.fTSVariance
&& self.fTSDriftRate == other.fTSDriftRate
&& self.fVoiceLevel == other.fVoiceLevel
&& self.fNoiseLevel == other.fNoiseLevel
&& self.fERLE == other.fERLE
&& self.fAvgERLE == other.fAvgERLE
&& self.dwReserved == other.dwReserved
}
}
impl ::core::cmp::Eq for AecQualityMetrics_Struct {}
unsafe impl ::windows::core::Abi for AecQualityMetrics_Struct {
type Abi = Self;
}
pub const CAC3DecMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x03d7c802_ecfa_47d9_b268_5fb3e310dee4);
pub const CClusterDetectorDmo: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x36e820c4_165a_4521_863c_619e1160d4d4);
pub const CColorControlDmo: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x798059f0_89ca_4160_b325_aeb48efe4f9a);
pub const CColorConvertDMO: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x98230571_0087_4204_b020_3282538e57d3);
pub const CColorLegalizerDmo: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfdfaa753_e48e_4e33_9c74_98a27fc6726a);
pub const CDTVAudDecoderDS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8e269032_fe03_4753_9b17_18253c21722e);
pub const CDTVVidDecoderDS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x64777dc8_4e24_4beb_9d19_60a35be1daaf);
pub const CDVDecoderMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe54709c5_1e17_4c8d_94e7_478940433584);
pub const CDVEncoderMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc82ae729_c327_4cce_914d_8171fefebefb);
pub const CDeColorConvMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x49034c05_f43c_400f_84c1_90a683195a3a);
pub const CFrameInterpDMO: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0a7cfe1b_6ab5_4334_9ed8_3f97cb37daa1);
pub const CFrameRateConvertDmo: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x01f36ce2_0907_4d8b_979d_f151be91c883);
pub const CInterlaceMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb5a89c80_4901_407b_9abc_90d9a644bb46);
pub const CLSID_AudioResamplerMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf447b69e_1884_4a7e_8055_346f74d6edb3);
pub const CLSID_CAsfTocParser: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9b77c0f2_8735_46c5_b90f_5f0b303ef6ab);
pub const CLSID_CAviTocParser: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3adce5cc_13c8_4573_b328_ed438eb694f9);
pub const CLSID_CClusterDetectorEx: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x47354492_827e_4b8a_b318_c80eba1381f0);
pub const CLSID_CFileClient: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbfccd195_1244_4840_ab44_480975c4ffe4);
pub const CLSID_CFileIo: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x11993195_1244_4840_ab44_480975c4ffe4);
pub const CLSID_CToc: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4fe24495_28ce_4920_a4c4_e556e1f0df2a);
pub const CLSID_CTocCollection: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5058292d_a244_4840_ab44_480975c4ffe4);
pub const CLSID_CTocEntry: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf22f5e05_585c_4def_8523_6555cfbc0cb3);
pub const CLSID_CTocEntryList: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3a8cccbc_0efd_43a3_b838_f38a552ba237);
pub const CLSID_CTocParser: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x499eaeea_2737_4849_8bb6_47f107eaf358);
pub const CLSID_CreateMediaExtensionObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xef65a54d_0788_45b8_8b14_bc0f6a6b5137);
pub const CLSID_FrameServerNetworkCameraSource: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7a213aa7_866f_414a_8c1a_275c7283a395);
pub const CLSID_HttpSchemePlugin: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x44cb442b_9da9_49df_b3fd_023777b16e50);
pub const CLSID_MFByteStreamProxyClassFactory: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x770e8e77_4916_441c_a9a7_b342d0eebc71);
pub const CLSID_MFCaptureEngine: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xefce38d3_8914_4674_a7df_ae1b3d654b8a);
pub const CLSID_MFCaptureEngineClassFactory: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xefce38d3_8914_4674_a7df_ae1b3d654b8a);
pub const CLSID_MFImageSharingEngineClassFactory: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb22c3339_87f3_4059_a0c5_037aa9707eaf);
pub const CLSID_MFMediaEngineClassFactory: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb44392da_499b_446b_a4cb_005fead0e6d5);
pub const CLSID_MFMediaSharingEngineClassFactory: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf8e307fb_6d45_4ad3_9993_66cd5a529659);
pub const CLSID_MFReadWriteClassFactory: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x48e2ed0f_98c2_4a37_bed5_166312ddd83f);
pub const CLSID_MFSinkWriter: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa3bbfb17_8273_4e52_9e0e_9739dc887990);
pub const CLSID_MFSourceReader: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1777133c_0881_411b_a577_ad545f0714c4);
pub const CLSID_MFSourceResolver: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x90eab60f_e43a_4188_bcc4_e47fdf04868c);
pub const CLSID_MP3DecMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbbeea841_0a63_4f52_a7ab_a9b3a84ed38a);
pub const CLSID_MPEG2ByteStreamPlugin: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x40871c59_ab40_471f_8dc3_1f259d862479);
pub const CLSID_MPEG2DLNASink: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfa5fe7c5_6a1d_4b11_b41f_f959d6c76500);
pub const CLSID_MSAACDecMFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x32d186a7_218f_4c75_8876_dd77273a8999);
pub const CLSID_MSDDPlusDecMFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x177c0afe_900b_48d4_9e4c_57add250b3d4);
pub const CLSID_MSH264DecoderMFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x62ce7e72_4c71_4d20_b15d_452831a87d9d);
pub const CLSID_MSH264EncoderMFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6ca50344_051a_4ded_9779_a43305165e35);
pub const CLSID_MSH265DecoderMFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x420a51a3_d605_430c_b4fc_45274fa6c562);
pub const CLSID_MSMPEGAudDecMFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x70707b39_b2ca_4015_abea_f8447d22d88b);
pub const CLSID_MSMPEGDecoderMFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2d709e52_123f_49b5_9cbc_9af5cde28fb9);
pub const CLSID_MSOpusDecoder: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x63e17c10_2d43_4c42_8fe3_8d8b63e46a6a);
pub const CLSID_MSVPxDecoder: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe3aaf548_c9a4_4c6e_234d_5ada374b0000);
pub const CLSID_NetSchemePlugin: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe9f4ebab_d97b_463e_a2b1_c54ee3f9414d);
pub const CLSID_PlayToSourceClassFactory: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xda17539a_3dc3_42c1_a749_a183b51f085e);
pub const CLSID_UrlmonSchemePlugin: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9ec4b4f9_3029_45ad_947b_344de2a249e2);
pub const CLSID_VideoProcessorMFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x88753b26_5b24_49bd_b2e7_0c445c78c982);
pub const CLSID_WMADecMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2eeb4adf_4578_4d10_bca7_bb955f56320a);
pub const CLSID_WMDRMSystemID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8948bb22_11bd_4796_93e3_974d1b575678);
pub const CLSID_WMVDecoderMFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x82d353df_90bd_4382_8bc2_3f6192b76e34);
pub const CMP3DecMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbbeea841_0a63_4f52_a7ab_a9b3a84ed38a);
pub const CMPEG2AudDecoderDS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe1f1a0b8_beee_490d_ba7c_066c40b5e2b9);
pub const CMPEG2AudioEncoderMFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x46a4dd5c_73f8_4304_94df_308f760974f4);
pub const CMPEG2EncoderAudioDS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xacd453bc_c58a_44d1_bbf5_bfb325be2d78);
pub const CMPEG2EncoderDS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5f5aff4a_2f7f_4279_88c2_cd88eb39d144);
pub const CMPEG2EncoderVideoDS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x42150cd9_ca9a_4ea5_9939_30ee037f6e74);
pub const CMPEG2VidDecoderDS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x212690fb_83e5_4526_8fd7_74478b7939cd);
pub const CMPEG2VideoEncoderMFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe6335f02_80b7_4dc4_adfa_dfe7210d20d5);
pub const CMPEGAACDecMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8dde1772_edad_41c3_b4be_1f30fb4ee0d6);
pub const CMSAACDecMFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x32d186a7_218f_4c75_8876_dd77273a8999);
pub const CMSAC3Enc: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc6b400e2_20a7_4e58_a2fe_24619682ce6c);
pub const CMSALACDecMFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc0cd7d12_31fc_4bbc_b363_7322ee3e1879);
pub const CMSALACEncMFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9ab6a28c_748e_4b6a_bfff_cc443b8e8fb4);
pub const CMSDDPlusDecMFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x177c0afe_900b_48d4_9e4c_57add250b3d4);
pub const CMSDolbyDigitalEncMFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xac3315c9_f481_45d7_826c_0b406c1f64b8);
pub const CMSFLACDecMFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6b0b3e6b_a2c5_4514_8055_afe8a95242d9);
pub const CMSFLACEncMFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x128509e9_c44e_45dc_95e9_c255b8f466a6);
pub const CMSH263EncoderMFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbc47fcfe_98a0_4f27_bb07_698af24f2b38);
pub const CMSH264DecoderMFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x62ce7e72_4c71_4d20_b15d_452831a87d9d);
pub const CMSH264EncoderMFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6ca50344_051a_4ded_9779_a43305165e35);
pub const CMSH264RemuxMFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x05a47ebb_8bf0_4cbf_ad2f_3b71d75866f5);
pub const CMSH265EncoderMFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf2f84074_8bca_40bd_9159_e880f673dd3b);
pub const CMSMPEGAudDecMFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x70707b39_b2ca_4015_abea_f8447d22d88b);
pub const CMSMPEGDecoderMFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2d709e52_123f_49b5_9cbc_9af5cde28fb9);
pub const CMSOpusDecMFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x63e17c10_2d43_4c42_8fe3_8d8b63e46a6a);
pub const CMSSCDecMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7bafb3b1_d8f4_4279_9253_27da423108de);
pub const CMSSCEncMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8cb9cc06_d139_4ae6_8bb4_41e612e141d5);
pub const CMSSCEncMediaObject2: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf7ffe0a0_a4f5_44b5_949e_15ed2bc66f9d);
pub const CMSVPXEncoderMFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xaeb6c755_2546_4881_82cc_e15ae5ebff3d);
pub const CMSVideoDSPMFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51571744_7fe4_4ff2_a498_2dc34ff74f1b);
pub const CMpeg2DecMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x863d66cd_cdce_4617_b47f_c8929cfc28a6);
pub const CMpeg43DecMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xcba9e78b_49a3_49ea_93d4_6bcba8c4de07);
pub const CMpeg4DecMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf371728a_6052_4d47_827c_d039335dfe0a);
pub const CMpeg4EncMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x24f258d8_c651_4042_93e4_ca654abb682c);
pub const CMpeg4sDecMFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5686a0d9_fe39_409f_9dff_3fdbc849f9f5);
pub const CMpeg4sDecMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2a11bae2_fe6e_4249_864b_9e9ed6e8dbc2);
pub const CMpeg4sEncMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6ec5a7be_d81e_4f9e_ada3_cd1bf262b6d8);
pub const CNokiaAACCCDecMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xeabf7a6f_ccba_4d60_8620_b152cc977263);
pub const CNokiaAACDecMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb2bde4_4e29_4c44_a73e_2d7c2c46d6ec);
pub const CODECAPI_AVAudioChannelConfig: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x17f89cb3_c38d_4368_9ede_63b94d177f9f);
pub const CODECAPI_AVAudioChannelCount: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1d3583c4_1583_474e_b71a_5ee463c198e4);
pub const CODECAPI_AVAudioSampleRate: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x971d2723_1acb_42e7_855c_520a4b70a5f2);
pub const CODECAPI_AVDDSurroundMode: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x99f2f386_98d1_4452_a163_abc78a6eb770);
pub const CODECAPI_AVDSPLoudnessEqualization: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8afd1a15_1812_4cbf_9319_433a5b2a3b27);
pub const CODECAPI_AVDSPSpeakerFill: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5612bca1_56da_4582_8da1_ca8090f92768);
pub const CODECAPI_AVDecAACDownmixMode: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x01274475_f6bb_4017_b084_81a763c942d4);
pub const CODECAPI_AVDecAudioDualMono: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4a52cda8_30f8_4216_be0f_ba0b2025921d);
pub const CODECAPI_AVDecAudioDualMonoReproMode: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa5106186_cc94_4bc9_8cd9_aa2f61f6807e);
pub const CODECAPI_AVDecCommonInputFormat: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe5005239_bd89_4be3_9c0f_5dde317988cc);
pub const CODECAPI_AVDecCommonMeanBitRate: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x59488217_007a_4f7a_8e41_5c48b1eac5c6);
pub const CODECAPI_AVDecCommonMeanBitRateInterval: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0ee437c6_38a7_4c5c_944c_68ab42116b85);
pub const CODECAPI_AVDecCommonOutputFormat: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3c790028_c0ce_4256_b1a2_1b0fc8b1dcdc);
pub const CODECAPI_AVDecDDDynamicRangeScaleHigh: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x50196c21_1f33_4af5_b296_11426d6c8789);
pub const CODECAPI_AVDecDDDynamicRangeScaleLow: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x044e62e4_11a5_42d5_a3b2_3bb2c7c2d7cf);
pub const CODECAPI_AVDecDDMatrixDecodingMode: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xddc811a5_04ed_4bf3_a0ca_d00449f9355f);
pub const CODECAPI_AVDecDDOperationalMode: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd6d6c6d1_064e_4fdd_a40e_3ecbfcb7ebd0);
pub const CODECAPI_AVDecDDStereoDownMixMode: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6ce4122c_3ee9_4182_b4ae_c10fc088649d);
pub const CODECAPI_AVDecDisableVideoPostProcessing: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf8749193_667a_4f2c_a9e8_5d4af924f08f);
pub const CODECAPI_AVDecHEAACDynamicRangeControl: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x287c8abe_69a4_4d39_8080_d3d9712178a0);
pub const CODECAPI_AVDecNumWorkerThreads: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9561c3e8_ea9e_4435_9b1e_a93e691894d8);
pub const CODECAPI_AVDecSoftwareDynamicFormatChange: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x862e2f0a_507b_47ff_af47_01e2624298b7);
pub const CODECAPI_AVDecVideoAcceleration_H264: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf7db8a2f_4f48_4ee8_ae31_8b6ebe558ae2);
pub const CODECAPI_AVDecVideoAcceleration_MPEG2: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf7db8a2e_4f48_4ee8_ae31_8b6ebe558ae2);
pub const CODECAPI_AVDecVideoAcceleration_VC1: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf7db8a30_4f48_4ee8_ae31_8b6ebe558ae2);
pub const CODECAPI_AVDecVideoCodecType: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x434528e5_21f0_46b6_b62c_9b1b6b658cd1);
pub const CODECAPI_AVDecVideoDXVABusEncryption: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x42153c8b_fd0b_4765_a462_ddd9e8bcc388);
pub const CODECAPI_AVDecVideoDXVAMode: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf758f09e_7337_4ae7_8387_73dc2d54e67d);
pub const CODECAPI_AVDecVideoDropPicWithMissingRef: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf8226383_14c2_4567_9734_5004e96ff887);
pub const CODECAPI_AVDecVideoFastDecodeMode: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6b529f7d_d3b1_49c6_a999_9ec6911bedbf);
pub const CODECAPI_AVDecVideoH264ErrorConcealment: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xececace8_3436_462c_9294_cd7bacd758a9);
pub const CODECAPI_AVDecVideoImageSize: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5ee5747c_6801_4cab_aaf1_6248fa841ba4);
pub const CODECAPI_AVDecVideoInputScanType: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x38477e1f_0ea7_42cd_8cd1_130ced57c580);
pub const CODECAPI_AVDecVideoMPEG2ErrorConcealment: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9d2bfe18_728d_48d2_b358_bc7e436c6674);
pub const CODECAPI_AVDecVideoMaxCodedHeight: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7262a16a_d2dc_4e75_9ba8_65c0c6d32b13);
pub const CODECAPI_AVDecVideoMaxCodedWidth: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5ae557b8_77af_41f5_9fa6_4db2fe1d4bca);
pub const CODECAPI_AVDecVideoPixelAspectRatio: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb0cf8245_f32d_41df_b02c_87bd304d12ab);
pub const CODECAPI_AVDecVideoProcDeinterlaceCSC: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf7db8a31_4f48_4ee8_ae31_8b6ebe558ae2);
pub const CODECAPI_AVDecVideoSWPowerLevel: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfb5d2347_4dd8_4509_aed0_db5fa9aa93f4);
pub const CODECAPI_AVDecVideoSoftwareDeinterlaceMode: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0c08d1ce_9ced_4540_bae3_ceb380141109);
pub const CODECAPI_AVDecVideoThumbnailGenerationMode: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2efd8eee_1150_4328_9cf5_66dce933fcf4);
pub const CODECAPI_AVEnableInLoopDeblockFilter: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd2e8e399_0623_4bf3_92a8_4d1818529ded);
pub const CODECAPI_AVEncAdaptiveMode: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4419b185_da1f_4f53_bc76_097d0c1efb1e);
pub const CODECAPI_AVEncAudioDualMono: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3648126b_a3e8_4329_9b3a_5ce566a43bd3);
pub const CODECAPI_AVEncAudioInputContent: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3e226c2b_60b9_4a39_b00b_a7b40f70d566);
pub const CODECAPI_AVEncAudioIntervalToEncode: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x866e4b4d_725a_467c_bb01_b496b23b25f9);
pub const CODECAPI_AVEncAudioIntervalToSkip: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x88c15f94_c38c_4796_a9e8_96e967983f26);
pub const CODECAPI_AVEncAudioMapDestChannel0: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbc5d0b60_df6a_4e16_9803_b82007a30c8d);
pub const CODECAPI_AVEncAudioMapDestChannel1: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbc5d0b61_df6a_4e16_9803_b82007a30c8d);
pub const CODECAPI_AVEncAudioMapDestChannel10: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbc5d0b6a_df6a_4e16_9803_b82007a30c8d);
pub const CODECAPI_AVEncAudioMapDestChannel11: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbc5d0b6b_df6a_4e16_9803_b82007a30c8d);
pub const CODECAPI_AVEncAudioMapDestChannel12: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbc5d0b6c_df6a_4e16_9803_b82007a30c8d);
pub const CODECAPI_AVEncAudioMapDestChannel13: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbc5d0b6d_df6a_4e16_9803_b82007a30c8d);
pub const CODECAPI_AVEncAudioMapDestChannel14: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbc5d0b6e_df6a_4e16_9803_b82007a30c8d);
pub const CODECAPI_AVEncAudioMapDestChannel15: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbc5d0b6f_df6a_4e16_9803_b82007a30c8d);
pub const CODECAPI_AVEncAudioMapDestChannel2: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbc5d0b62_df6a_4e16_9803_b82007a30c8d);
pub const CODECAPI_AVEncAudioMapDestChannel3: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbc5d0b63_df6a_4e16_9803_b82007a30c8d);
pub const CODECAPI_AVEncAudioMapDestChannel4: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbc5d0b64_df6a_4e16_9803_b82007a30c8d);
pub const CODECAPI_AVEncAudioMapDestChannel5: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbc5d0b65_df6a_4e16_9803_b82007a30c8d);
pub const CODECAPI_AVEncAudioMapDestChannel6: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbc5d0b66_df6a_4e16_9803_b82007a30c8d);
pub const CODECAPI_AVEncAudioMapDestChannel7: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbc5d0b67_df6a_4e16_9803_b82007a30c8d);
pub const CODECAPI_AVEncAudioMapDestChannel8: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbc5d0b68_df6a_4e16_9803_b82007a30c8d);
pub const CODECAPI_AVEncAudioMapDestChannel9: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbc5d0b69_df6a_4e16_9803_b82007a30c8d);
pub const CODECAPI_AVEncAudioMeanBitRate: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x921295bb_4fca_4679_aab8_9e2a1d753384);
pub const CODECAPI_AVEncChromaEncodeMode: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8a47ab5a_4798_4c93_b5a5_554f9a3b9f50);
pub const CODECAPI_AVEncChromaUpdateTime: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4b4fd998_4274_40bb_8ee4_07553e7e2d3a);
pub const CODECAPI_AVEncCodecType: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x08af4ac1_f3f2_4c74_9dcf_37f2ec79f826);
pub const CODECAPI_AVEncCommonAllowFrameDrops: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd8477dcb_9598_48e3_8d0c_752bf206093e);
pub const CODECAPI_AVEncCommonBufferInLevel: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd9c5c8db_fc74_4064_94e9_cd19f947ed45);
pub const CODECAPI_AVEncCommonBufferOutLevel: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xccae7f49_d0bc_4e3d_a57e_fb5740140069);
pub const CODECAPI_AVEncCommonBufferSize: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0db96574_b6a4_4c8b_8106_3773de0310cd);
pub const CODECAPI_AVEncCommonFormatConstraint: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x57cbb9b8_116f_4951_b40c_c2a035ed8f17);
pub const CODECAPI_AVEncCommonLowLatency: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9d3ecd55_89e8_490a_970a_0c9548d5a56e);
pub const CODECAPI_AVEncCommonMaxBitRate: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9651eae4_39b9_4ebf_85ef_d7f444ec7465);
pub const CODECAPI_AVEncCommonMeanBitRate: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf7222374_2144_4815_b550_a37f8e12ee52);
pub const CODECAPI_AVEncCommonMeanBitRateInterval: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbfaa2f0c_cb82_4bc0_8474_f06a8a0d0258);
pub const CODECAPI_AVEncCommonMinBitRate: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x101405b2_2083_4034_a806_efbeddd7c9ff);
pub const CODECAPI_AVEncCommonMultipassMode: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x22533d4c_47e1_41b5_9352_a2b7780e7ac4);
pub const CODECAPI_AVEncCommonPassEnd: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0e3d01bc_c85c_467d_8b60_c41012ee3bf6);
pub const CODECAPI_AVEncCommonPassStart: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6a67739f_4eb5_4385_9928_f276a939ef95);
pub const CODECAPI_AVEncCommonQuality: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfcbf57a3_7ea5_4b0c_9644_69b40c39c391);
pub const CODECAPI_AVEncCommonQualityVsSpeed: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x98332df8_03cd_476b_89fa_3f9e442dec9f);
pub const CODECAPI_AVEncCommonRateControlMode: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1c0608e9_370c_4710_8a58_cb6181c42423);
pub const CODECAPI_AVEncCommonRealTime: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x143a0ff6_a131_43da_b81e_98fbb8ec378e);
pub const CODECAPI_AVEncCommonStreamEndHandling: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6aad30af_6ba8_4ccc_8fca_18d19beaeb1c);
pub const CODECAPI_AVEncCommonTranscodeEncodingProfile: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6947787c_f508_4ea9_b1e9_a1fe3a49fbc9);
pub const CODECAPI_AVEncDDAtoDConverterType: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x719f9612_81a1_47e0_9a05_d94ad5fca948);
pub const CODECAPI_AVEncDDCentreDownMixLevel: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe285072c_c958_4a81_afd2_e5e0daf1b148);
pub const CODECAPI_AVEncDDChannelBWLowPassFilter: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe197821d_d2e7_43e2_ad2c_00582f518545);
pub const CODECAPI_AVEncDDCopyright: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8694f076_cd75_481d_a5c6_a904dcc828f0);
pub const CODECAPI_AVEncDDDCHighPassFilter: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9565239f_861c_4ac8_bfda_e00cb4db8548);
pub const CODECAPI_AVEncDDDialogNormalization: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd7055acf_f125_437d_a704_79c79f0404a8);
pub const CODECAPI_AVEncDDDigitalDeemphasis: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe024a2c2_947c_45ac_87d8_f1030c5c0082);
pub const CODECAPI_AVEncDDDynamicRangeCompressionControl: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xcfc2ff6d_79b8_4b8d_a8aa_a0c9bd1c2940);
pub const CODECAPI_AVEncDDHeadphoneMode: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4052dbec_52f5_42f5_9b00_d134b1341b9d);
pub const CODECAPI_AVEncDDLFELowPassFilter: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd3b80f6f_9d15_45e5_91be_019c3fab1f01);
pub const CODECAPI_AVEncDDLoRoCenterMixLvl_x10: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1cfba222_25b3_4bf4_9bfd_e7111267858c);
pub const CODECAPI_AVEncDDLoRoSurroundMixLvl_x10: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe725cff6_eb56_40c7_8450_2b9367e91555);
pub const CODECAPI_AVEncDDLtRtCenterMixLvl_x10: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdca128a2_491f_4600_b2da_76e3344b4197);
pub const CODECAPI_AVEncDDLtRtSurroundMixLvl_x10: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x212246c7_3d2c_4dfa_bc21_652a9098690d);
pub const CODECAPI_AVEncDDOriginalBitstream: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x966ae800_5bd3_4ff9_95b9_d30566273856);
pub const CODECAPI_AVEncDDPreferredStereoDownMixMode: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7f4e6b31_9185_403d_b0a2_763743e6f063);
pub const CODECAPI_AVEncDDProductionInfoExists: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb0b7fe5f_b6ab_4f40_964d_8d91f17c19e8);
pub const CODECAPI_AVEncDDProductionMixLevel: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x301d103a_cbf9_4776_8899_7c15b461ab26);
pub const CODECAPI_AVEncDDProductionRoomType: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdad7ad60_23d8_4ab7_a284_556986d8a6fe);
pub const CODECAPI_AVEncDDRFPreEmphasisFilter: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x21af44c0_244e_4f3d_a2cc_3d3068b2e73f);
pub const CODECAPI_AVEncDDService: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd2e1bec7_5172_4d2a_a50e_2f3b82b1ddf8);
pub const CODECAPI_AVEncDDSurround3dBAttenuation: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4d43b99d_31e2_48b9_bf2e_5cbf1a572784);
pub const CODECAPI_AVEncDDSurround90DegreeePhaseShift: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x25ecec9d_3553_42c0_bb56_d25792104f80);
pub const CODECAPI_AVEncDDSurroundDownMixLevel: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7b20d6e5_0bcf_4273_a487_506b047997e9);
pub const CODECAPI_AVEncDDSurroundExMode: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x91607cee_dbdd_4eb6_bca2_aadfafa3dd68);
pub const CODECAPI_AVEncEnableVideoProcessing: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x006f4bf6_0ea3_4d42_8702_b5d8be0f7a92);
pub const CODECAPI_AVEncH264CABACEnable: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xee6cad62_d305_4248_a50e_e1b255f7caf8);
pub const CODECAPI_AVEncH264PPSID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbfe29ec2_056c_4d68_a38d_ae5944c8582e);
pub const CODECAPI_AVEncH264SPSID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x50f38f51_2b79_40e3_b39c_7e9fa0770501);
pub const CODECAPI_AVEncInputVideoSystem: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbede146d_b616_4dc7_92b2_f5d9fa9298f7);
pub const CODECAPI_AVEncLowPowerEncoder: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb668d582_8bad_4f6a_9141_375a95358b6d);
pub const CODECAPI_AVEncMP12MuxDVDNavPacks: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc7607ced_8cf1_4a99_83a1_ee5461be3574);
pub const CODECAPI_AVEncMP12MuxEarliestPTS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x157232b6_f809_474e_9464_a7f93014a817);
pub const CODECAPI_AVEncMP12MuxInitialSCR: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3433ad21_1b91_4a0b_b190_2b77063b63a4);
pub const CODECAPI_AVEncMP12MuxLargestPacketSize: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x35ceb711_f461_4b92_a4ef_17b6841ed254);
pub const CODECAPI_AVEncMP12MuxMuxRate: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xee047c72_4bdb_4a9d_8e21_41926c823da7);
pub const CODECAPI_AVEncMP12MuxNumStreams: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf7164a41_dced_4659_a8f2_fb693f2a4cd0);
pub const CODECAPI_AVEncMP12MuxPackSize: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf916053a_1ce8_4faf_aa0b_ba31c80034b8);
pub const CODECAPI_AVEncMP12MuxPacketOverhead: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe40bd720_3955_4453_acf9_b79132a38fa0);
pub const CODECAPI_AVEncMP12MuxSysAudioLock: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0fbb5752_1d43_47bf_bd79_f2293d8ce337);
pub const CODECAPI_AVEncMP12MuxSysCSPS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7952ff45_9c0d_4822_bc82_8ad772e02993);
pub const CODECAPI_AVEncMP12MuxSysFixed: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xcefb987e_894f_452e_8f89_a4ef8cec063a);
pub const CODECAPI_AVEncMP12MuxSysRateBound: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x05f0428a_ee30_489d_ae28_205c72446710);
pub const CODECAPI_AVEncMP12MuxSysSTDBufferBound: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x35746903_b545_43e7_bb35_c5e0a7d5093c);
pub const CODECAPI_AVEncMP12MuxSysVideoLock: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb8296408_2430_4d37_a2a1_95b3e435a91d);
pub const CODECAPI_AVEncMP12MuxTargetPacketizer: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd862212a_2015_45dd_9a32_1b3aa88205a0);
pub const CODECAPI_AVEncMP12PktzCopyright: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc8f4b0c1_094c_43c7_8e68_a595405a6ef8);
pub const CODECAPI_AVEncMP12PktzInitialPTS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2a4f2065_9a63_4d20_ae22_0a1bc896a315);
pub const CODECAPI_AVEncMP12PktzOriginal: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6b178416_31b9_4964_94cb_6bff866cdf83);
pub const CODECAPI_AVEncMP12PktzPacketSize: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xab71347a_1332_4dde_a0e5_ccf7da8a0f22);
pub const CODECAPI_AVEncMP12PktzSTDBuffer: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0b751bd0_819e_478c_9435_75208926b377);
pub const CODECAPI_AVEncMP12PktzStreamID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc834d038_f5e8_4408_9b60_88f36493fedf);
pub const CODECAPI_AVEncMPACodingMode: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb16ade03_4b93_43d7_a550_90b4fe224537);
pub const CODECAPI_AVEncMPACopyright: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa6ae762a_d0a9_4454_b8ef_f2dbeefdd3bd);
pub const CODECAPI_AVEncMPAEmphasisType: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2d59fcda_bf4e_4ed6_b5df_5b03b36b0a1f);
pub const CODECAPI_AVEncMPAEnableRedundancyProtection: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5e54b09e_b2e7_4973_a89b_0b3650a3beda);
pub const CODECAPI_AVEncMPALayer: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9d377230_f91b_453d_9ce0_78445414c22d);
pub const CODECAPI_AVEncMPAOriginalBitstream: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cfb7855_9cc9_47ff_b829_b36786c92346);
pub const CODECAPI_AVEncMPAPrivateUserBit: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xafa505ce_c1e3_4e3d_851b_61b700e5e6cc);
pub const CODECAPI_AVEncMPVAddSeqEndCode: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa823178f_57df_4c7a_b8fd_e5ec8887708d);
pub const CODECAPI_AVEncMPVDefaultBPictureCount: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8d390aac_dc5c_4200_b57f_814d04babab2);
pub const CODECAPI_AVEncMPVFrameFieldMode: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xacb5de96_7b93_4c2f_8825_b0295fa93bf4);
pub const CODECAPI_AVEncMPVGOPOpen: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb1d5d4a6_3300_49b1_ae61_a09937ab0e49);
pub const CODECAPI_AVEncMPVGOPSInSeq: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x993410d4_2691_4192_9978_98dc2603669f);
pub const CODECAPI_AVEncMPVGOPSize: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x95f31b26_95a4_41aa_9303_246a7fc6eef1);
pub const CODECAPI_AVEncMPVGOPSizeMax: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfe7de4c4_1936_4fe2_bdf7_1f18ca1d001f);
pub const CODECAPI_AVEncMPVGOPSizeMin: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7155cf20_d440_4852_ad0f_9c4abfe37a6a);
pub const CODECAPI_AVEncMPVGenerateHeaderPicDispExt: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc6412f84_c03f_4f40_a00c_4293df8395bb);
pub const CODECAPI_AVEncMPVGenerateHeaderPicExt: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1b8464ab_944f_45f0_b74e_3a58dad11f37);
pub const CODECAPI_AVEncMPVGenerateHeaderSeqDispExt: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6437aa6f_5a3c_4de9_8a16_53d9c4ad326f);
pub const CODECAPI_AVEncMPVGenerateHeaderSeqExt: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd5e78611_082d_4e6b_98af_0f51ab139222);
pub const CODECAPI_AVEncMPVGenerateHeaderSeqScaleExt: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0722d62f_dd59_4a86_9cd5_644f8e2653d8);
pub const CODECAPI_AVEncMPVIntraDCPrecision: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa0116151_cbc8_4af3_97dc_d00cceb82d79);
pub const CODECAPI_AVEncMPVIntraVLCTable: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa2b83ff5_1a99_405a_af95_c5997d558d3a);
pub const CODECAPI_AVEncMPVLevel: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6ee40c40_a60c_41ef_8f50_37c2249e2cb3);
pub const CODECAPI_AVEncMPVProfile: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdabb534a_1d99_4284_975a_d90e2239baa1);
pub const CODECAPI_AVEncMPVQScaleType: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2b79ebb7_f484_4af7_bb58_a2a188c5cbbe);
pub const CODECAPI_AVEncMPVQuantMatrixChromaIntra: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9eb9ecd4_018d_4ffd_8f2d_39e49f07b17a);
pub const CODECAPI_AVEncMPVQuantMatrixChromaNonIntra: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1415b6b1_362a_4338_ba9a_1ef58703c05b);
pub const CODECAPI_AVEncMPVQuantMatrixIntra: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9bea04f3_6621_442c_8ba1_3ac378979698);
pub const CODECAPI_AVEncMPVQuantMatrixNonIntra: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x87f441d8_0997_4beb_a08e_8573d409cf75);
pub const CODECAPI_AVEncMPVScanPattern: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7f8a478e_7bbb_4ae2_b2fc_96d17fc4a2d6);
pub const CODECAPI_AVEncMPVSceneDetection: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x552799f1_db4c_405b_8a3a_c93f2d0674dc);
pub const CODECAPI_AVEncMPVUseConcealmentMotionVectors: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xec770cf3_6908_4b4b_aa30_7fb986214fea);
pub const CODECAPI_AVEncMaxFrameRate: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb98e1b31_19fa_4d4f_9931_d6a5b8aab93c);
pub const CODECAPI_AVEncMuxOutputStreamType: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xcedd9e8f_34d3_44db_a1d8_f81520254f3e);
pub const CODECAPI_AVEncNoInputCopy: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd2b46a2a_e8ee_4ec5_869e_449b6c62c81a);
pub const CODECAPI_AVEncNumWorkerThreads: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb0c8bf60_16f7_4951_a30b_1db1609293d6);
pub const CODECAPI_AVEncProgressiveUpdateTime: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x649faf66_afc6_4828_8fdc_0771cd9ab17d);
pub const CODECAPI_AVEncSliceControlMode: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe9e782ef_5f18_44c9_a90b_e9c3c2c17b0b);
pub const CODECAPI_AVEncSliceControlSize: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x92f51df3_07a5_4172_aefe_c69ca3b60e35);
pub const CODECAPI_AVEncSliceGenerationMode: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8a6bc67f_9497_4286_b46b_02db8d60edbc);
pub const CODECAPI_AVEncStatAudioAverageBPS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xca6724db_7059_4351_8b43_f82198826a14);
pub const CODECAPI_AVEncStatAudioAveragePCMValue: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x979272f8_d17f_4e32_bb73_4e731c68ba2d);
pub const CODECAPI_AVEncStatAudioPeakPCMValue: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdce7fd34_dc00_4c16_821b_35d9eb00fb1a);
pub const CODECAPI_AVEncStatAverageBPS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xca6724db_7059_4351_8b43_f82198826a14);
pub const CODECAPI_AVEncStatCommonCompletedPasses: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3e5de533_9df7_438c_854f_9f7dd3683d34);
pub const CODECAPI_AVEncStatHardwareBandwidthUtilitization: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0124ba9b_dc41_4826_b45f_18ac01b3d5a8);
pub const CODECAPI_AVEncStatHardwareProcessorUtilitization: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x995dc027_cb95_49e6_b91b_5967753cdcb8);
pub const CODECAPI_AVEncStatMPVSkippedEmptyFrames: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x32195fd3_590d_4812_a7ed_6d639a1f9711);
pub const CODECAPI_AVEncStatVideoCodedFrames: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd47f8d61_6f5a_4a26_bb9f_cd9518462bcd);
pub const CODECAPI_AVEncStatVideoOutputFrameRate: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbe747849_9ab4_4a63_98fe_f143f04f8ee9);
pub const CODECAPI_AVEncStatVideoTotalFrames: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfdaa9916_119a_4222_9ad6_3f7cab99cc8b);
pub const CODECAPI_AVEncStatWMVCBAvg: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6aa6229f_d602_4b9d_b68c_c1ad78884bef);
pub const CODECAPI_AVEncStatWMVCBMax: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe976bef8_00fe_44b4_b625_8f238bc03499);
pub const CODECAPI_AVEncStatWMVDecoderComplexityProfile: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x89e69fc3_0f9b_436c_974a_df821227c90d);
pub const CODECAPI_AVEncVideoCBRMotionTradeoff: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0d49451e_18d5_4367_a4ef_3240df1693c4);
pub const CODECAPI_AVEncVideoCTBSize: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd47db8b2_e73b_4cb9_8c3e_bd877d06d77b);
pub const CODECAPI_AVEncVideoCodedVideoAccessUnitSize: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb4b10c15_14a7_4ce8_b173_dc90a0b4fcdb);
pub const CODECAPI_AVEncVideoContentType: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x66117aca_eb77_459d_930c_a48d9d0683fc);
pub const CODECAPI_AVEncVideoDefaultUpperFieldDominant: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x810167c4_0bc1_47ca_8fc2_57055a1474a5);
pub const CODECAPI_AVEncVideoDirtyRectEnabled: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8acb8fdd_5e0c_4c66_8729_b8f629ab04fb);
pub const CODECAPI_AVEncVideoDisplayDimension: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xde053668_f4ec_47a9_86d0_836770f0c1d5);
pub const CODECAPI_AVEncVideoEncodeDimension: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1074df28_7e0f_47a4_a453_cdd73870f5ce);
pub const CODECAPI_AVEncVideoEncodeFrameTypeQP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xaa70b610_e03f_450c_ad07_07314e639ce7);
pub const CODECAPI_AVEncVideoEncodeOffsetOrigin: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6bc098fe_a71a_4454_852e_4d2ddeb2cd24);
pub const CODECAPI_AVEncVideoEncodeQP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2cb5696b_23fb_4ce1_a0f9_ef5b90fd55ca);
pub const CODECAPI_AVEncVideoFieldSwap: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfefd7569_4e0a_49f2_9f2b_360ea48c19a2);
pub const CODECAPI_AVEncVideoForceKeyFrame: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x398c1b98_8353_475a_9ef2_8f265d260345);
pub const CODECAPI_AVEncVideoForceSourceScanType: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1ef2065f_058a_4765_a4fc_8a864c103012);
pub const CODECAPI_AVEncVideoGradualIntraRefresh: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8f347dee_cb0d_49ba_b462_db6927ee2101);
pub const CODECAPI_AVEncVideoHeaderDropFrame: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6ed9e124_7925_43fe_971b_e019f62222b4);
pub const CODECAPI_AVEncVideoHeaderFrames: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xafd5f567_5c1b_4adc_bdaf_735610381436);
pub const CODECAPI_AVEncVideoHeaderHours: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2acc7702_e2da_4158_bf9b_88880129d740);
pub const CODECAPI_AVEncVideoHeaderMinutes: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdc1a99ce_0307_408b_880b_b8348ee8ca7f);
pub const CODECAPI_AVEncVideoHeaderSeconds: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4a2e1a05_a780_4f58_8120_9a449d69656b);
pub const CODECAPI_AVEncVideoInputChromaResolution: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbb0cec33_16f1_47b0_8a88_37815bee1739);
pub const CODECAPI_AVEncVideoInputChromaSubsampling: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa8e73a39_4435_4ec3_a6ea_98300f4b36f7);
pub const CODECAPI_AVEncVideoInputColorLighting: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x46a99549_0015_4a45_9c30_1d5cfa258316);
pub const CODECAPI_AVEncVideoInputColorNominalRange: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x16cf25c6_a2a6_48e9_ae80_21aec41d427e);
pub const CODECAPI_AVEncVideoInputColorPrimaries: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc24d783f_7ce6_4278_90ab_28a4f1e5f86c);
pub const CODECAPI_AVEncVideoInputColorTransferFunction: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8c056111_a9c3_4b08_a0a0_ce13f8a27c75);
pub const CODECAPI_AVEncVideoInputColorTransferMatrix: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x52ed68b9_72d5_4089_958d_f5405d55081c);
pub const CODECAPI_AVEncVideoInstantTemporalUpSwitching: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa3308307_0d96_4ba4_b1f0_b91a5e49df10);
pub const CODECAPI_AVEncVideoIntraLayerPrediction: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd3af46b8_bf47_44bb_a283_69f0b0228ff9);
pub const CODECAPI_AVEncVideoInverseTelecineEnable: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2ea9098b_e76d_4ccd_a030_d3b889c1b64c);
pub const CODECAPI_AVEncVideoInverseTelecineThreshold: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x40247d84_e895_497f_b44c_b74560acfe27);
pub const CODECAPI_AVEncVideoLTRBufferControl: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa4a0e93d_4cbc_444c_89f4_826d310e92a7);
pub const CODECAPI_AVEncVideoMarkLTRFrame: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe42f4748_a06d_4ef9_8cea_3d05fde3bd3b);
pub const CODECAPI_AVEncVideoMaxCTBSize: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x822363ff_cec8_43e5_92fd_e097488485e9);
pub const CODECAPI_AVEncVideoMaxKeyframeDistance: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2987123a_ba93_4704_b489_ec1e5f25292c);
pub const CODECAPI_AVEncVideoMaxNumRefFrame: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x964829ed_94f9_43b4_b74d_ef40944b69a0);
pub const CODECAPI_AVEncVideoMaxQP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3daf6f66_a6a7_45e0_a8e5_f2743f46a3a2);
pub const CODECAPI_AVEncVideoMaxTemporalLayers: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9c668cfe_08e1_424a_934e_b764b064802a);
pub const CODECAPI_AVEncVideoMeanAbsoluteDifference: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe5c0c10f_81a4_422d_8c3f_b474a4581336);
pub const CODECAPI_AVEncVideoMinQP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0ee22c6a_a37c_4568_b5f1_9d4c2b3ab886);
pub const CODECAPI_AVEncVideoNoOfFieldsToEncode: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x61e4bbe2_4ee0_40e7_80ab_51ddeebe6291);
pub const CODECAPI_AVEncVideoNoOfFieldsToSkip: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa97e1240_1427_4c16_a7f7_3dcfd8ba4cc5);
pub const CODECAPI_AVEncVideoNumGOPsPerIDR: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x83bc5bdb_5b89_4521_8f66_33151c373176);
pub const CODECAPI_AVEncVideoOutputChromaResolution: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6097b4c9_7c1d_4e64_bfcc_9e9765318ae7);
pub const CODECAPI_AVEncVideoOutputChromaSubsampling: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfa561c6c_7d17_44f0_83c9_32ed12e96343);
pub const CODECAPI_AVEncVideoOutputColorLighting: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0e5aaac6_ace6_4c5c_998e_1a8c9c6c0f89);
pub const CODECAPI_AVEncVideoOutputColorNominalRange: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x972835ed_87b5_4e95_9500_c73958566e54);
pub const CODECAPI_AVEncVideoOutputColorPrimaries: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbe95907c_9d04_4921_8985_a6d6d87d1a6c);
pub const CODECAPI_AVEncVideoOutputColorTransferFunction: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4a7f884a_ea11_460d_bf57_b88bc75900de);
pub const CODECAPI_AVEncVideoOutputColorTransferMatrix: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa9b90444_af40_4310_8fbe_ed6d933f892b);
pub const CODECAPI_AVEncVideoOutputFrameRate: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xea85e7c3_9567_4d99_87c4_02c1c278ca7c);
pub const CODECAPI_AVEncVideoOutputFrameRateConversion: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8c068bf4_369a_4ba3_82fd_b2518fb3396e);
pub const CODECAPI_AVEncVideoOutputScanType: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x460b5576_842e_49ab_a62d_b36f7312c9db);
pub const CODECAPI_AVEncVideoPixelAspectRatio: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cdc718f_b3e9_4eb6_a57f_cf1f1b321b87);
pub const CODECAPI_AVEncVideoROIEnabled: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd74f7f18_44dd_4b85_aba3_05d9f42a8280);
pub const CODECAPI_AVEncVideoRateControlParams: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x87d43767_7645_44ec_b438_d3322fbca29f);
pub const CODECAPI_AVEncVideoSelectLayer: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xeb1084f5_6aaa_4914_bb2f_6147227f12e7);
pub const CODECAPI_AVEncVideoSourceFilmContent: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1791c64b_ccfc_4827_a0ed_2557793b2b1c);
pub const CODECAPI_AVEncVideoSourceIsBW: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x42ffc49b_1812_4fdc_8d24_7054c521e6eb);
pub const CODECAPI_AVEncVideoSupportedControls: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd3f40fdd_77b9_473d_8196_061259e69cff);
pub const CODECAPI_AVEncVideoTemporalLayerCount: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x19caebff_b74d_4cfd_8c27_c2f9d97d5f52);
pub const CODECAPI_AVEncVideoUsage: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1f636849_5dc1_49f1_b1d8_ce3cf62ea385);
pub const CODECAPI_AVEncVideoUseLTRFrame: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00752db8_55f7_4f80_895b_27639195f2ad);
pub const CODECAPI_AVEncWMVDecoderComplexity: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf32c0dab_f3cb_4217_b79f_8762768b5f67);
pub const CODECAPI_AVEncWMVInterlacedEncoding: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe3d00f8a_c6f5_4e14_a588_0ec87a726f9b);
pub const CODECAPI_AVEncWMVKeyFrameBufferLevelMarker: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51ff1115_33ac_426c_a1b1_09321bdf96b4);
pub const CODECAPI_AVEncWMVKeyFrameDistance: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5569055e_e268_4771_b83e_9555ea28aed3);
pub const CODECAPI_AVEncWMVProduceDummyFrames: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd669d001_183c_42e3_a3ca_2f4586d2396c);
pub const CODECAPI_AVLowLatencyMode: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9c27891a_ed7a_40e1_88e8_b22727a024ee);
pub const CODECAPI_AVPriorityControl: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x54ba3dc8_bdde_4329_b187_2018bc5c2ba1);
pub const CODECAPI_AVRealtimeControl: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6f440632_c4ad_4bf7_9e52_456942b454b0);
pub const CODECAPI_AVScenarioInfo: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb28a6e64_3ff9_446a_8a4b_0d7a53413236);
pub const CODECAPI_GUID_AVDecAudioInputAAC: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x97df7828_b94a_47e2_a4bc_51194db22a4d);
pub const CODECAPI_GUID_AVDecAudioInputDTS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x600bc0ca_6a1f_4e91_b241_1bbeb1cb19e0);
pub const CODECAPI_GUID_AVDecAudioInputDolby: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8e4228a0_f000_4e0b_8f54_ab8d24ad61a2);
pub const CODECAPI_GUID_AVDecAudioInputDolbyDigitalPlus: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0803e185_8f5d_47f5_9908_19a5bbc9fe34);
pub const CODECAPI_GUID_AVDecAudioInputHEAAC: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x16efb4aa_330e_4f5c_98a8_cf6ac55cbe60);
pub const CODECAPI_GUID_AVDecAudioInputMPEG: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x91106f36_02c5_4f75_9719_3b7abf75e1f6);
pub const CODECAPI_GUID_AVDecAudioInputPCM: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf2421da5_bbb4_4cd5_a996_933c6b5d1347);
pub const CODECAPI_GUID_AVDecAudioInputWMA: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc95e8dcf_4058_4204_8c42_cb24d91e4b9b);
pub const CODECAPI_GUID_AVDecAudioInputWMAPro: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0128b7c7_da72_4fe3_bef8_5c52e3557704);
pub const CODECAPI_GUID_AVDecAudioOutputFormat_PCM: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x696e1d31_548f_4036_825f_7026c60011bd);
pub const CODECAPI_GUID_AVDecAudioOutputFormat_PCM_Headphones: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x696e1d34_548f_4036_825f_7026c60011bd);
pub const CODECAPI_GUID_AVDecAudioOutputFormat_PCM_Stereo_Auto: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x696e1d35_548f_4036_825f_7026c60011bd);
pub const CODECAPI_GUID_AVDecAudioOutputFormat_PCM_Stereo_MatrixEncoded: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x696e1d30_548f_4036_825f_7026c60011bd);
pub const CODECAPI_GUID_AVDecAudioOutputFormat_SPDIF_Bitstream: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x696e1d33_548f_4036_825f_7026c60011bd);
pub const CODECAPI_GUID_AVDecAudioOutputFormat_SPDIF_PCM: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x696e1d32_548f_4036_825f_7026c60011bd);
pub const CODECAPI_GUID_AVEncCommonFormatATSC: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8d7b897c_a019_4670_aa76_2edcac7ac296);
pub const CODECAPI_GUID_AVEncCommonFormatDVB: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x71830d8f_6c33_430d_844b_c2705baae6db);
pub const CODECAPI_GUID_AVEncCommonFormatDVD_DashVR: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe55199d6_044c_4dae_a488_531ed306235b);
pub const CODECAPI_GUID_AVEncCommonFormatDVD_PlusVR: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe74c6f2e_ec37_478d_9af4_a5e135b6271c);
pub const CODECAPI_GUID_AVEncCommonFormatDVD_V: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xcc9598c4_e7fe_451d_b1ca_761bc840b7f3);
pub const CODECAPI_GUID_AVEncCommonFormatHighMAT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1eabe760_fb2b_4928_90d1_78db88eee889);
pub const CODECAPI_GUID_AVEncCommonFormatHighMPV: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa2d25db8_b8f9_42c2_8bc7_0b93cf604788);
pub const CODECAPI_GUID_AVEncCommonFormatMP3: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x349733cd_eb08_4dc2_8197_e49835ef828b);
pub const CODECAPI_GUID_AVEncCommonFormatSVCD: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51d85818_8220_448c_8066_d69bed16c9ad);
pub const CODECAPI_GUID_AVEncCommonFormatUnSpecified: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xaf46a35a_6024_4525_a48a_094b97f5b3c2);
pub const CODECAPI_GUID_AVEncCommonFormatVCD: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x95035bf7_9d90_40ff_ad5c_5cf8cf71ca1d);
pub const CODECAPI_GUID_AVEncDTS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x45fbcaa2_5e6e_4ab0_8893_5903bee93acf);
pub const CODECAPI_GUID_AVEncDTSHD: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2052e630_469d_4bfb_80ca_1d656e7e918f);
pub const CODECAPI_GUID_AVEncDV: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x09b769c7_3329_44fb_8954_fa30937d3d5a);
pub const CODECAPI_GUID_AVEncDolbyDigitalConsumer: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc1a7bf6c_0059_4bfa_94ef_ef747a768d52);
pub const CODECAPI_GUID_AVEncDolbyDigitalPlus: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x698d1b80_f7dd_415c_971c_42492a2056c6);
pub const CODECAPI_GUID_AVEncDolbyDigitalPro: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf5be76cc_0ff8_40eb_9cb1_bba94004d44f);
pub const CODECAPI_GUID_AVEncH264Video: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x95044eab_31b3_47de_8e75_38a42bb03e28);
pub const CODECAPI_GUID_AVEncMLP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x05f73e29_f0d1_431e_a41c_a47432ec5a66);
pub const CODECAPI_GUID_AVEncMPEG1Audio: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd4dd1362_cd4a_4cd6_8138_b94db4542b04);
pub const CODECAPI_GUID_AVEncMPEG1Video: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc8dafefe_da1e_4774_b27d_11830c16b1fe);
pub const CODECAPI_GUID_AVEncMPEG2Audio: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xee4cbb1f_9c3f_4770_92b5_fcb7c2a8d381);
pub const CODECAPI_GUID_AVEncMPEG2Video: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x046dc19a_6677_4aaa_a31d_c1ab716f4560);
pub const CODECAPI_GUID_AVEncPCM: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x844be7f4_26cf_4779_b386_cc05d187990c);
pub const CODECAPI_GUID_AVEncSDDS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1dc1b82f_11c8_4c71_b7b6_ee3eb9bc2b94);
pub const CODECAPI_GUID_AVEncWMALossless: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x55ca7265_23d8_4761_9031_b74fbe12f4c1);
pub const CODECAPI_GUID_AVEncWMAPro: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1955f90c_33f7_4a68_ab81_53f5657125c4);
pub const CODECAPI_GUID_AVEncWMAVoice: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x13ed18cb_50e8_4276_a288_a6aa228382d9);
pub const CODECAPI_GUID_AVEncWMV: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4e0fef9b_1d43_41bd_b8bd_4d7bf7457a2a);
pub const CODECAPI_GUID_AVEndMPEG4Video: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdd37b12a_9503_4f8b_b8d0_324a00c0a1cf);
pub const CODECAPI_GetOPMContext: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2f036c05_4c14_4689_8839_294c6d73e053);
pub const CODECAPI_SetHDCPManagerContext: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6d2d1fc8_3dc9_47eb_a1a2_471c80cd60d0);
pub const CODECAPI_VideoEncoderDisplayContentType: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x79b90b27_f4b1_42dc_9dd7_cdaf8135c400);
pub const COPP_ProtectionType_ACP: i32 = 2i32;
pub const COPP_ProtectionType_CGMSA: i32 = 4i32;
pub const COPP_ProtectionType_HDCP: i32 = 1i32;
pub const COPP_ProtectionType_Mask: i32 = -2147483641i32;
pub const COPP_ProtectionType_None: i32 = 0i32;
pub const COPP_ProtectionType_Reserved: i32 = 2147483640i32;
pub const COPP_ProtectionType_Unknown: i32 = -2147483648i32;
pub const CPK_DS_AC3Decoder: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6c9c69d6_0ffc_4481_afdb_cdf1c79c6f3e);
pub const CPK_DS_MPEG2Decoder: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9910c5cd_95c9_4e06_865a_efa1c8016bf4);
pub const CResamplerMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf447b69e_1884_4a7e_8055_346f74d6edb3);
pub const CResizerDMO: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1ea1ea14_48f4_4054_ad1a_e8aee10ac805);
pub const CResizerMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd3ec8b8b_7728_4fd8_9fe0_7b67d19f73a3);
pub const CShotDetectorDmo: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x56aefacd_110c_4397_9292_b0a0c61b6750);
pub const CSmpteTransformsDmo: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbde6388b_da25_485d_ba7f_fabc28b20318);
pub const CThumbnailGeneratorDmo: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x559c6bad_1ea8_4963_a087_8a6810f9218b);
pub const CTocGeneratorDmo: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4dda1941_77a0_4fb1_a518_e2185041d70c);
pub const CVodafoneAACCCDecMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7e76bf7f_c993_4e26_8fab_470a70c0d59c);
pub const CVodafoneAACDecMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7f36f942_dcf3_4d82_9289_5b1820278f7c);
pub const CWMADecMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2eeb4adf_4578_4d10_bca7_bb955f56320a);
pub const CWMAEncMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x70f598e9_f4ab_495a_99e2_a7c4d3d89abf);
pub const CWMATransMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xedcad9cb_3127_40df_b527_0152ccb3f6f5);
pub const CWMAudioAEC: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x745057c7_f353_4f2d_a7ee_58434477730e);
pub const CWMAudioCAPXGFXAPO: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x13ab3ebd_137e_4903_9d89_60be8277fd17);
pub const CWMAudioCAPXLFXAPO: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc9453e73_8c5c_4463_9984_af8bab2f5447);
pub const CWMAudioGFXAPO: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x637c490d_eee3_4c0a_973f_371958802da2);
pub const CWMAudioLFXAPO: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x62dc1a93_ae24_464c_a43e_452f824c4250);
pub const CWMAudioSpdTxDMO: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5210f8e4_b0bb_47c3_a8d9_7b2282cc79ed);
pub const CWMSPDecMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x874131cb_4ecc_443b_8948_746b89595d20);
pub const CWMSPEncMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x67841b03_c689_4188_ad3f_4c9ebeec710b);
pub const CWMSPEncMediaObject2: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1f1f4e1a_2252_4063_84bb_eee75f8856d5);
pub const CWMTDecMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf9dbc64e_2dd0_45dd_9b52_66642ef94431);
pub const CWMTEncMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x60b67652_e46b_4e44_8609_f74bffdc083c);
pub const CWMV9EncMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd23b90d0_144f_46bd_841d_59e4eb19dc59);
pub const CWMVDecMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x82d353df_90bd_4382_8bc2_3f6192b76e34);
pub const CWMVEncMediaObject2: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x96b57cdd_8966_410c_bb1f_c97eea765c04);
pub const CWMVXEncMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7e320092_596a_41b2_bbeb_175d10504eb6);
pub const CWVC1DecMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc9bfbccf_e60e_4588_a3df_5a03b1fd9585);
pub const CWVC1EncMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x44653d0d_8cca_41e7_baca_884337b747ac);
pub const CZuneAACCCDecMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa74e98f2_52d6_4b4e_885b_e0a6ca4f187a);
pub const CZuneM4S2DecMediaObject: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc56fc25c_0fc6_404a_9503_b10bf51a8ab9);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct CodecAPIEventData {
pub guid: ::windows::core::GUID,
pub dataLength: u32,
pub reserved: [u32; 3],
}
impl CodecAPIEventData {}
impl ::core::default::Default for CodecAPIEventData {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for CodecAPIEventData {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("CodecAPIEventData").field("guid", &self.guid).field("dataLength", &self.dataLength).field("reserved", &self.reserved).finish()
}
}
impl ::core::cmp::PartialEq for CodecAPIEventData {
fn eq(&self, other: &Self) -> bool {
self.guid == other.guid && self.dataLength == other.dataLength && self.reserved == other.reserved
}
}
impl ::core::cmp::Eq for CodecAPIEventData {}
unsafe impl ::windows::core::Abi for CodecAPIEventData {
type Abi = Self;
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
#[inline]
pub unsafe fn CreateNamedPropertyStore() -> ::windows::core::Result<super::super::UI::Shell::PropertiesSystem::INamedPropertyStore> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn CreateNamedPropertyStore(ppstore: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <super::super::UI::Shell::PropertiesSystem::INamedPropertyStore as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
CreateNamedPropertyStore(&mut result__).from_abi::<super::super::UI::Shell::PropertiesSystem::INamedPropertyStore>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
#[inline]
pub unsafe fn CreatePropertyStore() -> ::windows::core::Result<super::super::UI::Shell::PropertiesSystem::IPropertyStore> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn CreatePropertyStore(ppstore: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <super::super::UI::Shell::PropertiesSystem::IPropertyStore as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
CreatePropertyStore(&mut result__).from_abi::<super::super::UI::Shell::PropertiesSystem::IPropertyStore>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_BITSTREAM_ENCRYPTION_TYPE(pub i32);
pub const D3D12_BITSTREAM_ENCRYPTION_TYPE_NONE: D3D12_BITSTREAM_ENCRYPTION_TYPE = D3D12_BITSTREAM_ENCRYPTION_TYPE(0i32);
impl ::core::convert::From<i32> for D3D12_BITSTREAM_ENCRYPTION_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_BITSTREAM_ENCRYPTION_TYPE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct D3D12_FEATURE_DATA_VIDEO_ARCHITECTURE {
pub IOCoherent: super::super::Foundation::BOOL,
}
#[cfg(feature = "Win32_Foundation")]
impl D3D12_FEATURE_DATA_VIDEO_ARCHITECTURE {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_ARCHITECTURE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_ARCHITECTURE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_ARCHITECTURE").field("IOCoherent", &self.IOCoherent).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_ARCHITECTURE {
fn eq(&self, other: &Self) -> bool {
self.IOCoherent == other.IOCoherent
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_ARCHITECTURE {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_ARCHITECTURE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
pub struct D3D12_FEATURE_DATA_VIDEO_DECODER_HEAP_SIZE {
pub VideoDecoderHeapDesc: D3D12_VIDEO_DECODER_HEAP_DESC,
pub MemoryPoolL0Size: u64,
pub MemoryPoolL1Size: u64,
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl D3D12_FEATURE_DATA_VIDEO_DECODER_HEAP_SIZE {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_DECODER_HEAP_SIZE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_DECODER_HEAP_SIZE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_DECODER_HEAP_SIZE").field("VideoDecoderHeapDesc", &self.VideoDecoderHeapDesc).field("MemoryPoolL0Size", &self.MemoryPoolL0Size).field("MemoryPoolL1Size", &self.MemoryPoolL1Size).finish()
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_DECODER_HEAP_SIZE {
fn eq(&self, other: &Self) -> bool {
self.VideoDecoderHeapDesc == other.VideoDecoderHeapDesc && self.MemoryPoolL0Size == other.MemoryPoolL0Size && self.MemoryPoolL1Size == other.MemoryPoolL1Size
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_DECODER_HEAP_SIZE {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_DECODER_HEAP_SIZE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
pub struct D3D12_FEATURE_DATA_VIDEO_DECODER_HEAP_SIZE1 {
pub VideoDecoderHeapDesc: D3D12_VIDEO_DECODER_HEAP_DESC,
pub Protected: super::super::Foundation::BOOL,
pub MemoryPoolL0Size: u64,
pub MemoryPoolL1Size: u64,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl D3D12_FEATURE_DATA_VIDEO_DECODER_HEAP_SIZE1 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_DECODER_HEAP_SIZE1 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_DECODER_HEAP_SIZE1 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_DECODER_HEAP_SIZE1").field("VideoDecoderHeapDesc", &self.VideoDecoderHeapDesc).field("Protected", &self.Protected).field("MemoryPoolL0Size", &self.MemoryPoolL0Size).field("MemoryPoolL1Size", &self.MemoryPoolL1Size).finish()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_DECODER_HEAP_SIZE1 {
fn eq(&self, other: &Self) -> bool {
self.VideoDecoderHeapDesc == other.VideoDecoderHeapDesc && self.Protected == other.Protected && self.MemoryPoolL0Size == other.MemoryPoolL0Size && self.MemoryPoolL1Size == other.MemoryPoolL1Size
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_DECODER_HEAP_SIZE1 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_DECODER_HEAP_SIZE1 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
pub struct D3D12_FEATURE_DATA_VIDEO_DECODE_CONVERSION_SUPPORT {
pub NodeIndex: u32,
pub Configuration: D3D12_VIDEO_DECODE_CONFIGURATION,
pub DecodeSample: D3D12_VIDEO_SAMPLE,
pub OutputFormat: D3D12_VIDEO_FORMAT,
pub FrameRate: super::super::Graphics::Dxgi::Common::DXGI_RATIONAL,
pub BitRate: u32,
pub SupportFlags: D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS,
pub ScaleSupport: D3D12_VIDEO_SCALE_SUPPORT,
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl D3D12_FEATURE_DATA_VIDEO_DECODE_CONVERSION_SUPPORT {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_DECODE_CONVERSION_SUPPORT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_DECODE_CONVERSION_SUPPORT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_DECODE_CONVERSION_SUPPORT")
.field("NodeIndex", &self.NodeIndex)
.field("Configuration", &self.Configuration)
.field("DecodeSample", &self.DecodeSample)
.field("OutputFormat", &self.OutputFormat)
.field("FrameRate", &self.FrameRate)
.field("BitRate", &self.BitRate)
.field("SupportFlags", &self.SupportFlags)
.field("ScaleSupport", &self.ScaleSupport)
.finish()
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_DECODE_CONVERSION_SUPPORT {
fn eq(&self, other: &Self) -> bool {
self.NodeIndex == other.NodeIndex && self.Configuration == other.Configuration && self.DecodeSample == other.DecodeSample && self.OutputFormat == other.OutputFormat && self.FrameRate == other.FrameRate && self.BitRate == other.BitRate && self.SupportFlags == other.SupportFlags && self.ScaleSupport == other.ScaleSupport
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_DECODE_CONVERSION_SUPPORT {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_DECODE_CONVERSION_SUPPORT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
pub struct D3D12_FEATURE_DATA_VIDEO_DECODE_FORMATS {
pub NodeIndex: u32,
pub Configuration: D3D12_VIDEO_DECODE_CONFIGURATION,
pub FormatCount: u32,
pub pOutputFormats: *mut super::super::Graphics::Dxgi::Common::DXGI_FORMAT,
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl D3D12_FEATURE_DATA_VIDEO_DECODE_FORMATS {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_DECODE_FORMATS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_DECODE_FORMATS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_DECODE_FORMATS").field("NodeIndex", &self.NodeIndex).field("Configuration", &self.Configuration).field("FormatCount", &self.FormatCount).field("pOutputFormats", &self.pOutputFormats).finish()
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_DECODE_FORMATS {
fn eq(&self, other: &Self) -> bool {
self.NodeIndex == other.NodeIndex && self.Configuration == other.Configuration && self.FormatCount == other.FormatCount && self.pOutputFormats == other.pOutputFormats
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_DECODE_FORMATS {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_DECODE_FORMATS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_FEATURE_DATA_VIDEO_DECODE_FORMAT_COUNT {
pub NodeIndex: u32,
pub Configuration: D3D12_VIDEO_DECODE_CONFIGURATION,
pub FormatCount: u32,
}
impl D3D12_FEATURE_DATA_VIDEO_DECODE_FORMAT_COUNT {}
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_DECODE_FORMAT_COUNT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_DECODE_FORMAT_COUNT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_DECODE_FORMAT_COUNT").field("NodeIndex", &self.NodeIndex).field("Configuration", &self.Configuration).field("FormatCount", &self.FormatCount).finish()
}
}
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_DECODE_FORMAT_COUNT {
fn eq(&self, other: &Self) -> bool {
self.NodeIndex == other.NodeIndex && self.Configuration == other.Configuration && self.FormatCount == other.FormatCount
}
}
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_DECODE_FORMAT_COUNT {}
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_DECODE_FORMAT_COUNT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
pub struct D3D12_FEATURE_DATA_VIDEO_DECODE_HISTOGRAM {
pub NodeIndex: u32,
pub DecodeProfile: ::windows::core::GUID,
pub Width: u32,
pub Height: u32,
pub DecodeFormat: super::super::Graphics::Dxgi::Common::DXGI_FORMAT,
pub Components: D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS,
pub BinCount: u32,
pub CounterBitDepth: u32,
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl D3D12_FEATURE_DATA_VIDEO_DECODE_HISTOGRAM {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_DECODE_HISTOGRAM {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_DECODE_HISTOGRAM {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_DECODE_HISTOGRAM")
.field("NodeIndex", &self.NodeIndex)
.field("DecodeProfile", &self.DecodeProfile)
.field("Width", &self.Width)
.field("Height", &self.Height)
.field("DecodeFormat", &self.DecodeFormat)
.field("Components", &self.Components)
.field("BinCount", &self.BinCount)
.field("CounterBitDepth", &self.CounterBitDepth)
.finish()
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_DECODE_HISTOGRAM {
fn eq(&self, other: &Self) -> bool {
self.NodeIndex == other.NodeIndex && self.DecodeProfile == other.DecodeProfile && self.Width == other.Width && self.Height == other.Height && self.DecodeFormat == other.DecodeFormat && self.Components == other.Components && self.BinCount == other.BinCount && self.CounterBitDepth == other.CounterBitDepth
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_DECODE_HISTOGRAM {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_DECODE_HISTOGRAM {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_FEATURE_DATA_VIDEO_DECODE_PROFILES {
pub NodeIndex: u32,
pub ProfileCount: u32,
pub pProfiles: *mut ::windows::core::GUID,
}
impl D3D12_FEATURE_DATA_VIDEO_DECODE_PROFILES {}
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_DECODE_PROFILES {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_DECODE_PROFILES {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_DECODE_PROFILES").field("NodeIndex", &self.NodeIndex).field("ProfileCount", &self.ProfileCount).field("pProfiles", &self.pProfiles).finish()
}
}
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_DECODE_PROFILES {
fn eq(&self, other: &Self) -> bool {
self.NodeIndex == other.NodeIndex && self.ProfileCount == other.ProfileCount && self.pProfiles == other.pProfiles
}
}
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_DECODE_PROFILES {}
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_DECODE_PROFILES {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_FEATURE_DATA_VIDEO_DECODE_PROFILE_COUNT {
pub NodeIndex: u32,
pub ProfileCount: u32,
}
impl D3D12_FEATURE_DATA_VIDEO_DECODE_PROFILE_COUNT {}
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_DECODE_PROFILE_COUNT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_DECODE_PROFILE_COUNT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_DECODE_PROFILE_COUNT").field("NodeIndex", &self.NodeIndex).field("ProfileCount", &self.ProfileCount).finish()
}
}
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_DECODE_PROFILE_COUNT {
fn eq(&self, other: &Self) -> bool {
self.NodeIndex == other.NodeIndex && self.ProfileCount == other.ProfileCount
}
}
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_DECODE_PROFILE_COUNT {}
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_DECODE_PROFILE_COUNT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_FEATURE_DATA_VIDEO_DECODE_PROTECTED_RESOURCES {
pub NodeIndex: u32,
pub Configuration: D3D12_VIDEO_DECODE_CONFIGURATION,
pub SupportFlags: D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS,
}
impl D3D12_FEATURE_DATA_VIDEO_DECODE_PROTECTED_RESOURCES {}
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_DECODE_PROTECTED_RESOURCES {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_DECODE_PROTECTED_RESOURCES {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_DECODE_PROTECTED_RESOURCES").field("NodeIndex", &self.NodeIndex).field("Configuration", &self.Configuration).field("SupportFlags", &self.SupportFlags).finish()
}
}
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_DECODE_PROTECTED_RESOURCES {
fn eq(&self, other: &Self) -> bool {
self.NodeIndex == other.NodeIndex && self.Configuration == other.Configuration && self.SupportFlags == other.SupportFlags
}
}
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_DECODE_PROTECTED_RESOURCES {}
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_DECODE_PROTECTED_RESOURCES {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
pub struct D3D12_FEATURE_DATA_VIDEO_DECODE_SUPPORT {
pub NodeIndex: u32,
pub Configuration: D3D12_VIDEO_DECODE_CONFIGURATION,
pub Width: u32,
pub Height: u32,
pub DecodeFormat: super::super::Graphics::Dxgi::Common::DXGI_FORMAT,
pub FrameRate: super::super::Graphics::Dxgi::Common::DXGI_RATIONAL,
pub BitRate: u32,
pub SupportFlags: D3D12_VIDEO_DECODE_SUPPORT_FLAGS,
pub ConfigurationFlags: D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS,
pub DecodeTier: D3D12_VIDEO_DECODE_TIER,
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl D3D12_FEATURE_DATA_VIDEO_DECODE_SUPPORT {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_DECODE_SUPPORT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_DECODE_SUPPORT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_DECODE_SUPPORT")
.field("NodeIndex", &self.NodeIndex)
.field("Configuration", &self.Configuration)
.field("Width", &self.Width)
.field("Height", &self.Height)
.field("DecodeFormat", &self.DecodeFormat)
.field("FrameRate", &self.FrameRate)
.field("BitRate", &self.BitRate)
.field("SupportFlags", &self.SupportFlags)
.field("ConfigurationFlags", &self.ConfigurationFlags)
.field("DecodeTier", &self.DecodeTier)
.finish()
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_DECODE_SUPPORT {
fn eq(&self, other: &Self) -> bool {
self.NodeIndex == other.NodeIndex && self.Configuration == other.Configuration && self.Width == other.Width && self.Height == other.Height && self.DecodeFormat == other.DecodeFormat && self.FrameRate == other.FrameRate && self.BitRate == other.BitRate && self.SupportFlags == other.SupportFlags && self.ConfigurationFlags == other.ConfigurationFlags && self.DecodeTier == other.DecodeTier
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_DECODE_SUPPORT {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_DECODE_SUPPORT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC {
pub NodeIndex: u32,
pub Codec: D3D12_VIDEO_ENCODER_CODEC,
pub IsSupported: super::super::Foundation::BOOL,
}
#[cfg(feature = "Win32_Foundation")]
impl D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC").field("NodeIndex", &self.NodeIndex).field("Codec", &self.Codec).field("IsSupported", &self.IsSupported).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC {
fn eq(&self, other: &Self) -> bool {
self.NodeIndex == other.NodeIndex && self.Codec == other.Codec && self.IsSupported == other.IsSupported
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT {
pub NodeIndex: u32,
pub Codec: D3D12_VIDEO_ENCODER_CODEC,
pub Profile: D3D12_VIDEO_ENCODER_PROFILE_DESC,
pub IsSupported: super::super::Foundation::BOOL,
pub CodecSupportLimits: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT,
}
#[cfg(feature = "Win32_Foundation")]
impl D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT {
pub NodeIndex: u32,
pub Codec: D3D12_VIDEO_ENCODER_CODEC,
pub Profile: D3D12_VIDEO_ENCODER_PROFILE_DESC,
pub IsSupported: super::super::Foundation::BOOL,
pub PictureSupport: D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT,
}
#[cfg(feature = "Win32_Foundation")]
impl D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct D3D12_FEATURE_DATA_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE {
pub NodeIndex: u32,
pub Codec: D3D12_VIDEO_ENCODER_CODEC,
pub Profile: D3D12_VIDEO_ENCODER_PROFILE_DESC,
pub Level: D3D12_VIDEO_ENCODER_LEVEL_SETTING,
pub SubregionMode: D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE,
pub IsSupported: super::super::Foundation::BOOL,
}
#[cfg(feature = "Win32_Foundation")]
impl D3D12_FEATURE_DATA_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct D3D12_FEATURE_DATA_VIDEO_ENCODER_HEAP_SIZE {
pub HeapDesc: D3D12_VIDEO_ENCODER_HEAP_DESC,
pub IsSupported: super::super::Foundation::BOOL,
pub MemoryPoolL0Size: u64,
pub MemoryPoolL1Size: u64,
}
#[cfg(feature = "Win32_Foundation")]
impl D3D12_FEATURE_DATA_VIDEO_ENCODER_HEAP_SIZE {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_ENCODER_HEAP_SIZE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_ENCODER_HEAP_SIZE {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_ENCODER_HEAP_SIZE {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_ENCODER_HEAP_SIZE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
pub struct D3D12_FEATURE_DATA_VIDEO_ENCODER_INPUT_FORMAT {
pub NodeIndex: u32,
pub Codec: D3D12_VIDEO_ENCODER_CODEC,
pub Profile: D3D12_VIDEO_ENCODER_PROFILE_DESC,
pub Format: super::super::Graphics::Dxgi::Common::DXGI_FORMAT,
pub IsSupported: super::super::Foundation::BOOL,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl D3D12_FEATURE_DATA_VIDEO_ENCODER_INPUT_FORMAT {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_ENCODER_INPUT_FORMAT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_ENCODER_INPUT_FORMAT {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_ENCODER_INPUT_FORMAT {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_ENCODER_INPUT_FORMAT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct D3D12_FEATURE_DATA_VIDEO_ENCODER_INTRA_REFRESH_MODE {
pub NodeIndex: u32,
pub Codec: D3D12_VIDEO_ENCODER_CODEC,
pub Profile: D3D12_VIDEO_ENCODER_PROFILE_DESC,
pub Level: D3D12_VIDEO_ENCODER_LEVEL_SETTING,
pub IntraRefreshMode: D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE,
pub IsSupported: super::super::Foundation::BOOL,
}
#[cfg(feature = "Win32_Foundation")]
impl D3D12_FEATURE_DATA_VIDEO_ENCODER_INTRA_REFRESH_MODE {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_ENCODER_INTRA_REFRESH_MODE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_ENCODER_INTRA_REFRESH_MODE {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_ENCODER_INTRA_REFRESH_MODE {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_ENCODER_INTRA_REFRESH_MODE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct D3D12_FEATURE_DATA_VIDEO_ENCODER_OUTPUT_RESOLUTION {
pub NodeIndex: u32,
pub Codec: D3D12_VIDEO_ENCODER_CODEC,
pub ResolutionRatiosCount: u32,
pub IsSupported: super::super::Foundation::BOOL,
pub MinResolutionSupported: D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC,
pub MaxResolutionSupported: D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC,
pub ResolutionWidthMultipleRequirement: u32,
pub ResolutionHeightMultipleRequirement: u32,
pub pResolutionRatios: *mut D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_RATIO_DESC,
}
#[cfg(feature = "Win32_Foundation")]
impl D3D12_FEATURE_DATA_VIDEO_ENCODER_OUTPUT_RESOLUTION {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_ENCODER_OUTPUT_RESOLUTION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_ENCODER_OUTPUT_RESOLUTION {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_ENCODER_OUTPUT_RESOLUTION")
.field("NodeIndex", &self.NodeIndex)
.field("Codec", &self.Codec)
.field("ResolutionRatiosCount", &self.ResolutionRatiosCount)
.field("IsSupported", &self.IsSupported)
.field("MinResolutionSupported", &self.MinResolutionSupported)
.field("MaxResolutionSupported", &self.MaxResolutionSupported)
.field("ResolutionWidthMultipleRequirement", &self.ResolutionWidthMultipleRequirement)
.field("ResolutionHeightMultipleRequirement", &self.ResolutionHeightMultipleRequirement)
.field("pResolutionRatios", &self.pResolutionRatios)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_ENCODER_OUTPUT_RESOLUTION {
fn eq(&self, other: &Self) -> bool {
self.NodeIndex == other.NodeIndex
&& self.Codec == other.Codec
&& self.ResolutionRatiosCount == other.ResolutionRatiosCount
&& self.IsSupported == other.IsSupported
&& self.MinResolutionSupported == other.MinResolutionSupported
&& self.MaxResolutionSupported == other.MaxResolutionSupported
&& self.ResolutionWidthMultipleRequirement == other.ResolutionWidthMultipleRequirement
&& self.ResolutionHeightMultipleRequirement == other.ResolutionHeightMultipleRequirement
&& self.pResolutionRatios == other.pResolutionRatios
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_ENCODER_OUTPUT_RESOLUTION {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_ENCODER_OUTPUT_RESOLUTION {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_FEATURE_DATA_VIDEO_ENCODER_OUTPUT_RESOLUTION_RATIOS_COUNT {
pub NodeIndex: u32,
pub Codec: D3D12_VIDEO_ENCODER_CODEC,
pub ResolutionRatiosCount: u32,
}
impl D3D12_FEATURE_DATA_VIDEO_ENCODER_OUTPUT_RESOLUTION_RATIOS_COUNT {}
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_ENCODER_OUTPUT_RESOLUTION_RATIOS_COUNT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_ENCODER_OUTPUT_RESOLUTION_RATIOS_COUNT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_ENCODER_OUTPUT_RESOLUTION_RATIOS_COUNT").field("NodeIndex", &self.NodeIndex).field("Codec", &self.Codec).field("ResolutionRatiosCount", &self.ResolutionRatiosCount).finish()
}
}
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_ENCODER_OUTPUT_RESOLUTION_RATIOS_COUNT {
fn eq(&self, other: &Self) -> bool {
self.NodeIndex == other.NodeIndex && self.Codec == other.Codec && self.ResolutionRatiosCount == other.ResolutionRatiosCount
}
}
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_ENCODER_OUTPUT_RESOLUTION_RATIOS_COUNT {}
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_ENCODER_OUTPUT_RESOLUTION_RATIOS_COUNT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct D3D12_FEATURE_DATA_VIDEO_ENCODER_PROFILE_LEVEL {
pub NodeIndex: u32,
pub Codec: D3D12_VIDEO_ENCODER_CODEC,
pub Profile: D3D12_VIDEO_ENCODER_PROFILE_DESC,
pub IsSupported: super::super::Foundation::BOOL,
pub MinSupportedLevel: D3D12_VIDEO_ENCODER_LEVEL_SETTING,
pub MaxSupportedLevel: D3D12_VIDEO_ENCODER_LEVEL_SETTING,
}
#[cfg(feature = "Win32_Foundation")]
impl D3D12_FEATURE_DATA_VIDEO_ENCODER_PROFILE_LEVEL {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_ENCODER_PROFILE_LEVEL {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_ENCODER_PROFILE_LEVEL {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_ENCODER_PROFILE_LEVEL {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_ENCODER_PROFILE_LEVEL {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct D3D12_FEATURE_DATA_VIDEO_ENCODER_RATE_CONTROL_MODE {
pub NodeIndex: u32,
pub Codec: D3D12_VIDEO_ENCODER_CODEC,
pub RateControlMode: D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE,
pub IsSupported: super::super::Foundation::BOOL,
}
#[cfg(feature = "Win32_Foundation")]
impl D3D12_FEATURE_DATA_VIDEO_ENCODER_RATE_CONTROL_MODE {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_ENCODER_RATE_CONTROL_MODE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_ENCODER_RATE_CONTROL_MODE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_ENCODER_RATE_CONTROL_MODE").field("NodeIndex", &self.NodeIndex).field("Codec", &self.Codec).field("RateControlMode", &self.RateControlMode).field("IsSupported", &self.IsSupported).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_ENCODER_RATE_CONTROL_MODE {
fn eq(&self, other: &Self) -> bool {
self.NodeIndex == other.NodeIndex && self.Codec == other.Codec && self.RateControlMode == other.RateControlMode && self.IsSupported == other.IsSupported
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_ENCODER_RATE_CONTROL_MODE {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_ENCODER_RATE_CONTROL_MODE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_LIMITS {
pub MaxSubregionsNumber: u32,
pub MaxIntraRefreshFrameDuration: u32,
pub SubregionBlockPixelsSize: u32,
pub QPMapRegionPixelsSize: u32,
}
impl D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_LIMITS {}
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_LIMITS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_LIMITS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_LIMITS")
.field("MaxSubregionsNumber", &self.MaxSubregionsNumber)
.field("MaxIntraRefreshFrameDuration", &self.MaxIntraRefreshFrameDuration)
.field("SubregionBlockPixelsSize", &self.SubregionBlockPixelsSize)
.field("QPMapRegionPixelsSize", &self.QPMapRegionPixelsSize)
.finish()
}
}
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_LIMITS {
fn eq(&self, other: &Self) -> bool {
self.MaxSubregionsNumber == other.MaxSubregionsNumber && self.MaxIntraRefreshFrameDuration == other.MaxIntraRefreshFrameDuration && self.SubregionBlockPixelsSize == other.SubregionBlockPixelsSize && self.QPMapRegionPixelsSize == other.QPMapRegionPixelsSize
}
}
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_LIMITS {}
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_LIMITS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
pub struct D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOURCE_REQUIREMENTS {
pub NodeIndex: u32,
pub Codec: D3D12_VIDEO_ENCODER_CODEC,
pub Profile: D3D12_VIDEO_ENCODER_PROFILE_DESC,
pub InputFormat: super::super::Graphics::Dxgi::Common::DXGI_FORMAT,
pub PictureTargetResolution: D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC,
pub IsSupported: super::super::Foundation::BOOL,
pub CompressedBitstreamBufferAccessAlignment: u32,
pub EncoderMetadataBufferAccessAlignment: u32,
pub MaxEncoderOutputMetadataBufferSize: u32,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOURCE_REQUIREMENTS {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOURCE_REQUIREMENTS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOURCE_REQUIREMENTS {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOURCE_REQUIREMENTS {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOURCE_REQUIREMENTS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
pub struct D3D12_FEATURE_DATA_VIDEO_ENCODER_SUPPORT {
pub NodeIndex: u32,
pub Codec: D3D12_VIDEO_ENCODER_CODEC,
pub InputFormat: super::super::Graphics::Dxgi::Common::DXGI_FORMAT,
pub CodecConfiguration: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION,
pub CodecGopSequence: D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE,
pub RateControl: D3D12_VIDEO_ENCODER_RATE_CONTROL,
pub IntraRefresh: D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE,
pub SubregionFrameEncoding: D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE,
pub ResolutionsListCount: u32,
pub pResolutionList: *mut D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC,
pub MaxReferenceFramesInDPB: u32,
pub ValidationFlags: D3D12_VIDEO_ENCODER_VALIDATION_FLAGS,
pub SupportFlags: D3D12_VIDEO_ENCODER_SUPPORT_FLAGS,
pub SuggestedProfile: D3D12_VIDEO_ENCODER_PROFILE_DESC,
pub SuggestedLevel: D3D12_VIDEO_ENCODER_LEVEL_SETTING,
pub pResolutionDependentSupport: *mut D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_LIMITS,
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl D3D12_FEATURE_DATA_VIDEO_ENCODER_SUPPORT {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_ENCODER_SUPPORT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_ENCODER_SUPPORT {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_ENCODER_SUPPORT {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_ENCODER_SUPPORT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
pub struct D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMANDS {
pub NodeIndex: u32,
pub CommandCount: u32,
pub pCommandInfos: *mut D3D12_VIDEO_EXTENSION_COMMAND_INFO,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
impl D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMANDS {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMANDS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMANDS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMANDS").field("NodeIndex", &self.NodeIndex).field("CommandCount", &self.CommandCount).field("pCommandInfos", &self.pCommandInfos).finish()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMANDS {
fn eq(&self, other: &Self) -> bool {
self.NodeIndex == other.NodeIndex && self.CommandCount == other.CommandCount && self.pCommandInfos == other.pCommandInfos
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMANDS {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMANDS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_COUNT {
pub NodeIndex: u32,
pub CommandCount: u32,
}
impl D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_COUNT {}
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_COUNT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_COUNT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_COUNT").field("NodeIndex", &self.NodeIndex).field("CommandCount", &self.CommandCount).finish()
}
}
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_COUNT {
fn eq(&self, other: &Self) -> bool {
self.NodeIndex == other.NodeIndex && self.CommandCount == other.CommandCount
}
}
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_COUNT {}
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_COUNT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_PARAMETERS {
pub CommandId: ::windows::core::GUID,
pub Stage: D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE,
pub ParameterCount: u32,
pub pParameterInfos: *mut D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_INFO,
}
#[cfg(feature = "Win32_Foundation")]
impl D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_PARAMETERS {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_PARAMETERS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_PARAMETERS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_PARAMETERS").field("CommandId", &self.CommandId).field("Stage", &self.Stage).field("ParameterCount", &self.ParameterCount).field("pParameterInfos", &self.pParameterInfos).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_PARAMETERS {
fn eq(&self, other: &Self) -> bool {
self.CommandId == other.CommandId && self.Stage == other.Stage && self.ParameterCount == other.ParameterCount && self.pParameterInfos == other.pParameterInfos
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_PARAMETERS {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_PARAMETERS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_PARAMETER_COUNT {
pub CommandId: ::windows::core::GUID,
pub Stage: D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE,
pub ParameterCount: u32,
pub ParameterPacking: u32,
}
impl D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_PARAMETER_COUNT {}
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_PARAMETER_COUNT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_PARAMETER_COUNT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_PARAMETER_COUNT").field("CommandId", &self.CommandId).field("Stage", &self.Stage).field("ParameterCount", &self.ParameterCount).field("ParameterPacking", &self.ParameterPacking).finish()
}
}
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_PARAMETER_COUNT {
fn eq(&self, other: &Self) -> bool {
self.CommandId == other.CommandId && self.Stage == other.Stage && self.ParameterCount == other.ParameterCount && self.ParameterPacking == other.ParameterPacking
}
}
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_PARAMETER_COUNT {}
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_PARAMETER_COUNT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_SIZE {
pub NodeIndex: u32,
pub CommandId: ::windows::core::GUID,
pub pCreationParameters: *mut ::core::ffi::c_void,
pub CreationParametersSizeInBytes: usize,
pub MemoryPoolL0Size: u64,
pub MemoryPoolL1Size: u64,
}
impl D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_SIZE {}
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_SIZE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_SIZE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_SIZE")
.field("NodeIndex", &self.NodeIndex)
.field("CommandId", &self.CommandId)
.field("pCreationParameters", &self.pCreationParameters)
.field("CreationParametersSizeInBytes", &self.CreationParametersSizeInBytes)
.field("MemoryPoolL0Size", &self.MemoryPoolL0Size)
.field("MemoryPoolL1Size", &self.MemoryPoolL1Size)
.finish()
}
}
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_SIZE {
fn eq(&self, other: &Self) -> bool {
self.NodeIndex == other.NodeIndex && self.CommandId == other.CommandId && self.pCreationParameters == other.pCreationParameters && self.CreationParametersSizeInBytes == other.CreationParametersSizeInBytes && self.MemoryPoolL0Size == other.MemoryPoolL0Size && self.MemoryPoolL1Size == other.MemoryPoolL1Size
}
}
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_SIZE {}
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_SIZE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_SUPPORT {
pub NodeIndex: u32,
pub CommandId: ::windows::core::GUID,
pub pInputData: *mut ::core::ffi::c_void,
pub InputDataSizeInBytes: usize,
pub pOutputData: *mut ::core::ffi::c_void,
pub OutputDataSizeInBytes: usize,
}
impl D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_SUPPORT {}
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_SUPPORT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_SUPPORT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_SUPPORT")
.field("NodeIndex", &self.NodeIndex)
.field("CommandId", &self.CommandId)
.field("pInputData", &self.pInputData)
.field("InputDataSizeInBytes", &self.InputDataSizeInBytes)
.field("pOutputData", &self.pOutputData)
.field("OutputDataSizeInBytes", &self.OutputDataSizeInBytes)
.finish()
}
}
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_SUPPORT {
fn eq(&self, other: &Self) -> bool {
self.NodeIndex == other.NodeIndex && self.CommandId == other.CommandId && self.pInputData == other.pInputData && self.InputDataSizeInBytes == other.InputDataSizeInBytes && self.pOutputData == other.pOutputData && self.OutputDataSizeInBytes == other.OutputDataSizeInBytes
}
}
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_SUPPORT {}
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_SUPPORT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct D3D12_FEATURE_DATA_VIDEO_FEATURE_AREA_SUPPORT {
pub NodeIndex: u32,
pub VideoDecodeSupport: super::super::Foundation::BOOL,
pub VideoProcessSupport: super::super::Foundation::BOOL,
pub VideoEncodeSupport: super::super::Foundation::BOOL,
}
#[cfg(feature = "Win32_Foundation")]
impl D3D12_FEATURE_DATA_VIDEO_FEATURE_AREA_SUPPORT {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_FEATURE_AREA_SUPPORT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_FEATURE_AREA_SUPPORT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_FEATURE_AREA_SUPPORT").field("NodeIndex", &self.NodeIndex).field("VideoDecodeSupport", &self.VideoDecodeSupport).field("VideoProcessSupport", &self.VideoProcessSupport).field("VideoEncodeSupport", &self.VideoEncodeSupport).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_FEATURE_AREA_SUPPORT {
fn eq(&self, other: &Self) -> bool {
self.NodeIndex == other.NodeIndex && self.VideoDecodeSupport == other.VideoDecodeSupport && self.VideoProcessSupport == other.VideoProcessSupport && self.VideoEncodeSupport == other.VideoEncodeSupport
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_FEATURE_AREA_SUPPORT {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_FEATURE_AREA_SUPPORT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
pub struct D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR {
pub NodeIndex: u32,
pub InputFormat: super::super::Graphics::Dxgi::Common::DXGI_FORMAT,
pub BlockSizeFlags: D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS,
pub PrecisionFlags: D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS,
pub SizeRange: D3D12_VIDEO_SIZE_RANGE,
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR").field("NodeIndex", &self.NodeIndex).field("InputFormat", &self.InputFormat).field("BlockSizeFlags", &self.BlockSizeFlags).field("PrecisionFlags", &self.PrecisionFlags).field("SizeRange", &self.SizeRange).finish()
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR {
fn eq(&self, other: &Self) -> bool {
self.NodeIndex == other.NodeIndex && self.InputFormat == other.InputFormat && self.BlockSizeFlags == other.BlockSizeFlags && self.PrecisionFlags == other.PrecisionFlags && self.SizeRange == other.SizeRange
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR_PROTECTED_RESOURCES {
pub NodeIndex: u32,
pub SupportFlags: D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS,
}
impl D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR_PROTECTED_RESOURCES {}
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR_PROTECTED_RESOURCES {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR_PROTECTED_RESOURCES {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR_PROTECTED_RESOURCES").field("NodeIndex", &self.NodeIndex).field("SupportFlags", &self.SupportFlags).finish()
}
}
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR_PROTECTED_RESOURCES {
fn eq(&self, other: &Self) -> bool {
self.NodeIndex == other.NodeIndex && self.SupportFlags == other.SupportFlags
}
}
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR_PROTECTED_RESOURCES {}
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR_PROTECTED_RESOURCES {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
pub struct D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR_SIZE {
pub NodeIndex: u32,
pub InputFormat: super::super::Graphics::Dxgi::Common::DXGI_FORMAT,
pub BlockSize: D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE,
pub Precision: D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION,
pub SizeRange: D3D12_VIDEO_SIZE_RANGE,
pub Protected: super::super::Foundation::BOOL,
pub MotionVectorHeapMemoryPoolL0Size: u64,
pub MotionVectorHeapMemoryPoolL1Size: u64,
pub MotionEstimatorMemoryPoolL0Size: u64,
pub MotionEstimatorMemoryPoolL1Size: u64,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR_SIZE {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR_SIZE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR_SIZE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR_SIZE")
.field("NodeIndex", &self.NodeIndex)
.field("InputFormat", &self.InputFormat)
.field("BlockSize", &self.BlockSize)
.field("Precision", &self.Precision)
.field("SizeRange", &self.SizeRange)
.field("Protected", &self.Protected)
.field("MotionVectorHeapMemoryPoolL0Size", &self.MotionVectorHeapMemoryPoolL0Size)
.field("MotionVectorHeapMemoryPoolL1Size", &self.MotionVectorHeapMemoryPoolL1Size)
.field("MotionEstimatorMemoryPoolL0Size", &self.MotionEstimatorMemoryPoolL0Size)
.field("MotionEstimatorMemoryPoolL1Size", &self.MotionEstimatorMemoryPoolL1Size)
.finish()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR_SIZE {
fn eq(&self, other: &Self) -> bool {
self.NodeIndex == other.NodeIndex
&& self.InputFormat == other.InputFormat
&& self.BlockSize == other.BlockSize
&& self.Precision == other.Precision
&& self.SizeRange == other.SizeRange
&& self.Protected == other.Protected
&& self.MotionVectorHeapMemoryPoolL0Size == other.MotionVectorHeapMemoryPoolL0Size
&& self.MotionVectorHeapMemoryPoolL1Size == other.MotionVectorHeapMemoryPoolL1Size
&& self.MotionEstimatorMemoryPoolL0Size == other.MotionEstimatorMemoryPoolL0Size
&& self.MotionEstimatorMemoryPoolL1Size == other.MotionEstimatorMemoryPoolL1Size
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR_SIZE {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR_SIZE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
pub struct D3D12_FEATURE_DATA_VIDEO_PROCESSOR_SIZE {
pub NodeMask: u32,
pub pOutputStreamDesc: *mut D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC,
pub NumInputStreamDescs: u32,
pub pInputStreamDescs: *mut D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC,
pub MemoryPoolL0Size: u64,
pub MemoryPoolL1Size: u64,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl D3D12_FEATURE_DATA_VIDEO_PROCESSOR_SIZE {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_PROCESSOR_SIZE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_PROCESSOR_SIZE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_PROCESSOR_SIZE")
.field("NodeMask", &self.NodeMask)
.field("pOutputStreamDesc", &self.pOutputStreamDesc)
.field("NumInputStreamDescs", &self.NumInputStreamDescs)
.field("pInputStreamDescs", &self.pInputStreamDescs)
.field("MemoryPoolL0Size", &self.MemoryPoolL0Size)
.field("MemoryPoolL1Size", &self.MemoryPoolL1Size)
.finish()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_PROCESSOR_SIZE {
fn eq(&self, other: &Self) -> bool {
self.NodeMask == other.NodeMask && self.pOutputStreamDesc == other.pOutputStreamDesc && self.NumInputStreamDescs == other.NumInputStreamDescs && self.pInputStreamDescs == other.pInputStreamDescs && self.MemoryPoolL0Size == other.MemoryPoolL0Size && self.MemoryPoolL1Size == other.MemoryPoolL1Size
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_PROCESSOR_SIZE {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_PROCESSOR_SIZE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
pub struct D3D12_FEATURE_DATA_VIDEO_PROCESSOR_SIZE1 {
pub NodeMask: u32,
pub pOutputStreamDesc: *mut D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC,
pub NumInputStreamDescs: u32,
pub pInputStreamDescs: *mut D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC,
pub Protected: super::super::Foundation::BOOL,
pub MemoryPoolL0Size: u64,
pub MemoryPoolL1Size: u64,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl D3D12_FEATURE_DATA_VIDEO_PROCESSOR_SIZE1 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_PROCESSOR_SIZE1 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_PROCESSOR_SIZE1 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_PROCESSOR_SIZE1")
.field("NodeMask", &self.NodeMask)
.field("pOutputStreamDesc", &self.pOutputStreamDesc)
.field("NumInputStreamDescs", &self.NumInputStreamDescs)
.field("pInputStreamDescs", &self.pInputStreamDescs)
.field("Protected", &self.Protected)
.field("MemoryPoolL0Size", &self.MemoryPoolL0Size)
.field("MemoryPoolL1Size", &self.MemoryPoolL1Size)
.finish()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_PROCESSOR_SIZE1 {
fn eq(&self, other: &Self) -> bool {
self.NodeMask == other.NodeMask && self.pOutputStreamDesc == other.pOutputStreamDesc && self.NumInputStreamDescs == other.NumInputStreamDescs && self.pInputStreamDescs == other.pInputStreamDescs && self.Protected == other.Protected && self.MemoryPoolL0Size == other.MemoryPoolL0Size && self.MemoryPoolL1Size == other.MemoryPoolL1Size
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_PROCESSOR_SIZE1 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_PROCESSOR_SIZE1 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_FEATURE_DATA_VIDEO_PROCESS_MAX_INPUT_STREAMS {
pub NodeIndex: u32,
pub MaxInputStreams: u32,
}
impl D3D12_FEATURE_DATA_VIDEO_PROCESS_MAX_INPUT_STREAMS {}
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_PROCESS_MAX_INPUT_STREAMS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_PROCESS_MAX_INPUT_STREAMS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_PROCESS_MAX_INPUT_STREAMS").field("NodeIndex", &self.NodeIndex).field("MaxInputStreams", &self.MaxInputStreams).finish()
}
}
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_PROCESS_MAX_INPUT_STREAMS {
fn eq(&self, other: &Self) -> bool {
self.NodeIndex == other.NodeIndex && self.MaxInputStreams == other.MaxInputStreams
}
}
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_PROCESS_MAX_INPUT_STREAMS {}
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_PROCESS_MAX_INPUT_STREAMS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_FEATURE_DATA_VIDEO_PROCESS_PROTECTED_RESOURCES {
pub NodeIndex: u32,
pub SupportFlags: D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS,
}
impl D3D12_FEATURE_DATA_VIDEO_PROCESS_PROTECTED_RESOURCES {}
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_PROCESS_PROTECTED_RESOURCES {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_PROCESS_PROTECTED_RESOURCES {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_PROCESS_PROTECTED_RESOURCES").field("NodeIndex", &self.NodeIndex).field("SupportFlags", &self.SupportFlags).finish()
}
}
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_PROCESS_PROTECTED_RESOURCES {
fn eq(&self, other: &Self) -> bool {
self.NodeIndex == other.NodeIndex && self.SupportFlags == other.SupportFlags
}
}
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_PROCESS_PROTECTED_RESOURCES {}
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_PROCESS_PROTECTED_RESOURCES {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
pub struct D3D12_FEATURE_DATA_VIDEO_PROCESS_REFERENCE_INFO {
pub NodeIndex: u32,
pub DeinterlaceMode: D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS,
pub Filters: D3D12_VIDEO_PROCESS_FILTER_FLAGS,
pub FeatureSupport: D3D12_VIDEO_PROCESS_FEATURE_FLAGS,
pub InputFrameRate: super::super::Graphics::Dxgi::Common::DXGI_RATIONAL,
pub OutputFrameRate: super::super::Graphics::Dxgi::Common::DXGI_RATIONAL,
pub EnableAutoProcessing: super::super::Foundation::BOOL,
pub PastFrames: u32,
pub FutureFrames: u32,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl D3D12_FEATURE_DATA_VIDEO_PROCESS_REFERENCE_INFO {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_PROCESS_REFERENCE_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_PROCESS_REFERENCE_INFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_PROCESS_REFERENCE_INFO")
.field("NodeIndex", &self.NodeIndex)
.field("DeinterlaceMode", &self.DeinterlaceMode)
.field("Filters", &self.Filters)
.field("FeatureSupport", &self.FeatureSupport)
.field("InputFrameRate", &self.InputFrameRate)
.field("OutputFrameRate", &self.OutputFrameRate)
.field("EnableAutoProcessing", &self.EnableAutoProcessing)
.field("PastFrames", &self.PastFrames)
.field("FutureFrames", &self.FutureFrames)
.finish()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_PROCESS_REFERENCE_INFO {
fn eq(&self, other: &Self) -> bool {
self.NodeIndex == other.NodeIndex && self.DeinterlaceMode == other.DeinterlaceMode && self.Filters == other.Filters && self.FeatureSupport == other.FeatureSupport && self.InputFrameRate == other.InputFrameRate && self.OutputFrameRate == other.OutputFrameRate && self.EnableAutoProcessing == other.EnableAutoProcessing && self.PastFrames == other.PastFrames && self.FutureFrames == other.FutureFrames
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_PROCESS_REFERENCE_INFO {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_PROCESS_REFERENCE_INFO {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
pub struct D3D12_FEATURE_DATA_VIDEO_PROCESS_SUPPORT {
pub NodeIndex: u32,
pub InputSample: D3D12_VIDEO_SAMPLE,
pub InputFieldType: D3D12_VIDEO_FIELD_TYPE,
pub InputStereoFormat: D3D12_VIDEO_FRAME_STEREO_FORMAT,
pub InputFrameRate: super::super::Graphics::Dxgi::Common::DXGI_RATIONAL,
pub OutputFormat: D3D12_VIDEO_FORMAT,
pub OutputStereoFormat: D3D12_VIDEO_FRAME_STEREO_FORMAT,
pub OutputFrameRate: super::super::Graphics::Dxgi::Common::DXGI_RATIONAL,
pub SupportFlags: D3D12_VIDEO_PROCESS_SUPPORT_FLAGS,
pub ScaleSupport: D3D12_VIDEO_SCALE_SUPPORT,
pub FeatureSupport: D3D12_VIDEO_PROCESS_FEATURE_FLAGS,
pub DeinterlaceSupport: D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS,
pub AutoProcessingSupport: D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS,
pub FilterSupport: D3D12_VIDEO_PROCESS_FILTER_FLAGS,
pub FilterRangeSupport: [D3D12_VIDEO_PROCESS_FILTER_RANGE; 32],
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl D3D12_FEATURE_DATA_VIDEO_PROCESS_SUPPORT {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::default::Default for D3D12_FEATURE_DATA_VIDEO_PROCESS_SUPPORT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::fmt::Debug for D3D12_FEATURE_DATA_VIDEO_PROCESS_SUPPORT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_FEATURE_DATA_VIDEO_PROCESS_SUPPORT")
.field("NodeIndex", &self.NodeIndex)
.field("InputSample", &self.InputSample)
.field("InputFieldType", &self.InputFieldType)
.field("InputStereoFormat", &self.InputStereoFormat)
.field("InputFrameRate", &self.InputFrameRate)
.field("OutputFormat", &self.OutputFormat)
.field("OutputStereoFormat", &self.OutputStereoFormat)
.field("OutputFrameRate", &self.OutputFrameRate)
.field("SupportFlags", &self.SupportFlags)
.field("ScaleSupport", &self.ScaleSupport)
.field("FeatureSupport", &self.FeatureSupport)
.field("DeinterlaceSupport", &self.DeinterlaceSupport)
.field("AutoProcessingSupport", &self.AutoProcessingSupport)
.field("FilterSupport", &self.FilterSupport)
.field("FilterRangeSupport", &self.FilterRangeSupport)
.finish()
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::PartialEq for D3D12_FEATURE_DATA_VIDEO_PROCESS_SUPPORT {
fn eq(&self, other: &Self) -> bool {
self.NodeIndex == other.NodeIndex
&& self.InputSample == other.InputSample
&& self.InputFieldType == other.InputFieldType
&& self.InputStereoFormat == other.InputStereoFormat
&& self.InputFrameRate == other.InputFrameRate
&& self.OutputFormat == other.OutputFormat
&& self.OutputStereoFormat == other.OutputStereoFormat
&& self.OutputFrameRate == other.OutputFrameRate
&& self.SupportFlags == other.SupportFlags
&& self.ScaleSupport == other.ScaleSupport
&& self.FeatureSupport == other.FeatureSupport
&& self.DeinterlaceSupport == other.DeinterlaceSupport
&& self.AutoProcessingSupport == other.AutoProcessingSupport
&& self.FilterSupport == other.FilterSupport
&& self.FilterRangeSupport == other.FilterRangeSupport
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::Eq for D3D12_FEATURE_DATA_VIDEO_PROCESS_SUPPORT {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
unsafe impl ::windows::core::Abi for D3D12_FEATURE_DATA_VIDEO_PROCESS_SUPPORT {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_FEATURE_VIDEO(pub i32);
pub const D3D12_FEATURE_VIDEO_DECODE_SUPPORT: D3D12_FEATURE_VIDEO = D3D12_FEATURE_VIDEO(0i32);
pub const D3D12_FEATURE_VIDEO_DECODE_PROFILES: D3D12_FEATURE_VIDEO = D3D12_FEATURE_VIDEO(1i32);
pub const D3D12_FEATURE_VIDEO_DECODE_FORMATS: D3D12_FEATURE_VIDEO = D3D12_FEATURE_VIDEO(2i32);
pub const D3D12_FEATURE_VIDEO_DECODE_CONVERSION_SUPPORT: D3D12_FEATURE_VIDEO = D3D12_FEATURE_VIDEO(3i32);
pub const D3D12_FEATURE_VIDEO_PROCESS_SUPPORT: D3D12_FEATURE_VIDEO = D3D12_FEATURE_VIDEO(5i32);
pub const D3D12_FEATURE_VIDEO_PROCESS_MAX_INPUT_STREAMS: D3D12_FEATURE_VIDEO = D3D12_FEATURE_VIDEO(6i32);
pub const D3D12_FEATURE_VIDEO_PROCESS_REFERENCE_INFO: D3D12_FEATURE_VIDEO = D3D12_FEATURE_VIDEO(7i32);
pub const D3D12_FEATURE_VIDEO_DECODER_HEAP_SIZE: D3D12_FEATURE_VIDEO = D3D12_FEATURE_VIDEO(8i32);
pub const D3D12_FEATURE_VIDEO_PROCESSOR_SIZE: D3D12_FEATURE_VIDEO = D3D12_FEATURE_VIDEO(9i32);
pub const D3D12_FEATURE_VIDEO_DECODE_PROFILE_COUNT: D3D12_FEATURE_VIDEO = D3D12_FEATURE_VIDEO(10i32);
pub const D3D12_FEATURE_VIDEO_DECODE_FORMAT_COUNT: D3D12_FEATURE_VIDEO = D3D12_FEATURE_VIDEO(11i32);
pub const D3D12_FEATURE_VIDEO_ARCHITECTURE: D3D12_FEATURE_VIDEO = D3D12_FEATURE_VIDEO(17i32);
pub const D3D12_FEATURE_VIDEO_DECODE_HISTOGRAM: D3D12_FEATURE_VIDEO = D3D12_FEATURE_VIDEO(18i32);
pub const D3D12_FEATURE_VIDEO_FEATURE_AREA_SUPPORT: D3D12_FEATURE_VIDEO = D3D12_FEATURE_VIDEO(19i32);
pub const D3D12_FEATURE_VIDEO_MOTION_ESTIMATOR: D3D12_FEATURE_VIDEO = D3D12_FEATURE_VIDEO(20i32);
pub const D3D12_FEATURE_VIDEO_MOTION_ESTIMATOR_SIZE: D3D12_FEATURE_VIDEO = D3D12_FEATURE_VIDEO(21i32);
pub const D3D12_FEATURE_VIDEO_EXTENSION_COMMAND_COUNT: D3D12_FEATURE_VIDEO = D3D12_FEATURE_VIDEO(22i32);
pub const D3D12_FEATURE_VIDEO_EXTENSION_COMMANDS: D3D12_FEATURE_VIDEO = D3D12_FEATURE_VIDEO(23i32);
pub const D3D12_FEATURE_VIDEO_EXTENSION_COMMAND_PARAMETER_COUNT: D3D12_FEATURE_VIDEO = D3D12_FEATURE_VIDEO(24i32);
pub const D3D12_FEATURE_VIDEO_EXTENSION_COMMAND_PARAMETERS: D3D12_FEATURE_VIDEO = D3D12_FEATURE_VIDEO(25i32);
pub const D3D12_FEATURE_VIDEO_EXTENSION_COMMAND_SUPPORT: D3D12_FEATURE_VIDEO = D3D12_FEATURE_VIDEO(26i32);
pub const D3D12_FEATURE_VIDEO_EXTENSION_COMMAND_SIZE: D3D12_FEATURE_VIDEO = D3D12_FEATURE_VIDEO(27i32);
pub const D3D12_FEATURE_VIDEO_DECODE_PROTECTED_RESOURCES: D3D12_FEATURE_VIDEO = D3D12_FEATURE_VIDEO(28i32);
pub const D3D12_FEATURE_VIDEO_PROCESS_PROTECTED_RESOURCES: D3D12_FEATURE_VIDEO = D3D12_FEATURE_VIDEO(29i32);
pub const D3D12_FEATURE_VIDEO_MOTION_ESTIMATOR_PROTECTED_RESOURCES: D3D12_FEATURE_VIDEO = D3D12_FEATURE_VIDEO(30i32);
pub const D3D12_FEATURE_VIDEO_DECODER_HEAP_SIZE1: D3D12_FEATURE_VIDEO = D3D12_FEATURE_VIDEO(31i32);
pub const D3D12_FEATURE_VIDEO_PROCESSOR_SIZE1: D3D12_FEATURE_VIDEO = D3D12_FEATURE_VIDEO(32i32);
impl ::core::convert::From<i32> for D3D12_FEATURE_VIDEO {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_FEATURE_VIDEO {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
pub struct D3D12_QUERY_DATA_VIDEO_DECODE_STATISTICS {
pub Status: u64,
pub NumMacroblocksAffected: u64,
pub FrameRate: super::super::Graphics::Dxgi::Common::DXGI_RATIONAL,
pub BitRate: u32,
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl D3D12_QUERY_DATA_VIDEO_DECODE_STATISTICS {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::default::Default for D3D12_QUERY_DATA_VIDEO_DECODE_STATISTICS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::fmt::Debug for D3D12_QUERY_DATA_VIDEO_DECODE_STATISTICS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_QUERY_DATA_VIDEO_DECODE_STATISTICS").field("Status", &self.Status).field("NumMacroblocksAffected", &self.NumMacroblocksAffected).field("FrameRate", &self.FrameRate).field("BitRate", &self.BitRate).finish()
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::PartialEq for D3D12_QUERY_DATA_VIDEO_DECODE_STATISTICS {
fn eq(&self, other: &Self) -> bool {
self.Status == other.Status && self.NumMacroblocksAffected == other.NumMacroblocksAffected && self.FrameRate == other.FrameRate && self.BitRate == other.BitRate
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::Eq for D3D12_QUERY_DATA_VIDEO_DECODE_STATISTICS {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
unsafe impl ::windows::core::Abi for D3D12_QUERY_DATA_VIDEO_DECODE_STATISTICS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
pub struct D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT {
pub pMotionVectorHeap: ::core::option::Option<ID3D12VideoMotionVectorHeap>,
pub PixelWidth: u32,
pub PixelHeight: u32,
}
impl D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT {}
impl ::core::default::Default for D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT").field("pMotionVectorHeap", &self.pMotionVectorHeap).field("PixelWidth", &self.PixelWidth).field("PixelHeight", &self.PixelHeight).finish()
}
}
impl ::core::cmp::PartialEq for D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT {
fn eq(&self, other: &Self) -> bool {
self.pMotionVectorHeap == other.pMotionVectorHeap && self.PixelWidth == other.PixelWidth && self.PixelHeight == other.PixelHeight
}
}
impl ::core::cmp::Eq for D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT {}
unsafe impl ::windows::core::Abi for D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub struct D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT {
pub pMotionVectorTexture2D: ::core::option::Option<super::super::Graphics::Direct3D12::ID3D12Resource>,
pub MotionVectorCoordinate: D3D12_RESOURCE_COORDINATE,
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT {}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::default::Default for D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::fmt::Debug for D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT").field("pMotionVectorTexture2D", &self.pMotionVectorTexture2D).field("MotionVectorCoordinate", &self.MotionVectorCoordinate).finish()
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::cmp::PartialEq for D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT {
fn eq(&self, other: &Self) -> bool {
self.pMotionVectorTexture2D == other.pMotionVectorTexture2D && self.MotionVectorCoordinate == other.MotionVectorCoordinate
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::cmp::Eq for D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT {}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
unsafe impl ::windows::core::Abi for D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_RESOURCE_COORDINATE {
pub X: u64,
pub Y: u32,
pub Z: u32,
pub SubresourceIndex: u32,
}
impl D3D12_RESOURCE_COORDINATE {}
impl ::core::default::Default for D3D12_RESOURCE_COORDINATE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_RESOURCE_COORDINATE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_RESOURCE_COORDINATE").field("X", &self.X).field("Y", &self.Y).field("Z", &self.Z).field("SubresourceIndex", &self.SubresourceIndex).finish()
}
}
impl ::core::cmp::PartialEq for D3D12_RESOURCE_COORDINATE {
fn eq(&self, other: &Self) -> bool {
self.X == other.X && self.Y == other.Y && self.Z == other.Z && self.SubresourceIndex == other.SubresourceIndex
}
}
impl ::core::cmp::Eq for D3D12_RESOURCE_COORDINATE {}
unsafe impl ::windows::core::Abi for D3D12_RESOURCE_COORDINATE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_DECODER_DESC {
pub NodeMask: u32,
pub Configuration: D3D12_VIDEO_DECODE_CONFIGURATION,
}
impl D3D12_VIDEO_DECODER_DESC {}
impl ::core::default::Default for D3D12_VIDEO_DECODER_DESC {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_VIDEO_DECODER_DESC {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_DECODER_DESC").field("NodeMask", &self.NodeMask).field("Configuration", &self.Configuration).finish()
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_DECODER_DESC {
fn eq(&self, other: &Self) -> bool {
self.NodeMask == other.NodeMask && self.Configuration == other.Configuration
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_DECODER_DESC {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_DECODER_DESC {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
pub struct D3D12_VIDEO_DECODER_HEAP_DESC {
pub NodeMask: u32,
pub Configuration: D3D12_VIDEO_DECODE_CONFIGURATION,
pub DecodeWidth: u32,
pub DecodeHeight: u32,
pub Format: super::super::Graphics::Dxgi::Common::DXGI_FORMAT,
pub FrameRate: super::super::Graphics::Dxgi::Common::DXGI_RATIONAL,
pub BitRate: u32,
pub MaxDecodePictureBufferCount: u32,
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl D3D12_VIDEO_DECODER_HEAP_DESC {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::default::Default for D3D12_VIDEO_DECODER_HEAP_DESC {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::fmt::Debug for D3D12_VIDEO_DECODER_HEAP_DESC {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_DECODER_HEAP_DESC")
.field("NodeMask", &self.NodeMask)
.field("Configuration", &self.Configuration)
.field("DecodeWidth", &self.DecodeWidth)
.field("DecodeHeight", &self.DecodeHeight)
.field("Format", &self.Format)
.field("FrameRate", &self.FrameRate)
.field("BitRate", &self.BitRate)
.field("MaxDecodePictureBufferCount", &self.MaxDecodePictureBufferCount)
.finish()
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_DECODER_HEAP_DESC {
fn eq(&self, other: &Self) -> bool {
self.NodeMask == other.NodeMask && self.Configuration == other.Configuration && self.DecodeWidth == other.DecodeWidth && self.DecodeHeight == other.DecodeHeight && self.Format == other.Format && self.FrameRate == other.FrameRate && self.BitRate == other.BitRate && self.MaxDecodePictureBufferCount == other.MaxDecodePictureBufferCount
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::Eq for D3D12_VIDEO_DECODER_HEAP_DESC {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_DECODER_HEAP_DESC {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_DECODE_ARGUMENT_TYPE(pub i32);
pub const D3D12_VIDEO_DECODE_ARGUMENT_TYPE_PICTURE_PARAMETERS: D3D12_VIDEO_DECODE_ARGUMENT_TYPE = D3D12_VIDEO_DECODE_ARGUMENT_TYPE(0i32);
pub const D3D12_VIDEO_DECODE_ARGUMENT_TYPE_INVERSE_QUANTIZATION_MATRIX: D3D12_VIDEO_DECODE_ARGUMENT_TYPE = D3D12_VIDEO_DECODE_ARGUMENT_TYPE(1i32);
pub const D3D12_VIDEO_DECODE_ARGUMENT_TYPE_SLICE_CONTROL: D3D12_VIDEO_DECODE_ARGUMENT_TYPE = D3D12_VIDEO_DECODE_ARGUMENT_TYPE(2i32);
pub const D3D12_VIDEO_DECODE_ARGUMENT_TYPE_MAX_VALID: D3D12_VIDEO_DECODE_ARGUMENT_TYPE = D3D12_VIDEO_DECODE_ARGUMENT_TYPE(3i32);
impl ::core::convert::From<i32> for D3D12_VIDEO_DECODE_ARGUMENT_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_DECODE_ARGUMENT_TYPE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub struct D3D12_VIDEO_DECODE_COMPRESSED_BITSTREAM {
pub pBuffer: ::core::option::Option<super::super::Graphics::Direct3D12::ID3D12Resource>,
pub Offset: u64,
pub Size: u64,
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl D3D12_VIDEO_DECODE_COMPRESSED_BITSTREAM {}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::default::Default for D3D12_VIDEO_DECODE_COMPRESSED_BITSTREAM {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::fmt::Debug for D3D12_VIDEO_DECODE_COMPRESSED_BITSTREAM {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_DECODE_COMPRESSED_BITSTREAM").field("pBuffer", &self.pBuffer).field("Offset", &self.Offset).field("Size", &self.Size).finish()
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_DECODE_COMPRESSED_BITSTREAM {
fn eq(&self, other: &Self) -> bool {
self.pBuffer == other.pBuffer && self.Offset == other.Offset && self.Size == other.Size
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::cmp::Eq for D3D12_VIDEO_DECODE_COMPRESSED_BITSTREAM {}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_DECODE_COMPRESSED_BITSTREAM {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_DECODE_CONFIGURATION {
pub DecodeProfile: ::windows::core::GUID,
pub BitstreamEncryption: D3D12_BITSTREAM_ENCRYPTION_TYPE,
pub InterlaceType: D3D12_VIDEO_FRAME_CODED_INTERLACE_TYPE,
}
impl D3D12_VIDEO_DECODE_CONFIGURATION {}
impl ::core::default::Default for D3D12_VIDEO_DECODE_CONFIGURATION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_VIDEO_DECODE_CONFIGURATION {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_DECODE_CONFIGURATION").field("DecodeProfile", &self.DecodeProfile).field("BitstreamEncryption", &self.BitstreamEncryption).field("InterlaceType", &self.InterlaceType).finish()
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_DECODE_CONFIGURATION {
fn eq(&self, other: &Self) -> bool {
self.DecodeProfile == other.DecodeProfile && self.BitstreamEncryption == other.BitstreamEncryption && self.InterlaceType == other.InterlaceType
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_DECODE_CONFIGURATION {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_DECODE_CONFIGURATION {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS(pub u32);
pub const D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_NONE: D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS = D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS(0u32);
pub const D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_HEIGHT_ALIGNMENT_MULTIPLE_32_REQUIRED: D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS = D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS(1u32);
pub const D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_POST_PROCESSING_SUPPORTED: D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS = D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS(2u32);
pub const D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_REFERENCE_ONLY_ALLOCATIONS_REQUIRED: D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS = D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS(4u32);
pub const D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_ALLOW_RESOLUTION_CHANGE_ON_NON_KEY_FRAME: D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS = D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS(8u32);
impl ::core::convert::From<u32> for D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
pub struct D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS {
pub Enable: super::super::Foundation::BOOL,
pub pReferenceTexture2D: ::core::option::Option<super::super::Graphics::Direct3D12::ID3D12Resource>,
pub ReferenceSubresource: u32,
pub OutputColorSpace: super::super::Graphics::Dxgi::Common::DXGI_COLOR_SPACE_TYPE,
pub DecodeColorSpace: super::super::Graphics::Dxgi::Common::DXGI_COLOR_SPACE_TYPE,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
impl D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::default::Default for D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::fmt::Debug for D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS")
.field("Enable", &self.Enable)
.field("pReferenceTexture2D", &self.pReferenceTexture2D)
.field("ReferenceSubresource", &self.ReferenceSubresource)
.field("OutputColorSpace", &self.OutputColorSpace)
.field("DecodeColorSpace", &self.DecodeColorSpace)
.finish()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::cmp::PartialEq for D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS {
fn eq(&self, other: &Self) -> bool {
self.Enable == other.Enable && self.pReferenceTexture2D == other.pReferenceTexture2D && self.ReferenceSubresource == other.ReferenceSubresource && self.OutputColorSpace == other.OutputColorSpace && self.DecodeColorSpace == other.DecodeColorSpace
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::cmp::Eq for D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
pub struct D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS1 {
pub Enable: super::super::Foundation::BOOL,
pub pReferenceTexture2D: ::core::option::Option<super::super::Graphics::Direct3D12::ID3D12Resource>,
pub ReferenceSubresource: u32,
pub OutputColorSpace: super::super::Graphics::Dxgi::Common::DXGI_COLOR_SPACE_TYPE,
pub DecodeColorSpace: super::super::Graphics::Dxgi::Common::DXGI_COLOR_SPACE_TYPE,
pub OutputWidth: u32,
pub OutputHeight: u32,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
impl D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS1 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::default::Default for D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS1 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::fmt::Debug for D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS1 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS1")
.field("Enable", &self.Enable)
.field("pReferenceTexture2D", &self.pReferenceTexture2D)
.field("ReferenceSubresource", &self.ReferenceSubresource)
.field("OutputColorSpace", &self.OutputColorSpace)
.field("DecodeColorSpace", &self.DecodeColorSpace)
.field("OutputWidth", &self.OutputWidth)
.field("OutputHeight", &self.OutputHeight)
.finish()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::cmp::PartialEq for D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS1 {
fn eq(&self, other: &Self) -> bool {
self.Enable == other.Enable && self.pReferenceTexture2D == other.pReferenceTexture2D && self.ReferenceSubresource == other.ReferenceSubresource && self.OutputColorSpace == other.OutputColorSpace && self.DecodeColorSpace == other.DecodeColorSpace && self.OutputWidth == other.OutputWidth && self.OutputHeight == other.OutputHeight
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::cmp::Eq for D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS1 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS1 {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS(pub u32);
pub const D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAG_NONE: D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS = D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS(0u32);
pub const D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAG_SUPPORTED: D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS = D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS(1u32);
impl ::core::convert::From<u32> for D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_DECODE_FRAME_ARGUMENT {
pub Type: D3D12_VIDEO_DECODE_ARGUMENT_TYPE,
pub Size: u32,
pub pData: *mut ::core::ffi::c_void,
}
impl D3D12_VIDEO_DECODE_FRAME_ARGUMENT {}
impl ::core::default::Default for D3D12_VIDEO_DECODE_FRAME_ARGUMENT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_VIDEO_DECODE_FRAME_ARGUMENT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_DECODE_FRAME_ARGUMENT").field("Type", &self.Type).field("Size", &self.Size).field("pData", &self.pData).finish()
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_DECODE_FRAME_ARGUMENT {
fn eq(&self, other: &Self) -> bool {
self.Type == other.Type && self.Size == other.Size && self.pData == other.pData
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_DECODE_FRAME_ARGUMENT {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_DECODE_FRAME_ARGUMENT {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT(pub i32);
pub const D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_Y: D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT = D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT(0i32);
pub const D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_U: D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT = D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT(1i32);
pub const D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_V: D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT = D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT(2i32);
pub const D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_R: D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT = D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT(0i32);
pub const D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_G: D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT = D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT(1i32);
pub const D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_B: D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT = D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT(2i32);
pub const D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_A: D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT = D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT(3i32);
impl ::core::convert::From<i32> for D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS(pub u32);
pub const D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_NONE: D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS = D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS(0u32);
pub const D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_Y: D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS = D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS(1u32);
pub const D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_U: D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS = D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS(2u32);
pub const D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_V: D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS = D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS(4u32);
pub const D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_R: D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS = D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS(1u32);
pub const D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_G: D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS = D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS(2u32);
pub const D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_B: D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS = D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS(4u32);
pub const D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_A: D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS = D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS(8u32);
impl ::core::convert::From<u32> for D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub struct D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS {
pub NumFrameArguments: u32,
pub FrameArguments: [D3D12_VIDEO_DECODE_FRAME_ARGUMENT; 10],
pub ReferenceFrames: D3D12_VIDEO_DECODE_REFERENCE_FRAMES,
pub CompressedBitstream: D3D12_VIDEO_DECODE_COMPRESSED_BITSTREAM,
pub pHeap: ::core::option::Option<ID3D12VideoDecoderHeap>,
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS {}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::default::Default for D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::fmt::Debug for D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS").field("NumFrameArguments", &self.NumFrameArguments).field("FrameArguments", &self.FrameArguments).field("ReferenceFrames", &self.ReferenceFrames).field("CompressedBitstream", &self.CompressedBitstream).field("pHeap", &self.pHeap).finish()
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS {
fn eq(&self, other: &Self) -> bool {
self.NumFrameArguments == other.NumFrameArguments && self.FrameArguments == other.FrameArguments && self.ReferenceFrames == other.ReferenceFrames && self.CompressedBitstream == other.CompressedBitstream && self.pHeap == other.pHeap
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::cmp::Eq for D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS {}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub struct D3D12_VIDEO_DECODE_OUTPUT_HISTOGRAM {
pub Offset: u64,
pub pBuffer: ::core::option::Option<super::super::Graphics::Direct3D12::ID3D12Resource>,
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl D3D12_VIDEO_DECODE_OUTPUT_HISTOGRAM {}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::default::Default for D3D12_VIDEO_DECODE_OUTPUT_HISTOGRAM {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::fmt::Debug for D3D12_VIDEO_DECODE_OUTPUT_HISTOGRAM {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_DECODE_OUTPUT_HISTOGRAM").field("Offset", &self.Offset).field("pBuffer", &self.pBuffer).finish()
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_DECODE_OUTPUT_HISTOGRAM {
fn eq(&self, other: &Self) -> bool {
self.Offset == other.Offset && self.pBuffer == other.pBuffer
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::cmp::Eq for D3D12_VIDEO_DECODE_OUTPUT_HISTOGRAM {}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_DECODE_OUTPUT_HISTOGRAM {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
pub struct D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS {
pub pOutputTexture2D: ::core::option::Option<super::super::Graphics::Direct3D12::ID3D12Resource>,
pub OutputSubresource: u32,
pub ConversionArguments: D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
impl D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::default::Default for D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::fmt::Debug for D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS").field("pOutputTexture2D", &self.pOutputTexture2D).field("OutputSubresource", &self.OutputSubresource).field("ConversionArguments", &self.ConversionArguments).finish()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::cmp::PartialEq for D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS {
fn eq(&self, other: &Self) -> bool {
self.pOutputTexture2D == other.pOutputTexture2D && self.OutputSubresource == other.OutputSubresource && self.ConversionArguments == other.ConversionArguments
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::cmp::Eq for D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
pub struct D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS1 {
pub pOutputTexture2D: ::core::option::Option<super::super::Graphics::Direct3D12::ID3D12Resource>,
pub OutputSubresource: u32,
pub ConversionArguments: D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS1,
pub Histograms: [D3D12_VIDEO_DECODE_OUTPUT_HISTOGRAM; 4],
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
impl D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS1 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::default::Default for D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS1 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::cmp::PartialEq for D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS1 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::cmp::Eq for D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS1 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS1 {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
pub const D3D12_VIDEO_DECODE_PROFILE_AV1_12BIT_PROFILE2: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x17127009_a00f_4ce1_994e_bf4081f6f3f0);
pub const D3D12_VIDEO_DECODE_PROFILE_AV1_12BIT_PROFILE2_420: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2d80bed6_9cac_4835_9e91_327bbc4f9ee8);
pub const D3D12_VIDEO_DECODE_PROFILE_AV1_PROFILE0: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb8be4ccb_cf53_46ba_8d59_d6b8a6da5d2a);
pub const D3D12_VIDEO_DECODE_PROFILE_AV1_PROFILE1: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6936ff0f_45b1_4163_9cc1_646ef6946108);
pub const D3D12_VIDEO_DECODE_PROFILE_AV1_PROFILE2: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0c5f2aa1_e541_4089_bb7b_98110a19d7c8);
pub const D3D12_VIDEO_DECODE_PROFILE_H264: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1b81be68_a0c7_11d3_b984_00c04f2e73c5);
pub const D3D12_VIDEO_DECODE_PROFILE_H264_MULTIVIEW: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x705b9d82_76cf_49d6_b7e6_ac8872db013c);
pub const D3D12_VIDEO_DECODE_PROFILE_H264_STEREO: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf9aaccbb_c2b6_4cfc_8779_5707b1760552);
pub const D3D12_VIDEO_DECODE_PROFILE_H264_STEREO_PROGRESSIVE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd79be8da_0cf1_4c81_b82a_69a4e236f43d);
pub const D3D12_VIDEO_DECODE_PROFILE_HEVC_MAIN: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5b11d51b_2f4c_4452_bcc3_09f2a1160cc0);
pub const D3D12_VIDEO_DECODE_PROFILE_HEVC_MAIN10: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x107af0e0_ef1a_4d19_aba8_67a163073d13);
pub const D3D12_VIDEO_DECODE_PROFILE_MPEG1_AND_MPEG2: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x86695f12_340e_4f04_9fd3_9253dd327460);
pub const D3D12_VIDEO_DECODE_PROFILE_MPEG2: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xee27417f_5e28_4e65_beea_1d26b508adc9);
pub const D3D12_VIDEO_DECODE_PROFILE_MPEG4PT2_ADVSIMPLE_NOGMC: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xed418a9f_010d_4eda_9ae3_9a65358d8d2e);
pub const D3D12_VIDEO_DECODE_PROFILE_MPEG4PT2_SIMPLE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xefd64d74_c9e8_41d7_a5e9_e9b0e39fa319);
pub const D3D12_VIDEO_DECODE_PROFILE_VC1: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1b81bea3_a0c7_11d3_b984_00c04f2e73c5);
pub const D3D12_VIDEO_DECODE_PROFILE_VC1_D2010: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1b81bea4_a0c7_11d3_b984_00c04f2e73c5);
pub const D3D12_VIDEO_DECODE_PROFILE_VP8: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x90b899ea_3a62_4705_88b3_8df04b2744e7);
pub const D3D12_VIDEO_DECODE_PROFILE_VP9: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x463707f8_a1d0_4585_876d_83aa6d60b89e);
pub const D3D12_VIDEO_DECODE_PROFILE_VP9_10BIT_PROFILE2: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa4c749ef_6ecf_48aa_8448_50a7a1165ff7);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub struct D3D12_VIDEO_DECODE_REFERENCE_FRAMES {
pub NumTexture2Ds: u32,
pub ppTexture2Ds: *mut ::core::option::Option<super::super::Graphics::Direct3D12::ID3D12Resource>,
pub pSubresources: *mut u32,
pub ppHeaps: *mut ::core::option::Option<ID3D12VideoDecoderHeap>,
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl D3D12_VIDEO_DECODE_REFERENCE_FRAMES {}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::default::Default for D3D12_VIDEO_DECODE_REFERENCE_FRAMES {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::fmt::Debug for D3D12_VIDEO_DECODE_REFERENCE_FRAMES {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_DECODE_REFERENCE_FRAMES").field("NumTexture2Ds", &self.NumTexture2Ds).field("ppTexture2Ds", &self.ppTexture2Ds).field("pSubresources", &self.pSubresources).field("ppHeaps", &self.ppHeaps).finish()
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_DECODE_REFERENCE_FRAMES {
fn eq(&self, other: &Self) -> bool {
self.NumTexture2Ds == other.NumTexture2Ds && self.ppTexture2Ds == other.ppTexture2Ds && self.pSubresources == other.pSubresources && self.ppHeaps == other.ppHeaps
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::cmp::Eq for D3D12_VIDEO_DECODE_REFERENCE_FRAMES {}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_DECODE_REFERENCE_FRAMES {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_DECODE_STATUS(pub i32);
pub const D3D12_VIDEO_DECODE_STATUS_OK: D3D12_VIDEO_DECODE_STATUS = D3D12_VIDEO_DECODE_STATUS(0i32);
pub const D3D12_VIDEO_DECODE_STATUS_CONTINUE: D3D12_VIDEO_DECODE_STATUS = D3D12_VIDEO_DECODE_STATUS(1i32);
pub const D3D12_VIDEO_DECODE_STATUS_CONTINUE_SKIP_DISPLAY: D3D12_VIDEO_DECODE_STATUS = D3D12_VIDEO_DECODE_STATUS(2i32);
pub const D3D12_VIDEO_DECODE_STATUS_RESTART: D3D12_VIDEO_DECODE_STATUS = D3D12_VIDEO_DECODE_STATUS(3i32);
pub const D3D12_VIDEO_DECODE_STATUS_RATE_EXCEEDED: D3D12_VIDEO_DECODE_STATUS = D3D12_VIDEO_DECODE_STATUS(4i32);
impl ::core::convert::From<i32> for D3D12_VIDEO_DECODE_STATUS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_DECODE_STATUS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_DECODE_SUPPORT_FLAGS(pub u32);
pub const D3D12_VIDEO_DECODE_SUPPORT_FLAG_NONE: D3D12_VIDEO_DECODE_SUPPORT_FLAGS = D3D12_VIDEO_DECODE_SUPPORT_FLAGS(0u32);
pub const D3D12_VIDEO_DECODE_SUPPORT_FLAG_SUPPORTED: D3D12_VIDEO_DECODE_SUPPORT_FLAGS = D3D12_VIDEO_DECODE_SUPPORT_FLAGS(1u32);
impl ::core::convert::From<u32> for D3D12_VIDEO_DECODE_SUPPORT_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_DECODE_SUPPORT_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for D3D12_VIDEO_DECODE_SUPPORT_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for D3D12_VIDEO_DECODE_SUPPORT_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for D3D12_VIDEO_DECODE_SUPPORT_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for D3D12_VIDEO_DECODE_SUPPORT_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for D3D12_VIDEO_DECODE_SUPPORT_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_DECODE_TIER(pub i32);
pub const D3D12_VIDEO_DECODE_TIER_NOT_SUPPORTED: D3D12_VIDEO_DECODE_TIER = D3D12_VIDEO_DECODE_TIER(0i32);
pub const D3D12_VIDEO_DECODE_TIER_1: D3D12_VIDEO_DECODE_TIER = D3D12_VIDEO_DECODE_TIER(1i32);
pub const D3D12_VIDEO_DECODE_TIER_2: D3D12_VIDEO_DECODE_TIER = D3D12_VIDEO_DECODE_TIER(2i32);
pub const D3D12_VIDEO_DECODE_TIER_3: D3D12_VIDEO_DECODE_TIER = D3D12_VIDEO_DECODE_TIER(3i32);
impl ::core::convert::From<i32> for D3D12_VIDEO_DECODE_TIER {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_DECODE_TIER {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_CODEC(pub i32);
pub const D3D12_VIDEO_ENCODER_CODEC_H264: D3D12_VIDEO_ENCODER_CODEC = D3D12_VIDEO_ENCODER_CODEC(0i32);
pub const D3D12_VIDEO_ENCODER_CODEC_HEVC: D3D12_VIDEO_ENCODER_CODEC = D3D12_VIDEO_ENCODER_CODEC(1i32);
impl ::core::convert::From<i32> for D3D12_VIDEO_ENCODER_CODEC {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_CODEC {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION {
pub DataSize: u32,
pub Anonymous: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_0,
}
impl D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_0 {
pub pH264Config: *mut D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264,
pub pHEVCConfig: *mut D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC,
}
impl D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_0 {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_0 {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264 {
pub ConfigurationFlags: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS,
pub DirectModeConfig: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES,
pub DisableDeblockingFilterConfig: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODES,
}
impl D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264 {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264").field("ConfigurationFlags", &self.ConfigurationFlags).field("DirectModeConfig", &self.DirectModeConfig).field("DisableDeblockingFilterConfig", &self.DisableDeblockingFilterConfig).finish()
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264 {
fn eq(&self, other: &Self) -> bool {
self.ConfigurationFlags == other.ConfigurationFlags && self.DirectModeConfig == other.DirectModeConfig && self.DisableDeblockingFilterConfig == other.DisableDeblockingFilterConfig
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264 {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264 {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES(pub i32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES_DISABLED: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES(0i32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES_TEMPORAL: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES(1i32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES_SPATIAL: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES(2i32);
impl ::core::convert::From<i32> for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS(pub u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAG_NONE: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS(0u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAG_USE_CONSTRAINED_INTRAPREDICTION: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS(1u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAG_USE_ADAPTIVE_8x8_TRANSFORM: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS(2u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAG_ENABLE_CABAC_ENCODING: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS(4u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAG_ALLOW_REQUEST_INTRA_CONSTRAINED_SLICES: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS(8u32);
impl ::core::convert::From<u32> for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODES(pub i32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_0_ALL_LUMA_CHROMA_SLICE_BLOCK_EDGES_ALWAYS_FILTERED: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODES = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODES(0i32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_1_DISABLE_ALL_SLICE_BLOCK_EDGES: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODES = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODES(1i32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_2_DISABLE_SLICE_BOUNDARIES_BLOCKS: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODES = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODES(2i32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_3_USE_TWO_STAGE_DEBLOCKING: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODES = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODES(3i32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_4_DISABLE_CHROMA_BLOCK_EDGES: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODES = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODES(4i32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_5_DISABLE_CHROMA_BLOCK_EDGES_AND_LUMA_BOUNDARIES: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODES = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODES(5i32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_6_DISABLE_CHROMA_BLOCK_EDGES_AND_USE_LUMA_TWO_STAGE_DEBLOCKING: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODES = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODES(6i32);
impl ::core::convert::From<i32> for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODES {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODES {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS(pub u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_NONE: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS(0u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_0_ALL_LUMA_CHROMA_SLICE_BLOCK_EDGES_ALWAYS_FILTERED: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS(1u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_1_DISABLE_ALL_SLICE_BLOCK_EDGES: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS(2u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_2_DISABLE_SLICE_BOUNDARIES_BLOCKS: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS(4u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_3_USE_TWO_STAGE_DEBLOCKING: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS(8u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_4_DISABLE_CHROMA_BLOCK_EDGES: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS(16u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_5_DISABLE_CHROMA_BLOCK_EDGES_AND_LUMA_BOUNDARIES: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS(32u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_6_DISABLE_CHROMA_BLOCK_EDGES_AND_USE_LUMA_TWO_STAGE_DEBLOCKING: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS(64u32);
impl ::core::convert::From<u32> for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC {
pub ConfigurationFlags: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS,
pub MinLumaCodingUnitSize: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE,
pub MaxLumaCodingUnitSize: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE,
pub MinLumaTransformUnitSize: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE,
pub MaxLumaTransformUnitSize: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE,
pub max_transform_hierarchy_depth_inter: u8,
pub max_transform_hierarchy_depth_intra: u8,
}
impl D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC")
.field("ConfigurationFlags", &self.ConfigurationFlags)
.field("MinLumaCodingUnitSize", &self.MinLumaCodingUnitSize)
.field("MaxLumaCodingUnitSize", &self.MaxLumaCodingUnitSize)
.field("MinLumaTransformUnitSize", &self.MinLumaTransformUnitSize)
.field("MaxLumaTransformUnitSize", &self.MaxLumaTransformUnitSize)
.field("max_transform_hierarchy_depth_inter", &self.max_transform_hierarchy_depth_inter)
.field("max_transform_hierarchy_depth_intra", &self.max_transform_hierarchy_depth_intra)
.finish()
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC {
fn eq(&self, other: &Self) -> bool {
self.ConfigurationFlags == other.ConfigurationFlags && self.MinLumaCodingUnitSize == other.MinLumaCodingUnitSize && self.MaxLumaCodingUnitSize == other.MaxLumaCodingUnitSize && self.MinLumaTransformUnitSize == other.MinLumaTransformUnitSize && self.MaxLumaTransformUnitSize == other.MaxLumaTransformUnitSize && self.max_transform_hierarchy_depth_inter == other.max_transform_hierarchy_depth_inter && self.max_transform_hierarchy_depth_intra == other.max_transform_hierarchy_depth_intra
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE(pub i32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE_8x8: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE(0i32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE_16x16: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE(1i32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE_32x32: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE(2i32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE_64x64: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE(3i32);
impl ::core::convert::From<i32> for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS(pub u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_NONE: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS(0u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_DISABLE_LOOP_FILTER_ACROSS_SLICES: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS(1u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_ALLOW_REQUEST_INTRA_CONSTRAINED_SLICES: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS(2u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_ENABLE_SAO_FILTER: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS(4u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_ENABLE_LONG_TERM_REFERENCES: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS(8u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_USE_ASYMETRIC_MOTION_PARTITION: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS(16u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_ENABLE_TRANSFORM_SKIPPING: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS(32u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_USE_CONSTRAINED_INTRAPREDICTION: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS(64u32);
impl ::core::convert::From<u32> for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE(pub i32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE_4x4: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE(0i32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE_8x8: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE(1i32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE_16x16: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE(2i32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE_32x32: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE(3i32);
impl ::core::convert::From<i32> for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT {
pub DataSize: u32,
pub Anonymous: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_0,
}
impl D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_0 {
pub pH264Support: *mut D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264,
pub pHEVCSupport: *mut D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC,
}
impl D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_0 {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_0 {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264 {
pub SupportFlags: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS,
pub DisableDeblockingFilterSupportedModes: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS,
}
impl D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264 {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264").field("SupportFlags", &self.SupportFlags).field("DisableDeblockingFilterSupportedModes", &self.DisableDeblockingFilterSupportedModes).finish()
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264 {
fn eq(&self, other: &Self) -> bool {
self.SupportFlags == other.SupportFlags && self.DisableDeblockingFilterSupportedModes == other.DisableDeblockingFilterSupportedModes
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264 {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264 {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS(pub u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_NONE: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS(0u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_CABAC_ENCODING_SUPPORT: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS(1u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_INTRA_SLICE_CONSTRAINED_ENCODING_SUPPORT: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS(2u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_BFRAME_LTR_COMBINED_SUPPORT: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS(4u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_ADAPTIVE_8x8_TRANSFORM_ENCODING_SUPPORT: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS(8u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_DIRECT_SPATIAL_ENCODING_SUPPORT: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS(16u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_DIRECT_TEMPORAL_ENCODING_SUPPORT: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS(32u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_CONSTRAINED_INTRAPREDICTION_SUPPORT: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS(64u32);
impl ::core::convert::From<u32> for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC {
pub SupportFlags: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS,
pub MinLumaCodingUnitSize: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE,
pub MaxLumaCodingUnitSize: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE,
pub MinLumaTransformUnitSize: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE,
pub MaxLumaTransformUnitSize: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE,
pub max_transform_hierarchy_depth_inter: u8,
pub max_transform_hierarchy_depth_intra: u8,
}
impl D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC")
.field("SupportFlags", &self.SupportFlags)
.field("MinLumaCodingUnitSize", &self.MinLumaCodingUnitSize)
.field("MaxLumaCodingUnitSize", &self.MaxLumaCodingUnitSize)
.field("MinLumaTransformUnitSize", &self.MinLumaTransformUnitSize)
.field("MaxLumaTransformUnitSize", &self.MaxLumaTransformUnitSize)
.field("max_transform_hierarchy_depth_inter", &self.max_transform_hierarchy_depth_inter)
.field("max_transform_hierarchy_depth_intra", &self.max_transform_hierarchy_depth_intra)
.finish()
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC {
fn eq(&self, other: &Self) -> bool {
self.SupportFlags == other.SupportFlags && self.MinLumaCodingUnitSize == other.MinLumaCodingUnitSize && self.MaxLumaCodingUnitSize == other.MaxLumaCodingUnitSize && self.MinLumaTransformUnitSize == other.MinLumaTransformUnitSize && self.MaxLumaTransformUnitSize == other.MaxLumaTransformUnitSize && self.max_transform_hierarchy_depth_inter == other.max_transform_hierarchy_depth_inter && self.max_transform_hierarchy_depth_intra == other.max_transform_hierarchy_depth_intra
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS(pub u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_NONE: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS(0u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_BFRAME_LTR_COMBINED_SUPPORT: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS(1u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_INTRA_SLICE_CONSTRAINED_ENCODING_SUPPORT: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS(2u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_CONSTRAINED_INTRAPREDICTION_SUPPORT: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS(4u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_SAO_FILTER_SUPPORT: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS(8u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_ASYMETRIC_MOTION_PARTITION_SUPPORT: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS(16u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_ASYMETRIC_MOTION_PARTITION_REQUIRED: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS(32u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_TRANSFORM_SKIP_SUPPORT: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS(64u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_DISABLING_LOOP_FILTER_ACROSS_SLICES_SUPPORT: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS(128u32);
pub const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_P_FRAMES_IMPLEMENTED_AS_LOW_DELAY_B_FRAMES: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS = D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS(256u32);
impl ::core::convert::From<u32> for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT {
pub DataSize: u32,
pub Anonymous: D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_0,
}
impl D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_0 {
pub pH264Support: *mut D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_H264,
pub pHEVCSupport: *mut D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_HEVC,
}
impl D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_0 {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_0 {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_H264 {
pub MaxL0ReferencesForP: u32,
pub MaxL0ReferencesForB: u32,
pub MaxL1ReferencesForB: u32,
pub MaxLongTermReferences: u32,
pub MaxDPBCapacity: u32,
}
impl D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_H264 {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_H264 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_H264 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_H264")
.field("MaxL0ReferencesForP", &self.MaxL0ReferencesForP)
.field("MaxL0ReferencesForB", &self.MaxL0ReferencesForB)
.field("MaxL1ReferencesForB", &self.MaxL1ReferencesForB)
.field("MaxLongTermReferences", &self.MaxLongTermReferences)
.field("MaxDPBCapacity", &self.MaxDPBCapacity)
.finish()
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_H264 {
fn eq(&self, other: &Self) -> bool {
self.MaxL0ReferencesForP == other.MaxL0ReferencesForP && self.MaxL0ReferencesForB == other.MaxL0ReferencesForB && self.MaxL1ReferencesForB == other.MaxL1ReferencesForB && self.MaxLongTermReferences == other.MaxLongTermReferences && self.MaxDPBCapacity == other.MaxDPBCapacity
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_H264 {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_H264 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_HEVC {
pub MaxL0ReferencesForP: u32,
pub MaxL0ReferencesForB: u32,
pub MaxL1ReferencesForB: u32,
pub MaxLongTermReferences: u32,
pub MaxDPBCapacity: u32,
}
impl D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_HEVC {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_HEVC {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_HEVC {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_HEVC")
.field("MaxL0ReferencesForP", &self.MaxL0ReferencesForP)
.field("MaxL0ReferencesForB", &self.MaxL0ReferencesForB)
.field("MaxL1ReferencesForB", &self.MaxL1ReferencesForB)
.field("MaxLongTermReferences", &self.MaxLongTermReferences)
.field("MaxDPBCapacity", &self.MaxDPBCapacity)
.finish()
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_HEVC {
fn eq(&self, other: &Self) -> bool {
self.MaxL0ReferencesForP == other.MaxL0ReferencesForP && self.MaxL0ReferencesForB == other.MaxL0ReferencesForB && self.MaxL1ReferencesForB == other.MaxL1ReferencesForB && self.MaxLongTermReferences == other.MaxLongTermReferences && self.MaxDPBCapacity == other.MaxDPBCapacity
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_HEVC {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_HEVC {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub struct D3D12_VIDEO_ENCODER_COMPRESSED_BITSTREAM {
pub pBuffer: ::core::option::Option<super::super::Graphics::Direct3D12::ID3D12Resource>,
pub FrameStartOffset: u64,
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl D3D12_VIDEO_ENCODER_COMPRESSED_BITSTREAM {}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::default::Default for D3D12_VIDEO_ENCODER_COMPRESSED_BITSTREAM {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODER_COMPRESSED_BITSTREAM {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODER_COMPRESSED_BITSTREAM").field("pBuffer", &self.pBuffer).field("FrameStartOffset", &self.FrameStartOffset).finish()
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_COMPRESSED_BITSTREAM {
fn eq(&self, other: &Self) -> bool {
self.pBuffer == other.pBuffer && self.FrameStartOffset == other.FrameStartOffset
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_COMPRESSED_BITSTREAM {}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_COMPRESSED_BITSTREAM {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
pub struct D3D12_VIDEO_ENCODER_DESC {
pub NodeMask: u32,
pub Flags: D3D12_VIDEO_ENCODER_FLAGS,
pub EncodeCodec: D3D12_VIDEO_ENCODER_CODEC,
pub EncodeProfile: D3D12_VIDEO_ENCODER_PROFILE_DESC,
pub InputFormat: super::super::Graphics::Dxgi::Common::DXGI_FORMAT,
pub CodecConfiguration: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION,
pub MaxMotionEstimationPrecision: D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE,
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl D3D12_VIDEO_ENCODER_DESC {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::default::Default for D3D12_VIDEO_ENCODER_DESC {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_DESC {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_DESC {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_DESC {
type Abi = Self;
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::clone::Clone for D3D12_VIDEO_ENCODER_ENCODEFRAME_INPUT_ARGUMENTS {
fn clone(&self) -> Self {
unimplemented!()
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
pub struct D3D12_VIDEO_ENCODER_ENCODEFRAME_INPUT_ARGUMENTS {
pub SequenceControlDesc: D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_DESC,
pub PictureControlDesc: D3D12_VIDEO_ENCODER_PICTURE_CONTROL_DESC,
pub pInputFrame: ::core::option::Option<super::super::Graphics::Direct3D12::ID3D12Resource>,
pub InputFrameSubresource: u32,
pub CurrentFrameBitstreamMetadataSize: u32,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
impl D3D12_VIDEO_ENCODER_ENCODEFRAME_INPUT_ARGUMENTS {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::default::Default for D3D12_VIDEO_ENCODER_ENCODEFRAME_INPUT_ARGUMENTS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_ENCODEFRAME_INPUT_ARGUMENTS {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_ENCODEFRAME_INPUT_ARGUMENTS {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_ENCODEFRAME_INPUT_ARGUMENTS {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub struct D3D12_VIDEO_ENCODER_ENCODEFRAME_OUTPUT_ARGUMENTS {
pub Bitstream: D3D12_VIDEO_ENCODER_COMPRESSED_BITSTREAM,
pub ReconstructedPicture: D3D12_VIDEO_ENCODER_RECONSTRUCTED_PICTURE,
pub EncoderOutputMetadata: D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER,
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl D3D12_VIDEO_ENCODER_ENCODEFRAME_OUTPUT_ARGUMENTS {}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::default::Default for D3D12_VIDEO_ENCODER_ENCODEFRAME_OUTPUT_ARGUMENTS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODER_ENCODEFRAME_OUTPUT_ARGUMENTS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODER_ENCODEFRAME_OUTPUT_ARGUMENTS").field("Bitstream", &self.Bitstream).field("ReconstructedPicture", &self.ReconstructedPicture).field("EncoderOutputMetadata", &self.EncoderOutputMetadata).finish()
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_ENCODEFRAME_OUTPUT_ARGUMENTS {
fn eq(&self, other: &Self) -> bool {
self.Bitstream == other.Bitstream && self.ReconstructedPicture == other.ReconstructedPicture && self.EncoderOutputMetadata == other.EncoderOutputMetadata
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_ENCODEFRAME_OUTPUT_ARGUMENTS {}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_ENCODEFRAME_OUTPUT_ARGUMENTS {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS(pub u32);
pub const D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAG_NO_ERROR: D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS = D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS(0u32);
pub const D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAG_CODEC_PICTURE_CONTROL_NOT_SUPPORTED: D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS = D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS(1u32);
pub const D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAG_SUBREGION_LAYOUT_CONFIGURATION_NOT_SUPPORTED: D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS = D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS(2u32);
pub const D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAG_INVALID_REFERENCE_PICTURES: D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS = D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS(4u32);
pub const D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAG_RECONFIGURATION_REQUEST_NOT_SUPPORTED: D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS = D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS(8u32);
pub const D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAG_INVALID_METADATA_BUFFER_SOURCE: D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS = D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS(16u32);
impl ::core::convert::From<u32> for D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub struct D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER {
pub pBuffer: ::core::option::Option<super::super::Graphics::Direct3D12::ID3D12Resource>,
pub Offset: u64,
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER {}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::default::Default for D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER").field("pBuffer", &self.pBuffer).field("Offset", &self.Offset).finish()
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER {
fn eq(&self, other: &Self) -> bool {
self.pBuffer == other.pBuffer && self.Offset == other.Offset
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER {}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_FLAGS(pub u32);
pub const D3D12_VIDEO_ENCODER_FLAG_NONE: D3D12_VIDEO_ENCODER_FLAGS = D3D12_VIDEO_ENCODER_FLAGS(0u32);
impl ::core::convert::From<u32> for D3D12_VIDEO_ENCODER_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for D3D12_VIDEO_ENCODER_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for D3D12_VIDEO_ENCODER_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for D3D12_VIDEO_ENCODER_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for D3D12_VIDEO_ENCODER_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for D3D12_VIDEO_ENCODER_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE(pub i32);
pub const D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_FULL_FRAME: D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE = D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE(0i32);
pub const D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_BYTES_PER_SUBREGION: D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE = D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE(1i32);
pub const D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_SQUARE_UNITS_PER_SUBREGION_ROW_UNALIGNED: D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE = D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE(2i32);
pub const D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_UNIFORM_PARTITIONING_ROWS_PER_SUBREGION: D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE = D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE(3i32);
pub const D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_UNIFORM_PARTITIONING_SUBREGIONS_PER_FRAME: D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE = D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE(4i32);
impl ::core::convert::From<i32> for D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_FRAME_SUBREGION_METADATA {
pub bSize: u64,
pub bStartOffset: u64,
pub bHeaderSize: u64,
}
impl D3D12_VIDEO_ENCODER_FRAME_SUBREGION_METADATA {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_FRAME_SUBREGION_METADATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODER_FRAME_SUBREGION_METADATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODER_FRAME_SUBREGION_METADATA").field("bSize", &self.bSize).field("bStartOffset", &self.bStartOffset).field("bHeaderSize", &self.bHeaderSize).finish()
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_FRAME_SUBREGION_METADATA {
fn eq(&self, other: &Self) -> bool {
self.bSize == other.bSize && self.bStartOffset == other.bStartOffset && self.bHeaderSize == other.bHeaderSize
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_FRAME_SUBREGION_METADATA {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_FRAME_SUBREGION_METADATA {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_FRAME_TYPE_H264(pub i32);
pub const D3D12_VIDEO_ENCODER_FRAME_TYPE_H264_I_FRAME: D3D12_VIDEO_ENCODER_FRAME_TYPE_H264 = D3D12_VIDEO_ENCODER_FRAME_TYPE_H264(0i32);
pub const D3D12_VIDEO_ENCODER_FRAME_TYPE_H264_P_FRAME: D3D12_VIDEO_ENCODER_FRAME_TYPE_H264 = D3D12_VIDEO_ENCODER_FRAME_TYPE_H264(1i32);
pub const D3D12_VIDEO_ENCODER_FRAME_TYPE_H264_B_FRAME: D3D12_VIDEO_ENCODER_FRAME_TYPE_H264 = D3D12_VIDEO_ENCODER_FRAME_TYPE_H264(2i32);
pub const D3D12_VIDEO_ENCODER_FRAME_TYPE_H264_IDR_FRAME: D3D12_VIDEO_ENCODER_FRAME_TYPE_H264 = D3D12_VIDEO_ENCODER_FRAME_TYPE_H264(3i32);
impl ::core::convert::From<i32> for D3D12_VIDEO_ENCODER_FRAME_TYPE_H264 {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_FRAME_TYPE_H264 {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC(pub i32);
pub const D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC_I_FRAME: D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC = D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC(0i32);
pub const D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC_P_FRAME: D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC = D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC(1i32);
pub const D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC_B_FRAME: D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC = D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC(2i32);
pub const D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC_IDR_FRAME: D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC = D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC(3i32);
impl ::core::convert::From<i32> for D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_HEAP_DESC {
pub NodeMask: u32,
pub Flags: D3D12_VIDEO_ENCODER_HEAP_FLAGS,
pub EncodeCodec: D3D12_VIDEO_ENCODER_CODEC,
pub EncodeProfile: D3D12_VIDEO_ENCODER_PROFILE_DESC,
pub EncodeLevel: D3D12_VIDEO_ENCODER_LEVEL_SETTING,
pub ResolutionsListCount: u32,
pub pResolutionList: *mut D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC,
}
impl D3D12_VIDEO_ENCODER_HEAP_DESC {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_HEAP_DESC {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_HEAP_DESC {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_HEAP_DESC {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_HEAP_DESC {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_HEAP_FLAGS(pub u32);
pub const D3D12_VIDEO_ENCODER_HEAP_FLAG_NONE: D3D12_VIDEO_ENCODER_HEAP_FLAGS = D3D12_VIDEO_ENCODER_HEAP_FLAGS(0u32);
impl ::core::convert::From<u32> for D3D12_VIDEO_ENCODER_HEAP_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_HEAP_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for D3D12_VIDEO_ENCODER_HEAP_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for D3D12_VIDEO_ENCODER_HEAP_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for D3D12_VIDEO_ENCODER_HEAP_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for D3D12_VIDEO_ENCODER_HEAP_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for D3D12_VIDEO_ENCODER_HEAP_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_INTRA_REFRESH {
pub Mode: D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE,
pub IntraRefreshDuration: u32,
}
impl D3D12_VIDEO_ENCODER_INTRA_REFRESH {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_INTRA_REFRESH {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODER_INTRA_REFRESH {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODER_INTRA_REFRESH").field("Mode", &self.Mode).field("IntraRefreshDuration", &self.IntraRefreshDuration).finish()
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_INTRA_REFRESH {
fn eq(&self, other: &Self) -> bool {
self.Mode == other.Mode && self.IntraRefreshDuration == other.IntraRefreshDuration
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_INTRA_REFRESH {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_INTRA_REFRESH {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE(pub i32);
pub const D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE_NONE: D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE = D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE(0i32);
pub const D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE_ROW_BASED: D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE = D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE(1i32);
impl ::core::convert::From<i32> for D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_LEVELS_H264(pub i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_H264_1: D3D12_VIDEO_ENCODER_LEVELS_H264 = D3D12_VIDEO_ENCODER_LEVELS_H264(0i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_H264_1b: D3D12_VIDEO_ENCODER_LEVELS_H264 = D3D12_VIDEO_ENCODER_LEVELS_H264(1i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_H264_11: D3D12_VIDEO_ENCODER_LEVELS_H264 = D3D12_VIDEO_ENCODER_LEVELS_H264(2i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_H264_12: D3D12_VIDEO_ENCODER_LEVELS_H264 = D3D12_VIDEO_ENCODER_LEVELS_H264(3i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_H264_13: D3D12_VIDEO_ENCODER_LEVELS_H264 = D3D12_VIDEO_ENCODER_LEVELS_H264(4i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_H264_2: D3D12_VIDEO_ENCODER_LEVELS_H264 = D3D12_VIDEO_ENCODER_LEVELS_H264(5i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_H264_21: D3D12_VIDEO_ENCODER_LEVELS_H264 = D3D12_VIDEO_ENCODER_LEVELS_H264(6i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_H264_22: D3D12_VIDEO_ENCODER_LEVELS_H264 = D3D12_VIDEO_ENCODER_LEVELS_H264(7i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_H264_3: D3D12_VIDEO_ENCODER_LEVELS_H264 = D3D12_VIDEO_ENCODER_LEVELS_H264(8i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_H264_31: D3D12_VIDEO_ENCODER_LEVELS_H264 = D3D12_VIDEO_ENCODER_LEVELS_H264(9i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_H264_32: D3D12_VIDEO_ENCODER_LEVELS_H264 = D3D12_VIDEO_ENCODER_LEVELS_H264(10i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_H264_4: D3D12_VIDEO_ENCODER_LEVELS_H264 = D3D12_VIDEO_ENCODER_LEVELS_H264(11i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_H264_41: D3D12_VIDEO_ENCODER_LEVELS_H264 = D3D12_VIDEO_ENCODER_LEVELS_H264(12i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_H264_42: D3D12_VIDEO_ENCODER_LEVELS_H264 = D3D12_VIDEO_ENCODER_LEVELS_H264(13i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_H264_5: D3D12_VIDEO_ENCODER_LEVELS_H264 = D3D12_VIDEO_ENCODER_LEVELS_H264(14i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_H264_51: D3D12_VIDEO_ENCODER_LEVELS_H264 = D3D12_VIDEO_ENCODER_LEVELS_H264(15i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_H264_52: D3D12_VIDEO_ENCODER_LEVELS_H264 = D3D12_VIDEO_ENCODER_LEVELS_H264(16i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_H264_6: D3D12_VIDEO_ENCODER_LEVELS_H264 = D3D12_VIDEO_ENCODER_LEVELS_H264(17i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_H264_61: D3D12_VIDEO_ENCODER_LEVELS_H264 = D3D12_VIDEO_ENCODER_LEVELS_H264(18i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_H264_62: D3D12_VIDEO_ENCODER_LEVELS_H264 = D3D12_VIDEO_ENCODER_LEVELS_H264(19i32);
impl ::core::convert::From<i32> for D3D12_VIDEO_ENCODER_LEVELS_H264 {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_LEVELS_H264 {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_LEVELS_HEVC(pub i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_HEVC_1: D3D12_VIDEO_ENCODER_LEVELS_HEVC = D3D12_VIDEO_ENCODER_LEVELS_HEVC(0i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_HEVC_2: D3D12_VIDEO_ENCODER_LEVELS_HEVC = D3D12_VIDEO_ENCODER_LEVELS_HEVC(1i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_HEVC_21: D3D12_VIDEO_ENCODER_LEVELS_HEVC = D3D12_VIDEO_ENCODER_LEVELS_HEVC(2i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_HEVC_3: D3D12_VIDEO_ENCODER_LEVELS_HEVC = D3D12_VIDEO_ENCODER_LEVELS_HEVC(3i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_HEVC_31: D3D12_VIDEO_ENCODER_LEVELS_HEVC = D3D12_VIDEO_ENCODER_LEVELS_HEVC(4i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_HEVC_4: D3D12_VIDEO_ENCODER_LEVELS_HEVC = D3D12_VIDEO_ENCODER_LEVELS_HEVC(5i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_HEVC_41: D3D12_VIDEO_ENCODER_LEVELS_HEVC = D3D12_VIDEO_ENCODER_LEVELS_HEVC(6i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_HEVC_5: D3D12_VIDEO_ENCODER_LEVELS_HEVC = D3D12_VIDEO_ENCODER_LEVELS_HEVC(7i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_HEVC_51: D3D12_VIDEO_ENCODER_LEVELS_HEVC = D3D12_VIDEO_ENCODER_LEVELS_HEVC(8i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_HEVC_52: D3D12_VIDEO_ENCODER_LEVELS_HEVC = D3D12_VIDEO_ENCODER_LEVELS_HEVC(9i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_HEVC_6: D3D12_VIDEO_ENCODER_LEVELS_HEVC = D3D12_VIDEO_ENCODER_LEVELS_HEVC(10i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_HEVC_61: D3D12_VIDEO_ENCODER_LEVELS_HEVC = D3D12_VIDEO_ENCODER_LEVELS_HEVC(11i32);
pub const D3D12_VIDEO_ENCODER_LEVELS_HEVC_62: D3D12_VIDEO_ENCODER_LEVELS_HEVC = D3D12_VIDEO_ENCODER_LEVELS_HEVC(12i32);
impl ::core::convert::From<i32> for D3D12_VIDEO_ENCODER_LEVELS_HEVC {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_LEVELS_HEVC {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_LEVEL_SETTING {
pub DataSize: u32,
pub Anonymous: D3D12_VIDEO_ENCODER_LEVEL_SETTING_0,
}
impl D3D12_VIDEO_ENCODER_LEVEL_SETTING {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_LEVEL_SETTING {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_LEVEL_SETTING {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_LEVEL_SETTING {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_LEVEL_SETTING {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union D3D12_VIDEO_ENCODER_LEVEL_SETTING_0 {
pub pH264LevelSetting: *mut D3D12_VIDEO_ENCODER_LEVELS_H264,
pub pHEVCLevelSetting: *mut D3D12_VIDEO_ENCODER_LEVEL_TIER_CONSTRAINTS_HEVC,
}
impl D3D12_VIDEO_ENCODER_LEVEL_SETTING_0 {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_LEVEL_SETTING_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_LEVEL_SETTING_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_LEVEL_SETTING_0 {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_LEVEL_SETTING_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_LEVEL_TIER_CONSTRAINTS_HEVC {
pub Level: D3D12_VIDEO_ENCODER_LEVELS_HEVC,
pub Tier: D3D12_VIDEO_ENCODER_TIER_HEVC,
}
impl D3D12_VIDEO_ENCODER_LEVEL_TIER_CONSTRAINTS_HEVC {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_LEVEL_TIER_CONSTRAINTS_HEVC {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODER_LEVEL_TIER_CONSTRAINTS_HEVC {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODER_LEVEL_TIER_CONSTRAINTS_HEVC").field("Level", &self.Level).field("Tier", &self.Tier).finish()
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_LEVEL_TIER_CONSTRAINTS_HEVC {
fn eq(&self, other: &Self) -> bool {
self.Level == other.Level && self.Tier == other.Tier
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_LEVEL_TIER_CONSTRAINTS_HEVC {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_LEVEL_TIER_CONSTRAINTS_HEVC {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE(pub i32);
pub const D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE_MAXIMUM: D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE = D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE(0i32);
pub const D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE_FULL_PIXEL: D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE = D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE(1i32);
pub const D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE_HALF_PIXEL: D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE = D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE(2i32);
pub const D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE_QUARTER_PIXEL: D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE = D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE(3i32);
impl ::core::convert::From<i32> for D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_OUTPUT_METADATA {
pub EncodeErrorFlags: u64,
pub EncodeStats: D3D12_VIDEO_ENCODER_OUTPUT_METADATA_STATISTICS,
pub EncodedBitstreamWrittenBytesCount: u64,
pub WrittenSubregionsCount: u64,
}
impl D3D12_VIDEO_ENCODER_OUTPUT_METADATA {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_OUTPUT_METADATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODER_OUTPUT_METADATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODER_OUTPUT_METADATA").field("EncodeErrorFlags", &self.EncodeErrorFlags).field("EncodeStats", &self.EncodeStats).field("EncodedBitstreamWrittenBytesCount", &self.EncodedBitstreamWrittenBytesCount).field("WrittenSubregionsCount", &self.WrittenSubregionsCount).finish()
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_OUTPUT_METADATA {
fn eq(&self, other: &Self) -> bool {
self.EncodeErrorFlags == other.EncodeErrorFlags && self.EncodeStats == other.EncodeStats && self.EncodedBitstreamWrittenBytesCount == other.EncodedBitstreamWrittenBytesCount && self.WrittenSubregionsCount == other.WrittenSubregionsCount
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_OUTPUT_METADATA {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_OUTPUT_METADATA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_OUTPUT_METADATA_STATISTICS {
pub AverageQP: u64,
pub IntraCodingUnitsCount: u64,
pub InterCodingUnitsCount: u64,
pub SkipCodingUnitsCount: u64,
pub AverageMotionEstimationXDirection: u64,
pub AverageMotionEstimationYDirection: u64,
}
impl D3D12_VIDEO_ENCODER_OUTPUT_METADATA_STATISTICS {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_OUTPUT_METADATA_STATISTICS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODER_OUTPUT_METADATA_STATISTICS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODER_OUTPUT_METADATA_STATISTICS")
.field("AverageQP", &self.AverageQP)
.field("IntraCodingUnitsCount", &self.IntraCodingUnitsCount)
.field("InterCodingUnitsCount", &self.InterCodingUnitsCount)
.field("SkipCodingUnitsCount", &self.SkipCodingUnitsCount)
.field("AverageMotionEstimationXDirection", &self.AverageMotionEstimationXDirection)
.field("AverageMotionEstimationYDirection", &self.AverageMotionEstimationYDirection)
.finish()
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_OUTPUT_METADATA_STATISTICS {
fn eq(&self, other: &Self) -> bool {
self.AverageQP == other.AverageQP && self.IntraCodingUnitsCount == other.IntraCodingUnitsCount && self.InterCodingUnitsCount == other.InterCodingUnitsCount && self.SkipCodingUnitsCount == other.SkipCodingUnitsCount && self.AverageMotionEstimationXDirection == other.AverageMotionEstimationXDirection && self.AverageMotionEstimationYDirection == other.AverageMotionEstimationYDirection
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_OUTPUT_METADATA_STATISTICS {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_OUTPUT_METADATA_STATISTICS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA {
pub DataSize: u32,
pub Anonymous: D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_0,
}
#[cfg(feature = "Win32_Foundation")]
impl D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub union D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_0 {
pub pH264PicData: *mut D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264,
pub pHEVCPicData: *mut D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC,
}
#[cfg(feature = "Win32_Foundation")]
impl D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_0 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_0 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264 {
pub Flags: D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS,
pub FrameType: D3D12_VIDEO_ENCODER_FRAME_TYPE_H264,
pub pic_parameter_set_id: u32,
pub idr_pic_id: u32,
pub PictureOrderCountNumber: u32,
pub FrameDecodingOrderNumber: u32,
pub TemporalLayerIndex: u32,
pub List0ReferenceFramesCount: u32,
pub pList0ReferenceFrames: *mut u32,
pub List1ReferenceFramesCount: u32,
pub pList1ReferenceFrames: *mut u32,
pub ReferenceFramesReconPictureDescriptorsCount: u32,
pub pReferenceFramesReconPictureDescriptors: *mut D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_H264,
pub adaptive_ref_pic_marking_mode_flag: u8,
pub RefPicMarkingOperationsCommandsCount: u32,
pub pRefPicMarkingOperationsCommands: *mut D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_MARKING_OPERATION,
pub List0RefPicModificationsCount: u32,
pub pList0RefPicModifications: *mut D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_LIST_MODIFICATION_OPERATION,
pub List1RefPicModificationsCount: u32,
pub pList1RefPicModifications: *mut D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_LIST_MODIFICATION_OPERATION,
pub QPMapValuesCount: u32,
pub pRateControlQPMap: *mut i8,
}
#[cfg(feature = "Win32_Foundation")]
impl D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264")
.field("Flags", &self.Flags)
.field("FrameType", &self.FrameType)
.field("pic_parameter_set_id", &self.pic_parameter_set_id)
.field("idr_pic_id", &self.idr_pic_id)
.field("PictureOrderCountNumber", &self.PictureOrderCountNumber)
.field("FrameDecodingOrderNumber", &self.FrameDecodingOrderNumber)
.field("TemporalLayerIndex", &self.TemporalLayerIndex)
.field("List0ReferenceFramesCount", &self.List0ReferenceFramesCount)
.field("pList0ReferenceFrames", &self.pList0ReferenceFrames)
.field("List1ReferenceFramesCount", &self.List1ReferenceFramesCount)
.field("pList1ReferenceFrames", &self.pList1ReferenceFrames)
.field("ReferenceFramesReconPictureDescriptorsCount", &self.ReferenceFramesReconPictureDescriptorsCount)
.field("pReferenceFramesReconPictureDescriptors", &self.pReferenceFramesReconPictureDescriptors)
.field("adaptive_ref_pic_marking_mode_flag", &self.adaptive_ref_pic_marking_mode_flag)
.field("RefPicMarkingOperationsCommandsCount", &self.RefPicMarkingOperationsCommandsCount)
.field("pRefPicMarkingOperationsCommands", &self.pRefPicMarkingOperationsCommands)
.field("List0RefPicModificationsCount", &self.List0RefPicModificationsCount)
.field("pList0RefPicModifications", &self.pList0RefPicModifications)
.field("List1RefPicModificationsCount", &self.List1RefPicModificationsCount)
.field("pList1RefPicModifications", &self.pList1RefPicModifications)
.field("QPMapValuesCount", &self.QPMapValuesCount)
.field("pRateControlQPMap", &self.pRateControlQPMap)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264 {
fn eq(&self, other: &Self) -> bool {
self.Flags == other.Flags
&& self.FrameType == other.FrameType
&& self.pic_parameter_set_id == other.pic_parameter_set_id
&& self.idr_pic_id == other.idr_pic_id
&& self.PictureOrderCountNumber == other.PictureOrderCountNumber
&& self.FrameDecodingOrderNumber == other.FrameDecodingOrderNumber
&& self.TemporalLayerIndex == other.TemporalLayerIndex
&& self.List0ReferenceFramesCount == other.List0ReferenceFramesCount
&& self.pList0ReferenceFrames == other.pList0ReferenceFrames
&& self.List1ReferenceFramesCount == other.List1ReferenceFramesCount
&& self.pList1ReferenceFrames == other.pList1ReferenceFrames
&& self.ReferenceFramesReconPictureDescriptorsCount == other.ReferenceFramesReconPictureDescriptorsCount
&& self.pReferenceFramesReconPictureDescriptors == other.pReferenceFramesReconPictureDescriptors
&& self.adaptive_ref_pic_marking_mode_flag == other.adaptive_ref_pic_marking_mode_flag
&& self.RefPicMarkingOperationsCommandsCount == other.RefPicMarkingOperationsCommandsCount
&& self.pRefPicMarkingOperationsCommands == other.pRefPicMarkingOperationsCommands
&& self.List0RefPicModificationsCount == other.List0RefPicModificationsCount
&& self.pList0RefPicModifications == other.pList0RefPicModifications
&& self.List1RefPicModificationsCount == other.List1RefPicModificationsCount
&& self.pList1RefPicModifications == other.pList1RefPicModifications
&& self.QPMapValuesCount == other.QPMapValuesCount
&& self.pRateControlQPMap == other.pRateControlQPMap
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264 {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS(pub u32);
pub const D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAG_NONE: D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS = D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS(0u32);
pub const D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAG_REQUEST_INTRA_CONSTRAINED_SLICES: D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS = D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS(1u32);
impl ::core::convert::From<u32> for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_LIST_MODIFICATION_OPERATION {
pub modification_of_pic_nums_idc: u8,
pub abs_diff_pic_num_minus1: u32,
pub long_term_pic_num: u32,
}
impl D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_LIST_MODIFICATION_OPERATION {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_LIST_MODIFICATION_OPERATION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_LIST_MODIFICATION_OPERATION {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_LIST_MODIFICATION_OPERATION")
.field("modification_of_pic_nums_idc", &self.modification_of_pic_nums_idc)
.field("abs_diff_pic_num_minus1", &self.abs_diff_pic_num_minus1)
.field("long_term_pic_num", &self.long_term_pic_num)
.finish()
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_LIST_MODIFICATION_OPERATION {
fn eq(&self, other: &Self) -> bool {
self.modification_of_pic_nums_idc == other.modification_of_pic_nums_idc && self.abs_diff_pic_num_minus1 == other.abs_diff_pic_num_minus1 && self.long_term_pic_num == other.long_term_pic_num
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_LIST_MODIFICATION_OPERATION {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_LIST_MODIFICATION_OPERATION {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_MARKING_OPERATION {
pub memory_management_control_operation: u8,
pub difference_of_pic_nums_minus1: u32,
pub long_term_pic_num: u32,
pub long_term_frame_idx: u32,
pub max_long_term_frame_idx_plus1: u32,
}
impl D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_MARKING_OPERATION {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_MARKING_OPERATION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_MARKING_OPERATION {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_MARKING_OPERATION")
.field("memory_management_control_operation", &self.memory_management_control_operation)
.field("difference_of_pic_nums_minus1", &self.difference_of_pic_nums_minus1)
.field("long_term_pic_num", &self.long_term_pic_num)
.field("long_term_frame_idx", &self.long_term_frame_idx)
.field("max_long_term_frame_idx_plus1", &self.max_long_term_frame_idx_plus1)
.finish()
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_MARKING_OPERATION {
fn eq(&self, other: &Self) -> bool {
self.memory_management_control_operation == other.memory_management_control_operation && self.difference_of_pic_nums_minus1 == other.difference_of_pic_nums_minus1 && self.long_term_pic_num == other.long_term_pic_num && self.long_term_frame_idx == other.long_term_frame_idx && self.max_long_term_frame_idx_plus1 == other.max_long_term_frame_idx_plus1
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_MARKING_OPERATION {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_MARKING_OPERATION {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC {
pub Flags: D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS,
pub FrameType: D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC,
pub slice_pic_parameter_set_id: u32,
pub PictureOrderCountNumber: u32,
pub TemporalLayerIndex: u32,
pub List0ReferenceFramesCount: u32,
pub pList0ReferenceFrames: *mut u32,
pub List1ReferenceFramesCount: u32,
pub pList1ReferenceFrames: *mut u32,
pub ReferenceFramesReconPictureDescriptorsCount: u32,
pub pReferenceFramesReconPictureDescriptors: *mut D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_HEVC,
pub List0RefPicModificationsCount: u32,
pub pList0RefPicModifications: *mut u32,
pub List1RefPicModificationsCount: u32,
pub pList1RefPicModifications: *mut u32,
pub QPMapValuesCount: u32,
pub pRateControlQPMap: *mut i8,
}
#[cfg(feature = "Win32_Foundation")]
impl D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC")
.field("Flags", &self.Flags)
.field("FrameType", &self.FrameType)
.field("slice_pic_parameter_set_id", &self.slice_pic_parameter_set_id)
.field("PictureOrderCountNumber", &self.PictureOrderCountNumber)
.field("TemporalLayerIndex", &self.TemporalLayerIndex)
.field("List0ReferenceFramesCount", &self.List0ReferenceFramesCount)
.field("pList0ReferenceFrames", &self.pList0ReferenceFrames)
.field("List1ReferenceFramesCount", &self.List1ReferenceFramesCount)
.field("pList1ReferenceFrames", &self.pList1ReferenceFrames)
.field("ReferenceFramesReconPictureDescriptorsCount", &self.ReferenceFramesReconPictureDescriptorsCount)
.field("pReferenceFramesReconPictureDescriptors", &self.pReferenceFramesReconPictureDescriptors)
.field("List0RefPicModificationsCount", &self.List0RefPicModificationsCount)
.field("pList0RefPicModifications", &self.pList0RefPicModifications)
.field("List1RefPicModificationsCount", &self.List1RefPicModificationsCount)
.field("pList1RefPicModifications", &self.pList1RefPicModifications)
.field("QPMapValuesCount", &self.QPMapValuesCount)
.field("pRateControlQPMap", &self.pRateControlQPMap)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC {
fn eq(&self, other: &Self) -> bool {
self.Flags == other.Flags
&& self.FrameType == other.FrameType
&& self.slice_pic_parameter_set_id == other.slice_pic_parameter_set_id
&& self.PictureOrderCountNumber == other.PictureOrderCountNumber
&& self.TemporalLayerIndex == other.TemporalLayerIndex
&& self.List0ReferenceFramesCount == other.List0ReferenceFramesCount
&& self.pList0ReferenceFrames == other.pList0ReferenceFrames
&& self.List1ReferenceFramesCount == other.List1ReferenceFramesCount
&& self.pList1ReferenceFrames == other.pList1ReferenceFrames
&& self.ReferenceFramesReconPictureDescriptorsCount == other.ReferenceFramesReconPictureDescriptorsCount
&& self.pReferenceFramesReconPictureDescriptors == other.pReferenceFramesReconPictureDescriptors
&& self.List0RefPicModificationsCount == other.List0RefPicModificationsCount
&& self.pList0RefPicModifications == other.pList0RefPicModifications
&& self.List1RefPicModificationsCount == other.List1RefPicModificationsCount
&& self.pList1RefPicModifications == other.pList1RefPicModifications
&& self.QPMapValuesCount == other.QPMapValuesCount
&& self.pRateControlQPMap == other.pRateControlQPMap
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS(pub u32);
pub const D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAG_NONE: D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS = D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS(0u32);
pub const D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAG_REQUEST_INTRA_CONSTRAINED_SLICES: D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS = D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS(1u32);
impl ::core::convert::From<u32> for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
pub struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_DESC {
pub IntraRefreshFrameIndex: u32,
pub Flags: D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS,
pub PictureControlCodecData: D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA,
pub ReferenceFrames: D3D12_VIDEO_ENCODE_REFERENCE_FRAMES,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
impl D3D12_VIDEO_ENCODER_PICTURE_CONTROL_DESC {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
impl ::core::default::Default for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_DESC {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_DESC {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_DESC {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_DESC {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS(pub u32);
pub const D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAG_NONE: D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS = D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS(0u32);
pub const D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAG_USED_AS_REFERENCE_PICTURE: D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS = D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS(1u32);
impl ::core::convert::From<u32> for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA {
pub DataSize: u32,
pub Anonymous: D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_0,
}
impl D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_0 {
pub pSlicesPartition_H264: *mut D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES,
pub pSlicesPartition_HEVC: *mut D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES,
}
impl D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_0 {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_0 {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES {
pub Anonymous: D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES_0,
}
impl D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES_0 {
pub MaxBytesPerSlice: u32,
pub NumberOfCodingUnitsPerSlice: u32,
pub NumberOfRowsPerSlice: u32,
pub NumberOfSlicesPerFrame: u32,
}
impl D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES_0 {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES_0 {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC {
pub Width: u32,
pub Height: u32,
}
impl D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC").field("Width", &self.Width).field("Height", &self.Height).finish()
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC {
fn eq(&self, other: &Self) -> bool {
self.Width == other.Width && self.Height == other.Height
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_RATIO_DESC {
pub WidthRatio: u32,
pub HeightRatio: u32,
}
impl D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_RATIO_DESC {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_RATIO_DESC {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_RATIO_DESC {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_RATIO_DESC").field("WidthRatio", &self.WidthRatio).field("HeightRatio", &self.HeightRatio).finish()
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_RATIO_DESC {
fn eq(&self, other: &Self) -> bool {
self.WidthRatio == other.WidthRatio && self.HeightRatio == other.HeightRatio
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_RATIO_DESC {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_RATIO_DESC {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_PROFILE_DESC {
pub DataSize: u32,
pub Anonymous: D3D12_VIDEO_ENCODER_PROFILE_DESC_0,
}
impl D3D12_VIDEO_ENCODER_PROFILE_DESC {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_PROFILE_DESC {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_PROFILE_DESC {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_PROFILE_DESC {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_PROFILE_DESC {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union D3D12_VIDEO_ENCODER_PROFILE_DESC_0 {
pub pH264Profile: *mut D3D12_VIDEO_ENCODER_PROFILE_H264,
pub pHEVCProfile: *mut D3D12_VIDEO_ENCODER_PROFILE_HEVC,
}
impl D3D12_VIDEO_ENCODER_PROFILE_DESC_0 {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_PROFILE_DESC_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_PROFILE_DESC_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_PROFILE_DESC_0 {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_PROFILE_DESC_0 {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_PROFILE_H264(pub i32);
pub const D3D12_VIDEO_ENCODER_PROFILE_H264_MAIN: D3D12_VIDEO_ENCODER_PROFILE_H264 = D3D12_VIDEO_ENCODER_PROFILE_H264(0i32);
pub const D3D12_VIDEO_ENCODER_PROFILE_H264_HIGH: D3D12_VIDEO_ENCODER_PROFILE_H264 = D3D12_VIDEO_ENCODER_PROFILE_H264(1i32);
pub const D3D12_VIDEO_ENCODER_PROFILE_H264_HIGH_10: D3D12_VIDEO_ENCODER_PROFILE_H264 = D3D12_VIDEO_ENCODER_PROFILE_H264(2i32);
impl ::core::convert::From<i32> for D3D12_VIDEO_ENCODER_PROFILE_H264 {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_PROFILE_H264 {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_PROFILE_HEVC(pub i32);
pub const D3D12_VIDEO_ENCODER_PROFILE_HEVC_MAIN: D3D12_VIDEO_ENCODER_PROFILE_HEVC = D3D12_VIDEO_ENCODER_PROFILE_HEVC(0i32);
pub const D3D12_VIDEO_ENCODER_PROFILE_HEVC_MAIN10: D3D12_VIDEO_ENCODER_PROFILE_HEVC = D3D12_VIDEO_ENCODER_PROFILE_HEVC(1i32);
impl ::core::convert::From<i32> for D3D12_VIDEO_ENCODER_PROFILE_HEVC {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_PROFILE_HEVC {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
pub struct D3D12_VIDEO_ENCODER_RATE_CONTROL {
pub Mode: D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE,
pub Flags: D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS,
pub ConfigParams: D3D12_VIDEO_ENCODER_RATE_CONTROL_CONFIGURATION_PARAMS,
pub TargetFrameRate: super::super::Graphics::Dxgi::Common::DXGI_RATIONAL,
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl D3D12_VIDEO_ENCODER_RATE_CONTROL {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::default::Default for D3D12_VIDEO_ENCODER_RATE_CONTROL {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_RATE_CONTROL {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_RATE_CONTROL {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_RATE_CONTROL {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_RATE_CONTROL_CBR {
pub InitialQP: u32,
pub MinQP: u32,
pub MaxQP: u32,
pub MaxFrameBitSize: u64,
pub TargetBitRate: u64,
pub VBVCapacity: u64,
pub InitialVBVFullness: u64,
}
impl D3D12_VIDEO_ENCODER_RATE_CONTROL_CBR {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_RATE_CONTROL_CBR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODER_RATE_CONTROL_CBR {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODER_RATE_CONTROL_CBR")
.field("InitialQP", &self.InitialQP)
.field("MinQP", &self.MinQP)
.field("MaxQP", &self.MaxQP)
.field("MaxFrameBitSize", &self.MaxFrameBitSize)
.field("TargetBitRate", &self.TargetBitRate)
.field("VBVCapacity", &self.VBVCapacity)
.field("InitialVBVFullness", &self.InitialVBVFullness)
.finish()
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_RATE_CONTROL_CBR {
fn eq(&self, other: &Self) -> bool {
self.InitialQP == other.InitialQP && self.MinQP == other.MinQP && self.MaxQP == other.MaxQP && self.MaxFrameBitSize == other.MaxFrameBitSize && self.TargetBitRate == other.TargetBitRate && self.VBVCapacity == other.VBVCapacity && self.InitialVBVFullness == other.InitialVBVFullness
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_RATE_CONTROL_CBR {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_RATE_CONTROL_CBR {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_RATE_CONTROL_CONFIGURATION_PARAMS {
pub DataSize: u32,
pub Anonymous: D3D12_VIDEO_ENCODER_RATE_CONTROL_CONFIGURATION_PARAMS_0,
}
impl D3D12_VIDEO_ENCODER_RATE_CONTROL_CONFIGURATION_PARAMS {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_RATE_CONTROL_CONFIGURATION_PARAMS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_RATE_CONTROL_CONFIGURATION_PARAMS {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_RATE_CONTROL_CONFIGURATION_PARAMS {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_RATE_CONTROL_CONFIGURATION_PARAMS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union D3D12_VIDEO_ENCODER_RATE_CONTROL_CONFIGURATION_PARAMS_0 {
pub pConfiguration_CQP: *mut D3D12_VIDEO_ENCODER_RATE_CONTROL_CQP,
pub pConfiguration_CBR: *mut D3D12_VIDEO_ENCODER_RATE_CONTROL_CBR,
pub pConfiguration_VBR: *mut D3D12_VIDEO_ENCODER_RATE_CONTROL_VBR,
pub pConfiguration_QVBR: *mut D3D12_VIDEO_ENCODER_RATE_CONTROL_QVBR,
}
impl D3D12_VIDEO_ENCODER_RATE_CONTROL_CONFIGURATION_PARAMS_0 {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_RATE_CONTROL_CONFIGURATION_PARAMS_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_RATE_CONTROL_CONFIGURATION_PARAMS_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_RATE_CONTROL_CONFIGURATION_PARAMS_0 {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_RATE_CONTROL_CONFIGURATION_PARAMS_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_RATE_CONTROL_CQP {
pub ConstantQP_FullIntracodedFrame: u32,
pub ConstantQP_InterPredictedFrame_PrevRefOnly: u32,
pub ConstantQP_InterPredictedFrame_BiDirectionalRef: u32,
}
impl D3D12_VIDEO_ENCODER_RATE_CONTROL_CQP {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_RATE_CONTROL_CQP {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODER_RATE_CONTROL_CQP {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODER_RATE_CONTROL_CQP")
.field("ConstantQP_FullIntracodedFrame", &self.ConstantQP_FullIntracodedFrame)
.field("ConstantQP_InterPredictedFrame_PrevRefOnly", &self.ConstantQP_InterPredictedFrame_PrevRefOnly)
.field("ConstantQP_InterPredictedFrame_BiDirectionalRef", &self.ConstantQP_InterPredictedFrame_BiDirectionalRef)
.finish()
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_RATE_CONTROL_CQP {
fn eq(&self, other: &Self) -> bool {
self.ConstantQP_FullIntracodedFrame == other.ConstantQP_FullIntracodedFrame && self.ConstantQP_InterPredictedFrame_PrevRefOnly == other.ConstantQP_InterPredictedFrame_PrevRefOnly && self.ConstantQP_InterPredictedFrame_BiDirectionalRef == other.ConstantQP_InterPredictedFrame_BiDirectionalRef
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_RATE_CONTROL_CQP {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_RATE_CONTROL_CQP {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS(pub u32);
pub const D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_NONE: D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS = D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS(0u32);
pub const D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_DELTA_QP: D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS = D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS(1u32);
pub const D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_FRAME_ANALYSIS: D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS = D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS(2u32);
pub const D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_QP_RANGE: D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS = D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS(4u32);
pub const D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_INITIAL_QP: D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS = D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS(8u32);
pub const D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_MAX_FRAME_SIZE: D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS = D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS(16u32);
pub const D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_VBV_SIZES: D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS = D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS(32u32);
impl ::core::convert::From<u32> for D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE(pub i32);
pub const D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE_ABSOLUTE_QP_MAP: D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE = D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE(0i32);
pub const D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE_CQP: D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE = D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE(1i32);
pub const D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE_CBR: D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE = D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE(2i32);
pub const D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE_VBR: D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE = D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE(3i32);
pub const D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE_QVBR: D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE = D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE(4i32);
impl ::core::convert::From<i32> for D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_RATE_CONTROL_QVBR {
pub InitialQP: u32,
pub MinQP: u32,
pub MaxQP: u32,
pub MaxFrameBitSize: u64,
pub TargetAvgBitRate: u64,
pub PeakBitRate: u64,
pub ConstantQualityTarget: u32,
}
impl D3D12_VIDEO_ENCODER_RATE_CONTROL_QVBR {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_RATE_CONTROL_QVBR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODER_RATE_CONTROL_QVBR {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODER_RATE_CONTROL_QVBR")
.field("InitialQP", &self.InitialQP)
.field("MinQP", &self.MinQP)
.field("MaxQP", &self.MaxQP)
.field("MaxFrameBitSize", &self.MaxFrameBitSize)
.field("TargetAvgBitRate", &self.TargetAvgBitRate)
.field("PeakBitRate", &self.PeakBitRate)
.field("ConstantQualityTarget", &self.ConstantQualityTarget)
.finish()
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_RATE_CONTROL_QVBR {
fn eq(&self, other: &Self) -> bool {
self.InitialQP == other.InitialQP && self.MinQP == other.MinQP && self.MaxQP == other.MaxQP && self.MaxFrameBitSize == other.MaxFrameBitSize && self.TargetAvgBitRate == other.TargetAvgBitRate && self.PeakBitRate == other.PeakBitRate && self.ConstantQualityTarget == other.ConstantQualityTarget
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_RATE_CONTROL_QVBR {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_RATE_CONTROL_QVBR {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_RATE_CONTROL_VBR {
pub InitialQP: u32,
pub MinQP: u32,
pub MaxQP: u32,
pub MaxFrameBitSize: u64,
pub TargetAvgBitRate: u64,
pub PeakBitRate: u64,
pub VBVCapacity: u64,
pub InitialVBVFullness: u64,
}
impl D3D12_VIDEO_ENCODER_RATE_CONTROL_VBR {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_RATE_CONTROL_VBR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODER_RATE_CONTROL_VBR {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODER_RATE_CONTROL_VBR")
.field("InitialQP", &self.InitialQP)
.field("MinQP", &self.MinQP)
.field("MaxQP", &self.MaxQP)
.field("MaxFrameBitSize", &self.MaxFrameBitSize)
.field("TargetAvgBitRate", &self.TargetAvgBitRate)
.field("PeakBitRate", &self.PeakBitRate)
.field("VBVCapacity", &self.VBVCapacity)
.field("InitialVBVFullness", &self.InitialVBVFullness)
.finish()
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_RATE_CONTROL_VBR {
fn eq(&self, other: &Self) -> bool {
self.InitialQP == other.InitialQP && self.MinQP == other.MinQP && self.MaxQP == other.MaxQP && self.MaxFrameBitSize == other.MaxFrameBitSize && self.TargetAvgBitRate == other.TargetAvgBitRate && self.PeakBitRate == other.PeakBitRate && self.VBVCapacity == other.VBVCapacity && self.InitialVBVFullness == other.InitialVBVFullness
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_RATE_CONTROL_VBR {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_RATE_CONTROL_VBR {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub struct D3D12_VIDEO_ENCODER_RECONSTRUCTED_PICTURE {
pub pReconstructedPicture: ::core::option::Option<super::super::Graphics::Direct3D12::ID3D12Resource>,
pub ReconstructedPictureSubresource: u32,
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl D3D12_VIDEO_ENCODER_RECONSTRUCTED_PICTURE {}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::default::Default for D3D12_VIDEO_ENCODER_RECONSTRUCTED_PICTURE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODER_RECONSTRUCTED_PICTURE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODER_RECONSTRUCTED_PICTURE").field("pReconstructedPicture", &self.pReconstructedPicture).field("ReconstructedPictureSubresource", &self.ReconstructedPictureSubresource).finish()
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_RECONSTRUCTED_PICTURE {
fn eq(&self, other: &Self) -> bool {
self.pReconstructedPicture == other.pReconstructedPicture && self.ReconstructedPictureSubresource == other.ReconstructedPictureSubresource
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_RECONSTRUCTED_PICTURE {}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_RECONSTRUCTED_PICTURE {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_H264 {
pub ReconstructedPictureResourceIndex: u32,
pub IsLongTermReference: super::super::Foundation::BOOL,
pub LongTermPictureIdx: u32,
pub PictureOrderCountNumber: u32,
pub FrameDecodingOrderNumber: u32,
pub TemporalLayerIndex: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_H264 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_H264 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_H264 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_H264")
.field("ReconstructedPictureResourceIndex", &self.ReconstructedPictureResourceIndex)
.field("IsLongTermReference", &self.IsLongTermReference)
.field("LongTermPictureIdx", &self.LongTermPictureIdx)
.field("PictureOrderCountNumber", &self.PictureOrderCountNumber)
.field("FrameDecodingOrderNumber", &self.FrameDecodingOrderNumber)
.field("TemporalLayerIndex", &self.TemporalLayerIndex)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_H264 {
fn eq(&self, other: &Self) -> bool {
self.ReconstructedPictureResourceIndex == other.ReconstructedPictureResourceIndex && self.IsLongTermReference == other.IsLongTermReference && self.LongTermPictureIdx == other.LongTermPictureIdx && self.PictureOrderCountNumber == other.PictureOrderCountNumber && self.FrameDecodingOrderNumber == other.FrameDecodingOrderNumber && self.TemporalLayerIndex == other.TemporalLayerIndex
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_H264 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_H264 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_HEVC {
pub ReconstructedPictureResourceIndex: u32,
pub IsRefUsedByCurrentPic: super::super::Foundation::BOOL,
pub IsLongTermReference: super::super::Foundation::BOOL,
pub PictureOrderCountNumber: u32,
pub TemporalLayerIndex: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_HEVC {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_HEVC {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_HEVC {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_HEVC")
.field("ReconstructedPictureResourceIndex", &self.ReconstructedPictureResourceIndex)
.field("IsRefUsedByCurrentPic", &self.IsRefUsedByCurrentPic)
.field("IsLongTermReference", &self.IsLongTermReference)
.field("PictureOrderCountNumber", &self.PictureOrderCountNumber)
.field("TemporalLayerIndex", &self.TemporalLayerIndex)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_HEVC {
fn eq(&self, other: &Self) -> bool {
self.ReconstructedPictureResourceIndex == other.ReconstructedPictureResourceIndex && self.IsRefUsedByCurrentPic == other.IsRefUsedByCurrentPic && self.IsLongTermReference == other.IsLongTermReference && self.PictureOrderCountNumber == other.PictureOrderCountNumber && self.TemporalLayerIndex == other.TemporalLayerIndex
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_HEVC {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_HEVC {
type Abi = Self;
}
#[cfg(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::clone::Clone for D3D12_VIDEO_ENCODER_RESOLVE_METADATA_INPUT_ARGUMENTS {
fn clone(&self) -> Self {
unimplemented!()
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
pub struct D3D12_VIDEO_ENCODER_RESOLVE_METADATA_INPUT_ARGUMENTS {
pub EncoderCodec: D3D12_VIDEO_ENCODER_CODEC,
pub EncoderProfile: D3D12_VIDEO_ENCODER_PROFILE_DESC,
pub EncoderInputFormat: super::super::Graphics::Dxgi::Common::DXGI_FORMAT,
pub EncodedPictureEffectiveResolution: D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC,
pub HWLayoutMetadata: D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER,
}
#[cfg(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
impl D3D12_VIDEO_ENCODER_RESOLVE_METADATA_INPUT_ARGUMENTS {}
#[cfg(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::default::Default for D3D12_VIDEO_ENCODER_RESOLVE_METADATA_INPUT_ARGUMENTS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_RESOLVE_METADATA_INPUT_ARGUMENTS {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_RESOLVE_METADATA_INPUT_ARGUMENTS {}
#[cfg(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_RESOLVE_METADATA_INPUT_ARGUMENTS {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub struct D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_ARGUMENTS {
pub ResolvedLayoutMetadata: D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER,
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_ARGUMENTS {}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::default::Default for D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_ARGUMENTS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_ARGUMENTS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_ARGUMENTS").field("ResolvedLayoutMetadata", &self.ResolvedLayoutMetadata).finish()
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_ARGUMENTS {
fn eq(&self, other: &Self) -> bool {
self.ResolvedLayoutMetadata == other.ResolvedLayoutMetadata
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_ARGUMENTS {}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_ARGUMENTS {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
pub struct D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_DESC {
pub Flags: D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS,
pub IntraRefreshConfig: D3D12_VIDEO_ENCODER_INTRA_REFRESH,
pub RateControl: D3D12_VIDEO_ENCODER_RATE_CONTROL,
pub PictureTargetResolution: D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC,
pub SelectedLayoutMode: D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE,
pub FrameSubregionsLayoutData: D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA,
pub CodecGopSequence: D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE,
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_DESC {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::default::Default for D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_DESC {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_DESC {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_DESC {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_DESC {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS(pub u32);
pub const D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAG_NONE: D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS = D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS(0u32);
pub const D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAG_RESOLUTION_CHANGE: D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS = D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS(1u32);
pub const D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAG_RATE_CONTROL_CHANGE: D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS = D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS(2u32);
pub const D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAG_SUBREGION_LAYOUT_CHANGE: D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS = D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS(4u32);
pub const D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAG_REQUEST_INTRA_REFRESH: D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS = D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS(8u32);
pub const D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAG_GOP_SEQUENCE_CHANGE: D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS = D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS(16u32);
impl ::core::convert::From<u32> for D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE {
pub DataSize: u32,
pub Anonymous: D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_0,
}
impl D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_0 {
pub pH264GroupOfPictures: *mut D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_H264,
pub pHEVCGroupOfPictures: *mut D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_HEVC,
}
impl D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_0 {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_0 {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_H264 {
pub GOPLength: u32,
pub PPicturePeriod: u32,
pub pic_order_cnt_type: u8,
pub log2_max_frame_num_minus4: u8,
pub log2_max_pic_order_cnt_lsb_minus4: u8,
}
impl D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_H264 {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_H264 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_H264 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_H264")
.field("GOPLength", &self.GOPLength)
.field("PPicturePeriod", &self.PPicturePeriod)
.field("pic_order_cnt_type", &self.pic_order_cnt_type)
.field("log2_max_frame_num_minus4", &self.log2_max_frame_num_minus4)
.field("log2_max_pic_order_cnt_lsb_minus4", &self.log2_max_pic_order_cnt_lsb_minus4)
.finish()
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_H264 {
fn eq(&self, other: &Self) -> bool {
self.GOPLength == other.GOPLength && self.PPicturePeriod == other.PPicturePeriod && self.pic_order_cnt_type == other.pic_order_cnt_type && self.log2_max_frame_num_minus4 == other.log2_max_frame_num_minus4 && self.log2_max_pic_order_cnt_lsb_minus4 == other.log2_max_pic_order_cnt_lsb_minus4
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_H264 {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_H264 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_HEVC {
pub GOPLength: u32,
pub PPicturePeriod: u32,
pub log2_max_pic_order_cnt_lsb_minus4: u8,
}
impl D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_HEVC {}
impl ::core::default::Default for D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_HEVC {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_HEVC {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_HEVC").field("GOPLength", &self.GOPLength).field("PPicturePeriod", &self.PPicturePeriod).field("log2_max_pic_order_cnt_lsb_minus4", &self.log2_max_pic_order_cnt_lsb_minus4).finish()
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_HEVC {
fn eq(&self, other: &Self) -> bool {
self.GOPLength == other.GOPLength && self.PPicturePeriod == other.PPicturePeriod && self.log2_max_pic_order_cnt_lsb_minus4 == other.log2_max_pic_order_cnt_lsb_minus4
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_HEVC {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_HEVC {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_SUPPORT_FLAGS(pub u32);
pub const D3D12_VIDEO_ENCODER_SUPPORT_FLAG_NONE: D3D12_VIDEO_ENCODER_SUPPORT_FLAGS = D3D12_VIDEO_ENCODER_SUPPORT_FLAGS(0u32);
pub const D3D12_VIDEO_ENCODER_SUPPORT_FLAG_GENERAL_SUPPORT_OK: D3D12_VIDEO_ENCODER_SUPPORT_FLAGS = D3D12_VIDEO_ENCODER_SUPPORT_FLAGS(1u32);
pub const D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_RECONFIGURATION_AVAILABLE: D3D12_VIDEO_ENCODER_SUPPORT_FLAGS = D3D12_VIDEO_ENCODER_SUPPORT_FLAGS(2u32);
pub const D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RESOLUTION_RECONFIGURATION_AVAILABLE: D3D12_VIDEO_ENCODER_SUPPORT_FLAGS = D3D12_VIDEO_ENCODER_SUPPORT_FLAGS(4u32);
pub const D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_VBV_SIZE_CONFIG_AVAILABLE: D3D12_VIDEO_ENCODER_SUPPORT_FLAGS = D3D12_VIDEO_ENCODER_SUPPORT_FLAGS(8u32);
pub const D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_FRAME_ANALYSIS_AVAILABLE: D3D12_VIDEO_ENCODER_SUPPORT_FLAGS = D3D12_VIDEO_ENCODER_SUPPORT_FLAGS(16u32);
pub const D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RECONSTRUCTED_FRAMES_REQUIRE_TEXTURE_ARRAYS: D3D12_VIDEO_ENCODER_SUPPORT_FLAGS = D3D12_VIDEO_ENCODER_SUPPORT_FLAGS(32u32);
pub const D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_DELTA_QP_AVAILABLE: D3D12_VIDEO_ENCODER_SUPPORT_FLAGS = D3D12_VIDEO_ENCODER_SUPPORT_FLAGS(64u32);
pub const D3D12_VIDEO_ENCODER_SUPPORT_FLAG_SUBREGION_LAYOUT_RECONFIGURATION_AVAILABLE: D3D12_VIDEO_ENCODER_SUPPORT_FLAGS = D3D12_VIDEO_ENCODER_SUPPORT_FLAGS(128u32);
pub const D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_ADJUSTABLE_QP_RANGE_AVAILABLE: D3D12_VIDEO_ENCODER_SUPPORT_FLAGS = D3D12_VIDEO_ENCODER_SUPPORT_FLAGS(256u32);
pub const D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_INITIAL_QP_AVAILABLE: D3D12_VIDEO_ENCODER_SUPPORT_FLAGS = D3D12_VIDEO_ENCODER_SUPPORT_FLAGS(512u32);
pub const D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_MAX_FRAME_SIZE_AVAILABLE: D3D12_VIDEO_ENCODER_SUPPORT_FLAGS = D3D12_VIDEO_ENCODER_SUPPORT_FLAGS(1024u32);
pub const D3D12_VIDEO_ENCODER_SUPPORT_FLAG_SEQUENCE_GOP_RECONFIGURATION_AVAILABLE: D3D12_VIDEO_ENCODER_SUPPORT_FLAGS = D3D12_VIDEO_ENCODER_SUPPORT_FLAGS(2048u32);
pub const D3D12_VIDEO_ENCODER_SUPPORT_FLAG_MOTION_ESTIMATION_PRECISION_MODE_LIMIT_AVAILABLE: D3D12_VIDEO_ENCODER_SUPPORT_FLAGS = D3D12_VIDEO_ENCODER_SUPPORT_FLAGS(4096u32);
impl ::core::convert::From<u32> for D3D12_VIDEO_ENCODER_SUPPORT_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_SUPPORT_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for D3D12_VIDEO_ENCODER_SUPPORT_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for D3D12_VIDEO_ENCODER_SUPPORT_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for D3D12_VIDEO_ENCODER_SUPPORT_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for D3D12_VIDEO_ENCODER_SUPPORT_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for D3D12_VIDEO_ENCODER_SUPPORT_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_TIER_HEVC(pub i32);
pub const D3D12_VIDEO_ENCODER_TIER_HEVC_MAIN: D3D12_VIDEO_ENCODER_TIER_HEVC = D3D12_VIDEO_ENCODER_TIER_HEVC(0i32);
pub const D3D12_VIDEO_ENCODER_TIER_HEVC_HIGH: D3D12_VIDEO_ENCODER_TIER_HEVC = D3D12_VIDEO_ENCODER_TIER_HEVC(1i32);
impl ::core::convert::From<i32> for D3D12_VIDEO_ENCODER_TIER_HEVC {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_TIER_HEVC {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_ENCODER_VALIDATION_FLAGS(pub u32);
pub const D3D12_VIDEO_ENCODER_VALIDATION_FLAG_NONE: D3D12_VIDEO_ENCODER_VALIDATION_FLAGS = D3D12_VIDEO_ENCODER_VALIDATION_FLAGS(0u32);
pub const D3D12_VIDEO_ENCODER_VALIDATION_FLAG_CODEC_NOT_SUPPORTED: D3D12_VIDEO_ENCODER_VALIDATION_FLAGS = D3D12_VIDEO_ENCODER_VALIDATION_FLAGS(1u32);
pub const D3D12_VIDEO_ENCODER_VALIDATION_FLAG_INPUT_FORMAT_NOT_SUPPORTED: D3D12_VIDEO_ENCODER_VALIDATION_FLAGS = D3D12_VIDEO_ENCODER_VALIDATION_FLAGS(8u32);
pub const D3D12_VIDEO_ENCODER_VALIDATION_FLAG_CODEC_CONFIGURATION_NOT_SUPPORTED: D3D12_VIDEO_ENCODER_VALIDATION_FLAGS = D3D12_VIDEO_ENCODER_VALIDATION_FLAGS(16u32);
pub const D3D12_VIDEO_ENCODER_VALIDATION_FLAG_RATE_CONTROL_MODE_NOT_SUPPORTED: D3D12_VIDEO_ENCODER_VALIDATION_FLAGS = D3D12_VIDEO_ENCODER_VALIDATION_FLAGS(32u32);
pub const D3D12_VIDEO_ENCODER_VALIDATION_FLAG_RATE_CONTROL_CONFIGURATION_NOT_SUPPORTED: D3D12_VIDEO_ENCODER_VALIDATION_FLAGS = D3D12_VIDEO_ENCODER_VALIDATION_FLAGS(64u32);
pub const D3D12_VIDEO_ENCODER_VALIDATION_FLAG_INTRA_REFRESH_MODE_NOT_SUPPORTED: D3D12_VIDEO_ENCODER_VALIDATION_FLAGS = D3D12_VIDEO_ENCODER_VALIDATION_FLAGS(128u32);
pub const D3D12_VIDEO_ENCODER_VALIDATION_FLAG_SUBREGION_LAYOUT_MODE_NOT_SUPPORTED: D3D12_VIDEO_ENCODER_VALIDATION_FLAGS = D3D12_VIDEO_ENCODER_VALIDATION_FLAGS(256u32);
pub const D3D12_VIDEO_ENCODER_VALIDATION_FLAG_RESOLUTION_NOT_SUPPORTED_IN_LIST: D3D12_VIDEO_ENCODER_VALIDATION_FLAGS = D3D12_VIDEO_ENCODER_VALIDATION_FLAGS(512u32);
pub const D3D12_VIDEO_ENCODER_VALIDATION_FLAG_GOP_STRUCTURE_NOT_SUPPORTED: D3D12_VIDEO_ENCODER_VALIDATION_FLAGS = D3D12_VIDEO_ENCODER_VALIDATION_FLAGS(2048u32);
impl ::core::convert::From<u32> for D3D12_VIDEO_ENCODER_VALIDATION_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODER_VALIDATION_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for D3D12_VIDEO_ENCODER_VALIDATION_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for D3D12_VIDEO_ENCODER_VALIDATION_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for D3D12_VIDEO_ENCODER_VALIDATION_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for D3D12_VIDEO_ENCODER_VALIDATION_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for D3D12_VIDEO_ENCODER_VALIDATION_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub struct D3D12_VIDEO_ENCODE_REFERENCE_FRAMES {
pub NumTexture2Ds: u32,
pub ppTexture2Ds: *mut ::core::option::Option<super::super::Graphics::Direct3D12::ID3D12Resource>,
pub pSubresources: *mut u32,
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl D3D12_VIDEO_ENCODE_REFERENCE_FRAMES {}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::default::Default for D3D12_VIDEO_ENCODE_REFERENCE_FRAMES {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::fmt::Debug for D3D12_VIDEO_ENCODE_REFERENCE_FRAMES {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_ENCODE_REFERENCE_FRAMES").field("NumTexture2Ds", &self.NumTexture2Ds).field("ppTexture2Ds", &self.ppTexture2Ds).field("pSubresources", &self.pSubresources).finish()
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_ENCODE_REFERENCE_FRAMES {
fn eq(&self, other: &Self) -> bool {
self.NumTexture2Ds == other.NumTexture2Ds && self.ppTexture2Ds == other.ppTexture2Ds && self.pSubresources == other.pSubresources
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::cmp::Eq for D3D12_VIDEO_ENCODE_REFERENCE_FRAMES {}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_ENCODE_REFERENCE_FRAMES {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_EXTENSION_COMMAND_DESC {
pub NodeMask: u32,
pub CommandId: ::windows::core::GUID,
}
impl D3D12_VIDEO_EXTENSION_COMMAND_DESC {}
impl ::core::default::Default for D3D12_VIDEO_EXTENSION_COMMAND_DESC {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_VIDEO_EXTENSION_COMMAND_DESC {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_EXTENSION_COMMAND_DESC").field("NodeMask", &self.NodeMask).field("CommandId", &self.CommandId).finish()
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_EXTENSION_COMMAND_DESC {
fn eq(&self, other: &Self) -> bool {
self.NodeMask == other.NodeMask && self.CommandId == other.CommandId
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_EXTENSION_COMMAND_DESC {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_EXTENSION_COMMAND_DESC {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
pub struct D3D12_VIDEO_EXTENSION_COMMAND_INFO {
pub CommandId: ::windows::core::GUID,
pub Name: super::super::Foundation::PWSTR,
pub CommandListSupportFlags: super::super::Graphics::Direct3D12::D3D12_COMMAND_LIST_SUPPORT_FLAGS,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
impl D3D12_VIDEO_EXTENSION_COMMAND_INFO {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
impl ::core::default::Default for D3D12_VIDEO_EXTENSION_COMMAND_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
impl ::core::fmt::Debug for D3D12_VIDEO_EXTENSION_COMMAND_INFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_EXTENSION_COMMAND_INFO").field("CommandId", &self.CommandId).field("Name", &self.Name).field("CommandListSupportFlags", &self.CommandListSupportFlags).finish()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
impl ::core::cmp::PartialEq for D3D12_VIDEO_EXTENSION_COMMAND_INFO {
fn eq(&self, other: &Self) -> bool {
self.CommandId == other.CommandId && self.Name == other.Name && self.CommandListSupportFlags == other.CommandListSupportFlags
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
impl ::core::cmp::Eq for D3D12_VIDEO_EXTENSION_COMMAND_INFO {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_EXTENSION_COMMAND_INFO {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS(pub u32);
pub const D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAG_NONE: D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS = D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS(0u32);
pub const D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAG_READ: D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS = D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS(1u32);
pub const D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAG_WRITE: D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS = D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS(2u32);
impl ::core::convert::From<u32> for D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_INFO {
pub Name: super::super::Foundation::PWSTR,
pub Type: D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE,
pub Flags: D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS,
}
#[cfg(feature = "Win32_Foundation")]
impl D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_INFO {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_INFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_INFO").field("Name", &self.Name).field("Type", &self.Type).field("Flags", &self.Flags).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_INFO {
fn eq(&self, other: &Self) -> bool {
self.Name == other.Name && self.Type == other.Type && self.Flags == other.Flags
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_INFO {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_INFO {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE(pub i32);
pub const D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE_CREATION: D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE = D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE(0i32);
pub const D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE_INITIALIZATION: D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE = D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE(1i32);
pub const D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE_EXECUTION: D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE = D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE(2i32);
pub const D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE_CAPS_INPUT: D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE = D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE(3i32);
pub const D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE_CAPS_OUTPUT: D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE = D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE(4i32);
pub const D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE_DEVICE_EXECUTE_INPUT: D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE = D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE(5i32);
pub const D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE_DEVICE_EXECUTE_OUTPUT: D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE = D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE(6i32);
impl ::core::convert::From<i32> for D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE(pub i32);
pub const D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_UINT8: D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE = D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE(0i32);
pub const D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_UINT16: D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE = D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE(1i32);
pub const D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_UINT32: D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE = D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE(2i32);
pub const D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_UINT64: D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE = D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE(3i32);
pub const D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_SINT8: D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE = D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE(4i32);
pub const D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_SINT16: D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE = D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE(5i32);
pub const D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_SINT32: D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE = D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE(6i32);
pub const D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_SINT64: D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE = D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE(7i32);
pub const D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_FLOAT: D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE = D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE(8i32);
pub const D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_DOUBLE: D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE = D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE(9i32);
pub const D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_RESOURCE: D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE = D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE(10i32);
impl ::core::convert::From<i32> for D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_FIELD_TYPE(pub i32);
pub const D3D12_VIDEO_FIELD_TYPE_NONE: D3D12_VIDEO_FIELD_TYPE = D3D12_VIDEO_FIELD_TYPE(0i32);
pub const D3D12_VIDEO_FIELD_TYPE_INTERLACED_TOP_FIELD_FIRST: D3D12_VIDEO_FIELD_TYPE = D3D12_VIDEO_FIELD_TYPE(1i32);
pub const D3D12_VIDEO_FIELD_TYPE_INTERLACED_BOTTOM_FIELD_FIRST: D3D12_VIDEO_FIELD_TYPE = D3D12_VIDEO_FIELD_TYPE(2i32);
impl ::core::convert::From<i32> for D3D12_VIDEO_FIELD_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_FIELD_TYPE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
pub struct D3D12_VIDEO_FORMAT {
pub Format: super::super::Graphics::Dxgi::Common::DXGI_FORMAT,
pub ColorSpace: super::super::Graphics::Dxgi::Common::DXGI_COLOR_SPACE_TYPE,
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl D3D12_VIDEO_FORMAT {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::default::Default for D3D12_VIDEO_FORMAT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::fmt::Debug for D3D12_VIDEO_FORMAT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_FORMAT").field("Format", &self.Format).field("ColorSpace", &self.ColorSpace).finish()
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_FORMAT {
fn eq(&self, other: &Self) -> bool {
self.Format == other.Format && self.ColorSpace == other.ColorSpace
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::Eq for D3D12_VIDEO_FORMAT {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_FORMAT {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_FRAME_CODED_INTERLACE_TYPE(pub i32);
pub const D3D12_VIDEO_FRAME_CODED_INTERLACE_TYPE_NONE: D3D12_VIDEO_FRAME_CODED_INTERLACE_TYPE = D3D12_VIDEO_FRAME_CODED_INTERLACE_TYPE(0i32);
pub const D3D12_VIDEO_FRAME_CODED_INTERLACE_TYPE_FIELD_BASED: D3D12_VIDEO_FRAME_CODED_INTERLACE_TYPE = D3D12_VIDEO_FRAME_CODED_INTERLACE_TYPE(1i32);
impl ::core::convert::From<i32> for D3D12_VIDEO_FRAME_CODED_INTERLACE_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_FRAME_CODED_INTERLACE_TYPE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_FRAME_STEREO_FORMAT(pub i32);
pub const D3D12_VIDEO_FRAME_STEREO_FORMAT_NONE: D3D12_VIDEO_FRAME_STEREO_FORMAT = D3D12_VIDEO_FRAME_STEREO_FORMAT(0i32);
pub const D3D12_VIDEO_FRAME_STEREO_FORMAT_MONO: D3D12_VIDEO_FRAME_STEREO_FORMAT = D3D12_VIDEO_FRAME_STEREO_FORMAT(1i32);
pub const D3D12_VIDEO_FRAME_STEREO_FORMAT_HORIZONTAL: D3D12_VIDEO_FRAME_STEREO_FORMAT = D3D12_VIDEO_FRAME_STEREO_FORMAT(2i32);
pub const D3D12_VIDEO_FRAME_STEREO_FORMAT_VERTICAL: D3D12_VIDEO_FRAME_STEREO_FORMAT = D3D12_VIDEO_FRAME_STEREO_FORMAT(3i32);
pub const D3D12_VIDEO_FRAME_STEREO_FORMAT_SEPARATE: D3D12_VIDEO_FRAME_STEREO_FORMAT = D3D12_VIDEO_FRAME_STEREO_FORMAT(4i32);
impl ::core::convert::From<i32> for D3D12_VIDEO_FRAME_STEREO_FORMAT {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_FRAME_STEREO_FORMAT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
pub struct D3D12_VIDEO_MOTION_ESTIMATOR_DESC {
pub NodeMask: u32,
pub InputFormat: super::super::Graphics::Dxgi::Common::DXGI_FORMAT,
pub BlockSize: D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE,
pub Precision: D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION,
pub SizeRange: D3D12_VIDEO_SIZE_RANGE,
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl D3D12_VIDEO_MOTION_ESTIMATOR_DESC {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::default::Default for D3D12_VIDEO_MOTION_ESTIMATOR_DESC {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::fmt::Debug for D3D12_VIDEO_MOTION_ESTIMATOR_DESC {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_MOTION_ESTIMATOR_DESC").field("NodeMask", &self.NodeMask).field("InputFormat", &self.InputFormat).field("BlockSize", &self.BlockSize).field("Precision", &self.Precision).field("SizeRange", &self.SizeRange).finish()
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_MOTION_ESTIMATOR_DESC {
fn eq(&self, other: &Self) -> bool {
self.NodeMask == other.NodeMask && self.InputFormat == other.InputFormat && self.BlockSize == other.BlockSize && self.Precision == other.Precision && self.SizeRange == other.SizeRange
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::Eq for D3D12_VIDEO_MOTION_ESTIMATOR_DESC {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_MOTION_ESTIMATOR_DESC {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub struct D3D12_VIDEO_MOTION_ESTIMATOR_INPUT {
pub pInputTexture2D: ::core::option::Option<super::super::Graphics::Direct3D12::ID3D12Resource>,
pub InputSubresourceIndex: u32,
pub pReferenceTexture2D: ::core::option::Option<super::super::Graphics::Direct3D12::ID3D12Resource>,
pub ReferenceSubresourceIndex: u32,
pub pHintMotionVectorHeap: ::core::option::Option<ID3D12VideoMotionVectorHeap>,
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl D3D12_VIDEO_MOTION_ESTIMATOR_INPUT {}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::default::Default for D3D12_VIDEO_MOTION_ESTIMATOR_INPUT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::fmt::Debug for D3D12_VIDEO_MOTION_ESTIMATOR_INPUT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_MOTION_ESTIMATOR_INPUT")
.field("pInputTexture2D", &self.pInputTexture2D)
.field("InputSubresourceIndex", &self.InputSubresourceIndex)
.field("pReferenceTexture2D", &self.pReferenceTexture2D)
.field("ReferenceSubresourceIndex", &self.ReferenceSubresourceIndex)
.field("pHintMotionVectorHeap", &self.pHintMotionVectorHeap)
.finish()
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_MOTION_ESTIMATOR_INPUT {
fn eq(&self, other: &Self) -> bool {
self.pInputTexture2D == other.pInputTexture2D && self.InputSubresourceIndex == other.InputSubresourceIndex && self.pReferenceTexture2D == other.pReferenceTexture2D && self.ReferenceSubresourceIndex == other.ReferenceSubresourceIndex && self.pHintMotionVectorHeap == other.pHintMotionVectorHeap
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::cmp::Eq for D3D12_VIDEO_MOTION_ESTIMATOR_INPUT {}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_MOTION_ESTIMATOR_INPUT {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
pub struct D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT {
pub pMotionVectorHeap: ::core::option::Option<ID3D12VideoMotionVectorHeap>,
}
impl D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT {}
impl ::core::default::Default for D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT").field("pMotionVectorHeap", &self.pMotionVectorHeap).finish()
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT {
fn eq(&self, other: &Self) -> bool {
self.pMotionVectorHeap == other.pMotionVectorHeap
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE(pub i32);
pub const D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_8X8: D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE = D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE(0i32);
pub const D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_16X16: D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE = D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE(1i32);
impl ::core::convert::From<i32> for D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS(pub u32);
pub const D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAG_NONE: D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS = D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS(0u32);
pub const D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAG_8X8: D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS = D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS(1u32);
pub const D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAG_16X16: D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS = D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS(2u32);
impl ::core::convert::From<u32> for D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION(pub i32);
pub const D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_QUARTER_PEL: D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION = D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION(0i32);
impl ::core::convert::From<i32> for D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS(pub u32);
pub const D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAG_NONE: D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS = D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS(0u32);
pub const D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAG_QUARTER_PEL: D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS = D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS(1u32);
impl ::core::convert::From<u32> for D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
pub struct D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC {
pub NodeMask: u32,
pub InputFormat: super::super::Graphics::Dxgi::Common::DXGI_FORMAT,
pub BlockSize: D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE,
pub Precision: D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION,
pub SizeRange: D3D12_VIDEO_SIZE_RANGE,
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::default::Default for D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::fmt::Debug for D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC").field("NodeMask", &self.NodeMask).field("InputFormat", &self.InputFormat).field("BlockSize", &self.BlockSize).field("Precision", &self.Precision).field("SizeRange", &self.SizeRange).finish()
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC {
fn eq(&self, other: &Self) -> bool {
self.NodeMask == other.NodeMask && self.InputFormat == other.InputFormat && self.BlockSize == other.BlockSize && self.Precision == other.Precision && self.SizeRange == other.SizeRange
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::Eq for D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct D3D12_VIDEO_PROCESS_ALPHA_BLENDING {
pub Enable: super::super::Foundation::BOOL,
pub Alpha: f32,
}
#[cfg(feature = "Win32_Foundation")]
impl D3D12_VIDEO_PROCESS_ALPHA_BLENDING {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for D3D12_VIDEO_PROCESS_ALPHA_BLENDING {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for D3D12_VIDEO_PROCESS_ALPHA_BLENDING {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_PROCESS_ALPHA_BLENDING").field("Enable", &self.Enable).field("Alpha", &self.Alpha).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_PROCESS_ALPHA_BLENDING {
fn eq(&self, other: &Self) -> bool {
self.Enable == other.Enable && self.Alpha == other.Alpha
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for D3D12_VIDEO_PROCESS_ALPHA_BLENDING {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_PROCESS_ALPHA_BLENDING {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE(pub i32);
pub const D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE_OPAQUE: D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE = D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE(0i32);
pub const D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE_BACKGROUND: D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE = D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE(1i32);
pub const D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE_DESTINATION: D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE = D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE(2i32);
pub const D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE_SOURCE_STREAM: D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE = D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE(3i32);
impl ::core::convert::From<i32> for D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS(pub u32);
pub const D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_NONE: D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS = D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS(0u32);
pub const D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_DENOISE: D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS = D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS(1u32);
pub const D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_DERINGING: D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS = D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS(2u32);
pub const D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_EDGE_ENHANCEMENT: D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS = D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS(4u32);
pub const D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_COLOR_CORRECTION: D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS = D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS(8u32);
pub const D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_FLESH_TONE_MAPPING: D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS = D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS(16u32);
pub const D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_IMAGE_STABILIZATION: D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS = D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS(32u32);
pub const D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_SUPER_RESOLUTION: D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS = D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS(64u32);
pub const D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_ANAMORPHIC_SCALING: D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS = D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS(128u32);
pub const D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_CUSTOM: D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS = D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS(2147483648u32);
impl ::core::convert::From<u32> for D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS(pub u32);
pub const D3D12_VIDEO_PROCESS_DEINTERLACE_FLAG_NONE: D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS = D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS(0u32);
pub const D3D12_VIDEO_PROCESS_DEINTERLACE_FLAG_BOB: D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS = D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS(1u32);
pub const D3D12_VIDEO_PROCESS_DEINTERLACE_FLAG_CUSTOM: D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS = D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS(2147483648u32);
impl ::core::convert::From<u32> for D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_PROCESS_FEATURE_FLAGS(pub u32);
pub const D3D12_VIDEO_PROCESS_FEATURE_FLAG_NONE: D3D12_VIDEO_PROCESS_FEATURE_FLAGS = D3D12_VIDEO_PROCESS_FEATURE_FLAGS(0u32);
pub const D3D12_VIDEO_PROCESS_FEATURE_FLAG_ALPHA_FILL: D3D12_VIDEO_PROCESS_FEATURE_FLAGS = D3D12_VIDEO_PROCESS_FEATURE_FLAGS(1u32);
pub const D3D12_VIDEO_PROCESS_FEATURE_FLAG_LUMA_KEY: D3D12_VIDEO_PROCESS_FEATURE_FLAGS = D3D12_VIDEO_PROCESS_FEATURE_FLAGS(2u32);
pub const D3D12_VIDEO_PROCESS_FEATURE_FLAG_STEREO: D3D12_VIDEO_PROCESS_FEATURE_FLAGS = D3D12_VIDEO_PROCESS_FEATURE_FLAGS(4u32);
pub const D3D12_VIDEO_PROCESS_FEATURE_FLAG_ROTATION: D3D12_VIDEO_PROCESS_FEATURE_FLAGS = D3D12_VIDEO_PROCESS_FEATURE_FLAGS(8u32);
pub const D3D12_VIDEO_PROCESS_FEATURE_FLAG_FLIP: D3D12_VIDEO_PROCESS_FEATURE_FLAGS = D3D12_VIDEO_PROCESS_FEATURE_FLAGS(16u32);
pub const D3D12_VIDEO_PROCESS_FEATURE_FLAG_ALPHA_BLENDING: D3D12_VIDEO_PROCESS_FEATURE_FLAGS = D3D12_VIDEO_PROCESS_FEATURE_FLAGS(32u32);
pub const D3D12_VIDEO_PROCESS_FEATURE_FLAG_PIXEL_ASPECT_RATIO: D3D12_VIDEO_PROCESS_FEATURE_FLAGS = D3D12_VIDEO_PROCESS_FEATURE_FLAGS(64u32);
impl ::core::convert::From<u32> for D3D12_VIDEO_PROCESS_FEATURE_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_PROCESS_FEATURE_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for D3D12_VIDEO_PROCESS_FEATURE_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for D3D12_VIDEO_PROCESS_FEATURE_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for D3D12_VIDEO_PROCESS_FEATURE_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for D3D12_VIDEO_PROCESS_FEATURE_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for D3D12_VIDEO_PROCESS_FEATURE_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_PROCESS_FILTER(pub i32);
pub const D3D12_VIDEO_PROCESS_FILTER_BRIGHTNESS: D3D12_VIDEO_PROCESS_FILTER = D3D12_VIDEO_PROCESS_FILTER(0i32);
pub const D3D12_VIDEO_PROCESS_FILTER_CONTRAST: D3D12_VIDEO_PROCESS_FILTER = D3D12_VIDEO_PROCESS_FILTER(1i32);
pub const D3D12_VIDEO_PROCESS_FILTER_HUE: D3D12_VIDEO_PROCESS_FILTER = D3D12_VIDEO_PROCESS_FILTER(2i32);
pub const D3D12_VIDEO_PROCESS_FILTER_SATURATION: D3D12_VIDEO_PROCESS_FILTER = D3D12_VIDEO_PROCESS_FILTER(3i32);
pub const D3D12_VIDEO_PROCESS_FILTER_NOISE_REDUCTION: D3D12_VIDEO_PROCESS_FILTER = D3D12_VIDEO_PROCESS_FILTER(4i32);
pub const D3D12_VIDEO_PROCESS_FILTER_EDGE_ENHANCEMENT: D3D12_VIDEO_PROCESS_FILTER = D3D12_VIDEO_PROCESS_FILTER(5i32);
pub const D3D12_VIDEO_PROCESS_FILTER_ANAMORPHIC_SCALING: D3D12_VIDEO_PROCESS_FILTER = D3D12_VIDEO_PROCESS_FILTER(6i32);
pub const D3D12_VIDEO_PROCESS_FILTER_STEREO_ADJUSTMENT: D3D12_VIDEO_PROCESS_FILTER = D3D12_VIDEO_PROCESS_FILTER(7i32);
impl ::core::convert::From<i32> for D3D12_VIDEO_PROCESS_FILTER {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_PROCESS_FILTER {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_PROCESS_FILTER_FLAGS(pub u32);
pub const D3D12_VIDEO_PROCESS_FILTER_FLAG_NONE: D3D12_VIDEO_PROCESS_FILTER_FLAGS = D3D12_VIDEO_PROCESS_FILTER_FLAGS(0u32);
pub const D3D12_VIDEO_PROCESS_FILTER_FLAG_BRIGHTNESS: D3D12_VIDEO_PROCESS_FILTER_FLAGS = D3D12_VIDEO_PROCESS_FILTER_FLAGS(1u32);
pub const D3D12_VIDEO_PROCESS_FILTER_FLAG_CONTRAST: D3D12_VIDEO_PROCESS_FILTER_FLAGS = D3D12_VIDEO_PROCESS_FILTER_FLAGS(2u32);
pub const D3D12_VIDEO_PROCESS_FILTER_FLAG_HUE: D3D12_VIDEO_PROCESS_FILTER_FLAGS = D3D12_VIDEO_PROCESS_FILTER_FLAGS(4u32);
pub const D3D12_VIDEO_PROCESS_FILTER_FLAG_SATURATION: D3D12_VIDEO_PROCESS_FILTER_FLAGS = D3D12_VIDEO_PROCESS_FILTER_FLAGS(8u32);
pub const D3D12_VIDEO_PROCESS_FILTER_FLAG_NOISE_REDUCTION: D3D12_VIDEO_PROCESS_FILTER_FLAGS = D3D12_VIDEO_PROCESS_FILTER_FLAGS(16u32);
pub const D3D12_VIDEO_PROCESS_FILTER_FLAG_EDGE_ENHANCEMENT: D3D12_VIDEO_PROCESS_FILTER_FLAGS = D3D12_VIDEO_PROCESS_FILTER_FLAGS(32u32);
pub const D3D12_VIDEO_PROCESS_FILTER_FLAG_ANAMORPHIC_SCALING: D3D12_VIDEO_PROCESS_FILTER_FLAGS = D3D12_VIDEO_PROCESS_FILTER_FLAGS(64u32);
pub const D3D12_VIDEO_PROCESS_FILTER_FLAG_STEREO_ADJUSTMENT: D3D12_VIDEO_PROCESS_FILTER_FLAGS = D3D12_VIDEO_PROCESS_FILTER_FLAGS(128u32);
impl ::core::convert::From<u32> for D3D12_VIDEO_PROCESS_FILTER_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_PROCESS_FILTER_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for D3D12_VIDEO_PROCESS_FILTER_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for D3D12_VIDEO_PROCESS_FILTER_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for D3D12_VIDEO_PROCESS_FILTER_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for D3D12_VIDEO_PROCESS_FILTER_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for D3D12_VIDEO_PROCESS_FILTER_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_PROCESS_FILTER_RANGE {
pub Minimum: i32,
pub Maximum: i32,
pub Default: i32,
pub Multiplier: f32,
}
impl D3D12_VIDEO_PROCESS_FILTER_RANGE {}
impl ::core::default::Default for D3D12_VIDEO_PROCESS_FILTER_RANGE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_VIDEO_PROCESS_FILTER_RANGE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_PROCESS_FILTER_RANGE").field("Minimum", &self.Minimum).field("Maximum", &self.Maximum).field("Default", &self.Default).field("Multiplier", &self.Multiplier).finish()
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_PROCESS_FILTER_RANGE {
fn eq(&self, other: &Self) -> bool {
self.Minimum == other.Minimum && self.Maximum == other.Maximum && self.Default == other.Default && self.Multiplier == other.Multiplier
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_PROCESS_FILTER_RANGE {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_PROCESS_FILTER_RANGE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub struct D3D12_VIDEO_PROCESS_INPUT_STREAM {
pub pTexture2D: ::core::option::Option<super::super::Graphics::Direct3D12::ID3D12Resource>,
pub Subresource: u32,
pub ReferenceSet: D3D12_VIDEO_PROCESS_REFERENCE_SET,
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl D3D12_VIDEO_PROCESS_INPUT_STREAM {}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::default::Default for D3D12_VIDEO_PROCESS_INPUT_STREAM {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::fmt::Debug for D3D12_VIDEO_PROCESS_INPUT_STREAM {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_PROCESS_INPUT_STREAM").field("pTexture2D", &self.pTexture2D).field("Subresource", &self.Subresource).field("ReferenceSet", &self.ReferenceSet).finish()
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_PROCESS_INPUT_STREAM {
fn eq(&self, other: &Self) -> bool {
self.pTexture2D == other.pTexture2D && self.Subresource == other.Subresource && self.ReferenceSet == other.ReferenceSet
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::cmp::Eq for D3D12_VIDEO_PROCESS_INPUT_STREAM {}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_PROCESS_INPUT_STREAM {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
pub struct D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS {
pub InputStream: [D3D12_VIDEO_PROCESS_INPUT_STREAM; 2],
pub Transform: D3D12_VIDEO_PROCESS_TRANSFORM,
pub Flags: D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS,
pub RateInfo: D3D12_VIDEO_PROCESS_INPUT_STREAM_RATE,
pub FilterLevels: [i32; 32],
pub AlphaBlending: D3D12_VIDEO_PROCESS_ALPHA_BLENDING,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
impl D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
impl ::core::default::Default for D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
impl ::core::cmp::PartialEq for D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
impl ::core::cmp::Eq for D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
pub struct D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS1 {
pub InputStream: [D3D12_VIDEO_PROCESS_INPUT_STREAM; 2],
pub Transform: D3D12_VIDEO_PROCESS_TRANSFORM,
pub Flags: D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS,
pub RateInfo: D3D12_VIDEO_PROCESS_INPUT_STREAM_RATE,
pub FilterLevels: [i32; 32],
pub AlphaBlending: D3D12_VIDEO_PROCESS_ALPHA_BLENDING,
pub FieldType: D3D12_VIDEO_FIELD_TYPE,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
impl D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS1 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
impl ::core::default::Default for D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS1 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
impl ::core::cmp::PartialEq for D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS1 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
impl ::core::cmp::Eq for D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS1 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS1 {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
pub struct D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC {
pub Format: super::super::Graphics::Dxgi::Common::DXGI_FORMAT,
pub ColorSpace: super::super::Graphics::Dxgi::Common::DXGI_COLOR_SPACE_TYPE,
pub SourceAspectRatio: super::super::Graphics::Dxgi::Common::DXGI_RATIONAL,
pub DestinationAspectRatio: super::super::Graphics::Dxgi::Common::DXGI_RATIONAL,
pub FrameRate: super::super::Graphics::Dxgi::Common::DXGI_RATIONAL,
pub SourceSizeRange: D3D12_VIDEO_SIZE_RANGE,
pub DestinationSizeRange: D3D12_VIDEO_SIZE_RANGE,
pub EnableOrientation: super::super::Foundation::BOOL,
pub FilterFlags: D3D12_VIDEO_PROCESS_FILTER_FLAGS,
pub StereoFormat: D3D12_VIDEO_FRAME_STEREO_FORMAT,
pub FieldType: D3D12_VIDEO_FIELD_TYPE,
pub DeinterlaceMode: D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS,
pub EnableAlphaBlending: super::super::Foundation::BOOL,
pub LumaKey: D3D12_VIDEO_PROCESS_LUMA_KEY,
pub NumPastFrames: u32,
pub NumFutureFrames: u32,
pub EnableAutoProcessing: super::super::Foundation::BOOL,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::default::Default for D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::fmt::Debug for D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC")
.field("Format", &self.Format)
.field("ColorSpace", &self.ColorSpace)
.field("SourceAspectRatio", &self.SourceAspectRatio)
.field("DestinationAspectRatio", &self.DestinationAspectRatio)
.field("FrameRate", &self.FrameRate)
.field("SourceSizeRange", &self.SourceSizeRange)
.field("DestinationSizeRange", &self.DestinationSizeRange)
.field("EnableOrientation", &self.EnableOrientation)
.field("FilterFlags", &self.FilterFlags)
.field("StereoFormat", &self.StereoFormat)
.field("FieldType", &self.FieldType)
.field("DeinterlaceMode", &self.DeinterlaceMode)
.field("EnableAlphaBlending", &self.EnableAlphaBlending)
.field("LumaKey", &self.LumaKey)
.field("NumPastFrames", &self.NumPastFrames)
.field("NumFutureFrames", &self.NumFutureFrames)
.field("EnableAutoProcessing", &self.EnableAutoProcessing)
.finish()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::cmp::PartialEq for D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC {
fn eq(&self, other: &Self) -> bool {
self.Format == other.Format
&& self.ColorSpace == other.ColorSpace
&& self.SourceAspectRatio == other.SourceAspectRatio
&& self.DestinationAspectRatio == other.DestinationAspectRatio
&& self.FrameRate == other.FrameRate
&& self.SourceSizeRange == other.SourceSizeRange
&& self.DestinationSizeRange == other.DestinationSizeRange
&& self.EnableOrientation == other.EnableOrientation
&& self.FilterFlags == other.FilterFlags
&& self.StereoFormat == other.StereoFormat
&& self.FieldType == other.FieldType
&& self.DeinterlaceMode == other.DeinterlaceMode
&& self.EnableAlphaBlending == other.EnableAlphaBlending
&& self.LumaKey == other.LumaKey
&& self.NumPastFrames == other.NumPastFrames
&& self.NumFutureFrames == other.NumFutureFrames
&& self.EnableAutoProcessing == other.EnableAutoProcessing
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::cmp::Eq for D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS(pub u32);
pub const D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAG_NONE: D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS = D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS(0u32);
pub const D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAG_FRAME_DISCONTINUITY: D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS = D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS(1u32);
pub const D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAG_FRAME_REPEAT: D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS = D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS(2u32);
impl ::core::convert::From<u32> for D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_PROCESS_INPUT_STREAM_RATE {
pub OutputIndex: u32,
pub InputFrameOrField: u32,
}
impl D3D12_VIDEO_PROCESS_INPUT_STREAM_RATE {}
impl ::core::default::Default for D3D12_VIDEO_PROCESS_INPUT_STREAM_RATE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_VIDEO_PROCESS_INPUT_STREAM_RATE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_PROCESS_INPUT_STREAM_RATE").field("OutputIndex", &self.OutputIndex).field("InputFrameOrField", &self.InputFrameOrField).finish()
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_PROCESS_INPUT_STREAM_RATE {
fn eq(&self, other: &Self) -> bool {
self.OutputIndex == other.OutputIndex && self.InputFrameOrField == other.InputFrameOrField
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_PROCESS_INPUT_STREAM_RATE {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_PROCESS_INPUT_STREAM_RATE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct D3D12_VIDEO_PROCESS_LUMA_KEY {
pub Enable: super::super::Foundation::BOOL,
pub Lower: f32,
pub Upper: f32,
}
#[cfg(feature = "Win32_Foundation")]
impl D3D12_VIDEO_PROCESS_LUMA_KEY {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for D3D12_VIDEO_PROCESS_LUMA_KEY {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for D3D12_VIDEO_PROCESS_LUMA_KEY {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_PROCESS_LUMA_KEY").field("Enable", &self.Enable).field("Lower", &self.Lower).field("Upper", &self.Upper).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_PROCESS_LUMA_KEY {
fn eq(&self, other: &Self) -> bool {
self.Enable == other.Enable && self.Lower == other.Lower && self.Upper == other.Upper
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for D3D12_VIDEO_PROCESS_LUMA_KEY {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_PROCESS_LUMA_KEY {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_PROCESS_ORIENTATION(pub i32);
pub const D3D12_VIDEO_PROCESS_ORIENTATION_DEFAULT: D3D12_VIDEO_PROCESS_ORIENTATION = D3D12_VIDEO_PROCESS_ORIENTATION(0i32);
pub const D3D12_VIDEO_PROCESS_ORIENTATION_FLIP_HORIZONTAL: D3D12_VIDEO_PROCESS_ORIENTATION = D3D12_VIDEO_PROCESS_ORIENTATION(1i32);
pub const D3D12_VIDEO_PROCESS_ORIENTATION_CLOCKWISE_90: D3D12_VIDEO_PROCESS_ORIENTATION = D3D12_VIDEO_PROCESS_ORIENTATION(2i32);
pub const D3D12_VIDEO_PROCESS_ORIENTATION_CLOCKWISE_90_FLIP_HORIZONTAL: D3D12_VIDEO_PROCESS_ORIENTATION = D3D12_VIDEO_PROCESS_ORIENTATION(3i32);
pub const D3D12_VIDEO_PROCESS_ORIENTATION_CLOCKWISE_180: D3D12_VIDEO_PROCESS_ORIENTATION = D3D12_VIDEO_PROCESS_ORIENTATION(4i32);
pub const D3D12_VIDEO_PROCESS_ORIENTATION_FLIP_VERTICAL: D3D12_VIDEO_PROCESS_ORIENTATION = D3D12_VIDEO_PROCESS_ORIENTATION(5i32);
pub const D3D12_VIDEO_PROCESS_ORIENTATION_CLOCKWISE_270: D3D12_VIDEO_PROCESS_ORIENTATION = D3D12_VIDEO_PROCESS_ORIENTATION(6i32);
pub const D3D12_VIDEO_PROCESS_ORIENTATION_CLOCKWISE_270_FLIP_HORIZONTAL: D3D12_VIDEO_PROCESS_ORIENTATION = D3D12_VIDEO_PROCESS_ORIENTATION(7i32);
impl ::core::convert::From<i32> for D3D12_VIDEO_PROCESS_ORIENTATION {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_PROCESS_ORIENTATION {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub struct D3D12_VIDEO_PROCESS_OUTPUT_STREAM {
pub pTexture2D: ::core::option::Option<super::super::Graphics::Direct3D12::ID3D12Resource>,
pub Subresource: u32,
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl D3D12_VIDEO_PROCESS_OUTPUT_STREAM {}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::default::Default for D3D12_VIDEO_PROCESS_OUTPUT_STREAM {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::fmt::Debug for D3D12_VIDEO_PROCESS_OUTPUT_STREAM {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_PROCESS_OUTPUT_STREAM").field("pTexture2D", &self.pTexture2D).field("Subresource", &self.Subresource).finish()
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_PROCESS_OUTPUT_STREAM {
fn eq(&self, other: &Self) -> bool {
self.pTexture2D == other.pTexture2D && self.Subresource == other.Subresource
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::cmp::Eq for D3D12_VIDEO_PROCESS_OUTPUT_STREAM {}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_PROCESS_OUTPUT_STREAM {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
pub struct D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS {
pub OutputStream: [D3D12_VIDEO_PROCESS_OUTPUT_STREAM; 2],
pub TargetRectangle: super::super::Foundation::RECT,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
impl D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
impl ::core::default::Default for D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
impl ::core::cmp::PartialEq for D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
impl ::core::cmp::Eq for D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
pub struct D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC {
pub Format: super::super::Graphics::Dxgi::Common::DXGI_FORMAT,
pub ColorSpace: super::super::Graphics::Dxgi::Common::DXGI_COLOR_SPACE_TYPE,
pub AlphaFillMode: D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE,
pub AlphaFillModeSourceStreamIndex: u32,
pub BackgroundColor: [f32; 4],
pub FrameRate: super::super::Graphics::Dxgi::Common::DXGI_RATIONAL,
pub EnableStereo: super::super::Foundation::BOOL,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::default::Default for D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::fmt::Debug for D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC")
.field("Format", &self.Format)
.field("ColorSpace", &self.ColorSpace)
.field("AlphaFillMode", &self.AlphaFillMode)
.field("AlphaFillModeSourceStreamIndex", &self.AlphaFillModeSourceStreamIndex)
.field("BackgroundColor", &self.BackgroundColor)
.field("FrameRate", &self.FrameRate)
.field("EnableStereo", &self.EnableStereo)
.finish()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::cmp::PartialEq for D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC {
fn eq(&self, other: &Self) -> bool {
self.Format == other.Format && self.ColorSpace == other.ColorSpace && self.AlphaFillMode == other.AlphaFillMode && self.AlphaFillModeSourceStreamIndex == other.AlphaFillModeSourceStreamIndex && self.BackgroundColor == other.BackgroundColor && self.FrameRate == other.FrameRate && self.EnableStereo == other.EnableStereo
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
impl ::core::cmp::Eq for D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub struct D3D12_VIDEO_PROCESS_REFERENCE_SET {
pub NumPastFrames: u32,
pub ppPastFrames: *mut ::core::option::Option<super::super::Graphics::Direct3D12::ID3D12Resource>,
pub pPastSubresources: *mut u32,
pub NumFutureFrames: u32,
pub ppFutureFrames: *mut ::core::option::Option<super::super::Graphics::Direct3D12::ID3D12Resource>,
pub pFutureSubresources: *mut u32,
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl D3D12_VIDEO_PROCESS_REFERENCE_SET {}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::default::Default for D3D12_VIDEO_PROCESS_REFERENCE_SET {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::fmt::Debug for D3D12_VIDEO_PROCESS_REFERENCE_SET {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_PROCESS_REFERENCE_SET")
.field("NumPastFrames", &self.NumPastFrames)
.field("ppPastFrames", &self.ppPastFrames)
.field("pPastSubresources", &self.pPastSubresources)
.field("NumFutureFrames", &self.NumFutureFrames)
.field("ppFutureFrames", &self.ppFutureFrames)
.field("pFutureSubresources", &self.pFutureSubresources)
.finish()
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_PROCESS_REFERENCE_SET {
fn eq(&self, other: &Self) -> bool {
self.NumPastFrames == other.NumPastFrames && self.ppPastFrames == other.ppPastFrames && self.pPastSubresources == other.pPastSubresources && self.NumFutureFrames == other.NumFutureFrames && self.ppFutureFrames == other.ppFutureFrames && self.pFutureSubresources == other.pFutureSubresources
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::cmp::Eq for D3D12_VIDEO_PROCESS_REFERENCE_SET {}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_PROCESS_REFERENCE_SET {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_PROCESS_SUPPORT_FLAGS(pub u32);
pub const D3D12_VIDEO_PROCESS_SUPPORT_FLAG_NONE: D3D12_VIDEO_PROCESS_SUPPORT_FLAGS = D3D12_VIDEO_PROCESS_SUPPORT_FLAGS(0u32);
pub const D3D12_VIDEO_PROCESS_SUPPORT_FLAG_SUPPORTED: D3D12_VIDEO_PROCESS_SUPPORT_FLAGS = D3D12_VIDEO_PROCESS_SUPPORT_FLAGS(1u32);
impl ::core::convert::From<u32> for D3D12_VIDEO_PROCESS_SUPPORT_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_PROCESS_SUPPORT_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for D3D12_VIDEO_PROCESS_SUPPORT_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for D3D12_VIDEO_PROCESS_SUPPORT_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for D3D12_VIDEO_PROCESS_SUPPORT_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for D3D12_VIDEO_PROCESS_SUPPORT_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for D3D12_VIDEO_PROCESS_SUPPORT_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct D3D12_VIDEO_PROCESS_TRANSFORM {
pub SourceRectangle: super::super::Foundation::RECT,
pub DestinationRectangle: super::super::Foundation::RECT,
pub Orientation: D3D12_VIDEO_PROCESS_ORIENTATION,
}
#[cfg(feature = "Win32_Foundation")]
impl D3D12_VIDEO_PROCESS_TRANSFORM {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for D3D12_VIDEO_PROCESS_TRANSFORM {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for D3D12_VIDEO_PROCESS_TRANSFORM {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_PROCESS_TRANSFORM").field("SourceRectangle", &self.SourceRectangle).field("DestinationRectangle", &self.DestinationRectangle).field("Orientation", &self.Orientation).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_PROCESS_TRANSFORM {
fn eq(&self, other: &Self) -> bool {
self.SourceRectangle == other.SourceRectangle && self.DestinationRectangle == other.DestinationRectangle && self.Orientation == other.Orientation
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for D3D12_VIDEO_PROCESS_TRANSFORM {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_PROCESS_TRANSFORM {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS(pub u32);
pub const D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAG_NONE: D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS = D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS(0u32);
pub const D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAG_SUPPORTED: D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS = D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS(1u32);
impl ::core::convert::From<u32> for D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
pub struct D3D12_VIDEO_SAMPLE {
pub Width: u32,
pub Height: u32,
pub Format: D3D12_VIDEO_FORMAT,
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl D3D12_VIDEO_SAMPLE {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::default::Default for D3D12_VIDEO_SAMPLE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::fmt::Debug for D3D12_VIDEO_SAMPLE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_SAMPLE").field("Width", &self.Width).field("Height", &self.Height).field("Format", &self.Format).finish()
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::PartialEq for D3D12_VIDEO_SAMPLE {
fn eq(&self, other: &Self) -> bool {
self.Width == other.Width && self.Height == other.Height && self.Format == other.Format
}
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
impl ::core::cmp::Eq for D3D12_VIDEO_SAMPLE {}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
unsafe impl ::windows::core::Abi for D3D12_VIDEO_SAMPLE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_SCALE_SUPPORT {
pub OutputSizeRange: D3D12_VIDEO_SIZE_RANGE,
pub Flags: D3D12_VIDEO_SCALE_SUPPORT_FLAGS,
}
impl D3D12_VIDEO_SCALE_SUPPORT {}
impl ::core::default::Default for D3D12_VIDEO_SCALE_SUPPORT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_VIDEO_SCALE_SUPPORT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_SCALE_SUPPORT").field("OutputSizeRange", &self.OutputSizeRange).field("Flags", &self.Flags).finish()
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_SCALE_SUPPORT {
fn eq(&self, other: &Self) -> bool {
self.OutputSizeRange == other.OutputSizeRange && self.Flags == other.Flags
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_SCALE_SUPPORT {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_SCALE_SUPPORT {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct D3D12_VIDEO_SCALE_SUPPORT_FLAGS(pub u32);
pub const D3D12_VIDEO_SCALE_SUPPORT_FLAG_NONE: D3D12_VIDEO_SCALE_SUPPORT_FLAGS = D3D12_VIDEO_SCALE_SUPPORT_FLAGS(0u32);
pub const D3D12_VIDEO_SCALE_SUPPORT_FLAG_POW2_ONLY: D3D12_VIDEO_SCALE_SUPPORT_FLAGS = D3D12_VIDEO_SCALE_SUPPORT_FLAGS(1u32);
pub const D3D12_VIDEO_SCALE_SUPPORT_FLAG_EVEN_DIMENSIONS_ONLY: D3D12_VIDEO_SCALE_SUPPORT_FLAGS = D3D12_VIDEO_SCALE_SUPPORT_FLAGS(2u32);
impl ::core::convert::From<u32> for D3D12_VIDEO_SCALE_SUPPORT_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_SCALE_SUPPORT_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for D3D12_VIDEO_SCALE_SUPPORT_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for D3D12_VIDEO_SCALE_SUPPORT_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for D3D12_VIDEO_SCALE_SUPPORT_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for D3D12_VIDEO_SCALE_SUPPORT_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for D3D12_VIDEO_SCALE_SUPPORT_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3D12_VIDEO_SIZE_RANGE {
pub MaxWidth: u32,
pub MaxHeight: u32,
pub MinWidth: u32,
pub MinHeight: u32,
}
impl D3D12_VIDEO_SIZE_RANGE {}
impl ::core::default::Default for D3D12_VIDEO_SIZE_RANGE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3D12_VIDEO_SIZE_RANGE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3D12_VIDEO_SIZE_RANGE").field("MaxWidth", &self.MaxWidth).field("MaxHeight", &self.MaxHeight).field("MinWidth", &self.MinWidth).field("MinHeight", &self.MinHeight).finish()
}
}
impl ::core::cmp::PartialEq for D3D12_VIDEO_SIZE_RANGE {
fn eq(&self, other: &Self) -> bool {
self.MaxWidth == other.MaxWidth && self.MaxHeight == other.MaxHeight && self.MinWidth == other.MinWidth && self.MinHeight == other.MinHeight
}
}
impl ::core::cmp::Eq for D3D12_VIDEO_SIZE_RANGE {}
unsafe impl ::windows::core::Abi for D3D12_VIDEO_SIZE_RANGE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
pub struct D3DCONTENTPROTECTIONCAPS {
pub Caps: u32,
pub KeyExchangeType: ::windows::core::GUID,
pub BufferAlignmentStart: u32,
pub BlockAlignmentSize: u32,
pub ProtectedMemorySize: u64,
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
impl D3DCONTENTPROTECTIONCAPS {}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
impl ::core::default::Default for D3DCONTENTPROTECTIONCAPS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
impl ::core::fmt::Debug for D3DCONTENTPROTECTIONCAPS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3DCONTENTPROTECTIONCAPS").field("Caps", &self.Caps).field("KeyExchangeType", &self.KeyExchangeType).field("BufferAlignmentStart", &self.BufferAlignmentStart).field("BlockAlignmentSize", &self.BlockAlignmentSize).field("ProtectedMemorySize", &self.ProtectedMemorySize).finish()
}
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
impl ::core::cmp::PartialEq for D3DCONTENTPROTECTIONCAPS {
fn eq(&self, other: &Self) -> bool {
self.Caps == other.Caps && self.KeyExchangeType == other.KeyExchangeType && self.BufferAlignmentStart == other.BufferAlignmentStart && self.BlockAlignmentSize == other.BlockAlignmentSize && self.ProtectedMemorySize == other.ProtectedMemorySize
}
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
impl ::core::cmp::Eq for D3DCONTENTPROTECTIONCAPS {}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
unsafe impl ::windows::core::Abi for D3DCONTENTPROTECTIONCAPS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
#[cfg(any(target_arch = "x86",))]
pub struct D3DCONTENTPROTECTIONCAPS {
pub Caps: u32,
pub KeyExchangeType: ::windows::core::GUID,
pub BufferAlignmentStart: u32,
pub BlockAlignmentSize: u32,
pub ProtectedMemorySize: u64,
}
#[cfg(any(target_arch = "x86",))]
impl D3DCONTENTPROTECTIONCAPS {}
#[cfg(any(target_arch = "x86",))]
impl ::core::default::Default for D3DCONTENTPROTECTIONCAPS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86",))]
impl ::core::cmp::PartialEq for D3DCONTENTPROTECTIONCAPS {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(any(target_arch = "x86",))]
impl ::core::cmp::Eq for D3DCONTENTPROTECTIONCAPS {}
#[cfg(any(target_arch = "x86",))]
unsafe impl ::windows::core::Abi for D3DCONTENTPROTECTIONCAPS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct D3DOVERLAYCAPS {
pub Caps: u32,
pub MaxOverlayDisplayWidth: u32,
pub MaxOverlayDisplayHeight: u32,
}
impl D3DOVERLAYCAPS {}
impl ::core::default::Default for D3DOVERLAYCAPS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for D3DOVERLAYCAPS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("D3DOVERLAYCAPS").field("Caps", &self.Caps).field("MaxOverlayDisplayWidth", &self.MaxOverlayDisplayWidth).field("MaxOverlayDisplayHeight", &self.MaxOverlayDisplayHeight).finish()
}
}
impl ::core::cmp::PartialEq for D3DOVERLAYCAPS {
fn eq(&self, other: &Self) -> bool {
self.Caps == other.Caps && self.MaxOverlayDisplayWidth == other.MaxOverlayDisplayWidth && self.MaxOverlayDisplayHeight == other.MaxOverlayDisplayHeight
}
}
impl ::core::cmp::Eq for D3DOVERLAYCAPS {}
unsafe impl ::windows::core::Abi for D3DOVERLAYCAPS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DEVICE_INFO {
pub pFriendlyDeviceName: super::super::Foundation::BSTR,
pub pUniqueDeviceName: super::super::Foundation::BSTR,
pub pManufacturerName: super::super::Foundation::BSTR,
pub pModelName: super::super::Foundation::BSTR,
pub pIconURL: super::super::Foundation::BSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl DEVICE_INFO {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DEVICE_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DEVICE_INFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEVICE_INFO").field("pFriendlyDeviceName", &self.pFriendlyDeviceName).field("pUniqueDeviceName", &self.pUniqueDeviceName).field("pManufacturerName", &self.pManufacturerName).field("pModelName", &self.pModelName).field("pIconURL", &self.pIconURL).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DEVICE_INFO {
fn eq(&self, other: &Self) -> bool {
self.pFriendlyDeviceName == other.pFriendlyDeviceName && self.pUniqueDeviceName == other.pUniqueDeviceName && self.pManufacturerName == other.pManufacturerName && self.pModelName == other.pModelName && self.pIconURL == other.pIconURL
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DEVICE_INFO {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DEVICE_INFO {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
pub const DEVPKEY_DeviceInterface_IsVirtualCamera: super::super::UI::Shell::PropertiesSystem::PROPERTYKEY = super::super::UI::Shell::PropertiesSystem::PROPERTYKEY { fmtid: ::windows::core::GUID::from_u128(0x6edc630d_c2e3_43b7_b2d1_20525a1af120), pid: 3u32 };
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DIRTYRECT_INFO {
pub FrameNumber: u32,
pub NumDirtyRects: u32,
pub DirtyRects: [super::super::Foundation::RECT; 1],
}
#[cfg(feature = "Win32_Foundation")]
impl DIRTYRECT_INFO {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DIRTYRECT_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DIRTYRECT_INFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DIRTYRECT_INFO").field("FrameNumber", &self.FrameNumber).field("NumDirtyRects", &self.NumDirtyRects).field("DirtyRects", &self.DirtyRects).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DIRTYRECT_INFO {
fn eq(&self, other: &Self) -> bool {
self.FrameNumber == other.FrameNumber && self.NumDirtyRects == other.NumDirtyRects && self.DirtyRects == other.DirtyRects
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DIRTYRECT_INFO {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DIRTYRECT_INFO {
type Abi = Self;
}
#[inline]
pub unsafe fn DXVA2CreateDirect3DDeviceManager9(presettoken: *mut u32, ppdevicemanager: *mut ::core::option::Option<IDirect3DDeviceManager9>) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DXVA2CreateDirect3DDeviceManager9(presettoken: *mut u32, ppdevicemanager: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
DXVA2CreateDirect3DDeviceManager9(::core::mem::transmute(presettoken), ::core::mem::transmute(ppdevicemanager)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
#[inline]
pub unsafe fn DXVA2CreateVideoService<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D9::IDirect3DDevice9>>(pdd: Param0, riid: *const ::windows::core::GUID, ppservice: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DXVA2CreateVideoService(pdd: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppservice: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT;
}
DXVA2CreateVideoService(pdd.into_param().abi(), ::core::mem::transmute(riid), ::core::mem::transmute(ppservice)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVA2_AES_CTR_IV {
pub IV: u64,
pub Count: u64,
}
impl DXVA2_AES_CTR_IV {}
impl ::core::default::Default for DXVA2_AES_CTR_IV {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVA2_AES_CTR_IV {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA2_AES_CTR_IV").field("IV", &self.IV).field("Count", &self.Count).finish()
}
}
impl ::core::cmp::PartialEq for DXVA2_AES_CTR_IV {
fn eq(&self, other: &Self) -> bool {
self.IV == other.IV && self.Count == other.Count
}
}
impl ::core::cmp::Eq for DXVA2_AES_CTR_IV {}
unsafe impl ::windows::core::Abi for DXVA2_AES_CTR_IV {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVA2_AYUVSample16 {
pub Cr: u16,
pub Cb: u16,
pub Y: u16,
pub Alpha: u16,
}
impl DXVA2_AYUVSample16 {}
impl ::core::default::Default for DXVA2_AYUVSample16 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVA2_AYUVSample16 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA2_AYUVSample16").field("Cr", &self.Cr).field("Cb", &self.Cb).field("Y", &self.Y).field("Alpha", &self.Alpha).finish()
}
}
impl ::core::cmp::PartialEq for DXVA2_AYUVSample16 {
fn eq(&self, other: &Self) -> bool {
self.Cr == other.Cr && self.Cb == other.Cb && self.Y == other.Y && self.Alpha == other.Alpha
}
}
impl ::core::cmp::Eq for DXVA2_AYUVSample16 {}
unsafe impl ::windows::core::Abi for DXVA2_AYUVSample16 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVA2_AYUVSample8 {
pub Cr: u8,
pub Cb: u8,
pub Y: u8,
pub Alpha: u8,
}
impl DXVA2_AYUVSample8 {}
impl ::core::default::Default for DXVA2_AYUVSample8 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVA2_AYUVSample8 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA2_AYUVSample8").field("Cr", &self.Cr).field("Cb", &self.Cb).field("Y", &self.Y).field("Alpha", &self.Alpha).finish()
}
}
impl ::core::cmp::PartialEq for DXVA2_AYUVSample8 {
fn eq(&self, other: &Self) -> bool {
self.Cr == other.Cr && self.Cb == other.Cb && self.Y == other.Y && self.Alpha == other.Alpha
}
}
impl ::core::cmp::Eq for DXVA2_AYUVSample8 {}
unsafe impl ::windows::core::Abi for DXVA2_AYUVSample8 {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA2_BufferfType(pub i32);
pub const DXVA2_PictureParametersBufferType: DXVA2_BufferfType = DXVA2_BufferfType(0i32);
pub const DXVA2_MacroBlockControlBufferType: DXVA2_BufferfType = DXVA2_BufferfType(1i32);
pub const DXVA2_ResidualDifferenceBufferType: DXVA2_BufferfType = DXVA2_BufferfType(2i32);
pub const DXVA2_DeblockingControlBufferType: DXVA2_BufferfType = DXVA2_BufferfType(3i32);
pub const DXVA2_InverseQuantizationMatrixBufferType: DXVA2_BufferfType = DXVA2_BufferfType(4i32);
pub const DXVA2_SliceControlBufferType: DXVA2_BufferfType = DXVA2_BufferfType(5i32);
pub const DXVA2_BitStreamDateBufferType: DXVA2_BufferfType = DXVA2_BufferfType(6i32);
pub const DXVA2_MotionVectorBuffer: DXVA2_BufferfType = DXVA2_BufferfType(7i32);
pub const DXVA2_FilmGrainBuffer: DXVA2_BufferfType = DXVA2_BufferfType(8i32);
impl ::core::convert::From<i32> for DXVA2_BufferfType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA2_BufferfType {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVA2_ConfigPictureDecode {
pub guidConfigBitstreamEncryption: ::windows::core::GUID,
pub guidConfigMBcontrolEncryption: ::windows::core::GUID,
pub guidConfigResidDiffEncryption: ::windows::core::GUID,
pub ConfigBitstreamRaw: u32,
pub ConfigMBcontrolRasterOrder: u32,
pub ConfigResidDiffHost: u32,
pub ConfigSpatialResid8: u32,
pub ConfigResid8Subtraction: u32,
pub ConfigSpatialHost8or9Clipping: u32,
pub ConfigSpatialResidInterleaved: u32,
pub ConfigIntraResidUnsigned: u32,
pub ConfigResidDiffAccelerator: u32,
pub ConfigHostInverseScan: u32,
pub ConfigSpecificIDCT: u32,
pub Config4GroupedCoefs: u32,
pub ConfigMinRenderTargetBuffCount: u16,
pub ConfigDecoderSpecific: u16,
}
impl DXVA2_ConfigPictureDecode {}
impl ::core::default::Default for DXVA2_ConfigPictureDecode {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVA2_ConfigPictureDecode {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA2_ConfigPictureDecode")
.field("guidConfigBitstreamEncryption", &self.guidConfigBitstreamEncryption)
.field("guidConfigMBcontrolEncryption", &self.guidConfigMBcontrolEncryption)
.field("guidConfigResidDiffEncryption", &self.guidConfigResidDiffEncryption)
.field("ConfigBitstreamRaw", &self.ConfigBitstreamRaw)
.field("ConfigMBcontrolRasterOrder", &self.ConfigMBcontrolRasterOrder)
.field("ConfigResidDiffHost", &self.ConfigResidDiffHost)
.field("ConfigSpatialResid8", &self.ConfigSpatialResid8)
.field("ConfigResid8Subtraction", &self.ConfigResid8Subtraction)
.field("ConfigSpatialHost8or9Clipping", &self.ConfigSpatialHost8or9Clipping)
.field("ConfigSpatialResidInterleaved", &self.ConfigSpatialResidInterleaved)
.field("ConfigIntraResidUnsigned", &self.ConfigIntraResidUnsigned)
.field("ConfigResidDiffAccelerator", &self.ConfigResidDiffAccelerator)
.field("ConfigHostInverseScan", &self.ConfigHostInverseScan)
.field("ConfigSpecificIDCT", &self.ConfigSpecificIDCT)
.field("Config4GroupedCoefs", &self.Config4GroupedCoefs)
.field("ConfigMinRenderTargetBuffCount", &self.ConfigMinRenderTargetBuffCount)
.field("ConfigDecoderSpecific", &self.ConfigDecoderSpecific)
.finish()
}
}
impl ::core::cmp::PartialEq for DXVA2_ConfigPictureDecode {
fn eq(&self, other: &Self) -> bool {
self.guidConfigBitstreamEncryption == other.guidConfigBitstreamEncryption
&& self.guidConfigMBcontrolEncryption == other.guidConfigMBcontrolEncryption
&& self.guidConfigResidDiffEncryption == other.guidConfigResidDiffEncryption
&& self.ConfigBitstreamRaw == other.ConfigBitstreamRaw
&& self.ConfigMBcontrolRasterOrder == other.ConfigMBcontrolRasterOrder
&& self.ConfigResidDiffHost == other.ConfigResidDiffHost
&& self.ConfigSpatialResid8 == other.ConfigSpatialResid8
&& self.ConfigResid8Subtraction == other.ConfigResid8Subtraction
&& self.ConfigSpatialHost8or9Clipping == other.ConfigSpatialHost8or9Clipping
&& self.ConfigSpatialResidInterleaved == other.ConfigSpatialResidInterleaved
&& self.ConfigIntraResidUnsigned == other.ConfigIntraResidUnsigned
&& self.ConfigResidDiffAccelerator == other.ConfigResidDiffAccelerator
&& self.ConfigHostInverseScan == other.ConfigHostInverseScan
&& self.ConfigSpecificIDCT == other.ConfigSpecificIDCT
&& self.Config4GroupedCoefs == other.Config4GroupedCoefs
&& self.ConfigMinRenderTargetBuffCount == other.ConfigMinRenderTargetBuffCount
&& self.ConfigDecoderSpecific == other.ConfigDecoderSpecific
}
}
impl ::core::cmp::Eq for DXVA2_ConfigPictureDecode {}
unsafe impl ::windows::core::Abi for DXVA2_ConfigPictureDecode {
type Abi = Self;
}
pub const DXVA2_DECODE_GET_DRIVER_HANDLE: u32 = 1829u32;
pub const DXVA2_DECODE_SPECIFY_ENCRYPTED_BLOCKS: u32 = 1828u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVA2_DecodeBufferDesc {
pub CompressedBufferType: DXVA2_BufferfType,
pub BufferIndex: u32,
pub DataOffset: u32,
pub DataSize: u32,
pub FirstMBaddress: u32,
pub NumMBsInBuffer: u32,
pub Width: u32,
pub Height: u32,
pub Stride: u32,
pub ReservedBits: u32,
pub pvPVPState: *mut ::core::ffi::c_void,
}
impl DXVA2_DecodeBufferDesc {}
impl ::core::default::Default for DXVA2_DecodeBufferDesc {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVA2_DecodeBufferDesc {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA2_DecodeBufferDesc")
.field("CompressedBufferType", &self.CompressedBufferType)
.field("BufferIndex", &self.BufferIndex)
.field("DataOffset", &self.DataOffset)
.field("DataSize", &self.DataSize)
.field("FirstMBaddress", &self.FirstMBaddress)
.field("NumMBsInBuffer", &self.NumMBsInBuffer)
.field("Width", &self.Width)
.field("Height", &self.Height)
.field("Stride", &self.Stride)
.field("ReservedBits", &self.ReservedBits)
.field("pvPVPState", &self.pvPVPState)
.finish()
}
}
impl ::core::cmp::PartialEq for DXVA2_DecodeBufferDesc {
fn eq(&self, other: &Self) -> bool {
self.CompressedBufferType == other.CompressedBufferType && self.BufferIndex == other.BufferIndex && self.DataOffset == other.DataOffset && self.DataSize == other.DataSize && self.FirstMBaddress == other.FirstMBaddress && self.NumMBsInBuffer == other.NumMBsInBuffer && self.Width == other.Width && self.Height == other.Height && self.Stride == other.Stride && self.ReservedBits == other.ReservedBits && self.pvPVPState == other.pvPVPState
}
}
impl ::core::cmp::Eq for DXVA2_DecodeBufferDesc {}
unsafe impl ::windows::core::Abi for DXVA2_DecodeBufferDesc {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVA2_DecodeExecuteParams {
pub NumCompBuffers: u32,
pub pCompressedBuffers: *mut DXVA2_DecodeBufferDesc,
pub pExtensionData: *mut DXVA2_DecodeExtensionData,
}
impl DXVA2_DecodeExecuteParams {}
impl ::core::default::Default for DXVA2_DecodeExecuteParams {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVA2_DecodeExecuteParams {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA2_DecodeExecuteParams").field("NumCompBuffers", &self.NumCompBuffers).field("pCompressedBuffers", &self.pCompressedBuffers).field("pExtensionData", &self.pExtensionData).finish()
}
}
impl ::core::cmp::PartialEq for DXVA2_DecodeExecuteParams {
fn eq(&self, other: &Self) -> bool {
self.NumCompBuffers == other.NumCompBuffers && self.pCompressedBuffers == other.pCompressedBuffers && self.pExtensionData == other.pExtensionData
}
}
impl ::core::cmp::Eq for DXVA2_DecodeExecuteParams {}
unsafe impl ::windows::core::Abi for DXVA2_DecodeExecuteParams {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVA2_DecodeExtensionData {
pub Function: u32,
pub pPrivateInputData: *mut ::core::ffi::c_void,
pub PrivateInputDataSize: u32,
pub pPrivateOutputData: *mut ::core::ffi::c_void,
pub PrivateOutputDataSize: u32,
}
impl DXVA2_DecodeExtensionData {}
impl ::core::default::Default for DXVA2_DecodeExtensionData {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVA2_DecodeExtensionData {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA2_DecodeExtensionData")
.field("Function", &self.Function)
.field("pPrivateInputData", &self.pPrivateInputData)
.field("PrivateInputDataSize", &self.PrivateInputDataSize)
.field("pPrivateOutputData", &self.pPrivateOutputData)
.field("PrivateOutputDataSize", &self.PrivateOutputDataSize)
.finish()
}
}
impl ::core::cmp::PartialEq for DXVA2_DecodeExtensionData {
fn eq(&self, other: &Self) -> bool {
self.Function == other.Function && self.pPrivateInputData == other.pPrivateInputData && self.PrivateInputDataSize == other.PrivateInputDataSize && self.pPrivateOutputData == other.pPrivateOutputData && self.PrivateOutputDataSize == other.PrivateOutputDataSize
}
}
impl ::core::cmp::Eq for DXVA2_DecodeExtensionData {}
unsafe impl ::windows::core::Abi for DXVA2_DecodeExtensionData {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA2_DeinterlaceTech(pub i32);
pub const DXVA2_DeinterlaceTech_Unknown: DXVA2_DeinterlaceTech = DXVA2_DeinterlaceTech(0i32);
pub const DXVA2_DeinterlaceTech_BOBLineReplicate: DXVA2_DeinterlaceTech = DXVA2_DeinterlaceTech(1i32);
pub const DXVA2_DeinterlaceTech_BOBVerticalStretch: DXVA2_DeinterlaceTech = DXVA2_DeinterlaceTech(2i32);
pub const DXVA2_DeinterlaceTech_BOBVerticalStretch4Tap: DXVA2_DeinterlaceTech = DXVA2_DeinterlaceTech(4i32);
pub const DXVA2_DeinterlaceTech_MedianFiltering: DXVA2_DeinterlaceTech = DXVA2_DeinterlaceTech(8i32);
pub const DXVA2_DeinterlaceTech_EdgeFiltering: DXVA2_DeinterlaceTech = DXVA2_DeinterlaceTech(16i32);
pub const DXVA2_DeinterlaceTech_FieldAdaptive: DXVA2_DeinterlaceTech = DXVA2_DeinterlaceTech(32i32);
pub const DXVA2_DeinterlaceTech_PixelAdaptive: DXVA2_DeinterlaceTech = DXVA2_DeinterlaceTech(64i32);
pub const DXVA2_DeinterlaceTech_MotionVectorSteered: DXVA2_DeinterlaceTech = DXVA2_DeinterlaceTech(128i32);
pub const DXVA2_DeinterlaceTech_InverseTelecine: DXVA2_DeinterlaceTech = DXVA2_DeinterlaceTech(256i32);
pub const DXVA2_DeinterlaceTech_Mask: DXVA2_DeinterlaceTech = DXVA2_DeinterlaceTech(511i32);
impl ::core::convert::From<i32> for DXVA2_DeinterlaceTech {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA2_DeinterlaceTech {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA2_DestData(pub i32);
pub const DXVA2_DestData_RFF: DXVA2_DestData = DXVA2_DestData(1i32);
pub const DXVA2_DestData_TFF: DXVA2_DestData = DXVA2_DestData(2i32);
pub const DXVA2_DestData_RFF_TFF_Present: DXVA2_DestData = DXVA2_DestData(4i32);
pub const DXVA2_DestData_Mask: DXVA2_DestData = DXVA2_DestData(65535i32);
impl ::core::convert::From<i32> for DXVA2_DestData {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA2_DestData {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA2_DetailFilterTech(pub i32);
pub const DXVA2_DetailFilterTech_Unsupported: DXVA2_DetailFilterTech = DXVA2_DetailFilterTech(0i32);
pub const DXVA2_DetailFilterTech_Unknown: DXVA2_DetailFilterTech = DXVA2_DetailFilterTech(1i32);
pub const DXVA2_DetailFilterTech_Edge: DXVA2_DetailFilterTech = DXVA2_DetailFilterTech(2i32);
pub const DXVA2_DetailFilterTech_Sharpening: DXVA2_DetailFilterTech = DXVA2_DetailFilterTech(4i32);
pub const DXVA2_DetailFilterTech_Mask: DXVA2_DetailFilterTech = DXVA2_DetailFilterTech(7i32);
impl ::core::convert::From<i32> for DXVA2_DetailFilterTech {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA2_DetailFilterTech {
type Abi = Self;
}
pub const DXVA2_E_NEW_VIDEO_DEVICE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147217407i32 as _);
pub const DXVA2_E_NOT_AVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147217405i32 as _);
pub const DXVA2_E_NOT_INITIALIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147217408i32 as _);
pub const DXVA2_E_VIDEO_DEVICE_LOCKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147217406i32 as _);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVA2_ExtendedFormat {
pub Anonymous: DXVA2_ExtendedFormat_0,
}
impl DXVA2_ExtendedFormat {}
impl ::core::default::Default for DXVA2_ExtendedFormat {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for DXVA2_ExtendedFormat {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for DXVA2_ExtendedFormat {}
unsafe impl ::windows::core::Abi for DXVA2_ExtendedFormat {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union DXVA2_ExtendedFormat_0 {
pub Anonymous: DXVA2_ExtendedFormat_0_0,
pub value: u32,
}
impl DXVA2_ExtendedFormat_0 {}
impl ::core::default::Default for DXVA2_ExtendedFormat_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for DXVA2_ExtendedFormat_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for DXVA2_ExtendedFormat_0 {}
unsafe impl ::windows::core::Abi for DXVA2_ExtendedFormat_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVA2_ExtendedFormat_0_0 {
pub _bitfield: u32,
}
impl DXVA2_ExtendedFormat_0_0 {}
impl ::core::default::Default for DXVA2_ExtendedFormat_0_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVA2_ExtendedFormat_0_0 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_Anonymous_e__Struct").field("_bitfield", &self._bitfield).finish()
}
}
impl ::core::cmp::PartialEq for DXVA2_ExtendedFormat_0_0 {
fn eq(&self, other: &Self) -> bool {
self._bitfield == other._bitfield
}
}
impl ::core::cmp::Eq for DXVA2_ExtendedFormat_0_0 {}
unsafe impl ::windows::core::Abi for DXVA2_ExtendedFormat_0_0 {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA2_FilterType(pub i32);
pub const DXVA2_NoiseFilterLumaLevel: DXVA2_FilterType = DXVA2_FilterType(1i32);
pub const DXVA2_NoiseFilterLumaThreshold: DXVA2_FilterType = DXVA2_FilterType(2i32);
pub const DXVA2_NoiseFilterLumaRadius: DXVA2_FilterType = DXVA2_FilterType(3i32);
pub const DXVA2_NoiseFilterChromaLevel: DXVA2_FilterType = DXVA2_FilterType(4i32);
pub const DXVA2_NoiseFilterChromaThreshold: DXVA2_FilterType = DXVA2_FilterType(5i32);
pub const DXVA2_NoiseFilterChromaRadius: DXVA2_FilterType = DXVA2_FilterType(6i32);
pub const DXVA2_DetailFilterLumaLevel: DXVA2_FilterType = DXVA2_FilterType(7i32);
pub const DXVA2_DetailFilterLumaThreshold: DXVA2_FilterType = DXVA2_FilterType(8i32);
pub const DXVA2_DetailFilterLumaRadius: DXVA2_FilterType = DXVA2_FilterType(9i32);
pub const DXVA2_DetailFilterChromaLevel: DXVA2_FilterType = DXVA2_FilterType(10i32);
pub const DXVA2_DetailFilterChromaThreshold: DXVA2_FilterType = DXVA2_FilterType(11i32);
pub const DXVA2_DetailFilterChromaRadius: DXVA2_FilterType = DXVA2_FilterType(12i32);
impl ::core::convert::From<i32> for DXVA2_FilterType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA2_FilterType {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVA2_FilterValues {
pub Level: DXVA2_Fixed32,
pub Threshold: DXVA2_Fixed32,
pub Radius: DXVA2_Fixed32,
}
impl DXVA2_FilterValues {}
impl ::core::default::Default for DXVA2_FilterValues {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for DXVA2_FilterValues {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for DXVA2_FilterValues {}
unsafe impl ::windows::core::Abi for DXVA2_FilterValues {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVA2_Fixed32 {
pub Anonymous: DXVA2_Fixed32_0,
}
impl DXVA2_Fixed32 {}
impl ::core::default::Default for DXVA2_Fixed32 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for DXVA2_Fixed32 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for DXVA2_Fixed32 {}
unsafe impl ::windows::core::Abi for DXVA2_Fixed32 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union DXVA2_Fixed32_0 {
pub Anonymous: DXVA2_Fixed32_0_0,
pub ll: i32,
}
impl DXVA2_Fixed32_0 {}
impl ::core::default::Default for DXVA2_Fixed32_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for DXVA2_Fixed32_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for DXVA2_Fixed32_0 {}
unsafe impl ::windows::core::Abi for DXVA2_Fixed32_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVA2_Fixed32_0_0 {
pub Fraction: u16,
pub Value: i16,
}
impl DXVA2_Fixed32_0_0 {}
impl ::core::default::Default for DXVA2_Fixed32_0_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVA2_Fixed32_0_0 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_Anonymous_e__Struct").field("Fraction", &self.Fraction).field("Value", &self.Value).finish()
}
}
impl ::core::cmp::PartialEq for DXVA2_Fixed32_0_0 {
fn eq(&self, other: &Self) -> bool {
self.Fraction == other.Fraction && self.Value == other.Value
}
}
impl ::core::cmp::Eq for DXVA2_Fixed32_0_0 {}
unsafe impl ::windows::core::Abi for DXVA2_Fixed32_0_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVA2_Frequency {
pub Numerator: u32,
pub Denominator: u32,
}
impl DXVA2_Frequency {}
impl ::core::default::Default for DXVA2_Frequency {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVA2_Frequency {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA2_Frequency").field("Numerator", &self.Numerator).field("Denominator", &self.Denominator).finish()
}
}
impl ::core::cmp::PartialEq for DXVA2_Frequency {
fn eq(&self, other: &Self) -> bool {
self.Numerator == other.Numerator && self.Denominator == other.Denominator
}
}
impl ::core::cmp::Eq for DXVA2_Frequency {}
unsafe impl ::windows::core::Abi for DXVA2_Frequency {
type Abi = Self;
}
pub const DXVA2_ModeH264_A: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1b81be64_a0c7_11d3_b984_00c04f2e73c5);
pub const DXVA2_ModeH264_B: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1b81be65_a0c7_11d3_b984_00c04f2e73c5);
pub const DXVA2_ModeH264_C: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1b81be66_a0c7_11d3_b984_00c04f2e73c5);
pub const DXVA2_ModeH264_D: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1b81be67_a0c7_11d3_b984_00c04f2e73c5);
pub const DXVA2_ModeH264_E: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1b81be68_a0c7_11d3_b984_00c04f2e73c5);
pub const DXVA2_ModeH264_F: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1b81be69_a0c7_11d3_b984_00c04f2e73c5);
pub const DXVA2_ModeH264_VLD_Multiview_NoFGT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x705b9d82_76cf_49d6_b7e6_ac8872db013c);
pub const DXVA2_ModeH264_VLD_Stereo_NoFGT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf9aaccbb_c2b6_4cfc_8779_5707b1760552);
pub const DXVA2_ModeH264_VLD_Stereo_Progressive_NoFGT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd79be8da_0cf1_4c81_b82a_69a4e236f43d);
pub const DXVA2_ModeH264_VLD_WithFMOASO_NoFGT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd5f04ff9_3418_45d8_9561_32a76aae2ddd);
pub const DXVA2_ModeHEVC_VLD_Main: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5b11d51b_2f4c_4452_bcc3_09f2a1160cc0);
pub const DXVA2_ModeHEVC_VLD_Main10: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x107af0e0_ef1a_4d19_aba8_67a163073d13);
pub const DXVA2_ModeMPEG1_VLD: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6f3ec719_3735_42cc_8063_65cc3cb36616);
pub const DXVA2_ModeMPEG2_IDCT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbf22ad00_03ea_4690_8077_473346209b7e);
pub const DXVA2_ModeMPEG2_MoComp: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe6a9f44b_61b0_4563_9ea4_63d2a3c6fe66);
pub const DXVA2_ModeMPEG2_VLD: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xee27417f_5e28_4e65_beea_1d26b508adc9);
pub const DXVA2_ModeMPEG2and1_VLD: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x86695f12_340e_4f04_9fd3_9253dd327460);
pub const DXVA2_ModeMPEG4pt2_VLD_AdvSimple_GMC: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xab998b5b_4258_44a9_9feb_94e597a6baae);
pub const DXVA2_ModeMPEG4pt2_VLD_AdvSimple_NoGMC: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xed418a9f_010d_4eda_9ae3_9a65358d8d2e);
pub const DXVA2_ModeMPEG4pt2_VLD_Simple: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xefd64d74_c9e8_41d7_a5e9_e9b0e39fa319);
pub const DXVA2_ModeVC1_A: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1b81bea0_a0c7_11d3_b984_00c04f2e73c5);
pub const DXVA2_ModeVC1_B: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1b81bea1_a0c7_11d3_b984_00c04f2e73c5);
pub const DXVA2_ModeVC1_C: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1b81bea2_a0c7_11d3_b984_00c04f2e73c5);
pub const DXVA2_ModeVC1_D: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1b81bea3_a0c7_11d3_b984_00c04f2e73c5);
pub const DXVA2_ModeVC1_D2010: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1b81bea4_a0c7_11d3_b984_00c04f2e73c5);
pub const DXVA2_ModeVP8_VLD: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x90b899ea_3a62_4705_88b3_8df04b2744e7);
pub const DXVA2_ModeVP9_VLD_10bit_Profile2: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa4c749ef_6ecf_48aa_8448_50a7a1165ff7);
pub const DXVA2_ModeVP9_VLD_Profile0: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x463707f8_a1d0_4585_876d_83aa6d60b89e);
pub const DXVA2_ModeWMV8_A: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1b81be80_a0c7_11d3_b984_00c04f2e73c5);
pub const DXVA2_ModeWMV8_B: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1b81be81_a0c7_11d3_b984_00c04f2e73c5);
pub const DXVA2_ModeWMV9_A: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1b81be90_a0c7_11d3_b984_00c04f2e73c5);
pub const DXVA2_ModeWMV9_B: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1b81be91_a0c7_11d3_b984_00c04f2e73c5);
pub const DXVA2_ModeWMV9_C: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1b81be94_a0c7_11d3_b984_00c04f2e73c5);
pub const DXVA2_NoEncrypt: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1b81bed0_a0c7_11d3_b984_00c04f2e73c5);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA2_NoiseFilterTech(pub i32);
pub const DXVA2_NoiseFilterTech_Unsupported: DXVA2_NoiseFilterTech = DXVA2_NoiseFilterTech(0i32);
pub const DXVA2_NoiseFilterTech_Unknown: DXVA2_NoiseFilterTech = DXVA2_NoiseFilterTech(1i32);
pub const DXVA2_NoiseFilterTech_Median: DXVA2_NoiseFilterTech = DXVA2_NoiseFilterTech(2i32);
pub const DXVA2_NoiseFilterTech_Temporal: DXVA2_NoiseFilterTech = DXVA2_NoiseFilterTech(4i32);
pub const DXVA2_NoiseFilterTech_BlockNoise: DXVA2_NoiseFilterTech = DXVA2_NoiseFilterTech(8i32);
pub const DXVA2_NoiseFilterTech_MosquitoNoise: DXVA2_NoiseFilterTech = DXVA2_NoiseFilterTech(16i32);
pub const DXVA2_NoiseFilterTech_Mask: DXVA2_NoiseFilterTech = DXVA2_NoiseFilterTech(31i32);
impl ::core::convert::From<i32> for DXVA2_NoiseFilterTech {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA2_NoiseFilterTech {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA2_NominalRange(pub i32);
pub const DXVA2_NominalRangeMask: DXVA2_NominalRange = DXVA2_NominalRange(7i32);
pub const DXVA2_NominalRange_Unknown: DXVA2_NominalRange = DXVA2_NominalRange(0i32);
pub const DXVA2_NominalRange_Normal: DXVA2_NominalRange = DXVA2_NominalRange(1i32);
pub const DXVA2_NominalRange_Wide: DXVA2_NominalRange = DXVA2_NominalRange(2i32);
pub const DXVA2_NominalRange_0_255: DXVA2_NominalRange = DXVA2_NominalRange(1i32);
pub const DXVA2_NominalRange_16_235: DXVA2_NominalRange = DXVA2_NominalRange(2i32);
pub const DXVA2_NominalRange_48_208: DXVA2_NominalRange = DXVA2_NominalRange(3i32);
impl ::core::convert::From<i32> for DXVA2_NominalRange {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA2_NominalRange {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA2_ProcAmp(pub i32);
pub const DXVA2_ProcAmp_None: DXVA2_ProcAmp = DXVA2_ProcAmp(0i32);
pub const DXVA2_ProcAmp_Brightness: DXVA2_ProcAmp = DXVA2_ProcAmp(1i32);
pub const DXVA2_ProcAmp_Contrast: DXVA2_ProcAmp = DXVA2_ProcAmp(2i32);
pub const DXVA2_ProcAmp_Hue: DXVA2_ProcAmp = DXVA2_ProcAmp(4i32);
pub const DXVA2_ProcAmp_Saturation: DXVA2_ProcAmp = DXVA2_ProcAmp(8i32);
pub const DXVA2_ProcAmp_Mask: DXVA2_ProcAmp = DXVA2_ProcAmp(15i32);
impl ::core::convert::From<i32> for DXVA2_ProcAmp {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA2_ProcAmp {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVA2_ProcAmpValues {
pub Brightness: DXVA2_Fixed32,
pub Contrast: DXVA2_Fixed32,
pub Hue: DXVA2_Fixed32,
pub Saturation: DXVA2_Fixed32,
}
impl DXVA2_ProcAmpValues {}
impl ::core::default::Default for DXVA2_ProcAmpValues {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for DXVA2_ProcAmpValues {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for DXVA2_ProcAmpValues {}
unsafe impl ::windows::core::Abi for DXVA2_ProcAmpValues {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA2_SampleData(pub i32);
pub const DXVA2_SampleData_RFF: DXVA2_SampleData = DXVA2_SampleData(1i32);
pub const DXVA2_SampleData_TFF: DXVA2_SampleData = DXVA2_SampleData(2i32);
pub const DXVA2_SampleData_RFF_TFF_Present: DXVA2_SampleData = DXVA2_SampleData(4i32);
pub const DXVA2_SampleData_Mask: DXVA2_SampleData = DXVA2_SampleData(65535i32);
impl ::core::convert::From<i32> for DXVA2_SampleData {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA2_SampleData {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA2_SampleFormat(pub i32);
pub const DXVA2_SampleFormatMask: DXVA2_SampleFormat = DXVA2_SampleFormat(255i32);
pub const DXVA2_SampleUnknown: DXVA2_SampleFormat = DXVA2_SampleFormat(0i32);
pub const DXVA2_SampleProgressiveFrame: DXVA2_SampleFormat = DXVA2_SampleFormat(2i32);
pub const DXVA2_SampleFieldInterleavedEvenFirst: DXVA2_SampleFormat = DXVA2_SampleFormat(3i32);
pub const DXVA2_SampleFieldInterleavedOddFirst: DXVA2_SampleFormat = DXVA2_SampleFormat(4i32);
pub const DXVA2_SampleFieldSingleEven: DXVA2_SampleFormat = DXVA2_SampleFormat(5i32);
pub const DXVA2_SampleFieldSingleOdd: DXVA2_SampleFormat = DXVA2_SampleFormat(6i32);
pub const DXVA2_SampleSubStream: DXVA2_SampleFormat = DXVA2_SampleFormat(7i32);
impl ::core::convert::From<i32> for DXVA2_SampleFormat {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA2_SampleFormat {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA2_SurfaceType(pub i32);
pub const DXVA2_SurfaceType_DecoderRenderTarget: DXVA2_SurfaceType = DXVA2_SurfaceType(0i32);
pub const DXVA2_SurfaceType_ProcessorRenderTarget: DXVA2_SurfaceType = DXVA2_SurfaceType(1i32);
pub const DXVA2_SurfaceType_D3DRenderTargetTexture: DXVA2_SurfaceType = DXVA2_SurfaceType(2i32);
impl ::core::convert::From<i32> for DXVA2_SurfaceType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA2_SurfaceType {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA2_VPDev(pub i32);
pub const DXVA2_VPDev_HardwareDevice: DXVA2_VPDev = DXVA2_VPDev(1i32);
pub const DXVA2_VPDev_EmulatedDXVA1: DXVA2_VPDev = DXVA2_VPDev(2i32);
pub const DXVA2_VPDev_SoftwareDevice: DXVA2_VPDev = DXVA2_VPDev(4i32);
pub const DXVA2_VPDev_Mask: DXVA2_VPDev = DXVA2_VPDev(7i32);
impl ::core::convert::From<i32> for DXVA2_VPDev {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA2_VPDev {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVA2_ValueRange {
pub MinValue: DXVA2_Fixed32,
pub MaxValue: DXVA2_Fixed32,
pub DefaultValue: DXVA2_Fixed32,
pub StepSize: DXVA2_Fixed32,
}
impl DXVA2_ValueRange {}
impl ::core::default::Default for DXVA2_ValueRange {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for DXVA2_ValueRange {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for DXVA2_ValueRange {}
unsafe impl ::windows::core::Abi for DXVA2_ValueRange {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA2_VideoChromaSubSampling(pub i32);
pub const DXVA2_VideoChromaSubsamplingMask: DXVA2_VideoChromaSubSampling = DXVA2_VideoChromaSubSampling(15i32);
pub const DXVA2_VideoChromaSubsampling_Unknown: DXVA2_VideoChromaSubSampling = DXVA2_VideoChromaSubSampling(0i32);
pub const DXVA2_VideoChromaSubsampling_ProgressiveChroma: DXVA2_VideoChromaSubSampling = DXVA2_VideoChromaSubSampling(8i32);
pub const DXVA2_VideoChromaSubsampling_Horizontally_Cosited: DXVA2_VideoChromaSubSampling = DXVA2_VideoChromaSubSampling(4i32);
pub const DXVA2_VideoChromaSubsampling_Vertically_Cosited: DXVA2_VideoChromaSubSampling = DXVA2_VideoChromaSubSampling(2i32);
pub const DXVA2_VideoChromaSubsampling_Vertically_AlignedChromaPlanes: DXVA2_VideoChromaSubSampling = DXVA2_VideoChromaSubSampling(1i32);
pub const DXVA2_VideoChromaSubsampling_MPEG2: DXVA2_VideoChromaSubSampling = DXVA2_VideoChromaSubSampling(5i32);
pub const DXVA2_VideoChromaSubsampling_MPEG1: DXVA2_VideoChromaSubSampling = DXVA2_VideoChromaSubSampling(1i32);
pub const DXVA2_VideoChromaSubsampling_DV_PAL: DXVA2_VideoChromaSubSampling = DXVA2_VideoChromaSubSampling(6i32);
pub const DXVA2_VideoChromaSubsampling_Cosited: DXVA2_VideoChromaSubSampling = DXVA2_VideoChromaSubSampling(7i32);
impl ::core::convert::From<i32> for DXVA2_VideoChromaSubSampling {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA2_VideoChromaSubSampling {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub struct DXVA2_VideoDesc {
pub SampleWidth: u32,
pub SampleHeight: u32,
pub SampleFormat: DXVA2_ExtendedFormat,
pub Format: super::super::Graphics::Direct3D9::D3DFORMAT,
pub InputSampleFreq: DXVA2_Frequency,
pub OutputFrameFreq: DXVA2_Frequency,
pub UABProtectionLevel: u32,
pub Reserved: u32,
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl DXVA2_VideoDesc {}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::default::Default for DXVA2_VideoDesc {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::cmp::PartialEq for DXVA2_VideoDesc {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::cmp::Eq for DXVA2_VideoDesc {}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
unsafe impl ::windows::core::Abi for DXVA2_VideoDesc {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA2_VideoLighting(pub i32);
pub const DXVA2_VideoLightingMask: DXVA2_VideoLighting = DXVA2_VideoLighting(15i32);
pub const DXVA2_VideoLighting_Unknown: DXVA2_VideoLighting = DXVA2_VideoLighting(0i32);
pub const DXVA2_VideoLighting_bright: DXVA2_VideoLighting = DXVA2_VideoLighting(1i32);
pub const DXVA2_VideoLighting_office: DXVA2_VideoLighting = DXVA2_VideoLighting(2i32);
pub const DXVA2_VideoLighting_dim: DXVA2_VideoLighting = DXVA2_VideoLighting(3i32);
pub const DXVA2_VideoLighting_dark: DXVA2_VideoLighting = DXVA2_VideoLighting(4i32);
impl ::core::convert::From<i32> for DXVA2_VideoLighting {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA2_VideoLighting {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA2_VideoPrimaries(pub i32);
pub const DXVA2_VideoPrimariesMask: DXVA2_VideoPrimaries = DXVA2_VideoPrimaries(31i32);
pub const DXVA2_VideoPrimaries_Unknown: DXVA2_VideoPrimaries = DXVA2_VideoPrimaries(0i32);
pub const DXVA2_VideoPrimaries_reserved: DXVA2_VideoPrimaries = DXVA2_VideoPrimaries(1i32);
pub const DXVA2_VideoPrimaries_BT709: DXVA2_VideoPrimaries = DXVA2_VideoPrimaries(2i32);
pub const DXVA2_VideoPrimaries_BT470_2_SysM: DXVA2_VideoPrimaries = DXVA2_VideoPrimaries(3i32);
pub const DXVA2_VideoPrimaries_BT470_2_SysBG: DXVA2_VideoPrimaries = DXVA2_VideoPrimaries(4i32);
pub const DXVA2_VideoPrimaries_SMPTE170M: DXVA2_VideoPrimaries = DXVA2_VideoPrimaries(5i32);
pub const DXVA2_VideoPrimaries_SMPTE240M: DXVA2_VideoPrimaries = DXVA2_VideoPrimaries(6i32);
pub const DXVA2_VideoPrimaries_EBU3213: DXVA2_VideoPrimaries = DXVA2_VideoPrimaries(7i32);
pub const DXVA2_VideoPrimaries_SMPTE_C: DXVA2_VideoPrimaries = DXVA2_VideoPrimaries(8i32);
impl ::core::convert::From<i32> for DXVA2_VideoPrimaries {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA2_VideoPrimaries {
type Abi = Self;
}
pub const DXVA2_VideoProcBobDevice: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x335aa36e_7884_43a4_9c91_7f87faf3e37e);
pub const DXVA2_VideoProcProgressiveDevice: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5a54a0c9_c7ec_4bd9_8ede_f3c75dc4393b);
pub const DXVA2_VideoProcSoftwareDevice: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4553d47f_ee7e_4e3f_9475_dbf1376c4810);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA2_VideoProcess(pub i32);
pub const DXVA2_VideoProcess_None: DXVA2_VideoProcess = DXVA2_VideoProcess(0i32);
pub const DXVA2_VideoProcess_YUV2RGB: DXVA2_VideoProcess = DXVA2_VideoProcess(1i32);
pub const DXVA2_VideoProcess_StretchX: DXVA2_VideoProcess = DXVA2_VideoProcess(2i32);
pub const DXVA2_VideoProcess_StretchY: DXVA2_VideoProcess = DXVA2_VideoProcess(4i32);
pub const DXVA2_VideoProcess_AlphaBlend: DXVA2_VideoProcess = DXVA2_VideoProcess(8i32);
pub const DXVA2_VideoProcess_SubRects: DXVA2_VideoProcess = DXVA2_VideoProcess(16i32);
pub const DXVA2_VideoProcess_SubStreams: DXVA2_VideoProcess = DXVA2_VideoProcess(32i32);
pub const DXVA2_VideoProcess_SubStreamsExtended: DXVA2_VideoProcess = DXVA2_VideoProcess(64i32);
pub const DXVA2_VideoProcess_YUV2RGBExtended: DXVA2_VideoProcess = DXVA2_VideoProcess(128i32);
pub const DXVA2_VideoProcess_AlphaBlendExtended: DXVA2_VideoProcess = DXVA2_VideoProcess(256i32);
pub const DXVA2_VideoProcess_Constriction: DXVA2_VideoProcess = DXVA2_VideoProcess(512i32);
pub const DXVA2_VideoProcess_NoiseFilter: DXVA2_VideoProcess = DXVA2_VideoProcess(1024i32);
pub const DXVA2_VideoProcess_DetailFilter: DXVA2_VideoProcess = DXVA2_VideoProcess(2048i32);
pub const DXVA2_VideoProcess_PlanarAlpha: DXVA2_VideoProcess = DXVA2_VideoProcess(4096i32);
pub const DXVA2_VideoProcess_LinearScaling: DXVA2_VideoProcess = DXVA2_VideoProcess(8192i32);
pub const DXVA2_VideoProcess_GammaCompensated: DXVA2_VideoProcess = DXVA2_VideoProcess(16384i32);
pub const DXVA2_VideoProcess_MaintainsOriginalFieldData: DXVA2_VideoProcess = DXVA2_VideoProcess(32768i32);
pub const DXVA2_VideoProcess_Mask: DXVA2_VideoProcess = DXVA2_VideoProcess(65535i32);
impl ::core::convert::From<i32> for DXVA2_VideoProcess {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA2_VideoProcess {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DXVA2_VideoProcessBltParams {
pub TargetFrame: i64,
pub TargetRect: super::super::Foundation::RECT,
pub ConstrictionSize: super::super::Foundation::SIZE,
pub StreamingFlags: u32,
pub BackgroundColor: DXVA2_AYUVSample16,
pub DestFormat: DXVA2_ExtendedFormat,
pub ProcAmpValues: DXVA2_ProcAmpValues,
pub Alpha: DXVA2_Fixed32,
pub NoiseFilterLuma: DXVA2_FilterValues,
pub NoiseFilterChroma: DXVA2_FilterValues,
pub DetailFilterLuma: DXVA2_FilterValues,
pub DetailFilterChroma: DXVA2_FilterValues,
pub DestData: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl DXVA2_VideoProcessBltParams {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DXVA2_VideoProcessBltParams {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DXVA2_VideoProcessBltParams {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DXVA2_VideoProcessBltParams {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DXVA2_VideoProcessBltParams {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub struct DXVA2_VideoProcessorCaps {
pub DeviceCaps: u32,
pub InputPool: super::super::Graphics::Direct3D9::D3DPOOL,
pub NumForwardRefSamples: u32,
pub NumBackwardRefSamples: u32,
pub Reserved: u32,
pub DeinterlaceTechnology: u32,
pub ProcAmpControlCaps: u32,
pub VideoProcessorOperations: u32,
pub NoiseFilterTechnology: u32,
pub DetailFilterTechnology: u32,
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl DXVA2_VideoProcessorCaps {}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::default::Default for DXVA2_VideoProcessorCaps {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::fmt::Debug for DXVA2_VideoProcessorCaps {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA2_VideoProcessorCaps")
.field("DeviceCaps", &self.DeviceCaps)
.field("InputPool", &self.InputPool)
.field("NumForwardRefSamples", &self.NumForwardRefSamples)
.field("NumBackwardRefSamples", &self.NumBackwardRefSamples)
.field("Reserved", &self.Reserved)
.field("DeinterlaceTechnology", &self.DeinterlaceTechnology)
.field("ProcAmpControlCaps", &self.ProcAmpControlCaps)
.field("VideoProcessorOperations", &self.VideoProcessorOperations)
.field("NoiseFilterTechnology", &self.NoiseFilterTechnology)
.field("DetailFilterTechnology", &self.DetailFilterTechnology)
.finish()
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::cmp::PartialEq for DXVA2_VideoProcessorCaps {
fn eq(&self, other: &Self) -> bool {
self.DeviceCaps == other.DeviceCaps
&& self.InputPool == other.InputPool
&& self.NumForwardRefSamples == other.NumForwardRefSamples
&& self.NumBackwardRefSamples == other.NumBackwardRefSamples
&& self.Reserved == other.Reserved
&& self.DeinterlaceTechnology == other.DeinterlaceTechnology
&& self.ProcAmpControlCaps == other.ProcAmpControlCaps
&& self.VideoProcessorOperations == other.VideoProcessorOperations
&& self.NoiseFilterTechnology == other.NoiseFilterTechnology
&& self.DetailFilterTechnology == other.DetailFilterTechnology
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::cmp::Eq for DXVA2_VideoProcessorCaps {}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
unsafe impl ::windows::core::Abi for DXVA2_VideoProcessorCaps {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA2_VideoRenderTargetType(pub i32);
pub const DXVA2_VideoDecoderRenderTarget: DXVA2_VideoRenderTargetType = DXVA2_VideoRenderTargetType(0i32);
pub const DXVA2_VideoProcessorRenderTarget: DXVA2_VideoRenderTargetType = DXVA2_VideoRenderTargetType(1i32);
pub const DXVA2_VideoSoftwareRenderTarget: DXVA2_VideoRenderTargetType = DXVA2_VideoRenderTargetType(2i32);
impl ::core::convert::From<i32> for DXVA2_VideoRenderTargetType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA2_VideoRenderTargetType {
type Abi = Self;
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
impl ::core::clone::Clone for DXVA2_VideoSample {
fn clone(&self) -> Self {
unimplemented!()
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
pub struct DXVA2_VideoSample {
pub Start: i64,
pub End: i64,
pub SampleFormat: DXVA2_ExtendedFormat,
pub SrcSurface: ::core::option::Option<super::super::Graphics::Direct3D9::IDirect3DSurface9>,
pub SrcRect: super::super::Foundation::RECT,
pub DstRect: super::super::Foundation::RECT,
pub Pal: [DXVA2_AYUVSample8; 16],
pub PlanarAlpha: DXVA2_Fixed32,
pub SampleData: u32,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
impl DXVA2_VideoSample {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
impl ::core::default::Default for DXVA2_VideoSample {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
impl ::core::cmp::PartialEq for DXVA2_VideoSample {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
impl ::core::cmp::Eq for DXVA2_VideoSample {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
unsafe impl ::windows::core::Abi for DXVA2_VideoSample {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA2_VideoTransferFunction(pub i32);
pub const DXVA2_VideoTransFuncMask: DXVA2_VideoTransferFunction = DXVA2_VideoTransferFunction(31i32);
pub const DXVA2_VideoTransFunc_Unknown: DXVA2_VideoTransferFunction = DXVA2_VideoTransferFunction(0i32);
pub const DXVA2_VideoTransFunc_10: DXVA2_VideoTransferFunction = DXVA2_VideoTransferFunction(1i32);
pub const DXVA2_VideoTransFunc_18: DXVA2_VideoTransferFunction = DXVA2_VideoTransferFunction(2i32);
pub const DXVA2_VideoTransFunc_20: DXVA2_VideoTransferFunction = DXVA2_VideoTransferFunction(3i32);
pub const DXVA2_VideoTransFunc_22: DXVA2_VideoTransferFunction = DXVA2_VideoTransferFunction(4i32);
pub const DXVA2_VideoTransFunc_709: DXVA2_VideoTransferFunction = DXVA2_VideoTransferFunction(5i32);
pub const DXVA2_VideoTransFunc_240M: DXVA2_VideoTransferFunction = DXVA2_VideoTransferFunction(6i32);
pub const DXVA2_VideoTransFunc_sRGB: DXVA2_VideoTransferFunction = DXVA2_VideoTransferFunction(7i32);
pub const DXVA2_VideoTransFunc_28: DXVA2_VideoTransferFunction = DXVA2_VideoTransferFunction(8i32);
impl ::core::convert::From<i32> for DXVA2_VideoTransferFunction {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA2_VideoTransferFunction {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA2_VideoTransferMatrix(pub i32);
pub const DXVA2_VideoTransferMatrixMask: DXVA2_VideoTransferMatrix = DXVA2_VideoTransferMatrix(7i32);
pub const DXVA2_VideoTransferMatrix_Unknown: DXVA2_VideoTransferMatrix = DXVA2_VideoTransferMatrix(0i32);
pub const DXVA2_VideoTransferMatrix_BT709: DXVA2_VideoTransferMatrix = DXVA2_VideoTransferMatrix(1i32);
pub const DXVA2_VideoTransferMatrix_BT601: DXVA2_VideoTransferMatrix = DXVA2_VideoTransferMatrix(2i32);
pub const DXVA2_VideoTransferMatrix_SMPTE240M: DXVA2_VideoTransferMatrix = DXVA2_VideoTransferMatrix(3i32);
impl ::core::convert::From<i32> for DXVA2_VideoTransferMatrix {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA2_VideoTransferMatrix {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVABufferInfo {
pub pCompSurface: *mut ::core::ffi::c_void,
pub DataOffset: u32,
pub DataSize: u32,
}
impl DXVABufferInfo {}
impl ::core::default::Default for DXVABufferInfo {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVABufferInfo {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVABufferInfo").field("pCompSurface", &self.pCompSurface).field("DataOffset", &self.DataOffset).field("DataSize", &self.DataSize).finish()
}
}
impl ::core::cmp::PartialEq for DXVABufferInfo {
fn eq(&self, other: &Self) -> bool {
self.pCompSurface == other.pCompSurface && self.DataOffset == other.DataOffset && self.DataSize == other.DataSize
}
}
impl ::core::cmp::Eq for DXVABufferInfo {}
unsafe impl ::windows::core::Abi for DXVABufferInfo {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub struct DXVACompBufferInfo {
pub NumCompBuffers: u32,
pub WidthToCreate: u32,
pub HeightToCreate: u32,
pub BytesToAllocate: u32,
pub Usage: u32,
pub Pool: super::super::Graphics::Direct3D9::D3DPOOL,
pub Format: super::super::Graphics::Direct3D9::D3DFORMAT,
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl DXVACompBufferInfo {}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::default::Default for DXVACompBufferInfo {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::fmt::Debug for DXVACompBufferInfo {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVACompBufferInfo")
.field("NumCompBuffers", &self.NumCompBuffers)
.field("WidthToCreate", &self.WidthToCreate)
.field("HeightToCreate", &self.HeightToCreate)
.field("BytesToAllocate", &self.BytesToAllocate)
.field("Usage", &self.Usage)
.field("Pool", &self.Pool)
.field("Format", &self.Format)
.finish()
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::cmp::PartialEq for DXVACompBufferInfo {
fn eq(&self, other: &Self) -> bool {
self.NumCompBuffers == other.NumCompBuffers && self.WidthToCreate == other.WidthToCreate && self.HeightToCreate == other.HeightToCreate && self.BytesToAllocate == other.BytesToAllocate && self.Usage == other.Usage && self.Pool == other.Pool && self.Format == other.Format
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::cmp::Eq for DXVACompBufferInfo {}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
unsafe impl ::windows::core::Abi for DXVACompBufferInfo {
type Abi = Self;
}
pub const DXVAHDControlGuid: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa0386e75_f70c_464c_a9ce_33c44e091623);
pub const DXVAHDETWGUID_CREATEVIDEOPROCESSOR: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x681e3d1e_5674_4fb3_a503_2f2055e91f60);
pub const DXVAHDETWGUID_DESTROYVIDEOPROCESSOR: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf943f0a0_3f16_43e0_8093_105a986aa5f1);
pub const DXVAHDETWGUID_VIDEOPROCESSBLTHD: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbef3d435_78c7_4de3_9707_cd1b083b160a);
pub const DXVAHDETWGUID_VIDEOPROCESSBLTHD_STREAM: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x27ae473e_a5fc_4be5_b4e3_f24994d3c495);
pub const DXVAHDETWGUID_VIDEOPROCESSBLTSTATE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x76c94b5a_193f_4692_9484_a4d999da81a8);
pub const DXVAHDETWGUID_VIDEOPROCESSSTREAMSTATE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x262c0b02_209d_47ed_94d8_82ae02b84aa7);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVAHDETW_CREATEVIDEOPROCESSOR {
pub pObject: u64,
pub pD3D9Ex: u64,
pub VPGuid: ::windows::core::GUID,
}
impl DXVAHDETW_CREATEVIDEOPROCESSOR {}
impl ::core::default::Default for DXVAHDETW_CREATEVIDEOPROCESSOR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVAHDETW_CREATEVIDEOPROCESSOR {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHDETW_CREATEVIDEOPROCESSOR").field("pObject", &self.pObject).field("pD3D9Ex", &self.pD3D9Ex).field("VPGuid", &self.VPGuid).finish()
}
}
impl ::core::cmp::PartialEq for DXVAHDETW_CREATEVIDEOPROCESSOR {
fn eq(&self, other: &Self) -> bool {
self.pObject == other.pObject && self.pD3D9Ex == other.pD3D9Ex && self.VPGuid == other.VPGuid
}
}
impl ::core::cmp::Eq for DXVAHDETW_CREATEVIDEOPROCESSOR {}
unsafe impl ::windows::core::Abi for DXVAHDETW_CREATEVIDEOPROCESSOR {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVAHDETW_DESTROYVIDEOPROCESSOR {
pub pObject: u64,
}
impl DXVAHDETW_DESTROYVIDEOPROCESSOR {}
impl ::core::default::Default for DXVAHDETW_DESTROYVIDEOPROCESSOR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVAHDETW_DESTROYVIDEOPROCESSOR {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHDETW_DESTROYVIDEOPROCESSOR").field("pObject", &self.pObject).finish()
}
}
impl ::core::cmp::PartialEq for DXVAHDETW_DESTROYVIDEOPROCESSOR {
fn eq(&self, other: &Self) -> bool {
self.pObject == other.pObject
}
}
impl ::core::cmp::Eq for DXVAHDETW_DESTROYVIDEOPROCESSOR {}
unsafe impl ::windows::core::Abi for DXVAHDETW_DESTROYVIDEOPROCESSOR {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
pub struct DXVAHDETW_VIDEOPROCESSBLTHD {
pub pObject: u64,
pub pOutputSurface: u64,
pub TargetRect: super::super::Foundation::RECT,
pub OutputFormat: super::super::Graphics::Direct3D9::D3DFORMAT,
pub ColorSpace: u32,
pub OutputFrame: u32,
pub StreamCount: u32,
pub Enter: super::super::Foundation::BOOL,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
impl DXVAHDETW_VIDEOPROCESSBLTHD {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
impl ::core::default::Default for DXVAHDETW_VIDEOPROCESSBLTHD {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
impl ::core::fmt::Debug for DXVAHDETW_VIDEOPROCESSBLTHD {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHDETW_VIDEOPROCESSBLTHD")
.field("pObject", &self.pObject)
.field("pOutputSurface", &self.pOutputSurface)
.field("TargetRect", &self.TargetRect)
.field("OutputFormat", &self.OutputFormat)
.field("ColorSpace", &self.ColorSpace)
.field("OutputFrame", &self.OutputFrame)
.field("StreamCount", &self.StreamCount)
.field("Enter", &self.Enter)
.finish()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
impl ::core::cmp::PartialEq for DXVAHDETW_VIDEOPROCESSBLTHD {
fn eq(&self, other: &Self) -> bool {
self.pObject == other.pObject && self.pOutputSurface == other.pOutputSurface && self.TargetRect == other.TargetRect && self.OutputFormat == other.OutputFormat && self.ColorSpace == other.ColorSpace && self.OutputFrame == other.OutputFrame && self.StreamCount == other.StreamCount && self.Enter == other.Enter
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
impl ::core::cmp::Eq for DXVAHDETW_VIDEOPROCESSBLTHD {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
unsafe impl ::windows::core::Abi for DXVAHDETW_VIDEOPROCESSBLTHD {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
pub struct DXVAHDETW_VIDEOPROCESSBLTHD_STREAM {
pub pObject: u64,
pub pInputSurface: u64,
pub SourceRect: super::super::Foundation::RECT,
pub DestinationRect: super::super::Foundation::RECT,
pub InputFormat: super::super::Graphics::Direct3D9::D3DFORMAT,
pub FrameFormat: DXVAHD_FRAME_FORMAT,
pub ColorSpace: u32,
pub StreamNumber: u32,
pub OutputIndex: u32,
pub InputFrameOrField: u32,
pub PastFrames: u32,
pub FutureFrames: u32,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
impl DXVAHDETW_VIDEOPROCESSBLTHD_STREAM {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
impl ::core::default::Default for DXVAHDETW_VIDEOPROCESSBLTHD_STREAM {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
impl ::core::fmt::Debug for DXVAHDETW_VIDEOPROCESSBLTHD_STREAM {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHDETW_VIDEOPROCESSBLTHD_STREAM")
.field("pObject", &self.pObject)
.field("pInputSurface", &self.pInputSurface)
.field("SourceRect", &self.SourceRect)
.field("DestinationRect", &self.DestinationRect)
.field("InputFormat", &self.InputFormat)
.field("FrameFormat", &self.FrameFormat)
.field("ColorSpace", &self.ColorSpace)
.field("StreamNumber", &self.StreamNumber)
.field("OutputIndex", &self.OutputIndex)
.field("InputFrameOrField", &self.InputFrameOrField)
.field("PastFrames", &self.PastFrames)
.field("FutureFrames", &self.FutureFrames)
.finish()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
impl ::core::cmp::PartialEq for DXVAHDETW_VIDEOPROCESSBLTHD_STREAM {
fn eq(&self, other: &Self) -> bool {
self.pObject == other.pObject
&& self.pInputSurface == other.pInputSurface
&& self.SourceRect == other.SourceRect
&& self.DestinationRect == other.DestinationRect
&& self.InputFormat == other.InputFormat
&& self.FrameFormat == other.FrameFormat
&& self.ColorSpace == other.ColorSpace
&& self.StreamNumber == other.StreamNumber
&& self.OutputIndex == other.OutputIndex
&& self.InputFrameOrField == other.InputFrameOrField
&& self.PastFrames == other.PastFrames
&& self.FutureFrames == other.FutureFrames
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
impl ::core::cmp::Eq for DXVAHDETW_VIDEOPROCESSBLTHD_STREAM {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
unsafe impl ::windows::core::Abi for DXVAHDETW_VIDEOPROCESSBLTHD_STREAM {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DXVAHDETW_VIDEOPROCESSBLTSTATE {
pub pObject: u64,
pub State: DXVAHD_BLT_STATE,
pub DataSize: u32,
pub SetState: super::super::Foundation::BOOL,
}
#[cfg(feature = "Win32_Foundation")]
impl DXVAHDETW_VIDEOPROCESSBLTSTATE {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DXVAHDETW_VIDEOPROCESSBLTSTATE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DXVAHDETW_VIDEOPROCESSBLTSTATE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHDETW_VIDEOPROCESSBLTSTATE").field("pObject", &self.pObject).field("State", &self.State).field("DataSize", &self.DataSize).field("SetState", &self.SetState).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DXVAHDETW_VIDEOPROCESSBLTSTATE {
fn eq(&self, other: &Self) -> bool {
self.pObject == other.pObject && self.State == other.State && self.DataSize == other.DataSize && self.SetState == other.SetState
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DXVAHDETW_VIDEOPROCESSBLTSTATE {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DXVAHDETW_VIDEOPROCESSBLTSTATE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DXVAHDETW_VIDEOPROCESSSTREAMSTATE {
pub pObject: u64,
pub StreamNumber: u32,
pub State: DXVAHD_STREAM_STATE,
pub DataSize: u32,
pub SetState: super::super::Foundation::BOOL,
}
#[cfg(feature = "Win32_Foundation")]
impl DXVAHDETW_VIDEOPROCESSSTREAMSTATE {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DXVAHDETW_VIDEOPROCESSSTREAMSTATE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DXVAHDETW_VIDEOPROCESSSTREAMSTATE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHDETW_VIDEOPROCESSSTREAMSTATE").field("pObject", &self.pObject).field("StreamNumber", &self.StreamNumber).field("State", &self.State).field("DataSize", &self.DataSize).field("SetState", &self.SetState).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DXVAHDETW_VIDEOPROCESSSTREAMSTATE {
fn eq(&self, other: &Self) -> bool {
self.pObject == other.pObject && self.StreamNumber == other.StreamNumber && self.State == other.State && self.DataSize == other.DataSize && self.SetState == other.SetState
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DXVAHDETW_VIDEOPROCESSSTREAMSTATE {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DXVAHDETW_VIDEOPROCESSSTREAMSTATE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
pub struct DXVAHDSW_CALLBACKS {
pub CreateDevice: ::core::option::Option<PDXVAHDSW_CreateDevice>,
pub ProposeVideoPrivateFormat: ::core::option::Option<PDXVAHDSW_ProposeVideoPrivateFormat>,
pub GetVideoProcessorDeviceCaps: ::core::option::Option<PDXVAHDSW_GetVideoProcessorDeviceCaps>,
pub GetVideoProcessorOutputFormats: ::core::option::Option<PDXVAHDSW_GetVideoProcessorOutputFormats>,
pub GetVideoProcessorInputFormats: ::core::option::Option<PDXVAHDSW_GetVideoProcessorInputFormats>,
pub GetVideoProcessorCaps: ::core::option::Option<PDXVAHDSW_GetVideoProcessorCaps>,
pub GetVideoProcessorCustomRates: ::core::option::Option<PDXVAHDSW_GetVideoProcessorCustomRates>,
pub GetVideoProcessorFilterRange: ::core::option::Option<PDXVAHDSW_GetVideoProcessorFilterRange>,
pub DestroyDevice: ::core::option::Option<PDXVAHDSW_DestroyDevice>,
pub CreateVideoProcessor: ::core::option::Option<PDXVAHDSW_CreateVideoProcessor>,
pub SetVideoProcessBltState: ::core::option::Option<PDXVAHDSW_SetVideoProcessBltState>,
pub GetVideoProcessBltStatePrivate: ::core::option::Option<PDXVAHDSW_GetVideoProcessBltStatePrivate>,
pub SetVideoProcessStreamState: ::core::option::Option<PDXVAHDSW_SetVideoProcessStreamState>,
pub GetVideoProcessStreamStatePrivate: ::core::option::Option<PDXVAHDSW_GetVideoProcessStreamStatePrivate>,
pub VideoProcessBltHD: ::core::option::Option<PDXVAHDSW_VideoProcessBltHD>,
pub DestroyVideoProcessor: ::core::option::Option<PDXVAHDSW_DestroyVideoProcessor>,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
impl DXVAHDSW_CALLBACKS {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
impl ::core::default::Default for DXVAHDSW_CALLBACKS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
impl ::core::fmt::Debug for DXVAHDSW_CALLBACKS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHDSW_CALLBACKS").finish()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
impl ::core::cmp::PartialEq for DXVAHDSW_CALLBACKS {
fn eq(&self, other: &Self) -> bool {
self.CreateDevice.map(|f| f as usize) == other.CreateDevice.map(|f| f as usize)
&& self.ProposeVideoPrivateFormat.map(|f| f as usize) == other.ProposeVideoPrivateFormat.map(|f| f as usize)
&& self.GetVideoProcessorDeviceCaps.map(|f| f as usize) == other.GetVideoProcessorDeviceCaps.map(|f| f as usize)
&& self.GetVideoProcessorOutputFormats.map(|f| f as usize) == other.GetVideoProcessorOutputFormats.map(|f| f as usize)
&& self.GetVideoProcessorInputFormats.map(|f| f as usize) == other.GetVideoProcessorInputFormats.map(|f| f as usize)
&& self.GetVideoProcessorCaps.map(|f| f as usize) == other.GetVideoProcessorCaps.map(|f| f as usize)
&& self.GetVideoProcessorCustomRates.map(|f| f as usize) == other.GetVideoProcessorCustomRates.map(|f| f as usize)
&& self.GetVideoProcessorFilterRange.map(|f| f as usize) == other.GetVideoProcessorFilterRange.map(|f| f as usize)
&& self.DestroyDevice.map(|f| f as usize) == other.DestroyDevice.map(|f| f as usize)
&& self.CreateVideoProcessor.map(|f| f as usize) == other.CreateVideoProcessor.map(|f| f as usize)
&& self.SetVideoProcessBltState.map(|f| f as usize) == other.SetVideoProcessBltState.map(|f| f as usize)
&& self.GetVideoProcessBltStatePrivate.map(|f| f as usize) == other.GetVideoProcessBltStatePrivate.map(|f| f as usize)
&& self.SetVideoProcessStreamState.map(|f| f as usize) == other.SetVideoProcessStreamState.map(|f| f as usize)
&& self.GetVideoProcessStreamStatePrivate.map(|f| f as usize) == other.GetVideoProcessStreamStatePrivate.map(|f| f as usize)
&& self.VideoProcessBltHD.map(|f| f as usize) == other.VideoProcessBltHD.map(|f| f as usize)
&& self.DestroyVideoProcessor.map(|f| f as usize) == other.DestroyVideoProcessor.map(|f| f as usize)
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
impl ::core::cmp::Eq for DXVAHDSW_CALLBACKS {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
unsafe impl ::windows::core::Abi for DXVAHDSW_CALLBACKS {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVAHD_ALPHA_FILL_MODE(pub i32);
pub const DXVAHD_ALPHA_FILL_MODE_OPAQUE: DXVAHD_ALPHA_FILL_MODE = DXVAHD_ALPHA_FILL_MODE(0i32);
pub const DXVAHD_ALPHA_FILL_MODE_BACKGROUND: DXVAHD_ALPHA_FILL_MODE = DXVAHD_ALPHA_FILL_MODE(1i32);
pub const DXVAHD_ALPHA_FILL_MODE_DESTINATION: DXVAHD_ALPHA_FILL_MODE = DXVAHD_ALPHA_FILL_MODE(2i32);
pub const DXVAHD_ALPHA_FILL_MODE_SOURCE_STREAM: DXVAHD_ALPHA_FILL_MODE = DXVAHD_ALPHA_FILL_MODE(3i32);
impl ::core::convert::From<i32> for DXVAHD_ALPHA_FILL_MODE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVAHD_ALPHA_FILL_MODE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVAHD_BLT_STATE(pub i32);
pub const DXVAHD_BLT_STATE_TARGET_RECT: DXVAHD_BLT_STATE = DXVAHD_BLT_STATE(0i32);
pub const DXVAHD_BLT_STATE_BACKGROUND_COLOR: DXVAHD_BLT_STATE = DXVAHD_BLT_STATE(1i32);
pub const DXVAHD_BLT_STATE_OUTPUT_COLOR_SPACE: DXVAHD_BLT_STATE = DXVAHD_BLT_STATE(2i32);
pub const DXVAHD_BLT_STATE_ALPHA_FILL: DXVAHD_BLT_STATE = DXVAHD_BLT_STATE(3i32);
pub const DXVAHD_BLT_STATE_CONSTRICTION: DXVAHD_BLT_STATE = DXVAHD_BLT_STATE(4i32);
pub const DXVAHD_BLT_STATE_PRIVATE: DXVAHD_BLT_STATE = DXVAHD_BLT_STATE(1000i32);
impl ::core::convert::From<i32> for DXVAHD_BLT_STATE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVAHD_BLT_STATE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVAHD_BLT_STATE_ALPHA_FILL_DATA {
pub Mode: DXVAHD_ALPHA_FILL_MODE,
pub StreamNumber: u32,
}
impl DXVAHD_BLT_STATE_ALPHA_FILL_DATA {}
impl ::core::default::Default for DXVAHD_BLT_STATE_ALPHA_FILL_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVAHD_BLT_STATE_ALPHA_FILL_DATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHD_BLT_STATE_ALPHA_FILL_DATA").field("Mode", &self.Mode).field("StreamNumber", &self.StreamNumber).finish()
}
}
impl ::core::cmp::PartialEq for DXVAHD_BLT_STATE_ALPHA_FILL_DATA {
fn eq(&self, other: &Self) -> bool {
self.Mode == other.Mode && self.StreamNumber == other.StreamNumber
}
}
impl ::core::cmp::Eq for DXVAHD_BLT_STATE_ALPHA_FILL_DATA {}
unsafe impl ::windows::core::Abi for DXVAHD_BLT_STATE_ALPHA_FILL_DATA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DXVAHD_BLT_STATE_BACKGROUND_COLOR_DATA {
pub YCbCr: super::super::Foundation::BOOL,
pub BackgroundColor: DXVAHD_COLOR,
}
#[cfg(feature = "Win32_Foundation")]
impl DXVAHD_BLT_STATE_BACKGROUND_COLOR_DATA {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DXVAHD_BLT_STATE_BACKGROUND_COLOR_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DXVAHD_BLT_STATE_BACKGROUND_COLOR_DATA {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DXVAHD_BLT_STATE_BACKGROUND_COLOR_DATA {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DXVAHD_BLT_STATE_BACKGROUND_COLOR_DATA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DXVAHD_BLT_STATE_CONSTRICTION_DATA {
pub Enable: super::super::Foundation::BOOL,
pub Size: super::super::Foundation::SIZE,
}
#[cfg(feature = "Win32_Foundation")]
impl DXVAHD_BLT_STATE_CONSTRICTION_DATA {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DXVAHD_BLT_STATE_CONSTRICTION_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DXVAHD_BLT_STATE_CONSTRICTION_DATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHD_BLT_STATE_CONSTRICTION_DATA").field("Enable", &self.Enable).field("Size", &self.Size).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DXVAHD_BLT_STATE_CONSTRICTION_DATA {
fn eq(&self, other: &Self) -> bool {
self.Enable == other.Enable && self.Size == other.Size
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DXVAHD_BLT_STATE_CONSTRICTION_DATA {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DXVAHD_BLT_STATE_CONSTRICTION_DATA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVAHD_BLT_STATE_OUTPUT_COLOR_SPACE_DATA {
pub Anonymous: DXVAHD_BLT_STATE_OUTPUT_COLOR_SPACE_DATA_0,
}
impl DXVAHD_BLT_STATE_OUTPUT_COLOR_SPACE_DATA {}
impl ::core::default::Default for DXVAHD_BLT_STATE_OUTPUT_COLOR_SPACE_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for DXVAHD_BLT_STATE_OUTPUT_COLOR_SPACE_DATA {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for DXVAHD_BLT_STATE_OUTPUT_COLOR_SPACE_DATA {}
unsafe impl ::windows::core::Abi for DXVAHD_BLT_STATE_OUTPUT_COLOR_SPACE_DATA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union DXVAHD_BLT_STATE_OUTPUT_COLOR_SPACE_DATA_0 {
pub Anonymous: DXVAHD_BLT_STATE_OUTPUT_COLOR_SPACE_DATA_0_0,
pub Value: u32,
}
impl DXVAHD_BLT_STATE_OUTPUT_COLOR_SPACE_DATA_0 {}
impl ::core::default::Default for DXVAHD_BLT_STATE_OUTPUT_COLOR_SPACE_DATA_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for DXVAHD_BLT_STATE_OUTPUT_COLOR_SPACE_DATA_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for DXVAHD_BLT_STATE_OUTPUT_COLOR_SPACE_DATA_0 {}
unsafe impl ::windows::core::Abi for DXVAHD_BLT_STATE_OUTPUT_COLOR_SPACE_DATA_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVAHD_BLT_STATE_OUTPUT_COLOR_SPACE_DATA_0_0 {
pub _bitfield: u32,
}
impl DXVAHD_BLT_STATE_OUTPUT_COLOR_SPACE_DATA_0_0 {}
impl ::core::default::Default for DXVAHD_BLT_STATE_OUTPUT_COLOR_SPACE_DATA_0_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVAHD_BLT_STATE_OUTPUT_COLOR_SPACE_DATA_0_0 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_Anonymous_e__Struct").field("_bitfield", &self._bitfield).finish()
}
}
impl ::core::cmp::PartialEq for DXVAHD_BLT_STATE_OUTPUT_COLOR_SPACE_DATA_0_0 {
fn eq(&self, other: &Self) -> bool {
self._bitfield == other._bitfield
}
}
impl ::core::cmp::Eq for DXVAHD_BLT_STATE_OUTPUT_COLOR_SPACE_DATA_0_0 {}
unsafe impl ::windows::core::Abi for DXVAHD_BLT_STATE_OUTPUT_COLOR_SPACE_DATA_0_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVAHD_BLT_STATE_PRIVATE_DATA {
pub Guid: ::windows::core::GUID,
pub DataSize: u32,
pub pData: *mut ::core::ffi::c_void,
}
impl DXVAHD_BLT_STATE_PRIVATE_DATA {}
impl ::core::default::Default for DXVAHD_BLT_STATE_PRIVATE_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVAHD_BLT_STATE_PRIVATE_DATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHD_BLT_STATE_PRIVATE_DATA").field("Guid", &self.Guid).field("DataSize", &self.DataSize).field("pData", &self.pData).finish()
}
}
impl ::core::cmp::PartialEq for DXVAHD_BLT_STATE_PRIVATE_DATA {
fn eq(&self, other: &Self) -> bool {
self.Guid == other.Guid && self.DataSize == other.DataSize && self.pData == other.pData
}
}
impl ::core::cmp::Eq for DXVAHD_BLT_STATE_PRIVATE_DATA {}
unsafe impl ::windows::core::Abi for DXVAHD_BLT_STATE_PRIVATE_DATA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DXVAHD_BLT_STATE_TARGET_RECT_DATA {
pub Enable: super::super::Foundation::BOOL,
pub TargetRect: super::super::Foundation::RECT,
}
#[cfg(feature = "Win32_Foundation")]
impl DXVAHD_BLT_STATE_TARGET_RECT_DATA {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DXVAHD_BLT_STATE_TARGET_RECT_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DXVAHD_BLT_STATE_TARGET_RECT_DATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHD_BLT_STATE_TARGET_RECT_DATA").field("Enable", &self.Enable).field("TargetRect", &self.TargetRect).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DXVAHD_BLT_STATE_TARGET_RECT_DATA {
fn eq(&self, other: &Self) -> bool {
self.Enable == other.Enable && self.TargetRect == other.TargetRect
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DXVAHD_BLT_STATE_TARGET_RECT_DATA {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DXVAHD_BLT_STATE_TARGET_RECT_DATA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union DXVAHD_COLOR {
pub RGB: DXVAHD_COLOR_RGBA,
pub YCbCr: DXVAHD_COLOR_YCbCrA,
}
impl DXVAHD_COLOR {}
impl ::core::default::Default for DXVAHD_COLOR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for DXVAHD_COLOR {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for DXVAHD_COLOR {}
unsafe impl ::windows::core::Abi for DXVAHD_COLOR {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVAHD_COLOR_RGBA {
pub R: f32,
pub G: f32,
pub B: f32,
pub A: f32,
}
impl DXVAHD_COLOR_RGBA {}
impl ::core::default::Default for DXVAHD_COLOR_RGBA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVAHD_COLOR_RGBA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHD_COLOR_RGBA").field("R", &self.R).field("G", &self.G).field("B", &self.B).field("A", &self.A).finish()
}
}
impl ::core::cmp::PartialEq for DXVAHD_COLOR_RGBA {
fn eq(&self, other: &Self) -> bool {
self.R == other.R && self.G == other.G && self.B == other.B && self.A == other.A
}
}
impl ::core::cmp::Eq for DXVAHD_COLOR_RGBA {}
unsafe impl ::windows::core::Abi for DXVAHD_COLOR_RGBA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVAHD_COLOR_YCbCrA {
pub Y: f32,
pub Cb: f32,
pub Cr: f32,
pub A: f32,
}
impl DXVAHD_COLOR_YCbCrA {}
impl ::core::default::Default for DXVAHD_COLOR_YCbCrA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVAHD_COLOR_YCbCrA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHD_COLOR_YCbCrA").field("Y", &self.Y).field("Cb", &self.Cb).field("Cr", &self.Cr).field("A", &self.A).finish()
}
}
impl ::core::cmp::PartialEq for DXVAHD_COLOR_YCbCrA {
fn eq(&self, other: &Self) -> bool {
self.Y == other.Y && self.Cb == other.Cb && self.Cr == other.Cr && self.A == other.A
}
}
impl ::core::cmp::Eq for DXVAHD_COLOR_YCbCrA {}
unsafe impl ::windows::core::Abi for DXVAHD_COLOR_YCbCrA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVAHD_CONTENT_DESC {
pub InputFrameFormat: DXVAHD_FRAME_FORMAT,
pub InputFrameRate: DXVAHD_RATIONAL,
pub InputWidth: u32,
pub InputHeight: u32,
pub OutputFrameRate: DXVAHD_RATIONAL,
pub OutputWidth: u32,
pub OutputHeight: u32,
}
impl DXVAHD_CONTENT_DESC {}
impl ::core::default::Default for DXVAHD_CONTENT_DESC {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVAHD_CONTENT_DESC {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHD_CONTENT_DESC")
.field("InputFrameFormat", &self.InputFrameFormat)
.field("InputFrameRate", &self.InputFrameRate)
.field("InputWidth", &self.InputWidth)
.field("InputHeight", &self.InputHeight)
.field("OutputFrameRate", &self.OutputFrameRate)
.field("OutputWidth", &self.OutputWidth)
.field("OutputHeight", &self.OutputHeight)
.finish()
}
}
impl ::core::cmp::PartialEq for DXVAHD_CONTENT_DESC {
fn eq(&self, other: &Self) -> bool {
self.InputFrameFormat == other.InputFrameFormat && self.InputFrameRate == other.InputFrameRate && self.InputWidth == other.InputWidth && self.InputHeight == other.InputHeight && self.OutputFrameRate == other.OutputFrameRate && self.OutputWidth == other.OutputWidth && self.OutputHeight == other.OutputHeight
}
}
impl ::core::cmp::Eq for DXVAHD_CONTENT_DESC {}
unsafe impl ::windows::core::Abi for DXVAHD_CONTENT_DESC {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DXVAHD_CUSTOM_RATE_DATA {
pub CustomRate: DXVAHD_RATIONAL,
pub OutputFrames: u32,
pub InputInterlaced: super::super::Foundation::BOOL,
pub InputFramesOrFields: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl DXVAHD_CUSTOM_RATE_DATA {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DXVAHD_CUSTOM_RATE_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DXVAHD_CUSTOM_RATE_DATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHD_CUSTOM_RATE_DATA").field("CustomRate", &self.CustomRate).field("OutputFrames", &self.OutputFrames).field("InputInterlaced", &self.InputInterlaced).field("InputFramesOrFields", &self.InputFramesOrFields).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DXVAHD_CUSTOM_RATE_DATA {
fn eq(&self, other: &Self) -> bool {
self.CustomRate == other.CustomRate && self.OutputFrames == other.OutputFrames && self.InputInterlaced == other.InputInterlaced && self.InputFramesOrFields == other.InputFramesOrFields
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DXVAHD_CUSTOM_RATE_DATA {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DXVAHD_CUSTOM_RATE_DATA {
type Abi = Self;
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
#[inline]
pub unsafe fn DXVAHD_CreateDevice<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D9::IDirect3DDevice9Ex>>(pd3ddevice: Param0, pcontentdesc: *const DXVAHD_CONTENT_DESC, usage: DXVAHD_DEVICE_USAGE, pplugin: ::core::option::Option<PDXVAHDSW_Plugin>) -> ::windows::core::Result<IDXVAHD_Device> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DXVAHD_CreateDevice(pd3ddevice: ::windows::core::RawPtr, pcontentdesc: *const DXVAHD_CONTENT_DESC, usage: DXVAHD_DEVICE_USAGE, pplugin: ::windows::core::RawPtr, ppdevice: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IDXVAHD_Device as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
DXVAHD_CreateDevice(pd3ddevice.into_param().abi(), ::core::mem::transmute(pcontentdesc), ::core::mem::transmute(usage), ::core::mem::transmute(pplugin), &mut result__).from_abi::<IDXVAHD_Device>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVAHD_DEVICE_CAPS(pub i32);
pub const DXVAHD_DEVICE_CAPS_LINEAR_SPACE: DXVAHD_DEVICE_CAPS = DXVAHD_DEVICE_CAPS(1i32);
pub const DXVAHD_DEVICE_CAPS_xvYCC: DXVAHD_DEVICE_CAPS = DXVAHD_DEVICE_CAPS(2i32);
pub const DXVAHD_DEVICE_CAPS_RGB_RANGE_CONVERSION: DXVAHD_DEVICE_CAPS = DXVAHD_DEVICE_CAPS(4i32);
pub const DXVAHD_DEVICE_CAPS_YCbCr_MATRIX_CONVERSION: DXVAHD_DEVICE_CAPS = DXVAHD_DEVICE_CAPS(8i32);
impl ::core::convert::From<i32> for DXVAHD_DEVICE_CAPS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVAHD_DEVICE_CAPS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVAHD_DEVICE_TYPE(pub i32);
pub const DXVAHD_DEVICE_TYPE_HARDWARE: DXVAHD_DEVICE_TYPE = DXVAHD_DEVICE_TYPE(0i32);
pub const DXVAHD_DEVICE_TYPE_SOFTWARE: DXVAHD_DEVICE_TYPE = DXVAHD_DEVICE_TYPE(1i32);
pub const DXVAHD_DEVICE_TYPE_REFERENCE: DXVAHD_DEVICE_TYPE = DXVAHD_DEVICE_TYPE(2i32);
pub const DXVAHD_DEVICE_TYPE_OTHER: DXVAHD_DEVICE_TYPE = DXVAHD_DEVICE_TYPE(3i32);
impl ::core::convert::From<i32> for DXVAHD_DEVICE_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVAHD_DEVICE_TYPE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVAHD_DEVICE_USAGE(pub i32);
pub const DXVAHD_DEVICE_USAGE_PLAYBACK_NORMAL: DXVAHD_DEVICE_USAGE = DXVAHD_DEVICE_USAGE(0i32);
pub const DXVAHD_DEVICE_USAGE_OPTIMAL_SPEED: DXVAHD_DEVICE_USAGE = DXVAHD_DEVICE_USAGE(1i32);
pub const DXVAHD_DEVICE_USAGE_OPTIMAL_QUALITY: DXVAHD_DEVICE_USAGE = DXVAHD_DEVICE_USAGE(2i32);
impl ::core::convert::From<i32> for DXVAHD_DEVICE_USAGE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVAHD_DEVICE_USAGE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVAHD_FEATURE_CAPS(pub i32);
pub const DXVAHD_FEATURE_CAPS_ALPHA_FILL: DXVAHD_FEATURE_CAPS = DXVAHD_FEATURE_CAPS(1i32);
pub const DXVAHD_FEATURE_CAPS_CONSTRICTION: DXVAHD_FEATURE_CAPS = DXVAHD_FEATURE_CAPS(2i32);
pub const DXVAHD_FEATURE_CAPS_LUMA_KEY: DXVAHD_FEATURE_CAPS = DXVAHD_FEATURE_CAPS(4i32);
pub const DXVAHD_FEATURE_CAPS_ALPHA_PALETTE: DXVAHD_FEATURE_CAPS = DXVAHD_FEATURE_CAPS(8i32);
impl ::core::convert::From<i32> for DXVAHD_FEATURE_CAPS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVAHD_FEATURE_CAPS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVAHD_FILTER(pub i32);
pub const DXVAHD_FILTER_BRIGHTNESS: DXVAHD_FILTER = DXVAHD_FILTER(0i32);
pub const DXVAHD_FILTER_CONTRAST: DXVAHD_FILTER = DXVAHD_FILTER(1i32);
pub const DXVAHD_FILTER_HUE: DXVAHD_FILTER = DXVAHD_FILTER(2i32);
pub const DXVAHD_FILTER_SATURATION: DXVAHD_FILTER = DXVAHD_FILTER(3i32);
pub const DXVAHD_FILTER_NOISE_REDUCTION: DXVAHD_FILTER = DXVAHD_FILTER(4i32);
pub const DXVAHD_FILTER_EDGE_ENHANCEMENT: DXVAHD_FILTER = DXVAHD_FILTER(5i32);
pub const DXVAHD_FILTER_ANAMORPHIC_SCALING: DXVAHD_FILTER = DXVAHD_FILTER(6i32);
impl ::core::convert::From<i32> for DXVAHD_FILTER {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVAHD_FILTER {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVAHD_FILTER_CAPS(pub i32);
pub const DXVAHD_FILTER_CAPS_BRIGHTNESS: DXVAHD_FILTER_CAPS = DXVAHD_FILTER_CAPS(1i32);
pub const DXVAHD_FILTER_CAPS_CONTRAST: DXVAHD_FILTER_CAPS = DXVAHD_FILTER_CAPS(2i32);
pub const DXVAHD_FILTER_CAPS_HUE: DXVAHD_FILTER_CAPS = DXVAHD_FILTER_CAPS(4i32);
pub const DXVAHD_FILTER_CAPS_SATURATION: DXVAHD_FILTER_CAPS = DXVAHD_FILTER_CAPS(8i32);
pub const DXVAHD_FILTER_CAPS_NOISE_REDUCTION: DXVAHD_FILTER_CAPS = DXVAHD_FILTER_CAPS(16i32);
pub const DXVAHD_FILTER_CAPS_EDGE_ENHANCEMENT: DXVAHD_FILTER_CAPS = DXVAHD_FILTER_CAPS(32i32);
pub const DXVAHD_FILTER_CAPS_ANAMORPHIC_SCALING: DXVAHD_FILTER_CAPS = DXVAHD_FILTER_CAPS(64i32);
impl ::core::convert::From<i32> for DXVAHD_FILTER_CAPS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVAHD_FILTER_CAPS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVAHD_FILTER_RANGE_DATA {
pub Minimum: i32,
pub Maximum: i32,
pub Default: i32,
pub Multiplier: f32,
}
impl DXVAHD_FILTER_RANGE_DATA {}
impl ::core::default::Default for DXVAHD_FILTER_RANGE_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVAHD_FILTER_RANGE_DATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHD_FILTER_RANGE_DATA").field("Minimum", &self.Minimum).field("Maximum", &self.Maximum).field("Default", &self.Default).field("Multiplier", &self.Multiplier).finish()
}
}
impl ::core::cmp::PartialEq for DXVAHD_FILTER_RANGE_DATA {
fn eq(&self, other: &Self) -> bool {
self.Minimum == other.Minimum && self.Maximum == other.Maximum && self.Default == other.Default && self.Multiplier == other.Multiplier
}
}
impl ::core::cmp::Eq for DXVAHD_FILTER_RANGE_DATA {}
unsafe impl ::windows::core::Abi for DXVAHD_FILTER_RANGE_DATA {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVAHD_FRAME_FORMAT(pub i32);
pub const DXVAHD_FRAME_FORMAT_PROGRESSIVE: DXVAHD_FRAME_FORMAT = DXVAHD_FRAME_FORMAT(0i32);
pub const DXVAHD_FRAME_FORMAT_INTERLACED_TOP_FIELD_FIRST: DXVAHD_FRAME_FORMAT = DXVAHD_FRAME_FORMAT(1i32);
pub const DXVAHD_FRAME_FORMAT_INTERLACED_BOTTOM_FIELD_FIRST: DXVAHD_FRAME_FORMAT = DXVAHD_FRAME_FORMAT(2i32);
impl ::core::convert::From<i32> for DXVAHD_FRAME_FORMAT {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVAHD_FRAME_FORMAT {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVAHD_INPUT_FORMAT_CAPS(pub i32);
pub const DXVAHD_INPUT_FORMAT_CAPS_RGB_INTERLACED: DXVAHD_INPUT_FORMAT_CAPS = DXVAHD_INPUT_FORMAT_CAPS(1i32);
pub const DXVAHD_INPUT_FORMAT_CAPS_RGB_PROCAMP: DXVAHD_INPUT_FORMAT_CAPS = DXVAHD_INPUT_FORMAT_CAPS(2i32);
pub const DXVAHD_INPUT_FORMAT_CAPS_RGB_LUMA_KEY: DXVAHD_INPUT_FORMAT_CAPS = DXVAHD_INPUT_FORMAT_CAPS(4i32);
pub const DXVAHD_INPUT_FORMAT_CAPS_PALETTE_INTERLACED: DXVAHD_INPUT_FORMAT_CAPS = DXVAHD_INPUT_FORMAT_CAPS(8i32);
impl ::core::convert::From<i32> for DXVAHD_INPUT_FORMAT_CAPS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVAHD_INPUT_FORMAT_CAPS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVAHD_ITELECINE_CAPS(pub i32);
pub const DXVAHD_ITELECINE_CAPS_32: DXVAHD_ITELECINE_CAPS = DXVAHD_ITELECINE_CAPS(1i32);
pub const DXVAHD_ITELECINE_CAPS_22: DXVAHD_ITELECINE_CAPS = DXVAHD_ITELECINE_CAPS(2i32);
pub const DXVAHD_ITELECINE_CAPS_2224: DXVAHD_ITELECINE_CAPS = DXVAHD_ITELECINE_CAPS(4i32);
pub const DXVAHD_ITELECINE_CAPS_2332: DXVAHD_ITELECINE_CAPS = DXVAHD_ITELECINE_CAPS(8i32);
pub const DXVAHD_ITELECINE_CAPS_32322: DXVAHD_ITELECINE_CAPS = DXVAHD_ITELECINE_CAPS(16i32);
pub const DXVAHD_ITELECINE_CAPS_55: DXVAHD_ITELECINE_CAPS = DXVAHD_ITELECINE_CAPS(32i32);
pub const DXVAHD_ITELECINE_CAPS_64: DXVAHD_ITELECINE_CAPS = DXVAHD_ITELECINE_CAPS(64i32);
pub const DXVAHD_ITELECINE_CAPS_87: DXVAHD_ITELECINE_CAPS = DXVAHD_ITELECINE_CAPS(128i32);
pub const DXVAHD_ITELECINE_CAPS_222222222223: DXVAHD_ITELECINE_CAPS = DXVAHD_ITELECINE_CAPS(256i32);
pub const DXVAHD_ITELECINE_CAPS_OTHER: DXVAHD_ITELECINE_CAPS = DXVAHD_ITELECINE_CAPS(-2147483648i32);
impl ::core::convert::From<i32> for DXVAHD_ITELECINE_CAPS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVAHD_ITELECINE_CAPS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVAHD_OUTPUT_RATE(pub i32);
pub const DXVAHD_OUTPUT_RATE_NORMAL: DXVAHD_OUTPUT_RATE = DXVAHD_OUTPUT_RATE(0i32);
pub const DXVAHD_OUTPUT_RATE_HALF: DXVAHD_OUTPUT_RATE = DXVAHD_OUTPUT_RATE(1i32);
pub const DXVAHD_OUTPUT_RATE_CUSTOM: DXVAHD_OUTPUT_RATE = DXVAHD_OUTPUT_RATE(2i32);
impl ::core::convert::From<i32> for DXVAHD_OUTPUT_RATE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVAHD_OUTPUT_RATE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVAHD_PROCESSOR_CAPS(pub i32);
pub const DXVAHD_PROCESSOR_CAPS_DEINTERLACE_BLEND: DXVAHD_PROCESSOR_CAPS = DXVAHD_PROCESSOR_CAPS(1i32);
pub const DXVAHD_PROCESSOR_CAPS_DEINTERLACE_BOB: DXVAHD_PROCESSOR_CAPS = DXVAHD_PROCESSOR_CAPS(2i32);
pub const DXVAHD_PROCESSOR_CAPS_DEINTERLACE_ADAPTIVE: DXVAHD_PROCESSOR_CAPS = DXVAHD_PROCESSOR_CAPS(4i32);
pub const DXVAHD_PROCESSOR_CAPS_DEINTERLACE_MOTION_COMPENSATION: DXVAHD_PROCESSOR_CAPS = DXVAHD_PROCESSOR_CAPS(8i32);
pub const DXVAHD_PROCESSOR_CAPS_INVERSE_TELECINE: DXVAHD_PROCESSOR_CAPS = DXVAHD_PROCESSOR_CAPS(16i32);
pub const DXVAHD_PROCESSOR_CAPS_FRAME_RATE_CONVERSION: DXVAHD_PROCESSOR_CAPS = DXVAHD_PROCESSOR_CAPS(32i32);
impl ::core::convert::From<i32> for DXVAHD_PROCESSOR_CAPS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVAHD_PROCESSOR_CAPS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVAHD_RATIONAL {
pub Numerator: u32,
pub Denominator: u32,
}
impl DXVAHD_RATIONAL {}
impl ::core::default::Default for DXVAHD_RATIONAL {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVAHD_RATIONAL {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHD_RATIONAL").field("Numerator", &self.Numerator).field("Denominator", &self.Denominator).finish()
}
}
impl ::core::cmp::PartialEq for DXVAHD_RATIONAL {
fn eq(&self, other: &Self) -> bool {
self.Numerator == other.Numerator && self.Denominator == other.Denominator
}
}
impl ::core::cmp::Eq for DXVAHD_RATIONAL {}
unsafe impl ::windows::core::Abi for DXVAHD_RATIONAL {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
pub struct DXVAHD_STREAM_DATA {
pub Enable: super::super::Foundation::BOOL,
pub OutputIndex: u32,
pub InputFrameOrField: u32,
pub PastFrames: u32,
pub FutureFrames: u32,
pub ppPastSurfaces: *mut ::core::option::Option<super::super::Graphics::Direct3D9::IDirect3DSurface9>,
pub pInputSurface: ::core::option::Option<super::super::Graphics::Direct3D9::IDirect3DSurface9>,
pub ppFutureSurfaces: *mut ::core::option::Option<super::super::Graphics::Direct3D9::IDirect3DSurface9>,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
impl DXVAHD_STREAM_DATA {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
impl ::core::default::Default for DXVAHD_STREAM_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
impl ::core::fmt::Debug for DXVAHD_STREAM_DATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHD_STREAM_DATA")
.field("Enable", &self.Enable)
.field("OutputIndex", &self.OutputIndex)
.field("InputFrameOrField", &self.InputFrameOrField)
.field("PastFrames", &self.PastFrames)
.field("FutureFrames", &self.FutureFrames)
.field("ppPastSurfaces", &self.ppPastSurfaces)
.field("pInputSurface", &self.pInputSurface)
.field("ppFutureSurfaces", &self.ppFutureSurfaces)
.finish()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
impl ::core::cmp::PartialEq for DXVAHD_STREAM_DATA {
fn eq(&self, other: &Self) -> bool {
self.Enable == other.Enable && self.OutputIndex == other.OutputIndex && self.InputFrameOrField == other.InputFrameOrField && self.PastFrames == other.PastFrames && self.FutureFrames == other.FutureFrames && self.ppPastSurfaces == other.ppPastSurfaces && self.pInputSurface == other.pInputSurface && self.ppFutureSurfaces == other.ppFutureSurfaces
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
impl ::core::cmp::Eq for DXVAHD_STREAM_DATA {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
unsafe impl ::windows::core::Abi for DXVAHD_STREAM_DATA {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVAHD_STREAM_STATE(pub i32);
pub const DXVAHD_STREAM_STATE_D3DFORMAT: DXVAHD_STREAM_STATE = DXVAHD_STREAM_STATE(0i32);
pub const DXVAHD_STREAM_STATE_FRAME_FORMAT: DXVAHD_STREAM_STATE = DXVAHD_STREAM_STATE(1i32);
pub const DXVAHD_STREAM_STATE_INPUT_COLOR_SPACE: DXVAHD_STREAM_STATE = DXVAHD_STREAM_STATE(2i32);
pub const DXVAHD_STREAM_STATE_OUTPUT_RATE: DXVAHD_STREAM_STATE = DXVAHD_STREAM_STATE(3i32);
pub const DXVAHD_STREAM_STATE_SOURCE_RECT: DXVAHD_STREAM_STATE = DXVAHD_STREAM_STATE(4i32);
pub const DXVAHD_STREAM_STATE_DESTINATION_RECT: DXVAHD_STREAM_STATE = DXVAHD_STREAM_STATE(5i32);
pub const DXVAHD_STREAM_STATE_ALPHA: DXVAHD_STREAM_STATE = DXVAHD_STREAM_STATE(6i32);
pub const DXVAHD_STREAM_STATE_PALETTE: DXVAHD_STREAM_STATE = DXVAHD_STREAM_STATE(7i32);
pub const DXVAHD_STREAM_STATE_LUMA_KEY: DXVAHD_STREAM_STATE = DXVAHD_STREAM_STATE(8i32);
pub const DXVAHD_STREAM_STATE_ASPECT_RATIO: DXVAHD_STREAM_STATE = DXVAHD_STREAM_STATE(9i32);
pub const DXVAHD_STREAM_STATE_FILTER_BRIGHTNESS: DXVAHD_STREAM_STATE = DXVAHD_STREAM_STATE(100i32);
pub const DXVAHD_STREAM_STATE_FILTER_CONTRAST: DXVAHD_STREAM_STATE = DXVAHD_STREAM_STATE(101i32);
pub const DXVAHD_STREAM_STATE_FILTER_HUE: DXVAHD_STREAM_STATE = DXVAHD_STREAM_STATE(102i32);
pub const DXVAHD_STREAM_STATE_FILTER_SATURATION: DXVAHD_STREAM_STATE = DXVAHD_STREAM_STATE(103i32);
pub const DXVAHD_STREAM_STATE_FILTER_NOISE_REDUCTION: DXVAHD_STREAM_STATE = DXVAHD_STREAM_STATE(104i32);
pub const DXVAHD_STREAM_STATE_FILTER_EDGE_ENHANCEMENT: DXVAHD_STREAM_STATE = DXVAHD_STREAM_STATE(105i32);
pub const DXVAHD_STREAM_STATE_FILTER_ANAMORPHIC_SCALING: DXVAHD_STREAM_STATE = DXVAHD_STREAM_STATE(106i32);
pub const DXVAHD_STREAM_STATE_PRIVATE: DXVAHD_STREAM_STATE = DXVAHD_STREAM_STATE(1000i32);
impl ::core::convert::From<i32> for DXVAHD_STREAM_STATE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVAHD_STREAM_STATE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DXVAHD_STREAM_STATE_ALPHA_DATA {
pub Enable: super::super::Foundation::BOOL,
pub Alpha: f32,
}
#[cfg(feature = "Win32_Foundation")]
impl DXVAHD_STREAM_STATE_ALPHA_DATA {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DXVAHD_STREAM_STATE_ALPHA_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DXVAHD_STREAM_STATE_ALPHA_DATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHD_STREAM_STATE_ALPHA_DATA").field("Enable", &self.Enable).field("Alpha", &self.Alpha).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DXVAHD_STREAM_STATE_ALPHA_DATA {
fn eq(&self, other: &Self) -> bool {
self.Enable == other.Enable && self.Alpha == other.Alpha
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DXVAHD_STREAM_STATE_ALPHA_DATA {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DXVAHD_STREAM_STATE_ALPHA_DATA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DXVAHD_STREAM_STATE_ASPECT_RATIO_DATA {
pub Enable: super::super::Foundation::BOOL,
pub SourceAspectRatio: DXVAHD_RATIONAL,
pub DestinationAspectRatio: DXVAHD_RATIONAL,
}
#[cfg(feature = "Win32_Foundation")]
impl DXVAHD_STREAM_STATE_ASPECT_RATIO_DATA {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DXVAHD_STREAM_STATE_ASPECT_RATIO_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DXVAHD_STREAM_STATE_ASPECT_RATIO_DATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHD_STREAM_STATE_ASPECT_RATIO_DATA").field("Enable", &self.Enable).field("SourceAspectRatio", &self.SourceAspectRatio).field("DestinationAspectRatio", &self.DestinationAspectRatio).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DXVAHD_STREAM_STATE_ASPECT_RATIO_DATA {
fn eq(&self, other: &Self) -> bool {
self.Enable == other.Enable && self.SourceAspectRatio == other.SourceAspectRatio && self.DestinationAspectRatio == other.DestinationAspectRatio
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DXVAHD_STREAM_STATE_ASPECT_RATIO_DATA {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DXVAHD_STREAM_STATE_ASPECT_RATIO_DATA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub struct DXVAHD_STREAM_STATE_D3DFORMAT_DATA {
pub Format: super::super::Graphics::Direct3D9::D3DFORMAT,
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl DXVAHD_STREAM_STATE_D3DFORMAT_DATA {}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::default::Default for DXVAHD_STREAM_STATE_D3DFORMAT_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::fmt::Debug for DXVAHD_STREAM_STATE_D3DFORMAT_DATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHD_STREAM_STATE_D3DFORMAT_DATA").field("Format", &self.Format).finish()
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::cmp::PartialEq for DXVAHD_STREAM_STATE_D3DFORMAT_DATA {
fn eq(&self, other: &Self) -> bool {
self.Format == other.Format
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::cmp::Eq for DXVAHD_STREAM_STATE_D3DFORMAT_DATA {}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
unsafe impl ::windows::core::Abi for DXVAHD_STREAM_STATE_D3DFORMAT_DATA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DXVAHD_STREAM_STATE_DESTINATION_RECT_DATA {
pub Enable: super::super::Foundation::BOOL,
pub DestinationRect: super::super::Foundation::RECT,
}
#[cfg(feature = "Win32_Foundation")]
impl DXVAHD_STREAM_STATE_DESTINATION_RECT_DATA {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DXVAHD_STREAM_STATE_DESTINATION_RECT_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DXVAHD_STREAM_STATE_DESTINATION_RECT_DATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHD_STREAM_STATE_DESTINATION_RECT_DATA").field("Enable", &self.Enable).field("DestinationRect", &self.DestinationRect).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DXVAHD_STREAM_STATE_DESTINATION_RECT_DATA {
fn eq(&self, other: &Self) -> bool {
self.Enable == other.Enable && self.DestinationRect == other.DestinationRect
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DXVAHD_STREAM_STATE_DESTINATION_RECT_DATA {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DXVAHD_STREAM_STATE_DESTINATION_RECT_DATA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DXVAHD_STREAM_STATE_FILTER_DATA {
pub Enable: super::super::Foundation::BOOL,
pub Level: i32,
}
#[cfg(feature = "Win32_Foundation")]
impl DXVAHD_STREAM_STATE_FILTER_DATA {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DXVAHD_STREAM_STATE_FILTER_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DXVAHD_STREAM_STATE_FILTER_DATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHD_STREAM_STATE_FILTER_DATA").field("Enable", &self.Enable).field("Level", &self.Level).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DXVAHD_STREAM_STATE_FILTER_DATA {
fn eq(&self, other: &Self) -> bool {
self.Enable == other.Enable && self.Level == other.Level
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DXVAHD_STREAM_STATE_FILTER_DATA {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DXVAHD_STREAM_STATE_FILTER_DATA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVAHD_STREAM_STATE_FRAME_FORMAT_DATA {
pub FrameFormat: DXVAHD_FRAME_FORMAT,
}
impl DXVAHD_STREAM_STATE_FRAME_FORMAT_DATA {}
impl ::core::default::Default for DXVAHD_STREAM_STATE_FRAME_FORMAT_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVAHD_STREAM_STATE_FRAME_FORMAT_DATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHD_STREAM_STATE_FRAME_FORMAT_DATA").field("FrameFormat", &self.FrameFormat).finish()
}
}
impl ::core::cmp::PartialEq for DXVAHD_STREAM_STATE_FRAME_FORMAT_DATA {
fn eq(&self, other: &Self) -> bool {
self.FrameFormat == other.FrameFormat
}
}
impl ::core::cmp::Eq for DXVAHD_STREAM_STATE_FRAME_FORMAT_DATA {}
unsafe impl ::windows::core::Abi for DXVAHD_STREAM_STATE_FRAME_FORMAT_DATA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVAHD_STREAM_STATE_INPUT_COLOR_SPACE_DATA {
pub Anonymous: DXVAHD_STREAM_STATE_INPUT_COLOR_SPACE_DATA_0,
}
impl DXVAHD_STREAM_STATE_INPUT_COLOR_SPACE_DATA {}
impl ::core::default::Default for DXVAHD_STREAM_STATE_INPUT_COLOR_SPACE_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for DXVAHD_STREAM_STATE_INPUT_COLOR_SPACE_DATA {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for DXVAHD_STREAM_STATE_INPUT_COLOR_SPACE_DATA {}
unsafe impl ::windows::core::Abi for DXVAHD_STREAM_STATE_INPUT_COLOR_SPACE_DATA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union DXVAHD_STREAM_STATE_INPUT_COLOR_SPACE_DATA_0 {
pub Anonymous: DXVAHD_STREAM_STATE_INPUT_COLOR_SPACE_DATA_0_0,
pub Value: u32,
}
impl DXVAHD_STREAM_STATE_INPUT_COLOR_SPACE_DATA_0 {}
impl ::core::default::Default for DXVAHD_STREAM_STATE_INPUT_COLOR_SPACE_DATA_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for DXVAHD_STREAM_STATE_INPUT_COLOR_SPACE_DATA_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for DXVAHD_STREAM_STATE_INPUT_COLOR_SPACE_DATA_0 {}
unsafe impl ::windows::core::Abi for DXVAHD_STREAM_STATE_INPUT_COLOR_SPACE_DATA_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVAHD_STREAM_STATE_INPUT_COLOR_SPACE_DATA_0_0 {
pub _bitfield: u32,
}
impl DXVAHD_STREAM_STATE_INPUT_COLOR_SPACE_DATA_0_0 {}
impl ::core::default::Default for DXVAHD_STREAM_STATE_INPUT_COLOR_SPACE_DATA_0_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVAHD_STREAM_STATE_INPUT_COLOR_SPACE_DATA_0_0 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_Anonymous_e__Struct").field("_bitfield", &self._bitfield).finish()
}
}
impl ::core::cmp::PartialEq for DXVAHD_STREAM_STATE_INPUT_COLOR_SPACE_DATA_0_0 {
fn eq(&self, other: &Self) -> bool {
self._bitfield == other._bitfield
}
}
impl ::core::cmp::Eq for DXVAHD_STREAM_STATE_INPUT_COLOR_SPACE_DATA_0_0 {}
unsafe impl ::windows::core::Abi for DXVAHD_STREAM_STATE_INPUT_COLOR_SPACE_DATA_0_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DXVAHD_STREAM_STATE_LUMA_KEY_DATA {
pub Enable: super::super::Foundation::BOOL,
pub Lower: f32,
pub Upper: f32,
}
#[cfg(feature = "Win32_Foundation")]
impl DXVAHD_STREAM_STATE_LUMA_KEY_DATA {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DXVAHD_STREAM_STATE_LUMA_KEY_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DXVAHD_STREAM_STATE_LUMA_KEY_DATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHD_STREAM_STATE_LUMA_KEY_DATA").field("Enable", &self.Enable).field("Lower", &self.Lower).field("Upper", &self.Upper).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DXVAHD_STREAM_STATE_LUMA_KEY_DATA {
fn eq(&self, other: &Self) -> bool {
self.Enable == other.Enable && self.Lower == other.Lower && self.Upper == other.Upper
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DXVAHD_STREAM_STATE_LUMA_KEY_DATA {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DXVAHD_STREAM_STATE_LUMA_KEY_DATA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DXVAHD_STREAM_STATE_OUTPUT_RATE_DATA {
pub RepeatFrame: super::super::Foundation::BOOL,
pub OutputRate: DXVAHD_OUTPUT_RATE,
pub CustomRate: DXVAHD_RATIONAL,
}
#[cfg(feature = "Win32_Foundation")]
impl DXVAHD_STREAM_STATE_OUTPUT_RATE_DATA {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DXVAHD_STREAM_STATE_OUTPUT_RATE_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DXVAHD_STREAM_STATE_OUTPUT_RATE_DATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHD_STREAM_STATE_OUTPUT_RATE_DATA").field("RepeatFrame", &self.RepeatFrame).field("OutputRate", &self.OutputRate).field("CustomRate", &self.CustomRate).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DXVAHD_STREAM_STATE_OUTPUT_RATE_DATA {
fn eq(&self, other: &Self) -> bool {
self.RepeatFrame == other.RepeatFrame && self.OutputRate == other.OutputRate && self.CustomRate == other.CustomRate
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DXVAHD_STREAM_STATE_OUTPUT_RATE_DATA {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DXVAHD_STREAM_STATE_OUTPUT_RATE_DATA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVAHD_STREAM_STATE_PALETTE_DATA {
pub Count: u32,
pub pEntries: *mut u32,
}
impl DXVAHD_STREAM_STATE_PALETTE_DATA {}
impl ::core::default::Default for DXVAHD_STREAM_STATE_PALETTE_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVAHD_STREAM_STATE_PALETTE_DATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHD_STREAM_STATE_PALETTE_DATA").field("Count", &self.Count).field("pEntries", &self.pEntries).finish()
}
}
impl ::core::cmp::PartialEq for DXVAHD_STREAM_STATE_PALETTE_DATA {
fn eq(&self, other: &Self) -> bool {
self.Count == other.Count && self.pEntries == other.pEntries
}
}
impl ::core::cmp::Eq for DXVAHD_STREAM_STATE_PALETTE_DATA {}
unsafe impl ::windows::core::Abi for DXVAHD_STREAM_STATE_PALETTE_DATA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVAHD_STREAM_STATE_PRIVATE_DATA {
pub Guid: ::windows::core::GUID,
pub DataSize: u32,
pub pData: *mut ::core::ffi::c_void,
}
impl DXVAHD_STREAM_STATE_PRIVATE_DATA {}
impl ::core::default::Default for DXVAHD_STREAM_STATE_PRIVATE_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVAHD_STREAM_STATE_PRIVATE_DATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHD_STREAM_STATE_PRIVATE_DATA").field("Guid", &self.Guid).field("DataSize", &self.DataSize).field("pData", &self.pData).finish()
}
}
impl ::core::cmp::PartialEq for DXVAHD_STREAM_STATE_PRIVATE_DATA {
fn eq(&self, other: &Self) -> bool {
self.Guid == other.Guid && self.DataSize == other.DataSize && self.pData == other.pData
}
}
impl ::core::cmp::Eq for DXVAHD_STREAM_STATE_PRIVATE_DATA {}
unsafe impl ::windows::core::Abi for DXVAHD_STREAM_STATE_PRIVATE_DATA {
type Abi = Self;
}
pub const DXVAHD_STREAM_STATE_PRIVATE_IVTC: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9c601e3c_0f33_414c_a739_99540ee42da5);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DXVAHD_STREAM_STATE_PRIVATE_IVTC_DATA {
pub Enable: super::super::Foundation::BOOL,
pub ITelecineFlags: u32,
pub Frames: u32,
pub InputField: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl DXVAHD_STREAM_STATE_PRIVATE_IVTC_DATA {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DXVAHD_STREAM_STATE_PRIVATE_IVTC_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DXVAHD_STREAM_STATE_PRIVATE_IVTC_DATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHD_STREAM_STATE_PRIVATE_IVTC_DATA").field("Enable", &self.Enable).field("ITelecineFlags", &self.ITelecineFlags).field("Frames", &self.Frames).field("InputField", &self.InputField).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DXVAHD_STREAM_STATE_PRIVATE_IVTC_DATA {
fn eq(&self, other: &Self) -> bool {
self.Enable == other.Enable && self.ITelecineFlags == other.ITelecineFlags && self.Frames == other.Frames && self.InputField == other.InputField
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DXVAHD_STREAM_STATE_PRIVATE_IVTC_DATA {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DXVAHD_STREAM_STATE_PRIVATE_IVTC_DATA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DXVAHD_STREAM_STATE_SOURCE_RECT_DATA {
pub Enable: super::super::Foundation::BOOL,
pub SourceRect: super::super::Foundation::RECT,
}
#[cfg(feature = "Win32_Foundation")]
impl DXVAHD_STREAM_STATE_SOURCE_RECT_DATA {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DXVAHD_STREAM_STATE_SOURCE_RECT_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DXVAHD_STREAM_STATE_SOURCE_RECT_DATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHD_STREAM_STATE_SOURCE_RECT_DATA").field("Enable", &self.Enable).field("SourceRect", &self.SourceRect).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DXVAHD_STREAM_STATE_SOURCE_RECT_DATA {
fn eq(&self, other: &Self) -> bool {
self.Enable == other.Enable && self.SourceRect == other.SourceRect
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DXVAHD_STREAM_STATE_SOURCE_RECT_DATA {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DXVAHD_STREAM_STATE_SOURCE_RECT_DATA {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVAHD_SURFACE_TYPE(pub i32);
pub const DXVAHD_SURFACE_TYPE_VIDEO_INPUT: DXVAHD_SURFACE_TYPE = DXVAHD_SURFACE_TYPE(0i32);
pub const DXVAHD_SURFACE_TYPE_VIDEO_INPUT_PRIVATE: DXVAHD_SURFACE_TYPE = DXVAHD_SURFACE_TYPE(1i32);
pub const DXVAHD_SURFACE_TYPE_VIDEO_OUTPUT: DXVAHD_SURFACE_TYPE = DXVAHD_SURFACE_TYPE(2i32);
impl ::core::convert::From<i32> for DXVAHD_SURFACE_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVAHD_SURFACE_TYPE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVAHD_VPCAPS {
pub VPGuid: ::windows::core::GUID,
pub PastFrames: u32,
pub FutureFrames: u32,
pub ProcessorCaps: u32,
pub ITelecineCaps: u32,
pub CustomRateCount: u32,
}
impl DXVAHD_VPCAPS {}
impl ::core::default::Default for DXVAHD_VPCAPS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVAHD_VPCAPS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHD_VPCAPS").field("VPGuid", &self.VPGuid).field("PastFrames", &self.PastFrames).field("FutureFrames", &self.FutureFrames).field("ProcessorCaps", &self.ProcessorCaps).field("ITelecineCaps", &self.ITelecineCaps).field("CustomRateCount", &self.CustomRateCount).finish()
}
}
impl ::core::cmp::PartialEq for DXVAHD_VPCAPS {
fn eq(&self, other: &Self) -> bool {
self.VPGuid == other.VPGuid && self.PastFrames == other.PastFrames && self.FutureFrames == other.FutureFrames && self.ProcessorCaps == other.ProcessorCaps && self.ITelecineCaps == other.ITelecineCaps && self.CustomRateCount == other.CustomRateCount
}
}
impl ::core::cmp::Eq for DXVAHD_VPCAPS {}
unsafe impl ::windows::core::Abi for DXVAHD_VPCAPS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub struct DXVAHD_VPDEVCAPS {
pub DeviceType: DXVAHD_DEVICE_TYPE,
pub DeviceCaps: u32,
pub FeatureCaps: u32,
pub FilterCaps: u32,
pub InputFormatCaps: u32,
pub InputPool: super::super::Graphics::Direct3D9::D3DPOOL,
pub OutputFormatCount: u32,
pub InputFormatCount: u32,
pub VideoProcessorCount: u32,
pub MaxInputStreams: u32,
pub MaxStreamStates: u32,
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl DXVAHD_VPDEVCAPS {}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::default::Default for DXVAHD_VPDEVCAPS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::fmt::Debug for DXVAHD_VPDEVCAPS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAHD_VPDEVCAPS")
.field("DeviceType", &self.DeviceType)
.field("DeviceCaps", &self.DeviceCaps)
.field("FeatureCaps", &self.FeatureCaps)
.field("FilterCaps", &self.FilterCaps)
.field("InputFormatCaps", &self.InputFormatCaps)
.field("InputPool", &self.InputPool)
.field("OutputFormatCount", &self.OutputFormatCount)
.field("InputFormatCount", &self.InputFormatCount)
.field("VideoProcessorCount", &self.VideoProcessorCount)
.field("MaxInputStreams", &self.MaxInputStreams)
.field("MaxStreamStates", &self.MaxStreamStates)
.finish()
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::cmp::PartialEq for DXVAHD_VPDEVCAPS {
fn eq(&self, other: &Self) -> bool {
self.DeviceType == other.DeviceType
&& self.DeviceCaps == other.DeviceCaps
&& self.FeatureCaps == other.FeatureCaps
&& self.FilterCaps == other.FilterCaps
&& self.InputFormatCaps == other.InputFormatCaps
&& self.InputPool == other.InputPool
&& self.OutputFormatCount == other.OutputFormatCount
&& self.InputFormatCount == other.InputFormatCount
&& self.VideoProcessorCount == other.VideoProcessorCount
&& self.MaxInputStreams == other.MaxInputStreams
&& self.MaxStreamStates == other.MaxStreamStates
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::cmp::Eq for DXVAHD_VPDEVCAPS {}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
unsafe impl ::windows::core::Abi for DXVAHD_VPDEVCAPS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub struct DXVAUncompDataInfo {
pub UncompWidth: u32,
pub UncompHeight: u32,
pub UncompFormat: super::super::Graphics::Direct3D9::D3DFORMAT,
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl DXVAUncompDataInfo {}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::default::Default for DXVAUncompDataInfo {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::fmt::Debug for DXVAUncompDataInfo {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVAUncompDataInfo").field("UncompWidth", &self.UncompWidth).field("UncompHeight", &self.UncompHeight).field("UncompFormat", &self.UncompFormat).finish()
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::cmp::PartialEq for DXVAUncompDataInfo {
fn eq(&self, other: &Self) -> bool {
self.UncompWidth == other.UncompWidth && self.UncompHeight == other.UncompHeight && self.UncompFormat == other.UncompFormat
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::cmp::Eq for DXVAUncompDataInfo {}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
unsafe impl ::windows::core::Abi for DXVAUncompDataInfo {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVA_AYUVsample2 {
pub bCrValue: u8,
pub bCbValue: u8,
pub bY_Value: u8,
pub bSampleAlpha8: u8,
}
impl DXVA_AYUVsample2 {}
impl ::core::default::Default for DXVA_AYUVsample2 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVA_AYUVsample2 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA_AYUVsample2").field("bCrValue", &self.bCrValue).field("bCbValue", &self.bCbValue).field("bY_Value", &self.bY_Value).field("bSampleAlpha8", &self.bSampleAlpha8).finish()
}
}
impl ::core::cmp::PartialEq for DXVA_AYUVsample2 {
fn eq(&self, other: &Self) -> bool {
self.bCrValue == other.bCrValue && self.bCbValue == other.bCbValue && self.bY_Value == other.bY_Value && self.bSampleAlpha8 == other.bSampleAlpha8
}
}
impl ::core::cmp::Eq for DXVA_AYUVsample2 {}
unsafe impl ::windows::core::Abi for DXVA_AYUVsample2 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct DXVA_BufferDescription {
pub dwTypeIndex: u32,
pub dwBufferIndex: u32,
pub dwDataOffset: u32,
pub dwDataSize: u32,
pub dwFirstMBaddress: u32,
pub dwNumMBsInBuffer: u32,
pub dwWidth: u32,
pub dwHeight: u32,
pub dwStride: u32,
pub dwReservedBits: u32,
}
impl DXVA_BufferDescription {}
impl ::core::default::Default for DXVA_BufferDescription {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for DXVA_BufferDescription {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for DXVA_BufferDescription {}
unsafe impl ::windows::core::Abi for DXVA_BufferDescription {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVA_COPPCommand {
pub macKDI: ::windows::core::GUID,
pub guidCommandID: ::windows::core::GUID,
pub dwSequence: u32,
pub cbSizeData: u32,
pub CommandData: [u8; 4056],
}
impl DXVA_COPPCommand {}
impl ::core::default::Default for DXVA_COPPCommand {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVA_COPPCommand {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA_COPPCommand").field("macKDI", &self.macKDI).field("guidCommandID", &self.guidCommandID).field("dwSequence", &self.dwSequence).field("cbSizeData", &self.cbSizeData).field("CommandData", &self.CommandData).finish()
}
}
impl ::core::cmp::PartialEq for DXVA_COPPCommand {
fn eq(&self, other: &Self) -> bool {
self.macKDI == other.macKDI && self.guidCommandID == other.guidCommandID && self.dwSequence == other.dwSequence && self.cbSizeData == other.cbSizeData && self.CommandData == other.CommandData
}
}
impl ::core::cmp::Eq for DXVA_COPPCommand {}
unsafe impl ::windows::core::Abi for DXVA_COPPCommand {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVA_COPPSignature {
pub Signature: [u8; 256],
}
impl DXVA_COPPSignature {}
impl ::core::default::Default for DXVA_COPPSignature {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVA_COPPSignature {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA_COPPSignature").field("Signature", &self.Signature).finish()
}
}
impl ::core::cmp::PartialEq for DXVA_COPPSignature {
fn eq(&self, other: &Self) -> bool {
self.Signature == other.Signature
}
}
impl ::core::cmp::Eq for DXVA_COPPSignature {}
unsafe impl ::windows::core::Abi for DXVA_COPPSignature {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVA_COPPStatusInput {
pub rApp: ::windows::core::GUID,
pub guidStatusRequestID: ::windows::core::GUID,
pub dwSequence: u32,
pub cbSizeData: u32,
pub StatusData: [u8; 4056],
}
impl DXVA_COPPStatusInput {}
impl ::core::default::Default for DXVA_COPPStatusInput {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVA_COPPStatusInput {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA_COPPStatusInput").field("rApp", &self.rApp).field("guidStatusRequestID", &self.guidStatusRequestID).field("dwSequence", &self.dwSequence).field("cbSizeData", &self.cbSizeData).field("StatusData", &self.StatusData).finish()
}
}
impl ::core::cmp::PartialEq for DXVA_COPPStatusInput {
fn eq(&self, other: &Self) -> bool {
self.rApp == other.rApp && self.guidStatusRequestID == other.guidStatusRequestID && self.dwSequence == other.dwSequence && self.cbSizeData == other.cbSizeData && self.StatusData == other.StatusData
}
}
impl ::core::cmp::Eq for DXVA_COPPStatusInput {}
unsafe impl ::windows::core::Abi for DXVA_COPPStatusInput {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVA_COPPStatusOutput {
pub macKDI: ::windows::core::GUID,
pub cbSizeData: u32,
pub COPPStatus: [u8; 4076],
}
impl DXVA_COPPStatusOutput {}
impl ::core::default::Default for DXVA_COPPStatusOutput {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVA_COPPStatusOutput {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA_COPPStatusOutput").field("macKDI", &self.macKDI).field("cbSizeData", &self.cbSizeData).field("COPPStatus", &self.COPPStatus).finish()
}
}
impl ::core::cmp::PartialEq for DXVA_COPPStatusOutput {
fn eq(&self, other: &Self) -> bool {
self.macKDI == other.macKDI && self.cbSizeData == other.cbSizeData && self.COPPStatus == other.COPPStatus
}
}
impl ::core::cmp::Eq for DXVA_COPPStatusOutput {}
unsafe impl ::windows::core::Abi for DXVA_COPPStatusOutput {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct DXVA_ConfigPictureDecode {
pub dwFunction: u32,
pub dwReservedBits: [u32; 3],
pub guidConfigBitstreamEncryption: ::windows::core::GUID,
pub guidConfigMBcontrolEncryption: ::windows::core::GUID,
pub guidConfigResidDiffEncryption: ::windows::core::GUID,
pub bConfigBitstreamRaw: u8,
pub bConfigMBcontrolRasterOrder: u8,
pub bConfigResidDiffHost: u8,
pub bConfigSpatialResid8: u8,
pub bConfigResid8Subtraction: u8,
pub bConfigSpatialHost8or9Clipping: u8,
pub bConfigSpatialResidInterleaved: u8,
pub bConfigIntraResidUnsigned: u8,
pub bConfigResidDiffAccelerator: u8,
pub bConfigHostInverseScan: u8,
pub bConfigSpecificIDCT: u8,
pub bConfig4GroupedCoefs: u8,
}
impl DXVA_ConfigPictureDecode {}
impl ::core::default::Default for DXVA_ConfigPictureDecode {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for DXVA_ConfigPictureDecode {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for DXVA_ConfigPictureDecode {}
unsafe impl ::windows::core::Abi for DXVA_ConfigPictureDecode {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DXVA_DeinterlaceBlt {
pub Size: u32,
pub Reserved: u32,
pub rtTarget: i64,
pub DstRect: super::super::Foundation::RECT,
pub SrcRect: super::super::Foundation::RECT,
pub NumSourceSurfaces: u32,
pub Alpha: f32,
pub Source: [DXVA_VideoSample; 32],
}
#[cfg(feature = "Win32_Foundation")]
impl DXVA_DeinterlaceBlt {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DXVA_DeinterlaceBlt {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DXVA_DeinterlaceBlt {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA_DeinterlaceBlt")
.field("Size", &self.Size)
.field("Reserved", &self.Reserved)
.field("rtTarget", &self.rtTarget)
.field("DstRect", &self.DstRect)
.field("SrcRect", &self.SrcRect)
.field("NumSourceSurfaces", &self.NumSourceSurfaces)
.field("Alpha", &self.Alpha)
.field("Source", &self.Source)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DXVA_DeinterlaceBlt {
fn eq(&self, other: &Self) -> bool {
self.Size == other.Size && self.Reserved == other.Reserved && self.rtTarget == other.rtTarget && self.DstRect == other.DstRect && self.SrcRect == other.SrcRect && self.NumSourceSurfaces == other.NumSourceSurfaces && self.Alpha == other.Alpha && self.Source == other.Source
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DXVA_DeinterlaceBlt {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DXVA_DeinterlaceBlt {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DXVA_DeinterlaceBltEx {
pub Size: u32,
pub BackgroundColor: DXVA_AYUVsample2,
pub rcTarget: super::super::Foundation::RECT,
pub rtTarget: i64,
pub NumSourceSurfaces: u32,
pub Alpha: f32,
pub Source: [DXVA_VideoSample2; 32],
pub DestinationFormat: u32,
pub DestinationFlags: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl DXVA_DeinterlaceBltEx {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DXVA_DeinterlaceBltEx {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DXVA_DeinterlaceBltEx {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA_DeinterlaceBltEx")
.field("Size", &self.Size)
.field("BackgroundColor", &self.BackgroundColor)
.field("rcTarget", &self.rcTarget)
.field("rtTarget", &self.rtTarget)
.field("NumSourceSurfaces", &self.NumSourceSurfaces)
.field("Alpha", &self.Alpha)
.field("Source", &self.Source)
.field("DestinationFormat", &self.DestinationFormat)
.field("DestinationFlags", &self.DestinationFlags)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DXVA_DeinterlaceBltEx {
fn eq(&self, other: &Self) -> bool {
self.Size == other.Size && self.BackgroundColor == other.BackgroundColor && self.rcTarget == other.rcTarget && self.rtTarget == other.rtTarget && self.NumSourceSurfaces == other.NumSourceSurfaces && self.Alpha == other.Alpha && self.Source == other.Source && self.DestinationFormat == other.DestinationFormat && self.DestinationFlags == other.DestinationFlags
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DXVA_DeinterlaceBltEx {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DXVA_DeinterlaceBltEx {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(feature = "Win32_Foundation")]
pub struct DXVA_DeinterlaceBltEx32 {
pub Size: u32,
pub BackgroundColor: DXVA_AYUVsample2,
pub rcTarget: super::super::Foundation::RECT,
pub rtTarget: i64,
pub NumSourceSurfaces: u32,
pub Alpha: f32,
pub Source: [DXVA_VideoSample32; 32],
pub DestinationFormat: u32,
pub DestinationFlags: u32,
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(feature = "Win32_Foundation")]
impl DXVA_DeinterlaceBltEx32 {}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DXVA_DeinterlaceBltEx32 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DXVA_DeinterlaceBltEx32 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA_DeinterlaceBltEx32")
.field("Size", &self.Size)
.field("BackgroundColor", &self.BackgroundColor)
.field("rcTarget", &self.rcTarget)
.field("rtTarget", &self.rtTarget)
.field("NumSourceSurfaces", &self.NumSourceSurfaces)
.field("Alpha", &self.Alpha)
.field("Source", &self.Source)
.field("DestinationFormat", &self.DestinationFormat)
.field("DestinationFlags", &self.DestinationFlags)
.finish()
}
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DXVA_DeinterlaceBltEx32 {
fn eq(&self, other: &Self) -> bool {
self.Size == other.Size && self.BackgroundColor == other.BackgroundColor && self.rcTarget == other.rcTarget && self.rtTarget == other.rtTarget && self.NumSourceSurfaces == other.NumSourceSurfaces && self.Alpha == other.Alpha && self.Source == other.Source && self.DestinationFormat == other.DestinationFormat && self.DestinationFlags == other.DestinationFlags
}
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DXVA_DeinterlaceBltEx32 {}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DXVA_DeinterlaceBltEx32 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub struct DXVA_DeinterlaceCaps {
pub Size: u32,
pub NumPreviousOutputFrames: u32,
pub InputPool: u32,
pub NumForwardRefSamples: u32,
pub NumBackwardRefSamples: u32,
pub d3dOutputFormat: super::super::Graphics::Direct3D9::D3DFORMAT,
pub VideoProcessingCaps: DXVA_VideoProcessCaps,
pub DeinterlaceTechnology: DXVA_DeinterlaceTech,
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl DXVA_DeinterlaceCaps {}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::default::Default for DXVA_DeinterlaceCaps {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::fmt::Debug for DXVA_DeinterlaceCaps {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA_DeinterlaceCaps")
.field("Size", &self.Size)
.field("NumPreviousOutputFrames", &self.NumPreviousOutputFrames)
.field("InputPool", &self.InputPool)
.field("NumForwardRefSamples", &self.NumForwardRefSamples)
.field("NumBackwardRefSamples", &self.NumBackwardRefSamples)
.field("d3dOutputFormat", &self.d3dOutputFormat)
.field("VideoProcessingCaps", &self.VideoProcessingCaps)
.field("DeinterlaceTechnology", &self.DeinterlaceTechnology)
.finish()
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::cmp::PartialEq for DXVA_DeinterlaceCaps {
fn eq(&self, other: &Self) -> bool {
self.Size == other.Size && self.NumPreviousOutputFrames == other.NumPreviousOutputFrames && self.InputPool == other.InputPool && self.NumForwardRefSamples == other.NumForwardRefSamples && self.NumBackwardRefSamples == other.NumBackwardRefSamples && self.d3dOutputFormat == other.d3dOutputFormat && self.VideoProcessingCaps == other.VideoProcessingCaps && self.DeinterlaceTechnology == other.DeinterlaceTechnology
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::cmp::Eq for DXVA_DeinterlaceCaps {}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
unsafe impl ::windows::core::Abi for DXVA_DeinterlaceCaps {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVA_DeinterlaceQueryAvailableModes {
pub Size: u32,
pub NumGuids: u32,
pub Guids: [::windows::core::GUID; 32],
}
impl DXVA_DeinterlaceQueryAvailableModes {}
impl ::core::default::Default for DXVA_DeinterlaceQueryAvailableModes {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVA_DeinterlaceQueryAvailableModes {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA_DeinterlaceQueryAvailableModes").field("Size", &self.Size).field("NumGuids", &self.NumGuids).field("Guids", &self.Guids).finish()
}
}
impl ::core::cmp::PartialEq for DXVA_DeinterlaceQueryAvailableModes {
fn eq(&self, other: &Self) -> bool {
self.Size == other.Size && self.NumGuids == other.NumGuids && self.Guids == other.Guids
}
}
impl ::core::cmp::Eq for DXVA_DeinterlaceQueryAvailableModes {}
unsafe impl ::windows::core::Abi for DXVA_DeinterlaceQueryAvailableModes {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub struct DXVA_DeinterlaceQueryModeCaps {
pub Size: u32,
pub Guid: ::windows::core::GUID,
pub VideoDesc: DXVA_VideoDesc,
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl DXVA_DeinterlaceQueryModeCaps {}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::default::Default for DXVA_DeinterlaceQueryModeCaps {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::fmt::Debug for DXVA_DeinterlaceQueryModeCaps {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA_DeinterlaceQueryModeCaps").field("Size", &self.Size).field("Guid", &self.Guid).field("VideoDesc", &self.VideoDesc).finish()
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::cmp::PartialEq for DXVA_DeinterlaceQueryModeCaps {
fn eq(&self, other: &Self) -> bool {
self.Size == other.Size && self.Guid == other.Guid && self.VideoDesc == other.VideoDesc
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::cmp::Eq for DXVA_DeinterlaceQueryModeCaps {}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
unsafe impl ::windows::core::Abi for DXVA_DeinterlaceQueryModeCaps {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA_DeinterlaceTech(pub i32);
pub const DXVA_DeinterlaceTech_Unknown: DXVA_DeinterlaceTech = DXVA_DeinterlaceTech(0i32);
pub const DXVA_DeinterlaceTech_BOBLineReplicate: DXVA_DeinterlaceTech = DXVA_DeinterlaceTech(1i32);
pub const DXVA_DeinterlaceTech_BOBVerticalStretch: DXVA_DeinterlaceTech = DXVA_DeinterlaceTech(2i32);
pub const DXVA_DeinterlaceTech_BOBVerticalStretch4Tap: DXVA_DeinterlaceTech = DXVA_DeinterlaceTech(256i32);
pub const DXVA_DeinterlaceTech_MedianFiltering: DXVA_DeinterlaceTech = DXVA_DeinterlaceTech(4i32);
pub const DXVA_DeinterlaceTech_EdgeFiltering: DXVA_DeinterlaceTech = DXVA_DeinterlaceTech(16i32);
pub const DXVA_DeinterlaceTech_FieldAdaptive: DXVA_DeinterlaceTech = DXVA_DeinterlaceTech(32i32);
pub const DXVA_DeinterlaceTech_PixelAdaptive: DXVA_DeinterlaceTech = DXVA_DeinterlaceTech(64i32);
pub const DXVA_DeinterlaceTech_MotionVectorSteered: DXVA_DeinterlaceTech = DXVA_DeinterlaceTech(128i32);
impl ::core::convert::From<i32> for DXVA_DeinterlaceTech {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA_DeinterlaceTech {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA_DestinationFlags(pub i32);
pub const DXVA_DestinationFlagMask: DXVA_DestinationFlags = DXVA_DestinationFlags(15i32);
pub const DXVA_DestinationFlag_Background_Changed: DXVA_DestinationFlags = DXVA_DestinationFlags(1i32);
pub const DXVA_DestinationFlag_TargetRect_Changed: DXVA_DestinationFlags = DXVA_DestinationFlags(2i32);
pub const DXVA_DestinationFlag_ColorData_Changed: DXVA_DestinationFlags = DXVA_DestinationFlags(4i32);
pub const DXVA_DestinationFlag_Alpha_Changed: DXVA_DestinationFlags = DXVA_DestinationFlags(8i32);
impl ::core::convert::From<i32> for DXVA_DestinationFlags {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA_DestinationFlags {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVA_ExtendedFormat {
pub _bitfield: u32,
}
impl DXVA_ExtendedFormat {}
impl ::core::default::Default for DXVA_ExtendedFormat {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVA_ExtendedFormat {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA_ExtendedFormat").field("_bitfield", &self._bitfield).finish()
}
}
impl ::core::cmp::PartialEq for DXVA_ExtendedFormat {
fn eq(&self, other: &Self) -> bool {
self._bitfield == other._bitfield
}
}
impl ::core::cmp::Eq for DXVA_ExtendedFormat {}
unsafe impl ::windows::core::Abi for DXVA_ExtendedFormat {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVA_Frequency {
pub Numerator: u32,
pub Denominator: u32,
}
impl DXVA_Frequency {}
impl ::core::default::Default for DXVA_Frequency {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVA_Frequency {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA_Frequency").field("Numerator", &self.Numerator).field("Denominator", &self.Denominator).finish()
}
}
impl ::core::cmp::PartialEq for DXVA_Frequency {
fn eq(&self, other: &Self) -> bool {
self.Numerator == other.Numerator && self.Denominator == other.Denominator
}
}
impl ::core::cmp::Eq for DXVA_Frequency {}
unsafe impl ::windows::core::Abi for DXVA_Frequency {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA_NominalRange(pub i32);
pub const DXVA_NominalRangeShift: DXVA_NominalRange = DXVA_NominalRange(12i32);
pub const DXVA_NominalRangeMask: DXVA_NominalRange = DXVA_NominalRange(28672i32);
pub const DXVA_NominalRange_Unknown: DXVA_NominalRange = DXVA_NominalRange(0i32);
pub const DXVA_NominalRange_Normal: DXVA_NominalRange = DXVA_NominalRange(1i32);
pub const DXVA_NominalRange_Wide: DXVA_NominalRange = DXVA_NominalRange(2i32);
pub const DXVA_NominalRange_0_255: DXVA_NominalRange = DXVA_NominalRange(1i32);
pub const DXVA_NominalRange_16_235: DXVA_NominalRange = DXVA_NominalRange(2i32);
pub const DXVA_NominalRange_48_208: DXVA_NominalRange = DXVA_NominalRange(3i32);
impl ::core::convert::From<i32> for DXVA_NominalRange {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA_NominalRange {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct DXVA_PictureParameters {
pub wDecodedPictureIndex: u16,
pub wDeblockedPictureIndex: u16,
pub wForwardRefPictureIndex: u16,
pub wBackwardRefPictureIndex: u16,
pub wPicWidthInMBminus1: u16,
pub wPicHeightInMBminus1: u16,
pub bMacroblockWidthMinus1: u8,
pub bMacroblockHeightMinus1: u8,
pub bBlockWidthMinus1: u8,
pub bBlockHeightMinus1: u8,
pub bBPPminus1: u8,
pub bPicStructure: u8,
pub bSecondField: u8,
pub bPicIntra: u8,
pub bPicBackwardPrediction: u8,
pub bBidirectionalAveragingMode: u8,
pub bMVprecisionAndChromaRelation: u8,
pub bChromaFormat: u8,
pub bPicScanFixed: u8,
pub bPicScanMethod: u8,
pub bPicReadbackRequests: u8,
pub bRcontrol: u8,
pub bPicSpatialResid8: u8,
pub bPicOverflowBlocks: u8,
pub bPicExtrapolation: u8,
pub bPicDeblocked: u8,
pub bPicDeblockConfined: u8,
pub bPic4MVallowed: u8,
pub bPicOBMC: u8,
pub bPicBinPB: u8,
pub bMV_RPS: u8,
pub bReservedBits: u8,
pub wBitstreamFcodes: u16,
pub wBitstreamPCEelements: u16,
pub bBitstreamConcealmentNeed: u8,
pub bBitstreamConcealmentMethod: u8,
}
impl DXVA_PictureParameters {}
impl ::core::default::Default for DXVA_PictureParameters {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for DXVA_PictureParameters {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for DXVA_PictureParameters {}
unsafe impl ::windows::core::Abi for DXVA_PictureParameters {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DXVA_ProcAmpControlBlt {
pub Size: u32,
pub DstRect: super::super::Foundation::RECT,
pub SrcRect: super::super::Foundation::RECT,
pub Alpha: f32,
pub Brightness: f32,
pub Contrast: f32,
pub Hue: f32,
pub Saturation: f32,
}
#[cfg(feature = "Win32_Foundation")]
impl DXVA_ProcAmpControlBlt {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DXVA_ProcAmpControlBlt {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DXVA_ProcAmpControlBlt {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA_ProcAmpControlBlt")
.field("Size", &self.Size)
.field("DstRect", &self.DstRect)
.field("SrcRect", &self.SrcRect)
.field("Alpha", &self.Alpha)
.field("Brightness", &self.Brightness)
.field("Contrast", &self.Contrast)
.field("Hue", &self.Hue)
.field("Saturation", &self.Saturation)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DXVA_ProcAmpControlBlt {
fn eq(&self, other: &Self) -> bool {
self.Size == other.Size && self.DstRect == other.DstRect && self.SrcRect == other.SrcRect && self.Alpha == other.Alpha && self.Brightness == other.Brightness && self.Contrast == other.Contrast && self.Hue == other.Hue && self.Saturation == other.Saturation
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DXVA_ProcAmpControlBlt {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DXVA_ProcAmpControlBlt {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub struct DXVA_ProcAmpControlCaps {
pub Size: u32,
pub InputPool: u32,
pub d3dOutputFormat: super::super::Graphics::Direct3D9::D3DFORMAT,
pub ProcAmpControlProps: u32,
pub VideoProcessingCaps: u32,
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl DXVA_ProcAmpControlCaps {}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::default::Default for DXVA_ProcAmpControlCaps {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::fmt::Debug for DXVA_ProcAmpControlCaps {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA_ProcAmpControlCaps").field("Size", &self.Size).field("InputPool", &self.InputPool).field("d3dOutputFormat", &self.d3dOutputFormat).field("ProcAmpControlProps", &self.ProcAmpControlProps).field("VideoProcessingCaps", &self.VideoProcessingCaps).finish()
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::cmp::PartialEq for DXVA_ProcAmpControlCaps {
fn eq(&self, other: &Self) -> bool {
self.Size == other.Size && self.InputPool == other.InputPool && self.d3dOutputFormat == other.d3dOutputFormat && self.ProcAmpControlProps == other.ProcAmpControlProps && self.VideoProcessingCaps == other.VideoProcessingCaps
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::cmp::Eq for DXVA_ProcAmpControlCaps {}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
unsafe impl ::windows::core::Abi for DXVA_ProcAmpControlCaps {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA_ProcAmpControlProp(pub i32);
pub const DXVA_ProcAmp_None: DXVA_ProcAmpControlProp = DXVA_ProcAmpControlProp(0i32);
pub const DXVA_ProcAmp_Brightness: DXVA_ProcAmpControlProp = DXVA_ProcAmpControlProp(1i32);
pub const DXVA_ProcAmp_Contrast: DXVA_ProcAmpControlProp = DXVA_ProcAmpControlProp(2i32);
pub const DXVA_ProcAmp_Hue: DXVA_ProcAmpControlProp = DXVA_ProcAmpControlProp(4i32);
pub const DXVA_ProcAmp_Saturation: DXVA_ProcAmpControlProp = DXVA_ProcAmpControlProp(8i32);
impl ::core::convert::From<i32> for DXVA_ProcAmpControlProp {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA_ProcAmpControlProp {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub struct DXVA_ProcAmpControlQueryRange {
pub Size: u32,
pub ProcAmpControlProp: DXVA_ProcAmpControlProp,
pub VideoDesc: DXVA_VideoDesc,
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl DXVA_ProcAmpControlQueryRange {}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::default::Default for DXVA_ProcAmpControlQueryRange {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::fmt::Debug for DXVA_ProcAmpControlQueryRange {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA_ProcAmpControlQueryRange").field("Size", &self.Size).field("ProcAmpControlProp", &self.ProcAmpControlProp).field("VideoDesc", &self.VideoDesc).finish()
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::cmp::PartialEq for DXVA_ProcAmpControlQueryRange {
fn eq(&self, other: &Self) -> bool {
self.Size == other.Size && self.ProcAmpControlProp == other.ProcAmpControlProp && self.VideoDesc == other.VideoDesc
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::cmp::Eq for DXVA_ProcAmpControlQueryRange {}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
unsafe impl ::windows::core::Abi for DXVA_ProcAmpControlQueryRange {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA_SampleFlags(pub i32);
pub const DXVA_SampleFlagsMask: DXVA_SampleFlags = DXVA_SampleFlags(15i32);
pub const DXVA_SampleFlag_Palette_Changed: DXVA_SampleFlags = DXVA_SampleFlags(1i32);
pub const DXVA_SampleFlag_SrcRect_Changed: DXVA_SampleFlags = DXVA_SampleFlags(2i32);
pub const DXVA_SampleFlag_DstRect_Changed: DXVA_SampleFlags = DXVA_SampleFlags(4i32);
pub const DXVA_SampleFlag_ColorData_Changed: DXVA_SampleFlags = DXVA_SampleFlags(8i32);
impl ::core::convert::From<i32> for DXVA_SampleFlags {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA_SampleFlags {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA_SampleFormat(pub i32);
pub const DXVA_SampleFormatMask: DXVA_SampleFormat = DXVA_SampleFormat(255i32);
pub const DXVA_SampleUnknown: DXVA_SampleFormat = DXVA_SampleFormat(0i32);
pub const DXVA_SamplePreviousFrame: DXVA_SampleFormat = DXVA_SampleFormat(1i32);
pub const DXVA_SampleProgressiveFrame: DXVA_SampleFormat = DXVA_SampleFormat(2i32);
pub const DXVA_SampleFieldInterleavedEvenFirst: DXVA_SampleFormat = DXVA_SampleFormat(3i32);
pub const DXVA_SampleFieldInterleavedOddFirst: DXVA_SampleFormat = DXVA_SampleFormat(4i32);
pub const DXVA_SampleFieldSingleEven: DXVA_SampleFormat = DXVA_SampleFormat(5i32);
pub const DXVA_SampleFieldSingleOdd: DXVA_SampleFormat = DXVA_SampleFormat(6i32);
pub const DXVA_SampleSubStream: DXVA_SampleFormat = DXVA_SampleFormat(7i32);
impl ::core::convert::From<i32> for DXVA_SampleFormat {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA_SampleFormat {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA_VideoChromaSubsampling(pub i32);
pub const DXVA_VideoChromaSubsamplingShift: DXVA_VideoChromaSubsampling = DXVA_VideoChromaSubsampling(8i32);
pub const DXVA_VideoChromaSubsamplingMask: DXVA_VideoChromaSubsampling = DXVA_VideoChromaSubsampling(3840i32);
pub const DXVA_VideoChromaSubsampling_Unknown: DXVA_VideoChromaSubsampling = DXVA_VideoChromaSubsampling(0i32);
pub const DXVA_VideoChromaSubsampling_ProgressiveChroma: DXVA_VideoChromaSubsampling = DXVA_VideoChromaSubsampling(8i32);
pub const DXVA_VideoChromaSubsampling_Horizontally_Cosited: DXVA_VideoChromaSubsampling = DXVA_VideoChromaSubsampling(4i32);
pub const DXVA_VideoChromaSubsampling_Vertically_Cosited: DXVA_VideoChromaSubsampling = DXVA_VideoChromaSubsampling(2i32);
pub const DXVA_VideoChromaSubsampling_Vertically_AlignedChromaPlanes: DXVA_VideoChromaSubsampling = DXVA_VideoChromaSubsampling(1i32);
pub const DXVA_VideoChromaSubsampling_MPEG2: DXVA_VideoChromaSubsampling = DXVA_VideoChromaSubsampling(5i32);
pub const DXVA_VideoChromaSubsampling_MPEG1: DXVA_VideoChromaSubsampling = DXVA_VideoChromaSubsampling(1i32);
pub const DXVA_VideoChromaSubsampling_DV_PAL: DXVA_VideoChromaSubsampling = DXVA_VideoChromaSubsampling(6i32);
pub const DXVA_VideoChromaSubsampling_Cosited: DXVA_VideoChromaSubsampling = DXVA_VideoChromaSubsampling(7i32);
impl ::core::convert::From<i32> for DXVA_VideoChromaSubsampling {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA_VideoChromaSubsampling {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub struct DXVA_VideoDesc {
pub Size: u32,
pub SampleWidth: u32,
pub SampleHeight: u32,
pub SampleFormat: u32,
pub d3dFormat: super::super::Graphics::Direct3D9::D3DFORMAT,
pub InputSampleFreq: DXVA_Frequency,
pub OutputFrameFreq: DXVA_Frequency,
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl DXVA_VideoDesc {}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::default::Default for DXVA_VideoDesc {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::fmt::Debug for DXVA_VideoDesc {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA_VideoDesc")
.field("Size", &self.Size)
.field("SampleWidth", &self.SampleWidth)
.field("SampleHeight", &self.SampleHeight)
.field("SampleFormat", &self.SampleFormat)
.field("d3dFormat", &self.d3dFormat)
.field("InputSampleFreq", &self.InputSampleFreq)
.field("OutputFrameFreq", &self.OutputFrameFreq)
.finish()
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::cmp::PartialEq for DXVA_VideoDesc {
fn eq(&self, other: &Self) -> bool {
self.Size == other.Size && self.SampleWidth == other.SampleWidth && self.SampleHeight == other.SampleHeight && self.SampleFormat == other.SampleFormat && self.d3dFormat == other.d3dFormat && self.InputSampleFreq == other.InputSampleFreq && self.OutputFrameFreq == other.OutputFrameFreq
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::cmp::Eq for DXVA_VideoDesc {}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
unsafe impl ::windows::core::Abi for DXVA_VideoDesc {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA_VideoLighting(pub i32);
pub const DXVA_VideoLightingShift: DXVA_VideoLighting = DXVA_VideoLighting(18i32);
pub const DXVA_VideoLightingMask: DXVA_VideoLighting = DXVA_VideoLighting(3932160i32);
pub const DXVA_VideoLighting_Unknown: DXVA_VideoLighting = DXVA_VideoLighting(0i32);
pub const DXVA_VideoLighting_bright: DXVA_VideoLighting = DXVA_VideoLighting(1i32);
pub const DXVA_VideoLighting_office: DXVA_VideoLighting = DXVA_VideoLighting(2i32);
pub const DXVA_VideoLighting_dim: DXVA_VideoLighting = DXVA_VideoLighting(3i32);
pub const DXVA_VideoLighting_dark: DXVA_VideoLighting = DXVA_VideoLighting(4i32);
impl ::core::convert::From<i32> for DXVA_VideoLighting {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA_VideoLighting {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA_VideoPrimaries(pub i32);
pub const DXVA_VideoPrimariesShift: DXVA_VideoPrimaries = DXVA_VideoPrimaries(22i32);
pub const DXVA_VideoPrimariesMask: DXVA_VideoPrimaries = DXVA_VideoPrimaries(130023424i32);
pub const DXVA_VideoPrimaries_Unknown: DXVA_VideoPrimaries = DXVA_VideoPrimaries(0i32);
pub const DXVA_VideoPrimaries_reserved: DXVA_VideoPrimaries = DXVA_VideoPrimaries(1i32);
pub const DXVA_VideoPrimaries_BT709: DXVA_VideoPrimaries = DXVA_VideoPrimaries(2i32);
pub const DXVA_VideoPrimaries_BT470_2_SysM: DXVA_VideoPrimaries = DXVA_VideoPrimaries(3i32);
pub const DXVA_VideoPrimaries_BT470_2_SysBG: DXVA_VideoPrimaries = DXVA_VideoPrimaries(4i32);
pub const DXVA_VideoPrimaries_SMPTE170M: DXVA_VideoPrimaries = DXVA_VideoPrimaries(5i32);
pub const DXVA_VideoPrimaries_SMPTE240M: DXVA_VideoPrimaries = DXVA_VideoPrimaries(6i32);
pub const DXVA_VideoPrimaries_EBU3213: DXVA_VideoPrimaries = DXVA_VideoPrimaries(7i32);
pub const DXVA_VideoPrimaries_SMPTE_C: DXVA_VideoPrimaries = DXVA_VideoPrimaries(8i32);
impl ::core::convert::From<i32> for DXVA_VideoPrimaries {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA_VideoPrimaries {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA_VideoProcessCaps(pub i32);
pub const DXVA_VideoProcess_None: DXVA_VideoProcessCaps = DXVA_VideoProcessCaps(0i32);
pub const DXVA_VideoProcess_YUV2RGB: DXVA_VideoProcessCaps = DXVA_VideoProcessCaps(1i32);
pub const DXVA_VideoProcess_StretchX: DXVA_VideoProcessCaps = DXVA_VideoProcessCaps(2i32);
pub const DXVA_VideoProcess_StretchY: DXVA_VideoProcessCaps = DXVA_VideoProcessCaps(4i32);
pub const DXVA_VideoProcess_AlphaBlend: DXVA_VideoProcessCaps = DXVA_VideoProcessCaps(8i32);
pub const DXVA_VideoProcess_SubRects: DXVA_VideoProcessCaps = DXVA_VideoProcessCaps(16i32);
pub const DXVA_VideoProcess_SubStreams: DXVA_VideoProcessCaps = DXVA_VideoProcessCaps(32i32);
pub const DXVA_VideoProcess_SubStreamsExtended: DXVA_VideoProcessCaps = DXVA_VideoProcessCaps(64i32);
pub const DXVA_VideoProcess_YUV2RGBExtended: DXVA_VideoProcessCaps = DXVA_VideoProcessCaps(128i32);
pub const DXVA_VideoProcess_AlphaBlendExtended: DXVA_VideoProcessCaps = DXVA_VideoProcessCaps(256i32);
impl ::core::convert::From<i32> for DXVA_VideoProcessCaps {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA_VideoProcessCaps {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVA_VideoPropertyRange {
pub MinValue: f32,
pub MaxValue: f32,
pub DefaultValue: f32,
pub StepSize: f32,
}
impl DXVA_VideoPropertyRange {}
impl ::core::default::Default for DXVA_VideoPropertyRange {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVA_VideoPropertyRange {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA_VideoPropertyRange").field("MinValue", &self.MinValue).field("MaxValue", &self.MaxValue).field("DefaultValue", &self.DefaultValue).field("StepSize", &self.StepSize).finish()
}
}
impl ::core::cmp::PartialEq for DXVA_VideoPropertyRange {
fn eq(&self, other: &Self) -> bool {
self.MinValue == other.MinValue && self.MaxValue == other.MaxValue && self.DefaultValue == other.DefaultValue && self.StepSize == other.StepSize
}
}
impl ::core::cmp::Eq for DXVA_VideoPropertyRange {}
unsafe impl ::windows::core::Abi for DXVA_VideoPropertyRange {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DXVA_VideoSample {
pub rtStart: i64,
pub rtEnd: i64,
pub SampleFormat: DXVA_SampleFormat,
pub lpDDSSrcSurface: *mut ::core::ffi::c_void,
}
impl DXVA_VideoSample {}
impl ::core::default::Default for DXVA_VideoSample {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DXVA_VideoSample {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA_VideoSample").field("rtStart", &self.rtStart).field("rtEnd", &self.rtEnd).field("SampleFormat", &self.SampleFormat).field("lpDDSSrcSurface", &self.lpDDSSrcSurface).finish()
}
}
impl ::core::cmp::PartialEq for DXVA_VideoSample {
fn eq(&self, other: &Self) -> bool {
self.rtStart == other.rtStart && self.rtEnd == other.rtEnd && self.SampleFormat == other.SampleFormat && self.lpDDSSrcSurface == other.lpDDSSrcSurface
}
}
impl ::core::cmp::Eq for DXVA_VideoSample {}
unsafe impl ::windows::core::Abi for DXVA_VideoSample {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(feature = "Win32_Foundation")]
pub struct DXVA_VideoSample2 {
pub Size: u32,
pub Reserved: u32,
pub rtStart: i64,
pub rtEnd: i64,
pub SampleFormat: u32,
pub SampleFlags: u32,
pub lpDDSSrcSurface: *mut ::core::ffi::c_void,
pub rcSrc: super::super::Foundation::RECT,
pub rcDst: super::super::Foundation::RECT,
pub Palette: [DXVA_AYUVsample2; 16],
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(feature = "Win32_Foundation")]
impl DXVA_VideoSample2 {}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DXVA_VideoSample2 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DXVA_VideoSample2 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA_VideoSample2")
.field("Size", &self.Size)
.field("Reserved", &self.Reserved)
.field("rtStart", &self.rtStart)
.field("rtEnd", &self.rtEnd)
.field("SampleFormat", &self.SampleFormat)
.field("SampleFlags", &self.SampleFlags)
.field("lpDDSSrcSurface", &self.lpDDSSrcSurface)
.field("rcSrc", &self.rcSrc)
.field("rcDst", &self.rcDst)
.field("Palette", &self.Palette)
.finish()
}
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DXVA_VideoSample2 {
fn eq(&self, other: &Self) -> bool {
self.Size == other.Size && self.Reserved == other.Reserved && self.rtStart == other.rtStart && self.rtEnd == other.rtEnd && self.SampleFormat == other.SampleFormat && self.SampleFlags == other.SampleFlags && self.lpDDSSrcSurface == other.lpDDSSrcSurface && self.rcSrc == other.rcSrc && self.rcDst == other.rcDst && self.Palette == other.Palette
}
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DXVA_VideoSample2 {}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DXVA_VideoSample2 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
pub struct DXVA_VideoSample2 {
pub rtStart: i64,
pub rtEnd: i64,
pub SampleFormat: u32,
pub SampleFlags: u32,
pub lpDDSSrcSurface: *mut ::core::ffi::c_void,
pub rcSrc: super::super::Foundation::RECT,
pub rcDst: super::super::Foundation::RECT,
pub Palette: [DXVA_AYUVsample2; 16],
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl DXVA_VideoSample2 {}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DXVA_VideoSample2 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DXVA_VideoSample2 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA_VideoSample2")
.field("rtStart", &self.rtStart)
.field("rtEnd", &self.rtEnd)
.field("SampleFormat", &self.SampleFormat)
.field("SampleFlags", &self.SampleFlags)
.field("lpDDSSrcSurface", &self.lpDDSSrcSurface)
.field("rcSrc", &self.rcSrc)
.field("rcDst", &self.rcDst)
.field("Palette", &self.Palette)
.finish()
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DXVA_VideoSample2 {
fn eq(&self, other: &Self) -> bool {
self.rtStart == other.rtStart && self.rtEnd == other.rtEnd && self.SampleFormat == other.SampleFormat && self.SampleFlags == other.SampleFlags && self.lpDDSSrcSurface == other.lpDDSSrcSurface && self.rcSrc == other.rcSrc && self.rcDst == other.rcDst && self.Palette == other.Palette
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DXVA_VideoSample2 {}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DXVA_VideoSample2 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(feature = "Win32_Foundation")]
pub struct DXVA_VideoSample32 {
pub rtStart: i64,
pub rtEnd: i64,
pub SampleFormat: u32,
pub SampleFlags: u32,
pub lpDDSSrcSurface: u32,
pub rcSrc: super::super::Foundation::RECT,
pub rcDst: super::super::Foundation::RECT,
pub Palette: [DXVA_AYUVsample2; 16],
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(feature = "Win32_Foundation")]
impl DXVA_VideoSample32 {}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DXVA_VideoSample32 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DXVA_VideoSample32 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DXVA_VideoSample32")
.field("rtStart", &self.rtStart)
.field("rtEnd", &self.rtEnd)
.field("SampleFormat", &self.SampleFormat)
.field("SampleFlags", &self.SampleFlags)
.field("lpDDSSrcSurface", &self.lpDDSSrcSurface)
.field("rcSrc", &self.rcSrc)
.field("rcDst", &self.rcDst)
.field("Palette", &self.Palette)
.finish()
}
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DXVA_VideoSample32 {
fn eq(&self, other: &Self) -> bool {
self.rtStart == other.rtStart && self.rtEnd == other.rtEnd && self.SampleFormat == other.SampleFormat && self.SampleFlags == other.SampleFlags && self.lpDDSSrcSurface == other.lpDDSSrcSurface && self.rcSrc == other.rcSrc && self.rcDst == other.rcDst && self.Palette == other.Palette
}
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DXVA_VideoSample32 {}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DXVA_VideoSample32 {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA_VideoTransferFunction(pub i32);
pub const DXVA_VideoTransFuncShift: DXVA_VideoTransferFunction = DXVA_VideoTransferFunction(27i32);
pub const DXVA_VideoTransFuncMask: DXVA_VideoTransferFunction = DXVA_VideoTransferFunction(-134217728i32);
pub const DXVA_VideoTransFunc_Unknown: DXVA_VideoTransferFunction = DXVA_VideoTransferFunction(0i32);
pub const DXVA_VideoTransFunc_10: DXVA_VideoTransferFunction = DXVA_VideoTransferFunction(1i32);
pub const DXVA_VideoTransFunc_18: DXVA_VideoTransferFunction = DXVA_VideoTransferFunction(2i32);
pub const DXVA_VideoTransFunc_20: DXVA_VideoTransferFunction = DXVA_VideoTransferFunction(3i32);
pub const DXVA_VideoTransFunc_22: DXVA_VideoTransferFunction = DXVA_VideoTransferFunction(4i32);
pub const DXVA_VideoTransFunc_22_709: DXVA_VideoTransferFunction = DXVA_VideoTransferFunction(5i32);
pub const DXVA_VideoTransFunc_22_240M: DXVA_VideoTransferFunction = DXVA_VideoTransferFunction(6i32);
pub const DXVA_VideoTransFunc_22_8bit_sRGB: DXVA_VideoTransferFunction = DXVA_VideoTransferFunction(7i32);
pub const DXVA_VideoTransFunc_28: DXVA_VideoTransferFunction = DXVA_VideoTransferFunction(8i32);
impl ::core::convert::From<i32> for DXVA_VideoTransferFunction {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA_VideoTransferFunction {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DXVA_VideoTransferMatrix(pub i32);
pub const DXVA_VideoTransferMatrixShift: DXVA_VideoTransferMatrix = DXVA_VideoTransferMatrix(15i32);
pub const DXVA_VideoTransferMatrixMask: DXVA_VideoTransferMatrix = DXVA_VideoTransferMatrix(229376i32);
pub const DXVA_VideoTransferMatrix_Unknown: DXVA_VideoTransferMatrix = DXVA_VideoTransferMatrix(0i32);
pub const DXVA_VideoTransferMatrix_BT709: DXVA_VideoTransferMatrix = DXVA_VideoTransferMatrix(1i32);
pub const DXVA_VideoTransferMatrix_BT601: DXVA_VideoTransferMatrix = DXVA_VideoTransferMatrix(2i32);
pub const DXVA_VideoTransferMatrix_SMPTE240M: DXVA_VideoTransferMatrix = DXVA_VideoTransferMatrix(3i32);
impl ::core::convert::From<i32> for DXVA_VideoTransferMatrix {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DXVA_VideoTransferMatrix {
type Abi = Self;
}
pub const DXVAp_DeinterlaceBobDevice: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x335aa36e_7884_43a4_9c91_7f87faf3e37e);
pub const DXVAp_DeinterlaceContainerDevice: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0e85cb93_3046_4ff0_aecc_d58cb5f035fd);
pub const DXVAp_ModeMPEG2_A: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1b81be0a_a0c7_11d3_b984_00c04f2e73c5);
pub const DXVAp_ModeMPEG2_C: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1b81be0c_a0c7_11d3_b984_00c04f2e73c5);
pub const DXVAp_NoEncrypt: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1b81bed0_a0c7_11d3_b984_00c04f2e73c5);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DeviceStreamState(pub i32);
pub const DeviceStreamState_Stop: DeviceStreamState = DeviceStreamState(0i32);
pub const DeviceStreamState_Pause: DeviceStreamState = DeviceStreamState(1i32);
pub const DeviceStreamState_Run: DeviceStreamState = DeviceStreamState(2i32);
pub const DeviceStreamState_Disabled: DeviceStreamState = DeviceStreamState(3i32);
impl ::core::convert::From<i32> for DeviceStreamState {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DeviceStreamState {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DigitalWindowSetting {
pub OriginX: f64,
pub OriginY: f64,
pub WindowSize: f64,
}
impl DigitalWindowSetting {}
impl ::core::default::Default for DigitalWindowSetting {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DigitalWindowSetting {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DigitalWindowSetting").field("OriginX", &self.OriginX).field("OriginY", &self.OriginY).field("WindowSize", &self.WindowSize).finish()
}
}
impl ::core::cmp::PartialEq for DigitalWindowSetting {
fn eq(&self, other: &Self) -> bool {
self.OriginX == other.OriginX && self.OriginY == other.OriginY && self.WindowSize == other.WindowSize
}
}
impl ::core::cmp::Eq for DigitalWindowSetting {}
unsafe impl ::windows::core::Abi for DigitalWindowSetting {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct EAllocationType(pub i32);
pub const eAllocationTypeDynamic: EAllocationType = EAllocationType(0i32);
pub const eAllocationTypeRT: EAllocationType = EAllocationType(1i32);
pub const eAllocationTypePageable: EAllocationType = EAllocationType(2i32);
pub const eAllocationTypeIgnore: EAllocationType = EAllocationType(3i32);
impl ::core::convert::From<i32> for EAllocationType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for EAllocationType {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct EVRFilterConfigPrefs(pub i32);
pub const EVRFilterConfigPrefs_EnableQoS: EVRFilterConfigPrefs = EVRFilterConfigPrefs(1i32);
pub const EVRFilterConfigPrefs_Mask: EVRFilterConfigPrefs = EVRFilterConfigPrefs(1i32);
impl ::core::convert::From<i32> for EVRFilterConfigPrefs {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for EVRFilterConfigPrefs {
type Abi = Self;
}
pub const E_TOCPARSER_INVALIDASFFILE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1728053247i32 as _);
pub const E_TOCPARSER_INVALIDRIFFFILE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1728053246i32 as _);
pub const FACILITY_MF: u32 = 13u32;
pub const FACILITY_MF_WIN32: u32 = 7u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct FILE_ACCESSMODE(pub i32);
pub const ACCESSMODE_READ: FILE_ACCESSMODE = FILE_ACCESSMODE(1i32);
pub const ACCESSMODE_WRITE: FILE_ACCESSMODE = FILE_ACCESSMODE(2i32);
pub const ACCESSMODE_READWRITE: FILE_ACCESSMODE = FILE_ACCESSMODE(3i32);
pub const ACCESSMODE_WRITE_EXCLUSIVE: FILE_ACCESSMODE = FILE_ACCESSMODE(4i32);
impl ::core::convert::From<i32> for FILE_ACCESSMODE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for FILE_ACCESSMODE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct FILE_OPENMODE(pub i32);
pub const OPENMODE_FAIL_IF_NOT_EXIST: FILE_OPENMODE = FILE_OPENMODE(0i32);
pub const OPENMODE_FAIL_IF_EXIST: FILE_OPENMODE = FILE_OPENMODE(1i32);
pub const OPENMODE_RESET_IF_EXIST: FILE_OPENMODE = FILE_OPENMODE(2i32);
pub const OPENMODE_APPEND_IF_EXIST: FILE_OPENMODE = FILE_OPENMODE(3i32);
pub const OPENMODE_DELETE_IF_EXIST: FILE_OPENMODE = FILE_OPENMODE(4i32);
impl ::core::convert::From<i32> for FILE_OPENMODE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for FILE_OPENMODE {
type Abi = Self;
}
pub const FORMAT_MFVideoFormat: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xaed4ab2d_7326_43cb_9464_c879cab9c43d);
pub const GUID_NativeDeviceService: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xef71e53c_52f4_43c5_b86a_ad6cb216a61e);
pub const GUID_PlayToService: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf6a8ff9d_9e14_41c9_bf0f_120a2b3ce120);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IAdvancedMediaCapture(pub ::windows::core::IUnknown);
impl IAdvancedMediaCapture {
pub unsafe fn GetAdvancedMediaCaptureSettings(&self) -> ::windows::core::Result<IAdvancedMediaCaptureSettings> {
let mut result__: <IAdvancedMediaCaptureSettings as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IAdvancedMediaCaptureSettings>(result__)
}
}
unsafe impl ::windows::core::Interface for IAdvancedMediaCapture {
type Vtable = IAdvancedMediaCapture_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd0751585_d216_4344_b5bf_463b68f977bb);
}
impl ::core::convert::From<IAdvancedMediaCapture> for ::windows::core::IUnknown {
fn from(value: IAdvancedMediaCapture) -> Self {
value.0
}
}
impl ::core::convert::From<&IAdvancedMediaCapture> for ::windows::core::IUnknown {
fn from(value: &IAdvancedMediaCapture) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IAdvancedMediaCapture {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IAdvancedMediaCapture {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IAdvancedMediaCapture_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, value: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IAdvancedMediaCaptureInitializationSettings(pub ::windows::core::IUnknown);
impl IAdvancedMediaCaptureInitializationSettings {
pub unsafe fn SetDirectxDeviceManager<'a, Param0: ::windows::core::IntoParam<'a, IMFDXGIDeviceManager>>(&self, value: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), value.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IAdvancedMediaCaptureInitializationSettings {
type Vtable = IAdvancedMediaCaptureInitializationSettings_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3de21209_8ba6_4f2a_a577_2819b56ff14d);
}
impl ::core::convert::From<IAdvancedMediaCaptureInitializationSettings> for ::windows::core::IUnknown {
fn from(value: IAdvancedMediaCaptureInitializationSettings) -> Self {
value.0
}
}
impl ::core::convert::From<&IAdvancedMediaCaptureInitializationSettings> for ::windows::core::IUnknown {
fn from(value: &IAdvancedMediaCaptureInitializationSettings) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IAdvancedMediaCaptureInitializationSettings {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IAdvancedMediaCaptureInitializationSettings {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IAdvancedMediaCaptureInitializationSettings_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, value: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IAdvancedMediaCaptureSettings(pub ::windows::core::IUnknown);
impl IAdvancedMediaCaptureSettings {
pub unsafe fn GetDirectxDeviceManager(&self) -> ::windows::core::Result<IMFDXGIDeviceManager> {
let mut result__: <IMFDXGIDeviceManager as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFDXGIDeviceManager>(result__)
}
}
unsafe impl ::windows::core::Interface for IAdvancedMediaCaptureSettings {
type Vtable = IAdvancedMediaCaptureSettings_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x24e0485f_a33e_4aa1_b564_6019b1d14f65);
}
impl ::core::convert::From<IAdvancedMediaCaptureSettings> for ::windows::core::IUnknown {
fn from(value: IAdvancedMediaCaptureSettings) -> Self {
value.0
}
}
impl ::core::convert::From<&IAdvancedMediaCaptureSettings> for ::windows::core::IUnknown {
fn from(value: &IAdvancedMediaCaptureSettings) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IAdvancedMediaCaptureSettings {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IAdvancedMediaCaptureSettings {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IAdvancedMediaCaptureSettings_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, value: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IAudioSourceProvider(pub ::windows::core::IUnknown);
impl IAudioSourceProvider {
pub unsafe fn ProvideInput(&self, dwsamplecount: u32, pdwchannelcount: *mut u32, pinterleavedaudiodata: *mut f32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsamplecount), ::core::mem::transmute(pdwchannelcount), ::core::mem::transmute(pinterleavedaudiodata)).ok()
}
}
unsafe impl ::windows::core::Interface for IAudioSourceProvider {
type Vtable = IAudioSourceProvider_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xebbaf249_afc2_4582_91c6_b60df2e84954);
}
impl ::core::convert::From<IAudioSourceProvider> for ::windows::core::IUnknown {
fn from(value: IAudioSourceProvider) -> Self {
value.0
}
}
impl ::core::convert::From<&IAudioSourceProvider> for ::windows::core::IUnknown {
fn from(value: &IAudioSourceProvider) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IAudioSourceProvider {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IAudioSourceProvider {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IAudioSourceProvider_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsamplecount: u32, pdwchannelcount: *mut u32, pinterleavedaudiodata: *mut f32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IClusterDetector(pub ::windows::core::IUnknown);
impl IClusterDetector {
pub unsafe fn Initialize(&self, wbaseentrylevel: u16, wclusterentrylevel: u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(wbaseentrylevel), ::core::mem::transmute(wclusterentrylevel)).ok()
}
pub unsafe fn Detect<'a, Param3: ::windows::core::IntoParam<'a, IToc>>(&self, dwmaxnumclusters: u32, fminclusterduration: f32, fmaxclusterduration: f32, psrctoc: Param3) -> ::windows::core::Result<IToc> {
let mut result__: <IToc as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwmaxnumclusters), ::core::mem::transmute(fminclusterduration), ::core::mem::transmute(fmaxclusterduration), psrctoc.into_param().abi(), &mut result__).from_abi::<IToc>(result__)
}
}
unsafe impl ::windows::core::Interface for IClusterDetector {
type Vtable = IClusterDetector_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3f07f7b7_c680_41d9_9423_915107ec9ff9);
}
impl ::core::convert::From<IClusterDetector> for ::windows::core::IUnknown {
fn from(value: IClusterDetector) -> Self {
value.0
}
}
impl ::core::convert::From<&IClusterDetector> for ::windows::core::IUnknown {
fn from(value: &IClusterDetector) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IClusterDetector {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IClusterDetector {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IClusterDetector_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, wbaseentrylevel: u16, wclusterentrylevel: u16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwmaxnumclusters: u32, fminclusterduration: f32, fmaxclusterduration: f32, psrctoc: ::windows::core::RawPtr, ppdsttoc: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ICodecAPI(pub ::windows::core::IUnknown);
impl ICodecAPI {
pub unsafe fn IsSupported(&self, api: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(api)).ok()
}
pub unsafe fn IsModifiable(&self, api: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(api)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn GetParameterRange(&self, api: *const ::windows::core::GUID, valuemin: *mut super::super::System::Com::VARIANT, valuemax: *mut super::super::System::Com::VARIANT, steppingdelta: *mut super::super::System::Com::VARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(api), ::core::mem::transmute(valuemin), ::core::mem::transmute(valuemax), ::core::mem::transmute(steppingdelta)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn GetParameterValues(&self, api: *const ::windows::core::GUID, values: *mut *mut super::super::System::Com::VARIANT, valuescount: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(api), ::core::mem::transmute(values), ::core::mem::transmute(valuescount)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn GetDefaultValue(&self, api: *const ::windows::core::GUID) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(api), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn GetValue(&self, api: *const ::windows::core::GUID) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(api), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn SetValue(&self, api: *const ::windows::core::GUID, value: *const super::super::System::Com::VARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(api), ::core::mem::transmute(value)).ok()
}
pub unsafe fn RegisterForEvent(&self, api: *const ::windows::core::GUID, userdata: isize) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(api), ::core::mem::transmute(userdata)).ok()
}
pub unsafe fn UnregisterForEvent(&self, api: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(api)).ok()
}
pub unsafe fn SetAllDefaults(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn SetValueWithNotify(&self, api: *const ::windows::core::GUID, value: *mut super::super::System::Com::VARIANT, changedparam: *mut *mut ::windows::core::GUID, changedparamcount: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(api), ::core::mem::transmute(value), ::core::mem::transmute(changedparam), ::core::mem::transmute(changedparamcount)).ok()
}
pub unsafe fn SetAllDefaultsWithNotify(&self, changedparam: *mut *mut ::windows::core::GUID, changedparamcount: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(changedparam), ::core::mem::transmute(changedparamcount)).ok()
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn GetAllSettings<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::IStream>>(&self, __midl__icodecapi0000: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), __midl__icodecapi0000.into_param().abi()).ok()
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn SetAllSettings<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::IStream>>(&self, __midl__icodecapi0001: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), __midl__icodecapi0001.into_param().abi()).ok()
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn SetAllSettingsWithNotify<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::IStream>>(&self, __midl__icodecapi0002: Param0, changedparam: *mut *mut ::windows::core::GUID, changedparamcount: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), __midl__icodecapi0002.into_param().abi(), ::core::mem::transmute(changedparam), ::core::mem::transmute(changedparamcount)).ok()
}
}
unsafe impl ::windows::core::Interface for ICodecAPI {
type Vtable = ICodecAPI_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x901db4c7_31ce_41a2_85dc_8fa0bf41b8da);
}
impl ::core::convert::From<ICodecAPI> for ::windows::core::IUnknown {
fn from(value: ICodecAPI) -> Self {
value.0
}
}
impl ::core::convert::From<&ICodecAPI> for ::windows::core::IUnknown {
fn from(value: &ICodecAPI) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ICodecAPI {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ICodecAPI {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ICodecAPI_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, api: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, api: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, api: *const ::windows::core::GUID, valuemin: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, valuemax: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, steppingdelta: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, api: *const ::windows::core::GUID, values: *mut *mut super::super::System::Com::VARIANT, valuescount: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, api: *const ::windows::core::GUID, value: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, api: *const ::windows::core::GUID, value: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, api: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, api: *const ::windows::core::GUID, userdata: isize) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, api: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, api: *const ::windows::core::GUID, value: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, changedparam: *mut *mut ::windows::core::GUID, changedparamcount: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, changedparam: *mut *mut ::windows::core::GUID, changedparamcount: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, __midl__icodecapi0000: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, __midl__icodecapi0001: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, __midl__icodecapi0002: ::windows::core::RawPtr, changedparam: *mut *mut ::windows::core::GUID, changedparamcount: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ID3D12VideoDecodeCommandList(pub ::windows::core::IUnknown);
impl ID3D12VideoDecodeCommandList {
pub unsafe fn GetPrivateData(&self, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(pdatasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateData(&self, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(datasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guid: *const ::windows::core::GUID, pdata: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), pdata.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetName<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), name.into_param().abi()).ok()
}
pub unsafe fn GetDevice<T: ::windows::core::Interface>(&self, result__: *mut ::core::option::Option<T>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &<T as ::windows::core::Interface>::IID, result__ as *mut _ as *mut _).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn GetType(&self) -> super::super::Graphics::Direct3D12::D3D12_COMMAND_LIST_TYPE {
::core::mem::transmute((::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)))
}
pub unsafe fn Close(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn Reset<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12CommandAllocator>>(&self, pallocator: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), pallocator.into_param().abi()).ok()
}
pub unsafe fn ClearState(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn ResourceBarrier(&self, numbarriers: u32, pbarriers: *const super::super::Graphics::Direct3D12::D3D12_RESOURCE_BARRIER) {
::core::mem::transmute((::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(numbarriers), ::core::mem::transmute(pbarriers)))
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
pub unsafe fn DiscardResource<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Resource>>(&self, presource: Param0, pregion: *const super::super::Graphics::Direct3D12::D3D12_DISCARD_REGION) {
::core::mem::transmute((::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), presource.into_param().abi(), ::core::mem::transmute(pregion)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn BeginQuery<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12QueryHeap>>(&self, pqueryheap: Param0, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), pqueryheap.into_param().abi(), ::core::mem::transmute(r#type), ::core::mem::transmute(index)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn EndQuery<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12QueryHeap>>(&self, pqueryheap: Param0, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), pqueryheap.into_param().abi(), ::core::mem::transmute(r#type), ::core::mem::transmute(index)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn ResolveQueryData<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12QueryHeap>, Param4: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Resource>>(&self, pqueryheap: Param0, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, startindex: u32, numqueries: u32, pdestinationbuffer: Param4, aligneddestinationbufferoffset: u64) {
::core::mem::transmute((::windows::core::Interface::vtable(self).16)(
::core::mem::transmute_copy(self),
pqueryheap.into_param().abi(),
::core::mem::transmute(r#type),
::core::mem::transmute(startindex),
::core::mem::transmute(numqueries),
pdestinationbuffer.into_param().abi(),
::core::mem::transmute(aligneddestinationbufferoffset),
))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn SetPredication<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Resource>>(&self, pbuffer: Param0, alignedbufferoffset: u64, operation: super::super::Graphics::Direct3D12::D3D12_PREDICATION_OP) {
::core::mem::transmute((::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), pbuffer.into_param().abi(), ::core::mem::transmute(alignedbufferoffset), ::core::mem::transmute(operation)))
}
pub unsafe fn SetMarker(&self, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(metadata), ::core::mem::transmute(pdata), ::core::mem::transmute(size)))
}
pub unsafe fn BeginEvent(&self, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(metadata), ::core::mem::transmute(pdata), ::core::mem::transmute(size)))
}
pub unsafe fn EndEvent(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)))
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
pub unsafe fn DecodeFrame<'a, Param0: ::windows::core::IntoParam<'a, ID3D12VideoDecoder>>(&self, pdecoder: Param0, poutputarguments: *const D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS, pinputarguments: *const D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS) {
::core::mem::transmute((::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), pdecoder.into_param().abi(), ::core::mem::transmute(poutputarguments), ::core::mem::transmute(pinputarguments)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn WriteBufferImmediate(&self, count: u32, pparams: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_PARAMETER, pmodes: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_MODE) {
::core::mem::transmute((::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(pparams), ::core::mem::transmute(pmodes)))
}
}
unsafe impl ::windows::core::Interface for ID3D12VideoDecodeCommandList {
type Vtable = ID3D12VideoDecodeCommandList_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3b60536e_ad29_4e64_a269_f853837e5e53);
}
impl ::core::convert::From<ID3D12VideoDecodeCommandList> for ::windows::core::IUnknown {
fn from(value: ID3D12VideoDecodeCommandList) -> Self {
value.0
}
}
impl ::core::convert::From<&ID3D12VideoDecodeCommandList> for ::windows::core::IUnknown {
fn from(value: &ID3D12VideoDecodeCommandList) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ID3D12VideoDecodeCommandList {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ID3D12VideoDecodeCommandList {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoDecodeCommandList> for super::super::Graphics::Direct3D12::ID3D12CommandList {
fn from(value: ID3D12VideoDecodeCommandList) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoDecodeCommandList> for super::super::Graphics::Direct3D12::ID3D12CommandList {
fn from(value: &ID3D12VideoDecodeCommandList) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> for ID3D12VideoDecodeCommandList {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> for &ID3D12VideoDecodeCommandList {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoDecodeCommandList> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: ID3D12VideoDecodeCommandList) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoDecodeCommandList> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: &ID3D12VideoDecodeCommandList) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for ID3D12VideoDecodeCommandList {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for &ID3D12VideoDecodeCommandList {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoDecodeCommandList> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: ID3D12VideoDecodeCommandList) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoDecodeCommandList> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: &ID3D12VideoDecodeCommandList) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for ID3D12VideoDecodeCommandList {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for &ID3D12VideoDecodeCommandList {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ID3D12VideoDecodeCommandList_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdata: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvdevice: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Graphics::Direct3D12::D3D12_COMMAND_LIST_TYPE,
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pallocator: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, numbarriers: u32, pbarriers: *const ::core::mem::ManuallyDrop<super::super::Graphics::Direct3D12::D3D12_RESOURCE_BARRIER>),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presource: ::windows::core::RawPtr, pregion: *const super::super::Graphics::Direct3D12::D3D12_DISCARD_REGION),
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12")))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqueryheap: ::windows::core::RawPtr, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqueryheap: ::windows::core::RawPtr, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqueryheap: ::windows::core::RawPtr, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, startindex: u32, numqueries: u32, pdestinationbuffer: ::windows::core::RawPtr, aligneddestinationbufferoffset: u64),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbuffer: ::windows::core::RawPtr, alignedbufferoffset: u64, operation: super::super::Graphics::Direct3D12::D3D12_PREDICATION_OP),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdecoder: ::windows::core::RawPtr, poutputarguments: *const ::core::mem::ManuallyDrop<D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS>, pinputarguments: *const ::core::mem::ManuallyDrop<D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS>),
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common")))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, pparams: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_PARAMETER, pmodes: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_MODE),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ID3D12VideoDecodeCommandList1(pub ::windows::core::IUnknown);
impl ID3D12VideoDecodeCommandList1 {
pub unsafe fn GetPrivateData(&self, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(pdatasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateData(&self, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(datasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guid: *const ::windows::core::GUID, pdata: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), pdata.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetName<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), name.into_param().abi()).ok()
}
pub unsafe fn GetDevice<T: ::windows::core::Interface>(&self, result__: *mut ::core::option::Option<T>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &<T as ::windows::core::Interface>::IID, result__ as *mut _ as *mut _).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn GetType(&self) -> super::super::Graphics::Direct3D12::D3D12_COMMAND_LIST_TYPE {
::core::mem::transmute((::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)))
}
pub unsafe fn Close(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn Reset<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12CommandAllocator>>(&self, pallocator: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), pallocator.into_param().abi()).ok()
}
pub unsafe fn ClearState(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn ResourceBarrier(&self, numbarriers: u32, pbarriers: *const super::super::Graphics::Direct3D12::D3D12_RESOURCE_BARRIER) {
::core::mem::transmute((::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(numbarriers), ::core::mem::transmute(pbarriers)))
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
pub unsafe fn DiscardResource<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Resource>>(&self, presource: Param0, pregion: *const super::super::Graphics::Direct3D12::D3D12_DISCARD_REGION) {
::core::mem::transmute((::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), presource.into_param().abi(), ::core::mem::transmute(pregion)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn BeginQuery<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12QueryHeap>>(&self, pqueryheap: Param0, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), pqueryheap.into_param().abi(), ::core::mem::transmute(r#type), ::core::mem::transmute(index)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn EndQuery<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12QueryHeap>>(&self, pqueryheap: Param0, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), pqueryheap.into_param().abi(), ::core::mem::transmute(r#type), ::core::mem::transmute(index)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn ResolveQueryData<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12QueryHeap>, Param4: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Resource>>(&self, pqueryheap: Param0, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, startindex: u32, numqueries: u32, pdestinationbuffer: Param4, aligneddestinationbufferoffset: u64) {
::core::mem::transmute((::windows::core::Interface::vtable(self).16)(
::core::mem::transmute_copy(self),
pqueryheap.into_param().abi(),
::core::mem::transmute(r#type),
::core::mem::transmute(startindex),
::core::mem::transmute(numqueries),
pdestinationbuffer.into_param().abi(),
::core::mem::transmute(aligneddestinationbufferoffset),
))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn SetPredication<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Resource>>(&self, pbuffer: Param0, alignedbufferoffset: u64, operation: super::super::Graphics::Direct3D12::D3D12_PREDICATION_OP) {
::core::mem::transmute((::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), pbuffer.into_param().abi(), ::core::mem::transmute(alignedbufferoffset), ::core::mem::transmute(operation)))
}
pub unsafe fn SetMarker(&self, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(metadata), ::core::mem::transmute(pdata), ::core::mem::transmute(size)))
}
pub unsafe fn BeginEvent(&self, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(metadata), ::core::mem::transmute(pdata), ::core::mem::transmute(size)))
}
pub unsafe fn EndEvent(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)))
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
pub unsafe fn DecodeFrame<'a, Param0: ::windows::core::IntoParam<'a, ID3D12VideoDecoder>>(&self, pdecoder: Param0, poutputarguments: *const D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS, pinputarguments: *const D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS) {
::core::mem::transmute((::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), pdecoder.into_param().abi(), ::core::mem::transmute(poutputarguments), ::core::mem::transmute(pinputarguments)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn WriteBufferImmediate(&self, count: u32, pparams: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_PARAMETER, pmodes: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_MODE) {
::core::mem::transmute((::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(pparams), ::core::mem::transmute(pmodes)))
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
pub unsafe fn DecodeFrame1<'a, Param0: ::windows::core::IntoParam<'a, ID3D12VideoDecoder>>(&self, pdecoder: Param0, poutputarguments: *const D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS1, pinputarguments: *const D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS) {
::core::mem::transmute((::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), pdecoder.into_param().abi(), ::core::mem::transmute(poutputarguments), ::core::mem::transmute(pinputarguments)))
}
}
unsafe impl ::windows::core::Interface for ID3D12VideoDecodeCommandList1 {
type Vtable = ID3D12VideoDecodeCommandList1_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd52f011b_b56e_453c_a05a_a7f311c8f472);
}
impl ::core::convert::From<ID3D12VideoDecodeCommandList1> for ::windows::core::IUnknown {
fn from(value: ID3D12VideoDecodeCommandList1) -> Self {
value.0
}
}
impl ::core::convert::From<&ID3D12VideoDecodeCommandList1> for ::windows::core::IUnknown {
fn from(value: &ID3D12VideoDecodeCommandList1) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ID3D12VideoDecodeCommandList1 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ID3D12VideoDecodeCommandList1 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ID3D12VideoDecodeCommandList1> for ID3D12VideoDecodeCommandList {
fn from(value: ID3D12VideoDecodeCommandList1) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ID3D12VideoDecodeCommandList1> for ID3D12VideoDecodeCommandList {
fn from(value: &ID3D12VideoDecodeCommandList1) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoDecodeCommandList> for ID3D12VideoDecodeCommandList1 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoDecodeCommandList> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoDecodeCommandList> for &ID3D12VideoDecodeCommandList1 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoDecodeCommandList> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoDecodeCommandList1> for super::super::Graphics::Direct3D12::ID3D12CommandList {
fn from(value: ID3D12VideoDecodeCommandList1) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoDecodeCommandList1> for super::super::Graphics::Direct3D12::ID3D12CommandList {
fn from(value: &ID3D12VideoDecodeCommandList1) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> for ID3D12VideoDecodeCommandList1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> for &ID3D12VideoDecodeCommandList1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoDecodeCommandList1> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: ID3D12VideoDecodeCommandList1) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoDecodeCommandList1> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: &ID3D12VideoDecodeCommandList1) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for ID3D12VideoDecodeCommandList1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for &ID3D12VideoDecodeCommandList1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoDecodeCommandList1> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: ID3D12VideoDecodeCommandList1) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoDecodeCommandList1> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: &ID3D12VideoDecodeCommandList1) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for ID3D12VideoDecodeCommandList1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for &ID3D12VideoDecodeCommandList1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ID3D12VideoDecodeCommandList1_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdata: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvdevice: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Graphics::Direct3D12::D3D12_COMMAND_LIST_TYPE,
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pallocator: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, numbarriers: u32, pbarriers: *const ::core::mem::ManuallyDrop<super::super::Graphics::Direct3D12::D3D12_RESOURCE_BARRIER>),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presource: ::windows::core::RawPtr, pregion: *const super::super::Graphics::Direct3D12::D3D12_DISCARD_REGION),
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12")))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqueryheap: ::windows::core::RawPtr, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqueryheap: ::windows::core::RawPtr, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqueryheap: ::windows::core::RawPtr, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, startindex: u32, numqueries: u32, pdestinationbuffer: ::windows::core::RawPtr, aligneddestinationbufferoffset: u64),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbuffer: ::windows::core::RawPtr, alignedbufferoffset: u64, operation: super::super::Graphics::Direct3D12::D3D12_PREDICATION_OP),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdecoder: ::windows::core::RawPtr, poutputarguments: *const ::core::mem::ManuallyDrop<D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS>, pinputarguments: *const ::core::mem::ManuallyDrop<D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS>),
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common")))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, pparams: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_PARAMETER, pmodes: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_MODE),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdecoder: ::windows::core::RawPtr, poutputarguments: *const ::core::mem::ManuallyDrop<D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS1>, pinputarguments: *const ::core::mem::ManuallyDrop<D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS>),
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ID3D12VideoDecodeCommandList2(pub ::windows::core::IUnknown);
impl ID3D12VideoDecodeCommandList2 {
pub unsafe fn GetPrivateData(&self, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(pdatasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateData(&self, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(datasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guid: *const ::windows::core::GUID, pdata: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), pdata.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetName<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), name.into_param().abi()).ok()
}
pub unsafe fn GetDevice<T: ::windows::core::Interface>(&self, result__: *mut ::core::option::Option<T>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &<T as ::windows::core::Interface>::IID, result__ as *mut _ as *mut _).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn GetType(&self) -> super::super::Graphics::Direct3D12::D3D12_COMMAND_LIST_TYPE {
::core::mem::transmute((::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)))
}
pub unsafe fn Close(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn Reset<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12CommandAllocator>>(&self, pallocator: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), pallocator.into_param().abi()).ok()
}
pub unsafe fn ClearState(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn ResourceBarrier(&self, numbarriers: u32, pbarriers: *const super::super::Graphics::Direct3D12::D3D12_RESOURCE_BARRIER) {
::core::mem::transmute((::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(numbarriers), ::core::mem::transmute(pbarriers)))
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
pub unsafe fn DiscardResource<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Resource>>(&self, presource: Param0, pregion: *const super::super::Graphics::Direct3D12::D3D12_DISCARD_REGION) {
::core::mem::transmute((::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), presource.into_param().abi(), ::core::mem::transmute(pregion)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn BeginQuery<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12QueryHeap>>(&self, pqueryheap: Param0, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), pqueryheap.into_param().abi(), ::core::mem::transmute(r#type), ::core::mem::transmute(index)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn EndQuery<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12QueryHeap>>(&self, pqueryheap: Param0, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), pqueryheap.into_param().abi(), ::core::mem::transmute(r#type), ::core::mem::transmute(index)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn ResolveQueryData<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12QueryHeap>, Param4: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Resource>>(&self, pqueryheap: Param0, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, startindex: u32, numqueries: u32, pdestinationbuffer: Param4, aligneddestinationbufferoffset: u64) {
::core::mem::transmute((::windows::core::Interface::vtable(self).16)(
::core::mem::transmute_copy(self),
pqueryheap.into_param().abi(),
::core::mem::transmute(r#type),
::core::mem::transmute(startindex),
::core::mem::transmute(numqueries),
pdestinationbuffer.into_param().abi(),
::core::mem::transmute(aligneddestinationbufferoffset),
))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn SetPredication<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Resource>>(&self, pbuffer: Param0, alignedbufferoffset: u64, operation: super::super::Graphics::Direct3D12::D3D12_PREDICATION_OP) {
::core::mem::transmute((::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), pbuffer.into_param().abi(), ::core::mem::transmute(alignedbufferoffset), ::core::mem::transmute(operation)))
}
pub unsafe fn SetMarker(&self, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(metadata), ::core::mem::transmute(pdata), ::core::mem::transmute(size)))
}
pub unsafe fn BeginEvent(&self, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(metadata), ::core::mem::transmute(pdata), ::core::mem::transmute(size)))
}
pub unsafe fn EndEvent(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)))
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
pub unsafe fn DecodeFrame<'a, Param0: ::windows::core::IntoParam<'a, ID3D12VideoDecoder>>(&self, pdecoder: Param0, poutputarguments: *const D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS, pinputarguments: *const D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS) {
::core::mem::transmute((::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), pdecoder.into_param().abi(), ::core::mem::transmute(poutputarguments), ::core::mem::transmute(pinputarguments)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn WriteBufferImmediate(&self, count: u32, pparams: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_PARAMETER, pmodes: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_MODE) {
::core::mem::transmute((::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(pparams), ::core::mem::transmute(pmodes)))
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
pub unsafe fn DecodeFrame1<'a, Param0: ::windows::core::IntoParam<'a, ID3D12VideoDecoder>>(&self, pdecoder: Param0, poutputarguments: *const D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS1, pinputarguments: *const D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS) {
::core::mem::transmute((::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), pdecoder.into_param().abi(), ::core::mem::transmute(poutputarguments), ::core::mem::transmute(pinputarguments)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn SetProtectedResourceSession<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12ProtectedResourceSession>>(&self, pprotectedresourcesession: Param0) {
::core::mem::transmute((::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), pprotectedresourcesession.into_param().abi()))
}
pub unsafe fn InitializeExtensionCommand<'a, Param0: ::windows::core::IntoParam<'a, ID3D12VideoExtensionCommand>>(&self, pextensioncommand: Param0, pinitializationparameters: *const ::core::ffi::c_void, initializationparameterssizeinbytes: usize) {
::core::mem::transmute((::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), pextensioncommand.into_param().abi(), ::core::mem::transmute(pinitializationparameters), ::core::mem::transmute(initializationparameterssizeinbytes)))
}
pub unsafe fn ExecuteExtensionCommand<'a, Param0: ::windows::core::IntoParam<'a, ID3D12VideoExtensionCommand>>(&self, pextensioncommand: Param0, pexecutionparameters: *const ::core::ffi::c_void, executionparameterssizeinbytes: usize) {
::core::mem::transmute((::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), pextensioncommand.into_param().abi(), ::core::mem::transmute(pexecutionparameters), ::core::mem::transmute(executionparameterssizeinbytes)))
}
}
unsafe impl ::windows::core::Interface for ID3D12VideoDecodeCommandList2 {
type Vtable = ID3D12VideoDecodeCommandList2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6e120880_c114_4153_8036_d247051e1729);
}
impl ::core::convert::From<ID3D12VideoDecodeCommandList2> for ::windows::core::IUnknown {
fn from(value: ID3D12VideoDecodeCommandList2) -> Self {
value.0
}
}
impl ::core::convert::From<&ID3D12VideoDecodeCommandList2> for ::windows::core::IUnknown {
fn from(value: &ID3D12VideoDecodeCommandList2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ID3D12VideoDecodeCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ID3D12VideoDecodeCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ID3D12VideoDecodeCommandList2> for ID3D12VideoDecodeCommandList1 {
fn from(value: ID3D12VideoDecodeCommandList2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ID3D12VideoDecodeCommandList2> for ID3D12VideoDecodeCommandList1 {
fn from(value: &ID3D12VideoDecodeCommandList2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoDecodeCommandList1> for ID3D12VideoDecodeCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoDecodeCommandList1> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoDecodeCommandList1> for &ID3D12VideoDecodeCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoDecodeCommandList1> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<ID3D12VideoDecodeCommandList2> for ID3D12VideoDecodeCommandList {
fn from(value: ID3D12VideoDecodeCommandList2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ID3D12VideoDecodeCommandList2> for ID3D12VideoDecodeCommandList {
fn from(value: &ID3D12VideoDecodeCommandList2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoDecodeCommandList> for ID3D12VideoDecodeCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoDecodeCommandList> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoDecodeCommandList> for &ID3D12VideoDecodeCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoDecodeCommandList> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoDecodeCommandList2> for super::super::Graphics::Direct3D12::ID3D12CommandList {
fn from(value: ID3D12VideoDecodeCommandList2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoDecodeCommandList2> for super::super::Graphics::Direct3D12::ID3D12CommandList {
fn from(value: &ID3D12VideoDecodeCommandList2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> for ID3D12VideoDecodeCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> for &ID3D12VideoDecodeCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoDecodeCommandList2> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: ID3D12VideoDecodeCommandList2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoDecodeCommandList2> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: &ID3D12VideoDecodeCommandList2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for ID3D12VideoDecodeCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for &ID3D12VideoDecodeCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoDecodeCommandList2> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: ID3D12VideoDecodeCommandList2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoDecodeCommandList2> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: &ID3D12VideoDecodeCommandList2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for ID3D12VideoDecodeCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for &ID3D12VideoDecodeCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ID3D12VideoDecodeCommandList2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdata: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvdevice: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Graphics::Direct3D12::D3D12_COMMAND_LIST_TYPE,
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pallocator: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, numbarriers: u32, pbarriers: *const ::core::mem::ManuallyDrop<super::super::Graphics::Direct3D12::D3D12_RESOURCE_BARRIER>),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presource: ::windows::core::RawPtr, pregion: *const super::super::Graphics::Direct3D12::D3D12_DISCARD_REGION),
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12")))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqueryheap: ::windows::core::RawPtr, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqueryheap: ::windows::core::RawPtr, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqueryheap: ::windows::core::RawPtr, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, startindex: u32, numqueries: u32, pdestinationbuffer: ::windows::core::RawPtr, aligneddestinationbufferoffset: u64),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbuffer: ::windows::core::RawPtr, alignedbufferoffset: u64, operation: super::super::Graphics::Direct3D12::D3D12_PREDICATION_OP),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdecoder: ::windows::core::RawPtr, poutputarguments: *const ::core::mem::ManuallyDrop<D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS>, pinputarguments: *const ::core::mem::ManuallyDrop<D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS>),
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common")))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, pparams: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_PARAMETER, pmodes: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_MODE),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdecoder: ::windows::core::RawPtr, poutputarguments: *const ::core::mem::ManuallyDrop<D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS1>, pinputarguments: *const ::core::mem::ManuallyDrop<D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS>),
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common")))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pprotectedresourcesession: ::windows::core::RawPtr),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pextensioncommand: ::windows::core::RawPtr, pinitializationparameters: *const ::core::ffi::c_void, initializationparameterssizeinbytes: usize),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pextensioncommand: ::windows::core::RawPtr, pexecutionparameters: *const ::core::ffi::c_void, executionparameterssizeinbytes: usize),
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ID3D12VideoDecoder(pub ::windows::core::IUnknown);
impl ID3D12VideoDecoder {
pub unsafe fn GetPrivateData(&self, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(pdatasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateData(&self, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(datasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guid: *const ::windows::core::GUID, pdata: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), pdata.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetName<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), name.into_param().abi()).ok()
}
pub unsafe fn GetDevice<T: ::windows::core::Interface>(&self, result__: *mut ::core::option::Option<T>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &<T as ::windows::core::Interface>::IID, result__ as *mut _ as *mut _).ok()
}
pub unsafe fn GetDesc(&self) -> D3D12_VIDEO_DECODER_DESC {
let mut result__: D3D12_VIDEO_DECODER_DESC = ::core::default::Default::default();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__);
result__
}
}
unsafe impl ::windows::core::Interface for ID3D12VideoDecoder {
type Vtable = ID3D12VideoDecoder_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc59b6bdc_7720_4074_a136_17a156037470);
}
impl ::core::convert::From<ID3D12VideoDecoder> for ::windows::core::IUnknown {
fn from(value: ID3D12VideoDecoder) -> Self {
value.0
}
}
impl ::core::convert::From<&ID3D12VideoDecoder> for ::windows::core::IUnknown {
fn from(value: &ID3D12VideoDecoder) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ID3D12VideoDecoder {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ID3D12VideoDecoder {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoDecoder> for super::super::Graphics::Direct3D12::ID3D12Pageable {
fn from(value: ID3D12VideoDecoder) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoDecoder> for super::super::Graphics::Direct3D12::ID3D12Pageable {
fn from(value: &ID3D12VideoDecoder) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> for ID3D12VideoDecoder {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> for &ID3D12VideoDecoder {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoDecoder> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: ID3D12VideoDecoder) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoDecoder> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: &ID3D12VideoDecoder) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for ID3D12VideoDecoder {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for &ID3D12VideoDecoder {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoDecoder> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: ID3D12VideoDecoder) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoDecoder> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: &ID3D12VideoDecoder) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for ID3D12VideoDecoder {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for &ID3D12VideoDecoder {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ID3D12VideoDecoder_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdata: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvdevice: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, result__: *mut D3D12_VIDEO_DECODER_DESC),
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ID3D12VideoDecoder1(pub ::windows::core::IUnknown);
impl ID3D12VideoDecoder1 {
pub unsafe fn GetPrivateData(&self, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(pdatasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateData(&self, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(datasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guid: *const ::windows::core::GUID, pdata: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), pdata.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetName<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), name.into_param().abi()).ok()
}
pub unsafe fn GetDevice<T: ::windows::core::Interface>(&self, result__: *mut ::core::option::Option<T>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &<T as ::windows::core::Interface>::IID, result__ as *mut _ as *mut _).ok()
}
pub unsafe fn GetDesc(&self) -> D3D12_VIDEO_DECODER_DESC {
let mut result__: D3D12_VIDEO_DECODER_DESC = ::core::default::Default::default();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__);
result__
}
pub unsafe fn GetProtectedResourceSession<T: ::windows::core::Interface>(&self, result__: *mut ::core::option::Option<T>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &<T as ::windows::core::Interface>::IID, result__ as *mut _ as *mut _).ok()
}
}
unsafe impl ::windows::core::Interface for ID3D12VideoDecoder1 {
type Vtable = ID3D12VideoDecoder1_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x79a2e5fb_ccd2_469a_9fde_195d10951f7e);
}
impl ::core::convert::From<ID3D12VideoDecoder1> for ::windows::core::IUnknown {
fn from(value: ID3D12VideoDecoder1) -> Self {
value.0
}
}
impl ::core::convert::From<&ID3D12VideoDecoder1> for ::windows::core::IUnknown {
fn from(value: &ID3D12VideoDecoder1) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ID3D12VideoDecoder1 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ID3D12VideoDecoder1 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ID3D12VideoDecoder1> for ID3D12VideoDecoder {
fn from(value: ID3D12VideoDecoder1) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ID3D12VideoDecoder1> for ID3D12VideoDecoder {
fn from(value: &ID3D12VideoDecoder1) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoDecoder> for ID3D12VideoDecoder1 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoDecoder> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoDecoder> for &ID3D12VideoDecoder1 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoDecoder> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoDecoder1> for super::super::Graphics::Direct3D12::ID3D12Pageable {
fn from(value: ID3D12VideoDecoder1) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoDecoder1> for super::super::Graphics::Direct3D12::ID3D12Pageable {
fn from(value: &ID3D12VideoDecoder1) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> for ID3D12VideoDecoder1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> for &ID3D12VideoDecoder1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoDecoder1> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: ID3D12VideoDecoder1) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoDecoder1> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: &ID3D12VideoDecoder1) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for ID3D12VideoDecoder1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for &ID3D12VideoDecoder1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoDecoder1> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: ID3D12VideoDecoder1) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoDecoder1> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: &ID3D12VideoDecoder1) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for ID3D12VideoDecoder1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for &ID3D12VideoDecoder1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ID3D12VideoDecoder1_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdata: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvdevice: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, result__: *mut D3D12_VIDEO_DECODER_DESC),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppprotectedsession: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ID3D12VideoDecoderHeap(pub ::windows::core::IUnknown);
impl ID3D12VideoDecoderHeap {
pub unsafe fn GetPrivateData(&self, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(pdatasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateData(&self, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(datasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guid: *const ::windows::core::GUID, pdata: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), pdata.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetName<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), name.into_param().abi()).ok()
}
pub unsafe fn GetDevice<T: ::windows::core::Interface>(&self, result__: *mut ::core::option::Option<T>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &<T as ::windows::core::Interface>::IID, result__ as *mut _ as *mut _).ok()
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
pub unsafe fn GetDesc(&self) -> D3D12_VIDEO_DECODER_HEAP_DESC {
let mut result__: D3D12_VIDEO_DECODER_HEAP_DESC = ::core::default::Default::default();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__);
result__
}
}
unsafe impl ::windows::core::Interface for ID3D12VideoDecoderHeap {
type Vtable = ID3D12VideoDecoderHeap_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0946b7c9_ebf6_4047_bb73_8683e27dbb1f);
}
impl ::core::convert::From<ID3D12VideoDecoderHeap> for ::windows::core::IUnknown {
fn from(value: ID3D12VideoDecoderHeap) -> Self {
value.0
}
}
impl ::core::convert::From<&ID3D12VideoDecoderHeap> for ::windows::core::IUnknown {
fn from(value: &ID3D12VideoDecoderHeap) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ID3D12VideoDecoderHeap {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ID3D12VideoDecoderHeap {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoDecoderHeap> for super::super::Graphics::Direct3D12::ID3D12Pageable {
fn from(value: ID3D12VideoDecoderHeap) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoDecoderHeap> for super::super::Graphics::Direct3D12::ID3D12Pageable {
fn from(value: &ID3D12VideoDecoderHeap) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> for ID3D12VideoDecoderHeap {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> for &ID3D12VideoDecoderHeap {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoDecoderHeap> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: ID3D12VideoDecoderHeap) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoDecoderHeap> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: &ID3D12VideoDecoderHeap) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for ID3D12VideoDecoderHeap {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for &ID3D12VideoDecoderHeap {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoDecoderHeap> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: ID3D12VideoDecoderHeap) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoDecoderHeap> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: &ID3D12VideoDecoderHeap) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for ID3D12VideoDecoderHeap {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for &ID3D12VideoDecoderHeap {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ID3D12VideoDecoderHeap_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdata: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvdevice: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Dxgi_Common")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, result__: *mut D3D12_VIDEO_DECODER_HEAP_DESC),
#[cfg(not(feature = "Win32_Graphics_Dxgi_Common"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ID3D12VideoDecoderHeap1(pub ::windows::core::IUnknown);
impl ID3D12VideoDecoderHeap1 {
pub unsafe fn GetPrivateData(&self, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(pdatasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateData(&self, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(datasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guid: *const ::windows::core::GUID, pdata: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), pdata.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetName<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), name.into_param().abi()).ok()
}
pub unsafe fn GetDevice<T: ::windows::core::Interface>(&self, result__: *mut ::core::option::Option<T>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &<T as ::windows::core::Interface>::IID, result__ as *mut _ as *mut _).ok()
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
pub unsafe fn GetDesc(&self) -> D3D12_VIDEO_DECODER_HEAP_DESC {
let mut result__: D3D12_VIDEO_DECODER_HEAP_DESC = ::core::default::Default::default();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__);
result__
}
pub unsafe fn GetProtectedResourceSession<T: ::windows::core::Interface>(&self, result__: *mut ::core::option::Option<T>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &<T as ::windows::core::Interface>::IID, result__ as *mut _ as *mut _).ok()
}
}
unsafe impl ::windows::core::Interface for ID3D12VideoDecoderHeap1 {
type Vtable = ID3D12VideoDecoderHeap1_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xda1d98c5_539f_41b2_bf6b_1198a03b6d26);
}
impl ::core::convert::From<ID3D12VideoDecoderHeap1> for ::windows::core::IUnknown {
fn from(value: ID3D12VideoDecoderHeap1) -> Self {
value.0
}
}
impl ::core::convert::From<&ID3D12VideoDecoderHeap1> for ::windows::core::IUnknown {
fn from(value: &ID3D12VideoDecoderHeap1) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ID3D12VideoDecoderHeap1 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ID3D12VideoDecoderHeap1 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ID3D12VideoDecoderHeap1> for ID3D12VideoDecoderHeap {
fn from(value: ID3D12VideoDecoderHeap1) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ID3D12VideoDecoderHeap1> for ID3D12VideoDecoderHeap {
fn from(value: &ID3D12VideoDecoderHeap1) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoDecoderHeap> for ID3D12VideoDecoderHeap1 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoDecoderHeap> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoDecoderHeap> for &ID3D12VideoDecoderHeap1 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoDecoderHeap> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoDecoderHeap1> for super::super::Graphics::Direct3D12::ID3D12Pageable {
fn from(value: ID3D12VideoDecoderHeap1) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoDecoderHeap1> for super::super::Graphics::Direct3D12::ID3D12Pageable {
fn from(value: &ID3D12VideoDecoderHeap1) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> for ID3D12VideoDecoderHeap1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> for &ID3D12VideoDecoderHeap1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoDecoderHeap1> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: ID3D12VideoDecoderHeap1) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoDecoderHeap1> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: &ID3D12VideoDecoderHeap1) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for ID3D12VideoDecoderHeap1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for &ID3D12VideoDecoderHeap1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoDecoderHeap1> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: ID3D12VideoDecoderHeap1) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoDecoderHeap1> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: &ID3D12VideoDecoderHeap1) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for ID3D12VideoDecoderHeap1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for &ID3D12VideoDecoderHeap1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ID3D12VideoDecoderHeap1_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdata: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvdevice: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Dxgi_Common")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, result__: *mut D3D12_VIDEO_DECODER_HEAP_DESC),
#[cfg(not(feature = "Win32_Graphics_Dxgi_Common"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppprotectedsession: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ID3D12VideoDevice(pub ::windows::core::IUnknown);
impl ID3D12VideoDevice {
pub unsafe fn CheckFeatureSupport(&self, featurevideo: D3D12_FEATURE_VIDEO, pfeaturesupportdata: *mut ::core::ffi::c_void, featuresupportdatasize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(featurevideo), ::core::mem::transmute(pfeaturesupportdata), ::core::mem::transmute(featuresupportdatasize)).ok()
}
pub unsafe fn CreateVideoDecoder<T: ::windows::core::Interface>(&self, pdesc: *const D3D12_VIDEO_DECODER_DESC) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdesc), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
pub unsafe fn CreateVideoDecoderHeap<T: ::windows::core::Interface>(&self, pvideodecoderheapdesc: *const D3D12_VIDEO_DECODER_HEAP_DESC) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(pvideodecoderheapdesc), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
pub unsafe fn CreateVideoProcessor<T: ::windows::core::Interface>(&self, nodemask: u32, poutputstreamdesc: *const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC, numinputstreamdescs: u32, pinputstreamdescs: *const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(nodemask), ::core::mem::transmute(poutputstreamdesc), ::core::mem::transmute(numinputstreamdescs), ::core::mem::transmute(pinputstreamdescs), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
}
unsafe impl ::windows::core::Interface for ID3D12VideoDevice {
type Vtable = ID3D12VideoDevice_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1f052807_0b46_4acc_8a89_364f793718a4);
}
impl ::core::convert::From<ID3D12VideoDevice> for ::windows::core::IUnknown {
fn from(value: ID3D12VideoDevice) -> Self {
value.0
}
}
impl ::core::convert::From<&ID3D12VideoDevice> for ::windows::core::IUnknown {
fn from(value: &ID3D12VideoDevice) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ID3D12VideoDevice {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ID3D12VideoDevice {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ID3D12VideoDevice_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, featurevideo: D3D12_FEATURE_VIDEO, pfeaturesupportdata: *mut ::core::ffi::c_void, featuresupportdatasize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdesc: *const D3D12_VIDEO_DECODER_DESC, riid: *const ::windows::core::GUID, ppvideodecoder: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Dxgi_Common")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pvideodecoderheapdesc: *const D3D12_VIDEO_DECODER_HEAP_DESC, riid: *const ::windows::core::GUID, ppvideodecoderheap: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Dxgi_Common"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, nodemask: u32, poutputstreamdesc: *const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC, numinputstreamdescs: u32, pinputstreamdescs: *const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC, riid: *const ::windows::core::GUID, ppvideoprocessor: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ID3D12VideoDevice1(pub ::windows::core::IUnknown);
impl ID3D12VideoDevice1 {
pub unsafe fn CheckFeatureSupport(&self, featurevideo: D3D12_FEATURE_VIDEO, pfeaturesupportdata: *mut ::core::ffi::c_void, featuresupportdatasize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(featurevideo), ::core::mem::transmute(pfeaturesupportdata), ::core::mem::transmute(featuresupportdatasize)).ok()
}
pub unsafe fn CreateVideoDecoder<T: ::windows::core::Interface>(&self, pdesc: *const D3D12_VIDEO_DECODER_DESC) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdesc), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
pub unsafe fn CreateVideoDecoderHeap<T: ::windows::core::Interface>(&self, pvideodecoderheapdesc: *const D3D12_VIDEO_DECODER_HEAP_DESC) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(pvideodecoderheapdesc), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
pub unsafe fn CreateVideoProcessor<T: ::windows::core::Interface>(&self, nodemask: u32, poutputstreamdesc: *const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC, numinputstreamdescs: u32, pinputstreamdescs: *const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(nodemask), ::core::mem::transmute(poutputstreamdesc), ::core::mem::transmute(numinputstreamdescs), ::core::mem::transmute(pinputstreamdescs), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
pub unsafe fn CreateVideoMotionEstimator<'a, Param1: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12ProtectedResourceSession>, T: ::windows::core::Interface>(&self, pdesc: *const D3D12_VIDEO_MOTION_ESTIMATOR_DESC, pprotectedresourcesession: Param1) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdesc), pprotectedresourcesession.into_param().abi(), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
pub unsafe fn CreateVideoMotionVectorHeap<'a, Param1: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12ProtectedResourceSession>, T: ::windows::core::Interface>(&self, pdesc: *const D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC, pprotectedresourcesession: Param1) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdesc), pprotectedresourcesession.into_param().abi(), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
}
unsafe impl ::windows::core::Interface for ID3D12VideoDevice1 {
type Vtable = ID3D12VideoDevice1_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x981611ad_a144_4c83_9890_f30e26d658ab);
}
impl ::core::convert::From<ID3D12VideoDevice1> for ::windows::core::IUnknown {
fn from(value: ID3D12VideoDevice1) -> Self {
value.0
}
}
impl ::core::convert::From<&ID3D12VideoDevice1> for ::windows::core::IUnknown {
fn from(value: &ID3D12VideoDevice1) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ID3D12VideoDevice1 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ID3D12VideoDevice1 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ID3D12VideoDevice1> for ID3D12VideoDevice {
fn from(value: ID3D12VideoDevice1) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ID3D12VideoDevice1> for ID3D12VideoDevice {
fn from(value: &ID3D12VideoDevice1) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoDevice> for ID3D12VideoDevice1 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoDevice> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoDevice> for &ID3D12VideoDevice1 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoDevice> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ID3D12VideoDevice1_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, featurevideo: D3D12_FEATURE_VIDEO, pfeaturesupportdata: *mut ::core::ffi::c_void, featuresupportdatasize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdesc: *const D3D12_VIDEO_DECODER_DESC, riid: *const ::windows::core::GUID, ppvideodecoder: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Dxgi_Common")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pvideodecoderheapdesc: *const D3D12_VIDEO_DECODER_HEAP_DESC, riid: *const ::windows::core::GUID, ppvideodecoderheap: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Dxgi_Common"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, nodemask: u32, poutputstreamdesc: *const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC, numinputstreamdescs: u32, pinputstreamdescs: *const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC, riid: *const ::windows::core::GUID, ppvideoprocessor: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common")))] usize,
#[cfg(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdesc: *const D3D12_VIDEO_MOTION_ESTIMATOR_DESC, pprotectedresourcesession: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvideomotionestimator: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common")))] usize,
#[cfg(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdesc: *const D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC, pprotectedresourcesession: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvideomotionvectorheap: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ID3D12VideoDevice2(pub ::windows::core::IUnknown);
impl ID3D12VideoDevice2 {
pub unsafe fn CheckFeatureSupport(&self, featurevideo: D3D12_FEATURE_VIDEO, pfeaturesupportdata: *mut ::core::ffi::c_void, featuresupportdatasize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(featurevideo), ::core::mem::transmute(pfeaturesupportdata), ::core::mem::transmute(featuresupportdatasize)).ok()
}
pub unsafe fn CreateVideoDecoder<T: ::windows::core::Interface>(&self, pdesc: *const D3D12_VIDEO_DECODER_DESC) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdesc), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
pub unsafe fn CreateVideoDecoderHeap<T: ::windows::core::Interface>(&self, pvideodecoderheapdesc: *const D3D12_VIDEO_DECODER_HEAP_DESC) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(pvideodecoderheapdesc), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
pub unsafe fn CreateVideoProcessor<T: ::windows::core::Interface>(&self, nodemask: u32, poutputstreamdesc: *const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC, numinputstreamdescs: u32, pinputstreamdescs: *const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(nodemask), ::core::mem::transmute(poutputstreamdesc), ::core::mem::transmute(numinputstreamdescs), ::core::mem::transmute(pinputstreamdescs), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
pub unsafe fn CreateVideoMotionEstimator<'a, Param1: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12ProtectedResourceSession>, T: ::windows::core::Interface>(&self, pdesc: *const D3D12_VIDEO_MOTION_ESTIMATOR_DESC, pprotectedresourcesession: Param1) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdesc), pprotectedresourcesession.into_param().abi(), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
pub unsafe fn CreateVideoMotionVectorHeap<'a, Param1: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12ProtectedResourceSession>, T: ::windows::core::Interface>(&self, pdesc: *const D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC, pprotectedresourcesession: Param1) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdesc), pprotectedresourcesession.into_param().abi(), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn CreateVideoDecoder1<'a, Param1: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12ProtectedResourceSession>, T: ::windows::core::Interface>(&self, pdesc: *const D3D12_VIDEO_DECODER_DESC, pprotectedresourcesession: Param1) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdesc), pprotectedresourcesession.into_param().abi(), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
pub unsafe fn CreateVideoDecoderHeap1<'a, Param1: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12ProtectedResourceSession>, T: ::windows::core::Interface>(&self, pvideodecoderheapdesc: *const D3D12_VIDEO_DECODER_HEAP_DESC, pprotectedresourcesession: Param1) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(pvideodecoderheapdesc), pprotectedresourcesession.into_param().abi(), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
pub unsafe fn CreateVideoProcessor1<'a, Param4: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12ProtectedResourceSession>, T: ::windows::core::Interface>(&self, nodemask: u32, poutputstreamdesc: *const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC, numinputstreamdescs: u32, pinputstreamdescs: *const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC, pprotectedresourcesession: Param4) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).11)(
::core::mem::transmute_copy(self),
::core::mem::transmute(nodemask),
::core::mem::transmute(poutputstreamdesc),
::core::mem::transmute(numinputstreamdescs),
::core::mem::transmute(pinputstreamdescs),
pprotectedresourcesession.into_param().abi(),
&<T as ::windows::core::Interface>::IID,
&mut result__ as *mut _ as *mut _,
)
.and_some(result__)
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn CreateVideoExtensionCommand<'a, Param3: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12ProtectedResourceSession>, T: ::windows::core::Interface>(&self, pdesc: *const D3D12_VIDEO_EXTENSION_COMMAND_DESC, pcreationparameters: *const ::core::ffi::c_void, creationparametersdatasizeinbytes: usize, pprotectedresourcesession: Param3) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdesc), ::core::mem::transmute(pcreationparameters), ::core::mem::transmute(creationparametersdatasizeinbytes), pprotectedresourcesession.into_param().abi(), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
pub unsafe fn ExecuteExtensionCommand<'a, Param0: ::windows::core::IntoParam<'a, ID3D12VideoExtensionCommand>>(&self, pextensioncommand: Param0, pexecutionparameters: *const ::core::ffi::c_void, executionparameterssizeinbytes: usize, poutputdata: *mut ::core::ffi::c_void, outputdatasizeinbytes: usize) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), pextensioncommand.into_param().abi(), ::core::mem::transmute(pexecutionparameters), ::core::mem::transmute(executionparameterssizeinbytes), ::core::mem::transmute(poutputdata), ::core::mem::transmute(outputdatasizeinbytes)).ok()
}
}
unsafe impl ::windows::core::Interface for ID3D12VideoDevice2 {
type Vtable = ID3D12VideoDevice2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf019ac49_f838_4a95_9b17_579437c8f513);
}
impl ::core::convert::From<ID3D12VideoDevice2> for ::windows::core::IUnknown {
fn from(value: ID3D12VideoDevice2) -> Self {
value.0
}
}
impl ::core::convert::From<&ID3D12VideoDevice2> for ::windows::core::IUnknown {
fn from(value: &ID3D12VideoDevice2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ID3D12VideoDevice2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ID3D12VideoDevice2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ID3D12VideoDevice2> for ID3D12VideoDevice1 {
fn from(value: ID3D12VideoDevice2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ID3D12VideoDevice2> for ID3D12VideoDevice1 {
fn from(value: &ID3D12VideoDevice2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoDevice1> for ID3D12VideoDevice2 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoDevice1> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoDevice1> for &ID3D12VideoDevice2 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoDevice1> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<ID3D12VideoDevice2> for ID3D12VideoDevice {
fn from(value: ID3D12VideoDevice2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ID3D12VideoDevice2> for ID3D12VideoDevice {
fn from(value: &ID3D12VideoDevice2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoDevice> for ID3D12VideoDevice2 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoDevice> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoDevice> for &ID3D12VideoDevice2 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoDevice> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ID3D12VideoDevice2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, featurevideo: D3D12_FEATURE_VIDEO, pfeaturesupportdata: *mut ::core::ffi::c_void, featuresupportdatasize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdesc: *const D3D12_VIDEO_DECODER_DESC, riid: *const ::windows::core::GUID, ppvideodecoder: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Dxgi_Common")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pvideodecoderheapdesc: *const D3D12_VIDEO_DECODER_HEAP_DESC, riid: *const ::windows::core::GUID, ppvideodecoderheap: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Dxgi_Common"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, nodemask: u32, poutputstreamdesc: *const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC, numinputstreamdescs: u32, pinputstreamdescs: *const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC, riid: *const ::windows::core::GUID, ppvideoprocessor: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common")))] usize,
#[cfg(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdesc: *const D3D12_VIDEO_MOTION_ESTIMATOR_DESC, pprotectedresourcesession: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvideomotionestimator: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common")))] usize,
#[cfg(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdesc: *const D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC, pprotectedresourcesession: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvideomotionvectorheap: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common")))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdesc: *const D3D12_VIDEO_DECODER_DESC, pprotectedresourcesession: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvideodecoder: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pvideodecoderheapdesc: *const D3D12_VIDEO_DECODER_HEAP_DESC, pprotectedresourcesession: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvideodecoderheap: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, nodemask: u32, poutputstreamdesc: *const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC, numinputstreamdescs: u32, pinputstreamdescs: *const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC, pprotectedresourcesession: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvideoprocessor: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common")))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdesc: *const D3D12_VIDEO_EXTENSION_COMMAND_DESC, pcreationparameters: *const ::core::ffi::c_void, creationparametersdatasizeinbytes: usize, pprotectedresourcesession: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvideoextensioncommand: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pextensioncommand: ::windows::core::RawPtr, pexecutionparameters: *const ::core::ffi::c_void, executionparameterssizeinbytes: usize, poutputdata: *mut ::core::ffi::c_void, outputdatasizeinbytes: usize) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ID3D12VideoDevice3(pub ::windows::core::IUnknown);
impl ID3D12VideoDevice3 {
pub unsafe fn CheckFeatureSupport(&self, featurevideo: D3D12_FEATURE_VIDEO, pfeaturesupportdata: *mut ::core::ffi::c_void, featuresupportdatasize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(featurevideo), ::core::mem::transmute(pfeaturesupportdata), ::core::mem::transmute(featuresupportdatasize)).ok()
}
pub unsafe fn CreateVideoDecoder<T: ::windows::core::Interface>(&self, pdesc: *const D3D12_VIDEO_DECODER_DESC) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdesc), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
pub unsafe fn CreateVideoDecoderHeap<T: ::windows::core::Interface>(&self, pvideodecoderheapdesc: *const D3D12_VIDEO_DECODER_HEAP_DESC) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(pvideodecoderheapdesc), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
pub unsafe fn CreateVideoProcessor<T: ::windows::core::Interface>(&self, nodemask: u32, poutputstreamdesc: *const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC, numinputstreamdescs: u32, pinputstreamdescs: *const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(nodemask), ::core::mem::transmute(poutputstreamdesc), ::core::mem::transmute(numinputstreamdescs), ::core::mem::transmute(pinputstreamdescs), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
pub unsafe fn CreateVideoMotionEstimator<'a, Param1: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12ProtectedResourceSession>, T: ::windows::core::Interface>(&self, pdesc: *const D3D12_VIDEO_MOTION_ESTIMATOR_DESC, pprotectedresourcesession: Param1) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdesc), pprotectedresourcesession.into_param().abi(), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
pub unsafe fn CreateVideoMotionVectorHeap<'a, Param1: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12ProtectedResourceSession>, T: ::windows::core::Interface>(&self, pdesc: *const D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC, pprotectedresourcesession: Param1) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdesc), pprotectedresourcesession.into_param().abi(), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn CreateVideoDecoder1<'a, Param1: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12ProtectedResourceSession>, T: ::windows::core::Interface>(&self, pdesc: *const D3D12_VIDEO_DECODER_DESC, pprotectedresourcesession: Param1) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdesc), pprotectedresourcesession.into_param().abi(), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
pub unsafe fn CreateVideoDecoderHeap1<'a, Param1: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12ProtectedResourceSession>, T: ::windows::core::Interface>(&self, pvideodecoderheapdesc: *const D3D12_VIDEO_DECODER_HEAP_DESC, pprotectedresourcesession: Param1) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(pvideodecoderheapdesc), pprotectedresourcesession.into_param().abi(), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
pub unsafe fn CreateVideoProcessor1<'a, Param4: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12ProtectedResourceSession>, T: ::windows::core::Interface>(&self, nodemask: u32, poutputstreamdesc: *const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC, numinputstreamdescs: u32, pinputstreamdescs: *const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC, pprotectedresourcesession: Param4) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).11)(
::core::mem::transmute_copy(self),
::core::mem::transmute(nodemask),
::core::mem::transmute(poutputstreamdesc),
::core::mem::transmute(numinputstreamdescs),
::core::mem::transmute(pinputstreamdescs),
pprotectedresourcesession.into_param().abi(),
&<T as ::windows::core::Interface>::IID,
&mut result__ as *mut _ as *mut _,
)
.and_some(result__)
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn CreateVideoExtensionCommand<'a, Param3: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12ProtectedResourceSession>, T: ::windows::core::Interface>(&self, pdesc: *const D3D12_VIDEO_EXTENSION_COMMAND_DESC, pcreationparameters: *const ::core::ffi::c_void, creationparametersdatasizeinbytes: usize, pprotectedresourcesession: Param3) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdesc), ::core::mem::transmute(pcreationparameters), ::core::mem::transmute(creationparametersdatasizeinbytes), pprotectedresourcesession.into_param().abi(), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
pub unsafe fn ExecuteExtensionCommand<'a, Param0: ::windows::core::IntoParam<'a, ID3D12VideoExtensionCommand>>(&self, pextensioncommand: Param0, pexecutionparameters: *const ::core::ffi::c_void, executionparameterssizeinbytes: usize, poutputdata: *mut ::core::ffi::c_void, outputdatasizeinbytes: usize) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), pextensioncommand.into_param().abi(), ::core::mem::transmute(pexecutionparameters), ::core::mem::transmute(executionparameterssizeinbytes), ::core::mem::transmute(poutputdata), ::core::mem::transmute(outputdatasizeinbytes)).ok()
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
pub unsafe fn CreateVideoEncoder<T: ::windows::core::Interface>(&self, pdesc: *const D3D12_VIDEO_ENCODER_DESC) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdesc), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
pub unsafe fn CreateVideoEncoderHeap<T: ::windows::core::Interface>(&self, pdesc: *const D3D12_VIDEO_ENCODER_HEAP_DESC) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdesc), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
}
unsafe impl ::windows::core::Interface for ID3D12VideoDevice3 {
type Vtable = ID3D12VideoDevice3_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4243adb4_3a32_4666_973c_0ccc5625dc44);
}
impl ::core::convert::From<ID3D12VideoDevice3> for ::windows::core::IUnknown {
fn from(value: ID3D12VideoDevice3) -> Self {
value.0
}
}
impl ::core::convert::From<&ID3D12VideoDevice3> for ::windows::core::IUnknown {
fn from(value: &ID3D12VideoDevice3) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ID3D12VideoDevice3 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ID3D12VideoDevice3 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ID3D12VideoDevice3> for ID3D12VideoDevice2 {
fn from(value: ID3D12VideoDevice3) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ID3D12VideoDevice3> for ID3D12VideoDevice2 {
fn from(value: &ID3D12VideoDevice3) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoDevice2> for ID3D12VideoDevice3 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoDevice2> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoDevice2> for &ID3D12VideoDevice3 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoDevice2> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<ID3D12VideoDevice3> for ID3D12VideoDevice1 {
fn from(value: ID3D12VideoDevice3) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ID3D12VideoDevice3> for ID3D12VideoDevice1 {
fn from(value: &ID3D12VideoDevice3) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoDevice1> for ID3D12VideoDevice3 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoDevice1> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoDevice1> for &ID3D12VideoDevice3 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoDevice1> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<ID3D12VideoDevice3> for ID3D12VideoDevice {
fn from(value: ID3D12VideoDevice3) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ID3D12VideoDevice3> for ID3D12VideoDevice {
fn from(value: &ID3D12VideoDevice3) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoDevice> for ID3D12VideoDevice3 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoDevice> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoDevice> for &ID3D12VideoDevice3 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoDevice> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ID3D12VideoDevice3_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, featurevideo: D3D12_FEATURE_VIDEO, pfeaturesupportdata: *mut ::core::ffi::c_void, featuresupportdatasize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdesc: *const D3D12_VIDEO_DECODER_DESC, riid: *const ::windows::core::GUID, ppvideodecoder: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Dxgi_Common")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pvideodecoderheapdesc: *const D3D12_VIDEO_DECODER_HEAP_DESC, riid: *const ::windows::core::GUID, ppvideodecoderheap: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Dxgi_Common"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, nodemask: u32, poutputstreamdesc: *const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC, numinputstreamdescs: u32, pinputstreamdescs: *const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC, riid: *const ::windows::core::GUID, ppvideoprocessor: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common")))] usize,
#[cfg(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdesc: *const D3D12_VIDEO_MOTION_ESTIMATOR_DESC, pprotectedresourcesession: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvideomotionestimator: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common")))] usize,
#[cfg(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdesc: *const D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC, pprotectedresourcesession: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvideomotionvectorheap: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common")))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdesc: *const D3D12_VIDEO_DECODER_DESC, pprotectedresourcesession: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvideodecoder: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pvideodecoderheapdesc: *const D3D12_VIDEO_DECODER_HEAP_DESC, pprotectedresourcesession: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvideodecoderheap: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, nodemask: u32, poutputstreamdesc: *const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC, numinputstreamdescs: u32, pinputstreamdescs: *const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC, pprotectedresourcesession: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvideoprocessor: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common")))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdesc: *const D3D12_VIDEO_EXTENSION_COMMAND_DESC, pcreationparameters: *const ::core::ffi::c_void, creationparametersdatasizeinbytes: usize, pprotectedresourcesession: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvideoextensioncommand: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pextensioncommand: ::windows::core::RawPtr, pexecutionparameters: *const ::core::ffi::c_void, executionparameterssizeinbytes: usize, poutputdata: *mut ::core::ffi::c_void, outputdatasizeinbytes: usize) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Dxgi_Common")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdesc: *const D3D12_VIDEO_ENCODER_DESC, riid: *const ::windows::core::GUID, ppvideoencoder: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Dxgi_Common"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdesc: *const D3D12_VIDEO_ENCODER_HEAP_DESC, riid: *const ::windows::core::GUID, ppvideoencoderheap: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ID3D12VideoEncodeCommandList(pub ::windows::core::IUnknown);
impl ID3D12VideoEncodeCommandList {
pub unsafe fn GetPrivateData(&self, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(pdatasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateData(&self, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(datasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guid: *const ::windows::core::GUID, pdata: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), pdata.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetName<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), name.into_param().abi()).ok()
}
pub unsafe fn GetDevice<T: ::windows::core::Interface>(&self, result__: *mut ::core::option::Option<T>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &<T as ::windows::core::Interface>::IID, result__ as *mut _ as *mut _).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn GetType(&self) -> super::super::Graphics::Direct3D12::D3D12_COMMAND_LIST_TYPE {
::core::mem::transmute((::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)))
}
pub unsafe fn Close(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn Reset<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12CommandAllocator>>(&self, pallocator: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), pallocator.into_param().abi()).ok()
}
pub unsafe fn ClearState(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn ResourceBarrier(&self, numbarriers: u32, pbarriers: *const super::super::Graphics::Direct3D12::D3D12_RESOURCE_BARRIER) {
::core::mem::transmute((::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(numbarriers), ::core::mem::transmute(pbarriers)))
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
pub unsafe fn DiscardResource<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Resource>>(&self, presource: Param0, pregion: *const super::super::Graphics::Direct3D12::D3D12_DISCARD_REGION) {
::core::mem::transmute((::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), presource.into_param().abi(), ::core::mem::transmute(pregion)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn BeginQuery<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12QueryHeap>>(&self, pqueryheap: Param0, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), pqueryheap.into_param().abi(), ::core::mem::transmute(r#type), ::core::mem::transmute(index)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn EndQuery<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12QueryHeap>>(&self, pqueryheap: Param0, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), pqueryheap.into_param().abi(), ::core::mem::transmute(r#type), ::core::mem::transmute(index)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn ResolveQueryData<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12QueryHeap>, Param4: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Resource>>(&self, pqueryheap: Param0, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, startindex: u32, numqueries: u32, pdestinationbuffer: Param4, aligneddestinationbufferoffset: u64) {
::core::mem::transmute((::windows::core::Interface::vtable(self).16)(
::core::mem::transmute_copy(self),
pqueryheap.into_param().abi(),
::core::mem::transmute(r#type),
::core::mem::transmute(startindex),
::core::mem::transmute(numqueries),
pdestinationbuffer.into_param().abi(),
::core::mem::transmute(aligneddestinationbufferoffset),
))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn SetPredication<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Resource>>(&self, pbuffer: Param0, alignedbufferoffset: u64, operation: super::super::Graphics::Direct3D12::D3D12_PREDICATION_OP) {
::core::mem::transmute((::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), pbuffer.into_param().abi(), ::core::mem::transmute(alignedbufferoffset), ::core::mem::transmute(operation)))
}
pub unsafe fn SetMarker(&self, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(metadata), ::core::mem::transmute(pdata), ::core::mem::transmute(size)))
}
pub unsafe fn BeginEvent(&self, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(metadata), ::core::mem::transmute(pdata), ::core::mem::transmute(size)))
}
pub unsafe fn EndEvent(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn EstimateMotion<'a, Param0: ::windows::core::IntoParam<'a, ID3D12VideoMotionEstimator>>(&self, pmotionestimator: Param0, poutputarguments: *const D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT, pinputarguments: *const D3D12_VIDEO_MOTION_ESTIMATOR_INPUT) {
::core::mem::transmute((::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), pmotionestimator.into_param().abi(), ::core::mem::transmute(poutputarguments), ::core::mem::transmute(pinputarguments)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn ResolveMotionVectorHeap(&self, poutputarguments: *const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT, pinputarguments: *const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT) {
::core::mem::transmute((::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(poutputarguments), ::core::mem::transmute(pinputarguments)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn WriteBufferImmediate(&self, count: u32, pparams: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_PARAMETER, pmodes: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_MODE) {
::core::mem::transmute((::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(pparams), ::core::mem::transmute(pmodes)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn SetProtectedResourceSession<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12ProtectedResourceSession>>(&self, pprotectedresourcesession: Param0) {
::core::mem::transmute((::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), pprotectedresourcesession.into_param().abi()))
}
}
unsafe impl ::windows::core::Interface for ID3D12VideoEncodeCommandList {
type Vtable = ID3D12VideoEncodeCommandList_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8455293a_0cbd_4831_9b39_fbdbab724723);
}
impl ::core::convert::From<ID3D12VideoEncodeCommandList> for ::windows::core::IUnknown {
fn from(value: ID3D12VideoEncodeCommandList) -> Self {
value.0
}
}
impl ::core::convert::From<&ID3D12VideoEncodeCommandList> for ::windows::core::IUnknown {
fn from(value: &ID3D12VideoEncodeCommandList) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ID3D12VideoEncodeCommandList {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ID3D12VideoEncodeCommandList {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoEncodeCommandList> for super::super::Graphics::Direct3D12::ID3D12CommandList {
fn from(value: ID3D12VideoEncodeCommandList) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoEncodeCommandList> for super::super::Graphics::Direct3D12::ID3D12CommandList {
fn from(value: &ID3D12VideoEncodeCommandList) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> for ID3D12VideoEncodeCommandList {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> for &ID3D12VideoEncodeCommandList {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoEncodeCommandList> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: ID3D12VideoEncodeCommandList) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoEncodeCommandList> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: &ID3D12VideoEncodeCommandList) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for ID3D12VideoEncodeCommandList {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for &ID3D12VideoEncodeCommandList {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoEncodeCommandList> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: ID3D12VideoEncodeCommandList) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoEncodeCommandList> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: &ID3D12VideoEncodeCommandList) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for ID3D12VideoEncodeCommandList {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for &ID3D12VideoEncodeCommandList {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ID3D12VideoEncodeCommandList_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdata: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvdevice: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Graphics::Direct3D12::D3D12_COMMAND_LIST_TYPE,
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pallocator: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, numbarriers: u32, pbarriers: *const ::core::mem::ManuallyDrop<super::super::Graphics::Direct3D12::D3D12_RESOURCE_BARRIER>),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presource: ::windows::core::RawPtr, pregion: *const super::super::Graphics::Direct3D12::D3D12_DISCARD_REGION),
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12")))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqueryheap: ::windows::core::RawPtr, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqueryheap: ::windows::core::RawPtr, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqueryheap: ::windows::core::RawPtr, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, startindex: u32, numqueries: u32, pdestinationbuffer: ::windows::core::RawPtr, aligneddestinationbufferoffset: u64),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbuffer: ::windows::core::RawPtr, alignedbufferoffset: u64, operation: super::super::Graphics::Direct3D12::D3D12_PREDICATION_OP),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pmotionestimator: ::windows::core::RawPtr, poutputarguments: *const ::core::mem::ManuallyDrop<D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT>, pinputarguments: *const ::core::mem::ManuallyDrop<D3D12_VIDEO_MOTION_ESTIMATOR_INPUT>),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, poutputarguments: *const ::core::mem::ManuallyDrop<D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT>, pinputarguments: *const ::core::mem::ManuallyDrop<D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT>),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, pparams: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_PARAMETER, pmodes: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_MODE),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pprotectedresourcesession: ::windows::core::RawPtr),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ID3D12VideoEncodeCommandList1(pub ::windows::core::IUnknown);
impl ID3D12VideoEncodeCommandList1 {
pub unsafe fn GetPrivateData(&self, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(pdatasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateData(&self, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(datasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guid: *const ::windows::core::GUID, pdata: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), pdata.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetName<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), name.into_param().abi()).ok()
}
pub unsafe fn GetDevice<T: ::windows::core::Interface>(&self, result__: *mut ::core::option::Option<T>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &<T as ::windows::core::Interface>::IID, result__ as *mut _ as *mut _).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn GetType(&self) -> super::super::Graphics::Direct3D12::D3D12_COMMAND_LIST_TYPE {
::core::mem::transmute((::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)))
}
pub unsafe fn Close(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn Reset<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12CommandAllocator>>(&self, pallocator: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), pallocator.into_param().abi()).ok()
}
pub unsafe fn ClearState(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn ResourceBarrier(&self, numbarriers: u32, pbarriers: *const super::super::Graphics::Direct3D12::D3D12_RESOURCE_BARRIER) {
::core::mem::transmute((::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(numbarriers), ::core::mem::transmute(pbarriers)))
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
pub unsafe fn DiscardResource<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Resource>>(&self, presource: Param0, pregion: *const super::super::Graphics::Direct3D12::D3D12_DISCARD_REGION) {
::core::mem::transmute((::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), presource.into_param().abi(), ::core::mem::transmute(pregion)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn BeginQuery<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12QueryHeap>>(&self, pqueryheap: Param0, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), pqueryheap.into_param().abi(), ::core::mem::transmute(r#type), ::core::mem::transmute(index)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn EndQuery<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12QueryHeap>>(&self, pqueryheap: Param0, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), pqueryheap.into_param().abi(), ::core::mem::transmute(r#type), ::core::mem::transmute(index)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn ResolveQueryData<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12QueryHeap>, Param4: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Resource>>(&self, pqueryheap: Param0, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, startindex: u32, numqueries: u32, pdestinationbuffer: Param4, aligneddestinationbufferoffset: u64) {
::core::mem::transmute((::windows::core::Interface::vtable(self).16)(
::core::mem::transmute_copy(self),
pqueryheap.into_param().abi(),
::core::mem::transmute(r#type),
::core::mem::transmute(startindex),
::core::mem::transmute(numqueries),
pdestinationbuffer.into_param().abi(),
::core::mem::transmute(aligneddestinationbufferoffset),
))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn SetPredication<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Resource>>(&self, pbuffer: Param0, alignedbufferoffset: u64, operation: super::super::Graphics::Direct3D12::D3D12_PREDICATION_OP) {
::core::mem::transmute((::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), pbuffer.into_param().abi(), ::core::mem::transmute(alignedbufferoffset), ::core::mem::transmute(operation)))
}
pub unsafe fn SetMarker(&self, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(metadata), ::core::mem::transmute(pdata), ::core::mem::transmute(size)))
}
pub unsafe fn BeginEvent(&self, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(metadata), ::core::mem::transmute(pdata), ::core::mem::transmute(size)))
}
pub unsafe fn EndEvent(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn EstimateMotion<'a, Param0: ::windows::core::IntoParam<'a, ID3D12VideoMotionEstimator>>(&self, pmotionestimator: Param0, poutputarguments: *const D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT, pinputarguments: *const D3D12_VIDEO_MOTION_ESTIMATOR_INPUT) {
::core::mem::transmute((::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), pmotionestimator.into_param().abi(), ::core::mem::transmute(poutputarguments), ::core::mem::transmute(pinputarguments)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn ResolveMotionVectorHeap(&self, poutputarguments: *const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT, pinputarguments: *const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT) {
::core::mem::transmute((::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(poutputarguments), ::core::mem::transmute(pinputarguments)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn WriteBufferImmediate(&self, count: u32, pparams: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_PARAMETER, pmodes: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_MODE) {
::core::mem::transmute((::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(pparams), ::core::mem::transmute(pmodes)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn SetProtectedResourceSession<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12ProtectedResourceSession>>(&self, pprotectedresourcesession: Param0) {
::core::mem::transmute((::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), pprotectedresourcesession.into_param().abi()))
}
pub unsafe fn InitializeExtensionCommand<'a, Param0: ::windows::core::IntoParam<'a, ID3D12VideoExtensionCommand>>(&self, pextensioncommand: Param0, pinitializationparameters: *const ::core::ffi::c_void, initializationparameterssizeinbytes: usize) {
::core::mem::transmute((::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), pextensioncommand.into_param().abi(), ::core::mem::transmute(pinitializationparameters), ::core::mem::transmute(initializationparameterssizeinbytes)))
}
pub unsafe fn ExecuteExtensionCommand<'a, Param0: ::windows::core::IntoParam<'a, ID3D12VideoExtensionCommand>>(&self, pextensioncommand: Param0, pexecutionparameters: *const ::core::ffi::c_void, executionparameterssizeinbytes: usize) {
::core::mem::transmute((::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), pextensioncommand.into_param().abi(), ::core::mem::transmute(pexecutionparameters), ::core::mem::transmute(executionparameterssizeinbytes)))
}
}
unsafe impl ::windows::core::Interface for ID3D12VideoEncodeCommandList1 {
type Vtable = ID3D12VideoEncodeCommandList1_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x94971eca_2bdb_4769_88cf_3675ea757ebc);
}
impl ::core::convert::From<ID3D12VideoEncodeCommandList1> for ::windows::core::IUnknown {
fn from(value: ID3D12VideoEncodeCommandList1) -> Self {
value.0
}
}
impl ::core::convert::From<&ID3D12VideoEncodeCommandList1> for ::windows::core::IUnknown {
fn from(value: &ID3D12VideoEncodeCommandList1) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ID3D12VideoEncodeCommandList1 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ID3D12VideoEncodeCommandList1 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ID3D12VideoEncodeCommandList1> for ID3D12VideoEncodeCommandList {
fn from(value: ID3D12VideoEncodeCommandList1) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ID3D12VideoEncodeCommandList1> for ID3D12VideoEncodeCommandList {
fn from(value: &ID3D12VideoEncodeCommandList1) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoEncodeCommandList> for ID3D12VideoEncodeCommandList1 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoEncodeCommandList> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoEncodeCommandList> for &ID3D12VideoEncodeCommandList1 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoEncodeCommandList> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoEncodeCommandList1> for super::super::Graphics::Direct3D12::ID3D12CommandList {
fn from(value: ID3D12VideoEncodeCommandList1) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoEncodeCommandList1> for super::super::Graphics::Direct3D12::ID3D12CommandList {
fn from(value: &ID3D12VideoEncodeCommandList1) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> for ID3D12VideoEncodeCommandList1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> for &ID3D12VideoEncodeCommandList1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoEncodeCommandList1> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: ID3D12VideoEncodeCommandList1) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoEncodeCommandList1> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: &ID3D12VideoEncodeCommandList1) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for ID3D12VideoEncodeCommandList1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for &ID3D12VideoEncodeCommandList1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoEncodeCommandList1> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: ID3D12VideoEncodeCommandList1) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoEncodeCommandList1> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: &ID3D12VideoEncodeCommandList1) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for ID3D12VideoEncodeCommandList1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for &ID3D12VideoEncodeCommandList1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ID3D12VideoEncodeCommandList1_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdata: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvdevice: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Graphics::Direct3D12::D3D12_COMMAND_LIST_TYPE,
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pallocator: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, numbarriers: u32, pbarriers: *const ::core::mem::ManuallyDrop<super::super::Graphics::Direct3D12::D3D12_RESOURCE_BARRIER>),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presource: ::windows::core::RawPtr, pregion: *const super::super::Graphics::Direct3D12::D3D12_DISCARD_REGION),
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12")))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqueryheap: ::windows::core::RawPtr, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqueryheap: ::windows::core::RawPtr, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqueryheap: ::windows::core::RawPtr, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, startindex: u32, numqueries: u32, pdestinationbuffer: ::windows::core::RawPtr, aligneddestinationbufferoffset: u64),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbuffer: ::windows::core::RawPtr, alignedbufferoffset: u64, operation: super::super::Graphics::Direct3D12::D3D12_PREDICATION_OP),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pmotionestimator: ::windows::core::RawPtr, poutputarguments: *const ::core::mem::ManuallyDrop<D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT>, pinputarguments: *const ::core::mem::ManuallyDrop<D3D12_VIDEO_MOTION_ESTIMATOR_INPUT>),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, poutputarguments: *const ::core::mem::ManuallyDrop<D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT>, pinputarguments: *const ::core::mem::ManuallyDrop<D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT>),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, pparams: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_PARAMETER, pmodes: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_MODE),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pprotectedresourcesession: ::windows::core::RawPtr),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pextensioncommand: ::windows::core::RawPtr, pinitializationparameters: *const ::core::ffi::c_void, initializationparameterssizeinbytes: usize),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pextensioncommand: ::windows::core::RawPtr, pexecutionparameters: *const ::core::ffi::c_void, executionparameterssizeinbytes: usize),
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ID3D12VideoEncodeCommandList2(pub ::windows::core::IUnknown);
impl ID3D12VideoEncodeCommandList2 {
pub unsafe fn GetPrivateData(&self, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(pdatasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateData(&self, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(datasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guid: *const ::windows::core::GUID, pdata: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), pdata.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetName<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), name.into_param().abi()).ok()
}
pub unsafe fn GetDevice<T: ::windows::core::Interface>(&self, result__: *mut ::core::option::Option<T>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &<T as ::windows::core::Interface>::IID, result__ as *mut _ as *mut _).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn GetType(&self) -> super::super::Graphics::Direct3D12::D3D12_COMMAND_LIST_TYPE {
::core::mem::transmute((::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)))
}
pub unsafe fn Close(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn Reset<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12CommandAllocator>>(&self, pallocator: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), pallocator.into_param().abi()).ok()
}
pub unsafe fn ClearState(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn ResourceBarrier(&self, numbarriers: u32, pbarriers: *const super::super::Graphics::Direct3D12::D3D12_RESOURCE_BARRIER) {
::core::mem::transmute((::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(numbarriers), ::core::mem::transmute(pbarriers)))
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
pub unsafe fn DiscardResource<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Resource>>(&self, presource: Param0, pregion: *const super::super::Graphics::Direct3D12::D3D12_DISCARD_REGION) {
::core::mem::transmute((::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), presource.into_param().abi(), ::core::mem::transmute(pregion)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn BeginQuery<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12QueryHeap>>(&self, pqueryheap: Param0, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), pqueryheap.into_param().abi(), ::core::mem::transmute(r#type), ::core::mem::transmute(index)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn EndQuery<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12QueryHeap>>(&self, pqueryheap: Param0, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), pqueryheap.into_param().abi(), ::core::mem::transmute(r#type), ::core::mem::transmute(index)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn ResolveQueryData<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12QueryHeap>, Param4: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Resource>>(&self, pqueryheap: Param0, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, startindex: u32, numqueries: u32, pdestinationbuffer: Param4, aligneddestinationbufferoffset: u64) {
::core::mem::transmute((::windows::core::Interface::vtable(self).16)(
::core::mem::transmute_copy(self),
pqueryheap.into_param().abi(),
::core::mem::transmute(r#type),
::core::mem::transmute(startindex),
::core::mem::transmute(numqueries),
pdestinationbuffer.into_param().abi(),
::core::mem::transmute(aligneddestinationbufferoffset),
))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn SetPredication<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Resource>>(&self, pbuffer: Param0, alignedbufferoffset: u64, operation: super::super::Graphics::Direct3D12::D3D12_PREDICATION_OP) {
::core::mem::transmute((::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), pbuffer.into_param().abi(), ::core::mem::transmute(alignedbufferoffset), ::core::mem::transmute(operation)))
}
pub unsafe fn SetMarker(&self, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(metadata), ::core::mem::transmute(pdata), ::core::mem::transmute(size)))
}
pub unsafe fn BeginEvent(&self, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(metadata), ::core::mem::transmute(pdata), ::core::mem::transmute(size)))
}
pub unsafe fn EndEvent(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn EstimateMotion<'a, Param0: ::windows::core::IntoParam<'a, ID3D12VideoMotionEstimator>>(&self, pmotionestimator: Param0, poutputarguments: *const D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT, pinputarguments: *const D3D12_VIDEO_MOTION_ESTIMATOR_INPUT) {
::core::mem::transmute((::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), pmotionestimator.into_param().abi(), ::core::mem::transmute(poutputarguments), ::core::mem::transmute(pinputarguments)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn ResolveMotionVectorHeap(&self, poutputarguments: *const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT, pinputarguments: *const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT) {
::core::mem::transmute((::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(poutputarguments), ::core::mem::transmute(pinputarguments)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn WriteBufferImmediate(&self, count: u32, pparams: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_PARAMETER, pmodes: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_MODE) {
::core::mem::transmute((::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(pparams), ::core::mem::transmute(pmodes)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn SetProtectedResourceSession<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12ProtectedResourceSession>>(&self, pprotectedresourcesession: Param0) {
::core::mem::transmute((::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), pprotectedresourcesession.into_param().abi()))
}
pub unsafe fn InitializeExtensionCommand<'a, Param0: ::windows::core::IntoParam<'a, ID3D12VideoExtensionCommand>>(&self, pextensioncommand: Param0, pinitializationparameters: *const ::core::ffi::c_void, initializationparameterssizeinbytes: usize) {
::core::mem::transmute((::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), pextensioncommand.into_param().abi(), ::core::mem::transmute(pinitializationparameters), ::core::mem::transmute(initializationparameterssizeinbytes)))
}
pub unsafe fn ExecuteExtensionCommand<'a, Param0: ::windows::core::IntoParam<'a, ID3D12VideoExtensionCommand>>(&self, pextensioncommand: Param0, pexecutionparameters: *const ::core::ffi::c_void, executionparameterssizeinbytes: usize) {
::core::mem::transmute((::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), pextensioncommand.into_param().abi(), ::core::mem::transmute(pexecutionparameters), ::core::mem::transmute(executionparameterssizeinbytes)))
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
pub unsafe fn EncodeFrame<'a, Param0: ::windows::core::IntoParam<'a, ID3D12VideoEncoder>, Param1: ::windows::core::IntoParam<'a, ID3D12VideoEncoderHeap>>(&self, pencoder: Param0, pheap: Param1, pinputarguments: *const D3D12_VIDEO_ENCODER_ENCODEFRAME_INPUT_ARGUMENTS, poutputarguments: *const D3D12_VIDEO_ENCODER_ENCODEFRAME_OUTPUT_ARGUMENTS) {
::core::mem::transmute((::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), pencoder.into_param().abi(), pheap.into_param().abi(), ::core::mem::transmute(pinputarguments), ::core::mem::transmute(poutputarguments)))
}
#[cfg(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))]
pub unsafe fn ResolveEncoderOutputMetadata(&self, pinputarguments: *const D3D12_VIDEO_ENCODER_RESOLVE_METADATA_INPUT_ARGUMENTS, poutputarguments: *const D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_ARGUMENTS) {
::core::mem::transmute((::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(pinputarguments), ::core::mem::transmute(poutputarguments)))
}
}
unsafe impl ::windows::core::Interface for ID3D12VideoEncodeCommandList2 {
type Vtable = ID3D12VideoEncodeCommandList2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x895491e2_e701_46a9_9a1f_8d3480ed867a);
}
impl ::core::convert::From<ID3D12VideoEncodeCommandList2> for ::windows::core::IUnknown {
fn from(value: ID3D12VideoEncodeCommandList2) -> Self {
value.0
}
}
impl ::core::convert::From<&ID3D12VideoEncodeCommandList2> for ::windows::core::IUnknown {
fn from(value: &ID3D12VideoEncodeCommandList2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ID3D12VideoEncodeCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ID3D12VideoEncodeCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ID3D12VideoEncodeCommandList2> for ID3D12VideoEncodeCommandList1 {
fn from(value: ID3D12VideoEncodeCommandList2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ID3D12VideoEncodeCommandList2> for ID3D12VideoEncodeCommandList1 {
fn from(value: &ID3D12VideoEncodeCommandList2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoEncodeCommandList1> for ID3D12VideoEncodeCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoEncodeCommandList1> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoEncodeCommandList1> for &ID3D12VideoEncodeCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoEncodeCommandList1> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<ID3D12VideoEncodeCommandList2> for ID3D12VideoEncodeCommandList {
fn from(value: ID3D12VideoEncodeCommandList2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ID3D12VideoEncodeCommandList2> for ID3D12VideoEncodeCommandList {
fn from(value: &ID3D12VideoEncodeCommandList2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoEncodeCommandList> for ID3D12VideoEncodeCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoEncodeCommandList> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoEncodeCommandList> for &ID3D12VideoEncodeCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoEncodeCommandList> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoEncodeCommandList2> for super::super::Graphics::Direct3D12::ID3D12CommandList {
fn from(value: ID3D12VideoEncodeCommandList2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoEncodeCommandList2> for super::super::Graphics::Direct3D12::ID3D12CommandList {
fn from(value: &ID3D12VideoEncodeCommandList2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> for ID3D12VideoEncodeCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> for &ID3D12VideoEncodeCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoEncodeCommandList2> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: ID3D12VideoEncodeCommandList2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoEncodeCommandList2> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: &ID3D12VideoEncodeCommandList2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for ID3D12VideoEncodeCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for &ID3D12VideoEncodeCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoEncodeCommandList2> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: ID3D12VideoEncodeCommandList2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoEncodeCommandList2> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: &ID3D12VideoEncodeCommandList2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for ID3D12VideoEncodeCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for &ID3D12VideoEncodeCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ID3D12VideoEncodeCommandList2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdata: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvdevice: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Graphics::Direct3D12::D3D12_COMMAND_LIST_TYPE,
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pallocator: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, numbarriers: u32, pbarriers: *const ::core::mem::ManuallyDrop<super::super::Graphics::Direct3D12::D3D12_RESOURCE_BARRIER>),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presource: ::windows::core::RawPtr, pregion: *const super::super::Graphics::Direct3D12::D3D12_DISCARD_REGION),
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12")))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqueryheap: ::windows::core::RawPtr, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqueryheap: ::windows::core::RawPtr, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqueryheap: ::windows::core::RawPtr, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, startindex: u32, numqueries: u32, pdestinationbuffer: ::windows::core::RawPtr, aligneddestinationbufferoffset: u64),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbuffer: ::windows::core::RawPtr, alignedbufferoffset: u64, operation: super::super::Graphics::Direct3D12::D3D12_PREDICATION_OP),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pmotionestimator: ::windows::core::RawPtr, poutputarguments: *const ::core::mem::ManuallyDrop<D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT>, pinputarguments: *const ::core::mem::ManuallyDrop<D3D12_VIDEO_MOTION_ESTIMATOR_INPUT>),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, poutputarguments: *const ::core::mem::ManuallyDrop<D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT>, pinputarguments: *const ::core::mem::ManuallyDrop<D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT>),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, pparams: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_PARAMETER, pmodes: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_MODE),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pprotectedresourcesession: ::windows::core::RawPtr),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pextensioncommand: ::windows::core::RawPtr, pinitializationparameters: *const ::core::ffi::c_void, initializationparameterssizeinbytes: usize),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pextensioncommand: ::windows::core::RawPtr, pexecutionparameters: *const ::core::ffi::c_void, executionparameterssizeinbytes: usize),
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pencoder: ::windows::core::RawPtr, pheap: ::windows::core::RawPtr, pinputarguments: *const ::core::mem::ManuallyDrop<D3D12_VIDEO_ENCODER_ENCODEFRAME_INPUT_ARGUMENTS>, poutputarguments: *const ::core::mem::ManuallyDrop<D3D12_VIDEO_ENCODER_ENCODEFRAME_OUTPUT_ARGUMENTS>),
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common")))] usize,
#[cfg(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pinputarguments: *const ::core::mem::ManuallyDrop<D3D12_VIDEO_ENCODER_RESOLVE_METADATA_INPUT_ARGUMENTS>, poutputarguments: *const ::core::mem::ManuallyDrop<D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_ARGUMENTS>),
#[cfg(not(all(feature = "Win32_Graphics_Direct3D12", feature = "Win32_Graphics_Dxgi_Common")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ID3D12VideoEncoder(pub ::windows::core::IUnknown);
impl ID3D12VideoEncoder {
pub unsafe fn GetPrivateData(&self, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(pdatasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateData(&self, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(datasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guid: *const ::windows::core::GUID, pdata: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), pdata.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetName<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), name.into_param().abi()).ok()
}
pub unsafe fn GetDevice<T: ::windows::core::Interface>(&self, result__: *mut ::core::option::Option<T>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &<T as ::windows::core::Interface>::IID, result__ as *mut _ as *mut _).ok()
}
pub unsafe fn GetNodeMask(&self) -> u32 {
::core::mem::transmute((::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetEncoderFlags(&self) -> D3D12_VIDEO_ENCODER_FLAGS {
::core::mem::transmute((::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetCodec(&self) -> D3D12_VIDEO_ENCODER_CODEC {
::core::mem::transmute((::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetCodecProfile(&self, dstprofile: D3D12_VIDEO_ENCODER_PROFILE_DESC) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(dstprofile)).ok()
}
pub unsafe fn GetCodecConfiguration(&self, dstcodecconfig: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(dstcodecconfig)).ok()
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
pub unsafe fn GetInputFormat(&self) -> super::super::Graphics::Dxgi::Common::DXGI_FORMAT {
::core::mem::transmute((::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetMaxMotionEstimationPrecision(&self) -> D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE {
::core::mem::transmute((::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self)))
}
}
unsafe impl ::windows::core::Interface for ID3D12VideoEncoder {
type Vtable = ID3D12VideoEncoder_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2e0d212d_8df9_44a6_a770_bb289b182737);
}
impl ::core::convert::From<ID3D12VideoEncoder> for ::windows::core::IUnknown {
fn from(value: ID3D12VideoEncoder) -> Self {
value.0
}
}
impl ::core::convert::From<&ID3D12VideoEncoder> for ::windows::core::IUnknown {
fn from(value: &ID3D12VideoEncoder) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ID3D12VideoEncoder {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ID3D12VideoEncoder {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoEncoder> for super::super::Graphics::Direct3D12::ID3D12Pageable {
fn from(value: ID3D12VideoEncoder) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoEncoder> for super::super::Graphics::Direct3D12::ID3D12Pageable {
fn from(value: &ID3D12VideoEncoder) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> for ID3D12VideoEncoder {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> for &ID3D12VideoEncoder {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoEncoder> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: ID3D12VideoEncoder) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoEncoder> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: &ID3D12VideoEncoder) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for ID3D12VideoEncoder {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for &ID3D12VideoEncoder {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoEncoder> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: ID3D12VideoEncoder) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoEncoder> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: &ID3D12VideoEncoder) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for ID3D12VideoEncoder {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for &ID3D12VideoEncoder {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ID3D12VideoEncoder_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdata: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvdevice: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> D3D12_VIDEO_ENCODER_FLAGS,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> D3D12_VIDEO_ENCODER_CODEC,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dstprofile: D3D12_VIDEO_ENCODER_PROFILE_DESC) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dstcodecconfig: D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Dxgi_Common")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Graphics::Dxgi::Common::DXGI_FORMAT,
#[cfg(not(feature = "Win32_Graphics_Dxgi_Common"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ID3D12VideoEncoderHeap(pub ::windows::core::IUnknown);
impl ID3D12VideoEncoderHeap {
pub unsafe fn GetPrivateData(&self, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(pdatasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateData(&self, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(datasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guid: *const ::windows::core::GUID, pdata: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), pdata.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetName<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), name.into_param().abi()).ok()
}
pub unsafe fn GetDevice<T: ::windows::core::Interface>(&self, result__: *mut ::core::option::Option<T>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &<T as ::windows::core::Interface>::IID, result__ as *mut _ as *mut _).ok()
}
pub unsafe fn GetNodeMask(&self) -> u32 {
::core::mem::transmute((::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetEncoderHeapFlags(&self) -> D3D12_VIDEO_ENCODER_HEAP_FLAGS {
::core::mem::transmute((::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetCodec(&self) -> D3D12_VIDEO_ENCODER_CODEC {
::core::mem::transmute((::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetCodecProfile(&self, dstprofile: D3D12_VIDEO_ENCODER_PROFILE_DESC) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(dstprofile)).ok()
}
pub unsafe fn GetCodecLevel(&self, dstlevel: D3D12_VIDEO_ENCODER_LEVEL_SETTING) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(dstlevel)).ok()
}
pub unsafe fn GetResolutionListCount(&self) -> u32 {
::core::mem::transmute((::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetResolutionList(&self, resolutionslistcount: u32, presolutionlist: *mut D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(resolutionslistcount), ::core::mem::transmute(presolutionlist)).ok()
}
}
unsafe impl ::windows::core::Interface for ID3D12VideoEncoderHeap {
type Vtable = ID3D12VideoEncoderHeap_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x22b35d96_876a_44c0_b25e_fb8c9c7f1c4a);
}
impl ::core::convert::From<ID3D12VideoEncoderHeap> for ::windows::core::IUnknown {
fn from(value: ID3D12VideoEncoderHeap) -> Self {
value.0
}
}
impl ::core::convert::From<&ID3D12VideoEncoderHeap> for ::windows::core::IUnknown {
fn from(value: &ID3D12VideoEncoderHeap) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ID3D12VideoEncoderHeap {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ID3D12VideoEncoderHeap {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoEncoderHeap> for super::super::Graphics::Direct3D12::ID3D12Pageable {
fn from(value: ID3D12VideoEncoderHeap) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoEncoderHeap> for super::super::Graphics::Direct3D12::ID3D12Pageable {
fn from(value: &ID3D12VideoEncoderHeap) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> for ID3D12VideoEncoderHeap {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> for &ID3D12VideoEncoderHeap {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoEncoderHeap> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: ID3D12VideoEncoderHeap) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoEncoderHeap> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: &ID3D12VideoEncoderHeap) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for ID3D12VideoEncoderHeap {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for &ID3D12VideoEncoderHeap {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoEncoderHeap> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: ID3D12VideoEncoderHeap) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoEncoderHeap> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: &ID3D12VideoEncoderHeap) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for ID3D12VideoEncoderHeap {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for &ID3D12VideoEncoderHeap {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ID3D12VideoEncoderHeap_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdata: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvdevice: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> D3D12_VIDEO_ENCODER_HEAP_FLAGS,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> D3D12_VIDEO_ENCODER_CODEC,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dstprofile: D3D12_VIDEO_ENCODER_PROFILE_DESC) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dstlevel: D3D12_VIDEO_ENCODER_LEVEL_SETTING) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, resolutionslistcount: u32, presolutionlist: *mut D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ID3D12VideoExtensionCommand(pub ::windows::core::IUnknown);
impl ID3D12VideoExtensionCommand {
pub unsafe fn GetPrivateData(&self, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(pdatasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateData(&self, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(datasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guid: *const ::windows::core::GUID, pdata: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), pdata.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetName<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), name.into_param().abi()).ok()
}
pub unsafe fn GetDevice<T: ::windows::core::Interface>(&self, result__: *mut ::core::option::Option<T>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &<T as ::windows::core::Interface>::IID, result__ as *mut _ as *mut _).ok()
}
pub unsafe fn GetDesc(&self) -> D3D12_VIDEO_EXTENSION_COMMAND_DESC {
let mut result__: D3D12_VIDEO_EXTENSION_COMMAND_DESC = ::core::default::Default::default();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__);
result__
}
pub unsafe fn GetProtectedResourceSession<T: ::windows::core::Interface>(&self, result__: *mut ::core::option::Option<T>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &<T as ::windows::core::Interface>::IID, result__ as *mut _ as *mut _).ok()
}
}
unsafe impl ::windows::core::Interface for ID3D12VideoExtensionCommand {
type Vtable = ID3D12VideoExtensionCommand_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x554e41e8_ae8e_4a8c_b7d2_5b4f274a30e4);
}
impl ::core::convert::From<ID3D12VideoExtensionCommand> for ::windows::core::IUnknown {
fn from(value: ID3D12VideoExtensionCommand) -> Self {
value.0
}
}
impl ::core::convert::From<&ID3D12VideoExtensionCommand> for ::windows::core::IUnknown {
fn from(value: &ID3D12VideoExtensionCommand) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ID3D12VideoExtensionCommand {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ID3D12VideoExtensionCommand {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoExtensionCommand> for super::super::Graphics::Direct3D12::ID3D12Pageable {
fn from(value: ID3D12VideoExtensionCommand) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoExtensionCommand> for super::super::Graphics::Direct3D12::ID3D12Pageable {
fn from(value: &ID3D12VideoExtensionCommand) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> for ID3D12VideoExtensionCommand {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> for &ID3D12VideoExtensionCommand {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoExtensionCommand> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: ID3D12VideoExtensionCommand) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoExtensionCommand> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: &ID3D12VideoExtensionCommand) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for ID3D12VideoExtensionCommand {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for &ID3D12VideoExtensionCommand {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoExtensionCommand> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: ID3D12VideoExtensionCommand) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoExtensionCommand> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: &ID3D12VideoExtensionCommand) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for ID3D12VideoExtensionCommand {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for &ID3D12VideoExtensionCommand {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ID3D12VideoExtensionCommand_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdata: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvdevice: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, result__: *mut D3D12_VIDEO_EXTENSION_COMMAND_DESC),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppprotectedsession: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ID3D12VideoMotionEstimator(pub ::windows::core::IUnknown);
impl ID3D12VideoMotionEstimator {
pub unsafe fn GetPrivateData(&self, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(pdatasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateData(&self, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(datasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guid: *const ::windows::core::GUID, pdata: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), pdata.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetName<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), name.into_param().abi()).ok()
}
pub unsafe fn GetDevice<T: ::windows::core::Interface>(&self, result__: *mut ::core::option::Option<T>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &<T as ::windows::core::Interface>::IID, result__ as *mut _ as *mut _).ok()
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
pub unsafe fn GetDesc(&self) -> D3D12_VIDEO_MOTION_ESTIMATOR_DESC {
let mut result__: D3D12_VIDEO_MOTION_ESTIMATOR_DESC = ::core::default::Default::default();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__);
result__
}
pub unsafe fn GetProtectedResourceSession<T: ::windows::core::Interface>(&self, result__: *mut ::core::option::Option<T>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &<T as ::windows::core::Interface>::IID, result__ as *mut _ as *mut _).ok()
}
}
unsafe impl ::windows::core::Interface for ID3D12VideoMotionEstimator {
type Vtable = ID3D12VideoMotionEstimator_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x33fdae0e_098b_428f_87bb_34b695de08f8);
}
impl ::core::convert::From<ID3D12VideoMotionEstimator> for ::windows::core::IUnknown {
fn from(value: ID3D12VideoMotionEstimator) -> Self {
value.0
}
}
impl ::core::convert::From<&ID3D12VideoMotionEstimator> for ::windows::core::IUnknown {
fn from(value: &ID3D12VideoMotionEstimator) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ID3D12VideoMotionEstimator {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ID3D12VideoMotionEstimator {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoMotionEstimator> for super::super::Graphics::Direct3D12::ID3D12Pageable {
fn from(value: ID3D12VideoMotionEstimator) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoMotionEstimator> for super::super::Graphics::Direct3D12::ID3D12Pageable {
fn from(value: &ID3D12VideoMotionEstimator) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> for ID3D12VideoMotionEstimator {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> for &ID3D12VideoMotionEstimator {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoMotionEstimator> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: ID3D12VideoMotionEstimator) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoMotionEstimator> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: &ID3D12VideoMotionEstimator) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for ID3D12VideoMotionEstimator {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for &ID3D12VideoMotionEstimator {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoMotionEstimator> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: ID3D12VideoMotionEstimator) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoMotionEstimator> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: &ID3D12VideoMotionEstimator) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for ID3D12VideoMotionEstimator {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for &ID3D12VideoMotionEstimator {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ID3D12VideoMotionEstimator_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdata: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvdevice: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Dxgi_Common")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, result__: *mut D3D12_VIDEO_MOTION_ESTIMATOR_DESC),
#[cfg(not(feature = "Win32_Graphics_Dxgi_Common"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppprotectedsession: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ID3D12VideoMotionVectorHeap(pub ::windows::core::IUnknown);
impl ID3D12VideoMotionVectorHeap {
pub unsafe fn GetPrivateData(&self, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(pdatasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateData(&self, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(datasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guid: *const ::windows::core::GUID, pdata: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), pdata.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetName<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), name.into_param().abi()).ok()
}
pub unsafe fn GetDevice<T: ::windows::core::Interface>(&self, result__: *mut ::core::option::Option<T>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &<T as ::windows::core::Interface>::IID, result__ as *mut _ as *mut _).ok()
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
pub unsafe fn GetDesc(&self) -> D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC {
let mut result__: D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC = ::core::default::Default::default();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__);
result__
}
pub unsafe fn GetProtectedResourceSession<T: ::windows::core::Interface>(&self, result__: *mut ::core::option::Option<T>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &<T as ::windows::core::Interface>::IID, result__ as *mut _ as *mut _).ok()
}
}
unsafe impl ::windows::core::Interface for ID3D12VideoMotionVectorHeap {
type Vtable = ID3D12VideoMotionVectorHeap_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5be17987_743a_4061_834b_23d22daea505);
}
impl ::core::convert::From<ID3D12VideoMotionVectorHeap> for ::windows::core::IUnknown {
fn from(value: ID3D12VideoMotionVectorHeap) -> Self {
value.0
}
}
impl ::core::convert::From<&ID3D12VideoMotionVectorHeap> for ::windows::core::IUnknown {
fn from(value: &ID3D12VideoMotionVectorHeap) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ID3D12VideoMotionVectorHeap {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ID3D12VideoMotionVectorHeap {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoMotionVectorHeap> for super::super::Graphics::Direct3D12::ID3D12Pageable {
fn from(value: ID3D12VideoMotionVectorHeap) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoMotionVectorHeap> for super::super::Graphics::Direct3D12::ID3D12Pageable {
fn from(value: &ID3D12VideoMotionVectorHeap) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> for ID3D12VideoMotionVectorHeap {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> for &ID3D12VideoMotionVectorHeap {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoMotionVectorHeap> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: ID3D12VideoMotionVectorHeap) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoMotionVectorHeap> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: &ID3D12VideoMotionVectorHeap) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for ID3D12VideoMotionVectorHeap {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for &ID3D12VideoMotionVectorHeap {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoMotionVectorHeap> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: ID3D12VideoMotionVectorHeap) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoMotionVectorHeap> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: &ID3D12VideoMotionVectorHeap) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for ID3D12VideoMotionVectorHeap {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for &ID3D12VideoMotionVectorHeap {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ID3D12VideoMotionVectorHeap_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdata: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvdevice: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Dxgi_Common")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, result__: *mut D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC),
#[cfg(not(feature = "Win32_Graphics_Dxgi_Common"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppprotectedsession: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ID3D12VideoProcessCommandList(pub ::windows::core::IUnknown);
impl ID3D12VideoProcessCommandList {
pub unsafe fn GetPrivateData(&self, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(pdatasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateData(&self, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(datasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guid: *const ::windows::core::GUID, pdata: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), pdata.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetName<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), name.into_param().abi()).ok()
}
pub unsafe fn GetDevice<T: ::windows::core::Interface>(&self, result__: *mut ::core::option::Option<T>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &<T as ::windows::core::Interface>::IID, result__ as *mut _ as *mut _).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn GetType(&self) -> super::super::Graphics::Direct3D12::D3D12_COMMAND_LIST_TYPE {
::core::mem::transmute((::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)))
}
pub unsafe fn Close(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn Reset<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12CommandAllocator>>(&self, pallocator: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), pallocator.into_param().abi()).ok()
}
pub unsafe fn ClearState(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn ResourceBarrier(&self, numbarriers: u32, pbarriers: *const super::super::Graphics::Direct3D12::D3D12_RESOURCE_BARRIER) {
::core::mem::transmute((::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(numbarriers), ::core::mem::transmute(pbarriers)))
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
pub unsafe fn DiscardResource<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Resource>>(&self, presource: Param0, pregion: *const super::super::Graphics::Direct3D12::D3D12_DISCARD_REGION) {
::core::mem::transmute((::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), presource.into_param().abi(), ::core::mem::transmute(pregion)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn BeginQuery<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12QueryHeap>>(&self, pqueryheap: Param0, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), pqueryheap.into_param().abi(), ::core::mem::transmute(r#type), ::core::mem::transmute(index)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn EndQuery<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12QueryHeap>>(&self, pqueryheap: Param0, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), pqueryheap.into_param().abi(), ::core::mem::transmute(r#type), ::core::mem::transmute(index)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn ResolveQueryData<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12QueryHeap>, Param4: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Resource>>(&self, pqueryheap: Param0, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, startindex: u32, numqueries: u32, pdestinationbuffer: Param4, aligneddestinationbufferoffset: u64) {
::core::mem::transmute((::windows::core::Interface::vtable(self).16)(
::core::mem::transmute_copy(self),
pqueryheap.into_param().abi(),
::core::mem::transmute(r#type),
::core::mem::transmute(startindex),
::core::mem::transmute(numqueries),
pdestinationbuffer.into_param().abi(),
::core::mem::transmute(aligneddestinationbufferoffset),
))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn SetPredication<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Resource>>(&self, pbuffer: Param0, alignedbufferoffset: u64, operation: super::super::Graphics::Direct3D12::D3D12_PREDICATION_OP) {
::core::mem::transmute((::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), pbuffer.into_param().abi(), ::core::mem::transmute(alignedbufferoffset), ::core::mem::transmute(operation)))
}
pub unsafe fn SetMarker(&self, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(metadata), ::core::mem::transmute(pdata), ::core::mem::transmute(size)))
}
pub unsafe fn BeginEvent(&self, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(metadata), ::core::mem::transmute(pdata), ::core::mem::transmute(size)))
}
pub unsafe fn EndEvent(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)))
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
pub unsafe fn ProcessFrames<'a, Param0: ::windows::core::IntoParam<'a, ID3D12VideoProcessor>>(&self, pvideoprocessor: Param0, poutputarguments: *const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS, numinputstreams: u32, pinputarguments: *const D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS) {
::core::mem::transmute((::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), pvideoprocessor.into_param().abi(), ::core::mem::transmute(poutputarguments), ::core::mem::transmute(numinputstreams), ::core::mem::transmute(pinputarguments)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn WriteBufferImmediate(&self, count: u32, pparams: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_PARAMETER, pmodes: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_MODE) {
::core::mem::transmute((::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(pparams), ::core::mem::transmute(pmodes)))
}
}
unsafe impl ::windows::core::Interface for ID3D12VideoProcessCommandList {
type Vtable = ID3D12VideoProcessCommandList_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xaeb2543a_167f_4682_acc8_d159ed4a6209);
}
impl ::core::convert::From<ID3D12VideoProcessCommandList> for ::windows::core::IUnknown {
fn from(value: ID3D12VideoProcessCommandList) -> Self {
value.0
}
}
impl ::core::convert::From<&ID3D12VideoProcessCommandList> for ::windows::core::IUnknown {
fn from(value: &ID3D12VideoProcessCommandList) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ID3D12VideoProcessCommandList {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ID3D12VideoProcessCommandList {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoProcessCommandList> for super::super::Graphics::Direct3D12::ID3D12CommandList {
fn from(value: ID3D12VideoProcessCommandList) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoProcessCommandList> for super::super::Graphics::Direct3D12::ID3D12CommandList {
fn from(value: &ID3D12VideoProcessCommandList) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> for ID3D12VideoProcessCommandList {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> for &ID3D12VideoProcessCommandList {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoProcessCommandList> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: ID3D12VideoProcessCommandList) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoProcessCommandList> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: &ID3D12VideoProcessCommandList) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for ID3D12VideoProcessCommandList {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for &ID3D12VideoProcessCommandList {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoProcessCommandList> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: ID3D12VideoProcessCommandList) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoProcessCommandList> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: &ID3D12VideoProcessCommandList) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for ID3D12VideoProcessCommandList {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for &ID3D12VideoProcessCommandList {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ID3D12VideoProcessCommandList_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdata: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvdevice: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Graphics::Direct3D12::D3D12_COMMAND_LIST_TYPE,
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pallocator: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, numbarriers: u32, pbarriers: *const ::core::mem::ManuallyDrop<super::super::Graphics::Direct3D12::D3D12_RESOURCE_BARRIER>),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presource: ::windows::core::RawPtr, pregion: *const super::super::Graphics::Direct3D12::D3D12_DISCARD_REGION),
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12")))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqueryheap: ::windows::core::RawPtr, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqueryheap: ::windows::core::RawPtr, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqueryheap: ::windows::core::RawPtr, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, startindex: u32, numqueries: u32, pdestinationbuffer: ::windows::core::RawPtr, aligneddestinationbufferoffset: u64),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbuffer: ::windows::core::RawPtr, alignedbufferoffset: u64, operation: super::super::Graphics::Direct3D12::D3D12_PREDICATION_OP),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pvideoprocessor: ::windows::core::RawPtr, poutputarguments: *const ::core::mem::ManuallyDrop<D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS>, numinputstreams: u32, pinputarguments: *const ::core::mem::ManuallyDrop<D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS>),
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12")))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, pparams: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_PARAMETER, pmodes: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_MODE),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ID3D12VideoProcessCommandList1(pub ::windows::core::IUnknown);
impl ID3D12VideoProcessCommandList1 {
pub unsafe fn GetPrivateData(&self, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(pdatasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateData(&self, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(datasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guid: *const ::windows::core::GUID, pdata: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), pdata.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetName<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), name.into_param().abi()).ok()
}
pub unsafe fn GetDevice<T: ::windows::core::Interface>(&self, result__: *mut ::core::option::Option<T>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &<T as ::windows::core::Interface>::IID, result__ as *mut _ as *mut _).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn GetType(&self) -> super::super::Graphics::Direct3D12::D3D12_COMMAND_LIST_TYPE {
::core::mem::transmute((::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)))
}
pub unsafe fn Close(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn Reset<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12CommandAllocator>>(&self, pallocator: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), pallocator.into_param().abi()).ok()
}
pub unsafe fn ClearState(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn ResourceBarrier(&self, numbarriers: u32, pbarriers: *const super::super::Graphics::Direct3D12::D3D12_RESOURCE_BARRIER) {
::core::mem::transmute((::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(numbarriers), ::core::mem::transmute(pbarriers)))
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
pub unsafe fn DiscardResource<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Resource>>(&self, presource: Param0, pregion: *const super::super::Graphics::Direct3D12::D3D12_DISCARD_REGION) {
::core::mem::transmute((::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), presource.into_param().abi(), ::core::mem::transmute(pregion)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn BeginQuery<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12QueryHeap>>(&self, pqueryheap: Param0, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), pqueryheap.into_param().abi(), ::core::mem::transmute(r#type), ::core::mem::transmute(index)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn EndQuery<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12QueryHeap>>(&self, pqueryheap: Param0, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), pqueryheap.into_param().abi(), ::core::mem::transmute(r#type), ::core::mem::transmute(index)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn ResolveQueryData<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12QueryHeap>, Param4: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Resource>>(&self, pqueryheap: Param0, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, startindex: u32, numqueries: u32, pdestinationbuffer: Param4, aligneddestinationbufferoffset: u64) {
::core::mem::transmute((::windows::core::Interface::vtable(self).16)(
::core::mem::transmute_copy(self),
pqueryheap.into_param().abi(),
::core::mem::transmute(r#type),
::core::mem::transmute(startindex),
::core::mem::transmute(numqueries),
pdestinationbuffer.into_param().abi(),
::core::mem::transmute(aligneddestinationbufferoffset),
))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn SetPredication<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Resource>>(&self, pbuffer: Param0, alignedbufferoffset: u64, operation: super::super::Graphics::Direct3D12::D3D12_PREDICATION_OP) {
::core::mem::transmute((::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), pbuffer.into_param().abi(), ::core::mem::transmute(alignedbufferoffset), ::core::mem::transmute(operation)))
}
pub unsafe fn SetMarker(&self, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(metadata), ::core::mem::transmute(pdata), ::core::mem::transmute(size)))
}
pub unsafe fn BeginEvent(&self, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(metadata), ::core::mem::transmute(pdata), ::core::mem::transmute(size)))
}
pub unsafe fn EndEvent(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)))
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
pub unsafe fn ProcessFrames<'a, Param0: ::windows::core::IntoParam<'a, ID3D12VideoProcessor>>(&self, pvideoprocessor: Param0, poutputarguments: *const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS, numinputstreams: u32, pinputarguments: *const D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS) {
::core::mem::transmute((::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), pvideoprocessor.into_param().abi(), ::core::mem::transmute(poutputarguments), ::core::mem::transmute(numinputstreams), ::core::mem::transmute(pinputarguments)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn WriteBufferImmediate(&self, count: u32, pparams: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_PARAMETER, pmodes: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_MODE) {
::core::mem::transmute((::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(pparams), ::core::mem::transmute(pmodes)))
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
pub unsafe fn ProcessFrames1<'a, Param0: ::windows::core::IntoParam<'a, ID3D12VideoProcessor>>(&self, pvideoprocessor: Param0, poutputarguments: *const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS, numinputstreams: u32, pinputarguments: *const D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS1) {
::core::mem::transmute((::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), pvideoprocessor.into_param().abi(), ::core::mem::transmute(poutputarguments), ::core::mem::transmute(numinputstreams), ::core::mem::transmute(pinputarguments)))
}
}
unsafe impl ::windows::core::Interface for ID3D12VideoProcessCommandList1 {
type Vtable = ID3D12VideoProcessCommandList1_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x542c5c4d_7596_434f_8c93_4efa6766f267);
}
impl ::core::convert::From<ID3D12VideoProcessCommandList1> for ::windows::core::IUnknown {
fn from(value: ID3D12VideoProcessCommandList1) -> Self {
value.0
}
}
impl ::core::convert::From<&ID3D12VideoProcessCommandList1> for ::windows::core::IUnknown {
fn from(value: &ID3D12VideoProcessCommandList1) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ID3D12VideoProcessCommandList1 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ID3D12VideoProcessCommandList1 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ID3D12VideoProcessCommandList1> for ID3D12VideoProcessCommandList {
fn from(value: ID3D12VideoProcessCommandList1) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ID3D12VideoProcessCommandList1> for ID3D12VideoProcessCommandList {
fn from(value: &ID3D12VideoProcessCommandList1) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoProcessCommandList> for ID3D12VideoProcessCommandList1 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoProcessCommandList> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoProcessCommandList> for &ID3D12VideoProcessCommandList1 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoProcessCommandList> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoProcessCommandList1> for super::super::Graphics::Direct3D12::ID3D12CommandList {
fn from(value: ID3D12VideoProcessCommandList1) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoProcessCommandList1> for super::super::Graphics::Direct3D12::ID3D12CommandList {
fn from(value: &ID3D12VideoProcessCommandList1) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> for ID3D12VideoProcessCommandList1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> for &ID3D12VideoProcessCommandList1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoProcessCommandList1> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: ID3D12VideoProcessCommandList1) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoProcessCommandList1> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: &ID3D12VideoProcessCommandList1) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for ID3D12VideoProcessCommandList1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for &ID3D12VideoProcessCommandList1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoProcessCommandList1> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: ID3D12VideoProcessCommandList1) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoProcessCommandList1> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: &ID3D12VideoProcessCommandList1) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for ID3D12VideoProcessCommandList1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for &ID3D12VideoProcessCommandList1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ID3D12VideoProcessCommandList1_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdata: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvdevice: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Graphics::Direct3D12::D3D12_COMMAND_LIST_TYPE,
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pallocator: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, numbarriers: u32, pbarriers: *const ::core::mem::ManuallyDrop<super::super::Graphics::Direct3D12::D3D12_RESOURCE_BARRIER>),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presource: ::windows::core::RawPtr, pregion: *const super::super::Graphics::Direct3D12::D3D12_DISCARD_REGION),
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12")))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqueryheap: ::windows::core::RawPtr, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqueryheap: ::windows::core::RawPtr, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqueryheap: ::windows::core::RawPtr, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, startindex: u32, numqueries: u32, pdestinationbuffer: ::windows::core::RawPtr, aligneddestinationbufferoffset: u64),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbuffer: ::windows::core::RawPtr, alignedbufferoffset: u64, operation: super::super::Graphics::Direct3D12::D3D12_PREDICATION_OP),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pvideoprocessor: ::windows::core::RawPtr, poutputarguments: *const ::core::mem::ManuallyDrop<D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS>, numinputstreams: u32, pinputarguments: *const ::core::mem::ManuallyDrop<D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS>),
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12")))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, pparams: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_PARAMETER, pmodes: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_MODE),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pvideoprocessor: ::windows::core::RawPtr, poutputarguments: *const ::core::mem::ManuallyDrop<D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS>, numinputstreams: u32, pinputarguments: *const ::core::mem::ManuallyDrop<D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS1>),
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ID3D12VideoProcessCommandList2(pub ::windows::core::IUnknown);
impl ID3D12VideoProcessCommandList2 {
pub unsafe fn GetPrivateData(&self, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(pdatasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateData(&self, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(datasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guid: *const ::windows::core::GUID, pdata: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), pdata.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetName<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), name.into_param().abi()).ok()
}
pub unsafe fn GetDevice<T: ::windows::core::Interface>(&self, result__: *mut ::core::option::Option<T>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &<T as ::windows::core::Interface>::IID, result__ as *mut _ as *mut _).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn GetType(&self) -> super::super::Graphics::Direct3D12::D3D12_COMMAND_LIST_TYPE {
::core::mem::transmute((::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)))
}
pub unsafe fn Close(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn Reset<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12CommandAllocator>>(&self, pallocator: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), pallocator.into_param().abi()).ok()
}
pub unsafe fn ClearState(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn ResourceBarrier(&self, numbarriers: u32, pbarriers: *const super::super::Graphics::Direct3D12::D3D12_RESOURCE_BARRIER) {
::core::mem::transmute((::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(numbarriers), ::core::mem::transmute(pbarriers)))
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
pub unsafe fn DiscardResource<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Resource>>(&self, presource: Param0, pregion: *const super::super::Graphics::Direct3D12::D3D12_DISCARD_REGION) {
::core::mem::transmute((::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), presource.into_param().abi(), ::core::mem::transmute(pregion)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn BeginQuery<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12QueryHeap>>(&self, pqueryheap: Param0, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), pqueryheap.into_param().abi(), ::core::mem::transmute(r#type), ::core::mem::transmute(index)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn EndQuery<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12QueryHeap>>(&self, pqueryheap: Param0, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), pqueryheap.into_param().abi(), ::core::mem::transmute(r#type), ::core::mem::transmute(index)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn ResolveQueryData<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12QueryHeap>, Param4: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Resource>>(&self, pqueryheap: Param0, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, startindex: u32, numqueries: u32, pdestinationbuffer: Param4, aligneddestinationbufferoffset: u64) {
::core::mem::transmute((::windows::core::Interface::vtable(self).16)(
::core::mem::transmute_copy(self),
pqueryheap.into_param().abi(),
::core::mem::transmute(r#type),
::core::mem::transmute(startindex),
::core::mem::transmute(numqueries),
pdestinationbuffer.into_param().abi(),
::core::mem::transmute(aligneddestinationbufferoffset),
))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn SetPredication<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Resource>>(&self, pbuffer: Param0, alignedbufferoffset: u64, operation: super::super::Graphics::Direct3D12::D3D12_PREDICATION_OP) {
::core::mem::transmute((::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), pbuffer.into_param().abi(), ::core::mem::transmute(alignedbufferoffset), ::core::mem::transmute(operation)))
}
pub unsafe fn SetMarker(&self, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(metadata), ::core::mem::transmute(pdata), ::core::mem::transmute(size)))
}
pub unsafe fn BeginEvent(&self, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(metadata), ::core::mem::transmute(pdata), ::core::mem::transmute(size)))
}
pub unsafe fn EndEvent(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)))
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
pub unsafe fn ProcessFrames<'a, Param0: ::windows::core::IntoParam<'a, ID3D12VideoProcessor>>(&self, pvideoprocessor: Param0, poutputarguments: *const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS, numinputstreams: u32, pinputarguments: *const D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS) {
::core::mem::transmute((::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), pvideoprocessor.into_param().abi(), ::core::mem::transmute(poutputarguments), ::core::mem::transmute(numinputstreams), ::core::mem::transmute(pinputarguments)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn WriteBufferImmediate(&self, count: u32, pparams: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_PARAMETER, pmodes: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_MODE) {
::core::mem::transmute((::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(pparams), ::core::mem::transmute(pmodes)))
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))]
pub unsafe fn ProcessFrames1<'a, Param0: ::windows::core::IntoParam<'a, ID3D12VideoProcessor>>(&self, pvideoprocessor: Param0, poutputarguments: *const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS, numinputstreams: u32, pinputarguments: *const D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS1) {
::core::mem::transmute((::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), pvideoprocessor.into_param().abi(), ::core::mem::transmute(poutputarguments), ::core::mem::transmute(numinputstreams), ::core::mem::transmute(pinputarguments)))
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn SetProtectedResourceSession<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12ProtectedResourceSession>>(&self, pprotectedresourcesession: Param0) {
::core::mem::transmute((::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), pprotectedresourcesession.into_param().abi()))
}
pub unsafe fn InitializeExtensionCommand<'a, Param0: ::windows::core::IntoParam<'a, ID3D12VideoExtensionCommand>>(&self, pextensioncommand: Param0, pinitializationparameters: *const ::core::ffi::c_void, initializationparameterssizeinbytes: usize) {
::core::mem::transmute((::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), pextensioncommand.into_param().abi(), ::core::mem::transmute(pinitializationparameters), ::core::mem::transmute(initializationparameterssizeinbytes)))
}
pub unsafe fn ExecuteExtensionCommand<'a, Param0: ::windows::core::IntoParam<'a, ID3D12VideoExtensionCommand>>(&self, pextensioncommand: Param0, pexecutionparameters: *const ::core::ffi::c_void, executionparameterssizeinbytes: usize) {
::core::mem::transmute((::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), pextensioncommand.into_param().abi(), ::core::mem::transmute(pexecutionparameters), ::core::mem::transmute(executionparameterssizeinbytes)))
}
}
unsafe impl ::windows::core::Interface for ID3D12VideoProcessCommandList2 {
type Vtable = ID3D12VideoProcessCommandList2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdb525ae4_6ad6_473c_baa7_59b2e37082e4);
}
impl ::core::convert::From<ID3D12VideoProcessCommandList2> for ::windows::core::IUnknown {
fn from(value: ID3D12VideoProcessCommandList2) -> Self {
value.0
}
}
impl ::core::convert::From<&ID3D12VideoProcessCommandList2> for ::windows::core::IUnknown {
fn from(value: &ID3D12VideoProcessCommandList2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ID3D12VideoProcessCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ID3D12VideoProcessCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ID3D12VideoProcessCommandList2> for ID3D12VideoProcessCommandList1 {
fn from(value: ID3D12VideoProcessCommandList2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ID3D12VideoProcessCommandList2> for ID3D12VideoProcessCommandList1 {
fn from(value: &ID3D12VideoProcessCommandList2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoProcessCommandList1> for ID3D12VideoProcessCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoProcessCommandList1> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoProcessCommandList1> for &ID3D12VideoProcessCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoProcessCommandList1> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<ID3D12VideoProcessCommandList2> for ID3D12VideoProcessCommandList {
fn from(value: ID3D12VideoProcessCommandList2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ID3D12VideoProcessCommandList2> for ID3D12VideoProcessCommandList {
fn from(value: &ID3D12VideoProcessCommandList2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoProcessCommandList> for ID3D12VideoProcessCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoProcessCommandList> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoProcessCommandList> for &ID3D12VideoProcessCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoProcessCommandList> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoProcessCommandList2> for super::super::Graphics::Direct3D12::ID3D12CommandList {
fn from(value: ID3D12VideoProcessCommandList2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoProcessCommandList2> for super::super::Graphics::Direct3D12::ID3D12CommandList {
fn from(value: &ID3D12VideoProcessCommandList2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> for ID3D12VideoProcessCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> for &ID3D12VideoProcessCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12CommandList> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoProcessCommandList2> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: ID3D12VideoProcessCommandList2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoProcessCommandList2> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: &ID3D12VideoProcessCommandList2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for ID3D12VideoProcessCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for &ID3D12VideoProcessCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoProcessCommandList2> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: ID3D12VideoProcessCommandList2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoProcessCommandList2> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: &ID3D12VideoProcessCommandList2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for ID3D12VideoProcessCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for &ID3D12VideoProcessCommandList2 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ID3D12VideoProcessCommandList2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdata: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvdevice: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Graphics::Direct3D12::D3D12_COMMAND_LIST_TYPE,
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pallocator: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, numbarriers: u32, pbarriers: *const ::core::mem::ManuallyDrop<super::super::Graphics::Direct3D12::D3D12_RESOURCE_BARRIER>),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presource: ::windows::core::RawPtr, pregion: *const super::super::Graphics::Direct3D12::D3D12_DISCARD_REGION),
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12")))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqueryheap: ::windows::core::RawPtr, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqueryheap: ::windows::core::RawPtr, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, index: u32),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqueryheap: ::windows::core::RawPtr, r#type: super::super::Graphics::Direct3D12::D3D12_QUERY_TYPE, startindex: u32, numqueries: u32, pdestinationbuffer: ::windows::core::RawPtr, aligneddestinationbufferoffset: u64),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbuffer: ::windows::core::RawPtr, alignedbufferoffset: u64, operation: super::super::Graphics::Direct3D12::D3D12_PREDICATION_OP),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, metadata: u32, pdata: *const ::core::ffi::c_void, size: u32),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pvideoprocessor: ::windows::core::RawPtr, poutputarguments: *const ::core::mem::ManuallyDrop<D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS>, numinputstreams: u32, pinputarguments: *const ::core::mem::ManuallyDrop<D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS>),
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12")))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, pparams: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_PARAMETER, pmodes: *const super::super::Graphics::Direct3D12::D3D12_WRITEBUFFERIMMEDIATE_MODE),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pvideoprocessor: ::windows::core::RawPtr, poutputarguments: *const ::core::mem::ManuallyDrop<D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS>, numinputstreams: u32, pinputarguments: *const ::core::mem::ManuallyDrop<D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS1>),
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D12")))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pprotectedresourcesession: ::windows::core::RawPtr),
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pextensioncommand: ::windows::core::RawPtr, pinitializationparameters: *const ::core::ffi::c_void, initializationparameterssizeinbytes: usize),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pextensioncommand: ::windows::core::RawPtr, pexecutionparameters: *const ::core::ffi::c_void, executionparameterssizeinbytes: usize),
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ID3D12VideoProcessor(pub ::windows::core::IUnknown);
impl ID3D12VideoProcessor {
pub unsafe fn GetPrivateData(&self, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(pdatasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateData(&self, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(datasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guid: *const ::windows::core::GUID, pdata: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), pdata.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetName<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), name.into_param().abi()).ok()
}
pub unsafe fn GetDevice<T: ::windows::core::Interface>(&self, result__: *mut ::core::option::Option<T>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &<T as ::windows::core::Interface>::IID, result__ as *mut _ as *mut _).ok()
}
pub unsafe fn GetNodeMask(&self) -> u32 {
::core::mem::transmute((::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetNumInputStreamDescs(&self) -> u32 {
::core::mem::transmute((::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)))
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
pub unsafe fn GetInputStreamDescs(&self, numinputstreamdescs: u32, pinputstreamdescs: *mut D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(numinputstreamdescs), ::core::mem::transmute(pinputstreamdescs)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
pub unsafe fn GetOutputStreamDesc(&self) -> D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC {
let mut result__: D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC = ::core::default::Default::default();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__);
result__
}
}
unsafe impl ::windows::core::Interface for ID3D12VideoProcessor {
type Vtable = ID3D12VideoProcessor_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x304fdb32_bede_410a_8545_943ac6a46138);
}
impl ::core::convert::From<ID3D12VideoProcessor> for ::windows::core::IUnknown {
fn from(value: ID3D12VideoProcessor) -> Self {
value.0
}
}
impl ::core::convert::From<&ID3D12VideoProcessor> for ::windows::core::IUnknown {
fn from(value: &ID3D12VideoProcessor) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ID3D12VideoProcessor {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ID3D12VideoProcessor {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoProcessor> for super::super::Graphics::Direct3D12::ID3D12Pageable {
fn from(value: ID3D12VideoProcessor) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoProcessor> for super::super::Graphics::Direct3D12::ID3D12Pageable {
fn from(value: &ID3D12VideoProcessor) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> for ID3D12VideoProcessor {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> for &ID3D12VideoProcessor {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoProcessor> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: ID3D12VideoProcessor) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoProcessor> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: &ID3D12VideoProcessor) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for ID3D12VideoProcessor {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for &ID3D12VideoProcessor {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoProcessor> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: ID3D12VideoProcessor) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoProcessor> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: &ID3D12VideoProcessor) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for ID3D12VideoProcessor {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for &ID3D12VideoProcessor {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ID3D12VideoProcessor_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdata: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvdevice: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, numinputstreamdescs: u32, pinputstreamdescs: *mut D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, result__: *mut D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC),
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ID3D12VideoProcessor1(pub ::windows::core::IUnknown);
impl ID3D12VideoProcessor1 {
pub unsafe fn GetPrivateData(&self, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(pdatasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateData(&self, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(datasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guid: *const ::windows::core::GUID, pdata: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), pdata.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetName<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), name.into_param().abi()).ok()
}
pub unsafe fn GetDevice<T: ::windows::core::Interface>(&self, result__: *mut ::core::option::Option<T>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &<T as ::windows::core::Interface>::IID, result__ as *mut _ as *mut _).ok()
}
pub unsafe fn GetNodeMask(&self) -> u32 {
::core::mem::transmute((::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetNumInputStreamDescs(&self) -> u32 {
::core::mem::transmute((::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)))
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
pub unsafe fn GetInputStreamDescs(&self, numinputstreamdescs: u32, pinputstreamdescs: *mut D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(numinputstreamdescs), ::core::mem::transmute(pinputstreamdescs)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))]
pub unsafe fn GetOutputStreamDesc(&self) -> D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC {
let mut result__: D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC = ::core::default::Default::default();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__);
result__
}
pub unsafe fn GetProtectedResourceSession<T: ::windows::core::Interface>(&self, result__: *mut ::core::option::Option<T>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &<T as ::windows::core::Interface>::IID, result__ as *mut _ as *mut _).ok()
}
}
unsafe impl ::windows::core::Interface for ID3D12VideoProcessor1 {
type Vtable = ID3D12VideoProcessor1_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf3cfe615_553f_425c_86d8_ee8c1b1fb01c);
}
impl ::core::convert::From<ID3D12VideoProcessor1> for ::windows::core::IUnknown {
fn from(value: ID3D12VideoProcessor1) -> Self {
value.0
}
}
impl ::core::convert::From<&ID3D12VideoProcessor1> for ::windows::core::IUnknown {
fn from(value: &ID3D12VideoProcessor1) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ID3D12VideoProcessor1 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ID3D12VideoProcessor1 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ID3D12VideoProcessor1> for ID3D12VideoProcessor {
fn from(value: ID3D12VideoProcessor1) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ID3D12VideoProcessor1> for ID3D12VideoProcessor {
fn from(value: &ID3D12VideoProcessor1) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoProcessor> for ID3D12VideoProcessor1 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoProcessor> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ID3D12VideoProcessor> for &ID3D12VideoProcessor1 {
fn into_param(self) -> ::windows::core::Param<'a, ID3D12VideoProcessor> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoProcessor1> for super::super::Graphics::Direct3D12::ID3D12Pageable {
fn from(value: ID3D12VideoProcessor1) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoProcessor1> for super::super::Graphics::Direct3D12::ID3D12Pageable {
fn from(value: &ID3D12VideoProcessor1) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> for ID3D12VideoProcessor1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> for &ID3D12VideoProcessor1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Pageable> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoProcessor1> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: ID3D12VideoProcessor1) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoProcessor1> for super::super::Graphics::Direct3D12::ID3D12DeviceChild {
fn from(value: &ID3D12VideoProcessor1) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for ID3D12VideoProcessor1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> for &ID3D12VideoProcessor1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12DeviceChild> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<ID3D12VideoProcessor1> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: ID3D12VideoProcessor1) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl ::core::convert::From<&ID3D12VideoProcessor1> for super::super::Graphics::Direct3D12::ID3D12Object {
fn from(value: &ID3D12VideoProcessor1) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for ID3D12VideoProcessor1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
impl<'a> ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Object> for &ID3D12VideoProcessor1 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::Graphics::Direct3D12::ID3D12Object> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ID3D12VideoProcessor1_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdatasize: *mut u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pdata: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvdevice: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, numinputstreamdescs: u32, pinputstreamdescs: *mut D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, result__: *mut D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC),
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Dxgi_Common")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppprotectedsession: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDXVAHD_Device(pub ::windows::core::IUnknown);
impl IDXVAHD_Device {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
pub unsafe fn CreateVideoSurface(&self, width: u32, height: u32, format: super::super::Graphics::Direct3D9::D3DFORMAT, pool: super::super::Graphics::Direct3D9::D3DPOOL, usage: u32, r#type: DXVAHD_SURFACE_TYPE, numsurfaces: u32, ppsurfaces: *mut ::core::option::Option<super::super::Graphics::Direct3D9::IDirect3DSurface9>, psharedhandle: *mut super::super::Foundation::HANDLE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(
::core::mem::transmute_copy(self),
::core::mem::transmute(width),
::core::mem::transmute(height),
::core::mem::transmute(format),
::core::mem::transmute(pool),
::core::mem::transmute(usage),
::core::mem::transmute(r#type),
::core::mem::transmute(numsurfaces),
::core::mem::transmute(ppsurfaces),
::core::mem::transmute(psharedhandle),
)
.ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub unsafe fn GetVideoProcessorDeviceCaps(&self) -> ::windows::core::Result<DXVAHD_VPDEVCAPS> {
let mut result__: <DXVAHD_VPDEVCAPS as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<DXVAHD_VPDEVCAPS>(result__)
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub unsafe fn GetVideoProcessorOutputFormats(&self, count: u32, pformats: *mut super::super::Graphics::Direct3D9::D3DFORMAT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(pformats)).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub unsafe fn GetVideoProcessorInputFormats(&self, count: u32, pformats: *mut super::super::Graphics::Direct3D9::D3DFORMAT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(pformats)).ok()
}
pub unsafe fn GetVideoProcessorCaps(&self, count: u32, pcaps: *mut DXVAHD_VPCAPS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(pcaps)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetVideoProcessorCustomRates(&self, pvpguid: *const ::windows::core::GUID, count: u32, prates: *mut DXVAHD_CUSTOM_RATE_DATA) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(pvpguid), ::core::mem::transmute(count), ::core::mem::transmute(prates)).ok()
}
pub unsafe fn GetVideoProcessorFilterRange(&self, filter: DXVAHD_FILTER) -> ::windows::core::Result<DXVAHD_FILTER_RANGE_DATA> {
let mut result__: <DXVAHD_FILTER_RANGE_DATA as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(filter), &mut result__).from_abi::<DXVAHD_FILTER_RANGE_DATA>(result__)
}
pub unsafe fn CreateVideoProcessor(&self, pvpguid: *const ::windows::core::GUID) -> ::windows::core::Result<IDXVAHD_VideoProcessor> {
let mut result__: <IDXVAHD_VideoProcessor as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(pvpguid), &mut result__).from_abi::<IDXVAHD_VideoProcessor>(result__)
}
}
unsafe impl ::windows::core::Interface for IDXVAHD_Device {
type Vtable = IDXVAHD_Device_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x95f12dfd_d77e_49be_815f_57d579634d6d);
}
impl ::core::convert::From<IDXVAHD_Device> for ::windows::core::IUnknown {
fn from(value: IDXVAHD_Device) -> Self {
value.0
}
}
impl ::core::convert::From<&IDXVAHD_Device> for ::windows::core::IUnknown {
fn from(value: &IDXVAHD_Device) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDXVAHD_Device {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDXVAHD_Device {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDXVAHD_Device_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, width: u32, height: u32, format: super::super::Graphics::Direct3D9::D3DFORMAT, pool: super::super::Graphics::Direct3D9::D3DPOOL, usage: u32, r#type: DXVAHD_SURFACE_TYPE, numsurfaces: u32, ppsurfaces: *mut ::windows::core::RawPtr, psharedhandle: *mut super::super::Foundation::HANDLE) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9")))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D9")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcaps: *mut DXVAHD_VPDEVCAPS) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D9"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D9")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, pformats: *mut super::super::Graphics::Direct3D9::D3DFORMAT) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D9"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D9")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, pformats: *mut super::super::Graphics::Direct3D9::D3DFORMAT) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D9"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, pcaps: *mut DXVAHD_VPCAPS) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pvpguid: *const ::windows::core::GUID, count: u32, prates: *mut DXVAHD_CUSTOM_RATE_DATA) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, filter: DXVAHD_FILTER, prange: *mut DXVAHD_FILTER_RANGE_DATA) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pvpguid: *const ::windows::core::GUID, ppvideoprocessor: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDXVAHD_VideoProcessor(pub ::windows::core::IUnknown);
impl IDXVAHD_VideoProcessor {
pub unsafe fn SetVideoProcessBltState(&self, state: DXVAHD_BLT_STATE, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(state), ::core::mem::transmute(datasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn GetVideoProcessBltState(&self, state: DXVAHD_BLT_STATE, datasize: u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(state), ::core::mem::transmute(datasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn SetVideoProcessStreamState(&self, streamnumber: u32, state: DXVAHD_STREAM_STATE, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(streamnumber), ::core::mem::transmute(state), ::core::mem::transmute(datasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn GetVideoProcessStreamState(&self, streamnumber: u32, state: DXVAHD_STREAM_STATE, datasize: u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(streamnumber), ::core::mem::transmute(state), ::core::mem::transmute(datasize), ::core::mem::transmute(pdata)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
pub unsafe fn VideoProcessBltHD<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D9::IDirect3DSurface9>>(&self, poutputsurface: Param0, outputframe: u32, streamcount: u32, pstreams: *const DXVAHD_STREAM_DATA) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), poutputsurface.into_param().abi(), ::core::mem::transmute(outputframe), ::core::mem::transmute(streamcount), ::core::mem::transmute(pstreams)).ok()
}
}
unsafe impl ::windows::core::Interface for IDXVAHD_VideoProcessor {
type Vtable = IDXVAHD_VideoProcessor_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x95f4edf4_6e03_4cd7_be1b_3075d665aa52);
}
impl ::core::convert::From<IDXVAHD_VideoProcessor> for ::windows::core::IUnknown {
fn from(value: IDXVAHD_VideoProcessor) -> Self {
value.0
}
}
impl ::core::convert::From<&IDXVAHD_VideoProcessor> for ::windows::core::IUnknown {
fn from(value: &IDXVAHD_VideoProcessor) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDXVAHD_VideoProcessor {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDXVAHD_VideoProcessor {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDXVAHD_VideoProcessor_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, state: DXVAHD_BLT_STATE, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, state: DXVAHD_BLT_STATE, datasize: u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, streamnumber: u32, state: DXVAHD_STREAM_STATE, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, streamnumber: u32, state: DXVAHD_STREAM_STATE, datasize: u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, poutputsurface: ::windows::core::RawPtr, outputframe: u32, streamcount: u32, pstreams: *const ::core::mem::ManuallyDrop<DXVAHD_STREAM_DATA>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDirect3D9ExOverlayExtension(pub ::windows::core::IUnknown);
impl IDirect3D9ExOverlayExtension {
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub unsafe fn CheckDeviceOverlayType(&self, adapter: u32, devtype: super::super::Graphics::Direct3D9::D3DDEVTYPE, overlaywidth: u32, overlayheight: u32, overlayformat: super::super::Graphics::Direct3D9::D3DFORMAT, pdisplaymode: *mut super::super::Graphics::Direct3D9::D3DDISPLAYMODEEX, displayrotation: super::super::Graphics::Direct3D9::D3DDISPLAYROTATION, poverlaycaps: *mut D3DOVERLAYCAPS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(
::core::mem::transmute_copy(self),
::core::mem::transmute(adapter),
::core::mem::transmute(devtype),
::core::mem::transmute(overlaywidth),
::core::mem::transmute(overlayheight),
::core::mem::transmute(overlayformat),
::core::mem::transmute(pdisplaymode),
::core::mem::transmute(displayrotation),
::core::mem::transmute(poverlaycaps),
)
.ok()
}
}
unsafe impl ::windows::core::Interface for IDirect3D9ExOverlayExtension {
type Vtable = IDirect3D9ExOverlayExtension_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x187aeb13_aaf5_4c59_876d_e059088c0df8);
}
impl ::core::convert::From<IDirect3D9ExOverlayExtension> for ::windows::core::IUnknown {
fn from(value: IDirect3D9ExOverlayExtension) -> Self {
value.0
}
}
impl ::core::convert::From<&IDirect3D9ExOverlayExtension> for ::windows::core::IUnknown {
fn from(value: &IDirect3D9ExOverlayExtension) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDirect3D9ExOverlayExtension {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDirect3D9ExOverlayExtension {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDirect3D9ExOverlayExtension_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Graphics_Direct3D9")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, adapter: u32, devtype: super::super::Graphics::Direct3D9::D3DDEVTYPE, overlaywidth: u32, overlayheight: u32, overlayformat: super::super::Graphics::Direct3D9::D3DFORMAT, pdisplaymode: *mut super::super::Graphics::Direct3D9::D3DDISPLAYMODEEX, displayrotation: super::super::Graphics::Direct3D9::D3DDISPLAYROTATION, poverlaycaps: *mut D3DOVERLAYCAPS) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D9"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDirect3DAuthenticatedChannel9(pub ::windows::core::IUnknown);
impl IDirect3DAuthenticatedChannel9 {
pub unsafe fn GetCertificateSize(&self, pcertificatesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pcertificatesize)).ok()
}
pub unsafe fn GetCertificate(&self, certifactesize: u32, ppcertificate: *mut u8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(certifactesize), ::core::mem::transmute(ppcertificate)).ok()
}
pub unsafe fn NegotiateKeyExchange(&self, datasize: u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(datasize), ::core::mem::transmute(pdata)).ok()
}
pub unsafe fn Query(&self, inputsize: u32, pinput: *const ::core::ffi::c_void, outputsize: u32, poutput: *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(inputsize), ::core::mem::transmute(pinput), ::core::mem::transmute(outputsize), ::core::mem::transmute(poutput)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
pub unsafe fn Configure(&self, inputsize: u32, pinput: *const ::core::ffi::c_void, poutput: *mut super::super::Graphics::Direct3D9::D3DAUTHENTICATEDCHANNEL_CONFIGURE_OUTPUT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(inputsize), ::core::mem::transmute(pinput), ::core::mem::transmute(poutput)).ok()
}
}
unsafe impl ::windows::core::Interface for IDirect3DAuthenticatedChannel9 {
type Vtable = IDirect3DAuthenticatedChannel9_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xff24beee_da21_4beb_98b5_d2f899f98af9);
}
impl ::core::convert::From<IDirect3DAuthenticatedChannel9> for ::windows::core::IUnknown {
fn from(value: IDirect3DAuthenticatedChannel9) -> Self {
value.0
}
}
impl ::core::convert::From<&IDirect3DAuthenticatedChannel9> for ::windows::core::IUnknown {
fn from(value: &IDirect3DAuthenticatedChannel9) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDirect3DAuthenticatedChannel9 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDirect3DAuthenticatedChannel9 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDirect3DAuthenticatedChannel9_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcertificatesize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, certifactesize: u32, ppcertificate: *mut u8) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, datasize: u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, inputsize: u32, pinput: *const ::core::ffi::c_void, outputsize: u32, poutput: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, inputsize: u32, pinput: *const ::core::ffi::c_void, poutput: *mut super::super::Graphics::Direct3D9::D3DAUTHENTICATEDCHANNEL_CONFIGURE_OUTPUT) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDirect3DCryptoSession9(pub ::windows::core::IUnknown);
impl IDirect3DCryptoSession9 {
pub unsafe fn GetCertificateSize(&self, pcertificatesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pcertificatesize)).ok()
}
pub unsafe fn GetCertificate(&self, certifactesize: u32, ppcertificate: *mut u8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(certifactesize), ::core::mem::transmute(ppcertificate)).ok()
}
pub unsafe fn NegotiateKeyExchange(&self, datasize: u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(datasize), ::core::mem::transmute(pdata)).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub unsafe fn EncryptionBlt<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D9::IDirect3DSurface9>, Param1: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D9::IDirect3DSurface9>>(&self, psrcsurface: Param0, pdstsurface: Param1, dstsurfacesize: u32, piv: *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), psrcsurface.into_param().abi(), pdstsurface.into_param().abi(), ::core::mem::transmute(dstsurfacesize), ::core::mem::transmute(piv)).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub unsafe fn DecryptionBlt<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D9::IDirect3DSurface9>, Param1: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D9::IDirect3DSurface9>>(&self, psrcsurface: Param0, pdstsurface: Param1, srcsurfacesize: u32, pencryptedblockinfo: *mut super::super::Graphics::Direct3D9::D3DENCRYPTED_BLOCK_INFO, pcontentkey: *mut ::core::ffi::c_void, piv: *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), psrcsurface.into_param().abi(), pdstsurface.into_param().abi(), ::core::mem::transmute(srcsurfacesize), ::core::mem::transmute(pencryptedblockinfo), ::core::mem::transmute(pcontentkey), ::core::mem::transmute(piv)).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub unsafe fn GetSurfacePitch<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D9::IDirect3DSurface9>>(&self, psrcsurface: Param0, psurfacepitch: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), psrcsurface.into_param().abi(), ::core::mem::transmute(psurfacepitch)).ok()
}
pub unsafe fn StartSessionKeyRefresh(&self, prandomnumber: *mut ::core::ffi::c_void, randomnumbersize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(prandomnumber), ::core::mem::transmute(randomnumbersize)).ok()
}
pub unsafe fn FinishSessionKeyRefresh(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetEncryptionBltKey(&self, preadbackkey: *mut ::core::ffi::c_void, keysize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(preadbackkey), ::core::mem::transmute(keysize)).ok()
}
}
unsafe impl ::windows::core::Interface for IDirect3DCryptoSession9 {
type Vtable = IDirect3DCryptoSession9_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfa0ab799_7a9c_48ca_8c5b_237e71a54434);
}
impl ::core::convert::From<IDirect3DCryptoSession9> for ::windows::core::IUnknown {
fn from(value: IDirect3DCryptoSession9) -> Self {
value.0
}
}
impl ::core::convert::From<&IDirect3DCryptoSession9> for ::windows::core::IUnknown {
fn from(value: &IDirect3DCryptoSession9) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDirect3DCryptoSession9 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDirect3DCryptoSession9 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDirect3DCryptoSession9_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcertificatesize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, certifactesize: u32, ppcertificate: *mut u8) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, datasize: u32, pdata: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Direct3D9")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psrcsurface: ::windows::core::RawPtr, pdstsurface: ::windows::core::RawPtr, dstsurfacesize: u32, piv: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D9"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D9")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psrcsurface: ::windows::core::RawPtr, pdstsurface: ::windows::core::RawPtr, srcsurfacesize: u32, pencryptedblockinfo: *mut super::super::Graphics::Direct3D9::D3DENCRYPTED_BLOCK_INFO, pcontentkey: *mut ::core::ffi::c_void, piv: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D9"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D9")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psrcsurface: ::windows::core::RawPtr, psurfacepitch: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D9"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prandomnumber: *mut ::core::ffi::c_void, randomnumbersize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, preadbackkey: *mut ::core::ffi::c_void, keysize: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDirect3DDevice9Video(pub ::windows::core::IUnknown);
impl IDirect3DDevice9Video {
pub unsafe fn GetContentProtectionCaps(&self, pcryptotype: *const ::windows::core::GUID, pdecodeprofile: *const ::windows::core::GUID, pcaps: *mut D3DCONTENTPROTECTIONCAPS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pcryptotype), ::core::mem::transmute(pdecodeprofile), ::core::mem::transmute(pcaps)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
pub unsafe fn CreateAuthenticatedChannel(&self, channeltype: super::super::Graphics::Direct3D9::D3DAUTHENTICATEDCHANNELTYPE, ppauthenticatedchannel: *mut ::core::option::Option<IDirect3DAuthenticatedChannel9>, pchannelhandle: *mut super::super::Foundation::HANDLE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(channeltype), ::core::mem::transmute(ppauthenticatedchannel), ::core::mem::transmute(pchannelhandle)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateCryptoSession(&self, pcryptotype: *const ::windows::core::GUID, pdecodeprofile: *const ::windows::core::GUID, ppcryptosession: *mut ::core::option::Option<IDirect3DCryptoSession9>, pcryptohandle: *mut super::super::Foundation::HANDLE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(pcryptotype), ::core::mem::transmute(pdecodeprofile), ::core::mem::transmute(ppcryptosession), ::core::mem::transmute(pcryptohandle)).ok()
}
}
unsafe impl ::windows::core::Interface for IDirect3DDevice9Video {
type Vtable = IDirect3DDevice9Video_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x26dc4561_a1ee_4ae7_96da_118a36c0ec95);
}
impl ::core::convert::From<IDirect3DDevice9Video> for ::windows::core::IUnknown {
fn from(value: IDirect3DDevice9Video) -> Self {
value.0
}
}
impl ::core::convert::From<&IDirect3DDevice9Video> for ::windows::core::IUnknown {
fn from(value: &IDirect3DDevice9Video) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDirect3DDevice9Video {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDirect3DDevice9Video {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDirect3DDevice9Video_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcryptotype: *const ::windows::core::GUID, pdecodeprofile: *const ::windows::core::GUID, pcaps: *mut D3DCONTENTPROTECTIONCAPS) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, channeltype: super::super::Graphics::Direct3D9::D3DAUTHENTICATEDCHANNELTYPE, ppauthenticatedchannel: *mut ::windows::core::RawPtr, pchannelhandle: *mut super::super::Foundation::HANDLE) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcryptotype: *const ::windows::core::GUID, pdecodeprofile: *const ::windows::core::GUID, ppcryptosession: *mut ::windows::core::RawPtr, pcryptohandle: *mut super::super::Foundation::HANDLE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDirect3DDeviceManager9(pub ::windows::core::IUnknown);
impl IDirect3DDeviceManager9 {
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub unsafe fn ResetDevice<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D9::IDirect3DDevice9>>(&self, pdevice: Param0, resettoken: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pdevice.into_param().abi(), ::core::mem::transmute(resettoken)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenDeviceHandle(&self) -> ::windows::core::Result<super::super::Foundation::HANDLE> {
let mut result__: <super::super::Foundation::HANDLE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::HANDLE>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CloseDeviceHandle<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::HANDLE>>(&self, hdevice: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), hdevice.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn TestDevice<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::HANDLE>>(&self, hdevice: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), hdevice.into_param().abi()).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
pub unsafe fn LockDevice<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, hdevice: Param0, ppdevice: *mut ::core::option::Option<super::super::Graphics::Direct3D9::IDirect3DDevice9>, fblock: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), hdevice.into_param().abi(), ::core::mem::transmute(ppdevice), fblock.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn UnlockDevice<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, hdevice: Param0, fsavestate: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), hdevice.into_param().abi(), fsavestate.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetVideoService<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::HANDLE>>(&self, hdevice: Param0, riid: *const ::windows::core::GUID, ppservice: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), hdevice.into_param().abi(), ::core::mem::transmute(riid), ::core::mem::transmute(ppservice)).ok()
}
}
unsafe impl ::windows::core::Interface for IDirect3DDeviceManager9 {
type Vtable = IDirect3DDeviceManager9_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa0cade0f_06d5_4cf4_a1c7_f3cdd725aa75);
}
impl ::core::convert::From<IDirect3DDeviceManager9> for ::windows::core::IUnknown {
fn from(value: IDirect3DDeviceManager9) -> Self {
value.0
}
}
impl ::core::convert::From<&IDirect3DDeviceManager9> for ::windows::core::IUnknown {
fn from(value: &IDirect3DDeviceManager9) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDirect3DDeviceManager9 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDirect3DDeviceManager9 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDirect3DDeviceManager9_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Graphics_Direct3D9")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdevice: ::windows::core::RawPtr, resettoken: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D9"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, phdevice: *mut super::super::Foundation::HANDLE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hdevice: super::super::Foundation::HANDLE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hdevice: super::super::Foundation::HANDLE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hdevice: super::super::Foundation::HANDLE, ppdevice: *mut ::windows::core::RawPtr, fblock: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hdevice: super::super::Foundation::HANDLE, fsavestate: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hdevice: super::super::Foundation::HANDLE, riid: *const ::windows::core::GUID, ppservice: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDirectXVideoAccelerationService(pub ::windows::core::IUnknown);
impl IDirectXVideoAccelerationService {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
pub unsafe fn CreateSurface(&self, width: u32, height: u32, backbuffers: u32, format: super::super::Graphics::Direct3D9::D3DFORMAT, pool: super::super::Graphics::Direct3D9::D3DPOOL, usage: u32, dxvatype: DXVA2_VideoRenderTargetType, ppsurface: *mut ::core::option::Option<super::super::Graphics::Direct3D9::IDirect3DSurface9>, psharedhandle: *mut super::super::Foundation::HANDLE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(
::core::mem::transmute_copy(self),
::core::mem::transmute(width),
::core::mem::transmute(height),
::core::mem::transmute(backbuffers),
::core::mem::transmute(format),
::core::mem::transmute(pool),
::core::mem::transmute(usage),
::core::mem::transmute(dxvatype),
::core::mem::transmute(ppsurface),
::core::mem::transmute(psharedhandle),
)
.ok()
}
}
unsafe impl ::windows::core::Interface for IDirectXVideoAccelerationService {
type Vtable = IDirectXVideoAccelerationService_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfc51a550_d5e7_11d9_af55_00054e43ff02);
}
impl ::core::convert::From<IDirectXVideoAccelerationService> for ::windows::core::IUnknown {
fn from(value: IDirectXVideoAccelerationService) -> Self {
value.0
}
}
impl ::core::convert::From<&IDirectXVideoAccelerationService> for ::windows::core::IUnknown {
fn from(value: &IDirectXVideoAccelerationService) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDirectXVideoAccelerationService {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDirectXVideoAccelerationService {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDirectXVideoAccelerationService_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, width: u32, height: u32, backbuffers: u32, format: super::super::Graphics::Direct3D9::D3DFORMAT, pool: super::super::Graphics::Direct3D9::D3DPOOL, usage: u32, dxvatype: DXVA2_VideoRenderTargetType, ppsurface: *mut ::windows::core::RawPtr, psharedhandle: *mut super::super::Foundation::HANDLE) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDirectXVideoDecoder(pub ::windows::core::IUnknown);
impl IDirectXVideoDecoder {
pub unsafe fn GetVideoDecoderService(&self) -> ::windows::core::Result<IDirectXVideoDecoderService> {
let mut result__: <IDirectXVideoDecoderService as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDirectXVideoDecoderService>(result__)
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub unsafe fn GetCreationParameters(&self, pdeviceguid: *mut ::windows::core::GUID, pvideodesc: *mut DXVA2_VideoDesc, pconfig: *mut DXVA2_ConfigPictureDecode, pdecoderrendertargets: *mut *mut ::core::option::Option<super::super::Graphics::Direct3D9::IDirect3DSurface9>, pnumsurfaces: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdeviceguid), ::core::mem::transmute(pvideodesc), ::core::mem::transmute(pconfig), ::core::mem::transmute(pdecoderrendertargets), ::core::mem::transmute(pnumsurfaces)).ok()
}
pub unsafe fn GetBuffer(&self, buffertype: DXVA2_BufferfType, ppbuffer: *mut *mut ::core::ffi::c_void, pbuffersize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffertype), ::core::mem::transmute(ppbuffer), ::core::mem::transmute(pbuffersize)).ok()
}
pub unsafe fn ReleaseBuffer(&self, buffertype: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffertype)).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub unsafe fn BeginFrame<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D9::IDirect3DSurface9>>(&self, prendertarget: Param0, pvpvpdata: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), prendertarget.into_param().abi(), ::core::mem::transmute(pvpvpdata)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EndFrame(&self, phandlecomplete: *mut super::super::Foundation::HANDLE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(phandlecomplete)).ok()
}
pub unsafe fn Execute(&self, pexecuteparams: *const DXVA2_DecodeExecuteParams) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(pexecuteparams)).ok()
}
}
unsafe impl ::windows::core::Interface for IDirectXVideoDecoder {
type Vtable = IDirectXVideoDecoder_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf2b0810a_fd00_43c9_918c_df94e2d8ef7d);
}
impl ::core::convert::From<IDirectXVideoDecoder> for ::windows::core::IUnknown {
fn from(value: IDirectXVideoDecoder) -> Self {
value.0
}
}
impl ::core::convert::From<&IDirectXVideoDecoder> for ::windows::core::IUnknown {
fn from(value: &IDirectXVideoDecoder) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDirectXVideoDecoder {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDirectXVideoDecoder {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDirectXVideoDecoder_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppservice: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Direct3D9")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdeviceguid: *mut ::windows::core::GUID, pvideodesc: *mut DXVA2_VideoDesc, pconfig: *mut DXVA2_ConfigPictureDecode, pdecoderrendertargets: *mut *mut ::windows::core::RawPtr, pnumsurfaces: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D9"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffertype: DXVA2_BufferfType, ppbuffer: *mut *mut ::core::ffi::c_void, pbuffersize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffertype: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Direct3D9")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prendertarget: ::windows::core::RawPtr, pvpvpdata: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D9"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, phandlecomplete: *mut super::super::Foundation::HANDLE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pexecuteparams: *const DXVA2_DecodeExecuteParams) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDirectXVideoDecoderService(pub ::windows::core::IUnknown);
impl IDirectXVideoDecoderService {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
pub unsafe fn CreateSurface(&self, width: u32, height: u32, backbuffers: u32, format: super::super::Graphics::Direct3D9::D3DFORMAT, pool: super::super::Graphics::Direct3D9::D3DPOOL, usage: u32, dxvatype: DXVA2_VideoRenderTargetType, ppsurface: *mut ::core::option::Option<super::super::Graphics::Direct3D9::IDirect3DSurface9>, psharedhandle: *mut super::super::Foundation::HANDLE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(
::core::mem::transmute_copy(self),
::core::mem::transmute(width),
::core::mem::transmute(height),
::core::mem::transmute(backbuffers),
::core::mem::transmute(format),
::core::mem::transmute(pool),
::core::mem::transmute(usage),
::core::mem::transmute(dxvatype),
::core::mem::transmute(ppsurface),
::core::mem::transmute(psharedhandle),
)
.ok()
}
pub unsafe fn GetDecoderDeviceGuids(&self, pcount: *mut u32, pguids: *mut *mut ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pcount), ::core::mem::transmute(pguids)).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub unsafe fn GetDecoderRenderTargets(&self, guid: *const ::windows::core::GUID, pcount: *mut u32, pformats: *mut *mut super::super::Graphics::Direct3D9::D3DFORMAT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(pcount), ::core::mem::transmute(pformats)).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub unsafe fn GetDecoderConfigurations(&self, guid: *const ::windows::core::GUID, pvideodesc: *const DXVA2_VideoDesc, preserved: *mut ::core::ffi::c_void, pcount: *mut u32, ppconfigs: *mut *mut DXVA2_ConfigPictureDecode) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(pvideodesc), ::core::mem::transmute(preserved), ::core::mem::transmute(pcount), ::core::mem::transmute(ppconfigs)).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub unsafe fn CreateVideoDecoder(&self, guid: *const ::windows::core::GUID, pvideodesc: *const DXVA2_VideoDesc, pconfig: *const DXVA2_ConfigPictureDecode, ppdecoderrendertargets: *const ::core::option::Option<super::super::Graphics::Direct3D9::IDirect3DSurface9>, numrendertargets: u32) -> ::windows::core::Result<IDirectXVideoDecoder> {
let mut result__: <IDirectXVideoDecoder as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(pvideodesc), ::core::mem::transmute(pconfig), ::core::mem::transmute(ppdecoderrendertargets), ::core::mem::transmute(numrendertargets), &mut result__).from_abi::<IDirectXVideoDecoder>(result__)
}
}
unsafe impl ::windows::core::Interface for IDirectXVideoDecoderService {
type Vtable = IDirectXVideoDecoderService_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfc51a551_d5e7_11d9_af55_00054e43ff02);
}
impl ::core::convert::From<IDirectXVideoDecoderService> for ::windows::core::IUnknown {
fn from(value: IDirectXVideoDecoderService) -> Self {
value.0
}
}
impl ::core::convert::From<&IDirectXVideoDecoderService> for ::windows::core::IUnknown {
fn from(value: &IDirectXVideoDecoderService) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDirectXVideoDecoderService {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDirectXVideoDecoderService {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDirectXVideoDecoderService> for IDirectXVideoAccelerationService {
fn from(value: IDirectXVideoDecoderService) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDirectXVideoDecoderService> for IDirectXVideoAccelerationService {
fn from(value: &IDirectXVideoDecoderService) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDirectXVideoAccelerationService> for IDirectXVideoDecoderService {
fn into_param(self) -> ::windows::core::Param<'a, IDirectXVideoAccelerationService> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDirectXVideoAccelerationService> for &IDirectXVideoDecoderService {
fn into_param(self) -> ::windows::core::Param<'a, IDirectXVideoAccelerationService> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDirectXVideoDecoderService_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, width: u32, height: u32, backbuffers: u32, format: super::super::Graphics::Direct3D9::D3DFORMAT, pool: super::super::Graphics::Direct3D9::D3DPOOL, usage: u32, dxvatype: DXVA2_VideoRenderTargetType, ppsurface: *mut ::windows::core::RawPtr, psharedhandle: *mut super::super::Foundation::HANDLE) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcount: *mut u32, pguids: *mut *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Direct3D9")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pcount: *mut u32, pformats: *mut *mut super::super::Graphics::Direct3D9::D3DFORMAT) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D9"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D9")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pvideodesc: *const DXVA2_VideoDesc, preserved: *mut ::core::ffi::c_void, pcount: *mut u32, ppconfigs: *mut *mut DXVA2_ConfigPictureDecode) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D9"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D9")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pvideodesc: *const DXVA2_VideoDesc, pconfig: *const DXVA2_ConfigPictureDecode, ppdecoderrendertargets: *const ::windows::core::RawPtr, numrendertargets: u32, ppdecode: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D9"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDirectXVideoMemoryConfiguration(pub ::windows::core::IUnknown);
impl IDirectXVideoMemoryConfiguration {
pub unsafe fn GetAvailableSurfaceTypeByIndex(&self, dwtypeindex: u32) -> ::windows::core::Result<DXVA2_SurfaceType> {
let mut result__: <DXVA2_SurfaceType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwtypeindex), &mut result__).from_abi::<DXVA2_SurfaceType>(result__)
}
pub unsafe fn SetSurfaceType(&self, dwtype: DXVA2_SurfaceType) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwtype)).ok()
}
}
unsafe impl ::windows::core::Interface for IDirectXVideoMemoryConfiguration {
type Vtable = IDirectXVideoMemoryConfiguration_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb7f916dd_db3b_49c1_84d7_e45ef99ec726);
}
impl ::core::convert::From<IDirectXVideoMemoryConfiguration> for ::windows::core::IUnknown {
fn from(value: IDirectXVideoMemoryConfiguration) -> Self {
value.0
}
}
impl ::core::convert::From<&IDirectXVideoMemoryConfiguration> for ::windows::core::IUnknown {
fn from(value: &IDirectXVideoMemoryConfiguration) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDirectXVideoMemoryConfiguration {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDirectXVideoMemoryConfiguration {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDirectXVideoMemoryConfiguration_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwtypeindex: u32, pdwtype: *mut DXVA2_SurfaceType) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwtype: DXVA2_SurfaceType) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDirectXVideoProcessor(pub ::windows::core::IUnknown);
impl IDirectXVideoProcessor {
pub unsafe fn GetVideoProcessorService(&self) -> ::windows::core::Result<IDirectXVideoProcessorService> {
let mut result__: <IDirectXVideoProcessorService as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDirectXVideoProcessorService>(result__)
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub unsafe fn GetCreationParameters(&self, pdeviceguid: *mut ::windows::core::GUID, pvideodesc: *mut DXVA2_VideoDesc, prendertargetformat: *mut super::super::Graphics::Direct3D9::D3DFORMAT, pmaxnumsubstreams: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdeviceguid), ::core::mem::transmute(pvideodesc), ::core::mem::transmute(prendertargetformat), ::core::mem::transmute(pmaxnumsubstreams)).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub unsafe fn GetVideoProcessorCaps(&self) -> ::windows::core::Result<DXVA2_VideoProcessorCaps> {
let mut result__: <DXVA2_VideoProcessorCaps as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<DXVA2_VideoProcessorCaps>(result__)
}
pub unsafe fn GetProcAmpRange(&self, procampcap: u32) -> ::windows::core::Result<DXVA2_ValueRange> {
let mut result__: <DXVA2_ValueRange as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(procampcap), &mut result__).from_abi::<DXVA2_ValueRange>(result__)
}
pub unsafe fn GetFilterPropertyRange(&self, filtersetting: u32) -> ::windows::core::Result<DXVA2_ValueRange> {
let mut result__: <DXVA2_ValueRange as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(filtersetting), &mut result__).from_abi::<DXVA2_ValueRange>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
pub unsafe fn VideoProcessBlt<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D9::IDirect3DSurface9>>(&self, prendertarget: Param0, pbltparams: *const DXVA2_VideoProcessBltParams, psamples: *const DXVA2_VideoSample, numsamples: u32, phandlecomplete: *mut super::super::Foundation::HANDLE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), prendertarget.into_param().abi(), ::core::mem::transmute(pbltparams), ::core::mem::transmute(psamples), ::core::mem::transmute(numsamples), ::core::mem::transmute(phandlecomplete)).ok()
}
}
unsafe impl ::windows::core::Interface for IDirectXVideoProcessor {
type Vtable = IDirectXVideoProcessor_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8c3a39f0_916e_4690_804f_4c8001355d25);
}
impl ::core::convert::From<IDirectXVideoProcessor> for ::windows::core::IUnknown {
fn from(value: IDirectXVideoProcessor) -> Self {
value.0
}
}
impl ::core::convert::From<&IDirectXVideoProcessor> for ::windows::core::IUnknown {
fn from(value: &IDirectXVideoProcessor) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDirectXVideoProcessor {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDirectXVideoProcessor {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDirectXVideoProcessor_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppservice: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Direct3D9")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdeviceguid: *mut ::windows::core::GUID, pvideodesc: *mut DXVA2_VideoDesc, prendertargetformat: *mut super::super::Graphics::Direct3D9::D3DFORMAT, pmaxnumsubstreams: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D9"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D9")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcaps: *mut DXVA2_VideoProcessorCaps) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D9"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, procampcap: u32, prange: *mut DXVA2_ValueRange) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, filtersetting: u32, prange: *mut DXVA2_ValueRange) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prendertarget: ::windows::core::RawPtr, pbltparams: *const DXVA2_VideoProcessBltParams, psamples: *const ::core::mem::ManuallyDrop<DXVA2_VideoSample>, numsamples: u32, phandlecomplete: *mut super::super::Foundation::HANDLE) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDirectXVideoProcessorService(pub ::windows::core::IUnknown);
impl IDirectXVideoProcessorService {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
pub unsafe fn CreateSurface(&self, width: u32, height: u32, backbuffers: u32, format: super::super::Graphics::Direct3D9::D3DFORMAT, pool: super::super::Graphics::Direct3D9::D3DPOOL, usage: u32, dxvatype: DXVA2_VideoRenderTargetType, ppsurface: *mut ::core::option::Option<super::super::Graphics::Direct3D9::IDirect3DSurface9>, psharedhandle: *mut super::super::Foundation::HANDLE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(
::core::mem::transmute_copy(self),
::core::mem::transmute(width),
::core::mem::transmute(height),
::core::mem::transmute(backbuffers),
::core::mem::transmute(format),
::core::mem::transmute(pool),
::core::mem::transmute(usage),
::core::mem::transmute(dxvatype),
::core::mem::transmute(ppsurface),
::core::mem::transmute(psharedhandle),
)
.ok()
}
pub unsafe fn RegisterVideoProcessorSoftwareDevice(&self, pcallbacks: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pcallbacks)).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub unsafe fn GetVideoProcessorDeviceGuids(&self, pvideodesc: *const DXVA2_VideoDesc, pcount: *mut u32, pguids: *mut *mut ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(pvideodesc), ::core::mem::transmute(pcount), ::core::mem::transmute(pguids)).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub unsafe fn GetVideoProcessorRenderTargets(&self, videoprocdeviceguid: *const ::windows::core::GUID, pvideodesc: *const DXVA2_VideoDesc, pcount: *mut u32, pformats: *mut *mut super::super::Graphics::Direct3D9::D3DFORMAT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(videoprocdeviceguid), ::core::mem::transmute(pvideodesc), ::core::mem::transmute(pcount), ::core::mem::transmute(pformats)).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub unsafe fn GetVideoProcessorSubStreamFormats(&self, videoprocdeviceguid: *const ::windows::core::GUID, pvideodesc: *const DXVA2_VideoDesc, rendertargetformat: super::super::Graphics::Direct3D9::D3DFORMAT, pcount: *mut u32, pformats: *mut *mut super::super::Graphics::Direct3D9::D3DFORMAT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(videoprocdeviceguid), ::core::mem::transmute(pvideodesc), ::core::mem::transmute(rendertargetformat), ::core::mem::transmute(pcount), ::core::mem::transmute(pformats)).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub unsafe fn GetVideoProcessorCaps(&self, videoprocdeviceguid: *const ::windows::core::GUID, pvideodesc: *const DXVA2_VideoDesc, rendertargetformat: super::super::Graphics::Direct3D9::D3DFORMAT) -> ::windows::core::Result<DXVA2_VideoProcessorCaps> {
let mut result__: <DXVA2_VideoProcessorCaps as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(videoprocdeviceguid), ::core::mem::transmute(pvideodesc), ::core::mem::transmute(rendertargetformat), &mut result__).from_abi::<DXVA2_VideoProcessorCaps>(result__)
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub unsafe fn GetProcAmpRange(&self, videoprocdeviceguid: *const ::windows::core::GUID, pvideodesc: *const DXVA2_VideoDesc, rendertargetformat: super::super::Graphics::Direct3D9::D3DFORMAT, procampcap: u32) -> ::windows::core::Result<DXVA2_ValueRange> {
let mut result__: <DXVA2_ValueRange as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(videoprocdeviceguid), ::core::mem::transmute(pvideodesc), ::core::mem::transmute(rendertargetformat), ::core::mem::transmute(procampcap), &mut result__).from_abi::<DXVA2_ValueRange>(result__)
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub unsafe fn GetFilterPropertyRange(&self, videoprocdeviceguid: *const ::windows::core::GUID, pvideodesc: *const DXVA2_VideoDesc, rendertargetformat: super::super::Graphics::Direct3D9::D3DFORMAT, filtersetting: u32) -> ::windows::core::Result<DXVA2_ValueRange> {
let mut result__: <DXVA2_ValueRange as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(videoprocdeviceguid), ::core::mem::transmute(pvideodesc), ::core::mem::transmute(rendertargetformat), ::core::mem::transmute(filtersetting), &mut result__).from_abi::<DXVA2_ValueRange>(result__)
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub unsafe fn CreateVideoProcessor(&self, videoprocdeviceguid: *const ::windows::core::GUID, pvideodesc: *const DXVA2_VideoDesc, rendertargetformat: super::super::Graphics::Direct3D9::D3DFORMAT, maxnumsubstreams: u32) -> ::windows::core::Result<IDirectXVideoProcessor> {
let mut result__: <IDirectXVideoProcessor as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(videoprocdeviceguid), ::core::mem::transmute(pvideodesc), ::core::mem::transmute(rendertargetformat), ::core::mem::transmute(maxnumsubstreams), &mut result__).from_abi::<IDirectXVideoProcessor>(result__)
}
}
unsafe impl ::windows::core::Interface for IDirectXVideoProcessorService {
type Vtable = IDirectXVideoProcessorService_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfc51a552_d5e7_11d9_af55_00054e43ff02);
}
impl ::core::convert::From<IDirectXVideoProcessorService> for ::windows::core::IUnknown {
fn from(value: IDirectXVideoProcessorService) -> Self {
value.0
}
}
impl ::core::convert::From<&IDirectXVideoProcessorService> for ::windows::core::IUnknown {
fn from(value: &IDirectXVideoProcessorService) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDirectXVideoProcessorService {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDirectXVideoProcessorService {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDirectXVideoProcessorService> for IDirectXVideoAccelerationService {
fn from(value: IDirectXVideoProcessorService) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDirectXVideoProcessorService> for IDirectXVideoAccelerationService {
fn from(value: &IDirectXVideoProcessorService) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDirectXVideoAccelerationService> for IDirectXVideoProcessorService {
fn into_param(self) -> ::windows::core::Param<'a, IDirectXVideoAccelerationService> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDirectXVideoAccelerationService> for &IDirectXVideoProcessorService {
fn into_param(self) -> ::windows::core::Param<'a, IDirectXVideoAccelerationService> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDirectXVideoProcessorService_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, width: u32, height: u32, backbuffers: u32, format: super::super::Graphics::Direct3D9::D3DFORMAT, pool: super::super::Graphics::Direct3D9::D3DPOOL, usage: u32, dxvatype: DXVA2_VideoRenderTargetType, ppsurface: *mut ::windows::core::RawPtr, psharedhandle: *mut super::super::Foundation::HANDLE) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcallbacks: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Direct3D9")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pvideodesc: *const DXVA2_VideoDesc, pcount: *mut u32, pguids: *mut *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D9"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D9")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, videoprocdeviceguid: *const ::windows::core::GUID, pvideodesc: *const DXVA2_VideoDesc, pcount: *mut u32, pformats: *mut *mut super::super::Graphics::Direct3D9::D3DFORMAT) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D9"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D9")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, videoprocdeviceguid: *const ::windows::core::GUID, pvideodesc: *const DXVA2_VideoDesc, rendertargetformat: super::super::Graphics::Direct3D9::D3DFORMAT, pcount: *mut u32, pformats: *mut *mut super::super::Graphics::Direct3D9::D3DFORMAT) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D9"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D9")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, videoprocdeviceguid: *const ::windows::core::GUID, pvideodesc: *const DXVA2_VideoDesc, rendertargetformat: super::super::Graphics::Direct3D9::D3DFORMAT, pcaps: *mut DXVA2_VideoProcessorCaps) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D9"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D9")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, videoprocdeviceguid: *const ::windows::core::GUID, pvideodesc: *const DXVA2_VideoDesc, rendertargetformat: super::super::Graphics::Direct3D9::D3DFORMAT, procampcap: u32, prange: *mut DXVA2_ValueRange) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D9"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D9")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, videoprocdeviceguid: *const ::windows::core::GUID, pvideodesc: *const DXVA2_VideoDesc, rendertargetformat: super::super::Graphics::Direct3D9::D3DFORMAT, filtersetting: u32, prange: *mut DXVA2_ValueRange) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D9"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D9")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, videoprocdeviceguid: *const ::windows::core::GUID, pvideodesc: *const DXVA2_VideoDesc, rendertargetformat: super::super::Graphics::Direct3D9::D3DFORMAT, maxnumsubstreams: u32, ppvidprocess: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D9"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IEVRFilterConfig(pub ::windows::core::IUnknown);
impl IEVRFilterConfig {
pub unsafe fn SetNumberOfStreams(&self, dwmaxstreams: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwmaxstreams)).ok()
}
pub unsafe fn GetNumberOfStreams(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
}
unsafe impl ::windows::core::Interface for IEVRFilterConfig {
type Vtable = IEVRFilterConfig_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x83e91e85_82c1_4ea7_801d_85dc50b75086);
}
impl ::core::convert::From<IEVRFilterConfig> for ::windows::core::IUnknown {
fn from(value: IEVRFilterConfig) -> Self {
value.0
}
}
impl ::core::convert::From<&IEVRFilterConfig> for ::windows::core::IUnknown {
fn from(value: &IEVRFilterConfig) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IEVRFilterConfig {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IEVRFilterConfig {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IEVRFilterConfig_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwmaxstreams: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwmaxstreams: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IEVRFilterConfigEx(pub ::windows::core::IUnknown);
impl IEVRFilterConfigEx {
pub unsafe fn SetNumberOfStreams(&self, dwmaxstreams: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwmaxstreams)).ok()
}
pub unsafe fn GetNumberOfStreams(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetConfigPrefs(&self, dwconfigflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwconfigflags)).ok()
}
pub unsafe fn GetConfigPrefs(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
}
unsafe impl ::windows::core::Interface for IEVRFilterConfigEx {
type Vtable = IEVRFilterConfigEx_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xaea36028_796d_454f_beee_b48071e24304);
}
impl ::core::convert::From<IEVRFilterConfigEx> for ::windows::core::IUnknown {
fn from(value: IEVRFilterConfigEx) -> Self {
value.0
}
}
impl ::core::convert::From<&IEVRFilterConfigEx> for ::windows::core::IUnknown {
fn from(value: &IEVRFilterConfigEx) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IEVRFilterConfigEx {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IEVRFilterConfigEx {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IEVRFilterConfigEx> for IEVRFilterConfig {
fn from(value: IEVRFilterConfigEx) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IEVRFilterConfigEx> for IEVRFilterConfig {
fn from(value: &IEVRFilterConfigEx) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IEVRFilterConfig> for IEVRFilterConfigEx {
fn into_param(self) -> ::windows::core::Param<'a, IEVRFilterConfig> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IEVRFilterConfig> for &IEVRFilterConfigEx {
fn into_param(self) -> ::windows::core::Param<'a, IEVRFilterConfig> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IEVRFilterConfigEx_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwmaxstreams: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwmaxstreams: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwconfigflags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwconfigflags: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IEVRTrustedVideoPlugin(pub ::windows::core::IUnknown);
impl IEVRTrustedVideoPlugin {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsInTrustedVideoMode(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CanConstrict(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn SetConstriction(&self, dwkpix: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwkpix)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DisableImageExport<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, bdisable: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), bdisable.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IEVRTrustedVideoPlugin {
type Vtable = IEVRTrustedVideoPlugin_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x83a4ce40_7710_494b_a893_a472049af630);
}
impl ::core::convert::From<IEVRTrustedVideoPlugin> for ::windows::core::IUnknown {
fn from(value: IEVRTrustedVideoPlugin) -> Self {
value.0
}
}
impl ::core::convert::From<&IEVRTrustedVideoPlugin> for ::windows::core::IUnknown {
fn from(value: &IEVRTrustedVideoPlugin) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IEVRTrustedVideoPlugin {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IEVRTrustedVideoPlugin {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IEVRTrustedVideoPlugin_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pyes: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pyes: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwkpix: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bdisable: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IEVRVideoStreamControl(pub ::windows::core::IUnknown);
impl IEVRVideoStreamControl {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetStreamActiveState<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, factive: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), factive.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetStreamActiveState(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
}
unsafe impl ::windows::core::Interface for IEVRVideoStreamControl {
type Vtable = IEVRVideoStreamControl_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd0cfe38b_93e7_4772_8957_0400c49a4485);
}
impl ::core::convert::From<IEVRVideoStreamControl> for ::windows::core::IUnknown {
fn from(value: IEVRVideoStreamControl) -> Self {
value.0
}
}
impl ::core::convert::From<&IEVRVideoStreamControl> for ::windows::core::IUnknown {
fn from(value: &IEVRVideoStreamControl) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IEVRVideoStreamControl {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IEVRVideoStreamControl {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IEVRVideoStreamControl_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, factive: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, lpfactive: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IFileClient(pub ::windows::core::IUnknown);
impl IFileClient {
pub unsafe fn GetObjectDiskSize(&self, pqwsize: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pqwsize)).ok()
}
pub unsafe fn Write<'a, Param0: ::windows::core::IntoParam<'a, IFileIo>>(&self, pfio: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pfio.into_param().abi()).ok()
}
pub unsafe fn Read<'a, Param0: ::windows::core::IntoParam<'a, IFileIo>>(&self, pfio: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pfio.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IFileClient {
type Vtable = IFileClient_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbfccd196_1244_4840_ab44_480975c4ffe4);
}
impl ::core::convert::From<IFileClient> for ::windows::core::IUnknown {
fn from(value: IFileClient) -> Self {
value.0
}
}
impl ::core::convert::From<&IFileClient> for ::windows::core::IUnknown {
fn from(value: &IFileClient) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IFileClient {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IFileClient {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IFileClient_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqwsize: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfio: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfio: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IFileIo(pub ::windows::core::IUnknown);
impl IFileIo {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Initialize<'a, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, eaccessmode: FILE_ACCESSMODE, eopenmode: FILE_OPENMODE, pwszfilename: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(eaccessmode), ::core::mem::transmute(eopenmode), pwszfilename.into_param().abi()).ok()
}
pub unsafe fn GetLength(&self, pqwlength: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pqwlength)).ok()
}
pub unsafe fn SetLength(&self, qwlength: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(qwlength)).ok()
}
pub unsafe fn GetCurrentPosition(&self, pqwposition: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(pqwposition)).ok()
}
pub unsafe fn SetCurrentPosition(&self, qwposition: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(qwposition)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsEndOfStream(&self, pbendofstream: *mut super::super::Foundation::BOOL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbendofstream)).ok()
}
pub unsafe fn Read(&self, pbt: *mut u8, ul: u32, pulread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbt), ::core::mem::transmute(ul), ::core::mem::transmute(pulread)).ok()
}
pub unsafe fn Write(&self, pbt: *mut u8, ul: u32, pulwritten: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbt), ::core::mem::transmute(ul), ::core::mem::transmute(pulwritten)).ok()
}
pub unsafe fn Seek(&self, eseekorigin: SEEK_ORIGIN, qwseekoffset: u64, dwseekflags: u32, pqwcurrentposition: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(eseekorigin), ::core::mem::transmute(qwseekoffset), ::core::mem::transmute(dwseekflags), ::core::mem::transmute(pqwcurrentposition)).ok()
}
pub unsafe fn Close(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IFileIo {
type Vtable = IFileIo_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x11993196_1244_4840_ab44_480975c4ffe4);
}
impl ::core::convert::From<IFileIo> for ::windows::core::IUnknown {
fn from(value: IFileIo) -> Self {
value.0
}
}
impl ::core::convert::From<&IFileIo> for ::windows::core::IUnknown {
fn from(value: &IFileIo) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IFileIo {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IFileIo {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IFileIo_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, eaccessmode: FILE_ACCESSMODE, eopenmode: FILE_OPENMODE, pwszfilename: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqwlength: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, qwlength: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqwposition: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, qwposition: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbendofstream: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbt: *mut u8, ul: u32, pulread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbt: *mut u8, ul: u32, pulwritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, eseekorigin: SEEK_ORIGIN, qwseekoffset: u64, dwseekflags: u32, pqwcurrentposition: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMF2DBuffer(pub ::windows::core::IUnknown);
impl IMF2DBuffer {
pub unsafe fn Lock2D(&self, ppbscanline0: *mut *mut u8, plpitch: *mut i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(ppbscanline0), ::core::mem::transmute(plpitch)).ok()
}
pub unsafe fn Unlock2D(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetScanline0AndPitch(&self, pbscanline0: *mut *mut u8, plpitch: *mut i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbscanline0), ::core::mem::transmute(plpitch)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsContiguousFormat(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn GetContiguousLength(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn ContiguousCopyTo(&self, pbdestbuffer: *mut u8, cbdestbuffer: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbdestbuffer), ::core::mem::transmute(cbdestbuffer)).ok()
}
pub unsafe fn ContiguousCopyFrom(&self, pbsrcbuffer: *const u8, cbsrcbuffer: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbsrcbuffer), ::core::mem::transmute(cbsrcbuffer)).ok()
}
}
unsafe impl ::windows::core::Interface for IMF2DBuffer {
type Vtable = IMF2DBuffer_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7dc9d5f9_9ed9_44ec_9bbf_0600bb589fbb);
}
impl ::core::convert::From<IMF2DBuffer> for ::windows::core::IUnknown {
fn from(value: IMF2DBuffer) -> Self {
value.0
}
}
impl ::core::convert::From<&IMF2DBuffer> for ::windows::core::IUnknown {
fn from(value: &IMF2DBuffer) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMF2DBuffer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMF2DBuffer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMF2DBuffer_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppbscanline0: *mut *mut u8, plpitch: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbscanline0: *mut *mut u8, plpitch: *mut i32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfiscontiguous: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcblength: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbdestbuffer: *mut u8, cbdestbuffer: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbsrcbuffer: *const u8, cbsrcbuffer: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMF2DBuffer2(pub ::windows::core::IUnknown);
impl IMF2DBuffer2 {
pub unsafe fn Lock2D(&self, ppbscanline0: *mut *mut u8, plpitch: *mut i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(ppbscanline0), ::core::mem::transmute(plpitch)).ok()
}
pub unsafe fn Unlock2D(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetScanline0AndPitch(&self, pbscanline0: *mut *mut u8, plpitch: *mut i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbscanline0), ::core::mem::transmute(plpitch)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsContiguousFormat(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn GetContiguousLength(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn ContiguousCopyTo(&self, pbdestbuffer: *mut u8, cbdestbuffer: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbdestbuffer), ::core::mem::transmute(cbdestbuffer)).ok()
}
pub unsafe fn ContiguousCopyFrom(&self, pbsrcbuffer: *const u8, cbsrcbuffer: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbsrcbuffer), ::core::mem::transmute(cbsrcbuffer)).ok()
}
pub unsafe fn Lock2DSize(&self, lockflags: MF2DBuffer_LockFlags, ppbscanline0: *mut *mut u8, plpitch: *mut i32, ppbbufferstart: *mut *mut u8, pcbbufferlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(lockflags), ::core::mem::transmute(ppbscanline0), ::core::mem::transmute(plpitch), ::core::mem::transmute(ppbbufferstart), ::core::mem::transmute(pcbbufferlength)).ok()
}
pub unsafe fn Copy2DTo<'a, Param0: ::windows::core::IntoParam<'a, IMF2DBuffer2>>(&self, pdestbuffer: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), pdestbuffer.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMF2DBuffer2 {
type Vtable = IMF2DBuffer2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x33ae5ea6_4316_436f_8ddd_d73d22f829ec);
}
impl ::core::convert::From<IMF2DBuffer2> for ::windows::core::IUnknown {
fn from(value: IMF2DBuffer2) -> Self {
value.0
}
}
impl ::core::convert::From<&IMF2DBuffer2> for ::windows::core::IUnknown {
fn from(value: &IMF2DBuffer2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMF2DBuffer2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMF2DBuffer2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMF2DBuffer2> for IMF2DBuffer {
fn from(value: IMF2DBuffer2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMF2DBuffer2> for IMF2DBuffer {
fn from(value: &IMF2DBuffer2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMF2DBuffer> for IMF2DBuffer2 {
fn into_param(self) -> ::windows::core::Param<'a, IMF2DBuffer> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMF2DBuffer> for &IMF2DBuffer2 {
fn into_param(self) -> ::windows::core::Param<'a, IMF2DBuffer> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMF2DBuffer2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppbscanline0: *mut *mut u8, plpitch: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbscanline0: *mut *mut u8, plpitch: *mut i32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfiscontiguous: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcblength: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbdestbuffer: *mut u8, cbdestbuffer: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbsrcbuffer: *const u8, cbsrcbuffer: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, lockflags: MF2DBuffer_LockFlags, ppbscanline0: *mut *mut u8, plpitch: *mut i32, ppbbufferstart: *mut *mut u8, pcbbufferlength: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdestbuffer: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFASFContentInfo(pub ::windows::core::IUnknown);
impl IMFASFContentInfo {
pub unsafe fn GetHeaderSize<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaBuffer>>(&self, pistartofcontent: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pistartofcontent.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn ParseHeader<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaBuffer>>(&self, piheaderbuffer: Param0, cboffsetwithinheader: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), piheaderbuffer.into_param().abi(), ::core::mem::transmute(cboffsetwithinheader)).ok()
}
pub unsafe fn GenerateHeader<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaBuffer>>(&self, piheader: Param0, pcbheader: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), piheader.into_param().abi(), ::core::mem::transmute(pcbheader)).ok()
}
pub unsafe fn GetProfile(&self) -> ::windows::core::Result<IMFASFProfile> {
let mut result__: <IMFASFProfile as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFASFProfile>(result__)
}
pub unsafe fn SetProfile<'a, Param0: ::windows::core::IntoParam<'a, IMFASFProfile>>(&self, piprofile: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), piprofile.into_param().abi()).ok()
}
pub unsafe fn GeneratePresentationDescriptor(&self) -> ::windows::core::Result<IMFPresentationDescriptor> {
let mut result__: <IMFPresentationDescriptor as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFPresentationDescriptor>(result__)
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
pub unsafe fn GetEncodingConfigurationPropertyStore(&self, wstreamnumber: u16) -> ::windows::core::Result<super::super::UI::Shell::PropertiesSystem::IPropertyStore> {
let mut result__: <super::super::UI::Shell::PropertiesSystem::IPropertyStore as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(wstreamnumber), &mut result__).from_abi::<super::super::UI::Shell::PropertiesSystem::IPropertyStore>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFASFContentInfo {
type Vtable = IMFASFContentInfo_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb1dca5cd_d5da_4451_8e9e_db5c59914ead);
}
impl ::core::convert::From<IMFASFContentInfo> for ::windows::core::IUnknown {
fn from(value: IMFASFContentInfo) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFASFContentInfo> for ::windows::core::IUnknown {
fn from(value: &IMFASFContentInfo) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFASFContentInfo {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFASFContentInfo {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFASFContentInfo_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pistartofcontent: ::windows::core::RawPtr, cbheadersize: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, piheaderbuffer: ::windows::core::RawPtr, cboffsetwithinheader: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, piheader: ::windows::core::RawPtr, pcbheader: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppiprofile: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, piprofile: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppipresentationdescriptor: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, wstreamnumber: u16, ppistore: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFASFIndexer(pub ::windows::core::IUnknown);
impl IMFASFIndexer {
pub unsafe fn SetFlags(&self, dwflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwflags)).ok()
}
pub unsafe fn GetFlags(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn Initialize<'a, Param0: ::windows::core::IntoParam<'a, IMFASFContentInfo>>(&self, picontentinfo: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), picontentinfo.into_param().abi()).ok()
}
pub unsafe fn GetIndexPosition<'a, Param0: ::windows::core::IntoParam<'a, IMFASFContentInfo>>(&self, picontentinfo: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), picontentinfo.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn SetIndexByteStreams(&self, ppibytestreams: *const ::core::option::Option<IMFByteStream>, cbytestreams: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(ppibytestreams), ::core::mem::transmute(cbytestreams)).ok()
}
pub unsafe fn GetIndexByteStreamCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetIndexStatus(&self, pindexidentifier: *const ASF_INDEX_IDENTIFIER, pfisindexed: *mut super::super::Foundation::BOOL, pbindexdescriptor: *mut u8, pcbindexdescriptor: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(pindexidentifier), ::core::mem::transmute(pfisindexed), ::core::mem::transmute(pbindexdescriptor), ::core::mem::transmute(pcbindexdescriptor)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetIndexStatus<'a, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, pbindexdescriptor: *const u8, cbindexdescriptor: u32, fgenerateindex: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbindexdescriptor), ::core::mem::transmute(cbindexdescriptor), fgenerateindex.into_param().abi()).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetSeekPositionForValue(&self, pvarvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pindexidentifier: *const ASF_INDEX_IDENTIFIER, pcboffsetwithindata: *mut u64, phnsapproxtime: *mut i64, pdwpayloadnumberofstreamwithinpacket: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(pvarvalue), ::core::mem::transmute(pindexidentifier), ::core::mem::transmute(pcboffsetwithindata), ::core::mem::transmute(phnsapproxtime), ::core::mem::transmute(pdwpayloadnumberofstreamwithinpacket)).ok()
}
pub unsafe fn GenerateIndexEntries<'a, Param0: ::windows::core::IntoParam<'a, IMFSample>>(&self, piasfpacketsample: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), piasfpacketsample.into_param().abi()).ok()
}
pub unsafe fn CommitIndex<'a, Param0: ::windows::core::IntoParam<'a, IMFASFContentInfo>>(&self, picontentinfo: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), picontentinfo.into_param().abi()).ok()
}
pub unsafe fn GetIndexWriteSpace(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetCompletedIndex<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaBuffer>>(&self, piindexbuffer: Param0, cboffsetwithinindex: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), piindexbuffer.into_param().abi(), ::core::mem::transmute(cboffsetwithinindex)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFASFIndexer {
type Vtable = IMFASFIndexer_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x53590f48_dc3b_4297_813f_787761ad7b3e);
}
impl ::core::convert::From<IMFASFIndexer> for ::windows::core::IUnknown {
fn from(value: IMFASFIndexer) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFASFIndexer> for ::windows::core::IUnknown {
fn from(value: &IMFASFIndexer) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFASFIndexer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFASFIndexer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFASFIndexer_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwflags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwflags: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, picontentinfo: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, picontentinfo: ::windows::core::RawPtr, pcbindexoffset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppibytestreams: *const ::windows::core::RawPtr, cbytestreams: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcbytestreams: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pindexidentifier: *const ASF_INDEX_IDENTIFIER, pfisindexed: *mut super::super::Foundation::BOOL, pbindexdescriptor: *mut u8, pcbindexdescriptor: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbindexdescriptor: *const u8, cbindexdescriptor: u32, fgenerateindex: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pvarvalue: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>, pindexidentifier: *const ASF_INDEX_IDENTIFIER, pcboffsetwithindata: *mut u64, phnsapproxtime: *mut i64, pdwpayloadnumberofstreamwithinpacket: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, piasfpacketsample: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, picontentinfo: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcbindexwritespace: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, piindexbuffer: ::windows::core::RawPtr, cboffsetwithinindex: u64) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFASFMultiplexer(pub ::windows::core::IUnknown);
impl IMFASFMultiplexer {
pub unsafe fn Initialize<'a, Param0: ::windows::core::IntoParam<'a, IMFASFContentInfo>>(&self, picontentinfo: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), picontentinfo.into_param().abi()).ok()
}
pub unsafe fn SetFlags(&self, dwflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwflags)).ok()
}
pub unsafe fn GetFlags(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn ProcessSample<'a, Param1: ::windows::core::IntoParam<'a, IMFSample>>(&self, wstreamnumber: u16, pisample: Param1, hnstimestampadjust: i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(wstreamnumber), pisample.into_param().abi(), ::core::mem::transmute(hnstimestampadjust)).ok()
}
pub unsafe fn GetNextPacket(&self, pdwstatusflags: *mut u32, ppipacket: *mut ::core::option::Option<IMFSample>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdwstatusflags), ::core::mem::transmute(ppipacket)).ok()
}
pub unsafe fn Flush(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn End<'a, Param0: ::windows::core::IntoParam<'a, IMFASFContentInfo>>(&self, picontentinfo: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), picontentinfo.into_param().abi()).ok()
}
pub unsafe fn GetStatistics(&self, wstreamnumber: u16) -> ::windows::core::Result<ASF_MUX_STATISTICS> {
let mut result__: <ASF_MUX_STATISTICS as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(wstreamnumber), &mut result__).from_abi::<ASF_MUX_STATISTICS>(result__)
}
pub unsafe fn SetSyncTolerance(&self, mssynctolerance: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(mssynctolerance)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFASFMultiplexer {
type Vtable = IMFASFMultiplexer_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x57bdd80a_9b38_4838_b737_c58f670d7d4f);
}
impl ::core::convert::From<IMFASFMultiplexer> for ::windows::core::IUnknown {
fn from(value: IMFASFMultiplexer) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFASFMultiplexer> for ::windows::core::IUnknown {
fn from(value: &IMFASFMultiplexer) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFASFMultiplexer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFASFMultiplexer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFASFMultiplexer_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, picontentinfo: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwflags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwflags: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, wstreamnumber: u16, pisample: ::windows::core::RawPtr, hnstimestampadjust: i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwstatusflags: *mut u32, ppipacket: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, picontentinfo: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, wstreamnumber: u16, pmuxstats: *mut ASF_MUX_STATISTICS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mssynctolerance: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFASFMutualExclusion(pub ::windows::core::IUnknown);
impl IMFASFMutualExclusion {
pub unsafe fn GetType(&self) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
pub unsafe fn SetType(&self, guidtype: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidtype)).ok()
}
pub unsafe fn GetRecordCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetStreamsForRecord(&self, dwrecordnumber: u32, pwstreamnumarray: *mut u16, pcstreams: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwrecordnumber), ::core::mem::transmute(pwstreamnumarray), ::core::mem::transmute(pcstreams)).ok()
}
pub unsafe fn AddStreamForRecord(&self, dwrecordnumber: u32, wstreamnumber: u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwrecordnumber), ::core::mem::transmute(wstreamnumber)).ok()
}
pub unsafe fn RemoveStreamFromRecord(&self, dwrecordnumber: u32, wstreamnumber: u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwrecordnumber), ::core::mem::transmute(wstreamnumber)).ok()
}
pub unsafe fn RemoveRecord(&self, dwrecordnumber: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwrecordnumber)).ok()
}
pub unsafe fn AddRecord(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn Clone(&self) -> ::windows::core::Result<IMFASFMutualExclusion> {
let mut result__: <IMFASFMutualExclusion as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFASFMutualExclusion>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFASFMutualExclusion {
type Vtable = IMFASFMutualExclusion_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x12558291_e399_11d5_bc2a_00b0d0f3f4ab);
}
impl ::core::convert::From<IMFASFMutualExclusion> for ::windows::core::IUnknown {
fn from(value: IMFASFMutualExclusion) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFASFMutualExclusion> for ::windows::core::IUnknown {
fn from(value: &IMFASFMutualExclusion) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFASFMutualExclusion {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFASFMutualExclusion {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFASFMutualExclusion_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pguidtype: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidtype: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwrecordcount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwrecordnumber: u32, pwstreamnumarray: *mut u16, pcstreams: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwrecordnumber: u32, wstreamnumber: u16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwrecordnumber: u32, wstreamnumber: u16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwrecordnumber: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwrecordnumber: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppimutex: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFASFProfile(pub ::windows::core::IUnknown);
impl IMFASFProfile {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItem(&self, guidkey: *const ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn GetItemType(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<MF_ATTRIBUTE_TYPE> {
let mut result__: <MF_ATTRIBUTE_TYPE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<MF_ATTRIBUTE_TYPE>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn CompareItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Compare<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, ptheirs: Param0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ptheirs.into_param().abi(), ::core::mem::transmute(matchtype), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn GetUINT32(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetUINT64(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetDouble(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<f64> {
let mut result__: <f64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<f64>(result__)
}
pub unsafe fn GetGUID(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
pub unsafe fn GetStringLength(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetString(&self, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pwszvalue), ::core::mem::transmute(cchbufsize), ::core::mem::transmute(pcchlength)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetAllocatedString(&self, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppwszvalue), ::core::mem::transmute(pcchlength)).ok()
}
pub unsafe fn GetBlobSize(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize), ::core::mem::transmute(pcbblobsize)).ok()
}
pub unsafe fn GetAllocatedBlob(&self, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppbuf), ::core::mem::transmute(pcbsize)).ok()
}
pub unsafe fn GetUnknown<T: ::windows::core::Interface>(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn SetItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value)).ok()
}
pub unsafe fn DeleteItem(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey)).ok()
}
pub unsafe fn DeleteAllItems(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetUINT32(&self, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetUINT64(&self, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetDouble(&self, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(fvalue)).ok()
}
pub unsafe fn SetGUID(&self, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(guidvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetString<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, guidkey: *const ::windows::core::GUID, wszvalue: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), wszvalue.into_param().abi()).ok()
}
pub unsafe fn SetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize)).ok()
}
pub unsafe fn SetUnknown<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guidkey: *const ::windows::core::GUID, punknown: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), punknown.into_param().abi()).ok()
}
pub unsafe fn LockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn UnlockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(unindex), ::core::mem::transmute(pguidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn CopyAllItems<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, pdest: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), pdest.into_param().abi()).ok()
}
pub unsafe fn GetStreamCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetStream(&self, dwstreamindex: u32, pwstreamnumber: *mut u16, ppistream: *mut ::core::option::Option<IMFASFStreamConfig>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(pwstreamnumber), ::core::mem::transmute(ppistream)).ok()
}
pub unsafe fn GetStreamByNumber(&self, wstreamnumber: u16) -> ::windows::core::Result<IMFASFStreamConfig> {
let mut result__: <IMFASFStreamConfig as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), ::core::mem::transmute(wstreamnumber), &mut result__).from_abi::<IMFASFStreamConfig>(result__)
}
pub unsafe fn SetStream<'a, Param0: ::windows::core::IntoParam<'a, IMFASFStreamConfig>>(&self, pistream: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), pistream.into_param().abi()).ok()
}
pub unsafe fn RemoveStream(&self, wstreamnumber: u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), ::core::mem::transmute(wstreamnumber)).ok()
}
pub unsafe fn CreateStream<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaType>>(&self, pimediatype: Param0) -> ::windows::core::Result<IMFASFStreamConfig> {
let mut result__: <IMFASFStreamConfig as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self), pimediatype.into_param().abi(), &mut result__).from_abi::<IMFASFStreamConfig>(result__)
}
pub unsafe fn GetMutualExclusionCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetMutualExclusion(&self, dwmutexindex: u32) -> ::windows::core::Result<IMFASFMutualExclusion> {
let mut result__: <IMFASFMutualExclusion as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).40)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwmutexindex), &mut result__).from_abi::<IMFASFMutualExclusion>(result__)
}
pub unsafe fn AddMutualExclusion<'a, Param0: ::windows::core::IntoParam<'a, IMFASFMutualExclusion>>(&self, pimutex: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), pimutex.into_param().abi()).ok()
}
pub unsafe fn RemoveMutualExclusion(&self, dwmutexindex: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwmutexindex)).ok()
}
pub unsafe fn CreateMutualExclusion(&self) -> ::windows::core::Result<IMFASFMutualExclusion> {
let mut result__: <IMFASFMutualExclusion as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFASFMutualExclusion>(result__)
}
pub unsafe fn GetStreamPrioritization(&self) -> ::windows::core::Result<IMFASFStreamPrioritization> {
let mut result__: <IMFASFStreamPrioritization as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).44)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFASFStreamPrioritization>(result__)
}
pub unsafe fn AddStreamPrioritization<'a, Param0: ::windows::core::IntoParam<'a, IMFASFStreamPrioritization>>(&self, pistreamprioritization: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).45)(::core::mem::transmute_copy(self), pistreamprioritization.into_param().abi()).ok()
}
pub unsafe fn RemoveStreamPrioritization(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).46)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn CreateStreamPrioritization(&self) -> ::windows::core::Result<IMFASFStreamPrioritization> {
let mut result__: <IMFASFStreamPrioritization as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).47)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFASFStreamPrioritization>(result__)
}
pub unsafe fn Clone(&self) -> ::windows::core::Result<IMFASFProfile> {
let mut result__: <IMFASFProfile as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).48)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFASFProfile>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFASFProfile {
type Vtable = IMFASFProfile_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd267bf6a_028b_4e0d_903d_43f0ef82d0d4);
}
impl ::core::convert::From<IMFASFProfile> for ::windows::core::IUnknown {
fn from(value: IMFASFProfile) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFASFProfile> for ::windows::core::IUnknown {
fn from(value: &IMFASFProfile) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFASFProfile {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFASFProfile {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFASFProfile> for IMFAttributes {
fn from(value: IMFASFProfile) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFASFProfile> for IMFAttributes {
fn from(value: &IMFASFProfile) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for IMFASFProfile {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for &IMFASFProfile {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFASFProfile_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ptype: *mut MF_ATTRIBUTE_TYPE) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptheirs: ::windows::core::RawPtr, matchtype: MF_ATTRIBUTES_MATCH_TYPE, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pfvalue: *mut f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pguidvalue: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, wszvalue: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punknown: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcitems: *mut u32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdest: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcstreams: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, pwstreamnumber: *mut u16, ppistream: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, wstreamnumber: u16, ppistream: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pistream: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, wstreamnumber: u16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pimediatype: ::windows::core::RawPtr, ppistream: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcmutexs: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwmutexindex: u32, ppimutex: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pimutex: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwmutexindex: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppimutex: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppistreamprioritization: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pistreamprioritization: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppistreamprioritization: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppiprofile: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFASFSplitter(pub ::windows::core::IUnknown);
impl IMFASFSplitter {
pub unsafe fn Initialize<'a, Param0: ::windows::core::IntoParam<'a, IMFASFContentInfo>>(&self, picontentinfo: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), picontentinfo.into_param().abi()).ok()
}
pub unsafe fn SetFlags(&self, dwflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwflags)).ok()
}
pub unsafe fn GetFlags(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SelectStreams(&self, pwstreamnumbers: *const u16, wnumstreams: u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(pwstreamnumbers), ::core::mem::transmute(wnumstreams)).ok()
}
pub unsafe fn GetSelectedStreams(&self, pwstreamnumbers: *mut u16, pwnumstreams: *mut u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(pwstreamnumbers), ::core::mem::transmute(pwnumstreams)).ok()
}
pub unsafe fn ParseData<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaBuffer>>(&self, pibuffer: Param0, cbbufferoffset: u32, cblength: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), pibuffer.into_param().abi(), ::core::mem::transmute(cbbufferoffset), ::core::mem::transmute(cblength)).ok()
}
pub unsafe fn GetNextSample(&self, pdwstatusflags: *mut ASF_STATUSFLAGS, pwstreamnumber: *mut u16, ppisample: *mut ::core::option::Option<IMFSample>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdwstatusflags), ::core::mem::transmute(pwstreamnumber), ::core::mem::transmute(ppisample)).ok()
}
pub unsafe fn Flush(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetLastSendTime(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFASFSplitter {
type Vtable = IMFASFSplitter_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x12558295_e399_11d5_bc2a_00b0d0f3f4ab);
}
impl ::core::convert::From<IMFASFSplitter> for ::windows::core::IUnknown {
fn from(value: IMFASFSplitter) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFASFSplitter> for ::windows::core::IUnknown {
fn from(value: &IMFASFSplitter) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFASFSplitter {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFASFSplitter {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFASFSplitter_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, picontentinfo: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwflags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwflags: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pwstreamnumbers: *const u16, wnumstreams: u16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pwstreamnumbers: *mut u16, pwnumstreams: *mut u16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pibuffer: ::windows::core::RawPtr, cbbufferoffset: u32, cblength: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwstatusflags: *mut ASF_STATUSFLAGS, pwstreamnumber: *mut u16, ppisample: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwlastsendtime: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFASFStreamConfig(pub ::windows::core::IUnknown);
impl IMFASFStreamConfig {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItem(&self, guidkey: *const ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn GetItemType(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<MF_ATTRIBUTE_TYPE> {
let mut result__: <MF_ATTRIBUTE_TYPE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<MF_ATTRIBUTE_TYPE>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn CompareItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Compare<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, ptheirs: Param0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ptheirs.into_param().abi(), ::core::mem::transmute(matchtype), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn GetUINT32(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetUINT64(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetDouble(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<f64> {
let mut result__: <f64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<f64>(result__)
}
pub unsafe fn GetGUID(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
pub unsafe fn GetStringLength(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetString(&self, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pwszvalue), ::core::mem::transmute(cchbufsize), ::core::mem::transmute(pcchlength)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetAllocatedString(&self, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppwszvalue), ::core::mem::transmute(pcchlength)).ok()
}
pub unsafe fn GetBlobSize(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize), ::core::mem::transmute(pcbblobsize)).ok()
}
pub unsafe fn GetAllocatedBlob(&self, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppbuf), ::core::mem::transmute(pcbsize)).ok()
}
pub unsafe fn GetUnknown<T: ::windows::core::Interface>(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn SetItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value)).ok()
}
pub unsafe fn DeleteItem(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey)).ok()
}
pub unsafe fn DeleteAllItems(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetUINT32(&self, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetUINT64(&self, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetDouble(&self, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(fvalue)).ok()
}
pub unsafe fn SetGUID(&self, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(guidvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetString<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, guidkey: *const ::windows::core::GUID, wszvalue: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), wszvalue.into_param().abi()).ok()
}
pub unsafe fn SetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize)).ok()
}
pub unsafe fn SetUnknown<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guidkey: *const ::windows::core::GUID, punknown: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), punknown.into_param().abi()).ok()
}
pub unsafe fn LockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn UnlockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(unindex), ::core::mem::transmute(pguidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn CopyAllItems<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, pdest: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), pdest.into_param().abi()).ok()
}
pub unsafe fn GetStreamType(&self) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
pub unsafe fn GetStreamNumber(&self) -> u16 {
::core::mem::transmute((::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self)))
}
pub unsafe fn SetStreamNumber(&self, wstreamnum: u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), ::core::mem::transmute(wstreamnum)).ok()
}
pub unsafe fn GetMediaType(&self) -> ::windows::core::Result<IMFMediaType> {
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFMediaType>(result__)
}
pub unsafe fn SetMediaType<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaType>>(&self, pimediatype: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), pimediatype.into_param().abi()).ok()
}
pub unsafe fn GetPayloadExtensionCount(&self) -> ::windows::core::Result<u16> {
let mut result__: <u16 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u16>(result__)
}
pub unsafe fn GetPayloadExtension(&self, wpayloadextensionnumber: u16, pguidextensionsystemid: *mut ::windows::core::GUID, pcbextensiondatasize: *mut u16, pbextensionsysteminfo: *mut u8, pcbextensionsysteminfo: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), ::core::mem::transmute(wpayloadextensionnumber), ::core::mem::transmute(pguidextensionsystemid), ::core::mem::transmute(pcbextensiondatasize), ::core::mem::transmute(pbextensionsysteminfo), ::core::mem::transmute(pcbextensionsysteminfo)).ok()
}
pub unsafe fn AddPayloadExtension<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::GUID>>(&self, guidextensionsystemid: Param0, cbextensiondatasize: u16, pbextensionsysteminfo: *const u8, cbextensionsysteminfo: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).40)(::core::mem::transmute_copy(self), guidextensionsystemid.into_param().abi(), ::core::mem::transmute(cbextensiondatasize), ::core::mem::transmute(pbextensionsysteminfo), ::core::mem::transmute(cbextensionsysteminfo)).ok()
}
pub unsafe fn RemoveAllPayloadExtensions(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Clone(&self) -> ::windows::core::Result<IMFASFStreamConfig> {
let mut result__: <IMFASFStreamConfig as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFASFStreamConfig>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFASFStreamConfig {
type Vtable = IMFASFStreamConfig_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9e8ae8d2_dbbd_4200_9aca_06e6df484913);
}
impl ::core::convert::From<IMFASFStreamConfig> for ::windows::core::IUnknown {
fn from(value: IMFASFStreamConfig) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFASFStreamConfig> for ::windows::core::IUnknown {
fn from(value: &IMFASFStreamConfig) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFASFStreamConfig {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFASFStreamConfig {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFASFStreamConfig> for IMFAttributes {
fn from(value: IMFASFStreamConfig) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFASFStreamConfig> for IMFAttributes {
fn from(value: &IMFASFStreamConfig) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for IMFASFStreamConfig {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for &IMFASFStreamConfig {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFASFStreamConfig_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ptype: *mut MF_ATTRIBUTE_TYPE) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptheirs: ::windows::core::RawPtr, matchtype: MF_ATTRIBUTES_MATCH_TYPE, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pfvalue: *mut f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pguidvalue: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, wszvalue: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punknown: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcitems: *mut u32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdest: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pguidstreamtype: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u16,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, wstreamnum: u16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppimediatype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pimediatype: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcpayloadextensions: *mut u16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, wpayloadextensionnumber: u16, pguidextensionsystemid: *mut ::windows::core::GUID, pcbextensiondatasize: *mut u16, pbextensionsysteminfo: *mut u8, pcbextensionsysteminfo: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidextensionsystemid: ::windows::core::GUID, cbextensiondatasize: u16, pbextensionsysteminfo: *const u8, cbextensionsysteminfo: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppistreamconfig: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFASFStreamPrioritization(pub ::windows::core::IUnknown);
impl IMFASFStreamPrioritization {
pub unsafe fn GetStreamCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetStream(&self, dwstreamindex: u32, pwstreamnumber: *mut u16, pwstreamflags: *mut u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(pwstreamnumber), ::core::mem::transmute(pwstreamflags)).ok()
}
pub unsafe fn AddStream(&self, wstreamnumber: u16, wstreamflags: u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(wstreamnumber), ::core::mem::transmute(wstreamflags)).ok()
}
pub unsafe fn RemoveStream(&self, dwstreamindex: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex)).ok()
}
pub unsafe fn Clone(&self) -> ::windows::core::Result<IMFASFStreamPrioritization> {
let mut result__: <IMFASFStreamPrioritization as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFASFStreamPrioritization>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFASFStreamPrioritization {
type Vtable = IMFASFStreamPrioritization_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x699bdc27_bbaf_49ff_8e38_9c39c9b5e088);
}
impl ::core::convert::From<IMFASFStreamPrioritization> for ::windows::core::IUnknown {
fn from(value: IMFASFStreamPrioritization) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFASFStreamPrioritization> for ::windows::core::IUnknown {
fn from(value: &IMFASFStreamPrioritization) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFASFStreamPrioritization {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFASFStreamPrioritization {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFASFStreamPrioritization_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwstreamcount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, pwstreamnumber: *mut u16, pwstreamflags: *mut u16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, wstreamnumber: u16, wstreamflags: u16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppistreamprioritization: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFASFStreamSelector(pub ::windows::core::IUnknown);
impl IMFASFStreamSelector {
pub unsafe fn GetStreamCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetOutputCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetOutputStreamCount(&self, dwoutputnum: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwoutputnum), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetOutputStreamNumbers(&self, dwoutputnum: u32) -> ::windows::core::Result<u16> {
let mut result__: <u16 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwoutputnum), &mut result__).from_abi::<u16>(result__)
}
pub unsafe fn GetOutputFromStream(&self, wstreamnum: u16) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(wstreamnum), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetOutputOverride(&self, dwoutputnum: u32) -> ::windows::core::Result<ASF_SELECTION_STATUS> {
let mut result__: <ASF_SELECTION_STATUS as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwoutputnum), &mut result__).from_abi::<ASF_SELECTION_STATUS>(result__)
}
pub unsafe fn SetOutputOverride(&self, dwoutputnum: u32, selection: ASF_SELECTION_STATUS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwoutputnum), ::core::mem::transmute(selection)).ok()
}
pub unsafe fn GetOutputMutexCount(&self, dwoutputnum: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwoutputnum), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetOutputMutex(&self, dwoutputnum: u32, dwmutexnum: u32) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwoutputnum), ::core::mem::transmute(dwmutexnum), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
pub unsafe fn SetOutputMutexSelection(&self, dwoutputnum: u32, dwmutexnum: u32, wselectedrecord: u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwoutputnum), ::core::mem::transmute(dwmutexnum), ::core::mem::transmute(wselectedrecord)).ok()
}
pub unsafe fn GetBandwidthStepCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetBandwidthStep(&self, dwstepnum: u32, pdwbitrate: *mut u32, rgwstreamnumbers: *mut u16, rgselections: *mut ASF_SELECTION_STATUS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstepnum), ::core::mem::transmute(pdwbitrate), ::core::mem::transmute(rgwstreamnumbers), ::core::mem::transmute(rgselections)).ok()
}
pub unsafe fn BitrateToStepNumber(&self, dwbitrate: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwbitrate), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetStreamSelectorFlags(&self, dwstreamselectorflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamselectorflags)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFASFStreamSelector {
type Vtable = IMFASFStreamSelector_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd01bad4a_4fa0_4a60_9349_c27e62da9d41);
}
impl ::core::convert::From<IMFASFStreamSelector> for ::windows::core::IUnknown {
fn from(value: IMFASFStreamSelector) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFASFStreamSelector> for ::windows::core::IUnknown {
fn from(value: &IMFASFStreamSelector) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFASFStreamSelector {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFASFStreamSelector {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFASFStreamSelector_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcstreams: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcoutputs: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwoutputnum: u32, pcstreams: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwoutputnum: u32, rgwstreamnumbers: *mut u16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, wstreamnum: u16, pdwoutput: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwoutputnum: u32, pselection: *mut ASF_SELECTION_STATUS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwoutputnum: u32, selection: ASF_SELECTION_STATUS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwoutputnum: u32, pcmutexes: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwoutputnum: u32, dwmutexnum: u32, ppmutex: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwoutputnum: u32, dwmutexnum: u32, wselectedrecord: u16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcstepcount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstepnum: u32, pdwbitrate: *mut u32, rgwstreamnumbers: *mut u16, rgselections: *mut ASF_SELECTION_STATUS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwbitrate: u32, pdwstepnum: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamselectorflags: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFActivate(pub ::windows::core::IUnknown);
impl IMFActivate {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItem(&self, guidkey: *const ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn GetItemType(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<MF_ATTRIBUTE_TYPE> {
let mut result__: <MF_ATTRIBUTE_TYPE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<MF_ATTRIBUTE_TYPE>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn CompareItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Compare<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, ptheirs: Param0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ptheirs.into_param().abi(), ::core::mem::transmute(matchtype), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn GetUINT32(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetUINT64(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetDouble(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<f64> {
let mut result__: <f64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<f64>(result__)
}
pub unsafe fn GetGUID(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
pub unsafe fn GetStringLength(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetString(&self, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pwszvalue), ::core::mem::transmute(cchbufsize), ::core::mem::transmute(pcchlength)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetAllocatedString(&self, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppwszvalue), ::core::mem::transmute(pcchlength)).ok()
}
pub unsafe fn GetBlobSize(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize), ::core::mem::transmute(pcbblobsize)).ok()
}
pub unsafe fn GetAllocatedBlob(&self, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppbuf), ::core::mem::transmute(pcbsize)).ok()
}
pub unsafe fn GetUnknown<T: ::windows::core::Interface>(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn SetItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value)).ok()
}
pub unsafe fn DeleteItem(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey)).ok()
}
pub unsafe fn DeleteAllItems(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetUINT32(&self, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetUINT64(&self, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetDouble(&self, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(fvalue)).ok()
}
pub unsafe fn SetGUID(&self, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(guidvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetString<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, guidkey: *const ::windows::core::GUID, wszvalue: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), wszvalue.into_param().abi()).ok()
}
pub unsafe fn SetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize)).ok()
}
pub unsafe fn SetUnknown<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guidkey: *const ::windows::core::GUID, punknown: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), punknown.into_param().abi()).ok()
}
pub unsafe fn LockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn UnlockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(unindex), ::core::mem::transmute(pguidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn CopyAllItems<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, pdest: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), pdest.into_param().abi()).ok()
}
pub unsafe fn ActivateObject<T: ::windows::core::Interface>(&self) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
pub unsafe fn ShutdownObject(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn DetachObject(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFActivate {
type Vtable = IMFActivate_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7fee9e9a_4a89_47a6_899c_b6a53a70fb67);
}
impl ::core::convert::From<IMFActivate> for ::windows::core::IUnknown {
fn from(value: IMFActivate) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFActivate> for ::windows::core::IUnknown {
fn from(value: &IMFActivate) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFActivate {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFActivate {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFActivate> for IMFAttributes {
fn from(value: IMFActivate) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFActivate> for IMFAttributes {
fn from(value: &IMFActivate) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for IMFActivate {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for &IMFActivate {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFActivate_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ptype: *mut MF_ATTRIBUTE_TYPE) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptheirs: ::windows::core::RawPtr, matchtype: MF_ATTRIBUTES_MATCH_TYPE, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pfvalue: *mut f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pguidvalue: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, wszvalue: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punknown: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcitems: *mut u32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdest: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFAsyncCallback(pub ::windows::core::IUnknown);
impl IMFAsyncCallback {
pub unsafe fn GetParameters(&self, pdwflags: *mut u32, pdwqueue: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdwflags), ::core::mem::transmute(pdwqueue)).ok()
}
pub unsafe fn Invoke<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, pasyncresult: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pasyncresult.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFAsyncCallback {
type Vtable = IMFAsyncCallback_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa27003cf_2354_4f2a_8d6a_ab7cff15437e);
}
impl ::core::convert::From<IMFAsyncCallback> for ::windows::core::IUnknown {
fn from(value: IMFAsyncCallback) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFAsyncCallback> for ::windows::core::IUnknown {
fn from(value: &IMFAsyncCallback) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFAsyncCallback {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFAsyncCallback {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFAsyncCallback_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwflags: *mut u32, pdwqueue: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pasyncresult: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFAsyncCallbackLogging(pub ::windows::core::IUnknown);
impl IMFAsyncCallbackLogging {
pub unsafe fn GetParameters(&self, pdwflags: *mut u32, pdwqueue: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdwflags), ::core::mem::transmute(pdwqueue)).ok()
}
pub unsafe fn Invoke<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, pasyncresult: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pasyncresult.into_param().abi()).ok()
}
pub unsafe fn GetObjectPointer(&self) -> *mut ::core::ffi::c_void {
::core::mem::transmute((::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetObjectTag(&self) -> u32 {
::core::mem::transmute((::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self)))
}
}
unsafe impl ::windows::core::Interface for IMFAsyncCallbackLogging {
type Vtable = IMFAsyncCallbackLogging_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc7a4dca1_f5f0_47b6_b92b_bf0106d25791);
}
impl ::core::convert::From<IMFAsyncCallbackLogging> for ::windows::core::IUnknown {
fn from(value: IMFAsyncCallbackLogging) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFAsyncCallbackLogging> for ::windows::core::IUnknown {
fn from(value: &IMFAsyncCallbackLogging) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFAsyncCallbackLogging {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFAsyncCallbackLogging {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFAsyncCallbackLogging> for IMFAsyncCallback {
fn from(value: IMFAsyncCallbackLogging) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFAsyncCallbackLogging> for IMFAsyncCallback {
fn from(value: &IMFAsyncCallbackLogging) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAsyncCallback> for IMFAsyncCallbackLogging {
fn into_param(self) -> ::windows::core::Param<'a, IMFAsyncCallback> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAsyncCallback> for &IMFAsyncCallbackLogging {
fn into_param(self) -> ::windows::core::Param<'a, IMFAsyncCallback> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFAsyncCallbackLogging_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwflags: *mut u32, pdwqueue: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pasyncresult: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> *mut ::core::ffi::c_void,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFAsyncResult(pub ::windows::core::IUnknown);
impl IMFAsyncResult {
pub unsafe fn GetState(&self) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
pub unsafe fn GetStatus(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetStatus(&self, hrstatus: ::windows::core::HRESULT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(hrstatus)).ok()
}
pub unsafe fn GetObject(&self) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
pub unsafe fn GetStateNoAddRef(&self) -> ::core::option::Option<::windows::core::IUnknown> {
::core::mem::transmute((::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)))
}
}
unsafe impl ::windows::core::Interface for IMFAsyncResult {
type Vtable = IMFAsyncResult_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xac6b7889_0740_4d51_8619_905994a55cc6);
}
impl ::core::convert::From<IMFAsyncResult> for ::windows::core::IUnknown {
fn from(value: IMFAsyncResult) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFAsyncResult> for ::windows::core::IUnknown {
fn from(value: &IMFAsyncResult) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFAsyncResult {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFAsyncResult {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFAsyncResult_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppunkstate: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hrstatus: ::windows::core::HRESULT) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppobject: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::RawPtr,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFAttributes(pub ::windows::core::IUnknown);
impl IMFAttributes {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItem(&self, guidkey: *const ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn GetItemType(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<MF_ATTRIBUTE_TYPE> {
let mut result__: <MF_ATTRIBUTE_TYPE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<MF_ATTRIBUTE_TYPE>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn CompareItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Compare<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, ptheirs: Param0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ptheirs.into_param().abi(), ::core::mem::transmute(matchtype), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn GetUINT32(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetUINT64(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetDouble(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<f64> {
let mut result__: <f64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<f64>(result__)
}
pub unsafe fn GetGUID(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
pub unsafe fn GetStringLength(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetString(&self, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pwszvalue), ::core::mem::transmute(cchbufsize), ::core::mem::transmute(pcchlength)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetAllocatedString(&self, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppwszvalue), ::core::mem::transmute(pcchlength)).ok()
}
pub unsafe fn GetBlobSize(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize), ::core::mem::transmute(pcbblobsize)).ok()
}
pub unsafe fn GetAllocatedBlob(&self, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppbuf), ::core::mem::transmute(pcbsize)).ok()
}
pub unsafe fn GetUnknown<T: ::windows::core::Interface>(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn SetItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value)).ok()
}
pub unsafe fn DeleteItem(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey)).ok()
}
pub unsafe fn DeleteAllItems(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetUINT32(&self, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetUINT64(&self, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetDouble(&self, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(fvalue)).ok()
}
pub unsafe fn SetGUID(&self, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(guidvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetString<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, guidkey: *const ::windows::core::GUID, wszvalue: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), wszvalue.into_param().abi()).ok()
}
pub unsafe fn SetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize)).ok()
}
pub unsafe fn SetUnknown<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guidkey: *const ::windows::core::GUID, punknown: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), punknown.into_param().abi()).ok()
}
pub unsafe fn LockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn UnlockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(unindex), ::core::mem::transmute(pguidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn CopyAllItems<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, pdest: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), pdest.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFAttributes {
type Vtable = IMFAttributes_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2cd2d921_c447_44a7_a13c_4adabfc247e3);
}
impl ::core::convert::From<IMFAttributes> for ::windows::core::IUnknown {
fn from(value: IMFAttributes) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFAttributes> for ::windows::core::IUnknown {
fn from(value: &IMFAttributes) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFAttributes {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFAttributes {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFAttributes_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ptype: *mut MF_ATTRIBUTE_TYPE) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptheirs: ::windows::core::RawPtr, matchtype: MF_ATTRIBUTES_MATCH_TYPE, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pfvalue: *mut f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pguidvalue: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, wszvalue: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punknown: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcitems: *mut u32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdest: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFAudioMediaType(pub ::windows::core::IUnknown);
impl IMFAudioMediaType {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItem(&self, guidkey: *const ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn GetItemType(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<MF_ATTRIBUTE_TYPE> {
let mut result__: <MF_ATTRIBUTE_TYPE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<MF_ATTRIBUTE_TYPE>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn CompareItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Compare<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, ptheirs: Param0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ptheirs.into_param().abi(), ::core::mem::transmute(matchtype), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn GetUINT32(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetUINT64(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetDouble(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<f64> {
let mut result__: <f64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<f64>(result__)
}
pub unsafe fn GetGUID(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
pub unsafe fn GetStringLength(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetString(&self, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pwszvalue), ::core::mem::transmute(cchbufsize), ::core::mem::transmute(pcchlength)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetAllocatedString(&self, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppwszvalue), ::core::mem::transmute(pcchlength)).ok()
}
pub unsafe fn GetBlobSize(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize), ::core::mem::transmute(pcbblobsize)).ok()
}
pub unsafe fn GetAllocatedBlob(&self, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppbuf), ::core::mem::transmute(pcbsize)).ok()
}
pub unsafe fn GetUnknown<T: ::windows::core::Interface>(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn SetItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value)).ok()
}
pub unsafe fn DeleteItem(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey)).ok()
}
pub unsafe fn DeleteAllItems(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetUINT32(&self, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetUINT64(&self, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetDouble(&self, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(fvalue)).ok()
}
pub unsafe fn SetGUID(&self, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(guidvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetString<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, guidkey: *const ::windows::core::GUID, wszvalue: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), wszvalue.into_param().abi()).ok()
}
pub unsafe fn SetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize)).ok()
}
pub unsafe fn SetUnknown<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guidkey: *const ::windows::core::GUID, punknown: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), punknown.into_param().abi()).ok()
}
pub unsafe fn LockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn UnlockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(unindex), ::core::mem::transmute(pguidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn CopyAllItems<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, pdest: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), pdest.into_param().abi()).ok()
}
pub unsafe fn GetMajorType(&self) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsCompressedFormat(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn IsEqual<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaType>>(&self, pimediatype: Param0) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), pimediatype.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetRepresentation<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::GUID>>(&self, guidrepresentation: Param0, ppvrepresentation: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), guidrepresentation.into_param().abi(), ::core::mem::transmute(ppvrepresentation)).ok()
}
pub unsafe fn FreeRepresentation<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::GUID>>(&self, guidrepresentation: Param0, pvrepresentation: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), guidrepresentation.into_param().abi(), ::core::mem::transmute(pvrepresentation)).ok()
}
#[cfg(feature = "Win32_Media_Audio")]
pub unsafe fn GetAudioFormat(&self) -> *mut super::Audio::WAVEFORMATEX {
::core::mem::transmute((::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self)))
}
}
unsafe impl ::windows::core::Interface for IMFAudioMediaType {
type Vtable = IMFAudioMediaType_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x26a0adc3_ce26_4672_9304_69552edd3faf);
}
impl ::core::convert::From<IMFAudioMediaType> for ::windows::core::IUnknown {
fn from(value: IMFAudioMediaType) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFAudioMediaType> for ::windows::core::IUnknown {
fn from(value: &IMFAudioMediaType) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFAudioMediaType {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFAudioMediaType {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFAudioMediaType> for IMFMediaType {
fn from(value: IMFAudioMediaType) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFAudioMediaType> for IMFMediaType {
fn from(value: &IMFAudioMediaType) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaType> for IMFAudioMediaType {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaType> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaType> for &IMFAudioMediaType {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaType> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<IMFAudioMediaType> for IMFAttributes {
fn from(value: IMFAudioMediaType) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFAudioMediaType> for IMFAttributes {
fn from(value: &IMFAudioMediaType) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for IMFAudioMediaType {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for &IMFAudioMediaType {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFAudioMediaType_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ptype: *mut MF_ATTRIBUTE_TYPE) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptheirs: ::windows::core::RawPtr, matchtype: MF_ATTRIBUTES_MATCH_TYPE, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pfvalue: *mut f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pguidvalue: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, wszvalue: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punknown: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcitems: *mut u32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdest: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pguidmajortype: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfcompressed: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pimediatype: ::windows::core::RawPtr, pdwflags: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidrepresentation: ::windows::core::GUID, ppvrepresentation: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidrepresentation: ::windows::core::GUID, pvrepresentation: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Media_Audio")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> *mut super::Audio::WAVEFORMATEX,
#[cfg(not(feature = "Win32_Media_Audio"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFAudioPolicy(pub ::windows::core::IUnknown);
impl IMFAudioPolicy {
pub unsafe fn SetGroupingParam(&self, rguidclass: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(rguidclass)).ok()
}
pub unsafe fn GetGroupingParam(&self) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetDisplayName<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszname: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pszname.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDisplayName(&self) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetIconPath<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszpath: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), pszpath.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetIconPath(&self) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFAudioPolicy {
type Vtable = IMFAudioPolicy_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa0638c2b_6465_4395_9ae7_a321a9fd2856);
}
impl ::core::convert::From<IMFAudioPolicy> for ::windows::core::IUnknown {
fn from(value: IMFAudioPolicy) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFAudioPolicy> for ::windows::core::IUnknown {
fn from(value: &IMFAudioPolicy) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFAudioPolicy {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFAudioPolicy {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFAudioPolicy_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rguidclass: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pguidclass: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszname: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszname: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszpath: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszpath: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFAudioStreamVolume(pub ::windows::core::IUnknown);
impl IMFAudioStreamVolume {
pub unsafe fn GetChannelCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetChannelVolume(&self, dwindex: u32, flevel: f32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwindex), ::core::mem::transmute(flevel)).ok()
}
pub unsafe fn GetChannelVolume(&self, dwindex: u32) -> ::windows::core::Result<f32> {
let mut result__: <f32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwindex), &mut result__).from_abi::<f32>(result__)
}
pub unsafe fn SetAllVolumes(&self, dwcount: u32, pfvolumes: *const f32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwcount), ::core::mem::transmute(pfvolumes)).ok()
}
pub unsafe fn GetAllVolumes(&self, dwcount: u32, pfvolumes: *mut f32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwcount), ::core::mem::transmute(pfvolumes)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFAudioStreamVolume {
type Vtable = IMFAudioStreamVolume_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x76b1bbdb_4ec8_4f36_b106_70a9316df593);
}
impl ::core::convert::From<IMFAudioStreamVolume> for ::windows::core::IUnknown {
fn from(value: IMFAudioStreamVolume) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFAudioStreamVolume> for ::windows::core::IUnknown {
fn from(value: &IMFAudioStreamVolume) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFAudioStreamVolume {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFAudioStreamVolume {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFAudioStreamVolume_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwindex: u32, flevel: f32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwindex: u32, pflevel: *mut f32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwcount: u32, pfvolumes: *const f32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwcount: u32, pfvolumes: *mut f32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFBufferListNotify(pub ::windows::core::IUnknown);
impl IMFBufferListNotify {
pub unsafe fn OnAddSourceBuffer(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)))
}
pub unsafe fn OnRemoveSourceBuffer(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)))
}
}
unsafe impl ::windows::core::Interface for IMFBufferListNotify {
type Vtable = IMFBufferListNotify_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x24cd47f7_81d8_4785_adb2_af697a963cd2);
}
impl ::core::convert::From<IMFBufferListNotify> for ::windows::core::IUnknown {
fn from(value: IMFBufferListNotify) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFBufferListNotify> for ::windows::core::IUnknown {
fn from(value: &IMFBufferListNotify) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFBufferListNotify {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFBufferListNotify {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFBufferListNotify_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFByteStream(pub ::windows::core::IUnknown);
impl IMFByteStream {
pub unsafe fn GetCapabilities(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetLength(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn SetLength(&self, qwlength: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(qwlength)).ok()
}
pub unsafe fn GetCurrentPosition(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn SetCurrentPosition(&self, qwposition: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(qwposition)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsEndOfStream(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn Read(&self, pb: *mut u8, cb: u32, pcbread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(pb), ::core::mem::transmute(cb), ::core::mem::transmute(pcbread)).ok()
}
pub unsafe fn BeginRead<'a, Param2: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param3: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pb: *mut u8, cb: u32, pcallback: Param2, punkstate: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(pb), ::core::mem::transmute(cb), pcallback.into_param().abi(), punkstate.into_param().abi()).ok()
}
pub unsafe fn EndRead<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), presult.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn Write(&self, pb: *const u8, cb: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(pb), ::core::mem::transmute(cb), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn BeginWrite<'a, Param2: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param3: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pb: *const u8, cb: u32, pcallback: Param2, punkstate: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(pb), ::core::mem::transmute(cb), pcallback.into_param().abi(), punkstate.into_param().abi()).ok()
}
pub unsafe fn EndWrite<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), presult.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn Seek(&self, seekorigin: MFBYTESTREAM_SEEK_ORIGIN, llseekoffset: i64, dwseekflags: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(seekorigin), ::core::mem::transmute(llseekoffset), ::core::mem::transmute(dwseekflags), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn Flush(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Close(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFByteStream {
type Vtable = IMFByteStream_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xad4c1b00_4bf7_422f_9175_756693d9130d);
}
impl ::core::convert::From<IMFByteStream> for ::windows::core::IUnknown {
fn from(value: IMFByteStream) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFByteStream> for ::windows::core::IUnknown {
fn from(value: &IMFByteStream) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFByteStream {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFByteStream {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFByteStream_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcapabilities: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqwlength: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, qwlength: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqwposition: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, qwposition: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfendofstream: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pb: *mut u8, cb: u32, pcbread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pb: *mut u8, cb: u32, pcallback: ::windows::core::RawPtr, punkstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr, pcbread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pb: *const u8, cb: u32, pcbwritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pb: *const u8, cb: u32, pcallback: ::windows::core::RawPtr, punkstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr, pcbwritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, seekorigin: MFBYTESTREAM_SEEK_ORIGIN, llseekoffset: i64, dwseekflags: u32, pqwcurrentposition: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFByteStreamBuffering(pub ::windows::core::IUnknown);
impl IMFByteStreamBuffering {
pub unsafe fn SetBufferingParams(&self, pparams: *const MFBYTESTREAM_BUFFERING_PARAMS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pparams)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnableBuffering<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, fenable: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), fenable.into_param().abi()).ok()
}
pub unsafe fn StopBuffering(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFByteStreamBuffering {
type Vtable = IMFByteStreamBuffering_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6d66d782_1d4f_4db7_8c63_cb8c77f1ef5e);
}
impl ::core::convert::From<IMFByteStreamBuffering> for ::windows::core::IUnknown {
fn from(value: IMFByteStreamBuffering) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFByteStreamBuffering> for ::windows::core::IUnknown {
fn from(value: &IMFByteStreamBuffering) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFByteStreamBuffering {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFByteStreamBuffering {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFByteStreamBuffering_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pparams: *const MFBYTESTREAM_BUFFERING_PARAMS) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, fenable: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFByteStreamCacheControl(pub ::windows::core::IUnknown);
impl IMFByteStreamCacheControl {
pub unsafe fn StopBackgroundTransfer(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFByteStreamCacheControl {
type Vtable = IMFByteStreamCacheControl_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf5042ea4_7a96_4a75_aa7b_2be1ef7f88d5);
}
impl ::core::convert::From<IMFByteStreamCacheControl> for ::windows::core::IUnknown {
fn from(value: IMFByteStreamCacheControl) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFByteStreamCacheControl> for ::windows::core::IUnknown {
fn from(value: &IMFByteStreamCacheControl) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFByteStreamCacheControl {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFByteStreamCacheControl {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFByteStreamCacheControl_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFByteStreamCacheControl2(pub ::windows::core::IUnknown);
impl IMFByteStreamCacheControl2 {
pub unsafe fn StopBackgroundTransfer(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetByteRanges(&self, pcranges: *mut u32, ppranges: *mut *mut MF_BYTE_STREAM_CACHE_RANGE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pcranges), ::core::mem::transmute(ppranges)).ok()
}
pub unsafe fn SetCacheLimit(&self, qwbytes: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(qwbytes)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsBackgroundTransferActive(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFByteStreamCacheControl2 {
type Vtable = IMFByteStreamCacheControl2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x71ce469c_f34b_49ea_a56b_2d2a10e51149);
}
impl ::core::convert::From<IMFByteStreamCacheControl2> for ::windows::core::IUnknown {
fn from(value: IMFByteStreamCacheControl2) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFByteStreamCacheControl2> for ::windows::core::IUnknown {
fn from(value: &IMFByteStreamCacheControl2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFByteStreamCacheControl2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFByteStreamCacheControl2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFByteStreamCacheControl2> for IMFByteStreamCacheControl {
fn from(value: IMFByteStreamCacheControl2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFByteStreamCacheControl2> for IMFByteStreamCacheControl {
fn from(value: &IMFByteStreamCacheControl2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFByteStreamCacheControl> for IMFByteStreamCacheControl2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFByteStreamCacheControl> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFByteStreamCacheControl> for &IMFByteStreamCacheControl2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFByteStreamCacheControl> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFByteStreamCacheControl2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcranges: *mut u32, ppranges: *mut *mut MF_BYTE_STREAM_CACHE_RANGE) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, qwbytes: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfactive: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFByteStreamHandler(pub ::windows::core::IUnknown);
impl IMFByteStreamHandler {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem"))]
pub unsafe fn BeginCreateObject<'a, Param0: ::windows::core::IntoParam<'a, IMFByteStream>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::UI::Shell::PropertiesSystem::IPropertyStore>, Param5: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param6: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(
&self,
pbytestream: Param0,
pwszurl: Param1,
dwflags: u32,
pprops: Param3,
ppiunknowncancelcookie: *mut ::core::option::Option<::windows::core::IUnknown>,
pcallback: Param5,
punkstate: Param6,
) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pbytestream.into_param().abi(), pwszurl.into_param().abi(), ::core::mem::transmute(dwflags), pprops.into_param().abi(), ::core::mem::transmute(ppiunknowncancelcookie), pcallback.into_param().abi(), punkstate.into_param().abi()).ok()
}
pub unsafe fn EndCreateObject<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0, pobjecttype: *mut MF_OBJECT_TYPE, ppobject: *mut ::core::option::Option<::windows::core::IUnknown>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), presult.into_param().abi(), ::core::mem::transmute(pobjecttype), ::core::mem::transmute(ppobject)).ok()
}
pub unsafe fn CancelObjectCreation<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, piunknowncancelcookie: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), piunknowncancelcookie.into_param().abi()).ok()
}
pub unsafe fn GetMaxNumberOfBytesRequiredForResolution(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFByteStreamHandler {
type Vtable = IMFByteStreamHandler_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbb420aa4_765b_4a1f_91fe_d6a8a143924c);
}
impl ::core::convert::From<IMFByteStreamHandler> for ::windows::core::IUnknown {
fn from(value: IMFByteStreamHandler) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFByteStreamHandler> for ::windows::core::IUnknown {
fn from(value: &IMFByteStreamHandler) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFByteStreamHandler {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFByteStreamHandler {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFByteStreamHandler_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbytestream: ::windows::core::RawPtr, pwszurl: super::super::Foundation::PWSTR, dwflags: u32, pprops: ::windows::core::RawPtr, ppiunknowncancelcookie: *mut ::windows::core::RawPtr, pcallback: ::windows::core::RawPtr, punkstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr, pobjecttype: *mut MF_OBJECT_TYPE, ppobject: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, piunknowncancelcookie: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqwbytes: *mut u64) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFByteStreamProxyClassFactory(pub ::windows::core::IUnknown);
impl IMFByteStreamProxyClassFactory {
pub unsafe fn CreateByteStreamProxy<'a, Param0: ::windows::core::IntoParam<'a, IMFByteStream>, Param1: ::windows::core::IntoParam<'a, IMFAttributes>, T: ::windows::core::Interface>(&self, pbytestream: Param0, pattributes: Param1) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pbytestream.into_param().abi(), pattributes.into_param().abi(), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
}
unsafe impl ::windows::core::Interface for IMFByteStreamProxyClassFactory {
type Vtable = IMFByteStreamProxyClassFactory_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa6b43f84_5c0a_42e8_a44d_b1857a76992f);
}
impl ::core::convert::From<IMFByteStreamProxyClassFactory> for ::windows::core::IUnknown {
fn from(value: IMFByteStreamProxyClassFactory) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFByteStreamProxyClassFactory> for ::windows::core::IUnknown {
fn from(value: &IMFByteStreamProxyClassFactory) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFByteStreamProxyClassFactory {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFByteStreamProxyClassFactory {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFByteStreamProxyClassFactory_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbytestream: ::windows::core::RawPtr, pattributes: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFByteStreamTimeSeek(pub ::windows::core::IUnknown);
impl IMFByteStreamTimeSeek {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsTimeSeekSupported(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn TimeSeek(&self, qwtimeposition: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(qwtimeposition)).ok()
}
pub unsafe fn GetTimeSeekResult(&self, pqwstarttime: *mut u64, pqwstoptime: *mut u64, pqwduration: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(pqwstarttime), ::core::mem::transmute(pqwstoptime), ::core::mem::transmute(pqwduration)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFByteStreamTimeSeek {
type Vtable = IMFByteStreamTimeSeek_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x64976bfa_fb61_4041_9069_8c9a5f659beb);
}
impl ::core::convert::From<IMFByteStreamTimeSeek> for ::windows::core::IUnknown {
fn from(value: IMFByteStreamTimeSeek) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFByteStreamTimeSeek> for ::windows::core::IUnknown {
fn from(value: &IMFByteStreamTimeSeek) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFByteStreamTimeSeek {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFByteStreamTimeSeek {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFByteStreamTimeSeek_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pftimeseekissupported: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, qwtimeposition: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqwstarttime: *mut u64, pqwstoptime: *mut u64, pqwduration: *mut u64) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFCameraOcclusionStateMonitor(pub ::windows::core::IUnknown);
impl IMFCameraOcclusionStateMonitor {
pub unsafe fn Start(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Stop(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetSupportedStates(&self) -> u32 {
::core::mem::transmute((::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)))
}
}
unsafe impl ::windows::core::Interface for IMFCameraOcclusionStateMonitor {
type Vtable = IMFCameraOcclusionStateMonitor_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xcc692f46_c697_47e2_a72d_7b064617749b);
}
impl ::core::convert::From<IMFCameraOcclusionStateMonitor> for ::windows::core::IUnknown {
fn from(value: IMFCameraOcclusionStateMonitor) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFCameraOcclusionStateMonitor> for ::windows::core::IUnknown {
fn from(value: &IMFCameraOcclusionStateMonitor) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFCameraOcclusionStateMonitor {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFCameraOcclusionStateMonitor {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFCameraOcclusionStateMonitor_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFCameraOcclusionStateReport(pub ::windows::core::IUnknown);
impl IMFCameraOcclusionStateReport {
pub unsafe fn GetOcclusionState(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFCameraOcclusionStateReport {
type Vtable = IMFCameraOcclusionStateReport_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1640b2cf_74da_4462_a43b_b76d3bdc1434);
}
impl ::core::convert::From<IMFCameraOcclusionStateReport> for ::windows::core::IUnknown {
fn from(value: IMFCameraOcclusionStateReport) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFCameraOcclusionStateReport> for ::windows::core::IUnknown {
fn from(value: &IMFCameraOcclusionStateReport) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFCameraOcclusionStateReport {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFCameraOcclusionStateReport {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFCameraOcclusionStateReport_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, occlusionstate: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFCameraOcclusionStateReportCallback(pub ::windows::core::IUnknown);
impl IMFCameraOcclusionStateReportCallback {
pub unsafe fn OnOcclusionStateReport<'a, Param0: ::windows::core::IntoParam<'a, IMFCameraOcclusionStateReport>>(&self, occlusionstatereport: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), occlusionstatereport.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFCameraOcclusionStateReportCallback {
type Vtable = IMFCameraOcclusionStateReportCallback_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6e5841c7_3889_4019_9035_783fb19b5948);
}
impl ::core::convert::From<IMFCameraOcclusionStateReportCallback> for ::windows::core::IUnknown {
fn from(value: IMFCameraOcclusionStateReportCallback) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFCameraOcclusionStateReportCallback> for ::windows::core::IUnknown {
fn from(value: &IMFCameraOcclusionStateReportCallback) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFCameraOcclusionStateReportCallback {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFCameraOcclusionStateReportCallback {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFCameraOcclusionStateReportCallback_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, occlusionstatereport: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFCameraSyncObject(pub ::windows::core::IUnknown);
impl IMFCameraSyncObject {
pub unsafe fn WaitOnSignal(&self, timeoutinms: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(timeoutinms)).ok()
}
pub unsafe fn Shutdown(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)))
}
}
unsafe impl ::windows::core::Interface for IMFCameraSyncObject {
type Vtable = IMFCameraSyncObject_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6338b23a_3042_49d2_a3ea_ec0fed815407);
}
impl ::core::convert::From<IMFCameraSyncObject> for ::windows::core::IUnknown {
fn from(value: IMFCameraSyncObject) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFCameraSyncObject> for ::windows::core::IUnknown {
fn from(value: &IMFCameraSyncObject) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFCameraSyncObject {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFCameraSyncObject {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFCameraSyncObject_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, timeoutinms: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFCaptureEngine(pub ::windows::core::IUnknown);
impl IMFCaptureEngine {
pub unsafe fn Initialize<'a, Param0: ::windows::core::IntoParam<'a, IMFCaptureEngineOnEventCallback>, Param1: ::windows::core::IntoParam<'a, IMFAttributes>, Param2: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>, Param3: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, peventcallback: Param0, pattributes: Param1, paudiosource: Param2, pvideosource: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), peventcallback.into_param().abi(), pattributes.into_param().abi(), paudiosource.into_param().abi(), pvideosource.into_param().abi()).ok()
}
pub unsafe fn StartPreview(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn StopPreview(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn StartRecord(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StopRecord<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, bfinalize: Param0, bflushunprocessedsamples: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), bfinalize.into_param().abi(), bflushunprocessedsamples.into_param().abi()).ok()
}
pub unsafe fn TakePhoto(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetSink(&self, mfcaptureenginesinktype: MF_CAPTURE_ENGINE_SINK_TYPE) -> ::windows::core::Result<IMFCaptureSink> {
let mut result__: <IMFCaptureSink as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(mfcaptureenginesinktype), &mut result__).from_abi::<IMFCaptureSink>(result__)
}
pub unsafe fn GetSource(&self) -> ::windows::core::Result<IMFCaptureSource> {
let mut result__: <IMFCaptureSource as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFCaptureSource>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFCaptureEngine {
type Vtable = IMFCaptureEngine_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa6bba433_176b_48b2_b375_53aa03473207);
}
impl ::core::convert::From<IMFCaptureEngine> for ::windows::core::IUnknown {
fn from(value: IMFCaptureEngine) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFCaptureEngine> for ::windows::core::IUnknown {
fn from(value: &IMFCaptureEngine) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFCaptureEngine {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFCaptureEngine {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFCaptureEngine_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, peventcallback: ::windows::core::RawPtr, pattributes: ::windows::core::RawPtr, paudiosource: ::windows::core::RawPtr, pvideosource: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bfinalize: super::super::Foundation::BOOL, bflushunprocessedsamples: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mfcaptureenginesinktype: MF_CAPTURE_ENGINE_SINK_TYPE, ppsink: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppsource: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFCaptureEngineClassFactory(pub ::windows::core::IUnknown);
impl IMFCaptureEngineClassFactory {
pub unsafe fn CreateInstance(&self, clsid: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(clsid), ::core::mem::transmute(riid), ::core::mem::transmute(ppvobject)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFCaptureEngineClassFactory {
type Vtable = IMFCaptureEngineClassFactory_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8f02d140_56fc_4302_a705_3a97c78be779);
}
impl ::core::convert::From<IMFCaptureEngineClassFactory> for ::windows::core::IUnknown {
fn from(value: IMFCaptureEngineClassFactory) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFCaptureEngineClassFactory> for ::windows::core::IUnknown {
fn from(value: &IMFCaptureEngineClassFactory) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFCaptureEngineClassFactory {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFCaptureEngineClassFactory {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFCaptureEngineClassFactory_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, clsid: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFCaptureEngineOnEventCallback(pub ::windows::core::IUnknown);
impl IMFCaptureEngineOnEventCallback {
pub unsafe fn OnEvent<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaEvent>>(&self, pevent: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pevent.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFCaptureEngineOnEventCallback {
type Vtable = IMFCaptureEngineOnEventCallback_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xaeda51c0_9025_4983_9012_de597b88b089);
}
impl ::core::convert::From<IMFCaptureEngineOnEventCallback> for ::windows::core::IUnknown {
fn from(value: IMFCaptureEngineOnEventCallback) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFCaptureEngineOnEventCallback> for ::windows::core::IUnknown {
fn from(value: &IMFCaptureEngineOnEventCallback) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFCaptureEngineOnEventCallback {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFCaptureEngineOnEventCallback {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFCaptureEngineOnEventCallback_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pevent: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFCaptureEngineOnSampleCallback(pub ::windows::core::IUnknown);
impl IMFCaptureEngineOnSampleCallback {
pub unsafe fn OnSample<'a, Param0: ::windows::core::IntoParam<'a, IMFSample>>(&self, psample: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), psample.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFCaptureEngineOnSampleCallback {
type Vtable = IMFCaptureEngineOnSampleCallback_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x52150b82_ab39_4467_980f_e48bf0822ecd);
}
impl ::core::convert::From<IMFCaptureEngineOnSampleCallback> for ::windows::core::IUnknown {
fn from(value: IMFCaptureEngineOnSampleCallback) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFCaptureEngineOnSampleCallback> for ::windows::core::IUnknown {
fn from(value: &IMFCaptureEngineOnSampleCallback) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFCaptureEngineOnSampleCallback {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFCaptureEngineOnSampleCallback {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFCaptureEngineOnSampleCallback_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psample: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFCaptureEngineOnSampleCallback2(pub ::windows::core::IUnknown);
impl IMFCaptureEngineOnSampleCallback2 {
pub unsafe fn OnSample<'a, Param0: ::windows::core::IntoParam<'a, IMFSample>>(&self, psample: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), psample.into_param().abi()).ok()
}
pub unsafe fn OnSynchronizedEvent<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaEvent>>(&self, pevent: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pevent.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFCaptureEngineOnSampleCallback2 {
type Vtable = IMFCaptureEngineOnSampleCallback2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe37ceed7_340f_4514_9f4d_9c2ae026100b);
}
impl ::core::convert::From<IMFCaptureEngineOnSampleCallback2> for ::windows::core::IUnknown {
fn from(value: IMFCaptureEngineOnSampleCallback2) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFCaptureEngineOnSampleCallback2> for ::windows::core::IUnknown {
fn from(value: &IMFCaptureEngineOnSampleCallback2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFCaptureEngineOnSampleCallback2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFCaptureEngineOnSampleCallback2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFCaptureEngineOnSampleCallback2> for IMFCaptureEngineOnSampleCallback {
fn from(value: IMFCaptureEngineOnSampleCallback2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFCaptureEngineOnSampleCallback2> for IMFCaptureEngineOnSampleCallback {
fn from(value: &IMFCaptureEngineOnSampleCallback2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFCaptureEngineOnSampleCallback> for IMFCaptureEngineOnSampleCallback2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFCaptureEngineOnSampleCallback> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFCaptureEngineOnSampleCallback> for &IMFCaptureEngineOnSampleCallback2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFCaptureEngineOnSampleCallback> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFCaptureEngineOnSampleCallback2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psample: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pevent: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFCapturePhotoConfirmation(pub ::windows::core::IUnknown);
impl IMFCapturePhotoConfirmation {
pub unsafe fn SetPhotoConfirmationCallback<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncCallback>>(&self, pnotificationcallback: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pnotificationcallback.into_param().abi()).ok()
}
pub unsafe fn SetPixelFormat<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::GUID>>(&self, subtype: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), subtype.into_param().abi()).ok()
}
pub unsafe fn GetPixelFormat(&self) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFCapturePhotoConfirmation {
type Vtable = IMFCapturePhotoConfirmation_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x19f68549_ca8a_4706_a4ef_481dbc95e12c);
}
impl ::core::convert::From<IMFCapturePhotoConfirmation> for ::windows::core::IUnknown {
fn from(value: IMFCapturePhotoConfirmation) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFCapturePhotoConfirmation> for ::windows::core::IUnknown {
fn from(value: &IMFCapturePhotoConfirmation) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFCapturePhotoConfirmation {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFCapturePhotoConfirmation {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFCapturePhotoConfirmation_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pnotificationcallback: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, subtype: ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, subtype: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFCapturePhotoSink(pub ::windows::core::IUnknown);
impl IMFCapturePhotoSink {
pub unsafe fn GetOutputMediaType(&self, dwsinkstreamindex: u32) -> ::windows::core::Result<IMFMediaType> {
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsinkstreamindex), &mut result__).from_abi::<IMFMediaType>(result__)
}
pub unsafe fn GetService(&self, dwsinkstreamindex: u32, rguidservice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsinkstreamindex), ::core::mem::transmute(rguidservice), ::core::mem::transmute(riid), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
pub unsafe fn AddStream<'a, Param1: ::windows::core::IntoParam<'a, IMFMediaType>, Param2: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, dwsourcestreamindex: u32, pmediatype: Param1, pattributes: Param2) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsourcestreamindex), pmediatype.into_param().abi(), pattributes.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn Prepare(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn RemoveAllStreams(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetOutputFileName<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, filename: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), filename.into_param().abi()).ok()
}
pub unsafe fn SetSampleCallback<'a, Param0: ::windows::core::IntoParam<'a, IMFCaptureEngineOnSampleCallback>>(&self, pcallback: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), pcallback.into_param().abi()).ok()
}
pub unsafe fn SetOutputByteStream<'a, Param0: ::windows::core::IntoParam<'a, IMFByteStream>>(&self, pbytestream: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), pbytestream.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFCapturePhotoSink {
type Vtable = IMFCapturePhotoSink_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd2d43cc8_48bb_4aa7_95db_10c06977e777);
}
impl ::core::convert::From<IMFCapturePhotoSink> for ::windows::core::IUnknown {
fn from(value: IMFCapturePhotoSink) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFCapturePhotoSink> for ::windows::core::IUnknown {
fn from(value: &IMFCapturePhotoSink) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFCapturePhotoSink {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFCapturePhotoSink {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFCapturePhotoSink> for IMFCaptureSink {
fn from(value: IMFCapturePhotoSink) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFCapturePhotoSink> for IMFCaptureSink {
fn from(value: &IMFCapturePhotoSink) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFCaptureSink> for IMFCapturePhotoSink {
fn into_param(self) -> ::windows::core::Param<'a, IMFCaptureSink> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFCaptureSink> for &IMFCapturePhotoSink {
fn into_param(self) -> ::windows::core::Param<'a, IMFCaptureSink> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFCapturePhotoSink_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsinkstreamindex: u32, ppmediatype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsinkstreamindex: u32, rguidservice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppunknown: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsourcestreamindex: u32, pmediatype: ::windows::core::RawPtr, pattributes: ::windows::core::RawPtr, pdwsinkstreamindex: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, filename: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcallback: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbytestream: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFCapturePreviewSink(pub ::windows::core::IUnknown);
impl IMFCapturePreviewSink {
pub unsafe fn GetOutputMediaType(&self, dwsinkstreamindex: u32) -> ::windows::core::Result<IMFMediaType> {
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsinkstreamindex), &mut result__).from_abi::<IMFMediaType>(result__)
}
pub unsafe fn GetService(&self, dwsinkstreamindex: u32, rguidservice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsinkstreamindex), ::core::mem::transmute(rguidservice), ::core::mem::transmute(riid), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
pub unsafe fn AddStream<'a, Param1: ::windows::core::IntoParam<'a, IMFMediaType>, Param2: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, dwsourcestreamindex: u32, pmediatype: Param1, pattributes: Param2) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsourcestreamindex), pmediatype.into_param().abi(), pattributes.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn Prepare(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn RemoveAllStreams(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetRenderHandle<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::HANDLE>>(&self, handle: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), handle.into_param().abi()).ok()
}
pub unsafe fn SetRenderSurface<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, psurface: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), psurface.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn UpdateVideo(&self, psrc: *const MFVideoNormalizedRect, pdst: *const super::super::Foundation::RECT, pborderclr: *const u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(psrc), ::core::mem::transmute(pdst), ::core::mem::transmute(pborderclr)).ok()
}
pub unsafe fn SetSampleCallback<'a, Param1: ::windows::core::IntoParam<'a, IMFCaptureEngineOnSampleCallback>>(&self, dwstreamsinkindex: u32, pcallback: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamsinkindex), pcallback.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetMirrorState(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetMirrorState<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, fmirrorstate: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), fmirrorstate.into_param().abi()).ok()
}
pub unsafe fn GetRotation(&self, dwstreamindex: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetRotation(&self, dwstreamindex: u32, dwrotationvalue: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(dwrotationvalue)).ok()
}
pub unsafe fn SetCustomSink<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaSink>>(&self, pmediasink: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), pmediasink.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFCapturePreviewSink {
type Vtable = IMFCapturePreviewSink_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x77346cfd_5b49_4d73_ace0_5b52a859f2e0);
}
impl ::core::convert::From<IMFCapturePreviewSink> for ::windows::core::IUnknown {
fn from(value: IMFCapturePreviewSink) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFCapturePreviewSink> for ::windows::core::IUnknown {
fn from(value: &IMFCapturePreviewSink) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFCapturePreviewSink {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFCapturePreviewSink {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFCapturePreviewSink> for IMFCaptureSink {
fn from(value: IMFCapturePreviewSink) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFCapturePreviewSink> for IMFCaptureSink {
fn from(value: &IMFCapturePreviewSink) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFCaptureSink> for IMFCapturePreviewSink {
fn into_param(self) -> ::windows::core::Param<'a, IMFCaptureSink> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFCaptureSink> for &IMFCapturePreviewSink {
fn into_param(self) -> ::windows::core::Param<'a, IMFCaptureSink> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFCapturePreviewSink_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsinkstreamindex: u32, ppmediatype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsinkstreamindex: u32, rguidservice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppunknown: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsourcestreamindex: u32, pmediatype: ::windows::core::RawPtr, pattributes: ::windows::core::RawPtr, pdwsinkstreamindex: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: super::super::Foundation::HANDLE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psurface: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psrc: *const MFVideoNormalizedRect, pdst: *const super::super::Foundation::RECT, pborderclr: *const u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamsinkindex: u32, pcallback: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfmirrorstate: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, fmirrorstate: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, pdwrotationvalue: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, dwrotationvalue: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pmediasink: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFCaptureRecordSink(pub ::windows::core::IUnknown);
impl IMFCaptureRecordSink {
pub unsafe fn GetOutputMediaType(&self, dwsinkstreamindex: u32) -> ::windows::core::Result<IMFMediaType> {
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsinkstreamindex), &mut result__).from_abi::<IMFMediaType>(result__)
}
pub unsafe fn GetService(&self, dwsinkstreamindex: u32, rguidservice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsinkstreamindex), ::core::mem::transmute(rguidservice), ::core::mem::transmute(riid), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
pub unsafe fn AddStream<'a, Param1: ::windows::core::IntoParam<'a, IMFMediaType>, Param2: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, dwsourcestreamindex: u32, pmediatype: Param1, pattributes: Param2) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsourcestreamindex), pmediatype.into_param().abi(), pattributes.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn Prepare(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn RemoveAllStreams(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetOutputByteStream<'a, Param0: ::windows::core::IntoParam<'a, IMFByteStream>>(&self, pbytestream: Param0, guidcontainertype: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), pbytestream.into_param().abi(), ::core::mem::transmute(guidcontainertype)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetOutputFileName<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, filename: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), filename.into_param().abi()).ok()
}
pub unsafe fn SetSampleCallback<'a, Param1: ::windows::core::IntoParam<'a, IMFCaptureEngineOnSampleCallback>>(&self, dwstreamsinkindex: u32, pcallback: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamsinkindex), pcallback.into_param().abi()).ok()
}
pub unsafe fn SetCustomSink<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaSink>>(&self, pmediasink: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), pmediasink.into_param().abi()).ok()
}
pub unsafe fn GetRotation(&self, dwstreamindex: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetRotation(&self, dwstreamindex: u32, dwrotationvalue: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(dwrotationvalue)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFCaptureRecordSink {
type Vtable = IMFCaptureRecordSink_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3323b55a_f92a_4fe2_8edc_e9bfc0634d77);
}
impl ::core::convert::From<IMFCaptureRecordSink> for ::windows::core::IUnknown {
fn from(value: IMFCaptureRecordSink) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFCaptureRecordSink> for ::windows::core::IUnknown {
fn from(value: &IMFCaptureRecordSink) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFCaptureRecordSink {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFCaptureRecordSink {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFCaptureRecordSink> for IMFCaptureSink {
fn from(value: IMFCaptureRecordSink) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFCaptureRecordSink> for IMFCaptureSink {
fn from(value: &IMFCaptureRecordSink) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFCaptureSink> for IMFCaptureRecordSink {
fn into_param(self) -> ::windows::core::Param<'a, IMFCaptureSink> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFCaptureSink> for &IMFCaptureRecordSink {
fn into_param(self) -> ::windows::core::Param<'a, IMFCaptureSink> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFCaptureRecordSink_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsinkstreamindex: u32, ppmediatype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsinkstreamindex: u32, rguidservice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppunknown: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsourcestreamindex: u32, pmediatype: ::windows::core::RawPtr, pattributes: ::windows::core::RawPtr, pdwsinkstreamindex: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbytestream: ::windows::core::RawPtr, guidcontainertype: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, filename: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamsinkindex: u32, pcallback: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pmediasink: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, pdwrotationvalue: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, dwrotationvalue: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFCaptureSink(pub ::windows::core::IUnknown);
impl IMFCaptureSink {
pub unsafe fn GetOutputMediaType(&self, dwsinkstreamindex: u32) -> ::windows::core::Result<IMFMediaType> {
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsinkstreamindex), &mut result__).from_abi::<IMFMediaType>(result__)
}
pub unsafe fn GetService(&self, dwsinkstreamindex: u32, rguidservice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsinkstreamindex), ::core::mem::transmute(rguidservice), ::core::mem::transmute(riid), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
pub unsafe fn AddStream<'a, Param1: ::windows::core::IntoParam<'a, IMFMediaType>, Param2: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, dwsourcestreamindex: u32, pmediatype: Param1, pattributes: Param2) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsourcestreamindex), pmediatype.into_param().abi(), pattributes.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn Prepare(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn RemoveAllStreams(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFCaptureSink {
type Vtable = IMFCaptureSink_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x72d6135b_35e9_412c_b926_fd5265f2a885);
}
impl ::core::convert::From<IMFCaptureSink> for ::windows::core::IUnknown {
fn from(value: IMFCaptureSink) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFCaptureSink> for ::windows::core::IUnknown {
fn from(value: &IMFCaptureSink) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFCaptureSink {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFCaptureSink {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFCaptureSink_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsinkstreamindex: u32, ppmediatype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsinkstreamindex: u32, rguidservice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppunknown: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsourcestreamindex: u32, pmediatype: ::windows::core::RawPtr, pattributes: ::windows::core::RawPtr, pdwsinkstreamindex: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFCaptureSink2(pub ::windows::core::IUnknown);
impl IMFCaptureSink2 {
pub unsafe fn GetOutputMediaType(&self, dwsinkstreamindex: u32) -> ::windows::core::Result<IMFMediaType> {
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsinkstreamindex), &mut result__).from_abi::<IMFMediaType>(result__)
}
pub unsafe fn GetService(&self, dwsinkstreamindex: u32, rguidservice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsinkstreamindex), ::core::mem::transmute(rguidservice), ::core::mem::transmute(riid), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
pub unsafe fn AddStream<'a, Param1: ::windows::core::IntoParam<'a, IMFMediaType>, Param2: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, dwsourcestreamindex: u32, pmediatype: Param1, pattributes: Param2) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsourcestreamindex), pmediatype.into_param().abi(), pattributes.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn Prepare(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn RemoveAllStreams(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetOutputMediaType<'a, Param1: ::windows::core::IntoParam<'a, IMFMediaType>, Param2: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, dwstreamindex: u32, pmediatype: Param1, pencodingattributes: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), pmediatype.into_param().abi(), pencodingattributes.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFCaptureSink2 {
type Vtable = IMFCaptureSink2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf9e4219e_6197_4b5e_b888_bee310ab2c59);
}
impl ::core::convert::From<IMFCaptureSink2> for ::windows::core::IUnknown {
fn from(value: IMFCaptureSink2) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFCaptureSink2> for ::windows::core::IUnknown {
fn from(value: &IMFCaptureSink2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFCaptureSink2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFCaptureSink2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFCaptureSink2> for IMFCaptureSink {
fn from(value: IMFCaptureSink2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFCaptureSink2> for IMFCaptureSink {
fn from(value: &IMFCaptureSink2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFCaptureSink> for IMFCaptureSink2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFCaptureSink> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFCaptureSink> for &IMFCaptureSink2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFCaptureSink> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFCaptureSink2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsinkstreamindex: u32, ppmediatype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsinkstreamindex: u32, rguidservice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppunknown: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsourcestreamindex: u32, pmediatype: ::windows::core::RawPtr, pattributes: ::windows::core::RawPtr, pdwsinkstreamindex: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, pmediatype: ::windows::core::RawPtr, pencodingattributes: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFCaptureSource(pub ::windows::core::IUnknown);
impl IMFCaptureSource {
pub unsafe fn GetCaptureDeviceSource(&self, mfcaptureenginedevicetype: MF_CAPTURE_ENGINE_DEVICE_TYPE) -> ::windows::core::Result<IMFMediaSource> {
let mut result__: <IMFMediaSource as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(mfcaptureenginedevicetype), &mut result__).from_abi::<IMFMediaSource>(result__)
}
pub unsafe fn GetCaptureDeviceActivate(&self, mfcaptureenginedevicetype: MF_CAPTURE_ENGINE_DEVICE_TYPE) -> ::windows::core::Result<IMFActivate> {
let mut result__: <IMFActivate as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(mfcaptureenginedevicetype), &mut result__).from_abi::<IMFActivate>(result__)
}
pub unsafe fn GetService(&self, rguidservice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(rguidservice), ::core::mem::transmute(riid), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
pub unsafe fn AddEffect<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, dwsourcestreamindex: u32, punknown: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsourcestreamindex), punknown.into_param().abi()).ok()
}
pub unsafe fn RemoveEffect<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, dwsourcestreamindex: u32, punknown: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsourcestreamindex), punknown.into_param().abi()).ok()
}
pub unsafe fn RemoveAllEffects(&self, dwsourcestreamindex: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsourcestreamindex)).ok()
}
pub unsafe fn GetAvailableDeviceMediaType(&self, dwsourcestreamindex: u32, dwmediatypeindex: u32) -> ::windows::core::Result<IMFMediaType> {
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsourcestreamindex), ::core::mem::transmute(dwmediatypeindex), &mut result__).from_abi::<IMFMediaType>(result__)
}
pub unsafe fn SetCurrentDeviceMediaType<'a, Param1: ::windows::core::IntoParam<'a, IMFMediaType>>(&self, dwsourcestreamindex: u32, pmediatype: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsourcestreamindex), pmediatype.into_param().abi()).ok()
}
pub unsafe fn GetCurrentDeviceMediaType(&self, dwsourcestreamindex: u32) -> ::windows::core::Result<IMFMediaType> {
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsourcestreamindex), &mut result__).from_abi::<IMFMediaType>(result__)
}
pub unsafe fn GetDeviceStreamCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetDeviceStreamCategory(&self, dwsourcestreamindex: u32) -> ::windows::core::Result<MF_CAPTURE_ENGINE_STREAM_CATEGORY> {
let mut result__: <MF_CAPTURE_ENGINE_STREAM_CATEGORY as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsourcestreamindex), &mut result__).from_abi::<MF_CAPTURE_ENGINE_STREAM_CATEGORY>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetMirrorState(&self, dwstreamindex: u32) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetMirrorState<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, dwstreamindex: u32, fmirrorstate: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), fmirrorstate.into_param().abi()).ok()
}
pub unsafe fn GetStreamIndexFromFriendlyName(&self, uifriendlyname: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(uifriendlyname), &mut result__).from_abi::<u32>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFCaptureSource {
type Vtable = IMFCaptureSource_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x439a42a8_0d2c_4505_be83_f79b2a05d5c4);
}
impl ::core::convert::From<IMFCaptureSource> for ::windows::core::IUnknown {
fn from(value: IMFCaptureSource) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFCaptureSource> for ::windows::core::IUnknown {
fn from(value: &IMFCaptureSource) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFCaptureSource {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFCaptureSource {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFCaptureSource_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mfcaptureenginedevicetype: MF_CAPTURE_ENGINE_DEVICE_TYPE, ppmediasource: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mfcaptureenginedevicetype: MF_CAPTURE_ENGINE_DEVICE_TYPE, ppactivate: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rguidservice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppunknown: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsourcestreamindex: u32, punknown: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsourcestreamindex: u32, punknown: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsourcestreamindex: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsourcestreamindex: u32, dwmediatypeindex: u32, ppmediatype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsourcestreamindex: u32, pmediatype: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsourcestreamindex: u32, ppmediatype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwstreamcount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsourcestreamindex: u32, pstreamcategory: *mut MF_CAPTURE_ENGINE_STREAM_CATEGORY) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, pfmirrorstate: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, fmirrorstate: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, uifriendlyname: u32, pdwactualstreamindex: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFCdmSuspendNotify(pub ::windows::core::IUnknown);
impl IMFCdmSuspendNotify {
pub unsafe fn Begin(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn End(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFCdmSuspendNotify {
type Vtable = IMFCdmSuspendNotify_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7a5645d2_43bd_47fd_87b7_dcd24cc7d692);
}
impl ::core::convert::From<IMFCdmSuspendNotify> for ::windows::core::IUnknown {
fn from(value: IMFCdmSuspendNotify) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFCdmSuspendNotify> for ::windows::core::IUnknown {
fn from(value: &IMFCdmSuspendNotify) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFCdmSuspendNotify {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFCdmSuspendNotify {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFCdmSuspendNotify_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFClock(pub ::windows::core::IUnknown);
impl IMFClock {
pub unsafe fn GetClockCharacteristics(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCorrelatedTime(&self, dwreserved: u32, pllclocktime: *mut i64, phnssystemtime: *mut i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwreserved), ::core::mem::transmute(pllclocktime), ::core::mem::transmute(phnssystemtime)).ok()
}
pub unsafe fn GetContinuityKey(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetState(&self, dwreserved: u32) -> ::windows::core::Result<MFCLOCK_STATE> {
let mut result__: <MFCLOCK_STATE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwreserved), &mut result__).from_abi::<MFCLOCK_STATE>(result__)
}
pub unsafe fn GetProperties(&self) -> ::windows::core::Result<MFCLOCK_PROPERTIES> {
let mut result__: <MFCLOCK_PROPERTIES as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MFCLOCK_PROPERTIES>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFClock {
type Vtable = IMFClock_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2eb1e945_18b8_4139_9b1a_d5d584818530);
}
impl ::core::convert::From<IMFClock> for ::windows::core::IUnknown {
fn from(value: IMFClock) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFClock> for ::windows::core::IUnknown {
fn from(value: &IMFClock) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFClock {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFClock {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFClock_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcharacteristics: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwreserved: u32, pllclocktime: *mut i64, phnssystemtime: *mut i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcontinuitykey: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwreserved: u32, peclockstate: *mut MFCLOCK_STATE) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pclockproperties: *mut MFCLOCK_PROPERTIES) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFClockConsumer(pub ::windows::core::IUnknown);
impl IMFClockConsumer {
pub unsafe fn SetPresentationClock<'a, Param0: ::windows::core::IntoParam<'a, IMFPresentationClock>>(&self, ppresentationclock: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ppresentationclock.into_param().abi()).ok()
}
pub unsafe fn GetPresentationClock(&self) -> ::windows::core::Result<IMFPresentationClock> {
let mut result__: <IMFPresentationClock as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFPresentationClock>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFClockConsumer {
type Vtable = IMFClockConsumer_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6ef2a662_47c0_4666_b13d_cbb717f2fa2c);
}
impl ::core::convert::From<IMFClockConsumer> for ::windows::core::IUnknown {
fn from(value: IMFClockConsumer) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFClockConsumer> for ::windows::core::IUnknown {
fn from(value: &IMFClockConsumer) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFClockConsumer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFClockConsumer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFClockConsumer_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppresentationclock: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pppresentationclock: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFClockStateSink(pub ::windows::core::IUnknown);
impl IMFClockStateSink {
pub unsafe fn OnClockStart(&self, hnssystemtime: i64, llclockstartoffset: i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(hnssystemtime), ::core::mem::transmute(llclockstartoffset)).ok()
}
pub unsafe fn OnClockStop(&self, hnssystemtime: i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(hnssystemtime)).ok()
}
pub unsafe fn OnClockPause(&self, hnssystemtime: i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(hnssystemtime)).ok()
}
pub unsafe fn OnClockRestart(&self, hnssystemtime: i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(hnssystemtime)).ok()
}
pub unsafe fn OnClockSetRate(&self, hnssystemtime: i64, flrate: f32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(hnssystemtime), ::core::mem::transmute(flrate)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFClockStateSink {
type Vtable = IMFClockStateSink_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf6696e82_74f7_4f3d_a178_8a5e09c3659f);
}
impl ::core::convert::From<IMFClockStateSink> for ::windows::core::IUnknown {
fn from(value: IMFClockStateSink) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFClockStateSink> for ::windows::core::IUnknown {
fn from(value: &IMFClockStateSink) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFClockStateSink {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFClockStateSink {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFClockStateSink_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hnssystemtime: i64, llclockstartoffset: i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hnssystemtime: i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hnssystemtime: i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hnssystemtime: i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hnssystemtime: i64, flrate: f32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFCollection(pub ::windows::core::IUnknown);
impl IMFCollection {
pub unsafe fn GetElementCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetElement(&self, dwelementindex: u32) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwelementindex), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
pub unsafe fn AddElement<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, punkelement: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), punkelement.into_param().abi()).ok()
}
pub unsafe fn RemoveElement(&self, dwelementindex: u32) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwelementindex), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
pub unsafe fn InsertElementAt<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, dwindex: u32, punknown: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwindex), punknown.into_param().abi()).ok()
}
pub unsafe fn RemoveAllElements(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFCollection {
type Vtable = IMFCollection_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5bc8a76b_869a_46a3_9b03_fa218a66aebe);
}
impl ::core::convert::From<IMFCollection> for ::windows::core::IUnknown {
fn from(value: IMFCollection) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFCollection> for ::windows::core::IUnknown {
fn from(value: &IMFCollection) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFCollection {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFCollection {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFCollection_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcelements: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwelementindex: u32, ppunkelement: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, punkelement: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwelementindex: u32, ppunkelement: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwindex: u32, punknown: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFContentDecryptionModule(pub ::windows::core::IUnknown);
impl IMFContentDecryptionModule {
pub unsafe fn SetContentEnabler<'a, Param0: ::windows::core::IntoParam<'a, IMFContentEnabler>, Param1: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, contentenabler: Param0, result: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), contentenabler.into_param().abi(), result.into_param().abi()).ok()
}
pub unsafe fn GetSuspendNotify(&self) -> ::windows::core::Result<IMFCdmSuspendNotify> {
let mut result__: <IMFCdmSuspendNotify as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFCdmSuspendNotify>(result__)
}
pub unsafe fn SetPMPHostApp<'a, Param0: ::windows::core::IntoParam<'a, IMFPMPHostApp>>(&self, pmphostapp: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pmphostapp.into_param().abi()).ok()
}
pub unsafe fn CreateSession<'a, Param1: ::windows::core::IntoParam<'a, IMFContentDecryptionModuleSessionCallbacks>>(&self, sessiontype: MF_MEDIAKEYSESSION_TYPE, callbacks: Param1) -> ::windows::core::Result<IMFContentDecryptionModuleSession> {
let mut result__: <IMFContentDecryptionModuleSession as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(sessiontype), callbacks.into_param().abi(), &mut result__).from_abi::<IMFContentDecryptionModuleSession>(result__)
}
pub unsafe fn SetServerCertificate(&self, certificate: *const u8, certificatesize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(certificate), ::core::mem::transmute(certificatesize)).ok()
}
pub unsafe fn CreateTrustedInput(&self, contentinitdata: *const u8, contentinitdatasize: u32) -> ::windows::core::Result<IMFTrustedInput> {
let mut result__: <IMFTrustedInput as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(contentinitdata), ::core::mem::transmute(contentinitdatasize), &mut result__).from_abi::<IMFTrustedInput>(result__)
}
pub unsafe fn GetProtectionSystemIds(&self, systemids: *mut *mut ::windows::core::GUID, count: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(systemids), ::core::mem::transmute(count)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFContentDecryptionModule {
type Vtable = IMFContentDecryptionModule_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x87be986c_10be_4943_bf48_4b54ce1983a2);
}
impl ::core::convert::From<IMFContentDecryptionModule> for ::windows::core::IUnknown {
fn from(value: IMFContentDecryptionModule) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFContentDecryptionModule> for ::windows::core::IUnknown {
fn from(value: &IMFContentDecryptionModule) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFContentDecryptionModule {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFContentDecryptionModule {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFContentDecryptionModule_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, contentenabler: ::windows::core::RawPtr, result: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, notify: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pmphostapp: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, sessiontype: MF_MEDIAKEYSESSION_TYPE, callbacks: ::windows::core::RawPtr, session: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, certificate: *const u8, certificatesize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, contentinitdata: *const u8, contentinitdatasize: u32, trustedinput: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, systemids: *mut *mut ::windows::core::GUID, count: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFContentDecryptionModuleAccess(pub ::windows::core::IUnknown);
impl IMFContentDecryptionModuleAccess {
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
pub unsafe fn CreateContentDecryptionModule<'a, Param0: ::windows::core::IntoParam<'a, super::super::UI::Shell::PropertiesSystem::IPropertyStore>>(&self, contentdecryptionmoduleproperties: Param0) -> ::windows::core::Result<IMFContentDecryptionModule> {
let mut result__: <IMFContentDecryptionModule as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), contentdecryptionmoduleproperties.into_param().abi(), &mut result__).from_abi::<IMFContentDecryptionModule>(result__)
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
pub unsafe fn GetConfiguration(&self) -> ::windows::core::Result<super::super::UI::Shell::PropertiesSystem::IPropertyStore> {
let mut result__: <super::super::UI::Shell::PropertiesSystem::IPropertyStore as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::UI::Shell::PropertiesSystem::IPropertyStore>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetKeySystem(&self) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFContentDecryptionModuleAccess {
type Vtable = IMFContentDecryptionModuleAccess_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa853d1f4_e2a0_4303_9edc_f1a68ee43136);
}
impl ::core::convert::From<IMFContentDecryptionModuleAccess> for ::windows::core::IUnknown {
fn from(value: IMFContentDecryptionModuleAccess) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFContentDecryptionModuleAccess> for ::windows::core::IUnknown {
fn from(value: &IMFContentDecryptionModuleAccess) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFContentDecryptionModuleAccess {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFContentDecryptionModuleAccess {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFContentDecryptionModuleAccess_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, contentdecryptionmoduleproperties: ::windows::core::RawPtr, contentdecryptionmodule: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] usize,
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, configuration: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, keysystem: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFContentDecryptionModuleFactory(pub ::windows::core::IUnknown);
impl IMFContentDecryptionModuleFactory {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsTypeSupported<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, keysystem: Param0, contenttype: Param1) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), keysystem.into_param().abi(), contenttype.into_param().abi()))
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem"))]
pub unsafe fn CreateContentDecryptionModuleAccess<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, keysystem: Param0, configurations: *const ::core::option::Option<super::super::UI::Shell::PropertiesSystem::IPropertyStore>, numconfigurations: u32) -> ::windows::core::Result<IMFContentDecryptionModuleAccess> {
let mut result__: <IMFContentDecryptionModuleAccess as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), keysystem.into_param().abi(), ::core::mem::transmute(configurations), ::core::mem::transmute(numconfigurations), &mut result__).from_abi::<IMFContentDecryptionModuleAccess>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFContentDecryptionModuleFactory {
type Vtable = IMFContentDecryptionModuleFactory_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7d5abf16_4cbb_4e08_b977_9ba59049943e);
}
impl ::core::convert::From<IMFContentDecryptionModuleFactory> for ::windows::core::IUnknown {
fn from(value: IMFContentDecryptionModuleFactory) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFContentDecryptionModuleFactory> for ::windows::core::IUnknown {
fn from(value: &IMFContentDecryptionModuleFactory) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFContentDecryptionModuleFactory {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFContentDecryptionModuleFactory {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFContentDecryptionModuleFactory_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, keysystem: super::super::Foundation::PWSTR, contenttype: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, keysystem: super::super::Foundation::PWSTR, configurations: *const ::windows::core::RawPtr, numconfigurations: u32, contentdecryptionmoduleaccess: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFContentDecryptionModuleSession(pub ::windows::core::IUnknown);
impl IMFContentDecryptionModuleSession {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSessionId(&self) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
pub unsafe fn GetExpiration(&self) -> ::windows::core::Result<f64> {
let mut result__: <f64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<f64>(result__)
}
pub unsafe fn GetKeyStatuses(&self, keystatuses: *mut *mut MFMediaKeyStatus, numkeystatuses: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(keystatuses), ::core::mem::transmute(numkeystatuses)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Load<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, sessionid: Param0) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), sessionid.into_param().abi(), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GenerateRequest<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, initdatatype: Param0, initdata: *const u8, initdatasize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), initdatatype.into_param().abi(), ::core::mem::transmute(initdata), ::core::mem::transmute(initdatasize)).ok()
}
pub unsafe fn Update(&self, response: *const u8, responsesize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(response), ::core::mem::transmute(responsesize)).ok()
}
pub unsafe fn Close(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Remove(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFContentDecryptionModuleSession {
type Vtable = IMFContentDecryptionModuleSession_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4e233efd_1dd2_49e8_b577_d63eee4c0d33);
}
impl ::core::convert::From<IMFContentDecryptionModuleSession> for ::windows::core::IUnknown {
fn from(value: IMFContentDecryptionModuleSession) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFContentDecryptionModuleSession> for ::windows::core::IUnknown {
fn from(value: &IMFContentDecryptionModuleSession) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFContentDecryptionModuleSession {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFContentDecryptionModuleSession {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFContentDecryptionModuleSession_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, sessionid: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, expiration: *mut f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, keystatuses: *mut *mut MFMediaKeyStatus, numkeystatuses: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, sessionid: super::super::Foundation::PWSTR, loaded: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, initdatatype: super::super::Foundation::PWSTR, initdata: *const u8, initdatasize: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, response: *const u8, responsesize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFContentDecryptionModuleSessionCallbacks(pub ::windows::core::IUnknown);
impl IMFContentDecryptionModuleSessionCallbacks {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn KeyMessage<'a, Param3: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, messagetype: MF_MEDIAKEYSESSION_MESSAGETYPE, message: *const u8, messagesize: u32, destinationurl: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(messagetype), ::core::mem::transmute(message), ::core::mem::transmute(messagesize), destinationurl.into_param().abi()).ok()
}
pub unsafe fn KeyStatusChanged(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFContentDecryptionModuleSessionCallbacks {
type Vtable = IMFContentDecryptionModuleSessionCallbacks_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3f96ee40_ad81_4096_8470_59a4b770f89a);
}
impl ::core::convert::From<IMFContentDecryptionModuleSessionCallbacks> for ::windows::core::IUnknown {
fn from(value: IMFContentDecryptionModuleSessionCallbacks) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFContentDecryptionModuleSessionCallbacks> for ::windows::core::IUnknown {
fn from(value: &IMFContentDecryptionModuleSessionCallbacks) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFContentDecryptionModuleSessionCallbacks {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFContentDecryptionModuleSessionCallbacks {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFContentDecryptionModuleSessionCallbacks_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, messagetype: MF_MEDIAKEYSESSION_MESSAGETYPE, message: *const u8, messagesize: u32, destinationurl: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFContentDecryptorContext(pub ::windows::core::IUnknown);
impl IMFContentDecryptorContext {
pub unsafe fn InitializeHardwareKey(&self, inputprivatedatabytecount: u32, inputprivatedata: *const ::core::ffi::c_void) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(inputprivatedatabytecount), ::core::mem::transmute(inputprivatedata), &mut result__).from_abi::<u64>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFContentDecryptorContext {
type Vtable = IMFContentDecryptorContext_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7ec4b1bd_43fb_4763_85d2_64fcb5c5f4cb);
}
impl ::core::convert::From<IMFContentDecryptorContext> for ::windows::core::IUnknown {
fn from(value: IMFContentDecryptorContext) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFContentDecryptorContext> for ::windows::core::IUnknown {
fn from(value: &IMFContentDecryptorContext) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFContentDecryptorContext {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFContentDecryptorContext {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFContentDecryptorContext_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, inputprivatedatabytecount: u32, inputprivatedata: *const ::core::ffi::c_void, outputprivatedata: *mut u64) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFContentEnabler(pub ::windows::core::IUnknown);
impl IMFContentEnabler {
pub unsafe fn GetEnableType(&self) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEnableURL(&self, ppwszurl: *mut super::super::Foundation::PWSTR, pcchurl: *mut u32, ptruststatus: *mut MF_URL_TRUST_STATUS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(ppwszurl), ::core::mem::transmute(pcchurl), ::core::mem::transmute(ptruststatus)).ok()
}
pub unsafe fn GetEnableData(&self, ppbdata: *mut *mut u8, pcbdata: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(ppbdata), ::core::mem::transmute(pcbdata)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsAutomaticSupported(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn AutomaticEnable(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn MonitorEnable(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Cancel(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFContentEnabler {
type Vtable = IMFContentEnabler_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd3c4ef59_49ce_4381_9071_d5bcd044c770);
}
impl ::core::convert::From<IMFContentEnabler> for ::windows::core::IUnknown {
fn from(value: IMFContentEnabler) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFContentEnabler> for ::windows::core::IUnknown {
fn from(value: &IMFContentEnabler) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFContentEnabler {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFContentEnabler {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFContentEnabler_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptype: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppwszurl: *mut super::super::Foundation::PWSTR, pcchurl: *mut u32, ptruststatus: *mut MF_URL_TRUST_STATUS) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppbdata: *mut *mut u8, pcbdata: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfautomatic: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFContentProtectionDevice(pub ::windows::core::IUnknown);
impl IMFContentProtectionDevice {
pub unsafe fn InvokeFunction(&self, functionid: u32, inputbufferbytecount: u32, inputbuffer: *const u8, outputbufferbytecount: *mut u32, outputbuffer: *mut u8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(functionid), ::core::mem::transmute(inputbufferbytecount), ::core::mem::transmute(inputbuffer), ::core::mem::transmute(outputbufferbytecount), ::core::mem::transmute(outputbuffer)).ok()
}
pub unsafe fn GetPrivateDataByteCount(&self, privateinputbytecount: *mut u32, privateoutputbytecount: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(privateinputbytecount), ::core::mem::transmute(privateoutputbytecount)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFContentProtectionDevice {
type Vtable = IMFContentProtectionDevice_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe6257174_a060_4c9a_a088_3b1b471cad28);
}
impl ::core::convert::From<IMFContentProtectionDevice> for ::windows::core::IUnknown {
fn from(value: IMFContentProtectionDevice) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFContentProtectionDevice> for ::windows::core::IUnknown {
fn from(value: &IMFContentProtectionDevice) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFContentProtectionDevice {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFContentProtectionDevice {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFContentProtectionDevice_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, functionid: u32, inputbufferbytecount: u32, inputbuffer: *const u8, outputbufferbytecount: *mut u32, outputbuffer: *mut u8) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, privateinputbytecount: *mut u32, privateoutputbytecount: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFContentProtectionManager(pub ::windows::core::IUnknown);
impl IMFContentProtectionManager {
pub unsafe fn BeginEnableContent<'a, Param0: ::windows::core::IntoParam<'a, IMFActivate>, Param1: ::windows::core::IntoParam<'a, IMFTopology>, Param2: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param3: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, penableractivate: Param0, ptopo: Param1, pcallback: Param2, punkstate: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), penableractivate.into_param().abi(), ptopo.into_param().abi(), pcallback.into_param().abi(), punkstate.into_param().abi()).ok()
}
pub unsafe fn EndEnableContent<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), presult.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFContentProtectionManager {
type Vtable = IMFContentProtectionManager_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xacf92459_6a61_42bd_b57c_b43e51203cb0);
}
impl ::core::convert::From<IMFContentProtectionManager> for ::windows::core::IUnknown {
fn from(value: IMFContentProtectionManager) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFContentProtectionManager> for ::windows::core::IUnknown {
fn from(value: &IMFContentProtectionManager) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFContentProtectionManager {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFContentProtectionManager {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFContentProtectionManager_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, penableractivate: ::windows::core::RawPtr, ptopo: ::windows::core::RawPtr, pcallback: ::windows::core::RawPtr, punkstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFD3D12SynchronizationObject(pub ::windows::core::IUnknown);
impl IMFD3D12SynchronizationObject {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SignalEventOnFinalResourceRelease<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::HANDLE>>(&self, hevent: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), hevent.into_param().abi()).ok()
}
pub unsafe fn Reset(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFD3D12SynchronizationObject {
type Vtable = IMFD3D12SynchronizationObject_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x802302b0_82de_45e1_b421_f19ee5bdaf23);
}
impl ::core::convert::From<IMFD3D12SynchronizationObject> for ::windows::core::IUnknown {
fn from(value: IMFD3D12SynchronizationObject) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFD3D12SynchronizationObject> for ::windows::core::IUnknown {
fn from(value: &IMFD3D12SynchronizationObject) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFD3D12SynchronizationObject {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFD3D12SynchronizationObject {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFD3D12SynchronizationObject_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hevent: super::super::Foundation::HANDLE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFD3D12SynchronizationObjectCommands(pub ::windows::core::IUnknown);
impl IMFD3D12SynchronizationObjectCommands {
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn EnqueueResourceReady<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12CommandQueue>>(&self, pproducercommandqueue: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pproducercommandqueue.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn EnqueueResourceReadyWait<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12CommandQueue>>(&self, pconsumercommandqueue: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pconsumercommandqueue.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SignalEventOnResourceReady<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::HANDLE>>(&self, hevent: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), hevent.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
pub unsafe fn EnqueueResourceRelease<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12CommandQueue>>(&self, pconsumercommandqueue: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), pconsumercommandqueue.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFD3D12SynchronizationObjectCommands {
type Vtable = IMFD3D12SynchronizationObjectCommands_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x09d0f835_92ff_4e53_8efa_40faa551f233);
}
impl ::core::convert::From<IMFD3D12SynchronizationObjectCommands> for ::windows::core::IUnknown {
fn from(value: IMFD3D12SynchronizationObjectCommands) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFD3D12SynchronizationObjectCommands> for ::windows::core::IUnknown {
fn from(value: &IMFD3D12SynchronizationObjectCommands) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFD3D12SynchronizationObjectCommands {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFD3D12SynchronizationObjectCommands {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFD3D12SynchronizationObjectCommands_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pproducercommandqueue: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pconsumercommandqueue: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hevent: super::super::Foundation::HANDLE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pconsumercommandqueue: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFDLNASinkInit(pub ::windows::core::IUnknown);
impl IMFDLNASinkInit {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Initialize<'a, Param0: ::windows::core::IntoParam<'a, IMFByteStream>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, pbytestream: Param0, fpal: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pbytestream.into_param().abi(), fpal.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFDLNASinkInit {
type Vtable = IMFDLNASinkInit_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0c012799_1b61_4c10_bda9_04445be5f561);
}
impl ::core::convert::From<IMFDLNASinkInit> for ::windows::core::IUnknown {
fn from(value: IMFDLNASinkInit) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFDLNASinkInit> for ::windows::core::IUnknown {
fn from(value: &IMFDLNASinkInit) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFDLNASinkInit {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFDLNASinkInit {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFDLNASinkInit_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbytestream: ::windows::core::RawPtr, fpal: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFDRMNetHelper(pub ::windows::core::IUnknown);
impl IMFDRMNetHelper {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ProcessLicenseRequest(&self, plicenserequest: *const u8, cblicenserequest: u32, pplicenseresponse: *mut *mut u8, pcblicenseresponse: *mut u32, pbstrkid: *mut super::super::Foundation::BSTR) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(plicenserequest), ::core::mem::transmute(cblicenserequest), ::core::mem::transmute(pplicenseresponse), ::core::mem::transmute(pcblicenseresponse), ::core::mem::transmute(pbstrkid)).ok()
}
pub unsafe fn GetChainedLicenseResponse(&self, pplicenseresponse: *mut *mut u8, pcblicenseresponse: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pplicenseresponse), ::core::mem::transmute(pcblicenseresponse)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFDRMNetHelper {
type Vtable = IMFDRMNetHelper_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3d1ff0ea_679a_4190_8d46_7fa69e8c7e15);
}
impl ::core::convert::From<IMFDRMNetHelper> for ::windows::core::IUnknown {
fn from(value: IMFDRMNetHelper) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFDRMNetHelper> for ::windows::core::IUnknown {
fn from(value: &IMFDRMNetHelper) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFDRMNetHelper {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFDRMNetHelper {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFDRMNetHelper_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, plicenserequest: *const u8, cblicenserequest: u32, pplicenseresponse: *mut *mut u8, pcblicenseresponse: *mut u32, pbstrkid: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pplicenseresponse: *mut *mut u8, pcblicenseresponse: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFDXGIBuffer(pub ::windows::core::IUnknown);
impl IMFDXGIBuffer {
pub unsafe fn GetResource(&self, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(riid), ::core::mem::transmute(ppvobject)).ok()
}
pub unsafe fn GetSubresourceIndex(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetUnknown(&self, guid: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(riid), ::core::mem::transmute(ppvobject)).ok()
}
pub unsafe fn SetUnknown<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guid: *const ::windows::core::GUID, punkdata: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), punkdata.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFDXGIBuffer {
type Vtable = IMFDXGIBuffer_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe7174cfa_1c9e_48b1_8866_626226bfc258);
}
impl ::core::convert::From<IMFDXGIBuffer> for ::windows::core::IUnknown {
fn from(value: IMFDXGIBuffer) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFDXGIBuffer> for ::windows::core::IUnknown {
fn from(value: &IMFDXGIBuffer) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFDXGIBuffer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFDXGIBuffer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFDXGIBuffer_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pusubresource: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, punkdata: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFDXGIDeviceManager(pub ::windows::core::IUnknown);
impl IMFDXGIDeviceManager {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CloseDeviceHandle<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::HANDLE>>(&self, hdevice: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), hdevice.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetVideoService<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::HANDLE>>(&self, hdevice: Param0, riid: *const ::windows::core::GUID, ppservice: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), hdevice.into_param().abi(), ::core::mem::transmute(riid), ::core::mem::transmute(ppservice)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn LockDevice<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::HANDLE>, Param3: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, hdevice: Param0, riid: *const ::windows::core::GUID, ppunkdevice: *mut *mut ::core::ffi::c_void, fblock: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), hdevice.into_param().abi(), ::core::mem::transmute(riid), ::core::mem::transmute(ppunkdevice), fblock.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenDeviceHandle(&self) -> ::windows::core::Result<super::super::Foundation::HANDLE> {
let mut result__: <super::super::Foundation::HANDLE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::HANDLE>(result__)
}
pub unsafe fn ResetDevice<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, punkdevice: Param0, resettoken: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), punkdevice.into_param().abi(), ::core::mem::transmute(resettoken)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn TestDevice<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::HANDLE>>(&self, hdevice: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), hdevice.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn UnlockDevice<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, hdevice: Param0, fsavestate: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), hdevice.into_param().abi(), fsavestate.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFDXGIDeviceManager {
type Vtable = IMFDXGIDeviceManager_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xeb533d5d_2db6_40f8_97a9_494692014f07);
}
impl ::core::convert::From<IMFDXGIDeviceManager> for ::windows::core::IUnknown {
fn from(value: IMFDXGIDeviceManager) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFDXGIDeviceManager> for ::windows::core::IUnknown {
fn from(value: &IMFDXGIDeviceManager) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFDXGIDeviceManager {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFDXGIDeviceManager {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFDXGIDeviceManager_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hdevice: super::super::Foundation::HANDLE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hdevice: super::super::Foundation::HANDLE, riid: *const ::windows::core::GUID, ppservice: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hdevice: super::super::Foundation::HANDLE, riid: *const ::windows::core::GUID, ppunkdevice: *mut *mut ::core::ffi::c_void, fblock: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, phdevice: *mut super::super::Foundation::HANDLE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, punkdevice: ::windows::core::RawPtr, resettoken: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hdevice: super::super::Foundation::HANDLE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hdevice: super::super::Foundation::HANDLE, fsavestate: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFDXGIDeviceManagerSource(pub ::windows::core::IUnknown);
impl IMFDXGIDeviceManagerSource {
pub unsafe fn GetManager(&self) -> ::windows::core::Result<IMFDXGIDeviceManager> {
let mut result__: <IMFDXGIDeviceManager as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFDXGIDeviceManager>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFDXGIDeviceManagerSource {
type Vtable = IMFDXGIDeviceManagerSource_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x20bc074b_7a8d_4609_8c3b_64a0a3b5d7ce);
}
impl ::core::convert::From<IMFDXGIDeviceManagerSource> for ::windows::core::IUnknown {
fn from(value: IMFDXGIDeviceManagerSource) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFDXGIDeviceManagerSource> for ::windows::core::IUnknown {
fn from(value: &IMFDXGIDeviceManagerSource) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFDXGIDeviceManagerSource {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFDXGIDeviceManagerSource {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFDXGIDeviceManagerSource_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppmanager: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFDesiredSample(pub ::windows::core::IUnknown);
impl IMFDesiredSample {
pub unsafe fn GetDesiredSampleTimeAndDuration(&self, phnssampletime: *mut i64, phnssampleduration: *mut i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(phnssampletime), ::core::mem::transmute(phnssampleduration)).ok()
}
pub unsafe fn SetDesiredSampleTimeAndDuration(&self, hnssampletime: i64, hnssampleduration: i64) {
::core::mem::transmute((::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(hnssampletime), ::core::mem::transmute(hnssampleduration)))
}
pub unsafe fn Clear(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)))
}
}
unsafe impl ::windows::core::Interface for IMFDesiredSample {
type Vtable = IMFDesiredSample_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x56c294d0_753e_4260_8d61_a3d8820b1d54);
}
impl ::core::convert::From<IMFDesiredSample> for ::windows::core::IUnknown {
fn from(value: IMFDesiredSample) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFDesiredSample> for ::windows::core::IUnknown {
fn from(value: &IMFDesiredSample) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFDesiredSample {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFDesiredSample {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFDesiredSample_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, phnssampletime: *mut i64, phnssampleduration: *mut i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hnssampletime: i64, hnssampleduration: i64),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFExtendedCameraControl(pub ::windows::core::IUnknown);
impl IMFExtendedCameraControl {
pub unsafe fn GetCapabilities(&self) -> u64 {
::core::mem::transmute((::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)))
}
pub unsafe fn SetFlags(&self, ulflags: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulflags)).ok()
}
pub unsafe fn GetFlags(&self) -> u64 {
::core::mem::transmute((::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)))
}
pub unsafe fn LockPayload(&self, pppayload: *mut *mut u8, pulpayload: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(pppayload), ::core::mem::transmute(pulpayload)).ok()
}
pub unsafe fn UnlockPayload(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn CommitSettings(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFExtendedCameraControl {
type Vtable = IMFExtendedCameraControl_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x38e33520_fca1_4845_a27a_68b7c6ab3789);
}
impl ::core::convert::From<IMFExtendedCameraControl> for ::windows::core::IUnknown {
fn from(value: IMFExtendedCameraControl) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFExtendedCameraControl> for ::windows::core::IUnknown {
fn from(value: &IMFExtendedCameraControl) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFExtendedCameraControl {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFExtendedCameraControl {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFExtendedCameraControl_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u64,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulflags: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u64,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pppayload: *mut *mut u8, pulpayload: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFExtendedCameraController(pub ::windows::core::IUnknown);
impl IMFExtendedCameraController {
pub unsafe fn GetExtendedCameraControl(&self, dwstreamindex: u32, ulpropertyid: u32) -> ::windows::core::Result<IMFExtendedCameraControl> {
let mut result__: <IMFExtendedCameraControl as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(ulpropertyid), &mut result__).from_abi::<IMFExtendedCameraControl>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFExtendedCameraController {
type Vtable = IMFExtendedCameraController_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb91ebfee_ca03_4af4_8a82_a31752f4a0fc);
}
impl ::core::convert::From<IMFExtendedCameraController> for ::windows::core::IUnknown {
fn from(value: IMFExtendedCameraController) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFExtendedCameraController> for ::windows::core::IUnknown {
fn from(value: &IMFExtendedCameraController) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFExtendedCameraController {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFExtendedCameraController {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFExtendedCameraController_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, ulpropertyid: u32, ppcontrol: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFExtendedCameraIntrinsicModel(pub ::windows::core::IUnknown);
impl IMFExtendedCameraIntrinsicModel {
pub unsafe fn GetModel(&self) -> ::windows::core::Result<MFExtendedCameraIntrinsic_IntrinsicModel> {
let mut result__: <MFExtendedCameraIntrinsic_IntrinsicModel as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MFExtendedCameraIntrinsic_IntrinsicModel>(result__)
}
pub unsafe fn SetModel(&self, pintrinsicmodel: *const MFExtendedCameraIntrinsic_IntrinsicModel) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pintrinsicmodel)).ok()
}
pub unsafe fn GetDistortionModelType(&self) -> ::windows::core::Result<MFCameraIntrinsic_DistortionModelType> {
let mut result__: <MFCameraIntrinsic_DistortionModelType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MFCameraIntrinsic_DistortionModelType>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFExtendedCameraIntrinsicModel {
type Vtable = IMFExtendedCameraIntrinsicModel_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5c595e64_4630_4231_855a_12842f733245);
}
impl ::core::convert::From<IMFExtendedCameraIntrinsicModel> for ::windows::core::IUnknown {
fn from(value: IMFExtendedCameraIntrinsicModel) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFExtendedCameraIntrinsicModel> for ::windows::core::IUnknown {
fn from(value: &IMFExtendedCameraIntrinsicModel) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFExtendedCameraIntrinsicModel {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFExtendedCameraIntrinsicModel {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFExtendedCameraIntrinsicModel_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pintrinsicmodel: *mut MFExtendedCameraIntrinsic_IntrinsicModel) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pintrinsicmodel: *const MFExtendedCameraIntrinsic_IntrinsicModel) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdistortionmodeltype: *mut MFCameraIntrinsic_DistortionModelType) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFExtendedCameraIntrinsics(pub ::windows::core::IUnknown);
impl IMFExtendedCameraIntrinsics {
pub unsafe fn InitializeFromBuffer(&self, pbbuffer: *const u8, dwbuffersize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbbuffer), ::core::mem::transmute(dwbuffersize)).ok()
}
pub unsafe fn GetBufferSize(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SerializeToBuffer(&self, pbbuffer: *mut u8, pdwbuffersize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbbuffer), ::core::mem::transmute(pdwbuffersize)).ok()
}
pub unsafe fn GetIntrinsicModelCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetIntrinsicModelByIndex(&self, dwindex: u32) -> ::windows::core::Result<IMFExtendedCameraIntrinsicModel> {
let mut result__: <IMFExtendedCameraIntrinsicModel as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwindex), &mut result__).from_abi::<IMFExtendedCameraIntrinsicModel>(result__)
}
pub unsafe fn AddIntrinsicModel<'a, Param0: ::windows::core::IntoParam<'a, IMFExtendedCameraIntrinsicModel>>(&self, pintrinsicmodel: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), pintrinsicmodel.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFExtendedCameraIntrinsics {
type Vtable = IMFExtendedCameraIntrinsics_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x687f6dac_6987_4750_a16a_734d1e7a10fe);
}
impl ::core::convert::From<IMFExtendedCameraIntrinsics> for ::windows::core::IUnknown {
fn from(value: IMFExtendedCameraIntrinsics) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFExtendedCameraIntrinsics> for ::windows::core::IUnknown {
fn from(value: &IMFExtendedCameraIntrinsics) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFExtendedCameraIntrinsics {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFExtendedCameraIntrinsics {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFExtendedCameraIntrinsics_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbbuffer: *const u8, dwbuffersize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwbuffersize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbbuffer: *mut u8, pdwbuffersize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwindex: u32, ppintrinsicmodel: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pintrinsicmodel: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFExtendedCameraIntrinsicsDistortionModel6KT(pub ::windows::core::IUnknown);
impl IMFExtendedCameraIntrinsicsDistortionModel6KT {
pub unsafe fn GetDistortionModel(&self) -> ::windows::core::Result<MFCameraIntrinsic_DistortionModel6KT> {
let mut result__: <MFCameraIntrinsic_DistortionModel6KT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MFCameraIntrinsic_DistortionModel6KT>(result__)
}
pub unsafe fn SetDistortionModel(&self, pdistortionmodel: *const MFCameraIntrinsic_DistortionModel6KT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdistortionmodel)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFExtendedCameraIntrinsicsDistortionModel6KT {
type Vtable = IMFExtendedCameraIntrinsicsDistortionModel6KT_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x74c2653b_5f55_4eb1_9f0f_18b8f68b7d3d);
}
impl ::core::convert::From<IMFExtendedCameraIntrinsicsDistortionModel6KT> for ::windows::core::IUnknown {
fn from(value: IMFExtendedCameraIntrinsicsDistortionModel6KT) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFExtendedCameraIntrinsicsDistortionModel6KT> for ::windows::core::IUnknown {
fn from(value: &IMFExtendedCameraIntrinsicsDistortionModel6KT) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFExtendedCameraIntrinsicsDistortionModel6KT {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFExtendedCameraIntrinsicsDistortionModel6KT {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFExtendedCameraIntrinsicsDistortionModel6KT_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdistortionmodel: *mut MFCameraIntrinsic_DistortionModel6KT) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdistortionmodel: *const MFCameraIntrinsic_DistortionModel6KT) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFExtendedCameraIntrinsicsDistortionModelArcTan(pub ::windows::core::IUnknown);
impl IMFExtendedCameraIntrinsicsDistortionModelArcTan {
pub unsafe fn GetDistortionModel(&self) -> ::windows::core::Result<MFCameraIntrinsic_DistortionModelArcTan> {
let mut result__: <MFCameraIntrinsic_DistortionModelArcTan as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MFCameraIntrinsic_DistortionModelArcTan>(result__)
}
pub unsafe fn SetDistortionModel(&self, pdistortionmodel: *const MFCameraIntrinsic_DistortionModelArcTan) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdistortionmodel)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFExtendedCameraIntrinsicsDistortionModelArcTan {
type Vtable = IMFExtendedCameraIntrinsicsDistortionModelArcTan_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x812d5f95_b572_45dc_bafc_ae24199ddda8);
}
impl ::core::convert::From<IMFExtendedCameraIntrinsicsDistortionModelArcTan> for ::windows::core::IUnknown {
fn from(value: IMFExtendedCameraIntrinsicsDistortionModelArcTan) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFExtendedCameraIntrinsicsDistortionModelArcTan> for ::windows::core::IUnknown {
fn from(value: &IMFExtendedCameraIntrinsicsDistortionModelArcTan) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFExtendedCameraIntrinsicsDistortionModelArcTan {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFExtendedCameraIntrinsicsDistortionModelArcTan {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFExtendedCameraIntrinsicsDistortionModelArcTan_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdistortionmodel: *mut MFCameraIntrinsic_DistortionModelArcTan) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdistortionmodel: *const MFCameraIntrinsic_DistortionModelArcTan) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFExtendedDRMTypeSupport(pub ::windows::core::IUnknown);
impl IMFExtendedDRMTypeSupport {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsTypeSupportedEx<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, r#type: Param0, keysystem: Param1) -> ::windows::core::Result<MF_MEDIA_ENGINE_CANPLAY> {
let mut result__: <MF_MEDIA_ENGINE_CANPLAY as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), r#type.into_param().abi(), keysystem.into_param().abi(), &mut result__).from_abi::<MF_MEDIA_ENGINE_CANPLAY>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFExtendedDRMTypeSupport {
type Vtable = IMFExtendedDRMTypeSupport_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x332ec562_3758_468d_a784_e38f23552128);
}
impl ::core::convert::From<IMFExtendedDRMTypeSupport> for ::windows::core::IUnknown {
fn from(value: IMFExtendedDRMTypeSupport) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFExtendedDRMTypeSupport> for ::windows::core::IUnknown {
fn from(value: &IMFExtendedDRMTypeSupport) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFExtendedDRMTypeSupport {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFExtendedDRMTypeSupport {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFExtendedDRMTypeSupport_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, keysystem: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, panswer: *mut MF_MEDIA_ENGINE_CANPLAY) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFFieldOfUseMFTUnlock(pub ::windows::core::IUnknown);
impl IMFFieldOfUseMFTUnlock {
pub unsafe fn Unlock<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, punkmft: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), punkmft.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFFieldOfUseMFTUnlock {
type Vtable = IMFFieldOfUseMFTUnlock_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x508e71d3_ec66_4fc3_8775_b4b9ed6ba847);
}
impl ::core::convert::From<IMFFieldOfUseMFTUnlock> for ::windows::core::IUnknown {
fn from(value: IMFFieldOfUseMFTUnlock) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFFieldOfUseMFTUnlock> for ::windows::core::IUnknown {
fn from(value: &IMFFieldOfUseMFTUnlock) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFFieldOfUseMFTUnlock {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFFieldOfUseMFTUnlock {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFFieldOfUseMFTUnlock_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, punkmft: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFFinalizableMediaSink(pub ::windows::core::IUnknown);
impl IMFFinalizableMediaSink {
pub unsafe fn GetCharacteristics(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddStreamSink<'a, Param1: ::windows::core::IntoParam<'a, IMFMediaType>>(&self, dwstreamsinkidentifier: u32, pmediatype: Param1) -> ::windows::core::Result<IMFStreamSink> {
let mut result__: <IMFStreamSink as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamsinkidentifier), pmediatype.into_param().abi(), &mut result__).from_abi::<IMFStreamSink>(result__)
}
pub unsafe fn RemoveStreamSink(&self, dwstreamsinkidentifier: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamsinkidentifier)).ok()
}
pub unsafe fn GetStreamSinkCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetStreamSinkByIndex(&self, dwindex: u32) -> ::windows::core::Result<IMFStreamSink> {
let mut result__: <IMFStreamSink as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwindex), &mut result__).from_abi::<IMFStreamSink>(result__)
}
pub unsafe fn GetStreamSinkById(&self, dwstreamsinkidentifier: u32) -> ::windows::core::Result<IMFStreamSink> {
let mut result__: <IMFStreamSink as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamsinkidentifier), &mut result__).from_abi::<IMFStreamSink>(result__)
}
pub unsafe fn SetPresentationClock<'a, Param0: ::windows::core::IntoParam<'a, IMFPresentationClock>>(&self, ppresentationclock: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ppresentationclock.into_param().abi()).ok()
}
pub unsafe fn GetPresentationClock(&self) -> ::windows::core::Result<IMFPresentationClock> {
let mut result__: <IMFPresentationClock as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFPresentationClock>(result__)
}
pub unsafe fn Shutdown(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn BeginFinalize<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pcallback: Param0, punkstate: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), pcallback.into_param().abi(), punkstate.into_param().abi()).ok()
}
pub unsafe fn EndFinalize<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), presult.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFFinalizableMediaSink {
type Vtable = IMFFinalizableMediaSink_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xeaecb74a_9a50_42ce_9541_6a7f57aa4ad7);
}
impl ::core::convert::From<IMFFinalizableMediaSink> for ::windows::core::IUnknown {
fn from(value: IMFFinalizableMediaSink) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFFinalizableMediaSink> for ::windows::core::IUnknown {
fn from(value: &IMFFinalizableMediaSink) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFFinalizableMediaSink {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFFinalizableMediaSink {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFFinalizableMediaSink> for IMFMediaSink {
fn from(value: IMFFinalizableMediaSink) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFFinalizableMediaSink> for IMFMediaSink {
fn from(value: &IMFFinalizableMediaSink) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaSink> for IMFFinalizableMediaSink {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaSink> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaSink> for &IMFFinalizableMediaSink {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaSink> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFFinalizableMediaSink_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcharacteristics: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamsinkidentifier: u32, pmediatype: ::windows::core::RawPtr, ppstreamsink: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamsinkidentifier: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcstreamsinkcount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwindex: u32, ppstreamsink: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamsinkidentifier: u32, ppstreamsink: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppresentationclock: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pppresentationclock: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcallback: ::windows::core::RawPtr, punkstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFGetService(pub ::windows::core::IUnknown);
impl IMFGetService {
pub unsafe fn GetService<T: ::windows::core::Interface>(&self, guidservice: *const ::windows::core::GUID) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidservice), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
}
unsafe impl ::windows::core::Interface for IMFGetService {
type Vtable = IMFGetService_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfa993888_4383_415a_a930_dd472a8cf6f7);
}
impl ::core::convert::From<IMFGetService> for ::windows::core::IUnknown {
fn from(value: IMFGetService) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFGetService> for ::windows::core::IUnknown {
fn from(value: &IMFGetService) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFGetService {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFGetService {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFGetService_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidservice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFHDCPStatus(pub ::windows::core::IUnknown);
impl IMFHDCPStatus {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Query(&self, pstatus: *mut MF_HDCP_STATUS, pfstatus: *mut super::super::Foundation::BOOL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pstatus), ::core::mem::transmute(pfstatus)).ok()
}
pub unsafe fn Set(&self, status: MF_HDCP_STATUS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(status)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFHDCPStatus {
type Vtable = IMFHDCPStatus_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xde400f54_5bf1_40cf_8964_0bea136b1e3d);
}
impl ::core::convert::From<IMFHDCPStatus> for ::windows::core::IUnknown {
fn from(value: IMFHDCPStatus) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFHDCPStatus> for ::windows::core::IUnknown {
fn from(value: &IMFHDCPStatus) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFHDCPStatus {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFHDCPStatus {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFHDCPStatus_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstatus: *mut MF_HDCP_STATUS, pfstatus: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, status: MF_HDCP_STATUS) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFHttpDownloadRequest(pub ::windows::core::IUnknown);
impl IMFHttpDownloadRequest {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddHeader<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, szheader: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), szheader.into_param().abi()).ok()
}
pub unsafe fn BeginSendRequest<'a, Param2: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param3: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pbpayload: *const u8, cbpayload: u32, pcallback: Param2, punkstate: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbpayload), ::core::mem::transmute(cbpayload), pcallback.into_param().abi(), punkstate.into_param().abi()).ok()
}
pub unsafe fn EndSendRequest<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), presult.into_param().abi()).ok()
}
pub unsafe fn BeginReceiveResponse<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pcallback: Param0, punkstate: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), pcallback.into_param().abi(), punkstate.into_param().abi()).ok()
}
pub unsafe fn EndReceiveResponse<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), presult.into_param().abi()).ok()
}
pub unsafe fn BeginReadPayload<'a, Param2: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param3: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pb: *mut u8, cb: u32, pcallback: Param2, punkstate: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(pb), ::core::mem::transmute(cb), pcallback.into_param().abi(), punkstate.into_param().abi()).ok()
}
pub unsafe fn EndReadPayload<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0, pqwoffset: *mut u64, pcbread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), presult.into_param().abi(), ::core::mem::transmute(pqwoffset), ::core::mem::transmute(pcbread)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn QueryHeader<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, szheadername: Param0, dwindex: u32) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), szheadername.into_param().abi(), ::core::mem::transmute(dwindex), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetURL(&self) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn HasNullSourceOrigin(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn GetTimeSeekResult(&self, pqwstarttime: *mut u64, pqwstoptime: *mut u64, pqwduration: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(pqwstarttime), ::core::mem::transmute(pqwstoptime), ::core::mem::transmute(pqwduration)).ok()
}
pub unsafe fn GetHttpStatus(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetAtEndOfPayload(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn GetTotalLength(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetRangeEndOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn Close(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFHttpDownloadRequest {
type Vtable = IMFHttpDownloadRequest_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf779fddf_26e7_4270_8a8b_b983d1859de0);
}
impl ::core::convert::From<IMFHttpDownloadRequest> for ::windows::core::IUnknown {
fn from(value: IMFHttpDownloadRequest) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFHttpDownloadRequest> for ::windows::core::IUnknown {
fn from(value: &IMFHttpDownloadRequest) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFHttpDownloadRequest {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFHttpDownloadRequest {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFHttpDownloadRequest_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, szheader: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbpayload: *const u8, cbpayload: u32, pcallback: ::windows::core::RawPtr, punkstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcallback: ::windows::core::RawPtr, punkstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pb: *mut u8, cb: u32, pcallback: ::windows::core::RawPtr, punkstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr, pqwoffset: *mut u64, pcbread: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, szheadername: super::super::Foundation::PWSTR, dwindex: u32, ppszheadervalue: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppszurl: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfnullsourceorigin: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqwstarttime: *mut u64, pqwstoptime: *mut u64, pqwduration: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwhttpstatus: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfatendofpayload: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqwtotallength: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pqwrangeend: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFHttpDownloadSession(pub ::windows::core::IUnknown);
impl IMFHttpDownloadSession {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetServer<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, szservername: Param0, nport: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), szservername.into_param().abi(), ::core::mem::transmute(nport)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateRequest<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>, Param3: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(
&self,
szobjectname: Param0,
fbypassproxycache: Param1,
fsecure: Param2,
szverb: Param3,
szreferrer: Param4,
) -> ::windows::core::Result<IMFHttpDownloadRequest> {
let mut result__: <IMFHttpDownloadRequest as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), szobjectname.into_param().abi(), fbypassproxycache.into_param().abi(), fsecure.into_param().abi(), szverb.into_param().abi(), szreferrer.into_param().abi(), &mut result__).from_abi::<IMFHttpDownloadRequest>(result__)
}
pub unsafe fn Close(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFHttpDownloadSession {
type Vtable = IMFHttpDownloadSession_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x71fa9a2c_53ce_4662_a132_1a7e8cbf62db);
}
impl ::core::convert::From<IMFHttpDownloadSession> for ::windows::core::IUnknown {
fn from(value: IMFHttpDownloadSession) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFHttpDownloadSession> for ::windows::core::IUnknown {
fn from(value: &IMFHttpDownloadSession) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFHttpDownloadSession {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFHttpDownloadSession {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFHttpDownloadSession_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, szservername: super::super::Foundation::PWSTR, nport: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, szobjectname: super::super::Foundation::PWSTR, fbypassproxycache: super::super::Foundation::BOOL, fsecure: super::super::Foundation::BOOL, szverb: super::super::Foundation::PWSTR, szreferrer: super::super::Foundation::PWSTR, pprequest: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFHttpDownloadSessionProvider(pub ::windows::core::IUnknown);
impl IMFHttpDownloadSessionProvider {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateHttpDownloadSession<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, wszscheme: Param0) -> ::windows::core::Result<IMFHttpDownloadSession> {
let mut result__: <IMFHttpDownloadSession as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), wszscheme.into_param().abi(), &mut result__).from_abi::<IMFHttpDownloadSession>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFHttpDownloadSessionProvider {
type Vtable = IMFHttpDownloadSessionProvider_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1b4cf4b9_3a16_4115_839d_03cc5c99df01);
}
impl ::core::convert::From<IMFHttpDownloadSessionProvider> for ::windows::core::IUnknown {
fn from(value: IMFHttpDownloadSessionProvider) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFHttpDownloadSessionProvider> for ::windows::core::IUnknown {
fn from(value: &IMFHttpDownloadSessionProvider) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFHttpDownloadSessionProvider {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFHttpDownloadSessionProvider {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFHttpDownloadSessionProvider_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, wszscheme: super::super::Foundation::PWSTR, ppdownloadsession: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFImageSharingEngine(pub ::windows::core::IUnknown);
impl IMFImageSharingEngine {
pub unsafe fn SetSource<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pstream: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pstream.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDevice(&self) -> ::windows::core::Result<DEVICE_INFO> {
let mut result__: <DEVICE_INFO as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<DEVICE_INFO>(result__)
}
pub unsafe fn Shutdown(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFImageSharingEngine {
type Vtable = IMFImageSharingEngine_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xcfa0ae8e_7e1c_44d2_ae68_fc4c148a6354);
}
impl ::core::convert::From<IMFImageSharingEngine> for ::windows::core::IUnknown {
fn from(value: IMFImageSharingEngine) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFImageSharingEngine> for ::windows::core::IUnknown {
fn from(value: &IMFImageSharingEngine) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFImageSharingEngine {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFImageSharingEngine {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFImageSharingEngine_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstream: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdevice: *mut ::core::mem::ManuallyDrop<DEVICE_INFO>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFImageSharingEngineClassFactory(pub ::windows::core::IUnknown);
impl IMFImageSharingEngineClassFactory {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateInstanceFromUDN<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, puniquedevicename: Param0) -> ::windows::core::Result<IMFImageSharingEngine> {
let mut result__: <IMFImageSharingEngine as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), puniquedevicename.into_param().abi(), &mut result__).from_abi::<IMFImageSharingEngine>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFImageSharingEngineClassFactory {
type Vtable = IMFImageSharingEngineClassFactory_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1fc55727_a7fb_4fc8_83ae_8af024990af1);
}
impl ::core::convert::From<IMFImageSharingEngineClassFactory> for ::windows::core::IUnknown {
fn from(value: IMFImageSharingEngineClassFactory) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFImageSharingEngineClassFactory> for ::windows::core::IUnknown {
fn from(value: &IMFImageSharingEngineClassFactory) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFImageSharingEngineClassFactory {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFImageSharingEngineClassFactory {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFImageSharingEngineClassFactory_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, puniquedevicename: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, ppengine: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFInputTrustAuthority(pub ::windows::core::IUnknown);
impl IMFInputTrustAuthority {
pub unsafe fn GetDecrypter(&self, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(riid), ::core::mem::transmute(ppv)).ok()
}
pub unsafe fn RequestAccess(&self, action: MFPOLICYMANAGER_ACTION) -> ::windows::core::Result<IMFActivate> {
let mut result__: <IMFActivate as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(action), &mut result__).from_abi::<IMFActivate>(result__)
}
pub unsafe fn GetPolicy(&self, action: MFPOLICYMANAGER_ACTION) -> ::windows::core::Result<IMFOutputPolicy> {
let mut result__: <IMFOutputPolicy as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(action), &mut result__).from_abi::<IMFOutputPolicy>(result__)
}
pub unsafe fn BindAccess(&self, pparam: *const MFINPUTTRUSTAUTHORITY_ACCESS_PARAMS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(pparam)).ok()
}
pub unsafe fn UpdateAccess(&self, pparam: *const MFINPUTTRUSTAUTHORITY_ACCESS_PARAMS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(pparam)).ok()
}
pub unsafe fn Reset(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFInputTrustAuthority {
type Vtable = IMFInputTrustAuthority_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd19f8e98_b126_4446_890c_5dcb7ad71453);
}
impl ::core::convert::From<IMFInputTrustAuthority> for ::windows::core::IUnknown {
fn from(value: IMFInputTrustAuthority) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFInputTrustAuthority> for ::windows::core::IUnknown {
fn from(value: &IMFInputTrustAuthority) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFInputTrustAuthority {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFInputTrustAuthority {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFInputTrustAuthority_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, action: MFPOLICYMANAGER_ACTION, ppcontentenableractivate: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, action: MFPOLICYMANAGER_ACTION, pppolicy: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pparam: *const MFINPUTTRUSTAUTHORITY_ACCESS_PARAMS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pparam: *const MFINPUTTRUSTAUTHORITY_ACCESS_PARAMS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFLocalMFTRegistration(pub ::windows::core::IUnknown);
impl IMFLocalMFTRegistration {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn RegisterMFTs(&self, pmfts: *const MFT_REGISTRATION_INFO, cmfts: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pmfts), ::core::mem::transmute(cmfts)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFLocalMFTRegistration {
type Vtable = IMFLocalMFTRegistration_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x149c4d73_b4be_4f8d_8b87_079e926b6add);
}
impl ::core::convert::From<IMFLocalMFTRegistration> for ::windows::core::IUnknown {
fn from(value: IMFLocalMFTRegistration) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFLocalMFTRegistration> for ::windows::core::IUnknown {
fn from(value: &IMFLocalMFTRegistration) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFLocalMFTRegistration {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFLocalMFTRegistration {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFLocalMFTRegistration_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pmfts: *const MFT_REGISTRATION_INFO, cmfts: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaBuffer(pub ::windows::core::IUnknown);
impl IMFMediaBuffer {
pub unsafe fn Lock(&self, ppbbuffer: *mut *mut u8, pcbmaxlength: *mut u32, pcbcurrentlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(ppbbuffer), ::core::mem::transmute(pcbmaxlength), ::core::mem::transmute(pcbcurrentlength)).ok()
}
pub unsafe fn Unlock(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetCurrentLength(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetCurrentLength(&self, cbcurrentlength: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(cbcurrentlength)).ok()
}
pub unsafe fn GetMaxLength(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFMediaBuffer {
type Vtable = IMFMediaBuffer_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x045fa593_8799_42b8_bc8d_8968c6453507);
}
impl ::core::convert::From<IMFMediaBuffer> for ::windows::core::IUnknown {
fn from(value: IMFMediaBuffer) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaBuffer> for ::windows::core::IUnknown {
fn from(value: &IMFMediaBuffer) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaBuffer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaBuffer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaBuffer_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppbbuffer: *mut *mut u8, pcbmaxlength: *mut u32, pcbcurrentlength: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcbcurrentlength: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, cbcurrentlength: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcbmaxlength: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaEngine(pub ::windows::core::IUnknown);
impl IMFMediaEngine {
pub unsafe fn GetError(&self) -> ::windows::core::Result<IMFMediaError> {
let mut result__: <IMFMediaError as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFMediaError>(result__)
}
pub unsafe fn SetErrorCode(&self, error: MF_MEDIA_ENGINE_ERR) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(error)).ok()
}
pub unsafe fn SetSourceElements<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaEngineSrcElements>>(&self, psrcelements: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), psrcelements.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSource<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, purl: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), purl.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetCurrentSource(&self) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetNetworkState(&self) -> u16 {
::core::mem::transmute((::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetPreload(&self) -> MF_MEDIA_ENGINE_PRELOAD {
::core::mem::transmute((::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)))
}
pub unsafe fn SetPreload(&self, preload: MF_MEDIA_ENGINE_PRELOAD) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(preload)).ok()
}
pub unsafe fn GetBuffered(&self) -> ::windows::core::Result<IMFMediaTimeRange> {
let mut result__: <IMFMediaTimeRange as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFMediaTimeRange>(result__)
}
pub unsafe fn Load(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CanPlayType<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, r#type: Param0) -> ::windows::core::Result<MF_MEDIA_ENGINE_CANPLAY> {
let mut result__: <MF_MEDIA_ENGINE_CANPLAY as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), r#type.into_param().abi(), &mut result__).from_abi::<MF_MEDIA_ENGINE_CANPLAY>(result__)
}
pub unsafe fn GetReadyState(&self) -> u16 {
::core::mem::transmute((::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsSeeking(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetCurrentTime(&self) -> f64 {
::core::mem::transmute((::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self)))
}
pub unsafe fn SetCurrentTime(&self, seektime: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(seektime)).ok()
}
pub unsafe fn GetStartTime(&self) -> f64 {
::core::mem::transmute((::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetDuration(&self) -> f64 {
::core::mem::transmute((::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsPaused(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetDefaultPlaybackRate(&self) -> f64 {
::core::mem::transmute((::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self)))
}
pub unsafe fn SetDefaultPlaybackRate(&self, rate: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(rate)).ok()
}
pub unsafe fn GetPlaybackRate(&self) -> f64 {
::core::mem::transmute((::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self)))
}
pub unsafe fn SetPlaybackRate(&self, rate: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(rate)).ok()
}
pub unsafe fn GetPlayed(&self) -> ::windows::core::Result<IMFMediaTimeRange> {
let mut result__: <IMFMediaTimeRange as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFMediaTimeRange>(result__)
}
pub unsafe fn GetSeekable(&self) -> ::windows::core::Result<IMFMediaTimeRange> {
let mut result__: <IMFMediaTimeRange as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFMediaTimeRange>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsEnded(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetAutoPlay(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetAutoPlay<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, autoplay: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), autoplay.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLoop(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetLoop<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, r#loop: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), r#loop.into_param().abi()).ok()
}
pub unsafe fn Play(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Pause(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetMuted(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetMuted<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, muted: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), muted.into_param().abi()).ok()
}
pub unsafe fn GetVolume(&self) -> f64 {
::core::mem::transmute((::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self)))
}
pub unsafe fn SetVolume(&self, volume: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), ::core::mem::transmute(volume)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn HasVideo(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn HasAudio(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetNativeVideoSize(&self, cx: *mut u32, cy: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).40)(::core::mem::transmute_copy(self), ::core::mem::transmute(cx), ::core::mem::transmute(cy)).ok()
}
pub unsafe fn GetVideoAspectRatio(&self, cx: *mut u32, cy: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), ::core::mem::transmute(cx), ::core::mem::transmute(cy)).ok()
}
pub unsafe fn Shutdown(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn TransferVideoFrame<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pdstsurf: Param0, psrc: *const MFVideoNormalizedRect, pdst: *const super::super::Foundation::RECT, pborderclr: *const MFARGB) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self), pdstsurf.into_param().abi(), ::core::mem::transmute(psrc), ::core::mem::transmute(pdst), ::core::mem::transmute(pborderclr)).ok()
}
pub unsafe fn OnVideoStreamTick(&self) -> ::windows::core::Result<i64> {
let mut result__: <i64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).44)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i64>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFMediaEngine {
type Vtable = IMFMediaEngine_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x98a1b0bb_03eb_4935_ae7c_93c1fa0e1c93);
}
impl ::core::convert::From<IMFMediaEngine> for ::windows::core::IUnknown {
fn from(value: IMFMediaEngine) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaEngine> for ::windows::core::IUnknown {
fn from(value: &IMFMediaEngine) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaEngine {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaEngine {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaEngine_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pperror: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, error: MF_MEDIA_ENGINE_ERR) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psrcelements: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, purl: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppurl: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u16,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> MF_MEDIA_ENGINE_PRELOAD,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, preload: MF_MEDIA_ENGINE_PRELOAD) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppbuffered: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, panswer: *mut MF_MEDIA_ENGINE_CANPLAY) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u16,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> f64,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, seektime: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> f64,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> f64,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> f64,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rate: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> f64,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rate: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppplayed: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppseekable: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, autoplay: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#loop: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, muted: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> f64,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, volume: f64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, cx: *mut u32, cy: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, cx: *mut u32, cy: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdstsurf: ::windows::core::RawPtr, psrc: *const MFVideoNormalizedRect, pdst: *const super::super::Foundation::RECT, pborderclr: *const MFARGB) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppts: *mut i64) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaEngineAudioEndpointId(pub ::windows::core::IUnknown);
impl IMFMediaEngineAudioEndpointId {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetAudioEndpointId<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszendpointid: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pszendpointid.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetAudioEndpointId(&self) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFMediaEngineAudioEndpointId {
type Vtable = IMFMediaEngineAudioEndpointId_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7a3bac98_0e76_49fb_8c20_8a86fd98eaf2);
}
impl ::core::convert::From<IMFMediaEngineAudioEndpointId> for ::windows::core::IUnknown {
fn from(value: IMFMediaEngineAudioEndpointId) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaEngineAudioEndpointId> for ::windows::core::IUnknown {
fn from(value: &IMFMediaEngineAudioEndpointId) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaEngineAudioEndpointId {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaEngineAudioEndpointId {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaEngineAudioEndpointId_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszendpointid: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppszendpointid: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaEngineClassFactory(pub ::windows::core::IUnknown);
impl IMFMediaEngineClassFactory {
pub unsafe fn CreateInstance<'a, Param1: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, dwflags: u32, pattr: Param1) -> ::windows::core::Result<IMFMediaEngine> {
let mut result__: <IMFMediaEngine as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwflags), pattr.into_param().abi(), &mut result__).from_abi::<IMFMediaEngine>(result__)
}
pub unsafe fn CreateTimeRange(&self) -> ::windows::core::Result<IMFMediaTimeRange> {
let mut result__: <IMFMediaTimeRange as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFMediaTimeRange>(result__)
}
pub unsafe fn CreateError(&self) -> ::windows::core::Result<IMFMediaError> {
let mut result__: <IMFMediaError as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFMediaError>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFMediaEngineClassFactory {
type Vtable = IMFMediaEngineClassFactory_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4d645ace_26aa_4688_9be1_df3516990b93);
}
impl ::core::convert::From<IMFMediaEngineClassFactory> for ::windows::core::IUnknown {
fn from(value: IMFMediaEngineClassFactory) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaEngineClassFactory> for ::windows::core::IUnknown {
fn from(value: &IMFMediaEngineClassFactory) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaEngineClassFactory {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaEngineClassFactory {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaEngineClassFactory_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwflags: u32, pattr: ::windows::core::RawPtr, ppplayer: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pptimerange: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pperror: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaEngineClassFactory2(pub ::windows::core::IUnknown);
impl IMFMediaEngineClassFactory2 {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateMediaKeys2<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, keysystem: Param0, defaultcdmstorepath: Param1, inprivatecdmstorepath: Param2) -> ::windows::core::Result<IMFMediaKeys> {
let mut result__: <IMFMediaKeys as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), keysystem.into_param().abi(), defaultcdmstorepath.into_param().abi(), inprivatecdmstorepath.into_param().abi(), &mut result__).from_abi::<IMFMediaKeys>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFMediaEngineClassFactory2 {
type Vtable = IMFMediaEngineClassFactory2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x09083cef_867f_4bf6_8776_dee3a7b42fca);
}
impl ::core::convert::From<IMFMediaEngineClassFactory2> for ::windows::core::IUnknown {
fn from(value: IMFMediaEngineClassFactory2) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaEngineClassFactory2> for ::windows::core::IUnknown {
fn from(value: &IMFMediaEngineClassFactory2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaEngineClassFactory2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaEngineClassFactory2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaEngineClassFactory2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, keysystem: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, defaultcdmstorepath: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, inprivatecdmstorepath: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, ppkeys: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaEngineClassFactory3(pub ::windows::core::IUnknown);
impl IMFMediaEngineClassFactory3 {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem"))]
pub unsafe fn CreateMediaKeySystemAccess<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, keysystem: Param0, ppsupportedconfigurationsarray: *const ::core::option::Option<super::super::UI::Shell::PropertiesSystem::IPropertyStore>, usize: u32) -> ::windows::core::Result<IMFMediaKeySystemAccess> {
let mut result__: <IMFMediaKeySystemAccess as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), keysystem.into_param().abi(), ::core::mem::transmute(ppsupportedconfigurationsarray), ::core::mem::transmute(usize), &mut result__).from_abi::<IMFMediaKeySystemAccess>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFMediaEngineClassFactory3 {
type Vtable = IMFMediaEngineClassFactory3_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3787614f_65f7_4003_b673_ead8293a0e60);
}
impl ::core::convert::From<IMFMediaEngineClassFactory3> for ::windows::core::IUnknown {
fn from(value: IMFMediaEngineClassFactory3) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaEngineClassFactory3> for ::windows::core::IUnknown {
fn from(value: &IMFMediaEngineClassFactory3) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaEngineClassFactory3 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaEngineClassFactory3 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaEngineClassFactory3_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, keysystem: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, ppsupportedconfigurationsarray: *const ::windows::core::RawPtr, usize: u32, ppkeyaccess: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaEngineClassFactory4(pub ::windows::core::IUnknown);
impl IMFMediaEngineClassFactory4 {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateContentDecryptionModuleFactory<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, keysystem: Param0, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), keysystem.into_param().abi(), ::core::mem::transmute(riid), ::core::mem::transmute(ppvobject)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFMediaEngineClassFactory4 {
type Vtable = IMFMediaEngineClassFactory4_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfbe256c1_43cf_4a9b_8cb8_ce8632a34186);
}
impl ::core::convert::From<IMFMediaEngineClassFactory4> for ::windows::core::IUnknown {
fn from(value: IMFMediaEngineClassFactory4) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaEngineClassFactory4> for ::windows::core::IUnknown {
fn from(value: &IMFMediaEngineClassFactory4) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaEngineClassFactory4 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaEngineClassFactory4 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaEngineClassFactory4_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, keysystem: super::super::Foundation::PWSTR, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaEngineClassFactoryEx(pub ::windows::core::IUnknown);
impl IMFMediaEngineClassFactoryEx {
pub unsafe fn CreateInstance<'a, Param1: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, dwflags: u32, pattr: Param1) -> ::windows::core::Result<IMFMediaEngine> {
let mut result__: <IMFMediaEngine as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwflags), pattr.into_param().abi(), &mut result__).from_abi::<IMFMediaEngine>(result__)
}
pub unsafe fn CreateTimeRange(&self) -> ::windows::core::Result<IMFMediaTimeRange> {
let mut result__: <IMFMediaTimeRange as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFMediaTimeRange>(result__)
}
pub unsafe fn CreateError(&self) -> ::windows::core::Result<IMFMediaError> {
let mut result__: <IMFMediaError as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFMediaError>(result__)
}
pub unsafe fn CreateMediaSourceExtension<'a, Param1: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, dwflags: u32, pattr: Param1) -> ::windows::core::Result<IMFMediaSourceExtension> {
let mut result__: <IMFMediaSourceExtension as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwflags), pattr.into_param().abi(), &mut result__).from_abi::<IMFMediaSourceExtension>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateMediaKeys<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, keysystem: Param0, cdmstorepath: Param1) -> ::windows::core::Result<IMFMediaKeys> {
let mut result__: <IMFMediaKeys as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), keysystem.into_param().abi(), cdmstorepath.into_param().abi(), &mut result__).from_abi::<IMFMediaKeys>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsTypeSupported<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, r#type: Param0, keysystem: Param1) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), r#type.into_param().abi(), keysystem.into_param().abi(), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFMediaEngineClassFactoryEx {
type Vtable = IMFMediaEngineClassFactoryEx_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc56156c6_ea5b_48a5_9df8_fbe035d0929e);
}
impl ::core::convert::From<IMFMediaEngineClassFactoryEx> for ::windows::core::IUnknown {
fn from(value: IMFMediaEngineClassFactoryEx) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaEngineClassFactoryEx> for ::windows::core::IUnknown {
fn from(value: &IMFMediaEngineClassFactoryEx) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaEngineClassFactoryEx {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaEngineClassFactoryEx {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFMediaEngineClassFactoryEx> for IMFMediaEngineClassFactory {
fn from(value: IMFMediaEngineClassFactoryEx) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFMediaEngineClassFactoryEx> for IMFMediaEngineClassFactory {
fn from(value: &IMFMediaEngineClassFactoryEx) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaEngineClassFactory> for IMFMediaEngineClassFactoryEx {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaEngineClassFactory> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaEngineClassFactory> for &IMFMediaEngineClassFactoryEx {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaEngineClassFactory> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaEngineClassFactoryEx_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwflags: u32, pattr: ::windows::core::RawPtr, ppplayer: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pptimerange: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pperror: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwflags: u32, pattr: ::windows::core::RawPtr, ppmse: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, keysystem: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, cdmstorepath: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, ppkeys: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, keysystem: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, issupported: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaEngineEME(pub ::windows::core::IUnknown);
impl IMFMediaEngineEME {
pub unsafe fn Keys(&self) -> ::windows::core::Result<IMFMediaKeys> {
let mut result__: <IMFMediaKeys as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFMediaKeys>(result__)
}
pub unsafe fn SetMediaKeys<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaKeys>>(&self, keys: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), keys.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFMediaEngineEME {
type Vtable = IMFMediaEngineEME_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x50dc93e4_ba4f_4275_ae66_83e836e57469);
}
impl ::core::convert::From<IMFMediaEngineEME> for ::windows::core::IUnknown {
fn from(value: IMFMediaEngineEME) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaEngineEME> for ::windows::core::IUnknown {
fn from(value: &IMFMediaEngineEME) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaEngineEME {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaEngineEME {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaEngineEME_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, keys: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, keys: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaEngineEMENotify(pub ::windows::core::IUnknown);
impl IMFMediaEngineEMENotify {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Encrypted<'a, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, pbinitdata: *const u8, cb: u32, bstrinitdatatype: Param2) {
::core::mem::transmute((::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbinitdata), ::core::mem::transmute(cb), bstrinitdatatype.into_param().abi()))
}
pub unsafe fn WaitingForKey(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)))
}
}
unsafe impl ::windows::core::Interface for IMFMediaEngineEMENotify {
type Vtable = IMFMediaEngineEMENotify_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9e184d15_cdb7_4f86_b49e_566689f4a601);
}
impl ::core::convert::From<IMFMediaEngineEMENotify> for ::windows::core::IUnknown {
fn from(value: IMFMediaEngineEMENotify) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaEngineEMENotify> for ::windows::core::IUnknown {
fn from(value: &IMFMediaEngineEMENotify) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaEngineEMENotify {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaEngineEMENotify {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaEngineEMENotify_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbinitdata: *const u8, cb: u32, bstrinitdatatype: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>),
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaEngineEx(pub ::windows::core::IUnknown);
impl IMFMediaEngineEx {
pub unsafe fn GetError(&self) -> ::windows::core::Result<IMFMediaError> {
let mut result__: <IMFMediaError as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFMediaError>(result__)
}
pub unsafe fn SetErrorCode(&self, error: MF_MEDIA_ENGINE_ERR) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(error)).ok()
}
pub unsafe fn SetSourceElements<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaEngineSrcElements>>(&self, psrcelements: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), psrcelements.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSource<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, purl: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), purl.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetCurrentSource(&self) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetNetworkState(&self) -> u16 {
::core::mem::transmute((::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetPreload(&self) -> MF_MEDIA_ENGINE_PRELOAD {
::core::mem::transmute((::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)))
}
pub unsafe fn SetPreload(&self, preload: MF_MEDIA_ENGINE_PRELOAD) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(preload)).ok()
}
pub unsafe fn GetBuffered(&self) -> ::windows::core::Result<IMFMediaTimeRange> {
let mut result__: <IMFMediaTimeRange as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFMediaTimeRange>(result__)
}
pub unsafe fn Load(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CanPlayType<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, r#type: Param0) -> ::windows::core::Result<MF_MEDIA_ENGINE_CANPLAY> {
let mut result__: <MF_MEDIA_ENGINE_CANPLAY as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), r#type.into_param().abi(), &mut result__).from_abi::<MF_MEDIA_ENGINE_CANPLAY>(result__)
}
pub unsafe fn GetReadyState(&self) -> u16 {
::core::mem::transmute((::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsSeeking(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetCurrentTime(&self) -> f64 {
::core::mem::transmute((::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self)))
}
pub unsafe fn SetCurrentTime(&self, seektime: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(seektime)).ok()
}
pub unsafe fn GetStartTime(&self) -> f64 {
::core::mem::transmute((::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetDuration(&self) -> f64 {
::core::mem::transmute((::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsPaused(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetDefaultPlaybackRate(&self) -> f64 {
::core::mem::transmute((::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self)))
}
pub unsafe fn SetDefaultPlaybackRate(&self, rate: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(rate)).ok()
}
pub unsafe fn GetPlaybackRate(&self) -> f64 {
::core::mem::transmute((::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self)))
}
pub unsafe fn SetPlaybackRate(&self, rate: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(rate)).ok()
}
pub unsafe fn GetPlayed(&self) -> ::windows::core::Result<IMFMediaTimeRange> {
let mut result__: <IMFMediaTimeRange as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFMediaTimeRange>(result__)
}
pub unsafe fn GetSeekable(&self) -> ::windows::core::Result<IMFMediaTimeRange> {
let mut result__: <IMFMediaTimeRange as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFMediaTimeRange>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsEnded(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetAutoPlay(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetAutoPlay<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, autoplay: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), autoplay.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLoop(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetLoop<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, r#loop: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), r#loop.into_param().abi()).ok()
}
pub unsafe fn Play(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Pause(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetMuted(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetMuted<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, muted: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), muted.into_param().abi()).ok()
}
pub unsafe fn GetVolume(&self) -> f64 {
::core::mem::transmute((::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self)))
}
pub unsafe fn SetVolume(&self, volume: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), ::core::mem::transmute(volume)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn HasVideo(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn HasAudio(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetNativeVideoSize(&self, cx: *mut u32, cy: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).40)(::core::mem::transmute_copy(self), ::core::mem::transmute(cx), ::core::mem::transmute(cy)).ok()
}
pub unsafe fn GetVideoAspectRatio(&self, cx: *mut u32, cy: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), ::core::mem::transmute(cx), ::core::mem::transmute(cy)).ok()
}
pub unsafe fn Shutdown(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn TransferVideoFrame<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pdstsurf: Param0, psrc: *const MFVideoNormalizedRect, pdst: *const super::super::Foundation::RECT, pborderclr: *const MFARGB) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self), pdstsurf.into_param().abi(), ::core::mem::transmute(psrc), ::core::mem::transmute(pdst), ::core::mem::transmute(pborderclr)).ok()
}
pub unsafe fn OnVideoStreamTick(&self) -> ::windows::core::Result<i64> {
let mut result__: <i64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).44)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSourceFromByteStream<'a, Param0: ::windows::core::IntoParam<'a, IMFByteStream>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, pbytestream: Param0, purl: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).45)(::core::mem::transmute_copy(self), pbytestream.into_param().abi(), purl.into_param().abi()).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetStatistics(&self, statisticid: MF_MEDIA_ENGINE_STATISTIC) -> ::windows::core::Result<super::super::System::Com::StructuredStorage::PROPVARIANT> {
let mut result__: <super::super::System::Com::StructuredStorage::PROPVARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).46)(::core::mem::transmute_copy(self), ::core::mem::transmute(statisticid), &mut result__).from_abi::<super::super::System::Com::StructuredStorage::PROPVARIANT>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn UpdateVideoStream(&self, psrc: *const MFVideoNormalizedRect, pdst: *const super::super::Foundation::RECT, pborderclr: *const MFARGB) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).47)(::core::mem::transmute_copy(self), ::core::mem::transmute(psrc), ::core::mem::transmute(pdst), ::core::mem::transmute(pborderclr)).ok()
}
pub unsafe fn GetBalance(&self) -> f64 {
::core::mem::transmute((::windows::core::Interface::vtable(self).48)(::core::mem::transmute_copy(self)))
}
pub unsafe fn SetBalance(&self, balance: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).49)(::core::mem::transmute_copy(self), ::core::mem::transmute(balance)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsPlaybackRateSupported(&self, rate: f64) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).50)(::core::mem::transmute_copy(self), ::core::mem::transmute(rate)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn FrameStep<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, forward: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).51)(::core::mem::transmute_copy(self), forward.into_param().abi()).ok()
}
pub unsafe fn GetResourceCharacteristics(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).52)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetPresentationAttribute(&self, guidmfattribute: *const ::windows::core::GUID) -> ::windows::core::Result<super::super::System::Com::StructuredStorage::PROPVARIANT> {
let mut result__: <super::super::System::Com::StructuredStorage::PROPVARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).53)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidmfattribute), &mut result__).from_abi::<super::super::System::Com::StructuredStorage::PROPVARIANT>(result__)
}
pub unsafe fn GetNumberOfStreams(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).54)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetStreamAttribute(&self, dwstreamindex: u32, guidmfattribute: *const ::windows::core::GUID) -> ::windows::core::Result<super::super::System::Com::StructuredStorage::PROPVARIANT> {
let mut result__: <super::super::System::Com::StructuredStorage::PROPVARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).55)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(guidmfattribute), &mut result__).from_abi::<super::super::System::Com::StructuredStorage::PROPVARIANT>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetStreamSelection(&self, dwstreamindex: u32) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).56)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetStreamSelection<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, dwstreamindex: u32, enabled: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).57)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), enabled.into_param().abi()).ok()
}
pub unsafe fn ApplyStreamSelections(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).58)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsProtected(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).59)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn InsertVideoEffect<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, peffect: Param0, foptional: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).60)(::core::mem::transmute_copy(self), peffect.into_param().abi(), foptional.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn InsertAudioEffect<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, peffect: Param0, foptional: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).61)(::core::mem::transmute_copy(self), peffect.into_param().abi(), foptional.into_param().abi()).ok()
}
pub unsafe fn RemoveAllEffects(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).62)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetTimelineMarkerTimer(&self, timetofire: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).63)(::core::mem::transmute_copy(self), ::core::mem::transmute(timetofire)).ok()
}
pub unsafe fn GetTimelineMarkerTimer(&self) -> ::windows::core::Result<f64> {
let mut result__: <f64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).64)(::core::mem::transmute_copy(self), &mut result__).from_abi::<f64>(result__)
}
pub unsafe fn CancelTimelineMarkerTimer(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).65)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsStereo3D(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).66)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetStereo3DFramePackingMode(&self) -> ::windows::core::Result<MF_MEDIA_ENGINE_S3D_PACKING_MODE> {
let mut result__: <MF_MEDIA_ENGINE_S3D_PACKING_MODE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).67)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MF_MEDIA_ENGINE_S3D_PACKING_MODE>(result__)
}
pub unsafe fn SetStereo3DFramePackingMode(&self, packmode: MF_MEDIA_ENGINE_S3D_PACKING_MODE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).68)(::core::mem::transmute_copy(self), ::core::mem::transmute(packmode)).ok()
}
pub unsafe fn GetStereo3DRenderMode(&self) -> ::windows::core::Result<MF3DVideoOutputType> {
let mut result__: <MF3DVideoOutputType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).69)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MF3DVideoOutputType>(result__)
}
pub unsafe fn SetStereo3DRenderMode(&self, outputtype: MF3DVideoOutputType) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).70)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputtype)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnableWindowlessSwapchainMode<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, fenable: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).71)(::core::mem::transmute_copy(self), fenable.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetVideoSwapchainHandle(&self) -> ::windows::core::Result<super::super::Foundation::HANDLE> {
let mut result__: <super::super::Foundation::HANDLE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).72)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::HANDLE>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnableHorizontalMirrorMode<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, fenable: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).73)(::core::mem::transmute_copy(self), fenable.into_param().abi()).ok()
}
pub unsafe fn GetAudioStreamCategory(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).74)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetAudioStreamCategory(&self, category: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).75)(::core::mem::transmute_copy(self), ::core::mem::transmute(category)).ok()
}
pub unsafe fn GetAudioEndpointRole(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).76)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetAudioEndpointRole(&self, role: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).77)(::core::mem::transmute_copy(self), ::core::mem::transmute(role)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRealTimeMode(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).78)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetRealTimeMode<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, fenable: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).79)(::core::mem::transmute_copy(self), fenable.into_param().abi()).ok()
}
pub unsafe fn SetCurrentTimeEx(&self, seektime: f64, seekmode: MF_MEDIA_ENGINE_SEEK_MODE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).80)(::core::mem::transmute_copy(self), ::core::mem::transmute(seektime), ::core::mem::transmute(seekmode)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnableTimeUpdateTimer<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, fenabletimer: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).81)(::core::mem::transmute_copy(self), fenabletimer.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFMediaEngineEx {
type Vtable = IMFMediaEngineEx_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x83015ead_b1e6_40d0_a98a_37145ffe1ad1);
}
impl ::core::convert::From<IMFMediaEngineEx> for ::windows::core::IUnknown {
fn from(value: IMFMediaEngineEx) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaEngineEx> for ::windows::core::IUnknown {
fn from(value: &IMFMediaEngineEx) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaEngineEx {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaEngineEx {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFMediaEngineEx> for IMFMediaEngine {
fn from(value: IMFMediaEngineEx) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFMediaEngineEx> for IMFMediaEngine {
fn from(value: &IMFMediaEngineEx) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaEngine> for IMFMediaEngineEx {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaEngine> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaEngine> for &IMFMediaEngineEx {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaEngine> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaEngineEx_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pperror: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, error: MF_MEDIA_ENGINE_ERR) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psrcelements: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, purl: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppurl: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u16,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> MF_MEDIA_ENGINE_PRELOAD,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, preload: MF_MEDIA_ENGINE_PRELOAD) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppbuffered: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, panswer: *mut MF_MEDIA_ENGINE_CANPLAY) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u16,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> f64,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, seektime: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> f64,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> f64,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> f64,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rate: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> f64,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rate: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppplayed: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppseekable: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, autoplay: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#loop: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, muted: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> f64,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, volume: f64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, cx: *mut u32, cy: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, cx: *mut u32, cy: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdstsurf: ::windows::core::RawPtr, psrc: *const MFVideoNormalizedRect, pdst: *const super::super::Foundation::RECT, pborderclr: *const MFARGB) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppts: *mut i64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbytestream: ::windows::core::RawPtr, purl: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, statisticid: MF_MEDIA_ENGINE_STATISTIC, pstatistic: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psrc: *const MFVideoNormalizedRect, pdst: *const super::super::Foundation::RECT, pborderclr: *const MFARGB) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> f64,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, balance: f64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rate: f64) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, forward: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcharacteristics: *mut u32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidmfattribute: *const ::windows::core::GUID, pvvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwstreamcount: *mut u32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, guidmfattribute: *const ::windows::core::GUID, pvvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, penabled: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, enabled: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pprotected: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, peffect: ::windows::core::RawPtr, foptional: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, peffect: ::windows::core::RawPtr, foptional: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, timetofire: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptimetofire: *mut f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, packmode: *mut MF_MEDIA_ENGINE_S3D_PACKING_MODE) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, packmode: MF_MEDIA_ENGINE_S3D_PACKING_MODE) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputtype: *mut MF3DVideoOutputType) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputtype: MF3DVideoOutputType) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, fenable: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, phswapchain: *mut super::super::Foundation::HANDLE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, fenable: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcategory: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, category: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prole: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, role: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfenabled: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, fenable: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, seektime: f64, seekmode: MF_MEDIA_ENGINE_SEEK_MODE) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, fenabletimer: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaEngineExtension(pub ::windows::core::IUnknown);
impl IMFMediaEngineExtension {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CanPlayType<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, audioonly: Param0, mimetype: Param1) -> ::windows::core::Result<MF_MEDIA_ENGINE_CANPLAY> {
let mut result__: <MF_MEDIA_ENGINE_CANPLAY as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), audioonly.into_param().abi(), mimetype.into_param().abi(), &mut result__).from_abi::<MF_MEDIA_ENGINE_CANPLAY>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn BeginCreateObject<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::core::IntoParam<'a, IMFByteStream>, Param4: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param5: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(
&self,
bstrurl: Param0,
pbytestream: Param1,
r#type: MF_OBJECT_TYPE,
ppiunknowncancelcookie: *mut ::core::option::Option<::windows::core::IUnknown>,
pcallback: Param4,
punkstate: Param5,
) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), bstrurl.into_param().abi(), pbytestream.into_param().abi(), ::core::mem::transmute(r#type), ::core::mem::transmute(ppiunknowncancelcookie), pcallback.into_param().abi(), punkstate.into_param().abi()).ok()
}
pub unsafe fn CancelObjectCreation<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, piunknowncancelcookie: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), piunknowncancelcookie.into_param().abi()).ok()
}
pub unsafe fn EndCreateObject<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), presult.into_param().abi(), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFMediaEngineExtension {
type Vtable = IMFMediaEngineExtension_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2f69d622_20b5_41e9_afdf_89ced1dda04e);
}
impl ::core::convert::From<IMFMediaEngineExtension> for ::windows::core::IUnknown {
fn from(value: IMFMediaEngineExtension) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaEngineExtension> for ::windows::core::IUnknown {
fn from(value: &IMFMediaEngineExtension) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaEngineExtension {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaEngineExtension {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaEngineExtension_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, audioonly: super::super::Foundation::BOOL, mimetype: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, panswer: *mut MF_MEDIA_ENGINE_CANPLAY) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bstrurl: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, pbytestream: ::windows::core::RawPtr, r#type: MF_OBJECT_TYPE, ppiunknowncancelcookie: *mut ::windows::core::RawPtr, pcallback: ::windows::core::RawPtr, punkstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, piunknowncancelcookie: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr, ppobject: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaEngineNeedKeyNotify(pub ::windows::core::IUnknown);
impl IMFMediaEngineNeedKeyNotify {
pub unsafe fn NeedKey(&self, initdata: *const u8, cb: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(initdata), ::core::mem::transmute(cb)))
}
}
unsafe impl ::windows::core::Interface for IMFMediaEngineNeedKeyNotify {
type Vtable = IMFMediaEngineNeedKeyNotify_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x46a30204_a696_4b18_8804_246b8f031bb1);
}
impl ::core::convert::From<IMFMediaEngineNeedKeyNotify> for ::windows::core::IUnknown {
fn from(value: IMFMediaEngineNeedKeyNotify) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaEngineNeedKeyNotify> for ::windows::core::IUnknown {
fn from(value: &IMFMediaEngineNeedKeyNotify) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaEngineNeedKeyNotify {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaEngineNeedKeyNotify {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaEngineNeedKeyNotify_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, initdata: *const u8, cb: u32),
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaEngineNotify(pub ::windows::core::IUnknown);
impl IMFMediaEngineNotify {
pub unsafe fn EventNotify(&self, event: u32, param1: usize, param2: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(event), ::core::mem::transmute(param1), ::core::mem::transmute(param2)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFMediaEngineNotify {
type Vtable = IMFMediaEngineNotify_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfee7c112_e776_42b5_9bbf_0048524e2bd5);
}
impl ::core::convert::From<IMFMediaEngineNotify> for ::windows::core::IUnknown {
fn from(value: IMFMediaEngineNotify) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaEngineNotify> for ::windows::core::IUnknown {
fn from(value: &IMFMediaEngineNotify) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaEngineNotify {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaEngineNotify {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaEngineNotify_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, event: u32, param1: usize, param2: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaEngineOPMInfo(pub ::windows::core::IUnknown);
impl IMFMediaEngineOPMInfo {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOPMInfo(&self, pstatus: *mut MF_MEDIA_ENGINE_OPM_STATUS, pconstricted: *mut super::super::Foundation::BOOL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pstatus), ::core::mem::transmute(pconstricted)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFMediaEngineOPMInfo {
type Vtable = IMFMediaEngineOPMInfo_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x765763e6_6c01_4b01_bb0f_b829f60ed28c);
}
impl ::core::convert::From<IMFMediaEngineOPMInfo> for ::windows::core::IUnknown {
fn from(value: IMFMediaEngineOPMInfo) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaEngineOPMInfo> for ::windows::core::IUnknown {
fn from(value: &IMFMediaEngineOPMInfo) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaEngineOPMInfo {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaEngineOPMInfo {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaEngineOPMInfo_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstatus: *mut MF_MEDIA_ENGINE_OPM_STATUS, pconstricted: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaEngineProtectedContent(pub ::windows::core::IUnknown);
impl IMFMediaEngineProtectedContent {
pub unsafe fn ShareResources<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, punkdevicecontext: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), punkdevicecontext.into_param().abi()).ok()
}
pub unsafe fn GetRequiredProtections(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetOPMWindow<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::HWND>>(&self, hwnd: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), hwnd.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn TransferVideoFrame<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pdstsurf: Param0, psrc: *const MFVideoNormalizedRect, pdst: *const super::super::Foundation::RECT, pborderclr: *const MFARGB) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), pdstsurf.into_param().abi(), ::core::mem::transmute(psrc), ::core::mem::transmute(pdst), ::core::mem::transmute(pborderclr), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetContentProtectionManager<'a, Param0: ::windows::core::IntoParam<'a, IMFContentProtectionManager>>(&self, pcpm: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), pcpm.into_param().abi()).ok()
}
pub unsafe fn SetApplicationCertificate(&self, pbblob: *const u8, cbblob: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbblob), ::core::mem::transmute(cbblob)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFMediaEngineProtectedContent {
type Vtable = IMFMediaEngineProtectedContent_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9f8021e8_9c8c_487e_bb5c_79aa4779938c);
}
impl ::core::convert::From<IMFMediaEngineProtectedContent> for ::windows::core::IUnknown {
fn from(value: IMFMediaEngineProtectedContent) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaEngineProtectedContent> for ::windows::core::IUnknown {
fn from(value: &IMFMediaEngineProtectedContent) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaEngineProtectedContent {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaEngineProtectedContent {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaEngineProtectedContent_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, punkdevicecontext: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pframeprotectionflags: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hwnd: super::super::Foundation::HWND) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdstsurf: ::windows::core::RawPtr, psrc: *const MFVideoNormalizedRect, pdst: *const super::super::Foundation::RECT, pborderclr: *const MFARGB, pframeprotectionflags: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcpm: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbblob: *const u8, cbblob: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaEngineSrcElements(pub ::windows::core::IUnknown);
impl IMFMediaEngineSrcElements {
pub unsafe fn GetLength(&self) -> u32 {
::core::mem::transmute((::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetURL(&self, index: u32) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetType(&self, index: u32) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetMedia(&self, index: u32) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddElement<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, purl: Param0, ptype: Param1, pmedia: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), purl.into_param().abi(), ptype.into_param().abi(), pmedia.into_param().abi()).ok()
}
pub unsafe fn RemoveAllElements(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFMediaEngineSrcElements {
type Vtable = IMFMediaEngineSrcElements_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7a5e5354_b114_4c72_b991_3131d75032ea);
}
impl ::core::convert::From<IMFMediaEngineSrcElements> for ::windows::core::IUnknown {
fn from(value: IMFMediaEngineSrcElements) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaEngineSrcElements> for ::windows::core::IUnknown {
fn from(value: &IMFMediaEngineSrcElements) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaEngineSrcElements {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaEngineSrcElements {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaEngineSrcElements_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, purl: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, ptype: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, pmedia: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, purl: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, ptype: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, pmedia: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaEngineSrcElementsEx(pub ::windows::core::IUnknown);
impl IMFMediaEngineSrcElementsEx {
pub unsafe fn GetLength(&self) -> u32 {
::core::mem::transmute((::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetURL(&self, index: u32) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetType(&self, index: u32) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetMedia(&self, index: u32) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddElement<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, purl: Param0, ptype: Param1, pmedia: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), purl.into_param().abi(), ptype.into_param().abi(), pmedia.into_param().abi()).ok()
}
pub unsafe fn RemoveAllElements(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddElementEx<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param3: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, purl: Param0, ptype: Param1, pmedia: Param2, keysystem: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), purl.into_param().abi(), ptype.into_param().abi(), pmedia.into_param().abi(), keysystem.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetKeySystem(&self, index: u32) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFMediaEngineSrcElementsEx {
type Vtable = IMFMediaEngineSrcElementsEx_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x654a6bb3_e1a3_424a_9908_53a43a0dfda0);
}
impl ::core::convert::From<IMFMediaEngineSrcElementsEx> for ::windows::core::IUnknown {
fn from(value: IMFMediaEngineSrcElementsEx) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaEngineSrcElementsEx> for ::windows::core::IUnknown {
fn from(value: &IMFMediaEngineSrcElementsEx) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaEngineSrcElementsEx {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaEngineSrcElementsEx {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFMediaEngineSrcElementsEx> for IMFMediaEngineSrcElements {
fn from(value: IMFMediaEngineSrcElementsEx) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFMediaEngineSrcElementsEx> for IMFMediaEngineSrcElements {
fn from(value: &IMFMediaEngineSrcElementsEx) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaEngineSrcElements> for IMFMediaEngineSrcElementsEx {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaEngineSrcElements> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaEngineSrcElements> for &IMFMediaEngineSrcElementsEx {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaEngineSrcElements> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaEngineSrcElementsEx_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, purl: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, ptype: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, pmedia: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, purl: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, ptype: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, pmedia: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, purl: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, ptype: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, pmedia: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, keysystem: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, ptype: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaEngineSupportsSourceTransfer(pub ::windows::core::IUnknown);
impl IMFMediaEngineSupportsSourceTransfer {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ShouldTransferSource(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn DetachMediaSource(&self, ppbytestream: *mut ::core::option::Option<IMFByteStream>, ppmediasource: *mut ::core::option::Option<IMFMediaSource>, ppmse: *mut ::core::option::Option<IMFMediaSourceExtension>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(ppbytestream), ::core::mem::transmute(ppmediasource), ::core::mem::transmute(ppmse)).ok()
}
pub unsafe fn AttachMediaSource<'a, Param0: ::windows::core::IntoParam<'a, IMFByteStream>, Param1: ::windows::core::IntoParam<'a, IMFMediaSource>, Param2: ::windows::core::IntoParam<'a, IMFMediaSourceExtension>>(&self, pbytestream: Param0, pmediasource: Param1, pmse: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pbytestream.into_param().abi(), pmediasource.into_param().abi(), pmse.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFMediaEngineSupportsSourceTransfer {
type Vtable = IMFMediaEngineSupportsSourceTransfer_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa724b056_1b2e_4642_a6f3_db9420c52908);
}
impl ::core::convert::From<IMFMediaEngineSupportsSourceTransfer> for ::windows::core::IUnknown {
fn from(value: IMFMediaEngineSupportsSourceTransfer) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaEngineSupportsSourceTransfer> for ::windows::core::IUnknown {
fn from(value: &IMFMediaEngineSupportsSourceTransfer) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaEngineSupportsSourceTransfer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaEngineSupportsSourceTransfer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaEngineSupportsSourceTransfer_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfshouldtransfer: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppbytestream: *mut ::windows::core::RawPtr, ppmediasource: *mut ::windows::core::RawPtr, ppmse: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbytestream: ::windows::core::RawPtr, pmediasource: ::windows::core::RawPtr, pmse: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaEngineTransferSource(pub ::windows::core::IUnknown);
impl IMFMediaEngineTransferSource {
pub unsafe fn TransferSourceToMediaEngine<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaEngine>>(&self, destination: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), destination.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFMediaEngineTransferSource {
type Vtable = IMFMediaEngineTransferSource_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x24230452_fe54_40cc_94f3_fcc394c340d6);
}
impl ::core::convert::From<IMFMediaEngineTransferSource> for ::windows::core::IUnknown {
fn from(value: IMFMediaEngineTransferSource) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaEngineTransferSource> for ::windows::core::IUnknown {
fn from(value: &IMFMediaEngineTransferSource) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaEngineTransferSource {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaEngineTransferSource {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaEngineTransferSource_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, destination: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaEngineWebSupport(pub ::windows::core::IUnknown);
impl IMFMediaEngineWebSupport {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ShouldDelayTheLoadEvent(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)))
}
pub unsafe fn ConnectWebAudio(&self, dwsamplerate: u32) -> ::windows::core::Result<IAudioSourceProvider> {
let mut result__: <IAudioSourceProvider as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsamplerate), &mut result__).from_abi::<IAudioSourceProvider>(result__)
}
pub unsafe fn DisconnectWebAudio(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFMediaEngineWebSupport {
type Vtable = IMFMediaEngineWebSupport_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xba2743a1_07e0_48ef_84b6_9a2ed023ca6c);
}
impl ::core::convert::From<IMFMediaEngineWebSupport> for ::windows::core::IUnknown {
fn from(value: IMFMediaEngineWebSupport) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaEngineWebSupport> for ::windows::core::IUnknown {
fn from(value: &IMFMediaEngineWebSupport) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaEngineWebSupport {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaEngineWebSupport {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaEngineWebSupport_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsamplerate: u32, ppsourceprovider: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaError(pub ::windows::core::IUnknown);
impl IMFMediaError {
pub unsafe fn GetErrorCode(&self) -> u16 {
::core::mem::transmute((::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetExtendedErrorCode(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetErrorCode(&self, error: MF_MEDIA_ENGINE_ERR) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(error)).ok()
}
pub unsafe fn SetExtendedErrorCode(&self, error: ::windows::core::HRESULT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(error)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFMediaError {
type Vtable = IMFMediaError_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfc0e10d2_ab2a_4501_a951_06bb1075184c);
}
impl ::core::convert::From<IMFMediaError> for ::windows::core::IUnknown {
fn from(value: IMFMediaError) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaError> for ::windows::core::IUnknown {
fn from(value: &IMFMediaError) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaError {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaError {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaError_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u16,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, error: MF_MEDIA_ENGINE_ERR) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, error: ::windows::core::HRESULT) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaEvent(pub ::windows::core::IUnknown);
impl IMFMediaEvent {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItem(&self, guidkey: *const ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn GetItemType(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<MF_ATTRIBUTE_TYPE> {
let mut result__: <MF_ATTRIBUTE_TYPE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<MF_ATTRIBUTE_TYPE>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn CompareItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Compare<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, ptheirs: Param0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ptheirs.into_param().abi(), ::core::mem::transmute(matchtype), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn GetUINT32(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetUINT64(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetDouble(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<f64> {
let mut result__: <f64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<f64>(result__)
}
pub unsafe fn GetGUID(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
pub unsafe fn GetStringLength(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetString(&self, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pwszvalue), ::core::mem::transmute(cchbufsize), ::core::mem::transmute(pcchlength)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetAllocatedString(&self, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppwszvalue), ::core::mem::transmute(pcchlength)).ok()
}
pub unsafe fn GetBlobSize(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize), ::core::mem::transmute(pcbblobsize)).ok()
}
pub unsafe fn GetAllocatedBlob(&self, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppbuf), ::core::mem::transmute(pcbsize)).ok()
}
pub unsafe fn GetUnknown<T: ::windows::core::Interface>(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn SetItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value)).ok()
}
pub unsafe fn DeleteItem(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey)).ok()
}
pub unsafe fn DeleteAllItems(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetUINT32(&self, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetUINT64(&self, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetDouble(&self, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(fvalue)).ok()
}
pub unsafe fn SetGUID(&self, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(guidvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetString<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, guidkey: *const ::windows::core::GUID, wszvalue: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), wszvalue.into_param().abi()).ok()
}
pub unsafe fn SetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize)).ok()
}
pub unsafe fn SetUnknown<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guidkey: *const ::windows::core::GUID, punknown: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), punknown.into_param().abi()).ok()
}
pub unsafe fn LockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn UnlockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(unindex), ::core::mem::transmute(pguidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn CopyAllItems<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, pdest: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), pdest.into_param().abi()).ok()
}
pub unsafe fn GetType(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetExtendedType(&self) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
pub unsafe fn GetStatus(&self) -> ::windows::core::Result<::windows::core::HRESULT> {
let mut result__: <::windows::core::HRESULT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::HRESULT>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetValue(&self) -> ::windows::core::Result<super::super::System::Com::StructuredStorage::PROPVARIANT> {
let mut result__: <super::super::System::Com::StructuredStorage::PROPVARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::StructuredStorage::PROPVARIANT>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFMediaEvent {
type Vtable = IMFMediaEvent_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdf598932_f10c_4e39_bba2_c308f101daa3);
}
impl ::core::convert::From<IMFMediaEvent> for ::windows::core::IUnknown {
fn from(value: IMFMediaEvent) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaEvent> for ::windows::core::IUnknown {
fn from(value: &IMFMediaEvent) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaEvent {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaEvent {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFMediaEvent> for IMFAttributes {
fn from(value: IMFMediaEvent) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFMediaEvent> for IMFAttributes {
fn from(value: &IMFMediaEvent) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for IMFMediaEvent {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for &IMFMediaEvent {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaEvent_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ptype: *mut MF_ATTRIBUTE_TYPE) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptheirs: ::windows::core::RawPtr, matchtype: MF_ATTRIBUTES_MATCH_TYPE, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pfvalue: *mut f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pguidvalue: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, wszvalue: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punknown: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcitems: *mut u32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdest: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pmet: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pguidextendedtype: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, phrstatus: *mut ::windows::core::HRESULT) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pvvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaEventGenerator(pub ::windows::core::IUnknown);
impl IMFMediaEventGenerator {
pub unsafe fn GetEvent(&self, dwflags: MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS) -> ::windows::core::Result<IMFMediaEvent> {
let mut result__: <IMFMediaEvent as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwflags), &mut result__).from_abi::<IMFMediaEvent>(result__)
}
pub unsafe fn BeginGetEvent<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pcallback: Param0, punkstate: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pcallback.into_param().abi(), punkstate.into_param().abi()).ok()
}
pub unsafe fn EndGetEvent<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0) -> ::windows::core::Result<IMFMediaEvent> {
let mut result__: <IMFMediaEvent as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), presult.into_param().abi(), &mut result__).from_abi::<IMFMediaEvent>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn QueueEvent(&self, met: u32, guidextendedtype: *const ::windows::core::GUID, hrstatus: ::windows::core::HRESULT, pvvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(met), ::core::mem::transmute(guidextendedtype), ::core::mem::transmute(hrstatus), ::core::mem::transmute(pvvalue)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFMediaEventGenerator {
type Vtable = IMFMediaEventGenerator_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2cd0bd52_bcd5_4b89_b62c_eadc0c031e7d);
}
impl ::core::convert::From<IMFMediaEventGenerator> for ::windows::core::IUnknown {
fn from(value: IMFMediaEventGenerator) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaEventGenerator> for ::windows::core::IUnknown {
fn from(value: &IMFMediaEventGenerator) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaEventGenerator {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaEventGenerator {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaEventGenerator_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwflags: MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS, ppevent: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcallback: ::windows::core::RawPtr, punkstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr, ppevent: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, met: u32, guidextendedtype: *const ::windows::core::GUID, hrstatus: ::windows::core::HRESULT, pvvalue: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaEventQueue(pub ::windows::core::IUnknown);
impl IMFMediaEventQueue {
pub unsafe fn GetEvent(&self, dwflags: u32) -> ::windows::core::Result<IMFMediaEvent> {
let mut result__: <IMFMediaEvent as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwflags), &mut result__).from_abi::<IMFMediaEvent>(result__)
}
pub unsafe fn BeginGetEvent<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pcallback: Param0, punkstate: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pcallback.into_param().abi(), punkstate.into_param().abi()).ok()
}
pub unsafe fn EndGetEvent<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0) -> ::windows::core::Result<IMFMediaEvent> {
let mut result__: <IMFMediaEvent as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), presult.into_param().abi(), &mut result__).from_abi::<IMFMediaEvent>(result__)
}
pub unsafe fn QueueEvent<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaEvent>>(&self, pevent: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), pevent.into_param().abi()).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn QueueEventParamVar(&self, met: u32, guidextendedtype: *const ::windows::core::GUID, hrstatus: ::windows::core::HRESULT, pvvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(met), ::core::mem::transmute(guidextendedtype), ::core::mem::transmute(hrstatus), ::core::mem::transmute(pvvalue)).ok()
}
pub unsafe fn QueueEventParamUnk<'a, Param3: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, met: u32, guidextendedtype: *const ::windows::core::GUID, hrstatus: ::windows::core::HRESULT, punk: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(met), ::core::mem::transmute(guidextendedtype), ::core::mem::transmute(hrstatus), punk.into_param().abi()).ok()
}
pub unsafe fn Shutdown(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFMediaEventQueue {
type Vtable = IMFMediaEventQueue_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x36f846fc_2256_48b6_b58e_e2b638316581);
}
impl ::core::convert::From<IMFMediaEventQueue> for ::windows::core::IUnknown {
fn from(value: IMFMediaEventQueue) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaEventQueue> for ::windows::core::IUnknown {
fn from(value: &IMFMediaEventQueue) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaEventQueue {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaEventQueue {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaEventQueue_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwflags: u32, ppevent: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcallback: ::windows::core::RawPtr, punkstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr, ppevent: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pevent: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, met: u32, guidextendedtype: *const ::windows::core::GUID, hrstatus: ::windows::core::HRESULT, pvvalue: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, met: u32, guidextendedtype: *const ::windows::core::GUID, hrstatus: ::windows::core::HRESULT, punk: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaKeySession(pub ::windows::core::IUnknown);
impl IMFMediaKeySession {
pub unsafe fn GetError(&self, code: *mut u16, systemcode: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(code), ::core::mem::transmute(systemcode)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn KeySystem(&self) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SessionId(&self) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
pub unsafe fn Update(&self, key: *const u8, cb: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(key), ::core::mem::transmute(cb)).ok()
}
pub unsafe fn Close(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFMediaKeySession {
type Vtable = IMFMediaKeySession_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x24fa67d5_d1d0_4dc5_995c_c0efdc191fb5);
}
impl ::core::convert::From<IMFMediaKeySession> for ::windows::core::IUnknown {
fn from(value: IMFMediaKeySession) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaKeySession> for ::windows::core::IUnknown {
fn from(value: &IMFMediaKeySession) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaKeySession {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaKeySession {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaKeySession_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, code: *mut u16, systemcode: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, keysystem: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, sessionid: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, key: *const u8, cb: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaKeySession2(pub ::windows::core::IUnknown);
impl IMFMediaKeySession2 {
pub unsafe fn GetError(&self, code: *mut u16, systemcode: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(code), ::core::mem::transmute(systemcode)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn KeySystem(&self) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SessionId(&self) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
pub unsafe fn Update(&self, key: *const u8, cb: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(key), ::core::mem::transmute(cb)).ok()
}
pub unsafe fn Close(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn KeyStatuses(&self, pkeystatusesarray: *mut *mut MFMediaKeyStatus, pusize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(pkeystatusesarray), ::core::mem::transmute(pusize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Load<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrsessionid: Param0) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), bstrsessionid.into_param().abi(), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GenerateRequest<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, initdatatype: Param0, pbinitdata: *const u8, cb: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), initdatatype.into_param().abi(), ::core::mem::transmute(pbinitdata), ::core::mem::transmute(cb)).ok()
}
pub unsafe fn Expiration(&self) -> ::windows::core::Result<f64> {
let mut result__: <f64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<f64>(result__)
}
pub unsafe fn Remove(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Shutdown(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFMediaKeySession2 {
type Vtable = IMFMediaKeySession2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe9707e05_6d55_4636_b185_3de21210bd75);
}
impl ::core::convert::From<IMFMediaKeySession2> for ::windows::core::IUnknown {
fn from(value: IMFMediaKeySession2) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaKeySession2> for ::windows::core::IUnknown {
fn from(value: &IMFMediaKeySession2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaKeySession2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaKeySession2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFMediaKeySession2> for IMFMediaKeySession {
fn from(value: IMFMediaKeySession2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFMediaKeySession2> for IMFMediaKeySession {
fn from(value: &IMFMediaKeySession2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaKeySession> for IMFMediaKeySession2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaKeySession> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaKeySession> for &IMFMediaKeySession2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaKeySession> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaKeySession2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, code: *mut u16, systemcode: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, keysystem: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, sessionid: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, key: *const u8, cb: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pkeystatusesarray: *mut *mut MFMediaKeyStatus, pusize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bstrsessionid: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, pfloaded: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, initdatatype: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, pbinitdata: *const u8, cb: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dblexpiration: *mut f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaKeySessionNotify(pub ::windows::core::IUnknown);
impl IMFMediaKeySessionNotify {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn KeyMessage<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, destinationurl: Param0, message: *const u8, cb: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), destinationurl.into_param().abi(), ::core::mem::transmute(message), ::core::mem::transmute(cb)))
}
pub unsafe fn KeyAdded(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)))
}
pub unsafe fn KeyError(&self, code: u16, systemcode: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(code), ::core::mem::transmute(systemcode)))
}
}
unsafe impl ::windows::core::Interface for IMFMediaKeySessionNotify {
type Vtable = IMFMediaKeySessionNotify_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6a0083f9_8947_4c1d_9ce0_cdee22b23135);
}
impl ::core::convert::From<IMFMediaKeySessionNotify> for ::windows::core::IUnknown {
fn from(value: IMFMediaKeySessionNotify) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaKeySessionNotify> for ::windows::core::IUnknown {
fn from(value: &IMFMediaKeySessionNotify) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaKeySessionNotify {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaKeySessionNotify {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaKeySessionNotify_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, destinationurl: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, message: *const u8, cb: u32),
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, code: u16, systemcode: u32),
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaKeySessionNotify2(pub ::windows::core::IUnknown);
impl IMFMediaKeySessionNotify2 {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn KeyMessage<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, destinationurl: Param0, message: *const u8, cb: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), destinationurl.into_param().abi(), ::core::mem::transmute(message), ::core::mem::transmute(cb)))
}
pub unsafe fn KeyAdded(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)))
}
pub unsafe fn KeyError(&self, code: u16, systemcode: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(code), ::core::mem::transmute(systemcode)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn KeyMessage2<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, emessagetype: MF_MEDIAKEYSESSION_MESSAGETYPE, destinationurl: Param1, pbmessage: *const u8, cbmessage: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(emessagetype), destinationurl.into_param().abi(), ::core::mem::transmute(pbmessage), ::core::mem::transmute(cbmessage)))
}
pub unsafe fn KeyStatusChange(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)))
}
}
unsafe impl ::windows::core::Interface for IMFMediaKeySessionNotify2 {
type Vtable = IMFMediaKeySessionNotify2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc3a9e92a_da88_46b0_a110_6cf953026cb9);
}
impl ::core::convert::From<IMFMediaKeySessionNotify2> for ::windows::core::IUnknown {
fn from(value: IMFMediaKeySessionNotify2) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaKeySessionNotify2> for ::windows::core::IUnknown {
fn from(value: &IMFMediaKeySessionNotify2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaKeySessionNotify2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaKeySessionNotify2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFMediaKeySessionNotify2> for IMFMediaKeySessionNotify {
fn from(value: IMFMediaKeySessionNotify2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFMediaKeySessionNotify2> for IMFMediaKeySessionNotify {
fn from(value: &IMFMediaKeySessionNotify2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaKeySessionNotify> for IMFMediaKeySessionNotify2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaKeySessionNotify> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaKeySessionNotify> for &IMFMediaKeySessionNotify2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaKeySessionNotify> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaKeySessionNotify2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, destinationurl: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, message: *const u8, cb: u32),
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, code: u16, systemcode: u32),
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, emessagetype: MF_MEDIAKEYSESSION_MESSAGETYPE, destinationurl: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, pbmessage: *const u8, cbmessage: u32),
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaKeySystemAccess(pub ::windows::core::IUnknown);
impl IMFMediaKeySystemAccess {
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
pub unsafe fn CreateMediaKeys<'a, Param0: ::windows::core::IntoParam<'a, super::super::UI::Shell::PropertiesSystem::IPropertyStore>>(&self, pcdmcustomconfig: Param0) -> ::windows::core::Result<IMFMediaKeys2> {
let mut result__: <IMFMediaKeys2 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pcdmcustomconfig.into_param().abi(), &mut result__).from_abi::<IMFMediaKeys2>(result__)
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
pub unsafe fn SupportedConfiguration(&self) -> ::windows::core::Result<super::super::UI::Shell::PropertiesSystem::IPropertyStore> {
let mut result__: <super::super::UI::Shell::PropertiesSystem::IPropertyStore as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::UI::Shell::PropertiesSystem::IPropertyStore>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn KeySystem(&self) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFMediaKeySystemAccess {
type Vtable = IMFMediaKeySystemAccess_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xaec63fda_7a97_4944_b35c_6c6df8085cc3);
}
impl ::core::convert::From<IMFMediaKeySystemAccess> for ::windows::core::IUnknown {
fn from(value: IMFMediaKeySystemAccess) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaKeySystemAccess> for ::windows::core::IUnknown {
fn from(value: &IMFMediaKeySystemAccess) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaKeySystemAccess {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaKeySystemAccess {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaKeySystemAccess_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcdmcustomconfig: ::windows::core::RawPtr, ppkeys: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] usize,
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppsupportedconfiguration: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pkeysystem: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaKeys(pub ::windows::core::IUnknown);
impl IMFMediaKeys {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateSession<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param5: ::windows::core::IntoParam<'a, IMFMediaKeySessionNotify>>(&self, mimetype: Param0, initdata: *const u8, cb: u32, customdata: *const u8, cbcustomdata: u32, notify: Param5) -> ::windows::core::Result<IMFMediaKeySession> {
let mut result__: <IMFMediaKeySession as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), mimetype.into_param().abi(), ::core::mem::transmute(initdata), ::core::mem::transmute(cb), ::core::mem::transmute(customdata), ::core::mem::transmute(cbcustomdata), notify.into_param().abi(), &mut result__).from_abi::<IMFMediaKeySession>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn KeySystem(&self) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
pub unsafe fn Shutdown(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetSuspendNotify(&self) -> ::windows::core::Result<IMFCdmSuspendNotify> {
let mut result__: <IMFCdmSuspendNotify as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFCdmSuspendNotify>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFMediaKeys {
type Vtable = IMFMediaKeys_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5cb31c05_61ff_418f_afda_caaf41421a38);
}
impl ::core::convert::From<IMFMediaKeys> for ::windows::core::IUnknown {
fn from(value: IMFMediaKeys) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaKeys> for ::windows::core::IUnknown {
fn from(value: &IMFMediaKeys) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaKeys {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaKeys {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaKeys_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mimetype: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, initdata: *const u8, cb: u32, customdata: *const u8, cbcustomdata: u32, notify: ::windows::core::RawPtr, ppsession: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, keysystem: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, notify: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaKeys2(pub ::windows::core::IUnknown);
impl IMFMediaKeys2 {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateSession<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param5: ::windows::core::IntoParam<'a, IMFMediaKeySessionNotify>>(&self, mimetype: Param0, initdata: *const u8, cb: u32, customdata: *const u8, cbcustomdata: u32, notify: Param5) -> ::windows::core::Result<IMFMediaKeySession> {
let mut result__: <IMFMediaKeySession as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), mimetype.into_param().abi(), ::core::mem::transmute(initdata), ::core::mem::transmute(cb), ::core::mem::transmute(customdata), ::core::mem::transmute(cbcustomdata), notify.into_param().abi(), &mut result__).from_abi::<IMFMediaKeySession>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn KeySystem(&self) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
pub unsafe fn Shutdown(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetSuspendNotify(&self) -> ::windows::core::Result<IMFCdmSuspendNotify> {
let mut result__: <IMFCdmSuspendNotify as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFCdmSuspendNotify>(result__)
}
pub unsafe fn CreateSession2<'a, Param1: ::windows::core::IntoParam<'a, IMFMediaKeySessionNotify2>>(&self, esessiontype: MF_MEDIAKEYSESSION_TYPE, pmfmediakeysessionnotify2: Param1) -> ::windows::core::Result<IMFMediaKeySession2> {
let mut result__: <IMFMediaKeySession2 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(esessiontype), pmfmediakeysessionnotify2.into_param().abi(), &mut result__).from_abi::<IMFMediaKeySession2>(result__)
}
pub unsafe fn SetServerCertificate(&self, pbservercertificate: *const u8, cb: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbservercertificate), ::core::mem::transmute(cb)).ok()
}
pub unsafe fn GetDOMException(&self, systemcode: ::windows::core::HRESULT) -> ::windows::core::Result<::windows::core::HRESULT> {
let mut result__: <::windows::core::HRESULT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(systemcode), &mut result__).from_abi::<::windows::core::HRESULT>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFMediaKeys2 {
type Vtable = IMFMediaKeys2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x45892507_ad66_4de2_83a2_acbb13cd8d43);
}
impl ::core::convert::From<IMFMediaKeys2> for ::windows::core::IUnknown {
fn from(value: IMFMediaKeys2) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaKeys2> for ::windows::core::IUnknown {
fn from(value: &IMFMediaKeys2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaKeys2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaKeys2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFMediaKeys2> for IMFMediaKeys {
fn from(value: IMFMediaKeys2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFMediaKeys2> for IMFMediaKeys {
fn from(value: &IMFMediaKeys2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaKeys> for IMFMediaKeys2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaKeys> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaKeys> for &IMFMediaKeys2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaKeys> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaKeys2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mimetype: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, initdata: *const u8, cb: u32, customdata: *const u8, cbcustomdata: u32, notify: ::windows::core::RawPtr, ppsession: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, keysystem: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, notify: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, esessiontype: MF_MEDIAKEYSESSION_TYPE, pmfmediakeysessionnotify2: ::windows::core::RawPtr, ppsession: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbservercertificate: *const u8, cb: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, systemcode: ::windows::core::HRESULT, code: *mut ::windows::core::HRESULT) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaSession(pub ::windows::core::IUnknown);
impl IMFMediaSession {
pub unsafe fn GetEvent(&self, dwflags: MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS) -> ::windows::core::Result<IMFMediaEvent> {
let mut result__: <IMFMediaEvent as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwflags), &mut result__).from_abi::<IMFMediaEvent>(result__)
}
pub unsafe fn BeginGetEvent<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pcallback: Param0, punkstate: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pcallback.into_param().abi(), punkstate.into_param().abi()).ok()
}
pub unsafe fn EndGetEvent<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0) -> ::windows::core::Result<IMFMediaEvent> {
let mut result__: <IMFMediaEvent as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), presult.into_param().abi(), &mut result__).from_abi::<IMFMediaEvent>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn QueueEvent(&self, met: u32, guidextendedtype: *const ::windows::core::GUID, hrstatus: ::windows::core::HRESULT, pvvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(met), ::core::mem::transmute(guidextendedtype), ::core::mem::transmute(hrstatus), ::core::mem::transmute(pvvalue)).ok()
}
pub unsafe fn SetTopology<'a, Param1: ::windows::core::IntoParam<'a, IMFTopology>>(&self, dwsettopologyflags: u32, ptopology: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsettopologyflags), ptopology.into_param().abi()).ok()
}
pub unsafe fn ClearTopologies(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn Start(&self, pguidtimeformat: *const ::windows::core::GUID, pvarstartposition: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(pguidtimeformat), ::core::mem::transmute(pvarstartposition)).ok()
}
pub unsafe fn Pause(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Stop(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Close(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Shutdown(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetClock(&self) -> ::windows::core::Result<IMFClock> {
let mut result__: <IMFClock as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFClock>(result__)
}
pub unsafe fn GetSessionCapabilities(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetFullTopology(&self, dwgetfulltopologyflags: u32, topoid: u64) -> ::windows::core::Result<IMFTopology> {
let mut result__: <IMFTopology as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwgetfulltopologyflags), ::core::mem::transmute(topoid), &mut result__).from_abi::<IMFTopology>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFMediaSession {
type Vtable = IMFMediaSession_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x90377834_21d0_4dee_8214_ba2e3e6c1127);
}
impl ::core::convert::From<IMFMediaSession> for ::windows::core::IUnknown {
fn from(value: IMFMediaSession) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaSession> for ::windows::core::IUnknown {
fn from(value: &IMFMediaSession) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaSession {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaSession {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFMediaSession> for IMFMediaEventGenerator {
fn from(value: IMFMediaSession) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFMediaSession> for IMFMediaEventGenerator {
fn from(value: &IMFMediaSession) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaEventGenerator> for IMFMediaSession {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaEventGenerator> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaEventGenerator> for &IMFMediaSession {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaEventGenerator> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaSession_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwflags: MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS, ppevent: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcallback: ::windows::core::RawPtr, punkstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr, ppevent: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, met: u32, guidextendedtype: *const ::windows::core::GUID, hrstatus: ::windows::core::HRESULT, pvvalue: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsettopologyflags: u32, ptopology: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pguidtimeformat: *const ::windows::core::GUID, pvarstartposition: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppclock: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcaps: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwgetfulltopologyflags: u32, topoid: u64, ppfulltopology: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaSharingEngine(pub ::windows::core::IUnknown);
impl IMFMediaSharingEngine {
pub unsafe fn GetError(&self) -> ::windows::core::Result<IMFMediaError> {
let mut result__: <IMFMediaError as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFMediaError>(result__)
}
pub unsafe fn SetErrorCode(&self, error: MF_MEDIA_ENGINE_ERR) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(error)).ok()
}
pub unsafe fn SetSourceElements<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaEngineSrcElements>>(&self, psrcelements: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), psrcelements.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSource<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, purl: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), purl.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetCurrentSource(&self) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetNetworkState(&self) -> u16 {
::core::mem::transmute((::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetPreload(&self) -> MF_MEDIA_ENGINE_PRELOAD {
::core::mem::transmute((::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)))
}
pub unsafe fn SetPreload(&self, preload: MF_MEDIA_ENGINE_PRELOAD) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(preload)).ok()
}
pub unsafe fn GetBuffered(&self) -> ::windows::core::Result<IMFMediaTimeRange> {
let mut result__: <IMFMediaTimeRange as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFMediaTimeRange>(result__)
}
pub unsafe fn Load(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CanPlayType<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, r#type: Param0) -> ::windows::core::Result<MF_MEDIA_ENGINE_CANPLAY> {
let mut result__: <MF_MEDIA_ENGINE_CANPLAY as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), r#type.into_param().abi(), &mut result__).from_abi::<MF_MEDIA_ENGINE_CANPLAY>(result__)
}
pub unsafe fn GetReadyState(&self) -> u16 {
::core::mem::transmute((::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsSeeking(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetCurrentTime(&self) -> f64 {
::core::mem::transmute((::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self)))
}
pub unsafe fn SetCurrentTime(&self, seektime: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(seektime)).ok()
}
pub unsafe fn GetStartTime(&self) -> f64 {
::core::mem::transmute((::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetDuration(&self) -> f64 {
::core::mem::transmute((::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsPaused(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetDefaultPlaybackRate(&self) -> f64 {
::core::mem::transmute((::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self)))
}
pub unsafe fn SetDefaultPlaybackRate(&self, rate: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(rate)).ok()
}
pub unsafe fn GetPlaybackRate(&self) -> f64 {
::core::mem::transmute((::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self)))
}
pub unsafe fn SetPlaybackRate(&self, rate: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(rate)).ok()
}
pub unsafe fn GetPlayed(&self) -> ::windows::core::Result<IMFMediaTimeRange> {
let mut result__: <IMFMediaTimeRange as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFMediaTimeRange>(result__)
}
pub unsafe fn GetSeekable(&self) -> ::windows::core::Result<IMFMediaTimeRange> {
let mut result__: <IMFMediaTimeRange as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFMediaTimeRange>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsEnded(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetAutoPlay(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetAutoPlay<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, autoplay: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), autoplay.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLoop(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetLoop<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, r#loop: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), r#loop.into_param().abi()).ok()
}
pub unsafe fn Play(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Pause(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetMuted(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetMuted<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, muted: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), muted.into_param().abi()).ok()
}
pub unsafe fn GetVolume(&self) -> f64 {
::core::mem::transmute((::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self)))
}
pub unsafe fn SetVolume(&self, volume: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), ::core::mem::transmute(volume)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn HasVideo(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn HasAudio(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetNativeVideoSize(&self, cx: *mut u32, cy: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).40)(::core::mem::transmute_copy(self), ::core::mem::transmute(cx), ::core::mem::transmute(cy)).ok()
}
pub unsafe fn GetVideoAspectRatio(&self, cx: *mut u32, cy: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), ::core::mem::transmute(cx), ::core::mem::transmute(cy)).ok()
}
pub unsafe fn Shutdown(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn TransferVideoFrame<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pdstsurf: Param0, psrc: *const MFVideoNormalizedRect, pdst: *const super::super::Foundation::RECT, pborderclr: *const MFARGB) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self), pdstsurf.into_param().abi(), ::core::mem::transmute(psrc), ::core::mem::transmute(pdst), ::core::mem::transmute(pborderclr)).ok()
}
pub unsafe fn OnVideoStreamTick(&self) -> ::windows::core::Result<i64> {
let mut result__: <i64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).44)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDevice(&self) -> ::windows::core::Result<DEVICE_INFO> {
let mut result__: <DEVICE_INFO as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).45)(::core::mem::transmute_copy(self), &mut result__).from_abi::<DEVICE_INFO>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFMediaSharingEngine {
type Vtable = IMFMediaSharingEngine_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8d3ce1bf_2367_40e0_9eee_40d377cc1b46);
}
impl ::core::convert::From<IMFMediaSharingEngine> for ::windows::core::IUnknown {
fn from(value: IMFMediaSharingEngine) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaSharingEngine> for ::windows::core::IUnknown {
fn from(value: &IMFMediaSharingEngine) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaSharingEngine {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaSharingEngine {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFMediaSharingEngine> for IMFMediaEngine {
fn from(value: IMFMediaSharingEngine) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFMediaSharingEngine> for IMFMediaEngine {
fn from(value: &IMFMediaSharingEngine) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaEngine> for IMFMediaSharingEngine {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaEngine> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaEngine> for &IMFMediaSharingEngine {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaEngine> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaSharingEngine_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pperror: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, error: MF_MEDIA_ENGINE_ERR) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psrcelements: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, purl: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppurl: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u16,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> MF_MEDIA_ENGINE_PRELOAD,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, preload: MF_MEDIA_ENGINE_PRELOAD) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppbuffered: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, panswer: *mut MF_MEDIA_ENGINE_CANPLAY) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u16,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> f64,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, seektime: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> f64,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> f64,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> f64,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rate: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> f64,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rate: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppplayed: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppseekable: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, autoplay: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#loop: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, muted: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> f64,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, volume: f64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, cx: *mut u32, cy: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, cx: *mut u32, cy: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdstsurf: ::windows::core::RawPtr, psrc: *const MFVideoNormalizedRect, pdst: *const super::super::Foundation::RECT, pborderclr: *const MFARGB) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppts: *mut i64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdevice: *mut ::core::mem::ManuallyDrop<DEVICE_INFO>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaSharingEngineClassFactory(pub ::windows::core::IUnknown);
impl IMFMediaSharingEngineClassFactory {
pub unsafe fn CreateInstance<'a, Param1: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, dwflags: u32, pattr: Param1) -> ::windows::core::Result<IMFMediaSharingEngine> {
let mut result__: <IMFMediaSharingEngine as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwflags), pattr.into_param().abi(), &mut result__).from_abi::<IMFMediaSharingEngine>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFMediaSharingEngineClassFactory {
type Vtable = IMFMediaSharingEngineClassFactory_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x524d2bc4_b2b1_4fe5_8fac_fa4e4512b4e0);
}
impl ::core::convert::From<IMFMediaSharingEngineClassFactory> for ::windows::core::IUnknown {
fn from(value: IMFMediaSharingEngineClassFactory) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaSharingEngineClassFactory> for ::windows::core::IUnknown {
fn from(value: &IMFMediaSharingEngineClassFactory) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaSharingEngineClassFactory {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaSharingEngineClassFactory {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaSharingEngineClassFactory_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwflags: u32, pattr: ::windows::core::RawPtr, ppengine: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaSink(pub ::windows::core::IUnknown);
impl IMFMediaSink {
pub unsafe fn GetCharacteristics(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddStreamSink<'a, Param1: ::windows::core::IntoParam<'a, IMFMediaType>>(&self, dwstreamsinkidentifier: u32, pmediatype: Param1) -> ::windows::core::Result<IMFStreamSink> {
let mut result__: <IMFStreamSink as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamsinkidentifier), pmediatype.into_param().abi(), &mut result__).from_abi::<IMFStreamSink>(result__)
}
pub unsafe fn RemoveStreamSink(&self, dwstreamsinkidentifier: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamsinkidentifier)).ok()
}
pub unsafe fn GetStreamSinkCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetStreamSinkByIndex(&self, dwindex: u32) -> ::windows::core::Result<IMFStreamSink> {
let mut result__: <IMFStreamSink as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwindex), &mut result__).from_abi::<IMFStreamSink>(result__)
}
pub unsafe fn GetStreamSinkById(&self, dwstreamsinkidentifier: u32) -> ::windows::core::Result<IMFStreamSink> {
let mut result__: <IMFStreamSink as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamsinkidentifier), &mut result__).from_abi::<IMFStreamSink>(result__)
}
pub unsafe fn SetPresentationClock<'a, Param0: ::windows::core::IntoParam<'a, IMFPresentationClock>>(&self, ppresentationclock: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ppresentationclock.into_param().abi()).ok()
}
pub unsafe fn GetPresentationClock(&self) -> ::windows::core::Result<IMFPresentationClock> {
let mut result__: <IMFPresentationClock as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFPresentationClock>(result__)
}
pub unsafe fn Shutdown(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFMediaSink {
type Vtable = IMFMediaSink_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6ef2a660_47c0_4666_b13d_cbb717f2fa2c);
}
impl ::core::convert::From<IMFMediaSink> for ::windows::core::IUnknown {
fn from(value: IMFMediaSink) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaSink> for ::windows::core::IUnknown {
fn from(value: &IMFMediaSink) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaSink {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaSink {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaSink_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcharacteristics: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamsinkidentifier: u32, pmediatype: ::windows::core::RawPtr, ppstreamsink: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamsinkidentifier: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcstreamsinkcount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwindex: u32, ppstreamsink: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamsinkidentifier: u32, ppstreamsink: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppresentationclock: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pppresentationclock: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaSinkPreroll(pub ::windows::core::IUnknown);
impl IMFMediaSinkPreroll {
pub unsafe fn NotifyPreroll(&self, hnsupcomingstarttime: i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(hnsupcomingstarttime)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFMediaSinkPreroll {
type Vtable = IMFMediaSinkPreroll_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5dfd4b2a_7674_4110_a4e6_8a68fd5f3688);
}
impl ::core::convert::From<IMFMediaSinkPreroll> for ::windows::core::IUnknown {
fn from(value: IMFMediaSinkPreroll) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaSinkPreroll> for ::windows::core::IUnknown {
fn from(value: &IMFMediaSinkPreroll) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaSinkPreroll {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaSinkPreroll {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaSinkPreroll_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hnsupcomingstarttime: i64) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaSource(pub ::windows::core::IUnknown);
impl IMFMediaSource {
pub unsafe fn GetEvent(&self, dwflags: MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS) -> ::windows::core::Result<IMFMediaEvent> {
let mut result__: <IMFMediaEvent as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwflags), &mut result__).from_abi::<IMFMediaEvent>(result__)
}
pub unsafe fn BeginGetEvent<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pcallback: Param0, punkstate: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pcallback.into_param().abi(), punkstate.into_param().abi()).ok()
}
pub unsafe fn EndGetEvent<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0) -> ::windows::core::Result<IMFMediaEvent> {
let mut result__: <IMFMediaEvent as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), presult.into_param().abi(), &mut result__).from_abi::<IMFMediaEvent>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn QueueEvent(&self, met: u32, guidextendedtype: *const ::windows::core::GUID, hrstatus: ::windows::core::HRESULT, pvvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(met), ::core::mem::transmute(guidextendedtype), ::core::mem::transmute(hrstatus), ::core::mem::transmute(pvvalue)).ok()
}
pub unsafe fn GetCharacteristics(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn CreatePresentationDescriptor(&self) -> ::windows::core::Result<IMFPresentationDescriptor> {
let mut result__: <IMFPresentationDescriptor as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFPresentationDescriptor>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn Start<'a, Param0: ::windows::core::IntoParam<'a, IMFPresentationDescriptor>>(&self, ppresentationdescriptor: Param0, pguidtimeformat: *const ::windows::core::GUID, pvarstartposition: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ppresentationdescriptor.into_param().abi(), ::core::mem::transmute(pguidtimeformat), ::core::mem::transmute(pvarstartposition)).ok()
}
pub unsafe fn Stop(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Pause(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Shutdown(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFMediaSource {
type Vtable = IMFMediaSource_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x279a808d_aec7_40c8_9c6b_a6b492c78a66);
}
impl ::core::convert::From<IMFMediaSource> for ::windows::core::IUnknown {
fn from(value: IMFMediaSource) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaSource> for ::windows::core::IUnknown {
fn from(value: &IMFMediaSource) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaSource {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaSource {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFMediaSource> for IMFMediaEventGenerator {
fn from(value: IMFMediaSource) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFMediaSource> for IMFMediaEventGenerator {
fn from(value: &IMFMediaSource) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaEventGenerator> for IMFMediaSource {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaEventGenerator> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaEventGenerator> for &IMFMediaSource {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaEventGenerator> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaSource_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwflags: MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS, ppevent: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcallback: ::windows::core::RawPtr, punkstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr, ppevent: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, met: u32, guidextendedtype: *const ::windows::core::GUID, hrstatus: ::windows::core::HRESULT, pvvalue: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcharacteristics: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pppresentationdescriptor: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppresentationdescriptor: ::windows::core::RawPtr, pguidtimeformat: *const ::windows::core::GUID, pvarstartposition: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaSource2(pub ::windows::core::IUnknown);
impl IMFMediaSource2 {
pub unsafe fn GetEvent(&self, dwflags: MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS) -> ::windows::core::Result<IMFMediaEvent> {
let mut result__: <IMFMediaEvent as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwflags), &mut result__).from_abi::<IMFMediaEvent>(result__)
}
pub unsafe fn BeginGetEvent<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pcallback: Param0, punkstate: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pcallback.into_param().abi(), punkstate.into_param().abi()).ok()
}
pub unsafe fn EndGetEvent<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0) -> ::windows::core::Result<IMFMediaEvent> {
let mut result__: <IMFMediaEvent as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), presult.into_param().abi(), &mut result__).from_abi::<IMFMediaEvent>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn QueueEvent(&self, met: u32, guidextendedtype: *const ::windows::core::GUID, hrstatus: ::windows::core::HRESULT, pvvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(met), ::core::mem::transmute(guidextendedtype), ::core::mem::transmute(hrstatus), ::core::mem::transmute(pvvalue)).ok()
}
pub unsafe fn GetCharacteristics(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn CreatePresentationDescriptor(&self) -> ::windows::core::Result<IMFPresentationDescriptor> {
let mut result__: <IMFPresentationDescriptor as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFPresentationDescriptor>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn Start<'a, Param0: ::windows::core::IntoParam<'a, IMFPresentationDescriptor>>(&self, ppresentationdescriptor: Param0, pguidtimeformat: *const ::windows::core::GUID, pvarstartposition: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ppresentationdescriptor.into_param().abi(), ::core::mem::transmute(pguidtimeformat), ::core::mem::transmute(pvarstartposition)).ok()
}
pub unsafe fn Stop(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Pause(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Shutdown(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetSourceAttributes(&self) -> ::windows::core::Result<IMFAttributes> {
let mut result__: <IMFAttributes as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFAttributes>(result__)
}
pub unsafe fn GetStreamAttributes(&self, dwstreamidentifier: u32) -> ::windows::core::Result<IMFAttributes> {
let mut result__: <IMFAttributes as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamidentifier), &mut result__).from_abi::<IMFAttributes>(result__)
}
pub unsafe fn SetD3DManager<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pmanager: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), pmanager.into_param().abi()).ok()
}
pub unsafe fn SetMediaType<'a, Param1: ::windows::core::IntoParam<'a, IMFMediaType>>(&self, dwstreamid: u32, pmediatype: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamid), pmediatype.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFMediaSource2 {
type Vtable = IMFMediaSource2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfbb03414_d13b_4786_8319_5ac51fc0a136);
}
impl ::core::convert::From<IMFMediaSource2> for ::windows::core::IUnknown {
fn from(value: IMFMediaSource2) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaSource2> for ::windows::core::IUnknown {
fn from(value: &IMFMediaSource2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaSource2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaSource2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFMediaSource2> for IMFMediaSourceEx {
fn from(value: IMFMediaSource2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFMediaSource2> for IMFMediaSourceEx {
fn from(value: &IMFMediaSource2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaSourceEx> for IMFMediaSource2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaSourceEx> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaSourceEx> for &IMFMediaSource2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaSourceEx> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<IMFMediaSource2> for IMFMediaSource {
fn from(value: IMFMediaSource2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFMediaSource2> for IMFMediaSource {
fn from(value: &IMFMediaSource2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaSource> for IMFMediaSource2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaSource> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaSource> for &IMFMediaSource2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaSource> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<IMFMediaSource2> for IMFMediaEventGenerator {
fn from(value: IMFMediaSource2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFMediaSource2> for IMFMediaEventGenerator {
fn from(value: &IMFMediaSource2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaEventGenerator> for IMFMediaSource2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaEventGenerator> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaEventGenerator> for &IMFMediaSource2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaEventGenerator> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaSource2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwflags: MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS, ppevent: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcallback: ::windows::core::RawPtr, punkstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr, ppevent: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, met: u32, guidextendedtype: *const ::windows::core::GUID, hrstatus: ::windows::core::HRESULT, pvvalue: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcharacteristics: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pppresentationdescriptor: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppresentationdescriptor: ::windows::core::RawPtr, pguidtimeformat: *const ::windows::core::GUID, pvarstartposition: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppattributes: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamidentifier: u32, ppattributes: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pmanager: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamid: u32, pmediatype: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaSourceEx(pub ::windows::core::IUnknown);
impl IMFMediaSourceEx {
pub unsafe fn GetEvent(&self, dwflags: MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS) -> ::windows::core::Result<IMFMediaEvent> {
let mut result__: <IMFMediaEvent as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwflags), &mut result__).from_abi::<IMFMediaEvent>(result__)
}
pub unsafe fn BeginGetEvent<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pcallback: Param0, punkstate: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pcallback.into_param().abi(), punkstate.into_param().abi()).ok()
}
pub unsafe fn EndGetEvent<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0) -> ::windows::core::Result<IMFMediaEvent> {
let mut result__: <IMFMediaEvent as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), presult.into_param().abi(), &mut result__).from_abi::<IMFMediaEvent>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn QueueEvent(&self, met: u32, guidextendedtype: *const ::windows::core::GUID, hrstatus: ::windows::core::HRESULT, pvvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(met), ::core::mem::transmute(guidextendedtype), ::core::mem::transmute(hrstatus), ::core::mem::transmute(pvvalue)).ok()
}
pub unsafe fn GetCharacteristics(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn CreatePresentationDescriptor(&self) -> ::windows::core::Result<IMFPresentationDescriptor> {
let mut result__: <IMFPresentationDescriptor as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFPresentationDescriptor>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn Start<'a, Param0: ::windows::core::IntoParam<'a, IMFPresentationDescriptor>>(&self, ppresentationdescriptor: Param0, pguidtimeformat: *const ::windows::core::GUID, pvarstartposition: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ppresentationdescriptor.into_param().abi(), ::core::mem::transmute(pguidtimeformat), ::core::mem::transmute(pvarstartposition)).ok()
}
pub unsafe fn Stop(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Pause(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Shutdown(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetSourceAttributes(&self) -> ::windows::core::Result<IMFAttributes> {
let mut result__: <IMFAttributes as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFAttributes>(result__)
}
pub unsafe fn GetStreamAttributes(&self, dwstreamidentifier: u32) -> ::windows::core::Result<IMFAttributes> {
let mut result__: <IMFAttributes as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamidentifier), &mut result__).from_abi::<IMFAttributes>(result__)
}
pub unsafe fn SetD3DManager<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pmanager: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), pmanager.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFMediaSourceEx {
type Vtable = IMFMediaSourceEx_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3c9b2eb9_86d5_4514_a394_f56664f9f0d8);
}
impl ::core::convert::From<IMFMediaSourceEx> for ::windows::core::IUnknown {
fn from(value: IMFMediaSourceEx) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaSourceEx> for ::windows::core::IUnknown {
fn from(value: &IMFMediaSourceEx) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaSourceEx {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaSourceEx {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFMediaSourceEx> for IMFMediaSource {
fn from(value: IMFMediaSourceEx) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFMediaSourceEx> for IMFMediaSource {
fn from(value: &IMFMediaSourceEx) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaSource> for IMFMediaSourceEx {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaSource> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaSource> for &IMFMediaSourceEx {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaSource> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<IMFMediaSourceEx> for IMFMediaEventGenerator {
fn from(value: IMFMediaSourceEx) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFMediaSourceEx> for IMFMediaEventGenerator {
fn from(value: &IMFMediaSourceEx) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaEventGenerator> for IMFMediaSourceEx {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaEventGenerator> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaEventGenerator> for &IMFMediaSourceEx {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaEventGenerator> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaSourceEx_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwflags: MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS, ppevent: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcallback: ::windows::core::RawPtr, punkstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr, ppevent: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, met: u32, guidextendedtype: *const ::windows::core::GUID, hrstatus: ::windows::core::HRESULT, pvvalue: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcharacteristics: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pppresentationdescriptor: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppresentationdescriptor: ::windows::core::RawPtr, pguidtimeformat: *const ::windows::core::GUID, pvarstartposition: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppattributes: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamidentifier: u32, ppattributes: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pmanager: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaSourceExtension(pub ::windows::core::IUnknown);
impl IMFMediaSourceExtension {
pub unsafe fn GetSourceBuffers(&self) -> ::core::option::Option<IMFSourceBufferList> {
::core::mem::transmute((::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetActiveSourceBuffers(&self) -> ::core::option::Option<IMFSourceBufferList> {
::core::mem::transmute((::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetReadyState(&self) -> MF_MSE_READY {
::core::mem::transmute((::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetDuration(&self) -> f64 {
::core::mem::transmute((::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self)))
}
pub unsafe fn SetDuration(&self, duration: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(duration)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddSourceBuffer<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::core::IntoParam<'a, IMFSourceBufferNotify>>(&self, r#type: Param0, pnotify: Param1) -> ::windows::core::Result<IMFSourceBuffer> {
let mut result__: <IMFSourceBuffer as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), r#type.into_param().abi(), pnotify.into_param().abi(), &mut result__).from_abi::<IMFSourceBuffer>(result__)
}
pub unsafe fn RemoveSourceBuffer<'a, Param0: ::windows::core::IntoParam<'a, IMFSourceBuffer>>(&self, psourcebuffer: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), psourcebuffer.into_param().abi()).ok()
}
pub unsafe fn SetEndOfStream(&self, error: MF_MSE_ERROR) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(error)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsTypeSupported<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, r#type: Param0) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), r#type.into_param().abi()))
}
pub unsafe fn GetSourceBuffer(&self, dwstreamindex: u32) -> ::core::option::Option<IMFSourceBuffer> {
::core::mem::transmute((::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex)))
}
}
unsafe impl ::windows::core::Interface for IMFMediaSourceExtension {
type Vtable = IMFMediaSourceExtension_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe467b94e_a713_4562_a802_816a42e9008a);
}
impl ::core::convert::From<IMFMediaSourceExtension> for ::windows::core::IUnknown {
fn from(value: IMFMediaSourceExtension) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaSourceExtension> for ::windows::core::IUnknown {
fn from(value: &IMFMediaSourceExtension) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaSourceExtension {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaSourceExtension {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaSourceExtension_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::RawPtr,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::RawPtr,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> MF_MSE_READY,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> f64,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, duration: f64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, pnotify: ::windows::core::RawPtr, ppsourcebuffer: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psourcebuffer: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, error: MF_MSE_ERROR) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32) -> ::windows::core::RawPtr,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaSourceExtensionLiveSeekableRange(pub ::windows::core::IUnknown);
impl IMFMediaSourceExtensionLiveSeekableRange {
pub unsafe fn SetLiveSeekableRange(&self, start: f64, end: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(end)).ok()
}
pub unsafe fn ClearLiveSeekableRange(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFMediaSourceExtensionLiveSeekableRange {
type Vtable = IMFMediaSourceExtensionLiveSeekableRange_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5d1abfd6_450a_4d92_9efc_d6b6cbc1f4da);
}
impl ::core::convert::From<IMFMediaSourceExtensionLiveSeekableRange> for ::windows::core::IUnknown {
fn from(value: IMFMediaSourceExtensionLiveSeekableRange) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaSourceExtensionLiveSeekableRange> for ::windows::core::IUnknown {
fn from(value: &IMFMediaSourceExtensionLiveSeekableRange) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaSourceExtensionLiveSeekableRange {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaSourceExtensionLiveSeekableRange {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaSourceExtensionLiveSeekableRange_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: f64, end: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaSourceExtensionNotify(pub ::windows::core::IUnknown);
impl IMFMediaSourceExtensionNotify {
pub unsafe fn OnSourceOpen(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)))
}
pub unsafe fn OnSourceEnded(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)))
}
pub unsafe fn OnSourceClose(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)))
}
}
unsafe impl ::windows::core::Interface for IMFMediaSourceExtensionNotify {
type Vtable = IMFMediaSourceExtensionNotify_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa7901327_05dd_4469_a7b7_0e01979e361d);
}
impl ::core::convert::From<IMFMediaSourceExtensionNotify> for ::windows::core::IUnknown {
fn from(value: IMFMediaSourceExtensionNotify) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaSourceExtensionNotify> for ::windows::core::IUnknown {
fn from(value: &IMFMediaSourceExtensionNotify) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaSourceExtensionNotify {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaSourceExtensionNotify {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaSourceExtensionNotify_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaSourcePresentationProvider(pub ::windows::core::IUnknown);
impl IMFMediaSourcePresentationProvider {
pub unsafe fn ForceEndOfPresentation<'a, Param0: ::windows::core::IntoParam<'a, IMFPresentationDescriptor>>(&self, ppresentationdescriptor: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ppresentationdescriptor.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFMediaSourcePresentationProvider {
type Vtable = IMFMediaSourcePresentationProvider_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0e1d600a_c9f3_442d_8c51_a42d2d49452f);
}
impl ::core::convert::From<IMFMediaSourcePresentationProvider> for ::windows::core::IUnknown {
fn from(value: IMFMediaSourcePresentationProvider) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaSourcePresentationProvider> for ::windows::core::IUnknown {
fn from(value: &IMFMediaSourcePresentationProvider) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaSourcePresentationProvider {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaSourcePresentationProvider {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaSourcePresentationProvider_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppresentationdescriptor: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaSourceTopologyProvider(pub ::windows::core::IUnknown);
impl IMFMediaSourceTopologyProvider {
pub unsafe fn GetMediaSourceTopology<'a, Param0: ::windows::core::IntoParam<'a, IMFPresentationDescriptor>>(&self, ppresentationdescriptor: Param0) -> ::windows::core::Result<IMFTopology> {
let mut result__: <IMFTopology as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ppresentationdescriptor.into_param().abi(), &mut result__).from_abi::<IMFTopology>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFMediaSourceTopologyProvider {
type Vtable = IMFMediaSourceTopologyProvider_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0e1d6009_c9f3_442d_8c51_a42d2d49452f);
}
impl ::core::convert::From<IMFMediaSourceTopologyProvider> for ::windows::core::IUnknown {
fn from(value: IMFMediaSourceTopologyProvider) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaSourceTopologyProvider> for ::windows::core::IUnknown {
fn from(value: &IMFMediaSourceTopologyProvider) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaSourceTopologyProvider {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaSourceTopologyProvider {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaSourceTopologyProvider_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppresentationdescriptor: ::windows::core::RawPtr, pptopology: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaStream(pub ::windows::core::IUnknown);
impl IMFMediaStream {
pub unsafe fn GetEvent(&self, dwflags: MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS) -> ::windows::core::Result<IMFMediaEvent> {
let mut result__: <IMFMediaEvent as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwflags), &mut result__).from_abi::<IMFMediaEvent>(result__)
}
pub unsafe fn BeginGetEvent<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pcallback: Param0, punkstate: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pcallback.into_param().abi(), punkstate.into_param().abi()).ok()
}
pub unsafe fn EndGetEvent<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0) -> ::windows::core::Result<IMFMediaEvent> {
let mut result__: <IMFMediaEvent as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), presult.into_param().abi(), &mut result__).from_abi::<IMFMediaEvent>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn QueueEvent(&self, met: u32, guidextendedtype: *const ::windows::core::GUID, hrstatus: ::windows::core::HRESULT, pvvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(met), ::core::mem::transmute(guidextendedtype), ::core::mem::transmute(hrstatus), ::core::mem::transmute(pvvalue)).ok()
}
pub unsafe fn GetMediaSource(&self) -> ::windows::core::Result<IMFMediaSource> {
let mut result__: <IMFMediaSource as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFMediaSource>(result__)
}
pub unsafe fn GetStreamDescriptor(&self) -> ::windows::core::Result<IMFStreamDescriptor> {
let mut result__: <IMFStreamDescriptor as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFStreamDescriptor>(result__)
}
pub unsafe fn RequestSample<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, ptoken: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ptoken.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFMediaStream {
type Vtable = IMFMediaStream_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd182108f_4ec6_443f_aa42_a71106ec825f);
}
impl ::core::convert::From<IMFMediaStream> for ::windows::core::IUnknown {
fn from(value: IMFMediaStream) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaStream> for ::windows::core::IUnknown {
fn from(value: &IMFMediaStream) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaStream {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaStream {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFMediaStream> for IMFMediaEventGenerator {
fn from(value: IMFMediaStream) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFMediaStream> for IMFMediaEventGenerator {
fn from(value: &IMFMediaStream) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaEventGenerator> for IMFMediaStream {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaEventGenerator> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaEventGenerator> for &IMFMediaStream {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaEventGenerator> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaStream_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwflags: MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS, ppevent: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcallback: ::windows::core::RawPtr, punkstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr, ppevent: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, met: u32, guidextendedtype: *const ::windows::core::GUID, hrstatus: ::windows::core::HRESULT, pvvalue: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppmediasource: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppstreamdescriptor: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptoken: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaStream2(pub ::windows::core::IUnknown);
impl IMFMediaStream2 {
pub unsafe fn GetEvent(&self, dwflags: MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS) -> ::windows::core::Result<IMFMediaEvent> {
let mut result__: <IMFMediaEvent as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwflags), &mut result__).from_abi::<IMFMediaEvent>(result__)
}
pub unsafe fn BeginGetEvent<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pcallback: Param0, punkstate: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pcallback.into_param().abi(), punkstate.into_param().abi()).ok()
}
pub unsafe fn EndGetEvent<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0) -> ::windows::core::Result<IMFMediaEvent> {
let mut result__: <IMFMediaEvent as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), presult.into_param().abi(), &mut result__).from_abi::<IMFMediaEvent>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn QueueEvent(&self, met: u32, guidextendedtype: *const ::windows::core::GUID, hrstatus: ::windows::core::HRESULT, pvvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(met), ::core::mem::transmute(guidextendedtype), ::core::mem::transmute(hrstatus), ::core::mem::transmute(pvvalue)).ok()
}
pub unsafe fn GetMediaSource(&self) -> ::windows::core::Result<IMFMediaSource> {
let mut result__: <IMFMediaSource as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFMediaSource>(result__)
}
pub unsafe fn GetStreamDescriptor(&self) -> ::windows::core::Result<IMFStreamDescriptor> {
let mut result__: <IMFStreamDescriptor as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFStreamDescriptor>(result__)
}
pub unsafe fn RequestSample<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, ptoken: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ptoken.into_param().abi()).ok()
}
pub unsafe fn SetStreamState(&self, value: MF_STREAM_STATE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(value)).ok()
}
pub unsafe fn GetStreamState(&self) -> ::windows::core::Result<MF_STREAM_STATE> {
let mut result__: <MF_STREAM_STATE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MF_STREAM_STATE>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFMediaStream2 {
type Vtable = IMFMediaStream2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc5bc37d6_75c7_46a1_a132_81b5f723c20f);
}
impl ::core::convert::From<IMFMediaStream2> for ::windows::core::IUnknown {
fn from(value: IMFMediaStream2) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaStream2> for ::windows::core::IUnknown {
fn from(value: &IMFMediaStream2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaStream2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaStream2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFMediaStream2> for IMFMediaStream {
fn from(value: IMFMediaStream2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFMediaStream2> for IMFMediaStream {
fn from(value: &IMFMediaStream2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaStream> for IMFMediaStream2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaStream> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaStream> for &IMFMediaStream2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaStream> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<IMFMediaStream2> for IMFMediaEventGenerator {
fn from(value: IMFMediaStream2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFMediaStream2> for IMFMediaEventGenerator {
fn from(value: &IMFMediaStream2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaEventGenerator> for IMFMediaStream2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaEventGenerator> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaEventGenerator> for &IMFMediaStream2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaEventGenerator> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaStream2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwflags: MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS, ppevent: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcallback: ::windows::core::RawPtr, punkstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr, ppevent: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, met: u32, guidextendedtype: *const ::windows::core::GUID, hrstatus: ::windows::core::HRESULT, pvvalue: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppmediasource: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppstreamdescriptor: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptoken: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, value: MF_STREAM_STATE) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, value: *mut MF_STREAM_STATE) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaStreamSourceSampleRequest(pub ::windows::core::IUnknown);
impl IMFMediaStreamSourceSampleRequest {
pub unsafe fn SetSample<'a, Param0: ::windows::core::IntoParam<'a, IMFSample>>(&self, value: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), value.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFMediaStreamSourceSampleRequest {
type Vtable = IMFMediaStreamSourceSampleRequest_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x380b9af9_a85b_4e78_a2af_ea5ce645c6b4);
}
impl ::core::convert::From<IMFMediaStreamSourceSampleRequest> for ::windows::core::IUnknown {
fn from(value: IMFMediaStreamSourceSampleRequest) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaStreamSourceSampleRequest> for ::windows::core::IUnknown {
fn from(value: &IMFMediaStreamSourceSampleRequest) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaStreamSourceSampleRequest {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaStreamSourceSampleRequest {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaStreamSourceSampleRequest_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, value: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaTimeRange(pub ::windows::core::IUnknown);
impl IMFMediaTimeRange {
pub unsafe fn GetLength(&self) -> u32 {
::core::mem::transmute((::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetStart(&self, index: u32) -> ::windows::core::Result<f64> {
let mut result__: <f64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<f64>(result__)
}
pub unsafe fn GetEnd(&self, index: u32) -> ::windows::core::Result<f64> {
let mut result__: <f64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<f64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ContainsTime(&self, time: f64) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(time)))
}
pub unsafe fn AddRange(&self, starttime: f64, endtime: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(starttime), ::core::mem::transmute(endtime)).ok()
}
pub unsafe fn Clear(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFMediaTimeRange {
type Vtable = IMFMediaTimeRange_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdb71a2fc_078a_414e_9df9_8c2531b0aa6c);
}
impl ::core::convert::From<IMFMediaTimeRange> for ::windows::core::IUnknown {
fn from(value: IMFMediaTimeRange) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaTimeRange> for ::windows::core::IUnknown {
fn from(value: &IMFMediaTimeRange) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaTimeRange {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaTimeRange {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaTimeRange_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, pstart: *mut f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, pend: *mut f64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, time: f64) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, starttime: f64, endtime: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaType(pub ::windows::core::IUnknown);
impl IMFMediaType {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItem(&self, guidkey: *const ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn GetItemType(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<MF_ATTRIBUTE_TYPE> {
let mut result__: <MF_ATTRIBUTE_TYPE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<MF_ATTRIBUTE_TYPE>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn CompareItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Compare<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, ptheirs: Param0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ptheirs.into_param().abi(), ::core::mem::transmute(matchtype), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn GetUINT32(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetUINT64(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetDouble(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<f64> {
let mut result__: <f64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<f64>(result__)
}
pub unsafe fn GetGUID(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
pub unsafe fn GetStringLength(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetString(&self, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pwszvalue), ::core::mem::transmute(cchbufsize), ::core::mem::transmute(pcchlength)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetAllocatedString(&self, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppwszvalue), ::core::mem::transmute(pcchlength)).ok()
}
pub unsafe fn GetBlobSize(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize), ::core::mem::transmute(pcbblobsize)).ok()
}
pub unsafe fn GetAllocatedBlob(&self, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppbuf), ::core::mem::transmute(pcbsize)).ok()
}
pub unsafe fn GetUnknown<T: ::windows::core::Interface>(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn SetItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value)).ok()
}
pub unsafe fn DeleteItem(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey)).ok()
}
pub unsafe fn DeleteAllItems(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetUINT32(&self, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetUINT64(&self, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetDouble(&self, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(fvalue)).ok()
}
pub unsafe fn SetGUID(&self, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(guidvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetString<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, guidkey: *const ::windows::core::GUID, wszvalue: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), wszvalue.into_param().abi()).ok()
}
pub unsafe fn SetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize)).ok()
}
pub unsafe fn SetUnknown<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guidkey: *const ::windows::core::GUID, punknown: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), punknown.into_param().abi()).ok()
}
pub unsafe fn LockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn UnlockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(unindex), ::core::mem::transmute(pguidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn CopyAllItems<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, pdest: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), pdest.into_param().abi()).ok()
}
pub unsafe fn GetMajorType(&self) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsCompressedFormat(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn IsEqual<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaType>>(&self, pimediatype: Param0) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), pimediatype.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetRepresentation<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::GUID>>(&self, guidrepresentation: Param0, ppvrepresentation: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), guidrepresentation.into_param().abi(), ::core::mem::transmute(ppvrepresentation)).ok()
}
pub unsafe fn FreeRepresentation<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::GUID>>(&self, guidrepresentation: Param0, pvrepresentation: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), guidrepresentation.into_param().abi(), ::core::mem::transmute(pvrepresentation)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFMediaType {
type Vtable = IMFMediaType_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x44ae0fa8_ea31_4109_8d2e_4cae4997c555);
}
impl ::core::convert::From<IMFMediaType> for ::windows::core::IUnknown {
fn from(value: IMFMediaType) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaType> for ::windows::core::IUnknown {
fn from(value: &IMFMediaType) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaType {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaType {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFMediaType> for IMFAttributes {
fn from(value: IMFMediaType) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFMediaType> for IMFAttributes {
fn from(value: &IMFMediaType) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for IMFMediaType {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for &IMFMediaType {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaType_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ptype: *mut MF_ATTRIBUTE_TYPE) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptheirs: ::windows::core::RawPtr, matchtype: MF_ATTRIBUTES_MATCH_TYPE, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pfvalue: *mut f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pguidvalue: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, wszvalue: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punknown: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcitems: *mut u32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdest: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pguidmajortype: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfcompressed: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pimediatype: ::windows::core::RawPtr, pdwflags: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidrepresentation: ::windows::core::GUID, ppvrepresentation: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidrepresentation: ::windows::core::GUID, pvrepresentation: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMediaTypeHandler(pub ::windows::core::IUnknown);
impl IMFMediaTypeHandler {
pub unsafe fn IsMediaTypeSupported<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaType>>(&self, pmediatype: Param0) -> ::windows::core::Result<IMFMediaType> {
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pmediatype.into_param().abi(), &mut result__).from_abi::<IMFMediaType>(result__)
}
pub unsafe fn GetMediaTypeCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetMediaTypeByIndex(&self, dwindex: u32) -> ::windows::core::Result<IMFMediaType> {
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwindex), &mut result__).from_abi::<IMFMediaType>(result__)
}
pub unsafe fn SetCurrentMediaType<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaType>>(&self, pmediatype: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), pmediatype.into_param().abi()).ok()
}
pub unsafe fn GetCurrentMediaType(&self) -> ::windows::core::Result<IMFMediaType> {
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFMediaType>(result__)
}
pub unsafe fn GetMajorType(&self) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFMediaTypeHandler {
type Vtable = IMFMediaTypeHandler_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe93dcf6c_4b07_4e1e_8123_aa16ed6eadf5);
}
impl ::core::convert::From<IMFMediaTypeHandler> for ::windows::core::IUnknown {
fn from(value: IMFMediaTypeHandler) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMediaTypeHandler> for ::windows::core::IUnknown {
fn from(value: &IMFMediaTypeHandler) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMediaTypeHandler {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMediaTypeHandler {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMediaTypeHandler_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pmediatype: ::windows::core::RawPtr, ppmediatype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwtypecount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwindex: u32, pptype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pmediatype: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppmediatype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pguidmajortype: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMetadata(pub ::windows::core::IUnknown);
impl IMFMetadata {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetLanguage<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pwszrfc1766: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pwszrfc1766.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLanguage(&self) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetAllLanguages(&self) -> ::windows::core::Result<super::super::System::Com::StructuredStorage::PROPVARIANT> {
let mut result__: <super::super::System::Com::StructuredStorage::PROPVARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::StructuredStorage::PROPVARIANT>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn SetProperty<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pwszname: Param0, ppvvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), pwszname.into_param().abi(), ::core::mem::transmute(ppvvalue)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetProperty<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pwszname: Param0) -> ::windows::core::Result<super::super::System::Com::StructuredStorage::PROPVARIANT> {
let mut result__: <super::super::System::Com::StructuredStorage::PROPVARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), pwszname.into_param().abi(), &mut result__).from_abi::<super::super::System::Com::StructuredStorage::PROPVARIANT>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DeleteProperty<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pwszname: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), pwszname.into_param().abi()).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetAllPropertyNames(&self) -> ::windows::core::Result<super::super::System::Com::StructuredStorage::PROPVARIANT> {
let mut result__: <super::super::System::Com::StructuredStorage::PROPVARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::StructuredStorage::PROPVARIANT>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFMetadata {
type Vtable = IMFMetadata_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf88cfb8c_ef16_4991_b450_cb8c69e51704);
}
impl ::core::convert::From<IMFMetadata> for ::windows::core::IUnknown {
fn from(value: IMFMetadata) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMetadata> for ::windows::core::IUnknown {
fn from(value: &IMFMetadata) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMetadata {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMetadata {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMetadata_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pwszrfc1766: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppwszrfc1766: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppvlanguages: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pwszname: super::super::Foundation::PWSTR, ppvvalue: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pwszname: super::super::Foundation::PWSTR, ppvvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pwszname: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppvnames: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMetadataProvider(pub ::windows::core::IUnknown);
impl IMFMetadataProvider {
pub unsafe fn GetMFMetadata<'a, Param0: ::windows::core::IntoParam<'a, IMFPresentationDescriptor>>(&self, ppresentationdescriptor: Param0, dwstreamidentifier: u32, dwflags: u32) -> ::windows::core::Result<IMFMetadata> {
let mut result__: <IMFMetadata as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ppresentationdescriptor.into_param().abi(), ::core::mem::transmute(dwstreamidentifier), ::core::mem::transmute(dwflags), &mut result__).from_abi::<IMFMetadata>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFMetadataProvider {
type Vtable = IMFMetadataProvider_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x56181d2d_e221_4adb_b1c8_3cee6a53f76f);
}
impl ::core::convert::From<IMFMetadataProvider> for ::windows::core::IUnknown {
fn from(value: IMFMetadataProvider) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMetadataProvider> for ::windows::core::IUnknown {
fn from(value: &IMFMetadataProvider) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMetadataProvider {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMetadataProvider {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMetadataProvider_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppresentationdescriptor: ::windows::core::RawPtr, dwstreamidentifier: u32, dwflags: u32, ppmfmetadata: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMuxStreamAttributesManager(pub ::windows::core::IUnknown);
impl IMFMuxStreamAttributesManager {
pub unsafe fn GetStreamCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetAttributes(&self, dwmuxstreamindex: u32) -> ::windows::core::Result<IMFAttributes> {
let mut result__: <IMFAttributes as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwmuxstreamindex), &mut result__).from_abi::<IMFAttributes>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFMuxStreamAttributesManager {
type Vtable = IMFMuxStreamAttributesManager_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xce8bd576_e440_43b3_be34_1e53f565f7e8);
}
impl ::core::convert::From<IMFMuxStreamAttributesManager> for ::windows::core::IUnknown {
fn from(value: IMFMuxStreamAttributesManager) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMuxStreamAttributesManager> for ::windows::core::IUnknown {
fn from(value: &IMFMuxStreamAttributesManager) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMuxStreamAttributesManager {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMuxStreamAttributesManager {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMuxStreamAttributesManager_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwmuxstreamcount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwmuxstreamindex: u32, ppstreamattributes: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMuxStreamMediaTypeManager(pub ::windows::core::IUnknown);
impl IMFMuxStreamMediaTypeManager {
pub unsafe fn GetStreamCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetMediaType(&self, dwmuxstreamindex: u32) -> ::windows::core::Result<IMFMediaType> {
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwmuxstreamindex), &mut result__).from_abi::<IMFMediaType>(result__)
}
pub unsafe fn GetStreamConfigurationCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddStreamConfiguration(&self, ullstreammask: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(ullstreammask)).ok()
}
pub unsafe fn RemoveStreamConfiguration(&self, ullstreammask: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(ullstreammask)).ok()
}
pub unsafe fn GetStreamConfiguration(&self, ulindex: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulindex), &mut result__).from_abi::<u64>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFMuxStreamMediaTypeManager {
type Vtable = IMFMuxStreamMediaTypeManager_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x505a2c72_42f7_4690_aeab_8f513d0ffdb8);
}
impl ::core::convert::From<IMFMuxStreamMediaTypeManager> for ::windows::core::IUnknown {
fn from(value: IMFMuxStreamMediaTypeManager) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMuxStreamMediaTypeManager> for ::windows::core::IUnknown {
fn from(value: &IMFMuxStreamMediaTypeManager) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMuxStreamMediaTypeManager {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMuxStreamMediaTypeManager {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMuxStreamMediaTypeManager_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwmuxstreamcount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwmuxstreamindex: u32, ppmediatype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ullstreammask: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ullstreammask: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulindex: u32, pullstreammask: *mut u64) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFMuxStreamSampleManager(pub ::windows::core::IUnknown);
impl IMFMuxStreamSampleManager {
pub unsafe fn GetStreamCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetSample(&self, dwmuxstreamindex: u32) -> ::windows::core::Result<IMFSample> {
let mut result__: <IMFSample as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwmuxstreamindex), &mut result__).from_abi::<IMFSample>(result__)
}
pub unsafe fn GetStreamConfiguration(&self) -> u64 {
::core::mem::transmute((::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)))
}
}
unsafe impl ::windows::core::Interface for IMFMuxStreamSampleManager {
type Vtable = IMFMuxStreamSampleManager_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x74abbc19_b1cc_4e41_bb8b_9d9b86a8f6ca);
}
impl ::core::convert::From<IMFMuxStreamSampleManager> for ::windows::core::IUnknown {
fn from(value: IMFMuxStreamSampleManager) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFMuxStreamSampleManager> for ::windows::core::IUnknown {
fn from(value: &IMFMuxStreamSampleManager) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFMuxStreamSampleManager {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFMuxStreamSampleManager {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFMuxStreamSampleManager_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwmuxstreamcount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwmuxstreamindex: u32, ppsample: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u64,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFNetCredential(pub ::windows::core::IUnknown);
impl IMFNetCredential {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetUser<'a, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, pbdata: *const u8, cbdata: u32, fdataisencrypted: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbdata), ::core::mem::transmute(cbdata), fdataisencrypted.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetPassword<'a, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, pbdata: *const u8, cbdata: u32, fdataisencrypted: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbdata), ::core::mem::transmute(cbdata), fdataisencrypted.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetUser<'a, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, pbdata: *mut u8, pcbdata: *mut u32, fencryptdata: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbdata), ::core::mem::transmute(pcbdata), fencryptdata.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPassword<'a, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, pbdata: *mut u8, pcbdata: *mut u32, fencryptdata: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbdata), ::core::mem::transmute(pcbdata), fencryptdata.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn LoggedOnUser(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFNetCredential {
type Vtable = IMFNetCredential_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5b87ef6a_7ed8_434f_ba0e_184fac1628d1);
}
impl ::core::convert::From<IMFNetCredential> for ::windows::core::IUnknown {
fn from(value: IMFNetCredential) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFNetCredential> for ::windows::core::IUnknown {
fn from(value: &IMFNetCredential) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFNetCredential {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFNetCredential {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFNetCredential_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbdata: *const u8, cbdata: u32, fdataisencrypted: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbdata: *const u8, cbdata: u32, fdataisencrypted: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbdata: *mut u8, pcbdata: *mut u32, fencryptdata: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbdata: *mut u8, pcbdata: *mut u32, fencryptdata: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfloggedonuser: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFNetCredentialCache(pub ::windows::core::IUnknown);
impl IMFNetCredentialCache {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetCredential<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszurl: Param0, pszrealm: Param1, dwauthenticationflags: u32, ppcred: *mut ::core::option::Option<IMFNetCredential>, pdwrequirementsflags: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pszurl.into_param().abi(), pszrealm.into_param().abi(), ::core::mem::transmute(dwauthenticationflags), ::core::mem::transmute(ppcred), ::core::mem::transmute(pdwrequirementsflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetGood<'a, Param0: ::windows::core::IntoParam<'a, IMFNetCredential>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, pcred: Param0, fgood: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pcred.into_param().abi(), fgood.into_param().abi()).ok()
}
pub unsafe fn SetUserOptions<'a, Param0: ::windows::core::IntoParam<'a, IMFNetCredential>>(&self, pcred: Param0, dwoptionsflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pcred.into_param().abi(), ::core::mem::transmute(dwoptionsflags)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFNetCredentialCache {
type Vtable = IMFNetCredentialCache_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5b87ef6c_7ed8_434f_ba0e_184fac1628d1);
}
impl ::core::convert::From<IMFNetCredentialCache> for ::windows::core::IUnknown {
fn from(value: IMFNetCredentialCache) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFNetCredentialCache> for ::windows::core::IUnknown {
fn from(value: &IMFNetCredentialCache) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFNetCredentialCache {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFNetCredentialCache {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFNetCredentialCache_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszurl: super::super::Foundation::PWSTR, pszrealm: super::super::Foundation::PWSTR, dwauthenticationflags: u32, ppcred: *mut ::windows::core::RawPtr, pdwrequirementsflags: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcred: ::windows::core::RawPtr, fgood: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcred: ::windows::core::RawPtr, dwoptionsflags: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFNetCredentialManager(pub ::windows::core::IUnknown);
impl IMFNetCredentialManager {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn BeginGetCredentials<'a, Param1: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param2: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pparam: *const MFNetCredentialManagerGetParam, pcallback: Param1, pstate: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pparam), pcallback.into_param().abi(), pstate.into_param().abi()).ok()
}
pub unsafe fn EndGetCredentials<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0) -> ::windows::core::Result<IMFNetCredential> {
let mut result__: <IMFNetCredential as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), presult.into_param().abi(), &mut result__).from_abi::<IMFNetCredential>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetGood<'a, Param0: ::windows::core::IntoParam<'a, IMFNetCredential>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, pcred: Param0, fgood: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pcred.into_param().abi(), fgood.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFNetCredentialManager {
type Vtable = IMFNetCredentialManager_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5b87ef6b_7ed8_434f_ba0e_184fac1628d1);
}
impl ::core::convert::From<IMFNetCredentialManager> for ::windows::core::IUnknown {
fn from(value: IMFNetCredentialManager) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFNetCredentialManager> for ::windows::core::IUnknown {
fn from(value: &IMFNetCredentialManager) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFNetCredentialManager {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFNetCredentialManager {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFNetCredentialManager_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pparam: *const MFNetCredentialManagerGetParam, pcallback: ::windows::core::RawPtr, pstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr, ppcred: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcred: ::windows::core::RawPtr, fgood: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFNetCrossOriginSupport(pub ::windows::core::IUnknown);
impl IMFNetCrossOriginSupport {
pub unsafe fn GetCrossOriginPolicy(&self) -> ::windows::core::Result<MF_CROSS_ORIGIN_POLICY> {
let mut result__: <MF_CROSS_ORIGIN_POLICY as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MF_CROSS_ORIGIN_POLICY>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourceOrigin(&self) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsSameOrigin<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, wszurl: Param0) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), wszurl.into_param().abi(), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFNetCrossOriginSupport {
type Vtable = IMFNetCrossOriginSupport_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbc2b7d44_a72d_49d5_8376_1480dee58b22);
}
impl ::core::convert::From<IMFNetCrossOriginSupport> for ::windows::core::IUnknown {
fn from(value: IMFNetCrossOriginSupport) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFNetCrossOriginSupport> for ::windows::core::IUnknown {
fn from(value: &IMFNetCrossOriginSupport) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFNetCrossOriginSupport {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFNetCrossOriginSupport {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFNetCrossOriginSupport_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppolicy: *mut MF_CROSS_ORIGIN_POLICY) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, wszsourceorigin: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, wszurl: super::super::Foundation::PWSTR, pfissameorigin: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFNetProxyLocator(pub ::windows::core::IUnknown);
impl IMFNetProxyLocator {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn FindFirstProxy<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, pszhost: Param0, pszurl: Param1, freserved: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pszhost.into_param().abi(), pszurl.into_param().abi(), freserved.into_param().abi()).ok()
}
pub unsafe fn FindNextProxy(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn RegisterProxyResult(&self, hrop: ::windows::core::HRESULT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(hrop)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetCurrentProxy(&self, pszstr: super::super::Foundation::PWSTR, pcchstr: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(pszstr), ::core::mem::transmute(pcchstr)).ok()
}
pub unsafe fn Clone(&self) -> ::windows::core::Result<IMFNetProxyLocator> {
let mut result__: <IMFNetProxyLocator as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFNetProxyLocator>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFNetProxyLocator {
type Vtable = IMFNetProxyLocator_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe9cd0383_a268_4bb4_82de_658d53574d41);
}
impl ::core::convert::From<IMFNetProxyLocator> for ::windows::core::IUnknown {
fn from(value: IMFNetProxyLocator) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFNetProxyLocator> for ::windows::core::IUnknown {
fn from(value: &IMFNetProxyLocator) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFNetProxyLocator {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFNetProxyLocator {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFNetProxyLocator_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszhost: super::super::Foundation::PWSTR, pszurl: super::super::Foundation::PWSTR, freserved: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hrop: ::windows::core::HRESULT) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszstr: super::super::Foundation::PWSTR, pcchstr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppproxylocator: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFNetProxyLocatorFactory(pub ::windows::core::IUnknown);
impl IMFNetProxyLocatorFactory {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProxyLocator<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszprotocol: Param0) -> ::windows::core::Result<IMFNetProxyLocator> {
let mut result__: <IMFNetProxyLocator as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pszprotocol.into_param().abi(), &mut result__).from_abi::<IMFNetProxyLocator>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFNetProxyLocatorFactory {
type Vtable = IMFNetProxyLocatorFactory_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe9cd0384_a268_4bb4_82de_658d53574d41);
}
impl ::core::convert::From<IMFNetProxyLocatorFactory> for ::windows::core::IUnknown {
fn from(value: IMFNetProxyLocatorFactory) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFNetProxyLocatorFactory> for ::windows::core::IUnknown {
fn from(value: &IMFNetProxyLocatorFactory) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFNetProxyLocatorFactory {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFNetProxyLocatorFactory {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFNetProxyLocatorFactory_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszprotocol: super::super::Foundation::PWSTR, ppproxylocator: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFNetResourceFilter(pub ::windows::core::IUnknown);
impl IMFNetResourceFilter {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OnRedirect<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszurl: Param0) -> ::windows::core::Result<i16> {
let mut result__: <i16 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pszurl.into_param().abi(), &mut result__).from_abi::<i16>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OnSendingRequest<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszurl: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pszurl.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFNetResourceFilter {
type Vtable = IMFNetResourceFilter_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x091878a3_bf11_4a5c_bc9f_33995b06ef2d);
}
impl ::core::convert::From<IMFNetResourceFilter> for ::windows::core::IUnknown {
fn from(value: IMFNetResourceFilter) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFNetResourceFilter> for ::windows::core::IUnknown {
fn from(value: &IMFNetResourceFilter) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFNetResourceFilter {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFNetResourceFilter {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFNetResourceFilter_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszurl: super::super::Foundation::PWSTR, pvbcancel: *mut i16) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszurl: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFNetSchemeHandlerConfig(pub ::windows::core::IUnknown);
impl IMFNetSchemeHandlerConfig {
pub unsafe fn GetNumberOfSupportedProtocols(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetSupportedProtocolType(&self, nprotocolindex: u32) -> ::windows::core::Result<MFNETSOURCE_PROTOCOL_TYPE> {
let mut result__: <MFNETSOURCE_PROTOCOL_TYPE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(nprotocolindex), &mut result__).from_abi::<MFNETSOURCE_PROTOCOL_TYPE>(result__)
}
pub unsafe fn ResetProtocolRolloverSettings(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFNetSchemeHandlerConfig {
type Vtable = IMFNetSchemeHandlerConfig_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7be19e73_c9bf_468a_ac5a_a5e8653bec87);
}
impl ::core::convert::From<IMFNetSchemeHandlerConfig> for ::windows::core::IUnknown {
fn from(value: IMFNetSchemeHandlerConfig) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFNetSchemeHandlerConfig> for ::windows::core::IUnknown {
fn from(value: &IMFNetSchemeHandlerConfig) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFNetSchemeHandlerConfig {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFNetSchemeHandlerConfig {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFNetSchemeHandlerConfig_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcprotocols: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, nprotocolindex: u32, pnprotocoltype: *mut MFNETSOURCE_PROTOCOL_TYPE) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFObjectReferenceStream(pub ::windows::core::IUnknown);
impl IMFObjectReferenceStream {
pub unsafe fn SaveReference<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, riid: *const ::windows::core::GUID, punk: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(riid), punk.into_param().abi()).ok()
}
pub unsafe fn LoadReference(&self, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(riid), ::core::mem::transmute(ppv)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFObjectReferenceStream {
type Vtable = IMFObjectReferenceStream_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x09ef5be3_c8a7_469e_8b70_73bf25bb193f);
}
impl ::core::convert::From<IMFObjectReferenceStream> for ::windows::core::IUnknown {
fn from(value: IMFObjectReferenceStream) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFObjectReferenceStream> for ::windows::core::IUnknown {
fn from(value: &IMFObjectReferenceStream) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFObjectReferenceStream {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFObjectReferenceStream {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFObjectReferenceStream_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, punk: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFOutputPolicy(pub ::windows::core::IUnknown);
impl IMFOutputPolicy {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItem(&self, guidkey: *const ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn GetItemType(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<MF_ATTRIBUTE_TYPE> {
let mut result__: <MF_ATTRIBUTE_TYPE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<MF_ATTRIBUTE_TYPE>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn CompareItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Compare<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, ptheirs: Param0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ptheirs.into_param().abi(), ::core::mem::transmute(matchtype), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn GetUINT32(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetUINT64(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetDouble(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<f64> {
let mut result__: <f64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<f64>(result__)
}
pub unsafe fn GetGUID(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
pub unsafe fn GetStringLength(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetString(&self, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pwszvalue), ::core::mem::transmute(cchbufsize), ::core::mem::transmute(pcchlength)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetAllocatedString(&self, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppwszvalue), ::core::mem::transmute(pcchlength)).ok()
}
pub unsafe fn GetBlobSize(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize), ::core::mem::transmute(pcbblobsize)).ok()
}
pub unsafe fn GetAllocatedBlob(&self, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppbuf), ::core::mem::transmute(pcbsize)).ok()
}
pub unsafe fn GetUnknown<T: ::windows::core::Interface>(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn SetItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value)).ok()
}
pub unsafe fn DeleteItem(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey)).ok()
}
pub unsafe fn DeleteAllItems(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetUINT32(&self, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetUINT64(&self, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetDouble(&self, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(fvalue)).ok()
}
pub unsafe fn SetGUID(&self, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(guidvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetString<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, guidkey: *const ::windows::core::GUID, wszvalue: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), wszvalue.into_param().abi()).ok()
}
pub unsafe fn SetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize)).ok()
}
pub unsafe fn SetUnknown<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guidkey: *const ::windows::core::GUID, punknown: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), punknown.into_param().abi()).ok()
}
pub unsafe fn LockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn UnlockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(unindex), ::core::mem::transmute(pguidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn CopyAllItems<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, pdest: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), pdest.into_param().abi()).ok()
}
pub unsafe fn GenerateRequiredSchemas<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::GUID>>(&self, dwattributes: u32, guidoutputsubtype: Param1, rgguidprotectionschemassupported: *const ::windows::core::GUID, cprotectionschemassupported: u32) -> ::windows::core::Result<IMFCollection> {
let mut result__: <IMFCollection as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwattributes), guidoutputsubtype.into_param().abi(), ::core::mem::transmute(rgguidprotectionschemassupported), ::core::mem::transmute(cprotectionschemassupported), &mut result__).from_abi::<IMFCollection>(result__)
}
pub unsafe fn GetOriginatorID(&self) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
pub unsafe fn GetMinimumGRLVersion(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFOutputPolicy {
type Vtable = IMFOutputPolicy_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7f00f10a_daed_41af_ab26_5fdfa4dfba3c);
}
impl ::core::convert::From<IMFOutputPolicy> for ::windows::core::IUnknown {
fn from(value: IMFOutputPolicy) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFOutputPolicy> for ::windows::core::IUnknown {
fn from(value: &IMFOutputPolicy) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFOutputPolicy {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFOutputPolicy {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFOutputPolicy> for IMFAttributes {
fn from(value: IMFOutputPolicy) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFOutputPolicy> for IMFAttributes {
fn from(value: &IMFOutputPolicy) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for IMFOutputPolicy {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for &IMFOutputPolicy {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFOutputPolicy_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ptype: *mut MF_ATTRIBUTE_TYPE) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptheirs: ::windows::core::RawPtr, matchtype: MF_ATTRIBUTES_MATCH_TYPE, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pfvalue: *mut f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pguidvalue: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, wszvalue: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punknown: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcitems: *mut u32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdest: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwattributes: u32, guidoutputsubtype: ::windows::core::GUID, rgguidprotectionschemassupported: *const ::windows::core::GUID, cprotectionschemassupported: u32, pprequiredprotectionschemas: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pguidoriginatorid: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwminimumgrlversion: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFOutputSchema(pub ::windows::core::IUnknown);
impl IMFOutputSchema {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItem(&self, guidkey: *const ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn GetItemType(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<MF_ATTRIBUTE_TYPE> {
let mut result__: <MF_ATTRIBUTE_TYPE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<MF_ATTRIBUTE_TYPE>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn CompareItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Compare<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, ptheirs: Param0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ptheirs.into_param().abi(), ::core::mem::transmute(matchtype), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn GetUINT32(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetUINT64(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetDouble(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<f64> {
let mut result__: <f64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<f64>(result__)
}
pub unsafe fn GetGUID(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
pub unsafe fn GetStringLength(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetString(&self, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pwszvalue), ::core::mem::transmute(cchbufsize), ::core::mem::transmute(pcchlength)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetAllocatedString(&self, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppwszvalue), ::core::mem::transmute(pcchlength)).ok()
}
pub unsafe fn GetBlobSize(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize), ::core::mem::transmute(pcbblobsize)).ok()
}
pub unsafe fn GetAllocatedBlob(&self, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppbuf), ::core::mem::transmute(pcbsize)).ok()
}
pub unsafe fn GetUnknown<T: ::windows::core::Interface>(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn SetItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value)).ok()
}
pub unsafe fn DeleteItem(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey)).ok()
}
pub unsafe fn DeleteAllItems(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetUINT32(&self, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetUINT64(&self, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetDouble(&self, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(fvalue)).ok()
}
pub unsafe fn SetGUID(&self, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(guidvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetString<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, guidkey: *const ::windows::core::GUID, wszvalue: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), wszvalue.into_param().abi()).ok()
}
pub unsafe fn SetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize)).ok()
}
pub unsafe fn SetUnknown<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guidkey: *const ::windows::core::GUID, punknown: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), punknown.into_param().abi()).ok()
}
pub unsafe fn LockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn UnlockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(unindex), ::core::mem::transmute(pguidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn CopyAllItems<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, pdest: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), pdest.into_param().abi()).ok()
}
pub unsafe fn GetSchemaType(&self) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
pub unsafe fn GetConfigurationData(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetOriginatorID(&self) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFOutputSchema {
type Vtable = IMFOutputSchema_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7be0fc5b_abd9_44fb_a5c8_f50136e71599);
}
impl ::core::convert::From<IMFOutputSchema> for ::windows::core::IUnknown {
fn from(value: IMFOutputSchema) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFOutputSchema> for ::windows::core::IUnknown {
fn from(value: &IMFOutputSchema) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFOutputSchema {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFOutputSchema {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFOutputSchema> for IMFAttributes {
fn from(value: IMFOutputSchema) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFOutputSchema> for IMFAttributes {
fn from(value: &IMFOutputSchema) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for IMFOutputSchema {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for &IMFOutputSchema {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFOutputSchema_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ptype: *mut MF_ATTRIBUTE_TYPE) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptheirs: ::windows::core::RawPtr, matchtype: MF_ATTRIBUTES_MATCH_TYPE, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pfvalue: *mut f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pguidvalue: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, wszvalue: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punknown: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcitems: *mut u32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdest: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pguidschematype: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwval: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pguidoriginatorid: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFOutputTrustAuthority(pub ::windows::core::IUnknown);
impl IMFOutputTrustAuthority {
pub unsafe fn GetAction(&self) -> ::windows::core::Result<MFPOLICYMANAGER_ACTION> {
let mut result__: <MFPOLICYMANAGER_ACTION as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MFPOLICYMANAGER_ACTION>(result__)
}
pub unsafe fn SetPolicy(&self, pppolicy: *const ::core::option::Option<IMFOutputPolicy>, npolicy: u32, ppbticket: *mut *mut u8, pcbticket: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pppolicy), ::core::mem::transmute(npolicy), ::core::mem::transmute(ppbticket), ::core::mem::transmute(pcbticket)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFOutputTrustAuthority {
type Vtable = IMFOutputTrustAuthority_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd19f8e94_b126_4446_890c_5dcb7ad71453);
}
impl ::core::convert::From<IMFOutputTrustAuthority> for ::windows::core::IUnknown {
fn from(value: IMFOutputTrustAuthority) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFOutputTrustAuthority> for ::windows::core::IUnknown {
fn from(value: &IMFOutputTrustAuthority) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFOutputTrustAuthority {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFOutputTrustAuthority {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFOutputTrustAuthority_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, paction: *mut MFPOLICYMANAGER_ACTION) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pppolicy: *const ::windows::core::RawPtr, npolicy: u32, ppbticket: *mut *mut u8, pcbticket: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFPMPClient(pub ::windows::core::IUnknown);
impl IMFPMPClient {
pub unsafe fn SetPMPHost<'a, Param0: ::windows::core::IntoParam<'a, IMFPMPHost>>(&self, ppmphost: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ppmphost.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFPMPClient {
type Vtable = IMFPMPClient_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6c4e655d_ead8_4421_b6b9_54dcdbbdf820);
}
impl ::core::convert::From<IMFPMPClient> for ::windows::core::IUnknown {
fn from(value: IMFPMPClient) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFPMPClient> for ::windows::core::IUnknown {
fn from(value: &IMFPMPClient) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFPMPClient {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFPMPClient {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFPMPClient_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppmphost: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFPMPClientApp(pub ::windows::core::IUnknown);
impl IMFPMPClientApp {
pub unsafe fn SetPMPHost<'a, Param0: ::windows::core::IntoParam<'a, IMFPMPHostApp>>(&self, ppmphost: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ppmphost.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFPMPClientApp {
type Vtable = IMFPMPClientApp_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc004f646_be2c_48f3_93a2_a0983eba1108);
}
impl ::core::convert::From<IMFPMPClientApp> for ::windows::core::IUnknown {
fn from(value: IMFPMPClientApp) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFPMPClientApp> for ::windows::core::IUnknown {
fn from(value: &IMFPMPClientApp) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFPMPClientApp {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFPMPClientApp {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFPMPClientApp_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppmphost: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFPMPHost(pub ::windows::core::IUnknown);
impl IMFPMPHost {
pub unsafe fn LockProcess(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn UnlockProcess(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn CreateObjectByCLSID<'a, Param1: ::windows::core::IntoParam<'a, super::super::System::Com::IStream>, T: ::windows::core::Interface>(&self, clsid: *const ::windows::core::GUID, pstream: Param1) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(clsid), pstream.into_param().abi(), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
}
unsafe impl ::windows::core::Interface for IMFPMPHost {
type Vtable = IMFPMPHost_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf70ca1a9_fdc7_4782_b994_adffb1c98606);
}
impl ::core::convert::From<IMFPMPHost> for ::windows::core::IUnknown {
fn from(value: IMFPMPHost) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFPMPHost> for ::windows::core::IUnknown {
fn from(value: &IMFPMPHost) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFPMPHost {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFPMPHost {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFPMPHost_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, clsid: *const ::windows::core::GUID, pstream: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFPMPHostApp(pub ::windows::core::IUnknown);
impl IMFPMPHostApp {
pub unsafe fn LockProcess(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn UnlockProcess(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe fn ActivateClassById<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::System::Com::IStream>, T: ::windows::core::Interface>(&self, id: Param0, pstream: Param1) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), id.into_param().abi(), pstream.into_param().abi(), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
}
unsafe impl ::windows::core::Interface for IMFPMPHostApp {
type Vtable = IMFPMPHostApp_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x84d2054a_3aa1_4728_a3b0_440a418cf49c);
}
impl ::core::convert::From<IMFPMPHostApp> for ::windows::core::IUnknown {
fn from(value: IMFPMPHostApp) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFPMPHostApp> for ::windows::core::IUnknown {
fn from(value: &IMFPMPHostApp) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFPMPHostApp {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFPMPHostApp {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFPMPHostApp_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: super::super::Foundation::PWSTR, pstream: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFPMPServer(pub ::windows::core::IUnknown);
impl IMFPMPServer {
pub unsafe fn LockProcess(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn UnlockProcess(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn CreateObjectByCLSID<T: ::windows::core::Interface>(&self, clsid: *const ::windows::core::GUID) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(clsid), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
}
unsafe impl ::windows::core::Interface for IMFPMPServer {
type Vtable = IMFPMPServer_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x994e23af_1cc2_493c_b9fa_46f1cb040fa4);
}
impl ::core::convert::From<IMFPMPServer> for ::windows::core::IUnknown {
fn from(value: IMFPMPServer) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFPMPServer> for ::windows::core::IUnknown {
fn from(value: &IMFPMPServer) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFPMPServer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFPMPServer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFPMPServer_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, clsid: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFPMediaItem(pub ::windows::core::IUnknown);
impl IMFPMediaItem {
pub unsafe fn GetMediaPlayer(&self) -> ::windows::core::Result<IMFPMediaPlayer> {
let mut result__: <IMFPMediaPlayer as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFPMediaPlayer>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetURL(&self) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
pub unsafe fn GetObject(&self) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
pub unsafe fn GetUserData(&self) -> ::windows::core::Result<usize> {
let mut result__: <usize as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<usize>(result__)
}
pub unsafe fn SetUserData(&self, dwuserdata: usize) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwuserdata)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetStartStopPosition(&self, pguidstartpositiontype: *mut ::windows::core::GUID, pvstartvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pguidstoppositiontype: *mut ::windows::core::GUID, pvstopvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(pguidstartpositiontype), ::core::mem::transmute(pvstartvalue), ::core::mem::transmute(pguidstoppositiontype), ::core::mem::transmute(pvstopvalue)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn SetStartStopPosition(&self, pguidstartpositiontype: *const ::windows::core::GUID, pvstartvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pguidstoppositiontype: *const ::windows::core::GUID, pvstopvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(pguidstartpositiontype), ::core::mem::transmute(pvstartvalue), ::core::mem::transmute(pguidstoppositiontype), ::core::mem::transmute(pvstopvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn HasVideo(&self, pfhasvideo: *mut super::super::Foundation::BOOL, pfselected: *mut super::super::Foundation::BOOL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(pfhasvideo), ::core::mem::transmute(pfselected)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn HasAudio(&self, pfhasaudio: *mut super::super::Foundation::BOOL, pfselected: *mut super::super::Foundation::BOOL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(pfhasaudio), ::core::mem::transmute(pfselected)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsProtected(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetDuration(&self, guidpositiontype: *const ::windows::core::GUID) -> ::windows::core::Result<super::super::System::Com::StructuredStorage::PROPVARIANT> {
let mut result__: <super::super::System::Com::StructuredStorage::PROPVARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidpositiontype), &mut result__).from_abi::<super::super::System::Com::StructuredStorage::PROPVARIANT>(result__)
}
pub unsafe fn GetNumberOfStreams(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetStreamSelection(&self, dwstreamindex: u32) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetStreamSelection<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, dwstreamindex: u32, fenabled: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), fenabled.into_param().abi()).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetStreamAttribute(&self, dwstreamindex: u32, guidmfattribute: *const ::windows::core::GUID) -> ::windows::core::Result<super::super::System::Com::StructuredStorage::PROPVARIANT> {
let mut result__: <super::super::System::Com::StructuredStorage::PROPVARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(guidmfattribute), &mut result__).from_abi::<super::super::System::Com::StructuredStorage::PROPVARIANT>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetPresentationAttribute(&self, guidmfattribute: *const ::windows::core::GUID) -> ::windows::core::Result<super::super::System::Com::StructuredStorage::PROPVARIANT> {
let mut result__: <super::super::System::Com::StructuredStorage::PROPVARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidmfattribute), &mut result__).from_abi::<super::super::System::Com::StructuredStorage::PROPVARIANT>(result__)
}
pub unsafe fn GetCharacteristics(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetStreamSink<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, dwstreamindex: u32, pmediasink: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), pmediasink.into_param().abi()).ok()
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
pub unsafe fn GetMetadata(&self) -> ::windows::core::Result<super::super::UI::Shell::PropertiesSystem::IPropertyStore> {
let mut result__: <super::super::UI::Shell::PropertiesSystem::IPropertyStore as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::UI::Shell::PropertiesSystem::IPropertyStore>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFPMediaItem {
type Vtable = IMFPMediaItem_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x90eb3e6b_ecbf_45cc_b1da_c6fe3ea70d57);
}
impl ::core::convert::From<IMFPMediaItem> for ::windows::core::IUnknown {
fn from(value: IMFPMediaItem) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFPMediaItem> for ::windows::core::IUnknown {
fn from(value: &IMFPMediaItem) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFPMediaItem {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFPMediaItem {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFPMediaItem_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppmediaplayer: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppwszurl: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppiunknown: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwuserdata: *mut usize) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwuserdata: usize) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pguidstartpositiontype: *mut ::windows::core::GUID, pvstartvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>, pguidstoppositiontype: *mut ::windows::core::GUID, pvstopvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pguidstartpositiontype: *const ::windows::core::GUID, pvstartvalue: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>, pguidstoppositiontype: *const ::windows::core::GUID, pvstopvalue: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfhasvideo: *mut super::super::Foundation::BOOL, pfselected: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfhasaudio: *mut super::super::Foundation::BOOL, pfselected: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfprotected: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidpositiontype: *const ::windows::core::GUID, pvdurationvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwstreamcount: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, pfenabled: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, fenabled: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, guidmfattribute: *const ::windows::core::GUID, pvvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidmfattribute: *const ::windows::core::GUID, pvvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcharacteristics: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, pmediasink: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppmetadatastore: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFPMediaPlayer(pub ::windows::core::IUnknown);
impl IMFPMediaPlayer {
pub unsafe fn Play(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Pause(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Stop(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn FrameStep(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn SetPosition(&self, guidpositiontype: *const ::windows::core::GUID, pvpositionvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidpositiontype), ::core::mem::transmute(pvpositionvalue)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetPosition(&self, guidpositiontype: *const ::windows::core::GUID) -> ::windows::core::Result<super::super::System::Com::StructuredStorage::PROPVARIANT> {
let mut result__: <super::super::System::Com::StructuredStorage::PROPVARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidpositiontype), &mut result__).from_abi::<super::super::System::Com::StructuredStorage::PROPVARIANT>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetDuration(&self, guidpositiontype: *const ::windows::core::GUID) -> ::windows::core::Result<super::super::System::Com::StructuredStorage::PROPVARIANT> {
let mut result__: <super::super::System::Com::StructuredStorage::PROPVARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidpositiontype), &mut result__).from_abi::<super::super::System::Com::StructuredStorage::PROPVARIANT>(result__)
}
pub unsafe fn SetRate(&self, flrate: f32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(flrate)).ok()
}
pub unsafe fn GetRate(&self) -> ::windows::core::Result<f32> {
let mut result__: <f32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<f32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSupportedRates<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, fforwarddirection: Param0, pflslowestrate: *mut f32, pflfastestrate: *mut f32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), fforwarddirection.into_param().abi(), ::core::mem::transmute(pflslowestrate), ::core::mem::transmute(pflfastestrate)).ok()
}
pub unsafe fn GetState(&self) -> ::windows::core::Result<MFP_MEDIAPLAYER_STATE> {
let mut result__: <MFP_MEDIAPLAYER_STATE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MFP_MEDIAPLAYER_STATE>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateMediaItemFromURL<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, pwszurl: Param0, fsync: Param1, dwuserdata: usize) -> ::windows::core::Result<IMFPMediaItem> {
let mut result__: <IMFPMediaItem as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), pwszurl.into_param().abi(), fsync.into_param().abi(), ::core::mem::transmute(dwuserdata), &mut result__).from_abi::<IMFPMediaItem>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateMediaItemFromObject<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, piunknownobj: Param0, fsync: Param1, dwuserdata: usize) -> ::windows::core::Result<IMFPMediaItem> {
let mut result__: <IMFPMediaItem as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), piunknownobj.into_param().abi(), fsync.into_param().abi(), ::core::mem::transmute(dwuserdata), &mut result__).from_abi::<IMFPMediaItem>(result__)
}
pub unsafe fn SetMediaItem<'a, Param0: ::windows::core::IntoParam<'a, IMFPMediaItem>>(&self, pimfpmediaitem: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), pimfpmediaitem.into_param().abi()).ok()
}
pub unsafe fn ClearMediaItem(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetMediaItem(&self) -> ::windows::core::Result<IMFPMediaItem> {
let mut result__: <IMFPMediaItem as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFPMediaItem>(result__)
}
pub unsafe fn GetVolume(&self) -> ::windows::core::Result<f32> {
let mut result__: <f32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), &mut result__).from_abi::<f32>(result__)
}
pub unsafe fn SetVolume(&self, flvolume: f32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(flvolume)).ok()
}
pub unsafe fn GetBalance(&self) -> ::windows::core::Result<f32> {
let mut result__: <f32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), &mut result__).from_abi::<f32>(result__)
}
pub unsafe fn SetBalance(&self, flbalance: f32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(flbalance)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetMute(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetMute<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, fmute: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), fmute.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNativeVideoSize(&self, pszvideo: *mut super::super::Foundation::SIZE, pszarvideo: *mut super::super::Foundation::SIZE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(pszvideo), ::core::mem::transmute(pszarvideo)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetIdealVideoSize(&self, pszmin: *mut super::super::Foundation::SIZE, pszmax: *mut super::super::Foundation::SIZE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(pszmin), ::core::mem::transmute(pszmax)).ok()
}
pub unsafe fn SetVideoSourceRect(&self, pnrcsource: *const MFVideoNormalizedRect) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(pnrcsource)).ok()
}
pub unsafe fn GetVideoSourceRect(&self) -> ::windows::core::Result<MFVideoNormalizedRect> {
let mut result__: <MFVideoNormalizedRect as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MFVideoNormalizedRect>(result__)
}
pub unsafe fn SetAspectRatioMode(&self, dwaspectratiomode: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwaspectratiomode)).ok()
}
pub unsafe fn GetAspectRatioMode(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetVideoWindow(&self) -> ::windows::core::Result<super::super::Foundation::HWND> {
let mut result__: <super::super::Foundation::HWND as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::HWND>(result__)
}
pub unsafe fn UpdateVideo(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetBorderColor(&self, clr: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), ::core::mem::transmute(clr)).ok()
}
pub unsafe fn GetBorderColor(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn InsertEffect<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, peffect: Param0, foptional: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), peffect.into_param().abi(), foptional.into_param().abi()).ok()
}
pub unsafe fn RemoveEffect<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, peffect: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), peffect.into_param().abi()).ok()
}
pub unsafe fn RemoveAllEffects(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Shutdown(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFPMediaPlayer {
type Vtable = IMFPMediaPlayer_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa714590a_58af_430a_85bf_44f5ec838d85);
}
impl ::core::convert::From<IMFPMediaPlayer> for ::windows::core::IUnknown {
fn from(value: IMFPMediaPlayer) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFPMediaPlayer> for ::windows::core::IUnknown {
fn from(value: &IMFPMediaPlayer) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFPMediaPlayer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFPMediaPlayer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFPMediaPlayer_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidpositiontype: *const ::windows::core::GUID, pvpositionvalue: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidpositiontype: *const ::windows::core::GUID, pvpositionvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidpositiontype: *const ::windows::core::GUID, pvdurationvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flrate: f32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pflrate: *mut f32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, fforwarddirection: super::super::Foundation::BOOL, pflslowestrate: *mut f32, pflfastestrate: *mut f32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pestate: *mut MFP_MEDIAPLAYER_STATE) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pwszurl: super::super::Foundation::PWSTR, fsync: super::super::Foundation::BOOL, dwuserdata: usize, ppmediaitem: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, piunknownobj: ::windows::core::RawPtr, fsync: super::super::Foundation::BOOL, dwuserdata: usize, ppmediaitem: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pimfpmediaitem: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppimfpmediaitem: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pflvolume: *mut f32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flvolume: f32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pflbalance: *mut f32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flbalance: f32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfmute: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, fmute: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvideo: *mut super::super::Foundation::SIZE, pszarvideo: *mut super::super::Foundation::SIZE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszmin: *mut super::super::Foundation::SIZE, pszmax: *mut super::super::Foundation::SIZE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pnrcsource: *const MFVideoNormalizedRect) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pnrcsource: *mut MFVideoNormalizedRect) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwaspectratiomode: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwaspectratiomode: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, phwndvideo: *mut super::super::Foundation::HWND) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, clr: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pclr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, peffect: ::windows::core::RawPtr, foptional: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, peffect: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFPMediaPlayerCallback(pub ::windows::core::IUnknown);
impl IMFPMediaPlayerCallback {
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
pub unsafe fn OnMediaPlayerEvent(&self, peventheader: *const MFP_EVENT_HEADER) {
::core::mem::transmute((::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(peventheader)))
}
}
unsafe impl ::windows::core::Interface for IMFPMediaPlayerCallback {
type Vtable = IMFPMediaPlayerCallback_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x766c8ffb_5fdb_4fea_a28d_b912996f51bd);
}
impl ::core::convert::From<IMFPMediaPlayerCallback> for ::windows::core::IUnknown {
fn from(value: IMFPMediaPlayerCallback) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFPMediaPlayerCallback> for ::windows::core::IUnknown {
fn from(value: &IMFPMediaPlayerCallback) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFPMediaPlayerCallback {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFPMediaPlayerCallback {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFPMediaPlayerCallback_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, peventheader: *const ::core::mem::ManuallyDrop<MFP_EVENT_HEADER>),
#[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFPluginControl(pub ::windows::core::IUnknown);
impl IMFPluginControl {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPreferredClsid<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, plugintype: u32, selector: Param1) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(plugintype), selector.into_param().abi(), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPreferredClsidByIndex(&self, plugintype: u32, index: u32, selector: *mut super::super::Foundation::PWSTR, clsid: *mut ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(plugintype), ::core::mem::transmute(index), ::core::mem::transmute(selector), ::core::mem::transmute(clsid)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetPreferredClsid<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, plugintype: u32, selector: Param1, clsid: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(plugintype), selector.into_param().abi(), ::core::mem::transmute(clsid)).ok()
}
pub unsafe fn IsDisabled(&self, plugintype: u32, clsid: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(plugintype), ::core::mem::transmute(clsid)).ok()
}
pub unsafe fn GetDisabledByIndex(&self, plugintype: u32, index: u32) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(plugintype), ::core::mem::transmute(index), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetDisabled<'a, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, plugintype: u32, clsid: *const ::windows::core::GUID, disabled: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(plugintype), ::core::mem::transmute(clsid), disabled.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFPluginControl {
type Vtable = IMFPluginControl_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5c6c44bf_1db6_435b_9249_e8cd10fdec96);
}
impl ::core::convert::From<IMFPluginControl> for ::windows::core::IUnknown {
fn from(value: IMFPluginControl) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFPluginControl> for ::windows::core::IUnknown {
fn from(value: &IMFPluginControl) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFPluginControl {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFPluginControl {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFPluginControl_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, plugintype: u32, selector: super::super::Foundation::PWSTR, clsid: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, plugintype: u32, index: u32, selector: *mut super::super::Foundation::PWSTR, clsid: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, plugintype: u32, selector: super::super::Foundation::PWSTR, clsid: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, plugintype: u32, clsid: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, plugintype: u32, index: u32, clsid: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, plugintype: u32, clsid: *const ::windows::core::GUID, disabled: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFPluginControl2(pub ::windows::core::IUnknown);
impl IMFPluginControl2 {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPreferredClsid<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, plugintype: u32, selector: Param1) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(plugintype), selector.into_param().abi(), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPreferredClsidByIndex(&self, plugintype: u32, index: u32, selector: *mut super::super::Foundation::PWSTR, clsid: *mut ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(plugintype), ::core::mem::transmute(index), ::core::mem::transmute(selector), ::core::mem::transmute(clsid)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetPreferredClsid<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, plugintype: u32, selector: Param1, clsid: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(plugintype), selector.into_param().abi(), ::core::mem::transmute(clsid)).ok()
}
pub unsafe fn IsDisabled(&self, plugintype: u32, clsid: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(plugintype), ::core::mem::transmute(clsid)).ok()
}
pub unsafe fn GetDisabledByIndex(&self, plugintype: u32, index: u32) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(plugintype), ::core::mem::transmute(index), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetDisabled<'a, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, plugintype: u32, clsid: *const ::windows::core::GUID, disabled: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(plugintype), ::core::mem::transmute(clsid), disabled.into_param().abi()).ok()
}
pub unsafe fn SetPolicy(&self, policy: MF_PLUGIN_CONTROL_POLICY) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(policy)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFPluginControl2 {
type Vtable = IMFPluginControl2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc6982083_3ddc_45cb_af5e_0f7a8ce4de77);
}
impl ::core::convert::From<IMFPluginControl2> for ::windows::core::IUnknown {
fn from(value: IMFPluginControl2) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFPluginControl2> for ::windows::core::IUnknown {
fn from(value: &IMFPluginControl2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFPluginControl2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFPluginControl2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFPluginControl2> for IMFPluginControl {
fn from(value: IMFPluginControl2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFPluginControl2> for IMFPluginControl {
fn from(value: &IMFPluginControl2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFPluginControl> for IMFPluginControl2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFPluginControl> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFPluginControl> for &IMFPluginControl2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFPluginControl> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFPluginControl2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, plugintype: u32, selector: super::super::Foundation::PWSTR, clsid: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, plugintype: u32, index: u32, selector: *mut super::super::Foundation::PWSTR, clsid: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, plugintype: u32, selector: super::super::Foundation::PWSTR, clsid: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, plugintype: u32, clsid: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, plugintype: u32, index: u32, clsid: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, plugintype: u32, clsid: *const ::windows::core::GUID, disabled: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, policy: MF_PLUGIN_CONTROL_POLICY) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFPresentationClock(pub ::windows::core::IUnknown);
impl IMFPresentationClock {
pub unsafe fn GetClockCharacteristics(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCorrelatedTime(&self, dwreserved: u32, pllclocktime: *mut i64, phnssystemtime: *mut i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwreserved), ::core::mem::transmute(pllclocktime), ::core::mem::transmute(phnssystemtime)).ok()
}
pub unsafe fn GetContinuityKey(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetState(&self, dwreserved: u32) -> ::windows::core::Result<MFCLOCK_STATE> {
let mut result__: <MFCLOCK_STATE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwreserved), &mut result__).from_abi::<MFCLOCK_STATE>(result__)
}
pub unsafe fn GetProperties(&self) -> ::windows::core::Result<MFCLOCK_PROPERTIES> {
let mut result__: <MFCLOCK_PROPERTIES as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MFCLOCK_PROPERTIES>(result__)
}
pub unsafe fn SetTimeSource<'a, Param0: ::windows::core::IntoParam<'a, IMFPresentationTimeSource>>(&self, ptimesource: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ptimesource.into_param().abi()).ok()
}
pub unsafe fn GetTimeSource(&self) -> ::windows::core::Result<IMFPresentationTimeSource> {
let mut result__: <IMFPresentationTimeSource as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFPresentationTimeSource>(result__)
}
pub unsafe fn GetTime(&self) -> ::windows::core::Result<i64> {
let mut result__: <i64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i64>(result__)
}
pub unsafe fn AddClockStateSink<'a, Param0: ::windows::core::IntoParam<'a, IMFClockStateSink>>(&self, pstatesink: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), pstatesink.into_param().abi()).ok()
}
pub unsafe fn RemoveClockStateSink<'a, Param0: ::windows::core::IntoParam<'a, IMFClockStateSink>>(&self, pstatesink: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), pstatesink.into_param().abi()).ok()
}
pub unsafe fn Start(&self, llclockstartoffset: i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(llclockstartoffset)).ok()
}
pub unsafe fn Stop(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Pause(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFPresentationClock {
type Vtable = IMFPresentationClock_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x868ce85c_8ea9_4f55_ab82_b009a910a805);
}
impl ::core::convert::From<IMFPresentationClock> for ::windows::core::IUnknown {
fn from(value: IMFPresentationClock) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFPresentationClock> for ::windows::core::IUnknown {
fn from(value: &IMFPresentationClock) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFPresentationClock {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFPresentationClock {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFPresentationClock> for IMFClock {
fn from(value: IMFPresentationClock) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFPresentationClock> for IMFClock {
fn from(value: &IMFPresentationClock) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFClock> for IMFPresentationClock {
fn into_param(self) -> ::windows::core::Param<'a, IMFClock> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFClock> for &IMFPresentationClock {
fn into_param(self) -> ::windows::core::Param<'a, IMFClock> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFPresentationClock_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcharacteristics: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwreserved: u32, pllclocktime: *mut i64, phnssystemtime: *mut i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcontinuitykey: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwreserved: u32, peclockstate: *mut MFCLOCK_STATE) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pclockproperties: *mut MFCLOCK_PROPERTIES) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptimesource: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pptimesource: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, phnsclocktime: *mut i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstatesink: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstatesink: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, llclockstartoffset: i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFPresentationDescriptor(pub ::windows::core::IUnknown);
impl IMFPresentationDescriptor {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItem(&self, guidkey: *const ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn GetItemType(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<MF_ATTRIBUTE_TYPE> {
let mut result__: <MF_ATTRIBUTE_TYPE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<MF_ATTRIBUTE_TYPE>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn CompareItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Compare<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, ptheirs: Param0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ptheirs.into_param().abi(), ::core::mem::transmute(matchtype), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn GetUINT32(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetUINT64(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetDouble(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<f64> {
let mut result__: <f64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<f64>(result__)
}
pub unsafe fn GetGUID(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
pub unsafe fn GetStringLength(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetString(&self, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pwszvalue), ::core::mem::transmute(cchbufsize), ::core::mem::transmute(pcchlength)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetAllocatedString(&self, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppwszvalue), ::core::mem::transmute(pcchlength)).ok()
}
pub unsafe fn GetBlobSize(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize), ::core::mem::transmute(pcbblobsize)).ok()
}
pub unsafe fn GetAllocatedBlob(&self, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppbuf), ::core::mem::transmute(pcbsize)).ok()
}
pub unsafe fn GetUnknown<T: ::windows::core::Interface>(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn SetItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value)).ok()
}
pub unsafe fn DeleteItem(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey)).ok()
}
pub unsafe fn DeleteAllItems(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetUINT32(&self, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetUINT64(&self, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetDouble(&self, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(fvalue)).ok()
}
pub unsafe fn SetGUID(&self, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(guidvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetString<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, guidkey: *const ::windows::core::GUID, wszvalue: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), wszvalue.into_param().abi()).ok()
}
pub unsafe fn SetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize)).ok()
}
pub unsafe fn SetUnknown<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guidkey: *const ::windows::core::GUID, punknown: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), punknown.into_param().abi()).ok()
}
pub unsafe fn LockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn UnlockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(unindex), ::core::mem::transmute(pguidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn CopyAllItems<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, pdest: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), pdest.into_param().abi()).ok()
}
pub unsafe fn GetStreamDescriptorCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetStreamDescriptorByIndex(&self, dwindex: u32, pfselected: *mut super::super::Foundation::BOOL, ppdescriptor: *mut ::core::option::Option<IMFStreamDescriptor>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwindex), ::core::mem::transmute(pfselected), ::core::mem::transmute(ppdescriptor)).ok()
}
pub unsafe fn SelectStream(&self, dwdescriptorindex: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwdescriptorindex)).ok()
}
pub unsafe fn DeselectStream(&self, dwdescriptorindex: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwdescriptorindex)).ok()
}
pub unsafe fn Clone(&self) -> ::windows::core::Result<IMFPresentationDescriptor> {
let mut result__: <IMFPresentationDescriptor as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFPresentationDescriptor>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFPresentationDescriptor {
type Vtable = IMFPresentationDescriptor_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x03cb2711_24d7_4db6_a17f_f3a7a479a536);
}
impl ::core::convert::From<IMFPresentationDescriptor> for ::windows::core::IUnknown {
fn from(value: IMFPresentationDescriptor) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFPresentationDescriptor> for ::windows::core::IUnknown {
fn from(value: &IMFPresentationDescriptor) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFPresentationDescriptor {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFPresentationDescriptor {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFPresentationDescriptor> for IMFAttributes {
fn from(value: IMFPresentationDescriptor) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFPresentationDescriptor> for IMFAttributes {
fn from(value: &IMFPresentationDescriptor) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for IMFPresentationDescriptor {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for &IMFPresentationDescriptor {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFPresentationDescriptor_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ptype: *mut MF_ATTRIBUTE_TYPE) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptheirs: ::windows::core::RawPtr, matchtype: MF_ATTRIBUTES_MATCH_TYPE, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pfvalue: *mut f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pguidvalue: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, wszvalue: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punknown: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcitems: *mut u32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdest: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwdescriptorcount: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwindex: u32, pfselected: *mut super::super::Foundation::BOOL, ppdescriptor: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwdescriptorindex: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwdescriptorindex: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pppresentationdescriptor: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFPresentationTimeSource(pub ::windows::core::IUnknown);
impl IMFPresentationTimeSource {
pub unsafe fn GetClockCharacteristics(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCorrelatedTime(&self, dwreserved: u32, pllclocktime: *mut i64, phnssystemtime: *mut i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwreserved), ::core::mem::transmute(pllclocktime), ::core::mem::transmute(phnssystemtime)).ok()
}
pub unsafe fn GetContinuityKey(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetState(&self, dwreserved: u32) -> ::windows::core::Result<MFCLOCK_STATE> {
let mut result__: <MFCLOCK_STATE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwreserved), &mut result__).from_abi::<MFCLOCK_STATE>(result__)
}
pub unsafe fn GetProperties(&self) -> ::windows::core::Result<MFCLOCK_PROPERTIES> {
let mut result__: <MFCLOCK_PROPERTIES as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MFCLOCK_PROPERTIES>(result__)
}
pub unsafe fn GetUnderlyingClock(&self) -> ::windows::core::Result<IMFClock> {
let mut result__: <IMFClock as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFClock>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFPresentationTimeSource {
type Vtable = IMFPresentationTimeSource_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7ff12cce_f76f_41c2_863b_1666c8e5e139);
}
impl ::core::convert::From<IMFPresentationTimeSource> for ::windows::core::IUnknown {
fn from(value: IMFPresentationTimeSource) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFPresentationTimeSource> for ::windows::core::IUnknown {
fn from(value: &IMFPresentationTimeSource) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFPresentationTimeSource {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFPresentationTimeSource {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFPresentationTimeSource> for IMFClock {
fn from(value: IMFPresentationTimeSource) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFPresentationTimeSource> for IMFClock {
fn from(value: &IMFPresentationTimeSource) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFClock> for IMFPresentationTimeSource {
fn into_param(self) -> ::windows::core::Param<'a, IMFClock> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFClock> for &IMFPresentationTimeSource {
fn into_param(self) -> ::windows::core::Param<'a, IMFClock> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFPresentationTimeSource_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcharacteristics: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwreserved: u32, pllclocktime: *mut i64, phnssystemtime: *mut i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcontinuitykey: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwreserved: u32, peclockstate: *mut MFCLOCK_STATE) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pclockproperties: *mut MFCLOCK_PROPERTIES) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppclock: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFProtectedEnvironmentAccess(pub ::windows::core::IUnknown);
impl IMFProtectedEnvironmentAccess {
pub unsafe fn Call(&self, inputlength: u32, input: *const u8, outputlength: u32) -> ::windows::core::Result<u8> {
let mut result__: <u8 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(inputlength), ::core::mem::transmute(input), ::core::mem::transmute(outputlength), &mut result__).from_abi::<u8>(result__)
}
pub unsafe fn ReadGRL(&self, outputlength: *mut u32, output: *mut *mut u8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputlength), ::core::mem::transmute(output)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFProtectedEnvironmentAccess {
type Vtable = IMFProtectedEnvironmentAccess_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xef5dc845_f0d9_4ec9_b00c_cb5183d38434);
}
impl ::core::convert::From<IMFProtectedEnvironmentAccess> for ::windows::core::IUnknown {
fn from(value: IMFProtectedEnvironmentAccess) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFProtectedEnvironmentAccess> for ::windows::core::IUnknown {
fn from(value: &IMFProtectedEnvironmentAccess) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFProtectedEnvironmentAccess {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFProtectedEnvironmentAccess {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFProtectedEnvironmentAccess_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, inputlength: u32, input: *const u8, outputlength: u32, output: *mut u8) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputlength: *mut u32, output: *mut *mut u8) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFQualityAdvise(pub ::windows::core::IUnknown);
impl IMFQualityAdvise {
pub unsafe fn SetDropMode(&self, edropmode: MF_QUALITY_DROP_MODE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(edropmode)).ok()
}
pub unsafe fn SetQualityLevel(&self, equalitylevel: MF_QUALITY_LEVEL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(equalitylevel)).ok()
}
pub unsafe fn GetDropMode(&self) -> ::windows::core::Result<MF_QUALITY_DROP_MODE> {
let mut result__: <MF_QUALITY_DROP_MODE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MF_QUALITY_DROP_MODE>(result__)
}
pub unsafe fn GetQualityLevel(&self) -> ::windows::core::Result<MF_QUALITY_LEVEL> {
let mut result__: <MF_QUALITY_LEVEL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MF_QUALITY_LEVEL>(result__)
}
pub unsafe fn DropTime(&self, hnsamounttodrop: i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(hnsamounttodrop)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFQualityAdvise {
type Vtable = IMFQualityAdvise_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xec15e2e9_e36b_4f7c_8758_77d452ef4ce7);
}
impl ::core::convert::From<IMFQualityAdvise> for ::windows::core::IUnknown {
fn from(value: IMFQualityAdvise) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFQualityAdvise> for ::windows::core::IUnknown {
fn from(value: &IMFQualityAdvise) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFQualityAdvise {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFQualityAdvise {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFQualityAdvise_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, edropmode: MF_QUALITY_DROP_MODE) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, equalitylevel: MF_QUALITY_LEVEL) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pedropmode: *mut MF_QUALITY_DROP_MODE) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pequalitylevel: *mut MF_QUALITY_LEVEL) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hnsamounttodrop: i64) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFQualityAdvise2(pub ::windows::core::IUnknown);
impl IMFQualityAdvise2 {
pub unsafe fn SetDropMode(&self, edropmode: MF_QUALITY_DROP_MODE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(edropmode)).ok()
}
pub unsafe fn SetQualityLevel(&self, equalitylevel: MF_QUALITY_LEVEL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(equalitylevel)).ok()
}
pub unsafe fn GetDropMode(&self) -> ::windows::core::Result<MF_QUALITY_DROP_MODE> {
let mut result__: <MF_QUALITY_DROP_MODE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MF_QUALITY_DROP_MODE>(result__)
}
pub unsafe fn GetQualityLevel(&self) -> ::windows::core::Result<MF_QUALITY_LEVEL> {
let mut result__: <MF_QUALITY_LEVEL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MF_QUALITY_LEVEL>(result__)
}
pub unsafe fn DropTime(&self, hnsamounttodrop: i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(hnsamounttodrop)).ok()
}
pub unsafe fn NotifyQualityEvent<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaEvent>>(&self, pevent: Param0) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), pevent.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFQualityAdvise2 {
type Vtable = IMFQualityAdvise2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf3706f0d_8ea2_4886_8000_7155e9ec2eae);
}
impl ::core::convert::From<IMFQualityAdvise2> for ::windows::core::IUnknown {
fn from(value: IMFQualityAdvise2) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFQualityAdvise2> for ::windows::core::IUnknown {
fn from(value: &IMFQualityAdvise2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFQualityAdvise2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFQualityAdvise2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFQualityAdvise2> for IMFQualityAdvise {
fn from(value: IMFQualityAdvise2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFQualityAdvise2> for IMFQualityAdvise {
fn from(value: &IMFQualityAdvise2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFQualityAdvise> for IMFQualityAdvise2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFQualityAdvise> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFQualityAdvise> for &IMFQualityAdvise2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFQualityAdvise> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFQualityAdvise2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, edropmode: MF_QUALITY_DROP_MODE) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, equalitylevel: MF_QUALITY_LEVEL) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pedropmode: *mut MF_QUALITY_DROP_MODE) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pequalitylevel: *mut MF_QUALITY_LEVEL) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hnsamounttodrop: i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pevent: ::windows::core::RawPtr, pdwflags: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFQualityAdviseLimits(pub ::windows::core::IUnknown);
impl IMFQualityAdviseLimits {
pub unsafe fn GetMaximumDropMode(&self) -> ::windows::core::Result<MF_QUALITY_DROP_MODE> {
let mut result__: <MF_QUALITY_DROP_MODE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MF_QUALITY_DROP_MODE>(result__)
}
pub unsafe fn GetMinimumQualityLevel(&self) -> ::windows::core::Result<MF_QUALITY_LEVEL> {
let mut result__: <MF_QUALITY_LEVEL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MF_QUALITY_LEVEL>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFQualityAdviseLimits {
type Vtable = IMFQualityAdviseLimits_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdfcd8e4d_30b5_4567_acaa_8eb5b7853dc9);
}
impl ::core::convert::From<IMFQualityAdviseLimits> for ::windows::core::IUnknown {
fn from(value: IMFQualityAdviseLimits) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFQualityAdviseLimits> for ::windows::core::IUnknown {
fn from(value: &IMFQualityAdviseLimits) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFQualityAdviseLimits {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFQualityAdviseLimits {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFQualityAdviseLimits_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pedropmode: *mut MF_QUALITY_DROP_MODE) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pequalitylevel: *mut MF_QUALITY_LEVEL) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFQualityManager(pub ::windows::core::IUnknown);
impl IMFQualityManager {
pub unsafe fn NotifyTopology<'a, Param0: ::windows::core::IntoParam<'a, IMFTopology>>(&self, ptopology: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ptopology.into_param().abi()).ok()
}
pub unsafe fn NotifyPresentationClock<'a, Param0: ::windows::core::IntoParam<'a, IMFPresentationClock>>(&self, pclock: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pclock.into_param().abi()).ok()
}
pub unsafe fn NotifyProcessInput<'a, Param0: ::windows::core::IntoParam<'a, IMFTopologyNode>, Param2: ::windows::core::IntoParam<'a, IMFSample>>(&self, pnode: Param0, linputindex: i32, psample: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pnode.into_param().abi(), ::core::mem::transmute(linputindex), psample.into_param().abi()).ok()
}
pub unsafe fn NotifyProcessOutput<'a, Param0: ::windows::core::IntoParam<'a, IMFTopologyNode>, Param2: ::windows::core::IntoParam<'a, IMFSample>>(&self, pnode: Param0, loutputindex: i32, psample: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), pnode.into_param().abi(), ::core::mem::transmute(loutputindex), psample.into_param().abi()).ok()
}
pub unsafe fn NotifyQualityEvent<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>, Param1: ::windows::core::IntoParam<'a, IMFMediaEvent>>(&self, pobject: Param0, pevent: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), pobject.into_param().abi(), pevent.into_param().abi()).ok()
}
pub unsafe fn Shutdown(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFQualityManager {
type Vtable = IMFQualityManager_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8d009d86_5b9f_4115_b1fc_9f80d52ab8ab);
}
impl ::core::convert::From<IMFQualityManager> for ::windows::core::IUnknown {
fn from(value: IMFQualityManager) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFQualityManager> for ::windows::core::IUnknown {
fn from(value: &IMFQualityManager) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFQualityManager {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFQualityManager {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFQualityManager_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptopology: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pclock: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pnode: ::windows::core::RawPtr, linputindex: i32, psample: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pnode: ::windows::core::RawPtr, loutputindex: i32, psample: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pobject: ::windows::core::RawPtr, pevent: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFRateControl(pub ::windows::core::IUnknown);
impl IMFRateControl {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetRate<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, fthin: Param0, flrate: f32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), fthin.into_param().abi(), ::core::mem::transmute(flrate)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRate(&self, pfthin: *mut super::super::Foundation::BOOL, pflrate: *mut f32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pfthin), ::core::mem::transmute(pflrate)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFRateControl {
type Vtable = IMFRateControl_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x88ddcd21_03c3_4275_91ed_55ee3929328f);
}
impl ::core::convert::From<IMFRateControl> for ::windows::core::IUnknown {
fn from(value: IMFRateControl) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFRateControl> for ::windows::core::IUnknown {
fn from(value: &IMFRateControl) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFRateControl {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFRateControl {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFRateControl_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, fthin: super::super::Foundation::BOOL, flrate: f32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfthin: *mut super::super::Foundation::BOOL, pflrate: *mut f32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFRateSupport(pub ::windows::core::IUnknown);
impl IMFRateSupport {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSlowestRate<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, edirection: MFRATE_DIRECTION, fthin: Param1) -> ::windows::core::Result<f32> {
let mut result__: <f32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(edirection), fthin.into_param().abi(), &mut result__).from_abi::<f32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetFastestRate<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, edirection: MFRATE_DIRECTION, fthin: Param1) -> ::windows::core::Result<f32> {
let mut result__: <f32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(edirection), fthin.into_param().abi(), &mut result__).from_abi::<f32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsRateSupported<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, fthin: Param0, flrate: f32, pflnearestsupportedrate: *mut f32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), fthin.into_param().abi(), ::core::mem::transmute(flrate), ::core::mem::transmute(pflnearestsupportedrate)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFRateSupport {
type Vtable = IMFRateSupport_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0a9ccdbc_d797_4563_9667_94ec5d79292d);
}
impl ::core::convert::From<IMFRateSupport> for ::windows::core::IUnknown {
fn from(value: IMFRateSupport) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFRateSupport> for ::windows::core::IUnknown {
fn from(value: &IMFRateSupport) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFRateSupport {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFRateSupport {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFRateSupport_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, edirection: MFRATE_DIRECTION, fthin: super::super::Foundation::BOOL, pflrate: *mut f32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, edirection: MFRATE_DIRECTION, fthin: super::super::Foundation::BOOL, pflrate: *mut f32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, fthin: super::super::Foundation::BOOL, flrate: f32, pflnearestsupportedrate: *mut f32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFReadWriteClassFactory(pub ::windows::core::IUnknown);
impl IMFReadWriteClassFactory {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateInstanceFromURL<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, clsid: *const ::windows::core::GUID, pwszurl: Param1, pattributes: Param2, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(clsid), pwszurl.into_param().abi(), pattributes.into_param().abi(), ::core::mem::transmute(riid), ::core::mem::transmute(ppvobject)).ok()
}
pub unsafe fn CreateInstanceFromObject<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>, Param2: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, clsid: *const ::windows::core::GUID, punkobject: Param1, pattributes: Param2, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(clsid), punkobject.into_param().abi(), pattributes.into_param().abi(), ::core::mem::transmute(riid), ::core::mem::transmute(ppvobject)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFReadWriteClassFactory {
type Vtable = IMFReadWriteClassFactory_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe7fe2e12_661c_40da_92f9_4f002ab67627);
}
impl ::core::convert::From<IMFReadWriteClassFactory> for ::windows::core::IUnknown {
fn from(value: IMFReadWriteClassFactory) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFReadWriteClassFactory> for ::windows::core::IUnknown {
fn from(value: &IMFReadWriteClassFactory) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFReadWriteClassFactory {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFReadWriteClassFactory {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFReadWriteClassFactory_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, clsid: *const ::windows::core::GUID, pwszurl: super::super::Foundation::PWSTR, pattributes: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, clsid: *const ::windows::core::GUID, punkobject: ::windows::core::RawPtr, pattributes: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFRealTimeClient(pub ::windows::core::IUnknown);
impl IMFRealTimeClient {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn RegisterThreads<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, dwtaskindex: u32, wszclass: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwtaskindex), wszclass.into_param().abi()).ok()
}
pub unsafe fn UnregisterThreads(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetWorkQueue(&self, dwworkqueueid: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwworkqueueid)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFRealTimeClient {
type Vtable = IMFRealTimeClient_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2347d60b_3fb5_480c_8803_8df3adcd3ef0);
}
impl ::core::convert::From<IMFRealTimeClient> for ::windows::core::IUnknown {
fn from(value: IMFRealTimeClient) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFRealTimeClient> for ::windows::core::IUnknown {
fn from(value: &IMFRealTimeClient) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFRealTimeClient {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFRealTimeClient {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFRealTimeClient_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwtaskindex: u32, wszclass: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwworkqueueid: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFRealTimeClientEx(pub ::windows::core::IUnknown);
impl IMFRealTimeClientEx {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn RegisterThreadsEx<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pdwtaskindex: *mut u32, wszclassname: Param1, lbasepriority: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdwtaskindex), wszclassname.into_param().abi(), ::core::mem::transmute(lbasepriority)).ok()
}
pub unsafe fn UnregisterThreads(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetWorkQueueEx(&self, dwmultithreadedworkqueueid: u32, lworkitembasepriority: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwmultithreadedworkqueueid), ::core::mem::transmute(lworkitembasepriority)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFRealTimeClientEx {
type Vtable = IMFRealTimeClientEx_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x03910848_ab16_4611_b100_17b88ae2f248);
}
impl ::core::convert::From<IMFRealTimeClientEx> for ::windows::core::IUnknown {
fn from(value: IMFRealTimeClientEx) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFRealTimeClientEx> for ::windows::core::IUnknown {
fn from(value: &IMFRealTimeClientEx) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFRealTimeClientEx {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFRealTimeClientEx {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFRealTimeClientEx_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwtaskindex: *mut u32, wszclassname: super::super::Foundation::PWSTR, lbasepriority: i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwmultithreadedworkqueueid: u32, lworkitembasepriority: i32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFRelativePanelReport(pub ::windows::core::IUnknown);
impl IMFRelativePanelReport {
pub unsafe fn GetRelativePanel(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFRelativePanelReport {
type Vtable = IMFRelativePanelReport_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf25362ea_2c0e_447f_81e2_755914cdc0c3);
}
impl ::core::convert::From<IMFRelativePanelReport> for ::windows::core::IUnknown {
fn from(value: IMFRelativePanelReport) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFRelativePanelReport> for ::windows::core::IUnknown {
fn from(value: &IMFRelativePanelReport) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFRelativePanelReport {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFRelativePanelReport {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFRelativePanelReport_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, panel: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFRelativePanelWatcher(pub ::windows::core::IUnknown);
impl IMFRelativePanelWatcher {
pub unsafe fn Shutdown(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetShutdownStatus(&self) -> ::windows::core::Result<MFSHUTDOWN_STATUS> {
let mut result__: <MFSHUTDOWN_STATUS as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MFSHUTDOWN_STATUS>(result__)
}
pub unsafe fn BeginGetReport<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pcallback: Param0, pstate: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pcallback.into_param().abi(), pstate.into_param().abi()).ok()
}
pub unsafe fn EndGetReport<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0) -> ::windows::core::Result<IMFRelativePanelReport> {
let mut result__: <IMFRelativePanelReport as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), presult.into_param().abi(), &mut result__).from_abi::<IMFRelativePanelReport>(result__)
}
pub unsafe fn GetReport(&self) -> ::windows::core::Result<IMFRelativePanelReport> {
let mut result__: <IMFRelativePanelReport as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFRelativePanelReport>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFRelativePanelWatcher {
type Vtable = IMFRelativePanelWatcher_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x421af7f6_573e_4ad0_8fda_2e57cedb18c6);
}
impl ::core::convert::From<IMFRelativePanelWatcher> for ::windows::core::IUnknown {
fn from(value: IMFRelativePanelWatcher) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFRelativePanelWatcher> for ::windows::core::IUnknown {
fn from(value: &IMFRelativePanelWatcher) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFRelativePanelWatcher {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFRelativePanelWatcher {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFRelativePanelWatcher> for IMFShutdown {
fn from(value: IMFRelativePanelWatcher) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFRelativePanelWatcher> for IMFShutdown {
fn from(value: &IMFRelativePanelWatcher) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFShutdown> for IMFRelativePanelWatcher {
fn into_param(self) -> ::windows::core::Param<'a, IMFShutdown> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFShutdown> for &IMFRelativePanelWatcher {
fn into_param(self) -> ::windows::core::Param<'a, IMFShutdown> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFRelativePanelWatcher_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstatus: *mut MFSHUTDOWN_STATUS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcallback: ::windows::core::RawPtr, pstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr, pprelativepanelreport: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pprelativepanelreport: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFRemoteAsyncCallback(pub ::windows::core::IUnknown);
impl IMFRemoteAsyncCallback {
pub unsafe fn Invoke<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, hr: ::windows::core::HRESULT, premoteresult: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(hr), premoteresult.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFRemoteAsyncCallback {
type Vtable = IMFRemoteAsyncCallback_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa27003d0_2354_4f2a_8d6a_ab7cff15437e);
}
impl ::core::convert::From<IMFRemoteAsyncCallback> for ::windows::core::IUnknown {
fn from(value: IMFRemoteAsyncCallback) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFRemoteAsyncCallback> for ::windows::core::IUnknown {
fn from(value: &IMFRemoteAsyncCallback) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFRemoteAsyncCallback {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFRemoteAsyncCallback {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFRemoteAsyncCallback_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hr: ::windows::core::HRESULT, premoteresult: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFRemoteDesktopPlugin(pub ::windows::core::IUnknown);
impl IMFRemoteDesktopPlugin {
pub unsafe fn UpdateTopology<'a, Param0: ::windows::core::IntoParam<'a, IMFTopology>>(&self, ptopology: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ptopology.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFRemoteDesktopPlugin {
type Vtable = IMFRemoteDesktopPlugin_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1cde6309_cae0_4940_907e_c1ec9c3d1d4a);
}
impl ::core::convert::From<IMFRemoteDesktopPlugin> for ::windows::core::IUnknown {
fn from(value: IMFRemoteDesktopPlugin) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFRemoteDesktopPlugin> for ::windows::core::IUnknown {
fn from(value: &IMFRemoteDesktopPlugin) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFRemoteDesktopPlugin {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFRemoteDesktopPlugin {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFRemoteDesktopPlugin_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptopology: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFRemoteProxy(pub ::windows::core::IUnknown);
impl IMFRemoteProxy {
pub unsafe fn GetRemoteObject(&self, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(riid), ::core::mem::transmute(ppv)).ok()
}
pub unsafe fn GetRemoteHost(&self, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(riid), ::core::mem::transmute(ppv)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFRemoteProxy {
type Vtable = IMFRemoteProxy_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x994e23ad_1cc2_493c_b9fa_46f1cb040fa4);
}
impl ::core::convert::From<IMFRemoteProxy> for ::windows::core::IUnknown {
fn from(value: IMFRemoteProxy) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFRemoteProxy> for ::windows::core::IUnknown {
fn from(value: &IMFRemoteProxy) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFRemoteProxy {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFRemoteProxy {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFRemoteProxy_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSAMIStyle(pub ::windows::core::IUnknown);
impl IMFSAMIStyle {
pub unsafe fn GetStyleCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetStyles(&self) -> ::windows::core::Result<super::super::System::Com::StructuredStorage::PROPVARIANT> {
let mut result__: <super::super::System::Com::StructuredStorage::PROPVARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::StructuredStorage::PROPVARIANT>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSelectedStyle<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pwszstyle: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pwszstyle.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSelectedStyle(&self) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFSAMIStyle {
type Vtable = IMFSAMIStyle_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa7e025dd_5303_4a62_89d6_e747e1efac73);
}
impl ::core::convert::From<IMFSAMIStyle> for ::windows::core::IUnknown {
fn from(value: IMFSAMIStyle) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSAMIStyle> for ::windows::core::IUnknown {
fn from(value: &IMFSAMIStyle) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSAMIStyle {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSAMIStyle {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSAMIStyle_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcount: *mut u32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppropvarstylearray: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pwszstyle: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppwszstyle: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSSLCertificateManager(pub ::windows::core::IUnknown);
impl IMFSSLCertificateManager {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetClientCertificate<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszurl: Param0, ppbdata: *mut *mut u8, pcbdata: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pszurl.into_param().abi(), ::core::mem::transmute(ppbdata), ::core::mem::transmute(pcbdata)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn BeginGetClientCertificate<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param2: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pszurl: Param0, pcallback: Param1, pstate: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pszurl.into_param().abi(), pcallback.into_param().abi(), pstate.into_param().abi()).ok()
}
pub unsafe fn EndGetClientCertificate<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0, ppbdata: *mut *mut u8, pcbdata: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), presult.into_param().abi(), ::core::mem::transmute(ppbdata), ::core::mem::transmute(pcbdata)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetCertificatePolicy<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszurl: Param0, pfoverrideautomaticcheck: *mut super::super::Foundation::BOOL, pfclientcertificateavailable: *mut super::super::Foundation::BOOL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), pszurl.into_param().abi(), ::core::mem::transmute(pfoverrideautomaticcheck), ::core::mem::transmute(pfclientcertificateavailable)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OnServerCertificate<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszurl: Param0, pbdata: *const u8, cbdata: u32) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), pszurl.into_param().abi(), ::core::mem::transmute(pbdata), ::core::mem::transmute(cbdata), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFSSLCertificateManager {
type Vtable = IMFSSLCertificateManager_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x61f7d887_1230_4a8b_aeba_8ad434d1a64d);
}
impl ::core::convert::From<IMFSSLCertificateManager> for ::windows::core::IUnknown {
fn from(value: IMFSSLCertificateManager) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSSLCertificateManager> for ::windows::core::IUnknown {
fn from(value: &IMFSSLCertificateManager) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSSLCertificateManager {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSSLCertificateManager {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSSLCertificateManager_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszurl: super::super::Foundation::PWSTR, ppbdata: *mut *mut u8, pcbdata: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszurl: super::super::Foundation::PWSTR, pcallback: ::windows::core::RawPtr, pstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr, ppbdata: *mut *mut u8, pcbdata: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszurl: super::super::Foundation::PWSTR, pfoverrideautomaticcheck: *mut super::super::Foundation::BOOL, pfclientcertificateavailable: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszurl: super::super::Foundation::PWSTR, pbdata: *const u8, cbdata: u32, pfisgood: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSample(pub ::windows::core::IUnknown);
impl IMFSample {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItem(&self, guidkey: *const ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn GetItemType(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<MF_ATTRIBUTE_TYPE> {
let mut result__: <MF_ATTRIBUTE_TYPE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<MF_ATTRIBUTE_TYPE>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn CompareItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Compare<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, ptheirs: Param0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ptheirs.into_param().abi(), ::core::mem::transmute(matchtype), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn GetUINT32(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetUINT64(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetDouble(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<f64> {
let mut result__: <f64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<f64>(result__)
}
pub unsafe fn GetGUID(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
pub unsafe fn GetStringLength(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetString(&self, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pwszvalue), ::core::mem::transmute(cchbufsize), ::core::mem::transmute(pcchlength)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetAllocatedString(&self, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppwszvalue), ::core::mem::transmute(pcchlength)).ok()
}
pub unsafe fn GetBlobSize(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize), ::core::mem::transmute(pcbblobsize)).ok()
}
pub unsafe fn GetAllocatedBlob(&self, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppbuf), ::core::mem::transmute(pcbsize)).ok()
}
pub unsafe fn GetUnknown<T: ::windows::core::Interface>(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn SetItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value)).ok()
}
pub unsafe fn DeleteItem(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey)).ok()
}
pub unsafe fn DeleteAllItems(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetUINT32(&self, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetUINT64(&self, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetDouble(&self, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(fvalue)).ok()
}
pub unsafe fn SetGUID(&self, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(guidvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetString<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, guidkey: *const ::windows::core::GUID, wszvalue: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), wszvalue.into_param().abi()).ok()
}
pub unsafe fn SetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize)).ok()
}
pub unsafe fn SetUnknown<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guidkey: *const ::windows::core::GUID, punknown: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), punknown.into_param().abi()).ok()
}
pub unsafe fn LockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn UnlockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(unindex), ::core::mem::transmute(pguidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn CopyAllItems<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, pdest: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), pdest.into_param().abi()).ok()
}
pub unsafe fn GetSampleFlags(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetSampleFlags(&self, dwsampleflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsampleflags)).ok()
}
pub unsafe fn GetSampleTime(&self) -> ::windows::core::Result<i64> {
let mut result__: <i64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i64>(result__)
}
pub unsafe fn SetSampleTime(&self, hnssampletime: i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), ::core::mem::transmute(hnssampletime)).ok()
}
pub unsafe fn GetSampleDuration(&self) -> ::windows::core::Result<i64> {
let mut result__: <i64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i64>(result__)
}
pub unsafe fn SetSampleDuration(&self, hnssampleduration: i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self), ::core::mem::transmute(hnssampleduration)).ok()
}
pub unsafe fn GetBufferCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetBufferByIndex(&self, dwindex: u32) -> ::windows::core::Result<IMFMediaBuffer> {
let mut result__: <IMFMediaBuffer as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).40)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwindex), &mut result__).from_abi::<IMFMediaBuffer>(result__)
}
pub unsafe fn ConvertToContiguousBuffer(&self) -> ::windows::core::Result<IMFMediaBuffer> {
let mut result__: <IMFMediaBuffer as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFMediaBuffer>(result__)
}
pub unsafe fn AddBuffer<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaBuffer>>(&self, pbuffer: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self), pbuffer.into_param().abi()).ok()
}
pub unsafe fn RemoveBufferByIndex(&self, dwindex: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwindex)).ok()
}
pub unsafe fn RemoveAllBuffers(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).44)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetTotalLength(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).45)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn CopyToBuffer<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaBuffer>>(&self, pbuffer: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).46)(::core::mem::transmute_copy(self), pbuffer.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFSample {
type Vtable = IMFSample_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc40a00f2_b93a_4d80_ae8c_5a1c634f58e4);
}
impl ::core::convert::From<IMFSample> for ::windows::core::IUnknown {
fn from(value: IMFSample) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSample> for ::windows::core::IUnknown {
fn from(value: &IMFSample) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSample {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSample {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFSample> for IMFAttributes {
fn from(value: IMFSample) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFSample> for IMFAttributes {
fn from(value: &IMFSample) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for IMFSample {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for &IMFSample {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSample_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ptype: *mut MF_ATTRIBUTE_TYPE) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptheirs: ::windows::core::RawPtr, matchtype: MF_ATTRIBUTES_MATCH_TYPE, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pfvalue: *mut f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pguidvalue: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, wszvalue: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punknown: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcitems: *mut u32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdest: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwsampleflags: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsampleflags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, phnssampletime: *mut i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hnssampletime: i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, phnssampleduration: *mut i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hnssampleduration: i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwbuffercount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwindex: u32, ppbuffer: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppbuffer: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbuffer: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwindex: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcbtotallength: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbuffer: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSampleAllocatorControl(pub ::windows::core::IUnknown);
impl IMFSampleAllocatorControl {
pub unsafe fn SetDefaultAllocator<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, dwoutputstreamid: u32, pallocator: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwoutputstreamid), pallocator.into_param().abi()).ok()
}
pub unsafe fn GetAllocatorUsage(&self, dwoutputstreamid: u32, pdwinputstreamid: *mut u32, peusage: *mut MFSampleAllocatorUsage) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwoutputstreamid), ::core::mem::transmute(pdwinputstreamid), ::core::mem::transmute(peusage)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFSampleAllocatorControl {
type Vtable = IMFSampleAllocatorControl_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xda62b958_3a38_4a97_bd27_149c640c0771);
}
impl ::core::convert::From<IMFSampleAllocatorControl> for ::windows::core::IUnknown {
fn from(value: IMFSampleAllocatorControl) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSampleAllocatorControl> for ::windows::core::IUnknown {
fn from(value: &IMFSampleAllocatorControl) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSampleAllocatorControl {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSampleAllocatorControl {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSampleAllocatorControl_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwoutputstreamid: u32, pallocator: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwoutputstreamid: u32, pdwinputstreamid: *mut u32, peusage: *mut MFSampleAllocatorUsage) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSampleGrabberSinkCallback(pub ::windows::core::IUnknown);
impl IMFSampleGrabberSinkCallback {
pub unsafe fn OnClockStart(&self, hnssystemtime: i64, llclockstartoffset: i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(hnssystemtime), ::core::mem::transmute(llclockstartoffset)).ok()
}
pub unsafe fn OnClockStop(&self, hnssystemtime: i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(hnssystemtime)).ok()
}
pub unsafe fn OnClockPause(&self, hnssystemtime: i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(hnssystemtime)).ok()
}
pub unsafe fn OnClockRestart(&self, hnssystemtime: i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(hnssystemtime)).ok()
}
pub unsafe fn OnClockSetRate(&self, hnssystemtime: i64, flrate: f32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(hnssystemtime), ::core::mem::transmute(flrate)).ok()
}
pub unsafe fn OnSetPresentationClock<'a, Param0: ::windows::core::IntoParam<'a, IMFPresentationClock>>(&self, ppresentationclock: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ppresentationclock.into_param().abi()).ok()
}
pub unsafe fn OnProcessSample(&self, guidmajormediatype: *const ::windows::core::GUID, dwsampleflags: u32, llsampletime: i64, llsampleduration: i64, psamplebuffer: *const u8, dwsamplesize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidmajormediatype), ::core::mem::transmute(dwsampleflags), ::core::mem::transmute(llsampletime), ::core::mem::transmute(llsampleduration), ::core::mem::transmute(psamplebuffer), ::core::mem::transmute(dwsamplesize)).ok()
}
pub unsafe fn OnShutdown(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFSampleGrabberSinkCallback {
type Vtable = IMFSampleGrabberSinkCallback_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8c7b80bf_ee42_4b59_b1df_55668e1bdca8);
}
impl ::core::convert::From<IMFSampleGrabberSinkCallback> for ::windows::core::IUnknown {
fn from(value: IMFSampleGrabberSinkCallback) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSampleGrabberSinkCallback> for ::windows::core::IUnknown {
fn from(value: &IMFSampleGrabberSinkCallback) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSampleGrabberSinkCallback {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSampleGrabberSinkCallback {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFSampleGrabberSinkCallback> for IMFClockStateSink {
fn from(value: IMFSampleGrabberSinkCallback) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFSampleGrabberSinkCallback> for IMFClockStateSink {
fn from(value: &IMFSampleGrabberSinkCallback) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFClockStateSink> for IMFSampleGrabberSinkCallback {
fn into_param(self) -> ::windows::core::Param<'a, IMFClockStateSink> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFClockStateSink> for &IMFSampleGrabberSinkCallback {
fn into_param(self) -> ::windows::core::Param<'a, IMFClockStateSink> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSampleGrabberSinkCallback_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hnssystemtime: i64, llclockstartoffset: i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hnssystemtime: i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hnssystemtime: i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hnssystemtime: i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hnssystemtime: i64, flrate: f32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppresentationclock: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidmajormediatype: *const ::windows::core::GUID, dwsampleflags: u32, llsampletime: i64, llsampleduration: i64, psamplebuffer: *const u8, dwsamplesize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSampleGrabberSinkCallback2(pub ::windows::core::IUnknown);
impl IMFSampleGrabberSinkCallback2 {
pub unsafe fn OnClockStart(&self, hnssystemtime: i64, llclockstartoffset: i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(hnssystemtime), ::core::mem::transmute(llclockstartoffset)).ok()
}
pub unsafe fn OnClockStop(&self, hnssystemtime: i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(hnssystemtime)).ok()
}
pub unsafe fn OnClockPause(&self, hnssystemtime: i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(hnssystemtime)).ok()
}
pub unsafe fn OnClockRestart(&self, hnssystemtime: i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(hnssystemtime)).ok()
}
pub unsafe fn OnClockSetRate(&self, hnssystemtime: i64, flrate: f32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(hnssystemtime), ::core::mem::transmute(flrate)).ok()
}
pub unsafe fn OnSetPresentationClock<'a, Param0: ::windows::core::IntoParam<'a, IMFPresentationClock>>(&self, ppresentationclock: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ppresentationclock.into_param().abi()).ok()
}
pub unsafe fn OnProcessSample(&self, guidmajormediatype: *const ::windows::core::GUID, dwsampleflags: u32, llsampletime: i64, llsampleduration: i64, psamplebuffer: *const u8, dwsamplesize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidmajormediatype), ::core::mem::transmute(dwsampleflags), ::core::mem::transmute(llsampletime), ::core::mem::transmute(llsampleduration), ::core::mem::transmute(psamplebuffer), ::core::mem::transmute(dwsamplesize)).ok()
}
pub unsafe fn OnShutdown(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn OnProcessSampleEx<'a, Param6: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, guidmajormediatype: *const ::windows::core::GUID, dwsampleflags: u32, llsampletime: i64, llsampleduration: i64, psamplebuffer: *const u8, dwsamplesize: u32, pattributes: Param6) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(
::core::mem::transmute_copy(self),
::core::mem::transmute(guidmajormediatype),
::core::mem::transmute(dwsampleflags),
::core::mem::transmute(llsampletime),
::core::mem::transmute(llsampleduration),
::core::mem::transmute(psamplebuffer),
::core::mem::transmute(dwsamplesize),
pattributes.into_param().abi(),
)
.ok()
}
}
unsafe impl ::windows::core::Interface for IMFSampleGrabberSinkCallback2 {
type Vtable = IMFSampleGrabberSinkCallback2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xca86aa50_c46e_429e_ab27_16d6ac6844cb);
}
impl ::core::convert::From<IMFSampleGrabberSinkCallback2> for ::windows::core::IUnknown {
fn from(value: IMFSampleGrabberSinkCallback2) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSampleGrabberSinkCallback2> for ::windows::core::IUnknown {
fn from(value: &IMFSampleGrabberSinkCallback2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSampleGrabberSinkCallback2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSampleGrabberSinkCallback2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFSampleGrabberSinkCallback2> for IMFSampleGrabberSinkCallback {
fn from(value: IMFSampleGrabberSinkCallback2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFSampleGrabberSinkCallback2> for IMFSampleGrabberSinkCallback {
fn from(value: &IMFSampleGrabberSinkCallback2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFSampleGrabberSinkCallback> for IMFSampleGrabberSinkCallback2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFSampleGrabberSinkCallback> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFSampleGrabberSinkCallback> for &IMFSampleGrabberSinkCallback2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFSampleGrabberSinkCallback> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<IMFSampleGrabberSinkCallback2> for IMFClockStateSink {
fn from(value: IMFSampleGrabberSinkCallback2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFSampleGrabberSinkCallback2> for IMFClockStateSink {
fn from(value: &IMFSampleGrabberSinkCallback2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFClockStateSink> for IMFSampleGrabberSinkCallback2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFClockStateSink> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFClockStateSink> for &IMFSampleGrabberSinkCallback2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFClockStateSink> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSampleGrabberSinkCallback2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hnssystemtime: i64, llclockstartoffset: i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hnssystemtime: i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hnssystemtime: i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hnssystemtime: i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hnssystemtime: i64, flrate: f32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppresentationclock: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidmajormediatype: *const ::windows::core::GUID, dwsampleflags: u32, llsampletime: i64, llsampleduration: i64, psamplebuffer: *const u8, dwsamplesize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidmajormediatype: *const ::windows::core::GUID, dwsampleflags: u32, llsampletime: i64, llsampleduration: i64, psamplebuffer: *const u8, dwsamplesize: u32, pattributes: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSampleOutputStream(pub ::windows::core::IUnknown);
impl IMFSampleOutputStream {
pub unsafe fn BeginWriteSample<'a, Param0: ::windows::core::IntoParam<'a, IMFSample>, Param1: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param2: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, psample: Param0, pcallback: Param1, punkstate: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), psample.into_param().abi(), pcallback.into_param().abi(), punkstate.into_param().abi()).ok()
}
pub unsafe fn EndWriteSample<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), presult.into_param().abi()).ok()
}
pub unsafe fn Close(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFSampleOutputStream {
type Vtable = IMFSampleOutputStream_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8feed468_6f7e_440d_869a_49bdd283ad0d);
}
impl ::core::convert::From<IMFSampleOutputStream> for ::windows::core::IUnknown {
fn from(value: IMFSampleOutputStream) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSampleOutputStream> for ::windows::core::IUnknown {
fn from(value: &IMFSampleOutputStream) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSampleOutputStream {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSampleOutputStream {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSampleOutputStream_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psample: ::windows::core::RawPtr, pcallback: ::windows::core::RawPtr, punkstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSampleProtection(pub ::windows::core::IUnknown);
impl IMFSampleProtection {
pub unsafe fn GetInputProtectionVersion(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetOutputProtectionVersion(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetProtectionCertificate(&self, dwversion: u32, ppcert: *mut *mut u8, pcbcert: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwversion), ::core::mem::transmute(ppcert), ::core::mem::transmute(pcbcert)).ok()
}
pub unsafe fn InitOutputProtection(&self, dwversion: u32, dwoutputid: u32, pbcert: *const u8, cbcert: u32, ppbseed: *mut *mut u8, pcbseed: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwversion), ::core::mem::transmute(dwoutputid), ::core::mem::transmute(pbcert), ::core::mem::transmute(cbcert), ::core::mem::transmute(ppbseed), ::core::mem::transmute(pcbseed)).ok()
}
pub unsafe fn InitInputProtection(&self, dwversion: u32, dwinputid: u32, pbseed: *const u8, cbseed: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwversion), ::core::mem::transmute(dwinputid), ::core::mem::transmute(pbseed), ::core::mem::transmute(cbseed)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFSampleProtection {
type Vtable = IMFSampleProtection_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8e36395f_c7b9_43c4_a54d_512b4af63c95);
}
impl ::core::convert::From<IMFSampleProtection> for ::windows::core::IUnknown {
fn from(value: IMFSampleProtection) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSampleProtection> for ::windows::core::IUnknown {
fn from(value: &IMFSampleProtection) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSampleProtection {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSampleProtection {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSampleProtection_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwversion: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwversion: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwversion: u32, ppcert: *mut *mut u8, pcbcert: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwversion: u32, dwoutputid: u32, pbcert: *const u8, cbcert: u32, ppbseed: *mut *mut u8, pcbseed: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwversion: u32, dwinputid: u32, pbseed: *const u8, cbseed: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSaveJob(pub ::windows::core::IUnknown);
impl IMFSaveJob {
pub unsafe fn BeginSave<'a, Param0: ::windows::core::IntoParam<'a, IMFByteStream>, Param1: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param2: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pstream: Param0, pcallback: Param1, pstate: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pstream.into_param().abi(), pcallback.into_param().abi(), pstate.into_param().abi()).ok()
}
pub unsafe fn EndSave<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), presult.into_param().abi()).ok()
}
pub unsafe fn CancelSave(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetProgress(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFSaveJob {
type Vtable = IMFSaveJob_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe9931663_80bf_4c6e_98af_5dcf58747d1f);
}
impl ::core::convert::From<IMFSaveJob> for ::windows::core::IUnknown {
fn from(value: IMFSaveJob) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSaveJob> for ::windows::core::IUnknown {
fn from(value: &IMFSaveJob) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSaveJob {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSaveJob {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSaveJob_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstream: ::windows::core::RawPtr, pcallback: ::windows::core::RawPtr, pstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwpercentcomplete: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSchemeHandler(pub ::windows::core::IUnknown);
impl IMFSchemeHandler {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem"))]
pub unsafe fn BeginCreateObject<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::UI::Shell::PropertiesSystem::IPropertyStore>, Param4: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param5: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(
&self,
pwszurl: Param0,
dwflags: u32,
pprops: Param2,
ppiunknowncancelcookie: *mut ::core::option::Option<::windows::core::IUnknown>,
pcallback: Param4,
punkstate: Param5,
) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pwszurl.into_param().abi(), ::core::mem::transmute(dwflags), pprops.into_param().abi(), ::core::mem::transmute(ppiunknowncancelcookie), pcallback.into_param().abi(), punkstate.into_param().abi()).ok()
}
pub unsafe fn EndCreateObject<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0, pobjecttype: *mut MF_OBJECT_TYPE, ppobject: *mut ::core::option::Option<::windows::core::IUnknown>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), presult.into_param().abi(), ::core::mem::transmute(pobjecttype), ::core::mem::transmute(ppobject)).ok()
}
pub unsafe fn CancelObjectCreation<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, piunknowncancelcookie: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), piunknowncancelcookie.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFSchemeHandler {
type Vtable = IMFSchemeHandler_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6d4c7b74_52a0_4bb7_b0db_55f29f47a668);
}
impl ::core::convert::From<IMFSchemeHandler> for ::windows::core::IUnknown {
fn from(value: IMFSchemeHandler) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSchemeHandler> for ::windows::core::IUnknown {
fn from(value: &IMFSchemeHandler) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSchemeHandler {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSchemeHandler {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSchemeHandler_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pwszurl: super::super::Foundation::PWSTR, dwflags: u32, pprops: ::windows::core::RawPtr, ppiunknowncancelcookie: *mut ::windows::core::RawPtr, pcallback: ::windows::core::RawPtr, punkstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr, pobjecttype: *mut MF_OBJECT_TYPE, ppobject: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, piunknowncancelcookie: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSecureBuffer(pub ::windows::core::IUnknown);
impl IMFSecureBuffer {
pub unsafe fn GetIdentifier(&self) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFSecureBuffer {
type Vtable = IMFSecureBuffer_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc1209904_e584_4752_a2d6_7f21693f8b21);
}
impl ::core::convert::From<IMFSecureBuffer> for ::windows::core::IUnknown {
fn from(value: IMFSecureBuffer) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSecureBuffer> for ::windows::core::IUnknown {
fn from(value: &IMFSecureBuffer) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSecureBuffer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSecureBuffer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSecureBuffer_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pguididentifier: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSecureChannel(pub ::windows::core::IUnknown);
impl IMFSecureChannel {
pub unsafe fn GetCertificate(&self, ppcert: *mut *mut u8, pcbcert: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(ppcert), ::core::mem::transmute(pcbcert)).ok()
}
pub unsafe fn SetupSession(&self, pbencryptedsessionkey: *const u8, cbsessionkey: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbencryptedsessionkey), ::core::mem::transmute(cbsessionkey)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFSecureChannel {
type Vtable = IMFSecureChannel_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd0ae555d_3b12_4d97_b060_0990bc5aeb67);
}
impl ::core::convert::From<IMFSecureChannel> for ::windows::core::IUnknown {
fn from(value: IMFSecureChannel) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSecureChannel> for ::windows::core::IUnknown {
fn from(value: &IMFSecureChannel) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSecureChannel {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSecureChannel {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSecureChannel_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppcert: *mut *mut u8, pcbcert: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbencryptedsessionkey: *const u8, cbsessionkey: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSeekInfo(pub ::windows::core::IUnknown);
impl IMFSeekInfo {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetNearestKeyFrames(&self, pguidtimeformat: *const ::windows::core::GUID, pvarstartposition: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarpreviouskeyframe: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pvarnextkeyframe: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pguidtimeformat), ::core::mem::transmute(pvarstartposition), ::core::mem::transmute(pvarpreviouskeyframe), ::core::mem::transmute(pvarnextkeyframe)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFSeekInfo {
type Vtable = IMFSeekInfo_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x26afea53_d9ed_42b5_ab80_e64f9ee34779);
}
impl ::core::convert::From<IMFSeekInfo> for ::windows::core::IUnknown {
fn from(value: IMFSeekInfo) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSeekInfo> for ::windows::core::IUnknown {
fn from(value: &IMFSeekInfo) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSeekInfo {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSeekInfo {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSeekInfo_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pguidtimeformat: *const ::windows::core::GUID, pvarstartposition: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>, pvarpreviouskeyframe: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>, pvarnextkeyframe: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSensorActivitiesReport(pub ::windows::core::IUnknown);
impl IMFSensorActivitiesReport {
pub unsafe fn GetCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetActivityReport(&self, index: u32) -> ::windows::core::Result<IMFSensorActivityReport> {
let mut result__: <IMFSensorActivityReport as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<IMFSensorActivityReport>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetActivityReportByDeviceName<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, symbolicname: Param0) -> ::windows::core::Result<IMFSensorActivityReport> {
let mut result__: <IMFSensorActivityReport as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), symbolicname.into_param().abi(), &mut result__).from_abi::<IMFSensorActivityReport>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFSensorActivitiesReport {
type Vtable = IMFSensorActivitiesReport_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x683f7a5e_4a19_43cd_b1a9_dbf4ab3f7777);
}
impl ::core::convert::From<IMFSensorActivitiesReport> for ::windows::core::IUnknown {
fn from(value: IMFSensorActivitiesReport) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSensorActivitiesReport> for ::windows::core::IUnknown {
fn from(value: &IMFSensorActivitiesReport) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSensorActivitiesReport {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSensorActivitiesReport {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSensorActivitiesReport_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pccount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, sensoractivityreport: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbolicname: super::super::Foundation::PWSTR, sensoractivityreport: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSensorActivitiesReportCallback(pub ::windows::core::IUnknown);
impl IMFSensorActivitiesReportCallback {
pub unsafe fn OnActivitiesReport<'a, Param0: ::windows::core::IntoParam<'a, IMFSensorActivitiesReport>>(&self, sensoractivitiesreport: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), sensoractivitiesreport.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFSensorActivitiesReportCallback {
type Vtable = IMFSensorActivitiesReportCallback_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xde5072ee_dbe3_46dc_8a87_b6f631194751);
}
impl ::core::convert::From<IMFSensorActivitiesReportCallback> for ::windows::core::IUnknown {
fn from(value: IMFSensorActivitiesReportCallback) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSensorActivitiesReportCallback> for ::windows::core::IUnknown {
fn from(value: &IMFSensorActivitiesReportCallback) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSensorActivitiesReportCallback {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSensorActivitiesReportCallback {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSensorActivitiesReportCallback_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, sensoractivitiesreport: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSensorActivityMonitor(pub ::windows::core::IUnknown);
impl IMFSensorActivityMonitor {
pub unsafe fn Start(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Stop(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFSensorActivityMonitor {
type Vtable = IMFSensorActivityMonitor_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd0cef145_b3f4_4340_a2e5_7a5080ca05cb);
}
impl ::core::convert::From<IMFSensorActivityMonitor> for ::windows::core::IUnknown {
fn from(value: IMFSensorActivityMonitor) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSensorActivityMonitor> for ::windows::core::IUnknown {
fn from(value: &IMFSensorActivityMonitor) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSensorActivityMonitor {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSensorActivityMonitor {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSensorActivityMonitor_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSensorActivityReport(pub ::windows::core::IUnknown);
impl IMFSensorActivityReport {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetFriendlyName(&self, friendlyname: super::super::Foundation::PWSTR, cchfriendlyname: u32, pcchwritten: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(friendlyname), ::core::mem::transmute(cchfriendlyname), ::core::mem::transmute(pcchwritten)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolicLink(&self, symboliclink: super::super::Foundation::PWSTR, cchsymboliclink: u32, pcchwritten: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(symboliclink), ::core::mem::transmute(cchsymboliclink), ::core::mem::transmute(pcchwritten)).ok()
}
pub unsafe fn GetProcessCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetProcessActivity(&self, index: u32) -> ::windows::core::Result<IMFSensorProcessActivity> {
let mut result__: <IMFSensorProcessActivity as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<IMFSensorProcessActivity>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFSensorActivityReport {
type Vtable = IMFSensorActivityReport_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3e8c4be1_a8c2_4528_90de_2851bde5fead);
}
impl ::core::convert::From<IMFSensorActivityReport> for ::windows::core::IUnknown {
fn from(value: IMFSensorActivityReport) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSensorActivityReport> for ::windows::core::IUnknown {
fn from(value: &IMFSensorActivityReport) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSensorActivityReport {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSensorActivityReport {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSensorActivityReport_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, friendlyname: super::super::Foundation::PWSTR, cchfriendlyname: u32, pcchwritten: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symboliclink: super::super::Foundation::PWSTR, cchsymboliclink: u32, pcchwritten: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pccount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, ppprocessactivity: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSensorDevice(pub ::windows::core::IUnknown);
impl IMFSensorDevice {
pub unsafe fn GetDeviceId(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetDeviceType(&self) -> ::windows::core::Result<MFSensorDeviceType> {
let mut result__: <MFSensorDeviceType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MFSensorDeviceType>(result__)
}
pub unsafe fn GetFlags(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolicLink(&self, symboliclink: super::super::Foundation::PWSTR, cchsymboliclink: i32, pcchwritten: *mut i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(symboliclink), ::core::mem::transmute(cchsymboliclink), ::core::mem::transmute(pcchwritten)).ok()
}
pub unsafe fn GetDeviceAttributes(&self) -> ::windows::core::Result<IMFAttributes> {
let mut result__: <IMFAttributes as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFAttributes>(result__)
}
pub unsafe fn GetStreamAttributesCount(&self, etype: MFSensorStreamType) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(etype), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetStreamAttributes(&self, etype: MFSensorStreamType, dwindex: u32) -> ::windows::core::Result<IMFAttributes> {
let mut result__: <IMFAttributes as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(etype), ::core::mem::transmute(dwindex), &mut result__).from_abi::<IMFAttributes>(result__)
}
pub unsafe fn SetSensorDeviceMode(&self, emode: MFSensorDeviceMode) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(emode)).ok()
}
pub unsafe fn GetSensorDeviceMode(&self) -> ::windows::core::Result<MFSensorDeviceMode> {
let mut result__: <MFSensorDeviceMode as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MFSensorDeviceMode>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFSensorDevice {
type Vtable = IMFSensorDevice_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfb9f48f2_2a18_4e28_9730_786f30f04dc4);
}
impl ::core::convert::From<IMFSensorDevice> for ::windows::core::IUnknown {
fn from(value: IMFSensorDevice) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSensorDevice> for ::windows::core::IUnknown {
fn from(value: &IMFSensorDevice) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSensorDevice {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSensorDevice {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSensorDevice_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdeviceid: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptype: *mut MFSensorDeviceType) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pflags: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symboliclink: super::super::Foundation::PWSTR, cchsymboliclink: i32, pcchwritten: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppattributes: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, etype: MFSensorStreamType, pdwcount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, etype: MFSensorStreamType, dwindex: u32, ppattributes: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, emode: MFSensorDeviceMode) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pemode: *mut MFSensorDeviceMode) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSensorGroup(pub ::windows::core::IUnknown);
impl IMFSensorGroup {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolicLink(&self, symboliclink: super::super::Foundation::PWSTR, cchsymboliclink: i32, pcchwritten: *mut i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(symboliclink), ::core::mem::transmute(cchsymboliclink), ::core::mem::transmute(pcchwritten)).ok()
}
pub unsafe fn GetFlags(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetSensorGroupAttributes(&self) -> ::windows::core::Result<IMFAttributes> {
let mut result__: <IMFAttributes as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFAttributes>(result__)
}
pub unsafe fn GetSensorDeviceCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetSensorDevice(&self, dwindex: u32) -> ::windows::core::Result<IMFSensorDevice> {
let mut result__: <IMFSensorDevice as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwindex), &mut result__).from_abi::<IMFSensorDevice>(result__)
}
pub unsafe fn SetDefaultSensorDeviceIndex(&self, dwindex: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwindex)).ok()
}
pub unsafe fn GetDefaultSensorDeviceIndex(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn CreateMediaSource(&self) -> ::windows::core::Result<IMFMediaSource> {
let mut result__: <IMFMediaSource as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFMediaSource>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFSensorGroup {
type Vtable = IMFSensorGroup_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4110243a_9757_461f_89f1_f22345bcab4e);
}
impl ::core::convert::From<IMFSensorGroup> for ::windows::core::IUnknown {
fn from(value: IMFSensorGroup) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSensorGroup> for ::windows::core::IUnknown {
fn from(value: &IMFSensorGroup) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSensorGroup {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSensorGroup {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSensorGroup_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symboliclink: super::super::Foundation::PWSTR, cchsymboliclink: i32, pcchwritten: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pflags: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppattributes: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwindex: u32, ppdevice: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwindex: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwindex: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppsource: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSensorProcessActivity(pub ::windows::core::IUnknown);
impl IMFSensorProcessActivity {
pub unsafe fn GetProcessId(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetStreamingState(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn GetStreamingMode(&self) -> ::windows::core::Result<MFSensorDeviceMode> {
let mut result__: <MFSensorDeviceMode as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MFSensorDeviceMode>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetReportTime(&self) -> ::windows::core::Result<super::super::Foundation::FILETIME> {
let mut result__: <super::super::Foundation::FILETIME as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::FILETIME>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFSensorProcessActivity {
type Vtable = IMFSensorProcessActivity_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x39dc7f4a_b141_4719_813c_a7f46162a2b8);
}
impl ::core::convert::From<IMFSensorProcessActivity> for ::windows::core::IUnknown {
fn from(value: IMFSensorProcessActivity) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSensorProcessActivity> for ::windows::core::IUnknown {
fn from(value: &IMFSensorProcessActivity) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSensorProcessActivity {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSensorProcessActivity {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSensorProcessActivity_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppid: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfstreaming: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pmode: *mut MFSensorDeviceMode) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pft: *mut super::super::Foundation::FILETIME) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSensorProfile(pub ::windows::core::IUnknown);
impl IMFSensorProfile {
pub unsafe fn GetProfileId(&self) -> ::windows::core::Result<SENSORPROFILEID> {
let mut result__: <SENSORPROFILEID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SENSORPROFILEID>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddProfileFilter<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, streamid: u32, wzfiltersetstring: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(streamid), wzfiltersetstring.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsMediaTypeSupported<'a, Param1: ::windows::core::IntoParam<'a, IMFMediaType>>(&self, streamid: u32, pmediatype: Param1) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(streamid), pmediatype.into_param().abi(), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddBlockedControl<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, wzblockedcontrol: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), wzblockedcontrol.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFSensorProfile {
type Vtable = IMFSensorProfile_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x22f765d1_8dab_4107_846d_56baf72215e7);
}
impl ::core::convert::From<IMFSensorProfile> for ::windows::core::IUnknown {
fn from(value: IMFSensorProfile) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSensorProfile> for ::windows::core::IUnknown {
fn from(value: &IMFSensorProfile) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSensorProfile {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSensorProfile {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSensorProfile_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pid: *mut SENSORPROFILEID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, streamid: u32, wzfiltersetstring: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, streamid: u32, pmediatype: ::windows::core::RawPtr, pfsupported: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, wzblockedcontrol: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSensorProfileCollection(pub ::windows::core::IUnknown);
impl IMFSensorProfileCollection {
pub unsafe fn GetProfileCount(&self) -> u32 {
::core::mem::transmute((::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetProfile(&self, index: u32) -> ::windows::core::Result<IMFSensorProfile> {
let mut result__: <IMFSensorProfile as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<IMFSensorProfile>(result__)
}
pub unsafe fn AddProfile<'a, Param0: ::windows::core::IntoParam<'a, IMFSensorProfile>>(&self, pprofile: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pprofile.into_param().abi()).ok()
}
pub unsafe fn FindProfile(&self, profileid: *const SENSORPROFILEID) -> ::windows::core::Result<IMFSensorProfile> {
let mut result__: <IMFSensorProfile as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(profileid), &mut result__).from_abi::<IMFSensorProfile>(result__)
}
pub unsafe fn RemoveProfileByIndex(&self, index: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(index)))
}
pub unsafe fn RemoveProfile(&self, profileid: *const SENSORPROFILEID) {
::core::mem::transmute((::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(profileid)))
}
}
unsafe impl ::windows::core::Interface for IMFSensorProfileCollection {
type Vtable = IMFSensorProfileCollection_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc95ea55b_0187_48be_9353_8d2507662351);
}
impl ::core::convert::From<IMFSensorProfileCollection> for ::windows::core::IUnknown {
fn from(value: IMFSensorProfileCollection) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSensorProfileCollection> for ::windows::core::IUnknown {
fn from(value: &IMFSensorProfileCollection) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSensorProfileCollection {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSensorProfileCollection {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSensorProfileCollection_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, ppprofile: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pprofile: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, profileid: *const SENSORPROFILEID, ppprofile: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, profileid: *const SENSORPROFILEID),
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSensorStream(pub ::windows::core::IUnknown);
impl IMFSensorStream {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItem(&self, guidkey: *const ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn GetItemType(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<MF_ATTRIBUTE_TYPE> {
let mut result__: <MF_ATTRIBUTE_TYPE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<MF_ATTRIBUTE_TYPE>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn CompareItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Compare<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, ptheirs: Param0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ptheirs.into_param().abi(), ::core::mem::transmute(matchtype), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn GetUINT32(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetUINT64(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetDouble(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<f64> {
let mut result__: <f64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<f64>(result__)
}
pub unsafe fn GetGUID(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
pub unsafe fn GetStringLength(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetString(&self, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pwszvalue), ::core::mem::transmute(cchbufsize), ::core::mem::transmute(pcchlength)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetAllocatedString(&self, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppwszvalue), ::core::mem::transmute(pcchlength)).ok()
}
pub unsafe fn GetBlobSize(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize), ::core::mem::transmute(pcbblobsize)).ok()
}
pub unsafe fn GetAllocatedBlob(&self, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppbuf), ::core::mem::transmute(pcbsize)).ok()
}
pub unsafe fn GetUnknown<T: ::windows::core::Interface>(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn SetItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value)).ok()
}
pub unsafe fn DeleteItem(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey)).ok()
}
pub unsafe fn DeleteAllItems(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetUINT32(&self, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetUINT64(&self, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetDouble(&self, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(fvalue)).ok()
}
pub unsafe fn SetGUID(&self, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(guidvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetString<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, guidkey: *const ::windows::core::GUID, wszvalue: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), wszvalue.into_param().abi()).ok()
}
pub unsafe fn SetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize)).ok()
}
pub unsafe fn SetUnknown<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guidkey: *const ::windows::core::GUID, punknown: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), punknown.into_param().abi()).ok()
}
pub unsafe fn LockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn UnlockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(unindex), ::core::mem::transmute(pguidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn CopyAllItems<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, pdest: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), pdest.into_param().abi()).ok()
}
pub unsafe fn GetMediaTypeCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetMediaType(&self, dwindex: u32) -> ::windows::core::Result<IMFMediaType> {
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwindex), &mut result__).from_abi::<IMFMediaType>(result__)
}
pub unsafe fn CloneSensorStream(&self) -> ::windows::core::Result<IMFSensorStream> {
let mut result__: <IMFSensorStream as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFSensorStream>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFSensorStream {
type Vtable = IMFSensorStream_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe9a42171_c56e_498a_8b39_eda5a070b7fc);
}
impl ::core::convert::From<IMFSensorStream> for ::windows::core::IUnknown {
fn from(value: IMFSensorStream) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSensorStream> for ::windows::core::IUnknown {
fn from(value: &IMFSensorStream) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSensorStream {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSensorStream {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFSensorStream> for IMFAttributes {
fn from(value: IMFSensorStream) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFSensorStream> for IMFAttributes {
fn from(value: &IMFSensorStream) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for IMFSensorStream {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for &IMFSensorStream {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSensorStream_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ptype: *mut MF_ATTRIBUTE_TYPE) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptheirs: ::windows::core::RawPtr, matchtype: MF_ATTRIBUTES_MATCH_TYPE, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pfvalue: *mut f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pguidvalue: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, wszvalue: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punknown: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcitems: *mut u32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdest: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwindex: u32, ppmediatype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppstream: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSensorTransformFactory(pub ::windows::core::IUnknown);
impl IMFSensorTransformFactory {
pub unsafe fn GetFactoryAttributes(&self) -> ::windows::core::Result<IMFAttributes> {
let mut result__: <IMFAttributes as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFAttributes>(result__)
}
pub unsafe fn InitializeFactory<'a, Param1: ::windows::core::IntoParam<'a, IMFCollection>, Param2: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, dwmaxtransformcount: u32, psensordevices: Param1, pattributes: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwmaxtransformcount), psensordevices.into_param().abi(), pattributes.into_param().abi()).ok()
}
pub unsafe fn GetTransformCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetTransformInformation(&self, transformindex: u32, pguidtransformid: *mut ::windows::core::GUID, ppattributes: *mut ::core::option::Option<IMFAttributes>, ppstreaminformation: *mut ::core::option::Option<IMFCollection>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(transformindex), ::core::mem::transmute(pguidtransformid), ::core::mem::transmute(ppattributes), ::core::mem::transmute(ppstreaminformation)).ok()
}
#[cfg(feature = "Win32_Media_Streaming")]
pub unsafe fn CreateTransform<'a, Param1: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, guidsensortransformid: *const ::windows::core::GUID, pattributes: Param1) -> ::windows::core::Result<super::Streaming::IMFDeviceTransform> {
let mut result__: <super::Streaming::IMFDeviceTransform as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidsensortransformid), pattributes.into_param().abi(), &mut result__).from_abi::<super::Streaming::IMFDeviceTransform>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFSensorTransformFactory {
type Vtable = IMFSensorTransformFactory_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xeed9c2ee_66b4_4f18_a697_ac7d3960215c);
}
impl ::core::convert::From<IMFSensorTransformFactory> for ::windows::core::IUnknown {
fn from(value: IMFSensorTransformFactory) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSensorTransformFactory> for ::windows::core::IUnknown {
fn from(value: &IMFSensorTransformFactory) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSensorTransformFactory {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSensorTransformFactory {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSensorTransformFactory_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppattributes: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwmaxtransformcount: u32, psensordevices: ::windows::core::RawPtr, pattributes: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, transformindex: u32, pguidtransformid: *mut ::windows::core::GUID, ppattributes: *mut ::windows::core::RawPtr, ppstreaminformation: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Media_Streaming")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidsensortransformid: *const ::windows::core::GUID, pattributes: ::windows::core::RawPtr, ppdevicemft: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Media_Streaming"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSequencerSource(pub ::windows::core::IUnknown);
impl IMFSequencerSource {
pub unsafe fn AppendTopology<'a, Param0: ::windows::core::IntoParam<'a, IMFTopology>>(&self, ptopology: Param0, dwflags: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ptopology.into_param().abi(), ::core::mem::transmute(dwflags), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn DeleteTopology(&self, dwid: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwid)).ok()
}
pub unsafe fn GetPresentationContext<'a, Param0: ::windows::core::IntoParam<'a, IMFPresentationDescriptor>>(&self, ppd: Param0, pid: *mut u32, pptopology: *mut ::core::option::Option<IMFTopology>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ppd.into_param().abi(), ::core::mem::transmute(pid), ::core::mem::transmute(pptopology)).ok()
}
pub unsafe fn UpdateTopology<'a, Param1: ::windows::core::IntoParam<'a, IMFTopology>>(&self, dwid: u32, ptopology: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwid), ptopology.into_param().abi()).ok()
}
pub unsafe fn UpdateTopologyFlags(&self, dwid: u32, dwflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwid), ::core::mem::transmute(dwflags)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFSequencerSource {
type Vtable = IMFSequencerSource_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x197cd219_19cb_4de1_a64c_acf2edcbe59e);
}
impl ::core::convert::From<IMFSequencerSource> for ::windows::core::IUnknown {
fn from(value: IMFSequencerSource) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSequencerSource> for ::windows::core::IUnknown {
fn from(value: &IMFSequencerSource) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSequencerSource {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSequencerSource {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSequencerSource_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptopology: ::windows::core::RawPtr, dwflags: u32, pdwid: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwid: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppd: ::windows::core::RawPtr, pid: *mut u32, pptopology: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwid: u32, ptopology: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwid: u32, dwflags: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSharingEngineClassFactory(pub ::windows::core::IUnknown);
impl IMFSharingEngineClassFactory {
pub unsafe fn CreateInstance<'a, Param1: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, dwflags: u32, pattr: Param1) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwflags), pattr.into_param().abi(), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFSharingEngineClassFactory {
type Vtable = IMFSharingEngineClassFactory_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2ba61f92_8305_413b_9733_faf15f259384);
}
impl ::core::convert::From<IMFSharingEngineClassFactory> for ::windows::core::IUnknown {
fn from(value: IMFSharingEngineClassFactory) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSharingEngineClassFactory> for ::windows::core::IUnknown {
fn from(value: &IMFSharingEngineClassFactory) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSharingEngineClassFactory {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSharingEngineClassFactory {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSharingEngineClassFactory_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwflags: u32, pattr: ::windows::core::RawPtr, ppengine: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFShutdown(pub ::windows::core::IUnknown);
impl IMFShutdown {
pub unsafe fn Shutdown(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetShutdownStatus(&self) -> ::windows::core::Result<MFSHUTDOWN_STATUS> {
let mut result__: <MFSHUTDOWN_STATUS as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MFSHUTDOWN_STATUS>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFShutdown {
type Vtable = IMFShutdown_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x97ec2ea4_0e42_4937_97ac_9d6d328824e1);
}
impl ::core::convert::From<IMFShutdown> for ::windows::core::IUnknown {
fn from(value: IMFShutdown) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFShutdown> for ::windows::core::IUnknown {
fn from(value: &IMFShutdown) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFShutdown {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFShutdown {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFShutdown_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstatus: *mut MFSHUTDOWN_STATUS) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSignedLibrary(pub ::windows::core::IUnknown);
impl IMFSignedLibrary {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetProcedureAddress<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PSTR>>(&self, name: Param0, address: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), name.into_param().abi(), ::core::mem::transmute(address)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFSignedLibrary {
type Vtable = IMFSignedLibrary_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4a724bca_ff6a_4c07_8e0d_7a358421cf06);
}
impl ::core::convert::From<IMFSignedLibrary> for ::windows::core::IUnknown {
fn from(value: IMFSignedLibrary) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSignedLibrary> for ::windows::core::IUnknown {
fn from(value: &IMFSignedLibrary) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSignedLibrary {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSignedLibrary {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSignedLibrary_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::Foundation::PSTR, address: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSimpleAudioVolume(pub ::windows::core::IUnknown);
impl IMFSimpleAudioVolume {
pub unsafe fn SetMasterVolume(&self, flevel: f32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(flevel)).ok()
}
pub unsafe fn GetMasterVolume(&self) -> ::windows::core::Result<f32> {
let mut result__: <f32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<f32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetMute<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, bmute: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), bmute.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetMute(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFSimpleAudioVolume {
type Vtable = IMFSimpleAudioVolume_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x089edf13_cf71_4338_8d13_9e569dbdc319);
}
impl ::core::convert::From<IMFSimpleAudioVolume> for ::windows::core::IUnknown {
fn from(value: IMFSimpleAudioVolume) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSimpleAudioVolume> for ::windows::core::IUnknown {
fn from(value: &IMFSimpleAudioVolume) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSimpleAudioVolume {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSimpleAudioVolume {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSimpleAudioVolume_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flevel: f32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pflevel: *mut f32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bmute: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbmute: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSinkWriter(pub ::windows::core::IUnknown);
impl IMFSinkWriter {
pub unsafe fn AddStream<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaType>>(&self, ptargetmediatype: Param0) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ptargetmediatype.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetInputMediaType<'a, Param1: ::windows::core::IntoParam<'a, IMFMediaType>, Param2: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, dwstreamindex: u32, pinputmediatype: Param1, pencodingparameters: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), pinputmediatype.into_param().abi(), pencodingparameters.into_param().abi()).ok()
}
pub unsafe fn BeginWriting(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn WriteSample<'a, Param1: ::windows::core::IntoParam<'a, IMFSample>>(&self, dwstreamindex: u32, psample: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), psample.into_param().abi()).ok()
}
pub unsafe fn SendStreamTick(&self, dwstreamindex: u32, lltimestamp: i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(lltimestamp)).ok()
}
pub unsafe fn PlaceMarker(&self, dwstreamindex: u32, pvcontext: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(pvcontext)).ok()
}
pub unsafe fn NotifyEndOfSegment(&self, dwstreamindex: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex)).ok()
}
pub unsafe fn Flush(&self, dwstreamindex: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex)).ok()
}
pub unsafe fn Finalize(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetServiceForStream(&self, dwstreamindex: u32, guidservice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(guidservice), ::core::mem::transmute(riid), ::core::mem::transmute(ppvobject)).ok()
}
pub unsafe fn GetStatistics(&self, dwstreamindex: u32) -> ::windows::core::Result<MF_SINK_WRITER_STATISTICS> {
let mut result__: <MF_SINK_WRITER_STATISTICS as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), &mut result__).from_abi::<MF_SINK_WRITER_STATISTICS>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFSinkWriter {
type Vtable = IMFSinkWriter_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3137f1cd_fe5e_4805_a5d8_fb477448cb3d);
}
impl ::core::convert::From<IMFSinkWriter> for ::windows::core::IUnknown {
fn from(value: IMFSinkWriter) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSinkWriter> for ::windows::core::IUnknown {
fn from(value: &IMFSinkWriter) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSinkWriter {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSinkWriter {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSinkWriter_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptargetmediatype: ::windows::core::RawPtr, pdwstreamindex: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, pinputmediatype: ::windows::core::RawPtr, pencodingparameters: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, psample: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, lltimestamp: i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, pvcontext: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, guidservice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, pstats: *mut MF_SINK_WRITER_STATISTICS) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSinkWriterCallback(pub ::windows::core::IUnknown);
impl IMFSinkWriterCallback {
pub unsafe fn OnFinalize(&self, hrstatus: ::windows::core::HRESULT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(hrstatus)).ok()
}
pub unsafe fn OnMarker(&self, dwstreamindex: u32, pvcontext: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(pvcontext)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFSinkWriterCallback {
type Vtable = IMFSinkWriterCallback_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x666f76de_33d2_41b9_a458_29ed0a972c58);
}
impl ::core::convert::From<IMFSinkWriterCallback> for ::windows::core::IUnknown {
fn from(value: IMFSinkWriterCallback) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSinkWriterCallback> for ::windows::core::IUnknown {
fn from(value: &IMFSinkWriterCallback) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSinkWriterCallback {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSinkWriterCallback {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSinkWriterCallback_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hrstatus: ::windows::core::HRESULT) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, pvcontext: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSinkWriterCallback2(pub ::windows::core::IUnknown);
impl IMFSinkWriterCallback2 {
pub unsafe fn OnFinalize(&self, hrstatus: ::windows::core::HRESULT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(hrstatus)).ok()
}
pub unsafe fn OnMarker(&self, dwstreamindex: u32, pvcontext: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(pvcontext)).ok()
}
pub unsafe fn OnTransformChange(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn OnStreamError(&self, dwstreamindex: u32, hrstatus: ::windows::core::HRESULT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(hrstatus)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFSinkWriterCallback2 {
type Vtable = IMFSinkWriterCallback2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2456bd58_c067_4513_84fe_8d0c88ffdc61);
}
impl ::core::convert::From<IMFSinkWriterCallback2> for ::windows::core::IUnknown {
fn from(value: IMFSinkWriterCallback2) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSinkWriterCallback2> for ::windows::core::IUnknown {
fn from(value: &IMFSinkWriterCallback2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSinkWriterCallback2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSinkWriterCallback2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFSinkWriterCallback2> for IMFSinkWriterCallback {
fn from(value: IMFSinkWriterCallback2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFSinkWriterCallback2> for IMFSinkWriterCallback {
fn from(value: &IMFSinkWriterCallback2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFSinkWriterCallback> for IMFSinkWriterCallback2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFSinkWriterCallback> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFSinkWriterCallback> for &IMFSinkWriterCallback2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFSinkWriterCallback> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSinkWriterCallback2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hrstatus: ::windows::core::HRESULT) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, pvcontext: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, hrstatus: ::windows::core::HRESULT) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSinkWriterEncoderConfig(pub ::windows::core::IUnknown);
impl IMFSinkWriterEncoderConfig {
pub unsafe fn SetTargetMediaType<'a, Param1: ::windows::core::IntoParam<'a, IMFMediaType>, Param2: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, dwstreamindex: u32, ptargetmediatype: Param1, pencodingparameters: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ptargetmediatype.into_param().abi(), pencodingparameters.into_param().abi()).ok()
}
pub unsafe fn PlaceEncodingParameters<'a, Param1: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, dwstreamindex: u32, pencodingparameters: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), pencodingparameters.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFSinkWriterEncoderConfig {
type Vtable = IMFSinkWriterEncoderConfig_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x17c3779e_3cde_4ede_8c60_3899f5f53ad6);
}
impl ::core::convert::From<IMFSinkWriterEncoderConfig> for ::windows::core::IUnknown {
fn from(value: IMFSinkWriterEncoderConfig) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSinkWriterEncoderConfig> for ::windows::core::IUnknown {
fn from(value: &IMFSinkWriterEncoderConfig) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSinkWriterEncoderConfig {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSinkWriterEncoderConfig {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSinkWriterEncoderConfig_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, ptargetmediatype: ::windows::core::RawPtr, pencodingparameters: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, pencodingparameters: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSinkWriterEx(pub ::windows::core::IUnknown);
impl IMFSinkWriterEx {
pub unsafe fn AddStream<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaType>>(&self, ptargetmediatype: Param0) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ptargetmediatype.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetInputMediaType<'a, Param1: ::windows::core::IntoParam<'a, IMFMediaType>, Param2: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, dwstreamindex: u32, pinputmediatype: Param1, pencodingparameters: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), pinputmediatype.into_param().abi(), pencodingparameters.into_param().abi()).ok()
}
pub unsafe fn BeginWriting(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn WriteSample<'a, Param1: ::windows::core::IntoParam<'a, IMFSample>>(&self, dwstreamindex: u32, psample: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), psample.into_param().abi()).ok()
}
pub unsafe fn SendStreamTick(&self, dwstreamindex: u32, lltimestamp: i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(lltimestamp)).ok()
}
pub unsafe fn PlaceMarker(&self, dwstreamindex: u32, pvcontext: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(pvcontext)).ok()
}
pub unsafe fn NotifyEndOfSegment(&self, dwstreamindex: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex)).ok()
}
pub unsafe fn Flush(&self, dwstreamindex: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex)).ok()
}
pub unsafe fn Finalize(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetServiceForStream(&self, dwstreamindex: u32, guidservice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(guidservice), ::core::mem::transmute(riid), ::core::mem::transmute(ppvobject)).ok()
}
pub unsafe fn GetStatistics(&self, dwstreamindex: u32) -> ::windows::core::Result<MF_SINK_WRITER_STATISTICS> {
let mut result__: <MF_SINK_WRITER_STATISTICS as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), &mut result__).from_abi::<MF_SINK_WRITER_STATISTICS>(result__)
}
pub unsafe fn GetTransformForStream(&self, dwstreamindex: u32, dwtransformindex: u32, pguidcategory: *mut ::windows::core::GUID, pptransform: *mut ::core::option::Option<IMFTransform>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(dwtransformindex), ::core::mem::transmute(pguidcategory), ::core::mem::transmute(pptransform)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFSinkWriterEx {
type Vtable = IMFSinkWriterEx_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x588d72ab_5bc1_496a_8714_b70617141b25);
}
impl ::core::convert::From<IMFSinkWriterEx> for ::windows::core::IUnknown {
fn from(value: IMFSinkWriterEx) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSinkWriterEx> for ::windows::core::IUnknown {
fn from(value: &IMFSinkWriterEx) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSinkWriterEx {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSinkWriterEx {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFSinkWriterEx> for IMFSinkWriter {
fn from(value: IMFSinkWriterEx) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFSinkWriterEx> for IMFSinkWriter {
fn from(value: &IMFSinkWriterEx) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFSinkWriter> for IMFSinkWriterEx {
fn into_param(self) -> ::windows::core::Param<'a, IMFSinkWriter> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFSinkWriter> for &IMFSinkWriterEx {
fn into_param(self) -> ::windows::core::Param<'a, IMFSinkWriter> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSinkWriterEx_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptargetmediatype: ::windows::core::RawPtr, pdwstreamindex: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, pinputmediatype: ::windows::core::RawPtr, pencodingparameters: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, psample: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, lltimestamp: i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, pvcontext: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, guidservice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, pstats: *mut MF_SINK_WRITER_STATISTICS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, dwtransformindex: u32, pguidcategory: *mut ::windows::core::GUID, pptransform: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSourceBuffer(pub ::windows::core::IUnknown);
impl IMFSourceBuffer {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetUpdating(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetBuffered(&self) -> ::windows::core::Result<IMFMediaTimeRange> {
let mut result__: <IMFMediaTimeRange as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFMediaTimeRange>(result__)
}
pub unsafe fn GetTimeStampOffset(&self) -> f64 {
::core::mem::transmute((::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)))
}
pub unsafe fn SetTimeStampOffset(&self, offset: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset)).ok()
}
pub unsafe fn GetAppendWindowStart(&self) -> f64 {
::core::mem::transmute((::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)))
}
pub unsafe fn SetAppendWindowStart(&self, time: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(time)).ok()
}
pub unsafe fn GetAppendWindowEnd(&self) -> f64 {
::core::mem::transmute((::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)))
}
pub unsafe fn SetAppendWindowEnd(&self, time: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(time)).ok()
}
pub unsafe fn Append(&self, pdata: *const u8, len: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdata), ::core::mem::transmute(len)).ok()
}
pub unsafe fn AppendByteStream<'a, Param0: ::windows::core::IntoParam<'a, IMFByteStream>>(&self, pstream: Param0, pmaxlen: *const u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), pstream.into_param().abi(), ::core::mem::transmute(pmaxlen)).ok()
}
pub unsafe fn Abort(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Remove(&self, start: f64, end: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(end)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFSourceBuffer {
type Vtable = IMFSourceBuffer_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe2cd3a4b_af25_4d3d_9110_da0e6f8ee877);
}
impl ::core::convert::From<IMFSourceBuffer> for ::windows::core::IUnknown {
fn from(value: IMFSourceBuffer) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSourceBuffer> for ::windows::core::IUnknown {
fn from(value: &IMFSourceBuffer) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSourceBuffer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSourceBuffer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSourceBuffer_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppbuffered: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> f64,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> f64,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, time: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> f64,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, time: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdata: *const u8, len: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstream: ::windows::core::RawPtr, pmaxlen: *const u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: f64, end: f64) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSourceBufferAppendMode(pub ::windows::core::IUnknown);
impl IMFSourceBufferAppendMode {
pub unsafe fn GetAppendMode(&self) -> MF_MSE_APPEND_MODE {
::core::mem::transmute((::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)))
}
pub unsafe fn SetAppendMode(&self, mode: MF_MSE_APPEND_MODE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(mode)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFSourceBufferAppendMode {
type Vtable = IMFSourceBufferAppendMode_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x19666fb4_babe_4c55_bc03_0a074da37e2a);
}
impl ::core::convert::From<IMFSourceBufferAppendMode> for ::windows::core::IUnknown {
fn from(value: IMFSourceBufferAppendMode) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSourceBufferAppendMode> for ::windows::core::IUnknown {
fn from(value: &IMFSourceBufferAppendMode) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSourceBufferAppendMode {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSourceBufferAppendMode {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSourceBufferAppendMode_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> MF_MSE_APPEND_MODE,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mode: MF_MSE_APPEND_MODE) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSourceBufferList(pub ::windows::core::IUnknown);
impl IMFSourceBufferList {
pub unsafe fn GetLength(&self) -> u32 {
::core::mem::transmute((::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetSourceBuffer(&self, index: u32) -> ::core::option::Option<IMFSourceBuffer> {
::core::mem::transmute((::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(index)))
}
}
unsafe impl ::windows::core::Interface for IMFSourceBufferList {
type Vtable = IMFSourceBufferList_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x249981f8_8325_41f3_b80c_3b9e3aad0cbe);
}
impl ::core::convert::From<IMFSourceBufferList> for ::windows::core::IUnknown {
fn from(value: IMFSourceBufferList) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSourceBufferList> for ::windows::core::IUnknown {
fn from(value: &IMFSourceBufferList) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSourceBufferList {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSourceBufferList {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSourceBufferList_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32) -> ::windows::core::RawPtr,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSourceBufferNotify(pub ::windows::core::IUnknown);
impl IMFSourceBufferNotify {
pub unsafe fn OnUpdateStart(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)))
}
pub unsafe fn OnAbort(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)))
}
pub unsafe fn OnError(&self, hr: ::windows::core::HRESULT) {
::core::mem::transmute((::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(hr)))
}
pub unsafe fn OnUpdate(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self)))
}
pub unsafe fn OnUpdateEnd(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)))
}
}
unsafe impl ::windows::core::Interface for IMFSourceBufferNotify {
type Vtable = IMFSourceBufferNotify_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x87e47623_2ceb_45d6_9b88_d8520c4dcbbc);
}
impl ::core::convert::From<IMFSourceBufferNotify> for ::windows::core::IUnknown {
fn from(value: IMFSourceBufferNotify) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSourceBufferNotify> for ::windows::core::IUnknown {
fn from(value: &IMFSourceBufferNotify) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSourceBufferNotify {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSourceBufferNotify {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSourceBufferNotify_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hr: ::windows::core::HRESULT),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSourceOpenMonitor(pub ::windows::core::IUnknown);
impl IMFSourceOpenMonitor {
pub unsafe fn OnSourceEvent<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaEvent>>(&self, pevent: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pevent.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFSourceOpenMonitor {
type Vtable = IMFSourceOpenMonitor_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x059054b3_027c_494c_a27d_9113291cf87f);
}
impl ::core::convert::From<IMFSourceOpenMonitor> for ::windows::core::IUnknown {
fn from(value: IMFSourceOpenMonitor) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSourceOpenMonitor> for ::windows::core::IUnknown {
fn from(value: &IMFSourceOpenMonitor) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSourceOpenMonitor {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSourceOpenMonitor {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSourceOpenMonitor_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pevent: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSourceReader(pub ::windows::core::IUnknown);
impl IMFSourceReader {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetStreamSelection(&self, dwstreamindex: u32) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetStreamSelection<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, dwstreamindex: u32, fselected: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), fselected.into_param().abi()).ok()
}
pub unsafe fn GetNativeMediaType(&self, dwstreamindex: u32, dwmediatypeindex: u32) -> ::windows::core::Result<IMFMediaType> {
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(dwmediatypeindex), &mut result__).from_abi::<IMFMediaType>(result__)
}
pub unsafe fn GetCurrentMediaType(&self, dwstreamindex: u32) -> ::windows::core::Result<IMFMediaType> {
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), &mut result__).from_abi::<IMFMediaType>(result__)
}
pub unsafe fn SetCurrentMediaType<'a, Param2: ::windows::core::IntoParam<'a, IMFMediaType>>(&self, dwstreamindex: u32, pdwreserved: *mut u32, pmediatype: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(pdwreserved), pmediatype.into_param().abi()).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn SetCurrentPosition(&self, guidtimeformat: *const ::windows::core::GUID, varposition: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidtimeformat), ::core::mem::transmute(varposition)).ok()
}
pub unsafe fn ReadSample(&self, dwstreamindex: u32, dwcontrolflags: u32, pdwactualstreamindex: *mut u32, pdwstreamflags: *mut u32, plltimestamp: *mut i64, ppsample: *mut ::core::option::Option<IMFSample>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(dwcontrolflags), ::core::mem::transmute(pdwactualstreamindex), ::core::mem::transmute(pdwstreamflags), ::core::mem::transmute(plltimestamp), ::core::mem::transmute(ppsample)).ok()
}
pub unsafe fn Flush(&self, dwstreamindex: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex)).ok()
}
pub unsafe fn GetServiceForStream(&self, dwstreamindex: u32, guidservice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(guidservice), ::core::mem::transmute(riid), ::core::mem::transmute(ppvobject)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetPresentationAttribute(&self, dwstreamindex: u32, guidattribute: *const ::windows::core::GUID) -> ::windows::core::Result<super::super::System::Com::StructuredStorage::PROPVARIANT> {
let mut result__: <super::super::System::Com::StructuredStorage::PROPVARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(guidattribute), &mut result__).from_abi::<super::super::System::Com::StructuredStorage::PROPVARIANT>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFSourceReader {
type Vtable = IMFSourceReader_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x70ae66f2_c809_4e4f_8915_bdcb406b7993);
}
impl ::core::convert::From<IMFSourceReader> for ::windows::core::IUnknown {
fn from(value: IMFSourceReader) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSourceReader> for ::windows::core::IUnknown {
fn from(value: &IMFSourceReader) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSourceReader {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSourceReader {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSourceReader_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, pfselected: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, fselected: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, dwmediatypeindex: u32, ppmediatype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, ppmediatype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, pdwreserved: *mut u32, pmediatype: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidtimeformat: *const ::windows::core::GUID, varposition: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, dwcontrolflags: u32, pdwactualstreamindex: *mut u32, pdwstreamflags: *mut u32, plltimestamp: *mut i64, ppsample: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, guidservice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, guidattribute: *const ::windows::core::GUID, pvarattribute: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSourceReaderCallback(pub ::windows::core::IUnknown);
impl IMFSourceReaderCallback {
pub unsafe fn OnReadSample<'a, Param4: ::windows::core::IntoParam<'a, IMFSample>>(&self, hrstatus: ::windows::core::HRESULT, dwstreamindex: u32, dwstreamflags: u32, lltimestamp: i64, psample: Param4) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(hrstatus), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(dwstreamflags), ::core::mem::transmute(lltimestamp), psample.into_param().abi()).ok()
}
pub unsafe fn OnFlush(&self, dwstreamindex: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex)).ok()
}
pub unsafe fn OnEvent<'a, Param1: ::windows::core::IntoParam<'a, IMFMediaEvent>>(&self, dwstreamindex: u32, pevent: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), pevent.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFSourceReaderCallback {
type Vtable = IMFSourceReaderCallback_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdeec8d99_fa1d_4d82_84c2_2c8969944867);
}
impl ::core::convert::From<IMFSourceReaderCallback> for ::windows::core::IUnknown {
fn from(value: IMFSourceReaderCallback) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSourceReaderCallback> for ::windows::core::IUnknown {
fn from(value: &IMFSourceReaderCallback) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSourceReaderCallback {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSourceReaderCallback {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSourceReaderCallback_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hrstatus: ::windows::core::HRESULT, dwstreamindex: u32, dwstreamflags: u32, lltimestamp: i64, psample: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, pevent: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSourceReaderCallback2(pub ::windows::core::IUnknown);
impl IMFSourceReaderCallback2 {
pub unsafe fn OnReadSample<'a, Param4: ::windows::core::IntoParam<'a, IMFSample>>(&self, hrstatus: ::windows::core::HRESULT, dwstreamindex: u32, dwstreamflags: u32, lltimestamp: i64, psample: Param4) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(hrstatus), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(dwstreamflags), ::core::mem::transmute(lltimestamp), psample.into_param().abi()).ok()
}
pub unsafe fn OnFlush(&self, dwstreamindex: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex)).ok()
}
pub unsafe fn OnEvent<'a, Param1: ::windows::core::IntoParam<'a, IMFMediaEvent>>(&self, dwstreamindex: u32, pevent: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), pevent.into_param().abi()).ok()
}
pub unsafe fn OnTransformChange(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn OnStreamError(&self, dwstreamindex: u32, hrstatus: ::windows::core::HRESULT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(hrstatus)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFSourceReaderCallback2 {
type Vtable = IMFSourceReaderCallback2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xcf839fe6_8c2a_4dd2_b6ea_c22d6961af05);
}
impl ::core::convert::From<IMFSourceReaderCallback2> for ::windows::core::IUnknown {
fn from(value: IMFSourceReaderCallback2) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSourceReaderCallback2> for ::windows::core::IUnknown {
fn from(value: &IMFSourceReaderCallback2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSourceReaderCallback2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSourceReaderCallback2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFSourceReaderCallback2> for IMFSourceReaderCallback {
fn from(value: IMFSourceReaderCallback2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFSourceReaderCallback2> for IMFSourceReaderCallback {
fn from(value: &IMFSourceReaderCallback2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFSourceReaderCallback> for IMFSourceReaderCallback2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFSourceReaderCallback> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFSourceReaderCallback> for &IMFSourceReaderCallback2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFSourceReaderCallback> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSourceReaderCallback2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hrstatus: ::windows::core::HRESULT, dwstreamindex: u32, dwstreamflags: u32, lltimestamp: i64, psample: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, pevent: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, hrstatus: ::windows::core::HRESULT) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSourceReaderEx(pub ::windows::core::IUnknown);
impl IMFSourceReaderEx {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetStreamSelection(&self, dwstreamindex: u32) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetStreamSelection<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, dwstreamindex: u32, fselected: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), fselected.into_param().abi()).ok()
}
pub unsafe fn GetNativeMediaType(&self, dwstreamindex: u32, dwmediatypeindex: u32) -> ::windows::core::Result<IMFMediaType> {
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(dwmediatypeindex), &mut result__).from_abi::<IMFMediaType>(result__)
}
pub unsafe fn GetCurrentMediaType(&self, dwstreamindex: u32) -> ::windows::core::Result<IMFMediaType> {
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), &mut result__).from_abi::<IMFMediaType>(result__)
}
pub unsafe fn SetCurrentMediaType<'a, Param2: ::windows::core::IntoParam<'a, IMFMediaType>>(&self, dwstreamindex: u32, pdwreserved: *mut u32, pmediatype: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(pdwreserved), pmediatype.into_param().abi()).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn SetCurrentPosition(&self, guidtimeformat: *const ::windows::core::GUID, varposition: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidtimeformat), ::core::mem::transmute(varposition)).ok()
}
pub unsafe fn ReadSample(&self, dwstreamindex: u32, dwcontrolflags: u32, pdwactualstreamindex: *mut u32, pdwstreamflags: *mut u32, plltimestamp: *mut i64, ppsample: *mut ::core::option::Option<IMFSample>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(dwcontrolflags), ::core::mem::transmute(pdwactualstreamindex), ::core::mem::transmute(pdwstreamflags), ::core::mem::transmute(plltimestamp), ::core::mem::transmute(ppsample)).ok()
}
pub unsafe fn Flush(&self, dwstreamindex: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex)).ok()
}
pub unsafe fn GetServiceForStream(&self, dwstreamindex: u32, guidservice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(guidservice), ::core::mem::transmute(riid), ::core::mem::transmute(ppvobject)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetPresentationAttribute(&self, dwstreamindex: u32, guidattribute: *const ::windows::core::GUID) -> ::windows::core::Result<super::super::System::Com::StructuredStorage::PROPVARIANT> {
let mut result__: <super::super::System::Com::StructuredStorage::PROPVARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(guidattribute), &mut result__).from_abi::<super::super::System::Com::StructuredStorage::PROPVARIANT>(result__)
}
pub unsafe fn SetNativeMediaType<'a, Param1: ::windows::core::IntoParam<'a, IMFMediaType>>(&self, dwstreamindex: u32, pmediatype: Param1) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), pmediatype.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddTransformForStream<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, dwstreamindex: u32, ptransformoractivate: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ptransformoractivate.into_param().abi()).ok()
}
pub unsafe fn RemoveAllTransformsForStream(&self, dwstreamindex: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex)).ok()
}
pub unsafe fn GetTransformForStream(&self, dwstreamindex: u32, dwtransformindex: u32, pguidcategory: *mut ::windows::core::GUID, pptransform: *mut ::core::option::Option<IMFTransform>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamindex), ::core::mem::transmute(dwtransformindex), ::core::mem::transmute(pguidcategory), ::core::mem::transmute(pptransform)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFSourceReaderEx {
type Vtable = IMFSourceReaderEx_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7b981cf0_560e_4116_9875_b099895f23d7);
}
impl ::core::convert::From<IMFSourceReaderEx> for ::windows::core::IUnknown {
fn from(value: IMFSourceReaderEx) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSourceReaderEx> for ::windows::core::IUnknown {
fn from(value: &IMFSourceReaderEx) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSourceReaderEx {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSourceReaderEx {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFSourceReaderEx> for IMFSourceReader {
fn from(value: IMFSourceReaderEx) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFSourceReaderEx> for IMFSourceReader {
fn from(value: &IMFSourceReaderEx) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFSourceReader> for IMFSourceReaderEx {
fn into_param(self) -> ::windows::core::Param<'a, IMFSourceReader> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFSourceReader> for &IMFSourceReaderEx {
fn into_param(self) -> ::windows::core::Param<'a, IMFSourceReader> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSourceReaderEx_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, pfselected: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, fselected: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, dwmediatypeindex: u32, ppmediatype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, ppmediatype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, pdwreserved: *mut u32, pmediatype: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidtimeformat: *const ::windows::core::GUID, varposition: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, dwcontrolflags: u32, pdwactualstreamindex: *mut u32, pdwstreamflags: *mut u32, plltimestamp: *mut i64, ppsample: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, guidservice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, guidattribute: *const ::windows::core::GUID, pvarattribute: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, pmediatype: ::windows::core::RawPtr, pdwstreamflags: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, ptransformoractivate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamindex: u32, dwtransformindex: u32, pguidcategory: *mut ::windows::core::GUID, pptransform: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSourceResolver(pub ::windows::core::IUnknown);
impl IMFSourceResolver {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem"))]
pub unsafe fn CreateObjectFromURL<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::UI::Shell::PropertiesSystem::IPropertyStore>>(&self, pwszurl: Param0, dwflags: u32, pprops: Param2, pobjecttype: *mut MF_OBJECT_TYPE, ppobject: *mut ::core::option::Option<::windows::core::IUnknown>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pwszurl.into_param().abi(), ::core::mem::transmute(dwflags), pprops.into_param().abi(), ::core::mem::transmute(pobjecttype), ::core::mem::transmute(ppobject)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem"))]
pub unsafe fn CreateObjectFromByteStream<'a, Param0: ::windows::core::IntoParam<'a, IMFByteStream>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::UI::Shell::PropertiesSystem::IPropertyStore>>(&self, pbytestream: Param0, pwszurl: Param1, dwflags: u32, pprops: Param3, pobjecttype: *mut MF_OBJECT_TYPE, ppobject: *mut ::core::option::Option<::windows::core::IUnknown>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pbytestream.into_param().abi(), pwszurl.into_param().abi(), ::core::mem::transmute(dwflags), pprops.into_param().abi(), ::core::mem::transmute(pobjecttype), ::core::mem::transmute(ppobject)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem"))]
pub unsafe fn BeginCreateObjectFromURL<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::UI::Shell::PropertiesSystem::IPropertyStore>, Param4: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param5: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(
&self,
pwszurl: Param0,
dwflags: u32,
pprops: Param2,
ppiunknowncancelcookie: *mut ::core::option::Option<::windows::core::IUnknown>,
pcallback: Param4,
punkstate: Param5,
) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pwszurl.into_param().abi(), ::core::mem::transmute(dwflags), pprops.into_param().abi(), ::core::mem::transmute(ppiunknowncancelcookie), pcallback.into_param().abi(), punkstate.into_param().abi()).ok()
}
pub unsafe fn EndCreateObjectFromURL<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0, pobjecttype: *mut MF_OBJECT_TYPE, ppobject: *mut ::core::option::Option<::windows::core::IUnknown>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), presult.into_param().abi(), ::core::mem::transmute(pobjecttype), ::core::mem::transmute(ppobject)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem"))]
pub unsafe fn BeginCreateObjectFromByteStream<'a, Param0: ::windows::core::IntoParam<'a, IMFByteStream>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::UI::Shell::PropertiesSystem::IPropertyStore>, Param5: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param6: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(
&self,
pbytestream: Param0,
pwszurl: Param1,
dwflags: u32,
pprops: Param3,
ppiunknowncancelcookie: *mut ::core::option::Option<::windows::core::IUnknown>,
pcallback: Param5,
punkstate: Param6,
) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), pbytestream.into_param().abi(), pwszurl.into_param().abi(), ::core::mem::transmute(dwflags), pprops.into_param().abi(), ::core::mem::transmute(ppiunknowncancelcookie), pcallback.into_param().abi(), punkstate.into_param().abi()).ok()
}
pub unsafe fn EndCreateObjectFromByteStream<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0, pobjecttype: *mut MF_OBJECT_TYPE, ppobject: *mut ::core::option::Option<::windows::core::IUnknown>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), presult.into_param().abi(), ::core::mem::transmute(pobjecttype), ::core::mem::transmute(ppobject)).ok()
}
pub unsafe fn CancelObjectCreation<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, piunknowncancelcookie: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), piunknowncancelcookie.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFSourceResolver {
type Vtable = IMFSourceResolver_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfbe5a32d_a497_4b61_bb85_97b1a848a6e3);
}
impl ::core::convert::From<IMFSourceResolver> for ::windows::core::IUnknown {
fn from(value: IMFSourceResolver) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSourceResolver> for ::windows::core::IUnknown {
fn from(value: &IMFSourceResolver) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSourceResolver {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSourceResolver {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSourceResolver_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pwszurl: super::super::Foundation::PWSTR, dwflags: u32, pprops: ::windows::core::RawPtr, pobjecttype: *mut MF_OBJECT_TYPE, ppobject: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbytestream: ::windows::core::RawPtr, pwszurl: super::super::Foundation::PWSTR, dwflags: u32, pprops: ::windows::core::RawPtr, pobjecttype: *mut MF_OBJECT_TYPE, ppobject: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pwszurl: super::super::Foundation::PWSTR, dwflags: u32, pprops: ::windows::core::RawPtr, ppiunknowncancelcookie: *mut ::windows::core::RawPtr, pcallback: ::windows::core::RawPtr, punkstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr, pobjecttype: *mut MF_OBJECT_TYPE, ppobject: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbytestream: ::windows::core::RawPtr, pwszurl: super::super::Foundation::PWSTR, dwflags: u32, pprops: ::windows::core::RawPtr, ppiunknowncancelcookie: *mut ::windows::core::RawPtr, pcallback: ::windows::core::RawPtr, punkstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr, pobjecttype: *mut MF_OBJECT_TYPE, ppobject: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, piunknowncancelcookie: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSpatialAudioObjectBuffer(pub ::windows::core::IUnknown);
impl IMFSpatialAudioObjectBuffer {
pub unsafe fn Lock(&self, ppbbuffer: *mut *mut u8, pcbmaxlength: *mut u32, pcbcurrentlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(ppbbuffer), ::core::mem::transmute(pcbmaxlength), ::core::mem::transmute(pcbcurrentlength)).ok()
}
pub unsafe fn Unlock(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetCurrentLength(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetCurrentLength(&self, cbcurrentlength: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(cbcurrentlength)).ok()
}
pub unsafe fn GetMaxLength(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetID(&self, u32id: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(u32id)).ok()
}
pub unsafe fn GetID(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Media_Audio")]
pub unsafe fn SetType(&self, r#type: super::Audio::AudioObjectType) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#type)).ok()
}
#[cfg(feature = "Win32_Media_Audio")]
pub unsafe fn GetType(&self) -> ::windows::core::Result<super::Audio::AudioObjectType> {
let mut result__: <super::Audio::AudioObjectType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::Audio::AudioObjectType>(result__)
}
#[cfg(feature = "Win32_Media_Audio")]
pub unsafe fn GetMetadataItems(&self) -> ::windows::core::Result<super::Audio::ISpatialAudioMetadataItems> {
let mut result__: <super::Audio::ISpatialAudioMetadataItems as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::Audio::ISpatialAudioMetadataItems>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFSpatialAudioObjectBuffer {
type Vtable = IMFSpatialAudioObjectBuffer_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd396ec8c_605e_4249_978d_72ad1c312872);
}
impl ::core::convert::From<IMFSpatialAudioObjectBuffer> for ::windows::core::IUnknown {
fn from(value: IMFSpatialAudioObjectBuffer) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSpatialAudioObjectBuffer> for ::windows::core::IUnknown {
fn from(value: &IMFSpatialAudioObjectBuffer) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSpatialAudioObjectBuffer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSpatialAudioObjectBuffer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFSpatialAudioObjectBuffer> for IMFMediaBuffer {
fn from(value: IMFSpatialAudioObjectBuffer) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFSpatialAudioObjectBuffer> for IMFMediaBuffer {
fn from(value: &IMFSpatialAudioObjectBuffer) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaBuffer> for IMFSpatialAudioObjectBuffer {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaBuffer> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaBuffer> for &IMFSpatialAudioObjectBuffer {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaBuffer> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSpatialAudioObjectBuffer_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppbbuffer: *mut *mut u8, pcbmaxlength: *mut u32, pcbcurrentlength: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcbcurrentlength: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, cbcurrentlength: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcbmaxlength: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, u32id: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pu32id: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Media_Audio")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: super::Audio::AudioObjectType) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Media_Audio"))] usize,
#[cfg(feature = "Win32_Media_Audio")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptype: *mut super::Audio::AudioObjectType) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Media_Audio"))] usize,
#[cfg(feature = "Win32_Media_Audio")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppmetadataitems: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Media_Audio"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSpatialAudioSample(pub ::windows::core::IUnknown);
impl IMFSpatialAudioSample {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItem(&self, guidkey: *const ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn GetItemType(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<MF_ATTRIBUTE_TYPE> {
let mut result__: <MF_ATTRIBUTE_TYPE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<MF_ATTRIBUTE_TYPE>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn CompareItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Compare<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, ptheirs: Param0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ptheirs.into_param().abi(), ::core::mem::transmute(matchtype), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn GetUINT32(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetUINT64(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetDouble(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<f64> {
let mut result__: <f64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<f64>(result__)
}
pub unsafe fn GetGUID(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
pub unsafe fn GetStringLength(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetString(&self, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pwszvalue), ::core::mem::transmute(cchbufsize), ::core::mem::transmute(pcchlength)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetAllocatedString(&self, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppwszvalue), ::core::mem::transmute(pcchlength)).ok()
}
pub unsafe fn GetBlobSize(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize), ::core::mem::transmute(pcbblobsize)).ok()
}
pub unsafe fn GetAllocatedBlob(&self, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppbuf), ::core::mem::transmute(pcbsize)).ok()
}
pub unsafe fn GetUnknown<T: ::windows::core::Interface>(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn SetItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value)).ok()
}
pub unsafe fn DeleteItem(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey)).ok()
}
pub unsafe fn DeleteAllItems(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetUINT32(&self, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetUINT64(&self, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetDouble(&self, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(fvalue)).ok()
}
pub unsafe fn SetGUID(&self, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(guidvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetString<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, guidkey: *const ::windows::core::GUID, wszvalue: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), wszvalue.into_param().abi()).ok()
}
pub unsafe fn SetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize)).ok()
}
pub unsafe fn SetUnknown<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guidkey: *const ::windows::core::GUID, punknown: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), punknown.into_param().abi()).ok()
}
pub unsafe fn LockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn UnlockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(unindex), ::core::mem::transmute(pguidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn CopyAllItems<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, pdest: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), pdest.into_param().abi()).ok()
}
pub unsafe fn GetSampleFlags(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetSampleFlags(&self, dwsampleflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsampleflags)).ok()
}
pub unsafe fn GetSampleTime(&self) -> ::windows::core::Result<i64> {
let mut result__: <i64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i64>(result__)
}
pub unsafe fn SetSampleTime(&self, hnssampletime: i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), ::core::mem::transmute(hnssampletime)).ok()
}
pub unsafe fn GetSampleDuration(&self) -> ::windows::core::Result<i64> {
let mut result__: <i64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i64>(result__)
}
pub unsafe fn SetSampleDuration(&self, hnssampleduration: i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self), ::core::mem::transmute(hnssampleduration)).ok()
}
pub unsafe fn GetBufferCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetBufferByIndex(&self, dwindex: u32) -> ::windows::core::Result<IMFMediaBuffer> {
let mut result__: <IMFMediaBuffer as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).40)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwindex), &mut result__).from_abi::<IMFMediaBuffer>(result__)
}
pub unsafe fn ConvertToContiguousBuffer(&self) -> ::windows::core::Result<IMFMediaBuffer> {
let mut result__: <IMFMediaBuffer as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFMediaBuffer>(result__)
}
pub unsafe fn AddBuffer<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaBuffer>>(&self, pbuffer: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self), pbuffer.into_param().abi()).ok()
}
pub unsafe fn RemoveBufferByIndex(&self, dwindex: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwindex)).ok()
}
pub unsafe fn RemoveAllBuffers(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).44)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetTotalLength(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).45)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn CopyToBuffer<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaBuffer>>(&self, pbuffer: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).46)(::core::mem::transmute_copy(self), pbuffer.into_param().abi()).ok()
}
pub unsafe fn GetObjectCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).47)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddSpatialAudioObject<'a, Param0: ::windows::core::IntoParam<'a, IMFSpatialAudioObjectBuffer>>(&self, paudioobjbuffer: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).48)(::core::mem::transmute_copy(self), paudioobjbuffer.into_param().abi()).ok()
}
pub unsafe fn GetSpatialAudioObjectByIndex(&self, dwindex: u32) -> ::windows::core::Result<IMFSpatialAudioObjectBuffer> {
let mut result__: <IMFSpatialAudioObjectBuffer as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).49)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwindex), &mut result__).from_abi::<IMFSpatialAudioObjectBuffer>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFSpatialAudioSample {
type Vtable = IMFSpatialAudioSample_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xabf28a9b_3393_4290_ba79_5ffc46d986b2);
}
impl ::core::convert::From<IMFSpatialAudioSample> for ::windows::core::IUnknown {
fn from(value: IMFSpatialAudioSample) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSpatialAudioSample> for ::windows::core::IUnknown {
fn from(value: &IMFSpatialAudioSample) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSpatialAudioSample {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSpatialAudioSample {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFSpatialAudioSample> for IMFSample {
fn from(value: IMFSpatialAudioSample) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFSpatialAudioSample> for IMFSample {
fn from(value: &IMFSpatialAudioSample) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFSample> for IMFSpatialAudioSample {
fn into_param(self) -> ::windows::core::Param<'a, IMFSample> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFSample> for &IMFSpatialAudioSample {
fn into_param(self) -> ::windows::core::Param<'a, IMFSample> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<IMFSpatialAudioSample> for IMFAttributes {
fn from(value: IMFSpatialAudioSample) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFSpatialAudioSample> for IMFAttributes {
fn from(value: &IMFSpatialAudioSample) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for IMFSpatialAudioSample {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for &IMFSpatialAudioSample {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSpatialAudioSample_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ptype: *mut MF_ATTRIBUTE_TYPE) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptheirs: ::windows::core::RawPtr, matchtype: MF_ATTRIBUTES_MATCH_TYPE, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pfvalue: *mut f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pguidvalue: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, wszvalue: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punknown: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcitems: *mut u32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdest: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwsampleflags: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsampleflags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, phnssampletime: *mut i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hnssampletime: i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, phnssampleduration: *mut i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hnssampleduration: i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwbuffercount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwindex: u32, ppbuffer: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppbuffer: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbuffer: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwindex: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcbtotallength: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbuffer: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwobjectcount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, paudioobjbuffer: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwindex: u32, ppaudioobjbuffer: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFStreamDescriptor(pub ::windows::core::IUnknown);
impl IMFStreamDescriptor {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItem(&self, guidkey: *const ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn GetItemType(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<MF_ATTRIBUTE_TYPE> {
let mut result__: <MF_ATTRIBUTE_TYPE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<MF_ATTRIBUTE_TYPE>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn CompareItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Compare<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, ptheirs: Param0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ptheirs.into_param().abi(), ::core::mem::transmute(matchtype), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn GetUINT32(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetUINT64(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetDouble(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<f64> {
let mut result__: <f64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<f64>(result__)
}
pub unsafe fn GetGUID(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
pub unsafe fn GetStringLength(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetString(&self, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pwszvalue), ::core::mem::transmute(cchbufsize), ::core::mem::transmute(pcchlength)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetAllocatedString(&self, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppwszvalue), ::core::mem::transmute(pcchlength)).ok()
}
pub unsafe fn GetBlobSize(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize), ::core::mem::transmute(pcbblobsize)).ok()
}
pub unsafe fn GetAllocatedBlob(&self, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppbuf), ::core::mem::transmute(pcbsize)).ok()
}
pub unsafe fn GetUnknown<T: ::windows::core::Interface>(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn SetItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value)).ok()
}
pub unsafe fn DeleteItem(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey)).ok()
}
pub unsafe fn DeleteAllItems(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetUINT32(&self, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetUINT64(&self, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetDouble(&self, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(fvalue)).ok()
}
pub unsafe fn SetGUID(&self, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(guidvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetString<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, guidkey: *const ::windows::core::GUID, wszvalue: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), wszvalue.into_param().abi()).ok()
}
pub unsafe fn SetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize)).ok()
}
pub unsafe fn SetUnknown<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guidkey: *const ::windows::core::GUID, punknown: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), punknown.into_param().abi()).ok()
}
pub unsafe fn LockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn UnlockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(unindex), ::core::mem::transmute(pguidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn CopyAllItems<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, pdest: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), pdest.into_param().abi()).ok()
}
pub unsafe fn GetStreamIdentifier(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetMediaTypeHandler(&self) -> ::windows::core::Result<IMFMediaTypeHandler> {
let mut result__: <IMFMediaTypeHandler as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFMediaTypeHandler>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFStreamDescriptor {
type Vtable = IMFStreamDescriptor_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x56c03d9c_9dbb_45f5_ab4b_d80f47c05938);
}
impl ::core::convert::From<IMFStreamDescriptor> for ::windows::core::IUnknown {
fn from(value: IMFStreamDescriptor) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFStreamDescriptor> for ::windows::core::IUnknown {
fn from(value: &IMFStreamDescriptor) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFStreamDescriptor {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFStreamDescriptor {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFStreamDescriptor> for IMFAttributes {
fn from(value: IMFStreamDescriptor) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFStreamDescriptor> for IMFAttributes {
fn from(value: &IMFStreamDescriptor) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for IMFStreamDescriptor {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for &IMFStreamDescriptor {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFStreamDescriptor_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ptype: *mut MF_ATTRIBUTE_TYPE) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptheirs: ::windows::core::RawPtr, matchtype: MF_ATTRIBUTES_MATCH_TYPE, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pfvalue: *mut f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pguidvalue: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, wszvalue: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punknown: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcitems: *mut u32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdest: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwstreamidentifier: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppmediatypehandler: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFStreamSink(pub ::windows::core::IUnknown);
impl IMFStreamSink {
pub unsafe fn GetEvent(&self, dwflags: MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS) -> ::windows::core::Result<IMFMediaEvent> {
let mut result__: <IMFMediaEvent as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwflags), &mut result__).from_abi::<IMFMediaEvent>(result__)
}
pub unsafe fn BeginGetEvent<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pcallback: Param0, punkstate: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pcallback.into_param().abi(), punkstate.into_param().abi()).ok()
}
pub unsafe fn EndGetEvent<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0) -> ::windows::core::Result<IMFMediaEvent> {
let mut result__: <IMFMediaEvent as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), presult.into_param().abi(), &mut result__).from_abi::<IMFMediaEvent>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn QueueEvent(&self, met: u32, guidextendedtype: *const ::windows::core::GUID, hrstatus: ::windows::core::HRESULT, pvvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(met), ::core::mem::transmute(guidextendedtype), ::core::mem::transmute(hrstatus), ::core::mem::transmute(pvvalue)).ok()
}
pub unsafe fn GetMediaSink(&self) -> ::windows::core::Result<IMFMediaSink> {
let mut result__: <IMFMediaSink as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFMediaSink>(result__)
}
pub unsafe fn GetIdentifier(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetMediaTypeHandler(&self) -> ::windows::core::Result<IMFMediaTypeHandler> {
let mut result__: <IMFMediaTypeHandler as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFMediaTypeHandler>(result__)
}
pub unsafe fn ProcessSample<'a, Param0: ::windows::core::IntoParam<'a, IMFSample>>(&self, psample: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), psample.into_param().abi()).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn PlaceMarker(&self, emarkertype: MFSTREAMSINK_MARKER_TYPE, pvarmarkervalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarcontextvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(emarkertype), ::core::mem::transmute(pvarmarkervalue), ::core::mem::transmute(pvarcontextvalue)).ok()
}
pub unsafe fn Flush(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFStreamSink {
type Vtable = IMFStreamSink_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0a97b3cf_8e7c_4a3d_8f8c_0c843dc247fb);
}
impl ::core::convert::From<IMFStreamSink> for ::windows::core::IUnknown {
fn from(value: IMFStreamSink) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFStreamSink> for ::windows::core::IUnknown {
fn from(value: &IMFStreamSink) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFStreamSink {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFStreamSink {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFStreamSink> for IMFMediaEventGenerator {
fn from(value: IMFStreamSink) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFStreamSink> for IMFMediaEventGenerator {
fn from(value: &IMFStreamSink) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaEventGenerator> for IMFStreamSink {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaEventGenerator> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaEventGenerator> for &IMFStreamSink {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaEventGenerator> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFStreamSink_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwflags: MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS, ppevent: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcallback: ::windows::core::RawPtr, punkstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr, ppevent: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, met: u32, guidextendedtype: *const ::windows::core::GUID, hrstatus: ::windows::core::HRESULT, pvvalue: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppmediasink: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwidentifier: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pphandler: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psample: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, emarkertype: MFSTREAMSINK_MARKER_TYPE, pvarmarkervalue: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>, pvarcontextvalue: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFStreamingSinkConfig(pub ::windows::core::IUnknown);
impl IMFStreamingSinkConfig {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartStreaming<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, fseekoffsetisbyteoffset: Param0, qwseekoffset: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), fseekoffsetisbyteoffset.into_param().abi(), ::core::mem::transmute(qwseekoffset)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFStreamingSinkConfig {
type Vtable = IMFStreamingSinkConfig_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9db7aa41_3cc5_40d4_8509_555804ad34cc);
}
impl ::core::convert::From<IMFStreamingSinkConfig> for ::windows::core::IUnknown {
fn from(value: IMFStreamingSinkConfig) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFStreamingSinkConfig> for ::windows::core::IUnknown {
fn from(value: &IMFStreamingSinkConfig) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFStreamingSinkConfig {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFStreamingSinkConfig {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFStreamingSinkConfig_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, fseekoffsetisbyteoffset: super::super::Foundation::BOOL, qwseekoffset: u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFSystemId(pub ::windows::core::IUnknown);
impl IMFSystemId {
pub unsafe fn GetData(&self, size: *mut u32, data: *mut *mut u8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(size), ::core::mem::transmute(data)).ok()
}
pub unsafe fn Setup(&self, stage: u32, cbin: u32, pbin: *const u8, pcbout: *mut u32, ppbout: *mut *mut u8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(stage), ::core::mem::transmute(cbin), ::core::mem::transmute(pbin), ::core::mem::transmute(pcbout), ::core::mem::transmute(ppbout)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFSystemId {
type Vtable = IMFSystemId_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfff4af3a_1fc1_4ef9_a29b_d26c49e2f31a);
}
impl ::core::convert::From<IMFSystemId> for ::windows::core::IUnknown {
fn from(value: IMFSystemId) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFSystemId> for ::windows::core::IUnknown {
fn from(value: &IMFSystemId) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFSystemId {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFSystemId {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFSystemId_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, size: *mut u32, data: *mut *mut u8) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, stage: u32, cbin: u32, pbin: *const u8, pcbout: *mut u32, ppbout: *mut *mut u8) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFTimecodeTranslate(pub ::windows::core::IUnknown);
impl IMFTimecodeTranslate {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn BeginConvertTimecodeToHNS<'a, Param1: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param2: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, ppropvartimecode: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pcallback: Param1, punkstate: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(ppropvartimecode), pcallback.into_param().abi(), punkstate.into_param().abi()).ok()
}
pub unsafe fn EndConvertTimecodeToHNS<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0) -> ::windows::core::Result<i64> {
let mut result__: <i64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), presult.into_param().abi(), &mut result__).from_abi::<i64>(result__)
}
pub unsafe fn BeginConvertHNSToTimecode<'a, Param1: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param2: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, hnstime: i64, pcallback: Param1, punkstate: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(hnstime), pcallback.into_param().abi(), punkstate.into_param().abi()).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn EndConvertHNSToTimecode<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0) -> ::windows::core::Result<super::super::System::Com::StructuredStorage::PROPVARIANT> {
let mut result__: <super::super::System::Com::StructuredStorage::PROPVARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), presult.into_param().abi(), &mut result__).from_abi::<super::super::System::Com::StructuredStorage::PROPVARIANT>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFTimecodeTranslate {
type Vtable = IMFTimecodeTranslate_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xab9d8661_f7e8_4ef4_9861_89f334f94e74);
}
impl ::core::convert::From<IMFTimecodeTranslate> for ::windows::core::IUnknown {
fn from(value: IMFTimecodeTranslate) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFTimecodeTranslate> for ::windows::core::IUnknown {
fn from(value: &IMFTimecodeTranslate) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFTimecodeTranslate {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFTimecodeTranslate {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFTimecodeTranslate_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppropvartimecode: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>, pcallback: ::windows::core::RawPtr, punkstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr, phnstime: *mut i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hnstime: i64, pcallback: ::windows::core::RawPtr, punkstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr, ppropvartimecode: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFTimedText(pub ::windows::core::IUnknown);
impl IMFTimedText {
pub unsafe fn RegisterNotifications<'a, Param0: ::windows::core::IntoParam<'a, IMFTimedTextNotify>>(&self, notify: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), notify.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SelectTrack<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, trackid: u32, selected: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(trackid), selected.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddDataSource<'a, Param0: ::windows::core::IntoParam<'a, IMFByteStream>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, bytestream: Param0, label: Param1, language: Param2, kind: MF_TIMED_TEXT_TRACK_KIND, isdefault: Param4) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), bytestream.into_param().abi(), label.into_param().abi(), language.into_param().abi(), ::core::mem::transmute(kind), isdefault.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddDataSourceFromUrl<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, url: Param0, label: Param1, language: Param2, kind: MF_TIMED_TEXT_TRACK_KIND, isdefault: Param4) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), url.into_param().abi(), label.into_param().abi(), language.into_param().abi(), ::core::mem::transmute(kind), isdefault.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddTrack<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, label: Param0, language: Param1, kind: MF_TIMED_TEXT_TRACK_KIND) -> ::windows::core::Result<IMFTimedTextTrack> {
let mut result__: <IMFTimedTextTrack as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), label.into_param().abi(), language.into_param().abi(), ::core::mem::transmute(kind), &mut result__).from_abi::<IMFTimedTextTrack>(result__)
}
pub unsafe fn RemoveTrack<'a, Param0: ::windows::core::IntoParam<'a, IMFTimedTextTrack>>(&self, track: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), track.into_param().abi()).ok()
}
pub unsafe fn GetCueTimeOffset(&self) -> ::windows::core::Result<f64> {
let mut result__: <f64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<f64>(result__)
}
pub unsafe fn SetCueTimeOffset(&self, offset: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset)).ok()
}
pub unsafe fn GetTracks(&self) -> ::windows::core::Result<IMFTimedTextTrackList> {
let mut result__: <IMFTimedTextTrackList as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFTimedTextTrackList>(result__)
}
pub unsafe fn GetActiveTracks(&self) -> ::windows::core::Result<IMFTimedTextTrackList> {
let mut result__: <IMFTimedTextTrackList as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFTimedTextTrackList>(result__)
}
pub unsafe fn GetTextTracks(&self) -> ::windows::core::Result<IMFTimedTextTrackList> {
let mut result__: <IMFTimedTextTrackList as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFTimedTextTrackList>(result__)
}
pub unsafe fn GetMetadataTracks(&self) -> ::windows::core::Result<IMFTimedTextTrackList> {
let mut result__: <IMFTimedTextTrackList as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFTimedTextTrackList>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetInBandEnabled<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, enabled: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), enabled.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsInBandEnabled(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self)))
}
}
unsafe impl ::windows::core::Interface for IMFTimedText {
type Vtable = IMFTimedText_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1f2a94c9_a3df_430d_9d0f_acd85ddc29af);
}
impl ::core::convert::From<IMFTimedText> for ::windows::core::IUnknown {
fn from(value: IMFTimedText) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFTimedText> for ::windows::core::IUnknown {
fn from(value: &IMFTimedText) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFTimedText {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFTimedText {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFTimedText_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, notify: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, trackid: u32, selected: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bytestream: ::windows::core::RawPtr, label: super::super::Foundation::PWSTR, language: super::super::Foundation::PWSTR, kind: MF_TIMED_TEXT_TRACK_KIND, isdefault: super::super::Foundation::BOOL, trackid: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, url: super::super::Foundation::PWSTR, label: super::super::Foundation::PWSTR, language: super::super::Foundation::PWSTR, kind: MF_TIMED_TEXT_TRACK_KIND, isdefault: super::super::Foundation::BOOL, trackid: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, label: super::super::Foundation::PWSTR, language: super::super::Foundation::PWSTR, kind: MF_TIMED_TEXT_TRACK_KIND, track: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, track: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, tracks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, activetracks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, texttracks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, metadatatracks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, enabled: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFTimedTextBinary(pub ::windows::core::IUnknown);
impl IMFTimedTextBinary {
pub unsafe fn GetData(&self, data: *mut *mut u8, length: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(data), ::core::mem::transmute(length)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFTimedTextBinary {
type Vtable = IMFTimedTextBinary_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4ae3a412_0545_43c4_bf6f_6b97a5c6c432);
}
impl ::core::convert::From<IMFTimedTextBinary> for ::windows::core::IUnknown {
fn from(value: IMFTimedTextBinary) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFTimedTextBinary> for ::windows::core::IUnknown {
fn from(value: &IMFTimedTextBinary) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFTimedTextBinary {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFTimedTextBinary {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFTimedTextBinary_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, data: *mut *mut u8, length: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFTimedTextBouten(pub ::windows::core::IUnknown);
impl IMFTimedTextBouten {
pub unsafe fn GetBoutenType(&self) -> ::windows::core::Result<MF_TIMED_TEXT_BOUTEN_TYPE> {
let mut result__: <MF_TIMED_TEXT_BOUTEN_TYPE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MF_TIMED_TEXT_BOUTEN_TYPE>(result__)
}
pub unsafe fn GetBoutenColor(&self) -> ::windows::core::Result<MFARGB> {
let mut result__: <MFARGB as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MFARGB>(result__)
}
pub unsafe fn GetBoutenPosition(&self) -> ::windows::core::Result<MF_TIMED_TEXT_BOUTEN_POSITION> {
let mut result__: <MF_TIMED_TEXT_BOUTEN_POSITION as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MF_TIMED_TEXT_BOUTEN_POSITION>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFTimedTextBouten {
type Vtable = IMFTimedTextBouten_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3c5f3e8a_90c0_464e_8136_898d2975f847);
}
impl ::core::convert::From<IMFTimedTextBouten> for ::windows::core::IUnknown {
fn from(value: IMFTimedTextBouten) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFTimedTextBouten> for ::windows::core::IUnknown {
fn from(value: &IMFTimedTextBouten) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFTimedTextBouten {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFTimedTextBouten {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFTimedTextBouten_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, value: *mut MF_TIMED_TEXT_BOUTEN_TYPE) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, value: *mut MFARGB) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, value: *mut MF_TIMED_TEXT_BOUTEN_POSITION) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFTimedTextCue(pub ::windows::core::IUnknown);
impl IMFTimedTextCue {
pub unsafe fn GetId(&self) -> u32 {
::core::mem::transmute((::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOriginalId(&self) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
pub unsafe fn GetCueKind(&self) -> MF_TIMED_TEXT_TRACK_KIND {
::core::mem::transmute((::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetStartTime(&self) -> f64 {
::core::mem::transmute((::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetDuration(&self) -> f64 {
::core::mem::transmute((::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetTrackId(&self) -> u32 {
::core::mem::transmute((::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetData(&self) -> ::windows::core::Result<IMFTimedTextBinary> {
let mut result__: <IMFTimedTextBinary as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFTimedTextBinary>(result__)
}
pub unsafe fn GetRegion(&self) -> ::windows::core::Result<IMFTimedTextRegion> {
let mut result__: <IMFTimedTextRegion as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFTimedTextRegion>(result__)
}
pub unsafe fn GetStyle(&self) -> ::windows::core::Result<IMFTimedTextStyle> {
let mut result__: <IMFTimedTextStyle as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFTimedTextStyle>(result__)
}
pub unsafe fn GetLineCount(&self) -> u32 {
::core::mem::transmute((::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetLine(&self, index: u32) -> ::windows::core::Result<IMFTimedTextFormattedText> {
let mut result__: <IMFTimedTextFormattedText as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<IMFTimedTextFormattedText>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFTimedTextCue {
type Vtable = IMFTimedTextCue_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1e560447_9a2b_43e1_a94c_b0aaabfbfbc9);
}
impl ::core::convert::From<IMFTimedTextCue> for ::windows::core::IUnknown {
fn from(value: IMFTimedTextCue) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFTimedTextCue> for ::windows::core::IUnknown {
fn from(value: &IMFTimedTextCue) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFTimedTextCue {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFTimedTextCue {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFTimedTextCue_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, originalid: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> MF_TIMED_TEXT_TRACK_KIND,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> f64,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> f64,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, data: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, region: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, style: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, line: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFTimedTextCueList(pub ::windows::core::IUnknown);
impl IMFTimedTextCueList {
pub unsafe fn GetLength(&self) -> u32 {
::core::mem::transmute((::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetCueByIndex(&self, index: u32) -> ::windows::core::Result<IMFTimedTextCue> {
let mut result__: <IMFTimedTextCue as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<IMFTimedTextCue>(result__)
}
pub unsafe fn GetCueById(&self, id: u32) -> ::windows::core::Result<IMFTimedTextCue> {
let mut result__: <IMFTimedTextCue as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(id), &mut result__).from_abi::<IMFTimedTextCue>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetCueByOriginalId<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, originalid: Param0) -> ::windows::core::Result<IMFTimedTextCue> {
let mut result__: <IMFTimedTextCue as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), originalid.into_param().abi(), &mut result__).from_abi::<IMFTimedTextCue>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddTextCue<'a, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, start: f64, duration: f64, text: Param2) -> ::windows::core::Result<IMFTimedTextCue> {
let mut result__: <IMFTimedTextCue as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(duration), text.into_param().abi(), &mut result__).from_abi::<IMFTimedTextCue>(result__)
}
pub unsafe fn AddDataCue(&self, start: f64, duration: f64, data: *const u8, datasize: u32) -> ::windows::core::Result<IMFTimedTextCue> {
let mut result__: <IMFTimedTextCue as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(duration), ::core::mem::transmute(data), ::core::mem::transmute(datasize), &mut result__).from_abi::<IMFTimedTextCue>(result__)
}
pub unsafe fn RemoveCue<'a, Param0: ::windows::core::IntoParam<'a, IMFTimedTextCue>>(&self, cue: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), cue.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFTimedTextCueList {
type Vtable = IMFTimedTextCueList_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xad128745_211b_40a0_9981_fe65f166d0fd);
}
impl ::core::convert::From<IMFTimedTextCueList> for ::windows::core::IUnknown {
fn from(value: IMFTimedTextCueList) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFTimedTextCueList> for ::windows::core::IUnknown {
fn from(value: &IMFTimedTextCueList) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFTimedTextCueList {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFTimedTextCueList {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFTimedTextCueList_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, cue: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: u32, cue: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, originalid: super::super::Foundation::PWSTR, cue: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: f64, duration: f64, text: super::super::Foundation::PWSTR, cue: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: f64, duration: f64, data: *const u8, datasize: u32, cue: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, cue: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFTimedTextFormattedText(pub ::windows::core::IUnknown);
impl IMFTimedTextFormattedText {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetText(&self) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
pub unsafe fn GetSubformattingCount(&self) -> u32 {
::core::mem::transmute((::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetSubformatting(&self, index: u32, firstchar: *mut u32, charlength: *mut u32, style: *mut ::core::option::Option<IMFTimedTextStyle>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(firstchar), ::core::mem::transmute(charlength), ::core::mem::transmute(style)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFTimedTextFormattedText {
type Vtable = IMFTimedTextFormattedText_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe13af3c1_4d47_4354_b1f5_e83ae0ecae60);
}
impl ::core::convert::From<IMFTimedTextFormattedText> for ::windows::core::IUnknown {
fn from(value: IMFTimedTextFormattedText) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFTimedTextFormattedText> for ::windows::core::IUnknown {
fn from(value: &IMFTimedTextFormattedText) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFTimedTextFormattedText {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFTimedTextFormattedText {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFTimedTextFormattedText_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, text: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, firstchar: *mut u32, charlength: *mut u32, style: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFTimedTextNotify(pub ::windows::core::IUnknown);
impl IMFTimedTextNotify {
pub unsafe fn TrackAdded(&self, trackid: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(trackid)))
}
pub unsafe fn TrackRemoved(&self, trackid: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(trackid)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn TrackSelected<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, trackid: u32, selected: Param1) {
::core::mem::transmute((::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(trackid), selected.into_param().abi()))
}
pub unsafe fn TrackReadyStateChanged(&self, trackid: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(trackid)))
}
pub unsafe fn Error(&self, errorcode: MF_TIMED_TEXT_ERROR_CODE, extendederrorcode: ::windows::core::HRESULT, sourcetrackid: u32) {
::core::mem::transmute((::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(errorcode), ::core::mem::transmute(extendederrorcode), ::core::mem::transmute(sourcetrackid)))
}
pub unsafe fn Cue<'a, Param2: ::windows::core::IntoParam<'a, IMFTimedTextCue>>(&self, cueevent: MF_TIMED_TEXT_CUE_EVENT, currenttime: f64, cue: Param2) {
::core::mem::transmute((::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(cueevent), ::core::mem::transmute(currenttime), cue.into_param().abi()))
}
pub unsafe fn Reset(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)))
}
}
unsafe impl ::windows::core::Interface for IMFTimedTextNotify {
type Vtable = IMFTimedTextNotify_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdf6b87b6_ce12_45db_aba7_432fe054e57d);
}
impl ::core::convert::From<IMFTimedTextNotify> for ::windows::core::IUnknown {
fn from(value: IMFTimedTextNotify) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFTimedTextNotify> for ::windows::core::IUnknown {
fn from(value: &IMFTimedTextNotify) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFTimedTextNotify {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFTimedTextNotify {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFTimedTextNotify_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, trackid: u32),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, trackid: u32),
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, trackid: u32, selected: super::super::Foundation::BOOL),
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, trackid: u32),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, errorcode: MF_TIMED_TEXT_ERROR_CODE, extendederrorcode: ::windows::core::HRESULT, sourcetrackid: u32),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, cueevent: MF_TIMED_TEXT_CUE_EVENT, currenttime: f64, cue: ::windows::core::RawPtr),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFTimedTextRegion(pub ::windows::core::IUnknown);
impl IMFTimedTextRegion {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
pub unsafe fn GetPosition(&self, px: *mut f64, py: *mut f64, unittype: *mut MF_TIMED_TEXT_UNIT_TYPE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(px), ::core::mem::transmute(py), ::core::mem::transmute(unittype)).ok()
}
pub unsafe fn GetExtent(&self, pwidth: *mut f64, pheight: *mut f64, unittype: *mut MF_TIMED_TEXT_UNIT_TYPE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(pwidth), ::core::mem::transmute(pheight), ::core::mem::transmute(unittype)).ok()
}
pub unsafe fn GetBackgroundColor(&self) -> ::windows::core::Result<MFARGB> {
let mut result__: <MFARGB as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MFARGB>(result__)
}
pub unsafe fn GetWritingMode(&self) -> ::windows::core::Result<MF_TIMED_TEXT_WRITING_MODE> {
let mut result__: <MF_TIMED_TEXT_WRITING_MODE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MF_TIMED_TEXT_WRITING_MODE>(result__)
}
pub unsafe fn GetDisplayAlignment(&self) -> ::windows::core::Result<MF_TIMED_TEXT_DISPLAY_ALIGNMENT> {
let mut result__: <MF_TIMED_TEXT_DISPLAY_ALIGNMENT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MF_TIMED_TEXT_DISPLAY_ALIGNMENT>(result__)
}
pub unsafe fn GetLineHeight(&self, plineheight: *mut f64, unittype: *mut MF_TIMED_TEXT_UNIT_TYPE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(plineheight), ::core::mem::transmute(unittype)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetClipOverflow(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn GetPadding(&self, before: *mut f64, start: *mut f64, after: *mut f64, end: *mut f64, unittype: *mut MF_TIMED_TEXT_UNIT_TYPE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(before), ::core::mem::transmute(start), ::core::mem::transmute(after), ::core::mem::transmute(end), ::core::mem::transmute(unittype)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetWrap(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn GetZIndex(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn GetScrollMode(&self) -> ::windows::core::Result<MF_TIMED_TEXT_SCROLL_MODE> {
let mut result__: <MF_TIMED_TEXT_SCROLL_MODE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MF_TIMED_TEXT_SCROLL_MODE>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFTimedTextRegion {
type Vtable = IMFTimedTextRegion_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc8d22afc_bc47_4bdf_9b04_787e49ce3f58);
}
impl ::core::convert::From<IMFTimedTextRegion> for ::windows::core::IUnknown {
fn from(value: IMFTimedTextRegion) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFTimedTextRegion> for ::windows::core::IUnknown {
fn from(value: &IMFTimedTextRegion) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFTimedTextRegion {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFTimedTextRegion {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFTimedTextRegion_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, px: *mut f64, py: *mut f64, unittype: *mut MF_TIMED_TEXT_UNIT_TYPE) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pwidth: *mut f64, pheight: *mut f64, unittype: *mut MF_TIMED_TEXT_UNIT_TYPE) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bgcolor: *mut MFARGB) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, writingmode: *mut MF_TIMED_TEXT_WRITING_MODE) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, displayalign: *mut MF_TIMED_TEXT_DISPLAY_ALIGNMENT) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, plineheight: *mut f64, unittype: *mut MF_TIMED_TEXT_UNIT_TYPE) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, clipoverflow: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, before: *mut f64, start: *mut f64, after: *mut f64, end: *mut f64, unittype: *mut MF_TIMED_TEXT_UNIT_TYPE) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, wrap: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, zindex: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, scrollmode: *mut MF_TIMED_TEXT_SCROLL_MODE) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFTimedTextRuby(pub ::windows::core::IUnknown);
impl IMFTimedTextRuby {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRubyText(&self) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
pub unsafe fn GetRubyPosition(&self) -> ::windows::core::Result<MF_TIMED_TEXT_RUBY_POSITION> {
let mut result__: <MF_TIMED_TEXT_RUBY_POSITION as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MF_TIMED_TEXT_RUBY_POSITION>(result__)
}
pub unsafe fn GetRubyAlign(&self) -> ::windows::core::Result<MF_TIMED_TEXT_RUBY_ALIGN> {
let mut result__: <MF_TIMED_TEXT_RUBY_ALIGN as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MF_TIMED_TEXT_RUBY_ALIGN>(result__)
}
pub unsafe fn GetRubyReserve(&self) -> ::windows::core::Result<MF_TIMED_TEXT_RUBY_RESERVE> {
let mut result__: <MF_TIMED_TEXT_RUBY_RESERVE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MF_TIMED_TEXT_RUBY_RESERVE>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFTimedTextRuby {
type Vtable = IMFTimedTextRuby_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x76c6a6f5_4955_4de5_b27b_14b734cc14b4);
}
impl ::core::convert::From<IMFTimedTextRuby> for ::windows::core::IUnknown {
fn from(value: IMFTimedTextRuby) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFTimedTextRuby> for ::windows::core::IUnknown {
fn from(value: &IMFTimedTextRuby) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFTimedTextRuby {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFTimedTextRuby {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFTimedTextRuby_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rubytext: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, value: *mut MF_TIMED_TEXT_RUBY_POSITION) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, value: *mut MF_TIMED_TEXT_RUBY_ALIGN) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, value: *mut MF_TIMED_TEXT_RUBY_RESERVE) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFTimedTextStyle(pub ::windows::core::IUnknown);
impl IMFTimedTextStyle {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsExternal(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetFontFamily(&self) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
pub unsafe fn GetFontSize(&self, fontsize: *mut f64, unittype: *mut MF_TIMED_TEXT_UNIT_TYPE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(fontsize), ::core::mem::transmute(unittype)).ok()
}
pub unsafe fn GetColor(&self) -> ::windows::core::Result<MFARGB> {
let mut result__: <MFARGB as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MFARGB>(result__)
}
pub unsafe fn GetBackgroundColor(&self) -> ::windows::core::Result<MFARGB> {
let mut result__: <MFARGB as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MFARGB>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetShowBackgroundAlways(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn GetFontStyle(&self) -> ::windows::core::Result<MF_TIMED_TEXT_FONT_STYLE> {
let mut result__: <MF_TIMED_TEXT_FONT_STYLE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MF_TIMED_TEXT_FONT_STYLE>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetBold(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRightToLeft(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn GetTextAlignment(&self) -> ::windows::core::Result<MF_TIMED_TEXT_ALIGNMENT> {
let mut result__: <MF_TIMED_TEXT_ALIGNMENT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MF_TIMED_TEXT_ALIGNMENT>(result__)
}
pub unsafe fn GetTextDecoration(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetTextOutline(&self, color: *mut MFARGB, thickness: *mut f64, blurradius: *mut f64, unittype: *mut MF_TIMED_TEXT_UNIT_TYPE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(color), ::core::mem::transmute(thickness), ::core::mem::transmute(blurradius), ::core::mem::transmute(unittype)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFTimedTextStyle {
type Vtable = IMFTimedTextStyle_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x09b2455d_b834_4f01_a347_9052e21c450e);
}
impl ::core::convert::From<IMFTimedTextStyle> for ::windows::core::IUnknown {
fn from(value: IMFTimedTextStyle) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFTimedTextStyle> for ::windows::core::IUnknown {
fn from(value: &IMFTimedTextStyle) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFTimedTextStyle {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFTimedTextStyle {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFTimedTextStyle_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, fontfamily: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, fontsize: *mut f64, unittype: *mut MF_TIMED_TEXT_UNIT_TYPE) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, color: *mut MFARGB) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bgcolor: *mut MFARGB) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, showbackgroundalways: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, fontstyle: *mut MF_TIMED_TEXT_FONT_STYLE) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bold: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, righttoleft: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, textalign: *mut MF_TIMED_TEXT_ALIGNMENT) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, textdecoration: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, color: *mut MFARGB, thickness: *mut f64, blurradius: *mut f64, unittype: *mut MF_TIMED_TEXT_UNIT_TYPE) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFTimedTextStyle2(pub ::windows::core::IUnknown);
impl IMFTimedTextStyle2 {
pub unsafe fn GetRuby(&self) -> ::windows::core::Result<IMFTimedTextRuby> {
let mut result__: <IMFTimedTextRuby as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFTimedTextRuby>(result__)
}
pub unsafe fn GetBouten(&self) -> ::windows::core::Result<IMFTimedTextBouten> {
let mut result__: <IMFTimedTextBouten as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFTimedTextBouten>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsTextCombined(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn GetFontAngleInDegrees(&self) -> ::windows::core::Result<f64> {
let mut result__: <f64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<f64>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFTimedTextStyle2 {
type Vtable = IMFTimedTextStyle2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdb639199_c809_4c89_bfca_d0bbb9729d6e);
}
impl ::core::convert::From<IMFTimedTextStyle2> for ::windows::core::IUnknown {
fn from(value: IMFTimedTextStyle2) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFTimedTextStyle2> for ::windows::core::IUnknown {
fn from(value: &IMFTimedTextStyle2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFTimedTextStyle2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFTimedTextStyle2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFTimedTextStyle2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ruby: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bouten: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, value: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, value: *mut f64) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFTimedTextTrack(pub ::windows::core::IUnknown);
impl IMFTimedTextTrack {
pub unsafe fn GetId(&self) -> u32 {
::core::mem::transmute((::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLabel(&self) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetLabel<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, label: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), label.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLanguage(&self) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
pub unsafe fn GetTrackKind(&self) -> MF_TIMED_TEXT_TRACK_KIND {
::core::mem::transmute((::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsInBand(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetInBandMetadataTrackDispatchType(&self) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsActive(&self) -> super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetErrorCode(&self) -> MF_TIMED_TEXT_ERROR_CODE {
::core::mem::transmute((::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetExtendedErrorCode(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetDataFormat(&self) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
pub unsafe fn GetReadyState(&self) -> MF_TIMED_TEXT_TRACK_READY_STATE {
::core::mem::transmute((::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetCueList(&self) -> ::windows::core::Result<IMFTimedTextCueList> {
let mut result__: <IMFTimedTextCueList as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFTimedTextCueList>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFTimedTextTrack {
type Vtable = IMFTimedTextTrack_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8822c32d_654e_4233_bf21_d7f2e67d30d4);
}
impl ::core::convert::From<IMFTimedTextTrack> for ::windows::core::IUnknown {
fn from(value: IMFTimedTextTrack) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFTimedTextTrack> for ::windows::core::IUnknown {
fn from(value: &IMFTimedTextTrack) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFTimedTextTrack {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFTimedTextTrack {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFTimedTextTrack_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, label: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, label: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, language: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> MF_TIMED_TEXT_TRACK_KIND,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispatchtype: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> MF_TIMED_TEXT_ERROR_CODE,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, format: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> MF_TIMED_TEXT_TRACK_READY_STATE,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, cues: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFTimedTextTrackList(pub ::windows::core::IUnknown);
impl IMFTimedTextTrackList {
pub unsafe fn GetLength(&self) -> u32 {
::core::mem::transmute((::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetTrack(&self, index: u32) -> ::windows::core::Result<IMFTimedTextTrack> {
let mut result__: <IMFTimedTextTrack as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<IMFTimedTextTrack>(result__)
}
pub unsafe fn GetTrackById(&self, trackid: u32) -> ::windows::core::Result<IMFTimedTextTrack> {
let mut result__: <IMFTimedTextTrack as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(trackid), &mut result__).from_abi::<IMFTimedTextTrack>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFTimedTextTrackList {
type Vtable = IMFTimedTextTrackList_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x23ff334c_442c_445f_bccc_edc438aa11e2);
}
impl ::core::convert::From<IMFTimedTextTrackList> for ::windows::core::IUnknown {
fn from(value: IMFTimedTextTrackList) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFTimedTextTrackList> for ::windows::core::IUnknown {
fn from(value: &IMFTimedTextTrackList) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFTimedTextTrackList {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFTimedTextTrackList {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFTimedTextTrackList_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, track: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, trackid: u32, track: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFTimer(pub ::windows::core::IUnknown);
impl IMFTimer {
pub unsafe fn SetTimer<'a, Param2: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param3: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, dwflags: u32, llclocktime: i64, pcallback: Param2, punkstate: Param3) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwflags), ::core::mem::transmute(llclocktime), pcallback.into_param().abi(), punkstate.into_param().abi(), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
pub unsafe fn CancelTimer<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, punkkey: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), punkkey.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFTimer {
type Vtable = IMFTimer_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe56e4cbd_8f70_49d8_a0f8_edb3d6ab9bf2);
}
impl ::core::convert::From<IMFTimer> for ::windows::core::IUnknown {
fn from(value: IMFTimer) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFTimer> for ::windows::core::IUnknown {
fn from(value: &IMFTimer) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFTimer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFTimer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFTimer_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwflags: u32, llclocktime: i64, pcallback: ::windows::core::RawPtr, punkstate: ::windows::core::RawPtr, ppunkkey: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, punkkey: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFTopoLoader(pub ::windows::core::IUnknown);
impl IMFTopoLoader {
pub unsafe fn Load<'a, Param0: ::windows::core::IntoParam<'a, IMFTopology>, Param2: ::windows::core::IntoParam<'a, IMFTopology>>(&self, pinputtopo: Param0, ppoutputtopo: *mut ::core::option::Option<IMFTopology>, pcurrenttopo: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pinputtopo.into_param().abi(), ::core::mem::transmute(ppoutputtopo), pcurrenttopo.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFTopoLoader {
type Vtable = IMFTopoLoader_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xde9a6157_f660_4643_b56a_df9f7998c7cd);
}
impl ::core::convert::From<IMFTopoLoader> for ::windows::core::IUnknown {
fn from(value: IMFTopoLoader) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFTopoLoader> for ::windows::core::IUnknown {
fn from(value: &IMFTopoLoader) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFTopoLoader {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFTopoLoader {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFTopoLoader_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pinputtopo: ::windows::core::RawPtr, ppoutputtopo: *mut ::windows::core::RawPtr, pcurrenttopo: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFTopology(pub ::windows::core::IUnknown);
impl IMFTopology {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItem(&self, guidkey: *const ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn GetItemType(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<MF_ATTRIBUTE_TYPE> {
let mut result__: <MF_ATTRIBUTE_TYPE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<MF_ATTRIBUTE_TYPE>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn CompareItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Compare<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, ptheirs: Param0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ptheirs.into_param().abi(), ::core::mem::transmute(matchtype), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn GetUINT32(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetUINT64(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetDouble(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<f64> {
let mut result__: <f64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<f64>(result__)
}
pub unsafe fn GetGUID(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
pub unsafe fn GetStringLength(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetString(&self, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pwszvalue), ::core::mem::transmute(cchbufsize), ::core::mem::transmute(pcchlength)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetAllocatedString(&self, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppwszvalue), ::core::mem::transmute(pcchlength)).ok()
}
pub unsafe fn GetBlobSize(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize), ::core::mem::transmute(pcbblobsize)).ok()
}
pub unsafe fn GetAllocatedBlob(&self, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppbuf), ::core::mem::transmute(pcbsize)).ok()
}
pub unsafe fn GetUnknown<T: ::windows::core::Interface>(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn SetItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value)).ok()
}
pub unsafe fn DeleteItem(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey)).ok()
}
pub unsafe fn DeleteAllItems(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetUINT32(&self, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetUINT64(&self, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetDouble(&self, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(fvalue)).ok()
}
pub unsafe fn SetGUID(&self, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(guidvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetString<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, guidkey: *const ::windows::core::GUID, wszvalue: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), wszvalue.into_param().abi()).ok()
}
pub unsafe fn SetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize)).ok()
}
pub unsafe fn SetUnknown<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guidkey: *const ::windows::core::GUID, punknown: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), punknown.into_param().abi()).ok()
}
pub unsafe fn LockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn UnlockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(unindex), ::core::mem::transmute(pguidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn CopyAllItems<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, pdest: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), pdest.into_param().abi()).ok()
}
pub unsafe fn GetTopologyID(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn AddNode<'a, Param0: ::windows::core::IntoParam<'a, IMFTopologyNode>>(&self, pnode: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), pnode.into_param().abi()).ok()
}
pub unsafe fn RemoveNode<'a, Param0: ::windows::core::IntoParam<'a, IMFTopologyNode>>(&self, pnode: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), pnode.into_param().abi()).ok()
}
pub unsafe fn GetNodeCount(&self) -> ::windows::core::Result<u16> {
let mut result__: <u16 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u16>(result__)
}
pub unsafe fn GetNode(&self, windex: u16) -> ::windows::core::Result<IMFTopologyNode> {
let mut result__: <IMFTopologyNode as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), ::core::mem::transmute(windex), &mut result__).from_abi::<IMFTopologyNode>(result__)
}
pub unsafe fn Clear(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn CloneFrom<'a, Param0: ::windows::core::IntoParam<'a, IMFTopology>>(&self, ptopology: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), ptopology.into_param().abi()).ok()
}
pub unsafe fn GetNodeByID(&self, qwtoponodeid: u64) -> ::windows::core::Result<IMFTopologyNode> {
let mut result__: <IMFTopologyNode as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).40)(::core::mem::transmute_copy(self), ::core::mem::transmute(qwtoponodeid), &mut result__).from_abi::<IMFTopologyNode>(result__)
}
pub unsafe fn GetSourceNodeCollection(&self) -> ::windows::core::Result<IMFCollection> {
let mut result__: <IMFCollection as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFCollection>(result__)
}
pub unsafe fn GetOutputNodeCollection(&self) -> ::windows::core::Result<IMFCollection> {
let mut result__: <IMFCollection as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFCollection>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFTopology {
type Vtable = IMFTopology_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x83cf873a_f6da_4bc8_823f_bacfd55dc433);
}
impl ::core::convert::From<IMFTopology> for ::windows::core::IUnknown {
fn from(value: IMFTopology) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFTopology> for ::windows::core::IUnknown {
fn from(value: &IMFTopology) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFTopology {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFTopology {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFTopology> for IMFAttributes {
fn from(value: IMFTopology) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFTopology> for IMFAttributes {
fn from(value: &IMFTopology) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for IMFTopology {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for &IMFTopology {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFTopology_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ptype: *mut MF_ATTRIBUTE_TYPE) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptheirs: ::windows::core::RawPtr, matchtype: MF_ATTRIBUTES_MATCH_TYPE, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pfvalue: *mut f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pguidvalue: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, wszvalue: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punknown: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcitems: *mut u32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdest: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pid: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pnode: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pnode: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pwnodes: *mut u16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, windex: u16, ppnode: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptopology: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, qwtoponodeid: u64, ppnode: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppcollection: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppcollection: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFTopologyNode(pub ::windows::core::IUnknown);
impl IMFTopologyNode {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItem(&self, guidkey: *const ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn GetItemType(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<MF_ATTRIBUTE_TYPE> {
let mut result__: <MF_ATTRIBUTE_TYPE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<MF_ATTRIBUTE_TYPE>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn CompareItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Compare<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, ptheirs: Param0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ptheirs.into_param().abi(), ::core::mem::transmute(matchtype), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn GetUINT32(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetUINT64(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetDouble(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<f64> {
let mut result__: <f64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<f64>(result__)
}
pub unsafe fn GetGUID(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
pub unsafe fn GetStringLength(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetString(&self, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pwszvalue), ::core::mem::transmute(cchbufsize), ::core::mem::transmute(pcchlength)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetAllocatedString(&self, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppwszvalue), ::core::mem::transmute(pcchlength)).ok()
}
pub unsafe fn GetBlobSize(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize), ::core::mem::transmute(pcbblobsize)).ok()
}
pub unsafe fn GetAllocatedBlob(&self, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppbuf), ::core::mem::transmute(pcbsize)).ok()
}
pub unsafe fn GetUnknown<T: ::windows::core::Interface>(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn SetItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value)).ok()
}
pub unsafe fn DeleteItem(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey)).ok()
}
pub unsafe fn DeleteAllItems(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetUINT32(&self, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetUINT64(&self, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetDouble(&self, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(fvalue)).ok()
}
pub unsafe fn SetGUID(&self, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(guidvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetString<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, guidkey: *const ::windows::core::GUID, wszvalue: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), wszvalue.into_param().abi()).ok()
}
pub unsafe fn SetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize)).ok()
}
pub unsafe fn SetUnknown<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guidkey: *const ::windows::core::GUID, punknown: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), punknown.into_param().abi()).ok()
}
pub unsafe fn LockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn UnlockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(unindex), ::core::mem::transmute(pguidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn CopyAllItems<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, pdest: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), pdest.into_param().abi()).ok()
}
pub unsafe fn SetObject<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pobject: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), pobject.into_param().abi()).ok()
}
pub unsafe fn GetObject(&self) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
pub unsafe fn GetNodeType(&self) -> ::windows::core::Result<MF_TOPOLOGY_TYPE> {
let mut result__: <MF_TOPOLOGY_TYPE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MF_TOPOLOGY_TYPE>(result__)
}
pub unsafe fn GetTopoNodeID(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn SetTopoNodeID(&self, ulltopoid: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulltopoid)).ok()
}
pub unsafe fn GetInputCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetOutputCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn ConnectOutput<'a, Param1: ::windows::core::IntoParam<'a, IMFTopologyNode>>(&self, dwoutputindex: u32, pdownstreamnode: Param1, dwinputindexondownstreamnode: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).40)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwoutputindex), pdownstreamnode.into_param().abi(), ::core::mem::transmute(dwinputindexondownstreamnode)).ok()
}
pub unsafe fn DisconnectOutput(&self, dwoutputindex: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwoutputindex)).ok()
}
pub unsafe fn GetInput(&self, dwinputindex: u32, ppupstreamnode: *mut ::core::option::Option<IMFTopologyNode>, pdwoutputindexonupstreamnode: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwinputindex), ::core::mem::transmute(ppupstreamnode), ::core::mem::transmute(pdwoutputindexonupstreamnode)).ok()
}
pub unsafe fn GetOutput(&self, dwoutputindex: u32, ppdownstreamnode: *mut ::core::option::Option<IMFTopologyNode>, pdwinputindexondownstreamnode: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwoutputindex), ::core::mem::transmute(ppdownstreamnode), ::core::mem::transmute(pdwinputindexondownstreamnode)).ok()
}
pub unsafe fn SetOutputPrefType<'a, Param1: ::windows::core::IntoParam<'a, IMFMediaType>>(&self, dwoutputindex: u32, ptype: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).44)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwoutputindex), ptype.into_param().abi()).ok()
}
pub unsafe fn GetOutputPrefType(&self, dwoutputindex: u32) -> ::windows::core::Result<IMFMediaType> {
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).45)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwoutputindex), &mut result__).from_abi::<IMFMediaType>(result__)
}
pub unsafe fn SetInputPrefType<'a, Param1: ::windows::core::IntoParam<'a, IMFMediaType>>(&self, dwinputindex: u32, ptype: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).46)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwinputindex), ptype.into_param().abi()).ok()
}
pub unsafe fn GetInputPrefType(&self, dwinputindex: u32) -> ::windows::core::Result<IMFMediaType> {
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).47)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwinputindex), &mut result__).from_abi::<IMFMediaType>(result__)
}
pub unsafe fn CloneFrom<'a, Param0: ::windows::core::IntoParam<'a, IMFTopologyNode>>(&self, pnode: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).48)(::core::mem::transmute_copy(self), pnode.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFTopologyNode {
type Vtable = IMFTopologyNode_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x83cf873a_f6da_4bc8_823f_bacfd55dc430);
}
impl ::core::convert::From<IMFTopologyNode> for ::windows::core::IUnknown {
fn from(value: IMFTopologyNode) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFTopologyNode> for ::windows::core::IUnknown {
fn from(value: &IMFTopologyNode) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFTopologyNode {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFTopologyNode {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFTopologyNode> for IMFAttributes {
fn from(value: IMFTopologyNode) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFTopologyNode> for IMFAttributes {
fn from(value: &IMFTopologyNode) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for IMFTopologyNode {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for &IMFTopologyNode {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFTopologyNode_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ptype: *mut MF_ATTRIBUTE_TYPE) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptheirs: ::windows::core::RawPtr, matchtype: MF_ATTRIBUTES_MATCH_TYPE, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pfvalue: *mut f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pguidvalue: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, wszvalue: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punknown: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcitems: *mut u32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdest: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pobject: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppobject: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptype: *mut MF_TOPOLOGY_TYPE) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pid: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulltopoid: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcinputs: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcoutputs: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwoutputindex: u32, pdownstreamnode: ::windows::core::RawPtr, dwinputindexondownstreamnode: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwoutputindex: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwinputindex: u32, ppupstreamnode: *mut ::windows::core::RawPtr, pdwoutputindexonupstreamnode: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwoutputindex: u32, ppdownstreamnode: *mut ::windows::core::RawPtr, pdwinputindexondownstreamnode: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwoutputindex: u32, ptype: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwoutputindex: u32, pptype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwinputindex: u32, ptype: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwinputindex: u32, pptype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pnode: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFTopologyNodeAttributeEditor(pub ::windows::core::IUnknown);
impl IMFTopologyNodeAttributeEditor {
pub unsafe fn UpdateNodeAttributes(&self, topoid: u64, cupdates: u32, pupdates: *const MFTOPONODE_ATTRIBUTE_UPDATE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(topoid), ::core::mem::transmute(cupdates), ::core::mem::transmute(pupdates)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFTopologyNodeAttributeEditor {
type Vtable = IMFTopologyNodeAttributeEditor_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x676aa6dd_238a_410d_bb99_65668d01605a);
}
impl ::core::convert::From<IMFTopologyNodeAttributeEditor> for ::windows::core::IUnknown {
fn from(value: IMFTopologyNodeAttributeEditor) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFTopologyNodeAttributeEditor> for ::windows::core::IUnknown {
fn from(value: &IMFTopologyNodeAttributeEditor) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFTopologyNodeAttributeEditor {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFTopologyNodeAttributeEditor {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFTopologyNodeAttributeEditor_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, topoid: u64, cupdates: u32, pupdates: *const MFTOPONODE_ATTRIBUTE_UPDATE) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFTopologyServiceLookup(pub ::windows::core::IUnknown);
impl IMFTopologyServiceLookup {
pub unsafe fn LookupService(&self, r#type: MF_SERVICE_LOOKUP_TYPE, dwindex: u32, guidservice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppvobjects: *mut *mut ::core::ffi::c_void, pnobjects: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#type), ::core::mem::transmute(dwindex), ::core::mem::transmute(guidservice), ::core::mem::transmute(riid), ::core::mem::transmute(ppvobjects), ::core::mem::transmute(pnobjects)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFTopologyServiceLookup {
type Vtable = IMFTopologyServiceLookup_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfa993889_4383_415a_a930_dd472a8cf6f7);
}
impl ::core::convert::From<IMFTopologyServiceLookup> for ::windows::core::IUnknown {
fn from(value: IMFTopologyServiceLookup) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFTopologyServiceLookup> for ::windows::core::IUnknown {
fn from(value: &IMFTopologyServiceLookup) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFTopologyServiceLookup {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFTopologyServiceLookup {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFTopologyServiceLookup_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: MF_SERVICE_LOOKUP_TYPE, dwindex: u32, guidservice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppvobjects: *mut *mut ::core::ffi::c_void, pnobjects: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFTopologyServiceLookupClient(pub ::windows::core::IUnknown);
impl IMFTopologyServiceLookupClient {
pub unsafe fn InitServicePointers<'a, Param0: ::windows::core::IntoParam<'a, IMFTopologyServiceLookup>>(&self, plookup: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), plookup.into_param().abi()).ok()
}
pub unsafe fn ReleaseServicePointers(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFTopologyServiceLookupClient {
type Vtable = IMFTopologyServiceLookupClient_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfa99388a_4383_415a_a930_dd472a8cf6f7);
}
impl ::core::convert::From<IMFTopologyServiceLookupClient> for ::windows::core::IUnknown {
fn from(value: IMFTopologyServiceLookupClient) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFTopologyServiceLookupClient> for ::windows::core::IUnknown {
fn from(value: &IMFTopologyServiceLookupClient) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFTopologyServiceLookupClient {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFTopologyServiceLookupClient {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFTopologyServiceLookupClient_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, plookup: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFTrackedSample(pub ::windows::core::IUnknown);
impl IMFTrackedSample {
pub unsafe fn SetAllocator<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, psampleallocator: Param0, punkstate: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), psampleallocator.into_param().abi(), punkstate.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFTrackedSample {
type Vtable = IMFTrackedSample_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x245bf8e9_0755_40f7_88a5_ae0f18d55e17);
}
impl ::core::convert::From<IMFTrackedSample> for ::windows::core::IUnknown {
fn from(value: IMFTrackedSample) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFTrackedSample> for ::windows::core::IUnknown {
fn from(value: &IMFTrackedSample) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFTrackedSample {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFTrackedSample {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFTrackedSample_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psampleallocator: ::windows::core::RawPtr, punkstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFTranscodeProfile(pub ::windows::core::IUnknown);
impl IMFTranscodeProfile {
pub unsafe fn SetAudioAttributes<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, pattrs: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pattrs.into_param().abi()).ok()
}
pub unsafe fn GetAudioAttributes(&self) -> ::windows::core::Result<IMFAttributes> {
let mut result__: <IMFAttributes as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFAttributes>(result__)
}
pub unsafe fn SetVideoAttributes<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, pattrs: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pattrs.into_param().abi()).ok()
}
pub unsafe fn GetVideoAttributes(&self) -> ::windows::core::Result<IMFAttributes> {
let mut result__: <IMFAttributes as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFAttributes>(result__)
}
pub unsafe fn SetContainerAttributes<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, pattrs: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), pattrs.into_param().abi()).ok()
}
pub unsafe fn GetContainerAttributes(&self) -> ::windows::core::Result<IMFAttributes> {
let mut result__: <IMFAttributes as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFAttributes>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFTranscodeProfile {
type Vtable = IMFTranscodeProfile_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4adfdba3_7ab0_4953_a62b_461e7ff3da1e);
}
impl ::core::convert::From<IMFTranscodeProfile> for ::windows::core::IUnknown {
fn from(value: IMFTranscodeProfile) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFTranscodeProfile> for ::windows::core::IUnknown {
fn from(value: &IMFTranscodeProfile) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFTranscodeProfile {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFTranscodeProfile {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFTranscodeProfile_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pattrs: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppattrs: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pattrs: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppattrs: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pattrs: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppattrs: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFTranscodeSinkInfoProvider(pub ::windows::core::IUnknown);
impl IMFTranscodeSinkInfoProvider {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetOutputFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pwszfilename: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pwszfilename.into_param().abi()).ok()
}
pub unsafe fn SetOutputByteStream<'a, Param0: ::windows::core::IntoParam<'a, IMFActivate>>(&self, pbytestreamactivate: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pbytestreamactivate.into_param().abi()).ok()
}
pub unsafe fn SetProfile<'a, Param0: ::windows::core::IntoParam<'a, IMFTranscodeProfile>>(&self, pprofile: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pprofile.into_param().abi()).ok()
}
pub unsafe fn GetSinkInfo(&self) -> ::windows::core::Result<MF_TRANSCODE_SINK_INFO> {
let mut result__: <MF_TRANSCODE_SINK_INFO as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MF_TRANSCODE_SINK_INFO>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFTranscodeSinkInfoProvider {
type Vtable = IMFTranscodeSinkInfoProvider_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8cffcd2e_5a03_4a3a_aff7_edcd107c620e);
}
impl ::core::convert::From<IMFTranscodeSinkInfoProvider> for ::windows::core::IUnknown {
fn from(value: IMFTranscodeSinkInfoProvider) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFTranscodeSinkInfoProvider> for ::windows::core::IUnknown {
fn from(value: &IMFTranscodeSinkInfoProvider) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFTranscodeSinkInfoProvider {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFTranscodeSinkInfoProvider {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFTranscodeSinkInfoProvider_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pwszfilename: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbytestreamactivate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pprofile: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psinkinfo: *mut ::core::mem::ManuallyDrop<MF_TRANSCODE_SINK_INFO>) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFTransform(pub ::windows::core::IUnknown);
impl IMFTransform {
pub unsafe fn GetStreamLimits(&self, pdwinputminimum: *mut u32, pdwinputmaximum: *mut u32, pdwoutputminimum: *mut u32, pdwoutputmaximum: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdwinputminimum), ::core::mem::transmute(pdwinputmaximum), ::core::mem::transmute(pdwoutputminimum), ::core::mem::transmute(pdwoutputmaximum)).ok()
}
pub unsafe fn GetStreamCount(&self, pcinputstreams: *mut u32, pcoutputstreams: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pcinputstreams), ::core::mem::transmute(pcoutputstreams)).ok()
}
pub unsafe fn GetStreamIDs(&self, dwinputidarraysize: u32, pdwinputids: *mut u32, dwoutputidarraysize: u32, pdwoutputids: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwinputidarraysize), ::core::mem::transmute(pdwinputids), ::core::mem::transmute(dwoutputidarraysize), ::core::mem::transmute(pdwoutputids)).ok()
}
pub unsafe fn GetInputStreamInfo(&self, dwinputstreamid: u32) -> ::windows::core::Result<MFT_INPUT_STREAM_INFO> {
let mut result__: <MFT_INPUT_STREAM_INFO as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwinputstreamid), &mut result__).from_abi::<MFT_INPUT_STREAM_INFO>(result__)
}
pub unsafe fn GetOutputStreamInfo(&self, dwoutputstreamid: u32) -> ::windows::core::Result<MFT_OUTPUT_STREAM_INFO> {
let mut result__: <MFT_OUTPUT_STREAM_INFO as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwoutputstreamid), &mut result__).from_abi::<MFT_OUTPUT_STREAM_INFO>(result__)
}
pub unsafe fn GetAttributes(&self) -> ::windows::core::Result<IMFAttributes> {
let mut result__: <IMFAttributes as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFAttributes>(result__)
}
pub unsafe fn GetInputStreamAttributes(&self, dwinputstreamid: u32) -> ::windows::core::Result<IMFAttributes> {
let mut result__: <IMFAttributes as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwinputstreamid), &mut result__).from_abi::<IMFAttributes>(result__)
}
pub unsafe fn GetOutputStreamAttributes(&self, dwoutputstreamid: u32) -> ::windows::core::Result<IMFAttributes> {
let mut result__: <IMFAttributes as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwoutputstreamid), &mut result__).from_abi::<IMFAttributes>(result__)
}
pub unsafe fn DeleteInputStream(&self, dwstreamid: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamid)).ok()
}
pub unsafe fn AddInputStreams(&self, cstreams: u32, adwstreamids: *const u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(cstreams), ::core::mem::transmute(adwstreamids)).ok()
}
pub unsafe fn GetInputAvailableType(&self, dwinputstreamid: u32, dwtypeindex: u32) -> ::windows::core::Result<IMFMediaType> {
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwinputstreamid), ::core::mem::transmute(dwtypeindex), &mut result__).from_abi::<IMFMediaType>(result__)
}
pub unsafe fn GetOutputAvailableType(&self, dwoutputstreamid: u32, dwtypeindex: u32) -> ::windows::core::Result<IMFMediaType> {
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwoutputstreamid), ::core::mem::transmute(dwtypeindex), &mut result__).from_abi::<IMFMediaType>(result__)
}
pub unsafe fn SetInputType<'a, Param1: ::windows::core::IntoParam<'a, IMFMediaType>>(&self, dwinputstreamid: u32, ptype: Param1, dwflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwinputstreamid), ptype.into_param().abi(), ::core::mem::transmute(dwflags)).ok()
}
pub unsafe fn SetOutputType<'a, Param1: ::windows::core::IntoParam<'a, IMFMediaType>>(&self, dwoutputstreamid: u32, ptype: Param1, dwflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwoutputstreamid), ptype.into_param().abi(), ::core::mem::transmute(dwflags)).ok()
}
pub unsafe fn GetInputCurrentType(&self, dwinputstreamid: u32) -> ::windows::core::Result<IMFMediaType> {
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwinputstreamid), &mut result__).from_abi::<IMFMediaType>(result__)
}
pub unsafe fn GetOutputCurrentType(&self, dwoutputstreamid: u32) -> ::windows::core::Result<IMFMediaType> {
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwoutputstreamid), &mut result__).from_abi::<IMFMediaType>(result__)
}
pub unsafe fn GetInputStatus(&self, dwinputstreamid: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwinputstreamid), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetOutputStatus(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetOutputBounds(&self, hnslowerbound: i64, hnsupperbound: i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(hnslowerbound), ::core::mem::transmute(hnsupperbound)).ok()
}
pub unsafe fn ProcessEvent<'a, Param1: ::windows::core::IntoParam<'a, IMFMediaEvent>>(&self, dwinputstreamid: u32, pevent: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwinputstreamid), pevent.into_param().abi()).ok()
}
pub unsafe fn ProcessMessage(&self, emessage: MFT_MESSAGE_TYPE, ulparam: usize) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(emessage), ::core::mem::transmute(ulparam)).ok()
}
pub unsafe fn ProcessInput<'a, Param1: ::windows::core::IntoParam<'a, IMFSample>>(&self, dwinputstreamid: u32, psample: Param1, dwflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwinputstreamid), psample.into_param().abi(), ::core::mem::transmute(dwflags)).ok()
}
pub unsafe fn ProcessOutput(&self, dwflags: u32, coutputbuffercount: u32, poutputsamples: *mut MFT_OUTPUT_DATA_BUFFER, pdwstatus: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwflags), ::core::mem::transmute(coutputbuffercount), ::core::mem::transmute(poutputsamples), ::core::mem::transmute(pdwstatus)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFTransform {
type Vtable = IMFTransform_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbf94c121_5b05_4e6f_8000_ba598961414d);
}
impl ::core::convert::From<IMFTransform> for ::windows::core::IUnknown {
fn from(value: IMFTransform) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFTransform> for ::windows::core::IUnknown {
fn from(value: &IMFTransform) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFTransform {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFTransform {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFTransform_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwinputminimum: *mut u32, pdwinputmaximum: *mut u32, pdwoutputminimum: *mut u32, pdwoutputmaximum: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcinputstreams: *mut u32, pcoutputstreams: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwinputidarraysize: u32, pdwinputids: *mut u32, dwoutputidarraysize: u32, pdwoutputids: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwinputstreamid: u32, pstreaminfo: *mut MFT_INPUT_STREAM_INFO) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwoutputstreamid: u32, pstreaminfo: *mut MFT_OUTPUT_STREAM_INFO) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pattributes: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwinputstreamid: u32, pattributes: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwoutputstreamid: u32, pattributes: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamid: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, cstreams: u32, adwstreamids: *const u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwinputstreamid: u32, dwtypeindex: u32, pptype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwoutputstreamid: u32, dwtypeindex: u32, pptype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwinputstreamid: u32, ptype: ::windows::core::RawPtr, dwflags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwoutputstreamid: u32, ptype: ::windows::core::RawPtr, dwflags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwinputstreamid: u32, pptype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwoutputstreamid: u32, pptype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwinputstreamid: u32, pdwflags: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwflags: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hnslowerbound: i64, hnsupperbound: i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwinputstreamid: u32, pevent: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, emessage: MFT_MESSAGE_TYPE, ulparam: usize) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwinputstreamid: u32, psample: ::windows::core::RawPtr, dwflags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwflags: u32, coutputbuffercount: u32, poutputsamples: *mut ::core::mem::ManuallyDrop<MFT_OUTPUT_DATA_BUFFER>, pdwstatus: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFTrustedInput(pub ::windows::core::IUnknown);
impl IMFTrustedInput {
pub unsafe fn GetInputTrustAuthority(&self, dwstreamid: u32, riid: *const ::windows::core::GUID) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamid), ::core::mem::transmute(riid), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFTrustedInput {
type Vtable = IMFTrustedInput_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x542612c4_a1b8_4632_b521_de11ea64a0b0);
}
impl ::core::convert::From<IMFTrustedInput> for ::windows::core::IUnknown {
fn from(value: IMFTrustedInput) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFTrustedInput> for ::windows::core::IUnknown {
fn from(value: &IMFTrustedInput) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFTrustedInput {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFTrustedInput {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFTrustedInput_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamid: u32, riid: *const ::windows::core::GUID, ppunkobject: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFTrustedOutput(pub ::windows::core::IUnknown);
impl IMFTrustedOutput {
pub unsafe fn GetOutputTrustAuthorityCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetOutputTrustAuthorityByIndex(&self, dwindex: u32) -> ::windows::core::Result<IMFOutputTrustAuthority> {
let mut result__: <IMFOutputTrustAuthority as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwindex), &mut result__).from_abi::<IMFOutputTrustAuthority>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsFinal(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFTrustedOutput {
type Vtable = IMFTrustedOutput_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd19f8e95_b126_4446_890c_5dcb7ad71453);
}
impl ::core::convert::From<IMFTrustedOutput> for ::windows::core::IUnknown {
fn from(value: IMFTrustedOutput) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFTrustedOutput> for ::windows::core::IUnknown {
fn from(value: &IMFTrustedOutput) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFTrustedOutput {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFTrustedOutput {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFTrustedOutput_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcoutputtrustauthorities: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwindex: u32, ppauthority: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfisfinal: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFVideoCaptureSampleAllocator(pub ::windows::core::IUnknown);
impl IMFVideoCaptureSampleAllocator {
pub unsafe fn SetDirectXManager<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pmanager: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pmanager.into_param().abi()).ok()
}
pub unsafe fn UninitializeSampleAllocator(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn InitializeSampleAllocator<'a, Param1: ::windows::core::IntoParam<'a, IMFMediaType>>(&self, crequestedframes: u32, pmediatype: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(crequestedframes), pmediatype.into_param().abi()).ok()
}
pub unsafe fn AllocateSample(&self) -> ::windows::core::Result<IMFSample> {
let mut result__: <IMFSample as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFSample>(result__)
}
pub unsafe fn InitializeCaptureSampleAllocator<'a, Param4: ::windows::core::IntoParam<'a, IMFAttributes>, Param5: ::windows::core::IntoParam<'a, IMFMediaType>>(&self, cbsamplesize: u32, cbcapturemetadatasize: u32, cbalignment: u32, cminimumsamples: u32, pattributes: Param4, pmediatype: Param5) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(cbsamplesize), ::core::mem::transmute(cbcapturemetadatasize), ::core::mem::transmute(cbalignment), ::core::mem::transmute(cminimumsamples), pattributes.into_param().abi(), pmediatype.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFVideoCaptureSampleAllocator {
type Vtable = IMFVideoCaptureSampleAllocator_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x725b77c7_ca9f_4fe5_9d72_9946bf9b3c70);
}
impl ::core::convert::From<IMFVideoCaptureSampleAllocator> for ::windows::core::IUnknown {
fn from(value: IMFVideoCaptureSampleAllocator) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFVideoCaptureSampleAllocator> for ::windows::core::IUnknown {
fn from(value: &IMFVideoCaptureSampleAllocator) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFVideoCaptureSampleAllocator {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFVideoCaptureSampleAllocator {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFVideoCaptureSampleAllocator> for IMFVideoSampleAllocator {
fn from(value: IMFVideoCaptureSampleAllocator) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFVideoCaptureSampleAllocator> for IMFVideoSampleAllocator {
fn from(value: &IMFVideoCaptureSampleAllocator) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFVideoSampleAllocator> for IMFVideoCaptureSampleAllocator {
fn into_param(self) -> ::windows::core::Param<'a, IMFVideoSampleAllocator> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFVideoSampleAllocator> for &IMFVideoCaptureSampleAllocator {
fn into_param(self) -> ::windows::core::Param<'a, IMFVideoSampleAllocator> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFVideoCaptureSampleAllocator_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pmanager: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, crequestedframes: u32, pmediatype: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppsample: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, cbsamplesize: u32, cbcapturemetadatasize: u32, cbalignment: u32, cminimumsamples: u32, pattributes: ::windows::core::RawPtr, pmediatype: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFVideoDeviceID(pub ::windows::core::IUnknown);
impl IMFVideoDeviceID {
pub unsafe fn GetDeviceID(&self) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFVideoDeviceID {
type Vtable = IMFVideoDeviceID_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa38d9567_5a9c_4f3c_b293_8eb415b279ba);
}
impl ::core::convert::From<IMFVideoDeviceID> for ::windows::core::IUnknown {
fn from(value: IMFVideoDeviceID) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFVideoDeviceID> for ::windows::core::IUnknown {
fn from(value: &IMFVideoDeviceID) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFVideoDeviceID {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFVideoDeviceID {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFVideoDeviceID_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdeviceid: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFVideoDisplayControl(pub ::windows::core::IUnknown);
impl IMFVideoDisplayControl {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNativeVideoSize(&self, pszvideo: *mut super::super::Foundation::SIZE, pszarvideo: *mut super::super::Foundation::SIZE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pszvideo), ::core::mem::transmute(pszarvideo)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetIdealVideoSize(&self, pszmin: *mut super::super::Foundation::SIZE, pszmax: *mut super::super::Foundation::SIZE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pszmin), ::core::mem::transmute(pszmax)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetVideoPosition(&self, pnrcsource: *const MFVideoNormalizedRect, prcdest: *const super::super::Foundation::RECT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(pnrcsource), ::core::mem::transmute(prcdest)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetVideoPosition(&self, pnrcsource: *mut MFVideoNormalizedRect, prcdest: *mut super::super::Foundation::RECT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(pnrcsource), ::core::mem::transmute(prcdest)).ok()
}
pub unsafe fn SetAspectRatioMode(&self, dwaspectratiomode: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwaspectratiomode)).ok()
}
pub unsafe fn GetAspectRatioMode(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetVideoWindow<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::HWND>>(&self, hwndvideo: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), hwndvideo.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetVideoWindow(&self) -> ::windows::core::Result<super::super::Foundation::HWND> {
let mut result__: <super::super::Foundation::HWND as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::HWND>(result__)
}
pub unsafe fn RepaintVideo(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Graphics_Gdi")]
pub unsafe fn GetCurrentImage(&self, pbih: *mut super::super::Graphics::Gdi::BITMAPINFOHEADER, pdib: *mut *mut u8, pcbdib: *mut u32, ptimestamp: *mut i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbih), ::core::mem::transmute(pdib), ::core::mem::transmute(pcbdib), ::core::mem::transmute(ptimestamp)).ok()
}
pub unsafe fn SetBorderColor(&self, clr: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(clr)).ok()
}
pub unsafe fn GetBorderColor(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetRenderingPrefs(&self, dwrenderflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwrenderflags)).ok()
}
pub unsafe fn GetRenderingPrefs(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetFullscreen<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, ffullscreen: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ffullscreen.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetFullscreen(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFVideoDisplayControl {
type Vtable = IMFVideoDisplayControl_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa490b1e4_ab84_4d31_a1b2_181e03b1077a);
}
impl ::core::convert::From<IMFVideoDisplayControl> for ::windows::core::IUnknown {
fn from(value: IMFVideoDisplayControl) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFVideoDisplayControl> for ::windows::core::IUnknown {
fn from(value: &IMFVideoDisplayControl) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFVideoDisplayControl {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFVideoDisplayControl {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFVideoDisplayControl_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvideo: *mut super::super::Foundation::SIZE, pszarvideo: *mut super::super::Foundation::SIZE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszmin: *mut super::super::Foundation::SIZE, pszmax: *mut super::super::Foundation::SIZE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pnrcsource: *const MFVideoNormalizedRect, prcdest: *const super::super::Foundation::RECT) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pnrcsource: *mut MFVideoNormalizedRect, prcdest: *mut super::super::Foundation::RECT) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwaspectratiomode: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwaspectratiomode: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hwndvideo: super::super::Foundation::HWND) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, phwndvideo: *mut super::super::Foundation::HWND) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Gdi")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbih: *mut super::super::Graphics::Gdi::BITMAPINFOHEADER, pdib: *mut *mut u8, pcbdib: *mut u32, ptimestamp: *mut i64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Gdi"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, clr: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pclr: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwrenderflags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwrenderflags: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ffullscreen: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pffullscreen: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFVideoMediaType(pub ::windows::core::IUnknown);
impl IMFVideoMediaType {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItem(&self, guidkey: *const ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn GetItemType(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<MF_ATTRIBUTE_TYPE> {
let mut result__: <MF_ATTRIBUTE_TYPE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<MF_ATTRIBUTE_TYPE>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn CompareItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Compare<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, ptheirs: Param0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ptheirs.into_param().abi(), ::core::mem::transmute(matchtype), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn GetUINT32(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetUINT64(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetDouble(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<f64> {
let mut result__: <f64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<f64>(result__)
}
pub unsafe fn GetGUID(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
pub unsafe fn GetStringLength(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetString(&self, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pwszvalue), ::core::mem::transmute(cchbufsize), ::core::mem::transmute(pcchlength)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetAllocatedString(&self, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppwszvalue), ::core::mem::transmute(pcchlength)).ok()
}
pub unsafe fn GetBlobSize(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize), ::core::mem::transmute(pcbblobsize)).ok()
}
pub unsafe fn GetAllocatedBlob(&self, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppbuf), ::core::mem::transmute(pcbsize)).ok()
}
pub unsafe fn GetUnknown<T: ::windows::core::Interface>(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn SetItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value)).ok()
}
pub unsafe fn DeleteItem(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey)).ok()
}
pub unsafe fn DeleteAllItems(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetUINT32(&self, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetUINT64(&self, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetDouble(&self, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(fvalue)).ok()
}
pub unsafe fn SetGUID(&self, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(guidvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetString<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, guidkey: *const ::windows::core::GUID, wszvalue: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), wszvalue.into_param().abi()).ok()
}
pub unsafe fn SetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize)).ok()
}
pub unsafe fn SetUnknown<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guidkey: *const ::windows::core::GUID, punknown: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), punknown.into_param().abi()).ok()
}
pub unsafe fn LockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn UnlockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(unindex), ::core::mem::transmute(pguidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn CopyAllItems<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, pdest: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), pdest.into_param().abi()).ok()
}
pub unsafe fn GetMajorType(&self) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsCompressedFormat(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn IsEqual<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaType>>(&self, pimediatype: Param0) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), pimediatype.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetRepresentation<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::GUID>>(&self, guidrepresentation: Param0, ppvrepresentation: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), guidrepresentation.into_param().abi(), ::core::mem::transmute(ppvrepresentation)).ok()
}
pub unsafe fn FreeRepresentation<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::GUID>>(&self, guidrepresentation: Param0, pvrepresentation: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), guidrepresentation.into_param().abi(), ::core::mem::transmute(pvrepresentation)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetVideoFormat(&self) -> *mut MFVIDEOFORMAT {
::core::mem::transmute((::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetVideoRepresentation<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::GUID>>(&self, guidrepresentation: Param0, ppvrepresentation: *mut *mut ::core::ffi::c_void, lstride: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), guidrepresentation.into_param().abi(), ::core::mem::transmute(ppvrepresentation), ::core::mem::transmute(lstride)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFVideoMediaType {
type Vtable = IMFVideoMediaType_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb99f381f_a8f9_47a2_a5af_ca3a225a3890);
}
impl ::core::convert::From<IMFVideoMediaType> for ::windows::core::IUnknown {
fn from(value: IMFVideoMediaType) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFVideoMediaType> for ::windows::core::IUnknown {
fn from(value: &IMFVideoMediaType) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFVideoMediaType {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFVideoMediaType {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFVideoMediaType> for IMFMediaType {
fn from(value: IMFVideoMediaType) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFVideoMediaType> for IMFMediaType {
fn from(value: &IMFVideoMediaType) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaType> for IMFVideoMediaType {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaType> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFMediaType> for &IMFVideoMediaType {
fn into_param(self) -> ::windows::core::Param<'a, IMFMediaType> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<IMFVideoMediaType> for IMFAttributes {
fn from(value: IMFVideoMediaType) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFVideoMediaType> for IMFAttributes {
fn from(value: &IMFVideoMediaType) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for IMFVideoMediaType {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for &IMFVideoMediaType {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFVideoMediaType_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ptype: *mut MF_ATTRIBUTE_TYPE) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptheirs: ::windows::core::RawPtr, matchtype: MF_ATTRIBUTES_MATCH_TYPE, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pfvalue: *mut f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pguidvalue: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, wszvalue: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punknown: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcitems: *mut u32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdest: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pguidmajortype: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfcompressed: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pimediatype: ::windows::core::RawPtr, pdwflags: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidrepresentation: ::windows::core::GUID, ppvrepresentation: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidrepresentation: ::windows::core::GUID, pvrepresentation: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> *mut MFVIDEOFORMAT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidrepresentation: ::windows::core::GUID, ppvrepresentation: *mut *mut ::core::ffi::c_void, lstride: i32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFVideoMixerBitmap(pub ::windows::core::IUnknown);
impl IMFVideoMixerBitmap {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9", feature = "Win32_Graphics_Gdi"))]
pub unsafe fn SetAlphaBitmap(&self, pbmpparms: *const MFVideoAlphaBitmap) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbmpparms)).ok()
}
pub unsafe fn ClearAlphaBitmap(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn UpdateAlphaBitmapParameters(&self, pbmpparms: *const MFVideoAlphaBitmapParams) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbmpparms)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetAlphaBitmapParameters(&self) -> ::windows::core::Result<MFVideoAlphaBitmapParams> {
let mut result__: <MFVideoAlphaBitmapParams as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<MFVideoAlphaBitmapParams>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFVideoMixerBitmap {
type Vtable = IMFVideoMixerBitmap_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x814c7b20_0fdb_4eec_af8f_f957c8f69edc);
}
impl ::core::convert::From<IMFVideoMixerBitmap> for ::windows::core::IUnknown {
fn from(value: IMFVideoMixerBitmap) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFVideoMixerBitmap> for ::windows::core::IUnknown {
fn from(value: &IMFVideoMixerBitmap) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFVideoMixerBitmap {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFVideoMixerBitmap {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFVideoMixerBitmap_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9", feature = "Win32_Graphics_Gdi"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbmpparms: *const ::core::mem::ManuallyDrop<MFVideoAlphaBitmap>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9", feature = "Win32_Graphics_Gdi")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbmpparms: *const MFVideoAlphaBitmapParams) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbmpparms: *mut MFVideoAlphaBitmapParams) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFVideoMixerControl(pub ::windows::core::IUnknown);
impl IMFVideoMixerControl {
pub unsafe fn SetStreamZOrder(&self, dwstreamid: u32, dwz: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamid), ::core::mem::transmute(dwz)).ok()
}
pub unsafe fn GetStreamZOrder(&self, dwstreamid: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamid), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetStreamOutputRect(&self, dwstreamid: u32, pnrcoutput: *const MFVideoNormalizedRect) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamid), ::core::mem::transmute(pnrcoutput)).ok()
}
pub unsafe fn GetStreamOutputRect(&self, dwstreamid: u32) -> ::windows::core::Result<MFVideoNormalizedRect> {
let mut result__: <MFVideoNormalizedRect as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamid), &mut result__).from_abi::<MFVideoNormalizedRect>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFVideoMixerControl {
type Vtable = IMFVideoMixerControl_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa5c6c53f_c202_4aa5_9695_175ba8c508a5);
}
impl ::core::convert::From<IMFVideoMixerControl> for ::windows::core::IUnknown {
fn from(value: IMFVideoMixerControl) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFVideoMixerControl> for ::windows::core::IUnknown {
fn from(value: &IMFVideoMixerControl) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFVideoMixerControl {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFVideoMixerControl {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFVideoMixerControl_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamid: u32, dwz: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamid: u32, pdwz: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamid: u32, pnrcoutput: *const MFVideoNormalizedRect) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamid: u32, pnrcoutput: *mut MFVideoNormalizedRect) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFVideoMixerControl2(pub ::windows::core::IUnknown);
impl IMFVideoMixerControl2 {
pub unsafe fn SetStreamZOrder(&self, dwstreamid: u32, dwz: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamid), ::core::mem::transmute(dwz)).ok()
}
pub unsafe fn GetStreamZOrder(&self, dwstreamid: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamid), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetStreamOutputRect(&self, dwstreamid: u32, pnrcoutput: *const MFVideoNormalizedRect) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamid), ::core::mem::transmute(pnrcoutput)).ok()
}
pub unsafe fn GetStreamOutputRect(&self, dwstreamid: u32) -> ::windows::core::Result<MFVideoNormalizedRect> {
let mut result__: <MFVideoNormalizedRect as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwstreamid), &mut result__).from_abi::<MFVideoNormalizedRect>(result__)
}
pub unsafe fn SetMixingPrefs(&self, dwmixflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwmixflags)).ok()
}
pub unsafe fn GetMixingPrefs(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFVideoMixerControl2 {
type Vtable = IMFVideoMixerControl2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8459616d_966e_4930_b658_54fa7e5a16d3);
}
impl ::core::convert::From<IMFVideoMixerControl2> for ::windows::core::IUnknown {
fn from(value: IMFVideoMixerControl2) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFVideoMixerControl2> for ::windows::core::IUnknown {
fn from(value: &IMFVideoMixerControl2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFVideoMixerControl2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFVideoMixerControl2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFVideoMixerControl2> for IMFVideoMixerControl {
fn from(value: IMFVideoMixerControl2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFVideoMixerControl2> for IMFVideoMixerControl {
fn from(value: &IMFVideoMixerControl2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFVideoMixerControl> for IMFVideoMixerControl2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFVideoMixerControl> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFVideoMixerControl> for &IMFVideoMixerControl2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFVideoMixerControl> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFVideoMixerControl2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamid: u32, dwz: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamid: u32, pdwz: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamid: u32, pnrcoutput: *const MFVideoNormalizedRect) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwstreamid: u32, pnrcoutput: *mut MFVideoNormalizedRect) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwmixflags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwmixflags: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFVideoPositionMapper(pub ::windows::core::IUnknown);
impl IMFVideoPositionMapper {
pub unsafe fn MapOutputCoordinateToInputStream(&self, xout: f32, yout: f32, dwoutputstreamindex: u32, dwinputstreamindex: u32, pxin: *mut f32, pyin: *mut f32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(xout), ::core::mem::transmute(yout), ::core::mem::transmute(dwoutputstreamindex), ::core::mem::transmute(dwinputstreamindex), ::core::mem::transmute(pxin), ::core::mem::transmute(pyin)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFVideoPositionMapper {
type Vtable = IMFVideoPositionMapper_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1f6a9f17_e70b_4e24_8ae4_0b2c3ba7a4ae);
}
impl ::core::convert::From<IMFVideoPositionMapper> for ::windows::core::IUnknown {
fn from(value: IMFVideoPositionMapper) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFVideoPositionMapper> for ::windows::core::IUnknown {
fn from(value: &IMFVideoPositionMapper) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFVideoPositionMapper {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFVideoPositionMapper {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFVideoPositionMapper_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, xout: f32, yout: f32, dwoutputstreamindex: u32, dwinputstreamindex: u32, pxin: *mut f32, pyin: *mut f32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFVideoPresenter(pub ::windows::core::IUnknown);
impl IMFVideoPresenter {
pub unsafe fn OnClockStart(&self, hnssystemtime: i64, llclockstartoffset: i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(hnssystemtime), ::core::mem::transmute(llclockstartoffset)).ok()
}
pub unsafe fn OnClockStop(&self, hnssystemtime: i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(hnssystemtime)).ok()
}
pub unsafe fn OnClockPause(&self, hnssystemtime: i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(hnssystemtime)).ok()
}
pub unsafe fn OnClockRestart(&self, hnssystemtime: i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(hnssystemtime)).ok()
}
pub unsafe fn OnClockSetRate(&self, hnssystemtime: i64, flrate: f32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(hnssystemtime), ::core::mem::transmute(flrate)).ok()
}
pub unsafe fn ProcessMessage(&self, emessage: MFVP_MESSAGE_TYPE, ulparam: usize) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(emessage), ::core::mem::transmute(ulparam)).ok()
}
pub unsafe fn GetCurrentMediaType(&self) -> ::windows::core::Result<IMFVideoMediaType> {
let mut result__: <IMFVideoMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFVideoMediaType>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFVideoPresenter {
type Vtable = IMFVideoPresenter_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x29aff080_182a_4a5d_af3b_448f3a6346cb);
}
impl ::core::convert::From<IMFVideoPresenter> for ::windows::core::IUnknown {
fn from(value: IMFVideoPresenter) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFVideoPresenter> for ::windows::core::IUnknown {
fn from(value: &IMFVideoPresenter) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFVideoPresenter {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFVideoPresenter {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFVideoPresenter> for IMFClockStateSink {
fn from(value: IMFVideoPresenter) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFVideoPresenter> for IMFClockStateSink {
fn from(value: &IMFVideoPresenter) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFClockStateSink> for IMFVideoPresenter {
fn into_param(self) -> ::windows::core::Param<'a, IMFClockStateSink> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFClockStateSink> for &IMFVideoPresenter {
fn into_param(self) -> ::windows::core::Param<'a, IMFClockStateSink> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFVideoPresenter_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hnssystemtime: i64, llclockstartoffset: i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hnssystemtime: i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hnssystemtime: i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hnssystemtime: i64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hnssystemtime: i64, flrate: f32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, emessage: MFVP_MESSAGE_TYPE, ulparam: usize) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppmediatype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFVideoProcessor(pub ::windows::core::IUnknown);
impl IMFVideoProcessor {
pub unsafe fn GetAvailableVideoProcessorModes(&self, lpdwnumprocessingmodes: *mut u32, ppvideoprocessingmodes: *mut *mut ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(lpdwnumprocessingmodes), ::core::mem::transmute(ppvideoprocessingmodes)).ok()
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub unsafe fn GetVideoProcessorCaps(&self, lpvideoprocessormode: *const ::windows::core::GUID) -> ::windows::core::Result<DXVA2_VideoProcessorCaps> {
let mut result__: <DXVA2_VideoProcessorCaps as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(lpvideoprocessormode), &mut result__).from_abi::<DXVA2_VideoProcessorCaps>(result__)
}
pub unsafe fn GetVideoProcessorMode(&self) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
pub unsafe fn SetVideoProcessorMode(&self, lpmode: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(lpmode)).ok()
}
pub unsafe fn GetProcAmpRange(&self, dwproperty: u32) -> ::windows::core::Result<DXVA2_ValueRange> {
let mut result__: <DXVA2_ValueRange as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwproperty), &mut result__).from_abi::<DXVA2_ValueRange>(result__)
}
pub unsafe fn GetProcAmpValues(&self, dwflags: u32) -> ::windows::core::Result<DXVA2_ProcAmpValues> {
let mut result__: <DXVA2_ProcAmpValues as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwflags), &mut result__).from_abi::<DXVA2_ProcAmpValues>(result__)
}
pub unsafe fn SetProcAmpValues(&self, dwflags: u32, pvalues: *const DXVA2_ProcAmpValues) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwflags), ::core::mem::transmute(pvalues)).ok()
}
pub unsafe fn GetFilteringRange(&self, dwproperty: u32) -> ::windows::core::Result<DXVA2_ValueRange> {
let mut result__: <DXVA2_ValueRange as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwproperty), &mut result__).from_abi::<DXVA2_ValueRange>(result__)
}
pub unsafe fn GetFilteringValue(&self, dwproperty: u32) -> ::windows::core::Result<DXVA2_Fixed32> {
let mut result__: <DXVA2_Fixed32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwproperty), &mut result__).from_abi::<DXVA2_Fixed32>(result__)
}
pub unsafe fn SetFilteringValue(&self, dwproperty: u32, pvalue: *const DXVA2_Fixed32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwproperty), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn GetBackgroundColor(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetBackgroundColor(&self, clrbkg: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(clrbkg)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFVideoProcessor {
type Vtable = IMFVideoProcessor_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6ab0000c_fece_4d1f_a2ac_a9573530656e);
}
impl ::core::convert::From<IMFVideoProcessor> for ::windows::core::IUnknown {
fn from(value: IMFVideoProcessor) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFVideoProcessor> for ::windows::core::IUnknown {
fn from(value: &IMFVideoProcessor) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFVideoProcessor {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFVideoProcessor {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFVideoProcessor_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, lpdwnumprocessingmodes: *mut u32, ppvideoprocessingmodes: *mut *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Graphics_Direct3D9")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, lpvideoprocessormode: *const ::windows::core::GUID, lpvideoprocessorcaps: *mut DXVA2_VideoProcessorCaps) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Graphics_Direct3D9"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, lpmode: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, lpmode: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwproperty: u32, pproprange: *mut DXVA2_ValueRange) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwflags: u32, values: *mut DXVA2_ProcAmpValues) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwflags: u32, pvalues: *const DXVA2_ProcAmpValues) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwproperty: u32, pproprange: *mut DXVA2_ValueRange) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwproperty: u32, pvalue: *mut DXVA2_Fixed32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwproperty: u32, pvalue: *const DXVA2_Fixed32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, lpclrbkg: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, clrbkg: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFVideoProcessorControl(pub ::windows::core::IUnknown);
impl IMFVideoProcessorControl {
pub unsafe fn SetBorderColor(&self, pbordercolor: *const MFARGB) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbordercolor)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSourceRectangle(&self, psrcrect: *const super::super::Foundation::RECT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(psrcrect)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetDestinationRectangle(&self, pdstrect: *const super::super::Foundation::RECT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdstrect)).ok()
}
pub unsafe fn SetMirror(&self, emirror: MF_VIDEO_PROCESSOR_MIRROR) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(emirror)).ok()
}
pub unsafe fn SetRotation(&self, erotation: MF_VIDEO_PROCESSOR_ROTATION) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(erotation)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetConstrictionSize(&self, pconstrictionsize: *const super::super::Foundation::SIZE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(pconstrictionsize)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFVideoProcessorControl {
type Vtable = IMFVideoProcessorControl_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa3f675d5_6119_4f7f_a100_1d8b280f0efb);
}
impl ::core::convert::From<IMFVideoProcessorControl> for ::windows::core::IUnknown {
fn from(value: IMFVideoProcessorControl) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFVideoProcessorControl> for ::windows::core::IUnknown {
fn from(value: &IMFVideoProcessorControl) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFVideoProcessorControl {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFVideoProcessorControl {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFVideoProcessorControl_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbordercolor: *const MFARGB) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psrcrect: *const super::super::Foundation::RECT) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdstrect: *const super::super::Foundation::RECT) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, emirror: MF_VIDEO_PROCESSOR_MIRROR) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, erotation: MF_VIDEO_PROCESSOR_ROTATION) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pconstrictionsize: *const super::super::Foundation::SIZE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFVideoProcessorControl2(pub ::windows::core::IUnknown);
impl IMFVideoProcessorControl2 {
pub unsafe fn SetBorderColor(&self, pbordercolor: *const MFARGB) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbordercolor)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSourceRectangle(&self, psrcrect: *const super::super::Foundation::RECT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(psrcrect)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetDestinationRectangle(&self, pdstrect: *const super::super::Foundation::RECT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdstrect)).ok()
}
pub unsafe fn SetMirror(&self, emirror: MF_VIDEO_PROCESSOR_MIRROR) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(emirror)).ok()
}
pub unsafe fn SetRotation(&self, erotation: MF_VIDEO_PROCESSOR_ROTATION) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(erotation)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetConstrictionSize(&self, pconstrictionsize: *const super::super::Foundation::SIZE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(pconstrictionsize)).ok()
}
pub unsafe fn SetRotationOverride(&self, uirotation: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(uirotation)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnableHardwareEffects<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, fenabled: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), fenabled.into_param().abi()).ok()
}
pub unsafe fn GetSupportedHardwareEffects(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFVideoProcessorControl2 {
type Vtable = IMFVideoProcessorControl2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbde633d3_e1dc_4a7f_a693_bbae399c4a20);
}
impl ::core::convert::From<IMFVideoProcessorControl2> for ::windows::core::IUnknown {
fn from(value: IMFVideoProcessorControl2) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFVideoProcessorControl2> for ::windows::core::IUnknown {
fn from(value: &IMFVideoProcessorControl2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFVideoProcessorControl2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFVideoProcessorControl2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFVideoProcessorControl2> for IMFVideoProcessorControl {
fn from(value: IMFVideoProcessorControl2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFVideoProcessorControl2> for IMFVideoProcessorControl {
fn from(value: &IMFVideoProcessorControl2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFVideoProcessorControl> for IMFVideoProcessorControl2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFVideoProcessorControl> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFVideoProcessorControl> for &IMFVideoProcessorControl2 {
fn into_param(self) -> ::windows::core::Param<'a, IMFVideoProcessorControl> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFVideoProcessorControl2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbordercolor: *const MFARGB) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psrcrect: *const super::super::Foundation::RECT) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdstrect: *const super::super::Foundation::RECT) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, emirror: MF_VIDEO_PROCESSOR_MIRROR) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, erotation: MF_VIDEO_PROCESSOR_ROTATION) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pconstrictionsize: *const super::super::Foundation::SIZE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, uirotation: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, fenabled: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, puisupport: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFVideoProcessorControl3(pub ::windows::core::IUnknown);
impl IMFVideoProcessorControl3 {
pub unsafe fn SetBorderColor(&self, pbordercolor: *const MFARGB) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbordercolor)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSourceRectangle(&self, psrcrect: *const super::super::Foundation::RECT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(psrcrect)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetDestinationRectangle(&self, pdstrect: *const super::super::Foundation::RECT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdstrect)).ok()
}
pub unsafe fn SetMirror(&self, emirror: MF_VIDEO_PROCESSOR_MIRROR) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(emirror)).ok()
}
pub unsafe fn SetRotation(&self, erotation: MF_VIDEO_PROCESSOR_ROTATION) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(erotation)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetConstrictionSize(&self, pconstrictionsize: *const super::super::Foundation::SIZE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(pconstrictionsize)).ok()
}
pub unsafe fn SetRotationOverride(&self, uirotation: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(uirotation)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnableHardwareEffects<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, fenabled: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), fenabled.into_param().abi()).ok()
}
pub unsafe fn GetSupportedHardwareEffects(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetNaturalOutputType(&self) -> ::windows::core::Result<IMFMediaType> {
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFMediaType>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnableSphericalVideoProcessing<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, fenable: Param0, eformat: MFVideoSphericalFormat, eprojectionmode: MFVideoSphericalProjectionMode) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), fenable.into_param().abi(), ::core::mem::transmute(eformat), ::core::mem::transmute(eprojectionmode)).ok()
}
pub unsafe fn SetSphericalVideoProperties(&self, x: f32, y: f32, z: f32, w: f32, fieldofview: f32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(x), ::core::mem::transmute(y), ::core::mem::transmute(z), ::core::mem::transmute(w), ::core::mem::transmute(fieldofview)).ok()
}
pub unsafe fn SetOutputDevice<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, poutputdevice: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), poutputdevice.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFVideoProcessorControl3 {
type Vtable = IMFVideoProcessorControl3_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2424b3f2_eb23_40f1_91aa_74bddeea0883);
}
impl ::core::convert::From<IMFVideoProcessorControl3> for ::windows::core::IUnknown {
fn from(value: IMFVideoProcessorControl3) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFVideoProcessorControl3> for ::windows::core::IUnknown {
fn from(value: &IMFVideoProcessorControl3) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFVideoProcessorControl3 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFVideoProcessorControl3 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFVideoProcessorControl3> for IMFVideoProcessorControl2 {
fn from(value: IMFVideoProcessorControl3) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFVideoProcessorControl3> for IMFVideoProcessorControl2 {
fn from(value: &IMFVideoProcessorControl3) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFVideoProcessorControl2> for IMFVideoProcessorControl3 {
fn into_param(self) -> ::windows::core::Param<'a, IMFVideoProcessorControl2> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFVideoProcessorControl2> for &IMFVideoProcessorControl3 {
fn into_param(self) -> ::windows::core::Param<'a, IMFVideoProcessorControl2> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<IMFVideoProcessorControl3> for IMFVideoProcessorControl {
fn from(value: IMFVideoProcessorControl3) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFVideoProcessorControl3> for IMFVideoProcessorControl {
fn from(value: &IMFVideoProcessorControl3) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFVideoProcessorControl> for IMFVideoProcessorControl3 {
fn into_param(self) -> ::windows::core::Param<'a, IMFVideoProcessorControl> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFVideoProcessorControl> for &IMFVideoProcessorControl3 {
fn into_param(self) -> ::windows::core::Param<'a, IMFVideoProcessorControl> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFVideoProcessorControl3_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbordercolor: *const MFARGB) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psrcrect: *const super::super::Foundation::RECT) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdstrect: *const super::super::Foundation::RECT) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, emirror: MF_VIDEO_PROCESSOR_MIRROR) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, erotation: MF_VIDEO_PROCESSOR_ROTATION) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pconstrictionsize: *const super::super::Foundation::SIZE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, uirotation: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, fenabled: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, puisupport: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pptype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, fenable: super::super::Foundation::BOOL, eformat: MFVideoSphericalFormat, eprojectionmode: MFVideoSphericalProjectionMode) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, x: f32, y: f32, z: f32, w: f32, fieldofview: f32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, poutputdevice: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFVideoRenderer(pub ::windows::core::IUnknown);
impl IMFVideoRenderer {
pub unsafe fn InitializeRenderer<'a, Param0: ::windows::core::IntoParam<'a, IMFTransform>, Param1: ::windows::core::IntoParam<'a, IMFVideoPresenter>>(&self, pvideomixer: Param0, pvideopresenter: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pvideomixer.into_param().abi(), pvideopresenter.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFVideoRenderer {
type Vtable = IMFVideoRenderer_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdfdfd197_a9ca_43d8_b341_6af3503792cd);
}
impl ::core::convert::From<IMFVideoRenderer> for ::windows::core::IUnknown {
fn from(value: IMFVideoRenderer) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFVideoRenderer> for ::windows::core::IUnknown {
fn from(value: &IMFVideoRenderer) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFVideoRenderer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFVideoRenderer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFVideoRenderer_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pvideomixer: ::windows::core::RawPtr, pvideopresenter: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFVideoRendererEffectControl(pub ::windows::core::IUnknown);
impl IMFVideoRendererEffectControl {
pub unsafe fn OnAppServiceConnectionEstablished<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pappserviceconnection: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pappserviceconnection.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFVideoRendererEffectControl {
type Vtable = IMFVideoRendererEffectControl_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x604d33d7_cf23_41d5_8224_5bbbb1a87475);
}
impl ::core::convert::From<IMFVideoRendererEffectControl> for ::windows::core::IUnknown {
fn from(value: IMFVideoRendererEffectControl) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFVideoRendererEffectControl> for ::windows::core::IUnknown {
fn from(value: &IMFVideoRendererEffectControl) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFVideoRendererEffectControl {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFVideoRendererEffectControl {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFVideoRendererEffectControl_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pappserviceconnection: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFVideoSampleAllocator(pub ::windows::core::IUnknown);
impl IMFVideoSampleAllocator {
pub unsafe fn SetDirectXManager<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pmanager: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pmanager.into_param().abi()).ok()
}
pub unsafe fn UninitializeSampleAllocator(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn InitializeSampleAllocator<'a, Param1: ::windows::core::IntoParam<'a, IMFMediaType>>(&self, crequestedframes: u32, pmediatype: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(crequestedframes), pmediatype.into_param().abi()).ok()
}
pub unsafe fn AllocateSample(&self) -> ::windows::core::Result<IMFSample> {
let mut result__: <IMFSample as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFSample>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFVideoSampleAllocator {
type Vtable = IMFVideoSampleAllocator_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x86cbc910_e533_4751_8e3b_f19b5b806a03);
}
impl ::core::convert::From<IMFVideoSampleAllocator> for ::windows::core::IUnknown {
fn from(value: IMFVideoSampleAllocator) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFVideoSampleAllocator> for ::windows::core::IUnknown {
fn from(value: &IMFVideoSampleAllocator) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFVideoSampleAllocator {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFVideoSampleAllocator {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFVideoSampleAllocator_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pmanager: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, crequestedframes: u32, pmediatype: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppsample: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFVideoSampleAllocatorCallback(pub ::windows::core::IUnknown);
impl IMFVideoSampleAllocatorCallback {
pub unsafe fn SetCallback<'a, Param0: ::windows::core::IntoParam<'a, IMFVideoSampleAllocatorNotify>>(&self, pnotify: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pnotify.into_param().abi()).ok()
}
pub unsafe fn GetFreeSampleCount(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFVideoSampleAllocatorCallback {
type Vtable = IMFVideoSampleAllocatorCallback_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x992388b4_3372_4f67_8b6f_c84c071f4751);
}
impl ::core::convert::From<IMFVideoSampleAllocatorCallback> for ::windows::core::IUnknown {
fn from(value: IMFVideoSampleAllocatorCallback) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFVideoSampleAllocatorCallback> for ::windows::core::IUnknown {
fn from(value: &IMFVideoSampleAllocatorCallback) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFVideoSampleAllocatorCallback {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFVideoSampleAllocatorCallback {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFVideoSampleAllocatorCallback_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pnotify: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, plsamples: *mut i32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFVideoSampleAllocatorEx(pub ::windows::core::IUnknown);
impl IMFVideoSampleAllocatorEx {
pub unsafe fn SetDirectXManager<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pmanager: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pmanager.into_param().abi()).ok()
}
pub unsafe fn UninitializeSampleAllocator(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn InitializeSampleAllocator<'a, Param1: ::windows::core::IntoParam<'a, IMFMediaType>>(&self, crequestedframes: u32, pmediatype: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(crequestedframes), pmediatype.into_param().abi()).ok()
}
pub unsafe fn AllocateSample(&self) -> ::windows::core::Result<IMFSample> {
let mut result__: <IMFSample as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFSample>(result__)
}
pub unsafe fn InitializeSampleAllocatorEx<'a, Param2: ::windows::core::IntoParam<'a, IMFAttributes>, Param3: ::windows::core::IntoParam<'a, IMFMediaType>>(&self, cinitialsamples: u32, cmaximumsamples: u32, pattributes: Param2, pmediatype: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(cinitialsamples), ::core::mem::transmute(cmaximumsamples), pattributes.into_param().abi(), pmediatype.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFVideoSampleAllocatorEx {
type Vtable = IMFVideoSampleAllocatorEx_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x545b3a48_3283_4f62_866f_a62d8f598f9f);
}
impl ::core::convert::From<IMFVideoSampleAllocatorEx> for ::windows::core::IUnknown {
fn from(value: IMFVideoSampleAllocatorEx) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFVideoSampleAllocatorEx> for ::windows::core::IUnknown {
fn from(value: &IMFVideoSampleAllocatorEx) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFVideoSampleAllocatorEx {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFVideoSampleAllocatorEx {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFVideoSampleAllocatorEx> for IMFVideoSampleAllocator {
fn from(value: IMFVideoSampleAllocatorEx) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFVideoSampleAllocatorEx> for IMFVideoSampleAllocator {
fn from(value: &IMFVideoSampleAllocatorEx) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFVideoSampleAllocator> for IMFVideoSampleAllocatorEx {
fn into_param(self) -> ::windows::core::Param<'a, IMFVideoSampleAllocator> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFVideoSampleAllocator> for &IMFVideoSampleAllocatorEx {
fn into_param(self) -> ::windows::core::Param<'a, IMFVideoSampleAllocator> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFVideoSampleAllocatorEx_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pmanager: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, crequestedframes: u32, pmediatype: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppsample: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, cinitialsamples: u32, cmaximumsamples: u32, pattributes: ::windows::core::RawPtr, pmediatype: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFVideoSampleAllocatorNotify(pub ::windows::core::IUnknown);
impl IMFVideoSampleAllocatorNotify {
pub unsafe fn NotifyRelease(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFVideoSampleAllocatorNotify {
type Vtable = IMFVideoSampleAllocatorNotify_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa792cdbe_c374_4e89_8335_278e7b9956a4);
}
impl ::core::convert::From<IMFVideoSampleAllocatorNotify> for ::windows::core::IUnknown {
fn from(value: IMFVideoSampleAllocatorNotify) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFVideoSampleAllocatorNotify> for ::windows::core::IUnknown {
fn from(value: &IMFVideoSampleAllocatorNotify) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFVideoSampleAllocatorNotify {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFVideoSampleAllocatorNotify {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFVideoSampleAllocatorNotify_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFVideoSampleAllocatorNotifyEx(pub ::windows::core::IUnknown);
impl IMFVideoSampleAllocatorNotifyEx {
pub unsafe fn NotifyRelease(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn NotifyPrune<'a, Param0: ::windows::core::IntoParam<'a, IMFSample>>(&self, __midl__imfvideosampleallocatornotifyex0000: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), __midl__imfvideosampleallocatornotifyex0000.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IMFVideoSampleAllocatorNotifyEx {
type Vtable = IMFVideoSampleAllocatorNotifyEx_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3978aa1a_6d5b_4b7f_a340_90899189ae34);
}
impl ::core::convert::From<IMFVideoSampleAllocatorNotifyEx> for ::windows::core::IUnknown {
fn from(value: IMFVideoSampleAllocatorNotifyEx) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFVideoSampleAllocatorNotifyEx> for ::windows::core::IUnknown {
fn from(value: &IMFVideoSampleAllocatorNotifyEx) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFVideoSampleAllocatorNotifyEx {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFVideoSampleAllocatorNotifyEx {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFVideoSampleAllocatorNotifyEx> for IMFVideoSampleAllocatorNotify {
fn from(value: IMFVideoSampleAllocatorNotifyEx) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFVideoSampleAllocatorNotifyEx> for IMFVideoSampleAllocatorNotify {
fn from(value: &IMFVideoSampleAllocatorNotifyEx) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFVideoSampleAllocatorNotify> for IMFVideoSampleAllocatorNotifyEx {
fn into_param(self) -> ::windows::core::Param<'a, IMFVideoSampleAllocatorNotify> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFVideoSampleAllocatorNotify> for &IMFVideoSampleAllocatorNotifyEx {
fn into_param(self) -> ::windows::core::Param<'a, IMFVideoSampleAllocatorNotify> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFVideoSampleAllocatorNotifyEx_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, __midl__imfvideosampleallocatornotifyex0000: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFVirtualCamera(pub ::windows::core::IUnknown);
impl IMFVirtualCamera {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItem(&self, guidkey: *const ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn GetItemType(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<MF_ATTRIBUTE_TYPE> {
let mut result__: <MF_ATTRIBUTE_TYPE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<MF_ATTRIBUTE_TYPE>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn CompareItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Compare<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, ptheirs: Param0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ptheirs.into_param().abi(), ::core::mem::transmute(matchtype), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
pub unsafe fn GetUINT32(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetUINT64(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetDouble(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<f64> {
let mut result__: <f64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<f64>(result__)
}
pub unsafe fn GetGUID(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
pub unsafe fn GetStringLength(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetString(&self, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pwszvalue), ::core::mem::transmute(cchbufsize), ::core::mem::transmute(pcchlength)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetAllocatedString(&self, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppwszvalue), ::core::mem::transmute(pcchlength)).ok()
}
pub unsafe fn GetBlobSize(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize), ::core::mem::transmute(pcbblobsize)).ok()
}
pub unsafe fn GetAllocatedBlob(&self, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(ppbuf), ::core::mem::transmute(pcbsize)).ok()
}
pub unsafe fn GetUnknown<T: ::windows::core::Interface>(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn SetItem(&self, guidkey: *const ::windows::core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(value)).ok()
}
pub unsafe fn DeleteItem(&self, guidkey: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey)).ok()
}
pub unsafe fn DeleteAllItems(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetUINT32(&self, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetUINT64(&self, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(unvalue)).ok()
}
pub unsafe fn SetDouble(&self, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(fvalue)).ok()
}
pub unsafe fn SetGUID(&self, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(guidvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetString<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, guidkey: *const ::windows::core::GUID, wszvalue: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), wszvalue.into_param().abi()).ok()
}
pub unsafe fn SetBlob(&self, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize)).ok()
}
pub unsafe fn SetUnknown<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guidkey: *const ::windows::core::GUID, punknown: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidkey), punknown.into_param().abi()).ok()
}
pub unsafe fn LockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn UnlockStore(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(unindex), ::core::mem::transmute(pguidkey), ::core::mem::transmute(pvalue)).ok()
}
pub unsafe fn CopyAllItems<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(&self, pdest: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), pdest.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddDeviceSourceInfo<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, devicesourceinfo: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), devicesourceinfo.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Devices_Properties")]
pub unsafe fn AddProperty(&self, pkey: *const super::super::Devices::Properties::DEVPROPKEY, r#type: u32, pbdata: *const u8, cbdata: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), ::core::mem::transmute(pkey), ::core::mem::transmute(r#type), ::core::mem::transmute(pbdata), ::core::mem::transmute(cbdata)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddRegistryEntry<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, entryname: Param0, subkeypath: Param1, dwregtype: u32, pbdata: *const u8, cbdata: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), entryname.into_param().abi(), subkeypath.into_param().abi(), ::core::mem::transmute(dwregtype), ::core::mem::transmute(pbdata), ::core::mem::transmute(cbdata)).ok()
}
pub unsafe fn Start<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncCallback>>(&self, pcallback: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), pcallback.into_param().abi()).ok()
}
pub unsafe fn Stop(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Remove(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetMediaSource(&self) -> ::windows::core::Result<IMFMediaSource> {
let mut result__: <IMFMediaSource as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IMFMediaSource>(result__)
}
pub unsafe fn SendCameraProperty(&self, propertyset: *const ::windows::core::GUID, propertyid: u32, propertyflags: u32, propertypayload: *mut ::core::ffi::c_void, propertypayloadlength: u32, data: *mut ::core::ffi::c_void, datalength: u32, datawritten: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).40)(
::core::mem::transmute_copy(self),
::core::mem::transmute(propertyset),
::core::mem::transmute(propertyid),
::core::mem::transmute(propertyflags),
::core::mem::transmute(propertypayload),
::core::mem::transmute(propertypayloadlength),
::core::mem::transmute(data),
::core::mem::transmute(datalength),
::core::mem::transmute(datawritten),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateSyncEvent<'a, Param3: ::windows::core::IntoParam<'a, super::super::Foundation::HANDLE>>(&self, kseventset: *const ::windows::core::GUID, kseventid: u32, kseventflags: u32, eventhandle: Param3) -> ::windows::core::Result<IMFCameraSyncObject> {
let mut result__: <IMFCameraSyncObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), ::core::mem::transmute(kseventset), ::core::mem::transmute(kseventid), ::core::mem::transmute(kseventflags), eventhandle.into_param().abi(), &mut result__).from_abi::<IMFCameraSyncObject>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateSyncSemaphore<'a, Param3: ::windows::core::IntoParam<'a, super::super::Foundation::HANDLE>>(&self, kseventset: *const ::windows::core::GUID, kseventid: u32, kseventflags: u32, semaphorehandle: Param3, semaphoreadjustment: i32) -> ::windows::core::Result<IMFCameraSyncObject> {
let mut result__: <IMFCameraSyncObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self), ::core::mem::transmute(kseventset), ::core::mem::transmute(kseventid), ::core::mem::transmute(kseventflags), semaphorehandle.into_param().abi(), ::core::mem::transmute(semaphoreadjustment), &mut result__).from_abi::<IMFCameraSyncObject>(result__)
}
pub unsafe fn Shutdown(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IMFVirtualCamera {
type Vtable = IMFVirtualCamera_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1c08a864_ef6c_4c75_af59_5f2d68da9563);
}
impl ::core::convert::From<IMFVirtualCamera> for ::windows::core::IUnknown {
fn from(value: IMFVirtualCamera) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFVirtualCamera> for ::windows::core::IUnknown {
fn from(value: &IMFVirtualCamera) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFVirtualCamera {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFVirtualCamera {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFVirtualCamera> for IMFAttributes {
fn from(value: IMFVirtualCamera) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFVirtualCamera> for IMFAttributes {
fn from(value: &IMFVirtualCamera) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for IMFVirtualCamera {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAttributes> for &IMFVirtualCamera {
fn into_param(self) -> ::windows::core::Param<'a, IMFAttributes> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFVirtualCamera_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ptype: *mut MF_ATTRIBUTE_TYPE) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptheirs: ::windows::core::RawPtr, matchtype: MF_ATTRIBUTES_MATCH_TYPE, pbresult: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punvalue: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pfvalue: *mut f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pguidvalue: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pwszvalue: super::super::Foundation::PWSTR, cchbufsize: u32, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppwszvalue: *mut super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, value: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, unvalue: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, fvalue: f64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, guidvalue: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, wszvalue: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidkey: *const ::windows::core::GUID, punknown: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcitems: *mut u32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, unindex: u32, pguidkey: *mut ::windows::core::GUID, pvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdest: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, devicesourceinfo: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Devices_Properties")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pkey: *const super::super::Devices::Properties::DEVPROPKEY, r#type: u32, pbdata: *const u8, cbdata: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Devices_Properties"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, entryname: super::super::Foundation::PWSTR, subkeypath: super::super::Foundation::PWSTR, dwregtype: u32, pbdata: *const u8, cbdata: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcallback: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppmediasource: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, propertyset: *const ::windows::core::GUID, propertyid: u32, propertyflags: u32, propertypayload: *mut ::core::ffi::c_void, propertypayloadlength: u32, data: *mut ::core::ffi::c_void, datalength: u32, datawritten: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kseventset: *const ::windows::core::GUID, kseventid: u32, kseventflags: u32, eventhandle: super::super::Foundation::HANDLE, camerasyncobject: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kseventset: *const ::windows::core::GUID, kseventid: u32, kseventflags: u32, semaphorehandle: super::super::Foundation::HANDLE, semaphoreadjustment: i32, camerasyncobject: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFWorkQueueServices(pub ::windows::core::IUnknown);
impl IMFWorkQueueServices {
pub unsafe fn BeginRegisterTopologyWorkQueuesWithMMCSS<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pcallback: Param0, pstate: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pcallback.into_param().abi(), pstate.into_param().abi()).ok()
}
pub unsafe fn EndRegisterTopologyWorkQueuesWithMMCSS<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), presult.into_param().abi()).ok()
}
pub unsafe fn BeginUnregisterTopologyWorkQueuesWithMMCSS<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pcallback: Param0, pstate: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pcallback.into_param().abi(), pstate.into_param().abi()).ok()
}
pub unsafe fn EndUnregisterTopologyWorkQueuesWithMMCSS<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), presult.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTopologyWorkQueueMMCSSClass(&self, dwtopologyworkqueueid: u32, pwszclass: super::super::Foundation::PWSTR, pcchclass: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwtopologyworkqueueid), ::core::mem::transmute(pwszclass), ::core::mem::transmute(pcchclass)).ok()
}
pub unsafe fn GetTopologyWorkQueueMMCSSTaskId(&self, dwtopologyworkqueueid: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwtopologyworkqueueid), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn BeginRegisterPlatformWorkQueueWithMMCSS<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param4: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, dwplatformworkqueue: u32, wszclass: Param1, dwtaskid: u32, pcallback: Param3, pstate: Param4) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwplatformworkqueue), wszclass.into_param().abi(), ::core::mem::transmute(dwtaskid), pcallback.into_param().abi(), pstate.into_param().abi()).ok()
}
pub unsafe fn EndRegisterPlatformWorkQueueWithMMCSS<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), presult.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn BeginUnregisterPlatformWorkQueueWithMMCSS<'a, Param1: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param2: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, dwplatformworkqueue: u32, pcallback: Param1, pstate: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwplatformworkqueue), pcallback.into_param().abi(), pstate.into_param().abi()).ok()
}
pub unsafe fn EndUnregisterPlatformWorkQueueWithMMCSS<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), presult.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPlaftormWorkQueueMMCSSClass(&self, dwplatformworkqueueid: u32, pwszclass: super::super::Foundation::PWSTR, pcchclass: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwplatformworkqueueid), ::core::mem::transmute(pwszclass), ::core::mem::transmute(pcchclass)).ok()
}
pub unsafe fn GetPlatformWorkQueueMMCSSTaskId(&self, dwplatformworkqueueid: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwplatformworkqueueid), &mut result__).from_abi::<u32>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFWorkQueueServices {
type Vtable = IMFWorkQueueServices_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x35fe1bb8_a3a9_40fe_bbec_eb569c9ccca3);
}
impl ::core::convert::From<IMFWorkQueueServices> for ::windows::core::IUnknown {
fn from(value: IMFWorkQueueServices) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFWorkQueueServices> for ::windows::core::IUnknown {
fn from(value: &IMFWorkQueueServices) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFWorkQueueServices {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFWorkQueueServices {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFWorkQueueServices_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcallback: ::windows::core::RawPtr, pstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcallback: ::windows::core::RawPtr, pstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwtopologyworkqueueid: u32, pwszclass: super::super::Foundation::PWSTR, pcchclass: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwtopologyworkqueueid: u32, pdwtaskid: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwplatformworkqueue: u32, wszclass: super::super::Foundation::PWSTR, dwtaskid: u32, pcallback: ::windows::core::RawPtr, pstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr, pdwtaskid: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwplatformworkqueue: u32, pcallback: ::windows::core::RawPtr, pstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwplatformworkqueueid: u32, pwszclass: super::super::Foundation::PWSTR, pcchclass: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwplatformworkqueueid: u32, pdwtaskid: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMFWorkQueueServicesEx(pub ::windows::core::IUnknown);
impl IMFWorkQueueServicesEx {
pub unsafe fn BeginRegisterTopologyWorkQueuesWithMMCSS<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pcallback: Param0, pstate: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pcallback.into_param().abi(), pstate.into_param().abi()).ok()
}
pub unsafe fn EndRegisterTopologyWorkQueuesWithMMCSS<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), presult.into_param().abi()).ok()
}
pub unsafe fn BeginUnregisterTopologyWorkQueuesWithMMCSS<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, pcallback: Param0, pstate: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pcallback.into_param().abi(), pstate.into_param().abi()).ok()
}
pub unsafe fn EndUnregisterTopologyWorkQueuesWithMMCSS<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), presult.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTopologyWorkQueueMMCSSClass(&self, dwtopologyworkqueueid: u32, pwszclass: super::super::Foundation::PWSTR, pcchclass: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwtopologyworkqueueid), ::core::mem::transmute(pwszclass), ::core::mem::transmute(pcchclass)).ok()
}
pub unsafe fn GetTopologyWorkQueueMMCSSTaskId(&self, dwtopologyworkqueueid: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwtopologyworkqueueid), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn BeginRegisterPlatformWorkQueueWithMMCSS<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param4: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, dwplatformworkqueue: u32, wszclass: Param1, dwtaskid: u32, pcallback: Param3, pstate: Param4) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwplatformworkqueue), wszclass.into_param().abi(), ::core::mem::transmute(dwtaskid), pcallback.into_param().abi(), pstate.into_param().abi()).ok()
}
pub unsafe fn EndRegisterPlatformWorkQueueWithMMCSS<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), presult.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn BeginUnregisterPlatformWorkQueueWithMMCSS<'a, Param1: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param2: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, dwplatformworkqueue: u32, pcallback: Param1, pstate: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwplatformworkqueue), pcallback.into_param().abi(), pstate.into_param().abi()).ok()
}
pub unsafe fn EndUnregisterPlatformWorkQueueWithMMCSS<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(&self, presult: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), presult.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPlaftormWorkQueueMMCSSClass(&self, dwplatformworkqueueid: u32, pwszclass: super::super::Foundation::PWSTR, pcchclass: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwplatformworkqueueid), ::core::mem::transmute(pwszclass), ::core::mem::transmute(pcchclass)).ok()
}
pub unsafe fn GetPlatformWorkQueueMMCSSTaskId(&self, dwplatformworkqueueid: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwplatformworkqueueid), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetTopologyWorkQueueMMCSSPriority(&self, dwtopologyworkqueueid: u32) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwtopologyworkqueueid), &mut result__).from_abi::<i32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn BeginRegisterPlatformWorkQueueWithMMCSSEx<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param5: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, dwplatformworkqueue: u32, wszclass: Param1, dwtaskid: u32, lpriority: i32, pcallback: Param4, pstate: Param5) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwplatformworkqueue), wszclass.into_param().abi(), ::core::mem::transmute(dwtaskid), ::core::mem::transmute(lpriority), pcallback.into_param().abi(), pstate.into_param().abi()).ok()
}
pub unsafe fn GetPlatformWorkQueueMMCSSPriority(&self, dwplatformworkqueueid: u32) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwplatformworkqueueid), &mut result__).from_abi::<i32>(result__)
}
}
unsafe impl ::windows::core::Interface for IMFWorkQueueServicesEx {
type Vtable = IMFWorkQueueServicesEx_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x96bf961b_40fe_42f1_ba9d_320238b49700);
}
impl ::core::convert::From<IMFWorkQueueServicesEx> for ::windows::core::IUnknown {
fn from(value: IMFWorkQueueServicesEx) -> Self {
value.0
}
}
impl ::core::convert::From<&IMFWorkQueueServicesEx> for ::windows::core::IUnknown {
fn from(value: &IMFWorkQueueServicesEx) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMFWorkQueueServicesEx {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMFWorkQueueServicesEx {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IMFWorkQueueServicesEx> for IMFWorkQueueServices {
fn from(value: IMFWorkQueueServicesEx) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IMFWorkQueueServicesEx> for IMFWorkQueueServices {
fn from(value: &IMFWorkQueueServicesEx) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFWorkQueueServices> for IMFWorkQueueServicesEx {
fn into_param(self) -> ::windows::core::Param<'a, IMFWorkQueueServices> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFWorkQueueServices> for &IMFWorkQueueServicesEx {
fn into_param(self) -> ::windows::core::Param<'a, IMFWorkQueueServices> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMFWorkQueueServicesEx_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcallback: ::windows::core::RawPtr, pstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcallback: ::windows::core::RawPtr, pstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwtopologyworkqueueid: u32, pwszclass: super::super::Foundation::PWSTR, pcchclass: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwtopologyworkqueueid: u32, pdwtaskid: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwplatformworkqueue: u32, wszclass: super::super::Foundation::PWSTR, dwtaskid: u32, pcallback: ::windows::core::RawPtr, pstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr, pdwtaskid: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwplatformworkqueue: u32, pcallback: ::windows::core::RawPtr, pstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, presult: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwplatformworkqueueid: u32, pwszclass: super::super::Foundation::PWSTR, pcchclass: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwplatformworkqueueid: u32, pdwtaskid: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwtopologyworkqueueid: u32, plpriority: *mut i32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwplatformworkqueue: u32, wszclass: super::super::Foundation::PWSTR, dwtaskid: u32, lpriority: i32, pcallback: ::windows::core::RawPtr, pstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwplatformworkqueueid: u32, plpriority: *mut i32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IOPMVideoOutput(pub ::windows::core::IUnknown);
impl IOPMVideoOutput {
pub unsafe fn StartInitialization(&self, prnrandomnumber: *mut OPM_RANDOM_NUMBER, ppbcertificate: *mut *mut u8, pulcertificatelength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(prnrandomnumber), ::core::mem::transmute(ppbcertificate), ::core::mem::transmute(pulcertificatelength)).ok()
}
pub unsafe fn FinishInitialization(&self, pparameters: *const OPM_ENCRYPTED_INITIALIZATION_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pparameters)).ok()
}
pub unsafe fn GetInformation(&self, pparameters: *const OPM_GET_INFO_PARAMETERS) -> ::windows::core::Result<OPM_REQUESTED_INFORMATION> {
let mut result__: <OPM_REQUESTED_INFORMATION as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(pparameters), &mut result__).from_abi::<OPM_REQUESTED_INFORMATION>(result__)
}
pub unsafe fn COPPCompatibleGetInformation(&self, pparameters: *const OPM_COPP_COMPATIBLE_GET_INFO_PARAMETERS) -> ::windows::core::Result<OPM_REQUESTED_INFORMATION> {
let mut result__: <OPM_REQUESTED_INFORMATION as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(pparameters), &mut result__).from_abi::<OPM_REQUESTED_INFORMATION>(result__)
}
pub unsafe fn Configure(&self, pparameters: *const OPM_CONFIGURE_PARAMETERS, uladditionalparameterssize: u32, pbadditionalparameters: *const u8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(pparameters), ::core::mem::transmute(uladditionalparameterssize), ::core::mem::transmute(pbadditionalparameters)).ok()
}
}
unsafe impl ::windows::core::Interface for IOPMVideoOutput {
type Vtable = IOPMVideoOutput_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0a15159d_41c7_4456_93e1_284cd61d4e8d);
}
impl ::core::convert::From<IOPMVideoOutput> for ::windows::core::IUnknown {
fn from(value: IOPMVideoOutput) -> Self {
value.0
}
}
impl ::core::convert::From<&IOPMVideoOutput> for ::windows::core::IUnknown {
fn from(value: &IOPMVideoOutput) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IOPMVideoOutput {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IOPMVideoOutput {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IOPMVideoOutput_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prnrandomnumber: *mut OPM_RANDOM_NUMBER, ppbcertificate: *mut *mut u8, pulcertificatelength: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pparameters: *const OPM_ENCRYPTED_INITIALIZATION_PARAMETERS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pparameters: *const OPM_GET_INFO_PARAMETERS, prequestedinformation: *mut OPM_REQUESTED_INFORMATION) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pparameters: *const OPM_COPP_COMPATIBLE_GET_INFO_PARAMETERS, prequestedinformation: *mut OPM_REQUESTED_INFORMATION) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pparameters: *const OPM_CONFIGURE_PARAMETERS, uladditionalparameterssize: u32, pbadditionalparameters: *const u8) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IPlayToControl(pub ::windows::core::IUnknown);
impl IPlayToControl {
pub unsafe fn Connect<'a, Param0: ::windows::core::IntoParam<'a, IMFSharingEngineClassFactory>>(&self, pfactory: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pfactory.into_param().abi()).ok()
}
pub unsafe fn Disconnect(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IPlayToControl {
type Vtable = IPlayToControl_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x607574eb_f4b6_45c1_b08c_cb715122901d);
}
impl ::core::convert::From<IPlayToControl> for ::windows::core::IUnknown {
fn from(value: IPlayToControl) -> Self {
value.0
}
}
impl ::core::convert::From<&IPlayToControl> for ::windows::core::IUnknown {
fn from(value: &IPlayToControl) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IPlayToControl {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IPlayToControl {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IPlayToControl_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfactory: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IPlayToControlWithCapabilities(pub ::windows::core::IUnknown);
impl IPlayToControlWithCapabilities {
pub unsafe fn Connect<'a, Param0: ::windows::core::IntoParam<'a, IMFSharingEngineClassFactory>>(&self, pfactory: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pfactory.into_param().abi()).ok()
}
pub unsafe fn Disconnect(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetCapabilities(&self) -> ::windows::core::Result<PLAYTO_SOURCE_CREATEFLAGS> {
let mut result__: <PLAYTO_SOURCE_CREATEFLAGS as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<PLAYTO_SOURCE_CREATEFLAGS>(result__)
}
}
unsafe impl ::windows::core::Interface for IPlayToControlWithCapabilities {
type Vtable = IPlayToControlWithCapabilities_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xaa9dd80f_c50a_4220_91c1_332287f82a34);
}
impl ::core::convert::From<IPlayToControlWithCapabilities> for ::windows::core::IUnknown {
fn from(value: IPlayToControlWithCapabilities) -> Self {
value.0
}
}
impl ::core::convert::From<&IPlayToControlWithCapabilities> for ::windows::core::IUnknown {
fn from(value: &IPlayToControlWithCapabilities) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IPlayToControlWithCapabilities {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IPlayToControlWithCapabilities {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IPlayToControlWithCapabilities> for IPlayToControl {
fn from(value: IPlayToControlWithCapabilities) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IPlayToControlWithCapabilities> for IPlayToControl {
fn from(value: &IPlayToControlWithCapabilities) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IPlayToControl> for IPlayToControlWithCapabilities {
fn into_param(self) -> ::windows::core::Param<'a, IPlayToControl> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IPlayToControl> for &IPlayToControlWithCapabilities {
fn into_param(self) -> ::windows::core::Param<'a, IPlayToControl> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IPlayToControlWithCapabilities_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfactory: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcapabilities: *mut PLAYTO_SOURCE_CREATEFLAGS) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IPlayToSourceClassFactory(pub ::windows::core::IUnknown);
impl IPlayToSourceClassFactory {
pub unsafe fn CreateInstance<'a, Param1: ::windows::core::IntoParam<'a, IPlayToControl>>(&self, dwflags: u32, pcontrol: Param1) -> ::windows::core::Result<::windows::core::IInspectable> {
let mut result__: <::windows::core::IInspectable as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwflags), pcontrol.into_param().abi(), &mut result__).from_abi::<::windows::core::IInspectable>(result__)
}
}
unsafe impl ::windows::core::Interface for IPlayToSourceClassFactory {
type Vtable = IPlayToSourceClassFactory_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x842b32a3_9b9b_4d1c_b3f3_49193248a554);
}
impl ::core::convert::From<IPlayToSourceClassFactory> for ::windows::core::IUnknown {
fn from(value: IPlayToSourceClassFactory) -> Self {
value.0
}
}
impl ::core::convert::From<&IPlayToSourceClassFactory> for ::windows::core::IUnknown {
fn from(value: &IPlayToSourceClassFactory) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IPlayToSourceClassFactory {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IPlayToSourceClassFactory {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IPlayToSourceClassFactory_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwflags: u32, pcontrol: ::windows::core::RawPtr, ppsource: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IToc(pub ::windows::core::IUnknown);
impl IToc {
pub unsafe fn SetDescriptor(&self, pdescriptor: *mut TOC_DESCRIPTOR) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdescriptor)).ok()
}
pub unsafe fn GetDescriptor(&self, pdescriptor: *mut TOC_DESCRIPTOR) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdescriptor)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetDescription<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pwszdescription: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pwszdescription.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDescription(&self, pwdescriptionsize: *mut u16, pwszdescription: super::super::Foundation::PWSTR) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(pwdescriptionsize), ::core::mem::transmute(pwszdescription)).ok()
}
pub unsafe fn SetContext(&self, dwcontextsize: u32, pbtcontext: *mut u8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwcontextsize), ::core::mem::transmute(pbtcontext)).ok()
}
pub unsafe fn GetContext(&self, pdwcontextsize: *mut u32, pbtcontext: *mut u8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdwcontextsize), ::core::mem::transmute(pbtcontext)).ok()
}
pub unsafe fn GetEntryListCount(&self, pwcount: *mut u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(pwcount)).ok()
}
pub unsafe fn GetEntryListByIndex(&self, wentrylistindex: u16) -> ::windows::core::Result<ITocEntryList> {
let mut result__: <ITocEntryList as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(wentrylistindex), &mut result__).from_abi::<ITocEntryList>(result__)
}
pub unsafe fn AddEntryList<'a, Param0: ::windows::core::IntoParam<'a, ITocEntryList>>(&self, pentrylist: Param0, pwentrylistindex: *mut u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), pentrylist.into_param().abi(), ::core::mem::transmute(pwentrylistindex)).ok()
}
pub unsafe fn AddEntryListByIndex<'a, Param1: ::windows::core::IntoParam<'a, ITocEntryList>>(&self, wentrylistindex: u16, pentrylist: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(wentrylistindex), pentrylist.into_param().abi()).ok()
}
pub unsafe fn RemoveEntryListByIndex(&self, wentrylistindex: u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(wentrylistindex)).ok()
}
}
unsafe impl ::windows::core::Interface for IToc {
type Vtable = IToc_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd6f05441_a919_423b_91a0_89d5b4a8ab77);
}
impl ::core::convert::From<IToc> for ::windows::core::IUnknown {
fn from(value: IToc) -> Self {
value.0
}
}
impl ::core::convert::From<&IToc> for ::windows::core::IUnknown {
fn from(value: &IToc) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IToc {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IToc {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IToc_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdescriptor: *mut TOC_DESCRIPTOR) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdescriptor: *mut TOC_DESCRIPTOR) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pwszdescription: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pwdescriptionsize: *mut u16, pwszdescription: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwcontextsize: u32, pbtcontext: *mut u8) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcontextsize: *mut u32, pbtcontext: *mut u8) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pwcount: *mut u16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, wentrylistindex: u16, ppentrylist: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pentrylist: ::windows::core::RawPtr, pwentrylistindex: *mut u16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, wentrylistindex: u16, pentrylist: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, wentrylistindex: u16) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ITocCollection(pub ::windows::core::IUnknown);
impl ITocCollection {
pub unsafe fn GetEntryCount(&self, pdwentrycount: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdwentrycount)).ok()
}
pub unsafe fn GetEntryByIndex(&self, dwentryindex: u32) -> ::windows::core::Result<IToc> {
let mut result__: <IToc as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwentryindex), &mut result__).from_abi::<IToc>(result__)
}
pub unsafe fn AddEntry<'a, Param0: ::windows::core::IntoParam<'a, IToc>>(&self, ptoc: Param0, pdwentryindex: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ptoc.into_param().abi(), ::core::mem::transmute(pdwentryindex)).ok()
}
pub unsafe fn AddEntryByIndex<'a, Param1: ::windows::core::IntoParam<'a, IToc>>(&self, dwentryindex: u32, ptoc: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwentryindex), ptoc.into_param().abi()).ok()
}
pub unsafe fn RemoveEntryByIndex(&self, dwentryindex: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwentryindex)).ok()
}
}
unsafe impl ::windows::core::Interface for ITocCollection {
type Vtable = ITocCollection_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x23fee831_ae96_42df_b170_25a04847a3ca);
}
impl ::core::convert::From<ITocCollection> for ::windows::core::IUnknown {
fn from(value: ITocCollection) -> Self {
value.0
}
}
impl ::core::convert::From<&ITocCollection> for ::windows::core::IUnknown {
fn from(value: &ITocCollection) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ITocCollection {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ITocCollection {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ITocCollection_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwentrycount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwentryindex: u32, pptoc: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptoc: ::windows::core::RawPtr, pdwentryindex: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwentryindex: u32, ptoc: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwentryindex: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ITocEntry(pub ::windows::core::IUnknown);
impl ITocEntry {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetTitle<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pwsztitle: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pwsztitle.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTitle(&self, pwtitlesize: *mut u16, pwsztitle: super::super::Foundation::PWSTR) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pwtitlesize), ::core::mem::transmute(pwsztitle)).ok()
}
pub unsafe fn SetDescriptor(&self, pdescriptor: *mut TOC_ENTRY_DESCRIPTOR) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdescriptor)).ok()
}
pub unsafe fn GetDescriptor(&self, pdescriptor: *mut TOC_ENTRY_DESCRIPTOR) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdescriptor)).ok()
}
pub unsafe fn SetSubEntries(&self, dwnumsubentries: u32, pwsubentryindices: *mut u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwnumsubentries), ::core::mem::transmute(pwsubentryindices)).ok()
}
pub unsafe fn GetSubEntries(&self, pdwnumsubentries: *mut u32, pwsubentryindices: *mut u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdwnumsubentries), ::core::mem::transmute(pwsubentryindices)).ok()
}
pub unsafe fn SetDescriptionData(&self, dwdescriptiondatasize: u32, pbtdescriptiondata: *mut u8, pguidtype: *mut ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwdescriptiondatasize), ::core::mem::transmute(pbtdescriptiondata), ::core::mem::transmute(pguidtype)).ok()
}
pub unsafe fn GetDescriptionData(&self, pdwdescriptiondatasize: *mut u32, pbtdescriptiondata: *mut u8, pguidtype: *mut ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdwdescriptiondatasize), ::core::mem::transmute(pbtdescriptiondata), ::core::mem::transmute(pguidtype)).ok()
}
}
unsafe impl ::windows::core::Interface for ITocEntry {
type Vtable = ITocEntry_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf22f5e06_585c_4def_8523_6555cfbc0cb3);
}
impl ::core::convert::From<ITocEntry> for ::windows::core::IUnknown {
fn from(value: ITocEntry) -> Self {
value.0
}
}
impl ::core::convert::From<&ITocEntry> for ::windows::core::IUnknown {
fn from(value: &ITocEntry) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ITocEntry {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ITocEntry {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ITocEntry_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pwsztitle: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pwtitlesize: *mut u16, pwsztitle: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdescriptor: *mut TOC_ENTRY_DESCRIPTOR) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdescriptor: *mut TOC_ENTRY_DESCRIPTOR) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwnumsubentries: u32, pwsubentryindices: *mut u16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwnumsubentries: *mut u32, pwsubentryindices: *mut u16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwdescriptiondatasize: u32, pbtdescriptiondata: *mut u8, pguidtype: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwdescriptiondatasize: *mut u32, pbtdescriptiondata: *mut u8, pguidtype: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ITocEntryList(pub ::windows::core::IUnknown);
impl ITocEntryList {
pub unsafe fn GetEntryCount(&self, pdwentrycount: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdwentrycount)).ok()
}
pub unsafe fn GetEntryByIndex(&self, dwentryindex: u32) -> ::windows::core::Result<ITocEntry> {
let mut result__: <ITocEntry as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwentryindex), &mut result__).from_abi::<ITocEntry>(result__)
}
pub unsafe fn AddEntry<'a, Param0: ::windows::core::IntoParam<'a, ITocEntry>>(&self, pentry: Param0, pdwentryindex: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pentry.into_param().abi(), ::core::mem::transmute(pdwentryindex)).ok()
}
pub unsafe fn AddEntryByIndex<'a, Param1: ::windows::core::IntoParam<'a, ITocEntry>>(&self, dwentryindex: u32, pentry: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwentryindex), pentry.into_param().abi()).ok()
}
pub unsafe fn RemoveEntryByIndex(&self, dwentryindex: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwentryindex)).ok()
}
}
unsafe impl ::windows::core::Interface for ITocEntryList {
type Vtable = ITocEntryList_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3a8cccbd_0efd_43a3_b838_f38a552ba237);
}
impl ::core::convert::From<ITocEntryList> for ::windows::core::IUnknown {
fn from(value: ITocEntryList) -> Self {
value.0
}
}
impl ::core::convert::From<&ITocEntryList> for ::windows::core::IUnknown {
fn from(value: &ITocEntryList) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ITocEntryList {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ITocEntryList {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ITocEntryList_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwentrycount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwentryindex: u32, ppentry: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pentry: ::windows::core::RawPtr, pdwentryindex: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwentryindex: u32, pentry: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwentryindex: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ITocParser(pub ::windows::core::IUnknown);
impl ITocParser {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Init<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pwszfilename: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pwszfilename.into_param().abi()).ok()
}
pub unsafe fn GetTocCount(&self, enumtocpostype: TOC_POS_TYPE, pdwtoccount: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(enumtocpostype), ::core::mem::transmute(pdwtoccount)).ok()
}
pub unsafe fn GetTocByIndex(&self, enumtocpostype: TOC_POS_TYPE, dwtocindex: u32) -> ::windows::core::Result<IToc> {
let mut result__: <IToc as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(enumtocpostype), ::core::mem::transmute(dwtocindex), &mut result__).from_abi::<IToc>(result__)
}
pub unsafe fn GetTocByType<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::GUID>>(&self, enumtocpostype: TOC_POS_TYPE, guidtoctype: Param1) -> ::windows::core::Result<ITocCollection> {
let mut result__: <ITocCollection as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(enumtocpostype), guidtoctype.into_param().abi(), &mut result__).from_abi::<ITocCollection>(result__)
}
pub unsafe fn AddToc<'a, Param1: ::windows::core::IntoParam<'a, IToc>>(&self, enumtocpostype: TOC_POS_TYPE, ptoc: Param1, pdwtocindex: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(enumtocpostype), ptoc.into_param().abi(), ::core::mem::transmute(pdwtocindex)).ok()
}
pub unsafe fn RemoveTocByIndex(&self, enumtocpostype: TOC_POS_TYPE, dwtocindex: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(enumtocpostype), ::core::mem::transmute(dwtocindex)).ok()
}
pub unsafe fn RemoveTocByType<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::GUID>>(&self, enumtocpostype: TOC_POS_TYPE, guidtoctype: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(enumtocpostype), guidtoctype.into_param().abi()).ok()
}
pub unsafe fn Commit(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for ITocParser {
type Vtable = ITocParser_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xecfb9a55_9298_4f49_887f_0b36206599d2);
}
impl ::core::convert::From<ITocParser> for ::windows::core::IUnknown {
fn from(value: ITocParser) -> Self {
value.0
}
}
impl ::core::convert::From<&ITocParser> for ::windows::core::IUnknown {
fn from(value: &ITocParser) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ITocParser {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ITocParser {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ITocParser_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pwszfilename: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, enumtocpostype: TOC_POS_TYPE, pdwtoccount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, enumtocpostype: TOC_POS_TYPE, dwtocindex: u32, pptoc: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, enumtocpostype: TOC_POS_TYPE, guidtoctype: ::windows::core::GUID, pptocs: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, enumtocpostype: TOC_POS_TYPE, ptoc: ::windows::core::RawPtr, pdwtocindex: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, enumtocpostype: TOC_POS_TYPE, dwtocindex: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, enumtocpostype: TOC_POS_TYPE, guidtoctype: ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IValidateBinding(pub ::windows::core::IUnknown);
impl IValidateBinding {
pub unsafe fn GetIdentifier<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::GUID>>(&self, guidlicensorid: Param0, pbephemeron: *const u8, cbephemeron: u32, ppbblobvalidationid: *mut *mut u8, pcbblobsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), guidlicensorid.into_param().abi(), ::core::mem::transmute(pbephemeron), ::core::mem::transmute(cbephemeron), ::core::mem::transmute(ppbblobvalidationid), ::core::mem::transmute(pcbblobsize)).ok()
}
}
unsafe impl ::windows::core::Interface for IValidateBinding {
type Vtable = IValidateBinding_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x04a578b2_e778_422a_a805_b3ee54d90bd9);
}
impl ::core::convert::From<IValidateBinding> for ::windows::core::IUnknown {
fn from(value: IValidateBinding) -> Self {
value.0
}
}
impl ::core::convert::From<&IValidateBinding> for ::windows::core::IUnknown {
fn from(value: &IValidateBinding) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IValidateBinding {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IValidateBinding {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IValidateBinding_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidlicensorid: ::windows::core::GUID, pbephemeron: *const u8, cbephemeron: u32, ppbblobvalidationid: *mut *mut u8, pcbblobsize: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IWMCodecLeakyBucket(pub ::windows::core::IUnknown);
impl IWMCodecLeakyBucket {
pub unsafe fn SetBufferSizeBits(&self, ulbuffersize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulbuffersize)).ok()
}
pub unsafe fn GetBufferSizeBits(&self, pulbuffersize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pulbuffersize)).ok()
}
pub unsafe fn SetBufferFullnessBits(&self, ulbufferfullness: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulbufferfullness)).ok()
}
pub unsafe fn GetBufferFullnessBits(&self, pulbufferfullness: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(pulbufferfullness)).ok()
}
}
unsafe impl ::windows::core::Interface for IWMCodecLeakyBucket {
type Vtable = IWMCodecLeakyBucket_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa81ba647_6227_43b7_b231_c7b15135dd7d);
}
impl ::core::convert::From<IWMCodecLeakyBucket> for ::windows::core::IUnknown {
fn from(value: IWMCodecLeakyBucket) -> Self {
value.0
}
}
impl ::core::convert::From<&IWMCodecLeakyBucket> for ::windows::core::IUnknown {
fn from(value: &IWMCodecLeakyBucket) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IWMCodecLeakyBucket {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IWMCodecLeakyBucket {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IWMCodecLeakyBucket_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulbuffersize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pulbuffersize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulbufferfullness: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pulbufferfullness: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IWMCodecOutputTimestamp(pub ::windows::core::IUnknown);
impl IWMCodecOutputTimestamp {
pub unsafe fn GetNextOutputTime(&self, prttime: *mut i64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(prttime)).ok()
}
}
unsafe impl ::windows::core::Interface for IWMCodecOutputTimestamp {
type Vtable = IWMCodecOutputTimestamp_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb72adf95_7adc_4a72_bc05_577d8ea6bf68);
}
impl ::core::convert::From<IWMCodecOutputTimestamp> for ::windows::core::IUnknown {
fn from(value: IWMCodecOutputTimestamp) -> Self {
value.0
}
}
impl ::core::convert::From<&IWMCodecOutputTimestamp> for ::windows::core::IUnknown {
fn from(value: &IWMCodecOutputTimestamp) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IWMCodecOutputTimestamp {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IWMCodecOutputTimestamp {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IWMCodecOutputTimestamp_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prttime: *mut i64) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IWMCodecPrivateData(pub ::windows::core::IUnknown);
impl IWMCodecPrivateData {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Media_DxMediaObjects"))]
pub unsafe fn SetPartialOutputType(&self, pmt: *mut super::DxMediaObjects::DMO_MEDIA_TYPE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pmt)).ok()
}
pub unsafe fn GetPrivateData(&self, pbdata: *mut u8, pcbdata: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbdata), ::core::mem::transmute(pcbdata)).ok()
}
}
unsafe impl ::windows::core::Interface for IWMCodecPrivateData {
type Vtable = IWMCodecPrivateData_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x73f0be8e_57f7_4f01_aa66_9f57340cfe0e);
}
impl ::core::convert::From<IWMCodecPrivateData> for ::windows::core::IUnknown {
fn from(value: IWMCodecPrivateData) -> Self {
value.0
}
}
impl ::core::convert::From<&IWMCodecPrivateData> for ::windows::core::IUnknown {
fn from(value: &IWMCodecPrivateData) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IWMCodecPrivateData {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IWMCodecPrivateData {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IWMCodecPrivateData_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Media_DxMediaObjects"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pmt: *mut ::core::mem::ManuallyDrop<super::DxMediaObjects::DMO_MEDIA_TYPE>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Media_DxMediaObjects")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbdata: *mut u8, pcbdata: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IWMCodecProps(pub ::windows::core::IUnknown);
impl IWMCodecProps {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Media_DxMediaObjects"))]
pub unsafe fn GetFormatProp<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pmt: *mut super::DxMediaObjects::DMO_MEDIA_TYPE, pszname: Param1, ptype: *mut WMT_PROP_DATATYPE, pvalue: *mut u8, pdwsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pmt), pszname.into_param().abi(), ::core::mem::transmute(ptype), ::core::mem::transmute(pvalue), ::core::mem::transmute(pdwsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetCodecProp<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, dwformat: u32, pszname: Param1, ptype: *mut WMT_PROP_DATATYPE, pvalue: *mut u8, pdwsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwformat), pszname.into_param().abi(), ::core::mem::transmute(ptype), ::core::mem::transmute(pvalue), ::core::mem::transmute(pdwsize)).ok()
}
}
unsafe impl ::windows::core::Interface for IWMCodecProps {
type Vtable = IWMCodecProps_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2573e11a_f01a_4fdd_a98d_63b8e0ba9589);
}
impl ::core::convert::From<IWMCodecProps> for ::windows::core::IUnknown {
fn from(value: IWMCodecProps) -> Self {
value.0
}
}
impl ::core::convert::From<&IWMCodecProps> for ::windows::core::IUnknown {
fn from(value: &IWMCodecProps) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IWMCodecProps {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IWMCodecProps {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IWMCodecProps_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Media_DxMediaObjects"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pmt: *mut ::core::mem::ManuallyDrop<super::DxMediaObjects::DMO_MEDIA_TYPE>, pszname: super::super::Foundation::PWSTR, ptype: *mut WMT_PROP_DATATYPE, pvalue: *mut u8, pdwsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Media_DxMediaObjects")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwformat: u32, pszname: super::super::Foundation::PWSTR, ptype: *mut WMT_PROP_DATATYPE, pvalue: *mut u8, pdwsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IWMCodecStrings(pub ::windows::core::IUnknown);
impl IWMCodecStrings {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Media_DxMediaObjects"))]
pub unsafe fn GetName(&self, pmt: *mut super::DxMediaObjects::DMO_MEDIA_TYPE, cchlength: u32, szname: super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pmt), ::core::mem::transmute(cchlength), ::core::mem::transmute(szname), ::core::mem::transmute(pcchlength)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Media_DxMediaObjects"))]
pub unsafe fn GetDescription(&self, pmt: *mut super::DxMediaObjects::DMO_MEDIA_TYPE, cchlength: u32, szdescription: super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pmt), ::core::mem::transmute(cchlength), ::core::mem::transmute(szdescription), ::core::mem::transmute(pcchlength)).ok()
}
}
unsafe impl ::windows::core::Interface for IWMCodecStrings {
type Vtable = IWMCodecStrings_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa7b2504b_e58a_47fb_958b_cac7165a057d);
}
impl ::core::convert::From<IWMCodecStrings> for ::windows::core::IUnknown {
fn from(value: IWMCodecStrings) -> Self {
value.0
}
}
impl ::core::convert::From<&IWMCodecStrings> for ::windows::core::IUnknown {
fn from(value: &IWMCodecStrings) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IWMCodecStrings {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IWMCodecStrings {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IWMCodecStrings_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Media_DxMediaObjects"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pmt: *mut ::core::mem::ManuallyDrop<super::DxMediaObjects::DMO_MEDIA_TYPE>, cchlength: u32, szname: super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Media_DxMediaObjects")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Media_DxMediaObjects"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pmt: *mut ::core::mem::ManuallyDrop<super::DxMediaObjects::DMO_MEDIA_TYPE>, cchlength: u32, szdescription: super::super::Foundation::PWSTR, pcchlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Media_DxMediaObjects")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IWMColorConvProps(pub ::windows::core::IUnknown);
impl IWMColorConvProps {
pub unsafe fn SetMode(&self, lmode: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(lmode)).ok()
}
pub unsafe fn SetFullCroppingParam(&self, lsrccropleft: i32, lsrccroptop: i32, ldstcropleft: i32, ldstcroptop: i32, lcropwidth: i32, lcropheight: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(lsrccropleft), ::core::mem::transmute(lsrccroptop), ::core::mem::transmute(ldstcropleft), ::core::mem::transmute(ldstcroptop), ::core::mem::transmute(lcropwidth), ::core::mem::transmute(lcropheight)).ok()
}
}
unsafe impl ::windows::core::Interface for IWMColorConvProps {
type Vtable = IWMColorConvProps_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe6a49e22_c099_421d_aad3_c061fb4ae85b);
}
impl ::core::convert::From<IWMColorConvProps> for ::windows::core::IUnknown {
fn from(value: IWMColorConvProps) -> Self {
value.0
}
}
impl ::core::convert::From<&IWMColorConvProps> for ::windows::core::IUnknown {
fn from(value: &IWMColorConvProps) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IWMColorConvProps {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IWMColorConvProps {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IWMColorConvProps_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, lmode: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, lsrccropleft: i32, lsrccroptop: i32, ldstcropleft: i32, ldstcroptop: i32, lcropwidth: i32, lcropheight: i32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IWMColorLegalizerProps(pub ::windows::core::IUnknown);
impl IWMColorLegalizerProps {
pub unsafe fn SetColorLegalizerQuality(&self, lquality: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(lquality)).ok()
}
}
unsafe impl ::windows::core::Interface for IWMColorLegalizerProps {
type Vtable = IWMColorLegalizerProps_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x776c93b3_b72d_4508_b6d0_208785f553e7);
}
impl ::core::convert::From<IWMColorLegalizerProps> for ::windows::core::IUnknown {
fn from(value: IWMColorLegalizerProps) -> Self {
value.0
}
}
impl ::core::convert::From<&IWMColorLegalizerProps> for ::windows::core::IUnknown {
fn from(value: &IWMColorLegalizerProps) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IWMColorLegalizerProps {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IWMColorLegalizerProps {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IWMColorLegalizerProps_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, lquality: i32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IWMFrameInterpProps(pub ::windows::core::IUnknown);
impl IWMFrameInterpProps {
pub unsafe fn SetFrameRateIn(&self, lframerate: i32, lscale: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(lframerate), ::core::mem::transmute(lscale)).ok()
}
pub unsafe fn SetFrameRateOut(&self, lframerate: i32, lscale: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(lframerate), ::core::mem::transmute(lscale)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetFrameInterpEnabled<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, bfienabled: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), bfienabled.into_param().abi()).ok()
}
pub unsafe fn SetComplexityLevel(&self, icomplexity: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(icomplexity)).ok()
}
}
unsafe impl ::windows::core::Interface for IWMFrameInterpProps {
type Vtable = IWMFrameInterpProps_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4c06bb9b_626c_4614_8329_cc6a21b93fa0);
}
impl ::core::convert::From<IWMFrameInterpProps> for ::windows::core::IUnknown {
fn from(value: IWMFrameInterpProps) -> Self {
value.0
}
}
impl ::core::convert::From<&IWMFrameInterpProps> for ::windows::core::IUnknown {
fn from(value: &IWMFrameInterpProps) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IWMFrameInterpProps {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IWMFrameInterpProps {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IWMFrameInterpProps_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, lframerate: i32, lscale: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, lframerate: i32, lscale: i32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bfienabled: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, icomplexity: i32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IWMInterlaceProps(pub ::windows::core::IUnknown);
impl IWMInterlaceProps {
pub unsafe fn SetProcessType(&self, iprocesstype: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(iprocesstype)).ok()
}
pub unsafe fn SetInitInverseTeleCinePattern(&self, iinitpattern: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(iinitpattern)).ok()
}
pub unsafe fn SetLastFrame(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IWMInterlaceProps {
type Vtable = IWMInterlaceProps_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7b12e5d1_bd22_48ea_bc06_98e893221c89);
}
impl ::core::convert::From<IWMInterlaceProps> for ::windows::core::IUnknown {
fn from(value: IWMInterlaceProps) -> Self {
value.0
}
}
impl ::core::convert::From<&IWMInterlaceProps> for ::windows::core::IUnknown {
fn from(value: &IWMInterlaceProps) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IWMInterlaceProps {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IWMInterlaceProps {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IWMInterlaceProps_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iprocesstype: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iinitpattern: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IWMResamplerProps(pub ::windows::core::IUnknown);
impl IWMResamplerProps {
pub unsafe fn SetHalfFilterLength(&self, lhalffilterlen: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(lhalffilterlen)).ok()
}
pub unsafe fn SetUserChannelMtx(&self, userchannelmtx: *mut f32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(userchannelmtx)).ok()
}
}
unsafe impl ::windows::core::Interface for IWMResamplerProps {
type Vtable = IWMResamplerProps_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe7e9984f_f09f_4da4_903f_6e2e0efe56b5);
}
impl ::core::convert::From<IWMResamplerProps> for ::windows::core::IUnknown {
fn from(value: IWMResamplerProps) -> Self {
value.0
}
}
impl ::core::convert::From<&IWMResamplerProps> for ::windows::core::IUnknown {
fn from(value: &IWMResamplerProps) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IWMResamplerProps {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IWMResamplerProps {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IWMResamplerProps_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, lhalffilterlen: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, userchannelmtx: *mut f32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IWMResizerProps(pub ::windows::core::IUnknown);
impl IWMResizerProps {
pub unsafe fn SetResizerQuality(&self, lquality: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(lquality)).ok()
}
pub unsafe fn SetInterlaceMode(&self, lmode: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(lmode)).ok()
}
pub unsafe fn SetClipRegion(&self, lcliporixsrc: i32, lcliporiysrc: i32, lclipwidthsrc: i32, lclipheightsrc: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(lcliporixsrc), ::core::mem::transmute(lcliporiysrc), ::core::mem::transmute(lclipwidthsrc), ::core::mem::transmute(lclipheightsrc)).ok()
}
pub unsafe fn SetFullCropRegion(&self, lcliporixsrc: i32, lcliporiysrc: i32, lclipwidthsrc: i32, lclipheightsrc: i32, lcliporixdst: i32, lcliporiydst: i32, lclipwidthdst: i32, lclipheightdst: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(
::core::mem::transmute_copy(self),
::core::mem::transmute(lcliporixsrc),
::core::mem::transmute(lcliporiysrc),
::core::mem::transmute(lclipwidthsrc),
::core::mem::transmute(lclipheightsrc),
::core::mem::transmute(lcliporixdst),
::core::mem::transmute(lcliporiydst),
::core::mem::transmute(lclipwidthdst),
::core::mem::transmute(lclipheightdst),
)
.ok()
}
pub unsafe fn GetFullCropRegion(&self, lcliporixsrc: *mut i32, lcliporiysrc: *mut i32, lclipwidthsrc: *mut i32, lclipheightsrc: *mut i32, lcliporixdst: *mut i32, lcliporiydst: *mut i32, lclipwidthdst: *mut i32, lclipheightdst: *mut i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(
::core::mem::transmute_copy(self),
::core::mem::transmute(lcliporixsrc),
::core::mem::transmute(lcliporiysrc),
::core::mem::transmute(lclipwidthsrc),
::core::mem::transmute(lclipheightsrc),
::core::mem::transmute(lcliporixdst),
::core::mem::transmute(lcliporiydst),
::core::mem::transmute(lclipwidthdst),
::core::mem::transmute(lclipheightdst),
)
.ok()
}
}
unsafe impl ::windows::core::Interface for IWMResizerProps {
type Vtable = IWMResizerProps_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x57665d4c_0414_4faa_905b_10e546f81c33);
}
impl ::core::convert::From<IWMResizerProps> for ::windows::core::IUnknown {
fn from(value: IWMResizerProps) -> Self {
value.0
}
}
impl ::core::convert::From<&IWMResizerProps> for ::windows::core::IUnknown {
fn from(value: &IWMResizerProps) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IWMResizerProps {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IWMResizerProps {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IWMResizerProps_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, lquality: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, lmode: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, lcliporixsrc: i32, lcliporiysrc: i32, lclipwidthsrc: i32, lclipheightsrc: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, lcliporixsrc: i32, lcliporiysrc: i32, lclipwidthsrc: i32, lclipheightsrc: i32, lcliporixdst: i32, lcliporiydst: i32, lclipwidthdst: i32, lclipheightdst: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, lcliporixsrc: *mut i32, lcliporiysrc: *mut i32, lclipwidthsrc: *mut i32, lclipheightsrc: *mut i32, lcliporixdst: *mut i32, lcliporiydst: *mut i32, lclipwidthdst: *mut i32, lclipheightdst: *mut i32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IWMSampleExtensionSupport(pub ::windows::core::IUnknown);
impl IWMSampleExtensionSupport {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetUseSampleExtensions<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, fuseextensions: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), fuseextensions.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IWMSampleExtensionSupport {
type Vtable = IWMSampleExtensionSupport_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9bca9884_0604_4c2a_87da_793ff4d586c3);
}
impl ::core::convert::From<IWMSampleExtensionSupport> for ::windows::core::IUnknown {
fn from(value: IWMSampleExtensionSupport) -> Self {
value.0
}
}
impl ::core::convert::From<&IWMSampleExtensionSupport> for ::windows::core::IUnknown {
fn from(value: &IWMSampleExtensionSupport) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IWMSampleExtensionSupport {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IWMSampleExtensionSupport {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IWMSampleExtensionSupport_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, fuseextensions: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IWMValidate(pub ::windows::core::IUnknown);
impl IWMValidate {
pub unsafe fn SetIdentifier<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::GUID>>(&self, guidvalidationid: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), guidvalidationid.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IWMValidate {
type Vtable = IWMValidate_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xcee3def2_3808_414d_be66_fafd472210bc);
}
impl ::core::convert::From<IWMValidate> for ::windows::core::IUnknown {
fn from(value: IWMValidate) -> Self {
value.0
}
}
impl ::core::convert::From<&IWMValidate> for ::windows::core::IUnknown {
fn from(value: &IWMValidate) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IWMValidate {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IWMValidate {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IWMValidate_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidvalidationid: ::windows::core::GUID) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IWMVideoDecoderHurryup(pub ::windows::core::IUnknown);
impl IWMVideoDecoderHurryup {
pub unsafe fn SetHurryup(&self, lhurryup: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(lhurryup)).ok()
}
pub unsafe fn GetHurryup(&self, plhurryup: *mut i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(plhurryup)).ok()
}
}
unsafe impl ::windows::core::Interface for IWMVideoDecoderHurryup {
type Vtable = IWMVideoDecoderHurryup_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x352bb3bd_2d4d_4323_9e71_dcdcfbd53ca6);
}
impl ::core::convert::From<IWMVideoDecoderHurryup> for ::windows::core::IUnknown {
fn from(value: IWMVideoDecoderHurryup) -> Self {
value.0
}
}
impl ::core::convert::From<&IWMVideoDecoderHurryup> for ::windows::core::IUnknown {
fn from(value: &IWMVideoDecoderHurryup) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IWMVideoDecoderHurryup {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IWMVideoDecoderHurryup {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IWMVideoDecoderHurryup_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, lhurryup: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, plhurryup: *mut i32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IWMVideoDecoderReconBuffer(pub ::windows::core::IUnknown);
impl IWMVideoDecoderReconBuffer {
pub unsafe fn GetReconstructedVideoFrameSize(&self, pdwsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdwsize)).ok()
}
#[cfg(feature = "Win32_Media_DxMediaObjects")]
pub unsafe fn GetReconstructedVideoFrame<'a, Param0: ::windows::core::IntoParam<'a, super::DxMediaObjects::IMediaBuffer>>(&self, pbuf: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pbuf.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Media_DxMediaObjects")]
pub unsafe fn SetReconstructedVideoFrame<'a, Param0: ::windows::core::IntoParam<'a, super::DxMediaObjects::IMediaBuffer>>(&self, pbuf: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pbuf.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IWMVideoDecoderReconBuffer {
type Vtable = IWMVideoDecoderReconBuffer_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x45bda2ac_88e2_4923_98ba_3949080711a3);
}
impl ::core::convert::From<IWMVideoDecoderReconBuffer> for ::windows::core::IUnknown {
fn from(value: IWMVideoDecoderReconBuffer) -> Self {
value.0
}
}
impl ::core::convert::From<&IWMVideoDecoderReconBuffer> for ::windows::core::IUnknown {
fn from(value: &IWMVideoDecoderReconBuffer) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IWMVideoDecoderReconBuffer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IWMVideoDecoderReconBuffer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IWMVideoDecoderReconBuffer_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Media_DxMediaObjects")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbuf: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Media_DxMediaObjects"))] usize,
#[cfg(feature = "Win32_Media_DxMediaObjects")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbuf: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Media_DxMediaObjects"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IWMVideoForceKeyFrame(pub ::windows::core::IUnknown);
impl IWMVideoForceKeyFrame {
pub unsafe fn SetKeyFrame(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IWMVideoForceKeyFrame {
type Vtable = IWMVideoForceKeyFrame_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9f8496be_5b9a_41b9_a9e8_f21cd80596c2);
}
impl ::core::convert::From<IWMVideoForceKeyFrame> for ::windows::core::IUnknown {
fn from(value: IWMVideoForceKeyFrame) -> Self {
value.0
}
}
impl ::core::convert::From<&IWMVideoForceKeyFrame> for ::windows::core::IUnknown {
fn from(value: &IWMVideoForceKeyFrame) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IWMVideoForceKeyFrame {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IWMVideoForceKeyFrame {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IWMVideoForceKeyFrame_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct KSMETHOD_OPMVIDEOOUTPUT(pub i32);
pub const KSMETHOD_OPMVIDEOOUTPUT_STARTINITIALIZATION: KSMETHOD_OPMVIDEOOUTPUT = KSMETHOD_OPMVIDEOOUTPUT(0i32);
pub const KSMETHOD_OPMVIDEOOUTPUT_FINISHINITIALIZATION: KSMETHOD_OPMVIDEOOUTPUT = KSMETHOD_OPMVIDEOOUTPUT(1i32);
pub const KSMETHOD_OPMVIDEOOUTPUT_GETINFORMATION: KSMETHOD_OPMVIDEOOUTPUT = KSMETHOD_OPMVIDEOOUTPUT(2i32);
impl ::core::convert::From<i32> for KSMETHOD_OPMVIDEOOUTPUT {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for KSMETHOD_OPMVIDEOOUTPUT {
type Abi = Self;
}
pub const KSPROPSETID_OPMVideoOutput: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x06f414bb_f43a_4fe2_a566_774b4c81f0db);
pub const LOCAL_D3DFMT_DEFINES: u32 = 1u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MACROBLOCK_DATA {
pub flags: u32,
pub motionVectorX: i16,
pub motionVectorY: i16,
pub QPDelta: i32,
}
impl MACROBLOCK_DATA {}
impl ::core::default::Default for MACROBLOCK_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MACROBLOCK_DATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MACROBLOCK_DATA").field("flags", &self.flags).field("motionVectorX", &self.motionVectorX).field("motionVectorY", &self.motionVectorY).field("QPDelta", &self.QPDelta).finish()
}
}
impl ::core::cmp::PartialEq for MACROBLOCK_DATA {
fn eq(&self, other: &Self) -> bool {
self.flags == other.flags && self.motionVectorX == other.motionVectorX && self.motionVectorY == other.motionVectorY && self.QPDelta == other.QPDelta
}
}
impl ::core::cmp::Eq for MACROBLOCK_DATA {}
unsafe impl ::windows::core::Abi for MACROBLOCK_DATA {
type Abi = Self;
}
pub const MACROBLOCK_FLAG_DIRTY: u32 = 2u32;
pub const MACROBLOCK_FLAG_HAS_MOTION_VECTOR: u32 = 16u32;
pub const MACROBLOCK_FLAG_HAS_QP: u32 = 32u32;
pub const MACROBLOCK_FLAG_MOTION: u32 = 4u32;
pub const MACROBLOCK_FLAG_SKIP: u32 = 1u32;
pub const MACROBLOCK_FLAG_VIDEO: u32 = 8u32;
pub const MAX_SUBSTREAMS: u32 = 15u32;
pub const MEDIASINK_CANNOT_MATCH_CLOCK: u32 = 2u32;
pub const MEDIASINK_CAN_PREROLL: u32 = 16u32;
pub const MEDIASINK_CLOCK_REQUIRED: u32 = 8u32;
pub const MEDIASINK_FIXED_STREAMS: u32 = 1u32;
pub const MEDIASINK_RATELESS: u32 = 4u32;
pub const MEDIASINK_REQUIRE_REFERENCE_MEDIATYPE: u32 = 32u32;
pub const MEDIASUBTYPE_AVC1: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x31435641_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_DOLBY_DDPLUS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa7fb87af_2d02_42fb_a4d4_05cd93843bdd);
pub const MEDIASUBTYPE_DOLBY_TRUEHD: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xeb27cec4_163e_4ca3_8b74_8e25f91b517e);
pub const MEDIASUBTYPE_DTS2: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00002001_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_DTS_HD: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa2e58eb7_0fa9_48bb_a40c_fa0e156d0645);
pub const MEDIASUBTYPE_DTS_HD_HRA: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa61ac364_ad0e_4744_89ff_213ce0df8804);
pub const MEDIASUBTYPE_DVM: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00002000_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_I420: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x30323449_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_M4S2: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3253344d_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_MP42: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3234504d_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_MP43: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3334504d_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_MP4S: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5334504d_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_MPEG_ADTS_AAC: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00001600_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_MPEG_HEAAC: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00001610_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_MPEG_LOAS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00001602_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_MPEG_RAW_AAC: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00001601_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_MPG4: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3447504d_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_MSAUDIO1: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000160_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_MSS1: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3153534d_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_MSS2: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3253534d_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_NOKIA_MPEG_ADTS_AAC: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00001608_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_NOKIA_MPEG_RAW_AAC: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00001609_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_NV11: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3131564e_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_None: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe436eb8e_524f_11ce_9f53_0020af0ba770);
pub const MEDIASUBTYPE_RAW_AAC1: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x000000ff_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_V216: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x36313256_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_V410: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x30313456_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_VODAFONE_MPEG_ADTS_AAC: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0000160a_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_VODAFONE_MPEG_RAW_AAC: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0000160b_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_WMASPDIF: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000164_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_WMAUDIO2: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000161_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_WMAUDIO3: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000162_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_WMAUDIO4: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000168_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_WMAUDIO_LOSSLESS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000163_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_WMV1: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x31564d57_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_WMV2: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x32564d57_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_WMV3: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x33564d57_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_WMVA: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x41564d57_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_WMVB: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x42564d57_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_WMVP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x50564d57_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_WMVR: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x52564d57_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_WVC1: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x31435657_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_WVP2: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x32505657_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_X264: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x34363258_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_Y41T: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x54313459_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_Y42T: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x54323459_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_h264: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x34363268_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_m4s2: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3273346d_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_mp42: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3234706d_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_mp43: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3334706d_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_mp4s: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7334706d_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_mpg4: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3467706d_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_v210: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x30313276_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_wmv1: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x31766d77_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_wmv2: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x32766d77_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_wmv3: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x33766d77_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_wmva: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x61766d77_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_wmvb: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x62766d77_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_wmvp: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x70766d77_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_wmvr: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x72766d77_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_wvc1: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x31637677_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_wvp2: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x32707677_0000_0010_8000_00aa00389b71);
pub const MEDIASUBTYPE_x264: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x34363278_0000_0010_8000_00aa00389b71);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS(pub u32);
pub const MF_EVENT_FLAG_NONE: MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS = MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS(0u32);
pub const MF_EVENT_FLAG_NO_WAIT: MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS = MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS(1u32);
impl ::core::convert::From<u32> for MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
pub const MEDeviceStreamCreated: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0252a1cf_3540_43b4_9164_d72eb405fa40);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF2DBuffer_LockFlags(pub i32);
pub const MF2DBuffer_LockFlags_LockTypeMask: MF2DBuffer_LockFlags = MF2DBuffer_LockFlags(3i32);
pub const MF2DBuffer_LockFlags_Read: MF2DBuffer_LockFlags = MF2DBuffer_LockFlags(1i32);
pub const MF2DBuffer_LockFlags_Write: MF2DBuffer_LockFlags = MF2DBuffer_LockFlags(2i32);
pub const MF2DBuffer_LockFlags_ReadWrite: MF2DBuffer_LockFlags = MF2DBuffer_LockFlags(3i32);
pub const MF2DBuffer_LockFlags_ForceDWORD: MF2DBuffer_LockFlags = MF2DBuffer_LockFlags(2147483647i32);
impl ::core::convert::From<i32> for MF2DBuffer_LockFlags {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF2DBuffer_LockFlags {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF3DVideoOutputType(pub i32);
pub const MF3DVideoOutputType_BaseView: MF3DVideoOutputType = MF3DVideoOutputType(0i32);
pub const MF3DVideoOutputType_Stereo: MF3DVideoOutputType = MF3DVideoOutputType(1i32);
impl ::core::convert::From<i32> for MF3DVideoOutputType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF3DVideoOutputType {
type Abi = Self;
}
pub const MFAMRNBByteStreamHandler: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xefe6208a_0a2c_49fa_8a01_3768b559b6da);
pub const MFAMRNBSinkClassFactory: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb0271158_70d2_4c5b_9f94_76f549d90fdf);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFARGB {
pub rgbBlue: u8,
pub rgbGreen: u8,
pub rgbRed: u8,
pub rgbAlpha: u8,
}
impl MFARGB {}
impl ::core::default::Default for MFARGB {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFARGB {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFARGB").field("rgbBlue", &self.rgbBlue).field("rgbGreen", &self.rgbGreen).field("rgbRed", &self.rgbRed).field("rgbAlpha", &self.rgbAlpha).finish()
}
}
impl ::core::cmp::PartialEq for MFARGB {
fn eq(&self, other: &Self) -> bool {
self.rgbBlue == other.rgbBlue && self.rgbGreen == other.rgbGreen && self.rgbRed == other.rgbRed && self.rgbAlpha == other.rgbAlpha
}
}
impl ::core::cmp::Eq for MFARGB {}
unsafe impl ::windows::core::Abi for MFARGB {
type Abi = Self;
}
pub const MFASFINDEXER_APPROX_SEEK_TIME_UNKNOWN: u64 = 18446744073709551615u64;
pub const MFASFINDEXER_NO_FIXED_INTERVAL: u32 = 4294967295u32;
pub const MFASFINDEXER_PER_ENTRY_BYTES_DYNAMIC: u32 = 65535u32;
pub const MFASFINDEXER_READ_FOR_REVERSEPLAYBACK_OUTOFDATASEGMENT: u64 = 18446744073709551615u64;
pub const MFASFINDEXER_TYPE_TIMECODE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x49815231_6bad_44fd_810a_3f60984ec7fd);
pub const MFASFMutexType_Bitrate: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x72178c2c_e45b_11d5_bc2a_00b0d0f3f4ab);
pub const MFASFMutexType_Language: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x72178c2b_e45b_11d5_bc2a_00b0d0f3f4ab);
pub const MFASFMutexType_Presentation: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x72178c2d_e45b_11d5_bc2a_00b0d0f3f4ab);
pub const MFASFMutexType_Unknown: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x72178c2e_e45b_11d5_bc2a_00b0d0f3f4ab);
pub const MFASFSPLITTER_PACKET_BOUNDARY: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfe584a05_e8d6_42e3_b176_f1211705fb6f);
pub const MFASFSampleExtension_ContentType: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd590dc20_07bc_436c_9cf7_f3bbfbf1a4dc);
pub const MFASFSampleExtension_Encryption_KeyID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x76376591_795f_4da1_86ed_9d46eca109a9);
pub const MFASFSampleExtension_Encryption_SampleID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6698b84e_0afa_4330_aeb2_1c0a98d7a44d);
pub const MFASFSampleExtension_FileName: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe165ec0e_19ed_45d7_b4a7_25cbd1e28e9b);
pub const MFASFSampleExtension_OutputCleanPoint: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf72a3c6f_6eb4_4ebc_b192_09ad9759e828);
pub const MFASFSampleExtension_PixelAspectRatio: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1b1ee554_f9ea_4bc8_821a_376b74e4c4b8);
pub const MFASFSampleExtension_SMPTE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x399595ec_8667_4e2d_8fdb_98814ce76c1e);
pub const MFASFSampleExtension_SampleDuration: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc6bd9450_867f_4907_83a3_c77921b733ad);
pub const MFASF_DEFAULT_BUFFER_WINDOW_MS: u32 = 3000u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFASF_INDEXER_FLAGS(pub i32);
pub const MFASF_INDEXER_WRITE_NEW_INDEX: MFASF_INDEXER_FLAGS = MFASF_INDEXER_FLAGS(1i32);
pub const MFASF_INDEXER_READ_FOR_REVERSEPLAYBACK: MFASF_INDEXER_FLAGS = MFASF_INDEXER_FLAGS(2i32);
pub const MFASF_INDEXER_WRITE_FOR_LIVEREAD: MFASF_INDEXER_FLAGS = MFASF_INDEXER_FLAGS(4i32);
impl ::core::convert::From<i32> for MFASF_INDEXER_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFASF_INDEXER_FLAGS {
type Abi = Self;
}
pub const MFASF_INVALID_STREAM_NUMBER: u32 = 128u32;
pub const MFASF_MAX_STREAM_NUMBER: u32 = 127u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFASF_MULTIPLEXERFLAGS(pub i32);
pub const MFASF_MULTIPLEXER_AUTOADJUST_BITRATE: MFASF_MULTIPLEXERFLAGS = MFASF_MULTIPLEXERFLAGS(1i32);
impl ::core::convert::From<i32> for MFASF_MULTIPLEXERFLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFASF_MULTIPLEXERFLAGS {
type Abi = Self;
}
pub const MFASF_PAYLOADEXTENSION_MAX_SIZE: u32 = 255u32;
pub const MFASF_PAYLOADEXTENSION_VARIABLE_SIZE: u32 = 65535u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFASF_SPLITTERFLAGS(pub i32);
pub const MFASF_SPLITTER_REVERSE: MFASF_SPLITTERFLAGS = MFASF_SPLITTERFLAGS(1i32);
pub const MFASF_SPLITTER_WMDRM: MFASF_SPLITTERFLAGS = MFASF_SPLITTERFLAGS(2i32);
impl ::core::convert::From<i32> for MFASF_SPLITTERFLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFASF_SPLITTERFLAGS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFASF_STREAMSELECTOR_FLAGS(pub i32);
pub const MFASF_STREAMSELECTOR_DISABLE_THINNING: MFASF_STREAMSELECTOR_FLAGS = MFASF_STREAMSELECTOR_FLAGS(1i32);
pub const MFASF_STREAMSELECTOR_USE_AVERAGE_BITRATE: MFASF_STREAMSELECTOR_FLAGS = MFASF_STREAMSELECTOR_FLAGS(2i32);
impl ::core::convert::From<i32> for MFASF_STREAMSELECTOR_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFASF_STREAMSELECTOR_FLAGS {
type Abi = Self;
}
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct MFASYNCRESULT(pub ::windows::core::IUnknown);
impl MFASYNCRESULT {
pub unsafe fn GetState(&self) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
pub unsafe fn GetStatus(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetStatus(&self, hrstatus: ::windows::core::HRESULT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(hrstatus)).ok()
}
pub unsafe fn GetObject(&self) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
pub unsafe fn GetStateNoAddRef(&self) -> ::core::option::Option<::windows::core::IUnknown> {
::core::mem::transmute((::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)))
}
}
unsafe impl ::windows::core::Interface for MFASYNCRESULT {
type Vtable = MFASYNCRESULT_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::zeroed();
}
impl ::core::convert::From<MFASYNCRESULT> for ::windows::core::IUnknown {
fn from(value: MFASYNCRESULT) -> Self {
value.0
}
}
impl ::core::convert::From<&MFASYNCRESULT> for ::windows::core::IUnknown {
fn from(value: &MFASYNCRESULT) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for MFASYNCRESULT {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a MFASYNCRESULT {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<MFASYNCRESULT> for IMFAsyncResult {
fn from(value: MFASYNCRESULT) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&MFASYNCRESULT> for IMFAsyncResult {
fn from(value: &MFASYNCRESULT) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAsyncResult> for MFASYNCRESULT {
fn into_param(self) -> ::windows::core::Param<'a, IMFAsyncResult> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IMFAsyncResult> for &MFASYNCRESULT {
fn into_param(self) -> ::windows::core::Param<'a, IMFAsyncResult> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct MFASYNCRESULT_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppunkstate: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hrstatus: ::windows::core::HRESULT) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppobject: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::RawPtr,
);
pub const MFASYNC_BLOCKING_CALLBACK: u32 = 4u32;
pub const MFASYNC_CALLBACK_QUEUE_ALL: u32 = 4294967295u32;
pub const MFASYNC_CALLBACK_QUEUE_IO: u32 = 3u32;
pub const MFASYNC_CALLBACK_QUEUE_LONG_FUNCTION: u32 = 7u32;
pub const MFASYNC_CALLBACK_QUEUE_MULTITHREADED: u32 = 5u32;
pub const MFASYNC_CALLBACK_QUEUE_PRIVATE_MASK: u32 = 4294901760u32;
pub const MFASYNC_CALLBACK_QUEUE_RT: u32 = 2u32;
pub const MFASYNC_CALLBACK_QUEUE_STANDARD: u32 = 1u32;
pub const MFASYNC_CALLBACK_QUEUE_TIMER: u32 = 4u32;
pub const MFASYNC_CALLBACK_QUEUE_UNDEFINED: u32 = 0u32;
pub const MFASYNC_FAST_IO_PROCESSING_CALLBACK: u32 = 1u32;
pub const MFASYNC_LOCALIZE_REMOTE_CALLBACK: u32 = 16u32;
pub const MFASYNC_REPLY_CALLBACK: u32 = 8u32;
pub const MFASYNC_SIGNAL_CALLBACK: u32 = 2u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFASYNC_WORKQUEUE_TYPE(pub i32);
pub const MF_STANDARD_WORKQUEUE: MFASYNC_WORKQUEUE_TYPE = MFASYNC_WORKQUEUE_TYPE(0i32);
pub const MF_WINDOW_WORKQUEUE: MFASYNC_WORKQUEUE_TYPE = MFASYNC_WORKQUEUE_TYPE(1i32);
pub const MF_MULTITHREADED_WORKQUEUE: MFASYNC_WORKQUEUE_TYPE = MFASYNC_WORKQUEUE_TYPE(2i32);
impl ::core::convert::From<i32> for MFASYNC_WORKQUEUE_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFASYNC_WORKQUEUE_TYPE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFAYUVSample {
pub bCrValue: u8,
pub bCbValue: u8,
pub bYValue: u8,
pub bSampleAlpha8: u8,
}
impl MFAYUVSample {}
impl ::core::default::Default for MFAYUVSample {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFAYUVSample {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFAYUVSample").field("bCrValue", &self.bCrValue).field("bCbValue", &self.bCbValue).field("bYValue", &self.bYValue).field("bSampleAlpha8", &self.bSampleAlpha8).finish()
}
}
impl ::core::cmp::PartialEq for MFAYUVSample {
fn eq(&self, other: &Self) -> bool {
self.bCrValue == other.bCrValue && self.bCbValue == other.bCbValue && self.bYValue == other.bYValue && self.bSampleAlpha8 == other.bSampleAlpha8
}
}
impl ::core::cmp::Eq for MFAYUVSample {}
unsafe impl ::windows::core::Abi for MFAYUVSample {
type Abi = Self;
}
#[inline]
pub unsafe fn MFAddPeriodicCallback<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(callback: ::core::option::Option<MFPERIODICCALLBACK>, pcontext: Param1) -> ::windows::core::Result<u32> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFAddPeriodicCallback(callback: ::windows::core::RawPtr, pcontext: ::windows::core::RawPtr, pdwkey: *mut u32) -> ::windows::core::HRESULT;
}
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFAddPeriodicCallback(::core::mem::transmute(callback), pcontext.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFAllocateSerialWorkQueue(dwworkqueue: u32) -> ::windows::core::Result<u32> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFAllocateSerialWorkQueue(dwworkqueue: u32, pdwworkqueue: *mut u32) -> ::windows::core::HRESULT;
}
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFAllocateSerialWorkQueue(::core::mem::transmute(dwworkqueue), &mut result__).from_abi::<u32>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFAllocateWorkQueue() -> ::windows::core::Result<u32> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFAllocateWorkQueue(pdwworkqueue: *mut u32) -> ::windows::core::HRESULT;
}
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFAllocateWorkQueue(&mut result__).from_abi::<u32>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFAllocateWorkQueueEx(workqueuetype: MFASYNC_WORKQUEUE_TYPE) -> ::windows::core::Result<u32> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFAllocateWorkQueueEx(workqueuetype: MFASYNC_WORKQUEUE_TYPE, pdwworkqueue: *mut u32) -> ::windows::core::HRESULT;
}
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFAllocateWorkQueueEx(::core::mem::transmute(workqueuetype), &mut result__).from_abi::<u32>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFAudioConstriction(pub i32);
pub const MFaudioConstrictionOff: MFAudioConstriction = MFAudioConstriction(0i32);
pub const MFaudioConstriction48_16: MFAudioConstriction = MFAudioConstriction(1i32);
pub const MFaudioConstriction44_16: MFAudioConstriction = MFAudioConstriction(2i32);
pub const MFaudioConstriction14_14: MFAudioConstriction = MFAudioConstriction(3i32);
pub const MFaudioConstrictionMute: MFAudioConstriction = MFAudioConstriction(4i32);
impl ::core::convert::From<i32> for MFAudioConstriction {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFAudioConstriction {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFAudioDecoderDegradationInfo {
pub eDegradationReason: MFT_AUDIO_DECODER_DEGRADATION_REASON,
pub eType: MFT_AUDIO_DECODER_DEGRADATION_TYPE,
}
impl MFAudioDecoderDegradationInfo {}
impl ::core::default::Default for MFAudioDecoderDegradationInfo {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFAudioDecoderDegradationInfo {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFAudioDecoderDegradationInfo").field("eDegradationReason", &self.eDegradationReason).field("eType", &self.eType).finish()
}
}
impl ::core::cmp::PartialEq for MFAudioDecoderDegradationInfo {
fn eq(&self, other: &Self) -> bool {
self.eDegradationReason == other.eDegradationReason && self.eType == other.eType
}
}
impl ::core::cmp::Eq for MFAudioDecoderDegradationInfo {}
unsafe impl ::windows::core::Abi for MFAudioDecoderDegradationInfo {
type Abi = Self;
}
pub const MFAudioFormat_AAC: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00001610_0000_0010_8000_00aa00389b71);
pub const MFAudioFormat_AAC_HDCP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x419bce76_8b72_400f_adeb_84b57d63484d);
pub const MFAudioFormat_ADTS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00001600_0000_0010_8000_00aa00389b71);
pub const MFAudioFormat_ADTS_HDCP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xda4963a3_14d8_4dcf_92b7_193eb84363db);
pub const MFAudioFormat_ALAC: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00006c61_0000_0010_8000_00aa00389b71);
pub const MFAudioFormat_AMR_NB: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00007361_0000_0010_8000_00aa00389b71);
pub const MFAudioFormat_AMR_WB: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00007362_0000_0010_8000_00aa00389b71);
pub const MFAudioFormat_AMR_WP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00007363_0000_0010_8000_00aa00389b71);
pub const MFAudioFormat_Base: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000000_0000_0010_8000_00aa00389b71);
pub const MFAudioFormat_Base_HDCP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3884b5bc_e277_43fd_983d_038aa8d9b605);
pub const MFAudioFormat_DRM: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000009_0000_0010_8000_00aa00389b71);
pub const MFAudioFormat_DTS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000008_0000_0010_8000_00aa00389b71);
pub const MFAudioFormat_DTS_HD: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa2e58eb7_0fa9_48bb_a40c_fa0e156d0645);
pub const MFAudioFormat_DTS_LBR: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc2fe6f0a_4e3c_4df1_9b60_50863091e4b9);
pub const MFAudioFormat_DTS_RAW: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe06d8033_db46_11cf_b4d1_00805f6cbbea);
pub const MFAudioFormat_DTS_UHD: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x87020117_ace3_42de_b73e_c656706263f8);
pub const MFAudioFormat_DTS_UHDY: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9b9cca00_91b9_4ccc_883a_8f787ac3cc86);
pub const MFAudioFormat_DTS_XLL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x45b37c1b_8c70_4e59_a7be_a1e42c81c80d);
pub const MFAudioFormat_Dolby_AC3: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe06d802c_db46_11cf_b4d1_00805f6cbbea);
pub const MFAudioFormat_Dolby_AC3_HDCP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x97663a80_8ffb_4445_a6ba_792d908f497f);
pub const MFAudioFormat_Dolby_AC3_SPDIF: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000092_0000_0010_8000_00aa00389b71);
pub const MFAudioFormat_Dolby_AC4: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0000ac40_0000_0010_8000_00aa00389b71);
pub const MFAudioFormat_Dolby_AC4_V1: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x36b7927c_3d87_4a2a_9196_a21ad9e935e6);
pub const MFAudioFormat_Dolby_AC4_V1_ES: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9d8dccc6_d156_4fb8_979c_a85be7d21dfa);
pub const MFAudioFormat_Dolby_AC4_V2: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7998b2a0_17dd_49b6_8dfa_9b278552a2ac);
pub const MFAudioFormat_Dolby_AC4_V2_ES: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7e58c9f9_b070_45f4_8ccd_a99a0417c1ac);
pub const MFAudioFormat_Dolby_DDPlus: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa7fb87af_2d02_42fb_a4d4_05cd93843bdd);
pub const MFAudioFormat_FLAC: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0000f1ac_0000_0010_8000_00aa00389b71);
pub const MFAudioFormat_Float: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000003_0000_0010_8000_00aa00389b71);
pub const MFAudioFormat_Float_SpatialObjects: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfa39cd94_bc64_4ab1_9b71_dcd09d5a7e7a);
pub const MFAudioFormat_LPCM: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe06d8032_db46_11cf_b4d1_00805f6cbbea);
pub const MFAudioFormat_MP3: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000055_0000_0010_8000_00aa00389b71);
pub const MFAudioFormat_MPEG: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000050_0000_0010_8000_00aa00389b71);
pub const MFAudioFormat_MSP1: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0000000a_0000_0010_8000_00aa00389b71);
pub const MFAudioFormat_Opus: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0000704f_0000_0010_8000_00aa00389b71);
pub const MFAudioFormat_PCM: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000001_0000_0010_8000_00aa00389b71);
pub const MFAudioFormat_PCM_HDCP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa5e7ff01_8411_4acc_a865_5f4941288d80);
pub const MFAudioFormat_Vorbis: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8d2fd10b_5841_4a6b_8905_588fec1aded9);
pub const MFAudioFormat_WMASPDIF: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000164_0000_0010_8000_00aa00389b71);
pub const MFAudioFormat_WMAudioV8: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000161_0000_0010_8000_00aa00389b71);
pub const MFAudioFormat_WMAudioV9: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000162_0000_0010_8000_00aa00389b71);
pub const MFAudioFormat_WMAudio_Lossless: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000163_0000_0010_8000_00aa00389b71);
#[inline]
pub unsafe fn MFAverageTimePerFrameToFrameRate(unaveragetimeperframe: u64, punnumerator: *mut u32, pundenominator: *mut u32) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFAverageTimePerFrameToFrameRate(unaveragetimeperframe: u64, punnumerator: *mut u32, pundenominator: *mut u32) -> ::windows::core::HRESULT;
}
MFAverageTimePerFrameToFrameRate(::core::mem::transmute(unaveragetimeperframe), ::core::mem::transmute(punnumerator), ::core::mem::transmute(pundenominator)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFBYTESTREAM_BUFFERING_PARAMS {
pub cbTotalFileSize: u64,
pub cbPlayableDataSize: u64,
pub prgBuckets: *mut MF_LEAKY_BUCKET_PAIR,
pub cBuckets: u32,
pub qwNetBufferingTime: u64,
pub qwExtraBufferingTimeDuringSeek: u64,
pub qwPlayDuration: u64,
pub dRate: f32,
}
impl MFBYTESTREAM_BUFFERING_PARAMS {}
impl ::core::default::Default for MFBYTESTREAM_BUFFERING_PARAMS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFBYTESTREAM_BUFFERING_PARAMS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFBYTESTREAM_BUFFERING_PARAMS")
.field("cbTotalFileSize", &self.cbTotalFileSize)
.field("cbPlayableDataSize", &self.cbPlayableDataSize)
.field("prgBuckets", &self.prgBuckets)
.field("cBuckets", &self.cBuckets)
.field("qwNetBufferingTime", &self.qwNetBufferingTime)
.field("qwExtraBufferingTimeDuringSeek", &self.qwExtraBufferingTimeDuringSeek)
.field("qwPlayDuration", &self.qwPlayDuration)
.field("dRate", &self.dRate)
.finish()
}
}
impl ::core::cmp::PartialEq for MFBYTESTREAM_BUFFERING_PARAMS {
fn eq(&self, other: &Self) -> bool {
self.cbTotalFileSize == other.cbTotalFileSize && self.cbPlayableDataSize == other.cbPlayableDataSize && self.prgBuckets == other.prgBuckets && self.cBuckets == other.cBuckets && self.qwNetBufferingTime == other.qwNetBufferingTime && self.qwExtraBufferingTimeDuringSeek == other.qwExtraBufferingTimeDuringSeek && self.qwPlayDuration == other.qwPlayDuration && self.dRate == other.dRate
}
}
impl ::core::cmp::Eq for MFBYTESTREAM_BUFFERING_PARAMS {}
unsafe impl ::windows::core::Abi for MFBYTESTREAM_BUFFERING_PARAMS {
type Abi = Self;
}
pub const MFBYTESTREAM_DOES_NOT_USE_NETWORK: u32 = 2048u32;
pub const MFBYTESTREAM_HAS_SLOW_SEEK: u32 = 256u32;
pub const MFBYTESTREAM_IS_DIRECTORY: u32 = 128u32;
pub const MFBYTESTREAM_IS_PARTIALLY_DOWNLOADED: u32 = 512u32;
pub const MFBYTESTREAM_IS_READABLE: u32 = 1u32;
pub const MFBYTESTREAM_IS_REMOTE: u32 = 8u32;
pub const MFBYTESTREAM_IS_SEEKABLE: u32 = 4u32;
pub const MFBYTESTREAM_IS_WRITABLE: u32 = 2u32;
pub const MFBYTESTREAM_SEEK_FLAG_CANCEL_PENDING_IO: u32 = 1u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFBYTESTREAM_SEEK_ORIGIN(pub i32);
pub const msoBegin: MFBYTESTREAM_SEEK_ORIGIN = MFBYTESTREAM_SEEK_ORIGIN(0i32);
pub const msoCurrent: MFBYTESTREAM_SEEK_ORIGIN = MFBYTESTREAM_SEEK_ORIGIN(1i32);
impl ::core::convert::From<i32> for MFBYTESTREAM_SEEK_ORIGIN {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFBYTESTREAM_SEEK_ORIGIN {
type Abi = Self;
}
pub const MFBYTESTREAM_SHARE_WRITE: u32 = 1024u32;
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFBeginCreateFile<'a, Param3: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param5: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(accessmode: MF_FILE_ACCESSMODE, openmode: MF_FILE_OPENMODE, fflags: MF_FILE_FLAGS, pwszfilepath: Param3, pcallback: Param4, pstate: Param5) -> ::windows::core::Result<::windows::core::IUnknown> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFBeginCreateFile(accessmode: MF_FILE_ACCESSMODE, openmode: MF_FILE_OPENMODE, fflags: MF_FILE_FLAGS, pwszfilepath: super::super::Foundation::PWSTR, pcallback: ::windows::core::RawPtr, pstate: ::windows::core::RawPtr, ppcancelcookie: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFBeginCreateFile(::core::mem::transmute(accessmode), ::core::mem::transmute(openmode), ::core::mem::transmute(fflags), pwszfilepath.into_param().abi(), pcallback.into_param().abi(), pstate.into_param().abi(), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFBeginRegisterWorkQueueWithMMCSS<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param4: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(dwworkqueueid: u32, wszclass: Param1, dwtaskid: u32, pdonecallback: Param3, pdonestate: Param4) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFBeginRegisterWorkQueueWithMMCSS(dwworkqueueid: u32, wszclass: super::super::Foundation::PWSTR, dwtaskid: u32, pdonecallback: ::windows::core::RawPtr, pdonestate: ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
MFBeginRegisterWorkQueueWithMMCSS(::core::mem::transmute(dwworkqueueid), wszclass.into_param().abi(), ::core::mem::transmute(dwtaskid), pdonecallback.into_param().abi(), pdonestate.into_param().abi()).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFBeginRegisterWorkQueueWithMMCSSEx<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param5: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(dwworkqueueid: u32, wszclass: Param1, dwtaskid: u32, lpriority: i32, pdonecallback: Param4, pdonestate: Param5) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFBeginRegisterWorkQueueWithMMCSSEx(dwworkqueueid: u32, wszclass: super::super::Foundation::PWSTR, dwtaskid: u32, lpriority: i32, pdonecallback: ::windows::core::RawPtr, pdonestate: ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
MFBeginRegisterWorkQueueWithMMCSSEx(::core::mem::transmute(dwworkqueueid), wszclass.into_param().abi(), ::core::mem::transmute(dwtaskid), ::core::mem::transmute(lpriority), pdonecallback.into_param().abi(), pdonestate.into_param().abi()).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFBeginUnregisterWorkQueueWithMMCSS<'a, Param1: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param2: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(dwworkqueueid: u32, pdonecallback: Param1, pdonestate: Param2) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFBeginUnregisterWorkQueueWithMMCSS(dwworkqueueid: u32, pdonecallback: ::windows::core::RawPtr, pdonestate: ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
MFBeginUnregisterWorkQueueWithMMCSS(::core::mem::transmute(dwworkqueueid), pdonecallback.into_param().abi(), pdonestate.into_param().abi()).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
pub const MFCAPTURE_METADATA_SCANLINE_VERTICAL: u32 = 4u32;
pub const MFCAPTURE_METADATA_SCAN_BOTTOM_TOP: u32 = 2u32;
pub const MFCAPTURE_METADATA_SCAN_RIGHT_LEFT: u32 = 1u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFCLOCK_CHARACTERISTICS_FLAGS(pub i32);
pub const MFCLOCK_CHARACTERISTICS_FLAG_FREQUENCY_10MHZ: MFCLOCK_CHARACTERISTICS_FLAGS = MFCLOCK_CHARACTERISTICS_FLAGS(2i32);
pub const MFCLOCK_CHARACTERISTICS_FLAG_ALWAYS_RUNNING: MFCLOCK_CHARACTERISTICS_FLAGS = MFCLOCK_CHARACTERISTICS_FLAGS(4i32);
pub const MFCLOCK_CHARACTERISTICS_FLAG_IS_SYSTEM_CLOCK: MFCLOCK_CHARACTERISTICS_FLAGS = MFCLOCK_CHARACTERISTICS_FLAGS(8i32);
impl ::core::convert::From<i32> for MFCLOCK_CHARACTERISTICS_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFCLOCK_CHARACTERISTICS_FLAGS {
type Abi = Self;
}
pub const MFCLOCK_FREQUENCY_HNS: u32 = 10000000u32;
pub const MFCLOCK_JITTER_DPC: u32 = 4000u32;
pub const MFCLOCK_JITTER_ISR: u32 = 1000u32;
pub const MFCLOCK_JITTER_PASSIVE: u32 = 10000u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFCLOCK_PROPERTIES {
pub qwCorrelationRate: u64,
pub guidClockId: ::windows::core::GUID,
pub dwClockFlags: u32,
pub qwClockFrequency: u64,
pub dwClockTolerance: u32,
pub dwClockJitter: u32,
}
impl MFCLOCK_PROPERTIES {}
impl ::core::default::Default for MFCLOCK_PROPERTIES {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFCLOCK_PROPERTIES {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFCLOCK_PROPERTIES")
.field("qwCorrelationRate", &self.qwCorrelationRate)
.field("guidClockId", &self.guidClockId)
.field("dwClockFlags", &self.dwClockFlags)
.field("qwClockFrequency", &self.qwClockFrequency)
.field("dwClockTolerance", &self.dwClockTolerance)
.field("dwClockJitter", &self.dwClockJitter)
.finish()
}
}
impl ::core::cmp::PartialEq for MFCLOCK_PROPERTIES {
fn eq(&self, other: &Self) -> bool {
self.qwCorrelationRate == other.qwCorrelationRate && self.guidClockId == other.guidClockId && self.dwClockFlags == other.dwClockFlags && self.qwClockFrequency == other.qwClockFrequency && self.dwClockTolerance == other.dwClockTolerance && self.dwClockJitter == other.dwClockJitter
}
}
impl ::core::cmp::Eq for MFCLOCK_PROPERTIES {}
unsafe impl ::windows::core::Abi for MFCLOCK_PROPERTIES {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFCLOCK_RELATIONAL_FLAGS(pub i32);
pub const MFCLOCK_RELATIONAL_FLAG_JITTER_NEVER_AHEAD: MFCLOCK_RELATIONAL_FLAGS = MFCLOCK_RELATIONAL_FLAGS(1i32);
impl ::core::convert::From<i32> for MFCLOCK_RELATIONAL_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFCLOCK_RELATIONAL_FLAGS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFCLOCK_STATE(pub i32);
pub const MFCLOCK_STATE_INVALID: MFCLOCK_STATE = MFCLOCK_STATE(0i32);
pub const MFCLOCK_STATE_RUNNING: MFCLOCK_STATE = MFCLOCK_STATE(1i32);
pub const MFCLOCK_STATE_STOPPED: MFCLOCK_STATE = MFCLOCK_STATE(2i32);
pub const MFCLOCK_STATE_PAUSED: MFCLOCK_STATE = MFCLOCK_STATE(3i32);
impl ::core::convert::From<i32> for MFCLOCK_STATE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFCLOCK_STATE {
type Abi = Self;
}
pub const MFCLOCK_TOLERANCE_UNKNOWN: u32 = 50000u32;
pub const MFCONNECTOR_AGP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xac3aef60_ce43_11d9_92db_000bdb28ff98);
pub const MFCONNECTOR_COMPONENT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x57cd596b_ce47_11d9_92db_000bdb28ff98);
pub const MFCONNECTOR_COMPOSITE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x57cd596a_ce47_11d9_92db_000bdb28ff98);
pub const MFCONNECTOR_DISPLAYPORT_EMBEDDED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x57cd5973_ce47_11d9_92db_000bdb28ff98);
pub const MFCONNECTOR_DISPLAYPORT_EXTERNAL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x57cd5972_ce47_11d9_92db_000bdb28ff98);
pub const MFCONNECTOR_DVI: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x57cd596c_ce47_11d9_92db_000bdb28ff98);
pub const MFCONNECTOR_D_JPN: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x57cd5970_ce47_11d9_92db_000bdb28ff98);
pub const MFCONNECTOR_HDMI: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x57cd596d_ce47_11d9_92db_000bdb28ff98);
pub const MFCONNECTOR_LVDS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x57cd596e_ce47_11d9_92db_000bdb28ff98);
pub const MFCONNECTOR_MIRACAST: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x57cd5977_ce47_11d9_92db_000bdb28ff98);
pub const MFCONNECTOR_PCI: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xac3aef5d_ce43_11d9_92db_000bdb28ff98);
pub const MFCONNECTOR_PCIX: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xac3aef5e_ce43_11d9_92db_000bdb28ff98);
pub const MFCONNECTOR_PCI_Express: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xac3aef5f_ce43_11d9_92db_000bdb28ff98);
pub const MFCONNECTOR_SDI: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x57cd5971_ce47_11d9_92db_000bdb28ff98);
pub const MFCONNECTOR_SPDIF: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0b94a712_ad3e_4cee_83ce_ce32e3db6522);
pub const MFCONNECTOR_SVIDEO: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x57cd5969_ce47_11d9_92db_000bdb28ff98);
pub const MFCONNECTOR_TRANSPORT_AGNOSTIC_DIGITAL_MODE_A: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x57cd5978_ce47_11d9_92db_000bdb28ff98);
pub const MFCONNECTOR_TRANSPORT_AGNOSTIC_DIGITAL_MODE_B: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x57cd5979_ce47_11d9_92db_000bdb28ff98);
pub const MFCONNECTOR_UDI_EMBEDDED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x57cd5975_ce47_11d9_92db_000bdb28ff98);
pub const MFCONNECTOR_UDI_EXTERNAL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x57cd5974_ce47_11d9_92db_000bdb28ff98);
pub const MFCONNECTOR_UNKNOWN: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xac3aef5c_ce43_11d9_92db_000bdb28ff98);
pub const MFCONNECTOR_VGA: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x57cd5968_ce47_11d9_92db_000bdb28ff98);
pub const MFCONTENTPROTECTIONDEVICE_FUNCTIONID_START: u32 = 67108864u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFCONTENTPROTECTIONDEVICE_INPUT_DATA {
pub HWProtectionFunctionID: u32,
pub PrivateDataByteCount: u32,
pub HWProtectionDataByteCount: u32,
pub Reserved: u32,
pub InputData: [u8; 4],
}
impl MFCONTENTPROTECTIONDEVICE_INPUT_DATA {}
impl ::core::default::Default for MFCONTENTPROTECTIONDEVICE_INPUT_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFCONTENTPROTECTIONDEVICE_INPUT_DATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFCONTENTPROTECTIONDEVICE_INPUT_DATA")
.field("HWProtectionFunctionID", &self.HWProtectionFunctionID)
.field("PrivateDataByteCount", &self.PrivateDataByteCount)
.field("HWProtectionDataByteCount", &self.HWProtectionDataByteCount)
.field("Reserved", &self.Reserved)
.field("InputData", &self.InputData)
.finish()
}
}
impl ::core::cmp::PartialEq for MFCONTENTPROTECTIONDEVICE_INPUT_DATA {
fn eq(&self, other: &Self) -> bool {
self.HWProtectionFunctionID == other.HWProtectionFunctionID && self.PrivateDataByteCount == other.PrivateDataByteCount && self.HWProtectionDataByteCount == other.HWProtectionDataByteCount && self.Reserved == other.Reserved && self.InputData == other.InputData
}
}
impl ::core::cmp::Eq for MFCONTENTPROTECTIONDEVICE_INPUT_DATA {}
unsafe impl ::windows::core::Abi for MFCONTENTPROTECTIONDEVICE_INPUT_DATA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFCONTENTPROTECTIONDEVICE_OUTPUT_DATA {
pub PrivateDataByteCount: u32,
pub MaxHWProtectionDataByteCount: u32,
pub HWProtectionDataByteCount: u32,
pub Status: ::windows::core::HRESULT,
pub TransportTimeInHundredsOfNanoseconds: i64,
pub ExecutionTimeInHundredsOfNanoseconds: i64,
pub OutputData: [u8; 4],
}
impl MFCONTENTPROTECTIONDEVICE_OUTPUT_DATA {}
impl ::core::default::Default for MFCONTENTPROTECTIONDEVICE_OUTPUT_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFCONTENTPROTECTIONDEVICE_OUTPUT_DATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFCONTENTPROTECTIONDEVICE_OUTPUT_DATA")
.field("PrivateDataByteCount", &self.PrivateDataByteCount)
.field("MaxHWProtectionDataByteCount", &self.MaxHWProtectionDataByteCount)
.field("HWProtectionDataByteCount", &self.HWProtectionDataByteCount)
.field("Status", &self.Status)
.field("TransportTimeInHundredsOfNanoseconds", &self.TransportTimeInHundredsOfNanoseconds)
.field("ExecutionTimeInHundredsOfNanoseconds", &self.ExecutionTimeInHundredsOfNanoseconds)
.field("OutputData", &self.OutputData)
.finish()
}
}
impl ::core::cmp::PartialEq for MFCONTENTPROTECTIONDEVICE_OUTPUT_DATA {
fn eq(&self, other: &Self) -> bool {
self.PrivateDataByteCount == other.PrivateDataByteCount && self.MaxHWProtectionDataByteCount == other.MaxHWProtectionDataByteCount && self.HWProtectionDataByteCount == other.HWProtectionDataByteCount && self.Status == other.Status && self.TransportTimeInHundredsOfNanoseconds == other.TransportTimeInHundredsOfNanoseconds && self.ExecutionTimeInHundredsOfNanoseconds == other.ExecutionTimeInHundredsOfNanoseconds && self.OutputData == other.OutputData
}
}
impl ::core::cmp::Eq for MFCONTENTPROTECTIONDEVICE_OUTPUT_DATA {}
unsafe impl ::windows::core::Abi for MFCONTENTPROTECTIONDEVICE_OUTPUT_DATA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFCONTENTPROTECTIONDEVICE_REALTIMECLIENT_DATA {
pub TaskIndex: u32,
pub ClassName: [u16; 260],
pub BasePriority: i32,
}
impl MFCONTENTPROTECTIONDEVICE_REALTIMECLIENT_DATA {}
impl ::core::default::Default for MFCONTENTPROTECTIONDEVICE_REALTIMECLIENT_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFCONTENTPROTECTIONDEVICE_REALTIMECLIENT_DATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFCONTENTPROTECTIONDEVICE_REALTIMECLIENT_DATA").field("TaskIndex", &self.TaskIndex).field("ClassName", &self.ClassName).field("BasePriority", &self.BasePriority).finish()
}
}
impl ::core::cmp::PartialEq for MFCONTENTPROTECTIONDEVICE_REALTIMECLIENT_DATA {
fn eq(&self, other: &Self) -> bool {
self.TaskIndex == other.TaskIndex && self.ClassName == other.ClassName && self.BasePriority == other.BasePriority
}
}
impl ::core::cmp::Eq for MFCONTENTPROTECTIONDEVICE_REALTIMECLIENT_DATA {}
unsafe impl ::windows::core::Abi for MFCONTENTPROTECTIONDEVICE_REALTIMECLIENT_DATA {
type Abi = Self;
}
pub const MFCONTENTPROTECTIONDEVICE_REALTIMECLIENT_DATA_FUNCTIONID: u32 = 67108864u32;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
#[inline]
pub unsafe fn MFCalculateBitmapImageSize(pbmih: *const super::super::Graphics::Gdi::BITMAPINFOHEADER, cbbufsize: u32, pcbimagesize: *mut u32, pbknown: *mut super::super::Foundation::BOOL) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCalculateBitmapImageSize(pbmih: *const super::super::Graphics::Gdi::BITMAPINFOHEADER, cbbufsize: u32, pcbimagesize: *mut u32, pbknown: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT;
}
MFCalculateBitmapImageSize(::core::mem::transmute(pbmih), ::core::mem::transmute(cbbufsize), ::core::mem::transmute(pcbimagesize), ::core::mem::transmute(pbknown)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCalculateImageSize(guidsubtype: *const ::windows::core::GUID, unwidth: u32, unheight: u32) -> ::windows::core::Result<u32> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCalculateImageSize(guidsubtype: *const ::windows::core::GUID, unwidth: u32, unheight: u32, pcbimagesize: *mut u32) -> ::windows::core::HRESULT;
}
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCalculateImageSize(::core::mem::transmute(guidsubtype), ::core::mem::transmute(unwidth), ::core::mem::transmute(unheight), &mut result__).from_abi::<u32>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFCameraExtrinsic_CalibratedTransform {
pub CalibrationId: ::windows::core::GUID,
pub Position: MF_FLOAT3,
pub Orientation: MF_QUATERNION,
}
impl MFCameraExtrinsic_CalibratedTransform {}
impl ::core::default::Default for MFCameraExtrinsic_CalibratedTransform {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFCameraExtrinsic_CalibratedTransform {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFCameraExtrinsic_CalibratedTransform").field("CalibrationId", &self.CalibrationId).field("Position", &self.Position).field("Orientation", &self.Orientation).finish()
}
}
impl ::core::cmp::PartialEq for MFCameraExtrinsic_CalibratedTransform {
fn eq(&self, other: &Self) -> bool {
self.CalibrationId == other.CalibrationId && self.Position == other.Position && self.Orientation == other.Orientation
}
}
impl ::core::cmp::Eq for MFCameraExtrinsic_CalibratedTransform {}
unsafe impl ::windows::core::Abi for MFCameraExtrinsic_CalibratedTransform {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFCameraExtrinsics {
pub TransformCount: u32,
pub CalibratedTransforms: [MFCameraExtrinsic_CalibratedTransform; 1],
}
impl MFCameraExtrinsics {}
impl ::core::default::Default for MFCameraExtrinsics {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFCameraExtrinsics {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFCameraExtrinsics").field("TransformCount", &self.TransformCount).field("CalibratedTransforms", &self.CalibratedTransforms).finish()
}
}
impl ::core::cmp::PartialEq for MFCameraExtrinsics {
fn eq(&self, other: &Self) -> bool {
self.TransformCount == other.TransformCount && self.CalibratedTransforms == other.CalibratedTransforms
}
}
impl ::core::cmp::Eq for MFCameraExtrinsics {}
unsafe impl ::windows::core::Abi for MFCameraExtrinsics {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFCameraIntrinsic_CameraModel {
pub FocalLength_x: f32,
pub FocalLength_y: f32,
pub PrincipalPoint_x: f32,
pub PrincipalPoint_y: f32,
}
impl MFCameraIntrinsic_CameraModel {}
impl ::core::default::Default for MFCameraIntrinsic_CameraModel {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFCameraIntrinsic_CameraModel {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFCameraIntrinsic_CameraModel").field("FocalLength_x", &self.FocalLength_x).field("FocalLength_y", &self.FocalLength_y).field("PrincipalPoint_x", &self.PrincipalPoint_x).field("PrincipalPoint_y", &self.PrincipalPoint_y).finish()
}
}
impl ::core::cmp::PartialEq for MFCameraIntrinsic_CameraModel {
fn eq(&self, other: &Self) -> bool {
self.FocalLength_x == other.FocalLength_x && self.FocalLength_y == other.FocalLength_y && self.PrincipalPoint_x == other.PrincipalPoint_x && self.PrincipalPoint_y == other.PrincipalPoint_y
}
}
impl ::core::cmp::Eq for MFCameraIntrinsic_CameraModel {}
unsafe impl ::windows::core::Abi for MFCameraIntrinsic_CameraModel {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFCameraIntrinsic_DistortionModel {
pub Radial_k1: f32,
pub Radial_k2: f32,
pub Radial_k3: f32,
pub Tangential_p1: f32,
pub Tangential_p2: f32,
}
impl MFCameraIntrinsic_DistortionModel {}
impl ::core::default::Default for MFCameraIntrinsic_DistortionModel {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFCameraIntrinsic_DistortionModel {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFCameraIntrinsic_DistortionModel").field("Radial_k1", &self.Radial_k1).field("Radial_k2", &self.Radial_k2).field("Radial_k3", &self.Radial_k3).field("Tangential_p1", &self.Tangential_p1).field("Tangential_p2", &self.Tangential_p2).finish()
}
}
impl ::core::cmp::PartialEq for MFCameraIntrinsic_DistortionModel {
fn eq(&self, other: &Self) -> bool {
self.Radial_k1 == other.Radial_k1 && self.Radial_k2 == other.Radial_k2 && self.Radial_k3 == other.Radial_k3 && self.Tangential_p1 == other.Tangential_p1 && self.Tangential_p2 == other.Tangential_p2
}
}
impl ::core::cmp::Eq for MFCameraIntrinsic_DistortionModel {}
unsafe impl ::windows::core::Abi for MFCameraIntrinsic_DistortionModel {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFCameraIntrinsic_DistortionModel6KT {
pub Radial_k1: f32,
pub Radial_k2: f32,
pub Radial_k3: f32,
pub Radial_k4: f32,
pub Radial_k5: f32,
pub Radial_k6: f32,
pub Tangential_p1: f32,
pub Tangential_p2: f32,
}
impl MFCameraIntrinsic_DistortionModel6KT {}
impl ::core::default::Default for MFCameraIntrinsic_DistortionModel6KT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFCameraIntrinsic_DistortionModel6KT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFCameraIntrinsic_DistortionModel6KT")
.field("Radial_k1", &self.Radial_k1)
.field("Radial_k2", &self.Radial_k2)
.field("Radial_k3", &self.Radial_k3)
.field("Radial_k4", &self.Radial_k4)
.field("Radial_k5", &self.Radial_k5)
.field("Radial_k6", &self.Radial_k6)
.field("Tangential_p1", &self.Tangential_p1)
.field("Tangential_p2", &self.Tangential_p2)
.finish()
}
}
impl ::core::cmp::PartialEq for MFCameraIntrinsic_DistortionModel6KT {
fn eq(&self, other: &Self) -> bool {
self.Radial_k1 == other.Radial_k1 && self.Radial_k2 == other.Radial_k2 && self.Radial_k3 == other.Radial_k3 && self.Radial_k4 == other.Radial_k4 && self.Radial_k5 == other.Radial_k5 && self.Radial_k6 == other.Radial_k6 && self.Tangential_p1 == other.Tangential_p1 && self.Tangential_p2 == other.Tangential_p2
}
}
impl ::core::cmp::Eq for MFCameraIntrinsic_DistortionModel6KT {}
unsafe impl ::windows::core::Abi for MFCameraIntrinsic_DistortionModel6KT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFCameraIntrinsic_DistortionModelArcTan {
pub Radial_k0: f32,
pub DistortionCenter_x: f32,
pub DistortionCenter_y: f32,
pub Tangential_x: f32,
pub Tangential_y: f32,
}
impl MFCameraIntrinsic_DistortionModelArcTan {}
impl ::core::default::Default for MFCameraIntrinsic_DistortionModelArcTan {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFCameraIntrinsic_DistortionModelArcTan {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFCameraIntrinsic_DistortionModelArcTan").field("Radial_k0", &self.Radial_k0).field("DistortionCenter_x", &self.DistortionCenter_x).field("DistortionCenter_y", &self.DistortionCenter_y).field("Tangential_x", &self.Tangential_x).field("Tangential_y", &self.Tangential_y).finish()
}
}
impl ::core::cmp::PartialEq for MFCameraIntrinsic_DistortionModelArcTan {
fn eq(&self, other: &Self) -> bool {
self.Radial_k0 == other.Radial_k0 && self.DistortionCenter_x == other.DistortionCenter_x && self.DistortionCenter_y == other.DistortionCenter_y && self.Tangential_x == other.Tangential_x && self.Tangential_y == other.Tangential_y
}
}
impl ::core::cmp::Eq for MFCameraIntrinsic_DistortionModelArcTan {}
unsafe impl ::windows::core::Abi for MFCameraIntrinsic_DistortionModelArcTan {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFCameraIntrinsic_DistortionModelType(pub i32);
pub const MFCameraIntrinsic_DistortionModelType_6KT: MFCameraIntrinsic_DistortionModelType = MFCameraIntrinsic_DistortionModelType(0i32);
pub const MFCameraIntrinsic_DistortionModelType_ArcTan: MFCameraIntrinsic_DistortionModelType = MFCameraIntrinsic_DistortionModelType(1i32);
impl ::core::convert::From<i32> for MFCameraIntrinsic_DistortionModelType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFCameraIntrinsic_DistortionModelType {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFCameraIntrinsic_PinholeCameraModel {
pub FocalLength: MF_FLOAT2,
pub PrincipalPoint: MF_FLOAT2,
}
impl MFCameraIntrinsic_PinholeCameraModel {}
impl ::core::default::Default for MFCameraIntrinsic_PinholeCameraModel {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFCameraIntrinsic_PinholeCameraModel {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFCameraIntrinsic_PinholeCameraModel").field("FocalLength", &self.FocalLength).field("PrincipalPoint", &self.PrincipalPoint).finish()
}
}
impl ::core::cmp::PartialEq for MFCameraIntrinsic_PinholeCameraModel {
fn eq(&self, other: &Self) -> bool {
self.FocalLength == other.FocalLength && self.PrincipalPoint == other.PrincipalPoint
}
}
impl ::core::cmp::Eq for MFCameraIntrinsic_PinholeCameraModel {}
unsafe impl ::windows::core::Abi for MFCameraIntrinsic_PinholeCameraModel {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFCameraOcclusionState(pub i32);
pub const MFCameraOcclusionState_Open: MFCameraOcclusionState = MFCameraOcclusionState(0i32);
pub const MFCameraOcclusionState_OccludedByLid: MFCameraOcclusionState = MFCameraOcclusionState(1i32);
pub const MFCameraOcclusionState_OccludedByCameraHardware: MFCameraOcclusionState = MFCameraOcclusionState(2i32);
impl ::core::convert::From<i32> for MFCameraOcclusionState {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFCameraOcclusionState {
type Abi = Self;
}
#[inline]
pub unsafe fn MFCancelCreateFile<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(pcancelcookie: Param0) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCancelCreateFile(pcancelcookie: ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
MFCancelCreateFile(pcancelcookie.into_param().abi()).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCancelWorkItem(key: u64) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCancelWorkItem(key: u64) -> ::windows::core::HRESULT;
}
MFCancelWorkItem(::core::mem::transmute(key)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFCombineSamples<'a, Param0: ::windows::core::IntoParam<'a, IMFSample>, Param1: ::windows::core::IntoParam<'a, IMFSample>>(psample: Param0, psampletoadd: Param1, dwmaxmergeddurationinms: u32) -> ::windows::core::Result<super::super::Foundation::BOOL> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCombineSamples(psample: ::windows::core::RawPtr, psampletoadd: ::windows::core::RawPtr, dwmaxmergeddurationinms: u32, pmerged: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT;
}
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCombineSamples(psample.into_param().abi(), psampletoadd.into_param().abi(), ::core::mem::transmute(dwmaxmergeddurationinms), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFCompareFullToPartialMediaType<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaType>, Param1: ::windows::core::IntoParam<'a, IMFMediaType>>(pmftypefull: Param0, pmftypepartial: Param1) -> super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCompareFullToPartialMediaType(pmftypefull: ::windows::core::RawPtr, pmftypepartial: ::windows::core::RawPtr) -> super::super::Foundation::BOOL;
}
::core::mem::transmute(MFCompareFullToPartialMediaType(pmftypefull.into_param().abi(), pmftypepartial.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFConvertColorInfoFromDXVA(ptoformat: *mut MFVIDEOFORMAT, dwfromdxva: u32) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFConvertColorInfoFromDXVA(ptoformat: *mut MFVIDEOFORMAT, dwfromdxva: u32) -> ::windows::core::HRESULT;
}
MFConvertColorInfoFromDXVA(::core::mem::transmute(ptoformat), ::core::mem::transmute(dwfromdxva)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFConvertColorInfoToDXVA(pdwtodxva: *mut u32, pfromformat: *const MFVIDEOFORMAT) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFConvertColorInfoToDXVA(pdwtodxva: *mut u32, pfromformat: *const MFVIDEOFORMAT) -> ::windows::core::HRESULT;
}
MFConvertColorInfoToDXVA(::core::mem::transmute(pdwtodxva), ::core::mem::transmute(pfromformat)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFConvertFromFP16Array(pdest: *mut f32, psrc: *const u16, dwcount: u32) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFConvertFromFP16Array(pdest: *mut f32, psrc: *const u16, dwcount: u32) -> ::windows::core::HRESULT;
}
MFConvertFromFP16Array(::core::mem::transmute(pdest), ::core::mem::transmute(psrc), ::core::mem::transmute(dwcount)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFConvertToFP16Array(pdest: *mut u16, psrc: *const f32, dwcount: u32) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFConvertToFP16Array(pdest: *mut u16, psrc: *const f32, dwcount: u32) -> ::windows::core::HRESULT;
}
MFConvertToFP16Array(::core::mem::transmute(pdest), ::core::mem::transmute(psrc), ::core::mem::transmute(dwcount)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCopyImage(pdest: *mut u8, ldeststride: i32, psrc: *const u8, lsrcstride: i32, dwwidthinbytes: u32, dwlines: u32) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCopyImage(pdest: *mut u8, ldeststride: i32, psrc: *const u8, lsrcstride: i32, dwwidthinbytes: u32, dwlines: u32) -> ::windows::core::HRESULT;
}
MFCopyImage(::core::mem::transmute(pdest), ::core::mem::transmute(ldeststride), ::core::mem::transmute(psrc), ::core::mem::transmute(lsrcstride), ::core::mem::transmute(dwwidthinbytes), ::core::mem::transmute(dwlines)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFCreate2DMediaBuffer<'a, Param3: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(dwwidth: u32, dwheight: u32, dwfourcc: u32, fbottomup: Param3) -> ::windows::core::Result<IMFMediaBuffer> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreate2DMediaBuffer(dwwidth: u32, dwheight: u32, dwfourcc: u32, fbottomup: super::super::Foundation::BOOL, ppbuffer: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaBuffer as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreate2DMediaBuffer(::core::mem::transmute(dwwidth), ::core::mem::transmute(dwheight), ::core::mem::transmute(dwfourcc), fbottomup.into_param().abi(), &mut result__).from_abi::<IMFMediaBuffer>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreate3GPMediaSink<'a, Param0: ::windows::core::IntoParam<'a, IMFByteStream>, Param1: ::windows::core::IntoParam<'a, IMFMediaType>, Param2: ::windows::core::IntoParam<'a, IMFMediaType>>(pibytestream: Param0, pvideomediatype: Param1, paudiomediatype: Param2) -> ::windows::core::Result<IMFMediaSink> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreate3GPMediaSink(pibytestream: ::windows::core::RawPtr, pvideomediatype: ::windows::core::RawPtr, paudiomediatype: ::windows::core::RawPtr, ppimediasink: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaSink as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreate3GPMediaSink(pibytestream.into_param().abi(), pvideomediatype.into_param().abi(), paudiomediatype.into_param().abi(), &mut result__).from_abi::<IMFMediaSink>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateAC3MediaSink<'a, Param0: ::windows::core::IntoParam<'a, IMFByteStream>, Param1: ::windows::core::IntoParam<'a, IMFMediaType>>(ptargetbytestream: Param0, paudiomediatype: Param1) -> ::windows::core::Result<IMFMediaSink> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateAC3MediaSink(ptargetbytestream: ::windows::core::RawPtr, paudiomediatype: ::windows::core::RawPtr, ppmediasink: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaSink as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateAC3MediaSink(ptargetbytestream.into_param().abi(), paudiomediatype.into_param().abi(), &mut result__).from_abi::<IMFMediaSink>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateADTSMediaSink<'a, Param0: ::windows::core::IntoParam<'a, IMFByteStream>, Param1: ::windows::core::IntoParam<'a, IMFMediaType>>(ptargetbytestream: Param0, paudiomediatype: Param1) -> ::windows::core::Result<IMFMediaSink> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateADTSMediaSink(ptargetbytestream: ::windows::core::RawPtr, paudiomediatype: ::windows::core::RawPtr, ppmediasink: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaSink as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateADTSMediaSink(ptargetbytestream.into_param().abi(), paudiomediatype.into_param().abi(), &mut result__).from_abi::<IMFMediaSink>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Media_DirectShow"))]
#[inline]
pub unsafe fn MFCreateAMMediaTypeFromMFMediaType<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaType>, Param1: ::windows::core::IntoParam<'a, ::windows::core::GUID>>(pmftype: Param0, guidformatblocktype: Param1, ppamtype: *mut *mut super::DirectShow::AM_MEDIA_TYPE) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateAMMediaTypeFromMFMediaType(pmftype: ::windows::core::RawPtr, guidformatblocktype: ::windows::core::GUID, ppamtype: *mut *mut super::DirectShow::AM_MEDIA_TYPE) -> ::windows::core::HRESULT;
}
MFCreateAMMediaTypeFromMFMediaType(pmftype.into_param().abi(), guidformatblocktype.into_param().abi(), ::core::mem::transmute(ppamtype)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateASFContentInfo() -> ::windows::core::Result<IMFASFContentInfo> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateASFContentInfo(ppicontentinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFASFContentInfo as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateASFContentInfo(&mut result__).from_abi::<IMFASFContentInfo>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateASFIndexer() -> ::windows::core::Result<IMFASFIndexer> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateASFIndexer(ppiindexer: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFASFIndexer as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateASFIndexer(&mut result__).from_abi::<IMFASFIndexer>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateASFIndexerByteStream<'a, Param0: ::windows::core::IntoParam<'a, IMFByteStream>>(picontentbytestream: Param0, cbindexstartoffset: u64) -> ::windows::core::Result<IMFByteStream> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateASFIndexerByteStream(picontentbytestream: ::windows::core::RawPtr, cbindexstartoffset: u64, piindexbytestream: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFByteStream as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateASFIndexerByteStream(picontentbytestream.into_param().abi(), ::core::mem::transmute(cbindexstartoffset), &mut result__).from_abi::<IMFByteStream>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateASFMediaSink<'a, Param0: ::windows::core::IntoParam<'a, IMFByteStream>>(pibytestream: Param0) -> ::windows::core::Result<IMFMediaSink> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateASFMediaSink(pibytestream: ::windows::core::RawPtr, ppimediasink: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaSink as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateASFMediaSink(pibytestream.into_param().abi(), &mut result__).from_abi::<IMFMediaSink>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFCreateASFMediaSinkActivate<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, IMFASFContentInfo>>(pwszfilename: Param0, pcontentinfo: Param1) -> ::windows::core::Result<IMFActivate> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateASFMediaSinkActivate(pwszfilename: super::super::Foundation::PWSTR, pcontentinfo: ::windows::core::RawPtr, ppiactivate: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFActivate as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateASFMediaSinkActivate(pwszfilename.into_param().abi(), pcontentinfo.into_param().abi(), &mut result__).from_abi::<IMFActivate>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateASFMultiplexer() -> ::windows::core::Result<IMFASFMultiplexer> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateASFMultiplexer(ppimultiplexer: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFASFMultiplexer as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateASFMultiplexer(&mut result__).from_abi::<IMFASFMultiplexer>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateASFProfile() -> ::windows::core::Result<IMFASFProfile> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateASFProfile(ppiprofile: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFASFProfile as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateASFProfile(&mut result__).from_abi::<IMFASFProfile>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateASFProfileFromPresentationDescriptor<'a, Param0: ::windows::core::IntoParam<'a, IMFPresentationDescriptor>>(pipd: Param0) -> ::windows::core::Result<IMFASFProfile> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateASFProfileFromPresentationDescriptor(pipd: ::windows::core::RawPtr, ppiprofile: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFASFProfile as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateASFProfileFromPresentationDescriptor(pipd.into_param().abi(), &mut result__).from_abi::<IMFASFProfile>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateASFSplitter() -> ::windows::core::Result<IMFASFSplitter> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateASFSplitter(ppisplitter: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFASFSplitter as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateASFSplitter(&mut result__).from_abi::<IMFASFSplitter>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateASFStreamSelector<'a, Param0: ::windows::core::IntoParam<'a, IMFASFProfile>>(piasfprofile: Param0) -> ::windows::core::Result<IMFASFStreamSelector> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateASFStreamSelector(piasfprofile: ::windows::core::RawPtr, ppselector: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFASFStreamSelector as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateASFStreamSelector(piasfprofile.into_param().abi(), &mut result__).from_abi::<IMFASFStreamSelector>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateASFStreamingMediaSink<'a, Param0: ::windows::core::IntoParam<'a, IMFByteStream>>(pibytestream: Param0) -> ::windows::core::Result<IMFMediaSink> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateASFStreamingMediaSink(pibytestream: ::windows::core::RawPtr, ppimediasink: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaSink as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateASFStreamingMediaSink(pibytestream.into_param().abi(), &mut result__).from_abi::<IMFMediaSink>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateASFStreamingMediaSinkActivate<'a, Param0: ::windows::core::IntoParam<'a, IMFActivate>, Param1: ::windows::core::IntoParam<'a, IMFASFContentInfo>>(pbytestreamactivate: Param0, pcontentinfo: Param1) -> ::windows::core::Result<IMFActivate> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateASFStreamingMediaSinkActivate(pbytestreamactivate: ::windows::core::RawPtr, pcontentinfo: ::windows::core::RawPtr, ppiactivate: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFActivate as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateASFStreamingMediaSinkActivate(pbytestreamactivate.into_param().abi(), pcontentinfo.into_param().abi(), &mut result__).from_abi::<IMFActivate>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateAVIMediaSink<'a, Param0: ::windows::core::IntoParam<'a, IMFByteStream>, Param1: ::windows::core::IntoParam<'a, IMFMediaType>, Param2: ::windows::core::IntoParam<'a, IMFMediaType>>(pibytestream: Param0, pvideomediatype: Param1, paudiomediatype: Param2) -> ::windows::core::Result<IMFMediaSink> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateAVIMediaSink(pibytestream: ::windows::core::RawPtr, pvideomediatype: ::windows::core::RawPtr, paudiomediatype: ::windows::core::RawPtr, ppimediasink: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaSink as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateAVIMediaSink(pibytestream.into_param().abi(), pvideomediatype.into_param().abi(), paudiomediatype.into_param().abi(), &mut result__).from_abi::<IMFMediaSink>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateAggregateSource<'a, Param0: ::windows::core::IntoParam<'a, IMFCollection>>(psourcecollection: Param0) -> ::windows::core::Result<IMFMediaSource> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateAggregateSource(psourcecollection: ::windows::core::RawPtr, ppaggsource: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaSource as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateAggregateSource(psourcecollection.into_param().abi(), &mut result__).from_abi::<IMFMediaSource>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateAlignedMemoryBuffer(cbmaxlength: u32, cbaligment: u32) -> ::windows::core::Result<IMFMediaBuffer> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateAlignedMemoryBuffer(cbmaxlength: u32, cbaligment: u32, ppbuffer: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaBuffer as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateAlignedMemoryBuffer(::core::mem::transmute(cbmaxlength), ::core::mem::transmute(cbaligment), &mut result__).from_abi::<IMFMediaBuffer>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateAsyncResult<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>, Param1: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param2: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(punkobject: Param0, pcallback: Param1, punkstate: Param2) -> ::windows::core::Result<IMFAsyncResult> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateAsyncResult(punkobject: ::windows::core::RawPtr, pcallback: ::windows::core::RawPtr, punkstate: ::windows::core::RawPtr, ppasyncresult: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFAsyncResult as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateAsyncResult(punkobject.into_param().abi(), pcallback.into_param().abi(), punkstate.into_param().abi(), &mut result__).from_abi::<IMFAsyncResult>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateAttributes(ppmfattributes: *mut ::core::option::Option<IMFAttributes>, cinitialsize: u32) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateAttributes(ppmfattributes: *mut ::windows::core::RawPtr, cinitialsize: u32) -> ::windows::core::HRESULT;
}
MFCreateAttributes(::core::mem::transmute(ppmfattributes), ::core::mem::transmute(cinitialsize)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Media_Audio")]
#[inline]
pub unsafe fn MFCreateAudioMediaType(paudioformat: *const super::Audio::WAVEFORMATEX) -> ::windows::core::Result<IMFAudioMediaType> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateAudioMediaType(paudioformat: *const super::Audio::WAVEFORMATEX, ppiaudiomediatype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFAudioMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateAudioMediaType(::core::mem::transmute(paudioformat), &mut result__).from_abi::<IMFAudioMediaType>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateAudioRenderer<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(paudioattributes: Param0) -> ::windows::core::Result<IMFMediaSink> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateAudioRenderer(paudioattributes: ::windows::core::RawPtr, ppsink: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaSink as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateAudioRenderer(paudioattributes.into_param().abi(), &mut result__).from_abi::<IMFMediaSink>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateAudioRendererActivate() -> ::windows::core::Result<IMFActivate> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateAudioRendererActivate(ppactivate: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFActivate as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateAudioRendererActivate(&mut result__).from_abi::<IMFActivate>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFCreateCameraOcclusionStateMonitor<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, IMFCameraOcclusionStateReportCallback>>(symboliclink: Param0, callback: Param1) -> ::windows::core::Result<IMFCameraOcclusionStateMonitor> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateCameraOcclusionStateMonitor(symboliclink: super::super::Foundation::PWSTR, callback: ::windows::core::RawPtr, occlusionstatemonitor: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFCameraOcclusionStateMonitor as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateCameraOcclusionStateMonitor(symboliclink.into_param().abi(), callback.into_param().abi(), &mut result__).from_abi::<IMFCameraOcclusionStateMonitor>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateCollection() -> ::windows::core::Result<IMFCollection> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateCollection(ppimfcollection: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFCollection as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateCollection(&mut result__).from_abi::<IMFCollection>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateContentDecryptorContext<'a, Param1: ::windows::core::IntoParam<'a, IMFDXGIDeviceManager>, Param2: ::windows::core::IntoParam<'a, IMFContentProtectionDevice>>(guidmediaprotectionsystemid: *const ::windows::core::GUID, pd3dmanager: Param1, pcontentprotectiondevice: Param2) -> ::windows::core::Result<IMFContentDecryptorContext> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateContentDecryptorContext(guidmediaprotectionsystemid: *const ::windows::core::GUID, pd3dmanager: ::windows::core::RawPtr, pcontentprotectiondevice: ::windows::core::RawPtr, ppcontentdecryptorcontext: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFContentDecryptorContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateContentDecryptorContext(::core::mem::transmute(guidmediaprotectionsystemid), pd3dmanager.into_param().abi(), pcontentprotectiondevice.into_param().abi(), &mut result__).from_abi::<IMFContentDecryptorContext>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateContentProtectionDevice(protectionsystemid: *const ::windows::core::GUID) -> ::windows::core::Result<IMFContentProtectionDevice> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateContentProtectionDevice(protectionsystemid: *const ::windows::core::GUID, contentprotectiondevice: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFContentProtectionDevice as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateContentProtectionDevice(::core::mem::transmute(protectionsystemid), &mut result__).from_abi::<IMFContentProtectionDevice>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateCredentialCache() -> ::windows::core::Result<IMFNetCredentialCache> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateCredentialCache(ppcache: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFNetCredentialCache as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateCredentialCache(&mut result__).from_abi::<IMFNetCredentialCache>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Graphics_Direct3D12")]
#[inline]
pub unsafe fn MFCreateD3D12SynchronizationObject<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D12::ID3D12Device>>(pdevice: Param0, riid: *const ::windows::core::GUID, ppvsyncobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateD3D12SynchronizationObject(pdevice: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvsyncobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT;
}
MFCreateD3D12SynchronizationObject(pdevice.into_param().abi(), ::core::mem::transmute(riid), ::core::mem::transmute(ppvsyncobject)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateDXGIDeviceManager(resettoken: *mut u32, ppdevicemanager: *mut ::core::option::Option<IMFDXGIDeviceManager>) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateDXGIDeviceManager(resettoken: *mut u32, ppdevicemanager: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
MFCreateDXGIDeviceManager(::core::mem::transmute(resettoken), ::core::mem::transmute(ppdevicemanager)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFCreateDXGISurfaceBuffer<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>, Param3: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(riid: *const ::windows::core::GUID, punksurface: Param1, usubresourceindex: u32, fbottomupwhenlinear: Param3) -> ::windows::core::Result<IMFMediaBuffer> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateDXGISurfaceBuffer(riid: *const ::windows::core::GUID, punksurface: ::windows::core::RawPtr, usubresourceindex: u32, fbottomupwhenlinear: super::super::Foundation::BOOL, ppbuffer: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaBuffer as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateDXGISurfaceBuffer(::core::mem::transmute(riid), punksurface.into_param().abi(), ::core::mem::transmute(usubresourceindex), fbottomupwhenlinear.into_param().abi(), &mut result__).from_abi::<IMFMediaBuffer>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFCreateDXSurfaceBuffer<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(riid: *const ::windows::core::GUID, punksurface: Param1, fbottomupwhenlinear: Param2) -> ::windows::core::Result<IMFMediaBuffer> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateDXSurfaceBuffer(riid: *const ::windows::core::GUID, punksurface: ::windows::core::RawPtr, fbottomupwhenlinear: super::super::Foundation::BOOL, ppbuffer: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaBuffer as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateDXSurfaceBuffer(::core::mem::transmute(riid), punksurface.into_param().abi(), fbottomupwhenlinear.into_param().abi(), &mut result__).from_abi::<IMFMediaBuffer>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateDeviceSource<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(pattributes: Param0) -> ::windows::core::Result<IMFMediaSource> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateDeviceSource(pattributes: ::windows::core::RawPtr, ppsource: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaSource as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateDeviceSource(pattributes.into_param().abi(), &mut result__).from_abi::<IMFMediaSource>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateDeviceSourceActivate<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(pattributes: Param0) -> ::windows::core::Result<IMFActivate> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateDeviceSourceActivate(pattributes: ::windows::core::RawPtr, ppactivate: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFActivate as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateDeviceSourceActivate(pattributes.into_param().abi(), &mut result__).from_abi::<IMFActivate>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
#[inline]
pub unsafe fn MFCreateEncryptedMediaExtensionsStoreActivate<'a, Param0: ::windows::core::IntoParam<'a, IMFPMPHostApp>, Param1: ::windows::core::IntoParam<'a, super::super::System::Com::IStream>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(pmphost: Param0, objectstream: Param1, classid: Param2) -> ::windows::core::Result<IMFActivate> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateEncryptedMediaExtensionsStoreActivate(pmphost: ::windows::core::RawPtr, objectstream: ::windows::core::RawPtr, classid: super::super::Foundation::PWSTR, activate: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFActivate as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateEncryptedMediaExtensionsStoreActivate(pmphost.into_param().abi(), objectstream.into_param().abi(), classid.into_param().abi(), &mut result__).from_abi::<IMFActivate>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateEventQueue() -> ::windows::core::Result<IMFMediaEventQueue> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateEventQueue(ppmediaeventqueue: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaEventQueue as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateEventQueue(&mut result__).from_abi::<IMFMediaEventQueue>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateExtendedCameraIntrinsicModel(distortionmodeltype: MFCameraIntrinsic_DistortionModelType) -> ::windows::core::Result<IMFExtendedCameraIntrinsicModel> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateExtendedCameraIntrinsicModel(distortionmodeltype: MFCameraIntrinsic_DistortionModelType, ppextendedcameraintrinsicmodel: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFExtendedCameraIntrinsicModel as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateExtendedCameraIntrinsicModel(::core::mem::transmute(distortionmodeltype), &mut result__).from_abi::<IMFExtendedCameraIntrinsicModel>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateExtendedCameraIntrinsics() -> ::windows::core::Result<IMFExtendedCameraIntrinsics> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateExtendedCameraIntrinsics(ppextendedcameraintrinsics: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFExtendedCameraIntrinsics as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateExtendedCameraIntrinsics(&mut result__).from_abi::<IMFExtendedCameraIntrinsics>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateFMPEG4MediaSink<'a, Param0: ::windows::core::IntoParam<'a, IMFByteStream>, Param1: ::windows::core::IntoParam<'a, IMFMediaType>, Param2: ::windows::core::IntoParam<'a, IMFMediaType>>(pibytestream: Param0, pvideomediatype: Param1, paudiomediatype: Param2) -> ::windows::core::Result<IMFMediaSink> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateFMPEG4MediaSink(pibytestream: ::windows::core::RawPtr, pvideomediatype: ::windows::core::RawPtr, paudiomediatype: ::windows::core::RawPtr, ppimediasink: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaSink as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateFMPEG4MediaSink(pibytestream.into_param().abi(), pvideomediatype.into_param().abi(), paudiomediatype.into_param().abi(), &mut result__).from_abi::<IMFMediaSink>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFCreateFile<'a, Param3: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(accessmode: MF_FILE_ACCESSMODE, openmode: MF_FILE_OPENMODE, fflags: MF_FILE_FLAGS, pwszfileurl: Param3) -> ::windows::core::Result<IMFByteStream> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateFile(accessmode: MF_FILE_ACCESSMODE, openmode: MF_FILE_OPENMODE, fflags: MF_FILE_FLAGS, pwszfileurl: super::super::Foundation::PWSTR, ppibytestream: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFByteStream as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateFile(::core::mem::transmute(accessmode), ::core::mem::transmute(openmode), ::core::mem::transmute(fflags), pwszfileurl.into_param().abi(), &mut result__).from_abi::<IMFByteStream>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Media_DxMediaObjects")]
#[inline]
pub unsafe fn MFCreateLegacyMediaBufferOnMFMediaBuffer<'a, Param0: ::windows::core::IntoParam<'a, IMFSample>, Param1: ::windows::core::IntoParam<'a, IMFMediaBuffer>>(psample: Param0, pmfmediabuffer: Param1, cboffset: u32) -> ::windows::core::Result<super::DxMediaObjects::IMediaBuffer> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateLegacyMediaBufferOnMFMediaBuffer(psample: ::windows::core::RawPtr, pmfmediabuffer: ::windows::core::RawPtr, cboffset: u32, ppmediabuffer: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <super::DxMediaObjects::IMediaBuffer as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateLegacyMediaBufferOnMFMediaBuffer(psample.into_param().abi(), pmfmediabuffer.into_param().abi(), ::core::mem::transmute(cboffset), &mut result__).from_abi::<super::DxMediaObjects::IMediaBuffer>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_System_Com")]
#[inline]
pub unsafe fn MFCreateMFByteStreamOnStream<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::IStream>>(pstream: Param0) -> ::windows::core::Result<IMFByteStream> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateMFByteStreamOnStream(pstream: ::windows::core::RawPtr, ppbytestream: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFByteStream as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateMFByteStreamOnStream(pstream.into_param().abi(), &mut result__).from_abi::<IMFByteStream>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateMFByteStreamOnStreamEx<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(punkstream: Param0) -> ::windows::core::Result<IMFByteStream> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateMFByteStreamOnStreamEx(punkstream: ::windows::core::RawPtr, ppbytestream: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFByteStream as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateMFByteStreamOnStreamEx(punkstream.into_param().abi(), &mut result__).from_abi::<IMFByteStream>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateMFByteStreamWrapper<'a, Param0: ::windows::core::IntoParam<'a, IMFByteStream>>(pstream: Param0) -> ::windows::core::Result<IMFByteStream> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateMFByteStreamWrapper(pstream: ::windows::core::RawPtr, ppstreamwrapper: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFByteStream as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateMFByteStreamWrapper(pstream.into_param().abi(), &mut result__).from_abi::<IMFByteStream>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFCreateMFVideoFormatFromMFMediaType<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaType>>(pmftype: Param0, ppmfvf: *mut *mut MFVIDEOFORMAT, pcbsize: *mut u32) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateMFVideoFormatFromMFMediaType(pmftype: ::windows::core::RawPtr, ppmfvf: *mut *mut MFVIDEOFORMAT, pcbsize: *mut u32) -> ::windows::core::HRESULT;
}
MFCreateMFVideoFormatFromMFMediaType(pmftype.into_param().abi(), ::core::mem::transmute(ppmfvf), ::core::mem::transmute(pcbsize)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateMP3MediaSink<'a, Param0: ::windows::core::IntoParam<'a, IMFByteStream>>(ptargetbytestream: Param0) -> ::windows::core::Result<IMFMediaSink> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateMP3MediaSink(ptargetbytestream: ::windows::core::RawPtr, ppmediasink: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaSink as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateMP3MediaSink(ptargetbytestream.into_param().abi(), &mut result__).from_abi::<IMFMediaSink>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateMPEG4MediaSink<'a, Param0: ::windows::core::IntoParam<'a, IMFByteStream>, Param1: ::windows::core::IntoParam<'a, IMFMediaType>, Param2: ::windows::core::IntoParam<'a, IMFMediaType>>(pibytestream: Param0, pvideomediatype: Param1, paudiomediatype: Param2) -> ::windows::core::Result<IMFMediaSink> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateMPEG4MediaSink(pibytestream: ::windows::core::RawPtr, pvideomediatype: ::windows::core::RawPtr, paudiomediatype: ::windows::core::RawPtr, ppimediasink: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaSink as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateMPEG4MediaSink(pibytestream.into_param().abi(), pvideomediatype.into_param().abi(), paudiomediatype.into_param().abi(), &mut result__).from_abi::<IMFMediaSink>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateMediaBufferFromMediaType<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaType>>(pmediatype: Param0, llduration: i64, dwminlength: u32, dwminalignment: u32) -> ::windows::core::Result<IMFMediaBuffer> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateMediaBufferFromMediaType(pmediatype: ::windows::core::RawPtr, llduration: i64, dwminlength: u32, dwminalignment: u32, ppbuffer: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaBuffer as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateMediaBufferFromMediaType(pmediatype.into_param().abi(), ::core::mem::transmute(llduration), ::core::mem::transmute(dwminlength), ::core::mem::transmute(dwminalignment), &mut result__).from_abi::<IMFMediaBuffer>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateMediaBufferWrapper<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaBuffer>>(pbuffer: Param0, cboffset: u32, dwlength: u32) -> ::windows::core::Result<IMFMediaBuffer> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateMediaBufferWrapper(pbuffer: ::windows::core::RawPtr, cboffset: u32, dwlength: u32, ppbuffer: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaBuffer as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateMediaBufferWrapper(pbuffer.into_param().abi(), ::core::mem::transmute(cboffset), ::core::mem::transmute(dwlength), &mut result__).from_abi::<IMFMediaBuffer>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
#[inline]
pub unsafe fn MFCreateMediaEvent(met: u32, guidextendedtype: *const ::windows::core::GUID, hrstatus: ::windows::core::HRESULT, pvvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows::core::Result<IMFMediaEvent> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateMediaEvent(met: u32, guidextendedtype: *const ::windows::core::GUID, hrstatus: ::windows::core::HRESULT, pvvalue: *const ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>, ppevent: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaEvent as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateMediaEvent(::core::mem::transmute(met), ::core::mem::transmute(guidextendedtype), ::core::mem::transmute(hrstatus), ::core::mem::transmute(pvvalue), &mut result__).from_abi::<IMFMediaEvent>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFCreateMediaExtensionActivate<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(szactivatableclassid: Param0, pconfiguration: Param1, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateMediaExtensionActivate(szactivatableclassid: super::super::Foundation::PWSTR, pconfiguration: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT;
}
MFCreateMediaExtensionActivate(szactivatableclassid.into_param().abi(), pconfiguration.into_param().abi(), ::core::mem::transmute(riid), ::core::mem::transmute(ppvobject)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateMediaSession<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(pconfiguration: Param0) -> ::windows::core::Result<IMFMediaSession> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateMediaSession(pconfiguration: ::windows::core::RawPtr, ppmediasession: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaSession as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateMediaSession(pconfiguration.into_param().abi(), &mut result__).from_abi::<IMFMediaSession>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateMediaType() -> ::windows::core::Result<IMFMediaType> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateMediaType(ppmftype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateMediaType(&mut result__).from_abi::<IMFMediaType>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateMediaTypeFromProperties<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(punkstream: Param0) -> ::windows::core::Result<IMFMediaType> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateMediaTypeFromProperties(punkstream: ::windows::core::RawPtr, ppmediatype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateMediaTypeFromProperties(punkstream.into_param().abi(), &mut result__).from_abi::<IMFMediaType>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateMediaTypeFromRepresentation<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::GUID>>(guidrepresentation: Param0, pvrepresentation: *const ::core::ffi::c_void) -> ::windows::core::Result<IMFMediaType> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateMediaTypeFromRepresentation(guidrepresentation: ::windows::core::GUID, pvrepresentation: *const ::core::ffi::c_void, ppimediatype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateMediaTypeFromRepresentation(guidrepresentation.into_param().abi(), ::core::mem::transmute(pvrepresentation), &mut result__).from_abi::<IMFMediaType>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateMemoryBuffer(cbmaxlength: u32) -> ::windows::core::Result<IMFMediaBuffer> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateMemoryBuffer(cbmaxlength: u32, ppbuffer: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaBuffer as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateMemoryBuffer(::core::mem::transmute(cbmaxlength), &mut result__).from_abi::<IMFMediaBuffer>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateMuxSink<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::GUID>, Param1: ::windows::core::IntoParam<'a, IMFAttributes>, Param2: ::windows::core::IntoParam<'a, IMFByteStream>>(guidoutputsubtype: Param0, poutputattributes: Param1, poutputbytestream: Param2) -> ::windows::core::Result<IMFMediaSink> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateMuxSink(guidoutputsubtype: ::windows::core::GUID, poutputattributes: ::windows::core::RawPtr, poutputbytestream: ::windows::core::RawPtr, ppmuxsink: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaSink as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateMuxSink(guidoutputsubtype.into_param().abi(), poutputattributes.into_param().abi(), poutputbytestream.into_param().abi(), &mut result__).from_abi::<IMFMediaSink>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateMuxStreamAttributes<'a, Param0: ::windows::core::IntoParam<'a, IMFCollection>>(pattributestomux: Param0) -> ::windows::core::Result<IMFAttributes> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateMuxStreamAttributes(pattributestomux: ::windows::core::RawPtr, ppmuxattribs: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFAttributes as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateMuxStreamAttributes(pattributestomux.into_param().abi(), &mut result__).from_abi::<IMFAttributes>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateMuxStreamMediaType<'a, Param0: ::windows::core::IntoParam<'a, IMFCollection>>(pmediatypestomux: Param0) -> ::windows::core::Result<IMFMediaType> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateMuxStreamMediaType(pmediatypestomux: ::windows::core::RawPtr, ppmuxmediatype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateMuxStreamMediaType(pmediatypestomux.into_param().abi(), &mut result__).from_abi::<IMFMediaType>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateMuxStreamSample<'a, Param0: ::windows::core::IntoParam<'a, IMFCollection>>(psamplestomux: Param0) -> ::windows::core::Result<IMFSample> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateMuxStreamSample(psamplestomux: ::windows::core::RawPtr, ppmuxsample: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFSample as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateMuxStreamSample(psamplestomux.into_param().abi(), &mut result__).from_abi::<IMFSample>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateNetSchemePlugin(riid: *const ::windows::core::GUID, ppvhandler: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateNetSchemePlugin(riid: *const ::windows::core::GUID, ppvhandler: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT;
}
MFCreateNetSchemePlugin(::core::mem::transmute(riid), ::core::mem::transmute(ppvhandler)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreatePMPMediaSession<'a, Param1: ::windows::core::IntoParam<'a, IMFAttributes>>(dwcreationflags: u32, pconfiguration: Param1, ppmediasession: *mut ::core::option::Option<IMFMediaSession>, ppenableractivate: *mut ::core::option::Option<IMFActivate>) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreatePMPMediaSession(dwcreationflags: u32, pconfiguration: ::windows::core::RawPtr, ppmediasession: *mut ::windows::core::RawPtr, ppenableractivate: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
MFCreatePMPMediaSession(::core::mem::transmute(dwcreationflags), pconfiguration.into_param().abi(), ::core::mem::transmute(ppmediasession), ::core::mem::transmute(ppenableractivate)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreatePMPServer(dwcreationflags: u32) -> ::windows::core::Result<IMFPMPServer> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreatePMPServer(dwcreationflags: u32, pppmpserver: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFPMPServer as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreatePMPServer(::core::mem::transmute(dwcreationflags), &mut result__).from_abi::<IMFPMPServer>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreatePresentationClock() -> ::windows::core::Result<IMFPresentationClock> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreatePresentationClock(pppresentationclock: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFPresentationClock as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreatePresentationClock(&mut result__).from_abi::<IMFPresentationClock>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreatePresentationDescriptor(cstreamdescriptors: u32, apstreamdescriptors: *const ::core::option::Option<IMFStreamDescriptor>) -> ::windows::core::Result<IMFPresentationDescriptor> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreatePresentationDescriptor(cstreamdescriptors: u32, apstreamdescriptors: *const ::windows::core::RawPtr, pppresentationdescriptor: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFPresentationDescriptor as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreatePresentationDescriptor(::core::mem::transmute(cstreamdescriptors), ::core::mem::transmute(apstreamdescriptors), &mut result__).from_abi::<IMFPresentationDescriptor>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreatePresentationDescriptorFromASFProfile<'a, Param0: ::windows::core::IntoParam<'a, IMFASFProfile>>(piprofile: Param0) -> ::windows::core::Result<IMFPresentationDescriptor> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreatePresentationDescriptorFromASFProfile(piprofile: ::windows::core::RawPtr, ppipd: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFPresentationDescriptor as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreatePresentationDescriptorFromASFProfile(piprofile.into_param().abi(), &mut result__).from_abi::<IMFPresentationDescriptor>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreatePropertiesFromMediaType<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaType>>(pmediatype: Param0, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreatePropertiesFromMediaType(pmediatype: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT;
}
MFCreatePropertiesFromMediaType(pmediatype.into_param().abi(), ::core::mem::transmute(riid), ::core::mem::transmute(ppv)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateProtectedEnvironmentAccess() -> ::windows::core::Result<IMFProtectedEnvironmentAccess> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateProtectedEnvironmentAccess(ppaccess: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFProtectedEnvironmentAccess as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateProtectedEnvironmentAccess(&mut result__).from_abi::<IMFProtectedEnvironmentAccess>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem"))]
#[inline]
pub unsafe fn MFCreateProxyLocator<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::UI::Shell::PropertiesSystem::IPropertyStore>>(pszprotocol: Param0, pproxyconfig: Param1) -> ::windows::core::Result<IMFNetProxyLocator> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateProxyLocator(pszprotocol: super::super::Foundation::PWSTR, pproxyconfig: ::windows::core::RawPtr, ppproxylocator: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFNetProxyLocator as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateProxyLocator(pszprotocol.into_param().abi(), pproxyconfig.into_param().abi(), &mut result__).from_abi::<IMFNetProxyLocator>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFCreateRelativePanelWatcher<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(videodeviceid: Param0, displaymonitordeviceid: Param1) -> ::windows::core::Result<IMFRelativePanelWatcher> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateRelativePanelWatcher(videodeviceid: super::super::Foundation::PWSTR, displaymonitordeviceid: super::super::Foundation::PWSTR, pprelativepanelwatcher: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFRelativePanelWatcher as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateRelativePanelWatcher(videodeviceid.into_param().abi(), displaymonitordeviceid.into_param().abi(), &mut result__).from_abi::<IMFRelativePanelWatcher>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateRemoteDesktopPlugin() -> ::windows::core::Result<IMFRemoteDesktopPlugin> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateRemoteDesktopPlugin(ppplugin: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFRemoteDesktopPlugin as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateRemoteDesktopPlugin(&mut result__).from_abi::<IMFRemoteDesktopPlugin>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateSample() -> ::windows::core::Result<IMFSample> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateSample(ppimfsample: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFSample as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateSample(&mut result__).from_abi::<IMFSample>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateSampleCopierMFT() -> ::windows::core::Result<IMFTransform> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateSampleCopierMFT(ppcopiermft: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFTransform as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateSampleCopierMFT(&mut result__).from_abi::<IMFTransform>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateSampleGrabberSinkActivate<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaType>, Param1: ::windows::core::IntoParam<'a, IMFSampleGrabberSinkCallback>>(pimfmediatype: Param0, pimfsamplegrabbersinkcallback: Param1) -> ::windows::core::Result<IMFActivate> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateSampleGrabberSinkActivate(pimfmediatype: ::windows::core::RawPtr, pimfsamplegrabbersinkcallback: ::windows::core::RawPtr, ppiactivate: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFActivate as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateSampleGrabberSinkActivate(pimfmediatype.into_param().abi(), pimfsamplegrabbersinkcallback.into_param().abi(), &mut result__).from_abi::<IMFActivate>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateSensorActivityMonitor<'a, Param0: ::windows::core::IntoParam<'a, IMFSensorActivitiesReportCallback>>(pcallback: Param0) -> ::windows::core::Result<IMFSensorActivityMonitor> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateSensorActivityMonitor(pcallback: ::windows::core::RawPtr, ppactivitymonitor: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFSensorActivityMonitor as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateSensorActivityMonitor(pcallback.into_param().abi(), &mut result__).from_abi::<IMFSensorActivityMonitor>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFCreateSensorGroup<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(sensorgroupsymboliclink: Param0) -> ::windows::core::Result<IMFSensorGroup> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateSensorGroup(sensorgroupsymboliclink: super::super::Foundation::PWSTR, ppsensorgroup: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFSensorGroup as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateSensorGroup(sensorgroupsymboliclink.into_param().abi(), &mut result__).from_abi::<IMFSensorGroup>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFCreateSensorProfile<'a, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(profiletype: *const ::windows::core::GUID, profileindex: u32, constraints: Param2) -> ::windows::core::Result<IMFSensorProfile> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateSensorProfile(profiletype: *const ::windows::core::GUID, profileindex: u32, constraints: super::super::Foundation::PWSTR, ppprofile: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFSensorProfile as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateSensorProfile(::core::mem::transmute(profiletype), ::core::mem::transmute(profileindex), constraints.into_param().abi(), &mut result__).from_abi::<IMFSensorProfile>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateSensorProfileCollection() -> ::windows::core::Result<IMFSensorProfileCollection> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateSensorProfileCollection(ppsensorprofile: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFSensorProfileCollection as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateSensorProfileCollection(&mut result__).from_abi::<IMFSensorProfileCollection>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateSensorStream<'a, Param1: ::windows::core::IntoParam<'a, IMFAttributes>, Param2: ::windows::core::IntoParam<'a, IMFCollection>>(streamid: u32, pattributes: Param1, pmediatypecollection: Param2) -> ::windows::core::Result<IMFSensorStream> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateSensorStream(streamid: u32, pattributes: ::windows::core::RawPtr, pmediatypecollection: ::windows::core::RawPtr, ppstream: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFSensorStream as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateSensorStream(::core::mem::transmute(streamid), pattributes.into_param().abi(), pmediatypecollection.into_param().abi(), &mut result__).from_abi::<IMFSensorStream>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
#[inline]
pub unsafe fn MFCreateSequencerSegmentOffset(dwid: u32, hnsoffset: i64) -> ::windows::core::Result<super::super::System::Com::StructuredStorage::PROPVARIANT> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateSequencerSegmentOffset(dwid: u32, hnsoffset: i64, pvarsegmentoffset: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT;
}
let mut result__: <super::super::System::Com::StructuredStorage::PROPVARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateSequencerSegmentOffset(::core::mem::transmute(dwid), ::core::mem::transmute(hnsoffset), &mut result__).from_abi::<super::super::System::Com::StructuredStorage::PROPVARIANT>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateSequencerSource<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(preserved: Param0) -> ::windows::core::Result<IMFSequencerSource> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateSequencerSource(preserved: ::windows::core::RawPtr, ppsequencersource: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFSequencerSource as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateSequencerSource(preserved.into_param().abi(), &mut result__).from_abi::<IMFSequencerSource>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateSimpleTypeHandler() -> ::windows::core::Result<IMFMediaTypeHandler> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateSimpleTypeHandler(pphandler: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaTypeHandler as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateSimpleTypeHandler(&mut result__).from_abi::<IMFMediaTypeHandler>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateSinkWriterFromMediaSink<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaSink>, Param1: ::windows::core::IntoParam<'a, IMFAttributes>>(pmediasink: Param0, pattributes: Param1) -> ::windows::core::Result<IMFSinkWriter> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateSinkWriterFromMediaSink(pmediasink: ::windows::core::RawPtr, pattributes: ::windows::core::RawPtr, ppsinkwriter: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFSinkWriter as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateSinkWriterFromMediaSink(pmediasink.into_param().abi(), pattributes.into_param().abi(), &mut result__).from_abi::<IMFSinkWriter>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFCreateSinkWriterFromURL<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, IMFByteStream>, Param2: ::windows::core::IntoParam<'a, IMFAttributes>>(pwszoutputurl: Param0, pbytestream: Param1, pattributes: Param2) -> ::windows::core::Result<IMFSinkWriter> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateSinkWriterFromURL(pwszoutputurl: super::super::Foundation::PWSTR, pbytestream: ::windows::core::RawPtr, pattributes: ::windows::core::RawPtr, ppsinkwriter: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFSinkWriter as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateSinkWriterFromURL(pwszoutputurl.into_param().abi(), pbytestream.into_param().abi(), pattributes.into_param().abi(), &mut result__).from_abi::<IMFSinkWriter>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateSourceReaderFromByteStream<'a, Param0: ::windows::core::IntoParam<'a, IMFByteStream>, Param1: ::windows::core::IntoParam<'a, IMFAttributes>>(pbytestream: Param0, pattributes: Param1) -> ::windows::core::Result<IMFSourceReader> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateSourceReaderFromByteStream(pbytestream: ::windows::core::RawPtr, pattributes: ::windows::core::RawPtr, ppsourcereader: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFSourceReader as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateSourceReaderFromByteStream(pbytestream.into_param().abi(), pattributes.into_param().abi(), &mut result__).from_abi::<IMFSourceReader>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateSourceReaderFromMediaSource<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaSource>, Param1: ::windows::core::IntoParam<'a, IMFAttributes>>(pmediasource: Param0, pattributes: Param1) -> ::windows::core::Result<IMFSourceReader> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateSourceReaderFromMediaSource(pmediasource: ::windows::core::RawPtr, pattributes: ::windows::core::RawPtr, ppsourcereader: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFSourceReader as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateSourceReaderFromMediaSource(pmediasource.into_param().abi(), pattributes.into_param().abi(), &mut result__).from_abi::<IMFSourceReader>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFCreateSourceReaderFromURL<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, IMFAttributes>>(pwszurl: Param0, pattributes: Param1) -> ::windows::core::Result<IMFSourceReader> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateSourceReaderFromURL(pwszurl: super::super::Foundation::PWSTR, pattributes: ::windows::core::RawPtr, ppsourcereader: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFSourceReader as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateSourceReaderFromURL(pwszurl.into_param().abi(), pattributes.into_param().abi(), &mut result__).from_abi::<IMFSourceReader>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateSourceResolver() -> ::windows::core::Result<IMFSourceResolver> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateSourceResolver(ppisourceresolver: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFSourceResolver as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateSourceResolver(&mut result__).from_abi::<IMFSourceResolver>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateStandardQualityManager() -> ::windows::core::Result<IMFQualityManager> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateStandardQualityManager(ppqualitymanager: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFQualityManager as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateStandardQualityManager(&mut result__).from_abi::<IMFQualityManager>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateStreamDescriptor(dwstreamidentifier: u32, cmediatypes: u32, apmediatypes: *const ::core::option::Option<IMFMediaType>) -> ::windows::core::Result<IMFStreamDescriptor> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateStreamDescriptor(dwstreamidentifier: u32, cmediatypes: u32, apmediatypes: *const ::windows::core::RawPtr, ppdescriptor: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFStreamDescriptor as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateStreamDescriptor(::core::mem::transmute(dwstreamidentifier), ::core::mem::transmute(cmediatypes), ::core::mem::transmute(apmediatypes), &mut result__).from_abi::<IMFStreamDescriptor>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_System_Com")]
#[inline]
pub unsafe fn MFCreateStreamOnMFByteStream<'a, Param0: ::windows::core::IntoParam<'a, IMFByteStream>>(pbytestream: Param0) -> ::windows::core::Result<super::super::System::Com::IStream> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateStreamOnMFByteStream(pbytestream: ::windows::core::RawPtr, ppstream: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <super::super::System::Com::IStream as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateStreamOnMFByteStream(pbytestream.into_param().abi(), &mut result__).from_abi::<super::super::System::Com::IStream>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateStreamOnMFByteStreamEx<'a, Param0: ::windows::core::IntoParam<'a, IMFByteStream>>(pbytestream: Param0, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateStreamOnMFByteStreamEx(pbytestream: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT;
}
MFCreateStreamOnMFByteStreamEx(pbytestream.into_param().abi(), ::core::mem::transmute(riid), ::core::mem::transmute(ppv)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateSystemTimeSource() -> ::windows::core::Result<IMFPresentationTimeSource> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateSystemTimeSource(ppsystemtimesource: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFPresentationTimeSource as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateSystemTimeSource(&mut result__).from_abi::<IMFPresentationTimeSource>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateTempFile(accessmode: MF_FILE_ACCESSMODE, openmode: MF_FILE_OPENMODE, fflags: MF_FILE_FLAGS) -> ::windows::core::Result<IMFByteStream> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateTempFile(accessmode: MF_FILE_ACCESSMODE, openmode: MF_FILE_OPENMODE, fflags: MF_FILE_FLAGS, ppibytestream: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFByteStream as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateTempFile(::core::mem::transmute(accessmode), ::core::mem::transmute(openmode), ::core::mem::transmute(fflags), &mut result__).from_abi::<IMFByteStream>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateTopoLoader() -> ::windows::core::Result<IMFTopoLoader> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateTopoLoader(ppobj: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFTopoLoader as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateTopoLoader(&mut result__).from_abi::<IMFTopoLoader>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateTopology() -> ::windows::core::Result<IMFTopology> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateTopology(pptopo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFTopology as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateTopology(&mut result__).from_abi::<IMFTopology>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateTopologyNode(nodetype: MF_TOPOLOGY_TYPE) -> ::windows::core::Result<IMFTopologyNode> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateTopologyNode(nodetype: MF_TOPOLOGY_TYPE, ppnode: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFTopologyNode as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateTopologyNode(::core::mem::transmute(nodetype), &mut result__).from_abi::<IMFTopologyNode>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateTrackedSample() -> ::windows::core::Result<IMFTrackedSample> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateTrackedSample(ppmfsample: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFTrackedSample as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateTrackedSample(&mut result__).from_abi::<IMFTrackedSample>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateTranscodeProfile() -> ::windows::core::Result<IMFTranscodeProfile> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateTranscodeProfile(pptranscodeprofile: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFTranscodeProfile as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateTranscodeProfile(&mut result__).from_abi::<IMFTranscodeProfile>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateTranscodeSinkActivate() -> ::windows::core::Result<IMFActivate> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateTranscodeSinkActivate(ppactivate: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFActivate as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateTranscodeSinkActivate(&mut result__).from_abi::<IMFActivate>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFCreateTranscodeTopology<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaSource>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, IMFTranscodeProfile>>(psrc: Param0, pwszoutputfilepath: Param1, pprofile: Param2) -> ::windows::core::Result<IMFTopology> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateTranscodeTopology(psrc: ::windows::core::RawPtr, pwszoutputfilepath: super::super::Foundation::PWSTR, pprofile: ::windows::core::RawPtr, pptranscodetopo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFTopology as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateTranscodeTopology(psrc.into_param().abi(), pwszoutputfilepath.into_param().abi(), pprofile.into_param().abi(), &mut result__).from_abi::<IMFTopology>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateTranscodeTopologyFromByteStream<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaSource>, Param1: ::windows::core::IntoParam<'a, IMFByteStream>, Param2: ::windows::core::IntoParam<'a, IMFTranscodeProfile>>(psrc: Param0, poutputstream: Param1, pprofile: Param2) -> ::windows::core::Result<IMFTopology> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateTranscodeTopologyFromByteStream(psrc: ::windows::core::RawPtr, poutputstream: ::windows::core::RawPtr, pprofile: ::windows::core::RawPtr, pptranscodetopo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFTopology as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateTranscodeTopologyFromByteStream(psrc.into_param().abi(), poutputstream.into_param().abi(), pprofile.into_param().abi(), &mut result__).from_abi::<IMFTopology>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateTransformActivate() -> ::windows::core::Result<IMFActivate> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateTransformActivate(ppactivate: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFActivate as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateTransformActivate(&mut result__).from_abi::<IMFActivate>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFCreateVideoMediaType(pvideoformat: *const MFVIDEOFORMAT) -> ::windows::core::Result<IMFVideoMediaType> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateVideoMediaType(pvideoformat: *const MFVIDEOFORMAT, ppivideomediatype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFVideoMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateVideoMediaType(::core::mem::transmute(pvideoformat), &mut result__).from_abi::<IMFVideoMediaType>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Graphics_Gdi")]
#[inline]
pub unsafe fn MFCreateVideoMediaTypeFromBitMapInfoHeader(pbmihbitmapinfoheader: *const super::super::Graphics::Gdi::BITMAPINFOHEADER, dwpixelaspectratiox: u32, dwpixelaspectratioy: u32, interlacemode: MFVideoInterlaceMode, videoflags: u64, qwframespersecondnumerator: u64, qwframesperseconddenominator: u64, dwmaxbitrate: u32) -> ::windows::core::Result<IMFVideoMediaType> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateVideoMediaTypeFromBitMapInfoHeader(pbmihbitmapinfoheader: *const super::super::Graphics::Gdi::BITMAPINFOHEADER, dwpixelaspectratiox: u32, dwpixelaspectratioy: u32, interlacemode: MFVideoInterlaceMode, videoflags: u64, qwframespersecondnumerator: u64, qwframesperseconddenominator: u64, dwmaxbitrate: u32, ppivideomediatype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFVideoMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateVideoMediaTypeFromBitMapInfoHeader(
::core::mem::transmute(pbmihbitmapinfoheader),
::core::mem::transmute(dwpixelaspectratiox),
::core::mem::transmute(dwpixelaspectratioy),
::core::mem::transmute(interlacemode),
::core::mem::transmute(videoflags),
::core::mem::transmute(qwframespersecondnumerator),
::core::mem::transmute(qwframesperseconddenominator),
::core::mem::transmute(dwmaxbitrate),
&mut result__,
)
.from_abi::<IMFVideoMediaType>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Graphics_Gdi")]
#[inline]
pub unsafe fn MFCreateVideoMediaTypeFromBitMapInfoHeaderEx(pbmihbitmapinfoheader: *const super::super::Graphics::Gdi::BITMAPINFOHEADER, cbbitmapinfoheader: u32, dwpixelaspectratiox: u32, dwpixelaspectratioy: u32, interlacemode: MFVideoInterlaceMode, videoflags: u64, dwframespersecondnumerator: u32, dwframesperseconddenominator: u32, dwmaxbitrate: u32) -> ::windows::core::Result<IMFVideoMediaType> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateVideoMediaTypeFromBitMapInfoHeaderEx(pbmihbitmapinfoheader: *const super::super::Graphics::Gdi::BITMAPINFOHEADER, cbbitmapinfoheader: u32, dwpixelaspectratiox: u32, dwpixelaspectratioy: u32, interlacemode: MFVideoInterlaceMode, videoflags: u64, dwframespersecondnumerator: u32, dwframesperseconddenominator: u32, dwmaxbitrate: u32, ppivideomediatype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFVideoMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateVideoMediaTypeFromBitMapInfoHeaderEx(
::core::mem::transmute(pbmihbitmapinfoheader),
::core::mem::transmute(cbbitmapinfoheader),
::core::mem::transmute(dwpixelaspectratiox),
::core::mem::transmute(dwpixelaspectratioy),
::core::mem::transmute(interlacemode),
::core::mem::transmute(videoflags),
::core::mem::transmute(dwframespersecondnumerator),
::core::mem::transmute(dwframesperseconddenominator),
::core::mem::transmute(dwmaxbitrate),
&mut result__,
)
.from_abi::<IMFVideoMediaType>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateVideoMediaTypeFromSubtype(pamsubtype: *const ::windows::core::GUID) -> ::windows::core::Result<IMFVideoMediaType> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateVideoMediaTypeFromSubtype(pamsubtype: *const ::windows::core::GUID, ppivideomediatype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFVideoMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateVideoMediaTypeFromSubtype(::core::mem::transmute(pamsubtype), &mut result__).from_abi::<IMFVideoMediaType>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateVideoMixer<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(powner: Param0, riiddevice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateVideoMixer(powner: ::windows::core::RawPtr, riiddevice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT;
}
MFCreateVideoMixer(powner.into_param().abi(), ::core::mem::transmute(riiddevice), ::core::mem::transmute(riid), ::core::mem::transmute(ppv)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateVideoMixerAndPresenter<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(pmixerowner: Param0, ppresenterowner: Param1, riidmixer: *const ::windows::core::GUID, ppvvideomixer: *mut *mut ::core::ffi::c_void, riidpresenter: *const ::windows::core::GUID, ppvvideopresenter: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateVideoMixerAndPresenter(pmixerowner: ::windows::core::RawPtr, ppresenterowner: ::windows::core::RawPtr, riidmixer: *const ::windows::core::GUID, ppvvideomixer: *mut *mut ::core::ffi::c_void, riidpresenter: *const ::windows::core::GUID, ppvvideopresenter: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT;
}
MFCreateVideoMixerAndPresenter(pmixerowner.into_param().abi(), ppresenterowner.into_param().abi(), ::core::mem::transmute(riidmixer), ::core::mem::transmute(ppvvideomixer), ::core::mem::transmute(riidpresenter), ::core::mem::transmute(ppvvideopresenter)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateVideoPresenter<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(powner: Param0, riiddevice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppvideopresenter: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateVideoPresenter(powner: ::windows::core::RawPtr, riiddevice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppvideopresenter: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT;
}
MFCreateVideoPresenter(powner.into_param().abi(), ::core::mem::transmute(riiddevice), ::core::mem::transmute(riid), ::core::mem::transmute(ppvideopresenter)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateVideoRenderer(riidrenderer: *const ::windows::core::GUID, ppvideorenderer: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateVideoRenderer(riidrenderer: *const ::windows::core::GUID, ppvideorenderer: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT;
}
MFCreateVideoRenderer(::core::mem::transmute(riidrenderer), ::core::mem::transmute(ppvideorenderer)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFCreateVideoRendererActivate<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::HWND>>(hwndvideo: Param0) -> ::windows::core::Result<IMFActivate> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateVideoRendererActivate(hwndvideo: super::super::Foundation::HWND, ppactivate: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFActivate as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateVideoRendererActivate(hwndvideo.into_param().abi(), &mut result__).from_abi::<IMFActivate>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateVideoSampleAllocator(riid: *const ::windows::core::GUID, ppsampleallocator: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateVideoSampleAllocator(riid: *const ::windows::core::GUID, ppsampleallocator: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT;
}
MFCreateVideoSampleAllocator(::core::mem::transmute(riid), ::core::mem::transmute(ppsampleallocator)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateVideoSampleAllocatorEx(riid: *const ::windows::core::GUID, ppsampleallocator: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateVideoSampleAllocatorEx(riid: *const ::windows::core::GUID, ppsampleallocator: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT;
}
MFCreateVideoSampleAllocatorEx(::core::mem::transmute(riid), ::core::mem::transmute(ppsampleallocator)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateVideoSampleFromSurface<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(punksurface: Param0) -> ::windows::core::Result<IMFSample> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateVideoSampleFromSurface(punksurface: ::windows::core::RawPtr, ppsample: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFSample as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateVideoSampleFromSurface(punksurface.into_param().abi(), &mut result__).from_abi::<IMFSample>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFCreateVirtualCamera<'a, Param3: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(
r#type: __MIDL___MIDL_itf_mfvirtualcamera_0000_0000_0001,
lifetime: __MIDL___MIDL_itf_mfvirtualcamera_0000_0000_0002,
access: __MIDL___MIDL_itf_mfvirtualcamera_0000_0000_0003,
friendlyname: Param3,
sourceid: Param4,
categories: *const ::windows::core::GUID,
categorycount: u32,
) -> ::windows::core::Result<IMFVirtualCamera> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateVirtualCamera(r#type: __MIDL___MIDL_itf_mfvirtualcamera_0000_0000_0001, lifetime: __MIDL___MIDL_itf_mfvirtualcamera_0000_0000_0002, access: __MIDL___MIDL_itf_mfvirtualcamera_0000_0000_0003, friendlyname: super::super::Foundation::PWSTR, sourceid: super::super::Foundation::PWSTR, categories: *const ::windows::core::GUID, categorycount: u32, virtualcamera: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFVirtualCamera as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateVirtualCamera(::core::mem::transmute(r#type), ::core::mem::transmute(lifetime), ::core::mem::transmute(access), friendlyname.into_param().abi(), sourceid.into_param().abi(), ::core::mem::transmute(categories), ::core::mem::transmute(categorycount), &mut result__).from_abi::<IMFVirtualCamera>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateWAVEMediaSink<'a, Param0: ::windows::core::IntoParam<'a, IMFByteStream>, Param1: ::windows::core::IntoParam<'a, IMFMediaType>>(ptargetbytestream: Param0, paudiomediatype: Param1) -> ::windows::core::Result<IMFMediaSink> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateWAVEMediaSink(ptargetbytestream: ::windows::core::RawPtr, paudiomediatype: ::windows::core::RawPtr, ppmediasink: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaSink as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateWAVEMediaSink(ptargetbytestream.into_param().abi(), paudiomediatype.into_param().abi(), &mut result__).from_abi::<IMFMediaSink>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFCreateWICBitmapBuffer<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(riid: *const ::windows::core::GUID, punksurface: Param1) -> ::windows::core::Result<IMFMediaBuffer> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateWICBitmapBuffer(riid: *const ::windows::core::GUID, punksurface: ::windows::core::RawPtr, ppbuffer: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaBuffer as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateWICBitmapBuffer(::core::mem::transmute(riid), punksurface.into_param().abi(), &mut result__).from_abi::<IMFMediaBuffer>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
#[inline]
pub unsafe fn MFCreateWMAEncoderActivate<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaType>, Param1: ::windows::core::IntoParam<'a, super::super::UI::Shell::PropertiesSystem::IPropertyStore>>(pmediatype: Param0, pencodingconfigurationproperties: Param1) -> ::windows::core::Result<IMFActivate> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateWMAEncoderActivate(pmediatype: ::windows::core::RawPtr, pencodingconfigurationproperties: ::windows::core::RawPtr, ppactivate: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFActivate as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateWMAEncoderActivate(pmediatype.into_param().abi(), pencodingconfigurationproperties.into_param().abi(), &mut result__).from_abi::<IMFActivate>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
#[inline]
pub unsafe fn MFCreateWMVEncoderActivate<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaType>, Param1: ::windows::core::IntoParam<'a, super::super::UI::Shell::PropertiesSystem::IPropertyStore>>(pmediatype: Param0, pencodingconfigurationproperties: Param1) -> ::windows::core::Result<IMFActivate> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateWMVEncoderActivate(pmediatype: ::windows::core::RawPtr, pencodingconfigurationproperties: ::windows::core::RawPtr, ppactivate: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFActivate as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFCreateWMVEncoderActivate(pmediatype.into_param().abi(), pencodingconfigurationproperties.into_param().abi(), &mut result__).from_abi::<IMFActivate>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Media_Audio")]
#[inline]
pub unsafe fn MFCreateWaveFormatExFromMFMediaType<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaType>>(pmftype: Param0, ppwf: *mut *mut super::Audio::WAVEFORMATEX, pcbsize: *mut u32, flags: u32) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFCreateWaveFormatExFromMFMediaType(pmftype: ::windows::core::RawPtr, ppwf: *mut *mut super::Audio::WAVEFORMATEX, pcbsize: *mut u32, flags: u32) -> ::windows::core::HRESULT;
}
MFCreateWaveFormatExFromMFMediaType(pmftype.into_param().abi(), ::core::mem::transmute(ppwf), ::core::mem::transmute(pcbsize), ::core::mem::transmute(flags)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFDepthMeasurement(pub i32);
pub const DistanceToFocalPlane: MFDepthMeasurement = MFDepthMeasurement(0i32);
pub const DistanceToOpticalCenter: MFDepthMeasurement = MFDepthMeasurement(1i32);
impl ::core::convert::From<i32> for MFDepthMeasurement {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFDepthMeasurement {
type Abi = Self;
}
#[cfg(feature = "Win32_System_Com")]
#[inline]
pub unsafe fn MFDeserializeAttributesFromStream<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>, Param2: ::windows::core::IntoParam<'a, super::super::System::Com::IStream>>(pattr: Param0, dwoptions: u32, pstm: Param2) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFDeserializeAttributesFromStream(pattr: ::windows::core::RawPtr, dwoptions: u32, pstm: ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
MFDeserializeAttributesFromStream(pattr.into_param().abi(), ::core::mem::transmute(dwoptions), pstm.into_param().abi()).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFDeserializePresentationDescriptor(cbdata: u32, pbdata: *const u8) -> ::windows::core::Result<IMFPresentationDescriptor> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFDeserializePresentationDescriptor(cbdata: u32, pbdata: *const u8, pppd: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFPresentationDescriptor as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFDeserializePresentationDescriptor(::core::mem::transmute(cbdata), ::core::mem::transmute(pbdata), &mut result__).from_abi::<IMFPresentationDescriptor>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
pub const MFENABLETYPE_MF_RebootRequired: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6d4d3d4b_0ece_4652_8b3a_f2d24260d887);
pub const MFENABLETYPE_MF_UpdateRevocationInformation: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe558b0b5_b3c4_44a0_924c_50d178932385);
pub const MFENABLETYPE_MF_UpdateUntrustedComponent: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9879f3d6_cee2_48e6_b573_9767ab172f16);
pub const MFENABLETYPE_WMDRMV1_LicenseAcquisition: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4ff6eeaf_0b43_4797_9b85_abf31815e7b0);
pub const MFENABLETYPE_WMDRMV7_Individualization: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xacd2c84a_b303_4f65_bc2c_2c848d01a989);
pub const MFENABLETYPE_WMDRMV7_LicenseAcquisition: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x003306df_4a06_4884_a097_ef6d22ec84a3);
pub const MFEVRDLL: u32 = 0u32;
#[inline]
pub unsafe fn MFEndCreateFile<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(presult: Param0) -> ::windows::core::Result<IMFByteStream> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFEndCreateFile(presult: ::windows::core::RawPtr, ppfile: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFByteStream as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFEndCreateFile(presult.into_param().abi(), &mut result__).from_abi::<IMFByteStream>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFEndRegisterWorkQueueWithMMCSS<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(presult: Param0) -> ::windows::core::Result<u32> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFEndRegisterWorkQueueWithMMCSS(presult: ::windows::core::RawPtr, pdwtaskid: *mut u32) -> ::windows::core::HRESULT;
}
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFEndRegisterWorkQueueWithMMCSS(presult.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFEndUnregisterWorkQueueWithMMCSS<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(presult: Param0) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFEndUnregisterWorkQueueWithMMCSS(presult: ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
MFEndUnregisterWorkQueueWithMMCSS(presult.into_param().abi()).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFEnumDeviceSources<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(pattributes: Param0, pppsourceactivate: *mut *mut ::core::option::Option<IMFActivate>, pcsourceactivate: *mut u32) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFEnumDeviceSources(pattributes: ::windows::core::RawPtr, pppsourceactivate: *mut *mut ::windows::core::RawPtr, pcsourceactivate: *mut u32) -> ::windows::core::HRESULT;
}
MFEnumDeviceSources(pattributes.into_param().abi(), ::core::mem::transmute(pppsourceactivate), ::core::mem::transmute(pcsourceactivate)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFExtendedCameraIntrinsic_IntrinsicModel {
pub Width: u32,
pub Height: u32,
pub SplitFrameId: u32,
pub CameraModel: MFCameraIntrinsic_CameraModel,
}
impl MFExtendedCameraIntrinsic_IntrinsicModel {}
impl ::core::default::Default for MFExtendedCameraIntrinsic_IntrinsicModel {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFExtendedCameraIntrinsic_IntrinsicModel {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFExtendedCameraIntrinsic_IntrinsicModel").field("Width", &self.Width).field("Height", &self.Height).field("SplitFrameId", &self.SplitFrameId).field("CameraModel", &self.CameraModel).finish()
}
}
impl ::core::cmp::PartialEq for MFExtendedCameraIntrinsic_IntrinsicModel {
fn eq(&self, other: &Self) -> bool {
self.Width == other.Width && self.Height == other.Height && self.SplitFrameId == other.SplitFrameId && self.CameraModel == other.CameraModel
}
}
impl ::core::cmp::Eq for MFExtendedCameraIntrinsic_IntrinsicModel {}
unsafe impl ::windows::core::Abi for MFExtendedCameraIntrinsic_IntrinsicModel {
type Abi = Self;
}
pub const MFFLACBytestreamHandler: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0e41cfb8_0506_40f4_a516_77cc23642d91);
pub const MFFLACSinkClassFactory: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7d39c56f_6075_47c9_9bae_8cf9e531b5f5);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFFOLDDOWN_MATRIX {
pub cbSize: u32,
pub cSrcChannels: u32,
pub cDstChannels: u32,
pub dwChannelMask: u32,
pub Coeff: [i32; 64],
}
impl MFFOLDDOWN_MATRIX {}
impl ::core::default::Default for MFFOLDDOWN_MATRIX {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFFOLDDOWN_MATRIX {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFFOLDDOWN_MATRIX").field("cbSize", &self.cbSize).field("cSrcChannels", &self.cSrcChannels).field("cDstChannels", &self.cDstChannels).field("dwChannelMask", &self.dwChannelMask).field("Coeff", &self.Coeff).finish()
}
}
impl ::core::cmp::PartialEq for MFFOLDDOWN_MATRIX {
fn eq(&self, other: &Self) -> bool {
self.cbSize == other.cbSize && self.cSrcChannels == other.cSrcChannels && self.cDstChannels == other.cDstChannels && self.dwChannelMask == other.dwChannelMask && self.Coeff == other.Coeff
}
}
impl ::core::cmp::Eq for MFFOLDDOWN_MATRIX {}
unsafe impl ::windows::core::Abi for MFFOLDDOWN_MATRIX {
type Abi = Self;
}
#[inline]
pub unsafe fn MFFrameRateToAverageTimePerFrame(unnumerator: u32, undenominator: u32) -> ::windows::core::Result<u64> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFFrameRateToAverageTimePerFrame(unnumerator: u32, undenominator: u32, punaveragetimeperframe: *mut u64) -> ::windows::core::HRESULT;
}
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFFrameRateToAverageTimePerFrame(::core::mem::transmute(unnumerator), ::core::mem::transmute(undenominator), &mut result__).from_abi::<u64>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFFrameSourceTypes(pub i32);
pub const MFFrameSourceTypes_Color: MFFrameSourceTypes = MFFrameSourceTypes(1i32);
pub const MFFrameSourceTypes_Infrared: MFFrameSourceTypes = MFFrameSourceTypes(2i32);
pub const MFFrameSourceTypes_Depth: MFFrameSourceTypes = MFFrameSourceTypes(4i32);
pub const MFFrameSourceTypes_Image: MFFrameSourceTypes = MFFrameSourceTypes(8i32);
pub const MFFrameSourceTypes_Custom: MFFrameSourceTypes = MFFrameSourceTypes(128i32);
impl ::core::convert::From<i32> for MFFrameSourceTypes {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFFrameSourceTypes {
type Abi = Self;
}
#[inline]
pub unsafe fn MFGetAttributesAsBlob<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(pattributes: Param0, pbuf: *mut u8, cbbufsize: u32) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFGetAttributesAsBlob(pattributes: ::windows::core::RawPtr, pbuf: *mut u8, cbbufsize: u32) -> ::windows::core::HRESULT;
}
MFGetAttributesAsBlob(pattributes.into_param().abi(), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFGetAttributesAsBlobSize<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(pattributes: Param0) -> ::windows::core::Result<u32> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFGetAttributesAsBlobSize(pattributes: ::windows::core::RawPtr, pcbbufsize: *mut u32) -> ::windows::core::HRESULT;
}
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFGetAttributesAsBlobSize(pattributes.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFGetContentProtectionSystemCLSID(guidprotectionsystemid: *const ::windows::core::GUID) -> ::windows::core::Result<::windows::core::GUID> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFGetContentProtectionSystemCLSID(guidprotectionsystemid: *const ::windows::core::GUID, pclsid: *mut ::windows::core::GUID) -> ::windows::core::HRESULT;
}
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFGetContentProtectionSystemCLSID(::core::mem::transmute(guidprotectionsystemid), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFGetLocalId(verifier: *const u8, size: u32) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFGetLocalId(verifier: *const u8, size: u32, id: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT;
}
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFGetLocalId(::core::mem::transmute(verifier), ::core::mem::transmute(size), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFGetMFTMerit<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(pmft: Param0, cbverifier: u32, verifier: *const u8, merit: *mut u32) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFGetMFTMerit(pmft: ::windows::core::RawPtr, cbverifier: u32, verifier: *const u8, merit: *mut u32) -> ::windows::core::HRESULT;
}
MFGetMFTMerit(pmft.into_param().abi(), ::core::mem::transmute(cbverifier), ::core::mem::transmute(verifier), ::core::mem::transmute(merit)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFGetPlaneSize(format: u32, dwwidth: u32, dwheight: u32) -> ::windows::core::Result<u32> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFGetPlaneSize(format: u32, dwwidth: u32, dwheight: u32, pdwplanesize: *mut u32) -> ::windows::core::HRESULT;
}
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFGetPlaneSize(::core::mem::transmute(format), ::core::mem::transmute(dwwidth), ::core::mem::transmute(dwheight), &mut result__).from_abi::<u32>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFGetPluginControl() -> ::windows::core::Result<IMFPluginControl> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFGetPluginControl(ppplugincontrol: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFPluginControl as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFGetPluginControl(&mut result__).from_abi::<IMFPluginControl>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFGetService<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(punkobject: Param0, guidservice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFGetService(punkobject: ::windows::core::RawPtr, guidservice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT;
}
MFGetService(punkobject.into_param().abi(), ::core::mem::transmute(guidservice), ::core::mem::transmute(riid), ::core::mem::transmute(ppvobject)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFGetStrideForBitmapInfoHeader(format: u32, dwwidth: u32) -> ::windows::core::Result<i32> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFGetStrideForBitmapInfoHeader(format: u32, dwwidth: u32, pstride: *mut i32) -> ::windows::core::HRESULT;
}
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFGetStrideForBitmapInfoHeader(::core::mem::transmute(format), ::core::mem::transmute(dwwidth), &mut result__).from_abi::<i32>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
#[inline]
pub unsafe fn MFGetSupportedMimeTypes() -> ::windows::core::Result<super::super::System::Com::StructuredStorage::PROPVARIANT> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFGetSupportedMimeTypes(ppropvarmimetypearray: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT;
}
let mut result__: <super::super::System::Com::StructuredStorage::PROPVARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFGetSupportedMimeTypes(&mut result__).from_abi::<super::super::System::Com::StructuredStorage::PROPVARIANT>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage"))]
#[inline]
pub unsafe fn MFGetSupportedSchemes() -> ::windows::core::Result<super::super::System::Com::StructuredStorage::PROPVARIANT> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFGetSupportedSchemes(ppropvarschemearray: *mut ::core::mem::ManuallyDrop<super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows::core::HRESULT;
}
let mut result__: <super::super::System::Com::StructuredStorage::PROPVARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFGetSupportedSchemes(&mut result__).from_abi::<super::super::System::Com::StructuredStorage::PROPVARIANT>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFGetSystemId() -> ::windows::core::Result<IMFSystemId> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFGetSystemId(ppid: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFSystemId as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFGetSystemId(&mut result__).from_abi::<IMFSystemId>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFGetSystemTime() -> i64 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFGetSystemTime() -> i64;
}
::core::mem::transmute(MFGetSystemTime())
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFGetTimerPeriodicity() -> ::windows::core::Result<u32> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFGetTimerPeriodicity(periodicity: *mut u32) -> ::windows::core::HRESULT;
}
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFGetTimerPeriodicity(&mut result__).from_abi::<u32>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFGetTopoNodeCurrentType<'a, Param0: ::windows::core::IntoParam<'a, IMFTopologyNode>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(pnode: Param0, dwstreamindex: u32, foutput: Param2) -> ::windows::core::Result<IMFMediaType> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFGetTopoNodeCurrentType(pnode: ::windows::core::RawPtr, dwstreamindex: u32, foutput: super::super::Foundation::BOOL, pptype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFGetTopoNodeCurrentType(pnode.into_param().abi(), ::core::mem::transmute(dwstreamindex), foutput.into_param().abi(), &mut result__).from_abi::<IMFMediaType>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFGetUncompressedVideoFormat(pvideoformat: *const MFVIDEOFORMAT) -> u32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFGetUncompressedVideoFormat(pvideoformat: *const MFVIDEOFORMAT) -> u32;
}
::core::mem::transmute(MFGetUncompressedVideoFormat(::core::mem::transmute(pvideoformat)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFGetWorkQueueMMCSSClass(dwworkqueueid: u32, pwszclass: super::super::Foundation::PWSTR, pcchclass: *mut u32) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFGetWorkQueueMMCSSClass(dwworkqueueid: u32, pwszclass: super::super::Foundation::PWSTR, pcchclass: *mut u32) -> ::windows::core::HRESULT;
}
MFGetWorkQueueMMCSSClass(::core::mem::transmute(dwworkqueueid), ::core::mem::transmute(pwszclass), ::core::mem::transmute(pcchclass)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFGetWorkQueueMMCSSPriority(dwworkqueueid: u32) -> ::windows::core::Result<i32> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFGetWorkQueueMMCSSPriority(dwworkqueueid: u32, lpriority: *mut i32) -> ::windows::core::HRESULT;
}
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFGetWorkQueueMMCSSPriority(::core::mem::transmute(dwworkqueueid), &mut result__).from_abi::<i32>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFGetWorkQueueMMCSSTaskId(dwworkqueueid: u32) -> ::windows::core::Result<u32> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFGetWorkQueueMMCSSTaskId(dwworkqueueid: u32, pdwtaskid: *mut u32) -> ::windows::core::HRESULT;
}
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFGetWorkQueueMMCSSTaskId(::core::mem::transmute(dwworkqueueid), &mut result__).from_abi::<u32>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFHeapAlloc<'a, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PSTR>>(nsize: usize, dwflags: u32, pszfile: Param2, line: i32, eat: EAllocationType) -> *mut ::core::ffi::c_void {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFHeapAlloc(nsize: usize, dwflags: u32, pszfile: super::super::Foundation::PSTR, line: i32, eat: EAllocationType) -> *mut ::core::ffi::c_void;
}
::core::mem::transmute(MFHeapAlloc(::core::mem::transmute(nsize), ::core::mem::transmute(dwflags), pszfile.into_param().abi(), ::core::mem::transmute(line), ::core::mem::transmute(eat)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFHeapFree(pv: *mut ::core::ffi::c_void) {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFHeapFree(pv: *mut ::core::ffi::c_void);
}
::core::mem::transmute(MFHeapFree(::core::mem::transmute(pv)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFINPUTTRUSTAUTHORITY_ACCESS_ACTION {
pub Action: MFPOLICYMANAGER_ACTION,
pub pbTicket: *mut u8,
pub cbTicket: u32,
}
impl MFINPUTTRUSTAUTHORITY_ACCESS_ACTION {}
impl ::core::default::Default for MFINPUTTRUSTAUTHORITY_ACCESS_ACTION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFINPUTTRUSTAUTHORITY_ACCESS_ACTION {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFINPUTTRUSTAUTHORITY_ACCESS_ACTION").field("Action", &self.Action).field("pbTicket", &self.pbTicket).field("cbTicket", &self.cbTicket).finish()
}
}
impl ::core::cmp::PartialEq for MFINPUTTRUSTAUTHORITY_ACCESS_ACTION {
fn eq(&self, other: &Self) -> bool {
self.Action == other.Action && self.pbTicket == other.pbTicket && self.cbTicket == other.cbTicket
}
}
impl ::core::cmp::Eq for MFINPUTTRUSTAUTHORITY_ACCESS_ACTION {}
unsafe impl ::windows::core::Abi for MFINPUTTRUSTAUTHORITY_ACCESS_ACTION {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFINPUTTRUSTAUTHORITY_ACCESS_PARAMS {
pub dwSize: u32,
pub dwVer: u32,
pub cbSignatureOffset: u32,
pub cbSignatureSize: u32,
pub cbExtensionOffset: u32,
pub cbExtensionSize: u32,
pub cActions: u32,
pub rgOutputActions: [MFINPUTTRUSTAUTHORITY_ACCESS_ACTION; 1],
}
impl MFINPUTTRUSTAUTHORITY_ACCESS_PARAMS {}
impl ::core::default::Default for MFINPUTTRUSTAUTHORITY_ACCESS_PARAMS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFINPUTTRUSTAUTHORITY_ACCESS_PARAMS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFINPUTTRUSTAUTHORITY_ACCESS_PARAMS")
.field("dwSize", &self.dwSize)
.field("dwVer", &self.dwVer)
.field("cbSignatureOffset", &self.cbSignatureOffset)
.field("cbSignatureSize", &self.cbSignatureSize)
.field("cbExtensionOffset", &self.cbExtensionOffset)
.field("cbExtensionSize", &self.cbExtensionSize)
.field("cActions", &self.cActions)
.field("rgOutputActions", &self.rgOutputActions)
.finish()
}
}
impl ::core::cmp::PartialEq for MFINPUTTRUSTAUTHORITY_ACCESS_PARAMS {
fn eq(&self, other: &Self) -> bool {
self.dwSize == other.dwSize && self.dwVer == other.dwVer && self.cbSignatureOffset == other.cbSignatureOffset && self.cbSignatureSize == other.cbSignatureSize && self.cbExtensionOffset == other.cbExtensionOffset && self.cbExtensionSize == other.cbExtensionSize && self.cActions == other.cActions && self.rgOutputActions == other.rgOutputActions
}
}
impl ::core::cmp::Eq for MFINPUTTRUSTAUTHORITY_ACCESS_PARAMS {}
unsafe impl ::windows::core::Abi for MFINPUTTRUSTAUTHORITY_ACCESS_PARAMS {
type Abi = Self;
}
pub const MFImageFormat_JPEG: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x19e4a5aa_5662_4fc5_a0c0_1758028e1057);
pub const MFImageFormat_RGB32: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000016_0000_0010_8000_00aa00389b71);
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Media_DirectShow"))]
#[inline]
pub unsafe fn MFInitAMMediaTypeFromMFMediaType<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaType>, Param1: ::windows::core::IntoParam<'a, ::windows::core::GUID>>(pmftype: Param0, guidformatblocktype: Param1, pamtype: *mut super::DirectShow::AM_MEDIA_TYPE) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFInitAMMediaTypeFromMFMediaType(pmftype: ::windows::core::RawPtr, guidformatblocktype: ::windows::core::GUID, pamtype: *mut ::core::mem::ManuallyDrop<super::DirectShow::AM_MEDIA_TYPE>) -> ::windows::core::HRESULT;
}
MFInitAMMediaTypeFromMFMediaType(pmftype.into_param().abi(), guidformatblocktype.into_param().abi(), ::core::mem::transmute(pamtype)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFInitAttributesFromBlob<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>>(pattributes: Param0, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFInitAttributesFromBlob(pattributes: ::windows::core::RawPtr, pbuf: *const u8, cbbufsize: u32) -> ::windows::core::HRESULT;
}
MFInitAttributesFromBlob(pattributes.into_param().abi(), ::core::mem::transmute(pbuf), ::core::mem::transmute(cbbufsize)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Media_DirectShow"))]
#[inline]
pub unsafe fn MFInitMediaTypeFromAMMediaType<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaType>>(pmftype: Param0, pamtype: *const super::DirectShow::AM_MEDIA_TYPE) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFInitMediaTypeFromAMMediaType(pmftype: ::windows::core::RawPtr, pamtype: *const ::core::mem::ManuallyDrop<super::DirectShow::AM_MEDIA_TYPE>) -> ::windows::core::HRESULT;
}
MFInitMediaTypeFromAMMediaType(pmftype.into_param().abi(), ::core::mem::transmute(pamtype)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFInitMediaTypeFromMFVideoFormat<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaType>>(pmftype: Param0, pmfvf: *const MFVIDEOFORMAT, cbbufsize: u32) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFInitMediaTypeFromMFVideoFormat(pmftype: ::windows::core::RawPtr, pmfvf: *const MFVIDEOFORMAT, cbbufsize: u32) -> ::windows::core::HRESULT;
}
MFInitMediaTypeFromMFVideoFormat(pmftype.into_param().abi(), ::core::mem::transmute(pmfvf), ::core::mem::transmute(cbbufsize)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Media_DirectShow"))]
#[inline]
pub unsafe fn MFInitMediaTypeFromMPEG1VideoInfo<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaType>>(pmftype: Param0, pmp1vi: *const super::DirectShow::MPEG1VIDEOINFO, cbbufsize: u32, psubtype: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFInitMediaTypeFromMPEG1VideoInfo(pmftype: ::windows::core::RawPtr, pmp1vi: *const super::DirectShow::MPEG1VIDEOINFO, cbbufsize: u32, psubtype: *const ::windows::core::GUID) -> ::windows::core::HRESULT;
}
MFInitMediaTypeFromMPEG1VideoInfo(pmftype.into_param().abi(), ::core::mem::transmute(pmp1vi), ::core::mem::transmute(cbbufsize), ::core::mem::transmute(psubtype)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Media_DirectShow"))]
#[inline]
pub unsafe fn MFInitMediaTypeFromMPEG2VideoInfo<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaType>>(pmftype: Param0, pmp2vi: *const super::DirectShow::MPEG2VIDEOINFO, cbbufsize: u32, psubtype: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFInitMediaTypeFromMPEG2VideoInfo(pmftype: ::windows::core::RawPtr, pmp2vi: *const super::DirectShow::MPEG2VIDEOINFO, cbbufsize: u32, psubtype: *const ::windows::core::GUID) -> ::windows::core::HRESULT;
}
MFInitMediaTypeFromMPEG2VideoInfo(pmftype.into_param().abi(), ::core::mem::transmute(pmp2vi), ::core::mem::transmute(cbbufsize), ::core::mem::transmute(psubtype)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Media_DirectShow"))]
#[inline]
pub unsafe fn MFInitMediaTypeFromVideoInfoHeader<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaType>>(pmftype: Param0, pvih: *const super::DirectShow::VIDEOINFOHEADER, cbbufsize: u32, psubtype: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFInitMediaTypeFromVideoInfoHeader(pmftype: ::windows::core::RawPtr, pvih: *const super::DirectShow::VIDEOINFOHEADER, cbbufsize: u32, psubtype: *const ::windows::core::GUID) -> ::windows::core::HRESULT;
}
MFInitMediaTypeFromVideoInfoHeader(pmftype.into_param().abi(), ::core::mem::transmute(pvih), ::core::mem::transmute(cbbufsize), ::core::mem::transmute(psubtype)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Media_DirectShow"))]
#[inline]
pub unsafe fn MFInitMediaTypeFromVideoInfoHeader2<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaType>>(pmftype: Param0, pvih2: *const super::DirectShow::VIDEOINFOHEADER2, cbbufsize: u32, psubtype: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFInitMediaTypeFromVideoInfoHeader2(pmftype: ::windows::core::RawPtr, pvih2: *const super::DirectShow::VIDEOINFOHEADER2, cbbufsize: u32, psubtype: *const ::windows::core::GUID) -> ::windows::core::HRESULT;
}
MFInitMediaTypeFromVideoInfoHeader2(pmftype.into_param().abi(), ::core::mem::transmute(pvih2), ::core::mem::transmute(cbbufsize), ::core::mem::transmute(psubtype)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Media_Audio")]
#[inline]
pub unsafe fn MFInitMediaTypeFromWaveFormatEx<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaType>>(pmftype: Param0, pwaveformat: *const super::Audio::WAVEFORMATEX, cbbufsize: u32) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFInitMediaTypeFromWaveFormatEx(pmftype: ::windows::core::RawPtr, pwaveformat: *const super::Audio::WAVEFORMATEX, cbbufsize: u32) -> ::windows::core::HRESULT;
}
MFInitMediaTypeFromWaveFormatEx(pmftype.into_param().abi(), ::core::mem::transmute(pwaveformat), ::core::mem::transmute(cbbufsize)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFInitVideoFormat(pvideoformat: *const MFVIDEOFORMAT, r#type: MFStandardVideoFormat) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFInitVideoFormat(pvideoformat: *const MFVIDEOFORMAT, r#type: MFStandardVideoFormat) -> ::windows::core::HRESULT;
}
MFInitVideoFormat(::core::mem::transmute(pvideoformat), ::core::mem::transmute(r#type)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFInitVideoFormat_RGB(pvideoformat: *const MFVIDEOFORMAT, dwwidth: u32, dwheight: u32, d3dfmt: u32) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFInitVideoFormat_RGB(pvideoformat: *const MFVIDEOFORMAT, dwwidth: u32, dwheight: u32, d3dfmt: u32) -> ::windows::core::HRESULT;
}
MFInitVideoFormat_RGB(::core::mem::transmute(pvideoformat), ::core::mem::transmute(dwwidth), ::core::mem::transmute(dwheight), ::core::mem::transmute(d3dfmt)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFInvokeCallback<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(pasyncresult: Param0) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFInvokeCallback(pasyncresult: ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
MFInvokeCallback(pasyncresult.into_param().abi()).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFIsContentProtectionDeviceSupported(protectionsystemid: *const ::windows::core::GUID) -> ::windows::core::Result<super::super::Foundation::BOOL> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFIsContentProtectionDeviceSupported(protectionsystemid: *const ::windows::core::GUID, issupported: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT;
}
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFIsContentProtectionDeviceSupported(::core::mem::transmute(protectionsystemid), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFIsFormatYUV(format: u32) -> super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFIsFormatYUV(format: u32) -> super::super::Foundation::BOOL;
}
::core::mem::transmute(MFIsFormatYUV(::core::mem::transmute(format)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFIsVirtualCameraTypeSupported(r#type: __MIDL___MIDL_itf_mfvirtualcamera_0000_0000_0001) -> ::windows::core::Result<super::super::Foundation::BOOL> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFIsVirtualCameraTypeSupported(r#type: __MIDL___MIDL_itf_mfvirtualcamera_0000_0000_0001, supported: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT;
}
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFIsVirtualCameraTypeSupported(::core::mem::transmute(r#type), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFLoadSignedLibrary<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(pszname: Param0) -> ::windows::core::Result<IMFSignedLibrary> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFLoadSignedLibrary(pszname: super::super::Foundation::PWSTR, pplib: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFSignedLibrary as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFLoadSignedLibrary(pszname.into_param().abi(), &mut result__).from_abi::<IMFSignedLibrary>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFLockDXGIDeviceManager(presettoken: *mut u32, ppmanager: *mut ::core::option::Option<IMFDXGIDeviceManager>) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFLockDXGIDeviceManager(presettoken: *mut u32, ppmanager: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
MFLockDXGIDeviceManager(::core::mem::transmute(presettoken), ::core::mem::transmute(ppmanager)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFLockPlatform() -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFLockPlatform() -> ::windows::core::HRESULT;
}
MFLockPlatform().ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFLockSharedWorkQueue<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(wszclass: Param0, basepriority: i32, pdwtaskid: *mut u32, pid: *mut u32) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFLockSharedWorkQueue(wszclass: super::super::Foundation::PWSTR, basepriority: i32, pdwtaskid: *mut u32, pid: *mut u32) -> ::windows::core::HRESULT;
}
MFLockSharedWorkQueue(wszclass.into_param().abi(), ::core::mem::transmute(basepriority), ::core::mem::transmute(pdwtaskid), ::core::mem::transmute(pid)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFLockWorkQueue(dwworkqueue: u32) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFLockWorkQueue(dwworkqueue: u32) -> ::windows::core::HRESULT;
}
MFLockWorkQueue(::core::mem::transmute(dwworkqueue)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFMEDIASOURCE_CHARACTERISTICS(pub i32);
pub const MFMEDIASOURCE_IS_LIVE: MFMEDIASOURCE_CHARACTERISTICS = MFMEDIASOURCE_CHARACTERISTICS(1i32);
pub const MFMEDIASOURCE_CAN_SEEK: MFMEDIASOURCE_CHARACTERISTICS = MFMEDIASOURCE_CHARACTERISTICS(2i32);
pub const MFMEDIASOURCE_CAN_PAUSE: MFMEDIASOURCE_CHARACTERISTICS = MFMEDIASOURCE_CHARACTERISTICS(4i32);
pub const MFMEDIASOURCE_HAS_SLOW_SEEK: MFMEDIASOURCE_CHARACTERISTICS = MFMEDIASOURCE_CHARACTERISTICS(8i32);
pub const MFMEDIASOURCE_HAS_MULTIPLE_PRESENTATIONS: MFMEDIASOURCE_CHARACTERISTICS = MFMEDIASOURCE_CHARACTERISTICS(16i32);
pub const MFMEDIASOURCE_CAN_SKIPFORWARD: MFMEDIASOURCE_CHARACTERISTICS = MFMEDIASOURCE_CHARACTERISTICS(32i32);
pub const MFMEDIASOURCE_CAN_SKIPBACKWARD: MFMEDIASOURCE_CHARACTERISTICS = MFMEDIASOURCE_CHARACTERISTICS(64i32);
pub const MFMEDIASOURCE_DOES_NOT_USE_NETWORK: MFMEDIASOURCE_CHARACTERISTICS = MFMEDIASOURCE_CHARACTERISTICS(128i32);
impl ::core::convert::From<i32> for MFMEDIASOURCE_CHARACTERISTICS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFMEDIASOURCE_CHARACTERISTICS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct MFMPEG2DLNASINKSTATS {
pub cBytesWritten: u64,
pub fPAL: super::super::Foundation::BOOL,
pub fccVideo: u32,
pub dwVideoWidth: u32,
pub dwVideoHeight: u32,
pub cVideoFramesReceived: u64,
pub cVideoFramesEncoded: u64,
pub cVideoFramesSkipped: u64,
pub cBlackVideoFramesEncoded: u64,
pub cVideoFramesDuplicated: u64,
pub cAudioSamplesPerSec: u32,
pub cAudioChannels: u32,
pub cAudioBytesReceived: u64,
pub cAudioFramesEncoded: u64,
}
#[cfg(feature = "Win32_Foundation")]
impl MFMPEG2DLNASINKSTATS {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for MFMPEG2DLNASINKSTATS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for MFMPEG2DLNASINKSTATS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFMPEG2DLNASINKSTATS")
.field("cBytesWritten", &self.cBytesWritten)
.field("fPAL", &self.fPAL)
.field("fccVideo", &self.fccVideo)
.field("dwVideoWidth", &self.dwVideoWidth)
.field("dwVideoHeight", &self.dwVideoHeight)
.field("cVideoFramesReceived", &self.cVideoFramesReceived)
.field("cVideoFramesEncoded", &self.cVideoFramesEncoded)
.field("cVideoFramesSkipped", &self.cVideoFramesSkipped)
.field("cBlackVideoFramesEncoded", &self.cBlackVideoFramesEncoded)
.field("cVideoFramesDuplicated", &self.cVideoFramesDuplicated)
.field("cAudioSamplesPerSec", &self.cAudioSamplesPerSec)
.field("cAudioChannels", &self.cAudioChannels)
.field("cAudioBytesReceived", &self.cAudioBytesReceived)
.field("cAudioFramesEncoded", &self.cAudioFramesEncoded)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for MFMPEG2DLNASINKSTATS {
fn eq(&self, other: &Self) -> bool {
self.cBytesWritten == other.cBytesWritten
&& self.fPAL == other.fPAL
&& self.fccVideo == other.fccVideo
&& self.dwVideoWidth == other.dwVideoWidth
&& self.dwVideoHeight == other.dwVideoHeight
&& self.cVideoFramesReceived == other.cVideoFramesReceived
&& self.cVideoFramesEncoded == other.cVideoFramesEncoded
&& self.cVideoFramesSkipped == other.cVideoFramesSkipped
&& self.cBlackVideoFramesEncoded == other.cBlackVideoFramesEncoded
&& self.cVideoFramesDuplicated == other.cVideoFramesDuplicated
&& self.cAudioSamplesPerSec == other.cAudioSamplesPerSec
&& self.cAudioChannels == other.cAudioChannels
&& self.cAudioBytesReceived == other.cAudioBytesReceived
&& self.cAudioFramesEncoded == other.cAudioFramesEncoded
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for MFMPEG2DLNASINKSTATS {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for MFMPEG2DLNASINKSTATS {
type Abi = Self;
}
pub const MFMPEG4Format_Base: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000000_767a_494d_b478_f29d25dc9037);
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
#[inline]
pub unsafe fn MFMapDX9FormatToDXGIFormat(dx9: u32) -> super::super::Graphics::Dxgi::Common::DXGI_FORMAT {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFMapDX9FormatToDXGIFormat(dx9: u32) -> super::super::Graphics::Dxgi::Common::DXGI_FORMAT;
}
::core::mem::transmute(MFMapDX9FormatToDXGIFormat(::core::mem::transmute(dx9)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Graphics_Dxgi_Common")]
#[inline]
pub unsafe fn MFMapDXGIFormatToDX9Format(dx11: super::super::Graphics::Dxgi::Common::DXGI_FORMAT) -> u32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFMapDXGIFormatToDX9Format(dx11: super::super::Graphics::Dxgi::Common::DXGI_FORMAT) -> u32;
}
::core::mem::transmute(MFMapDXGIFormatToDX9Format(::core::mem::transmute(dx11)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFMediaKeyStatus {
pub pbKeyId: *mut u8,
pub cbKeyId: u32,
pub eMediaKeyStatus: MF_MEDIAKEY_STATUS,
}
impl MFMediaKeyStatus {}
impl ::core::default::Default for MFMediaKeyStatus {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFMediaKeyStatus {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFMediaKeyStatus").field("pbKeyId", &self.pbKeyId).field("cbKeyId", &self.cbKeyId).field("eMediaKeyStatus", &self.eMediaKeyStatus).finish()
}
}
impl ::core::cmp::PartialEq for MFMediaKeyStatus {
fn eq(&self, other: &Self) -> bool {
self.pbKeyId == other.pbKeyId && self.cbKeyId == other.cbKeyId && self.eMediaKeyStatus == other.eMediaKeyStatus
}
}
impl ::core::cmp::Eq for MFMediaKeyStatus {}
unsafe impl ::windows::core::Abi for MFMediaKeyStatus {
type Abi = Self;
}
pub const MFMediaType_Audio: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x73647561_0000_0010_8000_00aa00389b71);
pub const MFMediaType_Binary: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x72178c25_e45b_11d5_bc2a_00b0d0f3f4ab);
pub const MFMediaType_Default: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x81a412e6_8103_4b06_857f_1862781024ac);
pub const MFMediaType_FileTransfer: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x72178c26_e45b_11d5_bc2a_00b0d0f3f4ab);
pub const MFMediaType_HTML: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x72178c24_e45b_11d5_bc2a_00b0d0f3f4ab);
pub const MFMediaType_Image: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x72178c23_e45b_11d5_bc2a_00b0d0f3f4ab);
pub const MFMediaType_Metadata: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2c8fa20c_82bb_4782_90a0_98a2a5bd8ef8);
pub const MFMediaType_MultiplexedFrames: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6ea542b0_281f_4231_a464_fe2f5022501c);
pub const MFMediaType_Perception: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x597ff6f9_6ea2_4670_85b4_ea84073fe940);
pub const MFMediaType_Protected: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7b4b6fe6_9d04_4494_be14_7e0bd076c8e4);
pub const MFMediaType_SAMI: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe69669a0_3dcd_40cb_9e2e_3708387c0616);
pub const MFMediaType_Script: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x72178c22_e45b_11d5_bc2a_00b0d0f3f4ab);
pub const MFMediaType_Stream: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe436eb83_524f_11ce_9f53_0020af0ba770);
pub const MFMediaType_Subtitle: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa6d13581_ed50_4e65_ae08_26065576aacc);
pub const MFMediaType_Video: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x73646976_0000_0010_8000_00aa00389b71);
pub const MFNETSOURCE_ACCELERATEDSTREAMINGDURATION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f277_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_AUTORECONNECTLIMIT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f27a_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_AUTORECONNECTPROGRESS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f282_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_BROWSERUSERAGENT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f28b_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_BROWSERWEBPAGE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f28c_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_BUFFERINGTIME: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f276_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_CACHEENABLED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f279_0505_4c5d_ae71_0a556344efa1);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFNETSOURCE_CACHE_STATE(pub i32);
pub const MFNETSOURCE_CACHE_UNAVAILABLE: MFNETSOURCE_CACHE_STATE = MFNETSOURCE_CACHE_STATE(0i32);
pub const MFNETSOURCE_CACHE_ACTIVE_WRITING: MFNETSOURCE_CACHE_STATE = MFNETSOURCE_CACHE_STATE(1i32);
pub const MFNETSOURCE_CACHE_ACTIVE_COMPLETE: MFNETSOURCE_CACHE_STATE = MFNETSOURCE_CACHE_STATE(2i32);
impl ::core::convert::From<i32> for MFNETSOURCE_CACHE_STATE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFNETSOURCE_CACHE_STATE {
type Abi = Self;
}
pub const MFNETSOURCE_CLIENTGUID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x60a2c4a6_f197_4c14_a5bf_88830d2458af);
pub const MFNETSOURCE_CONNECTIONBANDWIDTH: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f278_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_CREDENTIAL_MANAGER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f280_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_CROSS_ORIGIN_SUPPORT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9842207c_b02c_4271_a2fc_72e49308e5c2);
pub const MFNETSOURCE_DRMNET_LICENSE_REPRESENTATION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x47eae1bd_bdfe_42e2_82f3_54a48c17962d);
pub const MFNETSOURCE_ENABLE_DOWNLOAD: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f29d_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_ENABLE_HTTP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f299_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_ENABLE_MSB: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f296_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_ENABLE_PRIVATEMODE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x824779d8_f18b_4405_8cf1_464fb5aa8f71);
pub const MFNETSOURCE_ENABLE_RTSP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f298_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_ENABLE_STREAMING: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f29c_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_ENABLE_TCP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f295_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_ENABLE_UDP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f294_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_FRIENDLYNAME: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5b2a7757_bc6b_447e_aa06_0dda1c646e2f);
pub const MFNETSOURCE_HOSTEXE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f28f_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_HOSTVERSION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f291_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_HTTP_DOWNLOAD_SESSION_PROVIDER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7d55081e_307d_4d6d_a663_a93be97c4b5c);
pub const MFNETSOURCE_LOGPARAMS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x64936ae8_9418_453a_8cda_3e0a668b353b);
pub const MFNETSOURCE_LOGURL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f293_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_MAXBUFFERTIMEMS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x408b24e6_4038_4401_b5b2_fe701a9ebf10);
pub const MFNETSOURCE_MAXUDPACCELERATEDSTREAMINGDURATION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4aab2879_bbe1_4994_9ff0_5495bd250129);
pub const MFNETSOURCE_PEERMANAGER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x48b29adb_febf_45ee_a9bf_efb81c492efc);
pub const MFNETSOURCE_PLAYERID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f28e_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_PLAYERUSERAGENT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f292_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_PLAYERVERSION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f28d_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_PPBANDWIDTH: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f281_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_PREVIEWMODEENABLED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f27f_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_PROTOCOL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f27d_0505_4c5d_ae71_0a556344efa1);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFNETSOURCE_PROTOCOL_TYPE(pub i32);
pub const MFNETSOURCE_UNDEFINED: MFNETSOURCE_PROTOCOL_TYPE = MFNETSOURCE_PROTOCOL_TYPE(0i32);
pub const MFNETSOURCE_HTTP: MFNETSOURCE_PROTOCOL_TYPE = MFNETSOURCE_PROTOCOL_TYPE(1i32);
pub const MFNETSOURCE_RTSP: MFNETSOURCE_PROTOCOL_TYPE = MFNETSOURCE_PROTOCOL_TYPE(2i32);
pub const MFNETSOURCE_FILE: MFNETSOURCE_PROTOCOL_TYPE = MFNETSOURCE_PROTOCOL_TYPE(3i32);
pub const MFNETSOURCE_MULTICAST: MFNETSOURCE_PROTOCOL_TYPE = MFNETSOURCE_PROTOCOL_TYPE(4i32);
impl ::core::convert::From<i32> for MFNETSOURCE_PROTOCOL_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFNETSOURCE_PROTOCOL_TYPE {
type Abi = Self;
}
pub const MFNETSOURCE_PROXYBYPASSFORLOCAL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f286_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_PROXYEXCEPTIONLIST: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f285_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_PROXYHOSTNAME: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f284_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_PROXYINFO: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f29b_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_PROXYLOCATORFACTORY: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f283_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_PROXYPORT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f288_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_PROXYRERUNAUTODETECTION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f289_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_PROXYSETTINGS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f287_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_RESENDSENABLED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f27b_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_RESOURCE_FILTER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x815d0ff6_265a_4477_9e46_7b80ad80b5fb);
pub const MFNETSOURCE_SSLCERTIFICATE_MANAGER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x55e6cb27_e69b_4267_940c_2d7ec5bb8a0f);
pub const MFNETSOURCE_STATISTICS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f274_0505_4c5d_ae71_0a556344efa1);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFNETSOURCE_STATISTICS_IDS(pub i32);
pub const MFNETSOURCE_RECVPACKETS_ID: MFNETSOURCE_STATISTICS_IDS = MFNETSOURCE_STATISTICS_IDS(0i32);
pub const MFNETSOURCE_LOSTPACKETS_ID: MFNETSOURCE_STATISTICS_IDS = MFNETSOURCE_STATISTICS_IDS(1i32);
pub const MFNETSOURCE_RESENDSREQUESTED_ID: MFNETSOURCE_STATISTICS_IDS = MFNETSOURCE_STATISTICS_IDS(2i32);
pub const MFNETSOURCE_RESENDSRECEIVED_ID: MFNETSOURCE_STATISTICS_IDS = MFNETSOURCE_STATISTICS_IDS(3i32);
pub const MFNETSOURCE_RECOVEREDBYECCPACKETS_ID: MFNETSOURCE_STATISTICS_IDS = MFNETSOURCE_STATISTICS_IDS(4i32);
pub const MFNETSOURCE_RECOVEREDBYRTXPACKETS_ID: MFNETSOURCE_STATISTICS_IDS = MFNETSOURCE_STATISTICS_IDS(5i32);
pub const MFNETSOURCE_OUTPACKETS_ID: MFNETSOURCE_STATISTICS_IDS = MFNETSOURCE_STATISTICS_IDS(6i32);
pub const MFNETSOURCE_RECVRATE_ID: MFNETSOURCE_STATISTICS_IDS = MFNETSOURCE_STATISTICS_IDS(7i32);
pub const MFNETSOURCE_AVGBANDWIDTHBPS_ID: MFNETSOURCE_STATISTICS_IDS = MFNETSOURCE_STATISTICS_IDS(8i32);
pub const MFNETSOURCE_BYTESRECEIVED_ID: MFNETSOURCE_STATISTICS_IDS = MFNETSOURCE_STATISTICS_IDS(9i32);
pub const MFNETSOURCE_PROTOCOL_ID: MFNETSOURCE_STATISTICS_IDS = MFNETSOURCE_STATISTICS_IDS(10i32);
pub const MFNETSOURCE_TRANSPORT_ID: MFNETSOURCE_STATISTICS_IDS = MFNETSOURCE_STATISTICS_IDS(11i32);
pub const MFNETSOURCE_CACHE_STATE_ID: MFNETSOURCE_STATISTICS_IDS = MFNETSOURCE_STATISTICS_IDS(12i32);
pub const MFNETSOURCE_LINKBANDWIDTH_ID: MFNETSOURCE_STATISTICS_IDS = MFNETSOURCE_STATISTICS_IDS(13i32);
pub const MFNETSOURCE_CONTENTBITRATE_ID: MFNETSOURCE_STATISTICS_IDS = MFNETSOURCE_STATISTICS_IDS(14i32);
pub const MFNETSOURCE_SPEEDFACTOR_ID: MFNETSOURCE_STATISTICS_IDS = MFNETSOURCE_STATISTICS_IDS(15i32);
pub const MFNETSOURCE_BUFFERSIZE_ID: MFNETSOURCE_STATISTICS_IDS = MFNETSOURCE_STATISTICS_IDS(16i32);
pub const MFNETSOURCE_BUFFERPROGRESS_ID: MFNETSOURCE_STATISTICS_IDS = MFNETSOURCE_STATISTICS_IDS(17i32);
pub const MFNETSOURCE_LASTBWSWITCHTS_ID: MFNETSOURCE_STATISTICS_IDS = MFNETSOURCE_STATISTICS_IDS(18i32);
pub const MFNETSOURCE_SEEKRANGESTART_ID: MFNETSOURCE_STATISTICS_IDS = MFNETSOURCE_STATISTICS_IDS(19i32);
pub const MFNETSOURCE_SEEKRANGEEND_ID: MFNETSOURCE_STATISTICS_IDS = MFNETSOURCE_STATISTICS_IDS(20i32);
pub const MFNETSOURCE_BUFFERINGCOUNT_ID: MFNETSOURCE_STATISTICS_IDS = MFNETSOURCE_STATISTICS_IDS(21i32);
pub const MFNETSOURCE_INCORRECTLYSIGNEDPACKETS_ID: MFNETSOURCE_STATISTICS_IDS = MFNETSOURCE_STATISTICS_IDS(22i32);
pub const MFNETSOURCE_SIGNEDSESSION_ID: MFNETSOURCE_STATISTICS_IDS = MFNETSOURCE_STATISTICS_IDS(23i32);
pub const MFNETSOURCE_MAXBITRATE_ID: MFNETSOURCE_STATISTICS_IDS = MFNETSOURCE_STATISTICS_IDS(24i32);
pub const MFNETSOURCE_RECEPTION_QUALITY_ID: MFNETSOURCE_STATISTICS_IDS = MFNETSOURCE_STATISTICS_IDS(25i32);
pub const MFNETSOURCE_RECOVEREDPACKETS_ID: MFNETSOURCE_STATISTICS_IDS = MFNETSOURCE_STATISTICS_IDS(26i32);
pub const MFNETSOURCE_VBR_ID: MFNETSOURCE_STATISTICS_IDS = MFNETSOURCE_STATISTICS_IDS(27i32);
pub const MFNETSOURCE_DOWNLOADPROGRESS_ID: MFNETSOURCE_STATISTICS_IDS = MFNETSOURCE_STATISTICS_IDS(28i32);
pub const MFNETSOURCE_UNPREDEFINEDPROTOCOLNAME_ID: MFNETSOURCE_STATISTICS_IDS = MFNETSOURCE_STATISTICS_IDS(29i32);
impl ::core::convert::From<i32> for MFNETSOURCE_STATISTICS_IDS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFNETSOURCE_STATISTICS_IDS {
type Abi = Self;
}
pub const MFNETSOURCE_STATISTICS_SERVICE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f275_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_STREAM_LANGUAGE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9ab44318_f7cd_4f2d_8d6d_fa35b492cecb);
pub const MFNETSOURCE_THINNINGENABLED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f27c_0505_4c5d_ae71_0a556344efa1);
pub const MFNETSOURCE_TRANSPORT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f27e_0505_4c5d_ae71_0a556344efa1);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFNETSOURCE_TRANSPORT_TYPE(pub i32);
pub const MFNETSOURCE_UDP: MFNETSOURCE_TRANSPORT_TYPE = MFNETSOURCE_TRANSPORT_TYPE(0i32);
pub const MFNETSOURCE_TCP: MFNETSOURCE_TRANSPORT_TYPE = MFNETSOURCE_TRANSPORT_TYPE(1i32);
impl ::core::convert::From<i32> for MFNETSOURCE_TRANSPORT_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFNETSOURCE_TRANSPORT_TYPE {
type Abi = Self;
}
pub const MFNETSOURCE_UDP_PORT_RANGE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cb1f29a_0505_4c5d_ae71_0a556344efa1);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFNET_PROXYSETTINGS(pub i32);
pub const MFNET_PROXYSETTING_NONE: MFNET_PROXYSETTINGS = MFNET_PROXYSETTINGS(0i32);
pub const MFNET_PROXYSETTING_MANUAL: MFNET_PROXYSETTINGS = MFNET_PROXYSETTINGS(1i32);
pub const MFNET_PROXYSETTING_AUTO: MFNET_PROXYSETTINGS = MFNET_PROXYSETTINGS(2i32);
pub const MFNET_PROXYSETTING_BROWSER: MFNET_PROXYSETTINGS = MFNET_PROXYSETTINGS(3i32);
impl ::core::convert::From<i32> for MFNET_PROXYSETTINGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFNET_PROXYSETTINGS {
type Abi = Self;
}
pub const MFNET_SAVEJOB_SERVICE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb85a587f_3d02_4e52_9565_55d3ec1e7ff7);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFNetAuthenticationFlags(pub i32);
pub const MFNET_AUTHENTICATION_PROXY: MFNetAuthenticationFlags = MFNetAuthenticationFlags(1i32);
pub const MFNET_AUTHENTICATION_CLEAR_TEXT: MFNetAuthenticationFlags = MFNetAuthenticationFlags(2i32);
pub const MFNET_AUTHENTICATION_LOGGED_ON_USER: MFNetAuthenticationFlags = MFNetAuthenticationFlags(4i32);
impl ::core::convert::From<i32> for MFNetAuthenticationFlags {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFNetAuthenticationFlags {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct MFNetCredentialManagerGetParam {
pub hrOp: ::windows::core::HRESULT,
pub fAllowLoggedOnUser: super::super::Foundation::BOOL,
pub fClearTextPackage: super::super::Foundation::BOOL,
pub pszUrl: super::super::Foundation::PWSTR,
pub pszSite: super::super::Foundation::PWSTR,
pub pszRealm: super::super::Foundation::PWSTR,
pub pszPackage: super::super::Foundation::PWSTR,
pub nRetries: i32,
}
#[cfg(feature = "Win32_Foundation")]
impl MFNetCredentialManagerGetParam {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for MFNetCredentialManagerGetParam {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for MFNetCredentialManagerGetParam {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFNetCredentialManagerGetParam")
.field("hrOp", &self.hrOp)
.field("fAllowLoggedOnUser", &self.fAllowLoggedOnUser)
.field("fClearTextPackage", &self.fClearTextPackage)
.field("pszUrl", &self.pszUrl)
.field("pszSite", &self.pszSite)
.field("pszRealm", &self.pszRealm)
.field("pszPackage", &self.pszPackage)
.field("nRetries", &self.nRetries)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for MFNetCredentialManagerGetParam {
fn eq(&self, other: &Self) -> bool {
self.hrOp == other.hrOp && self.fAllowLoggedOnUser == other.fAllowLoggedOnUser && self.fClearTextPackage == other.fClearTextPackage && self.pszUrl == other.pszUrl && self.pszSite == other.pszSite && self.pszRealm == other.pszRealm && self.pszPackage == other.pszPackage && self.nRetries == other.nRetries
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for MFNetCredentialManagerGetParam {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for MFNetCredentialManagerGetParam {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFNetCredentialOptions(pub i32);
pub const MFNET_CREDENTIAL_SAVE: MFNetCredentialOptions = MFNetCredentialOptions(1i32);
pub const MFNET_CREDENTIAL_DONT_CACHE: MFNetCredentialOptions = MFNetCredentialOptions(2i32);
pub const MFNET_CREDENTIAL_ALLOW_CLEAR_TEXT: MFNetCredentialOptions = MFNetCredentialOptions(4i32);
impl ::core::convert::From<i32> for MFNetCredentialOptions {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFNetCredentialOptions {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFNetCredentialRequirements(pub i32);
pub const REQUIRE_PROMPT: MFNetCredentialRequirements = MFNetCredentialRequirements(1i32);
pub const REQUIRE_SAVE_SELECTED: MFNetCredentialRequirements = MFNetCredentialRequirements(2i32);
impl ::core::convert::From<i32> for MFNetCredentialRequirements {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFNetCredentialRequirements {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFNominalRange(pub i32);
pub const MFNominalRange_Unknown: MFNominalRange = MFNominalRange(0i32);
pub const MFNominalRange_Normal: MFNominalRange = MFNominalRange(1i32);
pub const MFNominalRange_Wide: MFNominalRange = MFNominalRange(2i32);
pub const MFNominalRange_0_255: MFNominalRange = MFNominalRange(1i32);
pub const MFNominalRange_16_235: MFNominalRange = MFNominalRange(2i32);
pub const MFNominalRange_48_208: MFNominalRange = MFNominalRange(3i32);
pub const MFNominalRange_64_127: MFNominalRange = MFNominalRange(4i32);
pub const MFNominalRange_Last: MFNominalRange = MFNominalRange(5i32);
pub const MFNominalRange_ForceDWORD: MFNominalRange = MFNominalRange(2147483647i32);
impl ::core::convert::From<i32> for MFNominalRange {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFNominalRange {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFOffset {
pub fract: u16,
pub value: i16,
}
impl MFOffset {}
impl ::core::default::Default for MFOffset {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFOffset {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFOffset").field("fract", &self.fract).field("value", &self.value).finish()
}
}
impl ::core::cmp::PartialEq for MFOffset {
fn eq(&self, other: &Self) -> bool {
self.fract == other.fract && self.value == other.value
}
}
impl ::core::cmp::Eq for MFOffset {}
unsafe impl ::windows::core::Abi for MFOffset {
type Abi = Self;
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFPCreateMediaPlayer<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>, Param3: ::windows::core::IntoParam<'a, IMFPMediaPlayerCallback>, Param4: ::windows::core::IntoParam<'a, super::super::Foundation::HWND>>(pwszurl: Param0, fstartplayback: Param1, creationoptions: MFP_CREATION_OPTIONS, pcallback: Param3, hwnd: Param4) -> ::windows::core::Result<IMFPMediaPlayer> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFPCreateMediaPlayer(pwszurl: super::super::Foundation::PWSTR, fstartplayback: super::super::Foundation::BOOL, creationoptions: MFP_CREATION_OPTIONS, pcallback: ::windows::core::RawPtr, hwnd: super::super::Foundation::HWND, ppmediaplayer: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFPMediaPlayer as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFPCreateMediaPlayer(pwszurl.into_param().abi(), fstartplayback.into_param().abi(), ::core::mem::transmute(creationoptions), pcallback.into_param().abi(), hwnd.into_param().abi(), &mut result__).from_abi::<IMFPMediaPlayer>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
pub type MFPERIODICCALLBACK = unsafe extern "system" fn(pcontext: ::windows::core::RawPtr);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFPMPSESSION_CREATION_FLAGS(pub i32);
pub const MFPMPSESSION_UNPROTECTED_PROCESS: MFPMPSESSION_CREATION_FLAGS = MFPMPSESSION_CREATION_FLAGS(1i32);
pub const MFPMPSESSION_IN_PROCESS: MFPMPSESSION_CREATION_FLAGS = MFPMPSESSION_CREATION_FLAGS(2i32);
impl ::core::convert::From<i32> for MFPMPSESSION_CREATION_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFPMPSESSION_CREATION_FLAGS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFPOLICYMANAGER_ACTION(pub i32);
pub const PEACTION_NO: MFPOLICYMANAGER_ACTION = MFPOLICYMANAGER_ACTION(0i32);
pub const PEACTION_PLAY: MFPOLICYMANAGER_ACTION = MFPOLICYMANAGER_ACTION(1i32);
pub const PEACTION_COPY: MFPOLICYMANAGER_ACTION = MFPOLICYMANAGER_ACTION(2i32);
pub const PEACTION_EXPORT: MFPOLICYMANAGER_ACTION = MFPOLICYMANAGER_ACTION(3i32);
pub const PEACTION_EXTRACT: MFPOLICYMANAGER_ACTION = MFPOLICYMANAGER_ACTION(4i32);
pub const PEACTION_RESERVED1: MFPOLICYMANAGER_ACTION = MFPOLICYMANAGER_ACTION(5i32);
pub const PEACTION_RESERVED2: MFPOLICYMANAGER_ACTION = MFPOLICYMANAGER_ACTION(6i32);
pub const PEACTION_RESERVED3: MFPOLICYMANAGER_ACTION = MFPOLICYMANAGER_ACTION(7i32);
pub const PEACTION_LAST: MFPOLICYMANAGER_ACTION = MFPOLICYMANAGER_ACTION(7i32);
impl ::core::convert::From<i32> for MFPOLICYMANAGER_ACTION {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFPOLICYMANAGER_ACTION {
type Abi = Self;
}
pub const MFPROTECTIONATTRIBUTE_BEST_EFFORT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc8e06331_75f0_4ec1_8e77_17578f773b46);
pub const MFPROTECTIONATTRIBUTE_CONSTRICTVIDEO_IMAGESIZE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x008476fc_4b58_4d80_a790_e7297673161d);
pub const MFPROTECTIONATTRIBUTE_FAIL_OVER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8536abc5_38f1_4151_9cce_f55d941229ac);
pub const MFPROTECTIONATTRIBUTE_HDCP_SRM: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6f302107_3477_4468_8a08_eef9db10e20f);
pub const MFPROTECTION_ACP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc3fd11c6_f8b7_4d20_b008_1db17d61f2da);
pub const MFPROTECTION_CGMSA: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe57e69e9_226b_4d31_b4e3_d3db008736dd);
pub const MFPROTECTION_CONSTRICTAUDIO: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xffc99b44_df48_4e16_8e66_096892c1578a);
pub const MFPROTECTION_CONSTRICTVIDEO: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x193370ce_c5e4_4c3a_8a66_6959b4da4442);
pub const MFPROTECTION_CONSTRICTVIDEO_NOOPM: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa580e8cd_c247_4957_b983_3c2eebd1ff59);
pub const MFPROTECTION_DISABLE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8cc6d81b_fec6_4d8f_964b_cfba0b0dad0d);
pub const MFPROTECTION_DISABLE_SCREEN_SCRAPE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa21179a4_b7cd_40d8_9614_8ef2371ba78d);
pub const MFPROTECTION_FFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x462a56b2_2866_4bb6_980d_6d8d9edb1a8c);
pub const MFPROTECTION_GRAPHICS_TRANSFER_AES_ENCRYPTION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc873de64_d8a5_49e6_88bb_fb963fd3d4ce);
pub const MFPROTECTION_HARDWARE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4ee7f0c1_9ed7_424f_b6be_996b33528856);
pub const MFPROTECTION_HDCP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xae7cc03d_c828_4021_acb7_d578d27aaf13);
pub const MFPROTECTION_HDCP_WITH_TYPE_ENFORCEMENT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa4a585e8_ed60_442d_814d_db4d4220a06d);
pub const MFPROTECTION_PROTECTED_SURFACE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4f5d9566_e742_4a25_8d1f_d287b5fa0ade);
pub const MFPROTECTION_TRUSTEDAUDIODRIVERS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x65bdf3d2_0168_4816_a533_55d47b027101);
pub const MFPROTECTION_VIDEO_FRAMES: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x36a59cbc_7401_4a8c_bc20_46a7c9e597f0);
pub const MFPROTECTION_WMDRMOTA: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa267a6a1_362e_47d0_8805_4628598a23e4);
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem"))]
pub struct MFP_ACQUIRE_USER_CREDENTIAL_EVENT {
pub header: MFP_EVENT_HEADER,
pub dwUserData: usize,
pub fProceedWithAuthentication: super::super::Foundation::BOOL,
pub hrAuthenticationStatus: ::windows::core::HRESULT,
pub pwszURL: super::super::Foundation::PWSTR,
pub pwszSite: super::super::Foundation::PWSTR,
pub pwszRealm: super::super::Foundation::PWSTR,
pub pwszPackage: super::super::Foundation::PWSTR,
pub nRetries: i32,
pub flags: u32,
pub pCredential: ::core::option::Option<IMFNetCredential>,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem"))]
impl MFP_ACQUIRE_USER_CREDENTIAL_EVENT {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem"))]
impl ::core::default::Default for MFP_ACQUIRE_USER_CREDENTIAL_EVENT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem"))]
impl ::core::fmt::Debug for MFP_ACQUIRE_USER_CREDENTIAL_EVENT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFP_ACQUIRE_USER_CREDENTIAL_EVENT")
.field("header", &self.header)
.field("dwUserData", &self.dwUserData)
.field("fProceedWithAuthentication", &self.fProceedWithAuthentication)
.field("hrAuthenticationStatus", &self.hrAuthenticationStatus)
.field("pwszURL", &self.pwszURL)
.field("pwszSite", &self.pwszSite)
.field("pwszRealm", &self.pwszRealm)
.field("pwszPackage", &self.pwszPackage)
.field("nRetries", &self.nRetries)
.field("flags", &self.flags)
.field("pCredential", &self.pCredential)
.finish()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem"))]
impl ::core::cmp::PartialEq for MFP_ACQUIRE_USER_CREDENTIAL_EVENT {
fn eq(&self, other: &Self) -> bool {
self.header == other.header && self.dwUserData == other.dwUserData && self.fProceedWithAuthentication == other.fProceedWithAuthentication && self.hrAuthenticationStatus == other.hrAuthenticationStatus && self.pwszURL == other.pwszURL && self.pwszSite == other.pwszSite && self.pwszRealm == other.pwszRealm && self.pwszPackage == other.pwszPackage && self.nRetries == other.nRetries && self.flags == other.flags && self.pCredential == other.pCredential
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem"))]
impl ::core::cmp::Eq for MFP_ACQUIRE_USER_CREDENTIAL_EVENT {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_Shell_PropertiesSystem"))]
unsafe impl ::windows::core::Abi for MFP_ACQUIRE_USER_CREDENTIAL_EVENT {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFP_CREATION_OPTIONS(pub i32);
pub const MFP_OPTION_NONE: MFP_CREATION_OPTIONS = MFP_CREATION_OPTIONS(0i32);
pub const MFP_OPTION_FREE_THREADED_CALLBACK: MFP_CREATION_OPTIONS = MFP_CREATION_OPTIONS(1i32);
pub const MFP_OPTION_NO_MMCSS: MFP_CREATION_OPTIONS = MFP_CREATION_OPTIONS(2i32);
pub const MFP_OPTION_NO_REMOTE_DESKTOP_OPTIMIZATION: MFP_CREATION_OPTIONS = MFP_CREATION_OPTIONS(4i32);
impl ::core::convert::From<i32> for MFP_CREATION_OPTIONS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFP_CREATION_OPTIONS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
pub struct MFP_ERROR_EVENT {
pub header: MFP_EVENT_HEADER,
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl MFP_ERROR_EVENT {}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::default::Default for MFP_ERROR_EVENT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::fmt::Debug for MFP_ERROR_EVENT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFP_ERROR_EVENT").field("header", &self.header).finish()
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::cmp::PartialEq for MFP_ERROR_EVENT {
fn eq(&self, other: &Self) -> bool {
self.header == other.header
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::cmp::Eq for MFP_ERROR_EVENT {}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
unsafe impl ::windows::core::Abi for MFP_ERROR_EVENT {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
pub struct MFP_EVENT_HEADER {
pub eEventType: MFP_EVENT_TYPE,
pub hrEvent: ::windows::core::HRESULT,
pub pMediaPlayer: ::core::option::Option<IMFPMediaPlayer>,
pub eState: MFP_MEDIAPLAYER_STATE,
pub pPropertyStore: ::core::option::Option<super::super::UI::Shell::PropertiesSystem::IPropertyStore>,
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl MFP_EVENT_HEADER {}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::default::Default for MFP_EVENT_HEADER {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::fmt::Debug for MFP_EVENT_HEADER {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFP_EVENT_HEADER").field("eEventType", &self.eEventType).field("hrEvent", &self.hrEvent).field("pMediaPlayer", &self.pMediaPlayer).field("eState", &self.eState).field("pPropertyStore", &self.pPropertyStore).finish()
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::cmp::PartialEq for MFP_EVENT_HEADER {
fn eq(&self, other: &Self) -> bool {
self.eEventType == other.eEventType && self.hrEvent == other.hrEvent && self.pMediaPlayer == other.pMediaPlayer && self.eState == other.eState && self.pPropertyStore == other.pPropertyStore
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::cmp::Eq for MFP_EVENT_HEADER {}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
unsafe impl ::windows::core::Abi for MFP_EVENT_HEADER {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFP_EVENT_TYPE(pub i32);
pub const MFP_EVENT_TYPE_PLAY: MFP_EVENT_TYPE = MFP_EVENT_TYPE(0i32);
pub const MFP_EVENT_TYPE_PAUSE: MFP_EVENT_TYPE = MFP_EVENT_TYPE(1i32);
pub const MFP_EVENT_TYPE_STOP: MFP_EVENT_TYPE = MFP_EVENT_TYPE(2i32);
pub const MFP_EVENT_TYPE_POSITION_SET: MFP_EVENT_TYPE = MFP_EVENT_TYPE(3i32);
pub const MFP_EVENT_TYPE_RATE_SET: MFP_EVENT_TYPE = MFP_EVENT_TYPE(4i32);
pub const MFP_EVENT_TYPE_MEDIAITEM_CREATED: MFP_EVENT_TYPE = MFP_EVENT_TYPE(5i32);
pub const MFP_EVENT_TYPE_MEDIAITEM_SET: MFP_EVENT_TYPE = MFP_EVENT_TYPE(6i32);
pub const MFP_EVENT_TYPE_FRAME_STEP: MFP_EVENT_TYPE = MFP_EVENT_TYPE(7i32);
pub const MFP_EVENT_TYPE_MEDIAITEM_CLEARED: MFP_EVENT_TYPE = MFP_EVENT_TYPE(8i32);
pub const MFP_EVENT_TYPE_MF: MFP_EVENT_TYPE = MFP_EVENT_TYPE(9i32);
pub const MFP_EVENT_TYPE_ERROR: MFP_EVENT_TYPE = MFP_EVENT_TYPE(10i32);
pub const MFP_EVENT_TYPE_PLAYBACK_ENDED: MFP_EVENT_TYPE = MFP_EVENT_TYPE(11i32);
pub const MFP_EVENT_TYPE_ACQUIRE_USER_CREDENTIAL: MFP_EVENT_TYPE = MFP_EVENT_TYPE(12i32);
impl ::core::convert::From<i32> for MFP_EVENT_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFP_EVENT_TYPE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
pub struct MFP_FRAME_STEP_EVENT {
pub header: MFP_EVENT_HEADER,
pub pMediaItem: ::core::option::Option<IMFPMediaItem>,
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl MFP_FRAME_STEP_EVENT {}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::default::Default for MFP_FRAME_STEP_EVENT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::fmt::Debug for MFP_FRAME_STEP_EVENT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFP_FRAME_STEP_EVENT").field("header", &self.header).field("pMediaItem", &self.pMediaItem).finish()
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::cmp::PartialEq for MFP_FRAME_STEP_EVENT {
fn eq(&self, other: &Self) -> bool {
self.header == other.header && self.pMediaItem == other.pMediaItem
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::cmp::Eq for MFP_FRAME_STEP_EVENT {}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
unsafe impl ::windows::core::Abi for MFP_FRAME_STEP_EVENT {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
pub struct MFP_MEDIAITEM_CLEARED_EVENT {
pub header: MFP_EVENT_HEADER,
pub pMediaItem: ::core::option::Option<IMFPMediaItem>,
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl MFP_MEDIAITEM_CLEARED_EVENT {}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::default::Default for MFP_MEDIAITEM_CLEARED_EVENT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::fmt::Debug for MFP_MEDIAITEM_CLEARED_EVENT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFP_MEDIAITEM_CLEARED_EVENT").field("header", &self.header).field("pMediaItem", &self.pMediaItem).finish()
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::cmp::PartialEq for MFP_MEDIAITEM_CLEARED_EVENT {
fn eq(&self, other: &Self) -> bool {
self.header == other.header && self.pMediaItem == other.pMediaItem
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::cmp::Eq for MFP_MEDIAITEM_CLEARED_EVENT {}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
unsafe impl ::windows::core::Abi for MFP_MEDIAITEM_CLEARED_EVENT {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
pub struct MFP_MEDIAITEM_CREATED_EVENT {
pub header: MFP_EVENT_HEADER,
pub pMediaItem: ::core::option::Option<IMFPMediaItem>,
pub dwUserData: usize,
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl MFP_MEDIAITEM_CREATED_EVENT {}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::default::Default for MFP_MEDIAITEM_CREATED_EVENT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::fmt::Debug for MFP_MEDIAITEM_CREATED_EVENT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFP_MEDIAITEM_CREATED_EVENT").field("header", &self.header).field("pMediaItem", &self.pMediaItem).field("dwUserData", &self.dwUserData).finish()
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::cmp::PartialEq for MFP_MEDIAITEM_CREATED_EVENT {
fn eq(&self, other: &Self) -> bool {
self.header == other.header && self.pMediaItem == other.pMediaItem && self.dwUserData == other.dwUserData
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::cmp::Eq for MFP_MEDIAITEM_CREATED_EVENT {}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
unsafe impl ::windows::core::Abi for MFP_MEDIAITEM_CREATED_EVENT {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
pub struct MFP_MEDIAITEM_SET_EVENT {
pub header: MFP_EVENT_HEADER,
pub pMediaItem: ::core::option::Option<IMFPMediaItem>,
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl MFP_MEDIAITEM_SET_EVENT {}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::default::Default for MFP_MEDIAITEM_SET_EVENT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::fmt::Debug for MFP_MEDIAITEM_SET_EVENT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFP_MEDIAITEM_SET_EVENT").field("header", &self.header).field("pMediaItem", &self.pMediaItem).finish()
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::cmp::PartialEq for MFP_MEDIAITEM_SET_EVENT {
fn eq(&self, other: &Self) -> bool {
self.header == other.header && self.pMediaItem == other.pMediaItem
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::cmp::Eq for MFP_MEDIAITEM_SET_EVENT {}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
unsafe impl ::windows::core::Abi for MFP_MEDIAITEM_SET_EVENT {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFP_MEDIAPLAYER_STATE(pub i32);
pub const MFP_MEDIAPLAYER_STATE_EMPTY: MFP_MEDIAPLAYER_STATE = MFP_MEDIAPLAYER_STATE(0i32);
pub const MFP_MEDIAPLAYER_STATE_STOPPED: MFP_MEDIAPLAYER_STATE = MFP_MEDIAPLAYER_STATE(1i32);
pub const MFP_MEDIAPLAYER_STATE_PLAYING: MFP_MEDIAPLAYER_STATE = MFP_MEDIAPLAYER_STATE(2i32);
pub const MFP_MEDIAPLAYER_STATE_PAUSED: MFP_MEDIAPLAYER_STATE = MFP_MEDIAPLAYER_STATE(3i32);
pub const MFP_MEDIAPLAYER_STATE_SHUTDOWN: MFP_MEDIAPLAYER_STATE = MFP_MEDIAPLAYER_STATE(4i32);
impl ::core::convert::From<i32> for MFP_MEDIAPLAYER_STATE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFP_MEDIAPLAYER_STATE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
pub struct MFP_MF_EVENT {
pub header: MFP_EVENT_HEADER,
pub MFEventType: u32,
pub pMFMediaEvent: ::core::option::Option<IMFMediaEvent>,
pub pMediaItem: ::core::option::Option<IMFPMediaItem>,
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl MFP_MF_EVENT {}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::default::Default for MFP_MF_EVENT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::fmt::Debug for MFP_MF_EVENT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFP_MF_EVENT").field("header", &self.header).field("MFEventType", &self.MFEventType).field("pMFMediaEvent", &self.pMFMediaEvent).field("pMediaItem", &self.pMediaItem).finish()
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::cmp::PartialEq for MFP_MF_EVENT {
fn eq(&self, other: &Self) -> bool {
self.header == other.header && self.MFEventType == other.MFEventType && self.pMFMediaEvent == other.pMFMediaEvent && self.pMediaItem == other.pMediaItem
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::cmp::Eq for MFP_MF_EVENT {}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
unsafe impl ::windows::core::Abi for MFP_MF_EVENT {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
pub struct MFP_PAUSE_EVENT {
pub header: MFP_EVENT_HEADER,
pub pMediaItem: ::core::option::Option<IMFPMediaItem>,
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl MFP_PAUSE_EVENT {}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::default::Default for MFP_PAUSE_EVENT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::fmt::Debug for MFP_PAUSE_EVENT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFP_PAUSE_EVENT").field("header", &self.header).field("pMediaItem", &self.pMediaItem).finish()
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::cmp::PartialEq for MFP_PAUSE_EVENT {
fn eq(&self, other: &Self) -> bool {
self.header == other.header && self.pMediaItem == other.pMediaItem
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::cmp::Eq for MFP_PAUSE_EVENT {}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
unsafe impl ::windows::core::Abi for MFP_PAUSE_EVENT {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
pub struct MFP_PLAYBACK_ENDED_EVENT {
pub header: MFP_EVENT_HEADER,
pub pMediaItem: ::core::option::Option<IMFPMediaItem>,
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl MFP_PLAYBACK_ENDED_EVENT {}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::default::Default for MFP_PLAYBACK_ENDED_EVENT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::fmt::Debug for MFP_PLAYBACK_ENDED_EVENT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFP_PLAYBACK_ENDED_EVENT").field("header", &self.header).field("pMediaItem", &self.pMediaItem).finish()
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::cmp::PartialEq for MFP_PLAYBACK_ENDED_EVENT {
fn eq(&self, other: &Self) -> bool {
self.header == other.header && self.pMediaItem == other.pMediaItem
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::cmp::Eq for MFP_PLAYBACK_ENDED_EVENT {}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
unsafe impl ::windows::core::Abi for MFP_PLAYBACK_ENDED_EVENT {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
pub struct MFP_PLAY_EVENT {
pub header: MFP_EVENT_HEADER,
pub pMediaItem: ::core::option::Option<IMFPMediaItem>,
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl MFP_PLAY_EVENT {}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::default::Default for MFP_PLAY_EVENT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::fmt::Debug for MFP_PLAY_EVENT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFP_PLAY_EVENT").field("header", &self.header).field("pMediaItem", &self.pMediaItem).finish()
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::cmp::PartialEq for MFP_PLAY_EVENT {
fn eq(&self, other: &Self) -> bool {
self.header == other.header && self.pMediaItem == other.pMediaItem
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::cmp::Eq for MFP_PLAY_EVENT {}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
unsafe impl ::windows::core::Abi for MFP_PLAY_EVENT {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
pub const MFP_POSITIONTYPE_100NS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000000_0000_0000_0000_000000000000);
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
pub struct MFP_POSITION_SET_EVENT {
pub header: MFP_EVENT_HEADER,
pub pMediaItem: ::core::option::Option<IMFPMediaItem>,
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl MFP_POSITION_SET_EVENT {}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::default::Default for MFP_POSITION_SET_EVENT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::fmt::Debug for MFP_POSITION_SET_EVENT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFP_POSITION_SET_EVENT").field("header", &self.header).field("pMediaItem", &self.pMediaItem).finish()
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::cmp::PartialEq for MFP_POSITION_SET_EVENT {
fn eq(&self, other: &Self) -> bool {
self.header == other.header && self.pMediaItem == other.pMediaItem
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::cmp::Eq for MFP_POSITION_SET_EVENT {}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
unsafe impl ::windows::core::Abi for MFP_POSITION_SET_EVENT {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
pub struct MFP_RATE_SET_EVENT {
pub header: MFP_EVENT_HEADER,
pub pMediaItem: ::core::option::Option<IMFPMediaItem>,
pub flRate: f32,
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl MFP_RATE_SET_EVENT {}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::default::Default for MFP_RATE_SET_EVENT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::fmt::Debug for MFP_RATE_SET_EVENT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFP_RATE_SET_EVENT").field("header", &self.header).field("pMediaItem", &self.pMediaItem).field("flRate", &self.flRate).finish()
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::cmp::PartialEq for MFP_RATE_SET_EVENT {
fn eq(&self, other: &Self) -> bool {
self.header == other.header && self.pMediaItem == other.pMediaItem && self.flRate == other.flRate
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::cmp::Eq for MFP_RATE_SET_EVENT {}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
unsafe impl ::windows::core::Abi for MFP_RATE_SET_EVENT {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
pub struct MFP_STOP_EVENT {
pub header: MFP_EVENT_HEADER,
pub pMediaItem: ::core::option::Option<IMFPMediaItem>,
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl MFP_STOP_EVENT {}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::default::Default for MFP_STOP_EVENT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::fmt::Debug for MFP_STOP_EVENT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFP_STOP_EVENT").field("header", &self.header).field("pMediaItem", &self.pMediaItem).finish()
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::cmp::PartialEq for MFP_STOP_EVENT {
fn eq(&self, other: &Self) -> bool {
self.header == other.header && self.pMediaItem == other.pMediaItem
}
}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
impl ::core::cmp::Eq for MFP_STOP_EVENT {}
#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
unsafe impl ::windows::core::Abi for MFP_STOP_EVENT {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union MFPaletteEntry {
pub ARGB: MFARGB,
pub AYCbCr: MFAYUVSample,
}
impl MFPaletteEntry {}
impl ::core::default::Default for MFPaletteEntry {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MFPaletteEntry {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MFPaletteEntry {}
unsafe impl ::windows::core::Abi for MFPaletteEntry {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFPinholeCameraIntrinsic_IntrinsicModel {
pub Width: u32,
pub Height: u32,
pub CameraModel: MFCameraIntrinsic_PinholeCameraModel,
pub DistortionModel: MFCameraIntrinsic_DistortionModel,
}
impl MFPinholeCameraIntrinsic_IntrinsicModel {}
impl ::core::default::Default for MFPinholeCameraIntrinsic_IntrinsicModel {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFPinholeCameraIntrinsic_IntrinsicModel {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFPinholeCameraIntrinsic_IntrinsicModel").field("Width", &self.Width).field("Height", &self.Height).field("CameraModel", &self.CameraModel).field("DistortionModel", &self.DistortionModel).finish()
}
}
impl ::core::cmp::PartialEq for MFPinholeCameraIntrinsic_IntrinsicModel {
fn eq(&self, other: &Self) -> bool {
self.Width == other.Width && self.Height == other.Height && self.CameraModel == other.CameraModel && self.DistortionModel == other.DistortionModel
}
}
impl ::core::cmp::Eq for MFPinholeCameraIntrinsic_IntrinsicModel {}
unsafe impl ::windows::core::Abi for MFPinholeCameraIntrinsic_IntrinsicModel {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFPinholeCameraIntrinsics {
pub IntrinsicModelCount: u32,
pub IntrinsicModels: [MFPinholeCameraIntrinsic_IntrinsicModel; 1],
}
impl MFPinholeCameraIntrinsics {}
impl ::core::default::Default for MFPinholeCameraIntrinsics {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFPinholeCameraIntrinsics {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFPinholeCameraIntrinsics").field("IntrinsicModelCount", &self.IntrinsicModelCount).field("IntrinsicModels", &self.IntrinsicModels).finish()
}
}
impl ::core::cmp::PartialEq for MFPinholeCameraIntrinsics {
fn eq(&self, other: &Self) -> bool {
self.IntrinsicModelCount == other.IntrinsicModelCount && self.IntrinsicModels == other.IntrinsicModels
}
}
impl ::core::cmp::Eq for MFPinholeCameraIntrinsics {}
unsafe impl ::windows::core::Abi for MFPinholeCameraIntrinsics {
type Abi = Self;
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFPutWaitingWorkItem<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, IMFAsyncResult>>(hevent: Param0, priority: i32, presult: Param2) -> ::windows::core::Result<u64> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFPutWaitingWorkItem(hevent: super::super::Foundation::HANDLE, priority: i32, presult: ::windows::core::RawPtr, pkey: *mut u64) -> ::windows::core::HRESULT;
}
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFPutWaitingWorkItem(hevent.into_param().abi(), ::core::mem::transmute(priority), presult.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFPutWorkItem<'a, Param1: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param2: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(dwqueue: u32, pcallback: Param1, pstate: Param2) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFPutWorkItem(dwqueue: u32, pcallback: ::windows::core::RawPtr, pstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
MFPutWorkItem(::core::mem::transmute(dwqueue), pcallback.into_param().abi(), pstate.into_param().abi()).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFPutWorkItem2<'a, Param2: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param3: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(dwqueue: u32, priority: i32, pcallback: Param2, pstate: Param3) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFPutWorkItem2(dwqueue: u32, priority: i32, pcallback: ::windows::core::RawPtr, pstate: ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
MFPutWorkItem2(::core::mem::transmute(dwqueue), ::core::mem::transmute(priority), pcallback.into_param().abi(), pstate.into_param().abi()).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFPutWorkItemEx<'a, Param1: ::windows::core::IntoParam<'a, IMFAsyncResult>>(dwqueue: u32, presult: Param1) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFPutWorkItemEx(dwqueue: u32, presult: ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
MFPutWorkItemEx(::core::mem::transmute(dwqueue), presult.into_param().abi()).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFPutWorkItemEx2<'a, Param2: ::windows::core::IntoParam<'a, IMFAsyncResult>>(dwqueue: u32, priority: i32, presult: Param2) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFPutWorkItemEx2(dwqueue: u32, priority: i32, presult: ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
MFPutWorkItemEx2(::core::mem::transmute(dwqueue), ::core::mem::transmute(priority), presult.into_param().abi()).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFRATE_DIRECTION(pub i32);
pub const MFRATE_FORWARD: MFRATE_DIRECTION = MFRATE_DIRECTION(0i32);
pub const MFRATE_REVERSE: MFRATE_DIRECTION = MFRATE_DIRECTION(1i32);
impl ::core::convert::From<i32> for MFRATE_DIRECTION {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFRATE_DIRECTION {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFRR_COMPONENTS {
pub dwRRInfoVersion: u32,
pub dwRRComponents: u32,
pub pRRComponents: *mut MFRR_COMPONENT_HASH_INFO,
}
impl MFRR_COMPONENTS {}
impl ::core::default::Default for MFRR_COMPONENTS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFRR_COMPONENTS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFRR_COMPONENTS").field("dwRRInfoVersion", &self.dwRRInfoVersion).field("dwRRComponents", &self.dwRRComponents).field("pRRComponents", &self.pRRComponents).finish()
}
}
impl ::core::cmp::PartialEq for MFRR_COMPONENTS {
fn eq(&self, other: &Self) -> bool {
self.dwRRInfoVersion == other.dwRRInfoVersion && self.dwRRComponents == other.dwRRComponents && self.pRRComponents == other.pRRComponents
}
}
impl ::core::cmp::Eq for MFRR_COMPONENTS {}
unsafe impl ::windows::core::Abi for MFRR_COMPONENTS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFRR_COMPONENT_HASH_INFO {
pub ulReason: u32,
pub rgHeaderHash: [u16; 43],
pub rgPublicKeyHash: [u16; 43],
pub wszName: [u16; 260],
}
impl MFRR_COMPONENT_HASH_INFO {}
impl ::core::default::Default for MFRR_COMPONENT_HASH_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFRR_COMPONENT_HASH_INFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFRR_COMPONENT_HASH_INFO").field("ulReason", &self.ulReason).field("rgHeaderHash", &self.rgHeaderHash).field("rgPublicKeyHash", &self.rgPublicKeyHash).field("wszName", &self.wszName).finish()
}
}
impl ::core::cmp::PartialEq for MFRR_COMPONENT_HASH_INFO {
fn eq(&self, other: &Self) -> bool {
self.ulReason == other.ulReason && self.rgHeaderHash == other.rgHeaderHash && self.rgPublicKeyHash == other.rgPublicKeyHash && self.wszName == other.wszName
}
}
impl ::core::cmp::Eq for MFRR_COMPONENT_HASH_INFO {}
unsafe impl ::windows::core::Abi for MFRR_COMPONENT_HASH_INFO {
type Abi = Self;
}
pub const MFRR_INFO_VERSION: u32 = 0u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFRatio {
pub Numerator: u32,
pub Denominator: u32,
}
impl MFRatio {}
impl ::core::default::Default for MFRatio {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFRatio {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFRatio").field("Numerator", &self.Numerator).field("Denominator", &self.Denominator).finish()
}
}
impl ::core::cmp::PartialEq for MFRatio {
fn eq(&self, other: &Self) -> bool {
self.Numerator == other.Numerator && self.Denominator == other.Denominator
}
}
impl ::core::cmp::Eq for MFRatio {}
unsafe impl ::windows::core::Abi for MFRatio {
type Abi = Self;
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFRegisterLocalByteStreamHandler<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, IMFActivate>>(szfileextension: Param0, szmimetype: Param1, pactivate: Param2) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFRegisterLocalByteStreamHandler(szfileextension: super::super::Foundation::PWSTR, szmimetype: super::super::Foundation::PWSTR, pactivate: ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
MFRegisterLocalByteStreamHandler(szfileextension.into_param().abi(), szmimetype.into_param().abi(), pactivate.into_param().abi()).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFRegisterLocalSchemeHandler<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, IMFActivate>>(szscheme: Param0, pactivate: Param1) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFRegisterLocalSchemeHandler(szscheme: super::super::Foundation::PWSTR, pactivate: ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
MFRegisterLocalSchemeHandler(szscheme.into_param().abi(), pactivate.into_param().abi()).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFRegisterPlatformWithMMCSS<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(wszclass: Param0, pdwtaskid: *mut u32, lpriority: i32) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFRegisterPlatformWithMMCSS(wszclass: super::super::Foundation::PWSTR, pdwtaskid: *mut u32, lpriority: i32) -> ::windows::core::HRESULT;
}
MFRegisterPlatformWithMMCSS(wszclass.into_param().abi(), ::core::mem::transmute(pdwtaskid), ::core::mem::transmute(lpriority)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFRemovePeriodicCallback(dwkey: u32) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFRemovePeriodicCallback(dwkey: u32) -> ::windows::core::HRESULT;
}
MFRemovePeriodicCallback(::core::mem::transmute(dwkey)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFRequireProtectedEnvironment<'a, Param0: ::windows::core::IntoParam<'a, IMFPresentationDescriptor>>(ppresentationdescriptor: Param0) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFRequireProtectedEnvironment(ppresentationdescriptor: ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
MFRequireProtectedEnvironment(ppresentationdescriptor.into_param().abi()).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
pub const MFSEQUENCER_INVALID_ELEMENT_ID: u32 = 4294967295u32;
pub const MFSESSIONCAP_DOES_NOT_USE_NETWORK: u32 = 64u32;
pub const MFSESSIONCAP_PAUSE: u32 = 4u32;
pub const MFSESSIONCAP_RATE_FORWARD: u32 = 16u32;
pub const MFSESSIONCAP_RATE_REVERSE: u32 = 32u32;
pub const MFSESSIONCAP_SEEK: u32 = 2u32;
pub const MFSESSIONCAP_START: u32 = 1u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFSESSION_GETFULLTOPOLOGY_FLAGS(pub i32);
pub const MFSESSION_GETFULLTOPOLOGY_CURRENT: MFSESSION_GETFULLTOPOLOGY_FLAGS = MFSESSION_GETFULLTOPOLOGY_FLAGS(1i32);
impl ::core::convert::From<i32> for MFSESSION_GETFULLTOPOLOGY_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFSESSION_GETFULLTOPOLOGY_FLAGS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFSESSION_SETTOPOLOGY_FLAGS(pub i32);
pub const MFSESSION_SETTOPOLOGY_IMMEDIATE: MFSESSION_SETTOPOLOGY_FLAGS = MFSESSION_SETTOPOLOGY_FLAGS(1i32);
pub const MFSESSION_SETTOPOLOGY_NORESOLUTION: MFSESSION_SETTOPOLOGY_FLAGS = MFSESSION_SETTOPOLOGY_FLAGS(2i32);
pub const MFSESSION_SETTOPOLOGY_CLEAR_CURRENT: MFSESSION_SETTOPOLOGY_FLAGS = MFSESSION_SETTOPOLOGY_FLAGS(4i32);
impl ::core::convert::From<i32> for MFSESSION_SETTOPOLOGY_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFSESSION_SETTOPOLOGY_FLAGS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFSHUTDOWN_STATUS(pub i32);
pub const MFSHUTDOWN_INITIATED: MFSHUTDOWN_STATUS = MFSHUTDOWN_STATUS(0i32);
pub const MFSHUTDOWN_COMPLETED: MFSHUTDOWN_STATUS = MFSHUTDOWN_STATUS(1i32);
impl ::core::convert::From<i32> for MFSHUTDOWN_STATUS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFSHUTDOWN_STATUS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFSINK_WMDRMACTION(pub i32);
pub const MFSINK_WMDRMACTION_UNDEFINED: MFSINK_WMDRMACTION = MFSINK_WMDRMACTION(0i32);
pub const MFSINK_WMDRMACTION_ENCODE: MFSINK_WMDRMACTION = MFSINK_WMDRMACTION(1i32);
pub const MFSINK_WMDRMACTION_TRANSCODE: MFSINK_WMDRMACTION = MFSINK_WMDRMACTION(2i32);
pub const MFSINK_WMDRMACTION_TRANSCRYPT: MFSINK_WMDRMACTION = MFSINK_WMDRMACTION(3i32);
pub const MFSINK_WMDRMACTION_LAST: MFSINK_WMDRMACTION = MFSINK_WMDRMACTION(3i32);
impl ::core::convert::From<i32> for MFSINK_WMDRMACTION {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFSINK_WMDRMACTION {
type Abi = Self;
}
pub const MFSTARTUP_FULL: u32 = 0u32;
pub const MFSTARTUP_LITE: u32 = 1u32;
pub const MFSTARTUP_NOSOCKET: u32 = 1u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFSTREAMSINK_MARKER_TYPE(pub i32);
pub const MFSTREAMSINK_MARKER_DEFAULT: MFSTREAMSINK_MARKER_TYPE = MFSTREAMSINK_MARKER_TYPE(0i32);
pub const MFSTREAMSINK_MARKER_ENDOFSEGMENT: MFSTREAMSINK_MARKER_TYPE = MFSTREAMSINK_MARKER_TYPE(1i32);
pub const MFSTREAMSINK_MARKER_TICK: MFSTREAMSINK_MARKER_TYPE = MFSTREAMSINK_MARKER_TYPE(2i32);
pub const MFSTREAMSINK_MARKER_EVENT: MFSTREAMSINK_MARKER_TYPE = MFSTREAMSINK_MARKER_TYPE(3i32);
impl ::core::convert::From<i32> for MFSTREAMSINK_MARKER_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFSTREAMSINK_MARKER_TYPE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFSampleAllocatorUsage(pub i32);
pub const MFSampleAllocatorUsage_UsesProvidedAllocator: MFSampleAllocatorUsage = MFSampleAllocatorUsage(0i32);
pub const MFSampleAllocatorUsage_UsesCustomAllocator: MFSampleAllocatorUsage = MFSampleAllocatorUsage(1i32);
pub const MFSampleAllocatorUsage_DoesNotAllocate: MFSampleAllocatorUsage = MFSampleAllocatorUsage(2i32);
impl ::core::convert::From<i32> for MFSampleAllocatorUsage {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFSampleAllocatorUsage {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFSampleEncryptionProtectionScheme(pub i32);
pub const MF_SAMPLE_ENCRYPTION_PROTECTION_SCHEME_NONE: MFSampleEncryptionProtectionScheme = MFSampleEncryptionProtectionScheme(0i32);
pub const MF_SAMPLE_ENCRYPTION_PROTECTION_SCHEME_AES_CTR: MFSampleEncryptionProtectionScheme = MFSampleEncryptionProtectionScheme(1i32);
pub const MF_SAMPLE_ENCRYPTION_PROTECTION_SCHEME_AES_CBC: MFSampleEncryptionProtectionScheme = MFSampleEncryptionProtectionScheme(2i32);
impl ::core::convert::From<i32> for MFSampleEncryptionProtectionScheme {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFSampleEncryptionProtectionScheme {
type Abi = Self;
}
pub const MFSampleExtension_3DVideo: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf86f97a4_dd54_4e2e_9a5e_55fc2d74a005);
pub const MFSampleExtension_3DVideo_SampleFormat: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x08671772_e36f_4cff_97b3_d72e20987a48);
pub const MFSampleExtension_AccumulatedNonRefPicPercent: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x79ea74df_a740_445b_bc98_c9ed1f260eee);
pub const MFSampleExtension_BottomFieldFirst: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x941ce0a3_6ae3_4dda_9a08_a64298340617);
pub const MFSampleExtension_CameraExtrinsics: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6b761658_b7ec_4c3b_8225_8623cabec31d);
pub const MFSampleExtension_CaptureMetadata: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2ebe23a8_faf5_444a_a6a2_eb810880ab5d);
pub const MFSampleExtension_ChromaOnly: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1eb9179c_a01f_4845_8c04_0e65a26eb04f);
pub const MFSampleExtension_CleanPoint: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9cdf01d8_a0f0_43ba_b077_eaa06cbd728a);
pub const MFSampleExtension_ClosedCaption_CEA708: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x26f09068_e744_47dc_aa03_dbf20403bde6);
pub const MFSampleExtension_ClosedCaption_CEA708_MAX_SIZE: u32 = 256u32;
pub const MFSampleExtension_Content_KeyID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc6c7f5b0_acca_415b_87d9_10441469efc6);
pub const MFSampleExtension_DecodeTimestamp: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x73a954d4_09e2_4861_befc_94bd97c08e6e);
pub const MFSampleExtension_Depth_MaxReliableDepth: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe45545d1_1f0f_4a32_a8a7_6101a24ea8be);
pub const MFSampleExtension_Depth_MinReliableDepth: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5f8582b2_e36b_47c8_9b87_fee1ca72c5b0);
pub const MFSampleExtension_DerivedFromTopField: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6852465a_ae1c_4553_8e9b_c3420fcb1637);
pub const MFSampleExtension_DescrambleData: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x43483be6_4903_4314_b032_2951365936fc);
pub const MFSampleExtension_DeviceReferenceSystemTime: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6523775a_ba2d_405f_b2c5_01ff88e2e8f6);
pub const MFSampleExtension_DeviceTimestamp: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8f3e35e7_2dcd_4887_8622_2a58baa652b0);
pub const MFSampleExtension_DirtyRects: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9ba70225_b342_4e97_9126_0b566ab7ea7e);
pub const MFSampleExtension_Discontinuity: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9cdf01d9_a0f0_43ba_b077_eaa06cbd728a);
pub const MFSampleExtension_Encryption_ClearSliceHeaderData: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5509a4f4_320d_4e6c_8d1a_94c66dd20cb0);
pub const MFSampleExtension_Encryption_CryptByteBlock: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9d84289b_0c7f_4713_ab95_108ab42ad801);
pub const MFSampleExtension_Encryption_HardwareProtection: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9a2b2d2b_8270_43e3_8448_994f426e8886);
pub const MFSampleExtension_Encryption_HardwareProtection_KeyInfo: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb2372080_455b_4dd7_9989_1a955784b754);
pub const MFSampleExtension_Encryption_HardwareProtection_KeyInfoID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8cbfcceb_94a5_4de1_8231_a85e47cf81e7);
pub const MFSampleExtension_Encryption_HardwareProtection_VideoDecryptorContext: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x693470c8_e837_47a0_88cb_535b905e3582);
pub const MFSampleExtension_Encryption_KeyID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x76376591_795f_4da1_86ed_9d46eca109a9);
pub const MFSampleExtension_Encryption_NALUTypes: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb0f067c7_714c_416c_8d59_5f4ddf8913b6);
pub const MFSampleExtension_Encryption_Opaque_Data: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x224d77e5_1391_4ffb_9f41_b432f68c611d);
pub const MFSampleExtension_Encryption_ProtectionScheme: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd054d096_28bb_45da_87ec_74f351871406);
pub const MFSampleExtension_Encryption_ResumeVideoOutput: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa435aba5_afde_4cf5_bc1c_f6acaf13949d);
pub const MFSampleExtension_Encryption_SEIData: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cf0e972_4542_4687_9999_585f565fba7d);
pub const MFSampleExtension_Encryption_SPSPPSData: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xaede0fa2_0e0c_453c_b7f3_de8693364d11);
pub const MFSampleExtension_Encryption_SampleID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6698b84e_0afa_4330_aeb2_1c0a98d7a44d);
pub const MFSampleExtension_Encryption_SkipByteBlock: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0d550548_8317_4ab1_845f_d06306e293e3);
pub const MFSampleExtension_Encryption_SubSampleMappingSplit: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfe0254b9_2aa5_4edc_99f7_17e89dbf9174);
pub const MFSampleExtension_Encryption_SubSample_Mapping: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8444f27a_69a1_48da_bd08_11cef36830d2);
pub const MFSampleExtension_ExtendedCameraIntrinsics: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x560bc4a5_4de0_4113_9cdc_832db9740f3d);
pub const MFSampleExtension_FeatureMap: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa032d165_46fc_400a_b449_49de53e62a6e);
pub const MFSampleExtension_ForwardedDecodeUnitType: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x089e57c7_47d3_4a26_bf9c_4b64fafb5d1e);
pub const MFSampleExtension_ForwardedDecodeUnits: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x424c754c_97c8_48d6_8777_fc41f7b60879);
pub const MFSampleExtension_FrameCorruption: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb4dd4a8c_0beb_44c4_8b75_b02b913b04f0);
pub const MFSampleExtension_GenKeyCtx: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x188120cb_d7da_4b59_9b3e_9252fd37301c);
pub const MFSampleExtension_GenKeyFunc: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x441ca1ee_6b1f_4501_903a_de87df42f6ed);
pub const MFSampleExtension_HDCP_FrameCounter: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9d389c60_f507_4aa6_a40a_71027a02f3de);
pub const MFSampleExtension_HDCP_OptionalHeader: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9a2e7390_121f_455f_8376_c97428e0b540);
pub const MFSampleExtension_HDCP_StreamID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x177e5d74_c370_4a7a_95a2_36833c01d0af);
pub const MFSampleExtension_Interlaced: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb1d5830a_deb8_40e3_90fa_389943716461);
pub const MFSampleExtension_LastSlice: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2b5d5457_5547_4f07_b8c8_b4a3a9a1daac);
pub const MFSampleExtension_LongTermReferenceFrameInfo: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9154733f_e1bd_41bf_81d3_fcd918f71332);
pub const MFSampleExtension_MDLCacheCookie: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5f002af9_d8f9_41a3_b6c3_a2ad43f647ad);
pub const MFSampleExtension_MULTIPLEXED_MANAGER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8dcdee79_6b5a_4c45_8db9_20b395f02fcf);
pub const MFSampleExtension_MaxDecodeFrameSize: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd3cc654f_f9f3_4a13_889f_f04eb2b5b957);
pub const MFSampleExtension_MeanAbsoluteDifference: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1cdbde11_08b4_4311_a6dd_0f9f371907aa);
pub const MFSampleExtension_MoveRegions: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe2a6c693_3a8b_4b8d_95d0_f60281a12fb7);
pub const MFSampleExtension_NALULengthInfo: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x19124e7c_ad4b_465f_bb18_20186287b6af);
pub const MFSampleExtension_PacketCrossOffsets: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2789671d_389f_40bb_90d9_c282f77f9abd);
pub const MFSampleExtension_PhotoThumbnail: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x74bbc85c_c8bb_42dc_b586_da17ffd35dcc);
pub const MFSampleExtension_PhotoThumbnailMediaType: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x61ad5420_ebf8_4143_89af_6bf25f672def);
pub const MFSampleExtension_PinholeCameraIntrinsics: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4ee3b6c5_6a15_4e72_9761_70c1db8b9fe3);
pub const MFSampleExtension_ROIRectangle: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3414a438_4998_4d2c_be82_be3ca0b24d43);
pub const MFSampleExtension_RepeatFirstField: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x304d257c_7493_4fbd_b149_9228de8d9a99);
pub const MFSampleExtension_RepeatFrame: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x88be738f_0711_4f42_b458_344aed42ec2f);
pub const MFSampleExtension_SampleKeyID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9ed713c8_9b87_4b26_8297_a93b0c5a8acc);
pub const MFSampleExtension_SingleField: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9d85f816_658b_455a_bde0_9fa7e15ab8f9);
pub const MFSampleExtension_Spatial_CameraCoordinateSystem: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9d13c82f_2199_4e67_91cd_d1a4181f2534);
pub const MFSampleExtension_Spatial_CameraProjectionTransform: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x47f9fcb5_2a02_4f26_a477_792fdf95886a);
pub const MFSampleExtension_Spatial_CameraViewTransform: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4e251fa4_830f_4770_859a_4b8d99aa809b);
pub const MFSampleExtension_TargetGlobalLuminance: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3f60ef36_31ef_4daf_8360_940397e41ef3);
pub const MFSampleExtension_Timestamp: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1e436999_69be_4c7a_9369_70068c0260cb);
pub const MFSampleExtension_Token: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8294da66_f328_4805_b551_00deb4c57a61);
pub const MFSampleExtension_VideoDSPMode: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc12d55cb_d7d9_476d_81f3_69117f163ea0);
pub const MFSampleExtension_VideoEncodePictureType: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x973704e6_cd14_483c_8f20_c9fc0928bad5);
pub const MFSampleExtension_VideoEncodeQP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb2efe478_f979_4c66_b95e_ee2b82c82f36);
#[inline]
pub unsafe fn MFScheduleWorkItem<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncCallback>, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(pcallback: Param0, pstate: Param1, timeout: i64) -> ::windows::core::Result<u64> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFScheduleWorkItem(pcallback: ::windows::core::RawPtr, pstate: ::windows::core::RawPtr, timeout: i64, pkey: *mut u64) -> ::windows::core::HRESULT;
}
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFScheduleWorkItem(pcallback.into_param().abi(), pstate.into_param().abi(), ::core::mem::transmute(timeout), &mut result__).from_abi::<u64>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFScheduleWorkItemEx<'a, Param0: ::windows::core::IntoParam<'a, IMFAsyncResult>>(presult: Param0, timeout: i64) -> ::windows::core::Result<u64> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFScheduleWorkItemEx(presult: ::windows::core::RawPtr, timeout: i64, pkey: *mut u64) -> ::windows::core::HRESULT;
}
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFScheduleWorkItemEx(presult.into_param().abi(), ::core::mem::transmute(timeout), &mut result__).from_abi::<u64>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFSensorDeviceMode(pub i32);
pub const MFSensorDeviceMode_Controller: MFSensorDeviceMode = MFSensorDeviceMode(0i32);
pub const MFSensorDeviceMode_Shared: MFSensorDeviceMode = MFSensorDeviceMode(1i32);
impl ::core::convert::From<i32> for MFSensorDeviceMode {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFSensorDeviceMode {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFSensorDeviceType(pub i32);
pub const MFSensorDeviceType_Unknown: MFSensorDeviceType = MFSensorDeviceType(0i32);
pub const MFSensorDeviceType_Device: MFSensorDeviceType = MFSensorDeviceType(1i32);
pub const MFSensorDeviceType_MediaSource: MFSensorDeviceType = MFSensorDeviceType(2i32);
pub const MFSensorDeviceType_FrameProvider: MFSensorDeviceType = MFSensorDeviceType(3i32);
pub const MFSensorDeviceType_SensorTransform: MFSensorDeviceType = MFSensorDeviceType(4i32);
impl ::core::convert::From<i32> for MFSensorDeviceType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFSensorDeviceType {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFSensorStreamType(pub i32);
pub const MFSensorStreamType_Unknown: MFSensorStreamType = MFSensorStreamType(0i32);
pub const MFSensorStreamType_Input: MFSensorStreamType = MFSensorStreamType(1i32);
pub const MFSensorStreamType_Output: MFSensorStreamType = MFSensorStreamType(2i32);
impl ::core::convert::From<i32> for MFSensorStreamType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFSensorStreamType {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFSequencerTopologyFlags(pub i32);
pub const SequencerTopologyFlags_Last: MFSequencerTopologyFlags = MFSequencerTopologyFlags(1i32);
impl ::core::convert::From<i32> for MFSequencerTopologyFlags {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFSequencerTopologyFlags {
type Abi = Self;
}
#[cfg(feature = "Win32_System_Com")]
#[inline]
pub unsafe fn MFSerializeAttributesToStream<'a, Param0: ::windows::core::IntoParam<'a, IMFAttributes>, Param2: ::windows::core::IntoParam<'a, super::super::System::Com::IStream>>(pattr: Param0, dwoptions: u32, pstm: Param2) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFSerializeAttributesToStream(pattr: ::windows::core::RawPtr, dwoptions: u32, pstm: ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
MFSerializeAttributesToStream(pattr.into_param().abi(), ::core::mem::transmute(dwoptions), pstm.into_param().abi()).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFSerializePresentationDescriptor<'a, Param0: ::windows::core::IntoParam<'a, IMFPresentationDescriptor>>(ppd: Param0, pcbdata: *mut u32, ppbdata: *mut *mut u8) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFSerializePresentationDescriptor(ppd: ::windows::core::RawPtr, pcbdata: *mut u32, ppbdata: *mut *mut u8) -> ::windows::core::HRESULT;
}
MFSerializePresentationDescriptor(ppd.into_param().abi(), ::core::mem::transmute(pcbdata), ::core::mem::transmute(ppbdata)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFShutdown() -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFShutdown() -> ::windows::core::HRESULT;
}
MFShutdown().ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFShutdownObject<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(punk: Param0) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFShutdownObject(punk: ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
MFShutdownObject(punk.into_param().abi()).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFSplitSample<'a, Param0: ::windows::core::IntoParam<'a, IMFSample>>(psample: Param0, poutputsamples: *mut ::core::option::Option<IMFSample>, dwoutputsamplemaxcount: u32, pdwoutputsamplecount: *mut u32) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFSplitSample(psample: ::windows::core::RawPtr, poutputsamples: *mut ::windows::core::RawPtr, dwoutputsamplemaxcount: u32, pdwoutputsamplecount: *mut u32) -> ::windows::core::HRESULT;
}
MFSplitSample(psample.into_param().abi(), ::core::mem::transmute(poutputsamples), ::core::mem::transmute(dwoutputsamplemaxcount), ::core::mem::transmute(pdwoutputsamplecount)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFStandardVideoFormat(pub i32);
pub const MFStdVideoFormat_reserved: MFStandardVideoFormat = MFStandardVideoFormat(0i32);
pub const MFStdVideoFormat_NTSC: MFStandardVideoFormat = MFStandardVideoFormat(1i32);
pub const MFStdVideoFormat_PAL: MFStandardVideoFormat = MFStandardVideoFormat(2i32);
pub const MFStdVideoFormat_DVD_NTSC: MFStandardVideoFormat = MFStandardVideoFormat(3i32);
pub const MFStdVideoFormat_DVD_PAL: MFStandardVideoFormat = MFStandardVideoFormat(4i32);
pub const MFStdVideoFormat_DV_PAL: MFStandardVideoFormat = MFStandardVideoFormat(5i32);
pub const MFStdVideoFormat_DV_NTSC: MFStandardVideoFormat = MFStandardVideoFormat(6i32);
pub const MFStdVideoFormat_ATSC_SD480i: MFStandardVideoFormat = MFStandardVideoFormat(7i32);
pub const MFStdVideoFormat_ATSC_HD1080i: MFStandardVideoFormat = MFStandardVideoFormat(8i32);
pub const MFStdVideoFormat_ATSC_HD720p: MFStandardVideoFormat = MFStandardVideoFormat(9i32);
impl ::core::convert::From<i32> for MFStandardVideoFormat {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFStandardVideoFormat {
type Abi = Self;
}
#[inline]
pub unsafe fn MFStartup(version: u32, dwflags: u32) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFStartup(version: u32, dwflags: u32) -> ::windows::core::HRESULT;
}
MFStartup(::core::mem::transmute(version), ::core::mem::transmute(dwflags)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
pub const MFStreamExtension_CameraExtrinsics: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x686196d0_13e2_41d9_9638_ef032c272a52);
pub const MFStreamExtension_ExtendedCameraIntrinsics: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xaa74b3df_9a2c_48d6_8393_5bd1c1a81e6e);
pub const MFStreamExtension_PinholeCameraIntrinsics: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdbac0455_0ec8_4aef_9c32_7a3ee3456f53);
pub const MFStreamFormat_MPEG2Program: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x263067d1_d330_45dc_b669_34d986e4e3e1);
pub const MFStreamFormat_MPEG2Transport: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe06d8023_db46_11cf_b4d1_00805f6cbbea);
pub const MFSubtitleFormat_ATSC: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7fa7faa3_feae_4e16_aedf_36b9acfbb099);
pub const MFSubtitleFormat_CustomUserData: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1bb3d849_6614_4d80_8882_ed24aa82da92);
pub const MFSubtitleFormat_PGS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x71f40e4a_1278_4442_b30d_39dd1d7722bc);
pub const MFSubtitleFormat_SRT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5e467f2e_77ca_4ca5_8391_d142ed4b76c8);
pub const MFSubtitleFormat_SSA: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x57176a1b_1a9e_4eea_abef_c61760198ac4);
pub const MFSubtitleFormat_TTML: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x73e73992_9a10_4356_9557_7194e91e3e54);
pub const MFSubtitleFormat_VobSub: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6b8e40f4_8d2c_4ced_ad91_5960e45b4433);
pub const MFSubtitleFormat_WebVTT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc886d215_f485_40bb_8db6_fadbc619a45d);
pub const MFSubtitleFormat_XML: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2006f94f_29ca_4195_b8db_00ded8ff0c97);
#[inline]
pub unsafe fn MFTEnum<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::GUID>, Param4: ::windows::core::IntoParam<'a, IMFAttributes>>(guidcategory: Param0, flags: u32, pinputtype: *const MFT_REGISTER_TYPE_INFO, poutputtype: *const MFT_REGISTER_TYPE_INFO, pattributes: Param4, ppclsidmft: *mut *mut ::windows::core::GUID, pcmfts: *mut u32) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFTEnum(guidcategory: ::windows::core::GUID, flags: u32, pinputtype: *const MFT_REGISTER_TYPE_INFO, poutputtype: *const MFT_REGISTER_TYPE_INFO, pattributes: ::windows::core::RawPtr, ppclsidmft: *mut *mut ::windows::core::GUID, pcmfts: *mut u32) -> ::windows::core::HRESULT;
}
MFTEnum(guidcategory.into_param().abi(), ::core::mem::transmute(flags), ::core::mem::transmute(pinputtype), ::core::mem::transmute(poutputtype), pattributes.into_param().abi(), ::core::mem::transmute(ppclsidmft), ::core::mem::transmute(pcmfts)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFTEnum2<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::GUID>, Param4: ::windows::core::IntoParam<'a, IMFAttributes>>(guidcategory: Param0, flags: u32, pinputtype: *const MFT_REGISTER_TYPE_INFO, poutputtype: *const MFT_REGISTER_TYPE_INFO, pattributes: Param4, pppmftactivate: *mut *mut ::core::option::Option<IMFActivate>, pnummftactivate: *mut u32) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFTEnum2(guidcategory: ::windows::core::GUID, flags: u32, pinputtype: *const MFT_REGISTER_TYPE_INFO, poutputtype: *const MFT_REGISTER_TYPE_INFO, pattributes: ::windows::core::RawPtr, pppmftactivate: *mut *mut ::windows::core::RawPtr, pnummftactivate: *mut u32) -> ::windows::core::HRESULT;
}
MFTEnum2(guidcategory.into_param().abi(), ::core::mem::transmute(flags), ::core::mem::transmute(pinputtype), ::core::mem::transmute(poutputtype), pattributes.into_param().abi(), ::core::mem::transmute(pppmftactivate), ::core::mem::transmute(pnummftactivate)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFTEnumEx<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::GUID>>(guidcategory: Param0, flags: u32, pinputtype: *const MFT_REGISTER_TYPE_INFO, poutputtype: *const MFT_REGISTER_TYPE_INFO, pppmftactivate: *mut *mut ::core::option::Option<IMFActivate>, pnummftactivate: *mut u32) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFTEnumEx(guidcategory: ::windows::core::GUID, flags: u32, pinputtype: *const MFT_REGISTER_TYPE_INFO, poutputtype: *const MFT_REGISTER_TYPE_INFO, pppmftactivate: *mut *mut ::windows::core::RawPtr, pnummftactivate: *mut u32) -> ::windows::core::HRESULT;
}
MFTEnumEx(guidcategory.into_param().abi(), ::core::mem::transmute(flags), ::core::mem::transmute(pinputtype), ::core::mem::transmute(poutputtype), ::core::mem::transmute(pppmftactivate), ::core::mem::transmute(pnummftactivate)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFTGetInfo<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::GUID>>(clsidmft: Param0, pszname: *mut super::super::Foundation::PWSTR, ppinputtypes: *mut *mut MFT_REGISTER_TYPE_INFO, pcinputtypes: *mut u32, ppoutputtypes: *mut *mut MFT_REGISTER_TYPE_INFO, pcoutputtypes: *mut u32, ppattributes: *mut ::core::option::Option<IMFAttributes>) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFTGetInfo(clsidmft: ::windows::core::GUID, pszname: *mut super::super::Foundation::PWSTR, ppinputtypes: *mut *mut MFT_REGISTER_TYPE_INFO, pcinputtypes: *mut u32, ppoutputtypes: *mut *mut MFT_REGISTER_TYPE_INFO, pcoutputtypes: *mut u32, ppattributes: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
MFTGetInfo(clsidmft.into_param().abi(), ::core::mem::transmute(pszname), ::core::mem::transmute(ppinputtypes), ::core::mem::transmute(pcinputtypes), ::core::mem::transmute(ppoutputtypes), ::core::mem::transmute(pcoutputtypes), ::core::mem::transmute(ppattributes)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFTIMER_FLAGS(pub i32);
pub const MFTIMER_RELATIVE: MFTIMER_FLAGS = MFTIMER_FLAGS(1i32);
impl ::core::convert::From<i32> for MFTIMER_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFTIMER_FLAGS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFTOPOLOGY_DXVA_MODE(pub i32);
pub const MFTOPOLOGY_DXVA_DEFAULT: MFTOPOLOGY_DXVA_MODE = MFTOPOLOGY_DXVA_MODE(0i32);
pub const MFTOPOLOGY_DXVA_NONE: MFTOPOLOGY_DXVA_MODE = MFTOPOLOGY_DXVA_MODE(1i32);
pub const MFTOPOLOGY_DXVA_FULL: MFTOPOLOGY_DXVA_MODE = MFTOPOLOGY_DXVA_MODE(2i32);
impl ::core::convert::From<i32> for MFTOPOLOGY_DXVA_MODE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFTOPOLOGY_DXVA_MODE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFTOPOLOGY_HARDWARE_MODE(pub i32);
pub const MFTOPOLOGY_HWMODE_SOFTWARE_ONLY: MFTOPOLOGY_HARDWARE_MODE = MFTOPOLOGY_HARDWARE_MODE(0i32);
pub const MFTOPOLOGY_HWMODE_USE_HARDWARE: MFTOPOLOGY_HARDWARE_MODE = MFTOPOLOGY_HARDWARE_MODE(1i32);
pub const MFTOPOLOGY_HWMODE_USE_ONLY_HARDWARE: MFTOPOLOGY_HARDWARE_MODE = MFTOPOLOGY_HARDWARE_MODE(2i32);
impl ::core::convert::From<i32> for MFTOPOLOGY_HARDWARE_MODE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFTOPOLOGY_HARDWARE_MODE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFTOPONODE_ATTRIBUTE_UPDATE {
pub NodeId: u64,
pub guidAttributeKey: ::windows::core::GUID,
pub attrType: MF_ATTRIBUTE_TYPE,
pub Anonymous: MFTOPONODE_ATTRIBUTE_UPDATE_0,
}
impl MFTOPONODE_ATTRIBUTE_UPDATE {}
impl ::core::default::Default for MFTOPONODE_ATTRIBUTE_UPDATE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MFTOPONODE_ATTRIBUTE_UPDATE {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MFTOPONODE_ATTRIBUTE_UPDATE {}
unsafe impl ::windows::core::Abi for MFTOPONODE_ATTRIBUTE_UPDATE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union MFTOPONODE_ATTRIBUTE_UPDATE_0 {
pub u32: u32,
pub u64: u64,
pub d: f64,
}
impl MFTOPONODE_ATTRIBUTE_UPDATE_0 {}
impl ::core::default::Default for MFTOPONODE_ATTRIBUTE_UPDATE_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MFTOPONODE_ATTRIBUTE_UPDATE_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MFTOPONODE_ATTRIBUTE_UPDATE_0 {}
unsafe impl ::windows::core::Abi for MFTOPONODE_ATTRIBUTE_UPDATE_0 {
type Abi = Self;
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFTRegister<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::GUID>, Param1: ::windows::core::IntoParam<'a, ::windows::core::GUID>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param8: ::windows::core::IntoParam<'a, IMFAttributes>>(
clsidmft: Param0,
guidcategory: Param1,
pszname: Param2,
flags: u32,
cinputtypes: u32,
pinputtypes: *const MFT_REGISTER_TYPE_INFO,
coutputtypes: u32,
poutputtypes: *const MFT_REGISTER_TYPE_INFO,
pattributes: Param8,
) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFTRegister(clsidmft: ::windows::core::GUID, guidcategory: ::windows::core::GUID, pszname: super::super::Foundation::PWSTR, flags: u32, cinputtypes: u32, pinputtypes: *const MFT_REGISTER_TYPE_INFO, coutputtypes: u32, poutputtypes: *const MFT_REGISTER_TYPE_INFO, pattributes: ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
MFTRegister(
clsidmft.into_param().abi(),
guidcategory.into_param().abi(),
pszname.into_param().abi(),
::core::mem::transmute(flags),
::core::mem::transmute(cinputtypes),
::core::mem::transmute(pinputtypes),
::core::mem::transmute(coutputtypes),
::core::mem::transmute(poutputtypes),
pattributes.into_param().abi(),
)
.ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
#[inline]
pub unsafe fn MFTRegisterLocal<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::IClassFactory>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(pclassfactory: Param0, guidcategory: *const ::windows::core::GUID, pszname: Param2, flags: u32, cinputtypes: u32, pinputtypes: *const MFT_REGISTER_TYPE_INFO, coutputtypes: u32, poutputtypes: *const MFT_REGISTER_TYPE_INFO) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFTRegisterLocal(pclassfactory: ::windows::core::RawPtr, guidcategory: *const ::windows::core::GUID, pszname: super::super::Foundation::PWSTR, flags: u32, cinputtypes: u32, pinputtypes: *const MFT_REGISTER_TYPE_INFO, coutputtypes: u32, poutputtypes: *const MFT_REGISTER_TYPE_INFO) -> ::windows::core::HRESULT;
}
MFTRegisterLocal(pclassfactory.into_param().abi(), ::core::mem::transmute(guidcategory), pszname.into_param().abi(), ::core::mem::transmute(flags), ::core::mem::transmute(cinputtypes), ::core::mem::transmute(pinputtypes), ::core::mem::transmute(coutputtypes), ::core::mem::transmute(poutputtypes)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MFTRegisterLocalByCLSID<'a, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(clisdmft: *const ::windows::core::GUID, guidcategory: *const ::windows::core::GUID, pszname: Param2, flags: u32, cinputtypes: u32, pinputtypes: *const MFT_REGISTER_TYPE_INFO, coutputtypes: u32, poutputtypes: *const MFT_REGISTER_TYPE_INFO) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFTRegisterLocalByCLSID(clisdmft: *const ::windows::core::GUID, guidcategory: *const ::windows::core::GUID, pszname: super::super::Foundation::PWSTR, flags: u32, cinputtypes: u32, pinputtypes: *const MFT_REGISTER_TYPE_INFO, coutputtypes: u32, poutputtypes: *const MFT_REGISTER_TYPE_INFO) -> ::windows::core::HRESULT;
}
MFTRegisterLocalByCLSID(::core::mem::transmute(clisdmft), ::core::mem::transmute(guidcategory), pszname.into_param().abi(), ::core::mem::transmute(flags), ::core::mem::transmute(cinputtypes), ::core::mem::transmute(pinputtypes), ::core::mem::transmute(coutputtypes), ::core::mem::transmute(poutputtypes)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFTUnregister<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::GUID>>(clsidmft: Param0) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFTUnregister(clsidmft: ::windows::core::GUID) -> ::windows::core::HRESULT;
}
MFTUnregister(clsidmft.into_param().abi()).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_System_Com")]
#[inline]
pub unsafe fn MFTUnregisterLocal<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::IClassFactory>>(pclassfactory: Param0) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFTUnregisterLocal(pclassfactory: ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
MFTUnregisterLocal(pclassfactory.into_param().abi()).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFTUnregisterLocalByCLSID<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::GUID>>(clsidmft: Param0) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFTUnregisterLocalByCLSID(clsidmft: ::windows::core::GUID) -> ::windows::core::HRESULT;
}
MFTUnregisterLocalByCLSID(clsidmft.into_param().abi()).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
pub const MFT_AUDIO_DECODER_AUDIO_ENDPOINT_ID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc7ccdd6e_5398_4695_8be7_51b3e95111bd);
pub const MFT_AUDIO_DECODER_DEGRADATION_INFO_ATTRIBUTE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6c3386ad_ec20_430d_b2a5_505c7178d9c4);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFT_AUDIO_DECODER_DEGRADATION_REASON(pub i32);
pub const MFT_AUDIO_DECODER_DEGRADATION_REASON_NONE: MFT_AUDIO_DECODER_DEGRADATION_REASON = MFT_AUDIO_DECODER_DEGRADATION_REASON(0i32);
pub const MFT_AUDIO_DECODER_DEGRADATION_REASON_LICENSING_REQUIREMENT: MFT_AUDIO_DECODER_DEGRADATION_REASON = MFT_AUDIO_DECODER_DEGRADATION_REASON(1i32);
impl ::core::convert::From<i32> for MFT_AUDIO_DECODER_DEGRADATION_REASON {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFT_AUDIO_DECODER_DEGRADATION_REASON {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFT_AUDIO_DECODER_DEGRADATION_TYPE(pub i32);
pub const MFT_AUDIO_DECODER_DEGRADATION_TYPE_NONE: MFT_AUDIO_DECODER_DEGRADATION_TYPE = MFT_AUDIO_DECODER_DEGRADATION_TYPE(0i32);
pub const MFT_AUDIO_DECODER_DEGRADATION_TYPE_DOWNMIX2CHANNEL: MFT_AUDIO_DECODER_DEGRADATION_TYPE = MFT_AUDIO_DECODER_DEGRADATION_TYPE(1i32);
pub const MFT_AUDIO_DECODER_DEGRADATION_TYPE_DOWNMIX6CHANNEL: MFT_AUDIO_DECODER_DEGRADATION_TYPE = MFT_AUDIO_DECODER_DEGRADATION_TYPE(2i32);
pub const MFT_AUDIO_DECODER_DEGRADATION_TYPE_DOWNMIX8CHANNEL: MFT_AUDIO_DECODER_DEGRADATION_TYPE = MFT_AUDIO_DECODER_DEGRADATION_TYPE(3i32);
impl ::core::convert::From<i32> for MFT_AUDIO_DECODER_DEGRADATION_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFT_AUDIO_DECODER_DEGRADATION_TYPE {
type Abi = Self;
}
pub const MFT_AUDIO_DECODER_SPATIAL_METADATA_CLIENT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x05987df4_1270_4999_925f_8e939a7c0af7);
pub const MFT_CATEGORY_AUDIO_DECODER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9ea73fb4_ef7a_4559_8d5d_719d8f0426c7);
pub const MFT_CATEGORY_AUDIO_EFFECT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x11064c48_3648_4ed0_932e_05ce8ac811b7);
pub const MFT_CATEGORY_AUDIO_ENCODER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x91c64bd0_f91e_4d8c_9276_db248279d975);
pub const MFT_CATEGORY_DEMULTIPLEXER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa8700a7a_939b_44c5_99d7_76226b23b3f1);
pub const MFT_CATEGORY_ENCRYPTOR: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb0c687be_01cd_44b5_b8b2_7c1d7e058b1f);
pub const MFT_CATEGORY_MULTIPLEXER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x059c561e_05ae_4b61_b69d_55b61ee54a7b);
pub const MFT_CATEGORY_OTHER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x90175d57_b7ea_4901_aeb3_933a8747756f);
pub const MFT_CATEGORY_VIDEO_DECODER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd6c02d4b_6833_45b4_971a_05a4b04bab91);
pub const MFT_CATEGORY_VIDEO_EFFECT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x12e17c21_532c_4a6e_8a1c_40825a736397);
pub const MFT_CATEGORY_VIDEO_ENCODER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf79eac7d_e545_4387_bdee_d647d7bde42a);
pub const MFT_CATEGORY_VIDEO_PROCESSOR: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x302ea3fc_aa5f_47f9_9f7a_c2188bb16302);
pub const MFT_CATEGORY_VIDEO_RENDERER_EFFECT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x145cd8b4_92f4_4b23_8ae7_e0df06c2da95);
pub const MFT_CODEC_MERIT_Attribute: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x88a7cb15_7b07_4a34_9128_e64c6703c4d3);
pub const MFT_CONNECTED_STREAM_ATTRIBUTE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x71eeb820_a59f_4de2_bcec_38db1dd611a4);
pub const MFT_CONNECTED_TO_HW_STREAM: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x34e6e728_06d6_4491_a553_4795650db912);
pub const MFT_DECODER_EXPOSE_OUTPUT_TYPES_IN_NATIVE_ORDER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xef80833f_f8fa_44d9_80d8_41ed6232670c);
pub const MFT_DECODER_FINAL_VIDEO_RESOLUTION_HINT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdc2f8496_15c4_407a_b6f0_1b66ab5fbf53);
pub const MFT_DECODER_QUALITY_MANAGEMENT_CUSTOM_CONTROL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa24e30d7_de25_4558_bbfb_71070a2d332e);
pub const MFT_DECODER_QUALITY_MANAGEMENT_RECOVERY_WITHOUT_ARTIFACTS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd8980deb_0a48_425f_8623_611db41d3810);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFT_DRAIN_TYPE(pub i32);
pub const MFT_DRAIN_PRODUCE_TAILS: MFT_DRAIN_TYPE = MFT_DRAIN_TYPE(0i32);
pub const MFT_DRAIN_NO_TAILS: MFT_DRAIN_TYPE = MFT_DRAIN_TYPE(1i32);
impl ::core::convert::From<i32> for MFT_DRAIN_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFT_DRAIN_TYPE {
type Abi = Self;
}
pub const MFT_ENCODER_ERROR: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc8d1eda4_98e4_41d5_9297_44f53852f90e);
pub const MFT_ENCODER_SUPPORTS_CONFIG_EVENT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x86a355ae_3a77_4ec4_9f31_01149a4e92de);
pub const MFT_END_STREAMING_AWARE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x70fbc845_b07e_4089_b064_399dc6110f29);
pub const MFT_ENUM_ADAPTER_LUID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1d39518c_e220_4da8_a07f_ba172552d6b1);
pub const MFT_ENUM_HARDWARE_URL_Attribute: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2fb866ac_b078_4942_ab6c_003d05cda674);
pub const MFT_ENUM_HARDWARE_VENDOR_ID_Attribute: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3aecb0cc_035b_4bcc_8185_2b8d551ef3af);
pub const MFT_ENUM_TRANSCODE_ONLY_ATTRIBUTE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x111ea8cd_b62a_4bdb_89f6_67ffcdc2458b);
pub const MFT_ENUM_VIDEO_RENDERER_EXTENSION_PROFILE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x62c56928_9a4e_443b_b9dc_cac830c24100);
pub const MFT_FIELDOFUSE_UNLOCK_Attribute: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8ec2e9fd_9148_410d_831e_702439461a8e);
pub const MFT_FRIENDLY_NAME_Attribute: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x314ffbae_5b41_4c95_9c19_4e7d586face3);
pub const MFT_GFX_DRIVER_VERSION_ID_Attribute: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf34b9093_05e0_4b16_993d_3e2a2cde6ad3);
pub const MFT_HW_TIMESTAMP_WITH_QPC_Attribute: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8d030fb8_cc43_4258_a22e_9210bef89be4);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFT_INPUT_STREAM_INFO {
pub hnsMaxLatency: i64,
pub dwFlags: u32,
pub cbSize: u32,
pub cbMaxLookahead: u32,
pub cbAlignment: u32,
}
impl MFT_INPUT_STREAM_INFO {}
impl ::core::default::Default for MFT_INPUT_STREAM_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFT_INPUT_STREAM_INFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFT_INPUT_STREAM_INFO").field("hnsMaxLatency", &self.hnsMaxLatency).field("dwFlags", &self.dwFlags).field("cbSize", &self.cbSize).field("cbMaxLookahead", &self.cbMaxLookahead).field("cbAlignment", &self.cbAlignment).finish()
}
}
impl ::core::cmp::PartialEq for MFT_INPUT_STREAM_INFO {
fn eq(&self, other: &Self) -> bool {
self.hnsMaxLatency == other.hnsMaxLatency && self.dwFlags == other.dwFlags && self.cbSize == other.cbSize && self.cbMaxLookahead == other.cbMaxLookahead && self.cbAlignment == other.cbAlignment
}
}
impl ::core::cmp::Eq for MFT_INPUT_STREAM_INFO {}
unsafe impl ::windows::core::Abi for MFT_INPUT_STREAM_INFO {
type Abi = Self;
}
pub const MFT_INPUT_TYPES_Attributes: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4276c9b1_759d_4bf3_9cd0_0d723d138f96);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFT_MESSAGE_TYPE(pub i32);
pub const MFT_MESSAGE_COMMAND_FLUSH: MFT_MESSAGE_TYPE = MFT_MESSAGE_TYPE(0i32);
pub const MFT_MESSAGE_COMMAND_DRAIN: MFT_MESSAGE_TYPE = MFT_MESSAGE_TYPE(1i32);
pub const MFT_MESSAGE_SET_D3D_MANAGER: MFT_MESSAGE_TYPE = MFT_MESSAGE_TYPE(2i32);
pub const MFT_MESSAGE_DROP_SAMPLES: MFT_MESSAGE_TYPE = MFT_MESSAGE_TYPE(3i32);
pub const MFT_MESSAGE_COMMAND_TICK: MFT_MESSAGE_TYPE = MFT_MESSAGE_TYPE(4i32);
pub const MFT_MESSAGE_NOTIFY_BEGIN_STREAMING: MFT_MESSAGE_TYPE = MFT_MESSAGE_TYPE(268435456i32);
pub const MFT_MESSAGE_NOTIFY_END_STREAMING: MFT_MESSAGE_TYPE = MFT_MESSAGE_TYPE(268435457i32);
pub const MFT_MESSAGE_NOTIFY_END_OF_STREAM: MFT_MESSAGE_TYPE = MFT_MESSAGE_TYPE(268435458i32);
pub const MFT_MESSAGE_NOTIFY_START_OF_STREAM: MFT_MESSAGE_TYPE = MFT_MESSAGE_TYPE(268435459i32);
pub const MFT_MESSAGE_NOTIFY_RELEASE_RESOURCES: MFT_MESSAGE_TYPE = MFT_MESSAGE_TYPE(268435460i32);
pub const MFT_MESSAGE_NOTIFY_REACQUIRE_RESOURCES: MFT_MESSAGE_TYPE = MFT_MESSAGE_TYPE(268435461i32);
pub const MFT_MESSAGE_NOTIFY_EVENT: MFT_MESSAGE_TYPE = MFT_MESSAGE_TYPE(268435462i32);
pub const MFT_MESSAGE_COMMAND_SET_OUTPUT_STREAM_STATE: MFT_MESSAGE_TYPE = MFT_MESSAGE_TYPE(268435463i32);
pub const MFT_MESSAGE_COMMAND_FLUSH_OUTPUT_STREAM: MFT_MESSAGE_TYPE = MFT_MESSAGE_TYPE(268435464i32);
pub const MFT_MESSAGE_COMMAND_MARKER: MFT_MESSAGE_TYPE = MFT_MESSAGE_TYPE(536870912i32);
impl ::core::convert::From<i32> for MFT_MESSAGE_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFT_MESSAGE_TYPE {
type Abi = Self;
}
pub const MFT_OUTPUT_BOUND_UPPER_UNBOUNDED: u64 = 9223372036854775807u64;
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
pub struct MFT_OUTPUT_DATA_BUFFER {
pub dwStreamID: u32,
pub pSample: ::core::option::Option<IMFSample>,
pub dwStatus: u32,
pub pEvents: ::core::option::Option<IMFCollection>,
}
impl MFT_OUTPUT_DATA_BUFFER {}
impl ::core::default::Default for MFT_OUTPUT_DATA_BUFFER {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFT_OUTPUT_DATA_BUFFER {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFT_OUTPUT_DATA_BUFFER").field("dwStreamID", &self.dwStreamID).field("pSample", &self.pSample).field("dwStatus", &self.dwStatus).field("pEvents", &self.pEvents).finish()
}
}
impl ::core::cmp::PartialEq for MFT_OUTPUT_DATA_BUFFER {
fn eq(&self, other: &Self) -> bool {
self.dwStreamID == other.dwStreamID && self.pSample == other.pSample && self.dwStatus == other.dwStatus && self.pEvents == other.pEvents
}
}
impl ::core::cmp::Eq for MFT_OUTPUT_DATA_BUFFER {}
unsafe impl ::windows::core::Abi for MFT_OUTPUT_DATA_BUFFER {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFT_OUTPUT_STREAM_INFO {
pub dwFlags: u32,
pub cbSize: u32,
pub cbAlignment: u32,
}
impl MFT_OUTPUT_STREAM_INFO {}
impl ::core::default::Default for MFT_OUTPUT_STREAM_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFT_OUTPUT_STREAM_INFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFT_OUTPUT_STREAM_INFO").field("dwFlags", &self.dwFlags).field("cbSize", &self.cbSize).field("cbAlignment", &self.cbAlignment).finish()
}
}
impl ::core::cmp::PartialEq for MFT_OUTPUT_STREAM_INFO {
fn eq(&self, other: &Self) -> bool {
self.dwFlags == other.dwFlags && self.cbSize == other.cbSize && self.cbAlignment == other.cbAlignment
}
}
impl ::core::cmp::Eq for MFT_OUTPUT_STREAM_INFO {}
unsafe impl ::windows::core::Abi for MFT_OUTPUT_STREAM_INFO {
type Abi = Self;
}
pub const MFT_OUTPUT_TYPES_Attributes: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8eae8cf3_a44f_4306_ba5c_bf5dda242818);
pub const MFT_POLICY_SET_AWARE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5a633b19_cc39_4fa8_8ca5_59981b7a0018);
pub const MFT_PREFERRED_ENCODER_PROFILE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x53004909_1ef5_46d7_a18e_5a75f8b5905f);
pub const MFT_PREFERRED_OUTPUTTYPE_Attribute: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7e700499_396a_49ee_b1b4_f628021e8c9d);
pub const MFT_PROCESS_LOCAL_Attribute: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x543186e4_4649_4e65_b588_4aa352aff379);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFT_REGISTER_TYPE_INFO {
pub guidMajorType: ::windows::core::GUID,
pub guidSubtype: ::windows::core::GUID,
}
impl MFT_REGISTER_TYPE_INFO {}
impl ::core::default::Default for MFT_REGISTER_TYPE_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFT_REGISTER_TYPE_INFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFT_REGISTER_TYPE_INFO").field("guidMajorType", &self.guidMajorType).field("guidSubtype", &self.guidSubtype).finish()
}
}
impl ::core::cmp::PartialEq for MFT_REGISTER_TYPE_INFO {
fn eq(&self, other: &Self) -> bool {
self.guidMajorType == other.guidMajorType && self.guidSubtype == other.guidSubtype
}
}
impl ::core::cmp::Eq for MFT_REGISTER_TYPE_INFO {}
unsafe impl ::windows::core::Abi for MFT_REGISTER_TYPE_INFO {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct MFT_REGISTRATION_INFO {
pub clsid: ::windows::core::GUID,
pub guidCategory: ::windows::core::GUID,
pub uiFlags: u32,
pub pszName: super::super::Foundation::PWSTR,
pub cInTypes: u32,
pub pInTypes: *mut MFT_REGISTER_TYPE_INFO,
pub cOutTypes: u32,
pub pOutTypes: *mut MFT_REGISTER_TYPE_INFO,
}
#[cfg(feature = "Win32_Foundation")]
impl MFT_REGISTRATION_INFO {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for MFT_REGISTRATION_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for MFT_REGISTRATION_INFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFT_REGISTRATION_INFO")
.field("clsid", &self.clsid)
.field("guidCategory", &self.guidCategory)
.field("uiFlags", &self.uiFlags)
.field("pszName", &self.pszName)
.field("cInTypes", &self.cInTypes)
.field("pInTypes", &self.pInTypes)
.field("cOutTypes", &self.cOutTypes)
.field("pOutTypes", &self.pOutTypes)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for MFT_REGISTRATION_INFO {
fn eq(&self, other: &Self) -> bool {
self.clsid == other.clsid && self.guidCategory == other.guidCategory && self.uiFlags == other.uiFlags && self.pszName == other.pszName && self.cInTypes == other.cInTypes && self.pInTypes == other.pInTypes && self.cOutTypes == other.cOutTypes && self.pOutTypes == other.pOutTypes
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for MFT_REGISTRATION_INFO {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for MFT_REGISTRATION_INFO {
type Abi = Self;
}
pub const MFT_REMUX_MARK_I_PICTURE_AS_CLEAN_POINT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x364e8f85_3f2e_436c_b2a2_4440a012a9e8);
pub const MFT_STREAMS_UNLIMITED: u32 = 4294967295u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFT_STREAM_STATE_PARAM {
pub StreamId: u32,
pub State: MF_STREAM_STATE,
}
impl MFT_STREAM_STATE_PARAM {}
impl ::core::default::Default for MFT_STREAM_STATE_PARAM {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFT_STREAM_STATE_PARAM {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFT_STREAM_STATE_PARAM").field("StreamId", &self.StreamId).field("State", &self.State).finish()
}
}
impl ::core::cmp::PartialEq for MFT_STREAM_STATE_PARAM {
fn eq(&self, other: &Self) -> bool {
self.StreamId == other.StreamId && self.State == other.State
}
}
impl ::core::cmp::Eq for MFT_STREAM_STATE_PARAM {}
unsafe impl ::windows::core::Abi for MFT_STREAM_STATE_PARAM {
type Abi = Self;
}
pub const MFT_SUPPORT_3DVIDEO: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x093f81b1_4f2e_4631_8168_7934032a01d3);
pub const MFT_SUPPORT_DYNAMIC_FORMAT_CHANGE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x53476a11_3f13_49fb_ac42_ee2733c96741);
pub const MFT_TRANSFORM_CLSID_Attribute: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6821c42b_65a4_4e82_99bc_9a88205ecd0c);
pub const MFT_USING_HARDWARE_DRM: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x34faa77d_d79e_4957_b8ce_362b2684996c);
pub const MFTranscodeContainerType_3GP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x34c50167_4472_4f34_9ea0_c49fbacf037d);
pub const MFTranscodeContainerType_AC3: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6d8d91c3_8c91_4ed1_8742_8c347d5b44d0);
pub const MFTranscodeContainerType_ADTS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x132fd27d_0f02_43de_a301_38fbbbb3834e);
pub const MFTranscodeContainerType_AMR: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x025d5ad3_621a_475b_964d_66b1c824f079);
pub const MFTranscodeContainerType_ASF: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x430f6f6e_b6bf_4fc1_a0bd_9ee46eee2afb);
pub const MFTranscodeContainerType_AVI: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7edfe8af_402f_4d76_a33c_619fd157d0f1);
pub const MFTranscodeContainerType_FLAC: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x31344aa3_05a9_42b5_901b_8e9d4257f75e);
pub const MFTranscodeContainerType_FMPEG4: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9ba876f1_419f_4b77_a1e0_35959d9d4004);
pub const MFTranscodeContainerType_MP3: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe438b912_83f1_4de6_9e3a_9ffbc6dd24d1);
pub const MFTranscodeContainerType_MPEG2: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbfc2dbf9_7bb4_4f8f_afde_e112c44ba882);
pub const MFTranscodeContainerType_MPEG4: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdc6cd05d_b9d0_40ef_bd35_fa622c1ab28a);
pub const MFTranscodeContainerType_WAVE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x64c3453c_0f26_4741_be63_87bdf8bb935b);
#[inline]
pub unsafe fn MFTranscodeGetAudioOutputAvailableTypes<'a, Param2: ::windows::core::IntoParam<'a, IMFAttributes>>(guidsubtype: *const ::windows::core::GUID, dwmftflags: u32, pcodecconfig: Param2) -> ::windows::core::Result<IMFCollection> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFTranscodeGetAudioOutputAvailableTypes(guidsubtype: *const ::windows::core::GUID, dwmftflags: u32, pcodecconfig: ::windows::core::RawPtr, ppavailabletypes: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFCollection as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFTranscodeGetAudioOutputAvailableTypes(::core::mem::transmute(guidsubtype), ::core::mem::transmute(dwmftflags), pcodecconfig.into_param().abi(), &mut result__).from_abi::<IMFCollection>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFUnlockDXGIDeviceManager() -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFUnlockDXGIDeviceManager() -> ::windows::core::HRESULT;
}
MFUnlockDXGIDeviceManager().ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFUnlockPlatform() -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFUnlockPlatform() -> ::windows::core::HRESULT;
}
MFUnlockPlatform().ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFUnlockWorkQueue(dwworkqueue: u32) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFUnlockWorkQueue(dwworkqueue: u32) -> ::windows::core::HRESULT;
}
MFUnlockWorkQueue(::core::mem::transmute(dwworkqueue)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFUnregisterPlatformFromMMCSS() -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFUnregisterPlatformFromMMCSS() -> ::windows::core::HRESULT;
}
MFUnregisterPlatformFromMMCSS().ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn MFUnwrapMediaType<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaType>>(pwrap: Param0) -> ::windows::core::Result<IMFMediaType> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFUnwrapMediaType(pwrap: ::windows::core::RawPtr, pporig: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFUnwrapMediaType(pwrap.into_param().abi(), &mut result__).from_abi::<IMFMediaType>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct MFVIDEOFORMAT {
pub dwSize: u32,
pub videoInfo: MFVideoInfo,
pub guidFormat: ::windows::core::GUID,
pub compressedInfo: MFVideoCompressedInfo,
pub surfaceInfo: MFVideoSurfaceInfo,
}
#[cfg(feature = "Win32_Foundation")]
impl MFVIDEOFORMAT {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for MFVIDEOFORMAT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for MFVIDEOFORMAT {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for MFVIDEOFORMAT {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for MFVIDEOFORMAT {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFVP_MESSAGE_TYPE(pub i32);
pub const MFVP_MESSAGE_FLUSH: MFVP_MESSAGE_TYPE = MFVP_MESSAGE_TYPE(0i32);
pub const MFVP_MESSAGE_INVALIDATEMEDIATYPE: MFVP_MESSAGE_TYPE = MFVP_MESSAGE_TYPE(1i32);
pub const MFVP_MESSAGE_PROCESSINPUTNOTIFY: MFVP_MESSAGE_TYPE = MFVP_MESSAGE_TYPE(2i32);
pub const MFVP_MESSAGE_BEGINSTREAMING: MFVP_MESSAGE_TYPE = MFVP_MESSAGE_TYPE(3i32);
pub const MFVP_MESSAGE_ENDSTREAMING: MFVP_MESSAGE_TYPE = MFVP_MESSAGE_TYPE(4i32);
pub const MFVP_MESSAGE_ENDOFSTREAM: MFVP_MESSAGE_TYPE = MFVP_MESSAGE_TYPE(5i32);
pub const MFVP_MESSAGE_STEP: MFVP_MESSAGE_TYPE = MFVP_MESSAGE_TYPE(6i32);
pub const MFVP_MESSAGE_CANCELSTEP: MFVP_MESSAGE_TYPE = MFVP_MESSAGE_TYPE(7i32);
impl ::core::convert::From<i32> for MFVP_MESSAGE_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFVP_MESSAGE_TYPE {
type Abi = Self;
}
#[inline]
pub unsafe fn MFValidateMediaTypeSize<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::GUID>>(formattype: Param0, pblock: *const u8, cbsize: u32) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFValidateMediaTypeSize(formattype: ::windows::core::GUID, pblock: *const u8, cbsize: u32) -> ::windows::core::HRESULT;
}
MFValidateMediaTypeSize(formattype.into_param().abi(), ::core::mem::transmute(pblock), ::core::mem::transmute(cbsize)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFVideo3DFormat(pub i32);
pub const MFVideo3DSampleFormat_BaseView: MFVideo3DFormat = MFVideo3DFormat(0i32);
pub const MFVideo3DSampleFormat_MultiView: MFVideo3DFormat = MFVideo3DFormat(1i32);
pub const MFVideo3DSampleFormat_Packed_LeftRight: MFVideo3DFormat = MFVideo3DFormat(2i32);
pub const MFVideo3DSampleFormat_Packed_TopBottom: MFVideo3DFormat = MFVideo3DFormat(3i32);
impl ::core::convert::From<i32> for MFVideo3DFormat {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFVideo3DFormat {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFVideo3DSampleFormat(pub i32);
pub const MFSampleExtension_3DVideo_MultiView: MFVideo3DSampleFormat = MFVideo3DSampleFormat(1i32);
pub const MFSampleExtension_3DVideo_Packed: MFVideo3DSampleFormat = MFVideo3DSampleFormat(0i32);
impl ::core::convert::From<i32> for MFVideo3DSampleFormat {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFVideo3DSampleFormat {
type Abi = Self;
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9", feature = "Win32_Graphics_Gdi"))]
impl ::core::clone::Clone for MFVideoAlphaBitmap {
fn clone(&self) -> Self {
unimplemented!()
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9", feature = "Win32_Graphics_Gdi"))]
pub struct MFVideoAlphaBitmap {
pub GetBitmapFromDC: super::super::Foundation::BOOL,
pub bitmap: MFVideoAlphaBitmap_0,
pub params: MFVideoAlphaBitmapParams,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9", feature = "Win32_Graphics_Gdi"))]
impl MFVideoAlphaBitmap {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9", feature = "Win32_Graphics_Gdi"))]
impl ::core::default::Default for MFVideoAlphaBitmap {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9", feature = "Win32_Graphics_Gdi"))]
impl ::core::cmp::PartialEq for MFVideoAlphaBitmap {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9", feature = "Win32_Graphics_Gdi"))]
impl ::core::cmp::Eq for MFVideoAlphaBitmap {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9", feature = "Win32_Graphics_Gdi"))]
unsafe impl ::windows::core::Abi for MFVideoAlphaBitmap {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9", feature = "Win32_Graphics_Gdi"))]
impl ::core::clone::Clone for MFVideoAlphaBitmap_0 {
fn clone(&self) -> Self {
unimplemented!()
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9", feature = "Win32_Graphics_Gdi"))]
pub union MFVideoAlphaBitmap_0 {
pub hdc: super::super::Graphics::Gdi::HDC,
pub pDDS: ::windows::core::RawPtr,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9", feature = "Win32_Graphics_Gdi"))]
impl MFVideoAlphaBitmap_0 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9", feature = "Win32_Graphics_Gdi"))]
impl ::core::default::Default for MFVideoAlphaBitmap_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9", feature = "Win32_Graphics_Gdi"))]
impl ::core::cmp::PartialEq for MFVideoAlphaBitmap_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9", feature = "Win32_Graphics_Gdi"))]
impl ::core::cmp::Eq for MFVideoAlphaBitmap_0 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9", feature = "Win32_Graphics_Gdi"))]
unsafe impl ::windows::core::Abi for MFVideoAlphaBitmap_0 {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFVideoAlphaBitmapFlags(pub i32);
pub const MFVideoAlphaBitmap_EntireDDS: MFVideoAlphaBitmapFlags = MFVideoAlphaBitmapFlags(1i32);
pub const MFVideoAlphaBitmap_SrcColorKey: MFVideoAlphaBitmapFlags = MFVideoAlphaBitmapFlags(2i32);
pub const MFVideoAlphaBitmap_SrcRect: MFVideoAlphaBitmapFlags = MFVideoAlphaBitmapFlags(4i32);
pub const MFVideoAlphaBitmap_DestRect: MFVideoAlphaBitmapFlags = MFVideoAlphaBitmapFlags(8i32);
pub const MFVideoAlphaBitmap_FilterMode: MFVideoAlphaBitmapFlags = MFVideoAlphaBitmapFlags(16i32);
pub const MFVideoAlphaBitmap_Alpha: MFVideoAlphaBitmapFlags = MFVideoAlphaBitmapFlags(32i32);
pub const MFVideoAlphaBitmap_BitMask: MFVideoAlphaBitmapFlags = MFVideoAlphaBitmapFlags(63i32);
impl ::core::convert::From<i32> for MFVideoAlphaBitmapFlags {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFVideoAlphaBitmapFlags {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct MFVideoAlphaBitmapParams {
pub dwFlags: u32,
pub clrSrcKey: u32,
pub rcSrc: super::super::Foundation::RECT,
pub nrcDest: MFVideoNormalizedRect,
pub fAlpha: f32,
pub dwFilterMode: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl MFVideoAlphaBitmapParams {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for MFVideoAlphaBitmapParams {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for MFVideoAlphaBitmapParams {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFVideoAlphaBitmapParams").field("dwFlags", &self.dwFlags).field("clrSrcKey", &self.clrSrcKey).field("rcSrc", &self.rcSrc).field("nrcDest", &self.nrcDest).field("fAlpha", &self.fAlpha).field("dwFilterMode", &self.dwFilterMode).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for MFVideoAlphaBitmapParams {
fn eq(&self, other: &Self) -> bool {
self.dwFlags == other.dwFlags && self.clrSrcKey == other.clrSrcKey && self.rcSrc == other.rcSrc && self.nrcDest == other.nrcDest && self.fAlpha == other.fAlpha && self.dwFilterMode == other.dwFilterMode
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for MFVideoAlphaBitmapParams {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for MFVideoAlphaBitmapParams {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct MFVideoArea {
pub OffsetX: MFOffset,
pub OffsetY: MFOffset,
pub Area: super::super::Foundation::SIZE,
}
#[cfg(feature = "Win32_Foundation")]
impl MFVideoArea {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for MFVideoArea {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for MFVideoArea {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFVideoArea").field("OffsetX", &self.OffsetX).field("OffsetY", &self.OffsetY).field("Area", &self.Area).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for MFVideoArea {
fn eq(&self, other: &Self) -> bool {
self.OffsetX == other.OffsetX && self.OffsetY == other.OffsetY && self.Area == other.Area
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for MFVideoArea {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for MFVideoArea {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFVideoAspectRatioMode(pub i32);
pub const MFVideoARMode_None: MFVideoAspectRatioMode = MFVideoAspectRatioMode(0i32);
pub const MFVideoARMode_PreservePicture: MFVideoAspectRatioMode = MFVideoAspectRatioMode(1i32);
pub const MFVideoARMode_PreservePixel: MFVideoAspectRatioMode = MFVideoAspectRatioMode(2i32);
pub const MFVideoARMode_NonLinearStretch: MFVideoAspectRatioMode = MFVideoAspectRatioMode(4i32);
pub const MFVideoARMode_Mask: MFVideoAspectRatioMode = MFVideoAspectRatioMode(7i32);
impl ::core::convert::From<i32> for MFVideoAspectRatioMode {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFVideoAspectRatioMode {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFVideoChromaSubsampling(pub i32);
pub const MFVideoChromaSubsampling_Unknown: MFVideoChromaSubsampling = MFVideoChromaSubsampling(0i32);
pub const MFVideoChromaSubsampling_ProgressiveChroma: MFVideoChromaSubsampling = MFVideoChromaSubsampling(8i32);
pub const MFVideoChromaSubsampling_Horizontally_Cosited: MFVideoChromaSubsampling = MFVideoChromaSubsampling(4i32);
pub const MFVideoChromaSubsampling_Vertically_Cosited: MFVideoChromaSubsampling = MFVideoChromaSubsampling(2i32);
pub const MFVideoChromaSubsampling_Vertically_AlignedChromaPlanes: MFVideoChromaSubsampling = MFVideoChromaSubsampling(1i32);
pub const MFVideoChromaSubsampling_MPEG2: MFVideoChromaSubsampling = MFVideoChromaSubsampling(5i32);
pub const MFVideoChromaSubsampling_MPEG1: MFVideoChromaSubsampling = MFVideoChromaSubsampling(1i32);
pub const MFVideoChromaSubsampling_DV_PAL: MFVideoChromaSubsampling = MFVideoChromaSubsampling(6i32);
pub const MFVideoChromaSubsampling_Cosited: MFVideoChromaSubsampling = MFVideoChromaSubsampling(7i32);
pub const MFVideoChromaSubsampling_Last: MFVideoChromaSubsampling = MFVideoChromaSubsampling(8i32);
pub const MFVideoChromaSubsampling_ForceDWORD: MFVideoChromaSubsampling = MFVideoChromaSubsampling(2147483647i32);
impl ::core::convert::From<i32> for MFVideoChromaSubsampling {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFVideoChromaSubsampling {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFVideoCompressedInfo {
pub AvgBitrate: i64,
pub AvgBitErrorRate: i64,
pub MaxKeyFrameSpacing: u32,
}
impl MFVideoCompressedInfo {}
impl ::core::default::Default for MFVideoCompressedInfo {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFVideoCompressedInfo {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFVideoCompressedInfo").field("AvgBitrate", &self.AvgBitrate).field("AvgBitErrorRate", &self.AvgBitErrorRate).field("MaxKeyFrameSpacing", &self.MaxKeyFrameSpacing).finish()
}
}
impl ::core::cmp::PartialEq for MFVideoCompressedInfo {
fn eq(&self, other: &Self) -> bool {
self.AvgBitrate == other.AvgBitrate && self.AvgBitErrorRate == other.AvgBitErrorRate && self.MaxKeyFrameSpacing == other.MaxKeyFrameSpacing
}
}
impl ::core::cmp::Eq for MFVideoCompressedInfo {}
unsafe impl ::windows::core::Abi for MFVideoCompressedInfo {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFVideoDRMFlags(pub i32);
pub const MFVideoDRMFlag_None: MFVideoDRMFlags = MFVideoDRMFlags(0i32);
pub const MFVideoDRMFlag_AnalogProtected: MFVideoDRMFlags = MFVideoDRMFlags(1i32);
pub const MFVideoDRMFlag_DigitallyProtected: MFVideoDRMFlags = MFVideoDRMFlags(2i32);
impl ::core::convert::From<i32> for MFVideoDRMFlags {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFVideoDRMFlags {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFVideoDSPMode(pub i32);
pub const MFVideoDSPMode_Passthrough: MFVideoDSPMode = MFVideoDSPMode(1i32);
pub const MFVideoDSPMode_Stabilization: MFVideoDSPMode = MFVideoDSPMode(4i32);
impl ::core::convert::From<i32> for MFVideoDSPMode {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFVideoDSPMode {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFVideoFlags(pub i32);
pub const MFVideoFlag_PAD_TO_Mask: MFVideoFlags = MFVideoFlags(3i32);
pub const MFVideoFlag_PAD_TO_None: MFVideoFlags = MFVideoFlags(0i32);
pub const MFVideoFlag_PAD_TO_4x3: MFVideoFlags = MFVideoFlags(1i32);
pub const MFVideoFlag_PAD_TO_16x9: MFVideoFlags = MFVideoFlags(2i32);
pub const MFVideoFlag_SrcContentHintMask: MFVideoFlags = MFVideoFlags(28i32);
pub const MFVideoFlag_SrcContentHintNone: MFVideoFlags = MFVideoFlags(0i32);
pub const MFVideoFlag_SrcContentHint16x9: MFVideoFlags = MFVideoFlags(4i32);
pub const MFVideoFlag_SrcContentHint235_1: MFVideoFlags = MFVideoFlags(8i32);
pub const MFVideoFlag_AnalogProtected: MFVideoFlags = MFVideoFlags(32i32);
pub const MFVideoFlag_DigitallyProtected: MFVideoFlags = MFVideoFlags(64i32);
pub const MFVideoFlag_ProgressiveContent: MFVideoFlags = MFVideoFlags(128i32);
pub const MFVideoFlag_FieldRepeatCountMask: MFVideoFlags = MFVideoFlags(1792i32);
pub const MFVideoFlag_FieldRepeatCountShift: MFVideoFlags = MFVideoFlags(8i32);
pub const MFVideoFlag_ProgressiveSeqReset: MFVideoFlags = MFVideoFlags(2048i32);
pub const MFVideoFlag_PanScanEnabled: MFVideoFlags = MFVideoFlags(131072i32);
pub const MFVideoFlag_LowerFieldFirst: MFVideoFlags = MFVideoFlags(262144i32);
pub const MFVideoFlag_BottomUpLinearRep: MFVideoFlags = MFVideoFlags(524288i32);
pub const MFVideoFlags_DXVASurface: MFVideoFlags = MFVideoFlags(1048576i32);
pub const MFVideoFlags_RenderTargetSurface: MFVideoFlags = MFVideoFlags(4194304i32);
pub const MFVideoFlags_ForceQWORD: MFVideoFlags = MFVideoFlags(2147483647i32);
impl ::core::convert::From<i32> for MFVideoFlags {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFVideoFlags {
type Abi = Self;
}
pub const MFVideoFormat_420O: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4f303234_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_A16B16G16R16F: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000071_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_A2R10G10B10: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0000001f_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_AI44: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x34344941_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_ARGB32: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000015_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_AV1: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x31305641_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_AYUV: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x56555941_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_Base: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000000_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_Base_HDCP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xeac3b9d5_bd14_4237_8f1f_bab428e49312);
pub const MFVideoFormat_D16: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000050_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_DV25: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x35327664_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_DV50: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x30357664_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_DVH1: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x31687664_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_DVHD: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x64687664_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_DVSD: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x64737664_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_DVSL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6c737664_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_H263: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x33363248_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_H264: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x34363248_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_H264_ES: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3f40f4f0_5622_4ff8_b6d8_a17a584bee5e);
pub const MFVideoFormat_H264_HDCP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5d0ce9dd_9817_49da_bdfd_f5f5b98f18a6);
pub const MFVideoFormat_H265: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x35363248_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_HEVC: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x43564548_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_HEVC_ES: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x53564548_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_HEVC_HDCP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3cfe0fe6_05c4_47dc_9d70_4bdb2959720f);
pub const MFVideoFormat_I420: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x30323449_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_IYUV: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x56555949_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_L16: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000051_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_L8: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000032_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_M4S2: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3253344d_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_MJPG: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x47504a4d_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_MP43: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3334504d_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_MP4S: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5334504d_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_MP4V: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5634504d_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_MPEG2: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe06d8026_db46_11cf_b4d1_00805f6cbbea);
pub const MFVideoFormat_MPG1: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3147504d_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_MSS1: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3153534d_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_MSS2: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3253534d_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_NV11: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3131564e_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_NV12: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3231564e_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_NV21: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3132564e_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_ORAW: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5741524f_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_P010: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x30313050_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_P016: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x36313050_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_P210: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x30313250_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_P216: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x36313250_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_RGB24: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000014_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_RGB32: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000016_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_RGB555: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000018_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_RGB565: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000017_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_RGB8: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00000029_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_Theora: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6f656874_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_UYVY: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x59565955_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_VP10: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x30315056_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_VP80: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x30385056_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_VP90: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x30395056_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_WMV1: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x31564d57_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_WMV2: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x32564d57_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_WMV3: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x33564d57_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_WVC1: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x31435657_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_Y210: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x30313259_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_Y216: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x36313259_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_Y410: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x30313459_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_Y416: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x36313459_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_Y41P: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x50313459_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_Y41T: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x54313459_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_Y42T: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x54323459_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_YUY2: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x32595559_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_YV12: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x32315659_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_YVU9: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x39555659_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_YVYU: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x55595659_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_v210: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x30313276_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_v216: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x36313276_0000_0010_8000_00aa00389b71);
pub const MFVideoFormat_v410: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x30313476_0000_0010_8000_00aa00389b71);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct MFVideoInfo {
pub dwWidth: u32,
pub dwHeight: u32,
pub PixelAspectRatio: MFRatio,
pub SourceChromaSubsampling: MFVideoChromaSubsampling,
pub InterlaceMode: MFVideoInterlaceMode,
pub TransferFunction: MFVideoTransferFunction,
pub ColorPrimaries: MFVideoPrimaries,
pub TransferMatrix: MFVideoTransferMatrix,
pub SourceLighting: MFVideoLighting,
pub FramesPerSecond: MFRatio,
pub NominalRange: MFNominalRange,
pub GeometricAperture: MFVideoArea,
pub MinimumDisplayAperture: MFVideoArea,
pub PanScanAperture: MFVideoArea,
pub VideoFlags: u64,
}
#[cfg(feature = "Win32_Foundation")]
impl MFVideoInfo {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for MFVideoInfo {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for MFVideoInfo {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFVideoInfo")
.field("dwWidth", &self.dwWidth)
.field("dwHeight", &self.dwHeight)
.field("PixelAspectRatio", &self.PixelAspectRatio)
.field("SourceChromaSubsampling", &self.SourceChromaSubsampling)
.field("InterlaceMode", &self.InterlaceMode)
.field("TransferFunction", &self.TransferFunction)
.field("ColorPrimaries", &self.ColorPrimaries)
.field("TransferMatrix", &self.TransferMatrix)
.field("SourceLighting", &self.SourceLighting)
.field("FramesPerSecond", &self.FramesPerSecond)
.field("NominalRange", &self.NominalRange)
.field("GeometricAperture", &self.GeometricAperture)
.field("MinimumDisplayAperture", &self.MinimumDisplayAperture)
.field("PanScanAperture", &self.PanScanAperture)
.field("VideoFlags", &self.VideoFlags)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for MFVideoInfo {
fn eq(&self, other: &Self) -> bool {
self.dwWidth == other.dwWidth
&& self.dwHeight == other.dwHeight
&& self.PixelAspectRatio == other.PixelAspectRatio
&& self.SourceChromaSubsampling == other.SourceChromaSubsampling
&& self.InterlaceMode == other.InterlaceMode
&& self.TransferFunction == other.TransferFunction
&& self.ColorPrimaries == other.ColorPrimaries
&& self.TransferMatrix == other.TransferMatrix
&& self.SourceLighting == other.SourceLighting
&& self.FramesPerSecond == other.FramesPerSecond
&& self.NominalRange == other.NominalRange
&& self.GeometricAperture == other.GeometricAperture
&& self.MinimumDisplayAperture == other.MinimumDisplayAperture
&& self.PanScanAperture == other.PanScanAperture
&& self.VideoFlags == other.VideoFlags
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for MFVideoInfo {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for MFVideoInfo {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFVideoInterlaceMode(pub i32);
pub const MFVideoInterlace_Unknown: MFVideoInterlaceMode = MFVideoInterlaceMode(0i32);
pub const MFVideoInterlace_Progressive: MFVideoInterlaceMode = MFVideoInterlaceMode(2i32);
pub const MFVideoInterlace_FieldInterleavedUpperFirst: MFVideoInterlaceMode = MFVideoInterlaceMode(3i32);
pub const MFVideoInterlace_FieldInterleavedLowerFirst: MFVideoInterlaceMode = MFVideoInterlaceMode(4i32);
pub const MFVideoInterlace_FieldSingleUpper: MFVideoInterlaceMode = MFVideoInterlaceMode(5i32);
pub const MFVideoInterlace_FieldSingleLower: MFVideoInterlaceMode = MFVideoInterlaceMode(6i32);
pub const MFVideoInterlace_MixedInterlaceOrProgressive: MFVideoInterlaceMode = MFVideoInterlaceMode(7i32);
pub const MFVideoInterlace_Last: MFVideoInterlaceMode = MFVideoInterlaceMode(8i32);
pub const MFVideoInterlace_ForceDWORD: MFVideoInterlaceMode = MFVideoInterlaceMode(2147483647i32);
impl ::core::convert::From<i32> for MFVideoInterlaceMode {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFVideoInterlaceMode {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFVideoLighting(pub i32);
pub const MFVideoLighting_Unknown: MFVideoLighting = MFVideoLighting(0i32);
pub const MFVideoLighting_bright: MFVideoLighting = MFVideoLighting(1i32);
pub const MFVideoLighting_office: MFVideoLighting = MFVideoLighting(2i32);
pub const MFVideoLighting_dim: MFVideoLighting = MFVideoLighting(3i32);
pub const MFVideoLighting_dark: MFVideoLighting = MFVideoLighting(4i32);
pub const MFVideoLighting_Last: MFVideoLighting = MFVideoLighting(5i32);
pub const MFVideoLighting_ForceDWORD: MFVideoLighting = MFVideoLighting(2147483647i32);
impl ::core::convert::From<i32> for MFVideoLighting {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFVideoLighting {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFVideoMixPrefs(pub i32);
pub const MFVideoMixPrefs_ForceHalfInterlace: MFVideoMixPrefs = MFVideoMixPrefs(1i32);
pub const MFVideoMixPrefs_AllowDropToHalfInterlace: MFVideoMixPrefs = MFVideoMixPrefs(2i32);
pub const MFVideoMixPrefs_AllowDropToBob: MFVideoMixPrefs = MFVideoMixPrefs(4i32);
pub const MFVideoMixPrefs_ForceBob: MFVideoMixPrefs = MFVideoMixPrefs(8i32);
pub const MFVideoMixPrefs_EnableRotation: MFVideoMixPrefs = MFVideoMixPrefs(16i32);
pub const MFVideoMixPrefs_Mask: MFVideoMixPrefs = MFVideoMixPrefs(31i32);
impl ::core::convert::From<i32> for MFVideoMixPrefs {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFVideoMixPrefs {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFVideoNormalizedRect {
pub left: f32,
pub top: f32,
pub right: f32,
pub bottom: f32,
}
impl MFVideoNormalizedRect {}
impl ::core::default::Default for MFVideoNormalizedRect {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MFVideoNormalizedRect {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MFVideoNormalizedRect").field("left", &self.left).field("top", &self.top).field("right", &self.right).field("bottom", &self.bottom).finish()
}
}
impl ::core::cmp::PartialEq for MFVideoNormalizedRect {
fn eq(&self, other: &Self) -> bool {
self.left == other.left && self.top == other.top && self.right == other.right && self.bottom == other.bottom
}
}
impl ::core::cmp::Eq for MFVideoNormalizedRect {}
unsafe impl ::windows::core::Abi for MFVideoNormalizedRect {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFVideoPadFlags(pub i32);
pub const MFVideoPadFlag_PAD_TO_None: MFVideoPadFlags = MFVideoPadFlags(0i32);
pub const MFVideoPadFlag_PAD_TO_4x3: MFVideoPadFlags = MFVideoPadFlags(1i32);
pub const MFVideoPadFlag_PAD_TO_16x9: MFVideoPadFlags = MFVideoPadFlags(2i32);
impl ::core::convert::From<i32> for MFVideoPadFlags {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFVideoPadFlags {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFVideoPrimaries(pub i32);
pub const MFVideoPrimaries_Unknown: MFVideoPrimaries = MFVideoPrimaries(0i32);
pub const MFVideoPrimaries_reserved: MFVideoPrimaries = MFVideoPrimaries(1i32);
pub const MFVideoPrimaries_BT709: MFVideoPrimaries = MFVideoPrimaries(2i32);
pub const MFVideoPrimaries_BT470_2_SysM: MFVideoPrimaries = MFVideoPrimaries(3i32);
pub const MFVideoPrimaries_BT470_2_SysBG: MFVideoPrimaries = MFVideoPrimaries(4i32);
pub const MFVideoPrimaries_SMPTE170M: MFVideoPrimaries = MFVideoPrimaries(5i32);
pub const MFVideoPrimaries_SMPTE240M: MFVideoPrimaries = MFVideoPrimaries(6i32);
pub const MFVideoPrimaries_EBU3213: MFVideoPrimaries = MFVideoPrimaries(7i32);
pub const MFVideoPrimaries_SMPTE_C: MFVideoPrimaries = MFVideoPrimaries(8i32);
pub const MFVideoPrimaries_BT2020: MFVideoPrimaries = MFVideoPrimaries(9i32);
pub const MFVideoPrimaries_XYZ: MFVideoPrimaries = MFVideoPrimaries(10i32);
pub const MFVideoPrimaries_DCI_P3: MFVideoPrimaries = MFVideoPrimaries(11i32);
pub const MFVideoPrimaries_ACES: MFVideoPrimaries = MFVideoPrimaries(12i32);
pub const MFVideoPrimaries_Last: MFVideoPrimaries = MFVideoPrimaries(13i32);
pub const MFVideoPrimaries_ForceDWORD: MFVideoPrimaries = MFVideoPrimaries(2147483647i32);
impl ::core::convert::From<i32> for MFVideoPrimaries {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFVideoPrimaries {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFVideoRenderPrefs(pub i32);
pub const MFVideoRenderPrefs_DoNotRenderBorder: MFVideoRenderPrefs = MFVideoRenderPrefs(1i32);
pub const MFVideoRenderPrefs_DoNotClipToDevice: MFVideoRenderPrefs = MFVideoRenderPrefs(2i32);
pub const MFVideoRenderPrefs_AllowOutputThrottling: MFVideoRenderPrefs = MFVideoRenderPrefs(4i32);
pub const MFVideoRenderPrefs_ForceOutputThrottling: MFVideoRenderPrefs = MFVideoRenderPrefs(8i32);
pub const MFVideoRenderPrefs_ForceBatching: MFVideoRenderPrefs = MFVideoRenderPrefs(16i32);
pub const MFVideoRenderPrefs_AllowBatching: MFVideoRenderPrefs = MFVideoRenderPrefs(32i32);
pub const MFVideoRenderPrefs_ForceScaling: MFVideoRenderPrefs = MFVideoRenderPrefs(64i32);
pub const MFVideoRenderPrefs_AllowScaling: MFVideoRenderPrefs = MFVideoRenderPrefs(128i32);
pub const MFVideoRenderPrefs_DoNotRepaintOnStop: MFVideoRenderPrefs = MFVideoRenderPrefs(256i32);
pub const MFVideoRenderPrefs_Mask: MFVideoRenderPrefs = MFVideoRenderPrefs(511i32);
impl ::core::convert::From<i32> for MFVideoRenderPrefs {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFVideoRenderPrefs {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFVideoRotationFormat(pub i32);
pub const MFVideoRotationFormat_0: MFVideoRotationFormat = MFVideoRotationFormat(0i32);
pub const MFVideoRotationFormat_90: MFVideoRotationFormat = MFVideoRotationFormat(90i32);
pub const MFVideoRotationFormat_180: MFVideoRotationFormat = MFVideoRotationFormat(180i32);
pub const MFVideoRotationFormat_270: MFVideoRotationFormat = MFVideoRotationFormat(270i32);
impl ::core::convert::From<i32> for MFVideoRotationFormat {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFVideoRotationFormat {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFVideoSphericalFormat(pub i32);
pub const MFVideoSphericalFormat_Unsupported: MFVideoSphericalFormat = MFVideoSphericalFormat(0i32);
pub const MFVideoSphericalFormat_Equirectangular: MFVideoSphericalFormat = MFVideoSphericalFormat(1i32);
pub const MFVideoSphericalFormat_CubeMap: MFVideoSphericalFormat = MFVideoSphericalFormat(2i32);
pub const MFVideoSphericalFormat_3DMesh: MFVideoSphericalFormat = MFVideoSphericalFormat(3i32);
impl ::core::convert::From<i32> for MFVideoSphericalFormat {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFVideoSphericalFormat {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFVideoSphericalProjectionMode(pub i32);
pub const MFVideoSphericalProjectionMode_Spherical: MFVideoSphericalProjectionMode = MFVideoSphericalProjectionMode(0i32);
pub const MFVideoSphericalProjectionMode_Flat: MFVideoSphericalProjectionMode = MFVideoSphericalProjectionMode(1i32);
impl ::core::convert::From<i32> for MFVideoSphericalProjectionMode {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFVideoSphericalProjectionMode {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFVideoSrcContentHintFlags(pub i32);
pub const MFVideoSrcContentHintFlag_None: MFVideoSrcContentHintFlags = MFVideoSrcContentHintFlags(0i32);
pub const MFVideoSrcContentHintFlag_16x9: MFVideoSrcContentHintFlags = MFVideoSrcContentHintFlags(1i32);
pub const MFVideoSrcContentHintFlag_235_1: MFVideoSrcContentHintFlags = MFVideoSrcContentHintFlags(2i32);
impl ::core::convert::From<i32> for MFVideoSrcContentHintFlags {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFVideoSrcContentHintFlags {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MFVideoSurfaceInfo {
pub Format: u32,
pub PaletteEntries: u32,
pub Palette: [MFPaletteEntry; 1],
}
impl MFVideoSurfaceInfo {}
impl ::core::default::Default for MFVideoSurfaceInfo {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MFVideoSurfaceInfo {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MFVideoSurfaceInfo {}
unsafe impl ::windows::core::Abi for MFVideoSurfaceInfo {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFVideoTransferFunction(pub i32);
pub const MFVideoTransFunc_Unknown: MFVideoTransferFunction = MFVideoTransferFunction(0i32);
pub const MFVideoTransFunc_10: MFVideoTransferFunction = MFVideoTransferFunction(1i32);
pub const MFVideoTransFunc_18: MFVideoTransferFunction = MFVideoTransferFunction(2i32);
pub const MFVideoTransFunc_20: MFVideoTransferFunction = MFVideoTransferFunction(3i32);
pub const MFVideoTransFunc_22: MFVideoTransferFunction = MFVideoTransferFunction(4i32);
pub const MFVideoTransFunc_709: MFVideoTransferFunction = MFVideoTransferFunction(5i32);
pub const MFVideoTransFunc_240M: MFVideoTransferFunction = MFVideoTransferFunction(6i32);
pub const MFVideoTransFunc_sRGB: MFVideoTransferFunction = MFVideoTransferFunction(7i32);
pub const MFVideoTransFunc_28: MFVideoTransferFunction = MFVideoTransferFunction(8i32);
pub const MFVideoTransFunc_Log_100: MFVideoTransferFunction = MFVideoTransferFunction(9i32);
pub const MFVideoTransFunc_Log_316: MFVideoTransferFunction = MFVideoTransferFunction(10i32);
pub const MFVideoTransFunc_709_sym: MFVideoTransferFunction = MFVideoTransferFunction(11i32);
pub const MFVideoTransFunc_2020_const: MFVideoTransferFunction = MFVideoTransferFunction(12i32);
pub const MFVideoTransFunc_2020: MFVideoTransferFunction = MFVideoTransferFunction(13i32);
pub const MFVideoTransFunc_26: MFVideoTransferFunction = MFVideoTransferFunction(14i32);
pub const MFVideoTransFunc_2084: MFVideoTransferFunction = MFVideoTransferFunction(15i32);
pub const MFVideoTransFunc_HLG: MFVideoTransferFunction = MFVideoTransferFunction(16i32);
pub const MFVideoTransFunc_10_rel: MFVideoTransferFunction = MFVideoTransferFunction(17i32);
pub const MFVideoTransFunc_Last: MFVideoTransferFunction = MFVideoTransferFunction(18i32);
pub const MFVideoTransFunc_ForceDWORD: MFVideoTransferFunction = MFVideoTransferFunction(2147483647i32);
impl ::core::convert::From<i32> for MFVideoTransferFunction {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFVideoTransferFunction {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFVideoTransferMatrix(pub i32);
pub const MFVideoTransferMatrix_Unknown: MFVideoTransferMatrix = MFVideoTransferMatrix(0i32);
pub const MFVideoTransferMatrix_BT709: MFVideoTransferMatrix = MFVideoTransferMatrix(1i32);
pub const MFVideoTransferMatrix_BT601: MFVideoTransferMatrix = MFVideoTransferMatrix(2i32);
pub const MFVideoTransferMatrix_SMPTE240M: MFVideoTransferMatrix = MFVideoTransferMatrix(3i32);
pub const MFVideoTransferMatrix_BT2020_10: MFVideoTransferMatrix = MFVideoTransferMatrix(4i32);
pub const MFVideoTransferMatrix_BT2020_12: MFVideoTransferMatrix = MFVideoTransferMatrix(5i32);
pub const MFVideoTransferMatrix_Last: MFVideoTransferMatrix = MFVideoTransferMatrix(6i32);
pub const MFVideoTransferMatrix_ForceDWORD: MFVideoTransferMatrix = MFVideoTransferMatrix(2147483647i32);
impl ::core::convert::From<i32> for MFVideoTransferMatrix {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFVideoTransferMatrix {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MFWaveFormatExConvertFlags(pub i32);
pub const MFWaveFormatExConvertFlag_Normal: MFWaveFormatExConvertFlags = MFWaveFormatExConvertFlags(0i32);
pub const MFWaveFormatExConvertFlag_ForceExtensible: MFWaveFormatExConvertFlags = MFWaveFormatExConvertFlags(1i32);
impl ::core::convert::From<i32> for MFWaveFormatExConvertFlags {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MFWaveFormatExConvertFlags {
type Abi = Self;
}
#[inline]
pub unsafe fn MFWrapMediaType<'a, Param0: ::windows::core::IntoParam<'a, IMFMediaType>>(porig: Param0, majortype: *const ::windows::core::GUID, subtype: *const ::windows::core::GUID) -> ::windows::core::Result<IMFMediaType> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFWrapMediaType(porig: ::windows::core::RawPtr, majortype: *const ::windows::core::GUID, subtype: *const ::windows::core::GUID, ppwrap: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IMFMediaType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
MFWrapMediaType(porig.into_param().abi(), ::core::mem::transmute(majortype), ::core::mem::transmute(subtype), &mut result__).from_abi::<IMFMediaType>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
pub const MF_1024_BYTE_ALIGNMENT: u32 = 1023u32;
pub const MF_128_BYTE_ALIGNMENT: u32 = 127u32;
pub const MF_16_BYTE_ALIGNMENT: u32 = 15u32;
pub const MF_1_BYTE_ALIGNMENT: u32 = 0u32;
pub const MF_2048_BYTE_ALIGNMENT: u32 = 2047u32;
pub const MF_256_BYTE_ALIGNMENT: u32 = 255u32;
pub const MF_2_BYTE_ALIGNMENT: u32 = 1u32;
pub const MF_32_BYTE_ALIGNMENT: u32 = 31u32;
pub const MF_4096_BYTE_ALIGNMENT: u32 = 4095u32;
pub const MF_4_BYTE_ALIGNMENT: u32 = 3u32;
pub const MF_512_BYTE_ALIGNMENT: u32 = 511u32;
pub const MF_64_BYTE_ALIGNMENT: u32 = 63u32;
pub const MF_8192_BYTE_ALIGNMENT: u32 = 8191u32;
pub const MF_8_BYTE_ALIGNMENT: u32 = 7u32;
pub const MF_ACCESS_CONTROLLED_MEDIASOURCE_SERVICE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x014a5031_2f05_4c6a_9f9c_7d0dc4eda5f4);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_ACTIVATE_CUSTOM_MIXER(pub i32);
pub const MF_ACTIVATE_CUSTOM_MIXER_ALLOWFAIL: MF_ACTIVATE_CUSTOM_MIXER = MF_ACTIVATE_CUSTOM_MIXER(1i32);
impl ::core::convert::From<i32> for MF_ACTIVATE_CUSTOM_MIXER {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_ACTIVATE_CUSTOM_MIXER {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_ACTIVATE_CUSTOM_PRESENTER(pub i32);
pub const MF_ACTIVATE_CUSTOM_PRESENTER_ALLOWFAIL: MF_ACTIVATE_CUSTOM_PRESENTER = MF_ACTIVATE_CUSTOM_PRESENTER(1i32);
impl ::core::convert::From<i32> for MF_ACTIVATE_CUSTOM_PRESENTER {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_ACTIVATE_CUSTOM_PRESENTER {
type Abi = Self;
}
pub const MF_ACTIVATE_CUSTOM_VIDEO_MIXER_ACTIVATE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xba491361_be50_451e_95ab_6d4accc7dad8);
pub const MF_ACTIVATE_CUSTOM_VIDEO_MIXER_CLSID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xba491360_be50_451e_95ab_6d4accc7dad8);
pub const MF_ACTIVATE_CUSTOM_VIDEO_MIXER_FLAGS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xba491362_be50_451e_95ab_6d4accc7dad8);
pub const MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_ACTIVATE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xba491365_be50_451e_95ab_6d4accc7dad8);
pub const MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_CLSID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xba491364_be50_451e_95ab_6d4accc7dad8);
pub const MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_FLAGS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xba491366_be50_451e_95ab_6d4accc7dad8);
pub const MF_ACTIVATE_MFT_LOCKED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc1f6093c_7f65_4fbd_9e39_5faec3c4fbd7);
pub const MF_ACTIVATE_VIDEO_WINDOW: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9a2dbbdd_f57e_4162_82b9_6831377682d3);
pub const MF_API_VERSION: u32 = 112u32;
pub const MF_ASFPROFILE_MAXPACKETSIZE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x22587627_47de_4168_87f5_b5aa9b12a8f0);
pub const MF_ASFPROFILE_MINPACKETSIZE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x22587626_47de_4168_87f5_b5aa9b12a8f0);
pub const MF_ASFSTREAMCONFIG_LEAKYBUCKET1: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc69b5901_ea1a_4c9b_b692_e2a0d29a8add);
pub const MF_ASFSTREAMCONFIG_LEAKYBUCKET2: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc69b5902_ea1a_4c9b_b692_e2a0d29a8add);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_ATTRIBUTES_MATCH_TYPE(pub i32);
pub const MF_ATTRIBUTES_MATCH_OUR_ITEMS: MF_ATTRIBUTES_MATCH_TYPE = MF_ATTRIBUTES_MATCH_TYPE(0i32);
pub const MF_ATTRIBUTES_MATCH_THEIR_ITEMS: MF_ATTRIBUTES_MATCH_TYPE = MF_ATTRIBUTES_MATCH_TYPE(1i32);
pub const MF_ATTRIBUTES_MATCH_ALL_ITEMS: MF_ATTRIBUTES_MATCH_TYPE = MF_ATTRIBUTES_MATCH_TYPE(2i32);
pub const MF_ATTRIBUTES_MATCH_INTERSECTION: MF_ATTRIBUTES_MATCH_TYPE = MF_ATTRIBUTES_MATCH_TYPE(3i32);
pub const MF_ATTRIBUTES_MATCH_SMALLER: MF_ATTRIBUTES_MATCH_TYPE = MF_ATTRIBUTES_MATCH_TYPE(4i32);
impl ::core::convert::From<i32> for MF_ATTRIBUTES_MATCH_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_ATTRIBUTES_MATCH_TYPE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_ATTRIBUTE_SERIALIZE_OPTIONS(pub i32);
pub const MF_ATTRIBUTE_SERIALIZE_UNKNOWN_BYREF: MF_ATTRIBUTE_SERIALIZE_OPTIONS = MF_ATTRIBUTE_SERIALIZE_OPTIONS(1i32);
impl ::core::convert::From<i32> for MF_ATTRIBUTE_SERIALIZE_OPTIONS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_ATTRIBUTE_SERIALIZE_OPTIONS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_ATTRIBUTE_TYPE(pub i32);
pub const MF_ATTRIBUTE_UINT32: MF_ATTRIBUTE_TYPE = MF_ATTRIBUTE_TYPE(19i32);
pub const MF_ATTRIBUTE_UINT64: MF_ATTRIBUTE_TYPE = MF_ATTRIBUTE_TYPE(21i32);
pub const MF_ATTRIBUTE_DOUBLE: MF_ATTRIBUTE_TYPE = MF_ATTRIBUTE_TYPE(5i32);
pub const MF_ATTRIBUTE_GUID: MF_ATTRIBUTE_TYPE = MF_ATTRIBUTE_TYPE(72i32);
pub const MF_ATTRIBUTE_STRING: MF_ATTRIBUTE_TYPE = MF_ATTRIBUTE_TYPE(31i32);
pub const MF_ATTRIBUTE_BLOB: MF_ATTRIBUTE_TYPE = MF_ATTRIBUTE_TYPE(4113i32);
pub const MF_ATTRIBUTE_IUNKNOWN: MF_ATTRIBUTE_TYPE = MF_ATTRIBUTE_TYPE(13i32);
impl ::core::convert::From<i32> for MF_ATTRIBUTE_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_ATTRIBUTE_TYPE {
type Abi = Self;
}
pub const MF_AUDIO_RENDERER_ATTRIBUTE_ENDPOINT_ID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb10aaec3_ef71_4cc3_b873_05a9a08b9f8e);
pub const MF_AUDIO_RENDERER_ATTRIBUTE_ENDPOINT_ROLE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6ba644ff_27c5_4d02_9887_c28619fdb91b);
pub const MF_AUDIO_RENDERER_ATTRIBUTE_FLAGS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xede4b5e0_f805_4d6c_99b3_db01bf95dfab);
pub const MF_AUDIO_RENDERER_ATTRIBUTE_FLAGS_CROSSPROCESS: u32 = 1u32;
pub const MF_AUDIO_RENDERER_ATTRIBUTE_FLAGS_DONT_ALLOW_FORMAT_CHANGES: u32 = 4u32;
pub const MF_AUDIO_RENDERER_ATTRIBUTE_FLAGS_NOPERSIST: u32 = 2u32;
pub const MF_AUDIO_RENDERER_ATTRIBUTE_SESSION_ID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xede4b5e3_f805_4d6c_99b3_db01bf95dfab);
pub const MF_AUDIO_RENDERER_ATTRIBUTE_STREAM_CATEGORY: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa9770471_92ec_4df4_94fe_81c36f0c3a7a);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_AUVRHP_ROOMMODEL(pub i32);
pub const VRHP_SMALLROOM: MF_AUVRHP_ROOMMODEL = MF_AUVRHP_ROOMMODEL(0i32);
pub const VRHP_MEDIUMROOM: MF_AUVRHP_ROOMMODEL = MF_AUVRHP_ROOMMODEL(1i32);
pub const VRHP_BIGROOM: MF_AUVRHP_ROOMMODEL = MF_AUVRHP_ROOMMODEL(2i32);
pub const VRHP_CUSTUMIZEDROOM: MF_AUVRHP_ROOMMODEL = MF_AUVRHP_ROOMMODEL(3i32);
impl ::core::convert::From<i32> for MF_AUVRHP_ROOMMODEL {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_AUVRHP_ROOMMODEL {
type Abi = Self;
}
pub const MF_BD_MVC_PLANE_OFFSET_METADATA: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x62a654e4_b76c_4901_9823_2cb615d47318);
pub const MF_BOOT_DRIVER_VERIFICATION_FAILED: u32 = 1048576u32;
pub const MF_BYTESTREAMHANDLER_ACCEPTS_SHARE_WRITE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa6e1f733_3001_4915_8150_1558a2180ec8);
pub const MF_BYTESTREAM_CONTENT_TYPE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfc358289_3cb6_460c_a424_b6681260375a);
pub const MF_BYTESTREAM_DLNA_PROFILE_ID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfc35828d_3cb6_460c_a424_b6681260375a);
pub const MF_BYTESTREAM_DURATION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfc35828a_3cb6_460c_a424_b6681260375a);
pub const MF_BYTESTREAM_EFFECTIVE_URL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9afa0209_89d1_42af_8456_1de6b562d691);
pub const MF_BYTESTREAM_IFO_FILE_URI: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfc35828c_3cb6_460c_a424_b6681260375a);
pub const MF_BYTESTREAM_LAST_MODIFIED_TIME: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfc35828b_3cb6_460c_a424_b6681260375a);
pub const MF_BYTESTREAM_ORIGIN_NAME: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfc358288_3cb6_460c_a424_b6681260375a);
pub const MF_BYTESTREAM_SERVICE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xab025e2b_16d9_4180_a127_ba6c70156161);
pub const MF_BYTESTREAM_TRANSCODED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb6c5c282_4dc9_4db9_ab48_cf3b6d8bc5e0);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MF_BYTE_STREAM_CACHE_RANGE {
pub qwStartOffset: u64,
pub qwEndOffset: u64,
}
impl MF_BYTE_STREAM_CACHE_RANGE {}
impl ::core::default::Default for MF_BYTE_STREAM_CACHE_RANGE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MF_BYTE_STREAM_CACHE_RANGE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MF_BYTE_STREAM_CACHE_RANGE").field("qwStartOffset", &self.qwStartOffset).field("qwEndOffset", &self.qwEndOffset).finish()
}
}
impl ::core::cmp::PartialEq for MF_BYTE_STREAM_CACHE_RANGE {
fn eq(&self, other: &Self) -> bool {
self.qwStartOffset == other.qwStartOffset && self.qwEndOffset == other.qwEndOffset
}
}
impl ::core::cmp::Eq for MF_BYTE_STREAM_CACHE_RANGE {}
unsafe impl ::windows::core::Abi for MF_BYTE_STREAM_CACHE_RANGE {
type Abi = Self;
}
pub const MF_CAPTURE_ENGINE_ALL_EFFECTS_REMOVED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfded7521_8ed8_431a_a96b_f3e2565e981c);
pub const MF_CAPTURE_ENGINE_AUDIO_PROCESSING: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x10f1be5e_7e11_410b_973d_f4b6109000fe);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_CAPTURE_ENGINE_AUDIO_PROCESSING_MODE(pub i32);
pub const MF_CAPTURE_ENGINE_AUDIO_PROCESSING_DEFAULT: MF_CAPTURE_ENGINE_AUDIO_PROCESSING_MODE = MF_CAPTURE_ENGINE_AUDIO_PROCESSING_MODE(0i32);
pub const MF_CAPTURE_ENGINE_AUDIO_PROCESSING_RAW: MF_CAPTURE_ENGINE_AUDIO_PROCESSING_MODE = MF_CAPTURE_ENGINE_AUDIO_PROCESSING_MODE(1i32);
impl ::core::convert::From<i32> for MF_CAPTURE_ENGINE_AUDIO_PROCESSING_MODE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_CAPTURE_ENGINE_AUDIO_PROCESSING_MODE {
type Abi = Self;
}
pub const MF_CAPTURE_ENGINE_CAMERA_STREAM_BLOCKED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa4209417_8d39_46f3_b759_5912528f4207);
pub const MF_CAPTURE_ENGINE_CAMERA_STREAM_UNBLOCKED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9be9eef0_cdaf_4717_8564_834aae66415c);
pub const MF_CAPTURE_ENGINE_D3D_MANAGER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x76e25e7b_d595_4283_962c_c594afd78ddf);
pub const MF_CAPTURE_ENGINE_DECODER_MFT_FIELDOFUSE_UNLOCK_Attribute: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2b8ad2e8_7acb_4321_a606_325c4249f4fc);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_CAPTURE_ENGINE_DEVICE_TYPE(pub i32);
pub const MF_CAPTURE_ENGINE_DEVICE_TYPE_AUDIO: MF_CAPTURE_ENGINE_DEVICE_TYPE = MF_CAPTURE_ENGINE_DEVICE_TYPE(0i32);
pub const MF_CAPTURE_ENGINE_DEVICE_TYPE_VIDEO: MF_CAPTURE_ENGINE_DEVICE_TYPE = MF_CAPTURE_ENGINE_DEVICE_TYPE(1i32);
impl ::core::convert::From<i32> for MF_CAPTURE_ENGINE_DEVICE_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_CAPTURE_ENGINE_DEVICE_TYPE {
type Abi = Self;
}
pub const MF_CAPTURE_ENGINE_DISABLE_DXVA: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf9818862_179d_433f_a32f_74cbcf74466d);
pub const MF_CAPTURE_ENGINE_DISABLE_HARDWARE_TRANSFORMS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb7c42a6b_3207_4495_b4e7_81f9c35d5991);
pub const MF_CAPTURE_ENGINE_EFFECT_ADDED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xaa8dc7b5_a048_4e13_8ebe_f23c46c830c1);
pub const MF_CAPTURE_ENGINE_EFFECT_REMOVED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc6e8db07_fb09_4a48_89c6_bf92a04222c9);
pub const MF_CAPTURE_ENGINE_ENABLE_CAMERA_STREAMSTATE_NOTIFICATION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4c808e9d_aaed_4713_90fb_cb24064ab8da);
pub const MF_CAPTURE_ENGINE_ENCODER_MFT_FIELDOFUSE_UNLOCK_Attribute: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x54c63a00_78d5_422f_aa3e_5e99ac649269);
pub const MF_CAPTURE_ENGINE_ERROR: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x46b89fc6_33cc_4399_9dad_784de77d587c);
pub const MF_CAPTURE_ENGINE_EVENT_GENERATOR_GUID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xabfa8ad5_fc6d_4911_87e0_961945f8f7ce);
pub const MF_CAPTURE_ENGINE_EVENT_STREAM_INDEX: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x82697f44_b1cf_42eb_9753_f86d649c8865);
pub const MF_CAPTURE_ENGINE_INITIALIZED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x219992bc_cf92_4531_a1ae_96e1e886c8f1);
pub const MF_CAPTURE_ENGINE_MEDIASOURCE_CONFIG: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbc6989d2_0fc1_46e1_a74f_efd36bc788de);
pub const MF_CAPTURE_ENGINE_MEDIA_CATEGORY: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8e3f5bd5_dbbf_42f0_8542_d07a3971762a);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_CAPTURE_ENGINE_MEDIA_CATEGORY_TYPE(pub i32);
pub const MF_CAPTURE_ENGINE_MEDIA_CATEGORY_TYPE_OTHER: MF_CAPTURE_ENGINE_MEDIA_CATEGORY_TYPE = MF_CAPTURE_ENGINE_MEDIA_CATEGORY_TYPE(0i32);
pub const MF_CAPTURE_ENGINE_MEDIA_CATEGORY_TYPE_COMMUNICATIONS: MF_CAPTURE_ENGINE_MEDIA_CATEGORY_TYPE = MF_CAPTURE_ENGINE_MEDIA_CATEGORY_TYPE(1i32);
pub const MF_CAPTURE_ENGINE_MEDIA_CATEGORY_TYPE_MEDIA: MF_CAPTURE_ENGINE_MEDIA_CATEGORY_TYPE = MF_CAPTURE_ENGINE_MEDIA_CATEGORY_TYPE(2i32);
pub const MF_CAPTURE_ENGINE_MEDIA_CATEGORY_TYPE_GAMECHAT: MF_CAPTURE_ENGINE_MEDIA_CATEGORY_TYPE = MF_CAPTURE_ENGINE_MEDIA_CATEGORY_TYPE(3i32);
pub const MF_CAPTURE_ENGINE_MEDIA_CATEGORY_TYPE_SPEECH: MF_CAPTURE_ENGINE_MEDIA_CATEGORY_TYPE = MF_CAPTURE_ENGINE_MEDIA_CATEGORY_TYPE(4i32);
pub const MF_CAPTURE_ENGINE_MEDIA_CATEGORY_TYPE_FARFIELDSPEECH: MF_CAPTURE_ENGINE_MEDIA_CATEGORY_TYPE = MF_CAPTURE_ENGINE_MEDIA_CATEGORY_TYPE(5i32);
pub const MF_CAPTURE_ENGINE_MEDIA_CATEGORY_TYPE_UNIFORMSPEECH: MF_CAPTURE_ENGINE_MEDIA_CATEGORY_TYPE = MF_CAPTURE_ENGINE_MEDIA_CATEGORY_TYPE(6i32);
pub const MF_CAPTURE_ENGINE_MEDIA_CATEGORY_TYPE_VOICETYPING: MF_CAPTURE_ENGINE_MEDIA_CATEGORY_TYPE = MF_CAPTURE_ENGINE_MEDIA_CATEGORY_TYPE(7i32);
impl ::core::convert::From<i32> for MF_CAPTURE_ENGINE_MEDIA_CATEGORY_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_CAPTURE_ENGINE_MEDIA_CATEGORY_TYPE {
type Abi = Self;
}
pub const MF_CAPTURE_ENGINE_OUTPUT_MEDIA_TYPE_SET: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xcaaad994_83ec_45e9_a30a_1f20aadb9831);
pub const MF_CAPTURE_ENGINE_PHOTO_TAKEN: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3c50c445_7304_48eb_865d_bba19ba3af5c);
pub const MF_CAPTURE_ENGINE_PREVIEW_STARTED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa416df21_f9d3_4a74_991b_b817298952c4);
pub const MF_CAPTURE_ENGINE_PREVIEW_STOPPED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x13d5143c_1edd_4e50_a2ef_350a47678060);
pub const MF_CAPTURE_ENGINE_RECORD_SINK_AUDIO_MAX_PROCESSED_SAMPLES: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9896e12a_f707_4500_b6bd_db8eb810b50f);
pub const MF_CAPTURE_ENGINE_RECORD_SINK_AUDIO_MAX_UNPROCESSED_SAMPLES: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1cddb141_a7f4_4d58_9896_4d15a53c4efe);
pub const MF_CAPTURE_ENGINE_RECORD_SINK_VIDEO_MAX_PROCESSED_SAMPLES: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe7b4a49e_382c_4aef_a946_aed5490b7111);
pub const MF_CAPTURE_ENGINE_RECORD_SINK_VIDEO_MAX_UNPROCESSED_SAMPLES: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb467f705_7913_4894_9d42_a215fea23da9);
pub const MF_CAPTURE_ENGINE_RECORD_STARTED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xac2b027b_ddf9_48a0_89be_38ab35ef45c0);
pub const MF_CAPTURE_ENGINE_RECORD_STOPPED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x55e5200a_f98f_4c0d_a9ec_9eb25ed3d773);
pub const MF_CAPTURE_ENGINE_SELECTEDCAMERAPROFILE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x03160b7e_1c6f_4db2_ad56_a7c430f82392);
pub const MF_CAPTURE_ENGINE_SELECTEDCAMERAPROFILE_INDEX: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3ce88613_2214_46c3_b417_82f8a313c9c3);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_CAPTURE_ENGINE_SINK_TYPE(pub i32);
pub const MF_CAPTURE_ENGINE_SINK_TYPE_RECORD: MF_CAPTURE_ENGINE_SINK_TYPE = MF_CAPTURE_ENGINE_SINK_TYPE(0i32);
pub const MF_CAPTURE_ENGINE_SINK_TYPE_PREVIEW: MF_CAPTURE_ENGINE_SINK_TYPE = MF_CAPTURE_ENGINE_SINK_TYPE(1i32);
pub const MF_CAPTURE_ENGINE_SINK_TYPE_PHOTO: MF_CAPTURE_ENGINE_SINK_TYPE = MF_CAPTURE_ENGINE_SINK_TYPE(2i32);
impl ::core::convert::From<i32> for MF_CAPTURE_ENGINE_SINK_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_CAPTURE_ENGINE_SINK_TYPE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_CAPTURE_ENGINE_SOURCE(pub u32);
pub const MF_CAPTURE_ENGINE_PREFERRED_SOURCE_STREAM_FOR_VIDEO_PREVIEW: MF_CAPTURE_ENGINE_SOURCE = MF_CAPTURE_ENGINE_SOURCE(4294967290u32);
pub const MF_CAPTURE_ENGINE_PREFERRED_SOURCE_STREAM_FOR_VIDEO_RECORD: MF_CAPTURE_ENGINE_SOURCE = MF_CAPTURE_ENGINE_SOURCE(4294967289u32);
pub const MF_CAPTURE_ENGINE_PREFERRED_SOURCE_STREAM_FOR_PHOTO: MF_CAPTURE_ENGINE_SOURCE = MF_CAPTURE_ENGINE_SOURCE(4294967288u32);
pub const MF_CAPTURE_ENGINE_PREFERRED_SOURCE_STREAM_FOR_AUDIO: MF_CAPTURE_ENGINE_SOURCE = MF_CAPTURE_ENGINE_SOURCE(4294967287u32);
pub const MF_CAPTURE_ENGINE_PREFERRED_SOURCE_STREAM_FOR_METADATA: MF_CAPTURE_ENGINE_SOURCE = MF_CAPTURE_ENGINE_SOURCE(4294967286u32);
pub const MF_CAPTURE_ENGINE_MEDIASOURCE: MF_CAPTURE_ENGINE_SOURCE = MF_CAPTURE_ENGINE_SOURCE(4294967295u32);
impl ::core::convert::From<u32> for MF_CAPTURE_ENGINE_SOURCE {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_CAPTURE_ENGINE_SOURCE {
type Abi = Self;
}
impl ::core::ops::BitOr for MF_CAPTURE_ENGINE_SOURCE {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for MF_CAPTURE_ENGINE_SOURCE {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for MF_CAPTURE_ENGINE_SOURCE {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for MF_CAPTURE_ENGINE_SOURCE {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for MF_CAPTURE_ENGINE_SOURCE {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_CAPTURE_ENGINE_STREAM_CATEGORY(pub i32);
pub const MF_CAPTURE_ENGINE_STREAM_CATEGORY_VIDEO_PREVIEW: MF_CAPTURE_ENGINE_STREAM_CATEGORY = MF_CAPTURE_ENGINE_STREAM_CATEGORY(0i32);
pub const MF_CAPTURE_ENGINE_STREAM_CATEGORY_VIDEO_CAPTURE: MF_CAPTURE_ENGINE_STREAM_CATEGORY = MF_CAPTURE_ENGINE_STREAM_CATEGORY(1i32);
pub const MF_CAPTURE_ENGINE_STREAM_CATEGORY_PHOTO_INDEPENDENT: MF_CAPTURE_ENGINE_STREAM_CATEGORY = MF_CAPTURE_ENGINE_STREAM_CATEGORY(2i32);
pub const MF_CAPTURE_ENGINE_STREAM_CATEGORY_PHOTO_DEPENDENT: MF_CAPTURE_ENGINE_STREAM_CATEGORY = MF_CAPTURE_ENGINE_STREAM_CATEGORY(3i32);
pub const MF_CAPTURE_ENGINE_STREAM_CATEGORY_AUDIO: MF_CAPTURE_ENGINE_STREAM_CATEGORY = MF_CAPTURE_ENGINE_STREAM_CATEGORY(4i32);
pub const MF_CAPTURE_ENGINE_STREAM_CATEGORY_UNSUPPORTED: MF_CAPTURE_ENGINE_STREAM_CATEGORY = MF_CAPTURE_ENGINE_STREAM_CATEGORY(5i32);
pub const MF_CAPTURE_ENGINE_STREAM_CATEGORY_METADATA: MF_CAPTURE_ENGINE_STREAM_CATEGORY = MF_CAPTURE_ENGINE_STREAM_CATEGORY(6i32);
impl ::core::convert::From<i32> for MF_CAPTURE_ENGINE_STREAM_CATEGORY {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_CAPTURE_ENGINE_STREAM_CATEGORY {
type Abi = Self;
}
pub const MF_CAPTURE_ENGINE_USE_AUDIO_DEVICE_ONLY: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1c8077da_8466_4dc4_8b8e_276b3f85923b);
pub const MF_CAPTURE_ENGINE_USE_VIDEO_DEVICE_ONLY: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7e025171_cf32_4f2e_8f19_410577b73a66);
pub const MF_CAPTURE_METADATA_DIGITALWINDOW: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x276f72a2_59c8_4f69_97b4_068b8c0ec044);
pub const MF_CAPTURE_METADATA_EXIF: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2e9575b8_8c31_4a02_8575_42b197b71592);
pub const MF_CAPTURE_METADATA_EXPOSURE_COMPENSATION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd198aa75_4b62_4345_abf3_3c31fa12c299);
pub const MF_CAPTURE_METADATA_EXPOSURE_TIME: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x16b9ae99_cd84_4063_879d_a28c7633729e);
pub const MF_CAPTURE_METADATA_FACEROICHARACTERIZATIONS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb927a1a8_18ef_46d3_b3af_69372f94d9b2);
pub const MF_CAPTURE_METADATA_FACEROIS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x864f25a6_349f_46b1_a30e_54cc22928a47);
pub const MF_CAPTURE_METADATA_FACEROITIMESTAMPS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe94d50cc_3da0_44d4_bb34_83198a741868);
pub const MF_CAPTURE_METADATA_FIRST_SCANLINE_START_TIME_QPC: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6a2c49f1_e052_46b6_b2d9_73c1558709af);
pub const MF_CAPTURE_METADATA_FLASH: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4a51520b_fb36_446c_9df2_68171b9a0389);
pub const MF_CAPTURE_METADATA_FLASH_POWER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9c0e0d49_0205_491a_bc9d_2d6e1f4d5684);
pub const MF_CAPTURE_METADATA_FOCUSSTATE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa87ee154_997f_465d_b91f_29d53b982b88);
pub const MF_CAPTURE_METADATA_FRAME_BACKGROUND_MASK: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x03f14dd3_75dd_433a_a8e2_1e3f5f2a50a0);
pub const MF_CAPTURE_METADATA_FRAME_ILLUMINATION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6d688ffc_63d3_46fe_bada_5b947db0d080);
pub const MF_CAPTURE_METADATA_FRAME_RAWSTREAM: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9252077b_2680_49b9_ae02_b19075973b70);
pub const MF_CAPTURE_METADATA_HISTOGRAM: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x85358432_2ef6_4ba9_a3fb_06d82974b895);
pub const MF_CAPTURE_METADATA_ISO_GAINS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x05802ac9_0e1d_41c7_a8c8_7e7369f84e1e);
pub const MF_CAPTURE_METADATA_ISO_SPEED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe528a68f_b2e3_44fe_8b65_07bf4b5a13ff);
pub const MF_CAPTURE_METADATA_LAST_SCANLINE_END_TIME_QPC: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdccadecb_c4d4_400d_b418_10e88525e1f6);
pub const MF_CAPTURE_METADATA_LENS_POSITION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb5fc8e86_11d1_4e70_819b_723a89fa4520);
pub const MF_CAPTURE_METADATA_PHOTO_FRAME_FLASH: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0f9dd6c6_6003_45d8_bd59_f1f53e3d04e8);
pub const MF_CAPTURE_METADATA_REQUESTED_FRAME_SETTING_ID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbb3716d9_8a61_47a4_8197_459c7ff174d5);
pub const MF_CAPTURE_METADATA_SCANLINE_DIRECTION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6496a3ba_1907_49e6_b0c3_123795f380a9);
pub const MF_CAPTURE_METADATA_SCANLINE_TIME_QPC_ACCURACY: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4cd79c51_f765_4b09_b1e1_27d1f7ebea09);
pub const MF_CAPTURE_METADATA_SCENE_MODE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9cc3b54d_5ed3_4bae_b388_7670aef59e13);
pub const MF_CAPTURE_METADATA_SENSORFRAMERATE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdb51357e_9d3d_4962_b06d_07ce650d9a0a);
pub const MF_CAPTURE_METADATA_UVC_PAYLOADHEADER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf9f88a87_e1dd_441e_95cb_42e21a64f1d9);
pub const MF_CAPTURE_METADATA_WHITEBALANCE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc736fd77_0fb9_4e2e_97a2_fcd490739ee9);
pub const MF_CAPTURE_METADATA_WHITEBALANCE_GAINS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe7570c8f_2dcb_4c7c_aace_22ece7cce647);
pub const MF_CAPTURE_METADATA_ZOOMFACTOR: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe50b0b81_e501_42c2_abf2_857ecb13fa5c);
pub const MF_CAPTURE_SINK_PREPARED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7bfce257_12b1_4409_8c34_d445daab7578);
pub const MF_CAPTURE_SOURCE_CURRENT_DEVICE_MEDIA_TYPE_SET: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe7e75e4c_039c_4410_815b_8741307b63aa);
pub const MF_COMPONENT_CERT_REVOKED: u32 = 32768u32;
pub const MF_COMPONENT_HS_CERT_REVOKED: u32 = 131072u32;
pub const MF_COMPONENT_INVALID_EKU: u32 = 16384u32;
pub const MF_COMPONENT_INVALID_ROOT: u32 = 65536u32;
pub const MF_COMPONENT_LS_CERT_REVOKED: u32 = 262144u32;
pub const MF_COMPONENT_REVOKED: u32 = 8192u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_CONNECT_METHOD(pub i32);
pub const MF_CONNECT_DIRECT: MF_CONNECT_METHOD = MF_CONNECT_METHOD(0i32);
pub const MF_CONNECT_ALLOW_CONVERTER: MF_CONNECT_METHOD = MF_CONNECT_METHOD(1i32);
pub const MF_CONNECT_ALLOW_DECODER: MF_CONNECT_METHOD = MF_CONNECT_METHOD(3i32);
pub const MF_CONNECT_RESOLVE_INDEPENDENT_OUTPUTTYPES: MF_CONNECT_METHOD = MF_CONNECT_METHOD(4i32);
pub const MF_CONNECT_AS_OPTIONAL: MF_CONNECT_METHOD = MF_CONNECT_METHOD(65536i32);
pub const MF_CONNECT_AS_OPTIONAL_BRANCH: MF_CONNECT_METHOD = MF_CONNECT_METHOD(131072i32);
impl ::core::convert::From<i32> for MF_CONNECT_METHOD {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_CONNECT_METHOD {
type Abi = Self;
}
pub const MF_CONTENTDECRYPTIONMODULE_SERVICE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x15320c45_ff80_484a_9dcb_0df894e69a01);
pub const MF_CONTENT_DECRYPTOR_SERVICE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x68a72927_fc7b_44ee_85f4_7c51bd55a659);
pub const MF_CONTENT_PROTECTION_DEVICE_SERVICE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xff58436f_76a0_41fe_b566_10cc53962edd);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_CROSS_ORIGIN_POLICY(pub i32);
pub const MF_CROSS_ORIGIN_POLICY_NONE: MF_CROSS_ORIGIN_POLICY = MF_CROSS_ORIGIN_POLICY(0i32);
pub const MF_CROSS_ORIGIN_POLICY_ANONYMOUS: MF_CROSS_ORIGIN_POLICY = MF_CROSS_ORIGIN_POLICY(1i32);
pub const MF_CROSS_ORIGIN_POLICY_USE_CREDENTIALS: MF_CROSS_ORIGIN_POLICY = MF_CROSS_ORIGIN_POLICY(2i32);
impl ::core::convert::From<i32> for MF_CROSS_ORIGIN_POLICY {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_CROSS_ORIGIN_POLICY {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_CUSTOM_DECODE_UNIT_TYPE(pub i32);
pub const MF_DECODE_UNIT_NAL: MF_CUSTOM_DECODE_UNIT_TYPE = MF_CUSTOM_DECODE_UNIT_TYPE(0i32);
pub const MF_DECODE_UNIT_SEI: MF_CUSTOM_DECODE_UNIT_TYPE = MF_CUSTOM_DECODE_UNIT_TYPE(1i32);
impl ::core::convert::From<i32> for MF_CUSTOM_DECODE_UNIT_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_CUSTOM_DECODE_UNIT_TYPE {
type Abi = Self;
}
pub const MF_D3D12_SYNCHRONIZATION_OBJECT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2a7c8d6a_85a6_494d_a046_06ea1a138f4b);
pub const MF_DECODER_FWD_CUSTOM_SEI_DECODE_ORDER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf13bbe3c_36d4_410a_b985_7a951a1e6294);
pub const MF_DEVICEMFT_CONNECTED_FILTER_KSCONTROL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6a2c4fa6_d179_41cd_9523_822371ea40e5);
pub const MF_DEVICEMFT_CONNECTED_PIN_KSCONTROL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe63310f7_b244_4ef8_9a7d_24c74e32ebd0);
pub const MF_DEVICEMFT_EXTENSION_PLUGIN_CLSID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0844dbae_34fa_48a0_a783_8e696fb1c9a8);
pub const MF_DEVICEMFT_SENSORPROFILE_COLLECTION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x36ebdc44_b12c_441b_89f4_08b2f41a9cfc);
pub const MF_DEVICESTREAM_ATTRIBUTE_FACEAUTH_CAPABILITY: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xcb6fd12a_2248_4e41_ad46_e78bb90ab9fc);
pub const MF_DEVICESTREAM_ATTRIBUTE_FRAMESOURCE_TYPES: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x17145fd1_1b2b_423c_8001_2b6833ed3588);
pub const MF_DEVICESTREAM_ATTRIBUTE_SECURE_CAPABILITY: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x940fd626_ea6e_4684_9840_36bd6ec9fbef);
pub const MF_DEVICESTREAM_EXTENSION_PLUGIN_CLSID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x048e6558_60c4_4173_bd5b_6a3ca2896aee);
pub const MF_DEVICESTREAM_EXTENSION_PLUGIN_CONNECTION_POINT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x37f9375c_e664_4ea4_aae4_cb6d1daca1f4);
pub const MF_DEVICESTREAM_FILTER_KSCONTROL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x46783cca_3df5_4923_a9ef_36b7223edde0);
pub const MF_DEVICESTREAM_FRAMESERVER_HIDDEN: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf402567b_4d91_4179_96d1_74c8480c2034);
pub const MF_DEVICESTREAM_FRAMESERVER_SHARED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1cb378e9_b279_41d4_af97_34a243e68320);
pub const MF_DEVICESTREAM_IMAGE_STREAM: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa7ffb865_e7b2_43b0_9f6f_9af2a0e50fc0);
pub const MF_DEVICESTREAM_INDEPENDENT_IMAGE_STREAM: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x03eeec7e_d605_4576_8b29_6580b490d7d3);
pub const MF_DEVICESTREAM_MAX_FRAME_BUFFERS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1684cebe_3175_4985_882c_0efd3e8ac11e);
pub const MF_DEVICESTREAM_MULTIPLEXED_MANAGER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6ea542b0_281f_4231_a464_fe2f5022501c);
pub const MF_DEVICESTREAM_PIN_KSCONTROL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xef3ef9a7_87f2_48ca_be02_674878918e98);
pub const MF_DEVICESTREAM_REQUIRED_CAPABILITIES: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6d8b957e_7cf6_43f4_af56_9c0e1e4fcbe1);
pub const MF_DEVICESTREAM_REQUIRED_SDDL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x331ae85d_c0d3_49ba_83ba_82a12d63cdd6);
pub const MF_DEVICESTREAM_SENSORSTREAM_ID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe35b9fe4_0659_4cad_bb51_33160be7e413);
pub const MF_DEVICESTREAM_SOURCE_ATTRIBUTES: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2f8cb617_361b_434f_85ea_99a03e1ce4e0);
pub const MF_DEVICESTREAM_STREAM_CATEGORY: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2939e7b8_a62e_4579_b674_d4073dfabbba);
pub const MF_DEVICESTREAM_STREAM_ID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x11bd5120_d124_446b_88e6_17060257fff9);
pub const MF_DEVICESTREAM_TAKEPHOTO_TRIGGER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1d180e34_538c_4fbb_a75a_859af7d261a6);
pub const MF_DEVICESTREAM_TRANSFORM_STREAM_ID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe63937b7_daaf_4d49_815f_d826f8ad31e7);
pub const MF_DEVICE_THERMAL_STATE_CHANGED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x70ccd0af_fc9f_4deb_a875_9fecd16c5bd4);
pub const MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x60d0e559_52f8_4fa2_bbce_acdb34a8ec01);
pub const MF_DEVSOURCE_ATTRIBUTE_MEDIA_TYPE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x56a819ca_0c78_4de4_a0a7_3ddaba0f24d4);
pub const MF_DEVSOURCE_ATTRIBUTE_SOURCE_PASSWORD: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa0fd7e16_42d9_49df_84c0_e82c5eab8874);
pub const MF_DEVSOURCE_ATTRIBUTE_SOURCE_STREAM_URL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9d7b40d2_3617_4043_93e3_8d6da9bb3492);
pub const MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc60ac5fe_252a_478f_a0ef_bc8fa5f7cad3);
pub const MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_ENDPOINT_ID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x30da9258_feb9_47a7_a453_763a7a8e1c5f);
pub const MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_GUID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x14dd9a1c_7cff_41be_b1b9_ba1ac6ecb571);
pub const MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_ROLE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbc9d118e_8c67_4a18_85d4_12d300400552);
pub const MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_SYMBOLIC_LINK: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x98d24b5e_5930_4614_b5a1_f600f9355a78);
pub const MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_CATEGORY: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x77f0ae69_c3bd_4509_941d_467e4d24899e);
pub const MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8ac3587a_4ae7_42d8_99e0_0a6013eef90f);
pub const MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_HW_SOURCE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xde7046ba_54d6_4487_a2a4_ec7c0d1bd163);
pub const MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_MAX_BUFFERS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7dd9b730_4f2d_41d5_8f95_0cc9a912ba26);
pub const MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_PROVIDER_DEVICE_ID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x36689d42_a06c_40ae_84cf_f5a034067cc4);
pub const MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x58f0aad8_22bf_4f8a_bb3d_d2c4978c6e2f);
pub const MF_DEVSOURCE_ATTRIBUTE_SOURCE_USERNAME: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x05d01add_949f_46eb_bc8e_8b0d2b32d79d);
pub const MF_DEVSOURCE_ATTRIBUTE_SOURCE_XADDRESS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbca0be52_c327_44c7_9b7d_7fa8d9b5bcda);
pub const MF_DISABLE_FRAME_CORRUPTION_INFO: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7086e16c_49c5_4201_882a_8538f38cf13a);
pub const MF_DISABLE_LOCALLY_REGISTERED_PLUGINS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x66b16da9_add4_47e0_a16b_5af1fb483634);
pub const MF_DMFT_FRAME_BUFFER_INFO: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x396ce1c9_67a9_454c_8797_95a45799d804);
pub const MF_ENABLE_3DVIDEO_OUTPUT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbdad7bca_0e5f_4b10_ab16_26de381b6293);
pub const MF_EVENT_DO_THINNING: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x321ea6fb_dad9_46e4_b31d_d2eae7090e30);
pub const MF_EVENT_MFT_CONTEXT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb7cd31f1_899e_4b41_80c9_26a896d32977);
pub const MF_EVENT_MFT_INPUT_STREAM_ID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf29c2cca_7ae6_42d2_b284_bf837cc874e2);
pub const MF_EVENT_OUTPUT_NODE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x830f1a8b_c060_46dd_a801_1c95dec9b107);
pub const MF_EVENT_PRESENTATION_TIME_OFFSET: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5ad914d1_9b45_4a8d_a2c0_81d1e50bfb07);
pub const MF_EVENT_SCRUBSAMPLE_TIME: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9ac712b3_dcb8_44d5_8d0c_37455a2782e3);
pub const MF_EVENT_SESSIONCAPS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7e5ebcd0_11b8_4abe_afad_10f6599a7f42);
pub const MF_EVENT_SESSIONCAPS_DELTA: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7e5ebcd1_11b8_4abe_afad_10f6599a7f42);
pub const MF_EVENT_SOURCE_ACTUAL_START: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa8cc55a9_6b31_419f_845d_ffb351a2434b);
pub const MF_EVENT_SOURCE_CHARACTERISTICS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x47db8490_8b22_4f52_afda_9ce1b2d3cfa8);
pub const MF_EVENT_SOURCE_CHARACTERISTICS_OLD: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x47db8491_8b22_4f52_afda_9ce1b2d3cfa8);
pub const MF_EVENT_SOURCE_FAKE_START: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa8cc55a7_6b31_419f_845d_ffb351a2434b);
pub const MF_EVENT_SOURCE_PROJECTSTART: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa8cc55a8_6b31_419f_845d_ffb351a2434b);
pub const MF_EVENT_SOURCE_TOPOLOGY_CANCELED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdb62f650_9a5e_4704_acf3_563bc6a73364);
pub const MF_EVENT_START_PRESENTATION_TIME: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5ad914d0_9b45_4a8d_a2c0_81d1e50bfb07);
pub const MF_EVENT_START_PRESENTATION_TIME_AT_OUTPUT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5ad914d2_9b45_4a8d_a2c0_81d1e50bfb07);
pub const MF_EVENT_STREAM_METADATA_CONTENT_KEYIDS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5063449d_cc29_4fc6_a75a_d247b35af85c);
pub const MF_EVENT_STREAM_METADATA_KEYDATA: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xcd59a4a1_4a3b_4bbd_8665_72a40fbea776);
pub const MF_EVENT_STREAM_METADATA_SYSTEMID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1ea2ef64_ba16_4a36_8719_fe7560ba32ad);
pub const MF_EVENT_TOPOLOGY_STATUS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x30c5018d_9a53_454b_ad9e_6d5f8fa7c43b);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_EVENT_TYPE(pub i32);
pub const MEUnknown: MF_EVENT_TYPE = MF_EVENT_TYPE(0i32);
pub const MEError: MF_EVENT_TYPE = MF_EVENT_TYPE(1i32);
pub const MEExtendedType: MF_EVENT_TYPE = MF_EVENT_TYPE(2i32);
pub const MENonFatalError: MF_EVENT_TYPE = MF_EVENT_TYPE(3i32);
pub const MEGenericV1Anchor: MF_EVENT_TYPE = MF_EVENT_TYPE(3i32);
pub const MESessionUnknown: MF_EVENT_TYPE = MF_EVENT_TYPE(100i32);
pub const MESessionTopologySet: MF_EVENT_TYPE = MF_EVENT_TYPE(101i32);
pub const MESessionTopologiesCleared: MF_EVENT_TYPE = MF_EVENT_TYPE(102i32);
pub const MESessionStarted: MF_EVENT_TYPE = MF_EVENT_TYPE(103i32);
pub const MESessionPaused: MF_EVENT_TYPE = MF_EVENT_TYPE(104i32);
pub const MESessionStopped: MF_EVENT_TYPE = MF_EVENT_TYPE(105i32);
pub const MESessionClosed: MF_EVENT_TYPE = MF_EVENT_TYPE(106i32);
pub const MESessionEnded: MF_EVENT_TYPE = MF_EVENT_TYPE(107i32);
pub const MESessionRateChanged: MF_EVENT_TYPE = MF_EVENT_TYPE(108i32);
pub const MESessionScrubSampleComplete: MF_EVENT_TYPE = MF_EVENT_TYPE(109i32);
pub const MESessionCapabilitiesChanged: MF_EVENT_TYPE = MF_EVENT_TYPE(110i32);
pub const MESessionTopologyStatus: MF_EVENT_TYPE = MF_EVENT_TYPE(111i32);
pub const MESessionNotifyPresentationTime: MF_EVENT_TYPE = MF_EVENT_TYPE(112i32);
pub const MENewPresentation: MF_EVENT_TYPE = MF_EVENT_TYPE(113i32);
pub const MELicenseAcquisitionStart: MF_EVENT_TYPE = MF_EVENT_TYPE(114i32);
pub const MELicenseAcquisitionCompleted: MF_EVENT_TYPE = MF_EVENT_TYPE(115i32);
pub const MEIndividualizationStart: MF_EVENT_TYPE = MF_EVENT_TYPE(116i32);
pub const MEIndividualizationCompleted: MF_EVENT_TYPE = MF_EVENT_TYPE(117i32);
pub const MEEnablerProgress: MF_EVENT_TYPE = MF_EVENT_TYPE(118i32);
pub const MEEnablerCompleted: MF_EVENT_TYPE = MF_EVENT_TYPE(119i32);
pub const MEPolicyError: MF_EVENT_TYPE = MF_EVENT_TYPE(120i32);
pub const MEPolicyReport: MF_EVENT_TYPE = MF_EVENT_TYPE(121i32);
pub const MEBufferingStarted: MF_EVENT_TYPE = MF_EVENT_TYPE(122i32);
pub const MEBufferingStopped: MF_EVENT_TYPE = MF_EVENT_TYPE(123i32);
pub const MEConnectStart: MF_EVENT_TYPE = MF_EVENT_TYPE(124i32);
pub const MEConnectEnd: MF_EVENT_TYPE = MF_EVENT_TYPE(125i32);
pub const MEReconnectStart: MF_EVENT_TYPE = MF_EVENT_TYPE(126i32);
pub const MEReconnectEnd: MF_EVENT_TYPE = MF_EVENT_TYPE(127i32);
pub const MERendererEvent: MF_EVENT_TYPE = MF_EVENT_TYPE(128i32);
pub const MESessionStreamSinkFormatChanged: MF_EVENT_TYPE = MF_EVENT_TYPE(129i32);
pub const MESessionV1Anchor: MF_EVENT_TYPE = MF_EVENT_TYPE(129i32);
pub const MESourceUnknown: MF_EVENT_TYPE = MF_EVENT_TYPE(200i32);
pub const MESourceStarted: MF_EVENT_TYPE = MF_EVENT_TYPE(201i32);
pub const MEStreamStarted: MF_EVENT_TYPE = MF_EVENT_TYPE(202i32);
pub const MESourceSeeked: MF_EVENT_TYPE = MF_EVENT_TYPE(203i32);
pub const MEStreamSeeked: MF_EVENT_TYPE = MF_EVENT_TYPE(204i32);
pub const MENewStream: MF_EVENT_TYPE = MF_EVENT_TYPE(205i32);
pub const MEUpdatedStream: MF_EVENT_TYPE = MF_EVENT_TYPE(206i32);
pub const MESourceStopped: MF_EVENT_TYPE = MF_EVENT_TYPE(207i32);
pub const MEStreamStopped: MF_EVENT_TYPE = MF_EVENT_TYPE(208i32);
pub const MESourcePaused: MF_EVENT_TYPE = MF_EVENT_TYPE(209i32);
pub const MEStreamPaused: MF_EVENT_TYPE = MF_EVENT_TYPE(210i32);
pub const MEEndOfPresentation: MF_EVENT_TYPE = MF_EVENT_TYPE(211i32);
pub const MEEndOfStream: MF_EVENT_TYPE = MF_EVENT_TYPE(212i32);
pub const MEMediaSample: MF_EVENT_TYPE = MF_EVENT_TYPE(213i32);
pub const MEStreamTick: MF_EVENT_TYPE = MF_EVENT_TYPE(214i32);
pub const MEStreamThinMode: MF_EVENT_TYPE = MF_EVENT_TYPE(215i32);
pub const MEStreamFormatChanged: MF_EVENT_TYPE = MF_EVENT_TYPE(216i32);
pub const MESourceRateChanged: MF_EVENT_TYPE = MF_EVENT_TYPE(217i32);
pub const MEEndOfPresentationSegment: MF_EVENT_TYPE = MF_EVENT_TYPE(218i32);
pub const MESourceCharacteristicsChanged: MF_EVENT_TYPE = MF_EVENT_TYPE(219i32);
pub const MESourceRateChangeRequested: MF_EVENT_TYPE = MF_EVENT_TYPE(220i32);
pub const MESourceMetadataChanged: MF_EVENT_TYPE = MF_EVENT_TYPE(221i32);
pub const MESequencerSourceTopologyUpdated: MF_EVENT_TYPE = MF_EVENT_TYPE(222i32);
pub const MESourceV1Anchor: MF_EVENT_TYPE = MF_EVENT_TYPE(222i32);
pub const MESinkUnknown: MF_EVENT_TYPE = MF_EVENT_TYPE(300i32);
pub const MEStreamSinkStarted: MF_EVENT_TYPE = MF_EVENT_TYPE(301i32);
pub const MEStreamSinkStopped: MF_EVENT_TYPE = MF_EVENT_TYPE(302i32);
pub const MEStreamSinkPaused: MF_EVENT_TYPE = MF_EVENT_TYPE(303i32);
pub const MEStreamSinkRateChanged: MF_EVENT_TYPE = MF_EVENT_TYPE(304i32);
pub const MEStreamSinkRequestSample: MF_EVENT_TYPE = MF_EVENT_TYPE(305i32);
pub const MEStreamSinkMarker: MF_EVENT_TYPE = MF_EVENT_TYPE(306i32);
pub const MEStreamSinkPrerolled: MF_EVENT_TYPE = MF_EVENT_TYPE(307i32);
pub const MEStreamSinkScrubSampleComplete: MF_EVENT_TYPE = MF_EVENT_TYPE(308i32);
pub const MEStreamSinkFormatChanged: MF_EVENT_TYPE = MF_EVENT_TYPE(309i32);
pub const MEStreamSinkDeviceChanged: MF_EVENT_TYPE = MF_EVENT_TYPE(310i32);
pub const MEQualityNotify: MF_EVENT_TYPE = MF_EVENT_TYPE(311i32);
pub const MESinkInvalidated: MF_EVENT_TYPE = MF_EVENT_TYPE(312i32);
pub const MEAudioSessionNameChanged: MF_EVENT_TYPE = MF_EVENT_TYPE(313i32);
pub const MEAudioSessionVolumeChanged: MF_EVENT_TYPE = MF_EVENT_TYPE(314i32);
pub const MEAudioSessionDeviceRemoved: MF_EVENT_TYPE = MF_EVENT_TYPE(315i32);
pub const MEAudioSessionServerShutdown: MF_EVENT_TYPE = MF_EVENT_TYPE(316i32);
pub const MEAudioSessionGroupingParamChanged: MF_EVENT_TYPE = MF_EVENT_TYPE(317i32);
pub const MEAudioSessionIconChanged: MF_EVENT_TYPE = MF_EVENT_TYPE(318i32);
pub const MEAudioSessionFormatChanged: MF_EVENT_TYPE = MF_EVENT_TYPE(319i32);
pub const MEAudioSessionDisconnected: MF_EVENT_TYPE = MF_EVENT_TYPE(320i32);
pub const MEAudioSessionExclusiveModeOverride: MF_EVENT_TYPE = MF_EVENT_TYPE(321i32);
pub const MESinkV1Anchor: MF_EVENT_TYPE = MF_EVENT_TYPE(321i32);
pub const MECaptureAudioSessionVolumeChanged: MF_EVENT_TYPE = MF_EVENT_TYPE(322i32);
pub const MECaptureAudioSessionDeviceRemoved: MF_EVENT_TYPE = MF_EVENT_TYPE(323i32);
pub const MECaptureAudioSessionFormatChanged: MF_EVENT_TYPE = MF_EVENT_TYPE(324i32);
pub const MECaptureAudioSessionDisconnected: MF_EVENT_TYPE = MF_EVENT_TYPE(325i32);
pub const MECaptureAudioSessionExclusiveModeOverride: MF_EVENT_TYPE = MF_EVENT_TYPE(326i32);
pub const MECaptureAudioSessionServerShutdown: MF_EVENT_TYPE = MF_EVENT_TYPE(327i32);
pub const MESinkV2Anchor: MF_EVENT_TYPE = MF_EVENT_TYPE(327i32);
pub const METrustUnknown: MF_EVENT_TYPE = MF_EVENT_TYPE(400i32);
pub const MEPolicyChanged: MF_EVENT_TYPE = MF_EVENT_TYPE(401i32);
pub const MEContentProtectionMessage: MF_EVENT_TYPE = MF_EVENT_TYPE(402i32);
pub const MEPolicySet: MF_EVENT_TYPE = MF_EVENT_TYPE(403i32);
pub const METrustV1Anchor: MF_EVENT_TYPE = MF_EVENT_TYPE(403i32);
pub const MEWMDRMLicenseBackupCompleted: MF_EVENT_TYPE = MF_EVENT_TYPE(500i32);
pub const MEWMDRMLicenseBackupProgress: MF_EVENT_TYPE = MF_EVENT_TYPE(501i32);
pub const MEWMDRMLicenseRestoreCompleted: MF_EVENT_TYPE = MF_EVENT_TYPE(502i32);
pub const MEWMDRMLicenseRestoreProgress: MF_EVENT_TYPE = MF_EVENT_TYPE(503i32);
pub const MEWMDRMLicenseAcquisitionCompleted: MF_EVENT_TYPE = MF_EVENT_TYPE(506i32);
pub const MEWMDRMIndividualizationCompleted: MF_EVENT_TYPE = MF_EVENT_TYPE(508i32);
pub const MEWMDRMIndividualizationProgress: MF_EVENT_TYPE = MF_EVENT_TYPE(513i32);
pub const MEWMDRMProximityCompleted: MF_EVENT_TYPE = MF_EVENT_TYPE(514i32);
pub const MEWMDRMLicenseStoreCleaned: MF_EVENT_TYPE = MF_EVENT_TYPE(515i32);
pub const MEWMDRMRevocationDownloadCompleted: MF_EVENT_TYPE = MF_EVENT_TYPE(516i32);
pub const MEWMDRMV1Anchor: MF_EVENT_TYPE = MF_EVENT_TYPE(516i32);
pub const METransformUnknown: MF_EVENT_TYPE = MF_EVENT_TYPE(600i32);
pub const METransformNeedInput: MF_EVENT_TYPE = MF_EVENT_TYPE(601i32);
pub const METransformHaveOutput: MF_EVENT_TYPE = MF_EVENT_TYPE(602i32);
pub const METransformDrainComplete: MF_EVENT_TYPE = MF_EVENT_TYPE(603i32);
pub const METransformMarker: MF_EVENT_TYPE = MF_EVENT_TYPE(604i32);
pub const METransformInputStreamStateChanged: MF_EVENT_TYPE = MF_EVENT_TYPE(605i32);
pub const MEByteStreamCharacteristicsChanged: MF_EVENT_TYPE = MF_EVENT_TYPE(700i32);
pub const MEVideoCaptureDeviceRemoved: MF_EVENT_TYPE = MF_EVENT_TYPE(800i32);
pub const MEVideoCaptureDevicePreempted: MF_EVENT_TYPE = MF_EVENT_TYPE(801i32);
pub const MEStreamSinkFormatInvalidated: MF_EVENT_TYPE = MF_EVENT_TYPE(802i32);
pub const MEEncodingParameters: MF_EVENT_TYPE = MF_EVENT_TYPE(803i32);
pub const MEContentProtectionMetadata: MF_EVENT_TYPE = MF_EVENT_TYPE(900i32);
pub const MEDeviceThermalStateChanged: MF_EVENT_TYPE = MF_EVENT_TYPE(950i32);
pub const MEReservedMax: MF_EVENT_TYPE = MF_EVENT_TYPE(10000i32);
impl ::core::convert::From<i32> for MF_EVENT_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_EVENT_TYPE {
type Abi = Self;
}
pub const MF_E_ALLOCATOR_ALREADY_COMMITED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072846854i32 as _);
pub const MF_E_ALLOCATOR_NOT_COMMITED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072846855i32 as _);
pub const MF_E_ALLOCATOR_NOT_INITIALIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072846856i32 as _);
pub const MF_E_ALL_PROCESS_RESTART_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860820i32 as _);
pub const MF_E_ALREADY_INITIALIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072871856i32 as _);
pub const MF_E_ASF_DROPPED_PACKET: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072874847i32 as _);
pub const MF_E_ASF_FILESINK_BITRATE_UNKNOWN: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072870848i32 as _);
pub const MF_E_ASF_INDEXNOTLOADED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072874850i32 as _);
pub const MF_E_ASF_INVALIDDATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072874854i32 as _);
pub const MF_E_ASF_MISSINGDATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072874855i32 as _);
pub const MF_E_ASF_NOINDEX: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072874852i32 as _);
pub const MF_E_ASF_OPAQUEPACKET: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072874853i32 as _);
pub const MF_E_ASF_OUTOFRANGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072874851i32 as _);
pub const MF_E_ASF_PARSINGINCOMPLETE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072874856i32 as _);
pub const MF_E_ASF_TOO_MANY_PAYLOADS: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072874849i32 as _);
pub const MF_E_ASF_UNSUPPORTED_STREAM_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072874848i32 as _);
pub const MF_E_ATTRIBUTENOTFOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875802i32 as _);
pub const MF_E_AUDIO_BUFFER_SIZE_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072869752i32 as _);
pub const MF_E_AUDIO_CLIENT_WRAPPER_SPOOF_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072869751i32 as _);
pub const MF_E_AUDIO_PLAYBACK_DEVICE_INVALIDATED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072869754i32 as _);
pub const MF_E_AUDIO_PLAYBACK_DEVICE_IN_USE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072869755i32 as _);
pub const MF_E_AUDIO_RECORDING_DEVICE_INVALIDATED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072873823i32 as _);
pub const MF_E_AUDIO_RECORDING_DEVICE_IN_USE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072873824i32 as _);
pub const MF_E_AUDIO_SERVICE_NOT_RUNNING: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072869753i32 as _);
pub const MF_E_BACKUP_RESTRICTED_LICENSE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860850i32 as _);
pub const MF_E_BAD_OPL_STRUCTURE_FORMAT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860803i32 as _);
pub const MF_E_BAD_STARTUP_VERSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875805i32 as _);
pub const MF_E_BANDWIDTH_OVERRUN: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072871855i32 as _);
pub const MF_E_BUFFERTOOSMALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875855i32 as _);
pub const MF_E_BYTESTREAM_NOT_SEEKABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875794i32 as _);
pub const MF_E_BYTESTREAM_UNKNOWN_LENGTH: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875781i32 as _);
pub const MF_E_CANNOT_CREATE_SINK: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875782i32 as _);
pub const MF_E_CANNOT_FIND_KEYFRAME_SAMPLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072873827i32 as _);
pub const MF_E_CANNOT_INDEX_IN_PLACE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072871849i32 as _);
pub const MF_E_CANNOT_PARSE_BYTESTREAM: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875792i32 as _);
pub const MF_E_CAPTURE_ENGINE_ALL_EFFECTS_REMOVED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072845851i32 as _);
pub const MF_E_CAPTURE_ENGINE_INVALID_OP: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072845852i32 as _);
pub const MF_E_CAPTURE_NO_SAMPLES_IN_QUEUE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072845845i32 as _);
pub const MF_E_CAPTURE_PROPERTY_SET_DURING_PHOTO: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072845846i32 as _);
pub const MF_E_CAPTURE_SINK_MIRROR_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072845854i32 as _);
pub const MF_E_CAPTURE_SINK_OUTPUT_NOT_SET: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072845855i32 as _);
pub const MF_E_CAPTURE_SINK_ROTATE_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072845853i32 as _);
pub const MF_E_CAPTURE_SOURCE_DEVICE_EXTENDEDPROP_OP_IN_PROGRESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072845847i32 as _);
pub const MF_E_CAPTURE_SOURCE_NO_AUDIO_STREAM_PRESENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072845848i32 as _);
pub const MF_E_CAPTURE_SOURCE_NO_INDEPENDENT_PHOTO_STREAM_PRESENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072845850i32 as _);
pub const MF_E_CAPTURE_SOURCE_NO_VIDEO_STREAM_PRESENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072845849i32 as _);
pub const MF_E_CLOCK_AUDIO_DEVICE_POSITION_UNEXPECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(891973i32 as _);
pub const MF_E_CLOCK_AUDIO_RENDER_POSITION_UNEXPECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(891974i32 as _);
pub const MF_E_CLOCK_AUDIO_RENDER_TIME_UNEXPECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(891975i32 as _);
pub const MF_E_CLOCK_INVALID_CONTINUITY_KEY: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072849856i32 as _);
pub const MF_E_CLOCK_NOT_SIMPLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072849853i32 as _);
pub const MF_E_CLOCK_NO_TIME_SOURCE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072849855i32 as _);
pub const MF_E_CLOCK_STATE_ALREADY_SET: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072849854i32 as _);
pub const MF_E_CODE_EXPIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860834i32 as _);
pub const MF_E_COMPONENT_REVOKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860847i32 as _);
pub const MF_E_CONTENT_PROTECTION_SYSTEM_NOT_ENABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860795i32 as _);
pub const MF_E_DEBUGGING_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860835i32 as _);
pub const MF_E_DISABLED_IN_SAFEMODE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875793i32 as _);
pub const MF_E_DRM_HARDWARE_INCONSISTENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860853i32 as _);
pub const MF_E_DRM_MIGRATION_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860793i32 as _);
pub const MF_E_DRM_UNSUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875776i32 as _);
pub const MF_E_DROPTIME_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072848854i32 as _);
pub const MF_E_DURATION_TOO_LONG: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875769i32 as _);
pub const MF_E_DXGI_DEVICE_NOT_INITIALIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147217408i32 as _);
pub const MF_E_DXGI_NEW_VIDEO_DEVICE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147217407i32 as _);
pub const MF_E_DXGI_VIDEO_DEVICE_LOCKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147217406i32 as _);
pub const MF_E_END_OF_STREAM: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072873852i32 as _);
pub const MF_E_FLUSH_NEEDED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072871853i32 as _);
pub const MF_E_FORMAT_CHANGE_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875778i32 as _);
pub const MF_E_GRL_ABSENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860814i32 as _);
pub const MF_E_GRL_EXTENSIBLE_ENTRY_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860831i32 as _);
pub const MF_E_GRL_INVALID_FORMAT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860822i32 as _);
pub const MF_E_GRL_RENEWAL_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860832i32 as _);
pub const MF_E_GRL_UNRECOGNIZED_FORMAT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860821i32 as _);
pub const MF_E_GRL_VERSION_TOO_LOW: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860833i32 as _);
pub const MF_E_HARDWARE_DRM_UNSUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875770i32 as _);
pub const MF_E_HDCP_AUTHENTICATION_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860792i32 as _);
pub const MF_E_HDCP_LINK_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860791i32 as _);
pub const MF_E_HIGH_SECURITY_LEVEL_CONTENT_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860808i32 as _);
pub const MF_E_HW_ACCELERATED_THUMBNAIL_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072845844i32 as _);
pub const MF_E_HW_MFT_FAILED_START_STREAMING: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875772i32 as _);
pub const MF_E_HW_STREAM_NOT_CONNECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072846851i32 as _);
pub const MF_E_INCOMPATIBLE_SAMPLE_PROTECTION: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860810i32 as _);
pub const MF_E_INDEX_NOT_COMMITTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072871851i32 as _);
pub const MF_E_INSUFFICIENT_BUFFER: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860816i32 as _);
pub const MF_E_INVALIDINDEX: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875841i32 as _);
pub const MF_E_INVALIDMEDIATYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875852i32 as _);
pub const MF_E_INVALIDNAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875844i32 as _);
pub const MF_E_INVALIDREQUEST: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875854i32 as _);
pub const MF_E_INVALIDSTREAMNUMBER: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875853i32 as _);
pub const MF_E_INVALIDTYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875843i32 as _);
pub const MF_E_INVALID_AKE_CHANNEL_PARAMETERS: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860796i32 as _);
pub const MF_E_INVALID_ASF_STREAMID: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072871847i32 as _);
pub const MF_E_INVALID_CODEC_MERIT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875773i32 as _);
pub const MF_E_INVALID_FILE_FORMAT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875842i32 as _);
pub const MF_E_INVALID_FORMAT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072873844i32 as _);
pub const MF_E_INVALID_KEY: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875806i32 as _);
pub const MF_E_INVALID_POSITION: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875803i32 as _);
pub const MF_E_INVALID_PROFILE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072871852i32 as _);
pub const MF_E_INVALID_STATE_TRANSITION: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072873854i32 as _);
pub const MF_E_INVALID_STREAM_DATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875829i32 as _);
pub const MF_E_INVALID_STREAM_STATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072846852i32 as _);
pub const MF_E_INVALID_TIMESTAMP: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875840i32 as _);
pub const MF_E_INVALID_WORKQUEUE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875777i32 as _);
pub const MF_E_ITA_ERROR_PARSING_SAP_PARAMETERS: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860805i32 as _);
pub const MF_E_ITA_OPL_DATA_NOT_INITIALIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860800i32 as _);
pub const MF_E_ITA_UNRECOGNIZED_ANALOG_VIDEO_OUTPUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860799i32 as _);
pub const MF_E_ITA_UNRECOGNIZED_ANALOG_VIDEO_PROTECTION_GUID: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860802i32 as _);
pub const MF_E_ITA_UNRECOGNIZED_DIGITAL_VIDEO_OUTPUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860798i32 as _);
pub const MF_E_ITA_UNSUPPORTED_ACTION: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860806i32 as _);
pub const MF_E_KERNEL_UNTRUSTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860830i32 as _);
pub const MF_E_LATE_SAMPLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072871854i32 as _);
pub const MF_E_LICENSE_INCORRECT_RIGHTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860856i32 as _);
pub const MF_E_LICENSE_OUTOFDATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860855i32 as _);
pub const MF_E_LICENSE_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860854i32 as _);
pub const MF_E_LICENSE_RESTORE_NEEDS_INDIVIDUALIZATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860849i32 as _);
pub const MF_E_LICENSE_RESTORE_NO_RIGHTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860851i32 as _);
pub const MF_E_MEDIAPROC_WRONGSTATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875790i32 as _);
pub const MF_E_MEDIA_EXTENSION_APPSERVICE_CONNECTION_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072843856i32 as _);
pub const MF_E_MEDIA_EXTENSION_APPSERVICE_REQUEST_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072843855i32 as _);
pub const MF_E_MEDIA_EXTENSION_PACKAGE_INTEGRITY_CHECK_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072843854i32 as _);
pub const MF_E_MEDIA_EXTENSION_PACKAGE_LICENSE_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072843853i32 as _);
pub const MF_E_MEDIA_SOURCE_NOT_STARTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072873839i32 as _);
pub const MF_E_MEDIA_SOURCE_NO_STREAMS_SELECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072873828i32 as _);
pub const MF_E_MEDIA_SOURCE_WRONGSTATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072873829i32 as _);
pub const MF_E_METADATA_TOO_LONG: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072870845i32 as _);
pub const MF_E_MISSING_ASF_LEAKYBUCKET: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072871848i32 as _);
pub const MF_E_MP3_BAD_CRC: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072873831i32 as _);
pub const MF_E_MP3_NOTFOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072873850i32 as _);
pub const MF_E_MP3_NOTMP3: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072873848i32 as _);
pub const MF_E_MP3_NOTSUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072873847i32 as _);
pub const MF_E_MP3_OUTOFDATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072873849i32 as _);
pub const MF_E_MULTIPLE_BEGIN: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875815i32 as _);
pub const MF_E_MULTIPLE_SUBSCRIBERS: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875814i32 as _);
pub const MF_E_NETWORK_RESOURCE_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872856i32 as _);
pub const MF_E_NET_BAD_CONTROL_DATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872838i32 as _);
pub const MF_E_NET_BAD_REQUEST: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872833i32 as _);
pub const MF_E_NET_BUSY: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872822i32 as _);
pub const MF_E_NET_BWLEVEL_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872851i32 as _);
pub const MF_E_NET_CACHESTREAM_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872847i32 as _);
pub const MF_E_NET_CACHE_NO_DATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872835i32 as _);
pub const MF_E_NET_CANNOTCONNECT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872825i32 as _);
pub const MF_E_NET_CLIENT_CLOSE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872839i32 as _);
pub const MF_E_NET_COMPANION_DRIVER_DISCONNECT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872811i32 as _);
pub const MF_E_NET_CONNECTION_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872829i32 as _);
pub const MF_E_NET_EOL: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872834i32 as _);
pub const MF_E_NET_ERROR_FROM_PROXY: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872820i32 as _);
pub const MF_E_NET_INCOMPATIBLE_PUSHSERVER: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872828i32 as _);
pub const MF_E_NET_INCOMPATIBLE_SERVER: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872837i32 as _);
pub const MF_E_NET_INTERNAL_SERVER_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872832i32 as _);
pub const MF_E_NET_INVALID_PRESENTATION_DESCRIPTOR: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872848i32 as _);
pub const MF_E_NET_INVALID_PUSH_PUBLISHING_POINT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872823i32 as _);
pub const MF_E_NET_INVALID_PUSH_TEMPLATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872824i32 as _);
pub const MF_E_NET_MANUALSS_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872849i32 as _);
pub const MF_E_NET_NOCONNECTION: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872830i32 as _);
pub const MF_E_NET_PROTOCOL_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872812i32 as _);
pub const MF_E_NET_PROXY_ACCESSDENIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872826i32 as _);
pub const MF_E_NET_PROXY_TIMEOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872819i32 as _);
pub const MF_E_NET_READ: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872854i32 as _);
pub const MF_E_NET_REDIRECT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872843i32 as _);
pub const MF_E_NET_REDIRECT_TO_PROXY: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872842i32 as _);
pub const MF_E_NET_REQUIRE_ASYNC: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872852i32 as _);
pub const MF_E_NET_REQUIRE_INPUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872844i32 as _);
pub const MF_E_NET_REQUIRE_NETWORK: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872853i32 as _);
pub const MF_E_NET_RESOURCE_GONE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872821i32 as _);
pub const MF_E_NET_SERVER_ACCESSDENIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872827i32 as _);
pub const MF_E_NET_SERVER_UNAVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872818i32 as _);
pub const MF_E_NET_SESSION_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872816i32 as _);
pub const MF_E_NET_SESSION_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872831i32 as _);
pub const MF_E_NET_STREAMGROUPS_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872850i32 as _);
pub const MF_E_NET_TIMEOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872840i32 as _);
pub const MF_E_NET_TOO_MANY_REDIRECTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872841i32 as _);
pub const MF_E_NET_TOO_MUCH_DATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872817i32 as _);
pub const MF_E_NET_UDP_BLOCKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872814i32 as _);
pub const MF_E_NET_UNSAFE_URL: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872836i32 as _);
pub const MF_E_NET_UNSUPPORTED_CONFIGURATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872813i32 as _);
pub const MF_E_NET_WRITE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872855i32 as _);
pub const MF_E_NEW_VIDEO_DEVICE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072869851i32 as _);
pub const MF_E_NON_PE_PROCESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860827i32 as _);
pub const MF_E_NOTACCEPTING: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875851i32 as _);
pub const MF_E_NOT_AVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875818i32 as _);
pub const MF_E_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875819i32 as _);
pub const MF_E_NOT_INITIALIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875850i32 as _);
pub const MF_E_NOT_PROTECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072873830i32 as _);
pub const MF_E_NO_AUDIO_PLAYBACK_DEVICE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072869756i32 as _);
pub const MF_E_NO_AUDIO_RECORDING_DEVICE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072873825i32 as _);
pub const MF_E_NO_BITPUMP: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875786i32 as _);
pub const MF_E_NO_CAPTURE_DEVICES_AVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072845856i32 as _);
pub const MF_E_NO_CLOCK: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875817i32 as _);
pub const MF_E_NO_CONTENT_PROTECTION_MANAGER: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860852i32 as _);
pub const MF_E_NO_DURATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072873846i32 as _);
pub const MF_E_NO_EVENTS_AVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072873856i32 as _);
pub const MF_E_NO_INDEX: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072871850i32 as _);
pub const MF_E_NO_MORE_DROP_MODES: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072848856i32 as _);
pub const MF_E_NO_MORE_QUALITY_LEVELS: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072848855i32 as _);
pub const MF_E_NO_MORE_TYPES: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875847i32 as _);
pub const MF_E_NO_PMP_HOST: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860801i32 as _);
pub const MF_E_NO_SAMPLE_DURATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875831i32 as _);
pub const MF_E_NO_SAMPLE_TIMESTAMP: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875832i32 as _);
pub const MF_E_NO_SOURCE_IN_CACHE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072864850i32 as _);
pub const MF_E_NO_VIDEO_SAMPLE_AVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072869850i32 as _);
pub const MF_E_OFFLINE_MODE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072872815i32 as _);
pub const MF_E_OPERATION_CANCELLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875795i32 as _);
pub const MF_E_OPERATION_IN_PROGRESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875771i32 as _);
pub const MF_E_OPERATION_UNSUPPORTED_AT_D3D_FEATURE_LEVEL: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875768i32 as _);
pub const MF_E_OPL_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860838i32 as _);
pub const MF_E_OUT_OF_RANGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875774i32 as _);
pub const MF_E_PEAUTH_NOT_STARTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860811i32 as _);
pub const MF_E_PEAUTH_PUBLICKEY_REVOKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860815i32 as _);
pub const MF_E_PEAUTH_SESSION_NOT_STARTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860817i32 as _);
pub const MF_E_PEAUTH_UNTRUSTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860829i32 as _);
pub const MF_E_PE_SESSIONS_MAXED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860809i32 as _);
pub const MF_E_PE_UNTRUSTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860812i32 as _);
pub const MF_E_PLATFORM_NOT_INITIALIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875856i32 as _);
pub const MF_E_POLICY_MGR_ACTION_OUTOFBOUNDS: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860804i32 as _);
pub const MF_E_POLICY_UNSUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860839i32 as _);
pub const MF_E_PROCESS_RESTART_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860819i32 as _);
pub const MF_E_PROPERTY_EMPTY: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875799i32 as _);
pub const MF_E_PROPERTY_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072873841i32 as _);
pub const MF_E_PROPERTY_NOT_EMPTY: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875798i32 as _);
pub const MF_E_PROPERTY_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072873843i32 as _);
pub const MF_E_PROPERTY_READ_ONLY: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072873842i32 as _);
pub const MF_E_PROPERTY_TYPE_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875801i32 as _);
pub const MF_E_PROPERTY_TYPE_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875800i32 as _);
pub const MF_E_PROPERTY_VECTOR_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875797i32 as _);
pub const MF_E_PROPERTY_VECTOR_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875796i32 as _);
pub const MF_E_QM_INVALIDSTATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072848852i32 as _);
pub const MF_E_QUALITYKNOB_WAIT_LONGER: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072848853i32 as _);
pub const MF_E_RATE_CHANGE_PREEMPTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875820i32 as _);
pub const MF_E_REBOOT_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860825i32 as _);
pub const MF_E_RESOLUTION_REQUIRES_PMP_CREATION_CALLBACK: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860797i32 as _);
pub const MF_E_REVERSE_UNSUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875822i32 as _);
pub const MF_E_RT_OUTOFMEMORY: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875785i32 as _);
pub const MF_E_RT_THROUGHPUT_NOT_AVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875789i32 as _);
pub const MF_E_RT_TOO_MANY_CLASSES: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875788i32 as _);
pub const MF_E_RT_UNAVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875825i32 as _);
pub const MF_E_RT_WORKQUEUE_CLASS_NOT_SPECIFIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875784i32 as _);
pub const MF_E_RT_WOULDBLOCK: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875787i32 as _);
pub const MF_E_SAMPLEALLOCATOR_CANCELED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072870851i32 as _);
pub const MF_E_SAMPLEALLOCATOR_EMPTY: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072870850i32 as _);
pub const MF_E_SAMPLE_HAS_TOO_MANY_BUFFERS: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875809i32 as _);
pub const MF_E_SAMPLE_NOT_WRITABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875808i32 as _);
pub const MF_E_SEQUENCER_UNKNOWN_SEGMENT_ID: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072864852i32 as _);
pub const MF_E_SESSION_PAUSEWHILESTOPPED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875780i32 as _);
pub const MF_E_SHUTDOWN: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072873851i32 as _);
pub const MF_E_SIGNATURE_VERIFICATION_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860836i32 as _);
pub const MF_E_SINK_ALREADYSTOPPED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072870849i32 as _);
pub const MF_E_SINK_HEADERS_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072870843i32 as _);
pub const MF_E_SINK_NO_SAMPLES_PROCESSED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072870844i32 as _);
pub const MF_E_SINK_NO_STREAMS: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072870847i32 as _);
pub const MF_E_SOURCERESOLVER_MUTUALLY_EXCLUSIVE_FLAGS: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875791i32 as _);
pub const MF_E_STATE_TRANSITION_PENDING: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875812i32 as _);
pub const MF_E_STREAMSINKS_FIXED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072870853i32 as _);
pub const MF_E_STREAMSINKS_OUT_OF_SYNC: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072870854i32 as _);
pub const MF_E_STREAMSINK_EXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072870852i32 as _);
pub const MF_E_STREAMSINK_REMOVED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072870856i32 as _);
pub const MF_E_STREAM_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072846853i32 as _);
pub const MF_E_TEST_SIGNED_COMPONENTS_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860807i32 as _);
pub const MF_E_THINNING_UNSUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875823i32 as _);
pub const MF_E_TIMELINECONTROLLER_CANNOT_ATTACH: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072844854i32 as _);
pub const MF_E_TIMELINECONTROLLER_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072844855i32 as _);
pub const MF_E_TIMELINECONTROLLER_UNSUPPORTED_SOURCE_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072844856i32 as _);
pub const MF_E_TIMER_ORPHANED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875813i32 as _);
pub const MF_E_TOPOLOGY_VERIFICATION_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860837i32 as _);
pub const MF_E_TOPO_CANNOT_CONNECT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072868845i32 as _);
pub const MF_E_TOPO_CANNOT_FIND_DECRYPTOR: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072868847i32 as _);
pub const MF_E_TOPO_CODEC_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072868846i32 as _);
pub const MF_E_TOPO_INVALID_OPTIONAL_NODE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072868850i32 as _);
pub const MF_E_TOPO_INVALID_TIME_ATTRIBUTES: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072868843i32 as _);
pub const MF_E_TOPO_LOOPS_IN_TOPOLOGY: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072868842i32 as _);
pub const MF_E_TOPO_MISSING_PRESENTATION_DESCRIPTOR: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072868841i32 as _);
pub const MF_E_TOPO_MISSING_SOURCE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072868838i32 as _);
pub const MF_E_TOPO_MISSING_STREAM_DESCRIPTOR: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072868840i32 as _);
pub const MF_E_TOPO_SINK_ACTIVATES_UNSUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072868837i32 as _);
pub const MF_E_TOPO_STREAM_DESCRIPTOR_NOT_SELECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072868839i32 as _);
pub const MF_E_TOPO_UNSUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072868844i32 as _);
pub const MF_E_TRANSCODE_INVALID_PROFILE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072847853i32 as _);
pub const MF_E_TRANSCODE_NO_CONTAINERTYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072847856i32 as _);
pub const MF_E_TRANSCODE_NO_MATCHING_ENCODER: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072847854i32 as _);
pub const MF_E_TRANSCODE_PROFILE_NO_MATCHING_STREAMS: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072847855i32 as _);
pub const MF_E_TRANSFORM_ASYNC_LOCKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072861833i32 as _);
pub const MF_E_TRANSFORM_ASYNC_MFT_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072861830i32 as _);
pub const MF_E_TRANSFORM_CANNOT_CHANGE_MEDIATYPE_WHILE_PROCESSING: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072861836i32 as _);
pub const MF_E_TRANSFORM_CANNOT_INITIALIZE_ACM_DRIVER: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072861832i32 as _);
pub const MF_E_TRANSFORM_CONFLICTS_WITH_OTHER_CURRENTLY_ENABLED_FEATURES: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072861840i32 as _);
pub const MF_E_TRANSFORM_EXATTRIBUTE_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072861828i32 as _);
pub const MF_E_TRANSFORM_INPUT_REMAINING: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072861854i32 as _);
pub const MF_E_TRANSFORM_NEED_MORE_INPUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072861838i32 as _);
pub const MF_E_TRANSFORM_NOT_POSSIBLE_FOR_CURRENT_INPUT_MEDIATYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072861842i32 as _);
pub const MF_E_TRANSFORM_NOT_POSSIBLE_FOR_CURRENT_MEDIATYPE_COMBINATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072861841i32 as _);
pub const MF_E_TRANSFORM_NOT_POSSIBLE_FOR_CURRENT_OUTPUT_MEDIATYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072861843i32 as _);
pub const MF_E_TRANSFORM_NOT_POSSIBLE_FOR_CURRENT_SPKR_CONFIG: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072861837i32 as _);
pub const MF_E_TRANSFORM_PROFILE_INVALID_OR_CORRUPT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072861852i32 as _);
pub const MF_E_TRANSFORM_PROFILE_MISSING: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072861853i32 as _);
pub const MF_E_TRANSFORM_PROFILE_TRUNCATED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072861851i32 as _);
pub const MF_E_TRANSFORM_PROPERTY_ARRAY_VALUE_WRONG_NUM_DIM: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072861847i32 as _);
pub const MF_E_TRANSFORM_PROPERTY_NOT_WRITEABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072861848i32 as _);
pub const MF_E_TRANSFORM_PROPERTY_PID_NOT_RECOGNIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072861850i32 as _);
pub const MF_E_TRANSFORM_PROPERTY_VALUE_INCOMPATIBLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072861844i32 as _);
pub const MF_E_TRANSFORM_PROPERTY_VALUE_OUT_OF_RANGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072861845i32 as _);
pub const MF_E_TRANSFORM_PROPERTY_VALUE_SIZE_WRONG: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072861846i32 as _);
pub const MF_E_TRANSFORM_PROPERTY_VARIANT_TYPE_WRONG: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072861849i32 as _);
pub const MF_E_TRANSFORM_STREAM_CHANGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072861855i32 as _);
pub const MF_E_TRANSFORM_STREAM_INVALID_RESOLUTION: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072861831i32 as _);
pub const MF_E_TRANSFORM_TYPE_NOT_SET: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072861856i32 as _);
pub const MF_E_TRUST_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860846i32 as _);
pub const MF_E_UNAUTHORIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875775i32 as _);
pub const MF_E_UNEXPECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875845i32 as _);
pub const MF_E_UNRECOVERABLE_ERROR_OCCURRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875810i32 as _);
pub const MF_E_UNSUPPORTED_BYTESTREAM_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875836i32 as _);
pub const MF_E_UNSUPPORTED_CAPTION: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875804i32 as _);
pub const MF_E_UNSUPPORTED_CAPTURE_DEVICE_PRESENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072845843i32 as _);
pub const MF_E_UNSUPPORTED_CHARACTERISTICS: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072873826i32 as _);
pub const MF_E_UNSUPPORTED_CONTENT_PROTECTION_SYSTEM: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860794i32 as _);
pub const MF_E_UNSUPPORTED_D3D_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072861834i32 as _);
pub const MF_E_UNSUPPORTED_FORMAT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072873832i32 as _);
pub const MF_E_UNSUPPORTED_MEDIATYPE_AT_D3D_FEATURE_LEVEL: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875767i32 as _);
pub const MF_E_UNSUPPORTED_RATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875824i32 as _);
pub const MF_E_UNSUPPORTED_RATE_TRANSITION: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875821i32 as _);
pub const MF_E_UNSUPPORTED_REPRESENTATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875849i32 as _);
pub const MF_E_UNSUPPORTED_SCHEME: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875837i32 as _);
pub const MF_E_UNSUPPORTED_SERVICE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875846i32 as _);
pub const MF_E_UNSUPPORTED_STATE_TRANSITION: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875811i32 as _);
pub const MF_E_UNSUPPORTED_TIME_FORMAT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072875835i32 as _);
pub const MF_E_USERMODE_UNTRUSTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860818i32 as _);
pub const MF_E_VIDEO_DEVICE_LOCKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072869852i32 as _);
pub const MF_E_VIDEO_RECORDING_DEVICE_INVALIDATED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072873822i32 as _);
pub const MF_E_VIDEO_RECORDING_DEVICE_PREEMPTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072873821i32 as _);
pub const MF_E_VIDEO_REN_COPYPROT_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072869854i32 as _);
pub const MF_E_VIDEO_REN_NO_DEINTERLACE_HW: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072869855i32 as _);
pub const MF_E_VIDEO_REN_NO_PROCAMP_HW: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072869856i32 as _);
pub const MF_E_VIDEO_REN_SURFACE_NOT_SHARED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072869853i32 as _);
pub const MF_E_WMDRMOTA_ACTION_ALREADY_SET: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860844i32 as _);
pub const MF_E_WMDRMOTA_ACTION_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860841i32 as _);
pub const MF_E_WMDRMOTA_DRM_ENCRYPTION_SCHEME_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860842i32 as _);
pub const MF_E_WMDRMOTA_DRM_HEADER_NOT_AVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860843i32 as _);
pub const MF_E_WMDRMOTA_INVALID_POLICY: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860840i32 as _);
pub const MF_E_WMDRMOTA_NO_ACTION: ::windows::core::HRESULT = ::windows::core::HRESULT(-1072860845i32 as _);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_FILE_ACCESSMODE(pub i32);
pub const MF_ACCESSMODE_READ: MF_FILE_ACCESSMODE = MF_FILE_ACCESSMODE(1i32);
pub const MF_ACCESSMODE_WRITE: MF_FILE_ACCESSMODE = MF_FILE_ACCESSMODE(2i32);
pub const MF_ACCESSMODE_READWRITE: MF_FILE_ACCESSMODE = MF_FILE_ACCESSMODE(3i32);
impl ::core::convert::From<i32> for MF_FILE_ACCESSMODE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_FILE_ACCESSMODE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_FILE_FLAGS(pub i32);
pub const MF_FILEFLAGS_NONE: MF_FILE_FLAGS = MF_FILE_FLAGS(0i32);
pub const MF_FILEFLAGS_NOBUFFERING: MF_FILE_FLAGS = MF_FILE_FLAGS(1i32);
pub const MF_FILEFLAGS_ALLOW_WRITE_SHARING: MF_FILE_FLAGS = MF_FILE_FLAGS(2i32);
impl ::core::convert::From<i32> for MF_FILE_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_FILE_FLAGS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_FILE_OPENMODE(pub i32);
pub const MF_OPENMODE_FAIL_IF_NOT_EXIST: MF_FILE_OPENMODE = MF_FILE_OPENMODE(0i32);
pub const MF_OPENMODE_FAIL_IF_EXIST: MF_FILE_OPENMODE = MF_FILE_OPENMODE(1i32);
pub const MF_OPENMODE_RESET_IF_EXIST: MF_FILE_OPENMODE = MF_FILE_OPENMODE(2i32);
pub const MF_OPENMODE_APPEND_IF_EXIST: MF_FILE_OPENMODE = MF_FILE_OPENMODE(3i32);
pub const MF_OPENMODE_DELETE_IF_EXIST: MF_FILE_OPENMODE = MF_FILE_OPENMODE(4i32);
impl ::core::convert::From<i32> for MF_FILE_OPENMODE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_FILE_OPENMODE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MF_FLOAT2 {
pub x: f32,
pub y: f32,
}
impl MF_FLOAT2 {}
impl ::core::default::Default for MF_FLOAT2 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MF_FLOAT2 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MF_FLOAT2").field("x", &self.x).field("y", &self.y).finish()
}
}
impl ::core::cmp::PartialEq for MF_FLOAT2 {
fn eq(&self, other: &Self) -> bool {
self.x == other.x && self.y == other.y
}
}
impl ::core::cmp::Eq for MF_FLOAT2 {}
unsafe impl ::windows::core::Abi for MF_FLOAT2 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MF_FLOAT3 {
pub x: f32,
pub y: f32,
pub z: f32,
}
impl MF_FLOAT3 {}
impl ::core::default::Default for MF_FLOAT3 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MF_FLOAT3 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MF_FLOAT3").field("x", &self.x).field("y", &self.y).field("z", &self.z).finish()
}
}
impl ::core::cmp::PartialEq for MF_FLOAT3 {
fn eq(&self, other: &Self) -> bool {
self.x == other.x && self.y == other.y && self.z == other.z
}
}
impl ::core::cmp::Eq for MF_FLOAT3 {}
unsafe impl ::windows::core::Abi for MF_FLOAT3 {
type Abi = Self;
}
pub const MF_FRAMESERVER_VCAMEVENT_EXTENDED_CUSTOM_EVENT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6e59489c_47d3_4467_83ef_12d34e871665);
pub const MF_FRAMESERVER_VCAMEVENT_EXTENDED_PIPELINE_SHUTDOWN: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x45a81b31_43f8_4e5d_8ce2_22dce026996d);
pub const MF_FRAMESERVER_VCAMEVENT_EXTENDED_SOURCE_INITIALIZE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe52c4dff_e46d_4d0b_bc75_ddd4c8723f96);
pub const MF_FRAMESERVER_VCAMEVENT_EXTENDED_SOURCE_START: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb1eeb989_b456_4f4a_ae40_079c28e24af8);
pub const MF_FRAMESERVER_VCAMEVENT_EXTENDED_SOURCE_STOP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb7fe7a61_fe91_415e_8608_d37dedb1a58b);
pub const MF_FRAMESERVER_VCAMEVENT_EXTENDED_SOURCE_UNINITIALIZE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa0ebaba7_a422_4e33_8401_b37d2800aa67);
pub const MF_GRL_ABSENT: u32 = 4096u32;
pub const MF_GRL_LOAD_FAILED: u32 = 16u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_HDCP_STATUS(pub i32);
pub const MF_HDCP_STATUS_ON: MF_HDCP_STATUS = MF_HDCP_STATUS(0i32);
pub const MF_HDCP_STATUS_OFF: MF_HDCP_STATUS = MF_HDCP_STATUS(1i32);
pub const MF_HDCP_STATUS_ON_WITH_TYPE_ENFORCEMENT: MF_HDCP_STATUS = MF_HDCP_STATUS(2i32);
impl ::core::convert::From<i32> for MF_HDCP_STATUS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_HDCP_STATUS {
type Abi = Self;
}
pub const MF_HISTOGRAM_CHANNEL_B: u32 = 8u32;
pub const MF_HISTOGRAM_CHANNEL_Cb: u32 = 16u32;
pub const MF_HISTOGRAM_CHANNEL_Cr: u32 = 32u32;
pub const MF_HISTOGRAM_CHANNEL_G: u32 = 4u32;
pub const MF_HISTOGRAM_CHANNEL_R: u32 = 2u32;
pub const MF_HISTOGRAM_CHANNEL_Y: u32 = 1u32;
pub const MF_INDEPENDENT_STILL_IMAGE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xea12af41_0710_42c9_a127_daa3e78483a5);
pub const MF_INDEX_SIZE_ERR: u32 = 2154823681u32;
pub const MF_INVALID_ACCESS_ERR: u32 = 2154823695u32;
pub const MF_INVALID_GRL_SIGNATURE: u32 = 32u32;
pub const MF_INVALID_PRESENTATION_TIME: u64 = 9223372036854775808u64;
pub const MF_INVALID_STATE_ERR: u32 = 2154823691u32;
pub const MF_I_MANUAL_PROXY: ::windows::core::HRESULT = ::windows::core::HRESULT(1074610802i32 as _);
pub const MF_KERNEL_MODE_COMPONENT_LOAD: u32 = 2u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MF_LEAKY_BUCKET_PAIR {
pub dwBitrate: u32,
pub msBufferWindow: u32,
}
impl MF_LEAKY_BUCKET_PAIR {}
impl ::core::default::Default for MF_LEAKY_BUCKET_PAIR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MF_LEAKY_BUCKET_PAIR {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MF_LEAKY_BUCKET_PAIR").field("dwBitrate", &self.dwBitrate).field("msBufferWindow", &self.msBufferWindow).finish()
}
}
impl ::core::cmp::PartialEq for MF_LEAKY_BUCKET_PAIR {
fn eq(&self, other: &Self) -> bool {
self.dwBitrate == other.dwBitrate && self.msBufferWindow == other.msBufferWindow
}
}
impl ::core::cmp::Eq for MF_LEAKY_BUCKET_PAIR {}
unsafe impl ::windows::core::Abi for MF_LEAKY_BUCKET_PAIR {
type Abi = Self;
}
pub const MF_LOCAL_MFT_REGISTRATION_SERVICE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xddf5cf9c_4506_45aa_abf0_6d5d94dd1b4a);
pub const MF_LOCAL_PLUGIN_CONTROL_POLICY: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd91b0085_c86d_4f81_8822_8c68e1d7fa04);
pub const MF_LOW_LATENCY: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9c27891a_ed7a_40e1_88e8_b22727a024ee);
pub const MF_LUMA_KEY_ENABLE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7369820f_76de_43ca_9284_47b8f37e0649);
pub const MF_LUMA_KEY_LOWER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x93d7b8d5_0b81_4715_aea0_8725871621e9);
pub const MF_LUMA_KEY_UPPER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd09f39bb_4602_4c31_a706_a12171a5110a);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_MEDIAKEYSESSION_MESSAGETYPE(pub i32);
pub const MF_MEDIAKEYSESSION_MESSAGETYPE_LICENSE_REQUEST: MF_MEDIAKEYSESSION_MESSAGETYPE = MF_MEDIAKEYSESSION_MESSAGETYPE(0i32);
pub const MF_MEDIAKEYSESSION_MESSAGETYPE_LICENSE_RENEWAL: MF_MEDIAKEYSESSION_MESSAGETYPE = MF_MEDIAKEYSESSION_MESSAGETYPE(1i32);
pub const MF_MEDIAKEYSESSION_MESSAGETYPE_LICENSE_RELEASE: MF_MEDIAKEYSESSION_MESSAGETYPE = MF_MEDIAKEYSESSION_MESSAGETYPE(2i32);
pub const MF_MEDIAKEYSESSION_MESSAGETYPE_INDIVIDUALIZATION_REQUEST: MF_MEDIAKEYSESSION_MESSAGETYPE = MF_MEDIAKEYSESSION_MESSAGETYPE(3i32);
impl ::core::convert::From<i32> for MF_MEDIAKEYSESSION_MESSAGETYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_MEDIAKEYSESSION_MESSAGETYPE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_MEDIAKEYSESSION_TYPE(pub i32);
pub const MF_MEDIAKEYSESSION_TYPE_TEMPORARY: MF_MEDIAKEYSESSION_TYPE = MF_MEDIAKEYSESSION_TYPE(0i32);
pub const MF_MEDIAKEYSESSION_TYPE_PERSISTENT_LICENSE: MF_MEDIAKEYSESSION_TYPE = MF_MEDIAKEYSESSION_TYPE(1i32);
pub const MF_MEDIAKEYSESSION_TYPE_PERSISTENT_RELEASE_MESSAGE: MF_MEDIAKEYSESSION_TYPE = MF_MEDIAKEYSESSION_TYPE(2i32);
pub const MF_MEDIAKEYSESSION_TYPE_PERSISTENT_USAGE_RECORD: MF_MEDIAKEYSESSION_TYPE = MF_MEDIAKEYSESSION_TYPE(3i32);
impl ::core::convert::From<i32> for MF_MEDIAKEYSESSION_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_MEDIAKEYSESSION_TYPE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_MEDIAKEYS_REQUIREMENT(pub i32);
pub const MF_MEDIAKEYS_REQUIREMENT_REQUIRED: MF_MEDIAKEYS_REQUIREMENT = MF_MEDIAKEYS_REQUIREMENT(1i32);
pub const MF_MEDIAKEYS_REQUIREMENT_OPTIONAL: MF_MEDIAKEYS_REQUIREMENT = MF_MEDIAKEYS_REQUIREMENT(2i32);
pub const MF_MEDIAKEYS_REQUIREMENT_NOT_ALLOWED: MF_MEDIAKEYS_REQUIREMENT = MF_MEDIAKEYS_REQUIREMENT(3i32);
impl ::core::convert::From<i32> for MF_MEDIAKEYS_REQUIREMENT {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_MEDIAKEYS_REQUIREMENT {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_MEDIAKEY_STATUS(pub i32);
pub const MF_MEDIAKEY_STATUS_USABLE: MF_MEDIAKEY_STATUS = MF_MEDIAKEY_STATUS(0i32);
pub const MF_MEDIAKEY_STATUS_EXPIRED: MF_MEDIAKEY_STATUS = MF_MEDIAKEY_STATUS(1i32);
pub const MF_MEDIAKEY_STATUS_OUTPUT_DOWNSCALED: MF_MEDIAKEY_STATUS = MF_MEDIAKEY_STATUS(2i32);
pub const MF_MEDIAKEY_STATUS_OUTPUT_NOT_ALLOWED: MF_MEDIAKEY_STATUS = MF_MEDIAKEY_STATUS(3i32);
pub const MF_MEDIAKEY_STATUS_STATUS_PENDING: MF_MEDIAKEY_STATUS = MF_MEDIAKEY_STATUS(4i32);
pub const MF_MEDIAKEY_STATUS_INTERNAL_ERROR: MF_MEDIAKEY_STATUS = MF_MEDIAKEY_STATUS(5i32);
pub const MF_MEDIAKEY_STATUS_RELEASED: MF_MEDIAKEY_STATUS = MF_MEDIAKEY_STATUS(6i32);
pub const MF_MEDIAKEY_STATUS_OUTPUT_RESTRICTED: MF_MEDIAKEY_STATUS = MF_MEDIAKEY_STATUS(7i32);
impl ::core::convert::From<i32> for MF_MEDIAKEY_STATUS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_MEDIAKEY_STATUS {
type Abi = Self;
}
pub const MF_MEDIASINK_AUTOFINALIZE_SUPPORTED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x48c131be_135a_41cb_8290_03652509c999);
pub const MF_MEDIASINK_ENABLE_AUTOFINALIZE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x34014265_cb7e_4cde_ac7c_effd3b3c2530);
pub const MF_MEDIASOURCE_EXPOSE_ALL_STREAMS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe7f250b8_8fd9_4a09_b6c1_6a315c7c720e);
pub const MF_MEDIASOURCE_SERVICE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf09992f7_9fba_4c4a_a37f_8c47b4e1dfe7);
pub const MF_MEDIATYPE_EQUAL_FORMAT_DATA: u32 = 4u32;
pub const MF_MEDIATYPE_EQUAL_FORMAT_TYPES: u32 = 2u32;
pub const MF_MEDIATYPE_EQUAL_FORMAT_USER_DATA: u32 = 8u32;
pub const MF_MEDIATYPE_EQUAL_MAJOR_TYPES: u32 = 1u32;
pub const MF_MEDIATYPE_MULTIPLEXED_MANAGER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x13c78fb5_f275_4ea0_bb5f_0249832b0d6e);
pub const MF_MEDIA_ENGINE_AUDIO_CATEGORY: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc8d4c51d_350e_41f2_ba46_faebbb0857f6);
pub const MF_MEDIA_ENGINE_AUDIO_ENDPOINT_ROLE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd2cb93d1_116a_44f2_9385_f7d0fda2fb46);
pub const MF_MEDIA_ENGINE_BROWSER_COMPATIBILITY_MODE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4e0212e2_e18f_41e1_95e5_c0e7e9235bc3);
pub const MF_MEDIA_ENGINE_BROWSER_COMPATIBILITY_MODE_IE10: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x11a47afd_6589_4124_b312_6158ec517fc3);
pub const MF_MEDIA_ENGINE_BROWSER_COMPATIBILITY_MODE_IE11: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1cf1315f_ce3f_4035_9391_16142f775189);
pub const MF_MEDIA_ENGINE_BROWSER_COMPATIBILITY_MODE_IE9: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x052c2d39_40c0_4188_ab86_f828273b7522);
pub const MF_MEDIA_ENGINE_BROWSER_COMPATIBILITY_MODE_IE_EDGE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa6f3e465_3aca_442c_a3f0_ad6ddad839ae);
pub const MF_MEDIA_ENGINE_CALLBACK: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc60381b8_83a4_41f8_a3d0_de05076849a9);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_MEDIA_ENGINE_CANPLAY(pub i32);
pub const MF_MEDIA_ENGINE_CANPLAY_NOT_SUPPORTED: MF_MEDIA_ENGINE_CANPLAY = MF_MEDIA_ENGINE_CANPLAY(0i32);
pub const MF_MEDIA_ENGINE_CANPLAY_MAYBE: MF_MEDIA_ENGINE_CANPLAY = MF_MEDIA_ENGINE_CANPLAY(1i32);
pub const MF_MEDIA_ENGINE_CANPLAY_PROBABLY: MF_MEDIA_ENGINE_CANPLAY = MF_MEDIA_ENGINE_CANPLAY(2i32);
impl ::core::convert::From<i32> for MF_MEDIA_ENGINE_CANPLAY {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_MEDIA_ENGINE_CANPLAY {
type Abi = Self;
}
pub const MF_MEDIA_ENGINE_COMPATIBILITY_MODE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3ef26ad4_dc54_45de_b9af_76c8c66bfa8e);
pub const MF_MEDIA_ENGINE_COMPATIBILITY_MODE_WIN10: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5b25e089_6ca7_4139_a2cb_fcaab39552a3);
pub const MF_MEDIA_ENGINE_COMPATIBILITY_MODE_WWA_EDGE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x15b29098_9f01_4e4d_b65a_c06c6c89da2a);
pub const MF_MEDIA_ENGINE_CONTENT_PROTECTION_FLAGS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe0350223_5aaf_4d76_a7c3_06de70894db4);
pub const MF_MEDIA_ENGINE_CONTENT_PROTECTION_MANAGER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfdd6dfaa_bd85_4af3_9e0f_a01d539d876a);
pub const MF_MEDIA_ENGINE_CONTINUE_ON_CODEC_ERROR: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdbcdb7f9_48e4_4295_b70d_d518234eeb38);
pub const MF_MEDIA_ENGINE_COREWINDOW: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfccae4dc_0b7f_41c2_9f96_4659948acddc);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_MEDIA_ENGINE_CREATEFLAGS(pub i32);
pub const MF_MEDIA_ENGINE_AUDIOONLY: MF_MEDIA_ENGINE_CREATEFLAGS = MF_MEDIA_ENGINE_CREATEFLAGS(1i32);
pub const MF_MEDIA_ENGINE_WAITFORSTABLE_STATE: MF_MEDIA_ENGINE_CREATEFLAGS = MF_MEDIA_ENGINE_CREATEFLAGS(2i32);
pub const MF_MEDIA_ENGINE_FORCEMUTE: MF_MEDIA_ENGINE_CREATEFLAGS = MF_MEDIA_ENGINE_CREATEFLAGS(4i32);
pub const MF_MEDIA_ENGINE_REAL_TIME_MODE: MF_MEDIA_ENGINE_CREATEFLAGS = MF_MEDIA_ENGINE_CREATEFLAGS(8i32);
pub const MF_MEDIA_ENGINE_DISABLE_LOCAL_PLUGINS: MF_MEDIA_ENGINE_CREATEFLAGS = MF_MEDIA_ENGINE_CREATEFLAGS(16i32);
pub const MF_MEDIA_ENGINE_CREATEFLAGS_MASK: MF_MEDIA_ENGINE_CREATEFLAGS = MF_MEDIA_ENGINE_CREATEFLAGS(31i32);
impl ::core::convert::From<i32> for MF_MEDIA_ENGINE_CREATEFLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_MEDIA_ENGINE_CREATEFLAGS {
type Abi = Self;
}
pub const MF_MEDIA_ENGINE_DXGI_MANAGER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x065702da_1094_486d_8617_ee7cc4ee4648);
pub const MF_MEDIA_ENGINE_EME_CALLBACK: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x494553a7_a481_4cb7_bec5_380903513731);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_MEDIA_ENGINE_ERR(pub i32);
pub const MF_MEDIA_ENGINE_ERR_NOERROR: MF_MEDIA_ENGINE_ERR = MF_MEDIA_ENGINE_ERR(0i32);
pub const MF_MEDIA_ENGINE_ERR_ABORTED: MF_MEDIA_ENGINE_ERR = MF_MEDIA_ENGINE_ERR(1i32);
pub const MF_MEDIA_ENGINE_ERR_NETWORK: MF_MEDIA_ENGINE_ERR = MF_MEDIA_ENGINE_ERR(2i32);
pub const MF_MEDIA_ENGINE_ERR_DECODE: MF_MEDIA_ENGINE_ERR = MF_MEDIA_ENGINE_ERR(3i32);
pub const MF_MEDIA_ENGINE_ERR_SRC_NOT_SUPPORTED: MF_MEDIA_ENGINE_ERR = MF_MEDIA_ENGINE_ERR(4i32);
pub const MF_MEDIA_ENGINE_ERR_ENCRYPTED: MF_MEDIA_ENGINE_ERR = MF_MEDIA_ENGINE_ERR(5i32);
impl ::core::convert::From<i32> for MF_MEDIA_ENGINE_ERR {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_MEDIA_ENGINE_ERR {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_MEDIA_ENGINE_EVENT(pub i32);
pub const MF_MEDIA_ENGINE_EVENT_LOADSTART: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(1i32);
pub const MF_MEDIA_ENGINE_EVENT_PROGRESS: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(2i32);
pub const MF_MEDIA_ENGINE_EVENT_SUSPEND: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(3i32);
pub const MF_MEDIA_ENGINE_EVENT_ABORT: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(4i32);
pub const MF_MEDIA_ENGINE_EVENT_ERROR: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(5i32);
pub const MF_MEDIA_ENGINE_EVENT_EMPTIED: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(6i32);
pub const MF_MEDIA_ENGINE_EVENT_STALLED: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(7i32);
pub const MF_MEDIA_ENGINE_EVENT_PLAY: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(8i32);
pub const MF_MEDIA_ENGINE_EVENT_PAUSE: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(9i32);
pub const MF_MEDIA_ENGINE_EVENT_LOADEDMETADATA: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(10i32);
pub const MF_MEDIA_ENGINE_EVENT_LOADEDDATA: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(11i32);
pub const MF_MEDIA_ENGINE_EVENT_WAITING: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(12i32);
pub const MF_MEDIA_ENGINE_EVENT_PLAYING: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(13i32);
pub const MF_MEDIA_ENGINE_EVENT_CANPLAY: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(14i32);
pub const MF_MEDIA_ENGINE_EVENT_CANPLAYTHROUGH: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(15i32);
pub const MF_MEDIA_ENGINE_EVENT_SEEKING: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(16i32);
pub const MF_MEDIA_ENGINE_EVENT_SEEKED: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(17i32);
pub const MF_MEDIA_ENGINE_EVENT_TIMEUPDATE: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(18i32);
pub const MF_MEDIA_ENGINE_EVENT_ENDED: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(19i32);
pub const MF_MEDIA_ENGINE_EVENT_RATECHANGE: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(20i32);
pub const MF_MEDIA_ENGINE_EVENT_DURATIONCHANGE: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(21i32);
pub const MF_MEDIA_ENGINE_EVENT_VOLUMECHANGE: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(22i32);
pub const MF_MEDIA_ENGINE_EVENT_FORMATCHANGE: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(1000i32);
pub const MF_MEDIA_ENGINE_EVENT_PURGEQUEUEDEVENTS: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(1001i32);
pub const MF_MEDIA_ENGINE_EVENT_TIMELINE_MARKER: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(1002i32);
pub const MF_MEDIA_ENGINE_EVENT_BALANCECHANGE: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(1003i32);
pub const MF_MEDIA_ENGINE_EVENT_DOWNLOADCOMPLETE: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(1004i32);
pub const MF_MEDIA_ENGINE_EVENT_BUFFERINGSTARTED: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(1005i32);
pub const MF_MEDIA_ENGINE_EVENT_BUFFERINGENDED: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(1006i32);
pub const MF_MEDIA_ENGINE_EVENT_FRAMESTEPCOMPLETED: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(1007i32);
pub const MF_MEDIA_ENGINE_EVENT_NOTIFYSTABLESTATE: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(1008i32);
pub const MF_MEDIA_ENGINE_EVENT_FIRSTFRAMEREADY: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(1009i32);
pub const MF_MEDIA_ENGINE_EVENT_TRACKSCHANGE: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(1010i32);
pub const MF_MEDIA_ENGINE_EVENT_OPMINFO: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(1011i32);
pub const MF_MEDIA_ENGINE_EVENT_RESOURCELOST: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(1012i32);
pub const MF_MEDIA_ENGINE_EVENT_DELAYLOADEVENT_CHANGED: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(1013i32);
pub const MF_MEDIA_ENGINE_EVENT_STREAMRENDERINGERROR: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(1014i32);
pub const MF_MEDIA_ENGINE_EVENT_SUPPORTEDRATES_CHANGED: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(1015i32);
pub const MF_MEDIA_ENGINE_EVENT_AUDIOENDPOINTCHANGE: MF_MEDIA_ENGINE_EVENT = MF_MEDIA_ENGINE_EVENT(1016i32);
impl ::core::convert::From<i32> for MF_MEDIA_ENGINE_EVENT {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_MEDIA_ENGINE_EVENT {
type Abi = Self;
}
pub const MF_MEDIA_ENGINE_EXTENSION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3109fd46_060d_4b62_8dcf_faff811318d2);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_MEDIA_ENGINE_EXTENSION_TYPE(pub i32);
pub const MF_MEDIA_ENGINE_EXTENSION_TYPE_MEDIASOURCE: MF_MEDIA_ENGINE_EXTENSION_TYPE = MF_MEDIA_ENGINE_EXTENSION_TYPE(0i32);
pub const MF_MEDIA_ENGINE_EXTENSION_TYPE_BYTESTREAM: MF_MEDIA_ENGINE_EXTENSION_TYPE = MF_MEDIA_ENGINE_EXTENSION_TYPE(1i32);
impl ::core::convert::From<i32> for MF_MEDIA_ENGINE_EXTENSION_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_MEDIA_ENGINE_EXTENSION_TYPE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_MEDIA_ENGINE_FRAME_PROTECTION_FLAGS(pub i32);
pub const MF_MEDIA_ENGINE_FRAME_PROTECTION_FLAG_PROTECTED: MF_MEDIA_ENGINE_FRAME_PROTECTION_FLAGS = MF_MEDIA_ENGINE_FRAME_PROTECTION_FLAGS(1i32);
pub const MF_MEDIA_ENGINE_FRAME_PROTECTION_FLAG_REQUIRES_SURFACE_PROTECTION: MF_MEDIA_ENGINE_FRAME_PROTECTION_FLAGS = MF_MEDIA_ENGINE_FRAME_PROTECTION_FLAGS(2i32);
pub const MF_MEDIA_ENGINE_FRAME_PROTECTION_FLAG_REQUIRES_ANTI_SCREEN_SCRAPE_PROTECTION: MF_MEDIA_ENGINE_FRAME_PROTECTION_FLAGS = MF_MEDIA_ENGINE_FRAME_PROTECTION_FLAGS(4i32);
impl ::core::convert::From<i32> for MF_MEDIA_ENGINE_FRAME_PROTECTION_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_MEDIA_ENGINE_FRAME_PROTECTION_FLAGS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_MEDIA_ENGINE_KEYERR(pub i32);
pub const MF_MEDIAENGINE_KEYERR_UNKNOWN: MF_MEDIA_ENGINE_KEYERR = MF_MEDIA_ENGINE_KEYERR(1i32);
pub const MF_MEDIAENGINE_KEYERR_CLIENT: MF_MEDIA_ENGINE_KEYERR = MF_MEDIA_ENGINE_KEYERR(2i32);
pub const MF_MEDIAENGINE_KEYERR_SERVICE: MF_MEDIA_ENGINE_KEYERR = MF_MEDIA_ENGINE_KEYERR(3i32);
pub const MF_MEDIAENGINE_KEYERR_OUTPUT: MF_MEDIA_ENGINE_KEYERR = MF_MEDIA_ENGINE_KEYERR(4i32);
pub const MF_MEDIAENGINE_KEYERR_HARDWARECHANGE: MF_MEDIA_ENGINE_KEYERR = MF_MEDIA_ENGINE_KEYERR(5i32);
pub const MF_MEDIAENGINE_KEYERR_DOMAIN: MF_MEDIA_ENGINE_KEYERR = MF_MEDIA_ENGINE_KEYERR(6i32);
impl ::core::convert::From<i32> for MF_MEDIA_ENGINE_KEYERR {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_MEDIA_ENGINE_KEYERR {
type Abi = Self;
}
pub const MF_MEDIA_ENGINE_MEDIA_PLAYER_MODE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3ddd8d45_5aa1_4112_82e5_36f6a2197e6e);
pub const MF_MEDIA_ENGINE_NEEDKEY_CALLBACK: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7ea80843_b6e4_432c_8ea4_7848ffe4220e);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_MEDIA_ENGINE_NETWORK(pub i32);
pub const MF_MEDIA_ENGINE_NETWORK_EMPTY: MF_MEDIA_ENGINE_NETWORK = MF_MEDIA_ENGINE_NETWORK(0i32);
pub const MF_MEDIA_ENGINE_NETWORK_IDLE: MF_MEDIA_ENGINE_NETWORK = MF_MEDIA_ENGINE_NETWORK(1i32);
pub const MF_MEDIA_ENGINE_NETWORK_LOADING: MF_MEDIA_ENGINE_NETWORK = MF_MEDIA_ENGINE_NETWORK(2i32);
pub const MF_MEDIA_ENGINE_NETWORK_NO_SOURCE: MF_MEDIA_ENGINE_NETWORK = MF_MEDIA_ENGINE_NETWORK(3i32);
impl ::core::convert::From<i32> for MF_MEDIA_ENGINE_NETWORK {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_MEDIA_ENGINE_NETWORK {
type Abi = Self;
}
pub const MF_MEDIA_ENGINE_OPM_HWND: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa0be8ee7_0572_4f2c_a801_2a151bd3e726);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_MEDIA_ENGINE_OPM_STATUS(pub i32);
pub const MF_MEDIA_ENGINE_OPM_NOT_REQUESTED: MF_MEDIA_ENGINE_OPM_STATUS = MF_MEDIA_ENGINE_OPM_STATUS(0i32);
pub const MF_MEDIA_ENGINE_OPM_ESTABLISHED: MF_MEDIA_ENGINE_OPM_STATUS = MF_MEDIA_ENGINE_OPM_STATUS(1i32);
pub const MF_MEDIA_ENGINE_OPM_FAILED_VM: MF_MEDIA_ENGINE_OPM_STATUS = MF_MEDIA_ENGINE_OPM_STATUS(2i32);
pub const MF_MEDIA_ENGINE_OPM_FAILED_BDA: MF_MEDIA_ENGINE_OPM_STATUS = MF_MEDIA_ENGINE_OPM_STATUS(3i32);
pub const MF_MEDIA_ENGINE_OPM_FAILED_UNSIGNED_DRIVER: MF_MEDIA_ENGINE_OPM_STATUS = MF_MEDIA_ENGINE_OPM_STATUS(4i32);
pub const MF_MEDIA_ENGINE_OPM_FAILED: MF_MEDIA_ENGINE_OPM_STATUS = MF_MEDIA_ENGINE_OPM_STATUS(5i32);
impl ::core::convert::From<i32> for MF_MEDIA_ENGINE_OPM_STATUS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_MEDIA_ENGINE_OPM_STATUS {
type Abi = Self;
}
pub const MF_MEDIA_ENGINE_PLAYBACK_HWND: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd988879b_67c9_4d92_baa7_6eadd446039d);
pub const MF_MEDIA_ENGINE_PLAYBACK_VISUAL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6debd26f_6ab9_4d7e_b0ee_c61a73ffad15);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_MEDIA_ENGINE_PRELOAD(pub i32);
pub const MF_MEDIA_ENGINE_PRELOAD_MISSING: MF_MEDIA_ENGINE_PRELOAD = MF_MEDIA_ENGINE_PRELOAD(0i32);
pub const MF_MEDIA_ENGINE_PRELOAD_EMPTY: MF_MEDIA_ENGINE_PRELOAD = MF_MEDIA_ENGINE_PRELOAD(1i32);
pub const MF_MEDIA_ENGINE_PRELOAD_NONE: MF_MEDIA_ENGINE_PRELOAD = MF_MEDIA_ENGINE_PRELOAD(2i32);
pub const MF_MEDIA_ENGINE_PRELOAD_METADATA: MF_MEDIA_ENGINE_PRELOAD = MF_MEDIA_ENGINE_PRELOAD(3i32);
pub const MF_MEDIA_ENGINE_PRELOAD_AUTOMATIC: MF_MEDIA_ENGINE_PRELOAD = MF_MEDIA_ENGINE_PRELOAD(4i32);
impl ::core::convert::From<i32> for MF_MEDIA_ENGINE_PRELOAD {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_MEDIA_ENGINE_PRELOAD {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_MEDIA_ENGINE_PROTECTION_FLAGS(pub i32);
pub const MF_MEDIA_ENGINE_ENABLE_PROTECTED_CONTENT: MF_MEDIA_ENGINE_PROTECTION_FLAGS = MF_MEDIA_ENGINE_PROTECTION_FLAGS(1i32);
pub const MF_MEDIA_ENGINE_USE_PMP_FOR_ALL_CONTENT: MF_MEDIA_ENGINE_PROTECTION_FLAGS = MF_MEDIA_ENGINE_PROTECTION_FLAGS(2i32);
pub const MF_MEDIA_ENGINE_USE_UNPROTECTED_PMP: MF_MEDIA_ENGINE_PROTECTION_FLAGS = MF_MEDIA_ENGINE_PROTECTION_FLAGS(4i32);
impl ::core::convert::From<i32> for MF_MEDIA_ENGINE_PROTECTION_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_MEDIA_ENGINE_PROTECTION_FLAGS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_MEDIA_ENGINE_READY(pub i32);
pub const MF_MEDIA_ENGINE_READY_HAVE_NOTHING: MF_MEDIA_ENGINE_READY = MF_MEDIA_ENGINE_READY(0i32);
pub const MF_MEDIA_ENGINE_READY_HAVE_METADATA: MF_MEDIA_ENGINE_READY = MF_MEDIA_ENGINE_READY(1i32);
pub const MF_MEDIA_ENGINE_READY_HAVE_CURRENT_DATA: MF_MEDIA_ENGINE_READY = MF_MEDIA_ENGINE_READY(2i32);
pub const MF_MEDIA_ENGINE_READY_HAVE_FUTURE_DATA: MF_MEDIA_ENGINE_READY = MF_MEDIA_ENGINE_READY(3i32);
pub const MF_MEDIA_ENGINE_READY_HAVE_ENOUGH_DATA: MF_MEDIA_ENGINE_READY = MF_MEDIA_ENGINE_READY(4i32);
impl ::core::convert::From<i32> for MF_MEDIA_ENGINE_READY {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_MEDIA_ENGINE_READY {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_MEDIA_ENGINE_S3D_PACKING_MODE(pub i32);
pub const MF_MEDIA_ENGINE_S3D_PACKING_MODE_NONE: MF_MEDIA_ENGINE_S3D_PACKING_MODE = MF_MEDIA_ENGINE_S3D_PACKING_MODE(0i32);
pub const MF_MEDIA_ENGINE_S3D_PACKING_MODE_SIDE_BY_SIDE: MF_MEDIA_ENGINE_S3D_PACKING_MODE = MF_MEDIA_ENGINE_S3D_PACKING_MODE(1i32);
pub const MF_MEDIA_ENGINE_S3D_PACKING_MODE_TOP_BOTTOM: MF_MEDIA_ENGINE_S3D_PACKING_MODE = MF_MEDIA_ENGINE_S3D_PACKING_MODE(2i32);
impl ::core::convert::From<i32> for MF_MEDIA_ENGINE_S3D_PACKING_MODE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_MEDIA_ENGINE_S3D_PACKING_MODE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_MEDIA_ENGINE_SEEK_MODE(pub i32);
pub const MF_MEDIA_ENGINE_SEEK_MODE_NORMAL: MF_MEDIA_ENGINE_SEEK_MODE = MF_MEDIA_ENGINE_SEEK_MODE(0i32);
pub const MF_MEDIA_ENGINE_SEEK_MODE_APPROXIMATE: MF_MEDIA_ENGINE_SEEK_MODE = MF_MEDIA_ENGINE_SEEK_MODE(1i32);
impl ::core::convert::From<i32> for MF_MEDIA_ENGINE_SEEK_MODE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_MEDIA_ENGINE_SEEK_MODE {
type Abi = Self;
}
pub const MF_MEDIA_ENGINE_SOURCE_RESOLVER_CONFIG_STORE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0ac0c497_b3c4_48c9_9cde_bb8ca2442ca3);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_MEDIA_ENGINE_STATISTIC(pub i32);
pub const MF_MEDIA_ENGINE_STATISTIC_FRAMES_RENDERED: MF_MEDIA_ENGINE_STATISTIC = MF_MEDIA_ENGINE_STATISTIC(0i32);
pub const MF_MEDIA_ENGINE_STATISTIC_FRAMES_DROPPED: MF_MEDIA_ENGINE_STATISTIC = MF_MEDIA_ENGINE_STATISTIC(1i32);
pub const MF_MEDIA_ENGINE_STATISTIC_BYTES_DOWNLOADED: MF_MEDIA_ENGINE_STATISTIC = MF_MEDIA_ENGINE_STATISTIC(2i32);
pub const MF_MEDIA_ENGINE_STATISTIC_BUFFER_PROGRESS: MF_MEDIA_ENGINE_STATISTIC = MF_MEDIA_ENGINE_STATISTIC(3i32);
pub const MF_MEDIA_ENGINE_STATISTIC_FRAMES_PER_SECOND: MF_MEDIA_ENGINE_STATISTIC = MF_MEDIA_ENGINE_STATISTIC(4i32);
pub const MF_MEDIA_ENGINE_STATISTIC_PLAYBACK_JITTER: MF_MEDIA_ENGINE_STATISTIC = MF_MEDIA_ENGINE_STATISTIC(5i32);
pub const MF_MEDIA_ENGINE_STATISTIC_FRAMES_CORRUPTED: MF_MEDIA_ENGINE_STATISTIC = MF_MEDIA_ENGINE_STATISTIC(6i32);
pub const MF_MEDIA_ENGINE_STATISTIC_TOTAL_FRAME_DELAY: MF_MEDIA_ENGINE_STATISTIC = MF_MEDIA_ENGINE_STATISTIC(7i32);
impl ::core::convert::From<i32> for MF_MEDIA_ENGINE_STATISTIC {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_MEDIA_ENGINE_STATISTIC {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_MEDIA_ENGINE_STREAMTYPE_FAILED(pub i32);
pub const MF_MEDIA_ENGINE_STREAMTYPE_FAILED_UNKNOWN: MF_MEDIA_ENGINE_STREAMTYPE_FAILED = MF_MEDIA_ENGINE_STREAMTYPE_FAILED(0i32);
pub const MF_MEDIA_ENGINE_STREAMTYPE_FAILED_AUDIO: MF_MEDIA_ENGINE_STREAMTYPE_FAILED = MF_MEDIA_ENGINE_STREAMTYPE_FAILED(1i32);
pub const MF_MEDIA_ENGINE_STREAMTYPE_FAILED_VIDEO: MF_MEDIA_ENGINE_STREAMTYPE_FAILED = MF_MEDIA_ENGINE_STREAMTYPE_FAILED(2i32);
impl ::core::convert::From<i32> for MF_MEDIA_ENGINE_STREAMTYPE_FAILED {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_MEDIA_ENGINE_STREAMTYPE_FAILED {
type Abi = Self;
}
pub const MF_MEDIA_ENGINE_STREAM_CONTAINS_ALPHA_CHANNEL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5cbfaf44_d2b2_4cfb_80a7_d429c74c789d);
pub const MF_MEDIA_ENGINE_SYNCHRONOUS_CLOSE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc3c2e12f_7e0e_4e43_b91c_dc992ccdfa5e);
pub const MF_MEDIA_ENGINE_TELEMETRY_APPLICATION_ID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1e7b273b_a7e4_402a_8f51_c48e88a2cabc);
pub const MF_MEDIA_ENGINE_TIMEDTEXT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x805ea411_92e0_4e59_9b6e_5c7d7915e64f);
pub const MF_MEDIA_ENGINE_TRACK_ID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x65bea312_4043_4815_8eab_44dce2ef8f2a);
pub const MF_MEDIA_ENGINE_VIDEO_OUTPUT_FORMAT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5066893c_8cf9_42bc_8b8a_472212e52726);
pub const MF_MEDIA_PROTECTION_MANAGER_PROPERTIES: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x38bd81a9_acea_4c73_89b2_5532c0aeca79);
pub const MF_MEDIA_SHARING_ENGINE_DEVICE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb461c58a_7a08_4b98_99a8_70fd5f3badfd);
pub const MF_MEDIA_SHARING_ENGINE_DEVICE_NAME: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x771e05d1_862f_4299_95ac_ae81fd14f3e7);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_MEDIA_SHARING_ENGINE_EVENT(pub i32);
pub const MF_MEDIA_SHARING_ENGINE_EVENT_DISCONNECT: MF_MEDIA_SHARING_ENGINE_EVENT = MF_MEDIA_SHARING_ENGINE_EVENT(2000i32);
impl ::core::convert::From<i32> for MF_MEDIA_SHARING_ENGINE_EVENT {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_MEDIA_SHARING_ENGINE_EVENT {
type Abi = Self;
}
pub const MF_MEDIA_SHARING_ENGINE_INITIAL_SEEK_TIME: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6f3497f5_d528_4a4f_8dd7_db36657ec4c9);
pub const MF_METADATAFACIALEXPRESSION_SMILE: u32 = 1u32;
pub const MF_METADATATIMESTAMPS_DEVICE: u32 = 1u32;
pub const MF_METADATATIMESTAMPS_PRESENTATION: u32 = 2u32;
pub const MF_METADATA_PROVIDER_SERVICE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdb214084_58a4_4d2e_b84f_6f755b2f7a0d);
pub const MF_MINCRYPT_FAILURE: u32 = 268435456u32;
pub const MF_MP2DLNA_AUDIO_BIT_RATE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2d1c070e_2b5f_4ab3_a7e6_8d943ba8d00a);
pub const MF_MP2DLNA_ENCODE_QUALITY: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb52379d7_1d46_4fb6_a317_a4a5f60959f8);
pub const MF_MP2DLNA_STATISTICS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x75e488a3_d5ad_4898_85e0_bcce24a722d7);
pub const MF_MP2DLNA_USE_MMCSS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x54f3e2ee_a2a2_497d_9834_973afde521eb);
pub const MF_MP2DLNA_VIDEO_BIT_RATE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe88548de_73b4_42d7_9c75_adfa0a2a6e4c);
pub const MF_MPEG4SINK_MAX_CODED_SEQUENCES_PER_FRAGMENT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfc1b3bd6_692d_4ce5_9299_738aa5463e9a);
pub const MF_MPEG4SINK_MINIMUM_PROPERTIES_SIZE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdca1ed52_450e_4a22_8c62_4ed452f7a187);
pub const MF_MPEG4SINK_MIN_FRAGMENT_DURATION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa30b570c_8efd_45e8_94fe_27c84b5bdff6);
pub const MF_MPEG4SINK_MOOV_BEFORE_MDAT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf672e3ac_e1e6_4f10_b5ec_5f3b30828816);
pub const MF_MPEG4SINK_SPSPPS_PASSTHROUGH: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5601a134_2005_4ad2_b37d_22a6c554deb2);
pub const MF_MSE_ACTIVELIST_CALLBACK: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x949bda0f_4549_46d5_ad7f_b846e1ab1652);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_MSE_APPEND_MODE(pub i32);
pub const MF_MSE_APPEND_MODE_SEGMENTS: MF_MSE_APPEND_MODE = MF_MSE_APPEND_MODE(0i32);
pub const MF_MSE_APPEND_MODE_SEQUENCE: MF_MSE_APPEND_MODE = MF_MSE_APPEND_MODE(1i32);
impl ::core::convert::From<i32> for MF_MSE_APPEND_MODE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_MSE_APPEND_MODE {
type Abi = Self;
}
pub const MF_MSE_BUFFERLIST_CALLBACK: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x42e669b0_d60e_4afb_a85b_d8e5fe6bdab5);
pub const MF_MSE_CALLBACK: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9063a7c0_42c5_4ffd_a8a8_6fcf9ea3d00c);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_MSE_ERROR(pub i32);
pub const MF_MSE_ERROR_NOERROR: MF_MSE_ERROR = MF_MSE_ERROR(0i32);
pub const MF_MSE_ERROR_NETWORK: MF_MSE_ERROR = MF_MSE_ERROR(1i32);
pub const MF_MSE_ERROR_DECODE: MF_MSE_ERROR = MF_MSE_ERROR(2i32);
pub const MF_MSE_ERROR_UNKNOWN_ERROR: MF_MSE_ERROR = MF_MSE_ERROR(3i32);
impl ::core::convert::From<i32> for MF_MSE_ERROR {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_MSE_ERROR {
type Abi = Self;
}
pub const MF_MSE_OPUS_SUPPORT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4d224cc1_8cc4_48a3_a7a7_e4c16ce6388a);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_MSE_OPUS_SUPPORT_TYPE(pub i32);
pub const MF_MSE_OPUS_SUPPORT_ON: MF_MSE_OPUS_SUPPORT_TYPE = MF_MSE_OPUS_SUPPORT_TYPE(0i32);
pub const MF_MSE_OPUS_SUPPORT_OFF: MF_MSE_OPUS_SUPPORT_TYPE = MF_MSE_OPUS_SUPPORT_TYPE(1i32);
impl ::core::convert::From<i32> for MF_MSE_OPUS_SUPPORT_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_MSE_OPUS_SUPPORT_TYPE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_MSE_READY(pub i32);
pub const MF_MSE_READY_CLOSED: MF_MSE_READY = MF_MSE_READY(1i32);
pub const MF_MSE_READY_OPEN: MF_MSE_READY = MF_MSE_READY(2i32);
pub const MF_MSE_READY_ENDED: MF_MSE_READY = MF_MSE_READY(3i32);
impl ::core::convert::From<i32> for MF_MSE_READY {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_MSE_READY {
type Abi = Self;
}
pub const MF_MSE_VP9_SUPPORT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x92d78429_d88b_4ff0_8322_803efa6e9626);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_MSE_VP9_SUPPORT_TYPE(pub i32);
pub const MF_MSE_VP9_SUPPORT_DEFAULT: MF_MSE_VP9_SUPPORT_TYPE = MF_MSE_VP9_SUPPORT_TYPE(0i32);
pub const MF_MSE_VP9_SUPPORT_ON: MF_MSE_VP9_SUPPORT_TYPE = MF_MSE_VP9_SUPPORT_TYPE(1i32);
pub const MF_MSE_VP9_SUPPORT_OFF: MF_MSE_VP9_SUPPORT_TYPE = MF_MSE_VP9_SUPPORT_TYPE(2i32);
impl ::core::convert::From<i32> for MF_MSE_VP9_SUPPORT_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_MSE_VP9_SUPPORT_TYPE {
type Abi = Self;
}
pub const MF_MT_AAC_AUDIO_PROFILE_LEVEL_INDICATION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7632f0e6_9538_4d61_acda_ea29c8c14456);
pub const MF_MT_AAC_PAYLOAD_TYPE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbfbabe79_7434_4d1c_94f0_72a3b9e17188);
pub const MF_MT_ALL_SAMPLES_INDEPENDENT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc9173739_5e56_461c_b713_46fb995cb95f);
pub const MF_MT_ALPHA_MODE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5d959b0d_4cbf_4d04_919f_3f5f7f284211);
pub const MF_MT_AM_FORMAT_TYPE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x73d1072d_1870_4174_a063_29ff4ff6c11e);
pub const MF_MT_ARBITRARY_FORMAT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5a75b249_0d7d_49a1_a1c3_e0d87f0cade5);
pub const MF_MT_ARBITRARY_HEADER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9e6bd6f5_0109_4f95_84ac_9309153a19fc);
pub const MF_MT_AUDIO_AVG_BYTES_PER_SECOND: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1aab75c8_cfef_451c_ab95_ac034b8e1731);
pub const MF_MT_AUDIO_BITS_PER_SAMPLE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf2deb57f_40fa_4764_aa33_ed4f2d1ff669);
pub const MF_MT_AUDIO_BLOCK_ALIGNMENT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x322de230_9eeb_43bd_ab7a_ff412251541d);
pub const MF_MT_AUDIO_CHANNEL_MASK: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x55fb5765_644a_4caf_8479_938983bb1588);
pub const MF_MT_AUDIO_FLAC_MAX_BLOCK_SIZE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8b81adae_4b5a_4d40_8022_f38d09ca3c5c);
pub const MF_MT_AUDIO_FLOAT_SAMPLES_PER_SECOND: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfb3b724a_cfb5_4319_aefe_6e42b2406132);
pub const MF_MT_AUDIO_FOLDDOWN_MATRIX: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9d62927c_36be_4cf2_b5c4_a3926e3e8711);
pub const MF_MT_AUDIO_NUM_CHANNELS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x37e48bf5_645e_4c5b_89de_ada9e29b696a);
pub const MF_MT_AUDIO_PREFER_WAVEFORMATEX: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa901aaba_e037_458a_bdf6_545be2074042);
pub const MF_MT_AUDIO_SAMPLES_PER_BLOCK: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xaab15aac_e13a_4995_9222_501ea15c6877);
pub const MF_MT_AUDIO_SAMPLES_PER_SECOND: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5faeeae7_0290_4c31_9e8a_c534f68d9dba);
pub const MF_MT_AUDIO_VALID_BITS_PER_SAMPLE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd9bf8d6a_9530_4b7c_9ddf_ff6fd58bbd06);
pub const MF_MT_AUDIO_WMADRC_AVGREF: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9d62927f_36be_4cf2_b5c4_a3926e3e8711);
pub const MF_MT_AUDIO_WMADRC_AVGTARGET: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9d629280_36be_4cf2_b5c4_a3926e3e8711);
pub const MF_MT_AUDIO_WMADRC_PEAKREF: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9d62927d_36be_4cf2_b5c4_a3926e3e8711);
pub const MF_MT_AUDIO_WMADRC_PEAKTARGET: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9d62927e_36be_4cf2_b5c4_a3926e3e8711);
pub const MF_MT_AVG_BITRATE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x20332624_fb0d_4d9e_bd0d_cbf6786c102e);
pub const MF_MT_AVG_BIT_ERROR_RATE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x799cabd6_3508_4db4_a3c7_569cd533deb1);
pub const MF_MT_COMPRESSED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3afd0cee_18f2_4ba5_a110_8bea502e1f92);
pub const MF_MT_CONTAINER_RATE_SCALING: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x83877f5e_0444_4e28_8479_6db0989b8c09);
pub const MF_MT_CUSTOM_VIDEO_PRIMARIES: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x47537213_8cfb_4722_aa34_fbc9e24d77b8);
pub const MF_MT_D3D12_CPU_READBACK: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x28ee9fe3_d481_46a6_b98a_7f69d5280e82);
pub const MF_MT_D3D12_RESOURCE_FLAG_ALLOW_CROSS_ADAPTER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa6a1e439_2f96_4ab5_98dc_adf74973505d);
pub const MF_MT_D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb1138dc3_01d5_4c14_9bdc_cdc9336f55b9);
pub const MF_MT_D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xeeac2585_3430_498c_84a2_77b1bba570f6);
pub const MF_MT_D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0a4940b2_cfd6_4738_9d02_98113734015a);
pub const MF_MT_D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x82c85647_5057_4960_9559_f45b8e271427);
pub const MF_MT_D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xba06bfac_ffe3_474a_ab55_161ee4417a2e);
pub const MF_MT_D3D12_TEXTURE_LAYOUT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x97c85caa_0beb_4ee1_9715_f22fad8c10f5);
pub const MF_MT_D3D_RESOURCE_VERSION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x174f1e85_fe26_453d_b52e_5bdd4e55b944);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_MT_D3D_RESOURCE_VERSION_ENUM(pub i32);
pub const MF_D3D11_RESOURCE: MF_MT_D3D_RESOURCE_VERSION_ENUM = MF_MT_D3D_RESOURCE_VERSION_ENUM(0i32);
pub const MF_D3D12_RESOURCE: MF_MT_D3D_RESOURCE_VERSION_ENUM = MF_MT_D3D_RESOURCE_VERSION_ENUM(1i32);
impl ::core::convert::From<i32> for MF_MT_D3D_RESOURCE_VERSION_ENUM {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_MT_D3D_RESOURCE_VERSION_ENUM {
type Abi = Self;
}
pub const MF_MT_DECODER_MAX_DPB_COUNT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x67be144c_88b7_4ca9_9628_c808d5262217);
pub const MF_MT_DECODER_USE_MAX_RESOLUTION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4c547c24_af9a_4f38_96ad_978773cf53e7);
pub const MF_MT_DEFAULT_STRIDE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x644b4e48_1e02_4516_b0eb_c01ca9d49ac6);
pub const MF_MT_DEPTH_MEASUREMENT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfd5ac489_0917_4bb6_9d54_3122bf70144b);
pub const MF_MT_DEPTH_VALUE_UNIT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x21a800f5_3189_4797_beba_f13cd9a31a5e);
pub const MF_MT_DRM_FLAGS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8772f323_355a_4cc7_bb78_6d61a048ae82);
pub const MF_MT_DV_AAUX_CTRL_PACK_0: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf731004e_1dd1_4515_aabe_f0c06aa536ac);
pub const MF_MT_DV_AAUX_CTRL_PACK_1: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xcd1f470d_1f04_4fe0_bfb9_d07ae0386ad8);
pub const MF_MT_DV_AAUX_SRC_PACK_0: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x84bd5d88_0fb8_4ac8_be4b_a8848bef98f3);
pub const MF_MT_DV_AAUX_SRC_PACK_1: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x720e6544_0225_4003_a651_0196563a958e);
pub const MF_MT_DV_VAUX_CTRL_PACK: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2f84e1c4_0da1_4788_938e_0dfbfbb34b48);
pub const MF_MT_DV_VAUX_SRC_PACK: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x41402d9d_7b57_43c6_b129_2cb997f15009);
pub const MF_MT_FIXED_SIZE_SAMPLES: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb8ebefaf_b718_4e04_b0a9_116775e3321b);
pub const MF_MT_FORWARD_CUSTOM_NALU: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xed336efd_244f_428d_9153_28f399458890);
pub const MF_MT_FORWARD_CUSTOM_SEI: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe27362f1_b136_41d1_9594_3a7e4febf2d1);
pub const MF_MT_FRAME_RATE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc459a2e8_3d2c_4e44_b132_fee5156c7bb0);
pub const MF_MT_FRAME_RATE_RANGE_MAX: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe3371d41_b4cf_4a05_bd4e_20b88bb2c4d6);
pub const MF_MT_FRAME_RATE_RANGE_MIN: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd2e7558c_dc1f_403f_9a72_d28bb1eb3b5e);
pub const MF_MT_FRAME_SIZE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1652c33d_d6b2_4012_b834_72030849a37d);
pub const MF_MT_GEOMETRIC_APERTURE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x66758743_7e5f_400d_980a_aa8596c85696);
pub const MF_MT_H264_CAPABILITIES: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbb3bd508_490a_11e0_99e4_1316dfd72085);
pub const MF_MT_H264_LAYOUT_PER_STREAM: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x85e299b2_90e3_4fe8_b2f5_c067e0bfe57a);
pub const MF_MT_H264_MAX_CODEC_CONFIG_DELAY: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf5929986_4c45_4fbb_bb49_6cc534d05b9b);
pub const MF_MT_H264_MAX_MB_PER_SEC: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x45256d30_7215_4576_9336_b0f1bcd59bb2);
pub const MF_MT_H264_RATE_CONTROL_MODES: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x705177d8_45cb_11e0_ac7d_b91ce0d72085);
pub const MF_MT_H264_RESOLUTION_SCALING: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe3854272_f715_4757_ba90_1b696c773457);
pub const MF_MT_H264_SIMULCAST_SUPPORT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9ea2d63d_53f0_4a34_b94e_9de49a078cb3);
pub const MF_MT_H264_SUPPORTED_RATE_CONTROL_MODES: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6a8ac47e_519c_4f18_9bb3_7eeaaea5594d);
pub const MF_MT_H264_SUPPORTED_SLICE_MODES: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc8be1937_4d64_4549_8343_a8086c0bfda5);
pub const MF_MT_H264_SUPPORTED_SYNC_FRAME_TYPES: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x89a52c01_f282_48d2_b522_22e6ae633199);
pub const MF_MT_H264_SUPPORTED_USAGES: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x60b1a998_dc01_40ce_9736_aba845a2dbdc);
pub const MF_MT_H264_SVC_CAPABILITIES: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf8993abe_d937_4a8f_bbca_6966fe9e1152);
pub const MF_MT_H264_USAGE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x359ce3a5_af00_49ca_a2f4_2ac94ca82b61);
pub const MF_MT_IMAGE_LOSS_TOLERANT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xed062cf4_e34e_4922_be99_934032133d7c);
pub const MF_MT_INTERLACE_MODE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe2724bb8_e676_4806_b4b2_a8d6efb44ccd);
pub const MF_MT_IN_BAND_PARAMETER_SET: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x75da5090_910b_4a03_896c_7b898feea5af);
pub const MF_MT_MAJOR_TYPE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x48eba18e_f8c9_4687_bf11_0a74c9f96a8f);
pub const MF_MT_MAX_FRAME_AVERAGE_LUMINANCE_LEVEL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x58d4bf57_6f52_4733_a195_a9e29ecf9e27);
pub const MF_MT_MAX_KEYFRAME_SPACING: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc16eb52b_73a1_476f_8d62_839d6a020652);
pub const MF_MT_MAX_LUMINANCE_LEVEL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x50253128_c110_4de4_98ae_46a324fae6da);
pub const MF_MT_MAX_MASTERING_LUMINANCE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd6c6b997_272f_4ca1_8d00_8042111a0ff6);
pub const MF_MT_MINIMUM_DISPLAY_APERTURE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd7388766_18fe_48c6_a177_ee894867c8c4);
pub const MF_MT_MIN_MASTERING_LUMINANCE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x839a4460_4e7e_4b4f_ae79_cc08905c7b27);
pub const MF_MT_MPEG2_CONTENT_PACKET: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x825d55e4_4f12_4197_9eb3_59b6e4710f06);
pub const MF_MT_MPEG2_FLAGS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x31e3991d_f701_4b2f_b426_8ae3bda9e04b);
pub const MF_MT_MPEG2_HDCP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x168f1b4a_3e91_450f_aea7_e4baeadae5ba);
pub const MF_MT_MPEG2_LEVEL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x96f66574_11c5_4015_8666_bff516436da7);
pub const MF_MT_MPEG2_ONE_FRAME_PER_PACKET: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x91a49eb5_1d20_4b42_ace8_804269bf95ed);
pub const MF_MT_MPEG2_PROFILE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xad76a80b_2d5c_4e0b_b375_64e520137036);
pub const MF_MT_MPEG2_STANDARD: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa20af9e8_928a_4b26_aaa9_f05c74cac47c);
pub const MF_MT_MPEG2_TIMECODE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5229ba10_e29d_4f80_a59c_df4f180207d2);
pub const MF_MT_MPEG4_CURRENT_SAMPLE_ENTRY: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9aa7e155_b64a_4c1d_a500_455d600b6560);
pub const MF_MT_MPEG4_SAMPLE_DESCRIPTION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x261e9d83_9529_4b8f_a111_8b9c950a81a9);
pub const MF_MT_MPEG4_TRACK_TYPE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x54f486dd_9327_4f6d_80ab_6f709ebb4cce);
pub const MF_MT_MPEG_SEQUENCE_HEADER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3c036de7_3ad0_4c9e_9216_ee6d6ac21cb3);
pub const MF_MT_MPEG_START_TIME_CODE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x91f67885_4333_4280_97cd_bd5a6c03a06e);
pub const MF_MT_ORIGINAL_4CC: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd7be3fe0_2bc7_492d_b843_61a1919b70c3);
pub const MF_MT_ORIGINAL_WAVE_FORMAT_TAG: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8cbbc843_9fd9_49c2_882f_a72586c408ad);
pub const MF_MT_OUTPUT_BUFFER_NUM: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa505d3ac_f930_436e_8ede_93a509ce23b2);
pub const MF_MT_PAD_CONTROL_FLAGS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4d0e73e5_80ea_4354_a9d0_1176ceb028ea);
pub const MF_MT_PALETTE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6d283f42_9846_4410_afd9_654d503b1a54);
pub const MF_MT_PAN_SCAN_APERTURE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x79614dde_9187_48fb_b8c7_4d52689de649);
pub const MF_MT_PAN_SCAN_ENABLED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4b7f6bc3_8b13_40b2_a993_abf630b8204e);
pub const MF_MT_PIXEL_ASPECT_RATIO: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc6376a1e_8d0a_4027_be45_6d9a0ad39bb6);
pub const MF_MT_REALTIME_CONTENT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbb12d222_2bdb_425e_91ec_2308e189a58f);
pub const MF_MT_SAMPLE_SIZE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdad3ab78_1990_408b_bce2_eba673dacc10);
pub const MF_MT_SECURE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc5acc4fd_0304_4ecf_809f_47bc97ff63bd);
pub const MF_MT_SOURCE_CONTENT_HINT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x68aca3cc_22d0_44e6_85f8_28167197fa38);
pub const MF_MT_SPATIAL_AUDIO_DATA_PRESENT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6842f6e7_d43e_4ebb_9c9c_c96f41784863);
pub const MF_MT_SPATIAL_AUDIO_MAX_DYNAMIC_OBJECTS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdcfba24a_2609_4240_a721_3faea76a4df9);
pub const MF_MT_SPATIAL_AUDIO_MAX_METADATA_ITEMS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x11aa80b4_e0da_47c6_8060_96c1259ae50d);
pub const MF_MT_SPATIAL_AUDIO_MIN_METADATA_ITEM_OFFSET_SPACING: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x83e96ec9_1184_417e_8254_9f269158fc06);
pub const MF_MT_SPATIAL_AUDIO_OBJECT_METADATA_FORMAT_ID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2ab71bc0_6223_4ba7_ad64_7b94b47ae792);
pub const MF_MT_SPATIAL_AUDIO_OBJECT_METADATA_LENGTH: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x094ba8be_d723_489f_92fa_766777b34726);
pub const MF_MT_SUBTYPE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf7e34c9a_42e8_4714_b74b_cb29d72c35e5);
pub const MF_MT_TIMESTAMP_CAN_BE_DTS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x24974215_1b7b_41e4_8625_ac469f2dedaa);
pub const MF_MT_TRANSFER_FUNCTION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5fb0fce9_be5c_4935_a811_ec838f8eed93);
pub const MF_MT_USER_DATA: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb6bc765f_4c3b_40a4_bd51_2535b66fe09d);
pub const MF_MT_VIDEO_3D: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xcb5e88cf_7b5b_476b_85aa_1ca5ae187555);
pub const MF_MT_VIDEO_3D_FIRST_IS_LEFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xec298493_0ada_4ea1_a4fe_cbbd36ce9331);
pub const MF_MT_VIDEO_3D_FORMAT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5315d8a0_87c5_4697_b793_6606c67c049b);
pub const MF_MT_VIDEO_3D_LEFT_IS_BASE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6d4b7bff_5629_4404_948c_c634f4ce26d4);
pub const MF_MT_VIDEO_3D_NUM_VIEWS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbb077e8a_dcbf_42eb_af60_418df98aa495);
pub const MF_MT_VIDEO_CHROMA_SITING: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x65df2370_c773_4c33_aa64_843e068efb0c);
pub const MF_MT_VIDEO_H264_NO_FMOASO: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xed461cd6_ec9f_416a_a8a3_26d7d31018d7);
pub const MF_MT_VIDEO_LEVEL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x96f66574_11c5_4015_8666_bff516436da7);
pub const MF_MT_VIDEO_LIGHTING: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x53a0529c_890b_4216_8bf9_599367ad6d20);
pub const MF_MT_VIDEO_NOMINAL_RANGE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc21b8ee5_b956_4071_8daf_325edf5cab11);
pub const MF_MT_VIDEO_NO_FRAME_ORDERING: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3f5b106f_6bc2_4ee3_b7ed_8902c18f5351);
pub const MF_MT_VIDEO_PRIMARIES: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdbfbe4d7_0740_4ee0_8192_850ab0e21935);
pub const MF_MT_VIDEO_PROFILE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xad76a80b_2d5c_4e0b_b375_64e520137036);
pub const MF_MT_VIDEO_RENDERER_EXTENSION_PROFILE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8437d4b9_d448_4fcd_9b6b_839bf96c7798);
pub const MF_MT_VIDEO_ROTATION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc380465d_2271_428c_9b83_ecea3b4a85c1);
pub const MF_MT_WRAPPED_TYPE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4d3f7b23_d02f_4e6c_9bee_e4bf2c6c695d);
pub const MF_MT_YUV_MATRIX: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3e23d450_2c75_4d25_a00e_b91670d12327);
pub const MF_NALU_LENGTH_INFORMATION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x19124e7c_ad4b_465f_bb18_20186287b6af);
pub const MF_NALU_LENGTH_SET: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa7911d53_12a4_4965_ae70_6eadd6ff0551);
pub const MF_NOT_FOUND_ERR: u32 = 2154823688u32;
pub const MF_NOT_SUPPORTED_ERR: u32 = 2154823689u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_OBJECT_TYPE(pub i32);
pub const MF_OBJECT_MEDIASOURCE: MF_OBJECT_TYPE = MF_OBJECT_TYPE(0i32);
pub const MF_OBJECT_BYTESTREAM: MF_OBJECT_TYPE = MF_OBJECT_TYPE(1i32);
pub const MF_OBJECT_INVALID: MF_OBJECT_TYPE = MF_OBJECT_TYPE(2i32);
impl ::core::convert::From<i32> for MF_OBJECT_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_OBJECT_TYPE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_OPM_ACP_PROTECTION_LEVEL(pub i32);
pub const MF_OPM_ACP_OFF: MF_OPM_ACP_PROTECTION_LEVEL = MF_OPM_ACP_PROTECTION_LEVEL(0i32);
pub const MF_OPM_ACP_LEVEL_ONE: MF_OPM_ACP_PROTECTION_LEVEL = MF_OPM_ACP_PROTECTION_LEVEL(1i32);
pub const MF_OPM_ACP_LEVEL_TWO: MF_OPM_ACP_PROTECTION_LEVEL = MF_OPM_ACP_PROTECTION_LEVEL(2i32);
pub const MF_OPM_ACP_LEVEL_THREE: MF_OPM_ACP_PROTECTION_LEVEL = MF_OPM_ACP_PROTECTION_LEVEL(3i32);
pub const MF_OPM_ACP_FORCE_ULONG: MF_OPM_ACP_PROTECTION_LEVEL = MF_OPM_ACP_PROTECTION_LEVEL(2147483647i32);
impl ::core::convert::From<i32> for MF_OPM_ACP_PROTECTION_LEVEL {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_OPM_ACP_PROTECTION_LEVEL {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_OPM_CGMSA_PROTECTION_LEVEL(pub i32);
pub const MF_OPM_CGMSA_OFF: MF_OPM_CGMSA_PROTECTION_LEVEL = MF_OPM_CGMSA_PROTECTION_LEVEL(0i32);
pub const MF_OPM_CGMSA_COPY_FREELY: MF_OPM_CGMSA_PROTECTION_LEVEL = MF_OPM_CGMSA_PROTECTION_LEVEL(1i32);
pub const MF_OPM_CGMSA_COPY_NO_MORE: MF_OPM_CGMSA_PROTECTION_LEVEL = MF_OPM_CGMSA_PROTECTION_LEVEL(2i32);
pub const MF_OPM_CGMSA_COPY_ONE_GENERATION: MF_OPM_CGMSA_PROTECTION_LEVEL = MF_OPM_CGMSA_PROTECTION_LEVEL(3i32);
pub const MF_OPM_CGMSA_COPY_NEVER: MF_OPM_CGMSA_PROTECTION_LEVEL = MF_OPM_CGMSA_PROTECTION_LEVEL(4i32);
pub const MF_OPM_CGMSA_REDISTRIBUTION_CONTROL_REQUIRED: MF_OPM_CGMSA_PROTECTION_LEVEL = MF_OPM_CGMSA_PROTECTION_LEVEL(8i32);
impl ::core::convert::From<i32> for MF_OPM_CGMSA_PROTECTION_LEVEL {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_OPM_CGMSA_PROTECTION_LEVEL {
type Abi = Self;
}
pub const MF_PARSE_ERR: u32 = 2154823761u32;
pub const MF_PD_ADAPTIVE_STREAMING: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xea0d5d97_29f9_488b_ae6b_7d6b4136112b);
pub const MF_PD_APP_CONTEXT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6c990d32_bb8e_477a_8598_0d5d96fcd88a);
pub const MF_PD_ASF_CODECLIST: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe4bb3509_c18d_4df1_bb99_7a36b3cc4119);
pub const MF_PD_ASF_CONTENTENCRYPTIONEX_ENCRYPTION_DATA: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x62508be5_ecdf_4924_a359_72bab3397b9d);
pub const MF_PD_ASF_CONTENTENCRYPTION_KEYID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8520fe3e_277e_46ea_99e4_e30a86db12be);
pub const MF_PD_ASF_CONTENTENCRYPTION_LICENSE_URL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8520fe40_277e_46ea_99e4_e30a86db12be);
pub const MF_PD_ASF_CONTENTENCRYPTION_SECRET_DATA: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8520fe3f_277e_46ea_99e4_e30a86db12be);
pub const MF_PD_ASF_CONTENTENCRYPTION_TYPE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8520fe3d_277e_46ea_99e4_e30a86db12be);
pub const MF_PD_ASF_DATA_LENGTH: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe7d5b3e8_1f29_45d3_8822_3e78fae272ed);
pub const MF_PD_ASF_DATA_START_OFFSET: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe7d5b3e7_1f29_45d3_8822_3e78fae272ed);
pub const MF_PD_ASF_FILEPROPERTIES_CREATION_TIME: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3de649b6_d76d_4e66_9ec9_78120fb4c7e3);
pub const MF_PD_ASF_FILEPROPERTIES_FILE_ID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3de649b4_d76d_4e66_9ec9_78120fb4c7e3);
pub const MF_PD_ASF_FILEPROPERTIES_FLAGS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3de649bb_d76d_4e66_9ec9_78120fb4c7e3);
pub const MF_PD_ASF_FILEPROPERTIES_MAX_BITRATE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3de649be_d76d_4e66_9ec9_78120fb4c7e3);
pub const MF_PD_ASF_FILEPROPERTIES_MAX_PACKET_SIZE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3de649bd_d76d_4e66_9ec9_78120fb4c7e3);
pub const MF_PD_ASF_FILEPROPERTIES_MIN_PACKET_SIZE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3de649bc_d76d_4e66_9ec9_78120fb4c7e3);
pub const MF_PD_ASF_FILEPROPERTIES_PACKETS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3de649b7_d76d_4e66_9ec9_78120fb4c7e3);
pub const MF_PD_ASF_FILEPROPERTIES_PLAY_DURATION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3de649b8_d76d_4e66_9ec9_78120fb4c7e3);
pub const MF_PD_ASF_FILEPROPERTIES_PREROLL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3de649ba_d76d_4e66_9ec9_78120fb4c7e3);
pub const MF_PD_ASF_FILEPROPERTIES_SEND_DURATION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3de649b9_d76d_4e66_9ec9_78120fb4c7e3);
pub const MF_PD_ASF_INFO_HAS_AUDIO: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x80e62295_2296_4a44_b31c_d103c6fed23c);
pub const MF_PD_ASF_INFO_HAS_NON_AUDIO_VIDEO: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x80e62297_2296_4a44_b31c_d103c6fed23c);
pub const MF_PD_ASF_INFO_HAS_VIDEO: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x80e62296_2296_4a44_b31c_d103c6fed23c);
pub const MF_PD_ASF_LANGLIST: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf23de43c_9977_460d_a6ec_32937f160f7d);
pub const MF_PD_ASF_LANGLIST_LEGACYORDER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf23de43d_9977_460d_a6ec_32937f160f7d);
pub const MF_PD_ASF_MARKER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5134330e_83a6_475e_a9d5_4fb875fb2e31);
pub const MF_PD_ASF_METADATA_IS_VBR: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5fc6947a_ef60_445d_b449_442ecc78b4c1);
pub const MF_PD_ASF_METADATA_LEAKY_BUCKET_PAIRS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5fc6947d_ef60_445d_b449_442ecc78b4c1);
pub const MF_PD_ASF_METADATA_V8_BUFFERAVERAGE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5fc6947c_ef60_445d_b449_442ecc78b4c1);
pub const MF_PD_ASF_METADATA_V8_VBRPEAK: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5fc6947b_ef60_445d_b449_442ecc78b4c1);
pub const MF_PD_ASF_SCRIPT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe29cd0d7_d602_4923_a7fe_73fd97ecc650);
pub const MF_PD_AUDIO_ENCODING_BITRATE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6c990d35_bb8e_477a_8598_0d5d96fcd88a);
pub const MF_PD_AUDIO_ISVARIABLEBITRATE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x33026ee0_e387_4582_ae0a_34a2ad3baa18);
pub const MF_PD_DURATION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6c990d33_bb8e_477a_8598_0d5d96fcd88a);
pub const MF_PD_LAST_MODIFIED_TIME: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6c990d38_bb8e_477a_8598_0d5d96fcd88a);
pub const MF_PD_MIME_TYPE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6c990d37_bb8e_477a_8598_0d5d96fcd88a);
pub const MF_PD_PLAYBACK_BOUNDARY_TIME: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6c990d3b_bb8e_477a_8598_0d5d96fcd88a);
pub const MF_PD_PLAYBACK_ELEMENT_ID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6c990d39_bb8e_477a_8598_0d5d96fcd88a);
pub const MF_PD_PMPHOST_CONTEXT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6c990d31_bb8e_477a_8598_0d5d96fcd88a);
pub const MF_PD_PREFERRED_LANGUAGE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6c990d3a_bb8e_477a_8598_0d5d96fcd88a);
pub const MF_PD_SAMI_STYLELIST: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe0b73c7f_486d_484e_9872_4de5192a7bf8);
pub const MF_PD_TOTAL_FILE_SIZE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6c990d34_bb8e_477a_8598_0d5d96fcd88a);
pub const MF_PD_VIDEO_ENCODING_BITRATE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6c990d36_bb8e_477a_8598_0d5d96fcd88a);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_PLUGIN_CONTROL_POLICY(pub i32);
pub const MF_PLUGIN_CONTROL_POLICY_USE_ALL_PLUGINS: MF_PLUGIN_CONTROL_POLICY = MF_PLUGIN_CONTROL_POLICY(0i32);
pub const MF_PLUGIN_CONTROL_POLICY_USE_APPROVED_PLUGINS: MF_PLUGIN_CONTROL_POLICY = MF_PLUGIN_CONTROL_POLICY(1i32);
pub const MF_PLUGIN_CONTROL_POLICY_USE_WEB_PLUGINS: MF_PLUGIN_CONTROL_POLICY = MF_PLUGIN_CONTROL_POLICY(2i32);
pub const MF_PLUGIN_CONTROL_POLICY_USE_WEB_PLUGINS_EDGEMODE: MF_PLUGIN_CONTROL_POLICY = MF_PLUGIN_CONTROL_POLICY(3i32);
impl ::core::convert::From<i32> for MF_PLUGIN_CONTROL_POLICY {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_PLUGIN_CONTROL_POLICY {
type Abi = Self;
}
pub const MF_PMP_SERVER_CONTEXT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2f00c910_d2cf_4278_8b6a_d077fac3a25f);
pub const MF_POLICY_ID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb160c24d_c059_48f1_a901_9ee298a9a8c3);
pub const MF_PREFERRED_SOURCE_URI: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5fc85488_436a_4db8_90af_4db402ae5c57);
pub const MF_PROGRESSIVE_CODING_CONTENT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8f020eea_1508_471f_9da6_507d7cfa40db);
pub const MF_PROPERTY_HANDLER_SERVICE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa3face02_32b8_41dd_90e7_5fef7c8991b5);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_Plugin_Type(pub i32);
pub const MF_Plugin_Type_MFT: MF_Plugin_Type = MF_Plugin_Type(0i32);
pub const MF_Plugin_Type_MediaSource: MF_Plugin_Type = MF_Plugin_Type(1i32);
pub const MF_Plugin_Type_MFT_MatchOutputType: MF_Plugin_Type = MF_Plugin_Type(2i32);
pub const MF_Plugin_Type_Other: MF_Plugin_Type = MF_Plugin_Type(-1i32);
impl ::core::convert::From<i32> for MF_Plugin_Type {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_Plugin_Type {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_QUALITY_ADVISE_FLAGS(pub i32);
pub const MF_QUALITY_CANNOT_KEEP_UP: MF_QUALITY_ADVISE_FLAGS = MF_QUALITY_ADVISE_FLAGS(1i32);
impl ::core::convert::From<i32> for MF_QUALITY_ADVISE_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_QUALITY_ADVISE_FLAGS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_QUALITY_DROP_MODE(pub i32);
pub const MF_DROP_MODE_NONE: MF_QUALITY_DROP_MODE = MF_QUALITY_DROP_MODE(0i32);
pub const MF_DROP_MODE_1: MF_QUALITY_DROP_MODE = MF_QUALITY_DROP_MODE(1i32);
pub const MF_DROP_MODE_2: MF_QUALITY_DROP_MODE = MF_QUALITY_DROP_MODE(2i32);
pub const MF_DROP_MODE_3: MF_QUALITY_DROP_MODE = MF_QUALITY_DROP_MODE(3i32);
pub const MF_DROP_MODE_4: MF_QUALITY_DROP_MODE = MF_QUALITY_DROP_MODE(4i32);
pub const MF_DROP_MODE_5: MF_QUALITY_DROP_MODE = MF_QUALITY_DROP_MODE(5i32);
pub const MF_NUM_DROP_MODES: MF_QUALITY_DROP_MODE = MF_QUALITY_DROP_MODE(6i32);
impl ::core::convert::From<i32> for MF_QUALITY_DROP_MODE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_QUALITY_DROP_MODE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_QUALITY_LEVEL(pub i32);
pub const MF_QUALITY_NORMAL: MF_QUALITY_LEVEL = MF_QUALITY_LEVEL(0i32);
pub const MF_QUALITY_NORMAL_MINUS_1: MF_QUALITY_LEVEL = MF_QUALITY_LEVEL(1i32);
pub const MF_QUALITY_NORMAL_MINUS_2: MF_QUALITY_LEVEL = MF_QUALITY_LEVEL(2i32);
pub const MF_QUALITY_NORMAL_MINUS_3: MF_QUALITY_LEVEL = MF_QUALITY_LEVEL(3i32);
pub const MF_QUALITY_NORMAL_MINUS_4: MF_QUALITY_LEVEL = MF_QUALITY_LEVEL(4i32);
pub const MF_QUALITY_NORMAL_MINUS_5: MF_QUALITY_LEVEL = MF_QUALITY_LEVEL(5i32);
pub const MF_NUM_QUALITY_LEVELS: MF_QUALITY_LEVEL = MF_QUALITY_LEVEL(6i32);
impl ::core::convert::From<i32> for MF_QUALITY_LEVEL {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_QUALITY_LEVEL {
type Abi = Self;
}
pub const MF_QUALITY_NOTIFY_PROCESSING_LATENCY: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf6b44af8_604d_46fe_a95d_45479b10c9bc);
pub const MF_QUALITY_NOTIFY_SAMPLE_LAG: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x30d15206_ed2a_4760_be17_eb4a9f12295c);
pub const MF_QUALITY_SERVICES: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb7e2be11_2f96_4640_b52c_282365bdf16c);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MF_QUATERNION {
pub x: f32,
pub y: f32,
pub z: f32,
pub w: f32,
}
impl MF_QUATERNION {}
impl ::core::default::Default for MF_QUATERNION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MF_QUATERNION {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MF_QUATERNION").field("x", &self.x).field("y", &self.y).field("z", &self.z).field("w", &self.w).finish()
}
}
impl ::core::cmp::PartialEq for MF_QUATERNION {
fn eq(&self, other: &Self) -> bool {
self.x == other.x && self.y == other.y && self.z == other.z && self.w == other.w
}
}
impl ::core::cmp::Eq for MF_QUATERNION {}
unsafe impl ::windows::core::Abi for MF_QUATERNION {
type Abi = Self;
}
pub const MF_QUOTA_EXCEEDED_ERR: u32 = 2154823702u32;
pub const MF_RATE_CONTROL_SERVICE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x866fa297_b802_4bf8_9dc9_5e3b6a9f53c9);
pub const MF_READWRITE_D3D_OPTIONAL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x216479d9_3071_42ca_bb6c_4c22102e1d18);
pub const MF_READWRITE_DISABLE_CONVERTERS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x98d5b065_1374_4847_8d5d_31520fee7156);
pub const MF_READWRITE_ENABLE_AUTOFINALIZE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdd7ca129_8cd1_4dc5_9dde_ce168675de61);
pub const MF_READWRITE_ENABLE_HARDWARE_TRANSFORMS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa634a91c_822b_41b9_a494_4de4643612b0);
pub const MF_READWRITE_MMCSS_CLASS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x39384300_d0eb_40b1_87a0_3318871b5a53);
pub const MF_READWRITE_MMCSS_CLASS_AUDIO: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x430847da_0890_4b0e_938c_054332c547e1);
pub const MF_READWRITE_MMCSS_PRIORITY: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x43ad19ce_f33f_4ba9_a580_e4cd12f2d144);
pub const MF_READWRITE_MMCSS_PRIORITY_AUDIO: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x273db885_2de2_4db2_a6a7_fdb66fb40b61);
pub const MF_REMOTE_PROXY: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2f00c90e_d2cf_4278_8b6a_d077fac3a25f);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_RESOLUTION_FLAGS(pub u32);
pub const MF_RESOLUTION_MEDIASOURCE: MF_RESOLUTION_FLAGS = MF_RESOLUTION_FLAGS(1u32);
pub const MF_RESOLUTION_BYTESTREAM: MF_RESOLUTION_FLAGS = MF_RESOLUTION_FLAGS(2u32);
pub const MF_RESOLUTION_CONTENT_DOES_NOT_HAVE_TO_MATCH_EXTENSION_OR_MIME_TYPE: MF_RESOLUTION_FLAGS = MF_RESOLUTION_FLAGS(16u32);
pub const MF_RESOLUTION_KEEP_BYTE_STREAM_ALIVE_ON_FAIL: MF_RESOLUTION_FLAGS = MF_RESOLUTION_FLAGS(32u32);
pub const MF_RESOLUTION_DISABLE_LOCAL_PLUGINS: MF_RESOLUTION_FLAGS = MF_RESOLUTION_FLAGS(64u32);
pub const MF_RESOLUTION_PLUGIN_CONTROL_POLICY_APPROVED_ONLY: MF_RESOLUTION_FLAGS = MF_RESOLUTION_FLAGS(128u32);
pub const MF_RESOLUTION_PLUGIN_CONTROL_POLICY_WEB_ONLY: MF_RESOLUTION_FLAGS = MF_RESOLUTION_FLAGS(256u32);
pub const MF_RESOLUTION_PLUGIN_CONTROL_POLICY_WEB_ONLY_EDGEMODE: MF_RESOLUTION_FLAGS = MF_RESOLUTION_FLAGS(512u32);
pub const MF_RESOLUTION_ENABLE_STORE_PLUGINS: MF_RESOLUTION_FLAGS = MF_RESOLUTION_FLAGS(1024u32);
pub const MF_RESOLUTION_READ: MF_RESOLUTION_FLAGS = MF_RESOLUTION_FLAGS(65536u32);
pub const MF_RESOLUTION_WRITE: MF_RESOLUTION_FLAGS = MF_RESOLUTION_FLAGS(131072u32);
impl ::core::convert::From<u32> for MF_RESOLUTION_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_RESOLUTION_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for MF_RESOLUTION_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for MF_RESOLUTION_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for MF_RESOLUTION_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for MF_RESOLUTION_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for MF_RESOLUTION_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
pub const MF_SAMI_SERVICE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x49a89ae7_b4d9_4ef2_aa5c_f65a3e05ae4e);
pub const MF_SAMPLEGRABBERSINK_IGNORE_CLOCK: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0efda2c0_2b69_4e2e_ab8d_46dcbff7d25d);
pub const MF_SAMPLEGRABBERSINK_SAMPLE_TIME_OFFSET: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x62e3d776_8100_4e03_a6e8_bd3857ac9c47);
pub const MF_SA_AUDIO_ENDPOINT_AWARE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc0381701_805c_42b2_ac8d_e2b4bf21f4f8);
pub const MF_SA_BUFFERS_PER_SAMPLE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x873c5171_1e3d_4e25_988d_b433ce041983);
pub const MF_SA_D3D11_ALLOCATE_DISPLAYABLE_RESOURCES: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xeeface6d_2ea9_4adf_bbdf_7bbc482a1b6d);
pub const MF_SA_D3D11_ALLOW_DYNAMIC_YUV_TEXTURE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xce06d49f_0613_4b9d_86a6_d8c4f9c10075);
pub const MF_SA_D3D11_AWARE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x206b4fc8_fcf9_4c51_afe3_9764369e33a0);
pub const MF_SA_D3D11_BINDFLAGS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xeacf97ad_065c_4408_bee3_fdcbfd128be2);
pub const MF_SA_D3D11_HW_PROTECTED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3a8ba9d9_92ca_4307_a391_6999dbf3b6ce);
pub const MF_SA_D3D11_SHARED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7b8f32c3_6d96_4b89_9203_dd38b61414f3);
pub const MF_SA_D3D11_SHARED_WITHOUT_MUTEX: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x39dbd44d_2e44_4931_a4c8_352d3dc42115);
pub const MF_SA_D3D11_USAGE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe85fe442_2ca3_486e_a9c7_109dda609880);
pub const MF_SA_D3D12_CLEAR_VALUE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x86ba9a39_0526_495d_9ab5_54ec9fad6fc3);
pub const MF_SA_D3D12_HEAP_FLAGS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x496b3266_d28f_4f8c_93a7_4a596b1a31a1);
pub const MF_SA_D3D12_HEAP_TYPE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x56f26a76_bbc1_4ce0_bb11_e22368d874ed);
pub const MF_SA_D3D_AWARE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xeaa35c29_775e_488e_9b61_b3283e49583b);
pub const MF_SA_MINIMUM_OUTPUT_SAMPLE_COUNT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x851745d5_c3d6_476d_9527_498ef2d10d18);
pub const MF_SA_MINIMUM_OUTPUT_SAMPLE_COUNT_PROGRESSIVE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0f5523a5_1cb2_47c5_a550_2eeb84b4d14a);
pub const MF_SA_REQUIRED_SAMPLE_COUNT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x18802c61_324b_4952_abd0_176ff5c696ff);
pub const MF_SA_REQUIRED_SAMPLE_COUNT_PROGRESSIVE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb172d58e_fa77_4e48_8d2a_1df2d850eac2);
pub const MF_SDK_VERSION: u32 = 2u32;
pub const MF_SD_AMBISONICS_SAMPLE3D_DESCRIPTION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf715cf3e_a964_4c3f_94ae_9d6ba7264641);
pub const MF_SD_ASF_EXTSTRMPROP_AVG_BUFFERSIZE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x48f8a524_305d_422d_8524_2502dda33680);
pub const MF_SD_ASF_EXTSTRMPROP_AVG_DATA_BITRATE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x48f8a523_305d_422d_8524_2502dda33680);
pub const MF_SD_ASF_EXTSTRMPROP_LANGUAGE_ID_INDEX: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x48f8a522_305d_422d_8524_2502dda33680);
pub const MF_SD_ASF_EXTSTRMPROP_MAX_BUFFERSIZE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x48f8a526_305d_422d_8524_2502dda33680);
pub const MF_SD_ASF_EXTSTRMPROP_MAX_DATA_BITRATE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x48f8a525_305d_422d_8524_2502dda33680);
pub const MF_SD_ASF_METADATA_DEVICE_CONFORMANCE_TEMPLATE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x245e929d_c44e_4f7e_bb3c_77d4dfd27f8a);
pub const MF_SD_ASF_STREAMBITRATES_BITRATE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa8e182ed_afc8_43d0_b0d1_f65bad9da558);
pub const MF_SD_AUDIO_ENCODER_DELAY: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8e85422c_73de_403f_9a35_550ad6e8b951);
pub const MF_SD_AUDIO_ENCODER_PADDING: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x529c7f2c_ac4b_4e3f_bfc3_0902194982cb);
pub const MF_SD_LANGUAGE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00af2180_bdc2_423c_abca_f503593bc121);
pub const MF_SD_MEDIASOURCE_STATUS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1913678b_fc0f_44da_8f43_1ba3b526f4ae);
pub const MF_SD_MUTUALLY_EXCLUSIVE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x023ef79c_388d_487f_ac17_696cd6e3c6f5);
pub const MF_SD_PROTECTED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x00af2181_bdc2_423c_abca_f503593bc121);
pub const MF_SD_SAMI_LANGUAGE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x36fcb98a_6cd0_44cb_acb9_a8f5600dd0bb);
pub const MF_SD_STREAM_NAME: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4f1b099d_d314_41e5_a781_7fefaa4c501f);
pub const MF_SD_VIDEO_SPHERICAL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa51da449_3fdc_478c_bcb5_30be76595f55);
pub const MF_SD_VIDEO_SPHERICAL_FORMAT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4a8fc407_6ea1_46c8_b567_6971d4a139c3);
pub const MF_SD_VIDEO_SPHERICAL_INITIAL_VIEWDIRECTION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x11d25a49_bb62_467f_9db1_c17165716c49);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_SERVICE_LOOKUP_TYPE(pub i32);
pub const MF_SERVICE_LOOKUP_UPSTREAM: MF_SERVICE_LOOKUP_TYPE = MF_SERVICE_LOOKUP_TYPE(0i32);
pub const MF_SERVICE_LOOKUP_UPSTREAM_DIRECT: MF_SERVICE_LOOKUP_TYPE = MF_SERVICE_LOOKUP_TYPE(1i32);
pub const MF_SERVICE_LOOKUP_DOWNSTREAM: MF_SERVICE_LOOKUP_TYPE = MF_SERVICE_LOOKUP_TYPE(2i32);
pub const MF_SERVICE_LOOKUP_DOWNSTREAM_DIRECT: MF_SERVICE_LOOKUP_TYPE = MF_SERVICE_LOOKUP_TYPE(3i32);
pub const MF_SERVICE_LOOKUP_ALL: MF_SERVICE_LOOKUP_TYPE = MF_SERVICE_LOOKUP_TYPE(4i32);
pub const MF_SERVICE_LOOKUP_GLOBAL: MF_SERVICE_LOOKUP_TYPE = MF_SERVICE_LOOKUP_TYPE(5i32);
impl ::core::convert::From<i32> for MF_SERVICE_LOOKUP_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_SERVICE_LOOKUP_TYPE {
type Abi = Self;
}
pub const MF_SESSION_APPROX_EVENT_OCCURRENCE_TIME: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x190e852f_6238_42d1_b5af_69ea338ef850);
pub const MF_SESSION_CONTENT_PROTECTION_MANAGER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1e83d482_1f1c_4571_8405_88f4b2181f74);
pub const MF_SESSION_GLOBAL_TIME: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1e83d482_1f1c_4571_8405_88f4b2181f72);
pub const MF_SESSION_QUALITY_MANAGER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1e83d482_1f1c_4571_8405_88f4b2181f73);
pub const MF_SESSION_REMOTE_SOURCE_MODE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf4033ef4_9bb3_4378_941f_85a0856bc244);
pub const MF_SESSION_SERVER_CONTEXT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xafe5b291_50fa_46e8_b9be_0c0c3ce4b3a5);
pub const MF_SESSION_TOPOLOADER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1e83d482_1f1c_4571_8405_88f4b2181f71);
pub const MF_SHARING_ENGINE_CALLBACK: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x57dc1e95_d252_43fa_9bbc_180070eefe6d);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_SHARING_ENGINE_EVENT(pub i32);
pub const MF_SHARING_ENGINE_EVENT_DISCONNECT: MF_SHARING_ENGINE_EVENT = MF_SHARING_ENGINE_EVENT(2000i32);
pub const MF_SHARING_ENGINE_EVENT_LOCALRENDERINGSTARTED: MF_SHARING_ENGINE_EVENT = MF_SHARING_ENGINE_EVENT(2001i32);
pub const MF_SHARING_ENGINE_EVENT_LOCALRENDERINGENDED: MF_SHARING_ENGINE_EVENT = MF_SHARING_ENGINE_EVENT(2002i32);
pub const MF_SHARING_ENGINE_EVENT_STOPPED: MF_SHARING_ENGINE_EVENT = MF_SHARING_ENGINE_EVENT(2003i32);
pub const MF_SHARING_ENGINE_EVENT_ERROR: MF_SHARING_ENGINE_EVENT = MF_SHARING_ENGINE_EVENT(2501i32);
impl ::core::convert::From<i32> for MF_SHARING_ENGINE_EVENT {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_SHARING_ENGINE_EVENT {
type Abi = Self;
}
pub const MF_SHARING_ENGINE_SHAREDRENDERER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xefa446a0_73e7_404e_8ae2_fef60af5a32b);
pub const MF_SHUTDOWN_RENDERER_ON_ENGINE_SHUTDOWN: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc112d94d_6b9c_48f8_b6f9_7950ff9ab71e);
pub const MF_SINK_VIDEO_DISPLAY_ASPECT_RATIO_DENOMINATOR: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6ea1eb97_1fe0_4f10_a6e4_1f4f661564e0);
pub const MF_SINK_VIDEO_DISPLAY_ASPECT_RATIO_NUMERATOR: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd0f33b22_b78a_4879_b455_f03ef3fa82cd);
pub const MF_SINK_VIDEO_NATIVE_HEIGHT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf0ca6705_490c_43e8_941c_c0b3206b9a65);
pub const MF_SINK_VIDEO_NATIVE_WIDTH: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe6d6a707_1505_4747_9b10_72d2d158cb3a);
pub const MF_SINK_VIDEO_PTS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2162bde7_421e_4b90_9b33_e58fbf1d58b6);
pub const MF_SINK_WRITER_ASYNC_CALLBACK: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x48cb183e_7b0b_46f4_822e_5e1d2dda4354);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_SINK_WRITER_CONSTANTS(pub u32);
pub const MF_SINK_WRITER_INVALID_STREAM_INDEX: MF_SINK_WRITER_CONSTANTS = MF_SINK_WRITER_CONSTANTS(4294967295u32);
pub const MF_SINK_WRITER_ALL_STREAMS: MF_SINK_WRITER_CONSTANTS = MF_SINK_WRITER_CONSTANTS(4294967294u32);
pub const MF_SINK_WRITER_MEDIASINK: MF_SINK_WRITER_CONSTANTS = MF_SINK_WRITER_CONSTANTS(4294967295u32);
impl ::core::convert::From<u32> for MF_SINK_WRITER_CONSTANTS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_SINK_WRITER_CONSTANTS {
type Abi = Self;
}
impl ::core::ops::BitOr for MF_SINK_WRITER_CONSTANTS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for MF_SINK_WRITER_CONSTANTS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for MF_SINK_WRITER_CONSTANTS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for MF_SINK_WRITER_CONSTANTS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for MF_SINK_WRITER_CONSTANTS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
pub const MF_SINK_WRITER_D3D_MANAGER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xec822da2_e1e9_4b29_a0d8_563c719f5269);
pub const MF_SINK_WRITER_DISABLE_THROTTLING: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x08b845d8_2b74_4afe_9d53_be16d2d5ae4f);
pub const MF_SINK_WRITER_ENCODER_CONFIG: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xad91cd04_a7cc_4ac7_99b6_a57b9a4a7c70);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MF_SINK_WRITER_STATISTICS {
pub cb: u32,
pub llLastTimestampReceived: i64,
pub llLastTimestampEncoded: i64,
pub llLastTimestampProcessed: i64,
pub llLastStreamTickReceived: i64,
pub llLastSinkSampleRequest: i64,
pub qwNumSamplesReceived: u64,
pub qwNumSamplesEncoded: u64,
pub qwNumSamplesProcessed: u64,
pub qwNumStreamTicksReceived: u64,
pub dwByteCountQueued: u32,
pub qwByteCountProcessed: u64,
pub dwNumOutstandingSinkSampleRequests: u32,
pub dwAverageSampleRateReceived: u32,
pub dwAverageSampleRateEncoded: u32,
pub dwAverageSampleRateProcessed: u32,
}
impl MF_SINK_WRITER_STATISTICS {}
impl ::core::default::Default for MF_SINK_WRITER_STATISTICS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MF_SINK_WRITER_STATISTICS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MF_SINK_WRITER_STATISTICS")
.field("cb", &self.cb)
.field("llLastTimestampReceived", &self.llLastTimestampReceived)
.field("llLastTimestampEncoded", &self.llLastTimestampEncoded)
.field("llLastTimestampProcessed", &self.llLastTimestampProcessed)
.field("llLastStreamTickReceived", &self.llLastStreamTickReceived)
.field("llLastSinkSampleRequest", &self.llLastSinkSampleRequest)
.field("qwNumSamplesReceived", &self.qwNumSamplesReceived)
.field("qwNumSamplesEncoded", &self.qwNumSamplesEncoded)
.field("qwNumSamplesProcessed", &self.qwNumSamplesProcessed)
.field("qwNumStreamTicksReceived", &self.qwNumStreamTicksReceived)
.field("dwByteCountQueued", &self.dwByteCountQueued)
.field("qwByteCountProcessed", &self.qwByteCountProcessed)
.field("dwNumOutstandingSinkSampleRequests", &self.dwNumOutstandingSinkSampleRequests)
.field("dwAverageSampleRateReceived", &self.dwAverageSampleRateReceived)
.field("dwAverageSampleRateEncoded", &self.dwAverageSampleRateEncoded)
.field("dwAverageSampleRateProcessed", &self.dwAverageSampleRateProcessed)
.finish()
}
}
impl ::core::cmp::PartialEq for MF_SINK_WRITER_STATISTICS {
fn eq(&self, other: &Self) -> bool {
self.cb == other.cb
&& self.llLastTimestampReceived == other.llLastTimestampReceived
&& self.llLastTimestampEncoded == other.llLastTimestampEncoded
&& self.llLastTimestampProcessed == other.llLastTimestampProcessed
&& self.llLastStreamTickReceived == other.llLastStreamTickReceived
&& self.llLastSinkSampleRequest == other.llLastSinkSampleRequest
&& self.qwNumSamplesReceived == other.qwNumSamplesReceived
&& self.qwNumSamplesEncoded == other.qwNumSamplesEncoded
&& self.qwNumSamplesProcessed == other.qwNumSamplesProcessed
&& self.qwNumStreamTicksReceived == other.qwNumStreamTicksReceived
&& self.dwByteCountQueued == other.dwByteCountQueued
&& self.qwByteCountProcessed == other.qwByteCountProcessed
&& self.dwNumOutstandingSinkSampleRequests == other.dwNumOutstandingSinkSampleRequests
&& self.dwAverageSampleRateReceived == other.dwAverageSampleRateReceived
&& self.dwAverageSampleRateEncoded == other.dwAverageSampleRateEncoded
&& self.dwAverageSampleRateProcessed == other.dwAverageSampleRateProcessed
}
}
impl ::core::cmp::Eq for MF_SINK_WRITER_STATISTICS {}
unsafe impl ::windows::core::Abi for MF_SINK_WRITER_STATISTICS {
type Abi = Self;
}
pub const MF_SOURCE_PRESENTATION_PROVIDER_SERVICE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe002aadc_f4af_4ee5_9847_053edf840426);
pub const MF_SOURCE_READER_ASYNC_CALLBACK: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1e3dbeac_bb43_4c35_b507_cd644464c965);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_SOURCE_READER_CONSTANTS(pub i32);
pub const MF_SOURCE_READER_INVALID_STREAM_INDEX: MF_SOURCE_READER_CONSTANTS = MF_SOURCE_READER_CONSTANTS(-1i32);
pub const MF_SOURCE_READER_ALL_STREAMS: MF_SOURCE_READER_CONSTANTS = MF_SOURCE_READER_CONSTANTS(-2i32);
pub const MF_SOURCE_READER_ANY_STREAM: MF_SOURCE_READER_CONSTANTS = MF_SOURCE_READER_CONSTANTS(-2i32);
pub const MF_SOURCE_READER_FIRST_AUDIO_STREAM: MF_SOURCE_READER_CONSTANTS = MF_SOURCE_READER_CONSTANTS(-3i32);
pub const MF_SOURCE_READER_FIRST_VIDEO_STREAM: MF_SOURCE_READER_CONSTANTS = MF_SOURCE_READER_CONSTANTS(-4i32);
pub const MF_SOURCE_READER_MEDIASOURCE: MF_SOURCE_READER_CONSTANTS = MF_SOURCE_READER_CONSTANTS(-1i32);
impl ::core::convert::From<i32> for MF_SOURCE_READER_CONSTANTS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_SOURCE_READER_CONSTANTS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_SOURCE_READER_CONTROL_FLAG(pub i32);
pub const MF_SOURCE_READER_CONTROLF_DRAIN: MF_SOURCE_READER_CONTROL_FLAG = MF_SOURCE_READER_CONTROL_FLAG(1i32);
impl ::core::convert::From<i32> for MF_SOURCE_READER_CONTROL_FLAG {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_SOURCE_READER_CONTROL_FLAG {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_SOURCE_READER_CURRENT_TYPE_CONSTANTS(pub i32);
pub const MF_SOURCE_READER_CURRENT_TYPE_INDEX: MF_SOURCE_READER_CURRENT_TYPE_CONSTANTS = MF_SOURCE_READER_CURRENT_TYPE_CONSTANTS(-1i32);
impl ::core::convert::From<i32> for MF_SOURCE_READER_CURRENT_TYPE_CONSTANTS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_SOURCE_READER_CURRENT_TYPE_CONSTANTS {
type Abi = Self;
}
pub const MF_SOURCE_READER_D3D11_BIND_FLAGS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x33f3197b_f73a_4e14_8d85_0e4c4368788d);
pub const MF_SOURCE_READER_D3D_MANAGER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xec822da2_e1e9_4b29_a0d8_563c719f5269);
pub const MF_SOURCE_READER_DISABLE_CAMERA_PLUGINS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9d3365dd_058f_4cfb_9f97_b314cc99c8ad);
pub const MF_SOURCE_READER_DISABLE_DXVA: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xaa456cfd_3943_4a1e_a77d_1838c0ea2e35);
pub const MF_SOURCE_READER_DISCONNECT_MEDIASOURCE_ON_SHUTDOWN: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x56b67165_219e_456d_a22e_2d3004c7fe56);
pub const MF_SOURCE_READER_ENABLE_ADVANCED_VIDEO_PROCESSING: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0f81da2c_b537_4672_a8b2_a681b17307a3);
pub const MF_SOURCE_READER_ENABLE_TRANSCODE_ONLY_TRANSFORMS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdfd4f008_b5fd_4e78_ae44_62a1e67bbe27);
pub const MF_SOURCE_READER_ENABLE_VIDEO_PROCESSING: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfb394f3d_ccf1_42ee_bbb3_f9b845d5681d);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_SOURCE_READER_FLAG(pub i32);
pub const MF_SOURCE_READERF_ERROR: MF_SOURCE_READER_FLAG = MF_SOURCE_READER_FLAG(1i32);
pub const MF_SOURCE_READERF_ENDOFSTREAM: MF_SOURCE_READER_FLAG = MF_SOURCE_READER_FLAG(2i32);
pub const MF_SOURCE_READERF_NEWSTREAM: MF_SOURCE_READER_FLAG = MF_SOURCE_READER_FLAG(4i32);
pub const MF_SOURCE_READERF_NATIVEMEDIATYPECHANGED: MF_SOURCE_READER_FLAG = MF_SOURCE_READER_FLAG(16i32);
pub const MF_SOURCE_READERF_CURRENTMEDIATYPECHANGED: MF_SOURCE_READER_FLAG = MF_SOURCE_READER_FLAG(32i32);
pub const MF_SOURCE_READERF_STREAMTICK: MF_SOURCE_READER_FLAG = MF_SOURCE_READER_FLAG(256i32);
pub const MF_SOURCE_READERF_ALLEFFECTSREMOVED: MF_SOURCE_READER_FLAG = MF_SOURCE_READER_FLAG(512i32);
impl ::core::convert::From<i32> for MF_SOURCE_READER_FLAG {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_SOURCE_READER_FLAG {
type Abi = Self;
}
pub const MF_SOURCE_READER_MEDIASOURCE_CHARACTERISTICS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6d23f5c8_c5d7_4a9b_9971_5d11f8bca880);
pub const MF_SOURCE_READER_MEDIASOURCE_CONFIG: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9085abeb_0354_48f9_abb5_200df838c68e);
pub const MF_SOURCE_STREAM_SUPPORTS_HW_CONNECTION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa38253aa_6314_42fd_a3ce_bb27b6859946);
pub const MF_STF_VERSION_DATE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x31a165d5_df67_4095_8e44_8868fc20dbfd);
pub const MF_STF_VERSION_INFO: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6770bd39_ef82_44ee_a49b_934beb24aef7);
pub const MF_STREAM_SINK_SUPPORTS_HW_CONNECTION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9b465cbf_0597_4f9e_9f3c_b97eeef90359);
pub const MF_STREAM_SINK_SUPPORTS_ROTATION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb3e96280_bd05_41a5_97ad_8a7fee24b912);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_STREAM_STATE(pub i32);
pub const MF_STREAM_STATE_STOPPED: MF_STREAM_STATE = MF_STREAM_STATE(0i32);
pub const MF_STREAM_STATE_PAUSED: MF_STREAM_STATE = MF_STREAM_STATE(1i32);
pub const MF_STREAM_STATE_RUNNING: MF_STREAM_STATE = MF_STREAM_STATE(2i32);
impl ::core::convert::From<i32> for MF_STREAM_STATE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_STREAM_STATE {
type Abi = Self;
}
pub const MF_ST_MEDIASOURCE_COLLECTION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x616de972_83ad_4950_8170_630d19cbe307);
pub const MF_SYNTAX_ERR: u32 = 2154823692u32;
pub const MF_S_ACTIVATE_REPLACED: ::windows::core::HRESULT = ::windows::core::HRESULT(866045i32 as _);
pub const MF_S_ASF_PARSEINPROGRESS: ::windows::core::HRESULT = ::windows::core::HRESULT(1074608792i32 as _);
pub const MF_S_CLOCK_STOPPED: ::windows::core::HRESULT = ::windows::core::HRESULT(891972i32 as _);
pub const MF_S_MULTIPLE_BEGIN: ::windows::core::HRESULT = ::windows::core::HRESULT(866008i32 as _);
pub const MF_S_PE_TRUSTED: ::windows::core::HRESULT = ::windows::core::HRESULT(881011i32 as _);
pub const MF_S_PROTECTION_NOT_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(880976i32 as _);
pub const MF_S_SEQUENCER_CONTEXT_CANCELED: ::windows::core::HRESULT = ::windows::core::HRESULT(876973i32 as _);
pub const MF_S_SEQUENCER_SEGMENT_AT_END_OF_STREAM: ::windows::core::HRESULT = ::windows::core::HRESULT(876975i32 as _);
pub const MF_S_SINK_NOT_FINALIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(870978i32 as _);
pub const MF_S_TRANSFORM_DO_NOT_PROPAGATE_EVENT: ::windows::core::HRESULT = ::windows::core::HRESULT(879989i32 as _);
pub const MF_S_VIDEO_DISABLED_WITH_UNKNOWN_SOFTWARE_OUTPUT: ::windows::core::HRESULT = ::windows::core::HRESULT(881001i32 as _);
pub const MF_S_WAIT_FOR_POLICY_SET: ::windows::core::HRESULT = ::windows::core::HRESULT(881000i32 as _);
pub const MF_SampleProtectionSalt: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5403deee_b9ee_438f_aa83_3804997e569d);
pub const MF_TEST_SIGNED_COMPONENT_LOADING: u32 = 16777216u32;
pub const MF_TIMECODE_SERVICE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa0d502a7_0eb3_4885_b1b9_9feb0d083454);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_TIMED_TEXT_ALIGNMENT(pub i32);
pub const MF_TIMED_TEXT_ALIGNMENT_START: MF_TIMED_TEXT_ALIGNMENT = MF_TIMED_TEXT_ALIGNMENT(0i32);
pub const MF_TIMED_TEXT_ALIGNMENT_END: MF_TIMED_TEXT_ALIGNMENT = MF_TIMED_TEXT_ALIGNMENT(1i32);
pub const MF_TIMED_TEXT_ALIGNMENT_CENTER: MF_TIMED_TEXT_ALIGNMENT = MF_TIMED_TEXT_ALIGNMENT(2i32);
impl ::core::convert::From<i32> for MF_TIMED_TEXT_ALIGNMENT {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_TIMED_TEXT_ALIGNMENT {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_TIMED_TEXT_BOUTEN_POSITION(pub i32);
pub const MF_TIMED_TEXT_BOUTEN_POSITION_BEFORE: MF_TIMED_TEXT_BOUTEN_POSITION = MF_TIMED_TEXT_BOUTEN_POSITION(0i32);
pub const MF_TIMED_TEXT_BOUTEN_POSITION_AFTER: MF_TIMED_TEXT_BOUTEN_POSITION = MF_TIMED_TEXT_BOUTEN_POSITION(1i32);
pub const MF_TIMED_TEXT_BOUTEN_POSITION_OUTSIDE: MF_TIMED_TEXT_BOUTEN_POSITION = MF_TIMED_TEXT_BOUTEN_POSITION(2i32);
impl ::core::convert::From<i32> for MF_TIMED_TEXT_BOUTEN_POSITION {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_TIMED_TEXT_BOUTEN_POSITION {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_TIMED_TEXT_BOUTEN_TYPE(pub i32);
pub const MF_TIMED_TEXT_BOUTEN_TYPE_NONE: MF_TIMED_TEXT_BOUTEN_TYPE = MF_TIMED_TEXT_BOUTEN_TYPE(0i32);
pub const MF_TIMED_TEXT_BOUTEN_TYPE_AUTO: MF_TIMED_TEXT_BOUTEN_TYPE = MF_TIMED_TEXT_BOUTEN_TYPE(1i32);
pub const MF_TIMED_TEXT_BOUTEN_TYPE_FILLEDCIRCLE: MF_TIMED_TEXT_BOUTEN_TYPE = MF_TIMED_TEXT_BOUTEN_TYPE(2i32);
pub const MF_TIMED_TEXT_BOUTEN_TYPE_OPENCIRCLE: MF_TIMED_TEXT_BOUTEN_TYPE = MF_TIMED_TEXT_BOUTEN_TYPE(3i32);
pub const MF_TIMED_TEXT_BOUTEN_TYPE_FILLEDDOT: MF_TIMED_TEXT_BOUTEN_TYPE = MF_TIMED_TEXT_BOUTEN_TYPE(4i32);
pub const MF_TIMED_TEXT_BOUTEN_TYPE_OPENDOT: MF_TIMED_TEXT_BOUTEN_TYPE = MF_TIMED_TEXT_BOUTEN_TYPE(5i32);
pub const MF_TIMED_TEXT_BOUTEN_TYPE_FILLEDSESAME: MF_TIMED_TEXT_BOUTEN_TYPE = MF_TIMED_TEXT_BOUTEN_TYPE(6i32);
pub const MF_TIMED_TEXT_BOUTEN_TYPE_OPENSESAME: MF_TIMED_TEXT_BOUTEN_TYPE = MF_TIMED_TEXT_BOUTEN_TYPE(7i32);
impl ::core::convert::From<i32> for MF_TIMED_TEXT_BOUTEN_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_TIMED_TEXT_BOUTEN_TYPE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_TIMED_TEXT_CUE_EVENT(pub i32);
pub const MF_TIMED_TEXT_CUE_EVENT_ACTIVE: MF_TIMED_TEXT_CUE_EVENT = MF_TIMED_TEXT_CUE_EVENT(0i32);
pub const MF_TIMED_TEXT_CUE_EVENT_INACTIVE: MF_TIMED_TEXT_CUE_EVENT = MF_TIMED_TEXT_CUE_EVENT(1i32);
pub const MF_TIMED_TEXT_CUE_EVENT_CLEAR: MF_TIMED_TEXT_CUE_EVENT = MF_TIMED_TEXT_CUE_EVENT(2i32);
impl ::core::convert::From<i32> for MF_TIMED_TEXT_CUE_EVENT {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_TIMED_TEXT_CUE_EVENT {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_TIMED_TEXT_DECORATION(pub i32);
pub const MF_TIMED_TEXT_DECORATION_NONE: MF_TIMED_TEXT_DECORATION = MF_TIMED_TEXT_DECORATION(0i32);
pub const MF_TIMED_TEXT_DECORATION_UNDERLINE: MF_TIMED_TEXT_DECORATION = MF_TIMED_TEXT_DECORATION(1i32);
pub const MF_TIMED_TEXT_DECORATION_LINE_THROUGH: MF_TIMED_TEXT_DECORATION = MF_TIMED_TEXT_DECORATION(2i32);
pub const MF_TIMED_TEXT_DECORATION_OVERLINE: MF_TIMED_TEXT_DECORATION = MF_TIMED_TEXT_DECORATION(4i32);
impl ::core::convert::From<i32> for MF_TIMED_TEXT_DECORATION {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_TIMED_TEXT_DECORATION {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_TIMED_TEXT_DISPLAY_ALIGNMENT(pub i32);
pub const MF_TIMED_TEXT_DISPLAY_ALIGNMENT_BEFORE: MF_TIMED_TEXT_DISPLAY_ALIGNMENT = MF_TIMED_TEXT_DISPLAY_ALIGNMENT(0i32);
pub const MF_TIMED_TEXT_DISPLAY_ALIGNMENT_AFTER: MF_TIMED_TEXT_DISPLAY_ALIGNMENT = MF_TIMED_TEXT_DISPLAY_ALIGNMENT(1i32);
pub const MF_TIMED_TEXT_DISPLAY_ALIGNMENT_CENTER: MF_TIMED_TEXT_DISPLAY_ALIGNMENT = MF_TIMED_TEXT_DISPLAY_ALIGNMENT(2i32);
impl ::core::convert::From<i32> for MF_TIMED_TEXT_DISPLAY_ALIGNMENT {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_TIMED_TEXT_DISPLAY_ALIGNMENT {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_TIMED_TEXT_ERROR_CODE(pub i32);
pub const MF_TIMED_TEXT_ERROR_CODE_NOERROR: MF_TIMED_TEXT_ERROR_CODE = MF_TIMED_TEXT_ERROR_CODE(0i32);
pub const MF_TIMED_TEXT_ERROR_CODE_FATAL: MF_TIMED_TEXT_ERROR_CODE = MF_TIMED_TEXT_ERROR_CODE(1i32);
pub const MF_TIMED_TEXT_ERROR_CODE_DATA_FORMAT: MF_TIMED_TEXT_ERROR_CODE = MF_TIMED_TEXT_ERROR_CODE(2i32);
pub const MF_TIMED_TEXT_ERROR_CODE_NETWORK: MF_TIMED_TEXT_ERROR_CODE = MF_TIMED_TEXT_ERROR_CODE(3i32);
pub const MF_TIMED_TEXT_ERROR_CODE_INTERNAL: MF_TIMED_TEXT_ERROR_CODE = MF_TIMED_TEXT_ERROR_CODE(4i32);
impl ::core::convert::From<i32> for MF_TIMED_TEXT_ERROR_CODE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_TIMED_TEXT_ERROR_CODE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_TIMED_TEXT_FONT_STYLE(pub i32);
pub const MF_TIMED_TEXT_FONT_STYLE_NORMAL: MF_TIMED_TEXT_FONT_STYLE = MF_TIMED_TEXT_FONT_STYLE(0i32);
pub const MF_TIMED_TEXT_FONT_STYLE_OBLIQUE: MF_TIMED_TEXT_FONT_STYLE = MF_TIMED_TEXT_FONT_STYLE(1i32);
pub const MF_TIMED_TEXT_FONT_STYLE_ITALIC: MF_TIMED_TEXT_FONT_STYLE = MF_TIMED_TEXT_FONT_STYLE(2i32);
impl ::core::convert::From<i32> for MF_TIMED_TEXT_FONT_STYLE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_TIMED_TEXT_FONT_STYLE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_TIMED_TEXT_RUBY_ALIGN(pub i32);
pub const MF_TIMED_TEXT_RUBY_ALIGN_CENTER: MF_TIMED_TEXT_RUBY_ALIGN = MF_TIMED_TEXT_RUBY_ALIGN(0i32);
pub const MF_TIMED_TEXT_RUBY_ALIGN_START: MF_TIMED_TEXT_RUBY_ALIGN = MF_TIMED_TEXT_RUBY_ALIGN(1i32);
pub const MF_TIMED_TEXT_RUBY_ALIGN_END: MF_TIMED_TEXT_RUBY_ALIGN = MF_TIMED_TEXT_RUBY_ALIGN(2i32);
pub const MF_TIMED_TEXT_RUBY_ALIGN_SPACEAROUND: MF_TIMED_TEXT_RUBY_ALIGN = MF_TIMED_TEXT_RUBY_ALIGN(3i32);
pub const MF_TIMED_TEXT_RUBY_ALIGN_SPACEBETWEEN: MF_TIMED_TEXT_RUBY_ALIGN = MF_TIMED_TEXT_RUBY_ALIGN(4i32);
pub const MF_TIMED_TEXT_RUBY_ALIGN_WITHBASE: MF_TIMED_TEXT_RUBY_ALIGN = MF_TIMED_TEXT_RUBY_ALIGN(5i32);
impl ::core::convert::From<i32> for MF_TIMED_TEXT_RUBY_ALIGN {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_TIMED_TEXT_RUBY_ALIGN {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_TIMED_TEXT_RUBY_POSITION(pub i32);
pub const MF_TIMED_TEXT_RUBY_POSITION_BEFORE: MF_TIMED_TEXT_RUBY_POSITION = MF_TIMED_TEXT_RUBY_POSITION(0i32);
pub const MF_TIMED_TEXT_RUBY_POSITION_AFTER: MF_TIMED_TEXT_RUBY_POSITION = MF_TIMED_TEXT_RUBY_POSITION(1i32);
pub const MF_TIMED_TEXT_RUBY_POSITION_OUTSIDE: MF_TIMED_TEXT_RUBY_POSITION = MF_TIMED_TEXT_RUBY_POSITION(2i32);
impl ::core::convert::From<i32> for MF_TIMED_TEXT_RUBY_POSITION {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_TIMED_TEXT_RUBY_POSITION {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_TIMED_TEXT_RUBY_RESERVE(pub i32);
pub const MF_TIMED_TEXT_RUBY_RESERVE_NONE: MF_TIMED_TEXT_RUBY_RESERVE = MF_TIMED_TEXT_RUBY_RESERVE(0i32);
pub const MF_TIMED_TEXT_RUBY_RESERVE_BEFORE: MF_TIMED_TEXT_RUBY_RESERVE = MF_TIMED_TEXT_RUBY_RESERVE(1i32);
pub const MF_TIMED_TEXT_RUBY_RESERVE_AFTER: MF_TIMED_TEXT_RUBY_RESERVE = MF_TIMED_TEXT_RUBY_RESERVE(2i32);
pub const MF_TIMED_TEXT_RUBY_RESERVE_BOTH: MF_TIMED_TEXT_RUBY_RESERVE = MF_TIMED_TEXT_RUBY_RESERVE(3i32);
pub const MF_TIMED_TEXT_RUBY_RESERVE_OUTSIDE: MF_TIMED_TEXT_RUBY_RESERVE = MF_TIMED_TEXT_RUBY_RESERVE(4i32);
impl ::core::convert::From<i32> for MF_TIMED_TEXT_RUBY_RESERVE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_TIMED_TEXT_RUBY_RESERVE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_TIMED_TEXT_SCROLL_MODE(pub i32);
pub const MF_TIMED_TEXT_SCROLL_MODE_POP_ON: MF_TIMED_TEXT_SCROLL_MODE = MF_TIMED_TEXT_SCROLL_MODE(0i32);
pub const MF_TIMED_TEXT_SCROLL_MODE_ROLL_UP: MF_TIMED_TEXT_SCROLL_MODE = MF_TIMED_TEXT_SCROLL_MODE(1i32);
impl ::core::convert::From<i32> for MF_TIMED_TEXT_SCROLL_MODE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_TIMED_TEXT_SCROLL_MODE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_TIMED_TEXT_TRACK_KIND(pub i32);
pub const MF_TIMED_TEXT_TRACK_KIND_UNKNOWN: MF_TIMED_TEXT_TRACK_KIND = MF_TIMED_TEXT_TRACK_KIND(0i32);
pub const MF_TIMED_TEXT_TRACK_KIND_SUBTITLES: MF_TIMED_TEXT_TRACK_KIND = MF_TIMED_TEXT_TRACK_KIND(1i32);
pub const MF_TIMED_TEXT_TRACK_KIND_CAPTIONS: MF_TIMED_TEXT_TRACK_KIND = MF_TIMED_TEXT_TRACK_KIND(2i32);
pub const MF_TIMED_TEXT_TRACK_KIND_METADATA: MF_TIMED_TEXT_TRACK_KIND = MF_TIMED_TEXT_TRACK_KIND(3i32);
impl ::core::convert::From<i32> for MF_TIMED_TEXT_TRACK_KIND {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_TIMED_TEXT_TRACK_KIND {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_TIMED_TEXT_TRACK_READY_STATE(pub i32);
pub const MF_TIMED_TEXT_TRACK_READY_STATE_NONE: MF_TIMED_TEXT_TRACK_READY_STATE = MF_TIMED_TEXT_TRACK_READY_STATE(0i32);
pub const MF_TIMED_TEXT_TRACK_READY_STATE_LOADING: MF_TIMED_TEXT_TRACK_READY_STATE = MF_TIMED_TEXT_TRACK_READY_STATE(1i32);
pub const MF_TIMED_TEXT_TRACK_READY_STATE_LOADED: MF_TIMED_TEXT_TRACK_READY_STATE = MF_TIMED_TEXT_TRACK_READY_STATE(2i32);
pub const MF_TIMED_TEXT_TRACK_READY_STATE_ERROR: MF_TIMED_TEXT_TRACK_READY_STATE = MF_TIMED_TEXT_TRACK_READY_STATE(3i32);
impl ::core::convert::From<i32> for MF_TIMED_TEXT_TRACK_READY_STATE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_TIMED_TEXT_TRACK_READY_STATE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_TIMED_TEXT_UNIT_TYPE(pub i32);
pub const MF_TIMED_TEXT_UNIT_TYPE_PIXELS: MF_TIMED_TEXT_UNIT_TYPE = MF_TIMED_TEXT_UNIT_TYPE(0i32);
pub const MF_TIMED_TEXT_UNIT_TYPE_PERCENTAGE: MF_TIMED_TEXT_UNIT_TYPE = MF_TIMED_TEXT_UNIT_TYPE(1i32);
impl ::core::convert::From<i32> for MF_TIMED_TEXT_UNIT_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_TIMED_TEXT_UNIT_TYPE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_TIMED_TEXT_WRITING_MODE(pub i32);
pub const MF_TIMED_TEXT_WRITING_MODE_LRTB: MF_TIMED_TEXT_WRITING_MODE = MF_TIMED_TEXT_WRITING_MODE(0i32);
pub const MF_TIMED_TEXT_WRITING_MODE_RLTB: MF_TIMED_TEXT_WRITING_MODE = MF_TIMED_TEXT_WRITING_MODE(1i32);
pub const MF_TIMED_TEXT_WRITING_MODE_TBRL: MF_TIMED_TEXT_WRITING_MODE = MF_TIMED_TEXT_WRITING_MODE(2i32);
pub const MF_TIMED_TEXT_WRITING_MODE_TBLR: MF_TIMED_TEXT_WRITING_MODE = MF_TIMED_TEXT_WRITING_MODE(3i32);
pub const MF_TIMED_TEXT_WRITING_MODE_LR: MF_TIMED_TEXT_WRITING_MODE = MF_TIMED_TEXT_WRITING_MODE(4i32);
pub const MF_TIMED_TEXT_WRITING_MODE_RL: MF_TIMED_TEXT_WRITING_MODE = MF_TIMED_TEXT_WRITING_MODE(5i32);
pub const MF_TIMED_TEXT_WRITING_MODE_TB: MF_TIMED_TEXT_WRITING_MODE = MF_TIMED_TEXT_WRITING_MODE(6i32);
impl ::core::convert::From<i32> for MF_TIMED_TEXT_WRITING_MODE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_TIMED_TEXT_WRITING_MODE {
type Abi = Self;
}
pub const MF_TIME_FORMAT_ENTRY_RELATIVE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4399f178_46d3_4504_afda_20d32e9ba360);
pub const MF_TIME_FORMAT_SEGMENT_OFFSET: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc8b8be77_869c_431d_812e_169693f65a39);
pub const MF_TOPOLOGY_DXVA_MODE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1e8d34f6_f5ab_4e23_bb88_874aa3a1a74d);
pub const MF_TOPOLOGY_DYNAMIC_CHANGE_NOT_ALLOWED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd529950b_d484_4527_a9cd_b1909532b5b0);
pub const MF_TOPOLOGY_ENABLE_XVP_FOR_PLAYBACK: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1967731f_cd78_42fc_b026_0992a56e5693);
pub const MF_TOPOLOGY_ENUMERATE_SOURCE_TYPES: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6248c36d_5d0b_4f40_a0bb_b0b305f77698);
pub const MF_TOPOLOGY_HARDWARE_MODE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd2d362fd_4e4f_4191_a579_c618b66706af);
pub const MF_TOPOLOGY_NO_MARKIN_MARKOUT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7ed3f804_86bb_4b3f_b7e4_7cb43afd4b80);
pub const MF_TOPOLOGY_PLAYBACK_FRAMERATE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc164737a_c2b1_4553_83bb_5a526072448f);
pub const MF_TOPOLOGY_PLAYBACK_MAX_DIMS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5715cf19_5768_44aa_ad6e_8721f1b0f9bb);
pub const MF_TOPOLOGY_PROJECTSTART: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7ed3f802_86bb_4b3f_b7e4_7cb43afd4b80);
pub const MF_TOPOLOGY_PROJECTSTOP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7ed3f803_86bb_4b3f_b7e4_7cb43afd4b80);
pub const MF_TOPOLOGY_RESOLUTION_STATUS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x494bbcde_b031_4e38_97c4_d5422dd618dc);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_TOPOLOGY_RESOLUTION_STATUS_FLAGS(pub i32);
pub const MF_TOPOLOGY_RESOLUTION_SUCCEEDED: MF_TOPOLOGY_RESOLUTION_STATUS_FLAGS = MF_TOPOLOGY_RESOLUTION_STATUS_FLAGS(0i32);
pub const MF_OPTIONAL_NODE_REJECTED_MEDIA_TYPE: MF_TOPOLOGY_RESOLUTION_STATUS_FLAGS = MF_TOPOLOGY_RESOLUTION_STATUS_FLAGS(1i32);
pub const MF_OPTIONAL_NODE_REJECTED_PROTECTED_PROCESS: MF_TOPOLOGY_RESOLUTION_STATUS_FLAGS = MF_TOPOLOGY_RESOLUTION_STATUS_FLAGS(2i32);
impl ::core::convert::From<i32> for MF_TOPOLOGY_RESOLUTION_STATUS_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_TOPOLOGY_RESOLUTION_STATUS_FLAGS {
type Abi = Self;
}
pub const MF_TOPOLOGY_START_TIME_ON_PRESENTATION_SWITCH: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc8cc113f_7951_4548_aad6_9ed6202e62b3);
pub const MF_TOPOLOGY_STATIC_PLAYBACK_OPTIMIZATIONS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb86cac42_41a6_4b79_897a_1ab0e52b4a1b);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_TOPOLOGY_TYPE(pub i32);
pub const MF_TOPOLOGY_OUTPUT_NODE: MF_TOPOLOGY_TYPE = MF_TOPOLOGY_TYPE(0i32);
pub const MF_TOPOLOGY_SOURCESTREAM_NODE: MF_TOPOLOGY_TYPE = MF_TOPOLOGY_TYPE(1i32);
pub const MF_TOPOLOGY_TRANSFORM_NODE: MF_TOPOLOGY_TYPE = MF_TOPOLOGY_TYPE(2i32);
pub const MF_TOPOLOGY_TEE_NODE: MF_TOPOLOGY_TYPE = MF_TOPOLOGY_TYPE(3i32);
pub const MF_TOPOLOGY_MAX: MF_TOPOLOGY_TYPE = MF_TOPOLOGY_TYPE(-1i32);
impl ::core::convert::From<i32> for MF_TOPOLOGY_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_TOPOLOGY_TYPE {
type Abi = Self;
}
pub const MF_TOPONODE_ATTRIBUTE_EDITOR_SERVICE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x65656e1a_077f_4472_83ef_316f11d5087a);
pub const MF_TOPONODE_CONNECT_METHOD: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x494bbcf1_b031_4e38_97c4_d5422dd618dc);
pub const MF_TOPONODE_D3DAWARE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x494bbced_b031_4e38_97c4_d5422dd618dc);
pub const MF_TOPONODE_DECODER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x494bbd02_b031_4e38_97c4_d5422dd618dc);
pub const MF_TOPONODE_DECRYPTOR: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x494bbcfa_b031_4e38_97c4_d5422dd618dc);
pub const MF_TOPONODE_DISABLE_PREROLL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x14932f9e_9087_4bb4_8412_5167145cbe04);
pub const MF_TOPONODE_DISCARDABLE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x494bbcfb_b031_4e38_97c4_d5422dd618dc);
pub const MF_TOPONODE_DRAIN: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x494bbce9_b031_4e38_97c4_d5422dd618dc);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_TOPONODE_DRAIN_MODE(pub i32);
pub const MF_TOPONODE_DRAIN_DEFAULT: MF_TOPONODE_DRAIN_MODE = MF_TOPONODE_DRAIN_MODE(0i32);
pub const MF_TOPONODE_DRAIN_ALWAYS: MF_TOPONODE_DRAIN_MODE = MF_TOPONODE_DRAIN_MODE(1i32);
pub const MF_TOPONODE_DRAIN_NEVER: MF_TOPONODE_DRAIN_MODE = MF_TOPONODE_DRAIN_MODE(2i32);
impl ::core::convert::From<i32> for MF_TOPONODE_DRAIN_MODE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_TOPONODE_DRAIN_MODE {
type Abi = Self;
}
pub const MF_TOPONODE_ERRORCODE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x494bbcee_b031_4e38_97c4_d5422dd618dc);
pub const MF_TOPONODE_ERROR_MAJORTYPE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x494bbcfd_b031_4e38_97c4_d5422dd618dc);
pub const MF_TOPONODE_ERROR_SUBTYPE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x494bbcfe_b031_4e38_97c4_d5422dd618dc);
pub const MF_TOPONODE_FLUSH: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x494bbce8_b031_4e38_97c4_d5422dd618dc);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_TOPONODE_FLUSH_MODE(pub i32);
pub const MF_TOPONODE_FLUSH_ALWAYS: MF_TOPONODE_FLUSH_MODE = MF_TOPONODE_FLUSH_MODE(0i32);
pub const MF_TOPONODE_FLUSH_SEEK: MF_TOPONODE_FLUSH_MODE = MF_TOPONODE_FLUSH_MODE(1i32);
pub const MF_TOPONODE_FLUSH_NEVER: MF_TOPONODE_FLUSH_MODE = MF_TOPONODE_FLUSH_MODE(2i32);
impl ::core::convert::From<i32> for MF_TOPONODE_FLUSH_MODE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_TOPONODE_FLUSH_MODE {
type Abi = Self;
}
pub const MF_TOPONODE_LOCKED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x494bbcf7_b031_4e38_97c4_d5422dd618dc);
pub const MF_TOPONODE_MARKIN_HERE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x494bbd00_b031_4e38_97c4_d5422dd618dc);
pub const MF_TOPONODE_MARKOUT_HERE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x494bbd01_b031_4e38_97c4_d5422dd618dc);
pub const MF_TOPONODE_MEDIASTART: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x835c58ea_e075_4bc7_bcba_4de000df9ae6);
pub const MF_TOPONODE_MEDIASTOP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x835c58eb_e075_4bc7_bcba_4de000df9ae6);
pub const MF_TOPONODE_NOSHUTDOWN_ON_REMOVE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x14932f9c_9087_4bb4_8412_5167145cbe04);
pub const MF_TOPONODE_PRESENTATION_DESCRIPTOR: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x835c58ed_e075_4bc7_bcba_4de000df9ae6);
pub const MF_TOPONODE_PRIMARYOUTPUT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6304ef99_16b2_4ebe_9d67_e4c539b3a259);
pub const MF_TOPONODE_RATELESS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x14932f9d_9087_4bb4_8412_5167145cbe04);
pub const MF_TOPONODE_SEQUENCE_ELEMENTID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x835c58ef_e075_4bc7_bcba_4de000df9ae6);
pub const MF_TOPONODE_SOURCE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x835c58ec_e075_4bc7_bcba_4de000df9ae6);
pub const MF_TOPONODE_STREAMID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x14932f9b_9087_4bb4_8412_5167145cbe04);
pub const MF_TOPONODE_STREAM_DESCRIPTOR: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x835c58ee_e075_4bc7_bcba_4de000df9ae6);
pub const MF_TOPONODE_TRANSFORM_OBJECTID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x88dcc0c9_293e_4e8b_9aeb_0ad64cc016b0);
pub const MF_TOPONODE_WORKQUEUE_ID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x494bbcf8_b031_4e38_97c4_d5422dd618dc);
pub const MF_TOPONODE_WORKQUEUE_ITEM_PRIORITY: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa1ff99be_5e97_4a53_b494_568c642c0ff3);
pub const MF_TOPONODE_WORKQUEUE_MMCSS_CLASS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x494bbcf9_b031_4e38_97c4_d5422dd618dc);
pub const MF_TOPONODE_WORKQUEUE_MMCSS_PRIORITY: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5001f840_2816_48f4_9364_ad1ef661a123);
pub const MF_TOPONODE_WORKQUEUE_MMCSS_TASKID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x494bbcff_b031_4e38_97c4_d5422dd618dc);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_TOPOSTATUS(pub i32);
pub const MF_TOPOSTATUS_INVALID: MF_TOPOSTATUS = MF_TOPOSTATUS(0i32);
pub const MF_TOPOSTATUS_READY: MF_TOPOSTATUS = MF_TOPOSTATUS(100i32);
pub const MF_TOPOSTATUS_STARTED_SOURCE: MF_TOPOSTATUS = MF_TOPOSTATUS(200i32);
pub const MF_TOPOSTATUS_DYNAMIC_CHANGED: MF_TOPOSTATUS = MF_TOPOSTATUS(210i32);
pub const MF_TOPOSTATUS_SINK_SWITCHED: MF_TOPOSTATUS = MF_TOPOSTATUS(300i32);
pub const MF_TOPOSTATUS_ENDED: MF_TOPOSTATUS = MF_TOPOSTATUS(400i32);
impl ::core::convert::From<i32> for MF_TOPOSTATUS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_TOPOSTATUS {
type Abi = Self;
}
pub const MF_TRANSCODE_ADJUST_PROFILE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9c37c21b_060f_487c_a690_80d7f50d1c72);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_TRANSCODE_ADJUST_PROFILE_FLAGS(pub i32);
pub const MF_TRANSCODE_ADJUST_PROFILE_DEFAULT: MF_TRANSCODE_ADJUST_PROFILE_FLAGS = MF_TRANSCODE_ADJUST_PROFILE_FLAGS(0i32);
pub const MF_TRANSCODE_ADJUST_PROFILE_USE_SOURCE_ATTRIBUTES: MF_TRANSCODE_ADJUST_PROFILE_FLAGS = MF_TRANSCODE_ADJUST_PROFILE_FLAGS(1i32);
impl ::core::convert::From<i32> for MF_TRANSCODE_ADJUST_PROFILE_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_TRANSCODE_ADJUST_PROFILE_FLAGS {
type Abi = Self;
}
pub const MF_TRANSCODE_CONTAINERTYPE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x150ff23f_4abc_478b_ac4f_e1916fba1cca);
pub const MF_TRANSCODE_DONOT_INSERT_ENCODER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf45aa7ce_ab24_4012_a11b_dc8220201410);
pub const MF_TRANSCODE_ENCODINGPROFILE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6947787c_f508_4ea9_b1e9_a1fe3a49fbc9);
pub const MF_TRANSCODE_QUALITYVSSPEED: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x98332df8_03cd_476b_89fa_3f9e442dec9f);
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
pub struct MF_TRANSCODE_SINK_INFO {
pub dwVideoStreamID: u32,
pub pVideoMediaType: ::core::option::Option<IMFMediaType>,
pub dwAudioStreamID: u32,
pub pAudioMediaType: ::core::option::Option<IMFMediaType>,
}
impl MF_TRANSCODE_SINK_INFO {}
impl ::core::default::Default for MF_TRANSCODE_SINK_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MF_TRANSCODE_SINK_INFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MF_TRANSCODE_SINK_INFO").field("dwVideoStreamID", &self.dwVideoStreamID).field("pVideoMediaType", &self.pVideoMediaType).field("dwAudioStreamID", &self.dwAudioStreamID).field("pAudioMediaType", &self.pAudioMediaType).finish()
}
}
impl ::core::cmp::PartialEq for MF_TRANSCODE_SINK_INFO {
fn eq(&self, other: &Self) -> bool {
self.dwVideoStreamID == other.dwVideoStreamID && self.pVideoMediaType == other.pVideoMediaType && self.dwAudioStreamID == other.dwAudioStreamID && self.pAudioMediaType == other.pAudioMediaType
}
}
impl ::core::cmp::Eq for MF_TRANSCODE_SINK_INFO {}
unsafe impl ::windows::core::Abi for MF_TRANSCODE_SINK_INFO {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
pub const MF_TRANSCODE_SKIP_METADATA_TRANSFER: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4e4469ef_b571_4959_8f83_3dcfba33a393);
pub const MF_TRANSCODE_TOPOLOGYMODE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3e3df610_394a_40b2_9dea_3bab650bebf2);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_TRANSCODE_TOPOLOGYMODE_FLAGS(pub i32);
pub const MF_TRANSCODE_TOPOLOGYMODE_SOFTWARE_ONLY: MF_TRANSCODE_TOPOLOGYMODE_FLAGS = MF_TRANSCODE_TOPOLOGYMODE_FLAGS(0i32);
pub const MF_TRANSCODE_TOPOLOGYMODE_HARDWARE_ALLOWED: MF_TRANSCODE_TOPOLOGYMODE_FLAGS = MF_TRANSCODE_TOPOLOGYMODE_FLAGS(1i32);
impl ::core::convert::From<i32> for MF_TRANSCODE_TOPOLOGYMODE_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_TRANSCODE_TOPOLOGYMODE_FLAGS {
type Abi = Self;
}
pub const MF_TRANSFORM_ASYNC: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf81a699a_649a_497d_8c73_29f8fed6ad7a);
pub const MF_TRANSFORM_ASYNC_UNLOCK: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe5666d6b_3422_4eb6_a421_da7db1f8e207);
pub const MF_TRANSFORM_CATEGORY_Attribute: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xceabba49_506d_4757_a6ff_66c184987e4e);
pub const MF_TRANSFORM_FLAGS_Attribute: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9359bb7e_6275_46c4_a025_1c01e45f1a86);
pub const MF_TYPE_ERR: u32 = 2154840069u32;
pub const MF_UNKNOWN_DURATION: u32 = 0u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_URL_TRUST_STATUS(pub i32);
pub const MF_LICENSE_URL_UNTRUSTED: MF_URL_TRUST_STATUS = MF_URL_TRUST_STATUS(0i32);
pub const MF_LICENSE_URL_TRUSTED: MF_URL_TRUST_STATUS = MF_URL_TRUST_STATUS(1i32);
pub const MF_LICENSE_URL_TAMPERED: MF_URL_TRUST_STATUS = MF_URL_TRUST_STATUS(2i32);
impl ::core::convert::From<i32> for MF_URL_TRUST_STATUS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_URL_TRUST_STATUS {
type Abi = Self;
}
pub const MF_USER_DATA_PAYLOAD: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd1d4985d_dc92_457a_b3a0_651a33a31047);
pub const MF_USER_EXTENDED_ATTRIBUTES: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc02abac6_feb2_4541_922f_920b43702722);
pub const MF_USER_MODE_COMPONENT_LOAD: u32 = 1u32;
pub const MF_VIDEODSP_MODE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x16d720f0_768c_11de_8a39_0800200c9a66);
pub const MF_VIDEO_MAX_MB_PER_SEC: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe3f2e203_d445_4b8c_9211_ae390d3ba017);
pub const MF_VIDEO_PROCESSOR_ALGORITHM: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4a0a1e1f_272c_4fb6_9eb1_db330cbc97ca);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_VIDEO_PROCESSOR_ALGORITHM_TYPE(pub i32);
pub const MF_VIDEO_PROCESSOR_ALGORITHM_DEFAULT: MF_VIDEO_PROCESSOR_ALGORITHM_TYPE = MF_VIDEO_PROCESSOR_ALGORITHM_TYPE(0i32);
pub const MF_VIDEO_PROCESSOR_ALGORITHM_MRF_CRF_444: MF_VIDEO_PROCESSOR_ALGORITHM_TYPE = MF_VIDEO_PROCESSOR_ALGORITHM_TYPE(1i32);
impl ::core::convert::From<i32> for MF_VIDEO_PROCESSOR_ALGORITHM_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_VIDEO_PROCESSOR_ALGORITHM_TYPE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_VIDEO_PROCESSOR_MIRROR(pub i32);
pub const MIRROR_NONE: MF_VIDEO_PROCESSOR_MIRROR = MF_VIDEO_PROCESSOR_MIRROR(0i32);
pub const MIRROR_HORIZONTAL: MF_VIDEO_PROCESSOR_MIRROR = MF_VIDEO_PROCESSOR_MIRROR(1i32);
pub const MIRROR_VERTICAL: MF_VIDEO_PROCESSOR_MIRROR = MF_VIDEO_PROCESSOR_MIRROR(2i32);
impl ::core::convert::From<i32> for MF_VIDEO_PROCESSOR_MIRROR {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_VIDEO_PROCESSOR_MIRROR {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MF_VIDEO_PROCESSOR_ROTATION(pub i32);
pub const ROTATION_NONE: MF_VIDEO_PROCESSOR_ROTATION = MF_VIDEO_PROCESSOR_ROTATION(0i32);
pub const ROTATION_NORMAL: MF_VIDEO_PROCESSOR_ROTATION = MF_VIDEO_PROCESSOR_ROTATION(1i32);
impl ::core::convert::From<i32> for MF_VIDEO_PROCESSOR_ROTATION {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MF_VIDEO_PROCESSOR_ROTATION {
type Abi = Self;
}
pub const MF_VIDEO_RENDERER_EFFECT_APP_SERVICE_NAME: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc6052a80_6d9c_40a3_9db8_f027a25c9ab9);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MF_VIDEO_SPHERICAL_VIEWDIRECTION {
pub iHeading: i32,
pub iPitch: i32,
pub iRoll: i32,
}
impl MF_VIDEO_SPHERICAL_VIEWDIRECTION {}
impl ::core::default::Default for MF_VIDEO_SPHERICAL_VIEWDIRECTION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MF_VIDEO_SPHERICAL_VIEWDIRECTION {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MF_VIDEO_SPHERICAL_VIEWDIRECTION").field("iHeading", &self.iHeading).field("iPitch", &self.iPitch).field("iRoll", &self.iRoll).finish()
}
}
impl ::core::cmp::PartialEq for MF_VIDEO_SPHERICAL_VIEWDIRECTION {
fn eq(&self, other: &Self) -> bool {
self.iHeading == other.iHeading && self.iPitch == other.iPitch && self.iRoll == other.iRoll
}
}
impl ::core::cmp::Eq for MF_VIDEO_SPHERICAL_VIEWDIRECTION {}
unsafe impl ::windows::core::Abi for MF_VIDEO_SPHERICAL_VIEWDIRECTION {
type Abi = Self;
}
pub const MF_VIRTUALCAMERA_CONFIGURATION_APP_PACKAGE_FAMILY_NAME: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x658abe51_8044_462e_97ea_e676fd72055f);
pub const MF_WORKQUEUE_SERVICES: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8e37d489_41e0_413a_9068_287c886d8dda);
pub const MF_WRAPPED_BUFFER_SERVICE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xab544072_c269_4ebc_a552_1c3b32bed5ca);
pub const MF_WRAPPED_OBJECT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2b182c4c_d6ac_49f4_8915_f71887db70cd);
pub const MF_WRAPPED_SAMPLE_SERVICE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x31f52bf2_d03e_4048_80d0_9c1046d87c61);
pub const MF_WVC1_PROG_SINGLE_SLICE_CONTENT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x67ec2559_0f2f_4420_a4dd_2f8ee7a5738b);
pub const MF_XVP_CALLER_ALLOCATES_OUTPUT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x04a2cabc_0cab_40b1_a1b9_75bc3658f000);
pub const MF_XVP_DISABLE_FRC: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2c0afa19_7a97_4d5a_9ee8_16d4fc518d8c);
pub const MF_XVP_SAMPLE_LOCK_TIMEOUT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xaa4ddb29_5134_4363_ac72_83ec4bc10426);
#[inline]
pub unsafe fn MFllMulDiv(a: i64, b: i64, c: i64, d: i64) -> i64 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MFllMulDiv(a: i64, b: i64, c: i64, d: i64) -> i64;
}
::core::mem::transmute(MFllMulDiv(::core::mem::transmute(a), ::core::mem::transmute(b), ::core::mem::transmute(c), ::core::mem::transmute(d)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MIC_ARRAY_MODE(pub i32);
pub const MICARRAY_SINGLE_CHAN: MIC_ARRAY_MODE = MIC_ARRAY_MODE(0i32);
pub const MICARRAY_SIMPLE_SUM: MIC_ARRAY_MODE = MIC_ARRAY_MODE(256i32);
pub const MICARRAY_SINGLE_BEAM: MIC_ARRAY_MODE = MIC_ARRAY_MODE(512i32);
pub const MICARRAY_FIXED_BEAM: MIC_ARRAY_MODE = MIC_ARRAY_MODE(1024i32);
pub const MICARRAY_EXTERN_BEAM: MIC_ARRAY_MODE = MIC_ARRAY_MODE(2048i32);
impl ::core::convert::From<i32> for MIC_ARRAY_MODE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MIC_ARRAY_MODE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct MOVEREGION_INFO {
pub FrameNumber: u32,
pub NumMoveRegions: u32,
pub MoveRegions: [MOVE_RECT; 1],
}
#[cfg(feature = "Win32_Foundation")]
impl MOVEREGION_INFO {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for MOVEREGION_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for MOVEREGION_INFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MOVEREGION_INFO").field("FrameNumber", &self.FrameNumber).field("NumMoveRegions", &self.NumMoveRegions).field("MoveRegions", &self.MoveRegions).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for MOVEREGION_INFO {
fn eq(&self, other: &Self) -> bool {
self.FrameNumber == other.FrameNumber && self.NumMoveRegions == other.NumMoveRegions && self.MoveRegions == other.MoveRegions
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for MOVEREGION_INFO {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for MOVEREGION_INFO {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct MOVE_RECT {
pub SourcePoint: super::super::Foundation::POINT,
pub DestRect: super::super::Foundation::RECT,
}
#[cfg(feature = "Win32_Foundation")]
impl MOVE_RECT {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for MOVE_RECT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for MOVE_RECT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MOVE_RECT").field("SourcePoint", &self.SourcePoint).field("DestRect", &self.DestRect).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for MOVE_RECT {
fn eq(&self, other: &Self) -> bool {
self.SourcePoint == other.SourcePoint && self.DestRect == other.DestRect
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for MOVE_RECT {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for MOVE_RECT {
type Abi = Self;
}
pub const MP3ACMCodecWrapper: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x11103421_354c_4cca_a7a3_1aff9a5b6701);
pub const MR_AUDIO_POLICY_SERVICE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x911fd737_6775_4ab0_a614_297862fdac88);
pub const MR_BUFFER_SERVICE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa562248c_9ac6_4ffc_9fba_3af8f8ad1a4d);
pub const MR_CAPTURE_POLICY_VOLUME_SERVICE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x24030acd_107a_4265_975c_414e33e65f2a);
pub const MR_POLICY_VOLUME_SERVICE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1abaa2ac_9d3b_47c6_ab48_c59506de784d);
pub const MR_STREAM_VOLUME_SERVICE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf8b5fa2f_32ef_46f5_b172_1321212fb2c4);
pub const MR_VIDEO_ACCELERATION_SERVICE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xefef5175_5c7d_4ce2_bbbd_34ff8bca6554);
pub const MR_VIDEO_MIXER_SERVICE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x073cd2fc_6cf4_40b7_8859_e89552c841f8);
pub const MR_VIDEO_RENDER_SERVICE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1092a86c_ab1a_459a_a336_831fbc4d11ff);
pub const MSAMRNBDecoder: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x265011ae_5481_4f77_a295_abb6ffe8d63e);
pub const MSAMRNBEncoder: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2fae8afe_04a3_423a_a814_85db454712b0);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct MT_ARBITRARY_HEADER {
pub majortype: ::windows::core::GUID,
pub subtype: ::windows::core::GUID,
pub bFixedSizeSamples: super::super::Foundation::BOOL,
pub bTemporalCompression: super::super::Foundation::BOOL,
pub lSampleSize: u32,
pub formattype: ::windows::core::GUID,
}
#[cfg(feature = "Win32_Foundation")]
impl MT_ARBITRARY_HEADER {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for MT_ARBITRARY_HEADER {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for MT_ARBITRARY_HEADER {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MT_ARBITRARY_HEADER")
.field("majortype", &self.majortype)
.field("subtype", &self.subtype)
.field("bFixedSizeSamples", &self.bFixedSizeSamples)
.field("bTemporalCompression", &self.bTemporalCompression)
.field("lSampleSize", &self.lSampleSize)
.field("formattype", &self.formattype)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for MT_ARBITRARY_HEADER {
fn eq(&self, other: &Self) -> bool {
self.majortype == other.majortype && self.subtype == other.subtype && self.bFixedSizeSamples == other.bFixedSizeSamples && self.bTemporalCompression == other.bTemporalCompression && self.lSampleSize == other.lSampleSize && self.formattype == other.formattype
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for MT_ARBITRARY_HEADER {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for MT_ARBITRARY_HEADER {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MT_CUSTOM_VIDEO_PRIMARIES {
pub fRx: f32,
pub fRy: f32,
pub fGx: f32,
pub fGy: f32,
pub fBx: f32,
pub fBy: f32,
pub fWx: f32,
pub fWy: f32,
}
impl MT_CUSTOM_VIDEO_PRIMARIES {}
impl ::core::default::Default for MT_CUSTOM_VIDEO_PRIMARIES {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MT_CUSTOM_VIDEO_PRIMARIES {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MT_CUSTOM_VIDEO_PRIMARIES").field("fRx", &self.fRx).field("fRy", &self.fRy).field("fGx", &self.fGx).field("fGy", &self.fGy).field("fBx", &self.fBx).field("fBy", &self.fBy).field("fWx", &self.fWx).field("fWy", &self.fWy).finish()
}
}
impl ::core::cmp::PartialEq for MT_CUSTOM_VIDEO_PRIMARIES {
fn eq(&self, other: &Self) -> bool {
self.fRx == other.fRx && self.fRy == other.fRy && self.fGx == other.fGx && self.fGy == other.fGy && self.fBx == other.fBx && self.fBy == other.fBy && self.fWx == other.fWx && self.fWy == other.fWy
}
}
impl ::core::cmp::Eq for MT_CUSTOM_VIDEO_PRIMARIES {}
unsafe impl ::windows::core::Abi for MT_CUSTOM_VIDEO_PRIMARIES {
type Abi = Self;
}
pub const MULawCodecWrapper: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x92b66080_5e2d_449e_90c4_c41f268e5514);
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn OPMGetVideoOutputForTarget(padapterluid: *const super::super::Foundation::LUID, vidpntarget: u32, vos: OPM_VIDEO_OUTPUT_SEMANTICS) -> ::windows::core::Result<IOPMVideoOutput> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn OPMGetVideoOutputForTarget(padapterluid: *const super::super::Foundation::LUID, vidpntarget: u32, vos: OPM_VIDEO_OUTPUT_SEMANTICS, ppopmvideooutput: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IOPMVideoOutput as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
OPMGetVideoOutputForTarget(::core::mem::transmute(padapterluid), ::core::mem::transmute(vidpntarget), ::core::mem::transmute(vos), &mut result__).from_abi::<IOPMVideoOutput>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Graphics_Gdi")]
#[inline]
pub unsafe fn OPMGetVideoOutputsFromHMONITOR<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Gdi::HMONITOR>>(hmonitor: Param0, vos: OPM_VIDEO_OUTPUT_SEMANTICS, pulnumvideooutputs: *mut u32, pppopmvideooutputarray: *mut *mut ::core::option::Option<IOPMVideoOutput>) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn OPMGetVideoOutputsFromHMONITOR(hmonitor: super::super::Graphics::Gdi::HMONITOR, vos: OPM_VIDEO_OUTPUT_SEMANTICS, pulnumvideooutputs: *mut u32, pppopmvideooutputarray: *mut *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
OPMGetVideoOutputsFromHMONITOR(hmonitor.into_param().abi(), ::core::mem::transmute(vos), ::core::mem::transmute(pulnumvideooutputs), ::core::mem::transmute(pppopmvideooutputarray)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
#[inline]
pub unsafe fn OPMGetVideoOutputsFromIDirect3DDevice9Object<'a, Param0: ::windows::core::IntoParam<'a, super::super::Graphics::Direct3D9::IDirect3DDevice9>>(pdirect3ddevice9: Param0, vos: OPM_VIDEO_OUTPUT_SEMANTICS, pulnumvideooutputs: *mut u32, pppopmvideooutputarray: *mut *mut ::core::option::Option<IOPMVideoOutput>) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn OPMGetVideoOutputsFromIDirect3DDevice9Object(pdirect3ddevice9: ::windows::core::RawPtr, vos: OPM_VIDEO_OUTPUT_SEMANTICS, pulnumvideooutputs: *mut u32, pppopmvideooutputarray: *mut *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
OPMGetVideoOutputsFromIDirect3DDevice9Object(pdirect3ddevice9.into_param().abi(), ::core::mem::transmute(vos), ::core::mem::transmute(pulnumvideooutputs), ::core::mem::transmute(pppopmvideooutputarray)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn OPMXboxEnableHDCP(hdcptype: OPM_HDCP_TYPE) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn OPMXboxEnableHDCP(hdcptype: OPM_HDCP_TYPE) -> ::windows::core::HRESULT;
}
OPMXboxEnableHDCP(::core::mem::transmute(hdcptype)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn OPMXboxGetHDCPStatus(phdcpstatus: *mut OPM_HDCP_STATUS) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn OPMXboxGetHDCPStatus(phdcpstatus: *mut OPM_HDCP_STATUS) -> ::windows::core::HRESULT;
}
OPMXboxGetHDCPStatus(::core::mem::transmute(phdcpstatus)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn OPMXboxGetHDCPStatusAndType(phdcpstatus: *mut OPM_HDCP_STATUS, phdcptype: *mut OPM_HDCP_TYPE) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn OPMXboxGetHDCPStatusAndType(phdcpstatus: *mut OPM_HDCP_STATUS, phdcptype: *mut OPM_HDCP_TYPE) -> ::windows::core::HRESULT;
}
OPMXboxGetHDCPStatusAndType(::core::mem::transmute(phdcpstatus), ::core::mem::transmute(phdcptype)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct OPM_ACP_AND_CGMSA_SIGNALING {
pub rnRandomNumber: OPM_RANDOM_NUMBER,
pub ulStatusFlags: u32,
pub ulAvailableTVProtectionStandards: u32,
pub ulActiveTVProtectionStandard: u32,
pub ulReserved: u32,
pub ulAspectRatioValidMask1: u32,
pub ulAspectRatioData1: u32,
pub ulAspectRatioValidMask2: u32,
pub ulAspectRatioData2: u32,
pub ulAspectRatioValidMask3: u32,
pub ulAspectRatioData3: u32,
pub ulReserved2: [u32; 4],
pub ulReserved3: [u32; 4],
}
impl OPM_ACP_AND_CGMSA_SIGNALING {}
impl ::core::default::Default for OPM_ACP_AND_CGMSA_SIGNALING {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for OPM_ACP_AND_CGMSA_SIGNALING {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for OPM_ACP_AND_CGMSA_SIGNALING {}
unsafe impl ::windows::core::Abi for OPM_ACP_AND_CGMSA_SIGNALING {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct OPM_ACP_PROTECTION_LEVEL(pub i32);
pub const OPM_ACP_OFF: OPM_ACP_PROTECTION_LEVEL = OPM_ACP_PROTECTION_LEVEL(0i32);
pub const OPM_ACP_LEVEL_ONE: OPM_ACP_PROTECTION_LEVEL = OPM_ACP_PROTECTION_LEVEL(1i32);
pub const OPM_ACP_LEVEL_TWO: OPM_ACP_PROTECTION_LEVEL = OPM_ACP_PROTECTION_LEVEL(2i32);
pub const OPM_ACP_LEVEL_THREE: OPM_ACP_PROTECTION_LEVEL = OPM_ACP_PROTECTION_LEVEL(3i32);
pub const OPM_ACP_FORCE_ULONG: OPM_ACP_PROTECTION_LEVEL = OPM_ACP_PROTECTION_LEVEL(2147483647i32);
impl ::core::convert::From<i32> for OPM_ACP_PROTECTION_LEVEL {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for OPM_ACP_PROTECTION_LEVEL {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub struct OPM_ACTUAL_OUTPUT_FORMAT {
pub rnRandomNumber: OPM_RANDOM_NUMBER,
pub ulStatusFlags: u32,
pub ulDisplayWidth: u32,
pub ulDisplayHeight: u32,
pub dsfSampleInterleaveFormat: DXVA2_SampleFormat,
pub d3dFormat: super::super::Graphics::Direct3D9::D3DFORMAT,
pub ulFrequencyNumerator: u32,
pub ulFrequencyDenominator: u32,
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl OPM_ACTUAL_OUTPUT_FORMAT {}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::default::Default for OPM_ACTUAL_OUTPUT_FORMAT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::cmp::PartialEq for OPM_ACTUAL_OUTPUT_FORMAT {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
impl ::core::cmp::Eq for OPM_ACTUAL_OUTPUT_FORMAT {}
#[cfg(feature = "Win32_Graphics_Direct3D9")]
unsafe impl ::windows::core::Abi for OPM_ACTUAL_OUTPUT_FORMAT {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct OPM_BUS_TYPE(pub i32);
pub const OPM_BUS_TYPE_OTHER: OPM_BUS_TYPE = OPM_BUS_TYPE(0i32);
pub const OPM_BUS_TYPE_PCI: OPM_BUS_TYPE = OPM_BUS_TYPE(1i32);
pub const OPM_BUS_TYPE_PCIX: OPM_BUS_TYPE = OPM_BUS_TYPE(2i32);
pub const OPM_BUS_TYPE_PCIEXPRESS: OPM_BUS_TYPE = OPM_BUS_TYPE(3i32);
pub const OPM_BUS_TYPE_AGP: OPM_BUS_TYPE = OPM_BUS_TYPE(4i32);
pub const OPM_BUS_IMPLEMENTATION_MODIFIER_INSIDE_OF_CHIPSET: OPM_BUS_TYPE = OPM_BUS_TYPE(65536i32);
pub const OPM_BUS_IMPLEMENTATION_MODIFIER_TRACKS_ON_MOTHER_BOARD_TO_CHIP: OPM_BUS_TYPE = OPM_BUS_TYPE(131072i32);
pub const OPM_BUS_IMPLEMENTATION_MODIFIER_TRACKS_ON_MOTHER_BOARD_TO_SOCKET: OPM_BUS_TYPE = OPM_BUS_TYPE(196608i32);
pub const OPM_BUS_IMPLEMENTATION_MODIFIER_DAUGHTER_BOARD_CONNECTOR: OPM_BUS_TYPE = OPM_BUS_TYPE(262144i32);
pub const OPM_BUS_IMPLEMENTATION_MODIFIER_DAUGHTER_BOARD_CONNECTOR_INSIDE_OF_NUAE: OPM_BUS_TYPE = OPM_BUS_TYPE(327680i32);
pub const OPM_BUS_IMPLEMENTATION_MODIFIER_NON_STANDARD: OPM_BUS_TYPE = OPM_BUS_TYPE(-2147483648i32);
pub const OPM_COPP_COMPATIBLE_BUS_TYPE_INTEGRATED: OPM_BUS_TYPE = OPM_BUS_TYPE(-2147483648i32);
impl ::core::convert::From<i32> for OPM_BUS_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for OPM_BUS_TYPE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct OPM_CGMSA(pub i32);
pub const OPM_CGMSA_OFF: OPM_CGMSA = OPM_CGMSA(0i32);
pub const OPM_CGMSA_COPY_FREELY: OPM_CGMSA = OPM_CGMSA(1i32);
pub const OPM_CGMSA_COPY_NO_MORE: OPM_CGMSA = OPM_CGMSA(2i32);
pub const OPM_CGMSA_COPY_ONE_GENERATION: OPM_CGMSA = OPM_CGMSA(3i32);
pub const OPM_CGMSA_COPY_NEVER: OPM_CGMSA = OPM_CGMSA(4i32);
pub const OPM_CGMSA_REDISTRIBUTION_CONTROL_REQUIRED: OPM_CGMSA = OPM_CGMSA(8i32);
impl ::core::convert::From<i32> for OPM_CGMSA {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for OPM_CGMSA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct OPM_CONFIGURE_PARAMETERS {
pub omac: OPM_OMAC,
pub guidSetting: ::windows::core::GUID,
pub ulSequenceNumber: u32,
pub cbParametersSize: u32,
pub abParameters: [u8; 4056],
}
impl OPM_CONFIGURE_PARAMETERS {}
impl ::core::default::Default for OPM_CONFIGURE_PARAMETERS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for OPM_CONFIGURE_PARAMETERS {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for OPM_CONFIGURE_PARAMETERS {}
unsafe impl ::windows::core::Abi for OPM_CONFIGURE_PARAMETERS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct OPM_CONNECTED_HDCP_DEVICE_INFORMATION {
pub rnRandomNumber: OPM_RANDOM_NUMBER,
pub ulStatusFlags: u32,
pub ulHDCPFlags: u32,
pub ksvB: OPM_HDCP_KEY_SELECTION_VECTOR,
pub Reserved: [u8; 11],
pub Reserved2: [u8; 16],
pub Reserved3: [u8; 16],
}
impl OPM_CONNECTED_HDCP_DEVICE_INFORMATION {}
impl ::core::default::Default for OPM_CONNECTED_HDCP_DEVICE_INFORMATION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for OPM_CONNECTED_HDCP_DEVICE_INFORMATION {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for OPM_CONNECTED_HDCP_DEVICE_INFORMATION {}
unsafe impl ::windows::core::Abi for OPM_CONNECTED_HDCP_DEVICE_INFORMATION {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct OPM_COPP_COMPATIBLE_GET_INFO_PARAMETERS {
pub rnRandomNumber: OPM_RANDOM_NUMBER,
pub guidInformation: ::windows::core::GUID,
pub ulSequenceNumber: u32,
pub cbParametersSize: u32,
pub abParameters: [u8; 4056],
}
impl OPM_COPP_COMPATIBLE_GET_INFO_PARAMETERS {}
impl ::core::default::Default for OPM_COPP_COMPATIBLE_GET_INFO_PARAMETERS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for OPM_COPP_COMPATIBLE_GET_INFO_PARAMETERS {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for OPM_COPP_COMPATIBLE_GET_INFO_PARAMETERS {}
unsafe impl ::windows::core::Abi for OPM_COPP_COMPATIBLE_GET_INFO_PARAMETERS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct OPM_DPCP_PROTECTION_LEVEL(pub i32);
pub const OPM_DPCP_OFF: OPM_DPCP_PROTECTION_LEVEL = OPM_DPCP_PROTECTION_LEVEL(0i32);
pub const OPM_DPCP_ON: OPM_DPCP_PROTECTION_LEVEL = OPM_DPCP_PROTECTION_LEVEL(1i32);
pub const OPM_DPCP_FORCE_ULONG: OPM_DPCP_PROTECTION_LEVEL = OPM_DPCP_PROTECTION_LEVEL(2147483647i32);
impl ::core::convert::From<i32> for OPM_DPCP_PROTECTION_LEVEL {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for OPM_DPCP_PROTECTION_LEVEL {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct OPM_DVI_CHARACTERISTIC(pub i32);
pub const OPM_DVI_CHARACTERISTIC_1_0: OPM_DVI_CHARACTERISTIC = OPM_DVI_CHARACTERISTIC(1i32);
pub const OPM_DVI_CHARACTERISTIC_1_1_OR_ABOVE: OPM_DVI_CHARACTERISTIC = OPM_DVI_CHARACTERISTIC(2i32);
impl ::core::convert::From<i32> for OPM_DVI_CHARACTERISTIC {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for OPM_DVI_CHARACTERISTIC {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct OPM_ENCRYPTED_INITIALIZATION_PARAMETERS {
pub abEncryptedInitializationParameters: [u8; 256],
}
impl OPM_ENCRYPTED_INITIALIZATION_PARAMETERS {}
impl ::core::default::Default for OPM_ENCRYPTED_INITIALIZATION_PARAMETERS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for OPM_ENCRYPTED_INITIALIZATION_PARAMETERS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("OPM_ENCRYPTED_INITIALIZATION_PARAMETERS").field("abEncryptedInitializationParameters", &self.abEncryptedInitializationParameters).finish()
}
}
impl ::core::cmp::PartialEq for OPM_ENCRYPTED_INITIALIZATION_PARAMETERS {
fn eq(&self, other: &Self) -> bool {
self.abEncryptedInitializationParameters == other.abEncryptedInitializationParameters
}
}
impl ::core::cmp::Eq for OPM_ENCRYPTED_INITIALIZATION_PARAMETERS {}
unsafe impl ::windows::core::Abi for OPM_ENCRYPTED_INITIALIZATION_PARAMETERS {
type Abi = Self;
}
pub const OPM_GET_ACP_AND_CGMSA_SIGNALING: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6629a591_3b79_4cf3_924a_11e8e7811671);
pub const OPM_GET_ACTUAL_OUTPUT_FORMAT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd7bf1ba3_ad13_4f8e_af98_0dcb3ca204cc);
pub const OPM_GET_ACTUAL_PROTECTION_LEVEL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1957210a_7766_452a_b99a_d27aed54f03a);
pub const OPM_GET_ADAPTER_BUS_TYPE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc6f4d673_6174_4184_8e35_f6db5200bcba);
pub const OPM_GET_CODEC_INFO: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4f374491_8f5f_4445_9dba_95588f6b58b4);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct OPM_GET_CODEC_INFO_INFORMATION {
pub rnRandomNumber: OPM_RANDOM_NUMBER,
pub Merit: u32,
}
impl OPM_GET_CODEC_INFO_INFORMATION {}
impl ::core::default::Default for OPM_GET_CODEC_INFO_INFORMATION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for OPM_GET_CODEC_INFO_INFORMATION {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for OPM_GET_CODEC_INFO_INFORMATION {}
unsafe impl ::windows::core::Abi for OPM_GET_CODEC_INFO_INFORMATION {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct OPM_GET_CODEC_INFO_PARAMETERS {
pub cbVerifier: u32,
pub Verifier: [u8; 4052],
}
impl OPM_GET_CODEC_INFO_PARAMETERS {}
impl ::core::default::Default for OPM_GET_CODEC_INFO_PARAMETERS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for OPM_GET_CODEC_INFO_PARAMETERS {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for OPM_GET_CODEC_INFO_PARAMETERS {}
unsafe impl ::windows::core::Abi for OPM_GET_CODEC_INFO_PARAMETERS {
type Abi = Self;
}
pub const OPM_GET_CONNECTED_HDCP_DEVICE_INFORMATION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0db59d74_a992_492e_a0bd_c23fda564e00);
pub const OPM_GET_CONNECTOR_TYPE: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x81d0bfd5_6afe_48c2_99c0_95a08f97c5da);
pub const OPM_GET_CURRENT_HDCP_SRM_VERSION: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x99c5ceff_5f1d_4879_81c1_c52443c9482b);
pub const OPM_GET_DVI_CHARACTERISTICS: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa470b3bb_5dd7_4172_839c_3d3776e0ebf5);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct OPM_GET_INFO_PARAMETERS {
pub omac: OPM_OMAC,
pub rnRandomNumber: OPM_RANDOM_NUMBER,
pub guidInformation: ::windows::core::GUID,
pub ulSequenceNumber: u32,
pub cbParametersSize: u32,
pub abParameters: [u8; 4056],
}
impl OPM_GET_INFO_PARAMETERS {}
impl ::core::default::Default for OPM_GET_INFO_PARAMETERS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for OPM_GET_INFO_PARAMETERS {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for OPM_GET_INFO_PARAMETERS {}
unsafe impl ::windows::core::Abi for OPM_GET_INFO_PARAMETERS {
type Abi = Self;
}
pub const OPM_GET_OUTPUT_HARDWARE_PROTECTION_SUPPORT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3b129589_2af8_4ef0_96a2_704a845a218e);
pub const OPM_GET_OUTPUT_ID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x72cb6df3_244f_40ce_b09e_20506af6302f);
pub const OPM_GET_SUPPORTED_PROTECTION_TYPES: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x38f2a801_9a6c_48bb_9107_b6696e6f1797);
pub const OPM_GET_VIRTUAL_PROTECTION_LEVEL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb2075857_3eda_4d5d_88db_748f8c1a0549);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct OPM_HDCP_FLAGS(pub u32);
pub const OPM_HDCP_FLAG_NONE: OPM_HDCP_FLAGS = OPM_HDCP_FLAGS(0u32);
pub const OPM_HDCP_FLAG_REPEATER: OPM_HDCP_FLAGS = OPM_HDCP_FLAGS(1u32);
impl ::core::convert::From<u32> for OPM_HDCP_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for OPM_HDCP_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for OPM_HDCP_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for OPM_HDCP_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for OPM_HDCP_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for OPM_HDCP_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for OPM_HDCP_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct OPM_HDCP_KEY_SELECTION_VECTOR {
pub abKeySelectionVector: [u8; 5],
}
impl OPM_HDCP_KEY_SELECTION_VECTOR {}
impl ::core::default::Default for OPM_HDCP_KEY_SELECTION_VECTOR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for OPM_HDCP_KEY_SELECTION_VECTOR {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("OPM_HDCP_KEY_SELECTION_VECTOR").field("abKeySelectionVector", &self.abKeySelectionVector).finish()
}
}
impl ::core::cmp::PartialEq for OPM_HDCP_KEY_SELECTION_VECTOR {
fn eq(&self, other: &Self) -> bool {
self.abKeySelectionVector == other.abKeySelectionVector
}
}
impl ::core::cmp::Eq for OPM_HDCP_KEY_SELECTION_VECTOR {}
unsafe impl ::windows::core::Abi for OPM_HDCP_KEY_SELECTION_VECTOR {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct OPM_HDCP_PROTECTION_LEVEL(pub i32);
pub const OPM_HDCP_OFF: OPM_HDCP_PROTECTION_LEVEL = OPM_HDCP_PROTECTION_LEVEL(0i32);
pub const OPM_HDCP_ON: OPM_HDCP_PROTECTION_LEVEL = OPM_HDCP_PROTECTION_LEVEL(1i32);
pub const OPM_HDCP_FORCE_ULONG: OPM_HDCP_PROTECTION_LEVEL = OPM_HDCP_PROTECTION_LEVEL(2147483647i32);
impl ::core::convert::From<i32> for OPM_HDCP_PROTECTION_LEVEL {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for OPM_HDCP_PROTECTION_LEVEL {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct OPM_HDCP_STATUS(pub i32);
pub const OPM_HDCP_STATUS_ON: OPM_HDCP_STATUS = OPM_HDCP_STATUS(0i32);
pub const OPM_HDCP_STATUS_OFF: OPM_HDCP_STATUS = OPM_HDCP_STATUS(1i32);
impl ::core::convert::From<i32> for OPM_HDCP_STATUS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for OPM_HDCP_STATUS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct OPM_HDCP_TYPE(pub i32);
pub const OPM_HDCP_TYPE_0: OPM_HDCP_TYPE = OPM_HDCP_TYPE(0i32);
pub const OPM_HDCP_TYPE_1: OPM_HDCP_TYPE = OPM_HDCP_TYPE(1i32);
impl ::core::convert::From<i32> for OPM_HDCP_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for OPM_HDCP_TYPE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct OPM_IMAGE_ASPECT_RATIO_EN300294(pub i32);
pub const OPM_ASPECT_RATIO_EN300294_FULL_FORMAT_4_BY_3: OPM_IMAGE_ASPECT_RATIO_EN300294 = OPM_IMAGE_ASPECT_RATIO_EN300294(0i32);
pub const OPM_ASPECT_RATIO_EN300294_BOX_14_BY_9_CENTER: OPM_IMAGE_ASPECT_RATIO_EN300294 = OPM_IMAGE_ASPECT_RATIO_EN300294(1i32);
pub const OPM_ASPECT_RATIO_EN300294_BOX_14_BY_9_TOP: OPM_IMAGE_ASPECT_RATIO_EN300294 = OPM_IMAGE_ASPECT_RATIO_EN300294(2i32);
pub const OPM_ASPECT_RATIO_EN300294_BOX_16_BY_9_CENTER: OPM_IMAGE_ASPECT_RATIO_EN300294 = OPM_IMAGE_ASPECT_RATIO_EN300294(3i32);
pub const OPM_ASPECT_RATIO_EN300294_BOX_16_BY_9_TOP: OPM_IMAGE_ASPECT_RATIO_EN300294 = OPM_IMAGE_ASPECT_RATIO_EN300294(4i32);
pub const OPM_ASPECT_RATIO_EN300294_BOX_GT_16_BY_9_CENTER: OPM_IMAGE_ASPECT_RATIO_EN300294 = OPM_IMAGE_ASPECT_RATIO_EN300294(5i32);
pub const OPM_ASPECT_RATIO_EN300294_FULL_FORMAT_4_BY_3_PROTECTED_CENTER: OPM_IMAGE_ASPECT_RATIO_EN300294 = OPM_IMAGE_ASPECT_RATIO_EN300294(6i32);
pub const OPM_ASPECT_RATIO_EN300294_FULL_FORMAT_16_BY_9_ANAMORPHIC: OPM_IMAGE_ASPECT_RATIO_EN300294 = OPM_IMAGE_ASPECT_RATIO_EN300294(7i32);
pub const OPM_ASPECT_RATIO_FORCE_ULONG: OPM_IMAGE_ASPECT_RATIO_EN300294 = OPM_IMAGE_ASPECT_RATIO_EN300294(2147483647i32);
impl ::core::convert::From<i32> for OPM_IMAGE_ASPECT_RATIO_EN300294 {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for OPM_IMAGE_ASPECT_RATIO_EN300294 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct OPM_OMAC {
pub abOMAC: [u8; 16],
}
impl OPM_OMAC {}
impl ::core::default::Default for OPM_OMAC {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for OPM_OMAC {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("OPM_OMAC").field("abOMAC", &self.abOMAC).finish()
}
}
impl ::core::cmp::PartialEq for OPM_OMAC {
fn eq(&self, other: &Self) -> bool {
self.abOMAC == other.abOMAC
}
}
impl ::core::cmp::Eq for OPM_OMAC {}
unsafe impl ::windows::core::Abi for OPM_OMAC {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct OPM_OUTPUT_HARDWARE_PROTECTION(pub i32);
pub const OPM_OUTPUT_HARDWARE_PROTECTION_NOT_SUPPORTED: OPM_OUTPUT_HARDWARE_PROTECTION = OPM_OUTPUT_HARDWARE_PROTECTION(0i32);
pub const OPM_OUTPUT_HARDWARE_PROTECTION_SUPPORTED: OPM_OUTPUT_HARDWARE_PROTECTION = OPM_OUTPUT_HARDWARE_PROTECTION(1i32);
impl ::core::convert::From<i32> for OPM_OUTPUT_HARDWARE_PROTECTION {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for OPM_OUTPUT_HARDWARE_PROTECTION {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct OPM_OUTPUT_ID_DATA {
pub rnRandomNumber: OPM_RANDOM_NUMBER,
pub ulStatusFlags: u32,
pub OutputId: u64,
}
impl OPM_OUTPUT_ID_DATA {}
impl ::core::default::Default for OPM_OUTPUT_ID_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for OPM_OUTPUT_ID_DATA {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for OPM_OUTPUT_ID_DATA {}
unsafe impl ::windows::core::Abi for OPM_OUTPUT_ID_DATA {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct OPM_PROTECTION_STANDARD_TYPE(pub u32);
pub const OPM_PROTECTION_STANDARD_OTHER: OPM_PROTECTION_STANDARD_TYPE = OPM_PROTECTION_STANDARD_TYPE(2147483648u32);
pub const OPM_PROTECTION_STANDARD_NONE: OPM_PROTECTION_STANDARD_TYPE = OPM_PROTECTION_STANDARD_TYPE(0u32);
pub const OPM_PROTECTION_STANDARD_IEC61880_525I: OPM_PROTECTION_STANDARD_TYPE = OPM_PROTECTION_STANDARD_TYPE(1u32);
pub const OPM_PROTECTION_STANDARD_IEC61880_2_525I: OPM_PROTECTION_STANDARD_TYPE = OPM_PROTECTION_STANDARD_TYPE(2u32);
pub const OPM_PROTECTION_STANDARD_IEC62375_625P: OPM_PROTECTION_STANDARD_TYPE = OPM_PROTECTION_STANDARD_TYPE(4u32);
pub const OPM_PROTECTION_STANDARD_EIA608B_525: OPM_PROTECTION_STANDARD_TYPE = OPM_PROTECTION_STANDARD_TYPE(8u32);
pub const OPM_PROTECTION_STANDARD_EN300294_625I: OPM_PROTECTION_STANDARD_TYPE = OPM_PROTECTION_STANDARD_TYPE(16u32);
pub const OPM_PROTECTION_STANDARD_CEA805A_TYPEA_525P: OPM_PROTECTION_STANDARD_TYPE = OPM_PROTECTION_STANDARD_TYPE(32u32);
pub const OPM_PROTECTION_STANDARD_CEA805A_TYPEA_750P: OPM_PROTECTION_STANDARD_TYPE = OPM_PROTECTION_STANDARD_TYPE(64u32);
pub const OPM_PROTECTION_STANDARD_CEA805A_TYPEA_1125I: OPM_PROTECTION_STANDARD_TYPE = OPM_PROTECTION_STANDARD_TYPE(128u32);
pub const OPM_PROTECTION_STANDARD_CEA805A_TYPEB_525P: OPM_PROTECTION_STANDARD_TYPE = OPM_PROTECTION_STANDARD_TYPE(256u32);
pub const OPM_PROTECTION_STANDARD_CEA805A_TYPEB_750P: OPM_PROTECTION_STANDARD_TYPE = OPM_PROTECTION_STANDARD_TYPE(512u32);
pub const OPM_PROTECTION_STANDARD_CEA805A_TYPEB_1125I: OPM_PROTECTION_STANDARD_TYPE = OPM_PROTECTION_STANDARD_TYPE(1024u32);
pub const OPM_PROTECTION_STANDARD_ARIBTRB15_525I: OPM_PROTECTION_STANDARD_TYPE = OPM_PROTECTION_STANDARD_TYPE(2048u32);
pub const OPM_PROTECTION_STANDARD_ARIBTRB15_525P: OPM_PROTECTION_STANDARD_TYPE = OPM_PROTECTION_STANDARD_TYPE(4096u32);
pub const OPM_PROTECTION_STANDARD_ARIBTRB15_750P: OPM_PROTECTION_STANDARD_TYPE = OPM_PROTECTION_STANDARD_TYPE(8192u32);
pub const OPM_PROTECTION_STANDARD_ARIBTRB15_1125I: OPM_PROTECTION_STANDARD_TYPE = OPM_PROTECTION_STANDARD_TYPE(16384u32);
impl ::core::convert::From<u32> for OPM_PROTECTION_STANDARD_TYPE {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for OPM_PROTECTION_STANDARD_TYPE {
type Abi = Self;
}
impl ::core::ops::BitOr for OPM_PROTECTION_STANDARD_TYPE {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for OPM_PROTECTION_STANDARD_TYPE {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for OPM_PROTECTION_STANDARD_TYPE {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for OPM_PROTECTION_STANDARD_TYPE {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for OPM_PROTECTION_STANDARD_TYPE {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct OPM_PROTECTION_TYPE(pub i32);
pub const OPM_PROTECTION_TYPE_OTHER: OPM_PROTECTION_TYPE = OPM_PROTECTION_TYPE(-2147483648i32);
pub const OPM_PROTECTION_TYPE_NONE: OPM_PROTECTION_TYPE = OPM_PROTECTION_TYPE(0i32);
pub const OPM_PROTECTION_TYPE_COPP_COMPATIBLE_HDCP: OPM_PROTECTION_TYPE = OPM_PROTECTION_TYPE(1i32);
pub const OPM_PROTECTION_TYPE_ACP: OPM_PROTECTION_TYPE = OPM_PROTECTION_TYPE(2i32);
pub const OPM_PROTECTION_TYPE_CGMSA: OPM_PROTECTION_TYPE = OPM_PROTECTION_TYPE(4i32);
pub const OPM_PROTECTION_TYPE_HDCP: OPM_PROTECTION_TYPE = OPM_PROTECTION_TYPE(8i32);
pub const OPM_PROTECTION_TYPE_DPCP: OPM_PROTECTION_TYPE = OPM_PROTECTION_TYPE(16i32);
pub const OPM_PROTECTION_TYPE_TYPE_ENFORCEMENT_HDCP: OPM_PROTECTION_TYPE = OPM_PROTECTION_TYPE(32i32);
impl ::core::convert::From<i32> for OPM_PROTECTION_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for OPM_PROTECTION_TYPE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct OPM_RANDOM_NUMBER {
pub abRandomNumber: [u8; 16],
}
impl OPM_RANDOM_NUMBER {}
impl ::core::default::Default for OPM_RANDOM_NUMBER {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for OPM_RANDOM_NUMBER {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("OPM_RANDOM_NUMBER").field("abRandomNumber", &self.abRandomNumber).finish()
}
}
impl ::core::cmp::PartialEq for OPM_RANDOM_NUMBER {
fn eq(&self, other: &Self) -> bool {
self.abRandomNumber == other.abRandomNumber
}
}
impl ::core::cmp::Eq for OPM_RANDOM_NUMBER {}
unsafe impl ::windows::core::Abi for OPM_RANDOM_NUMBER {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct OPM_REQUESTED_INFORMATION {
pub omac: OPM_OMAC,
pub cbRequestedInformationSize: u32,
pub abRequestedInformation: [u8; 4076],
}
impl OPM_REQUESTED_INFORMATION {}
impl ::core::default::Default for OPM_REQUESTED_INFORMATION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for OPM_REQUESTED_INFORMATION {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for OPM_REQUESTED_INFORMATION {}
unsafe impl ::windows::core::Abi for OPM_REQUESTED_INFORMATION {
type Abi = Self;
}
pub const OPM_SET_ACP_AND_CGMSA_SIGNALING: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x09a631a5_d684_4c60_8e4d_d3bb0f0be3ee);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct OPM_SET_ACP_AND_CGMSA_SIGNALING_PARAMETERS {
pub ulNewTVProtectionStandard: u32,
pub ulAspectRatioChangeMask1: u32,
pub ulAspectRatioData1: u32,
pub ulAspectRatioChangeMask2: u32,
pub ulAspectRatioData2: u32,
pub ulAspectRatioChangeMask3: u32,
pub ulAspectRatioData3: u32,
pub ulReserved: [u32; 4],
pub ulReserved2: [u32; 4],
pub ulReserved3: u32,
}
impl OPM_SET_ACP_AND_CGMSA_SIGNALING_PARAMETERS {}
impl ::core::default::Default for OPM_SET_ACP_AND_CGMSA_SIGNALING_PARAMETERS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for OPM_SET_ACP_AND_CGMSA_SIGNALING_PARAMETERS {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for OPM_SET_ACP_AND_CGMSA_SIGNALING_PARAMETERS {}
unsafe impl ::windows::core::Abi for OPM_SET_ACP_AND_CGMSA_SIGNALING_PARAMETERS {
type Abi = Self;
}
pub const OPM_SET_HDCP_SRM: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8b5ef5d1_c30d_44ff_84a5_ea71dce78f13);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct OPM_SET_HDCP_SRM_PARAMETERS {
pub ulSRMVersion: u32,
}
impl OPM_SET_HDCP_SRM_PARAMETERS {}
impl ::core::default::Default for OPM_SET_HDCP_SRM_PARAMETERS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for OPM_SET_HDCP_SRM_PARAMETERS {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for OPM_SET_HDCP_SRM_PARAMETERS {}
unsafe impl ::windows::core::Abi for OPM_SET_HDCP_SRM_PARAMETERS {
type Abi = Self;
}
pub const OPM_SET_PROTECTION_LEVEL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9bb9327c_4eb5_4727_9f00_b42b0919c0da);
pub const OPM_SET_PROTECTION_LEVEL_ACCORDING_TO_CSS_DVD: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x39ce333e_4cc0_44ae_bfcc_da50b5f82e72);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct OPM_SET_PROTECTION_LEVEL_PARAMETERS {
pub ulProtectionType: u32,
pub ulProtectionLevel: u32,
pub Reserved: u32,
pub Reserved2: u32,
}
impl OPM_SET_PROTECTION_LEVEL_PARAMETERS {}
impl ::core::default::Default for OPM_SET_PROTECTION_LEVEL_PARAMETERS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for OPM_SET_PROTECTION_LEVEL_PARAMETERS {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for OPM_SET_PROTECTION_LEVEL_PARAMETERS {}
unsafe impl ::windows::core::Abi for OPM_SET_PROTECTION_LEVEL_PARAMETERS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct OPM_STANDARD_INFORMATION {
pub rnRandomNumber: OPM_RANDOM_NUMBER,
pub ulStatusFlags: u32,
pub ulInformation: u32,
pub ulReserved: u32,
pub ulReserved2: u32,
}
impl OPM_STANDARD_INFORMATION {}
impl ::core::default::Default for OPM_STANDARD_INFORMATION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for OPM_STANDARD_INFORMATION {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for OPM_STANDARD_INFORMATION {}
unsafe impl ::windows::core::Abi for OPM_STANDARD_INFORMATION {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct OPM_STATUS(pub i32);
pub const OPM_STATUS_NORMAL: OPM_STATUS = OPM_STATUS(0i32);
pub const OPM_STATUS_LINK_LOST: OPM_STATUS = OPM_STATUS(1i32);
pub const OPM_STATUS_RENEGOTIATION_REQUIRED: OPM_STATUS = OPM_STATUS(2i32);
pub const OPM_STATUS_TAMPERING_DETECTED: OPM_STATUS = OPM_STATUS(4i32);
pub const OPM_STATUS_REVOKED_HDCP_DEVICE_ATTACHED: OPM_STATUS = OPM_STATUS(8i32);
impl ::core::convert::From<i32> for OPM_STATUS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for OPM_STATUS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct OPM_TYPE(pub i32);
pub const OPM_OMAC_SIZE: OPM_TYPE = OPM_TYPE(16i32);
pub const OPM_128_BIT_RANDOM_NUMBER_SIZE: OPM_TYPE = OPM_TYPE(16i32);
pub const OPM_ENCRYPTED_INITIALIZATION_PARAMETERS_SIZE: OPM_TYPE = OPM_TYPE(256i32);
pub const OPM_CONFIGURE_SETTING_DATA_SIZE: OPM_TYPE = OPM_TYPE(4056i32);
pub const OPM_GET_INFORMATION_PARAMETERS_SIZE: OPM_TYPE = OPM_TYPE(4056i32);
pub const OPM_REQUESTED_INFORMATION_SIZE: OPM_TYPE = OPM_TYPE(4076i32);
pub const OPM_HDCP_KEY_SELECTION_VECTOR_SIZE: OPM_TYPE = OPM_TYPE(5i32);
pub const OPM_PROTECTION_TYPE_SIZE: OPM_TYPE = OPM_TYPE(4i32);
pub const OPM_BUS_TYPE_MASK: OPM_TYPE = OPM_TYPE(65535i32);
pub const OPM_BUS_IMPLEMENTATION_MODIFIER_MASK: OPM_TYPE = OPM_TYPE(32767i32);
impl ::core::convert::From<i32> for OPM_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for OPM_TYPE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct OPM_TYPE_ENFORCEMENT_HDCP_PROTECTION_LEVEL(pub i32);
pub const OPM_TYPE_ENFORCEMENT_HDCP_OFF: OPM_TYPE_ENFORCEMENT_HDCP_PROTECTION_LEVEL = OPM_TYPE_ENFORCEMENT_HDCP_PROTECTION_LEVEL(0i32);
pub const OPM_TYPE_ENFORCEMENT_HDCP_ON_WITH_NO_TYPE_RESTRICTION: OPM_TYPE_ENFORCEMENT_HDCP_PROTECTION_LEVEL = OPM_TYPE_ENFORCEMENT_HDCP_PROTECTION_LEVEL(1i32);
pub const OPM_TYPE_ENFORCEMENT_HDCP_ON_WITH_TYPE1_RESTRICTION: OPM_TYPE_ENFORCEMENT_HDCP_PROTECTION_LEVEL = OPM_TYPE_ENFORCEMENT_HDCP_PROTECTION_LEVEL(2i32);
pub const OPM_TYPE_ENFORCEMENT_HDCP_FORCE_ULONG: OPM_TYPE_ENFORCEMENT_HDCP_PROTECTION_LEVEL = OPM_TYPE_ENFORCEMENT_HDCP_PROTECTION_LEVEL(2147483647i32);
impl ::core::convert::From<i32> for OPM_TYPE_ENFORCEMENT_HDCP_PROTECTION_LEVEL {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for OPM_TYPE_ENFORCEMENT_HDCP_PROTECTION_LEVEL {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct OPM_VIDEO_OUTPUT_SEMANTICS(pub i32);
pub const OPM_VOS_COPP_SEMANTICS: OPM_VIDEO_OUTPUT_SEMANTICS = OPM_VIDEO_OUTPUT_SEMANTICS(0i32);
pub const OPM_VOS_OPM_SEMANTICS: OPM_VIDEO_OUTPUT_SEMANTICS = OPM_VIDEO_OUTPUT_SEMANTICS(1i32);
pub const OPM_VOS_OPM_INDIRECT_DISPLAY: OPM_VIDEO_OUTPUT_SEMANTICS = OPM_VIDEO_OUTPUT_SEMANTICS(2i32);
impl ::core::convert::From<i32> for OPM_VIDEO_OUTPUT_SEMANTICS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for OPM_VIDEO_OUTPUT_SEMANTICS {
type Abi = Self;
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
pub type PDXVAHDSW_CreateDevice = unsafe extern "system" fn(pd3ddevice: ::windows::core::RawPtr, phdevice: *mut super::super::Foundation::HANDLE) -> ::windows::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub type PDXVAHDSW_CreateVideoProcessor = unsafe extern "system" fn(hdevice: super::super::Foundation::HANDLE, pvpguid: *const ::windows::core::GUID, phvideoprocessor: *mut super::super::Foundation::HANDLE) -> ::windows::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub type PDXVAHDSW_DestroyDevice = unsafe extern "system" fn(hdevice: super::super::Foundation::HANDLE) -> ::windows::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub type PDXVAHDSW_DestroyVideoProcessor = unsafe extern "system" fn(hvideoprocessor: super::super::Foundation::HANDLE) -> ::windows::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub type PDXVAHDSW_GetVideoProcessBltStatePrivate = unsafe extern "system" fn(hvideoprocessor: super::super::Foundation::HANDLE, pdata: *mut DXVAHD_BLT_STATE_PRIVATE_DATA) -> ::windows::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub type PDXVAHDSW_GetVideoProcessStreamStatePrivate = unsafe extern "system" fn(hvideoprocessor: super::super::Foundation::HANDLE, streamnumber: u32, pdata: *mut DXVAHD_STREAM_STATE_PRIVATE_DATA) -> ::windows::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub type PDXVAHDSW_GetVideoProcessorCaps = unsafe extern "system" fn(hdevice: super::super::Foundation::HANDLE, pcontentdesc: *const DXVAHD_CONTENT_DESC, usage: DXVAHD_DEVICE_USAGE, count: u32, pcaps: *mut DXVAHD_VPCAPS) -> ::windows::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub type PDXVAHDSW_GetVideoProcessorCustomRates = unsafe extern "system" fn(hdevice: super::super::Foundation::HANDLE, pvpguid: *const ::windows::core::GUID, count: u32, prates: *mut DXVAHD_CUSTOM_RATE_DATA) -> ::windows::core::HRESULT;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
pub type PDXVAHDSW_GetVideoProcessorDeviceCaps = unsafe extern "system" fn(hdevice: super::super::Foundation::HANDLE, pcontentdesc: *const DXVAHD_CONTENT_DESC, usage: DXVAHD_DEVICE_USAGE, pcaps: *mut DXVAHD_VPDEVCAPS) -> ::windows::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub type PDXVAHDSW_GetVideoProcessorFilterRange = unsafe extern "system" fn(hdevice: super::super::Foundation::HANDLE, filter: DXVAHD_FILTER, prange: *mut DXVAHD_FILTER_RANGE_DATA) -> ::windows::core::HRESULT;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
pub type PDXVAHDSW_GetVideoProcessorInputFormats = unsafe extern "system" fn(hdevice: super::super::Foundation::HANDLE, pcontentdesc: *const DXVAHD_CONTENT_DESC, usage: DXVAHD_DEVICE_USAGE, count: u32, pformats: *mut super::super::Graphics::Direct3D9::D3DFORMAT) -> ::windows::core::HRESULT;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
pub type PDXVAHDSW_GetVideoProcessorOutputFormats = unsafe extern "system" fn(hdevice: super::super::Foundation::HANDLE, pcontentdesc: *const DXVAHD_CONTENT_DESC, usage: DXVAHD_DEVICE_USAGE, count: u32, pformats: *mut super::super::Graphics::Direct3D9::D3DFORMAT) -> ::windows::core::HRESULT;
pub type PDXVAHDSW_Plugin = unsafe extern "system" fn(size: u32, pcallbacks: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
pub type PDXVAHDSW_ProposeVideoPrivateFormat = unsafe extern "system" fn(hdevice: super::super::Foundation::HANDLE, pformat: *mut super::super::Graphics::Direct3D9::D3DFORMAT) -> ::windows::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub type PDXVAHDSW_SetVideoProcessBltState = unsafe extern "system" fn(hvideoprocessor: super::super::Foundation::HANDLE, state: DXVAHD_BLT_STATE, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub type PDXVAHDSW_SetVideoProcessStreamState = unsafe extern "system" fn(hvideoprocessor: super::super::Foundation::HANDLE, streamnumber: u32, state: DXVAHD_STREAM_STATE, datasize: u32, pdata: *const ::core::ffi::c_void) -> ::windows::core::HRESULT;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Direct3D9"))]
pub type PDXVAHDSW_VideoProcessBltHD = unsafe extern "system" fn(hvideoprocessor: super::super::Foundation::HANDLE, poutputsurface: ::windows::core::RawPtr, outputframe: u32, streamcount: u32, pstreams: *const ::core::mem::ManuallyDrop<DXVAHD_STREAM_DATA>) -> ::windows::core::HRESULT;
#[cfg(feature = "Win32_Graphics_Direct3D9")]
pub type PDXVAHD_CreateDevice = unsafe extern "system" fn(pd3ddevice: ::windows::core::RawPtr, pcontentdesc: *const DXVAHD_CONTENT_DESC, usage: DXVAHD_DEVICE_USAGE, pplugin: ::windows::core::RawPtr, ppdevice: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct PLAYTO_SOURCE_CREATEFLAGS(pub i32);
pub const PLAYTO_SOURCE_NONE: PLAYTO_SOURCE_CREATEFLAGS = PLAYTO_SOURCE_CREATEFLAGS(0i32);
pub const PLAYTO_SOURCE_IMAGE: PLAYTO_SOURCE_CREATEFLAGS = PLAYTO_SOURCE_CREATEFLAGS(1i32);
pub const PLAYTO_SOURCE_AUDIO: PLAYTO_SOURCE_CREATEFLAGS = PLAYTO_SOURCE_CREATEFLAGS(2i32);
pub const PLAYTO_SOURCE_VIDEO: PLAYTO_SOURCE_CREATEFLAGS = PLAYTO_SOURCE_CREATEFLAGS(4i32);
pub const PLAYTO_SOURCE_PROTECTED: PLAYTO_SOURCE_CREATEFLAGS = PLAYTO_SOURCE_CREATEFLAGS(8i32);
impl ::core::convert::From<i32> for PLAYTO_SOURCE_CREATEFLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for PLAYTO_SOURCE_CREATEFLAGS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct PM_CONNECTOR_TYPE(pub i32);
pub const OPM_CONNECTOR_TYPE_OTHER: PM_CONNECTOR_TYPE = PM_CONNECTOR_TYPE(-1i32);
pub const OPM_CONNECTOR_TYPE_VGA: PM_CONNECTOR_TYPE = PM_CONNECTOR_TYPE(0i32);
pub const OPM_CONNECTOR_TYPE_SVIDEO: PM_CONNECTOR_TYPE = PM_CONNECTOR_TYPE(1i32);
pub const OPM_CONNECTOR_TYPE_COMPOSITE_VIDEO: PM_CONNECTOR_TYPE = PM_CONNECTOR_TYPE(2i32);
pub const OPM_CONNECTOR_TYPE_COMPONENT_VIDEO: PM_CONNECTOR_TYPE = PM_CONNECTOR_TYPE(3i32);
pub const OPM_CONNECTOR_TYPE_DVI: PM_CONNECTOR_TYPE = PM_CONNECTOR_TYPE(4i32);
pub const OPM_CONNECTOR_TYPE_HDMI: PM_CONNECTOR_TYPE = PM_CONNECTOR_TYPE(5i32);
pub const OPM_CONNECTOR_TYPE_LVDS: PM_CONNECTOR_TYPE = PM_CONNECTOR_TYPE(6i32);
pub const OPM_CONNECTOR_TYPE_D_JPN: PM_CONNECTOR_TYPE = PM_CONNECTOR_TYPE(8i32);
pub const OPM_CONNECTOR_TYPE_SDI: PM_CONNECTOR_TYPE = PM_CONNECTOR_TYPE(9i32);
pub const OPM_CONNECTOR_TYPE_DISPLAYPORT_EXTERNAL: PM_CONNECTOR_TYPE = PM_CONNECTOR_TYPE(10i32);
pub const OPM_CONNECTOR_TYPE_DISPLAYPORT_EMBEDDED: PM_CONNECTOR_TYPE = PM_CONNECTOR_TYPE(11i32);
pub const OPM_CONNECTOR_TYPE_UDI_EXTERNAL: PM_CONNECTOR_TYPE = PM_CONNECTOR_TYPE(12i32);
pub const OPM_CONNECTOR_TYPE_UDI_EMBEDDED: PM_CONNECTOR_TYPE = PM_CONNECTOR_TYPE(13i32);
pub const OPM_CONNECTOR_TYPE_RESERVED: PM_CONNECTOR_TYPE = PM_CONNECTOR_TYPE(14i32);
pub const OPM_CONNECTOR_TYPE_MIRACAST: PM_CONNECTOR_TYPE = PM_CONNECTOR_TYPE(15i32);
pub const OPM_CONNECTOR_TYPE_TRANSPORT_AGNOSTIC_DIGITAL_MODE_A: PM_CONNECTOR_TYPE = PM_CONNECTOR_TYPE(16i32);
pub const OPM_CONNECTOR_TYPE_TRANSPORT_AGNOSTIC_DIGITAL_MODE_B: PM_CONNECTOR_TYPE = PM_CONNECTOR_TYPE(17i32);
pub const OPM_COPP_COMPATIBLE_CONNECTOR_TYPE_INTERNAL: PM_CONNECTOR_TYPE = PM_CONNECTOR_TYPE(-2147483648i32);
impl ::core::convert::From<i32> for PM_CONNECTOR_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for PM_CONNECTOR_TYPE {
type Abi = Self;
}
pub const PRESENTATION_CURRENT_POSITION: u64 = 9223372036854775807u64;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct ROI_AREA {
pub rect: super::super::Foundation::RECT,
pub QPDelta: i32,
}
#[cfg(feature = "Win32_Foundation")]
impl ROI_AREA {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for ROI_AREA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for ROI_AREA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("ROI_AREA").field("rect", &self.rect).field("QPDelta", &self.QPDelta).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for ROI_AREA {
fn eq(&self, other: &Self) -> bool {
self.rect == other.rect && self.QPDelta == other.QPDelta
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for ROI_AREA {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for ROI_AREA {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SAMPLE_PROTECTION_VERSION(pub i32);
pub const SAMPLE_PROTECTION_VERSION_NO: SAMPLE_PROTECTION_VERSION = SAMPLE_PROTECTION_VERSION(0i32);
pub const SAMPLE_PROTECTION_VERSION_BASIC_LOKI: SAMPLE_PROTECTION_VERSION = SAMPLE_PROTECTION_VERSION(1i32);
pub const SAMPLE_PROTECTION_VERSION_SCATTER: SAMPLE_PROTECTION_VERSION = SAMPLE_PROTECTION_VERSION(2i32);
pub const SAMPLE_PROTECTION_VERSION_RC4: SAMPLE_PROTECTION_VERSION = SAMPLE_PROTECTION_VERSION(3i32);
pub const SAMPLE_PROTECTION_VERSION_AES128CTR: SAMPLE_PROTECTION_VERSION = SAMPLE_PROTECTION_VERSION(4i32);
impl ::core::convert::From<i32> for SAMPLE_PROTECTION_VERSION {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SAMPLE_PROTECTION_VERSION {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SEEK_ORIGIN(pub i32);
pub const _msoBegin: SEEK_ORIGIN = SEEK_ORIGIN(0i32);
pub const _msoCurrent: SEEK_ORIGIN = SEEK_ORIGIN(1i32);
impl ::core::convert::From<i32> for SEEK_ORIGIN {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SEEK_ORIGIN {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct SENSORPROFILEID {
pub Type: ::windows::core::GUID,
pub Index: u32,
pub Unused: u32,
}
impl SENSORPROFILEID {}
impl ::core::default::Default for SENSORPROFILEID {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for SENSORPROFILEID {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SENSORPROFILEID").field("Type", &self.Type).field("Index", &self.Index).field("Unused", &self.Unused).finish()
}
}
impl ::core::cmp::PartialEq for SENSORPROFILEID {
fn eq(&self, other: &Self) -> bool {
self.Type == other.Type && self.Index == other.Index && self.Unused == other.Unused
}
}
impl ::core::cmp::Eq for SENSORPROFILEID {}
unsafe impl ::windows::core::Abi for SENSORPROFILEID {
type Abi = Self;
}
pub const SHA_HASH_LEN: u32 = 20u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct STREAM_MEDIUM {
pub gidMedium: ::windows::core::GUID,
pub unMediumInstance: u32,
}
impl STREAM_MEDIUM {}
impl ::core::default::Default for STREAM_MEDIUM {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for STREAM_MEDIUM {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("STREAM_MEDIUM").field("gidMedium", &self.gidMedium).field("unMediumInstance", &self.unMediumInstance).finish()
}
}
impl ::core::cmp::PartialEq for STREAM_MEDIUM {
fn eq(&self, other: &Self) -> bool {
self.gidMedium == other.gidMedium && self.unMediumInstance == other.unMediumInstance
}
}
impl ::core::cmp::Eq for STREAM_MEDIUM {}
unsafe impl ::windows::core::Abi for STREAM_MEDIUM {
type Abi = Self;
}
pub const SYSFXUI_DONOTSHOW_BASSBOOST: u32 = 8u32;
pub const SYSFXUI_DONOTSHOW_BASSMANAGEMENT: u32 = 4u32;
pub const SYSFXUI_DONOTSHOW_CHANNELPHANTOMING: u32 = 128u32;
pub const SYSFXUI_DONOTSHOW_HEADPHONEVIRTUALIZATION: u32 = 16u32;
pub const SYSFXUI_DONOTSHOW_LOUDNESSEQUALIZATION: u32 = 1u32;
pub const SYSFXUI_DONOTSHOW_ROOMCORRECTION: u32 = 2u32;
pub const SYSFXUI_DONOTSHOW_SPEAKERFILLING: u32 = 64u32;
pub const SYSFXUI_DONOTSHOW_VIRTUALSURROUND: u32 = 32u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct TOC_DESCRIPTOR {
pub guidID: ::windows::core::GUID,
pub wStreamNumber: u16,
pub guidType: ::windows::core::GUID,
pub wLanguageIndex: u16,
}
impl TOC_DESCRIPTOR {}
impl ::core::default::Default for TOC_DESCRIPTOR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for TOC_DESCRIPTOR {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("TOC_DESCRIPTOR").field("guidID", &self.guidID).field("wStreamNumber", &self.wStreamNumber).field("guidType", &self.guidType).field("wLanguageIndex", &self.wLanguageIndex).finish()
}
}
impl ::core::cmp::PartialEq for TOC_DESCRIPTOR {
fn eq(&self, other: &Self) -> bool {
self.guidID == other.guidID && self.wStreamNumber == other.wStreamNumber && self.guidType == other.guidType && self.wLanguageIndex == other.wLanguageIndex
}
}
impl ::core::cmp::Eq for TOC_DESCRIPTOR {}
unsafe impl ::windows::core::Abi for TOC_DESCRIPTOR {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct TOC_ENTRY_DESCRIPTOR {
pub qwStartTime: u64,
pub qwEndTime: u64,
pub qwStartPacketOffset: u64,
pub qwEndPacketOffset: u64,
pub qwRepresentativeFrameTime: u64,
}
impl TOC_ENTRY_DESCRIPTOR {}
impl ::core::default::Default for TOC_ENTRY_DESCRIPTOR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for TOC_ENTRY_DESCRIPTOR {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("TOC_ENTRY_DESCRIPTOR")
.field("qwStartTime", &self.qwStartTime)
.field("qwEndTime", &self.qwEndTime)
.field("qwStartPacketOffset", &self.qwStartPacketOffset)
.field("qwEndPacketOffset", &self.qwEndPacketOffset)
.field("qwRepresentativeFrameTime", &self.qwRepresentativeFrameTime)
.finish()
}
}
impl ::core::cmp::PartialEq for TOC_ENTRY_DESCRIPTOR {
fn eq(&self, other: &Self) -> bool {
self.qwStartTime == other.qwStartTime && self.qwEndTime == other.qwEndTime && self.qwStartPacketOffset == other.qwStartPacketOffset && self.qwEndPacketOffset == other.qwEndPacketOffset && self.qwRepresentativeFrameTime == other.qwRepresentativeFrameTime
}
}
impl ::core::cmp::Eq for TOC_ENTRY_DESCRIPTOR {}
unsafe impl ::windows::core::Abi for TOC_ENTRY_DESCRIPTOR {
type Abi = Self;
}
pub const TOC_ENTRY_MAX_TITLE_SIZE: u32 = 65535u32;
pub const TOC_MAX_DESCRIPTION_SIZE: u32 = 65535u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct TOC_POS_TYPE(pub i32);
pub const TOC_POS_INHEADER: TOC_POS_TYPE = TOC_POS_TYPE(0i32);
pub const TOC_POS_TOPLEVELOBJECT: TOC_POS_TYPE = TOC_POS_TYPE(1i32);
impl ::core::convert::From<i32> for TOC_POS_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for TOC_POS_TYPE {
type Abi = Self;
}
pub const VIDEO_ZOOM_RECT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7aaa1638_1b7f_4c93_bd89_5b9c9fb6fcf0);
pub const VorbisDecoderMFT: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1a198ef2_60e5_4ea8_90d8_da1f2832c288);
pub const WMAAECMA_E_NO_ACTIVE_RENDER_STREAM: u32 = 2278293514u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct WMT_PROP_DATATYPE(pub i32);
pub const WMT_PROP_TYPE_DWORD: WMT_PROP_DATATYPE = WMT_PROP_DATATYPE(0i32);
pub const WMT_PROP_TYPE_STRING: WMT_PROP_DATATYPE = WMT_PROP_DATATYPE(1i32);
pub const WMT_PROP_TYPE_BINARY: WMT_PROP_DATATYPE = WMT_PROP_DATATYPE(2i32);
pub const WMT_PROP_TYPE_BOOL: WMT_PROP_DATATYPE = WMT_PROP_DATATYPE(3i32);
pub const WMT_PROP_TYPE_QWORD: WMT_PROP_DATATYPE = WMT_PROP_DATATYPE(4i32);
pub const WMT_PROP_TYPE_WORD: WMT_PROP_DATATYPE = WMT_PROP_DATATYPE(5i32);
pub const WMT_PROP_TYPE_GUID: WMT_PROP_DATATYPE = WMT_PROP_DATATYPE(6i32);
impl ::core::convert::From<i32> for WMT_PROP_DATATYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for WMT_PROP_DATATYPE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct WMV_DYNAMIC_FLAGS(pub i32);
pub const WMV_DYNAMIC_BITRATE: WMV_DYNAMIC_FLAGS = WMV_DYNAMIC_FLAGS(1i32);
pub const WMV_DYNAMIC_RESOLUTION: WMV_DYNAMIC_FLAGS = WMV_DYNAMIC_FLAGS(2i32);
pub const WMV_DYNAMIC_COMPLEXITY: WMV_DYNAMIC_FLAGS = WMV_DYNAMIC_FLAGS(4i32);
impl ::core::convert::From<i32> for WMV_DYNAMIC_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for WMV_DYNAMIC_FLAGS {
type Abi = Self;
}
pub const WM_CODEC_ONEPASS_CBR: u32 = 1u32;
pub const WM_CODEC_ONEPASS_VBR: u32 = 2u32;
pub const WM_CODEC_TWOPASS_CBR: u32 = 4u32;
pub const WM_CODEC_TWOPASS_VBR_PEAKCONSTRAINED: u32 = 16u32;
pub const WM_CODEC_TWOPASS_VBR_UNCONSTRAINED: u32 = 8u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct _MFP_CREDENTIAL_FLAGS(pub i32);
pub const MFP_CREDENTIAL_PROMPT: _MFP_CREDENTIAL_FLAGS = _MFP_CREDENTIAL_FLAGS(1i32);
pub const MFP_CREDENTIAL_SAVE: _MFP_CREDENTIAL_FLAGS = _MFP_CREDENTIAL_FLAGS(2i32);
pub const MFP_CREDENTIAL_DO_NOT_CACHE: _MFP_CREDENTIAL_FLAGS = _MFP_CREDENTIAL_FLAGS(4i32);
pub const MFP_CREDENTIAL_CLEAR_TEXT: _MFP_CREDENTIAL_FLAGS = _MFP_CREDENTIAL_FLAGS(8i32);
pub const MFP_CREDENTIAL_PROXY: _MFP_CREDENTIAL_FLAGS = _MFP_CREDENTIAL_FLAGS(16i32);
pub const MFP_CREDENTIAL_LOGGED_ON_USER: _MFP_CREDENTIAL_FLAGS = _MFP_CREDENTIAL_FLAGS(32i32);
impl ::core::convert::From<i32> for _MFP_CREDENTIAL_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for _MFP_CREDENTIAL_FLAGS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct _MFP_MEDIAITEM_CHARACTERISTICS(pub i32);
pub const MFP_MEDIAITEM_IS_LIVE: _MFP_MEDIAITEM_CHARACTERISTICS = _MFP_MEDIAITEM_CHARACTERISTICS(1i32);
pub const MFP_MEDIAITEM_CAN_SEEK: _MFP_MEDIAITEM_CHARACTERISTICS = _MFP_MEDIAITEM_CHARACTERISTICS(2i32);
pub const MFP_MEDIAITEM_CAN_PAUSE: _MFP_MEDIAITEM_CHARACTERISTICS = _MFP_MEDIAITEM_CHARACTERISTICS(4i32);
pub const MFP_MEDIAITEM_HAS_SLOW_SEEK: _MFP_MEDIAITEM_CHARACTERISTICS = _MFP_MEDIAITEM_CHARACTERISTICS(8i32);
impl ::core::convert::From<i32> for _MFP_MEDIAITEM_CHARACTERISTICS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for _MFP_MEDIAITEM_CHARACTERISTICS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct _MFT_ENUM_FLAG(pub i32);
pub const MFT_ENUM_FLAG_SYNCMFT: _MFT_ENUM_FLAG = _MFT_ENUM_FLAG(1i32);
pub const MFT_ENUM_FLAG_ASYNCMFT: _MFT_ENUM_FLAG = _MFT_ENUM_FLAG(2i32);
pub const MFT_ENUM_FLAG_HARDWARE: _MFT_ENUM_FLAG = _MFT_ENUM_FLAG(4i32);
pub const MFT_ENUM_FLAG_FIELDOFUSE: _MFT_ENUM_FLAG = _MFT_ENUM_FLAG(8i32);
pub const MFT_ENUM_FLAG_LOCALMFT: _MFT_ENUM_FLAG = _MFT_ENUM_FLAG(16i32);
pub const MFT_ENUM_FLAG_TRANSCODE_ONLY: _MFT_ENUM_FLAG = _MFT_ENUM_FLAG(32i32);
pub const MFT_ENUM_FLAG_SORTANDFILTER: _MFT_ENUM_FLAG = _MFT_ENUM_FLAG(64i32);
pub const MFT_ENUM_FLAG_SORTANDFILTER_APPROVED_ONLY: _MFT_ENUM_FLAG = _MFT_ENUM_FLAG(192i32);
pub const MFT_ENUM_FLAG_SORTANDFILTER_WEB_ONLY: _MFT_ENUM_FLAG = _MFT_ENUM_FLAG(320i32);
pub const MFT_ENUM_FLAG_SORTANDFILTER_WEB_ONLY_EDGEMODE: _MFT_ENUM_FLAG = _MFT_ENUM_FLAG(576i32);
pub const MFT_ENUM_FLAG_UNTRUSTED_STOREMFT: _MFT_ENUM_FLAG = _MFT_ENUM_FLAG(1024i32);
pub const MFT_ENUM_FLAG_ALL: _MFT_ENUM_FLAG = _MFT_ENUM_FLAG(63i32);
impl ::core::convert::From<i32> for _MFT_ENUM_FLAG {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for _MFT_ENUM_FLAG {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct _MFT_INPUT_DATA_BUFFER_FLAGS(pub i32);
pub const MFT_INPUT_DATA_BUFFER_PLACEHOLDER: _MFT_INPUT_DATA_BUFFER_FLAGS = _MFT_INPUT_DATA_BUFFER_FLAGS(-1i32);
impl ::core::convert::From<i32> for _MFT_INPUT_DATA_BUFFER_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for _MFT_INPUT_DATA_BUFFER_FLAGS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct _MFT_INPUT_STATUS_FLAGS(pub i32);
pub const MFT_INPUT_STATUS_ACCEPT_DATA: _MFT_INPUT_STATUS_FLAGS = _MFT_INPUT_STATUS_FLAGS(1i32);
impl ::core::convert::From<i32> for _MFT_INPUT_STATUS_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for _MFT_INPUT_STATUS_FLAGS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct _MFT_INPUT_STREAM_INFO_FLAGS(pub i32);
pub const MFT_INPUT_STREAM_WHOLE_SAMPLES: _MFT_INPUT_STREAM_INFO_FLAGS = _MFT_INPUT_STREAM_INFO_FLAGS(1i32);
pub const MFT_INPUT_STREAM_SINGLE_SAMPLE_PER_BUFFER: _MFT_INPUT_STREAM_INFO_FLAGS = _MFT_INPUT_STREAM_INFO_FLAGS(2i32);
pub const MFT_INPUT_STREAM_FIXED_SAMPLE_SIZE: _MFT_INPUT_STREAM_INFO_FLAGS = _MFT_INPUT_STREAM_INFO_FLAGS(4i32);
pub const MFT_INPUT_STREAM_HOLDS_BUFFERS: _MFT_INPUT_STREAM_INFO_FLAGS = _MFT_INPUT_STREAM_INFO_FLAGS(8i32);
pub const MFT_INPUT_STREAM_DOES_NOT_ADDREF: _MFT_INPUT_STREAM_INFO_FLAGS = _MFT_INPUT_STREAM_INFO_FLAGS(256i32);
pub const MFT_INPUT_STREAM_REMOVABLE: _MFT_INPUT_STREAM_INFO_FLAGS = _MFT_INPUT_STREAM_INFO_FLAGS(512i32);
pub const MFT_INPUT_STREAM_OPTIONAL: _MFT_INPUT_STREAM_INFO_FLAGS = _MFT_INPUT_STREAM_INFO_FLAGS(1024i32);
pub const MFT_INPUT_STREAM_PROCESSES_IN_PLACE: _MFT_INPUT_STREAM_INFO_FLAGS = _MFT_INPUT_STREAM_INFO_FLAGS(2048i32);
impl ::core::convert::From<i32> for _MFT_INPUT_STREAM_INFO_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for _MFT_INPUT_STREAM_INFO_FLAGS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct _MFT_OUTPUT_DATA_BUFFER_FLAGS(pub i32);
pub const MFT_OUTPUT_DATA_BUFFER_INCOMPLETE: _MFT_OUTPUT_DATA_BUFFER_FLAGS = _MFT_OUTPUT_DATA_BUFFER_FLAGS(16777216i32);
pub const MFT_OUTPUT_DATA_BUFFER_FORMAT_CHANGE: _MFT_OUTPUT_DATA_BUFFER_FLAGS = _MFT_OUTPUT_DATA_BUFFER_FLAGS(256i32);
pub const MFT_OUTPUT_DATA_BUFFER_STREAM_END: _MFT_OUTPUT_DATA_BUFFER_FLAGS = _MFT_OUTPUT_DATA_BUFFER_FLAGS(512i32);
pub const MFT_OUTPUT_DATA_BUFFER_NO_SAMPLE: _MFT_OUTPUT_DATA_BUFFER_FLAGS = _MFT_OUTPUT_DATA_BUFFER_FLAGS(768i32);
impl ::core::convert::From<i32> for _MFT_OUTPUT_DATA_BUFFER_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for _MFT_OUTPUT_DATA_BUFFER_FLAGS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct _MFT_OUTPUT_STATUS_FLAGS(pub i32);
pub const MFT_OUTPUT_STATUS_SAMPLE_READY: _MFT_OUTPUT_STATUS_FLAGS = _MFT_OUTPUT_STATUS_FLAGS(1i32);
impl ::core::convert::From<i32> for _MFT_OUTPUT_STATUS_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for _MFT_OUTPUT_STATUS_FLAGS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct _MFT_OUTPUT_STREAM_INFO_FLAGS(pub i32);
pub const MFT_OUTPUT_STREAM_WHOLE_SAMPLES: _MFT_OUTPUT_STREAM_INFO_FLAGS = _MFT_OUTPUT_STREAM_INFO_FLAGS(1i32);
pub const MFT_OUTPUT_STREAM_SINGLE_SAMPLE_PER_BUFFER: _MFT_OUTPUT_STREAM_INFO_FLAGS = _MFT_OUTPUT_STREAM_INFO_FLAGS(2i32);
pub const MFT_OUTPUT_STREAM_FIXED_SAMPLE_SIZE: _MFT_OUTPUT_STREAM_INFO_FLAGS = _MFT_OUTPUT_STREAM_INFO_FLAGS(4i32);
pub const MFT_OUTPUT_STREAM_DISCARDABLE: _MFT_OUTPUT_STREAM_INFO_FLAGS = _MFT_OUTPUT_STREAM_INFO_FLAGS(8i32);
pub const MFT_OUTPUT_STREAM_OPTIONAL: _MFT_OUTPUT_STREAM_INFO_FLAGS = _MFT_OUTPUT_STREAM_INFO_FLAGS(16i32);
pub const MFT_OUTPUT_STREAM_PROVIDES_SAMPLES: _MFT_OUTPUT_STREAM_INFO_FLAGS = _MFT_OUTPUT_STREAM_INFO_FLAGS(256i32);
pub const MFT_OUTPUT_STREAM_CAN_PROVIDE_SAMPLES: _MFT_OUTPUT_STREAM_INFO_FLAGS = _MFT_OUTPUT_STREAM_INFO_FLAGS(512i32);
pub const MFT_OUTPUT_STREAM_LAZY_READ: _MFT_OUTPUT_STREAM_INFO_FLAGS = _MFT_OUTPUT_STREAM_INFO_FLAGS(1024i32);
pub const MFT_OUTPUT_STREAM_REMOVABLE: _MFT_OUTPUT_STREAM_INFO_FLAGS = _MFT_OUTPUT_STREAM_INFO_FLAGS(2048i32);
impl ::core::convert::From<i32> for _MFT_OUTPUT_STREAM_INFO_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for _MFT_OUTPUT_STREAM_INFO_FLAGS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct _MFT_PROCESS_OUTPUT_FLAGS(pub i32);
pub const MFT_PROCESS_OUTPUT_DISCARD_WHEN_NO_BUFFER: _MFT_PROCESS_OUTPUT_FLAGS = _MFT_PROCESS_OUTPUT_FLAGS(1i32);
pub const MFT_PROCESS_OUTPUT_REGENERATE_LAST_OUTPUT: _MFT_PROCESS_OUTPUT_FLAGS = _MFT_PROCESS_OUTPUT_FLAGS(2i32);
impl ::core::convert::From<i32> for _MFT_PROCESS_OUTPUT_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for _MFT_PROCESS_OUTPUT_FLAGS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct _MFT_PROCESS_OUTPUT_STATUS(pub i32);
pub const MFT_PROCESS_OUTPUT_STATUS_NEW_STREAMS: _MFT_PROCESS_OUTPUT_STATUS = _MFT_PROCESS_OUTPUT_STATUS(256i32);
impl ::core::convert::From<i32> for _MFT_PROCESS_OUTPUT_STATUS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for _MFT_PROCESS_OUTPUT_STATUS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct _MFT_SET_TYPE_FLAGS(pub i32);
pub const MFT_SET_TYPE_TEST_ONLY: _MFT_SET_TYPE_FLAGS = _MFT_SET_TYPE_FLAGS(1i32);
impl ::core::convert::From<i32> for _MFT_SET_TYPE_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for _MFT_SET_TYPE_FLAGS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct __MIDL___MIDL_itf_mfvirtualcamera_0000_0000_0001(pub i32);
pub const MFVirtualCameraType_SoftwareCameraSource: __MIDL___MIDL_itf_mfvirtualcamera_0000_0000_0001 = __MIDL___MIDL_itf_mfvirtualcamera_0000_0000_0001(0i32);
impl ::core::convert::From<i32> for __MIDL___MIDL_itf_mfvirtualcamera_0000_0000_0001 {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for __MIDL___MIDL_itf_mfvirtualcamera_0000_0000_0001 {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct __MIDL___MIDL_itf_mfvirtualcamera_0000_0000_0002(pub i32);
pub const MFVirtualCameraLifetime_Session: __MIDL___MIDL_itf_mfvirtualcamera_0000_0000_0002 = __MIDL___MIDL_itf_mfvirtualcamera_0000_0000_0002(0i32);
pub const MFVirtualCameraLifetime_System: __MIDL___MIDL_itf_mfvirtualcamera_0000_0000_0002 = __MIDL___MIDL_itf_mfvirtualcamera_0000_0000_0002(1i32);
impl ::core::convert::From<i32> for __MIDL___MIDL_itf_mfvirtualcamera_0000_0000_0002 {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for __MIDL___MIDL_itf_mfvirtualcamera_0000_0000_0002 {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct __MIDL___MIDL_itf_mfvirtualcamera_0000_0000_0003(pub i32);
pub const MFVirtualCameraAccess_CurrentUser: __MIDL___MIDL_itf_mfvirtualcamera_0000_0000_0003 = __MIDL___MIDL_itf_mfvirtualcamera_0000_0000_0003(0i32);
pub const MFVirtualCameraAccess_AllUsers: __MIDL___MIDL_itf_mfvirtualcamera_0000_0000_0003 = __MIDL___MIDL_itf_mfvirtualcamera_0000_0000_0003(1i32);
impl ::core::convert::From<i32> for __MIDL___MIDL_itf_mfvirtualcamera_0000_0000_0003 {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for __MIDL___MIDL_itf_mfvirtualcamera_0000_0000_0003 {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVAudioChannelConfig(pub i32);
pub const eAVAudioChannelConfig_FRONT_LEFT: eAVAudioChannelConfig = eAVAudioChannelConfig(1i32);
pub const eAVAudioChannelConfig_FRONT_RIGHT: eAVAudioChannelConfig = eAVAudioChannelConfig(2i32);
pub const eAVAudioChannelConfig_FRONT_CENTER: eAVAudioChannelConfig = eAVAudioChannelConfig(4i32);
pub const eAVAudioChannelConfig_LOW_FREQUENCY: eAVAudioChannelConfig = eAVAudioChannelConfig(8i32);
pub const eAVAudioChannelConfig_BACK_LEFT: eAVAudioChannelConfig = eAVAudioChannelConfig(16i32);
pub const eAVAudioChannelConfig_BACK_RIGHT: eAVAudioChannelConfig = eAVAudioChannelConfig(32i32);
pub const eAVAudioChannelConfig_FRONT_LEFT_OF_CENTER: eAVAudioChannelConfig = eAVAudioChannelConfig(64i32);
pub const eAVAudioChannelConfig_FRONT_RIGHT_OF_CENTER: eAVAudioChannelConfig = eAVAudioChannelConfig(128i32);
pub const eAVAudioChannelConfig_BACK_CENTER: eAVAudioChannelConfig = eAVAudioChannelConfig(256i32);
pub const eAVAudioChannelConfig_SIDE_LEFT: eAVAudioChannelConfig = eAVAudioChannelConfig(512i32);
pub const eAVAudioChannelConfig_SIDE_RIGHT: eAVAudioChannelConfig = eAVAudioChannelConfig(1024i32);
pub const eAVAudioChannelConfig_TOP_CENTER: eAVAudioChannelConfig = eAVAudioChannelConfig(2048i32);
pub const eAVAudioChannelConfig_TOP_FRONT_LEFT: eAVAudioChannelConfig = eAVAudioChannelConfig(4096i32);
pub const eAVAudioChannelConfig_TOP_FRONT_CENTER: eAVAudioChannelConfig = eAVAudioChannelConfig(8192i32);
pub const eAVAudioChannelConfig_TOP_FRONT_RIGHT: eAVAudioChannelConfig = eAVAudioChannelConfig(16384i32);
pub const eAVAudioChannelConfig_TOP_BACK_LEFT: eAVAudioChannelConfig = eAVAudioChannelConfig(32768i32);
pub const eAVAudioChannelConfig_TOP_BACK_CENTER: eAVAudioChannelConfig = eAVAudioChannelConfig(65536i32);
pub const eAVAudioChannelConfig_TOP_BACK_RIGHT: eAVAudioChannelConfig = eAVAudioChannelConfig(131072i32);
impl ::core::convert::From<i32> for eAVAudioChannelConfig {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVAudioChannelConfig {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVDDSurroundMode(pub i32);
pub const eAVDDSurroundMode_NotIndicated: eAVDDSurroundMode = eAVDDSurroundMode(0i32);
pub const eAVDDSurroundMode_No: eAVDDSurroundMode = eAVDDSurroundMode(1i32);
pub const eAVDDSurroundMode_Yes: eAVDDSurroundMode = eAVDDSurroundMode(2i32);
impl ::core::convert::From<i32> for eAVDDSurroundMode {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVDDSurroundMode {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVDSPLoudnessEqualization(pub i32);
pub const eAVDSPLoudnessEqualization_OFF: eAVDSPLoudnessEqualization = eAVDSPLoudnessEqualization(0i32);
pub const eAVDSPLoudnessEqualization_ON: eAVDSPLoudnessEqualization = eAVDSPLoudnessEqualization(1i32);
pub const eAVDSPLoudnessEqualization_AUTO: eAVDSPLoudnessEqualization = eAVDSPLoudnessEqualization(2i32);
impl ::core::convert::From<i32> for eAVDSPLoudnessEqualization {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVDSPLoudnessEqualization {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVDSPSpeakerFill(pub i32);
pub const eAVDSPSpeakerFill_OFF: eAVDSPSpeakerFill = eAVDSPSpeakerFill(0i32);
pub const eAVDSPSpeakerFill_ON: eAVDSPSpeakerFill = eAVDSPSpeakerFill(1i32);
pub const eAVDSPSpeakerFill_AUTO: eAVDSPSpeakerFill = eAVDSPSpeakerFill(2i32);
impl ::core::convert::From<i32> for eAVDSPSpeakerFill {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVDSPSpeakerFill {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVDecAACDownmixMode(pub i32);
pub const eAVDecAACUseISODownmix: eAVDecAACDownmixMode = eAVDecAACDownmixMode(0i32);
pub const eAVDecAACUseARIBDownmix: eAVDecAACDownmixMode = eAVDecAACDownmixMode(1i32);
impl ::core::convert::From<i32> for eAVDecAACDownmixMode {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVDecAACDownmixMode {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVDecAudioDualMono(pub i32);
pub const eAVDecAudioDualMono_IsNotDualMono: eAVDecAudioDualMono = eAVDecAudioDualMono(0i32);
pub const eAVDecAudioDualMono_IsDualMono: eAVDecAudioDualMono = eAVDecAudioDualMono(1i32);
pub const eAVDecAudioDualMono_UnSpecified: eAVDecAudioDualMono = eAVDecAudioDualMono(2i32);
impl ::core::convert::From<i32> for eAVDecAudioDualMono {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVDecAudioDualMono {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVDecAudioDualMonoReproMode(pub i32);
pub const eAVDecAudioDualMonoReproMode_STEREO: eAVDecAudioDualMonoReproMode = eAVDecAudioDualMonoReproMode(0i32);
pub const eAVDecAudioDualMonoReproMode_LEFT_MONO: eAVDecAudioDualMonoReproMode = eAVDecAudioDualMonoReproMode(1i32);
pub const eAVDecAudioDualMonoReproMode_RIGHT_MONO: eAVDecAudioDualMonoReproMode = eAVDecAudioDualMonoReproMode(2i32);
pub const eAVDecAudioDualMonoReproMode_MIX_MONO: eAVDecAudioDualMonoReproMode = eAVDecAudioDualMonoReproMode(3i32);
impl ::core::convert::From<i32> for eAVDecAudioDualMonoReproMode {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVDecAudioDualMonoReproMode {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVDecDDMatrixDecodingMode(pub i32);
pub const eAVDecDDMatrixDecodingMode_OFF: eAVDecDDMatrixDecodingMode = eAVDecDDMatrixDecodingMode(0i32);
pub const eAVDecDDMatrixDecodingMode_ON: eAVDecDDMatrixDecodingMode = eAVDecDDMatrixDecodingMode(1i32);
pub const eAVDecDDMatrixDecodingMode_AUTO: eAVDecDDMatrixDecodingMode = eAVDecDDMatrixDecodingMode(2i32);
impl ::core::convert::From<i32> for eAVDecDDMatrixDecodingMode {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVDecDDMatrixDecodingMode {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVDecDDOperationalMode(pub i32);
pub const eAVDecDDOperationalMode_NONE: eAVDecDDOperationalMode = eAVDecDDOperationalMode(0i32);
pub const eAVDecDDOperationalMode_LINE: eAVDecDDOperationalMode = eAVDecDDOperationalMode(1i32);
pub const eAVDecDDOperationalMode_RF: eAVDecDDOperationalMode = eAVDecDDOperationalMode(2i32);
pub const eAVDecDDOperationalMode_CUSTOM0: eAVDecDDOperationalMode = eAVDecDDOperationalMode(3i32);
pub const eAVDecDDOperationalMode_CUSTOM1: eAVDecDDOperationalMode = eAVDecDDOperationalMode(4i32);
pub const eAVDecDDOperationalMode_PORTABLE8: eAVDecDDOperationalMode = eAVDecDDOperationalMode(5i32);
pub const eAVDecDDOperationalMode_PORTABLE11: eAVDecDDOperationalMode = eAVDecDDOperationalMode(6i32);
pub const eAVDecDDOperationalMode_PORTABLE14: eAVDecDDOperationalMode = eAVDecDDOperationalMode(7i32);
impl ::core::convert::From<i32> for eAVDecDDOperationalMode {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVDecDDOperationalMode {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVDecDDStereoDownMixMode(pub i32);
pub const eAVDecDDStereoDownMixMode_Auto: eAVDecDDStereoDownMixMode = eAVDecDDStereoDownMixMode(0i32);
pub const eAVDecDDStereoDownMixMode_LtRt: eAVDecDDStereoDownMixMode = eAVDecDDStereoDownMixMode(1i32);
pub const eAVDecDDStereoDownMixMode_LoRo: eAVDecDDStereoDownMixMode = eAVDecDDStereoDownMixMode(2i32);
impl ::core::convert::From<i32> for eAVDecDDStereoDownMixMode {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVDecDDStereoDownMixMode {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVDecHEAACDynamicRangeControl(pub i32);
pub const eAVDecHEAACDynamicRangeControl_OFF: eAVDecHEAACDynamicRangeControl = eAVDecHEAACDynamicRangeControl(0i32);
pub const eAVDecHEAACDynamicRangeControl_ON: eAVDecHEAACDynamicRangeControl = eAVDecHEAACDynamicRangeControl(1i32);
impl ::core::convert::From<i32> for eAVDecHEAACDynamicRangeControl {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVDecHEAACDynamicRangeControl {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVDecVideoCodecType(pub i32);
pub const eAVDecVideoCodecType_NOTPLAYING: eAVDecVideoCodecType = eAVDecVideoCodecType(0i32);
pub const eAVDecVideoCodecType_MPEG2: eAVDecVideoCodecType = eAVDecVideoCodecType(1i32);
pub const eAVDecVideoCodecType_H264: eAVDecVideoCodecType = eAVDecVideoCodecType(2i32);
impl ::core::convert::From<i32> for eAVDecVideoCodecType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVDecVideoCodecType {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVDecVideoDXVABusEncryption(pub i32);
pub const eAVDecVideoDXVABusEncryption_NONE: eAVDecVideoDXVABusEncryption = eAVDecVideoDXVABusEncryption(0i32);
pub const eAVDecVideoDXVABusEncryption_PRIVATE: eAVDecVideoDXVABusEncryption = eAVDecVideoDXVABusEncryption(1i32);
pub const eAVDecVideoDXVABusEncryption_AES: eAVDecVideoDXVABusEncryption = eAVDecVideoDXVABusEncryption(2i32);
impl ::core::convert::From<i32> for eAVDecVideoDXVABusEncryption {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVDecVideoDXVABusEncryption {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVDecVideoDXVAMode(pub i32);
pub const eAVDecVideoDXVAMode_NOTPLAYING: eAVDecVideoDXVAMode = eAVDecVideoDXVAMode(0i32);
pub const eAVDecVideoDXVAMode_SW: eAVDecVideoDXVAMode = eAVDecVideoDXVAMode(1i32);
pub const eAVDecVideoDXVAMode_MC: eAVDecVideoDXVAMode = eAVDecVideoDXVAMode(2i32);
pub const eAVDecVideoDXVAMode_IDCT: eAVDecVideoDXVAMode = eAVDecVideoDXVAMode(3i32);
pub const eAVDecVideoDXVAMode_VLD: eAVDecVideoDXVAMode = eAVDecVideoDXVAMode(4i32);
impl ::core::convert::From<i32> for eAVDecVideoDXVAMode {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVDecVideoDXVAMode {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVDecVideoH264ErrorConcealment(pub i32);
pub const eErrorConcealmentTypeDrop: eAVDecVideoH264ErrorConcealment = eAVDecVideoH264ErrorConcealment(0i32);
pub const eErrorConcealmentTypeBasic: eAVDecVideoH264ErrorConcealment = eAVDecVideoH264ErrorConcealment(1i32);
pub const eErrorConcealmentTypeAdvanced: eAVDecVideoH264ErrorConcealment = eAVDecVideoH264ErrorConcealment(2i32);
pub const eErrorConcealmentTypeDXVASetBlack: eAVDecVideoH264ErrorConcealment = eAVDecVideoH264ErrorConcealment(3i32);
impl ::core::convert::From<i32> for eAVDecVideoH264ErrorConcealment {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVDecVideoH264ErrorConcealment {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVDecVideoInputScanType(pub i32);
pub const eAVDecVideoInputScan_Unknown: eAVDecVideoInputScanType = eAVDecVideoInputScanType(0i32);
pub const eAVDecVideoInputScan_Progressive: eAVDecVideoInputScanType = eAVDecVideoInputScanType(1i32);
pub const eAVDecVideoInputScan_Interlaced_UpperFieldFirst: eAVDecVideoInputScanType = eAVDecVideoInputScanType(2i32);
pub const eAVDecVideoInputScan_Interlaced_LowerFieldFirst: eAVDecVideoInputScanType = eAVDecVideoInputScanType(3i32);
impl ::core::convert::From<i32> for eAVDecVideoInputScanType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVDecVideoInputScanType {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVDecVideoMPEG2ErrorConcealment(pub i32);
pub const eErrorConcealmentOff: eAVDecVideoMPEG2ErrorConcealment = eAVDecVideoMPEG2ErrorConcealment(0i32);
pub const eErrorConcealmentOn: eAVDecVideoMPEG2ErrorConcealment = eAVDecVideoMPEG2ErrorConcealment(1i32);
impl ::core::convert::From<i32> for eAVDecVideoMPEG2ErrorConcealment {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVDecVideoMPEG2ErrorConcealment {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVDecVideoSWPowerLevel(pub i32);
pub const eAVDecVideoSWPowerLevel_BatteryLife: eAVDecVideoSWPowerLevel = eAVDecVideoSWPowerLevel(0i32);
pub const eAVDecVideoSWPowerLevel_Balanced: eAVDecVideoSWPowerLevel = eAVDecVideoSWPowerLevel(50i32);
pub const eAVDecVideoSWPowerLevel_VideoQuality: eAVDecVideoSWPowerLevel = eAVDecVideoSWPowerLevel(100i32);
impl ::core::convert::From<i32> for eAVDecVideoSWPowerLevel {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVDecVideoSWPowerLevel {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVDecVideoSoftwareDeinterlaceMode(pub i32);
pub const eAVDecVideoSoftwareDeinterlaceMode_NoDeinterlacing: eAVDecVideoSoftwareDeinterlaceMode = eAVDecVideoSoftwareDeinterlaceMode(0i32);
pub const eAVDecVideoSoftwareDeinterlaceMode_ProgressiveDeinterlacing: eAVDecVideoSoftwareDeinterlaceMode = eAVDecVideoSoftwareDeinterlaceMode(1i32);
pub const eAVDecVideoSoftwareDeinterlaceMode_BOBDeinterlacing: eAVDecVideoSoftwareDeinterlaceMode = eAVDecVideoSoftwareDeinterlaceMode(2i32);
pub const eAVDecVideoSoftwareDeinterlaceMode_SmartBOBDeinterlacing: eAVDecVideoSoftwareDeinterlaceMode = eAVDecVideoSoftwareDeinterlaceMode(3i32);
impl ::core::convert::From<i32> for eAVDecVideoSoftwareDeinterlaceMode {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVDecVideoSoftwareDeinterlaceMode {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncAdaptiveMode(pub i32);
pub const eAVEncAdaptiveMode_None: eAVEncAdaptiveMode = eAVEncAdaptiveMode(0i32);
pub const eAVEncAdaptiveMode_Resolution: eAVEncAdaptiveMode = eAVEncAdaptiveMode(1i32);
pub const eAVEncAdaptiveMode_FrameRate: eAVEncAdaptiveMode = eAVEncAdaptiveMode(2i32);
impl ::core::convert::From<i32> for eAVEncAdaptiveMode {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncAdaptiveMode {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncAudioDualMono(pub i32);
pub const eAVEncAudioDualMono_SameAsInput: eAVEncAudioDualMono = eAVEncAudioDualMono(0i32);
pub const eAVEncAudioDualMono_Off: eAVEncAudioDualMono = eAVEncAudioDualMono(1i32);
pub const eAVEncAudioDualMono_On: eAVEncAudioDualMono = eAVEncAudioDualMono(2i32);
impl ::core::convert::From<i32> for eAVEncAudioDualMono {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncAudioDualMono {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncAudioInputContent(pub i32);
pub const AVEncAudioInputContent_Unknown: eAVEncAudioInputContent = eAVEncAudioInputContent(0i32);
pub const AVEncAudioInputContent_Voice: eAVEncAudioInputContent = eAVEncAudioInputContent(1i32);
pub const AVEncAudioInputContent_Music: eAVEncAudioInputContent = eAVEncAudioInputContent(2i32);
impl ::core::convert::From<i32> for eAVEncAudioInputContent {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncAudioInputContent {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncChromaEncodeMode(pub i32);
pub const eAVEncChromaEncodeMode_420: eAVEncChromaEncodeMode = eAVEncChromaEncodeMode(0i32);
pub const eAVEncChromaEncodeMode_444: eAVEncChromaEncodeMode = eAVEncChromaEncodeMode(1i32);
pub const eAVEncChromaEncodeMode_444_v2: eAVEncChromaEncodeMode = eAVEncChromaEncodeMode(2i32);
impl ::core::convert::From<i32> for eAVEncChromaEncodeMode {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncChromaEncodeMode {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncCommonRateControlMode(pub i32);
pub const eAVEncCommonRateControlMode_CBR: eAVEncCommonRateControlMode = eAVEncCommonRateControlMode(0i32);
pub const eAVEncCommonRateControlMode_PeakConstrainedVBR: eAVEncCommonRateControlMode = eAVEncCommonRateControlMode(1i32);
pub const eAVEncCommonRateControlMode_UnconstrainedVBR: eAVEncCommonRateControlMode = eAVEncCommonRateControlMode(2i32);
pub const eAVEncCommonRateControlMode_Quality: eAVEncCommonRateControlMode = eAVEncCommonRateControlMode(3i32);
pub const eAVEncCommonRateControlMode_LowDelayVBR: eAVEncCommonRateControlMode = eAVEncCommonRateControlMode(4i32);
pub const eAVEncCommonRateControlMode_GlobalVBR: eAVEncCommonRateControlMode = eAVEncCommonRateControlMode(5i32);
pub const eAVEncCommonRateControlMode_GlobalLowDelayVBR: eAVEncCommonRateControlMode = eAVEncCommonRateControlMode(6i32);
impl ::core::convert::From<i32> for eAVEncCommonRateControlMode {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncCommonRateControlMode {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncCommonStreamEndHandling(pub i32);
pub const eAVEncCommonStreamEndHandling_DiscardPartial: eAVEncCommonStreamEndHandling = eAVEncCommonStreamEndHandling(0i32);
pub const eAVEncCommonStreamEndHandling_EnsureComplete: eAVEncCommonStreamEndHandling = eAVEncCommonStreamEndHandling(1i32);
impl ::core::convert::From<i32> for eAVEncCommonStreamEndHandling {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncCommonStreamEndHandling {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncDDAtoDConverterType(pub i32);
pub const eAVEncDDAtoDConverterType_Standard: eAVEncDDAtoDConverterType = eAVEncDDAtoDConverterType(0i32);
pub const eAVEncDDAtoDConverterType_HDCD: eAVEncDDAtoDConverterType = eAVEncDDAtoDConverterType(1i32);
impl ::core::convert::From<i32> for eAVEncDDAtoDConverterType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncDDAtoDConverterType {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncDDDynamicRangeCompressionControl(pub i32);
pub const eAVEncDDDynamicRangeCompressionControl_None: eAVEncDDDynamicRangeCompressionControl = eAVEncDDDynamicRangeCompressionControl(0i32);
pub const eAVEncDDDynamicRangeCompressionControl_FilmStandard: eAVEncDDDynamicRangeCompressionControl = eAVEncDDDynamicRangeCompressionControl(1i32);
pub const eAVEncDDDynamicRangeCompressionControl_FilmLight: eAVEncDDDynamicRangeCompressionControl = eAVEncDDDynamicRangeCompressionControl(2i32);
pub const eAVEncDDDynamicRangeCompressionControl_MusicStandard: eAVEncDDDynamicRangeCompressionControl = eAVEncDDDynamicRangeCompressionControl(3i32);
pub const eAVEncDDDynamicRangeCompressionControl_MusicLight: eAVEncDDDynamicRangeCompressionControl = eAVEncDDDynamicRangeCompressionControl(4i32);
pub const eAVEncDDDynamicRangeCompressionControl_Speech: eAVEncDDDynamicRangeCompressionControl = eAVEncDDDynamicRangeCompressionControl(5i32);
impl ::core::convert::From<i32> for eAVEncDDDynamicRangeCompressionControl {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncDDDynamicRangeCompressionControl {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncDDHeadphoneMode(pub i32);
pub const eAVEncDDHeadphoneMode_NotIndicated: eAVEncDDHeadphoneMode = eAVEncDDHeadphoneMode(0i32);
pub const eAVEncDDHeadphoneMode_NotEncoded: eAVEncDDHeadphoneMode = eAVEncDDHeadphoneMode(1i32);
pub const eAVEncDDHeadphoneMode_Encoded: eAVEncDDHeadphoneMode = eAVEncDDHeadphoneMode(2i32);
impl ::core::convert::From<i32> for eAVEncDDHeadphoneMode {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncDDHeadphoneMode {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncDDPreferredStereoDownMixMode(pub i32);
pub const eAVEncDDPreferredStereoDownMixMode_LtRt: eAVEncDDPreferredStereoDownMixMode = eAVEncDDPreferredStereoDownMixMode(0i32);
pub const eAVEncDDPreferredStereoDownMixMode_LoRo: eAVEncDDPreferredStereoDownMixMode = eAVEncDDPreferredStereoDownMixMode(1i32);
impl ::core::convert::From<i32> for eAVEncDDPreferredStereoDownMixMode {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncDDPreferredStereoDownMixMode {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncDDProductionRoomType(pub i32);
pub const eAVEncDDProductionRoomType_NotIndicated: eAVEncDDProductionRoomType = eAVEncDDProductionRoomType(0i32);
pub const eAVEncDDProductionRoomType_Large: eAVEncDDProductionRoomType = eAVEncDDProductionRoomType(1i32);
pub const eAVEncDDProductionRoomType_Small: eAVEncDDProductionRoomType = eAVEncDDProductionRoomType(2i32);
impl ::core::convert::From<i32> for eAVEncDDProductionRoomType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncDDProductionRoomType {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncDDService(pub i32);
pub const eAVEncDDService_CM: eAVEncDDService = eAVEncDDService(0i32);
pub const eAVEncDDService_ME: eAVEncDDService = eAVEncDDService(1i32);
pub const eAVEncDDService_VI: eAVEncDDService = eAVEncDDService(2i32);
pub const eAVEncDDService_HI: eAVEncDDService = eAVEncDDService(3i32);
pub const eAVEncDDService_D: eAVEncDDService = eAVEncDDService(4i32);
pub const eAVEncDDService_C: eAVEncDDService = eAVEncDDService(5i32);
pub const eAVEncDDService_E: eAVEncDDService = eAVEncDDService(6i32);
pub const eAVEncDDService_VO: eAVEncDDService = eAVEncDDService(7i32);
impl ::core::convert::From<i32> for eAVEncDDService {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncDDService {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncDDSurroundExMode(pub i32);
pub const eAVEncDDSurroundExMode_NotIndicated: eAVEncDDSurroundExMode = eAVEncDDSurroundExMode(0i32);
pub const eAVEncDDSurroundExMode_No: eAVEncDDSurroundExMode = eAVEncDDSurroundExMode(1i32);
pub const eAVEncDDSurroundExMode_Yes: eAVEncDDSurroundExMode = eAVEncDDSurroundExMode(2i32);
impl ::core::convert::From<i32> for eAVEncDDSurroundExMode {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncDDSurroundExMode {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncH263PictureType(pub i32);
pub const eAVEncH263PictureType_I: eAVEncH263PictureType = eAVEncH263PictureType(0i32);
pub const eAVEncH263PictureType_P: eAVEncH263PictureType = eAVEncH263PictureType(1i32);
pub const eAVEncH263PictureType_B: eAVEncH263PictureType = eAVEncH263PictureType(2i32);
impl ::core::convert::From<i32> for eAVEncH263PictureType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncH263PictureType {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncH263VLevel(pub i32);
pub const eAVEncH263VLevel1: eAVEncH263VLevel = eAVEncH263VLevel(10i32);
pub const eAVEncH263VLevel2: eAVEncH263VLevel = eAVEncH263VLevel(20i32);
pub const eAVEncH263VLevel3: eAVEncH263VLevel = eAVEncH263VLevel(30i32);
pub const eAVEncH263VLevel4: eAVEncH263VLevel = eAVEncH263VLevel(40i32);
pub const eAVEncH263VLevel4_5: eAVEncH263VLevel = eAVEncH263VLevel(45i32);
pub const eAVEncH263VLevel5: eAVEncH263VLevel = eAVEncH263VLevel(50i32);
pub const eAVEncH263VLevel6: eAVEncH263VLevel = eAVEncH263VLevel(60i32);
pub const eAVEncH263VLevel7: eAVEncH263VLevel = eAVEncH263VLevel(70i32);
impl ::core::convert::From<i32> for eAVEncH263VLevel {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncH263VLevel {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncH263VProfile(pub i32);
pub const eAVEncH263VProfile_Base: eAVEncH263VProfile = eAVEncH263VProfile(0i32);
pub const eAVEncH263VProfile_CompatibilityV2: eAVEncH263VProfile = eAVEncH263VProfile(1i32);
pub const eAVEncH263VProfile_CompatibilityV1: eAVEncH263VProfile = eAVEncH263VProfile(2i32);
pub const eAVEncH263VProfile_WirelessV2: eAVEncH263VProfile = eAVEncH263VProfile(3i32);
pub const eAVEncH263VProfile_WirelessV3: eAVEncH263VProfile = eAVEncH263VProfile(4i32);
pub const eAVEncH263VProfile_HighCompression: eAVEncH263VProfile = eAVEncH263VProfile(5i32);
pub const eAVEncH263VProfile_Internet: eAVEncH263VProfile = eAVEncH263VProfile(6i32);
pub const eAVEncH263VProfile_Interlace: eAVEncH263VProfile = eAVEncH263VProfile(7i32);
pub const eAVEncH263VProfile_HighLatency: eAVEncH263VProfile = eAVEncH263VProfile(8i32);
impl ::core::convert::From<i32> for eAVEncH263VProfile {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncH263VProfile {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncH264PictureType(pub i32);
pub const eAVEncH264PictureType_IDR: eAVEncH264PictureType = eAVEncH264PictureType(0i32);
pub const eAVEncH264PictureType_P: eAVEncH264PictureType = eAVEncH264PictureType(1i32);
pub const eAVEncH264PictureType_B: eAVEncH264PictureType = eAVEncH264PictureType(2i32);
impl ::core::convert::From<i32> for eAVEncH264PictureType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncH264PictureType {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncH264VLevel(pub i32);
pub const eAVEncH264VLevel1: eAVEncH264VLevel = eAVEncH264VLevel(10i32);
pub const eAVEncH264VLevel1_b: eAVEncH264VLevel = eAVEncH264VLevel(11i32);
pub const eAVEncH264VLevel1_1: eAVEncH264VLevel = eAVEncH264VLevel(11i32);
pub const eAVEncH264VLevel1_2: eAVEncH264VLevel = eAVEncH264VLevel(12i32);
pub const eAVEncH264VLevel1_3: eAVEncH264VLevel = eAVEncH264VLevel(13i32);
pub const eAVEncH264VLevel2: eAVEncH264VLevel = eAVEncH264VLevel(20i32);
pub const eAVEncH264VLevel2_1: eAVEncH264VLevel = eAVEncH264VLevel(21i32);
pub const eAVEncH264VLevel2_2: eAVEncH264VLevel = eAVEncH264VLevel(22i32);
pub const eAVEncH264VLevel3: eAVEncH264VLevel = eAVEncH264VLevel(30i32);
pub const eAVEncH264VLevel3_1: eAVEncH264VLevel = eAVEncH264VLevel(31i32);
pub const eAVEncH264VLevel3_2: eAVEncH264VLevel = eAVEncH264VLevel(32i32);
pub const eAVEncH264VLevel4: eAVEncH264VLevel = eAVEncH264VLevel(40i32);
pub const eAVEncH264VLevel4_1: eAVEncH264VLevel = eAVEncH264VLevel(41i32);
pub const eAVEncH264VLevel4_2: eAVEncH264VLevel = eAVEncH264VLevel(42i32);
pub const eAVEncH264VLevel5: eAVEncH264VLevel = eAVEncH264VLevel(50i32);
pub const eAVEncH264VLevel5_1: eAVEncH264VLevel = eAVEncH264VLevel(51i32);
pub const eAVEncH264VLevel5_2: eAVEncH264VLevel = eAVEncH264VLevel(52i32);
impl ::core::convert::From<i32> for eAVEncH264VLevel {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncH264VLevel {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncH264VProfile(pub i32);
pub const eAVEncH264VProfile_unknown: eAVEncH264VProfile = eAVEncH264VProfile(0i32);
pub const eAVEncH264VProfile_Simple: eAVEncH264VProfile = eAVEncH264VProfile(66i32);
pub const eAVEncH264VProfile_Base: eAVEncH264VProfile = eAVEncH264VProfile(66i32);
pub const eAVEncH264VProfile_Main: eAVEncH264VProfile = eAVEncH264VProfile(77i32);
pub const eAVEncH264VProfile_High: eAVEncH264VProfile = eAVEncH264VProfile(100i32);
pub const eAVEncH264VProfile_422: eAVEncH264VProfile = eAVEncH264VProfile(122i32);
pub const eAVEncH264VProfile_High10: eAVEncH264VProfile = eAVEncH264VProfile(110i32);
pub const eAVEncH264VProfile_444: eAVEncH264VProfile = eAVEncH264VProfile(244i32);
pub const eAVEncH264VProfile_Extended: eAVEncH264VProfile = eAVEncH264VProfile(88i32);
pub const eAVEncH264VProfile_ScalableBase: eAVEncH264VProfile = eAVEncH264VProfile(83i32);
pub const eAVEncH264VProfile_ScalableHigh: eAVEncH264VProfile = eAVEncH264VProfile(86i32);
pub const eAVEncH264VProfile_MultiviewHigh: eAVEncH264VProfile = eAVEncH264VProfile(118i32);
pub const eAVEncH264VProfile_StereoHigh: eAVEncH264VProfile = eAVEncH264VProfile(128i32);
pub const eAVEncH264VProfile_ConstrainedBase: eAVEncH264VProfile = eAVEncH264VProfile(256i32);
pub const eAVEncH264VProfile_UCConstrainedHigh: eAVEncH264VProfile = eAVEncH264VProfile(257i32);
pub const eAVEncH264VProfile_UCScalableConstrainedBase: eAVEncH264VProfile = eAVEncH264VProfile(258i32);
pub const eAVEncH264VProfile_UCScalableConstrainedHigh: eAVEncH264VProfile = eAVEncH264VProfile(259i32);
impl ::core::convert::From<i32> for eAVEncH264VProfile {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncH264VProfile {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncH265VLevel(pub i32);
pub const eAVEncH265VLevel1: eAVEncH265VLevel = eAVEncH265VLevel(30i32);
pub const eAVEncH265VLevel2: eAVEncH265VLevel = eAVEncH265VLevel(60i32);
pub const eAVEncH265VLevel2_1: eAVEncH265VLevel = eAVEncH265VLevel(63i32);
pub const eAVEncH265VLevel3: eAVEncH265VLevel = eAVEncH265VLevel(90i32);
pub const eAVEncH265VLevel3_1: eAVEncH265VLevel = eAVEncH265VLevel(93i32);
pub const eAVEncH265VLevel4: eAVEncH265VLevel = eAVEncH265VLevel(120i32);
pub const eAVEncH265VLevel4_1: eAVEncH265VLevel = eAVEncH265VLevel(123i32);
pub const eAVEncH265VLevel5: eAVEncH265VLevel = eAVEncH265VLevel(150i32);
pub const eAVEncH265VLevel5_1: eAVEncH265VLevel = eAVEncH265VLevel(153i32);
pub const eAVEncH265VLevel5_2: eAVEncH265VLevel = eAVEncH265VLevel(156i32);
pub const eAVEncH265VLevel6: eAVEncH265VLevel = eAVEncH265VLevel(180i32);
pub const eAVEncH265VLevel6_1: eAVEncH265VLevel = eAVEncH265VLevel(183i32);
pub const eAVEncH265VLevel6_2: eAVEncH265VLevel = eAVEncH265VLevel(186i32);
impl ::core::convert::From<i32> for eAVEncH265VLevel {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncH265VLevel {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncH265VProfile(pub i32);
pub const eAVEncH265VProfile_unknown: eAVEncH265VProfile = eAVEncH265VProfile(0i32);
pub const eAVEncH265VProfile_Main_420_8: eAVEncH265VProfile = eAVEncH265VProfile(1i32);
pub const eAVEncH265VProfile_Main_420_10: eAVEncH265VProfile = eAVEncH265VProfile(2i32);
pub const eAVEncH265VProfile_Main_420_12: eAVEncH265VProfile = eAVEncH265VProfile(3i32);
pub const eAVEncH265VProfile_Main_422_10: eAVEncH265VProfile = eAVEncH265VProfile(4i32);
pub const eAVEncH265VProfile_Main_422_12: eAVEncH265VProfile = eAVEncH265VProfile(5i32);
pub const eAVEncH265VProfile_Main_444_8: eAVEncH265VProfile = eAVEncH265VProfile(6i32);
pub const eAVEncH265VProfile_Main_444_10: eAVEncH265VProfile = eAVEncH265VProfile(7i32);
pub const eAVEncH265VProfile_Main_444_12: eAVEncH265VProfile = eAVEncH265VProfile(8i32);
pub const eAVEncH265VProfile_Monochrome_12: eAVEncH265VProfile = eAVEncH265VProfile(9i32);
pub const eAVEncH265VProfile_Monochrome_16: eAVEncH265VProfile = eAVEncH265VProfile(10i32);
pub const eAVEncH265VProfile_MainIntra_420_8: eAVEncH265VProfile = eAVEncH265VProfile(11i32);
pub const eAVEncH265VProfile_MainIntra_420_10: eAVEncH265VProfile = eAVEncH265VProfile(12i32);
pub const eAVEncH265VProfile_MainIntra_420_12: eAVEncH265VProfile = eAVEncH265VProfile(13i32);
pub const eAVEncH265VProfile_MainIntra_422_10: eAVEncH265VProfile = eAVEncH265VProfile(14i32);
pub const eAVEncH265VProfile_MainIntra_422_12: eAVEncH265VProfile = eAVEncH265VProfile(15i32);
pub const eAVEncH265VProfile_MainIntra_444_8: eAVEncH265VProfile = eAVEncH265VProfile(16i32);
pub const eAVEncH265VProfile_MainIntra_444_10: eAVEncH265VProfile = eAVEncH265VProfile(17i32);
pub const eAVEncH265VProfile_MainIntra_444_12: eAVEncH265VProfile = eAVEncH265VProfile(18i32);
pub const eAVEncH265VProfile_MainIntra_444_16: eAVEncH265VProfile = eAVEncH265VProfile(19i32);
pub const eAVEncH265VProfile_MainStill_420_8: eAVEncH265VProfile = eAVEncH265VProfile(20i32);
pub const eAVEncH265VProfile_MainStill_444_8: eAVEncH265VProfile = eAVEncH265VProfile(21i32);
pub const eAVEncH265VProfile_MainStill_444_16: eAVEncH265VProfile = eAVEncH265VProfile(22i32);
impl ::core::convert::From<i32> for eAVEncH265VProfile {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncH265VProfile {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncInputVideoSystem(pub i32);
pub const eAVEncInputVideoSystem_Unspecified: eAVEncInputVideoSystem = eAVEncInputVideoSystem(0i32);
pub const eAVEncInputVideoSystem_PAL: eAVEncInputVideoSystem = eAVEncInputVideoSystem(1i32);
pub const eAVEncInputVideoSystem_NTSC: eAVEncInputVideoSystem = eAVEncInputVideoSystem(2i32);
pub const eAVEncInputVideoSystem_SECAM: eAVEncInputVideoSystem = eAVEncInputVideoSystem(3i32);
pub const eAVEncInputVideoSystem_MAC: eAVEncInputVideoSystem = eAVEncInputVideoSystem(4i32);
pub const eAVEncInputVideoSystem_HDV: eAVEncInputVideoSystem = eAVEncInputVideoSystem(5i32);
pub const eAVEncInputVideoSystem_Component: eAVEncInputVideoSystem = eAVEncInputVideoSystem(6i32);
impl ::core::convert::From<i32> for eAVEncInputVideoSystem {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncInputVideoSystem {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncMPACodingMode(pub i32);
pub const eAVEncMPACodingMode_Mono: eAVEncMPACodingMode = eAVEncMPACodingMode(0i32);
pub const eAVEncMPACodingMode_Stereo: eAVEncMPACodingMode = eAVEncMPACodingMode(1i32);
pub const eAVEncMPACodingMode_DualChannel: eAVEncMPACodingMode = eAVEncMPACodingMode(2i32);
pub const eAVEncMPACodingMode_JointStereo: eAVEncMPACodingMode = eAVEncMPACodingMode(3i32);
pub const eAVEncMPACodingMode_Surround: eAVEncMPACodingMode = eAVEncMPACodingMode(4i32);
impl ::core::convert::From<i32> for eAVEncMPACodingMode {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncMPACodingMode {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncMPAEmphasisType(pub i32);
pub const eAVEncMPAEmphasisType_None: eAVEncMPAEmphasisType = eAVEncMPAEmphasisType(0i32);
pub const eAVEncMPAEmphasisType_50_15: eAVEncMPAEmphasisType = eAVEncMPAEmphasisType(1i32);
pub const eAVEncMPAEmphasisType_Reserved: eAVEncMPAEmphasisType = eAVEncMPAEmphasisType(2i32);
pub const eAVEncMPAEmphasisType_CCITT_J17: eAVEncMPAEmphasisType = eAVEncMPAEmphasisType(3i32);
impl ::core::convert::From<i32> for eAVEncMPAEmphasisType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncMPAEmphasisType {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncMPALayer(pub i32);
pub const eAVEncMPALayer_1: eAVEncMPALayer = eAVEncMPALayer(1i32);
pub const eAVEncMPALayer_2: eAVEncMPALayer = eAVEncMPALayer(2i32);
pub const eAVEncMPALayer_3: eAVEncMPALayer = eAVEncMPALayer(3i32);
impl ::core::convert::From<i32> for eAVEncMPALayer {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncMPALayer {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncMPVFrameFieldMode(pub i32);
pub const eAVEncMPVFrameFieldMode_FieldMode: eAVEncMPVFrameFieldMode = eAVEncMPVFrameFieldMode(0i32);
pub const eAVEncMPVFrameFieldMode_FrameMode: eAVEncMPVFrameFieldMode = eAVEncMPVFrameFieldMode(1i32);
impl ::core::convert::From<i32> for eAVEncMPVFrameFieldMode {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncMPVFrameFieldMode {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncMPVIntraVLCTable(pub i32);
pub const eAVEncMPVIntraVLCTable_Auto: eAVEncMPVIntraVLCTable = eAVEncMPVIntraVLCTable(0i32);
pub const eAVEncMPVIntraVLCTable_MPEG1: eAVEncMPVIntraVLCTable = eAVEncMPVIntraVLCTable(1i32);
pub const eAVEncMPVIntraVLCTable_Alternate: eAVEncMPVIntraVLCTable = eAVEncMPVIntraVLCTable(2i32);
impl ::core::convert::From<i32> for eAVEncMPVIntraVLCTable {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncMPVIntraVLCTable {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncMPVLevel(pub i32);
pub const eAVEncMPVLevel_Low: eAVEncMPVLevel = eAVEncMPVLevel(1i32);
pub const eAVEncMPVLevel_Main: eAVEncMPVLevel = eAVEncMPVLevel(2i32);
pub const eAVEncMPVLevel_High1440: eAVEncMPVLevel = eAVEncMPVLevel(3i32);
pub const eAVEncMPVLevel_High: eAVEncMPVLevel = eAVEncMPVLevel(4i32);
impl ::core::convert::From<i32> for eAVEncMPVLevel {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncMPVLevel {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncMPVProfile(pub i32);
pub const eAVEncMPVProfile_unknown: eAVEncMPVProfile = eAVEncMPVProfile(0i32);
pub const eAVEncMPVProfile_Simple: eAVEncMPVProfile = eAVEncMPVProfile(1i32);
pub const eAVEncMPVProfile_Main: eAVEncMPVProfile = eAVEncMPVProfile(2i32);
pub const eAVEncMPVProfile_High: eAVEncMPVProfile = eAVEncMPVProfile(3i32);
pub const eAVEncMPVProfile_422: eAVEncMPVProfile = eAVEncMPVProfile(4i32);
impl ::core::convert::From<i32> for eAVEncMPVProfile {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncMPVProfile {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncMPVQScaleType(pub i32);
pub const eAVEncMPVQScaleType_Auto: eAVEncMPVQScaleType = eAVEncMPVQScaleType(0i32);
pub const eAVEncMPVQScaleType_Linear: eAVEncMPVQScaleType = eAVEncMPVQScaleType(1i32);
pub const eAVEncMPVQScaleType_NonLinear: eAVEncMPVQScaleType = eAVEncMPVQScaleType(2i32);
impl ::core::convert::From<i32> for eAVEncMPVQScaleType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncMPVQScaleType {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncMPVScanPattern(pub i32);
pub const eAVEncMPVScanPattern_Auto: eAVEncMPVScanPattern = eAVEncMPVScanPattern(0i32);
pub const eAVEncMPVScanPattern_ZigZagScan: eAVEncMPVScanPattern = eAVEncMPVScanPattern(1i32);
pub const eAVEncMPVScanPattern_AlternateScan: eAVEncMPVScanPattern = eAVEncMPVScanPattern(2i32);
impl ::core::convert::From<i32> for eAVEncMPVScanPattern {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncMPVScanPattern {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncMPVSceneDetection(pub i32);
pub const eAVEncMPVSceneDetection_None: eAVEncMPVSceneDetection = eAVEncMPVSceneDetection(0i32);
pub const eAVEncMPVSceneDetection_InsertIPicture: eAVEncMPVSceneDetection = eAVEncMPVSceneDetection(1i32);
pub const eAVEncMPVSceneDetection_StartNewGOP: eAVEncMPVSceneDetection = eAVEncMPVSceneDetection(2i32);
pub const eAVEncMPVSceneDetection_StartNewLocatableGOP: eAVEncMPVSceneDetection = eAVEncMPVSceneDetection(3i32);
impl ::core::convert::From<i32> for eAVEncMPVSceneDetection {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncMPVSceneDetection {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncMuxOutput(pub i32);
pub const eAVEncMuxOutputAuto: eAVEncMuxOutput = eAVEncMuxOutput(0i32);
pub const eAVEncMuxOutputPS: eAVEncMuxOutput = eAVEncMuxOutput(1i32);
pub const eAVEncMuxOutputTS: eAVEncMuxOutput = eAVEncMuxOutput(2i32);
impl ::core::convert::From<i32> for eAVEncMuxOutput {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncMuxOutput {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncVP9VProfile(pub i32);
pub const eAVEncVP9VProfile_unknown: eAVEncVP9VProfile = eAVEncVP9VProfile(0i32);
pub const eAVEncVP9VProfile_420_8: eAVEncVP9VProfile = eAVEncVP9VProfile(1i32);
pub const eAVEncVP9VProfile_420_10: eAVEncVP9VProfile = eAVEncVP9VProfile(2i32);
pub const eAVEncVP9VProfile_420_12: eAVEncVP9VProfile = eAVEncVP9VProfile(3i32);
impl ::core::convert::From<i32> for eAVEncVP9VProfile {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncVP9VProfile {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncVideoChromaResolution(pub i32);
pub const eAVEncVideoChromaResolution_SameAsSource: eAVEncVideoChromaResolution = eAVEncVideoChromaResolution(0i32);
pub const eAVEncVideoChromaResolution_444: eAVEncVideoChromaResolution = eAVEncVideoChromaResolution(1i32);
pub const eAVEncVideoChromaResolution_422: eAVEncVideoChromaResolution = eAVEncVideoChromaResolution(2i32);
pub const eAVEncVideoChromaResolution_420: eAVEncVideoChromaResolution = eAVEncVideoChromaResolution(3i32);
pub const eAVEncVideoChromaResolution_411: eAVEncVideoChromaResolution = eAVEncVideoChromaResolution(4i32);
impl ::core::convert::From<i32> for eAVEncVideoChromaResolution {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncVideoChromaResolution {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncVideoChromaSubsampling(pub i32);
pub const eAVEncVideoChromaSubsamplingFormat_SameAsSource: eAVEncVideoChromaSubsampling = eAVEncVideoChromaSubsampling(0i32);
pub const eAVEncVideoChromaSubsamplingFormat_ProgressiveChroma: eAVEncVideoChromaSubsampling = eAVEncVideoChromaSubsampling(8i32);
pub const eAVEncVideoChromaSubsamplingFormat_Horizontally_Cosited: eAVEncVideoChromaSubsampling = eAVEncVideoChromaSubsampling(4i32);
pub const eAVEncVideoChromaSubsamplingFormat_Vertically_Cosited: eAVEncVideoChromaSubsampling = eAVEncVideoChromaSubsampling(2i32);
pub const eAVEncVideoChromaSubsamplingFormat_Vertically_AlignedChromaPlanes: eAVEncVideoChromaSubsampling = eAVEncVideoChromaSubsampling(1i32);
impl ::core::convert::From<i32> for eAVEncVideoChromaSubsampling {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncVideoChromaSubsampling {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncVideoColorLighting(pub i32);
pub const eAVEncVideoColorLighting_SameAsSource: eAVEncVideoColorLighting = eAVEncVideoColorLighting(0i32);
pub const eAVEncVideoColorLighting_Unknown: eAVEncVideoColorLighting = eAVEncVideoColorLighting(1i32);
pub const eAVEncVideoColorLighting_Bright: eAVEncVideoColorLighting = eAVEncVideoColorLighting(2i32);
pub const eAVEncVideoColorLighting_Office: eAVEncVideoColorLighting = eAVEncVideoColorLighting(3i32);
pub const eAVEncVideoColorLighting_Dim: eAVEncVideoColorLighting = eAVEncVideoColorLighting(4i32);
pub const eAVEncVideoColorLighting_Dark: eAVEncVideoColorLighting = eAVEncVideoColorLighting(5i32);
impl ::core::convert::From<i32> for eAVEncVideoColorLighting {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncVideoColorLighting {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncVideoColorNominalRange(pub i32);
pub const eAVEncVideoColorNominalRange_SameAsSource: eAVEncVideoColorNominalRange = eAVEncVideoColorNominalRange(0i32);
pub const eAVEncVideoColorNominalRange_0_255: eAVEncVideoColorNominalRange = eAVEncVideoColorNominalRange(1i32);
pub const eAVEncVideoColorNominalRange_16_235: eAVEncVideoColorNominalRange = eAVEncVideoColorNominalRange(2i32);
pub const eAVEncVideoColorNominalRange_48_208: eAVEncVideoColorNominalRange = eAVEncVideoColorNominalRange(3i32);
impl ::core::convert::From<i32> for eAVEncVideoColorNominalRange {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncVideoColorNominalRange {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncVideoColorPrimaries(pub i32);
pub const eAVEncVideoColorPrimaries_SameAsSource: eAVEncVideoColorPrimaries = eAVEncVideoColorPrimaries(0i32);
pub const eAVEncVideoColorPrimaries_Reserved: eAVEncVideoColorPrimaries = eAVEncVideoColorPrimaries(1i32);
pub const eAVEncVideoColorPrimaries_BT709: eAVEncVideoColorPrimaries = eAVEncVideoColorPrimaries(2i32);
pub const eAVEncVideoColorPrimaries_BT470_2_SysM: eAVEncVideoColorPrimaries = eAVEncVideoColorPrimaries(3i32);
pub const eAVEncVideoColorPrimaries_BT470_2_SysBG: eAVEncVideoColorPrimaries = eAVEncVideoColorPrimaries(4i32);
pub const eAVEncVideoColorPrimaries_SMPTE170M: eAVEncVideoColorPrimaries = eAVEncVideoColorPrimaries(5i32);
pub const eAVEncVideoColorPrimaries_SMPTE240M: eAVEncVideoColorPrimaries = eAVEncVideoColorPrimaries(6i32);
pub const eAVEncVideoColorPrimaries_EBU3231: eAVEncVideoColorPrimaries = eAVEncVideoColorPrimaries(7i32);
pub const eAVEncVideoColorPrimaries_SMPTE_C: eAVEncVideoColorPrimaries = eAVEncVideoColorPrimaries(8i32);
impl ::core::convert::From<i32> for eAVEncVideoColorPrimaries {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncVideoColorPrimaries {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncVideoColorTransferFunction(pub i32);
pub const eAVEncVideoColorTransferFunction_SameAsSource: eAVEncVideoColorTransferFunction = eAVEncVideoColorTransferFunction(0i32);
pub const eAVEncVideoColorTransferFunction_10: eAVEncVideoColorTransferFunction = eAVEncVideoColorTransferFunction(1i32);
pub const eAVEncVideoColorTransferFunction_18: eAVEncVideoColorTransferFunction = eAVEncVideoColorTransferFunction(2i32);
pub const eAVEncVideoColorTransferFunction_20: eAVEncVideoColorTransferFunction = eAVEncVideoColorTransferFunction(3i32);
pub const eAVEncVideoColorTransferFunction_22: eAVEncVideoColorTransferFunction = eAVEncVideoColorTransferFunction(4i32);
pub const eAVEncVideoColorTransferFunction_22_709: eAVEncVideoColorTransferFunction = eAVEncVideoColorTransferFunction(5i32);
pub const eAVEncVideoColorTransferFunction_22_240M: eAVEncVideoColorTransferFunction = eAVEncVideoColorTransferFunction(6i32);
pub const eAVEncVideoColorTransferFunction_22_8bit_sRGB: eAVEncVideoColorTransferFunction = eAVEncVideoColorTransferFunction(7i32);
pub const eAVEncVideoColorTransferFunction_28: eAVEncVideoColorTransferFunction = eAVEncVideoColorTransferFunction(8i32);
impl ::core::convert::From<i32> for eAVEncVideoColorTransferFunction {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncVideoColorTransferFunction {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncVideoColorTransferMatrix(pub i32);
pub const eAVEncVideoColorTransferMatrix_SameAsSource: eAVEncVideoColorTransferMatrix = eAVEncVideoColorTransferMatrix(0i32);
pub const eAVEncVideoColorTransferMatrix_BT709: eAVEncVideoColorTransferMatrix = eAVEncVideoColorTransferMatrix(1i32);
pub const eAVEncVideoColorTransferMatrix_BT601: eAVEncVideoColorTransferMatrix = eAVEncVideoColorTransferMatrix(2i32);
pub const eAVEncVideoColorTransferMatrix_SMPTE240M: eAVEncVideoColorTransferMatrix = eAVEncVideoColorTransferMatrix(3i32);
impl ::core::convert::From<i32> for eAVEncVideoColorTransferMatrix {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncVideoColorTransferMatrix {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncVideoContentType(pub i32);
pub const eAVEncVideoContentType_Unknown: eAVEncVideoContentType = eAVEncVideoContentType(0i32);
pub const eAVEncVideoContentType_FixedCameraAngle: eAVEncVideoContentType = eAVEncVideoContentType(1i32);
impl ::core::convert::From<i32> for eAVEncVideoContentType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncVideoContentType {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncVideoFilmContent(pub i32);
pub const eAVEncVideoFilmContent_VideoOnly: eAVEncVideoFilmContent = eAVEncVideoFilmContent(0i32);
pub const eAVEncVideoFilmContent_FilmOnly: eAVEncVideoFilmContent = eAVEncVideoFilmContent(1i32);
pub const eAVEncVideoFilmContent_Mixed: eAVEncVideoFilmContent = eAVEncVideoFilmContent(2i32);
impl ::core::convert::From<i32> for eAVEncVideoFilmContent {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncVideoFilmContent {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncVideoOutputFrameRateConversion(pub i32);
pub const eAVEncVideoOutputFrameRateConversion_Disable: eAVEncVideoOutputFrameRateConversion = eAVEncVideoOutputFrameRateConversion(0i32);
pub const eAVEncVideoOutputFrameRateConversion_Enable: eAVEncVideoOutputFrameRateConversion = eAVEncVideoOutputFrameRateConversion(1i32);
pub const eAVEncVideoOutputFrameRateConversion_Alias: eAVEncVideoOutputFrameRateConversion = eAVEncVideoOutputFrameRateConversion(2i32);
impl ::core::convert::From<i32> for eAVEncVideoOutputFrameRateConversion {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncVideoOutputFrameRateConversion {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncVideoOutputScanType(pub i32);
pub const eAVEncVideoOutputScan_Progressive: eAVEncVideoOutputScanType = eAVEncVideoOutputScanType(0i32);
pub const eAVEncVideoOutputScan_Interlaced: eAVEncVideoOutputScanType = eAVEncVideoOutputScanType(1i32);
pub const eAVEncVideoOutputScan_SameAsInput: eAVEncVideoOutputScanType = eAVEncVideoOutputScanType(2i32);
pub const eAVEncVideoOutputScan_Automatic: eAVEncVideoOutputScanType = eAVEncVideoOutputScanType(3i32);
impl ::core::convert::From<i32> for eAVEncVideoOutputScanType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncVideoOutputScanType {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVEncVideoSourceScanType(pub i32);
pub const eAVEncVideoSourceScan_Automatic: eAVEncVideoSourceScanType = eAVEncVideoSourceScanType(0i32);
pub const eAVEncVideoSourceScan_Interlaced: eAVEncVideoSourceScanType = eAVEncVideoSourceScanType(1i32);
pub const eAVEncVideoSourceScan_Progressive: eAVEncVideoSourceScanType = eAVEncVideoSourceScanType(2i32);
impl ::core::convert::From<i32> for eAVEncVideoSourceScanType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVEncVideoSourceScanType {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVFastDecodeMode(pub i32);
pub const eVideoDecodeCompliant: eAVFastDecodeMode = eAVFastDecodeMode(0i32);
pub const eVideoDecodeOptimalLF: eAVFastDecodeMode = eAVFastDecodeMode(1i32);
pub const eVideoDecodeDisableLF: eAVFastDecodeMode = eAVFastDecodeMode(2i32);
pub const eVideoDecodeFastest: eAVFastDecodeMode = eAVFastDecodeMode(32i32);
impl ::core::convert::From<i32> for eAVFastDecodeMode {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVFastDecodeMode {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eAVScenarioInfo(pub i32);
pub const eAVScenarioInfo_Unknown: eAVScenarioInfo = eAVScenarioInfo(0i32);
pub const eAVScenarioInfo_DisplayRemoting: eAVScenarioInfo = eAVScenarioInfo(1i32);
pub const eAVScenarioInfo_VideoConference: eAVScenarioInfo = eAVScenarioInfo(2i32);
pub const eAVScenarioInfo_Archive: eAVScenarioInfo = eAVScenarioInfo(3i32);
pub const eAVScenarioInfo_LiveStreaming: eAVScenarioInfo = eAVScenarioInfo(4i32);
pub const eAVScenarioInfo_CameraRecord: eAVScenarioInfo = eAVScenarioInfo(5i32);
pub const eAVScenarioInfo_DisplayRemotingWithFeatureMap: eAVScenarioInfo = eAVScenarioInfo(6i32);
impl ::core::convert::From<i32> for eAVScenarioInfo {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eAVScenarioInfo {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct eVideoEncoderDisplayContentType(pub i32);
pub const eVideoEncoderDisplayContent_Unknown: eVideoEncoderDisplayContentType = eVideoEncoderDisplayContentType(0i32);
pub const eVideoEncoderDisplayContent_FullScreenVideo: eVideoEncoderDisplayContentType = eVideoEncoderDisplayContentType(1i32);
impl ::core::convert::From<i32> for eVideoEncoderDisplayContentType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for eVideoEncoderDisplayContentType {
type Abi = Self;
}
pub const g_wszSpeechFormatCaps: &'static str = "SpeechFormatCap";
pub const g_wszWMCPAudioVBRQuality: &'static str = "_VBRQUALITY";
pub const g_wszWMCPAudioVBRSupported: &'static str = "_VBRENABLED";
pub const g_wszWMCPCodecName: &'static str = "_CODECNAME";
pub const g_wszWMCPDefaultCrisp: &'static str = "_DEFAULTCRISP";
pub const g_wszWMCPMaxPasses: &'static str = "_PASSESRECOMMENDED";
pub const g_wszWMCPSupportedVBRModes: &'static str = "_SUPPORTEDVBRMODES";
|
#[doc = "Writer for register ICR"]
pub type W = crate::W<u32, super::ICR>;
#[doc = "Register ICR `reset()`'s with value 0"]
impl crate::ResetValue for super::ICR {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0
}
}
#[doc = "Write proxy for field `CTSMIC`"]
pub struct CTSMIC_W<'a> {
w: &'a mut W,
}
impl<'a> CTSMIC_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 1)) | (((value as u32) & 0x01) << 1);
self.w
}
}
#[doc = "Write proxy for field `RXIC`"]
pub struct RXIC_W<'a> {
w: &'a mut W,
}
impl<'a> RXIC_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 4)) | (((value as u32) & 0x01) << 4);
self.w
}
}
#[doc = "Write proxy for field `TXIC`"]
pub struct TXIC_W<'a> {
w: &'a mut W,
}
impl<'a> TXIC_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 5)) | (((value as u32) & 0x01) << 5);
self.w
}
}
#[doc = "Write proxy for field `RTIC`"]
pub struct RTIC_W<'a> {
w: &'a mut W,
}
impl<'a> RTIC_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 6)) | (((value as u32) & 0x01) << 6);
self.w
}
}
#[doc = "Write proxy for field `FEIC`"]
pub struct FEIC_W<'a> {
w: &'a mut W,
}
impl<'a> FEIC_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 7)) | (((value as u32) & 0x01) << 7);
self.w
}
}
#[doc = "Write proxy for field `PEIC`"]
pub struct PEIC_W<'a> {
w: &'a mut W,
}
impl<'a> PEIC_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 8)) | (((value as u32) & 0x01) << 8);
self.w
}
}
#[doc = "Write proxy for field `BEIC`"]
pub struct BEIC_W<'a> {
w: &'a mut W,
}
impl<'a> BEIC_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 9)) | (((value as u32) & 0x01) << 9);
self.w
}
}
#[doc = "Write proxy for field `OEIC`"]
pub struct OEIC_W<'a> {
w: &'a mut W,
}
impl<'a> OEIC_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 10)) | (((value as u32) & 0x01) << 10);
self.w
}
}
#[doc = "Write proxy for field `_9BITIC`"]
pub struct _9BITIC_W<'a> {
w: &'a mut W,
}
impl<'a> _9BITIC_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 12)) | (((value as u32) & 0x01) << 12);
self.w
}
}
impl W {
#[doc = "Bit 1 - UART Clear to Send Modem Interrupt Clear"]
#[inline(always)]
pub fn ctsmic(&mut self) -> CTSMIC_W {
CTSMIC_W { w: self }
}
#[doc = "Bit 4 - Receive Interrupt Clear"]
#[inline(always)]
pub fn rxic(&mut self) -> RXIC_W {
RXIC_W { w: self }
}
#[doc = "Bit 5 - Transmit Interrupt Clear"]
#[inline(always)]
pub fn txic(&mut self) -> TXIC_W {
TXIC_W { w: self }
}
#[doc = "Bit 6 - Receive Time-Out Interrupt Clear"]
#[inline(always)]
pub fn rtic(&mut self) -> RTIC_W {
RTIC_W { w: self }
}
#[doc = "Bit 7 - Framing Error Interrupt Clear"]
#[inline(always)]
pub fn feic(&mut self) -> FEIC_W {
FEIC_W { w: self }
}
#[doc = "Bit 8 - Parity Error Interrupt Clear"]
#[inline(always)]
pub fn peic(&mut self) -> PEIC_W {
PEIC_W { w: self }
}
#[doc = "Bit 9 - Break Error Interrupt Clear"]
#[inline(always)]
pub fn beic(&mut self) -> BEIC_W {
BEIC_W { w: self }
}
#[doc = "Bit 10 - Overrun Error Interrupt Clear"]
#[inline(always)]
pub fn oeic(&mut self) -> OEIC_W {
OEIC_W { w: self }
}
#[doc = "Bit 12 - 9-Bit Mode Interrupt Clear"]
#[inline(always)]
pub fn _9bitic(&mut self) -> _9BITIC_W {
_9BITIC_W { w: self }
}
}
|
// auto generated, do not modify.
// created: Wed Jan 20 00:44:03 2016
// src-file: /QtQml/qqmlengine.h
// dst-file: /src/qml/qqmlengine.rs
//
// header block begin =>
#![feature(libc)]
#![feature(core)]
#![feature(collections)]
extern crate libc;
use self::libc::*;
// <= header block end
// main block begin =>
// <= main block end
// use block begin =>
use super::qjsengine::QJSEngine; // 773
use std::ops::Deref;
use super::qqmlnetworkaccessmanagerfactory::QQmlNetworkAccessManagerFactory; // 773
use super::super::core::qstring::QString; // 771
use super::super::core::qobject::QObject; // 771
// use super::qqmlengine::QQmlImageProviderBase; // 773
use super::qqmlabstracturlinterceptor::QQmlAbstractUrlInterceptor; // 773
use super::super::core::qstringlist::QStringList; // 771
use super::qqmlcontext::QQmlContext; // 773
use super::qqmlincubator::QQmlIncubationController; // 773
use super::super::network::qnetworkaccessmanager::QNetworkAccessManager; // 771
use super::super::core::qurl::QUrl; // 771
// <= use block end
// ext block begin =>
// #[link(name = "Qt5Core")]
// #[link(name = "Qt5Gui")]
// #[link(name = "Qt5Widgets")]
// #[link(name = "QtInline")]
extern {
fn QQmlEngine_Class_Size() -> c_int;
// proto: void QQmlEngine::setNetworkAccessManagerFactory(QQmlNetworkAccessManagerFactory * );
fn _ZN10QQmlEngine30setNetworkAccessManagerFactoryEP31QQmlNetworkAccessManagerFactory(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: bool QQmlEngine::outputWarningsToStandardError();
fn _ZNK10QQmlEngine29outputWarningsToStandardErrorEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: void QQmlEngine::setOfflineStoragePath(const QString & dir);
fn _ZN10QQmlEngine21setOfflineStoragePathERK7QString(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: void QQmlEngine::trimComponentCache();
fn _ZN10QQmlEngine18trimComponentCacheEv(qthis: u64 /* *mut c_void*/);
// proto: bool QQmlEngine::addNamedBundle(const QString & name, const QString & fileName);
fn _ZN10QQmlEngine14addNamedBundleERK7QStringS2_(qthis: u64 /* *mut c_void*/, arg0: *mut c_void, arg1: *mut c_void) -> c_char;
// proto: void QQmlEngine::addImageProvider(const QString & id, QQmlImageProviderBase * );
fn _ZN10QQmlEngine16addImageProviderERK7QStringP21QQmlImageProviderBase(qthis: u64 /* *mut c_void*/, arg0: *mut c_void, arg1: *mut c_void);
// proto: void QQmlEngine::setUrlInterceptor(QQmlAbstractUrlInterceptor * urlInterceptor);
fn _ZN10QQmlEngine17setUrlInterceptorEP26QQmlAbstractUrlInterceptor(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: void QQmlEngine::setImportPathList(const QStringList & paths);
fn _ZN10QQmlEngine17setImportPathListERK11QStringList(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: void QQmlEngine::addPluginPath(const QString & dir);
fn _ZN10QQmlEngine13addPluginPathERK7QString(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: void QQmlEngine::setPluginPathList(const QStringList & paths);
fn _ZN10QQmlEngine17setPluginPathListERK11QStringList(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: static void QQmlEngine::setContextForObject(QObject * , QQmlContext * );
fn _ZN10QQmlEngine19setContextForObjectEP7QObjectP11QQmlContext(arg0: *mut c_void, arg1: *mut c_void);
// proto: QQmlImageProviderBase * QQmlEngine::imageProvider(const QString & id);
fn _ZNK10QQmlEngine13imageProviderERK7QString(qthis: u64 /* *mut c_void*/, arg0: *mut c_void) -> *mut c_void;
// proto: void QQmlEngine::QQmlEngine(const QQmlEngine & );
fn _ZN10QQmlEngineC2ERKS_(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: void QQmlEngine::~QQmlEngine();
fn _ZN10QQmlEngineD2Ev(qthis: u64 /* *mut c_void*/);
// proto: void QQmlEngine::QQmlEngine(QObject * p);
fn _ZN10QQmlEngineC2EP7QObject(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: QQmlContext * QQmlEngine::rootContext();
fn _ZNK10QQmlEngine11rootContextEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: void QQmlEngine::addImportPath(const QString & dir);
fn _ZN10QQmlEngine13addImportPathERK7QString(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: void QQmlEngine::setIncubationController(QQmlIncubationController * );
fn _ZN10QQmlEngine23setIncubationControllerEP24QQmlIncubationController(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: QStringList QQmlEngine::importPathList();
fn _ZNK10QQmlEngine14importPathListEv(qthis: u64 /* *mut c_void*/);
// proto: QQmlAbstractUrlInterceptor * QQmlEngine::urlInterceptor();
fn _ZNK10QQmlEngine14urlInterceptorEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: QString QQmlEngine::offlineStoragePath();
fn _ZNK10QQmlEngine18offlineStoragePathEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: void QQmlEngine::removeImageProvider(const QString & id);
fn _ZN10QQmlEngine19removeImageProviderERK7QString(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: QNetworkAccessManager * QQmlEngine::networkAccessManager();
fn _ZNK10QQmlEngine20networkAccessManagerEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: void QQmlEngine::setBaseUrl(const QUrl & );
fn _ZN10QQmlEngine10setBaseUrlERK4QUrl(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: QUrl QQmlEngine::baseUrl();
fn _ZNK10QQmlEngine7baseUrlEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: QQmlIncubationController * QQmlEngine::incubationController();
fn _ZNK10QQmlEngine20incubationControllerEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: static QQmlContext * QQmlEngine::contextForObject(const QObject * );
fn _ZN10QQmlEngine16contextForObjectEPK7QObject(arg0: *mut c_void) -> *mut c_void;
// proto: QQmlNetworkAccessManagerFactory * QQmlEngine::networkAccessManagerFactory();
fn _ZNK10QQmlEngine27networkAccessManagerFactoryEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: QStringList QQmlEngine::pluginPathList();
fn _ZNK10QQmlEngine14pluginPathListEv(qthis: u64 /* *mut c_void*/);
// proto: const QMetaObject * QQmlEngine::metaObject();
fn _ZNK10QQmlEngine10metaObjectEv(qthis: u64 /* *mut c_void*/);
// proto: void QQmlEngine::setOutputWarningsToStandardError(bool );
fn _ZN10QQmlEngine32setOutputWarningsToStandardErrorEb(qthis: u64 /* *mut c_void*/, arg0: c_char);
// proto: void QQmlEngine::clearComponentCache();
fn _ZN10QQmlEngine19clearComponentCacheEv(qthis: u64 /* *mut c_void*/);
fn QQmlImageProviderBase_Class_Size() -> c_int;
// proto: void QQmlImageProviderBase::QQmlImageProviderBase();
fn _ZN21QQmlImageProviderBaseC2Ev(qthis: u64 /* *mut c_void*/);
// proto: void QQmlImageProviderBase::~QQmlImageProviderBase();
fn _ZN21QQmlImageProviderBaseD2Ev(qthis: u64 /* *mut c_void*/);
fn QQmlEngine_SlotProxy_connect__ZN10QQmlEngine4quitEv(qthis: *mut c_void, ffifptr: *mut c_void, rsfptr: *mut c_void);
} // <= ext block end
// body block begin =>
// class sizeof(QQmlEngine)=1
#[derive(Default)]
pub struct QQmlEngine {
qbase: QJSEngine,
pub qclsinst: u64 /* *mut c_void*/,
pub _quit: QQmlEngine_quit_signal,
pub _warnings: QQmlEngine_warnings_signal,
}
// class sizeof(QQmlImageProviderBase)=8
#[derive(Default)]
pub struct QQmlImageProviderBase {
// qbase: None,
pub qclsinst: u64 /* *mut c_void*/,
}
impl /*struct*/ QQmlEngine {
pub fn inheritFrom(qthis: u64 /* *mut c_void*/) -> QQmlEngine {
return QQmlEngine{qbase: QJSEngine::inheritFrom(qthis), qclsinst: qthis, ..Default::default()};
}
}
impl Deref for QQmlEngine {
type Target = QJSEngine;
fn deref(&self) -> &QJSEngine {
return & self.qbase;
}
}
impl AsRef<QJSEngine> for QQmlEngine {
fn as_ref(& self) -> & QJSEngine {
return & self.qbase;
}
}
// proto: void QQmlEngine::setNetworkAccessManagerFactory(QQmlNetworkAccessManagerFactory * );
impl /*struct*/ QQmlEngine {
pub fn setNetworkAccessManagerFactory<RetType, T: QQmlEngine_setNetworkAccessManagerFactory<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setNetworkAccessManagerFactory(self);
// return 1;
}
}
pub trait QQmlEngine_setNetworkAccessManagerFactory<RetType> {
fn setNetworkAccessManagerFactory(self , rsthis: & QQmlEngine) -> RetType;
}
// proto: void QQmlEngine::setNetworkAccessManagerFactory(QQmlNetworkAccessManagerFactory * );
impl<'a> /*trait*/ QQmlEngine_setNetworkAccessManagerFactory<()> for (&'a QQmlNetworkAccessManagerFactory) {
fn setNetworkAccessManagerFactory(self , rsthis: & QQmlEngine) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN10QQmlEngine30setNetworkAccessManagerFactoryEP31QQmlNetworkAccessManagerFactory()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {_ZN10QQmlEngine30setNetworkAccessManagerFactoryEP31QQmlNetworkAccessManagerFactory(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: bool QQmlEngine::outputWarningsToStandardError();
impl /*struct*/ QQmlEngine {
pub fn outputWarningsToStandardError<RetType, T: QQmlEngine_outputWarningsToStandardError<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.outputWarningsToStandardError(self);
// return 1;
}
}
pub trait QQmlEngine_outputWarningsToStandardError<RetType> {
fn outputWarningsToStandardError(self , rsthis: & QQmlEngine) -> RetType;
}
// proto: bool QQmlEngine::outputWarningsToStandardError();
impl<'a> /*trait*/ QQmlEngine_outputWarningsToStandardError<i8> for () {
fn outputWarningsToStandardError(self , rsthis: & QQmlEngine) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK10QQmlEngine29outputWarningsToStandardErrorEv()};
let mut ret = unsafe {_ZNK10QQmlEngine29outputWarningsToStandardErrorEv(rsthis.qclsinst)};
return ret as i8;
// return 1;
}
}
// proto: void QQmlEngine::setOfflineStoragePath(const QString & dir);
impl /*struct*/ QQmlEngine {
pub fn setOfflineStoragePath<RetType, T: QQmlEngine_setOfflineStoragePath<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setOfflineStoragePath(self);
// return 1;
}
}
pub trait QQmlEngine_setOfflineStoragePath<RetType> {
fn setOfflineStoragePath(self , rsthis: & QQmlEngine) -> RetType;
}
// proto: void QQmlEngine::setOfflineStoragePath(const QString & dir);
impl<'a> /*trait*/ QQmlEngine_setOfflineStoragePath<()> for (&'a QString) {
fn setOfflineStoragePath(self , rsthis: & QQmlEngine) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN10QQmlEngine21setOfflineStoragePathERK7QString()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {_ZN10QQmlEngine21setOfflineStoragePathERK7QString(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QQmlEngine::trimComponentCache();
impl /*struct*/ QQmlEngine {
pub fn trimComponentCache<RetType, T: QQmlEngine_trimComponentCache<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.trimComponentCache(self);
// return 1;
}
}
pub trait QQmlEngine_trimComponentCache<RetType> {
fn trimComponentCache(self , rsthis: & QQmlEngine) -> RetType;
}
// proto: void QQmlEngine::trimComponentCache();
impl<'a> /*trait*/ QQmlEngine_trimComponentCache<()> for () {
fn trimComponentCache(self , rsthis: & QQmlEngine) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN10QQmlEngine18trimComponentCacheEv()};
unsafe {_ZN10QQmlEngine18trimComponentCacheEv(rsthis.qclsinst)};
// return 1;
}
}
// proto: bool QQmlEngine::addNamedBundle(const QString & name, const QString & fileName);
impl /*struct*/ QQmlEngine {
pub fn addNamedBundle<RetType, T: QQmlEngine_addNamedBundle<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.addNamedBundle(self);
// return 1;
}
}
pub trait QQmlEngine_addNamedBundle<RetType> {
fn addNamedBundle(self , rsthis: & QQmlEngine) -> RetType;
}
// proto: bool QQmlEngine::addNamedBundle(const QString & name, const QString & fileName);
impl<'a> /*trait*/ QQmlEngine_addNamedBundle<i8> for (&'a QString, &'a QString) {
fn addNamedBundle(self , rsthis: & QQmlEngine) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN10QQmlEngine14addNamedBundleERK7QStringS2_()};
let arg0 = self.0.qclsinst as *mut c_void;
let arg1 = self.1.qclsinst as *mut c_void;
let mut ret = unsafe {_ZN10QQmlEngine14addNamedBundleERK7QStringS2_(rsthis.qclsinst, arg0, arg1)};
return ret as i8;
// return 1;
}
}
// proto: void QQmlEngine::addImageProvider(const QString & id, QQmlImageProviderBase * );
impl /*struct*/ QQmlEngine {
pub fn addImageProvider<RetType, T: QQmlEngine_addImageProvider<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.addImageProvider(self);
// return 1;
}
}
pub trait QQmlEngine_addImageProvider<RetType> {
fn addImageProvider(self , rsthis: & QQmlEngine) -> RetType;
}
// proto: void QQmlEngine::addImageProvider(const QString & id, QQmlImageProviderBase * );
impl<'a> /*trait*/ QQmlEngine_addImageProvider<()> for (&'a QString, &'a QQmlImageProviderBase) {
fn addImageProvider(self , rsthis: & QQmlEngine) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN10QQmlEngine16addImageProviderERK7QStringP21QQmlImageProviderBase()};
let arg0 = self.0.qclsinst as *mut c_void;
let arg1 = self.1.qclsinst as *mut c_void;
unsafe {_ZN10QQmlEngine16addImageProviderERK7QStringP21QQmlImageProviderBase(rsthis.qclsinst, arg0, arg1)};
// return 1;
}
}
// proto: void QQmlEngine::setUrlInterceptor(QQmlAbstractUrlInterceptor * urlInterceptor);
impl /*struct*/ QQmlEngine {
pub fn setUrlInterceptor<RetType, T: QQmlEngine_setUrlInterceptor<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setUrlInterceptor(self);
// return 1;
}
}
pub trait QQmlEngine_setUrlInterceptor<RetType> {
fn setUrlInterceptor(self , rsthis: & QQmlEngine) -> RetType;
}
// proto: void QQmlEngine::setUrlInterceptor(QQmlAbstractUrlInterceptor * urlInterceptor);
impl<'a> /*trait*/ QQmlEngine_setUrlInterceptor<()> for (&'a QQmlAbstractUrlInterceptor) {
fn setUrlInterceptor(self , rsthis: & QQmlEngine) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN10QQmlEngine17setUrlInterceptorEP26QQmlAbstractUrlInterceptor()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {_ZN10QQmlEngine17setUrlInterceptorEP26QQmlAbstractUrlInterceptor(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QQmlEngine::setImportPathList(const QStringList & paths);
impl /*struct*/ QQmlEngine {
pub fn setImportPathList<RetType, T: QQmlEngine_setImportPathList<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setImportPathList(self);
// return 1;
}
}
pub trait QQmlEngine_setImportPathList<RetType> {
fn setImportPathList(self , rsthis: & QQmlEngine) -> RetType;
}
// proto: void QQmlEngine::setImportPathList(const QStringList & paths);
impl<'a> /*trait*/ QQmlEngine_setImportPathList<()> for (&'a QStringList) {
fn setImportPathList(self , rsthis: & QQmlEngine) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN10QQmlEngine17setImportPathListERK11QStringList()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {_ZN10QQmlEngine17setImportPathListERK11QStringList(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QQmlEngine::addPluginPath(const QString & dir);
impl /*struct*/ QQmlEngine {
pub fn addPluginPath<RetType, T: QQmlEngine_addPluginPath<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.addPluginPath(self);
// return 1;
}
}
pub trait QQmlEngine_addPluginPath<RetType> {
fn addPluginPath(self , rsthis: & QQmlEngine) -> RetType;
}
// proto: void QQmlEngine::addPluginPath(const QString & dir);
impl<'a> /*trait*/ QQmlEngine_addPluginPath<()> for (&'a QString) {
fn addPluginPath(self , rsthis: & QQmlEngine) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN10QQmlEngine13addPluginPathERK7QString()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {_ZN10QQmlEngine13addPluginPathERK7QString(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QQmlEngine::setPluginPathList(const QStringList & paths);
impl /*struct*/ QQmlEngine {
pub fn setPluginPathList<RetType, T: QQmlEngine_setPluginPathList<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setPluginPathList(self);
// return 1;
}
}
pub trait QQmlEngine_setPluginPathList<RetType> {
fn setPluginPathList(self , rsthis: & QQmlEngine) -> RetType;
}
// proto: void QQmlEngine::setPluginPathList(const QStringList & paths);
impl<'a> /*trait*/ QQmlEngine_setPluginPathList<()> for (&'a QStringList) {
fn setPluginPathList(self , rsthis: & QQmlEngine) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN10QQmlEngine17setPluginPathListERK11QStringList()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {_ZN10QQmlEngine17setPluginPathListERK11QStringList(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: static void QQmlEngine::setContextForObject(QObject * , QQmlContext * );
impl /*struct*/ QQmlEngine {
pub fn setContextForObject_s<RetType, T: QQmlEngine_setContextForObject_s<RetType>>( overload_args: T) -> RetType {
return overload_args.setContextForObject_s();
// return 1;
}
}
pub trait QQmlEngine_setContextForObject_s<RetType> {
fn setContextForObject_s(self ) -> RetType;
}
// proto: static void QQmlEngine::setContextForObject(QObject * , QQmlContext * );
impl<'a> /*trait*/ QQmlEngine_setContextForObject_s<()> for (&'a QObject, &'a QQmlContext) {
fn setContextForObject_s(self ) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN10QQmlEngine19setContextForObjectEP7QObjectP11QQmlContext()};
let arg0 = self.0.qclsinst as *mut c_void;
let arg1 = self.1.qclsinst as *mut c_void;
unsafe {_ZN10QQmlEngine19setContextForObjectEP7QObjectP11QQmlContext(arg0, arg1)};
// return 1;
}
}
// proto: QQmlImageProviderBase * QQmlEngine::imageProvider(const QString & id);
impl /*struct*/ QQmlEngine {
pub fn imageProvider<RetType, T: QQmlEngine_imageProvider<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.imageProvider(self);
// return 1;
}
}
pub trait QQmlEngine_imageProvider<RetType> {
fn imageProvider(self , rsthis: & QQmlEngine) -> RetType;
}
// proto: QQmlImageProviderBase * QQmlEngine::imageProvider(const QString & id);
impl<'a> /*trait*/ QQmlEngine_imageProvider<QQmlImageProviderBase> for (&'a QString) {
fn imageProvider(self , rsthis: & QQmlEngine) -> QQmlImageProviderBase {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK10QQmlEngine13imageProviderERK7QString()};
let arg0 = self.qclsinst as *mut c_void;
let mut ret = unsafe {_ZNK10QQmlEngine13imageProviderERK7QString(rsthis.qclsinst, arg0)};
let mut ret1 = QQmlImageProviderBase::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: void QQmlEngine::QQmlEngine(const QQmlEngine & );
impl /*struct*/ QQmlEngine {
pub fn new<T: QQmlEngine_new>(value: T) -> QQmlEngine {
let rsthis = value.new();
return rsthis;
// return 1;
}
}
pub trait QQmlEngine_new {
fn new(self) -> QQmlEngine;
}
// proto: void QQmlEngine::QQmlEngine(const QQmlEngine & );
impl<'a> /*trait*/ QQmlEngine_new for (&'a QQmlEngine) {
fn new(self) -> QQmlEngine {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN10QQmlEngineC2ERKS_()};
let ctysz: c_int = unsafe{QQmlEngine_Class_Size()};
let qthis_ph: u64 = unsafe{calloc(1, ctysz as usize)} as u64;
let arg0 = self.qclsinst as *mut c_void;
unsafe {_ZN10QQmlEngineC2ERKS_(qthis_ph, arg0)};
let qthis: u64 = qthis_ph;
let rsthis = QQmlEngine{qbase: QJSEngine::inheritFrom(qthis), qclsinst: qthis, ..Default::default()};
return rsthis;
// return 1;
}
}
// proto: void QQmlEngine::~QQmlEngine();
impl /*struct*/ QQmlEngine {
pub fn free<RetType, T: QQmlEngine_free<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.free(self);
// return 1;
}
}
pub trait QQmlEngine_free<RetType> {
fn free(self , rsthis: & QQmlEngine) -> RetType;
}
// proto: void QQmlEngine::~QQmlEngine();
impl<'a> /*trait*/ QQmlEngine_free<()> for () {
fn free(self , rsthis: & QQmlEngine) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN10QQmlEngineD2Ev()};
unsafe {_ZN10QQmlEngineD2Ev(rsthis.qclsinst)};
// return 1;
}
}
// proto: void QQmlEngine::QQmlEngine(QObject * p);
impl<'a> /*trait*/ QQmlEngine_new for (&'a QObject) {
fn new(self) -> QQmlEngine {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN10QQmlEngineC2EP7QObject()};
let ctysz: c_int = unsafe{QQmlEngine_Class_Size()};
let qthis_ph: u64 = unsafe{calloc(1, ctysz as usize)} as u64;
let arg0 = self.qclsinst as *mut c_void;
unsafe {_ZN10QQmlEngineC2EP7QObject(qthis_ph, arg0)};
let qthis: u64 = qthis_ph;
let rsthis = QQmlEngine{qbase: QJSEngine::inheritFrom(qthis), qclsinst: qthis, ..Default::default()};
return rsthis;
// return 1;
}
}
// proto: QQmlContext * QQmlEngine::rootContext();
impl /*struct*/ QQmlEngine {
pub fn rootContext<RetType, T: QQmlEngine_rootContext<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.rootContext(self);
// return 1;
}
}
pub trait QQmlEngine_rootContext<RetType> {
fn rootContext(self , rsthis: & QQmlEngine) -> RetType;
}
// proto: QQmlContext * QQmlEngine::rootContext();
impl<'a> /*trait*/ QQmlEngine_rootContext<QQmlContext> for () {
fn rootContext(self , rsthis: & QQmlEngine) -> QQmlContext {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK10QQmlEngine11rootContextEv()};
let mut ret = unsafe {_ZNK10QQmlEngine11rootContextEv(rsthis.qclsinst)};
let mut ret1 = QQmlContext::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: void QQmlEngine::addImportPath(const QString & dir);
impl /*struct*/ QQmlEngine {
pub fn addImportPath<RetType, T: QQmlEngine_addImportPath<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.addImportPath(self);
// return 1;
}
}
pub trait QQmlEngine_addImportPath<RetType> {
fn addImportPath(self , rsthis: & QQmlEngine) -> RetType;
}
// proto: void QQmlEngine::addImportPath(const QString & dir);
impl<'a> /*trait*/ QQmlEngine_addImportPath<()> for (&'a QString) {
fn addImportPath(self , rsthis: & QQmlEngine) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN10QQmlEngine13addImportPathERK7QString()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {_ZN10QQmlEngine13addImportPathERK7QString(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QQmlEngine::setIncubationController(QQmlIncubationController * );
impl /*struct*/ QQmlEngine {
pub fn setIncubationController<RetType, T: QQmlEngine_setIncubationController<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setIncubationController(self);
// return 1;
}
}
pub trait QQmlEngine_setIncubationController<RetType> {
fn setIncubationController(self , rsthis: & QQmlEngine) -> RetType;
}
// proto: void QQmlEngine::setIncubationController(QQmlIncubationController * );
impl<'a> /*trait*/ QQmlEngine_setIncubationController<()> for (&'a QQmlIncubationController) {
fn setIncubationController(self , rsthis: & QQmlEngine) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN10QQmlEngine23setIncubationControllerEP24QQmlIncubationController()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {_ZN10QQmlEngine23setIncubationControllerEP24QQmlIncubationController(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: QStringList QQmlEngine::importPathList();
impl /*struct*/ QQmlEngine {
pub fn importPathList<RetType, T: QQmlEngine_importPathList<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.importPathList(self);
// return 1;
}
}
pub trait QQmlEngine_importPathList<RetType> {
fn importPathList(self , rsthis: & QQmlEngine) -> RetType;
}
// proto: QStringList QQmlEngine::importPathList();
impl<'a> /*trait*/ QQmlEngine_importPathList<()> for () {
fn importPathList(self , rsthis: & QQmlEngine) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK10QQmlEngine14importPathListEv()};
unsafe {_ZNK10QQmlEngine14importPathListEv(rsthis.qclsinst)};
// return 1;
}
}
// proto: QQmlAbstractUrlInterceptor * QQmlEngine::urlInterceptor();
impl /*struct*/ QQmlEngine {
pub fn urlInterceptor<RetType, T: QQmlEngine_urlInterceptor<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.urlInterceptor(self);
// return 1;
}
}
pub trait QQmlEngine_urlInterceptor<RetType> {
fn urlInterceptor(self , rsthis: & QQmlEngine) -> RetType;
}
// proto: QQmlAbstractUrlInterceptor * QQmlEngine::urlInterceptor();
impl<'a> /*trait*/ QQmlEngine_urlInterceptor<QQmlAbstractUrlInterceptor> for () {
fn urlInterceptor(self , rsthis: & QQmlEngine) -> QQmlAbstractUrlInterceptor {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK10QQmlEngine14urlInterceptorEv()};
let mut ret = unsafe {_ZNK10QQmlEngine14urlInterceptorEv(rsthis.qclsinst)};
let mut ret1 = QQmlAbstractUrlInterceptor::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: QString QQmlEngine::offlineStoragePath();
impl /*struct*/ QQmlEngine {
pub fn offlineStoragePath<RetType, T: QQmlEngine_offlineStoragePath<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.offlineStoragePath(self);
// return 1;
}
}
pub trait QQmlEngine_offlineStoragePath<RetType> {
fn offlineStoragePath(self , rsthis: & QQmlEngine) -> RetType;
}
// proto: QString QQmlEngine::offlineStoragePath();
impl<'a> /*trait*/ QQmlEngine_offlineStoragePath<QString> for () {
fn offlineStoragePath(self , rsthis: & QQmlEngine) -> QString {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK10QQmlEngine18offlineStoragePathEv()};
let mut ret = unsafe {_ZNK10QQmlEngine18offlineStoragePathEv(rsthis.qclsinst)};
let mut ret1 = QString::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: void QQmlEngine::removeImageProvider(const QString & id);
impl /*struct*/ QQmlEngine {
pub fn removeImageProvider<RetType, T: QQmlEngine_removeImageProvider<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.removeImageProvider(self);
// return 1;
}
}
pub trait QQmlEngine_removeImageProvider<RetType> {
fn removeImageProvider(self , rsthis: & QQmlEngine) -> RetType;
}
// proto: void QQmlEngine::removeImageProvider(const QString & id);
impl<'a> /*trait*/ QQmlEngine_removeImageProvider<()> for (&'a QString) {
fn removeImageProvider(self , rsthis: & QQmlEngine) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN10QQmlEngine19removeImageProviderERK7QString()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {_ZN10QQmlEngine19removeImageProviderERK7QString(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: QNetworkAccessManager * QQmlEngine::networkAccessManager();
impl /*struct*/ QQmlEngine {
pub fn networkAccessManager<RetType, T: QQmlEngine_networkAccessManager<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.networkAccessManager(self);
// return 1;
}
}
pub trait QQmlEngine_networkAccessManager<RetType> {
fn networkAccessManager(self , rsthis: & QQmlEngine) -> RetType;
}
// proto: QNetworkAccessManager * QQmlEngine::networkAccessManager();
impl<'a> /*trait*/ QQmlEngine_networkAccessManager<QNetworkAccessManager> for () {
fn networkAccessManager(self , rsthis: & QQmlEngine) -> QNetworkAccessManager {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK10QQmlEngine20networkAccessManagerEv()};
let mut ret = unsafe {_ZNK10QQmlEngine20networkAccessManagerEv(rsthis.qclsinst)};
let mut ret1 = QNetworkAccessManager::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: void QQmlEngine::setBaseUrl(const QUrl & );
impl /*struct*/ QQmlEngine {
pub fn setBaseUrl<RetType, T: QQmlEngine_setBaseUrl<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setBaseUrl(self);
// return 1;
}
}
pub trait QQmlEngine_setBaseUrl<RetType> {
fn setBaseUrl(self , rsthis: & QQmlEngine) -> RetType;
}
// proto: void QQmlEngine::setBaseUrl(const QUrl & );
impl<'a> /*trait*/ QQmlEngine_setBaseUrl<()> for (&'a QUrl) {
fn setBaseUrl(self , rsthis: & QQmlEngine) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN10QQmlEngine10setBaseUrlERK4QUrl()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {_ZN10QQmlEngine10setBaseUrlERK4QUrl(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: QUrl QQmlEngine::baseUrl();
impl /*struct*/ QQmlEngine {
pub fn baseUrl<RetType, T: QQmlEngine_baseUrl<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.baseUrl(self);
// return 1;
}
}
pub trait QQmlEngine_baseUrl<RetType> {
fn baseUrl(self , rsthis: & QQmlEngine) -> RetType;
}
// proto: QUrl QQmlEngine::baseUrl();
impl<'a> /*trait*/ QQmlEngine_baseUrl<QUrl> for () {
fn baseUrl(self , rsthis: & QQmlEngine) -> QUrl {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK10QQmlEngine7baseUrlEv()};
let mut ret = unsafe {_ZNK10QQmlEngine7baseUrlEv(rsthis.qclsinst)};
let mut ret1 = QUrl::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: QQmlIncubationController * QQmlEngine::incubationController();
impl /*struct*/ QQmlEngine {
pub fn incubationController<RetType, T: QQmlEngine_incubationController<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.incubationController(self);
// return 1;
}
}
pub trait QQmlEngine_incubationController<RetType> {
fn incubationController(self , rsthis: & QQmlEngine) -> RetType;
}
// proto: QQmlIncubationController * QQmlEngine::incubationController();
impl<'a> /*trait*/ QQmlEngine_incubationController<QQmlIncubationController> for () {
fn incubationController(self , rsthis: & QQmlEngine) -> QQmlIncubationController {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK10QQmlEngine20incubationControllerEv()};
let mut ret = unsafe {_ZNK10QQmlEngine20incubationControllerEv(rsthis.qclsinst)};
let mut ret1 = QQmlIncubationController::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: static QQmlContext * QQmlEngine::contextForObject(const QObject * );
impl /*struct*/ QQmlEngine {
pub fn contextForObject_s<RetType, T: QQmlEngine_contextForObject_s<RetType>>( overload_args: T) -> RetType {
return overload_args.contextForObject_s();
// return 1;
}
}
pub trait QQmlEngine_contextForObject_s<RetType> {
fn contextForObject_s(self ) -> RetType;
}
// proto: static QQmlContext * QQmlEngine::contextForObject(const QObject * );
impl<'a> /*trait*/ QQmlEngine_contextForObject_s<QQmlContext> for (&'a QObject) {
fn contextForObject_s(self ) -> QQmlContext {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN10QQmlEngine16contextForObjectEPK7QObject()};
let arg0 = self.qclsinst as *mut c_void;
let mut ret = unsafe {_ZN10QQmlEngine16contextForObjectEPK7QObject(arg0)};
let mut ret1 = QQmlContext::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: QQmlNetworkAccessManagerFactory * QQmlEngine::networkAccessManagerFactory();
impl /*struct*/ QQmlEngine {
pub fn networkAccessManagerFactory<RetType, T: QQmlEngine_networkAccessManagerFactory<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.networkAccessManagerFactory(self);
// return 1;
}
}
pub trait QQmlEngine_networkAccessManagerFactory<RetType> {
fn networkAccessManagerFactory(self , rsthis: & QQmlEngine) -> RetType;
}
// proto: QQmlNetworkAccessManagerFactory * QQmlEngine::networkAccessManagerFactory();
impl<'a> /*trait*/ QQmlEngine_networkAccessManagerFactory<QQmlNetworkAccessManagerFactory> for () {
fn networkAccessManagerFactory(self , rsthis: & QQmlEngine) -> QQmlNetworkAccessManagerFactory {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK10QQmlEngine27networkAccessManagerFactoryEv()};
let mut ret = unsafe {_ZNK10QQmlEngine27networkAccessManagerFactoryEv(rsthis.qclsinst)};
let mut ret1 = QQmlNetworkAccessManagerFactory::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: QStringList QQmlEngine::pluginPathList();
impl /*struct*/ QQmlEngine {
pub fn pluginPathList<RetType, T: QQmlEngine_pluginPathList<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.pluginPathList(self);
// return 1;
}
}
pub trait QQmlEngine_pluginPathList<RetType> {
fn pluginPathList(self , rsthis: & QQmlEngine) -> RetType;
}
// proto: QStringList QQmlEngine::pluginPathList();
impl<'a> /*trait*/ QQmlEngine_pluginPathList<()> for () {
fn pluginPathList(self , rsthis: & QQmlEngine) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK10QQmlEngine14pluginPathListEv()};
unsafe {_ZNK10QQmlEngine14pluginPathListEv(rsthis.qclsinst)};
// return 1;
}
}
// proto: const QMetaObject * QQmlEngine::metaObject();
impl /*struct*/ QQmlEngine {
pub fn metaObject<RetType, T: QQmlEngine_metaObject<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.metaObject(self);
// return 1;
}
}
pub trait QQmlEngine_metaObject<RetType> {
fn metaObject(self , rsthis: & QQmlEngine) -> RetType;
}
// proto: const QMetaObject * QQmlEngine::metaObject();
impl<'a> /*trait*/ QQmlEngine_metaObject<()> for () {
fn metaObject(self , rsthis: & QQmlEngine) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK10QQmlEngine10metaObjectEv()};
unsafe {_ZNK10QQmlEngine10metaObjectEv(rsthis.qclsinst)};
// return 1;
}
}
// proto: void QQmlEngine::setOutputWarningsToStandardError(bool );
impl /*struct*/ QQmlEngine {
pub fn setOutputWarningsToStandardError<RetType, T: QQmlEngine_setOutputWarningsToStandardError<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setOutputWarningsToStandardError(self);
// return 1;
}
}
pub trait QQmlEngine_setOutputWarningsToStandardError<RetType> {
fn setOutputWarningsToStandardError(self , rsthis: & QQmlEngine) -> RetType;
}
// proto: void QQmlEngine::setOutputWarningsToStandardError(bool );
impl<'a> /*trait*/ QQmlEngine_setOutputWarningsToStandardError<()> for (i8) {
fn setOutputWarningsToStandardError(self , rsthis: & QQmlEngine) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN10QQmlEngine32setOutputWarningsToStandardErrorEb()};
let arg0 = self as c_char;
unsafe {_ZN10QQmlEngine32setOutputWarningsToStandardErrorEb(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QQmlEngine::clearComponentCache();
impl /*struct*/ QQmlEngine {
pub fn clearComponentCache<RetType, T: QQmlEngine_clearComponentCache<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.clearComponentCache(self);
// return 1;
}
}
pub trait QQmlEngine_clearComponentCache<RetType> {
fn clearComponentCache(self , rsthis: & QQmlEngine) -> RetType;
}
// proto: void QQmlEngine::clearComponentCache();
impl<'a> /*trait*/ QQmlEngine_clearComponentCache<()> for () {
fn clearComponentCache(self , rsthis: & QQmlEngine) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN10QQmlEngine19clearComponentCacheEv()};
unsafe {_ZN10QQmlEngine19clearComponentCacheEv(rsthis.qclsinst)};
// return 1;
}
}
impl /*struct*/ QQmlImageProviderBase {
pub fn inheritFrom(qthis: u64 /* *mut c_void*/) -> QQmlImageProviderBase {
return QQmlImageProviderBase{qclsinst: qthis, ..Default::default()};
}
}
// proto: void QQmlImageProviderBase::QQmlImageProviderBase();
impl /*struct*/ QQmlImageProviderBase {
pub fn new<T: QQmlImageProviderBase_new>(value: T) -> QQmlImageProviderBase {
let rsthis = value.new();
return rsthis;
// return 1;
}
}
pub trait QQmlImageProviderBase_new {
fn new(self) -> QQmlImageProviderBase;
}
// proto: void QQmlImageProviderBase::QQmlImageProviderBase();
impl<'a> /*trait*/ QQmlImageProviderBase_new for () {
fn new(self) -> QQmlImageProviderBase {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN21QQmlImageProviderBaseC2Ev()};
let ctysz: c_int = unsafe{QQmlImageProviderBase_Class_Size()};
let qthis_ph: u64 = unsafe{calloc(1, ctysz as usize)} as u64;
unsafe {_ZN21QQmlImageProviderBaseC2Ev(qthis_ph)};
let qthis: u64 = qthis_ph;
let rsthis = QQmlImageProviderBase{qclsinst: qthis, ..Default::default()};
return rsthis;
// return 1;
}
}
// proto: void QQmlImageProviderBase::~QQmlImageProviderBase();
impl /*struct*/ QQmlImageProviderBase {
pub fn free<RetType, T: QQmlImageProviderBase_free<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.free(self);
// return 1;
}
}
pub trait QQmlImageProviderBase_free<RetType> {
fn free(self , rsthis: & QQmlImageProviderBase) -> RetType;
}
// proto: void QQmlImageProviderBase::~QQmlImageProviderBase();
impl<'a> /*trait*/ QQmlImageProviderBase_free<()> for () {
fn free(self , rsthis: & QQmlImageProviderBase) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN21QQmlImageProviderBaseD2Ev()};
unsafe {_ZN21QQmlImageProviderBaseD2Ev(rsthis.qclsinst)};
// return 1;
}
}
#[derive(Default)] // for QQmlEngine_quit
pub struct QQmlEngine_quit_signal{poi:u64}
impl /* struct */ QQmlEngine {
pub fn quit(&self) -> QQmlEngine_quit_signal {
return QQmlEngine_quit_signal{poi:self.qclsinst};
}
}
impl /* struct */ QQmlEngine_quit_signal {
pub fn connect<T: QQmlEngine_quit_signal_connect>(self, overload_args: T) {
overload_args.connect(self);
}
}
pub trait QQmlEngine_quit_signal_connect {
fn connect(self, sigthis: QQmlEngine_quit_signal);
}
#[derive(Default)] // for QQmlEngine_warnings
pub struct QQmlEngine_warnings_signal{poi:u64}
impl /* struct */ QQmlEngine {
pub fn warnings(&self) -> QQmlEngine_warnings_signal {
return QQmlEngine_warnings_signal{poi:self.qclsinst};
}
}
impl /* struct */ QQmlEngine_warnings_signal {
pub fn connect<T: QQmlEngine_warnings_signal_connect>(self, overload_args: T) {
overload_args.connect(self);
}
}
pub trait QQmlEngine_warnings_signal_connect {
fn connect(self, sigthis: QQmlEngine_warnings_signal);
}
// quit()
extern fn QQmlEngine_quit_signal_connect_cb_0(rsfptr:fn(), ) {
println!("{}:{}", file!(), line!());
rsfptr();
}
extern fn QQmlEngine_quit_signal_connect_cb_box_0(rsfptr_raw:*mut Box<Fn()>, ) {
println!("{}:{}", file!(), line!());
let rsfptr = unsafe{Box::from_raw(rsfptr_raw)};
// rsfptr();
unsafe{(*rsfptr_raw)()};
}
impl /* trait */ QQmlEngine_quit_signal_connect for fn() {
fn connect(self, sigthis: QQmlEngine_quit_signal) {
// do smth...
// self as u64; // error for Fn, Ok for fn
self as *mut c_void as u64;
self as *mut c_void;
let arg0 = sigthis.poi as *mut c_void;
let arg1 = QQmlEngine_quit_signal_connect_cb_0 as *mut c_void;
let arg2 = self as *mut c_void;
unsafe {QQmlEngine_SlotProxy_connect__ZN10QQmlEngine4quitEv(arg0, arg1, arg2)};
}
}
impl /* trait */ QQmlEngine_quit_signal_connect for Box<Fn()> {
fn connect(self, sigthis: QQmlEngine_quit_signal) {
// do smth...
// Box::into_raw(self) as u64;
// Box::into_raw(self) as *mut c_void;
let arg0 = sigthis.poi as *mut c_void;
let arg1 = QQmlEngine_quit_signal_connect_cb_box_0 as *mut c_void;
let arg2 = Box::into_raw(Box::new(self)) as *mut c_void;
unsafe {QQmlEngine_SlotProxy_connect__ZN10QQmlEngine4quitEv(arg0, arg1, arg2)};
}
}
// <= body block end
|
use std::{io, fmt, path::Path, process::{self, Command}};
use colored::*;
// Define our error types. These may be customized for our error handling cases.
// Now we will be able to write our own errors, defer to an underlying error
// implementation, or do something in between.
#[derive(Debug)]
pub enum Error {
Io(io::Error),
Process(ProcessError),
}
#[derive(Debug)]
pub struct ProcessError {
output: process::Output,
command: Vec<String>,
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match &self {
Self::Io(e) => e.fmt(f),
Self::Process(e) => {
write!(
f,
"{} {}\n{} {:?}\n{} {}\n{} {}\n",
"process exited with exit code".red(),
e.output.status.to_string().red().bold(),
"Command:".bold(),
e.command,
"Stdout:".bold(),
String::from_utf8_lossy(&e.output.stdout),
"Stderr:".bold(),
String::from_utf8_lossy(&e.output.stderr),
)
}
}
}
}
impl From<io::Error> for Error {
fn from(e: io::Error) -> Self {
Self::Io(e)
}
}
impl std::error::Error for Error {
}
/// Run a git command with the given arguments in the current directory.
pub fn git_cwd(args: &[&str]) -> Result<process::Output, Error> {
git_internal(args, None)
}
/// Run a git command with the given arguments in the given directory.
pub fn git(args: &[&str], working_dir: &Path) -> Result<process::Output, Error> {
git_internal(args, Some(working_dir))
}
pub fn git_internal(args: &[&str], working_dir: Option<&Path>) -> Result<process::Output, Error> {
// eprintln!("{} $ {} {}", working_dir.unwrap_or(Path::new("")).to_string_lossy(), "git".bold(), args.join(" ").bold());
let mut command = Command::new("git");
if let Some(working_dir) = working_dir {
command.current_dir(working_dir);
}
let output = command
.args(args)
.output()?;
if !output.status.success() {
return Err(Error::Process(ProcessError {
output,
command: std::iter::once(&"git").chain(args.iter()).map(|&s| s.to_owned()).collect(),
}));
}
Ok(output)
}
|
use crate::{
container::Vec8,
error::{ProtoErrorKind, ProtoErrorResultExt, Result},
message::EdgeRect,
serialization::{Decode, Encode},
};
use byteorder::ReadBytesExt;
use core::mem;
use num_derive::FromPrimitive;
use std::io::{Cursor, Seek, SeekFrom, Write};
__flags_struct! {
SurfaceResponseFlags: u8 => {
failure = FAILURE = 0x80,
}
}
#[derive(Encode, Decode, FromPrimitive, Debug, PartialEq, Clone, Copy)]
#[repr(u8)]
pub enum SurfaceMessageType {
ListReq = 0x01,
ListRsp = 0x02,
MapReq = 0x03,
MapRsp = 0x04,
SelectReq = 0x05,
SelectRsp = 0x06,
}
// NOW_SURFACE_DEF
__flags_struct! {
SurfacePropertiesFlags: u16 => {
primary = PRIMARY = 0x0001,
mirrored = MIRRORED = 0x0002,
disabled = DISABLED = 0x0004,
selected = SELECTED = 0x0008,
}
}
impl Default for SurfacePropertiesFlags {
fn default() -> Self {
Self {
value: SurfacePropertiesFlags::SELECTED | SurfacePropertiesFlags::PRIMARY,
}
}
}
#[derive(Encode, Decode, FromPrimitive, Debug, PartialEq, Clone, Copy)]
#[repr(u16)]
pub enum SurfaceOrientation {
Landscape = 0,
Portrait = 90,
LandscapeFlipped = 180,
PortraitFlipped = 270,
}
#[derive(Debug, Clone, Encode, Decode)]
pub struct NowSurfaceDef {
size: u16,
pub flags: SurfacePropertiesFlags,
pub surface_id: u16,
pub orientation: SurfaceOrientation,
pub rect: EdgeRect,
// unused fields
#[decode_ignore]
#[encode_ignore]
dpi_x: u16,
#[decode_ignore]
#[encode_ignore]
dpi_y: u16,
#[decode_ignore]
#[encode_ignore]
pct_scale_x: u16,
#[decode_ignore]
#[encode_ignore]
pct_scale_y: u16,
#[decode_ignore]
#[encode_ignore]
native_rect: EdgeRect,
}
impl NowSurfaceDef {
pub const REQUIRED_SIZE: usize = 16;
pub fn new(surface_id: u16, rect: EdgeRect) -> Self {
Self {
size: Self::REQUIRED_SIZE as u16,
flags: SurfacePropertiesFlags::default(),
surface_id,
orientation: SurfaceOrientation::Landscape,
rect,
dpi_x: 0,
dpi_y: 0,
pct_scale_x: 0,
pct_scale_y: 0,
native_rect: EdgeRect::default(),
}
}
pub fn flags<F: Into<SurfacePropertiesFlags>>(self, flags: F) -> Self {
Self {
flags: flags.into(),
..self
}
}
pub fn orientation<O: Into<SurfaceOrientation>>(self, orientation: O) -> Self {
Self {
orientation: orientation.into(),
..self
}
}
}
// NOW_SURFACE_MAP
#[derive(Debug, Clone, Encode, Decode)]
pub struct NowSurfaceMap {
size: u16,
flags: u16,
pub surface_id: u16,
pub output_id: u16,
pub output_rect: EdgeRect,
}
impl NowSurfaceMap {
pub const REQUIRED_SIZE: usize = mem::size_of::<Self>();
pub fn new(surface_id: u16, output_id: u16, output_rect: EdgeRect) -> Self {
Self {
size: Self::REQUIRED_SIZE as u16,
flags: 0,
surface_id,
output_id,
output_rect,
}
}
}
// NOW_SURFACE_MSG
#[derive(Debug, Clone)]
pub enum NowSurfaceMsg {
ListReq(NowSurfaceListReqMsg),
ListRsp(NowSurfaceListRspMsg),
MapReq(NowSurfaceMapReqMsg),
MapRsp(NowSurfaceMapRspMsg),
SelectReq(NowSurfaceSelectReqMsg),
SelectRsp(NowSurfaceSelectRspMsg),
}
impl Encode for NowSurfaceMsg {
fn encoded_len(&self) -> usize {
match self {
NowSurfaceMsg::ListReq(msg) => msg.encoded_len(),
NowSurfaceMsg::ListRsp(msg) => msg.encoded_len(),
NowSurfaceMsg::MapReq(msg) => msg.encoded_len(),
NowSurfaceMsg::MapRsp(msg) => msg.encoded_len(),
NowSurfaceMsg::SelectReq(msg) => msg.encoded_len(),
NowSurfaceMsg::SelectRsp(msg) => msg.encoded_len(),
}
}
fn encode_into<W: Write>(&self, writer: &mut W) -> Result<()> {
match self {
NowSurfaceMsg::ListReq(msg) => msg
.encode_into(writer)
.chain(ProtoErrorKind::Encoding(stringify!(NowSurfaceMsg)))
.or_desc("couldn't encode list request message"),
NowSurfaceMsg::ListRsp(msg) => msg
.encode_into(writer)
.chain(ProtoErrorKind::Encoding(stringify!(NowSurfaceMsg)))
.or_desc("couldn't encode list response message"),
NowSurfaceMsg::MapReq(msg) => msg
.encode_into(writer)
.chain(ProtoErrorKind::Encoding(stringify!(NowSurfaceMsg)))
.or_desc("couldn't encode map request message"),
NowSurfaceMsg::MapRsp(msg) => msg
.encode_into(writer)
.chain(ProtoErrorKind::Encoding(stringify!(NowSurfaceMsg)))
.or_desc("couldn't encode map response message"),
NowSurfaceMsg::SelectReq(msg) => msg
.encode_into(writer)
.chain(ProtoErrorKind::Encoding(stringify!(NowSurfaceMsg)))
.or_desc("couldn't encode select request message"),
NowSurfaceMsg::SelectRsp(msg) => msg
.encode_into(writer)
.chain(ProtoErrorKind::Encoding(stringify!(NowSurfaceMsg)))
.or_desc("couldn't encode select response message"),
}
}
}
impl Decode<'_> for NowSurfaceMsg {
fn decode_from(cursor: &mut Cursor<&[u8]>) -> Result<Self> {
let subtype = num::FromPrimitive::from_u8(cursor.read_u8()?)
.chain(ProtoErrorKind::Decoding(stringify!(NowSurfaceMsg)))
.or_desc("invalid subtype")?;
cursor.seek(SeekFrom::Current(-1)).unwrap(); // cannot fail
match subtype {
SurfaceMessageType::ListReq => NowSurfaceListReqMsg::decode_from(cursor)
.map(Self::ListReq)
.chain(ProtoErrorKind::Decoding(stringify!(NowSurfaceMsg)))
.or_desc("invalid list request message"),
SurfaceMessageType::ListRsp => NowSurfaceListRspMsg::decode_from(cursor)
.map(Self::ListRsp)
.chain(ProtoErrorKind::Decoding(stringify!(NowSurfaceMsg)))
.or_desc("invalid list response message"),
SurfaceMessageType::MapReq => NowSurfaceMapReqMsg::decode_from(cursor)
.map(Self::MapReq)
.chain(ProtoErrorKind::Decoding(stringify!(NowSurfaceMsg)))
.or_desc("invalid map request message"),
SurfaceMessageType::MapRsp => NowSurfaceMapRspMsg::decode_from(cursor)
.map(Self::MapRsp)
.chain(ProtoErrorKind::Decoding(stringify!(NowSurfaceMsg)))
.or_desc("invalid map response message"),
SurfaceMessageType::SelectReq => NowSurfaceSelectReqMsg::decode_from(cursor)
.map(Self::SelectReq)
.chain(ProtoErrorKind::Decoding(stringify!(NowSurfaceMsg)))
.or_desc("invalid select request message"),
SurfaceMessageType::SelectRsp => NowSurfaceSelectRspMsg::decode_from(cursor)
.map(Self::SelectRsp)
.chain(ProtoErrorKind::Decoding(stringify!(NowSurfaceMsg)))
.or_desc("invalid select response message"),
}
}
}
impl From<NowSurfaceListReqMsg> for NowSurfaceMsg {
fn from(msg: NowSurfaceListReqMsg) -> Self {
Self::ListReq(msg)
}
}
impl From<NowSurfaceListRspMsg> for NowSurfaceMsg {
fn from(msg: NowSurfaceListRspMsg) -> Self {
Self::ListRsp(msg)
}
}
impl From<NowSurfaceMapReqMsg> for NowSurfaceMsg {
fn from(msg: NowSurfaceMapReqMsg) -> Self {
Self::MapReq(msg)
}
}
impl From<NowSurfaceMapRspMsg> for NowSurfaceMsg {
fn from(msg: NowSurfaceMapRspMsg) -> Self {
Self::MapRsp(msg)
}
}
impl From<NowSurfaceSelectReqMsg> for NowSurfaceMsg {
fn from(msg: NowSurfaceSelectReqMsg) -> Self {
Self::SelectReq(msg)
}
}
impl From<NowSurfaceSelectRspMsg> for NowSurfaceMsg {
fn from(msg: NowSurfaceSelectRspMsg) -> Self {
Self::SelectRsp(msg)
}
}
// subtypes
#[derive(Encode, Decode, Debug, Clone)]
pub struct NowSurfaceListReqMsg {
subtype: SurfaceMessageType,
flags: u8,
pub sequence_id: u16,
pub desktop_width: u16,
pub desktop_height: u16,
pub surfaces: Vec8<NowSurfaceDef>,
}
impl NowSurfaceListReqMsg {
pub const SUBTYPE: SurfaceMessageType = SurfaceMessageType::ListReq;
pub const REQUIRED_SIZE: usize = 9;
pub fn new(sequence_id: u16, desktop_width: u16, desktop_height: u16) -> Self {
Self::new_with_surfaces(sequence_id, desktop_width, desktop_height, Vec::new())
}
pub fn new_with_surfaces(
sequence_id: u16,
desktop_width: u16,
desktop_height: u16,
surfaces: Vec<NowSurfaceDef>,
) -> Self {
Self {
subtype: SurfaceMessageType::ListReq,
flags: 0,
sequence_id,
desktop_width,
desktop_height,
surfaces: Vec8(surfaces),
}
}
}
#[derive(Encode, Decode, Debug, Clone)]
pub struct NowSurfaceListRspMsg {
subtype: SurfaceMessageType,
pub flags: SurfaceResponseFlags,
pub sequence_id: u16,
}
impl NowSurfaceListRspMsg {
pub const SUBTYPE: SurfaceMessageType = SurfaceMessageType::ListRsp;
pub fn new(flags: SurfaceResponseFlags, sequence_id: u16) -> Self {
Self {
subtype: Self::SUBTYPE,
flags,
sequence_id,
}
}
}
#[derive(Encode, Decode, Debug, Clone)]
pub struct NowSurfaceMapReqMsg {
subtype: SurfaceMessageType,
pub flags: u8, // TODO: find flags values
pub sequence_id: u16,
pub desktop_width: u16,
pub desktop_height: u16,
pub maps: Vec8<NowSurfaceMap>,
}
impl NowSurfaceMapReqMsg {
pub const SUBTYPE: SurfaceMessageType = SurfaceMessageType::MapReq;
pub const REQUIRED_SIZE: usize = 9;
pub fn new(sequence_id: u16, desktop_width: u16, desktop_height: u16) -> Self {
Self::new_with_mappings(sequence_id, desktop_width, desktop_height, Vec::new())
}
pub fn new_with_mappings(
sequence_id: u16,
desktop_width: u16,
desktop_height: u16,
maps: Vec<NowSurfaceMap>,
) -> Self {
Self {
subtype: SurfaceMessageType::ListReq,
flags: 0,
sequence_id,
desktop_width,
desktop_height,
maps: Vec8(maps),
}
}
}
#[derive(Debug, Clone, Encode, Decode)]
pub struct NowSurfaceMapRspMsg {
subtype: SurfaceMessageType,
pub flags: SurfaceResponseFlags,
pub sequence_id: u16,
}
impl NowSurfaceMapRspMsg {
pub const SUBTYPE: SurfaceMessageType = SurfaceMessageType::MapRsp;
pub fn new(flags: SurfaceResponseFlags, sequence_id: u16) -> Self {
Self {
subtype: Self::SUBTYPE,
flags,
sequence_id,
}
}
}
#[derive(Debug, Clone, Decode, Encode)]
pub struct NowSurfaceSelectReqMsg {
subtype: SurfaceMessageType,
pub flags: u8, // TODO: find flags values
pub sequence_id: u16,
reserved: u16,
pub surface_id: u16,
}
impl NowSurfaceSelectReqMsg {
pub const SUBTYPE: SurfaceMessageType = SurfaceMessageType::SelectReq;
pub fn new(flags: u8, sequence_id: u16, surface_id: u16) -> Self {
Self {
subtype: Self::SUBTYPE,
flags,
sequence_id,
reserved: 0,
surface_id,
}
}
}
#[derive(Debug, Clone, Decode, Encode)]
pub struct NowSurfaceSelectRspMsg {
subtype: SurfaceMessageType,
pub flags: SurfaceResponseFlags,
pub sequence_id: u16,
}
impl NowSurfaceSelectRspMsg {
pub const SUBTYPE: SurfaceMessageType = SurfaceMessageType::SelectRsp;
pub fn new(flags: SurfaceResponseFlags, sequence_id: u16) -> Self {
Self {
subtype: Self::SUBTYPE,
flags,
sequence_id,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[rustfmt::skip]
const SURFACE_LIST_REQ_MSG: [u8; 25] = [
0x01, // subtype
0x00, // flags
0x00, 0x00, // sequence id
0x00, 0x04, // desktop width
0x00, 0x03, // desktop height
0x01, // surface count
// surface(s)
0x10, 0x00, // size
0x09, 0x00, // flags
0x00, 0x00, // surface id
0x00, 0x00, // orientation
0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x03, // rect
];
#[test]
fn decoding_with_subtype_check() {
let msg = NowSurfaceMsg::decode(&SURFACE_LIST_REQ_MSG).unwrap();
if let NowSurfaceMsg::ListReq(msg) = msg {
assert_eq!(msg.subtype, SurfaceMessageType::ListReq);
assert_eq!(msg.sequence_id, 0);
assert_eq!(msg.desktop_width, 1024);
assert_eq!(msg.desktop_height, 768);
assert_eq!(msg.surfaces.len(), 1);
let surface = &msg.surfaces[0];
assert_eq!(surface.size, 16);
assert_eq!(surface.flags, SurfacePropertiesFlags::default());
assert_eq!(surface.surface_id, 0);
assert_eq!(surface.orientation, SurfaceOrientation::Landscape);
let rect = &surface.rect;
assert_eq!(rect.left, 0);
assert_eq!(rect.top, 0);
assert_eq!(rect.right, 1024);
assert_eq!(rect.bottom, 768);
} else {
panic!("expected a surface list req message and got {:?}", msg);
}
}
#[test]
fn list_req_encoding() {
let rect = EdgeRect {
left: 0,
top: 0,
right: 1024,
bottom: 768,
};
let surface = NowSurfaceDef::new(0, rect);
let msg = NowSurfaceListReqMsg::new_with_surfaces(0, 1024, 768, vec![surface]);
assert_eq!(msg.encode().unwrap(), SURFACE_LIST_REQ_MSG.to_vec());
}
// TODO: test NowSurfaceMapReqMsg
}
|
// This file is part of linux-epoll. It is subject to the license terms in the COPYRIGHT file found in the top-level directory of this distribution and at https://raw.githubusercontent.com/lemonrock/linux-epoll/master/COPYRIGHT. No part of linux-epoll, including this file, may be copied, modified, propagated, or distributed except according to the terms contained in the COPYRIGHT file.
// Copyright © 2019 The developers of linux-epoll. See the COPYRIGHT file in the top-level directory of this distribution and at https://raw.githubusercontent.com/lemonrock/linux-epoll/master/COPYRIGHT.
pub(crate) enum AnswerOutcome
{
Answered,
/// There is no answer, although a complete `CNAME` chain or `DNAME` record might be present.
///
/// RFC 2308 Section 2.1: "Where no CNAME records appear, the NXDOMAIN response refers to the name in the label of the RR in the question section".
///
/// RFC 2308, Section 5: "A negative answer that resulted from a name error (NXDOMAIN) should be cached such that it can be retrieved and returned in response to another query for the same <QNAME, QCLASS> that resulted in the cached negative response.
///
/// For us, this means caching a negative response against the `QNAME` unary tuple for the last resolved name in the `CNAME` chain.
NameError(NegativeCachingTimeToLiveInSeconds),
/// There is no answer, although a complete `CNAME` chain or `DNAME` record might be present.
///
/// RFC 2308 Section 2.2: " ... in which case it would be the value of the last CNAME (the QNAME) for which NODATA would be concluded".
///
/// RFC 2308, Section 5: "A negative answer that resulted from a no data error (NODATA) should be cached such that it can be retrieved and returned in response to another query for the same <QNAME, QTYPE, QCLASS> that resulted in the cached negative response".
///
/// For us, this means caching a negative response against the `QNAME, QTYPE` binary tuple for the last resolved name in the `CNAME` chain.
NoData(NegativeCachingTimeToLiveInSeconds),
/// There is no answer, although a partial `CNAME` chain or `DNAME` record might be present.
///
/// We can opt to chase this, or we can just give up.
Referral,
}
|
// Copyright 2020 - 2021 Alex Dukhno
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use super::*;
#[rstest::rstest]
fn select_from_not_existed_table(database_with_schema: (InMemory, ResultCollector)) {
let (mut engine, collector) = database_with_schema;
engine
.execute(Inbound::Query {
sql: "select * from schema_name.non_existent;".to_owned(),
})
.expect("query executed");
collector
.lock()
.unwrap()
.assert_receive_single(Err(QueryError::table_does_not_exist("schema_name.non_existent")));
}
#[rstest::rstest]
fn select_named_columns_from_non_existent_table(database_with_schema: (InMemory, ResultCollector)) {
let (mut engine, collector) = database_with_schema;
engine
.execute(Inbound::Query {
sql: "select column_1 from schema_name.non_existent;".to_owned(),
})
.expect("query executed");
collector
.lock()
.unwrap()
.assert_receive_single(Err(QueryError::table_does_not_exist("schema_name.non_existent")));
}
#[rstest::rstest]
fn select_all_from_table_with_multiple_columns(database_with_schema: (InMemory, ResultCollector)) {
let (mut engine, collector) = database_with_schema;
engine
.execute(Inbound::Query {
sql: "create table schema_name.table_name (column_1 smallint, column_2 smallint, column_3 smallint);"
.to_owned(),
})
.expect("query executed");
collector
.lock()
.unwrap()
.assert_receive_single(Ok(QueryEvent::TableCreated));
engine
.execute(Inbound::Query {
sql: "insert into schema_name.table_name values (123, 456, 789);".to_owned(),
})
.expect("query executed");
collector
.lock()
.unwrap()
.assert_receive_single(Ok(QueryEvent::RecordsInserted(1)));
engine
.execute(Inbound::Query {
sql: "select * from schema_name.table_name;".to_owned(),
})
.expect("query executed");
collector.lock().unwrap().assert_receive_many(vec![
Ok(QueryEvent::RowDescription(vec![
("column_1".to_owned(), SMALLINT),
("column_2".to_owned(), SMALLINT),
("column_3".to_owned(), SMALLINT),
])),
Ok(QueryEvent::DataRow(vec![
"123".to_owned(),
"456".to_owned(),
"789".to_owned(),
])),
Ok(QueryEvent::RecordsSelected(1)),
]);
}
#[rstest::rstest]
fn select_not_all_columns(database_with_schema: (InMemory, ResultCollector)) {
let (mut engine, collector) = database_with_schema;
engine
.execute(Inbound::Query {
sql: "create table schema_name.table_name (column_1 smallint, column_2 smallint, column_3 smallint);"
.to_owned(),
})
.expect("query executed");
collector
.lock()
.unwrap()
.assert_receive_single(Ok(QueryEvent::TableCreated));
engine
.execute(Inbound::Query {
sql: "insert into schema_name.table_name values (1, 4, 7), (2, 5, 8), (3, 6, 9);".to_owned(),
})
.expect("query executed");
collector
.lock()
.unwrap()
.assert_receive_single(Ok(QueryEvent::RecordsInserted(3)));
engine
.execute(Inbound::Query {
sql: "select column_3, column_2 from schema_name.table_name;".to_owned(),
})
.expect("query executed");
collector.lock().unwrap().assert_receive_many(vec![
Ok(QueryEvent::RowDescription(vec![
("column_3".to_owned(), SMALLINT),
("column_2".to_owned(), SMALLINT),
])),
Ok(QueryEvent::DataRow(vec!["7".to_owned(), "4".to_owned()])),
Ok(QueryEvent::DataRow(vec!["8".to_owned(), "5".to_owned()])),
Ok(QueryEvent::DataRow(vec!["9".to_owned(), "6".to_owned()])),
Ok(QueryEvent::RecordsSelected(3)),
]);
}
#[rstest::rstest]
fn select_non_existing_columns_from_table(database_with_schema: (InMemory, ResultCollector)) {
let (mut engine, collector) = database_with_schema;
engine
.execute(Inbound::Query {
sql: "create table schema_name.table_name (column_in_table smallint);".to_owned(),
})
.expect("query executed");
collector
.lock()
.unwrap()
.assert_receive_single(Ok(QueryEvent::TableCreated));
engine
.execute(Inbound::Query {
sql: "select column_not_in_table1, column_not_in_table2 from schema_name.table_name;".to_owned(),
})
.expect("query executed");
collector
.lock()
.unwrap()
.assert_receive_many(vec![Err(QueryError::column_does_not_exist("column_not_in_table1"))]);
}
#[rstest::rstest]
fn select_first_and_last_columns_from_table_with_multiple_columns(database_with_schema: (InMemory, ResultCollector)) {
let (mut engine, collector) = database_with_schema;
engine
.execute(Inbound::Query {
sql: "create table schema_name.table_name (column_1 smallint, column_2 smallint, column_3 smallint);"
.to_owned(),
})
.expect("query executed");
collector
.lock()
.unwrap()
.assert_receive_single(Ok(QueryEvent::TableCreated));
engine
.execute(Inbound::Query {
sql: "insert into schema_name.table_name values (1, 2, 3), (4, 5, 6), (7, 8, 9);".to_owned(),
})
.expect("query executed");
collector
.lock()
.unwrap()
.assert_receive_single(Ok(QueryEvent::RecordsInserted(3)));
engine
.execute(Inbound::Query {
sql: "select column_3, column_1 from schema_name.table_name;".to_owned(),
})
.expect("query executed");
collector.lock().unwrap().assert_receive_many(vec![
Ok(QueryEvent::RowDescription(vec![
("column_3".to_owned(), SMALLINT),
("column_1".to_owned(), SMALLINT),
])),
Ok(QueryEvent::DataRow(vec!["3".to_owned(), "1".to_owned()])),
Ok(QueryEvent::DataRow(vec!["6".to_owned(), "4".to_owned()])),
Ok(QueryEvent::DataRow(vec!["9".to_owned(), "7".to_owned()])),
Ok(QueryEvent::RecordsSelected(3)),
]);
}
#[rstest::rstest]
fn select_all_columns_reordered_from_table_with_multiple_columns(database_with_schema: (InMemory, ResultCollector)) {
let (mut engine, collector) = database_with_schema;
engine
.execute(Inbound::Query {
sql: "create table schema_name.table_name (column_1 smallint, column_2 smallint, column_3 smallint);"
.to_owned(),
})
.expect("query executed");
collector
.lock()
.unwrap()
.assert_receive_single(Ok(QueryEvent::TableCreated));
engine
.execute(Inbound::Query {
sql: "insert into schema_name.table_name values (1, 2, 3), (4, 5, 6), (7, 8, 9);".to_owned(),
})
.expect("query executed");
collector
.lock()
.unwrap()
.assert_receive_single(Ok(QueryEvent::RecordsInserted(3)));
engine
.execute(Inbound::Query {
sql: "select column_3, column_1, column_2 from schema_name.table_name;".to_owned(),
})
.expect("query executed");
collector.lock().unwrap().assert_receive_many(vec![
Ok(QueryEvent::RowDescription(vec![
("column_3".to_owned(), SMALLINT),
("column_1".to_owned(), SMALLINT),
("column_2".to_owned(), SMALLINT),
])),
Ok(QueryEvent::DataRow(vec![
"3".to_owned(),
"1".to_owned(),
"2".to_owned(),
])),
Ok(QueryEvent::DataRow(vec![
"6".to_owned(),
"4".to_owned(),
"5".to_owned(),
])),
Ok(QueryEvent::DataRow(vec![
"9".to_owned(),
"7".to_owned(),
"8".to_owned(),
])),
Ok(QueryEvent::RecordsSelected(3)),
]);
}
#[rstest::rstest]
fn select_with_column_name_duplication(database_with_schema: (InMemory, ResultCollector)) {
let (mut engine, collector) = database_with_schema;
engine
.execute(Inbound::Query {
sql: "create table schema_name.table_name (column_1 smallint, column_2 smallint, column_3 smallint);"
.to_owned(),
})
.expect("query executed");
collector
.lock()
.unwrap()
.assert_receive_single(Ok(QueryEvent::TableCreated));
engine
.execute(Inbound::Query {
sql: "insert into schema_name.table_name values (1, 2, 3), (4, 5, 6), (7, 8, 9);".to_owned(),
})
.expect("query executed");
collector
.lock()
.unwrap()
.assert_receive_single(Ok(QueryEvent::RecordsInserted(3)));
engine
.execute(Inbound::Query {
sql: "select column_3, column_2, column_1, column_3, column_2 from schema_name.table_name;".to_owned(),
})
.expect("query executed");
collector.lock().unwrap().assert_receive_many(vec![
Ok(QueryEvent::RowDescription(vec![
("column_3".to_owned(), SMALLINT),
("column_2".to_owned(), SMALLINT),
("column_1".to_owned(), SMALLINT),
("column_3".to_owned(), SMALLINT),
("column_2".to_owned(), SMALLINT),
])),
Ok(QueryEvent::DataRow(vec![
"3".to_owned(),
"2".to_owned(),
"1".to_owned(),
"3".to_owned(),
"2".to_owned(),
])),
Ok(QueryEvent::DataRow(vec![
"6".to_owned(),
"5".to_owned(),
"4".to_owned(),
"6".to_owned(),
"5".to_owned(),
])),
Ok(QueryEvent::DataRow(vec![
"9".to_owned(),
"8".to_owned(),
"7".to_owned(),
"9".to_owned(),
"8".to_owned(),
])),
Ok(QueryEvent::RecordsSelected(3)),
]);
}
#[rstest::rstest]
fn select_different_integer_types(database_with_schema: (InMemory, ResultCollector)) {
let (mut engine, collector) = database_with_schema;
engine
.execute(Inbound::Query {
sql: "create table schema_name.table_name (column_si smallint, column_i integer, column_bi bigint);"
.to_owned(),
})
.expect("query executed");
collector
.lock()
.unwrap()
.assert_receive_single(Ok(QueryEvent::TableCreated));
engine
.execute(Inbound::Query { sql: "insert into schema_name.table_name values (1000, 2000000, 3000000000), (4000, 5000000, 6000000000), (7000, 8000000, 9000000000);".to_owned()}).expect("query executed");
collector
.lock()
.unwrap()
.assert_receive_single(Ok(QueryEvent::RecordsInserted(3)));
engine
.execute(Inbound::Query {
sql: "select * from schema_name.table_name;".to_owned(),
})
.expect("query executed");
collector.lock().unwrap().assert_receive_many(vec![
Ok(QueryEvent::RowDescription(vec![
("column_si".to_owned(), SMALLINT),
("column_i".to_owned(), INT),
("column_bi".to_owned(), BIGINT),
])),
Ok(QueryEvent::DataRow(vec![
"1000".to_owned(),
"2000000".to_owned(),
"3000000000".to_owned(),
])),
Ok(QueryEvent::DataRow(vec![
"4000".to_owned(),
"5000000".to_owned(),
"6000000000".to_owned(),
])),
Ok(QueryEvent::DataRow(vec![
"7000".to_owned(),
"8000000".to_owned(),
"9000000000".to_owned(),
])),
Ok(QueryEvent::RecordsSelected(3)),
]);
}
#[rstest::rstest]
fn select_different_character_strings_types(database_with_schema: (InMemory, ResultCollector)) {
let (mut engine, collector) = database_with_schema;
engine
.execute(Inbound::Query {
sql: "create table schema_name.table_name (char_10 char(10), var_char_20 varchar(20));".to_owned(),
})
.expect("query executed");
collector
.lock()
.unwrap()
.assert_receive_single(Ok(QueryEvent::TableCreated));
engine
.execute(Inbound::Query { sql: "insert into schema_name.table_name values ('1234567890', '12345678901234567890'), ('12345', '1234567890');".to_owned()}).expect("query executed");
collector
.lock()
.unwrap()
.assert_receive_single(Ok(QueryEvent::RecordsInserted(2)));
// TODO: string type is not recognizable on SqlTable level
// engine
// .execute(Request::Query { sql: "insert into schema_name.table_name values ('12345', '1234567890 ');".to_owned()}).expect("query executed");
// collector.lock().unwrap().assert_receive_single(Ok(QueryEvent::RecordsInserted(1)));
engine
.execute(Inbound::Query {
sql: "select * from schema_name.table_name;".to_owned(),
})
.expect("query executed");
collector.lock().unwrap().assert_receive_many(vec![
Ok(QueryEvent::RowDescription(vec![
("char_10".to_owned(), CHAR),
("var_char_20".to_owned(), VARCHAR),
])),
Ok(QueryEvent::DataRow(vec![
"1234567890".to_owned(),
"12345678901234567890".to_owned(),
])),
Ok(QueryEvent::DataRow(vec!["12345".to_owned(), "1234567890".to_owned()])),
// Ok(QueryEvent::DataRow(vec!["12345".to_owned(), "1234567890".to_owned()])),
Ok(QueryEvent::RecordsSelected(2)),
]);
}
|
use std::io::{Read, Write, stdin, stdout};
use llvm::*;
use llvm::Attribute::*;
use llvm::Function;
use parser;
use lexer::Token;
use codegen;
pub fn run(opt_level: usize) {
let context = Context::new();
let module = Module::new("my jit", &context);
let engine = JitEngine::new(&module, JitOptions {
opt_level: opt_level,
}).unwrap();
loop {
let builder = Builder::new(&context);
let mut input = String::new();
print!("> ", );
stdout().flush();
match stdin().read_line(&mut input) {
Ok(_) => (),
Err(_) => break,
}
if input.trim_left() == "" {
continue;
}
if input == "exit\n" {
break;
}
let mut parser = parser::Parser::from_source(&input);
match parser.current {
Some(Token::Define) => {
let func = match parser.parse_definition() {
Ok(func) => func,
Err(e) => {
println!("Error parsing definition: {}", e);
continue;
}
};
codegen::generate_function(&func, &builder, &module, &context).unwrap();
},
Some(Token::Extern) => {
let proto = match parser.parse_extern() {
Ok(proto) => proto,
Err(e) => {
println!("Error parsing extern: {}", e);
continue;
}
};
codegen::generate_prototype(&proto, &module, &context);
},
// Top level expression
_ => {
let expr = parser.parse_top_level_expr().unwrap();
let new_module = module.clone();
let func = codegen::generate_function(&expr, &builder, &new_module, &context).unwrap();
engine.add_module(&new_module);
let res = engine.run_function(&func, &[]);
println!("{}", f64::from_generic(&res, &context));
engine.remove_module(&new_module);
}
}
}
}
|
use parser::debug_pair;
use parser::Function;
use parser::parse_p_eip;
use parser::primitives::parse_constant;
use pest::iterators::Pair;
use std::collections::HashMap;
use super::Constant;
use super::Rule;
pub fn parse_funcall(pair: Pair<Rule>, memory: &HashMap<&str, Constant>, local: Option<&Vec<&str>>) -> Constant {
let inner = pair.clone().into_inner().nth(0).unwrap();
match inner.as_rule() {
Rule::p_sfuncall => {
let fun = parse_constant(inner.clone().into_inner().nth(0).unwrap(), memory);
let args = parse_funcall_args(inner.clone().into_inner().nth(1).unwrap(), memory, local);
match local {
Some(t) => Constant::Function(Function {
args,
argc: t.len(),
base_fn: Some(Box::new(fun)),
implementation: None,
}),
None => run_fn(fun, args)
}
}
Rule::p_iifuncall => panic!(),
_ => unreachable!()
}
}
pub fn parse_fundef(pair: Pair<Rule>, memory: &HashMap<&str, Constant>) -> Constant {
let mut args = vec![];
let mut fun = None;
for inner in pair.into_inner() {
match inner.as_rule() {
Rule::p_funparam => {
for p_funparam_inner in inner.into_inner() {
match p_funparam_inner.as_rule() {
Rule::p_funparam2 => {
for param in p_funparam_inner.into_inner() {
args.push(param.into_span().as_str());
}
},
_ => unreachable!()
}
}
},
Rule::p_eip => {
fun = Some(parse_p_eip_fn(inner, memory, &args));
},
_ => unreachable!()
}
}
fun.unwrap()
}
fn parse_funcall_args(pair: Pair<Rule>, memory: &HashMap<&str, Constant>, local: Option<&Vec<&str>>) -> Vec<Constant> {
let inner = pair.clone().into_inner();
let mut args;
match local {
Some(t) => args = vec![parse_p_eip_fn(inner.clone().nth(0).unwrap(), memory, t)],
None => args = vec![parse_p_eip(inner.clone().nth(0).unwrap(), memory)]
}
if inner.clone().count() > 1 {
args.append(parse_funcall_args(inner.clone().nth(1).unwrap(), memory, local).as_mut());
}
return args;
}
fn parse_p_eip_fn(pair: Pair<Rule>, memory: &HashMap<&str, Constant>, local: &Vec<&str>) -> Constant {
match pair.as_rule() {
Rule::constant => {
let name = pair.clone().into_span().as_str();
let index = local.iter().position(|&r| r == name);
match index {
Some(i) => Constant::Index(i),
None => parse_constant(pair, memory)
}
},
Rule::p_funcall => parse_funcall(pair, memory, Some(local)),
Rule::p_eip => parse_p_eip_fn(pair.into_inner().nth(0).unwrap(), memory, local),
_ => parse_p_eip(pair, memory)
}
}
pub fn run_fn(constant: Constant, args: Vec<Constant>) -> Constant {
match constant {
Constant::Function(fun) => {
let argc = args.len();
let diff = fun.argc - argc;
let new_args: Vec<Constant> = fun.args.into_iter().map(|a| match a {
Constant::Function(f) => run_fn(Constant::Function(f), args.clone()),
Constant::Index(i) => {
let v = args.get(i);
match v {
Some(t) => t.clone(),
None => Constant::Index(i - argc)
}
},
_ => a
}).collect();
if diff == 0 {
match fun.base_fn {
Some(t) => {
run_fn(unbox(t), new_args)
},
None => (fun.implementation.unwrap())(new_args)
}
} else if diff > 0 {
Constant::Function(Function {
args: new_args,
argc: diff,
base_fn: fun.base_fn,
implementation: fun.implementation,
})
} else {
eprintln!("Too many arguments passed.");
panic!()
}
},
_ => {
eprintln!("Tried to call a constant value \"{:?}\" instead of function!", constant);
panic!();
}
}
}
fn unbox<T>(value: Box<T>) -> T {
*value
} |
#![feature(macro_rules)]
extern crate getopts;
use getopts::{optopt,optflag,getopts,OptGroup};
use std::io::{BufferedReader,File};
use std::os;
use std::rand::{sample,task_rng};
macro_rules! random_char {
() => {
random_char("!$%^&*#(){}[];:<>?/|+-")
};
($chars:expr) => {
random_char($chars)
}
}
macro_rules! random_password {
() => {
random_password(16)
};
($len:expr) => {
random_password($len)
}
}
fn random_char(chars: &str) -> char {
let mut rng = task_rng();
sample(&mut rng, chars.chars(), 1)[0]
}
fn random_word(words: &Vec<String>) -> String {
let mut rng = task_rng();
sample(&mut rng, words.iter(), 1)[0].as_slice().trim().to_string()
}
fn random_password(len: uint) -> String {
let chars: &str = "abcdefghjkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789\
!$%^&*#(){}[];:<>?/|+-";
let mut pass = String::new();
for _ in range(0u, len) {
pass.push_char(random_char!(chars));
}
pass
}
#[test]
fn test_random_password_length() {
let pass5 = random_password(5);
let pass10 = random_password(10);
assert!(pass5.len() == 5);
assert!(pass10.len() == 10);
}
#[test]
fn test_random_password_uniqueness() {
let pass1 = random_password(16);
let pass2 = random_password(16);
assert!(pass1 != pass2);
}
fn dictwords_password() -> String {
let mut pass = String::new();
let path = Path::new("/usr/share/dict/words");
let mut file = BufferedReader::new(File::open(&path));
let lines: Vec<String> = file.lines().map(
|x| x.unwrap().replace("'s", "")
).filter(
|x| x.len() > 5 && x.len() <= 10
).collect();
let (tx, rx) = channel();
for _ in range(0u, 2) {
let tx = tx.clone();
let lines = lines.clone();
spawn(proc() {
tx.send(random_word(&lines));
});
}
pass.push_str(rx.recv().as_slice());
pass.push_char(random_char!());
for _ in range(0u, 2) {
pass.push_char(random_char!("0123456789"));
}
pass.push_str(rx.recv().as_slice());
pass
}
#[test]
fn test_dictwords_password_uniqueness() {
let pass1 = dictwords_password();
let pass2 = dictwords_password();
assert!(pass1 != pass2);
}
fn print_usage(program: &str, _opts: &[OptGroup]) {
println!("Usage: {} [options]", program);
println!("-m --mode [random|] \t Password generation mode");
println!(" random - Generate a random string (default length is 16)");
println!(" dictwords - Generate a password of the form ");
println!(" <word><symbol><num><num><word>");
println!("-l --length LENGTH \t Password length (for random generator)");
println!("-h --help \t Usage");
}
fn main() {
let args: Vec<String> = os::args().iter().map(
|x| x.to_string()
).collect();
let program = args[0].clone();
let opts = [
optopt("m", "mode", "mode", ""),
optopt("l", "length", "password length for random generator", "LENGTH"),
optflag("h", "help", "print this help menu")
];
let matches = match getopts(args.tail(), opts) {
Ok(m) => { m }
Err(f) => { fail!("{}", f) }
};
if matches.opt_present("h") {
print_usage(program.as_slice(), opts);
return;
}
match matches.opt_str("m").unwrap_or(String::from_str("random")).as_slice() {
"random" => {
let len_str = match matches.opt_default("l", "16") {
Some(ref s) => { s.to_string() },
None => String::from_str("16"),
};
let len = match from_str::<uint>(len_str.as_slice()) {
Some(n) => { n },
None => {
println!("{} is not a valid length.", len_str);
return;
}
};
let pass = random_password!(len);
println!("{}", pass);
},
"dictwords" => {
let pass = dictwords_password();
println!("{}", pass);
},
m => {
println!("{} is not a valid mode.", m);
}
};
}
|
let dbg_impl = quote! {
type Cb = std::boxed::Box<(dyn std::ops::Fn() + 'static)>;
struct Vars {
repr: Cb,
}
impl Vars {
fn new(f: impl Fn()) -> Self {
let cb = Box::new(f as Fn());
Vars {
repr: cb,
}
}
}
#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
pub struct DebugCollect {
pub args: std::collections::HashMap<String, String>,
}
impl DebugCollect {
pub fn new(s: &str) -> Self {
let d: DebugCollect = serde_json::from_str(s).unwrap();
d
}
pub fn step(&self) -> std::io::Result<String> {
println!("type var name or tab to auto-complete");
fn print_loop(dbg: &DebugCollect) -> std::io::Result<String> {
let mut input = crossterm::input();
let line = input.read_line()?;
if let Some(var) = dbg.args.get(line.as_str()) {
Ok(var.clone())
} else {
println!("could not find variable '{}' in scope", line);
print_loop(&dbg)
}
}
print_loop(&self)
}
fn capature(&mut self, map: Vars) {
}
}
};
|
mod common;
use common::{spawn_nodes, Topology};
// these tests are here instead of being under common/mod.rs so that they wont be executed as part
// of every `test/` case which includes `mod common;`.
const N: usize = 5;
#[tokio::test]
async fn check_topology_line() {
let nodes = spawn_nodes(N, Topology::Line).await;
for (i, node) in nodes.iter().enumerate() {
if i == 0 || i == N - 1 {
assert_eq!(node.peers().await.unwrap().len(), 1);
} else {
assert_eq!(node.peers().await.unwrap().len(), 2);
}
}
}
#[tokio::test]
async fn check_topology_ring() {
let nodes = spawn_nodes(N, Topology::Ring).await;
for node in &nodes {
assert_eq!(node.peers().await.unwrap().len(), 2);
}
}
#[tokio::test]
async fn check_topology_mesh() {
let nodes = spawn_nodes(N, Topology::Mesh).await;
for node in &nodes {
assert_eq!(node.peers().await.unwrap().len(), N - 1);
}
}
#[tokio::test]
async fn check_topology_star() {
let nodes = spawn_nodes(N, Topology::Star).await;
for (i, node) in nodes.iter().enumerate() {
if i == 0 {
assert_eq!(node.peers().await.unwrap().len(), N - 1);
} else {
assert_eq!(node.peers().await.unwrap().len(), 1);
}
}
}
|
//! Utilities for evaluating whether eagerly evaluated expressions can be made lazy and vice versa.
//!
//! Things to consider:
//! - has the expression side-effects?
//! - is the expression computationally expensive?
//!
//! See lints:
//! - unnecessary-lazy-evaluations
//! - or-fun-call
//! - option-if-let-else
use crate::ty::{all_predicates_of, is_copy};
use crate::visitors::is_const_evaluatable;
use rustc_hir::def::{DefKind, Res};
use rustc_hir::intravisit::{walk_expr, ErasedMap, NestedVisitorMap, Visitor};
use rustc_hir::{def_id::DefId, Block, Expr, ExprKind, QPath, UnOp};
use rustc_lint::LateContext;
use rustc_middle::ty::{self, PredicateKind};
use rustc_span::{sym, Symbol};
use std::cmp;
use std::ops;
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
enum EagernessSuggestion {
// The expression is cheap and should be evaluated eagerly
Eager,
// The expression may be cheap, so don't suggested lazy evaluation; or the expression may not be safe to switch to
// eager evaluation.
NoChange,
// The expression is likely expensive and should be evaluated lazily.
Lazy,
// The expression cannot be placed into a closure.
ForceNoChange,
}
impl ops::BitOr for EagernessSuggestion {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
cmp::max(self, rhs)
}
}
impl ops::BitOrAssign for EagernessSuggestion {
fn bitor_assign(&mut self, rhs: Self) {
*self = *self | rhs;
}
}
/// Determine the eagerness of the given function call.
fn fn_eagerness(cx: &LateContext<'tcx>, fn_id: DefId, name: Symbol, args: &'tcx [Expr<'_>]) -> EagernessSuggestion {
use EagernessSuggestion::{Eager, Lazy, NoChange};
let name = &*name.as_str();
let ty = match cx.tcx.impl_of_method(fn_id) {
Some(id) => cx.tcx.type_of(id),
None => return Lazy,
};
if (name.starts_with("as_") || name == "len" || name == "is_empty") && args.len() == 1 {
if matches!(
cx.tcx.crate_name(fn_id.krate),
sym::std | sym::core | sym::alloc | sym::proc_macro
) {
Eager
} else {
NoChange
}
} else if let ty::Adt(def, subs) = ty.kind() {
// Types where the only fields are generic types (or references to) with no trait bounds other
// than marker traits.
// Due to the limited operations on these types functions should be fairly cheap.
if def
.variants
.iter()
.flat_map(|v| v.fields.iter())
.any(|x| matches!(cx.tcx.type_of(x.did).peel_refs().kind(), ty::Param(_)))
&& all_predicates_of(cx.tcx, fn_id).all(|(pred, _)| match pred.kind().skip_binder() {
PredicateKind::Trait(pred) => cx.tcx.trait_def(pred.trait_ref.def_id).is_marker,
_ => true,
})
&& subs.types().all(|x| matches!(x.peel_refs().kind(), ty::Param(_)))
{
// Limit the function to either `(self) -> bool` or `(&self) -> bool`
match &**cx.tcx.fn_sig(fn_id).skip_binder().inputs_and_output {
[arg, res] if !arg.is_mutable_ptr() && arg.peel_refs() == ty && res.is_bool() => NoChange,
_ => Lazy,
}
} else {
Lazy
}
} else {
Lazy
}
}
#[allow(clippy::too_many_lines)]
fn expr_eagerness(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> EagernessSuggestion {
struct V<'cx, 'tcx> {
cx: &'cx LateContext<'tcx>,
eagerness: EagernessSuggestion,
}
impl<'cx, 'tcx> Visitor<'tcx> for V<'cx, 'tcx> {
type Map = ErasedMap<'tcx>;
fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
NestedVisitorMap::None
}
fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
use EagernessSuggestion::{ForceNoChange, Lazy, NoChange};
if self.eagerness == ForceNoChange {
return;
}
match e.kind {
ExprKind::Call(
&Expr {
kind: ExprKind::Path(ref path),
hir_id,
..
},
args,
) => match self.cx.qpath_res(path, hir_id) {
Res::Def(DefKind::Ctor(..) | DefKind::Variant, _) | Res::SelfCtor(_) => (),
Res::Def(_, id) if self.cx.tcx.is_promotable_const_fn(id) => (),
// No need to walk the arguments here, `is_const_evaluatable` already did
Res::Def(..) if is_const_evaluatable(self.cx, e) => {
self.eagerness |= NoChange;
return;
},
Res::Def(_, id) => match path {
QPath::Resolved(_, p) => {
self.eagerness |= fn_eagerness(self.cx, id, p.segments.last().unwrap().ident.name, args);
},
QPath::TypeRelative(_, name) => {
self.eagerness |= fn_eagerness(self.cx, id, name.ident.name, args);
},
QPath::LangItem(..) => self.eagerness = Lazy,
},
_ => self.eagerness = Lazy,
},
// No need to walk the arguments here, `is_const_evaluatable` already did
ExprKind::MethodCall(..) if is_const_evaluatable(self.cx, e) => {
self.eagerness |= NoChange;
return;
},
ExprKind::MethodCall(name, _, args, _) => {
self.eagerness |= self
.cx
.typeck_results()
.type_dependent_def_id(e.hir_id)
.map_or(Lazy, |id| fn_eagerness(self.cx, id, name.ident.name, args));
},
ExprKind::Index(_, e) => {
let ty = self.cx.typeck_results().expr_ty_adjusted(e);
if is_copy(self.cx, ty) && !ty.is_ref() {
self.eagerness |= NoChange;
} else {
self.eagerness = Lazy;
}
},
// Dereferences should be cheap, but dereferencing a raw pointer earlier may not be safe.
ExprKind::Unary(UnOp::Deref, e) if !self.cx.typeck_results().expr_ty(e).is_unsafe_ptr() => (),
ExprKind::Unary(UnOp::Deref, _) => self.eagerness |= NoChange,
ExprKind::Unary(_, e)
if matches!(
self.cx.typeck_results().expr_ty(e).kind(),
ty::Bool | ty::Int(_) | ty::Uint(_),
) => {},
ExprKind::Binary(_, lhs, rhs)
if self.cx.typeck_results().expr_ty(lhs).is_primitive()
&& self.cx.typeck_results().expr_ty(rhs).is_primitive() => {},
// Can't be moved into a closure
ExprKind::Break(..)
| ExprKind::Continue(_)
| ExprKind::Ret(_)
| ExprKind::InlineAsm(_)
| ExprKind::LlvmInlineAsm(_)
| ExprKind::Yield(..)
| ExprKind::Err => {
self.eagerness = ForceNoChange;
return;
},
// Memory allocation, custom operator, loop, or call to an unknown function
ExprKind::Box(_)
| ExprKind::Unary(..)
| ExprKind::Binary(..)
| ExprKind::Loop(..)
| ExprKind::Call(..) => self.eagerness = Lazy,
ExprKind::ConstBlock(_)
| ExprKind::Array(_)
| ExprKind::Tup(_)
| ExprKind::Lit(_)
| ExprKind::Cast(..)
| ExprKind::Type(..)
| ExprKind::DropTemps(_)
| ExprKind::Let(..)
| ExprKind::If(..)
| ExprKind::Match(..)
| ExprKind::Closure(..)
| ExprKind::Field(..)
| ExprKind::Path(_)
| ExprKind::AddrOf(..)
| ExprKind::Struct(..)
| ExprKind::Repeat(..)
| ExprKind::Block(Block { stmts: [], .. }, _) => (),
// Assignment might be to a local defined earlier, so don't eagerly evaluate.
// Blocks with multiple statements might be expensive, so don't eagerly evaluate.
// TODO: Actually check if either of these are true here.
ExprKind::Assign(..) | ExprKind::AssignOp(..) | ExprKind::Block(..) => self.eagerness |= NoChange,
}
walk_expr(self, e);
}
}
let mut v = V {
cx,
eagerness: EagernessSuggestion::Eager,
};
v.visit_expr(e);
v.eagerness
}
/// Whether the given expression should be changed to evaluate eagerly
pub fn switch_to_eager_eval(cx: &'_ LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
expr_eagerness(cx, expr) == EagernessSuggestion::Eager
}
/// Whether the given expression should be changed to evaluate lazily
pub fn switch_to_lazy_eval(cx: &'_ LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
expr_eagerness(cx, expr) == EagernessSuggestion::Lazy
}
|
/*
* Copyright 2020 Draphar
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*!
Support for reddit downloads.
# Domains
- `i.redd.it`
- `v.redd.it`
*/
use std::path::Path;
use http::Uri;
use std::process::Stdio;
use tokio::{fs, process::Command};
use crate::prelude::*;
use crate::sites::pushshift::{Gallery, SecureMedia};
use std::io::ErrorKind;
/// Specifies how videos from `v.redd.it` are downloaded.
#[derive(Debug)]
pub enum VRedditMode {
/// Leave out the audio.
NoAudio,
/// Use ffmpeg to combine the audio and video.
Ffmpeg,
/// Use a website to download the video.
/// The characters `{}` are replaced by the ID.
Website(String),
}
impl<'a> From<&'a str> for VRedditMode {
fn from(s: &str) -> Self {
match s {
"no-audio" => VRedditMode::NoAudio,
"ffmpeg" => VRedditMode::Ffmpeg,
other => VRedditMode::Website(other.to_string()),
}
}
}
/// Fetches an image from `i.redd.it`.
pub async fn fetch_image(client: &Client, url: &Uri, output: &Path) -> Result<()> {
trace!("fetch({:?}, {:?})", url, output);
download(client, url, output).await
}
/// Fetches images from a reddit gallery.
pub async fn fetch_gallery(
client: &Client,
url: &Uri,
output: &Path,
gallery: &Gallery,
) -> Result<()> {
trace!("fetch_gallery({}, {:?})", url, output);
fs::create_dir_all(output).await?;
let mut path = output.to_path_buf();
path.push("index"); // later overwritten
for (name, item) in gallery {
if item.status == "failed" {
warn!("File {:?} from gallery not available", name);
} else {
let r#type = item.e.as_ref().unwrap();
if r#type == "Image" {
let id = item.id.as_ref().unwrap();
let extension = match item.m.as_ref().unwrap().as_ref() {
"image/jpg" => "jpg",
"image/png" => "png",
"image/webp" => "webp",
_ => "",
};
debug!(
"Saving individual image \"{}.{}\" from gallery",
id, extension
);
let path = path.with_file_name(format!("{}.{}", id, extension));
download(
client,
&format!("https://i.redd.it/{}.{}", id, extension).parse()?,
&path,
)
.await; // ignore individual errors
} else {
warn!("The gallery item type {:?} is not supported", r#type);
}
}
}
Ok(())
}
/// Fetches a video from `v.redd.it`.
pub async fn fetch_video(
client: &Client,
url: &Uri,
output: &Path,
temp_dir: &Path,
vreddit_mode: &VRedditMode,
media: &Option<SecureMedia>,
) -> Result<()> {
let media = &media
.as_ref()
.and_then(|media| media.reddit_video.as_ref())
.ok_or_else(|| Error::new("No downloadable media found"))?;
let id = &url.path()[1..];
match vreddit_mode {
VRedditMode::NoAudio => no_audio(client, &media.fallback_url, output).await,
VRedditMode::Ffmpeg => ffmpeg(client, id, media.height, output, temp_dir).await,
VRedditMode::Website(url) => website(client, &url.replacen("{}", id, 1), output).await,
}
}
/// Downloads the video without audio.
async fn no_audio(client: &Client, url: &str, output: &Path) -> Result<()> {
trace!("no_audio({}, {:?})", url, output);
download(client, &url.parse()?, output).await?;
Ok(())
}
/// Download video and audio, then merge them using `ffmpeg -y -i video -i audio output`.
async fn ffmpeg(
client: &Client,
id: &str,
resolution: u64,
output: &Path,
temp_dir: &Path,
) -> Result<()> {
trace!("ffmpeg({:?}, {:?})", id, output);
let video_url = format!("https://v.redd.it/{}/DASH_{}", id, resolution).parse()?;
let video_path = temp_dir.with_file_name(format!("v_redd_it_{}_video", id));
let audio_url = format!("https://v.redd.it/{}/audio", id).parse()?;
let audio_path = temp_dir.with_file_name(format!("v_redd_it_{}_audio", id));
let video = download(client, &video_url, &video_path);
let audio = download(client, &audio_url, &audio_path);
let (video, audio) = futures_util::join!(video, audio);
async fn clear(video_path: &Path, audio_path: &Path) {
fs::remove_file(video_path).await;
fs::remove_file(audio_path).await;
}
if video.is_err() && audio.is_err() {
clear(&video_path, &audio_path).await;
if let Err(e) = video {
return Err(Error::new(format!(
"Failed to combine audio and video: {}",
e
)));
};
if let Err(e) = audio {
return Err(Error::new(format!(
"Failed to combine audio and video: {}",
e
)));
};
};
debug!("Generating file {:?} with `ffmpeg`", output);
match Command::new("ffmpeg")
.arg("-y")
.arg("-i")
.arg(&video_path)
.arg("-i")
.arg(&audio_path)
.arg("-c")
.arg("copy")
.arg(&output)
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::null())
.status()
.await
{
Ok(status) => {
if !status.success() {
clear(&video_path, &audio_path).await;
return Err(Error::new(format!(
"ffmpeg returned error status {}\n Note: {}",
status, HELP_FFMPEG
)));
};
}
Err(e) => {
clear(&video_path, &audio_path).await;
if e.kind() == ErrorKind::NotFound {
return Err(Error::new(format!("Failed to spawn ffmpeg command: {}\n Note: If you are using '--vreddit-mode ffmpeg' you have to have a local copy of the program.", e)));
} else {
return Err(Error::new(format!("Failed to spawn ffmpeg command: {}", e)));
};
}
};
clear(&video_path, &audio_path).await;
Ok(())
}
/// Use the URL to download the video.
async fn website(client: &Client, url: &str, output: &Path) -> Result<()> {
trace!("website({:?}, {:?})", url, output);
download(client, &url.parse()?, output).await
}
|
extern crate proc_macro;
extern crate syn;
#[macro_use]
extern crate quote;
use proc_macro::TokenStream;
#[proc_macro_derive(Positionable)]
pub fn positionable_derive(input: TokenStream) -> TokenStream {
let ast: syn::DeriveInput = syn::parse(input).unwrap();
let name: syn::Ident = ast.ident;
let gen = quote! {
impl Positionable for #name {
fn x(&self) -> f64 {
js_get!(self, x)
}
fn set_x(&self, new_x: f64) {
js_set!(self, x, new_x);
}
fn y(&self) -> f64 {
js_get!(self, y)
}
fn set_y(&self, new_y: f64) {
js_set!(self, y, new_y);
}
}
};
gen.into()
}
#[proc_macro_derive(Sizable)]
pub fn sizable_derive(input: TokenStream) -> TokenStream {
let ast: syn::DeriveInput = syn::parse(input).unwrap();
let name: syn::Ident = ast.ident;
let gen = quote! {
impl Sizable for #name {
fn width(&self) -> f64 {
js_get!(self, width)
}
fn set_width(&self, new_width: f64) {
js_set!(self, width, new_width);
}
fn height(&self) -> f64 {
js_get!(self, height)
}
fn set_height(&self, new_height: f64) {
js_set!(self, height, new_height);
}
}
};
gen.into()
}
#[proc_macro_derive(Rotatable)]
pub fn rotatable_derive(input: TokenStream) -> TokenStream {
let ast: syn::DeriveInput = syn::parse(input).unwrap();
let name: syn::Ident = ast.ident;
// Build the impl
let gen = quote! {
impl Rotatable for #name {
fn angle(&self) -> f64 {
js_get!(self, rotation)
}
fn set_angle(&self, angle: f64) {
js_set!(self, rotation, angle);
}
}
};
gen.into()
} |
use yew::prelude::*;
use yew::{html, Html};
use crate::models::{
skill::Skill,
};
#[derive(Clone, Debug, Eq, PartialEq, Properties)]
pub struct Props {
pub skill: Skill,
}
pub struct SkillDescription {
skill: Skill,
}
impl Component for SkillDescription {
type Message = ();
type Properties = Props;
fn create(_props: Self::Properties, _link: ComponentLink<Self>) -> Self {
Self {
skill: _props.skill.clone()
}
}
fn update(&mut self, _msg: Self::Message) -> ShouldRender {
unimplemented!()
}
fn change(&mut self, _props: Self::Properties) -> ShouldRender {
false
}
fn view(&self) -> Html {
let Self { skill } = self;
html! {
html! {
<li>
{ &skill.name }
</li>
}
}
}
} |
pub mod conformance_pb;
pub mod google;
use std::io::*;
use pecan::{self, Message};
use std::{io, mem};
use self::conformance_pb::*;
use self::google::protobuf::test_messages_proto3_pb::TestAllTypesProto3;
#[derive(Debug)]
pub enum Error {
Pecan(pecan::Error),
Io(io::Error),
}
impl From<pecan::Error> for Error {
fn from(e: pecan::Error) -> Error {
Error::Pecan(e)
}
}
impl From<io::Error> for Error {
fn from(e: io::Error) -> Error {
Error::Io(e)
}
}
pub type Result<T> = std::result::Result<T, Error>;
fn do_test(req: ConformanceRequest, resp: &mut ConformanceResponse) -> Result<()> {
if req.requested_output_format() == WireFormat::Json {
resp.set_skipped("JSON not supported.".to_owned());
return Ok(());
}
let payload = match &req.payload {
Some(ConformanceRequestNestedPayload::ProtobufPayload(p)) => p.clone(),
Some(ConformanceRequestNestedPayload::JsonPayload(_)) => {
resp.set_skipped("JSON not supported.".to_owned());
return Ok(());
}
Some(ConformanceRequestNestedPayload::TextPayload(_)) => {
resp.set_skipped("TEXT format not suppored.".to_owned());
return Ok(());
}
_ => {
resp.set_skipped("Payload not set.".to_owned());
return Ok(());
}
};
let msg = if req.message_type() == "protobuf_test_messages.proto3.TestAllTypesProto3" {
let mut msg = TestAllTypesProto3::new();
if let Err(e) = msg.merge_from_bytes(payload.as_slice()) {
resp.set_parse_error(format!("{}", e));
return Ok(());
}
Box::new(msg)
} else {
resp.set_skipped(format!("unsupport message type: {}", req.message_type()));
return Ok(());
};
match req.requested_output_format() {
WireFormat::Protobuf => {
let mut bytes = Vec::with_capacity(msg.len());
msg.write_to_vec(&mut bytes)?;
resp.set_protobuf_payload(bytes);
},
WireFormat::Json => {
resp.set_skipped("JSON not supported.".to_owned());
}
WireFormat::TextFormat => {
resp.set_skipped("TEXT format not suppored.".to_owned());
}
_ => {
resp.set_skipped("Output not set.".to_owned());
}
};
Ok(())
}
pub fn do_test_io() -> Result<bool> {
let mut len_bytes: [u8; 4] = [0; 4];
let mut stdin = stdin();
match stdin.read_exact(&mut len_bytes) {
Ok(_) => (),
Err(e) if e.kind() == io::ErrorKind::UnexpectedEof => return Ok(true),
Err(e) => return Err(e.into()),
}
let length = u32::from_le_bytes(len_bytes) as usize;
let mut bytes = vec![0; length];
stdin.read_exact(&mut bytes)?;
let mut req = conformance_pb::ConformanceRequest::default();
req.merge_from_bytes(bytes.as_slice())?;
let mut resp = ConformanceResponse::new();
if let Err(e) = do_test(req, &mut resp) {
resp.set_runtime_error(format!("{:?}", e));
}
let len = resp.len();
let mut res = Vec::with_capacity(len);
resp.write_to_vec(&mut res)?;
assert_eq!(len, res.len());
let mut stdout = stdout();
stdout.write_all(unsafe { mem::transmute::<_, &[u8; 4]>(&len) })?;
stdout.write_all(&res)?;
stdout.flush()?;
Ok(false)
}
|
use crate::ast;
use crate::{ParseError, ParseErrorKind};
use runestick::Span;
use std::collections::VecDeque;
use std::fmt;
/// Lexer for the rune language.
#[derive(Debug)]
pub struct Lexer<'a> {
/// Source iterator.
iter: SourceIter<'a>,
/// Current lexer mode.
modes: LexerModes,
/// Buffered tokens.
buffer: VecDeque<ast::Token>,
}
impl<'a> Lexer<'a> {
/// Construct a new lexer over the given source.
///
/// # Examples
///
/// ```rust
/// use rune::Lexer;
/// use rune::ast;
/// use runestick::span;
///
/// assert_eq! {
/// Lexer::new("fn").next().unwrap().unwrap(),
/// ast::Token {
/// kind: ast::Kind::Fn,
/// span: span!(0, 2),
/// }
/// };
///
/// assert_eq! {
/// Lexer::new("name").next().unwrap().unwrap(),
/// ast::Token {
/// kind: ast::Kind::Ident(ast::StringSource::Text),
/// span: span!(0, 4),
/// }
/// };
/// ```
pub fn new(source: &'a str) -> Self {
Self {
iter: SourceIter::new(source),
modes: LexerModes::default(),
buffer: VecDeque::new(),
}
}
/// Access the span of the lexer.
pub fn span(&self) -> Span {
self.iter.end_span(0)
}
fn emit_builtin_attribute(&mut self, span: Span) {
self.buffer.push_back(ast::Token { kind: K![#], span });
self.buffer.push_back(ast::Token {
kind: K!['['],
span,
});
self.buffer.push_back(ast::Token {
kind: ast::Kind::Ident(ast::StringSource::BuiltIn(ast::BuiltIn::BuiltIn)),
span,
});
self.buffer.push_back(ast::Token {
kind: K!['('],
span,
});
self.buffer.push_back(ast::Token {
kind: ast::Kind::Ident(ast::StringSource::BuiltIn(ast::BuiltIn::Literal)),
span,
});
self.buffer.push_back(ast::Token {
kind: K![')'],
span,
});
self.buffer.push_back(ast::Token {
kind: K![']'],
span,
});
}
fn next_ident(&mut self, start: usize) -> Result<Option<ast::Token>, ParseError> {
while let Some(c) = self.iter.peek() {
if !matches!(c, 'a'..='z' | 'A'..='Z' | '_' | '0'..='9') {
break;
}
self.iter.next();
}
let (ident, span) = self.iter.source_from(start);
let kind =
ast::Kind::from_keyword(ident).unwrap_or(ast::Kind::Ident(ast::StringSource::Text));
Ok(Some(ast::Token { kind, span }))
}
/// Consume a number literal.
fn next_number_literal(
&mut self,
c: char,
start: usize,
) -> Result<Option<ast::Token>, ParseError> {
let base = if let ('0', Some(m)) = (c, self.iter.peek()) {
// This loop is useful.
#[allow(clippy::never_loop)]
loop {
let number = match m {
'x' => ast::NumberBase::Hex,
'b' => ast::NumberBase::Binary,
'o' => ast::NumberBase::Octal,
_ => break ast::NumberBase::Decimal,
};
self.iter.next();
break number;
}
} else {
ast::NumberBase::Decimal
};
let mut is_fractional = false;
let mut has_exponent = false;
while let Some(c) = self.iter.peek() {
match c {
'e' if !has_exponent => {
self.iter.next();
has_exponent = true;
is_fractional = true;
}
'.' if !is_fractional => {
if let Some(p2) = self.iter.peek2() {
// NB: only skip if the next peek matches:
// * the beginning of an ident.
// * `..`, which is a range expression.
//
// Our goal is otherwise to consume as much alphanumeric
// content as possible to provide better diagnostics.
// But we must treat these cases differently since field
// accesses might be instance fn calls, and range
// expressions should work.
if matches!(p2, 'a'..='z' | 'A'..='Z' | '_' | '.') {
break;
}
}
self.iter.next();
is_fractional = true;
}
c if c.is_alphanumeric() => {
self.iter.next();
}
_ => break,
}
}
Ok(Some(ast::Token {
kind: ast::Kind::Number(ast::NumberSource::Text(ast::NumberText {
is_fractional,
base,
})),
span: self.iter.span_from(start),
}))
}
/// Consume a string literal.
fn next_char_or_label(&mut self, start: usize) -> Result<Option<ast::Token>, ParseError> {
let mut is_label = true;
let mut count = 0;
while let Some((s, c)) = self.iter.peek_with_pos() {
match c {
'\\' => {
self.iter.next();
if self.iter.next().is_none() {
return Err(ParseError::new(
self.iter.span_from(s),
ParseErrorKind::ExpectedEscape,
));
}
is_label = false;
count += 1;
}
'\'' => {
is_label = false;
self.iter.next();
break;
}
// components of labels.
'0'..='9' | 'a'..='z' => {
self.iter.next();
count += 1;
}
c if c.is_control() => {
let span = self.iter.span_from(start);
return Err(ParseError::new(span, ParseErrorKind::UnterminatedCharLit));
}
_ if is_label && count > 0 => {
break;
}
_ => {
is_label = false;
self.iter.next();
count += 1;
}
}
}
if count == 0 {
let span = self.iter.end_span(start);
if !is_label {
return Err(ParseError::new(span, ParseErrorKind::ExpectedCharClose));
}
return Err(ParseError::new(span, ParseErrorKind::ExpectedCharOrLabel));
}
if is_label {
Ok(Some(ast::Token {
kind: ast::Kind::Label(ast::StringSource::Text),
span: self.iter.span_from(start),
}))
} else {
Ok(Some(ast::Token {
kind: ast::Kind::Char(ast::CopySource::Text),
span: self.iter.span_from(start),
}))
}
}
/// Consume a string literal.
fn next_lit_byte(&mut self, start: usize) -> Result<Option<ast::Token>, ParseError> {
loop {
let (s, c) = match self.iter.next_with_pos() {
Some(c) => c,
None => {
return Err(ParseError::new(
self.iter.span_from(start),
ParseErrorKind::ExpectedByteClose,
));
}
};
match c {
'\\' => {
if self.iter.next().is_none() {
return Err(ParseError::new(
self.iter.span_from(s),
ParseErrorKind::ExpectedEscape,
));
}
}
'\'' => {
break;
}
c if c.is_control() => {
let span = self.iter.span_from(start);
return Err(ParseError::new(span, ParseErrorKind::UnterminatedByteLit));
}
_ => (),
}
}
Ok(Some(ast::Token {
kind: ast::Kind::Byte(ast::CopySource::Text),
span: self.iter.span_from(start),
}))
}
/// Consume a string literal.
fn next_str(
&mut self,
start: usize,
error_kind: impl FnOnce() -> ParseErrorKind + Copy,
kind: impl FnOnce(ast::StrSource) -> ast::Kind,
) -> Result<Option<ast::Token>, ParseError> {
let mut escaped = false;
loop {
let (s, c) = match self.iter.next_with_pos() {
Some(next) => next,
None => {
return Err(ParseError::new(self.iter.span_from(start), error_kind()));
}
};
match c {
'"' => break,
'\\' => {
if self.iter.next().is_none() {
return Err(ParseError::new(
self.iter.span_from(s),
ParseErrorKind::ExpectedEscape,
));
}
escaped = true;
}
_ => (),
}
}
Ok(Some(ast::Token {
kind: kind(ast::StrSource::Text(ast::StrText {
escaped,
wrapped: true,
})),
span: self.iter.span_from(start),
}))
}
/// Consume the entire line.
fn consume_line(&mut self) {
while !matches!(self.iter.next(), Some('\n') | None) {}
}
fn template_next(&mut self) -> Result<(), ParseError> {
use std::mem::take;
let start = self.iter.pos();
let mut escaped = false;
while let Some((s, c)) = self.iter.peek_with_pos() {
match c {
'$' => {
let expressions = self.modes.expression_count(&self.iter, start)?;
let span = self.iter.span_from(start);
let had_string = start != self.iter.pos();
let start = self.iter.pos();
self.iter.next();
match self.iter.next_with_pos() {
Some((_, '{')) => (),
Some((start, c)) => {
let span = self.iter.span_from(start);
return Err(ParseError::new(
span,
ParseErrorKind::UnexpectedChar { c },
));
}
None => {
let span = self.iter.end_span(start);
return Err(ParseError::new(span, ParseErrorKind::UnexpectedEof));
}
}
if had_string {
if *expressions > 0 {
self.buffer.push_back(ast::Token {
kind: ast::Kind::Comma,
span,
});
}
self.buffer.push_back(ast::Token {
kind: ast::Kind::Str(ast::StrSource::Text(ast::StrText {
escaped: take(&mut escaped),
wrapped: false,
})),
span,
});
*expressions += 1;
}
if *expressions > 0 {
self.buffer.push_back(ast::Token {
kind: ast::Kind::Comma,
span: self.iter.span_from(start),
});
}
self.modes.push(LexerMode::Default(1));
return Ok(());
}
'\\' => {
self.iter.next();
if self.iter.next().is_none() {
return Err(ParseError::new(
self.iter.span_from(s),
ParseErrorKind::ExpectedEscape,
));
}
escaped = true;
}
'`' => {
let span = self.iter.span_from(start);
let had_string = start != self.iter.pos();
let start = self.iter.pos();
self.iter.next();
let expressions = self.modes.expression_count(&self.iter, start)?;
if had_string {
if *expressions > 0 {
self.buffer.push_back(ast::Token {
kind: ast::Kind::Comma,
span,
});
}
self.buffer.push_back(ast::Token {
kind: ast::Kind::Str(ast::StrSource::Text(ast::StrText {
escaped: take(&mut escaped),
wrapped: false,
})),
span,
});
*expressions += 1;
}
self.buffer.push_back(ast::Token {
kind: K![')'],
span: self.iter.span_from(start),
});
let expressions = *expressions;
self.modes
.pop(&self.iter, LexerMode::Template(expressions))?;
return Ok(());
}
_ => {
self.iter.next();
}
}
}
Err(ParseError::new(
self.iter.point_span(),
ParseErrorKind::UnexpectedEof,
))
}
/// Consume the next token from the lexer.
#[allow(clippy::should_implement_trait)]
pub fn next(&mut self) -> Result<Option<ast::Token>, ParseError> {
'outer: loop {
if let Some(token) = self.buffer.pop_front() {
return Ok(Some(token));
}
let mode = self.modes.last();
let level = match mode {
LexerMode::Template(..) => {
self.template_next()?;
continue;
}
LexerMode::Default(level) => (level),
};
let (start, c) = match self.iter.next_with_pos() {
Some(next) => next,
None => {
self.modes.pop(&self.iter, LexerMode::Default(0))?;
return Ok(None);
}
};
if char::is_whitespace(c) {
continue;
}
// This loop is useful, at least until it's rewritten.
#[allow(clippy::never_loop)]
let kind = loop {
if let Some(c2) = self.iter.peek() {
match (c, c2) {
('+', '=') => {
self.iter.next();
break ast::Kind::PlusEq;
}
('-', '=') => {
self.iter.next();
break ast::Kind::DashEq;
}
('*', '=') => {
self.iter.next();
break ast::Kind::StarEq;
}
('/', '=') => {
self.iter.next();
break ast::Kind::SlashEq;
}
('%', '=') => {
self.iter.next();
break ast::Kind::PercEq;
}
('&', '=') => {
self.iter.next();
break ast::Kind::AmpEq;
}
('^', '=') => {
self.iter.next();
break ast::Kind::CaretEq;
}
('|', '=') => {
self.iter.next();
break ast::Kind::PipeEq;
}
('/', '/') => {
self.consume_line();
continue 'outer;
}
(':', ':') => {
self.iter.next();
break ast::Kind::ColonColon;
}
('<', '=') => {
self.iter.next();
break ast::Kind::LtEq;
}
('>', '=') => {
self.iter.next();
break ast::Kind::GtEq;
}
('=', '=') => {
self.iter.next();
break ast::Kind::EqEq;
}
('!', '=') => {
self.iter.next();
break ast::Kind::BangEq;
}
('&', '&') => {
self.iter.next();
break ast::Kind::AmpAmp;
}
('|', '|') => {
self.iter.next();
break ast::Kind::PipePipe;
}
('<', '<') => {
self.iter.next();
break if matches!(self.iter.peek(), Some('=')) {
self.iter.next();
ast::Kind::LtLtEq
} else {
ast::Kind::LtLt
};
}
('>', '>') => {
self.iter.next();
break if matches!(self.iter.peek(), Some('=')) {
self.iter.next();
ast::Kind::GtGtEq
} else {
ast::Kind::GtGt
};
}
('.', '.') => {
self.iter.next();
break if matches!(self.iter.peek(), Some('=')) {
self.iter.next();
ast::Kind::DotDotEq
} else {
ast::Kind::DotDot
};
}
('=', '>') => {
self.iter.next();
break ast::Kind::Rocket;
}
('-', '>') => {
self.iter.next();
break ast::Kind::Arrow;
}
('b', '\'') => {
self.iter.next();
self.iter.next();
return self.next_lit_byte(start);
}
('b', '"') => {
self.iter.next();
return self.next_str(
start,
|| ParseErrorKind::UnterminatedByteStrLit,
ast::Kind::ByteStr,
);
}
_ => (),
}
}
break match c {
'(' => ast::Kind::Open(ast::Delimiter::Parenthesis),
')' => ast::Kind::Close(ast::Delimiter::Parenthesis),
'{' => {
if level > 0 {
self.modes.push(LexerMode::Default(level + 1));
}
ast::Kind::Open(ast::Delimiter::Brace)
}
'}' => {
if level > 0 {
self.modes.pop(&self.iter, LexerMode::Default(level))?;
// NB: end of expression in template.
if level == 1 {
let expressions = self.modes.expression_count(&self.iter, start)?;
*expressions += 1;
continue 'outer;
}
}
ast::Kind::Close(ast::Delimiter::Brace)
}
'[' => ast::Kind::Open(ast::Delimiter::Bracket),
']' => ast::Kind::Close(ast::Delimiter::Bracket),
'_' => ast::Kind::Underscore,
',' => ast::Kind::Comma,
':' => ast::Kind::Colon,
'#' => ast::Kind::Pound,
'.' => ast::Kind::Dot,
';' => ast::Kind::SemiColon,
'=' => ast::Kind::Eq,
'+' => ast::Kind::Plus,
'-' => ast::Kind::Dash,
'/' => ast::Kind::Div,
'*' => ast::Kind::Star,
'&' => ast::Kind::Amp,
'>' => ast::Kind::Gt,
'<' => ast::Kind::Lt,
'!' => ast::Kind::Bang,
'?' => ast::Kind::QuestionMark,
'|' => ast::Kind::Pipe,
'%' => ast::Kind::Perc,
'^' => ast::Kind::Caret,
'@' => ast::Kind::At,
'$' => ast::Kind::Dollar,
'~' => ast::Kind::Tilde,
'a'..='z' | 'A'..='Z' => {
return self.next_ident(start);
}
'0'..='9' => {
return self.next_number_literal(c, start);
}
'"' => {
return self.next_str(
start,
|| ParseErrorKind::UnterminatedStrLit,
ast::Kind::Str,
);
}
'`' => {
let span = self.iter.span_from(start);
self.emit_builtin_attribute(span);
self.buffer.push_back(ast::Token {
kind: ast::Kind::Ident(ast::StringSource::BuiltIn(
ast::BuiltIn::Template,
)),
span,
});
self.buffer.push_back(ast::Token { kind: K![!], span });
self.buffer.push_back(ast::Token {
kind: K!['('],
span,
});
self.modes.push(LexerMode::Template(0));
continue 'outer;
}
'\'' => {
return self.next_char_or_label(start);
}
_ => {
let span = self.iter.span_from(start);
return Err(ParseError::new(span, ParseErrorKind::UnexpectedChar { c }));
}
};
};
return Ok(Some(ast::Token {
kind,
span: self.iter.span_from(start),
}));
}
}
}
#[derive(Debug, Clone)]
struct SourceIter<'a> {
source: &'a str,
chars: std::str::Chars<'a>,
}
impl<'a> SourceIter<'a> {
fn new(source: &'a str) -> Self {
Self {
source,
chars: source.chars(),
}
}
/// Get the current character position of the iterator.
fn pos(&self) -> usize {
self.source.len() - self.chars.as_str().len()
}
/// Get the source from the given start, to the current position.
fn source_from(&self, start: usize) -> (&'a str, Span) {
let end = self.pos();
let span = Span::new(start, end);
(&self.source[start..end], span)
}
/// Get the current point span.
fn point_span(&self) -> Span {
Span::point(self.pos())
}
/// Get the span from the given start, to the current position.
fn span_from(&self, start: usize) -> Span {
Span::new(start, self.pos())
}
/// Get the end span from the given start to the end of the source.
fn end_span(&self, start: usize) -> Span {
Span::new(start, self.source.len())
}
/// Peek the next index.
fn peek(&self) -> Option<char> {
self.chars.clone().next()
}
/// Peek the next next char.
fn peek2(&self) -> Option<char> {
let mut it = self.chars.clone();
it.next()?;
it.next()
}
/// Peek the next character with position.
fn peek_with_pos(&self) -> Option<(usize, char)> {
self.clone().next_with_pos()
}
/// Next with position.
fn next_with_pos(&mut self) -> Option<(usize, char)> {
let p = self.pos();
let c = self.next()?;
Some((p, c))
}
}
impl Iterator for SourceIter<'_> {
type Item = char;
/// Consume the next character.
fn next(&mut self) -> Option<Self::Item> {
self.chars.next()
}
}
struct WithCharIndex<'s, 'a> {
iter: &'s mut SourceIter<'a>,
}
impl Iterator for WithCharIndex<'_, '_> {
type Item = (usize, char);
fn next(&mut self) -> Option<Self::Item> {
let pos = self.iter.pos();
Some((pos, self.iter.next()?))
}
}
#[derive(Debug, Default)]
struct LexerModes {
modes: Vec<LexerMode>,
}
impl LexerModes {
/// Get the last mode.
fn last(&self) -> LexerMode {
self.modes.last().copied().unwrap_or_default()
}
/// Push the given lexer mode.
fn push(&mut self, mode: LexerMode) {
self.modes.push(mode);
}
/// Pop the expected lexer mode.
fn pop(&mut self, iter: &SourceIter<'_>, expected: LexerMode) -> Result<(), ParseError> {
let actual = self.modes.pop().unwrap_or_default();
if actual != expected {
return Err(ParseError::new(
iter.point_span(),
ParseErrorKind::BadLexerMode { actual, expected },
));
}
Ok(())
}
/// Get the expression count.
fn expression_count<'a>(
&'a mut self,
iter: &SourceIter<'_>,
start: usize,
) -> Result<&'a mut usize, ParseError> {
match self.modes.last_mut() {
Some(LexerMode::Template(expression)) => Ok(expression),
_ => {
let span = iter.span_from(start);
Err(ParseError::new(
span,
ParseErrorKind::BadLexerMode {
actual: LexerMode::default(),
expected: LexerMode::Template(0),
},
))
}
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LexerMode {
/// Default mode, boolean indicating if we are inside a template or not.
Default(usize),
/// We are parsing a template string.
Template(usize),
}
impl Default for LexerMode {
fn default() -> Self {
Self::Default(0)
}
}
impl fmt::Display for LexerMode {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
LexerMode::Default(..) => {
write!(f, "default")?;
}
LexerMode::Template(..) => {
write!(f, "template")?;
}
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::Lexer;
use crate::ast;
use runestick::span;
macro_rules! test_lexer {
($source:expr $(, $pat:pat)* $(,)?) => {{
let mut it = Lexer::new($source);
#[allow(never_used)]
#[allow(unused_assignments)]
{
let mut n = 0;
$(
match it.next().unwrap().expect("expected token") {
$pat => (),
#[allow(unreachable_patterns)]
other => {
panic!("\nGot bad token #{}.\nExpected: `{}`\nBut got: {:?}", n, stringify!($pat), other);
}
}
n += 1;
)*
}
assert_eq!(it.next().unwrap(), None);
}}
}
#[test]
fn test_number_literals() {
test_lexer! {
"(10)",
ast::Token {
span: span!(0, 1),
kind: ast::Kind::Open(ast::Delimiter::Parenthesis),
},
ast::Token {
span: span!(1, 3),
kind: ast::Kind::Number(ast::NumberSource::Text(ast::NumberText {
is_fractional: false,
base: ast::NumberBase::Decimal,
})),
},
ast::Token {
span: span!(3, 4),
kind: ast::Kind::Close(ast::Delimiter::Parenthesis),
},
};
test_lexer! {
"(10.)",
_,
ast::Token {
span: span!(1, 4),
kind: ast::Kind::Number(ast::NumberSource::Text(ast::NumberText {
is_fractional: true,
base: ast::NumberBase::Decimal,
})),
},
_,
};
}
#[test]
fn test_char_literal() {
test_lexer! {
"'a'",
ast::Token {
span: span!(0, 3),
kind: ast::Kind::Char(ast::CopySource::Text),
}
};
test_lexer! {
"'\\u{abcd}'",
ast::Token {
span: span!(0, 10),
kind: ast::Kind::Char(ast::CopySource::Text),
}
};
}
#[test]
fn test_label() {
test_lexer! {
"'asdf 'a' \"foo bar\"",
ast::Token {
span: span!(0, 5),
kind: ast::Kind::Label(ast::StringSource::Text),
},
ast::Token {
span: span!(6, 9),
kind: ast::Kind::Char(ast::CopySource::Text),
},
ast::Token {
span: span!(10, 19),
kind: ast::Kind::Str(ast::StrSource::Text(ast::StrText { escaped: false, wrapped: true })),
}
};
}
#[test]
fn test_operators() {
test_lexer! {
"+ += - -= * *= / /=",
ast::Token {
span: span!(0, 1),
kind: ast::Kind::Plus,
},
ast::Token {
span: span!(2, 4),
kind: ast::Kind::PlusEq,
},
ast::Token {
span: span!(5, 6),
kind: ast::Kind::Dash,
},
ast::Token {
span: span!(7, 9),
kind: ast::Kind::DashEq,
},
ast::Token {
span: span!(10, 11),
kind: ast::Kind::Star,
},
ast::Token {
span: span!(12, 14),
kind: ast::Kind::StarEq,
},
ast::Token {
span: span!(15, 16),
kind: ast::Kind::Div,
},
ast::Token {
span: span!(17, 19),
kind: ast::Kind::SlashEq,
}
};
}
#[test]
fn test_idents() {
test_lexer! {
"a.checked_div(10)",
ast::Token {
span: span!(0, 1),
kind: ast::Kind::Ident(ast::StringSource::Text),
},
ast::Token {
span: span!(1, 2),
kind: ast::Kind::Dot,
},
ast::Token {
span: span!(2, 13),
kind: ast::Kind::Ident(ast::StringSource::Text),
},
ast::Token {
span: span!(13, 14),
kind: ast::Kind::Open(ast::Delimiter::Parenthesis),
},
ast::Token {
span: span!(14, 16),
kind: ast::Kind::Number(ast::NumberSource::Text(ast::NumberText {
is_fractional: false,
base: ast::NumberBase::Decimal,
})),
},
ast::Token {
span: span!(16, 17),
kind: ast::Kind::Close(ast::Delimiter::Parenthesis),
},
};
}
#[test]
fn test_template_literals() {
test_lexer! {
"`foo ${bar} \\` baz`",
ast::Token {
kind: K![#],
span: span!(0, 1),
},
ast::Token {
kind: K!['['],
span: span!(0, 1),
},
ast::Token {
kind: ast::Kind::Ident(ast::StringSource::BuiltIn(ast::BuiltIn::BuiltIn)),
span: span!(0, 1),
},
ast::Token {
kind: K!['('],
span: span!(0, 1),
},
ast::Token {
kind: ast::Kind::Ident(ast::StringSource::BuiltIn(ast::BuiltIn::Literal)),
span: span!(0, 1),
},
ast::Token {
kind: K![')'],
span: span!(0, 1),
},
ast::Token {
kind: K![']'],
span: span!(0, 1),
},
ast::Token {
kind: ast::Kind::Ident(ast::StringSource::BuiltIn(ast::BuiltIn::Template)),
span: span!(0, 1),
},
ast::Token {
kind: ast::Kind::Bang,
span: span!(0, 1),
},
ast::Token {
kind: K!['('],
span: span!(0, 1),
},
ast::Token {
kind: ast::Kind::Str(ast::StrSource::Text(ast::StrText {
escaped: false,
wrapped: false,
})),
span: span!(1, 5),
},
ast::Token {
kind: ast::Kind::Comma,
span: span!(5, 7),
},
ast::Token {
kind: ast::Kind::Ident(ast::StringSource::Text),
span: span!(7, 10),
},
ast::Token {
kind: ast::Kind::Comma,
span: span!(11, 18),
},
ast::Token {
kind: ast::Kind::Str(ast::StrSource::Text(ast::StrText {
escaped: true,
wrapped: false,
})),
span: span!(11, 18),
},
ast::Token {
kind: K![')'],
span: span!(18, 19),
},
};
}
#[test]
fn test_template_literals_multi() {
test_lexer! {
"`foo ${bar} ${baz}`",
ast::Token {
kind: K![#],
span: span!(0, 1),
},
ast::Token {
kind: K!['['],
span: span!(0, 1),
},
ast::Token {
kind: ast::Kind::Ident(ast::StringSource::BuiltIn(ast::BuiltIn::BuiltIn)),
span: span!(0, 1),
},
ast::Token {
kind: K!['('],
span: span!(0, 1),
},
ast::Token {
kind: ast::Kind::Ident(ast::StringSource::BuiltIn(ast::BuiltIn::Literal)),
span: span!(0, 1),
},
ast::Token {
kind: K![')'],
span: span!(0, 1),
},
ast::Token {
kind: K![']'],
span: span!(0, 1),
},
ast::Token {
kind: ast::Kind::Ident(ast::StringSource::BuiltIn(ast::BuiltIn::Template)),
span: span!(0, 1),
},
ast::Token {
kind: ast::Kind::Bang,
span: span!(0, 1),
},
ast::Token {
kind: K!['('],
span: span!(0, 1),
},
ast::Token {
kind: ast::Kind::Str(ast::StrSource::Text(ast::StrText {
escaped: false,
wrapped: false,
})),
span: span!(1, 5),
},
ast::Token {
kind: ast::Kind::Comma,
span: span!(5, 7),
},
ast::Token {
kind: ast::Kind::Ident(ast::StringSource::Text),
span: span!(7, 10),
},
ast::Token {
kind: ast::Kind::Comma,
span: span!(11, 12),
},
ast::Token {
kind: ast::Kind::Str(ast::StrSource::Text(ast::StrText {
escaped: false,
wrapped: false,
})),
span: span!(11, 12),
},
ast::Token {
kind: ast::Kind::Comma,
span: span!(12, 14),
},
ast::Token {
kind: ast::Kind::Ident(ast::StringSource::Text),
span: span!(14, 17),
},
ast::Token {
kind: K![')'],
span: span!(18, 19),
},
};
}
#[test]
fn test_literals() {
test_lexer! {
r#"b"""#,
ast::Token {
span: span!(0, 3),
kind: ast::Kind::ByteStr(ast::StrSource::Text(ast::StrText {
escaped: false,
wrapped: true,
})),
},
};
test_lexer! {
r#"b"hello world""#,
ast::Token {
span: span!(0, 14),
kind: ast::Kind::ByteStr(ast::StrSource::Text(ast::StrText {
escaped: false,
wrapped: true,
})),
},
};
test_lexer! {
"b'\\\\''",
ast::Token {
span: span!(0, 6),
kind: ast::Kind::Byte(ast::CopySource::Text),
},
};
test_lexer! {
"'label 'a' b'a'",
ast::Token {
span: span!(0, 6),
kind: ast::Kind::Label(ast::StringSource::Text),
},
ast::Token {
span: span!(7, 10),
kind: ast::Kind::Char(ast::CopySource::Text),
},
ast::Token {
span: span!(11, 15),
kind: ast::Kind::Byte(ast::CopySource::Text),
},
};
test_lexer! {
"b'a'",
ast::Token {
span: span!(0, 4),
kind: ast::Kind::Byte(ast::CopySource::Text),
},
};
test_lexer! {
"b'\\n'",
ast::Token {
span: span!(0, 5),
kind: ast::Kind::Byte(ast::CopySource::Text),
},
};
}
}
|
extern crate hyper;
extern crate multipart;
use hyper::client::Request;
use hyper::method::Method;
use hyper::net::Streaming;
use multipart::client::Multipart;
use std::io::Read;
fn main() {
let url = "http://localhost:80".parse()
.expect("Failed to parse URL");
let request = Request::new(Method::Post, url)
.expect("Failed to create request");
let mut multipart = Multipart::from_request(request)
.expect("Failed to create Multipart");
write_body(&mut multipart)
.expect("Failed to write multipart body");
let mut response = multipart.send().expect("Failed to send multipart request");
if !response.status.is_success() {
let mut res = String::new();
response.read_to_string(&mut res).expect("failed to read response");
println!("response reported unsuccessful: {:?}\n {}", response, res);
}
// Optional: read out response
}
fn write_body(multi: &mut Multipart<Request<Streaming>>) -> hyper::Result<()> {
let mut binary = "Hello world from binary!".as_bytes();
multi.write_text("text", "Hello, world!")?;
multi.write_file("file", "lorem_ipsum.txt")?;
// &[u8] impl Read
multi.write_stream("binary", &mut binary, None, None)
.and(Ok(()))
}
|
fn main() {
yew::start_app::<counter_web_sys::Model>();
}
|
use crate::core::input::ser::Input;
use crate::gameplay::Action;
use glfw::{Key, MouseButton};
use serde::de::DeserializeOwned;
use serde_derive::{Deserialize, Serialize};
use std::collections::HashMap;
use std::error::Error;
use std::path::Path;
pub fn load_config<T, P: AsRef<Path>>(path: P) -> Result<T, Box<dyn Error>>
where
T: DeserializeOwned,
{
let content = std::fs::read_to_string(path)?;
serde_json::from_str(&content).map_err(|e| e.into())
}
#[derive(Debug, Serialize, Deserialize)]
pub struct PlayerConfig {
pub lateral_thrust: f32,
pub rotation_delta: f32,
}
impl Default for PlayerConfig {
fn default() -> Self {
Self {
lateral_thrust: 600.0,
rotation_delta: 0.05,
}
}
}
impl PlayerConfig {
pub fn load<P: AsRef<Path>>(path: P) -> Result<PlayerConfig, Box<dyn Error>> {
let content = std::fs::read_to_string(path)?;
serde_json::from_str(&content).map_err(|e| e.into())
}
}
#[derive(Default, Debug, Serialize, Deserialize)]
pub struct GameEngineConfig {
pub show_gizmos: bool,
}
#[derive(Default, Debug, Serialize, Deserialize)]
pub struct InputConfig(pub HashMap<Action, Input>);
impl InputConfig {
pub fn input_maps(self) -> (HashMap<Key, Action>, HashMap<MouseButton, Action>) {
let mut btn_map = HashMap::new();
let mut key_map = HashMap::new();
for (action, input) in self.0 {
match input {
Input::Key(k) => key_map.insert(k.into(), action),
Input::Mouse(btn) => btn_map.insert(btn.into(), action),
};
}
(key_map, btn_map)
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct AudioConfig {
pub background_volume: u32,
pub effects_volume: u32,
pub channel_nb: usize,
}
impl Default for AudioConfig {
fn default() -> Self {
Self {
background_volume: 100,
effects_volume: 100,
channel_nb: 15,
}
}
}
|
// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
use structopt::StructOpt;
#[derive(StructOpt, Clone, Debug)]
/// Stress test verifing wifi stability:
/// repeat scan, connect and disconnect.
/// If the following options are specified: -s -d -c -r 10,
/// the test will run (scan then connect then disconnect) 10 times
/// Note that the ordering of the options on the command line does not
/// impact the order of execution of the API calls.
/// User can specify a wait time in ms between consecutive repetitions
/// using the '-w' command line option.
pub struct Opt {
/// SSID of the network to use in the test
#[structopt(name = "target_ssid", default_value = "")]
pub target_ssid: String,
/// password for the target network
#[structopt(short = "p", long = "target_pwd", default_value = "")]
pub target_pwd: String,
/// flag indicating whether to stress the scan API
#[structopt(short = "s", long = "scan")]
pub scan_test_enabled: bool,
/// flag indicating whether to stress the connect API
#[structopt(short = "c", long = "connect")]
pub connect_test_enabled: bool,
/// flag indicating whether to stress the disconnect API
#[structopt(short = "d", long = "disconnect")]
pub disconnect_test_enabled: bool,
/// flag indicating number of times to call the API
#[structopt(short = "r", long = "repetitions", default_value = "1")]
pub repetitions: u128,
/// wait time (in millisecs) between iterations
#[structopt(short = "w", long = "wait_time_ms", default_value = "0")]
pub wait_time_ms: u64,
}
|
use crate::io::Buf;
use crate::mysql::protocol::AuthPlugin;
// https://dev.mysql.com/doc/dev/mysql-server/8.0.12/page_protocol_connection_phase_packets_protocol_auth_switch_request.html
#[derive(Debug)]
pub(crate) struct AuthSwitch {
pub(crate) auth_plugin: AuthPlugin,
pub(crate) auth_plugin_data: Box<[u8]>,
}
impl AuthSwitch {
pub(crate) fn read(mut buf: &[u8]) -> crate::Result<Self>
where
Self: Sized,
{
let header = buf.get_u8()?;
if header != 0xFE {
return Err(protocol_err!(
"expected AUTH SWITCH (0xFE); received 0x{:X}",
header
))?;
}
let auth_plugin = AuthPlugin::from_opt_str(Some(buf.get_str_nul()?))?;
let auth_plugin_data = buf.get_bytes(buf.len())?.to_owned().into_boxed_slice();
Ok(Self {
auth_plugin_data,
auth_plugin,
})
}
}
|
pub use VkDisplayPlaneAlphaFlagsKHR::*;
#[repr(u32)]
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum VkDisplayPlaneAlphaFlagsKHR {
VK_DISPLAY_PLANE_ALPHA_NULL_BIT = 0,
}
use crate::SetupVkFlags;
#[repr(C)]
#[derive(Clone, Copy, Eq, PartialEq, Hash)]
pub struct VkDisplayPlaneAlphaFlagBitsKHR(u32);
SetupVkFlags!(VkDisplayPlaneAlphaFlagsKHR, VkDisplayPlaneAlphaFlagBitsKHR);
|
use ws::{connect, CloseCode};
use std::rc::Rc;
use std::cell::Cell;
use serde_json::{Value};
use crate::api::config::Config;
use crate::api::create_offer::data::*;
use crate::api::message::amount::Amount;
use crate::api::utils::cast::get_account_sequence;
use crate::api::message::local_sign_tx::{LocalSignTx};
use crate::base::misc::util::{downcast_to_string};
use crate::base::local_sign::sign_tx::{SignTx};
pub struct CreateOffer {
pub config : Config,
pub account: String,
pub secret : String,
}
impl CreateOffer {
pub fn with_params(config: Config, account: String, secret: String) -> Self {
CreateOffer {
config : config,
account : account,
secret : secret,
}
}
pub fn create_offer<F>(&self, offer_type: OfferType, taker_gets: Amount, taker_pays: Amount, op: F)
where F: Fn(Result<OfferCreateTxResponse, OfferCreateSideKick>) {
let info = Rc::new(Cell::new("".to_string()));
let account_rc = Rc::new(Cell::new(String::from(self.account.as_str())));
let secret_rc = Rc::new(Cell::new(String::from(self.secret.as_str())));
let offer_type_rc = Rc::new(Cell::new(offer_type.get()));
let taker_gets_rc = Rc::new(Cell::new(taker_gets));
let taker_pays_rc = Rc::new(Cell::new(taker_pays));
// Get Account Seq
let account_seq = get_account_sequence(&self.config, self.account.clone());
connect(self.config.addr, |out| {
let copy = info.clone();
let account = account_rc.clone();
let secret = secret_rc.clone();
let offer_type = offer_type_rc.clone();
let taker_gets = taker_gets_rc.clone();
let taker_pays = taker_pays_rc.clone();
let tx_json = OfferCreateTxJson::new(account.take(), offer_type.take(), taker_gets.take(), taker_pays.take());
if self.config.local_sign {
let blob = SignTx::with_params(account_seq, &secret.take()).create_offer(&tx_json);
if let Ok(command) = LocalSignTx::new(blob).to_string() {
out.send(command).unwrap()
}
} else {
if let Ok(command) = OfferCreateTx::new(secret.take(), tx_json).to_string() {
out.send(command).unwrap()
}
}
move |msg: ws::Message| {
let c = msg.as_text()?;
copy.set(c.to_string());
out.close(CloseCode::Normal)
}
}).unwrap();
let resp = downcast_to_string(info);
if let Ok(x) = serde_json::from_str(&resp) as Result<Value, serde_json::error::Error> {
if let Some(status) = x["status"].as_str() {
if status == "success" {
let x: String = x["result"].to_string();
if let Ok(v) = serde_json::from_str(&x) as Result<OfferCreateTxResponse, serde_json::error::Error> {
op(Ok(v))
}
} else {
if let Ok(v) = serde_json::from_str(&x.to_string()) as Result<OfferCreateSideKick, serde_json::error::Error> {
op(Err(v))
}
}
}
}
}
}
|
use crate::typ;
pub type TypedModule = Module<Scope<typ::Type>, typ::Type>;
pub type UntypedModule = Module<(), ()>;
#[derive(Debug, Clone, PartialEq)]
pub struct Module<S, T> {
pub name: String,
pub typ: T,
pub statements: Vec<Statement<S, T>>,
}
impl<S, T> Module<S, T> {
pub fn dependancies(&self) -> Vec<String> {
self.statements
.iter()
.flat_map(|s| match s {
Statement::Import { module, .. } => Some(module.clone()),
_ => None,
})
.collect()
}
}
#[test]
fn module_dependencies_test() {
assert_eq!(
vec!["foo".to_string(), "bar".to_string(), "foo_bar".to_string()],
crate::grammar::ModuleParser::new()
.parse("import foo import bar import foo_bar")
.expect("syntax error")
.dependancies()
);
}
#[derive(Debug, Clone, PartialEq)]
pub struct Arg {
pub name: Option<String>,
}
#[derive(Debug, Clone, PartialEq)]
pub struct EnumConstructor {
pub meta: Meta,
pub name: String,
pub args: Vec<Type>,
}
#[derive(Debug, Clone, PartialEq)]
pub enum Type {
Constructor {
meta: Meta,
module: Option<String>,
name: String,
args: Vec<Type>,
},
Map {
meta: Meta,
fields: Vec<(String, Type)>,
tail: Option<Box<Type>>,
},
Module {
meta: Meta,
fields: Vec<(String, Type)>,
tail: Option<Box<Type>>,
},
Fn {
meta: Meta,
args: Vec<Type>,
retrn: Box<Type>,
},
Var {
meta: Meta,
name: String,
},
Tuple {
meta: Meta,
elems: Vec<Type>,
},
}
pub type TypedStatement = Statement<Scope<typ::Type>, typ::Type>;
pub type UntypedStatement = Statement<(), ()>;
#[derive(Debug, Clone, PartialEq)]
pub enum Statement<S, T> {
Fn {
meta: Meta,
name: String,
args: Vec<Arg>,
body: Expr<S, T>,
public: bool,
},
Enum {
meta: Meta,
name: String,
args: Vec<String>,
public: bool,
constructors: Vec<EnumConstructor>,
},
ExternalFn {
meta: Meta,
public: bool,
args: Vec<Type>,
name: String,
retrn: Type,
module: String,
fun: String,
},
ExternalType {
meta: Meta,
public: bool,
name: String,
args: Vec<String>,
},
Import {
meta: Meta,
module: String,
},
}
#[derive(Debug, Clone, PartialEq)]
pub enum BinOp {
Pipe,
And,
Or,
Lt,
LtEq,
Eq,
NotEq,
GtEq,
Gt,
AddInt,
AddFloat,
SubInt,
SubFloat,
MultInt,
MultFloat,
DivInt,
DivFloat,
ModuloInt,
}
pub type TypedScope = Scope<typ::Type>;
#[derive(Debug, Clone, PartialEq)]
pub enum Scope<T> {
/// A locally defined variable or function parameter
Local,
/// An enum constructor or singleton
Enum { arity: usize },
/// A function in the current module
Module { arity: usize },
/// An imported module
Import { module: String },
/// A constant value to be inlined
Constant { value: Box<Expr<Scope<T>, T>> },
}
pub type TypedExpr = Expr<Scope<typ::Type>, typ::Type>;
pub type UntypedExpr = Expr<(), ()>;
#[derive(Debug, PartialEq, Clone)]
pub enum Expr<S, T> {
Int {
meta: Meta,
typ: T,
value: i64,
},
Float {
meta: Meta,
typ: T,
value: f64,
},
String {
meta: Meta,
typ: T,
value: String,
},
Tuple {
meta: Meta,
typ: T,
elems: Vec<Expr<S, T>>,
},
Seq {
meta: Meta,
typ: T,
first: Box<Expr<S, T>>,
then: Box<Expr<S, T>>,
},
Var {
meta: Meta,
typ: T,
scope: S,
name: String,
},
Fn {
meta: Meta,
typ: T,
is_capture: bool,
args: Vec<Arg>,
body: Box<Expr<S, T>>,
},
Nil {
meta: Meta,
typ: T,
},
Cons {
meta: Meta,
typ: T,
head: Box<Expr<S, T>>,
tail: Box<Expr<S, T>>,
},
Call {
meta: Meta,
typ: T,
fun: Box<Expr<S, T>>,
args: Vec<Expr<S, T>>,
},
BinOp {
meta: Meta,
typ: T,
name: BinOp,
left: Box<Expr<S, T>>,
right: Box<Expr<S, T>>,
},
Let {
meta: Meta,
typ: T,
value: Box<Expr<S, T>>,
pattern: Pattern,
then: Box<Expr<S, T>>,
},
Case {
meta: Meta,
typ: T,
subject: Box<Expr<S, T>>,
clauses: Vec<Clause<S, T>>,
},
MapNil {
meta: Meta,
typ: T,
},
MapCons {
meta: Meta,
typ: T,
label: String,
value: Box<Expr<S, T>>,
tail: Box<Expr<S, T>>,
},
MapSelect {
meta: Meta,
typ: T,
label: String,
map: Box<Expr<S, T>>,
},
ModuleSelect {
meta: Meta,
typ: T,
label: String,
module: Box<Expr<S, T>>,
},
}
impl<S, T> Expr<S, T> {
pub fn meta(&self) -> &Meta {
match self {
Expr::Int { meta, .. } => meta,
Expr::Seq { meta, .. } => meta,
Expr::Var { meta, .. } => meta,
Expr::Fn { meta, .. } => meta,
Expr::Nil { meta, .. } => meta,
Expr::Let { meta, .. } => meta,
Expr::Case { meta, .. } => meta,
Expr::Cons { meta, .. } => meta,
Expr::Call { meta, .. } => meta,
Expr::Tuple { meta, .. } => meta,
Expr::Float { meta, .. } => meta,
Expr::BinOp { meta, .. } => meta,
Expr::String { meta, .. } => meta,
Expr::MapNil { meta, .. } => meta,
Expr::MapCons { meta, .. } => meta,
Expr::MapSelect { meta, .. } => meta,
Expr::ModuleSelect { meta, .. } => meta,
}
}
}
impl TypedExpr {
pub fn typ(&self) -> &typ::Type {
match self {
Expr::Int { typ, .. } => typ,
Expr::Float { typ, .. } => typ,
Expr::String { typ, .. } => typ,
Expr::Seq { then, .. } => then.typ(),
Expr::Tuple { typ, .. } => typ,
Expr::Var { typ, .. } => typ,
Expr::Fn { typ, .. } => typ,
Expr::Nil { typ, .. } => typ,
Expr::Cons { typ, .. } => typ,
Expr::Call { typ, .. } => typ,
Expr::BinOp { typ, .. } => typ,
Expr::Let { typ, .. } => typ,
Expr::Case { typ, .. } => typ,
Expr::MapNil { typ, .. } => typ,
Expr::MapCons { typ, .. } => typ,
Expr::MapSelect { typ, .. } => typ,
Expr::ModuleSelect { typ, .. } => typ,
}
}
}
pub type TypedClause = Clause<Scope<typ::Type>, typ::Type>;
pub type UntypedClause = Clause<(), ()>;
#[derive(Debug, Clone, PartialEq)]
pub struct Clause<S, T> {
pub meta: Meta,
pub pattern: Pattern,
pub then: Expr<S, T>,
}
#[derive(Debug, PartialEq, Default, Clone)]
pub struct Meta {
pub start: usize,
pub end: usize,
}
#[derive(Debug, Clone, PartialEq)]
pub enum Pattern {
Int {
meta: Meta,
value: i64,
},
Float {
meta: Meta,
value: f64,
},
String {
meta: Meta,
value: String,
},
Var {
meta: Meta,
name: String,
},
Discard {
meta: Meta,
},
Tuple {
meta: Meta,
elems: Vec<Pattern>,
},
Nil {
meta: Meta,
},
Cons {
meta: Meta,
head: Box<Pattern>,
tail: Box<Pattern>,
},
// Map {
// meta: Meta,
// label: String,
// fields: Vec<(Pattern, Pattern)>,
// },
Constructor {
meta: Meta,
name: String,
args: Vec<Pattern>,
module: Option<String>,
},
}
impl Pattern {
pub fn meta(&self) -> &Meta {
match self {
Pattern::Int { meta, .. } => meta,
Pattern::Var { meta, .. } => meta,
Pattern::Nil { meta, .. } => meta,
Pattern::Cons { meta, .. } => meta,
Pattern::Tuple { meta, .. } => meta,
Pattern::Float { meta, .. } => meta,
Pattern::Discard { meta, .. } => meta,
// Pattern::Map { meta, .. } => meta,
Pattern::String { meta, .. } => meta,
Pattern::Constructor { meta, .. } => meta,
}
}
}
|
pub struct Solution;
impl Solution {
pub fn coin_change(coins: Vec<i32>, amount: i32) -> i32 {
if amount == 0 {
return 0;
}
let mut coins = coins
.into_iter()
.filter(|&c| c <= amount)
.collect::<Vec<i32>>();
if coins.is_empty() {
return -1;
}
coins.sort();
coins.reverse();
let mut res = std::i32::MAX;
rec(&coins, amount, 0, &mut res);
if res == std::i32::MAX {
-1
} else {
res
}
}
}
fn rec(coins: &[i32], amount: i32, count: i32, res: &mut i32) {
let c = coins[0];
if amount % c == 0 {
let new_count = count + amount / c;
if new_count < *res {
*res = new_count;
}
return;
}
if coins.len() == 1 {
return;
}
for k in (0..=amount / c).rev() {
if count + k + (amount - k * c - 1) / coins[1] + 1 >= *res {
break;
}
rec(&coins[1..], amount - k * c, count + k, res);
}
}
#[test]
fn test0322() {
fn case(coins: Vec<i32>, amount: i32, want: i32) {
let got = Solution::coin_change(coins, amount);
assert_eq!(got, want);
}
case(vec![1, 2, 5], 11, 3);
case(vec![2], 3, -1);
case(vec![1, 2147483647], 2, 2);
case(vec![1], 0, 0);
case(vec![288, 160, 10, 249, 40, 77, 314, 429], 9208, 22);
}
|
// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
use log::{error, info};
use omaha_client::{
common::{App, AppSet, UserCounting, Version},
configuration::{Config, Updater},
protocol::{request::OS, Cohort},
};
use std::fs;
use std::io;
/// The source of the channel configuration.
#[derive(Debug, Eq, PartialEq)]
pub enum ChannelSource {
MinFS,
SysConfig,
Default,
}
pub fn get_app_set(version: &str, default_channel: Option<String>) -> (AppSet, ChannelSource) {
let id = match fs::read_to_string("/config/data/omaha_app_id") {
Ok(id) => id,
Err(e) => {
error!("Unable read omaha app id: {:?}", e);
String::new()
}
};
let version = match version.parse::<Version>() {
Ok(version) => version,
Err(e) => {
error!("Unable to parse '{}' as Omaha version format: {:?}", version, e);
Version::from([0])
}
};
let channel_config = sysconfig_client::channel::read_channel_config();
info!("Channel configuration in sysconfig: {:?}", channel_config);
let mut channel = channel_config.map(|config| config.channel_name().to_string()).ok();
let channel_source = if channel.is_some() {
ChannelSource::SysConfig
} else {
channel = default_channel;
if channel.is_some() {
ChannelSource::Default
} else {
// Channel will be loaded from `Storage` by state machine.
ChannelSource::MinFS
}
};
let cohort = Cohort { hint: channel.clone(), name: channel, ..Cohort::default() };
(
// Fuchsia only has a single app.
AppSet::new(vec![App {
id,
version,
fingerprint: None,
cohort,
user_counting: UserCounting::ClientRegulatedByDate(None),
}]),
channel_source,
)
}
pub fn get_config(version: &str) -> Config {
Config {
updater: Updater { name: "Fuchsia".to_string(), version: Version::from([0, 0, 1, 0]) },
os: OS {
platform: "Fuchsia".to_string(),
version: version.to_string(),
service_pack: "".to_string(),
arch: std::env::consts::ARCH.to_string(),
},
service_url: "https://clients2.google.com/service/update2/fuchsia/json".to_string(),
}
}
pub fn get_version() -> Result<String, io::Error> {
fs::read_to_string("/config/build-info/version").map(|s| s.trim_end().to_string())
}
#[cfg(test)]
mod tests {
use super::*;
use fuchsia_async as fasync;
#[test]
fn test_get_config() {
let config = get_config("1.2.3.4");
assert_eq!(config.updater.name, "Fuchsia");
let os = config.os;
assert_eq!(os.platform, "Fuchsia");
assert_eq!(os.version, "1.2.3.4");
assert_eq!(os.arch, std::env::consts::ARCH);
assert_eq!(config.service_url, "https://clients2.google.com/service/update2/fuchsia/json");
}
#[fasync::run_singlethreaded(test)]
async fn test_get_app_set() {
let (app_set, channel_source) = get_app_set("1.2.3.4", None);
assert_eq!(channel_source, ChannelSource::MinFS);
let apps = app_set.to_vec().await;
assert_eq!(apps.len(), 1);
assert_eq!(apps[0].id, "fuchsia:test-app-id");
assert_eq!(apps[0].version, Version::from([1, 2, 3, 4]));
assert_eq!(apps[0].cohort.name, None);
assert_eq!(apps[0].cohort.hint, None);
}
#[fasync::run_singlethreaded(test)]
async fn test_get_app_set_default_channel() {
let (app_set, channel_source) = get_app_set("1.2.3.4", Some("default-channel".to_string()));
assert_eq!(channel_source, ChannelSource::Default);
let apps = app_set.to_vec().await;
assert_eq!(apps.len(), 1);
assert_eq!(apps[0].id, "fuchsia:test-app-id");
assert_eq!(apps[0].version, Version::from([1, 2, 3, 4]));
assert_eq!(apps[0].cohort.name, Some("default-channel".to_string()));
assert_eq!(apps[0].cohort.hint, Some("default-channel".to_string()));
}
#[fasync::run_singlethreaded(test)]
async fn test_get_app_set_invalid_version() {
let (app_set, _) = get_app_set("invalid version", None);
let apps = app_set.to_vec().await;
assert_eq!(apps[0].version, Version::from([0]));
}
}
|
extern crate yahtzeevalue;
use yahtzeevalue::*;
use yahtzeevalue::constants::*;
fn main() {
let mut best_score = vec![0xFFFFu16; (1 + BONUS_LIMIT as usize) << 18];
let mut best_so_far = 0;
best_score[0] = 0;
let mut skipped = 0;
for i in 0..best_score.len() {
if best_score[i] == 0xFFFF {
skipped += 1;
continue;
}
if i % 10000 == 0 {
println!("{:7} {:3} {:?}", skipped, best_score[i], State::decode(i as u32));
}
let ub = best_score[i] + State::decode(i as u32).upper_bound_points() as u16;
best_so_far = best_so_far.max(best_score[i]);
let mut ub_correct = false;
let s = State::decode(i as u32);
for o in outcomes() {
actions(s, o, |action, next_state, points| {
let s = best_score[i] + points as u16;
let ub2 = s + next_state.upper_bound_points() as u16;
if ub2 > ub {
println!("{:?} with {:?} {:?} => {:?}, {} + {} + {} = {} > {}",
State::decode(i as u32),
o, action,
next_state,
best_score[i],
points,
next_state.upper_bound_points(),
ub2, ub);
}
assert!(ub2 <= ub);
if ub == ub2 {
ub_correct = true;
}
let next_state = next_state.encode() as usize;
assert!(next_state > i);
if best_score[next_state] == 0xFFFF {
best_score[next_state] = s;
} else {
best_score[next_state] = best_score[next_state].max(s);
}
});
}
if !ub_correct {
println!("TEST {:3} {:3} {:?}", best_score[i], ub, State::decode(i as u32));
}
}
println!("Skipped: {}", skipped);
}
|
use std::os::raw::c_char;
use std::ffi::{CStr, c_void};
use std::fmt;
#[repr(C)]
pub struct FILE {
path: *const c_char,
mode: *const c_char,
}
impl fmt::Display for FILE {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let path: &CStr = unsafe { CStr::from_ptr(self.path) };
let mode: &CStr = unsafe { CStr::from_ptr(self.mode) };
write!(f, "File path={}, mode={}", path.to_str().unwrap(), mode.to_str().unwrap())
}
}
#[no_mangle]
pub unsafe extern fn fopen(path: *const c_char, mode: *const c_char) -> *mut FILE {
println!("fopen");
Box::into_raw(Box::new(FILE {
path,
mode,
}))
}
#[no_mangle]
pub unsafe extern fn fprintf(file: *mut FILE, format: *const c_char, ...) -> i32 {
println!("fprintf");
println!("{}", &mut *file);
0
}
#[no_mangle]
pub unsafe extern "C" fn fputs(string: *const c_char, file: *mut FILE) -> i32 {
println!("fputs");
println!("{}", &mut *file);
0
}
#[no_mangle]
pub unsafe extern "C" fn puts(string: *const c_char) -> i32 {
println!("puts");
let message: &CStr = CStr::from_ptr(string);
println!("{}", message.to_str().unwrap());
0
}
#[no_mangle]
pub unsafe extern "C" fn fwrite(pointer: *const c_void, size: usize, count: usize, file: *mut FILE) -> usize {
println!("fwrite");
println!("{}", &mut *file);
0
}
#[no_mangle]
pub unsafe extern "C" fn fread(pointer: *mut c_void, size: usize, count: usize, file: *mut FILE) -> usize {
println!("fread");
println!("{}", &mut *file);
0
}
#[no_mangle]
pub unsafe extern "C" fn fclose(file: *mut FILE) -> i32 {
println!("fclose");
println!("{}", &mut *file);
0
}
|
fn main() {
let stdin = std::io::stdin();
let mut rd = ProconReader::new(stdin.lock());
let n: u64 = rd.get();
let m: usize = rd.get();
if m == 0 {
println!("1");
return;
}
let mut a: Vec<u64> = rd.get_vec(m);
a.sort();
let a = [vec![0], a, vec![n + 1]].concat();
let dists: Vec<u64> = a.windows(2).map(|w| w[1] - w[0] - 1).collect();
// println!("{:?}", dists);
let dists: Vec<u64> = dists.into_iter().filter(|&x| x > 0).collect();
if dists.is_empty() {
println!("{}", 0);
return;
}
let k = *dists.iter().min().unwrap();
let ans = dists.iter().fold(0u64, |acc, &d| acc + (d + k - 1) / k);
println!("{}", ans);
}
pub struct ProconReader<R> {
r: R,
line: String,
i: usize,
}
impl<R: std::io::BufRead> ProconReader<R> {
pub fn new(reader: R) -> Self {
Self {
r: reader,
line: String::new(),
i: 0,
}
}
pub fn get<T>(&mut self) -> T
where
T: std::str::FromStr,
<T as std::str::FromStr>::Err: std::fmt::Debug,
{
self.skip_blanks();
assert!(self.i < self.line.len());
assert_ne!(&self.line[self.i..=self.i], " ");
let line = &self.line[self.i..];
let end = line.find(' ').unwrap_or_else(|| line.len());
let s = &line[..end];
self.i += end;
s.parse()
.unwrap_or_else(|_| panic!("parse error `{}`", self.line))
}
fn skip_blanks(&mut self) {
loop {
let start = self.line[self.i..].find(|ch| ch != ' ');
match start {
Some(j) => {
self.i += j;
break;
}
None => {
self.line.clear();
self.i = 0;
let num_bytes = self.r.read_line(&mut self.line).unwrap();
assert!(num_bytes > 0, "reached EOF :(");
self.line = self.line.trim_end_matches(&['\r', '\n'][..]).to_string();
}
}
}
}
pub fn get_vec<T>(&mut self, n: usize) -> Vec<T>
where
T: std::str::FromStr,
<T as std::str::FromStr>::Err: std::fmt::Debug,
{
(0..n).map(|_| self.get()).collect()
}
}
#[cfg(test)]
mod tests {
use crate::ProconReader;
use std::io::Cursor;
fn get<T>(input: &str) -> T
where
T: std::str::FromStr,
<T as std::str::FromStr>::Err: std::fmt::Debug,
{
ProconReader::new(Cursor::new(input)).get()
}
#[test]
fn test_single() {
assert_eq!(get::<usize>("123"), 123);
assert_eq!(get::<i32>("-123"), -123);
assert_eq!(get::<char>("a"), 'a');
assert_eq!(get::<String>("abc"), "abc");
}
#[test]
fn test_space_separated() {
let input = "123 -123 a abc";
let mut rd = ProconReader::new(Cursor::new(input));
assert_eq!(rd.get::<usize>(), 123);
assert_eq!(rd.get::<i32>(), -123);
assert_eq!(rd.get::<char>(), 'a');
assert_eq!(rd.get::<String>(), "abc");
}
#[test]
fn test_line_separated() {
let input = "123\n-123\n\n\na\nabc";
let mut rd = ProconReader::new(Cursor::new(input));
assert_eq!(rd.get::<usize>(), 123);
assert_eq!(rd.get::<i32>(), -123);
assert_eq!(rd.get::<char>(), 'a');
assert_eq!(rd.get::<String>(), "abc");
}
fn get_vec<T>(input: &str, n: usize) -> Vec<T>
where
T: std::str::FromStr,
<T as std::str::FromStr>::Err: std::fmt::Debug,
{
ProconReader::new(Cursor::new(input)).get_vec(n)
}
#[test]
fn test_get_vec() {
assert_eq!(get_vec::<i32>("1 23 -456", 3), vec![1, 23, -456]);
assert_eq!(get_vec::<String>("abc\nde\nf", 3), vec!["abc", "de", "f"]);
}
#[test]
#[should_panic(expected = "reached EOF")]
fn too_many_get() {
let input = "123";
let mut rd = ProconReader::new(Cursor::new(input));
rd.get::<usize>(); // 123
rd.get::<usize>();
}
#[test]
#[should_panic]
fn cannot_parse_string_as_char() {
let input = "abc";
let mut rd = ProconReader::new(Cursor::new(input));
rd.get::<char>(); // mismatch type
}
}
|
pub fn borrow_stuff() {
//TODO pepper with more examples from chp4
let mut mutable_string = String::from("hello");
// mutable reference, max of 1 per value.
change(&mut mutable_string);
println!("the old familiar: {}.", mutable_string);
let string = String::from("hello");
// change sig has mutable borrow but string is declared immutable
//f::change(&mut string);
// println!("the old familiar: {}.", string);
// value of string moves into other_string and is dropped.
let other_string = string;
println!("Other string is still valid!: {}.", other_string)
// println! fails because value was already moved, println can't borrow.
//println!("STRING: {}.", string)
} // all values defined go out of scope and are dropped.
fn change(s: &mut String) {
s.push_str(", world!")
}
|
use domain_patterns::collections::Repository;
use survey_manager_core::survey::Survey;
use survey_manager_core::dtos::SurveyDTO;
use domain_patterns::models::{Entity, AggregateRoot};
use mysql;
use mysql::Error;
use mysql::error::ServerError;
pub struct MysqlSurveyWriteRepository {
// A single connection to Mysql. Handed down from a pool likely.
conn: mysql::PooledConn,
}
impl MysqlSurveyWriteRepository {
pub fn new() -> MysqlSurveyWriteRepository {
let pool = super::MYSQL_POOL.clone();
MysqlSurveyWriteRepository {
conn: pool.get_conn().unwrap(),
}
}
}
impl Repository<Survey> for MysqlSurveyWriteRepository {
type Error = mysql::Error;
fn insert(&mut self, entity: &Survey) -> Result<Option<String>, Self::Error> {
let survey_dto: SurveyDTO = entity.into();
let survey_json = serde_json::to_string(&survey_dto).unwrap();
// In this example survey_data is json of the entire survey object. the other fields are just useful for query purposes and duplicate data.
if let Err(e) = self.conn.prep_exec(
"INSERT INTO survey (id, version, author, title, category, created_on, survey_data) VALUES (?, ?, ?, ?, ?, ?, ?)",
(entity.id(), entity.version(), entity.author().to_string(), entity.title().to_string(), entity.category().to_string(), entity.created_on(), survey_json)
) {
return handle_duplicate_key(e);
};
// Success. Return the PK back as is.
Ok(Some(survey_dto.id))
}
fn get(&mut self, key: &String) -> Result<Option<Survey>, Self::Error> {
let survey_result: Option<SurveyDTO> =
match self.conn.prep_exec(
"SELECT survey_data FROM survey WHERE id=?",
(key,)
) {
Ok(mut q_result) => {
if let Some(row_result) = q_result.next() {
let row = row_result?;
let survey_data: String = mysql::from_row(row);
// TODO: Rather than using mysql-simple error type, create your own and attach theirs to yours
// so you can include serde serialization errors.
serde_json::from_str(&survey_data).unwrap()
} else {
None
}
},
Err(e) => {
return Err(e);
},
};
if let Some(survey_dto) = survey_result {
return Ok(Some(survey_dto.into()))
}
Ok(None)
}
// Intentionally leaving this unimplemented. we don't need it for command side.
#[allow(unused)]
fn get_paged(&mut self, page_num: usize, page_size: usize) -> Result<Option<Vec<Survey>>, Self::Error> {
unimplemented!()
}
fn update(&mut self, entity: &Survey) -> Result<Option<String>, Self::Error> {
let survey_dto: SurveyDTO = entity.into();
let survey_json = serde_json::to_string(&survey_dto).unwrap();
// In this example survey_data is json of the entire survey object. the other fields are just useful for query purposes and duplicate data.
match self.conn.prep_exec(
"UPDATE survey SET version = ?, title = ?, category = ?, survey_data = ? WHERE id = ?",
(entity.version(), entity.title().to_string(), entity.category().to_string(), survey_json, entity.id())
) {
Ok(result) => {
if result.affected_rows() == 0 {
return Ok(None);
}
},
Err(e) => {
return Err(e);
}
};
// Success. Return the PK back as is.
Ok(Some(survey_dto.id))
}
fn remove(&mut self, key: &String) -> Result<Option<String>, Self::Error> {
match self.conn.prep_exec(
"DELETE FROM survey WHERE id = ?",
(key,)
) {
Ok(result) => {
if result.affected_rows() == 0 {
return Ok(None);
}
},
Err(e) => {
return Err(e);
}
};
// Success. Return the PK back as is.
Ok(Some(key.clone()))
}
}
fn handle_duplicate_key(error: mysql::Error) -> Result<Option<String>, mysql::Error> {
if let Error::MySqlError(e) = error {
if e.code == ServerError::ER_DUP_ENTRY as u16 {
return Ok(None);
}
// Some other code, so return the error.
// TODO: Add ways to deal with other errors as we actually enounter them.
return Err(Error::MySqlError(e))
}
// TODO: Add ways to deal with other errors as we actually enounter them.
return Err(error);
}
|
mod print_vector_references;
fn main() {
print_vector_references::print_vectors();
} |
//! To run this code, clone the rusty_engine repository and run the command:
//!
//! cargo run --release --example keyboard_events
use rusty_engine::prelude::*;
fn main() {
let mut game = Game::new();
let mut race_car = game.add_sprite("Race Car", SpritePreset::RacingCarGreen);
race_car.translation = Vec2::new(0.0, 0.0);
race_car.rotation = UP;
race_car.scale = 1.0;
let instructions = "Discrete Movement with Keyboard Events\n==============================\nChange translation (move): w a s d / arrows\nChange Rotation: z c\nChange Scale: + -";
let text = game.add_text("instructions", instructions);
text.translation.y = 250.0;
game.add_logic(logic);
game.run(());
}
fn logic(game_state: &mut Engine, _: &mut ()) {
// Get the race car sprite
let race_car = game_state.sprites.get_mut("Race Car").unwrap();
// Loop through any keyboard input that hasn't been processed this frame
for keyboard_event in &game_state.keyboard_events {
if let KeyboardInput {
scan_code: _,
key_code: Some(key_code),
state: ButtonState::Pressed,
} = keyboard_event
{
// Handle various keypresses. The extra keys are for the Dvorak keyboard layout. ;-)
match key_code {
KeyCode::A | KeyCode::Left => race_car.translation.x -= 10.0,
KeyCode::D | KeyCode::Right | KeyCode::E => race_car.translation.x += 10.0,
KeyCode::O | KeyCode::Down | KeyCode::S => race_car.translation.y -= 10.0,
KeyCode::W | KeyCode::Up | KeyCode::Comma => race_car.translation.y += 10.0,
KeyCode::Z | KeyCode::Semicolon => race_car.rotation += std::f32::consts::FRAC_PI_4,
KeyCode::C | KeyCode::J => race_car.rotation -= std::f32::consts::FRAC_PI_4,
KeyCode::Plus | KeyCode::Equals => race_car.scale *= 1.1,
KeyCode::Minus | KeyCode::Underline => race_car.scale *= 0.9,
_ => {}
}
// Clamp the scale to a certain range so the scaling is reasonable
race_car.scale = race_car.scale.clamp(0.1, 3.0);
// Clamp the translation so that the car stays on the screen
race_car.translation = race_car.translation.clamp(
-game_state.window_dimensions * 0.5,
game_state.window_dimensions * 0.5,
);
}
}
}
|
use crate::cpp_data::{CppItem, CppPath, CppPathItem, CppTypeDeclaration};
use crate::cpp_function::{CppFunction, CppFunctionArgument, CppOperator};
use crate::cpp_type::CppType;
use crate::database::{DatabaseClient, ItemWithSource};
use crate::processor::ProcessorData;
use log::{debug, trace};
use ritual_common::errors::{bail, err_msg, Result};
use ritual_common::utils::MapIfOk;
/// Returns true if `type1` is a known template instantiation.
fn check_template_type(data: &ProcessorData<'_>, type1: &CppType) -> Result<()> {
match &type1 {
CppType::Class(path) => {
if let Some(template_arguments) = &path.last().template_arguments {
let is_available = data
.db
.all_cpp_items()
.filter_map(|i| i.item.as_type_ref())
.any(|inst| &inst.path == path);
if !is_available {
bail!("type is not available: {:?}", type1);
}
for arg in template_arguments {
check_template_type(data, arg)?;
}
}
}
CppType::PointerLike { ref target, .. } => {
check_template_type(data, target)?;
}
_ => {}
}
Ok(())
}
/// Tries to apply each of `template_instantiations` to `function`.
/// Only types at the specified `nested_level` are replaced.
/// Returns `Err` if any of `template_instantiations` is incompatible
/// with the function.
pub fn instantiate_function(
function: &CppFunction,
nested_level: usize,
arguments: &[CppType],
) -> Result<CppFunction> {
let mut new_method = function.clone();
new_method.arguments.clear();
for arg in &function.arguments {
new_method.arguments.push(CppFunctionArgument {
name: arg.name.clone(),
has_default_value: arg.has_default_value,
argument_type: arg.argument_type.instantiate(nested_level, arguments)?,
});
}
new_method.return_type = function.return_type.instantiate(nested_level, arguments)?;
new_method.path = new_method.path.instantiate(nested_level, arguments)?;
if let Some(args) = &new_method.path.last().template_arguments {
if args
.iter()
.any(|arg| arg.is_or_contains_template_parameter())
{
bail!(
"extra template parameters left: {}",
new_method.short_text()
);
}
if function.can_infer_template_arguments() {
// explicitly specifying template arguments sometimes causes compiler errors,
// so we prefer to get them inferred
new_method.path.last_mut().template_arguments = None;
}
}
let mut conversion_type = None;
if let Some(CppOperator::Conversion(cpp_type)) = &mut new_method.operator {
let r = cpp_type.instantiate(nested_level, arguments)?;
*cpp_type = r.clone();
conversion_type = Some(r);
}
if new_method
.all_involved_types()
.iter()
.any(CppType::is_or_contains_template_parameter)
{
bail!(
"extra template parameters left: {}",
new_method.short_text()
);
} else {
if let Some(conversion_type) = conversion_type {
*new_method.path.last_mut() = CppPathItem {
name: format!("operator {}", conversion_type.to_cpp_code(None)?),
template_arguments: None,
};
}
trace!("success: {}", new_method.short_text());
Ok(new_method)
}
}
// TODO: instantiations of QObject::findChild and QObject::findChildren should be available
#[derive(Debug)]
struct Substitution<'a> {
nested_level: usize,
arguments: &'a [CppType],
}
fn find_suitable_template_arguments<'a>(
path: &CppPath,
db: &'a DatabaseClient,
) -> Result<Vec<Substitution<'a>>> {
let mut current_path = path.clone();
let mut result = Vec::new();
loop {
if let Some(template_arguments) = ¤t_path.last().template_arguments {
assert!(!template_arguments.is_empty());
if template_arguments.iter().all(|t| t.is_template_parameter()) {
let items =
db.cpp_items()
.filter_map(|item| item.item.as_type_ref())
.filter(|type1| {
type1.path.parent_parts().ok() == current_path.parent_parts().ok()
&& type1.path.last().name == current_path.last().name
&& type1.path.last().template_arguments.as_ref().map_or(
false,
|args| {
!args.iter().all(CppType::is_or_contains_template_parameter)
},
)
})
.map_if_ok(|type1| {
let nested_level =
if let CppType::TemplateParameter(param) = &template_arguments[0] {
param.nested_level
} else {
bail!("only template parameters can be here");
};
let arguments = type1
.path
.last()
.template_arguments
.as_ref()
.ok_or_else(|| {
err_msg("template instantiation must have template arguments")
})?;
Ok(Substitution {
nested_level,
arguments,
})
})?;
result.extend(items);
}
}
if let Ok(p) = current_path.parent() {
current_path = p;
} else {
return Ok(result);
}
}
}
fn instantiate_types(data: &mut ProcessorData<'_>) -> Result<()> {
loop {
let mut new_types = Vec::<ItemWithSource<_>>::new();
for type1 in data
.db
.all_cpp_items()
.filter_map(|item| item.filter_map(|item| item.as_type_ref()))
{
trace!("class: {}", type1.item.path.to_cpp_pseudo_code());
for substitution in find_suitable_template_arguments(&type1.item.path, data.db)? {
trace!("found template instantiation: {:?}", substitution);
let new_type = CppTypeDeclaration {
kind: type1.item.kind.clone(),
path: type1
.item
.path
.instantiate(substitution.nested_level, substitution.arguments)?,
};
if data
.db
.all_cpp_items()
.filter_map(|item| item.item.as_type_ref())
.any(|item| item.is_same(&new_type))
|| new_types.iter().any(|item| item.item == new_type)
{
trace!("type already exists");
continue;
}
new_types.push(ItemWithSource::new(&type1.id, new_type));
}
}
let any_found = !new_types.is_empty();
for new_type in new_types {
data.add_cpp_item(Some(new_type.source_id), CppItem::Type(new_type.item))?;
}
if !any_found {
break;
}
}
Ok(())
}
fn instantiate_functions(data: &mut ProcessorData<'_>) -> Result<()> {
let mut new_methods = Vec::new();
for item in data.db.all_cpp_items() {
let function = if let Some(f) = item.item.as_function_ref() {
f
} else {
continue;
};
for type1 in function.all_involved_types() {
let path = match &type1 {
CppType::Class(class_type) => class_type,
CppType::PointerLike { target, .. } => match &**target {
CppType::Class(class_type) => class_type,
_ => continue,
},
_ => continue,
};
for substitution in find_suitable_template_arguments(path, data.db)? {
trace!("method: {}", function.short_text());
trace!("found template instantiation: {:?}", substitution);
match instantiate_function(
function,
substitution.nested_level,
substitution.arguments,
) {
Ok(method) => {
let mut ok = true;
for type1 in method.all_involved_types() {
match check_template_type(&data, &type1) {
Ok(_) => {}
Err(msg) => {
ok = false;
trace!("method is not accepted: {}", method.short_text());
trace!(" {}", msg);
}
}
}
if ok {
if data
.db
.all_cpp_items()
.filter_map(|item| item.item.as_function_ref())
.any(|item| item.is_same(&method))
{
trace!("this method already exists");
} else {
new_methods.push(ItemWithSource::new(&item.id, method));
}
}
}
Err(msg) => trace!("failed: {}", msg),
}
}
}
}
for new_method in new_methods {
data.add_cpp_item(
Some(new_method.source_id),
CppItem::Function(new_method.item),
)?;
}
Ok(())
}
/// Generates methods as template instantiations of
/// methods of existing template classes and existing template methods.
pub fn instantiate_templates(data: &mut ProcessorData<'_>) -> Result<()> {
instantiate_types(data)?;
instantiate_functions(data)?;
Ok(())
}
/// Searches for template instantiations in this library's API,
/// excluding results that were already processed in dependencies.
pub fn find_template_instantiations(data: &mut ProcessorData<'_>) -> Result<()> {
fn check_type(type1: &CppType, data: &ProcessorData<'_>, result: &mut Vec<CppPath>) {
match &type1 {
CppType::Class(path) => {
if let Some(template_arguments) = &path.last().template_arguments {
if !template_arguments
.iter()
.any(CppType::is_or_contains_template_parameter)
{
let is_in_database = data
.db
.all_cpp_items()
.filter_map(|item| item.item.as_type_ref())
.any(|i| &i.path == path);
if !is_in_database {
let is_in_result = result.iter().any(|x| x == path);
if !is_in_result {
result.push(path.clone());
}
}
}
for arg in template_arguments {
check_type(arg, &data, result);
}
}
}
CppType::PointerLike { target, .. } => check_type(target, data, result),
_ => {}
}
}
let mut result = Vec::new();
for item in data.db.cpp_items() {
for type1 in item.item.all_involved_types() {
check_type(&type1, &data, &mut result);
}
}
for item in result {
let original_type = data
.db
.all_cpp_items()
.filter_map(|x| x.filter_map(|item| item.as_type_ref()))
.find(|t| {
let t = &t.item;
t.path.parent_parts().ok() == item.parent_parts().ok()
&& t.path.last().name == item.last().name
&& t.path
.last()
.template_arguments
.as_ref()
.map_or(false, |args| {
args.iter().all(CppType::is_template_parameter)
})
});
if let Some(original_type) = original_type {
let mut new_type = original_type.item.clone();
new_type.path = item;
let source_id = original_type.id.clone();
data.add_cpp_item(Some(source_id), CppItem::Type(new_type))?;
} else {
debug!(
"original type not found for instantiation: {}",
item.to_cpp_pseudo_code()
);
}
}
Ok(())
}
|
// Copyright (c) 2021 Quark Container Authors / 2018 The gVisor Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use alloc::string::String;
use alloc::string::ToString;
use super::epoll_entry::*;
#[derive(Default)]
pub struct PollEntryList {
head: Option<PollEntry>,
tail: Option<PollEntry>,
}
impl PollEntryList {
pub fn GetString(&self) -> String {
let mut item = self.head.clone();
let mut output = "".to_string();
while item.is_some() {
let node = item.unwrap();
output += &format!("{} ", node.Id());
item = node.lock().next.clone();
}
return output
}
//remove all of the wait entries
pub fn Reset(&mut self) {
let mut cur = self.head.take();
self.tail = None;
while cur.is_some() {
let tmp = cur.clone().unwrap();
let next = tmp.lock().next.clone();
cur = next;
}
}
pub fn Empty(&self) -> bool {
return self.head.is_none()
}
pub fn Front(&self) -> Option<PollEntry> {
return self.head.clone();
}
pub fn Back(&self) -> Option<PollEntry> {
return self.tail.clone();
}
pub fn PushFront(&mut self, e: &PollEntry) {
if self.head.is_none() {
//empty
self.head = Some(e.clone());
self.tail = Some(e.clone())
} else {
let head = self.head.take().unwrap();
e.lock().next = Some(head.clone());
head.lock().prev = Some(e.clone());
self.head = Some(e.clone());
}
}
pub fn PushBack(&mut self, e: &PollEntry) {
if self.head.is_none() {
//empty
self.head = Some(e.clone());
self.tail = Some(e.clone())
} else {
//info!("self.head.is_none() is {}, self.tail.is_none() is {}",
// self.head.is_none(), self.tail.is_none());
let tail = self.tail.take().unwrap();
e.lock().prev = Some(tail.clone());
tail.lock().next = Some(e.clone());
self.tail = Some(e.clone());
}
}
pub fn PushBackList(&mut self, m: &mut PollEntryList) {
let head = m.head.take();
let tail = m.tail.take();
if head.is_none() {
return;
}
if self.head.is_none() {
self.head = head;
self.tail = tail;
} else {
self.tail.as_ref().unwrap().SetNext(head.clone());
head.as_ref().unwrap().SetPrev(self.tail.clone());
self.tail = tail;
}
}
pub fn RemoveAll(&mut self) {
self.Reset();
}
pub fn Remove(&mut self, e: &PollEntry) {
if e.lock().prev.is_none() {
//head
self.head = e.lock().next.clone();
} else {
let lock = e.lock();
lock.prev.clone().unwrap().lock().next = lock.next.clone();
}
if e.lock().next.is_none() {
//tail
self.tail = e.lock().prev.clone();
} else {
let lock = e.lock();
lock.next.clone().unwrap().lock().prev = lock.prev.clone();
}
e.Reset();
}
}
|
import front.ast;
import front.ast.ident;
import front.ast.def;
import front.ast.ann;
import front.creader;
import driver.session;
import util.common.new_def_hash;
import util.common.span;
import util.typestate_ann.ts_ann;
import std.map.hashmap;
import std.list.list;
import std.list.nil;
import std.list.cons;
import std.option;
import std.option.some;
import std.option.none;
import std._str;
import std._vec;
tag scope {
scope_crate(@ast.crate);
scope_item(@ast.item);
scope_native_item(@ast.native_item);
scope_external_mod(ast.def_id, vec[ast.ident]);
scope_loop(@ast.decl); // there's only 1 decl per loop.
scope_block(ast.block);
scope_arm(ast.arm);
}
type env = rec(list[scope] scopes,
session.session sess);
tag namespace {
ns_value;
ns_type;
}
type import_map = std.map.hashmap[ast.def_id,def_wrap];
// A simple wrapper over defs that stores a bit more information about modules
// and uses so that we can use the regular lookup_name when resolving imports.
tag def_wrap {
def_wrap_use(@ast.view_item);
def_wrap_import(@ast.view_item);
def_wrap_mod(@ast.item);
def_wrap_native_mod(@ast.item);
def_wrap_external_mod(ast.def_id);
def_wrap_external_native_mod(ast.def_id);
def_wrap_other(def);
def_wrap_expr_field(uint, def);
def_wrap_resolving;
}
fn unwrap_def(def_wrap d) -> def {
alt (d) {
case (def_wrap_use(?it)) {
alt (it.node) {
case (ast.view_item_use(_, _, ?id, _)) {
ret ast.def_use(id);
}
}
}
case (def_wrap_import(?it)) {
alt (it.node) {
case (ast.view_item_import(_, _, ?id, ?target_def)) {
alt (target_def) {
case (some[def](?d)) {
ret d;
}
case (none[def]) {
fail;
}
}
}
}
}
case (def_wrap_mod(?m)) {
alt (m.node) {
case (ast.item_mod(_, _, ?id)) {
ret ast.def_mod(id);
}
}
}
case (def_wrap_native_mod(?m)) {
alt (m.node) {
case (ast.item_native_mod(_, _, ?id)) {
ret ast.def_native_mod(id);
}
}
}
case (def_wrap_external_mod(?mod_id)) {
ret ast.def_mod(mod_id);
}
case (def_wrap_external_native_mod(?mod_id)) {
ret ast.def_native_mod(mod_id);
}
case (def_wrap_other(?d)) {
ret d;
}
case (def_wrap_expr_field(_, ?d)) {
ret d;
}
}
}
fn lookup_external_def(session.session sess, int cnum, vec[ident] idents)
-> option.t[def_wrap] {
alt (creader.lookup_def(sess, cnum, idents)) {
case (none[ast.def]) {
ret none[def_wrap];
}
case (some[ast.def](?def)) {
auto dw;
alt (def) {
case (ast.def_mod(?mod_id)) {
dw = def_wrap_external_mod(mod_id);
}
case (ast.def_native_mod(?mod_id)) {
dw = def_wrap_external_native_mod(mod_id);
}
case (_) {
dw = def_wrap_other(def);
}
}
ret some[def_wrap](dw);
}
}
}
// Follow the path of an import and return what it ultimately points to.
// If used after imports are resolved, import_id is none.
fn find_final_def(&env e, import_map index,
&span sp, vec[ident] idents, namespace ns,
option.t[ast.def_id] import_id) -> def_wrap {
// We are given a series of identifiers (p.q.r) and we know that
// in the environment 'e' the identifier 'p' was resolved to 'd'. We
// should return what p.q.r points to in the end.
fn found_something(&env e, import_map index,
&span sp, vec[ident] idents, namespace ns,
def_wrap d) -> def_wrap {
fn found_mod(&env e, &import_map index, &span sp,
vec[ident] idents, namespace ns,
@ast.item i) -> def_wrap {
auto len = _vec.len[ident](idents);
auto rest_idents = _vec.slice[ident](idents, 1u, len);
auto empty_e = rec(scopes = nil[scope],
sess = e.sess);
auto tmp_e = update_env_for_item(empty_e, i);
auto next_i = rest_idents.(0);
auto next_ = lookup_name_wrapped(tmp_e, next_i, ns);
alt (next_) {
case (none[tup(@env, def_wrap)]) {
e.sess.span_err(sp, "unresolved name: " + next_i);
fail;
}
case (some[tup(@env, def_wrap)](?next)) {
auto combined_e = update_env_for_item(e, i);
ret found_something(combined_e, index, sp,
rest_idents, ns, next._1);
}
}
}
// TODO: Refactor with above.
fn found_external_mod(&env e, &import_map index, &span sp,
vec[ident] idents, namespace ns,
ast.def_id mod_id)
-> def_wrap {
auto len = _vec.len[ident](idents);
auto rest_idents = _vec.slice[ident](idents, 1u, len);
auto empty_e = rec(scopes = nil[scope], sess = e.sess);
auto tmp_e = update_env_for_external_mod(empty_e, mod_id, idents);
auto next_i = rest_idents.(0);
auto next_ = lookup_name_wrapped(tmp_e, next_i, ns);
alt (next_) {
case (none[tup(@env, def_wrap)]) {
e.sess.span_err(sp, "unresolved name: " + next_i);
fail;
}
case (some[tup(@env, def_wrap)](?next)) {
auto combined_e = update_env_for_external_mod(e,
mod_id,
idents);
ret found_something(combined_e, index, sp,
rest_idents, ns, next._1);
}
}
}
fn found_crate(&env e, &import_map index, &span sp,
vec[ident] idents, int cnum) -> def_wrap {
auto len = _vec.len[ident](idents);
auto rest_idents = _vec.slice[ident](idents, 1u, len);
alt (lookup_external_def(e.sess, cnum, rest_idents)) {
case (none[def_wrap]) {
e.sess.span_err(sp, #fmt("unbound name '%s'",
_str.connect(idents, ".")));
fail;
}
case (some[def_wrap](?dw)) { ret dw; }
}
}
alt (d) {
case (def_wrap_import(?imp)) {
alt (imp.node) {
case (ast.view_item_import(_, ?new_idents, ?d, _)) {
auto x = find_final_def(e, index, sp, new_idents, ns,
some(d));
ret found_something(e, index, sp, idents, ns, x);
}
}
}
case (_) {
}
}
auto len = _vec.len[ident](idents);
if (len == 1u) {
ret d;
}
alt (d) {
case (def_wrap_mod(?i)) {
ret found_mod(e, index, sp, idents, ns, i);
}
case (def_wrap_native_mod(?i)) {
ret found_mod(e, index, sp, idents, ns, i);
}
case (def_wrap_external_mod(?mod_id)) {
ret found_external_mod(e, index, sp, idents, ns, mod_id);
}
case (def_wrap_external_native_mod(?mod_id)) {
ret found_external_mod(e, index, sp, idents, ns, mod_id);
}
case (def_wrap_use(?vi)) {
alt (vi.node) {
case (ast.view_item_use(_, _, _, ?cnum_opt)) {
auto cnum = option.get[int](cnum_opt);
ret found_crate(e, index, sp, idents, cnum);
}
}
}
case (def_wrap_other(?d)) {
let uint l = _vec.len[ident](idents);
ret def_wrap_expr_field(l, d);
}
}
fail;
}
if (import_id != none[ast.def_id]) {
alt (index.find(option.get[ast.def_id](import_id))) {
case (some[def_wrap](?x)) {
alt (x) {
case (def_wrap_resolving) {
e.sess.span_err(sp, "cyclic import");
fail;
}
case (_) {
ret x;
}
}
}
case (none[def_wrap]) {
}
}
index.insert(option.get[ast.def_id](import_id), def_wrap_resolving);
}
auto first = idents.(0);
auto d_ = lookup_name_wrapped(e, first, ns);
alt (d_) {
case (none[tup(@env, def_wrap)]) {
e.sess.span_err(sp, "unresolved name: " + first);
fail;
}
case (some[tup(@env, def_wrap)](?d)) {
auto x = found_something(*d._0, index, sp, idents, ns, d._1);
if (import_id != none[ast.def_id]) {
index.insert(option.get[ast.def_id](import_id), x);
}
ret x;
}
}
}
fn lookup_name_wrapped(&env e, ast.ident i, namespace ns)
-> option.t[tup(@env, def_wrap)] {
// log "resolving name " + i;
fn found_def_item(@ast.item i, namespace ns) -> def_wrap {
alt (i.node) {
case (ast.item_const(_, _, _, ?id, _)) {
ret def_wrap_other(ast.def_const(id));
}
case (ast.item_fn(_, _, _, ?id, _)) {
ret def_wrap_other(ast.def_fn(id));
}
case (ast.item_mod(_, _, ?id)) {
ret def_wrap_mod(i);
}
case (ast.item_native_mod(_, _, ?id)) {
ret def_wrap_native_mod(i);
}
case (ast.item_ty(_, _, _, ?id, _)) {
ret def_wrap_other(ast.def_ty(id));
}
case (ast.item_tag(_, _, _, ?id, _)) {
ret def_wrap_other(ast.def_ty(id));
}
case (ast.item_obj(_, _, _, ?odid, _)) {
alt (ns) {
case (ns_value) {
ret def_wrap_other(ast.def_obj(odid.ctor));
}
case (ns_type) {
ret def_wrap_other(ast.def_obj(odid.ty));
}
}
}
}
}
fn found_def_native_item(@ast.native_item i) -> def_wrap {
alt (i.node) {
case (ast.native_item_ty(_, ?id)) {
ret def_wrap_other(ast.def_native_ty(id));
}
case (ast.native_item_fn(_, _, _, _, ?id, _)) {
ret def_wrap_other(ast.def_native_fn(id));
}
}
}
fn found_def_view(@ast.view_item i) -> def_wrap {
alt (i.node) {
case (ast.view_item_use(_, _, ?id, _)) {
ret def_wrap_use(i);
}
case (ast.view_item_import(_, ?idents,?d, _)) {
ret def_wrap_import(i);
}
}
fail;
}
fn check_mod(ast.ident i, ast._mod m, namespace ns)
-> option.t[def_wrap] {
alt (m.index.find(i)) {
case (some[ast.mod_index_entry](?ent)) {
alt (ent) {
case (ast.mie_view_item(?view_item)) {
ret some(found_def_view(view_item));
}
case (ast.mie_item(?item)) {
ret some(found_def_item(item, ns));
}
case (ast.mie_tag_variant(?item, ?variant_idx)) {
alt (item.node) {
case (ast.item_tag(_, ?variants, _, ?tid, _)) {
auto vid = variants.(variant_idx).node.id;
auto t = ast.def_variant(tid, vid);
ret some[def_wrap](def_wrap_other(t));
}
case (_) {
log_err "tag item not actually a tag";
fail;
}
}
}
}
}
case (none[ast.mod_index_entry]) {
ret none[def_wrap];
}
}
}
fn check_native_mod(ast.ident i, ast.native_mod m) -> option.t[def_wrap] {
alt (m.index.find(i)) {
case (some[ast.native_mod_index_entry](?ent)) {
alt (ent) {
case (ast.nmie_view_item(?view_item)) {
ret some(found_def_view(view_item));
}
case (ast.nmie_item(?item)) {
ret some(found_def_native_item(item));
}
}
}
case (none[ast.native_mod_index_entry]) {
ret none[def_wrap];
}
}
}
fn handle_fn_decl(ast.ident identifier, &ast.fn_decl decl,
&vec[ast.ty_param] ty_params) -> option.t[def_wrap] {
for (ast.arg a in decl.inputs) {
if (_str.eq(a.ident, identifier)) {
auto t = ast.def_arg(a.id);
ret some(def_wrap_other(t));
}
}
auto i = 0u;
for (ast.ty_param tp in ty_params) {
if (_str.eq(tp, identifier)) {
auto t = ast.def_ty_arg(i);
ret some(def_wrap_other(t));
}
i += 1u;
}
ret none[def_wrap];
}
fn found_tag(@ast.item item, uint variant_idx) -> def_wrap {
alt (item.node) {
case (ast.item_tag(_, ?variants, _, ?tid, _)) {
auto vid = variants.(variant_idx).node.id;
auto t = ast.def_variant(tid, vid);
ret def_wrap_other(t);
}
case (_) {
log_err "tag item not actually a tag";
fail;
}
}
}
fn check_block(ast.ident i, &ast.block_ b, namespace ns)
-> option.t[def_wrap] {
alt (b.index.find(i)) {
case (some[ast.block_index_entry](?ix)) {
alt(ix) {
case (ast.bie_item(?it)) {
ret some(found_def_item(it, ns));
}
case (ast.bie_local(?l)) {
auto t = ast.def_local(l.id);
ret some(def_wrap_other(t));
}
case (ast.bie_tag_variant(?item, ?variant_idx)) {
ret some(found_tag(item, variant_idx));
}
}
}
case (_) { ret none[def_wrap]; }
}
}
fn in_scope(&session.session sess, ast.ident identifier, &scope s,
namespace ns) -> option.t[def_wrap] {
alt (s) {
case (scope_crate(?c)) {
ret check_mod(identifier, c.node.module, ns);
}
case (scope_item(?it)) {
alt (it.node) {
case (ast.item_fn(_, ?f, ?ty_params, _, _)) {
ret handle_fn_decl(identifier, f.decl, ty_params);
}
case (ast.item_obj(_, ?ob, ?ty_params, _, _)) {
for (ast.obj_field f in ob.fields) {
if (_str.eq(f.ident, identifier)) {
auto t = ast.def_obj_field(f.id);
ret some(def_wrap_other(t));
}
}
auto i = 0u;
for (ast.ty_param tp in ty_params) {
if (_str.eq(tp, identifier)) {
auto t = ast.def_ty_arg(i);
ret some(def_wrap_other(t));
}
i += 1u;
}
}
case (ast.item_tag(_,?variants,?ty_params,?tag_id,_)) {
auto i = 0u;
for (ast.ty_param tp in ty_params) {
if (_str.eq(tp, identifier)) {
auto t = ast.def_ty_arg(i);
ret some(def_wrap_other(t));
}
i += 1u;
}
}
case (ast.item_mod(_, ?m, _)) {
ret check_mod(identifier, m, ns);
}
case (ast.item_native_mod(_, ?m, _)) {
ret check_native_mod(identifier, m);
}
case (ast.item_ty(_, _, ?ty_params, _, _)) {
auto i = 0u;
for (ast.ty_param tp in ty_params) {
if (_str.eq(tp, identifier)) {
auto t = ast.def_ty_arg(i);
ret some(def_wrap_other(t));
}
i += 1u;
}
}
case (_) { /* fall through */ }
}
}
case (scope_native_item(?it)) {
alt (it.node) {
case (ast.native_item_fn(_, _, ?decl, ?ty_params, _, _)) {
ret handle_fn_decl(identifier, decl, ty_params);
}
}
}
case (scope_external_mod(?mod_id, ?path)) {
ret lookup_external_def(sess, mod_id._0, path);
}
case (scope_loop(?d)) {
alt (d.node) {
case (ast.decl_local(?local)) {
if (_str.eq(local.ident, identifier)) {
auto lc = ast.def_local(local.id);
ret some(def_wrap_other(lc));
}
}
}
}
case (scope_block(?b)) {
ret check_block(identifier, b.node, ns);
}
case (scope_arm(?a)) {
alt (a.index.find(identifier)) {
case (some[ast.def_id](?did)) {
auto t = ast.def_binding(did);
ret some[def_wrap](def_wrap_other(t));
}
case (_) { /* fall through */ }
}
}
}
ret none[def_wrap];
}
alt (e.scopes) {
case (nil[scope]) {
ret none[tup(@env, def_wrap)];
}
case (cons[scope](?hd, ?tl)) {
auto x = in_scope(e.sess, i, hd, ns);
alt (x) {
case (some[def_wrap](?x)) {
ret some(tup(@e, x));
}
case (none[def_wrap]) {
auto outer_env = rec(scopes = *tl with e);
ret lookup_name_wrapped(outer_env, i, ns);
}
}
}
}
}
fn fold_pat_tag(&env e, &span sp, ast.path p, vec[@ast.pat] args,
option.t[ast.variant_def] old_def,
ann a) -> @ast.pat {
auto len = _vec.len[ast.ident](p.node.idents);
auto last_id = p.node.idents.(len - 1u);
auto new_def;
auto index = new_def_hash[def_wrap]();
auto d = find_final_def(e, index, sp, p.node.idents, ns_value,
none[ast.def_id]);
alt (unwrap_def(d)) {
case (ast.def_variant(?did, ?vid)) {
new_def = some[ast.variant_def](tup(did, vid));
}
case (_) {
e.sess.span_err(sp, "not a tag variant: " + last_id);
new_def = none[ast.variant_def];
}
}
ret @fold.respan[ast.pat_](sp, ast.pat_tag(p, args, new_def, a));
}
// We received a path expression of the following form:
//
// a.b.c.d
//
// Somewhere along this path there might be a split from a path-expr
// to a runtime field-expr. For example:
//
// 'a' could be the name of a variable in the local scope
// and 'b.c.d' could be a field-sequence inside it.
//
// Or:
//
// 'a.b' could be a module path to a constant record, and 'c.d'
// could be a field within it.
//
// Our job here is to figure out what the prefix of 'a.b.c.d' is that
// corresponds to a static binding-name (a module or slot, with no type info)
// and split that off as the 'primary' expr_path, with secondary expr_field
// expressions tacked on the end.
fn fold_expr_path(&env e, &span sp, &ast.path p, &option.t[def] d,
ann a) -> @ast.expr {
auto n_idents = _vec.len[ast.ident](p.node.idents);
check (n_idents != 0u);
auto index = new_def_hash[def_wrap]();
auto d = find_final_def(e, index, sp, p.node.idents, ns_value,
none[ast.def_id]);
let uint path_len = 0u;
alt (d) {
case (def_wrap_expr_field(?remaining, _)) {
path_len = n_idents - remaining + 1u;
}
case (def_wrap_other(_)) {
path_len = n_idents;
}
case (def_wrap_mod(?m)) {
e.sess.span_err(sp,
"can't refer to a module as a first-class value");
fail;
}
}
auto path_elems =
_vec.slice[ident](p.node.idents, 0u, path_len);
auto p_ = rec(node=rec(idents = path_elems with p.node) with p);
auto d_ = some(unwrap_def(d));
auto ex = @fold.respan[ast.expr_](sp, ast.expr_path(p_, d_, a));
auto i = path_len;
while (i < n_idents) {
auto id = p.node.idents.(i);
ex = @fold.respan[ast.expr_](sp, ast.expr_field(ex, id, a));
i += 1u;
}
ret ex;
}
fn fold_view_item_import(&env e, &span sp,
import_map index, ident i,
vec[ident] is, ast.def_id id,
option.t[def] target_id) -> @ast.view_item {
// Produce errors for invalid imports
auto len = _vec.len[ast.ident](is);
auto last_id = is.(len - 1u);
auto d = find_final_def(e, index, sp, is, ns_value, some(id));
alt (d) {
case (def_wrap_expr_field(?remain, _)) {
auto ident = is.(len - remain);
e.sess.span_err(sp, ident + " is not a module or crate");
}
case (_) {
}
}
let option.t[def] target_def = some(unwrap_def(d));
ret @fold.respan[ast.view_item_](sp, ast.view_item_import(i, is, id,
target_def));
}
fn fold_ty_path(&env e, &span sp, ast.path p, &option.t[def] d) -> @ast.ty {
auto index = new_def_hash[def_wrap]();
auto d = find_final_def(e, index, sp, p.node.idents, ns_type,
none[ast.def_id]);
ret @fold.respan[ast.ty_](sp, ast.ty_path(p, some(unwrap_def(d))));
}
fn update_env_for_crate(&env e, @ast.crate c) -> env {
ret rec(scopes = cons[scope](scope_crate(c), @e.scopes) with e);
}
fn update_env_for_item(&env e, @ast.item i) -> env {
ret rec(scopes = cons[scope](scope_item(i), @e.scopes) with e);
}
fn update_env_for_native_item(&env e, @ast.native_item i) -> env {
ret rec(scopes = cons[scope](scope_native_item(i), @e.scopes) with e);
}
// Not actually called by fold, but here since this is analogous to
// update_env_for_item() above and is called by find_final_def().
fn update_env_for_external_mod(&env e, ast.def_id mod_id,
vec[ast.ident] idents) -> env {
ret rec(scopes = cons[scope](scope_external_mod(mod_id, idents),
@e.scopes)
with e);
}
fn update_env_for_block(&env e, &ast.block b) -> env {
ret rec(scopes = cons[scope](scope_block(b), @e.scopes) with e);
}
fn update_env_for_expr(&env e, @ast.expr x) -> env {
alt (x.node) {
case (ast.expr_for(?d, _, _, _)) {
ret rec(scopes = cons[scope](scope_loop(d), @e.scopes) with e);
}
case (ast.expr_for_each(?d, _, _, _)) {
ret rec(scopes = cons[scope](scope_loop(d), @e.scopes) with e);
}
case (_) { }
}
ret e;
}
fn update_env_for_arm(&env e, &ast.arm p) -> env {
ret rec(scopes = cons[scope](scope_arm(p), @e.scopes) with e);
}
fn resolve_imports(session.session sess, @ast.crate crate) -> @ast.crate {
let fold.ast_fold[env] fld = fold.new_identity_fold[env]();
auto import_index = new_def_hash[def_wrap]();
fld = @rec( fold_view_item_import
= bind fold_view_item_import(_,_,import_index,_,_,_,_),
update_env_for_crate = bind update_env_for_crate(_,_),
update_env_for_item = bind update_env_for_item(_,_),
update_env_for_native_item =
bind update_env_for_native_item(_,_),
update_env_for_block = bind update_env_for_block(_,_),
update_env_for_arm = bind update_env_for_arm(_,_),
update_env_for_expr = bind update_env_for_expr(_,_)
with *fld );
auto e = rec(scopes = nil[scope],
sess = sess);
ret fold.fold_crate[env](e, fld, crate);
}
fn resolve_crate(session.session sess, @ast.crate crate) -> @ast.crate {
let fold.ast_fold[env] fld = fold.new_identity_fold[env]();
auto new_crate = resolve_imports(sess, crate);
fld = @rec( fold_pat_tag = bind fold_pat_tag(_,_,_,_,_,_),
fold_expr_path = bind fold_expr_path(_,_,_,_,_),
fold_ty_path = bind fold_ty_path(_,_,_,_),
update_env_for_crate = bind update_env_for_crate(_,_),
update_env_for_item = bind update_env_for_item(_,_),
update_env_for_native_item =
bind update_env_for_native_item(_,_),
update_env_for_block = bind update_env_for_block(_,_),
update_env_for_arm = bind update_env_for_arm(_,_),
update_env_for_expr = bind update_env_for_expr(_,_)
with *fld );
auto e = rec(scopes = nil[scope],
sess = sess);
ret fold.fold_crate[env](e, fld, new_crate);
}
// Local Variables:
// mode: rust
// fill-column: 78;
// indent-tabs-mode: nil
// c-basic-offset: 4
// buffer-file-coding-system: utf-8-unix
// compile-command: "make -k -C $RBUILD 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
// End:
|
use crate::extensions::context::ClientContextExt;
use crate::extensions::ChannelExt;
use crate::models::apod::Apod;
use serenity::framework::standard::macros::command;
use serenity::framework::standard::CommandResult;
use serenity::model::prelude::Message;
use serenity::prelude::Context;
#[command]
pub async fn daily(ctx: &Context, msg: &Message) -> CommandResult {
let db = ctx.get_db().await;
let channel = msg
.channel(&ctx)
.await
.expect("Unable to fetch message channel?");
let apod = Apod::from(db.get_most_recent_apod().await);
channel.send_apod(ctx, &apod).await?;
Ok(())
}
|
use std::collections::HashMap;
#[derive(Debug, Clone, Copy)]
enum CmpToken {
Eq,
Ne,
Lt,
Gt,
Le,
Ge,
}
#[derive(Debug, Clone, Copy)]
enum OpToken {
Inc,
Dec,
}
#[derive(Debug, Clone)]
enum Token {
Register(String),
Operator(OpToken),
Number(i64),
If,
Compare(CmpToken),
}
impl Token {
fn get_register_name(&self) -> Result<String, ()> {
match self {
&Token::Register(ref s) => Ok(s.to_string()),
_ => Err(()),
}
}
fn get_number(&self) -> Result<i64, ()> {
match self {
&Token::Number(n) => Ok(n),
_ => Err(()),
}
}
fn get_cmp(&self) -> Result<CmpToken, ()> {
match self {
&Token::Compare(c) => Ok(c),
_ => Err(()),
}
}
fn get_op(&self) -> Result<OpToken, ()> {
match self {
&Token::Operator(o) => Ok(o),
_ => Err(()),
}
}
fn get_if(&self) -> Result<(), ()> {
match self {
&Token::If => Ok(()),
_ => Err(()),
}
}
}
struct Comparison {
left: i64,
cmp: CmpToken,
right: i64,
}
impl Comparison {
fn compare(&self) -> bool {
match self.cmp {
CmpToken::Eq => self.left == self.right,
CmpToken::Ne => self.left != self.right,
CmpToken::Lt => self.left < self.right,
CmpToken::Gt => self.left > self.right,
CmpToken::Le => self.left <= self.right,
CmpToken::Ge => self.left >= self.right,
}
}
}
struct Instruction<'a> {
register: &'a str,
op: OpToken,
val: i64,
}
impl<'a> Instruction<'a> {
fn eval(&self, registers: &mut HashMap<String, i64>) -> Result<(), ()> {
match self.op {
OpToken::Inc => {
let reg = registers.entry(self.register.into()).or_insert(0);
*reg += self.val;
Ok(())
},
OpToken::Dec => {
let reg = registers.entry(self.register.into()).or_insert(0);
*reg -= self.val;
Ok(())
}
}
}
}
fn get_register_val(name: &str, map: &mut HashMap<String, i64>) -> i64 {
let val = map.entry(name.into()).or_insert(0i64);
*val
}
fn eval(tokens: &[Token], registers: &mut HashMap<String, i64>) -> Result<(), ()> {
let register_name = tokens[0].get_register_name().expect("Parse error, expected register name");
let operator = tokens[1].get_op().expect("Parse error, expected operator");
let op_val = tokens[2].get_number().expect("Parse error, expected number");
let _ = tokens[3].get_if().expect("Parse error, expected 'if'");
let cmp_register = tokens[4].get_register_name().expect("Parse error, expected register name");
let cmp = tokens[5].get_cmp().expect("Parse error, expected comparison operator");
let cmp_val = tokens[6].get_number().expect("Parse error, expected comparison value");
let comparison = Comparison {
left: get_register_val(&cmp_register, registers),
cmp: cmp,
right: cmp_val,
};
if ! comparison.compare() {
// no need to compute the instruction if the comparison fails
return Ok(())
}
let instruction = Instruction {
register: ®ister_name,
op: operator,
val: op_val,
};
instruction.eval(registers)
}
fn find_max(map: &HashMap<String, i64>) -> i64 {
*map.values().max().unwrap_or(&0)
}
fn run(input: &str) -> i64 {
let mut registers: HashMap<String, i64> = HashMap::new();
let mut max: i64 = 0;
for line in input.trim().lines() {
let tokens = tokenize_line(&line);
let result = eval(&tokens, &mut registers);
let local_max = find_max(®isters);
max = if local_max > max {
local_max
} else {
max
};
println!("registers: {:?}", registers);
}
max
}
fn tokenize_line(input: &str) -> Vec<Token> {
let tokens = input.split_whitespace().map(|s| s.trim())
.map(|s| {
match s {
"==" => Token::Compare(CmpToken::Eq),
"!=" => Token::Compare(CmpToken::Ne),
"<" => Token::Compare(CmpToken::Lt),
">" => Token::Compare(CmpToken::Gt),
"<=" => Token::Compare(CmpToken::Le),
">=" => Token::Compare(CmpToken::Ge),
"if" => Token::If,
"inc" => Token::Operator(OpToken::Inc),
"dec" => Token::Operator(OpToken::Dec),
s if s.parse::<i64>().is_ok() => Token::Number(s.parse().expect("Couldn't parse number")),
s => Token::Register(s.into()),
}
}).collect();
tokens
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn it_works() {
let input = r#"
b inc 5 if a > 1
a inc 1 if b < 5
c dec -10 if a >= 1
c inc -20 if c == 10
"#;
assert_eq!(run(&input), 10);
}
#[test]
fn answer() {
let input = r#"
q inc -541 if c != 4
s inc -555 if o > -5
px dec -84 if x >= -4
y dec -822 if txk > -1
wdc inc -731 if tup < -5
ug dec -943 if s != -551
rz inc 468 if j > 1
rz dec 628 if j >= -3
zeq inc -801 if gr >= 7
jb dec 592 if px > 80
q inc -151 if rz <= -628
l dec -423 if b <= 7
vhu inc 904 if q >= -700
b dec 438 if kyh == 0
o inc 491 if vhu < 908
l inc 761 if tup >= 8
kq inc -790 if kyh > -9
tup dec 171 if vhu != 909
y dec 473 if px != 81
kq inc 689 if jb < -590
vhu inc -802 if o > 488
jb inc 165 if l >= 418
kps inc 49 if s >= -564
kps dec 508 if ug == 943
txk dec 352 if djl > -2
axi dec -4 if y <= 347
rz inc -40 if x <= -4
xhe inc -538 if l < 428
l dec 396 if kq < -97
djl inc -462 if rz < -619
xhe dec -173 if vhu > 98
ug dec 227 if jb < -417
x dec 754 if q == -692
kps inc 671 if gr < 10
ug inc 722 if o > 490
o inc 743 if s == -562
rz inc -427 if mp >= -2
s dec -630 if j < 0
vhu inc -413 if kyh > -8
kyh dec -389 if djl != -458
wdc inc 593 if ug >= 1432
o inc 988 if kq != -101
b inc -550 if c > -5
c inc -390 if q != -701
axi inc 450 if wdc <= 586
xhe dec 840 if kyh > 385
mp inc -789 if vhu > -313
wdc dec -387 if j <= 1
kps dec 625 if wdc != 980
q inc 40 if b <= -979
gr inc 164 if b > -982
ug inc 124 if kyh == 389
rz inc -893 if axi != 8
b dec 428 if x <= -757
vhu dec -205 if o != 500
ug inc -375 if q < -644
djl inc -954 if jb >= -434
px inc 170 if kyh <= 396
jb dec -844 if mp > -796
px dec -473 if c != -390
rz dec 480 if x > -759
kyh inc -698 if l <= 32
q dec -185 if x <= -753
c dec -765 if kps > 210
mp dec 207 if l < 28
l inc -870 if kyh <= -309
kyh inc -323 if s <= -559
x dec 805 if axi == 0
q inc 376 if kq == -101
x inc 550 if s < -550
x dec 647 if kps == 212
zeq inc -839 if rz >= -2436
djl dec -759 if l > -850
tup inc -551 if o > 481
vhu inc 12 if kq != -101
kq dec -953 if px == 254
c inc 523 if djl >= -657
kyh dec -524 if c == 898
tup dec 478 if px == 254
xhe inc 301 if q == -91
kyh dec -638 if y == 350
l inc -412 if rz <= -2421
ug dec 548 if kps > 207
djl dec -830 if mp <= -997
tup inc 367 if gr <= 0
ug dec 997 if tup < -824
mp dec -253 if txk >= -356
kq inc 204 if jb >= 415
px inc 567 if jb < 410
kps dec 306 if txk == -353
kps dec -171 if kyh > 222
djl inc -833 if xhe <= -902
kyh dec 648 if vhu >= -114
djl inc -903 if kq < 1051
kps inc -940 if djl < -1489
y dec -408 if j <= -10
mp dec -886 if o == 491
rz inc 571 if l >= -1246
s dec -178 if kq < 1062
kq dec 718 if jb < 421
axi dec 587 if kps <= -721
jb inc -879 if j != 0
tup dec 632 if zeq > -843
tup dec -673 if s != -378
kq dec -88 if vhu > -114
jb dec 74 if o <= 492
ug inc -716 if s <= -387
rz inc 265 if zeq > -842
axi inc -995 if l != -1246
px inc 481 if gr <= -1
x dec -811 if axi < -1590
y inc 375 if s != -386
wdc dec -484 if tup < -790
c inc -335 if xhe == -908
c inc -80 if px == 254
c inc 263 if kq == 426
gr inc 259 if kq > 429
tup dec -749 if txk == -356
jb inc 399 if wdc >= 1455
mp inc -334 if axi <= -1577
b inc 442 if zeq <= -836
px inc -890 if xhe >= -912
zeq inc -41 if o != 488
ug dec 781 if x >= -1654
wdc dec 246 if px > -645
gr dec -707 if djl <= -1482
wdc dec -90 if y <= 730
y inc 674 if o != 491
j dec -911 if vhu <= -102
jb dec 575 if y == 724
rz dec -10 if c <= 1088
axi dec 272 if axi != -1586
gr dec -678 if s != -377
kyh inc -768 if gr == 707
s inc 499 if mp > -195
zeq inc 574 if wdc <= 1317
axi dec -339 if x != -1647
o dec -884 if xhe >= -905
mp inc 718 if c >= 1073
l inc 101 if px == -636
djl dec -7 if y != 723
wdc dec 997 if b != -537
gr dec -155 if jb >= 176
tup dec -403 if kyh < -1201
kps dec -240 if djl <= -1480
c dec -786 if mp > 525
px inc -452 if ug >= -365
x inc -527 if vhu >= -113
zeq inc 524 if b != -552
djl inc -429 if mp != 528
c dec -667 if o >= 1368
o inc 724 if x >= -2185
gr dec 568 if kyh < -1195
axi inc -571 if j <= 904
px inc 423 if b >= -547
txk inc -561 if q <= -87
tup dec 382 if kps < -487
gr dec 18 if px > -674
xhe dec -981 if y > 721
tup dec -68 if txk > -908
q inc 583 if axi < -1508
gr dec -404 if s != 122
ug inc 743 if c == 2534
xhe inc 985 if c <= 2537
axi dec -258 if b != -538
o dec 994 if gr >= 113
vhu inc -278 if tup != -1181
djl inc 489 if djl == -1912
axi dec 580 if kps <= -490
ug dec -803 if xhe >= 1055
kps inc 156 if mp != 526
zeq inc 214 if mp >= 518
vhu inc 830 if mp < 536
b dec 249 if b > -549
o inc -626 if rz == -2153
jb dec -220 if x > -2193
djl dec -546 if j >= 902
px dec 964 if px >= -669
tup dec -719 if kps > -326
gr inc -555 if s >= 132
j dec -922 if o >= 485
j dec -112 if q != 482
tup inc -463 if s <= 118
jb dec -195 if o >= 472
x dec -973 if gr == 121
x inc 253 if axi == -1247
o inc 818 if wdc == 311
gr dec 687 if tup != -1171
s inc -869 if vhu <= 450
vhu dec 288 if l < -1149
rz dec 703 if xhe != 1067
rz dec 700 if o >= 1293
txk inc -983 if zeq >= 440
kq inc -364 if q != 492
kq inc 789 if x == -1201
px dec 560 if x <= -1208
wdc inc 562 if s == -741
j inc -665 if kyh != -1198
s inc 332 if kps >= -333
mp dec 411 if rz < -3552
axi dec 504 if wdc != 311
kps dec 56 if ug > 1182
jb inc 497 if px > -2191
axi dec -364 if q < 501
kq dec -308 if x < -1211
zeq dec 304 if q >= 489
kyh dec -957 if x >= -1211
tup dec -670 if l > -1145
jb dec -166 if o <= 1297
l dec -900 if s <= -406
txk inc 917 if px >= -2182
rz inc 426 if y == 724
kyh inc -993 if j > 353
y dec -513 if kq != 425
zeq inc 329 if l >= -251
kps dec 460 if mp < 121
wdc dec 492 if xhe != 1062
djl dec -945 if gr <= -560
px inc 368 if wdc == 311
zeq inc 250 if y != 1247
wdc dec 182 if y < 1237
txk dec 577 if rz <= -3128
b inc -252 if l < -247
j dec 173 if px == -1821
djl inc -858 if px == -1821
mp dec 609 if wdc != 321
wdc inc -723 if kyh != -1230
kyh dec -172 if kyh < -1229
wdc dec -702 if ug < 1187
px inc -276 if jb <= 1245
l dec -208 if txk > -1483
y dec 319 if kps < -850
kyh inc -597 if kps != -848
c dec 161 if tup == -1170
kps inc 320 if o <= 1302
rz inc 972 if px == -2097
kyh dec 483 if rz >= -2165
kps dec -845 if q <= 494
kyh dec 268 if o == 1301
jb dec 835 if ug >= 1192
kq inc 93 if vhu != 158
vhu inc -693 if q != 490
x dec -75 if txk <= -1484
jb dec 419 if jb >= 1243
b dec -84 if x >= -1137
xhe inc -156 if kq <= 424
s dec 653 if o >= 1297
kyh inc 880 if c >= 2530
wdc inc 295 if xhe > 1061
y dec 140 if xhe != 1062
txk dec 28 if wdc == -117
kps dec 640 if rz >= -2166
x dec 369 if y > 1232
kps inc 232 if l >= -255
b dec 89 if gr < -566
wdc inc -217 if b <= -954
vhu inc -29 if zeq <= 385
kyh inc 861 if zeq <= 370
rz inc 425 if jb == 826
ug inc -857 if ug >= 1189
mp inc -418 if x != -1505
jb dec -815 if kq == 426
ug inc -584 if xhe >= 1055
kyh dec 216 if y <= 1240
txk inc 106 if s <= -1064
gr inc -775 if xhe > 1063
o inc 647 if l == -254
djl inc -461 if kq == 426
s dec 962 if x >= -1512
s dec -721 if y < 1230
rz dec 289 if vhu == -567
kq inc 651 if kq < 432
px inc 371 if vhu <= -564
axi dec -325 if kq > 1071
b inc -971 if s != -2030
c dec -526 if zeq >= 380
zeq dec 239 if jb <= 1643
kq inc -757 if kps != -87
q dec 436 if y < 1241
kq dec -557 if kps < -81
s dec 115 if y >= 1236
s inc -134 if c < 2543
q inc -304 if txk <= -1407
xhe dec 975 if rz == -1733
tup dec 814 if rz >= -1742
l inc 969 if ug == 604
vhu dec 625 if wdc < -333
xhe inc -406 if zeq != 136
xhe inc 448 if jb >= 1640
c dec -894 if q > -249
b dec -778 if axi == -568
zeq inc 966 if o <= 1953
zeq dec 148 if wdc <= -334
mp inc 812 if zeq <= 958
zeq inc -295 if kyh != -878
j dec -719 if axi >= -574
tup inc -59 if c > 3425
txk inc 538 if jb == 1641
zeq dec 854 if jb <= 1644
mp dec 735 if o <= 1949
axi dec 750 if c >= 3421
gr dec 633 if axi >= -1321
x dec 626 if mp >= -827
xhe inc 138 if txk <= -872
axi inc -838 if txk < -866
px inc 571 if tup >= -2045
jb dec 793 if px >= -1730
l inc -759 if zeq == -202
kyh inc -923 if kq <= 881
tup dec 903 if b <= -181
o dec -958 if l != 707
xhe inc 814 if x == -1504
o inc 454 if o != 2906
djl inc 469 if jb == 848
mp dec -114 if q != -240
y dec -393 if djl < -776
ug inc -365 if mp > -713
tup dec -254 if gr == -1199
rz dec 587 if gr > -1203
px dec -611 if b > -191
txk inc -488 if kyh <= -1800
axi dec 834 if c <= 3437
tup inc -946 if gr <= -1199
x inc -225 if wdc < -342
j inc 526 if s < -2273
ug dec -654 if c != 3427
mp dec -521 if s <= -2274
vhu dec -319 if txk >= -1352
c inc 615 if gr > -1203
vhu inc -464 if zeq == -192
ug inc 469 if txk > -1367
l dec 541 if px >= -1106
s dec 632 if s <= -2282
djl dec 289 if q <= -245
xhe dec -816 if b >= -189
kps dec -166 if rz != -2326
txk inc -207 if txk == -1362
o inc -566 if kq < 879
ug dec 662 if kyh == -1807
s inc -147 if vhu != -1653
djl dec -675 if mp >= -200
c inc 734 if zeq < -191
y dec 440 if x < -1503
tup dec 267 if zeq == -192
o dec 971 if tup == -3909
c dec -880 if x > -1510
o dec 75 if s == -2279
jb dec 956 if c < 5659
txk dec -95 if c > 5655
wdc inc -521 if jb > -113
djl dec -798 if xhe <= 1901
vhu inc 711 if jb <= -104
jb dec -44 if tup < -3906
kyh inc 57 if wdc != -860
jb dec -817 if xhe <= 1902
x inc 91 if rz <= -2313
txk dec -604 if kps != 69
vhu inc -714 if xhe != 1894
txk inc 590 if rz <= -2318
tup dec -557 if vhu > -1649
wdc inc 621 if c == 5657
q inc -39 if ug <= 1067
s inc 947 if jb > 752
rz inc 974 if xhe != 1902
kq dec 787 if tup < -3913
px dec 41 if djl != 399
q dec 618 if kyh >= -1758
kq inc -265 if xhe != 1906
kps dec 748 if zeq >= -188
s dec 78 if q != -908
c inc 10 if px >= -1160
j inc 526 if djl < 411
s dec -329 if vhu == -1653
l inc 922 if px < -1149
y dec 546 if o >= 1738
tup dec 505 if rz >= -1347
zeq dec 983 if px < -1149
j inc -997 if txk < -275
rz inc 216 if xhe >= 1890
jb inc -616 if vhu >= -1664
kps dec 357 if wdc == -234
jb inc 241 if zeq >= -1184
djl dec -907 if kps < -285
xhe dec 699 if y < 650
x inc 319 if tup <= -4415
l dec -715 if x != -1419
tup dec -13 if rz > -1133
vhu dec -127 if mp > -209
kps inc 907 if mp < -196
kyh dec -953 if vhu >= -1530
gr dec 47 if mp >= -196
wdc dec 462 if px != -1164
wdc dec 441 if zeq > -1184
s dec 846 if ug > 1057
djl inc 418 if s >= -2260
tup inc -428 if ug == 1065
djl inc -471 if ug >= 1065
x dec 580 if tup < -4825
o dec 825 if kps < 619
s inc -901 if tup <= -4823
c dec -641 if xhe >= 1200
j inc -966 if gr > -1205
px dec 141 if zeq < -1173
kyh inc -244 if gr < -1192
j inc 759 if zeq < -1166
xhe dec -129 if axi >= -2999
gr inc 567 if axi == -2990
x inc 856 if axi <= -2993
kq dec -151 if djl < 351
kps dec -397 if q != -907
axi inc -714 if jb > 370
y inc -630 if tup > -4834
o dec 610 if y <= 16
ug inc -172 if jb > 380
gr dec -531 if s == -3157
s dec -860 if o > 1126
djl inc 584 if j >= 745
tup inc 861 if c < 5677
axi inc 562 if px < -1290
axi inc 55 if txk > -271
djl inc -747 if gr < -100
ug inc 601 if q > -896
x inc -77 if b < -175
l dec 448 if txk > -289
gr inc 469 if axi <= -3135
jb inc -627 if q < -913
s dec 830 if kps > 1020
l dec -386 if j <= 760
c dec -119 if axi != -3149
djl inc 960 if x == -2070
kq dec 326 if mp != -197
s inc -453 if y == 17
gr inc 386 if j == 752
q inc -147 if ug == 1065
s dec 657 if px <= -1303
b dec 810 if c < 5781
b inc -918 if q < -1051
zeq inc 342 if px > -1300
o inc 54 if kps >= 1018
j inc 239 if zeq <= -827
ug dec 428 if y < 23
ug inc -433 if mp <= -203
jb inc -356 if txk <= -286
ug dec -760 if j <= 989
djl inc -770 if axi >= -3142
wdc inc -880 if wdc != -1140
b dec -461 if o != 1184
mp inc 319 if px >= -1301
txk dec -110 if o <= 1196
s dec -752 if wdc < -2007
vhu dec 278 if zeq <= -825
px dec -505 if b == -642
ug dec -184 if kq > 430
kyh dec 507 if kps <= 1024
l inc -115 if kq > 445
q inc -359 if s > -2375
kq dec -35 if o >= 1193
l dec -610 if vhu <= -1810
xhe dec 124 if x <= -2064
txk inc 167 if ug <= 828
y inc 684 if q > -1058
xhe dec 706 if c > 5777
vhu inc -533 if rz > -1137
ug inc 140 if s >= -2379
kyh dec -93 if l <= 2294
jb inc -112 if axi < -3139
ug dec 987 if x < -2060
zeq dec 828 if axi > -3146
jb dec -573 if ug >= -31
gr inc -56 if o != 1190
txk dec 752 if xhe > 494
c dec 616 if l != 2289
tup inc 474 if tup < -3961
l dec -950 if mp != 125
zeq inc 516 if j == 991
l inc 313 if x >= -2071
rz inc 545 if djl > 370
txk inc 268 if o <= 1190
kq dec -484 if vhu >= -2330
s dec 241 if kq > 442
xhe inc -956 if kyh != -1456
mp dec 315 if mp == 120
wdc dec 925 if vhu >= -2345
y dec -789 if vhu < -2336
tup dec 281 if j != 990
s dec 899 if vhu == -2340
c dec 308 if j < 999
l inc 982 if s == -3274
axi inc 374 if gr >= 692
vhu dec 586 if kyh > -1465
mp dec 73 if xhe <= -457
o inc -210 if zeq >= -1154
vhu inc -484 if txk == -487
rz inc -481 if gr >= 689
q inc 882 if djl < 379
s inc -771 if xhe > -466
zeq inc 804 if c < 4871
djl inc -899 if kq <= 441
axi inc -29 if ug == -26
jb inc -562 if txk != -495
j inc 921 if q <= -168
s inc -148 if y != 1478
j inc -277 if xhe >= -468
txk dec 210 if jb != 277
zeq dec -86 if vhu > -3419
ug inc -330 if x <= -2062
xhe dec -893 if c != 4859
gr dec -290 if j == 1635
zeq dec -98 if b < -647
kps inc 954 if ug >= -357
wdc dec -497 if o != 974
q dec -882 if o > 969
axi inc -65 if kq <= 446
wdc inc -492 if wdc > -2455
vhu inc 704 if gr > 987
x dec 672 if j > 1626
kyh inc -785 if jb == 268
ug dec 0 if djl < -514
jb inc -706 if txk >= -487
mp inc -786 if y > 1485
px dec -734 if j == 1635
jb dec 43 if c <= 4869
rz inc -239 if tup <= -3775
kyh dec -694 if djl != -531
l dec -520 if txk <= -483
q dec 499 if jb > -474
l dec -452 if c > 4858
b dec -583 if axi > -2867
txk inc 556 if s != -4193
j inc 590 if c == 4860
y dec -309 if q >= 204
xhe inc 9 if s < -4197
xhe inc 92 if y == 1796
gr dec 184 if rz == -1304
jb inc 213 if zeq != -251
xhe dec -784 if q < 217
q inc -117 if xhe <= 1312
axi dec 140 if c <= 4870
gr inc 915 if ug <= -351
px dec -135 if djl > -523
rz inc 475 if kyh <= -756
mp inc 216 if jb < -249
q dec 337 if wdc > -2938
wdc inc 288 if kyh <= -757
jb inc -395 if ug == -356
c dec 747 if rz < -827
jb inc 930 if px > -60
tup inc -581 if jb > 285
px inc 340 if djl < -525
kps inc 973 if q < -243
vhu dec 753 if xhe <= 1313
o dec -284 if s >= -4199
xhe dec 196 if q == -241
l inc 818 if x == -2742
txk inc 917 if rz != -837
kps dec 247 if ug >= -361
zeq inc -944 if txk >= 431
axi dec 700 if j <= 1643
x inc 958 if x >= -2751
axi dec 413 if tup >= -3782
y dec -569 if x == -1784
mp inc 838 if q <= -237
jb inc -736 if wdc < -2645
q inc -755 if s <= -4189
gr dec 489 if tup < -3774
s inc 185 if tup < -3783
y dec 708 if l != 6327
kyh dec 738 if zeq < -253
wdc dec 483 if c != 4110
q inc -994 if txk < 421
px dec 942 if tup >= -3779
s dec 740 if djl > -527
q dec 924 if y >= 1655
vhu dec -383 if xhe == 1114
b dec -285 if kyh != -1499
zeq inc -594 if ug < -351
mp dec 349 if kps < 1733
gr inc -329 if gr < 1416
ug inc -423 if l > 6323
s inc 681 if jb > -470
o inc 802 if s <= -4258
kyh inc 979 if kps <= 1738
kq dec -48 if mp < -348
kyh dec 602 if b <= -58
zeq dec -844 if wdc != -3141
gr inc -725 if zeq < -4
px dec -295 if px >= -1005
kq inc -756 if s >= -4259
jb inc 775 if tup >= -3777
axi inc 181 if zeq != -6
txk dec 397 if c <= 4123
gr inc 518 if s >= -4246
rz dec 497 if c != 4107
l dec -579 if wdc == -3132
zeq inc 56 if kq < -269
wdc dec -268 if l <= 6906
zeq dec 241 if c >= 4106
djl dec 866 if j < 1629
txk dec 546 if vhu >= -3081
kyh inc -667 if xhe < 1122
o dec 759 if o == 1262
vhu inc -288 if rz != -1324
rz inc 355 if djl < -521
x inc 126 if rz == -972
djl dec 845 if l == 6904
vhu inc 551 if mp == -349
o dec -327 if axi == -3934
s inc 121 if mp < -349
djl inc 87 if q == -1920
zeq dec -157 if x != -1659
c dec -953 if j > 1635
ug inc -247 if mp >= -351
q dec 408 if l < 6914
rz dec 610 if axi >= -3936
jb dec 90 if kq <= -270
o dec -899 if ug > -1027
c dec 985 if j <= 1638
vhu dec 684 if c != 3130
s dec -392 if axi == -3934
tup inc 528 if kps != 1724
kyh dec 200 if j != 1635
gr dec -288 if wdc != -2865
j inc 253 if b > -64
c inc 102 if zeq < -26
q dec 415 if q >= -2336
l dec -913 if tup >= -3251
c inc 678 if px <= -705
b inc -887 if wdc != -2864
gr dec -710 if axi >= -3936
kyh inc -871 if q != -2749
j inc 262 if l <= 7821
tup dec -906 if o <= 1736
j dec -191 if jb > 218
mp dec 296 if tup >= -2342
j inc 582 if ug == -1026
y dec -480 if c == 3910
tup inc 184 if mp < -635
rz inc 825 if tup != -2162
q inc 931 if tup != -2153
b inc 223 if kyh <= -2657
xhe inc -399 if jb > 216
vhu dec -109 if kq > -276
txk inc -925 if xhe != 714
l inc -221 if axi <= -3934
axi inc -226 if b != 160
px inc 820 if vhu <= -2702
rz inc 638 if mp <= -636
axi inc -198 if x <= -1653
y inc 259 if djl >= -1285
j inc -665 if zeq <= -41
axi dec 906 if y <= 2403
axi inc -807 if px < 117
zeq inc 372 if o >= 1723
x inc -462 if s >= -3851
rz inc -852 if gr < 1355
y inc 698 if l >= 7606
y inc -731 if o == 1729
o inc 894 if l <= 7599
x inc -722 if xhe <= 719
kps inc -502 if b <= 165
djl dec 847 if zeq <= 335
s dec -400 if l >= 7594
zeq dec 513 if ug >= -1021
y inc 797 if wdc != -2864
b inc 332 if b >= 158
gr dec -59 if wdc <= -2860
vhu inc -968 if zeq < 334
wdc dec 100 if wdc == -2864
s dec -862 if y <= 1672
axi dec -319 if o >= 2632
j dec -294 if kyh > -2670
mp inc 342 if mp > -647
ug inc 337 if mp < -311
kq dec 702 if tup > -2163
px inc -729 if px >= 119
zeq dec 161 if xhe != 711
jb inc -745 if kyh <= -2654
txk inc 671 if djl < -1280
y inc -974 if gr < 1425
vhu inc 929 if gr == 1417
djl inc -771 if vhu < -1765
y dec 764 if vhu >= -1783
axi inc 913 if kq >= -969
y inc 428 if rz != -122
j inc 44 if c > 3901
wdc inc -219 if kyh == -2660
rz dec -713 if wdc <= -3178
jb dec -510 if kyh == -2660
rz inc -835 if mp <= -306
xhe inc 461 if tup <= -2152
c dec -986 if ug < -1017
wdc dec 838 if txk != -777
xhe dec -402 if zeq != 186
x inc -791 if tup < -2155
o inc -453 if jb >= -12
ug dec -531 if s <= -2591
s inc -552 if b > 500
vhu inc -780 if tup == -2157
zeq inc -198 if l <= 7601
ug dec 875 if vhu == -2555
y inc -896 if j == 3261
o dec -9 if kq >= -973
ug inc 383 if c == 4896
y dec 592 if l < 7601
q dec -111 if px < 122
l inc -845 if s < -2593
tup dec -602 if zeq >= -12
o dec -689 if ug > -997
c dec -587 if ug < -984
c dec -376 if mp >= -305
px inc 159 if o > 2866
txk dec -763 if rz < 597
rz inc -403 if ug <= -983
px dec 393 if l != 6759
kq dec 65 if q >= -1707
q dec 363 if gr <= 1407
rz inc -205 if c >= 5856
ug inc -810 if kyh < -2653
px inc -11 if jb >= -19
tup inc -997 if mp >= -297
l inc 365 if kps <= 1219
c dec 568 if txk <= 0
x dec 704 if s != -2598
gr inc 997 if gr != 1417
djl dec -200 if j <= 3270
vhu dec 534 if jb < -8
px inc 726 if q == -1701
mp dec -952 if wdc < -4016
zeq dec 851 if axi < -6072
rz dec -92 if djl <= -1849
wdc dec 115 if y == -1133
vhu dec -641 if mp < 652
b inc -389 if y != -1126
kps dec -429 if vhu <= -2440
rz dec 242 if l < 6758
axi dec -745 if jb > -16
j inc 343 if gr > 1415
x dec -733 if ug <= -1795
axi dec 6 if txk != -4
jb dec -438 if b == 107
axi inc -488 if q <= -1699
kq inc -648 if j <= 3610
jb dec 270 if wdc != -4139
txk dec 356 if axi >= -5819
txk dec -620 if b <= 111
l dec 394 if s == -2601
o inc 128 if x <= -2433
ug dec -749 if rz > -174
zeq dec 374 if gr > 1410
kyh dec -901 if mp != 647
b inc -161 if tup != -2157
txk inc -208 if o <= 3002
ug dec 940 if y != -1126
kyh inc -956 if tup == -2157
xhe dec 457 if b >= 101
mp inc -966 if c > 5290
px inc -408 if djl <= -1844
kps dec -599 if kq > -1683
jb dec 798 if gr <= 1426
wdc inc -749 if kq < -1685
tup inc 254 if txk != 51
b dec 841 if jb < -631
o dec 961 if l > 6758
wdc dec -597 if kq <= -1677
px dec -414 if l < 6757
kps inc 373 if px < 610
xhe dec 887 if ug >= -1992
kyh inc -715 if kyh > -2712
l dec -919 if rz <= -164
xhe dec -127 if l <= 7675
x dec 483 if b <= -727
jb inc 659 if ug >= -1997
tup dec -278 if jb > 17
jb dec 295 if c >= 5299
kq dec 624 if q >= -1703
xhe dec -771 if vhu != -2455
c inc 809 if kyh > -2716
djl inc 533 if mp < -307
xhe inc -291 if q == -1701
kyh inc -677 if x > -2928
b inc 828 if txk <= 54
s dec -989 if x > -2929
txk dec -303 if x != -2930
rz dec 462 if jb < 25
tup dec 378 if mp < -308
y dec -173 if xhe == 841
tup inc -808 if l >= 7669
s inc -185 if txk >= 347
s dec -782 if txk < 361
axi inc 551 if xhe >= 834
kq dec -155 if tup > -2814
rz inc -169 if gr >= 1422
mp dec -938 if y == -960
vhu dec 779 if zeq != -394
rz dec -788 if zeq != -389
djl dec 936 if kq != -2164
x inc -767 if c != 6096
xhe inc 425 if kyh <= -3394
kq dec 653 if rz == 162
ug dec -256 if kyh >= -3399
djl dec 160 if kyh == -3392
tup inc -748 if q != -1711
kq dec -338 if axi < -5254
o inc 223 if ug < -1723
c dec -66 if q < -1699
gr inc -340 if tup <= -3550
txk inc 471 if s == -1012
wdc dec 105 if y != -951
gr dec -866 if tup < -3566
kps dec 5 if wdc <= -4392
wdc dec -614 if wdc != -4390
l inc 511 if tup <= -3555
y dec 479 if ug != -1732
txk dec 712 if y != -960
b dec -508 if wdc < -3776
ug dec -573 if b != 609
vhu inc -954 if kps > 2022
gr dec -964 if djl >= -2412
txk inc 533 if px != 595
x inc 538 if gr < 1084
j inc -31 if b != 602
rz inc -934 if b != 600
j dec 566 if wdc != -3788
l dec 756 if l != 8189
q inc -567 if zeq < -384
rz inc -745 if wdc > -3788
px dec 453 if tup > -3558
ug inc -665 if l >= 7425
tup inc 798 if ug != -1816
ug inc 709 if jb == 23
txk dec -173 if ug > -1822
ug inc 501 if xhe < 850
gr inc 90 if o != 3219
tup inc -919 if kq <= -2461
axi dec -83 if xhe == 841
y dec 200 if wdc >= -3779
wdc dec 424 if o != 3226
zeq dec 253 if kq > -2473
rz dec -281 if mp <= 629
tup inc 760 if kps != 2031
mp dec -248 if y >= -1161
s dec 902 if djl <= -2408
mp dec -498 if txk < 1359
mp inc 996 if kyh == -3394
jb inc 492 if px <= 604
px dec 701 if mp >= 863
s dec -957 if tup < -2912
gr inc 214 if tup == -2920
o inc -730 if jb > 508
rz dec -646 if jb <= 513
x dec -2 if x == -3150
b inc -938 if l != 7420
x inc -268 if j != 3048
kq inc -589 if ug > -1317
xhe inc 83 if kps <= 2027
mp dec -962 if kyh <= -3383
j inc 977 if djl == -2415
axi dec 169 if mp <= 1831
px dec -774 if px != -92
kps dec 279 if px < 678
j inc -731 if o <= 2489
x inc -58 if c > 6167
gr inc 610 if vhu <= -3398
vhu inc 209 if kq > -2467
txk inc 11 if jb == 511
rz dec 341 if zeq >= -639
djl dec 297 if q > -2263
xhe dec -357 if o < 2496
kyh dec -579 if b >= -330
kps inc 186 if l < 7426
kyh dec -25 if y == -1160
djl inc 996 if djl >= -2416
mp inc 773 if zeq < -637
xhe inc 759 if tup > -2929
s inc -122 if axi == -5349
vhu dec -603 if l == 7425
gr dec 741 if tup <= -2919
djl dec -996 if mp < 2608
kps dec -645 if vhu < -2793
px dec -25 if djl < -416
px dec -624 if djl > -429
px dec -380 if kq > -2480
mp dec -526 if xhe != 2031
q dec -358 if zeq <= -639
rz inc 218 if jb > 507
q inc -54 if x >= -3420
mp dec 140 if kps < 2581
vhu inc 234 if vhu == -2799
q dec -428 if b == -336
mp dec 825 if wdc > -4209
px dec 22 if x != -3416
j dec -952 if axi > -5352
y inc -551 if y > -1167
djl inc -832 if txk >= 1364
vhu inc -318 if px >= 1701
o dec 783 if txk <= 1376
o inc -479 if txk >= 1365
j dec -924 if px > 1700
ug dec -230 if ug == -1323
q inc -572 if o > 1231
xhe inc 266 if ug <= -1099
y inc 810 if xhe >= 2035
j inc 599 if tup == -2920
xhe dec -795 if o <= 1232
b inc -972 if vhu <= -2884
q dec 715 if s != -1079
vhu inc -143 if y <= -902
wdc inc -704 if kq >= -2477
wdc inc 718 if rz >= -372
jb dec -224 if vhu != -2889
kps inc -197 if ug <= -1092
x inc -81 if x == -3416
xhe dec 492 if tup < -2917
px inc -853 if kq != -2470
djl inc 881 if kq < -2462
q inc 306 if j < 5768
mp inc 618 if b <= -332
s inc 651 if vhu >= -2889
x dec 852 if ug == -1092
x inc -61 if ug >= -1088
tup inc -674 if mp > 2775
j dec 656 if y < -892
kps inc 314 if djl < -364
txk inc -344 if x >= -3498
c dec -768 if ug >= -1101
mp dec -693 if axi != -5349
zeq inc 495 if axi <= -5347
b inc -944 if b <= -330
x inc 790 if mp == 2783
djl inc -776 if y > -911
txk inc 156 if wdc == -4189
x dec 929 if c < 6942
q dec -922 if j >= 5103
x dec 254 if ug <= -1089
mp inc 781 if px >= 1697
kps dec 639 if djl != -1141
j dec -543 if rz == -372
jb dec -961 if y <= -892
djl inc 430 if o == 1237
q dec -64 if o == 1227
txk dec -438 if px >= 1702
wdc inc -117 if x > -3894
px dec -660 if b >= -1287
tup inc 18 if o <= 1230
jb inc 27 if vhu != -2883
vhu inc 554 if x != -3890
s inc -344 if xhe == 2343
px dec 208 if axi < -5347
px inc -859 if o <= 1233
rz inc 717 if q > -242
x dec 315 if y != -910
vhu inc 846 if s == -779
zeq dec -557 if x == -4205
xhe inc -897 if txk < 1621
y inc -130 if kq <= -2464
c dec 430 if djl == -1150
b dec -73 if kyh < -3363
o inc -337 if kyh == -3367
xhe inc 924 if l < 7417
tup dec -126 if x == -4205
j dec -967 if kps == 2054
zeq inc -908 if mp == 3559
j inc -501 if txk != 1619
djl inc -810 if y >= -1033
y dec 525 if djl <= -1960
l inc 389 if x <= -4199
gr inc 111 if jb > 1692
x inc -206 if b > -1200
o inc -928 if s <= -765
l dec -372 if txk > 1612
jb inc -937 if kq == -2470
kq dec -296 if gr < 1276
j dec -643 if rz > -378
kps dec 412 if zeq >= 399
o inc -224 if kq < -2172
y inc -572 if jb == 759
l inc -663 if j < 6760
xhe inc -284 if l <= 7531
kps dec 209 if y <= -2119
tup inc 216 if mp != 3574
px dec -421 if ug >= -1101
wdc inc 854 if ug != -1095
djl inc -860 if wdc > -3453
j dec -541 if ug < -1087
b dec -27 if q != -234
kyh inc -345 if y == -2128
o inc -84 if xhe > 1163
b inc -512 if s > -782
ug dec -772 if l >= 7516
wdc inc -718 if wdc >= -3453
tup inc 48 if rz == -375
c inc 372 if kyh <= -3703
tup dec 753 if b <= -1683
l inc -573 if kps <= 1434
kq inc -589 if axi == -5349
q dec -905 if x >= -4213
jb inc 716 if y >= -2137
q dec -864 if gr <= 1278
axi dec -402 if ug != -322
px dec -442 if j <= 7300
"#;
println!("answer: {}", run(&input));
}
}
|
// use dirs_2;
// use reqwest;
// use std::process::exit;
// use std::fs;
// use std::io::Write;
//
// const LANG_URL: &str = "https://raw.githubusercontent.com/AltriusRS/NextLaunch/next/languages/languages.zip";
// const CONFIG_URL: &str = "https://raw.githubusercontent.com/AltriusRS/NextLaunch/next/nextlaunch.json";
// const README_URL: &str = "https://raw.githubusercontent.com/AltriusRS/NextLaunch/next/documents/readmes.zip";
fn main() {
// let raw_data_dir = dirs_2::data_dir();
// if let Some(data_path) = raw_data_dir {
// let dp = format!("{}/nextlaunch/", data_path.to_str().unwrap());
// let _ = fs::create_dir(&dp);
// println!("Downloading language files");
// let pack_response = reqwest::blocking::get(LANG_URL);
// println!("Downloading config files");
// let config_response = reqwest::blocking::get(CONFIG_URL);
// println!("Downloading components");
// let readme_response = reqwest::blocking::get(README_URL);
//
// if let Ok(raw_pack) = pack_response {
// println!("unpacking language files");
// let bytes = raw_pack.bytes();
// if let Ok(raw_bytes) = bytes {
// let opts = fs::OpenOptions::new().read(true).write(true).create(true).open(format!("{}/lang_pack.tmpfile", dp));
// if let Ok(mut file) = opts {
// let bytes: Vec<u8> = raw_bytes.to_vec();
// let _ = file.write_all(bytes.as_slice());
// let _ = file.flush();
//
// let mut archive = zip::ZipArchive::new(file).unwrap();
//
// if let Err(e) = archive.extract(format!("{}/languages", dp)) {
// println!("cargo:warning=NextLaunch failed to unpack language files");
// println!("cargo:warning={:#?}", e);
// exit(1);
// }
// } else {
// println!("cargo:warning=NextLaunch failed to unpack language files");
// println!("cargo:warning={:#?}", opts.unwrap_err());
// exit(1);
// }
// } else {
// println!("cargo:warning=NextLaunch failed to unpack language files");
// println!("cargo:warning={:#?}", bytes.unwrap_err());
// exit(1);
// }
// } else {
// println!("cargo:warning=NextLaunch failed to download language files");
// println!("cargo:warning={:#?}", pack_response.unwrap_err());
// exit(1);
// }
//
// if let Ok(raw_pack) = readme_response {
// println!("unpacking language files");
// let bytes = raw_pack.bytes();
// if let Ok(raw_bytes) = bytes {
// let opts = fs::OpenOptions::new().read(true).write(true).create(true).open(format!("{}/readme_pack.tmpfile", dp));
// if let Ok(mut file) = opts {
// let bytes: Vec<u8> = raw_bytes.to_vec();
// let _ = file.write_all(bytes.as_slice());
// let _ = file.flush();
//
// let mut archive = zip::ZipArchive::new(file).unwrap();
//
// if let Err(e) = archive.extract(format!("{}/readme", dp)) {
// println!("cargo:warning=NextLaunch failed to unpack language files");
// println!("cargo:warning={:#?}", e);
// exit(1);
// }
// } else {
// println!("cargo:warning=NextLaunch failed to unpack language files");
// println!("cargo:warning={:#?}", opts.unwrap_err());
// exit(1);
// }
// } else {
// println!("cargo:warning=NextLaunch failed to unpack language files");
// println!("cargo:warning={:#?}", bytes.unwrap_err());
// exit(1);
// }
// } else {
// println!("cargo:warning=NextLaunch failed to download language files");
// println!("cargo:warning={:#?}", readme_response.unwrap_err());
// exit(1);
// }
//
// if let Ok(raw_config) = config_response {
// println!("unpacking config files");
// let bytes = raw_config.bytes();
// if let Ok(raw_bytes) = bytes {
// let opts = fs::OpenOptions::new().write(true).create(true).open(format!("{}/config.json", dp));
// if let Ok(mut file) = opts {
// let bytes: Vec<u8> = raw_bytes.to_vec();
// let _ = file.write_all(bytes.as_slice());
// let _ = file.flush();
// } else {
// println!("cargo:warning=NextLaunch failed to unpack config files");
// println!("cargo:warning={:#?}", opts.unwrap_err());
// exit(1);
// }
// } else {
// println!("cargo:warning=NextLaunch failed to unpack config files");
// println!("cargo:warning={:#?}", bytes.unwrap_err());
// exit(1);
// }
// } else {
// println!("cargo:warning=NextLaunch failed to download config files");
// println!("cargo:warning={:#?}", config_response.unwrap_err());
// exit(1);
// }
//
// let _ = fs::remove_file(format!("{}/lang_pack.tmpfile", dp));
// let _ = fs::remove_file(format!("{}/readme_pack.tmpfile", dp));
//
// } else {
// println!("cargo:warning=NextLaunch failed to determine location to store required files");
// exit(1);
// }
} |
use crate::smb2::{
header,
helper_functions::{
fields,
negotiate_context::{
Ciphers, CompressionAlgorithms, CompressionCapabilities, ContextType,
EncryptionCapabilities, NegotiateContext, NetnameNegotiateContextId,
PreauthIntegrityCapabilities,
},
},
requests::{self, negotiate::Dialects},
};
pub const DEFAULT_DIALECT_COUNT: &[u8; 2] = b"\x05\x00";
pub const ALL_EXCEPT_ENCRYPTION: &[u8; 4] = b"\x3f\x00\x00\x00";
pub const DEFAULT_CONTEXT_OFFSET: &[u8; 4] = b"\x70\x00\x00\x00";
/// Builds the working default negotiate request.
pub fn build_default_negotiate_request() -> (
Option<header::SyncHeader>,
Option<requests::negotiate::Negotiate>,
) {
let mut neg_req = requests::negotiate::Negotiate::default();
neg_req.dialect_count = DEFAULT_DIALECT_COUNT.to_vec();
neg_req.security_mode = fields::SecurityMode::NegotiateSigningEnabled.unpack_byte_code(2);
neg_req.capabilities = ALL_EXCEPT_ENCRYPTION.to_vec();
neg_req.client_guid = vec![0; 16];
neg_req.dialects = build_default_dialect_list();
neg_req.padding = vec![0; 2];
neg_req.negotiate_context_list = build_default_negotiate_context_list();
neg_req.negotiate_context_count = (neg_req.negotiate_context_list.len() as u16)
.to_le_bytes()
.to_vec();
neg_req.negotiate_context_offset = DEFAULT_CONTEXT_OFFSET.to_vec();
(
Some(super::build_sync_header(
header::Commands::Negotiate,
0,
0,
None,
None,
0,
)),
Some(neg_req),
)
}
/// Builds the working default dialect list.
pub fn build_default_dialect_list() -> Vec<Vec<u8>> {
vec![
Dialects::Smb202.unpack_byte_code(),
Dialects::Smb21.unpack_byte_code(),
Dialects::Smb30.unpack_byte_code(),
Dialects::Smb302.unpack_byte_code(),
Dialects::Smb311.unpack_byte_code(),
]
}
/// Builds the negotiate context list according to the given parameters.
pub fn build_default_negotiate_context_list() -> Vec<NegotiateContext> {
vec![
build_default_preauthentication_context(),
build_default_compression_context(),
build_default_netname_context_id(),
]
}
/// Builds the working default preauthentication context.
pub fn build_default_preauthentication_context() -> NegotiateContext {
let mut preauth = NegotiateContext::default();
let mut preauth_caps = PreauthIntegrityCapabilities::default();
preauth_caps.hash_algorithm_count = b"\x01\x00".to_vec();
preauth_caps.salt_length = b"\x20\x00".to_vec();
preauth_caps.hash_algorithms = vec![b"\x01\x00".to_vec()];
preauth_caps.salt =
b"\x79\x13\x02\xd4\xd7\x0c\x2a\x12\x50\x84\xba\xa6\x03\xae\xda\xe4\x12\xe8\x0b\x6e\
\x96\xf7\xdb\xa9\x46\xdf\x3e\xdc\x16\xe8\x4a\x5a"
.to_vec();
let preauth_context = ContextType::PreauthIntegrityCapabilities(preauth_caps);
preauth.context_type = preauth_context.unpack_byte_code();
preauth.data_length = b"\x26\x00".to_vec();
preauth.data = Some(preauth_context);
preauth
}
/// Builds the working default encryption negotiate context.
pub fn build_default_encryption_context() -> NegotiateContext {
// TODO: add option to pass cipher selection.
let mut encrypt = NegotiateContext::default();
let mut encrypt_caps = EncryptionCapabilities::default();
encrypt_caps.cipher_count = b"\x02\x00".to_vec();
encrypt_caps.ciphers = vec![
Ciphers::Aes128Gcm.unpack_byte_code(),
Ciphers::Aes128Ccm.unpack_byte_code(),
];
let encrypt_context = ContextType::EncryptionCapabilities(encrypt_caps);
encrypt.context_type = encrypt_context.unpack_byte_code();
encrypt.data_length = b"\x06\x00".to_vec();
encrypt.data = Some(encrypt_context);
encrypt
}
/// Builds the working default compression context.
pub fn build_default_compression_context() -> NegotiateContext {
// TODO: add selection option for compression algorithms.
let mut compress = NegotiateContext::default();
let mut compress_caps = CompressionCapabilities::default();
compress_caps.compression_algorithm_count = b"\x03\x00".to_vec();
compress_caps.flags = vec![0; 4];
compress_caps.compression_algorithms = vec![
CompressionAlgorithms::Lz77.unpack_byte_code(),
CompressionAlgorithms::Lz77Huffman.unpack_byte_code(),
CompressionAlgorithms::Lznt1.unpack_byte_code(),
];
let compress_context = ContextType::CompressionCapabilities(compress_caps);
compress.context_type = compress_context.unpack_byte_code();
compress.data_length = b"\x0e\x00".to_vec();
compress.data = Some(compress_context);
compress
}
/// Builds the working default netname context id.
pub fn build_default_netname_context_id() -> NegotiateContext {
// TODO: add option to choose netname.
let mut netname = NegotiateContext::default();
let mut netname_id = NetnameNegotiateContextId::default();
netname_id.net_name = b"\x31\x00\x39\x00\x32\x00\x2e\x00\x31\x00\x36\x00\x38\
\x00\x2e\x00\x30\x00\x2e\x00\x31\x00\x37\x00\x31\x00"
.to_vec();
let netname_context = ContextType::NetnameNegotiateContextId(netname_id);
netname.context_type = netname_context.unpack_byte_code();
netname.data_length = b"\x1a\x00".to_vec();
netname.data = Some(netname_context);
netname
}
#[cfg(test)]
mod tests {
// use super::*;
#[test]
fn test_build_default_negotiate_request() {}
#[test]
fn test_build_default_preauthentication_context() {}
#[test]
fn test_build_default_encryption_context() {}
#[test]
fn test_build_default_compression_context() {}
#[test]
fn test_build_default_netname_context_id() {}
}
|
use procon_reader::ProconReader;
fn main() {
let stdin = std::io::stdin();
let mut rd = ProconReader::new(stdin.lock());
let l: u32 = rd.get();
let q: usize = rd.get();
use std::collections::BTreeSet;
let mut cuts = BTreeSet::new();
for _ in 0..q {
let c: u8 = rd.get();
let x: u32 = rd.get();
if c == 1 {
cuts.insert(x);
} else {
let left = cuts.range(..x).last().copied().unwrap_or(0);
let right = cuts.range((x + 1)..).next().copied().unwrap_or(l);
println!("{}", right - left);
}
}
}
|
//! Crate wide documentation?
extern crate minecraft_monitor as mon;
use mon::functions::configuration::{determine_config, Verbosity};
use mon::functions::minecraft_related::*;
use mon::functions::shared_data::*;
use mon::functions::web_server::handle_connections;
use std::io::{BufRead, BufReader, Write};
use std::path::Path;
use std::process::{Command, Stdio};
use std::sync::mpsc;
use std::thread;
use std::time::Duration;
use std::{env, net::Ipv4Addr};
fn main() {
// Create a writer that will write content to a file, only interactions that happen from this software will be logged, Minecraft logs itself
let (
address,
port,
web_index,
root_location,
jar_name,
gen_args,
min_ram,
max_ram,
web_log, // If interactions with the webserver should be saved to a log
verbosity, // Currently this is not set up
) = determine_config(env::args().collect()).unwrap();
env::set_current_dir(Path::new(&root_location)).unwrap();
// Logger::new(); // TODO Logging will be hard
let shared_data = ServerSharedData::new();
// call launch with shared data
loop {
launch(
shared_data.clone(),
address.clone(),
port.clone(),
web_index.clone(),
jar_name.clone(),
gen_args.clone(),
min_ram.clone(),
max_ram.clone(),
web_log.clone(),
verbosity.clone(),
);
let mut state = shared_data.gen_state.lock().unwrap();
if *state == GeneralState::Restart {
*state = GeneralState::Running;
let mut mc_state = shared_data.mcserver_state.lock().unwrap();
*mc_state = MinecraftServerState::Starting;
println!("Restarting Server");
} else if *state == GeneralState::ShutDown {
println!("Shutting Down Server");
break;
} // If it does not shutdown then it restarts, it shouldn't reach this point without being either shutdown or restart
}
}
fn launch(
shared_data: ServerSharedData,
address: Ipv4Addr,
port: u16,
web_index: String,
jar_name: String,
gen_args: Option<String>,
min_ram: String,
max_ram: String,
web_log: bool,
verbosity: Verbosity,
) {
let (web_sender, web_receiver) = mpsc::channel::<String>();
let shared_data_web = shared_data.clone();
let web_sender_clone = web_sender.clone();
let web_handle = thread::spawn(move || {
handle_connections(
shared_data_web,
web_sender_clone,
address,
port,
web_index,
verbosity,
)
.unwrap()
});
let mut child;
if gen_args == None {
child = Command::new("java")
.args(&[
format!("-Xms{}", min_ram).as_str(),
format!("-Xmx{}", max_ram).as_str(),
"-XX:+UseG1GC",
"-jar",
format!("{}", jar_name).as_str(),
"nogui",
])
.stdout(Stdio::piped())
.stdin(Stdio::piped())
.spawn()
.expect("Error starting server, refer to console for more details.");
} else {
// let args = Vec::new();
let args = gen_args.unwrap();
let split_args = args.split(" ").collect::<Vec<&str>>();
// let test = args.clone();
child = Command::new("java")
.args(split_args)
.stdout(Stdio::piped())
.stdin(Stdio::piped())
.spawn()
.expect("Error starting server, refer to console for more details.");
}
// Output section
let mut mcserver_out = BufReader::new(
child
.stdout
.take()
.expect("[Error] Failed to open server output"),
);
let shared_data_output = shared_data.clone();
let output_verbosity = verbosity.clone(); // This might not be needed because COPY has been derived now
let output_sender = web_sender.clone();
let output_handle = thread::spawn(move || {
let mut line_num: u32 = 0;
let output_sender_thread = output_sender.clone();
loop {
// let output_sender3 = output_sender2.clone();
{
// If the server is trying to restart exit the output thread to the minecraft server
let mc_state = shared_data_output.mcserver_state.lock().unwrap();
// println!("Checking state in output");
if *mc_state == MinecraftServerState::Off {
let mut state = shared_data_output.gen_state.lock().unwrap();
if *state == GeneralState::Restart || *state == GeneralState::ShutDown {
break;
} else if *state == GeneralState::Running {
*state = GeneralState::Restart;
break;
}
}
let state = shared_data_output.gen_state.lock().unwrap();
if *mc_state == MinecraftServerState::Eula && *state == GeneralState::Restart {
break;
}
}
let chat = shared_data_output.server_output.clone();
let mut buf = Vec::new();
mcserver_out.read_until(b'\n', &mut buf).unwrap();
let line = String::from_utf8(buf).unwrap();
if line != "".to_string() {
let content = &line.clone()[17..];
if line != "" {
let mut term = chat.lock().unwrap();
if output_verbosity == Verbosity::Mine || verbosity == Verbosity::MineWeb {
print!("\x1b[0;36m[Console]:\x1b[0m {}", line);
}
term.push_front((line_num, line));
while term.len() > 1000 {
term.pop_back();
}
}
// Check if a player has joined
server_output_scanning(content, shared_data_output.clone(), &output_sender_thread);
line_num += 1;
}
}
});
// Input section
let shared_data_input = shared_data.clone();
let input_verbosity = verbosity.clone();
let input_handle = thread::spawn(move || {
loop {
// let verbosity = verbosity.clone();
{
// If the server is trying to restart exit the input thread to the minecraft server
let mc_state = shared_data_input.mcserver_state.lock().unwrap();
if *mc_state == MinecraftServerState::Off {
let mut state = shared_data_input.gen_state.lock().unwrap();
println!("Checking state in input");
if *state == GeneralState::Restart || *state == GeneralState::ShutDown {
break;
} else if *state == GeneralState::Running {
*state = GeneralState::Restart;
break;
}
}
let state = shared_data_input.gen_state.lock().unwrap();
if *mc_state == MinecraftServerState::Eula && *state == GeneralState::Restart {
break;
}
}
// Sleeping per the tick rate, this might be slightly extreme for the purposes of this application
match web_receiver.recv_timeout(Duration::from_millis(50)) {
Ok(mut cmd) => {
cmd = cmd + "\n";
if input_verbosity == Verbosity::Mine || input_verbosity == Verbosity::MineWeb {
print!("\x1b[0;35m[Command]:\x1b[0m {}", cmd);
}
{
let server_in = child.stdin.as_mut().unwrap();
server_in.write_all(cmd.as_bytes()).unwrap();
}
}
Err(_) => {
// Input is empty after time out, there is either no new input or the server is processing the next input.
}
}
}
});
output_handle.join().unwrap();
if verbosity == Verbosity::Mine || verbosity == Verbosity::MineWeb {
println!("Minecraft Server Output Thread Closed");
}
input_handle.join().unwrap();
if verbosity == Verbosity::Mine || verbosity == Verbosity::MineWeb {
println!("Minecraft Server Input Thread Closed");
}
web_handle.join().unwrap();
if verbosity == Verbosity::Web || verbosity == Verbosity::MineWeb {
println!("Web Server Thread Closed");
}
}
|
use structopt::StructOpt;
#[derive(Debug, Clone, StructOpt)]
#[structopt(rename_all = "kebab-case")]
pub struct CmdLineOpt {
#[structopt(short = "c", long = "config-file", default_value = "Config.toml")]
pub config_file: String,
#[structopt(long = "migration")]
pub migration: bool,
}
|
//! Traits and types related to loading an abi_stable dynamic library,
//! as well as functions/modules within.
//!
//! # Loading the root module
//!
//! When you use the [`RootModule`]`::load_from*` associated functions,
//! the root module of a library is loaded in this order:
//! 1. A [`RawLibrary`] is loaded
//! (The library is leaked so that the root module loader can
//! do anything incompatible with library unloading.)
//! 2. An [`AbiHeaderRef`] handle to the static that contains the root module is obtained.
//! 3. The [`AbiHeaderRef`] checks that the abi_stable version used by that library is
//! compatible with the loader's, upgrading to a [`&'static LibHeader`] on success.
//! 4. The [`LibHeader`] checks that the layout of the types in the root module
//! (and everything it references) are compatible with the loader's
//! 5. The [root module](./trait.RootModule.html)
//! is loaded using the function from the loaded library
//! that was annotated with [`#[export_root_module]`](../attr.export_root_module.html).
//! 6. [`RootModule::initialize`] is called on the root module.
//!
//! All steps can return errors.
//!
//! [`RawLibrary`]: ./struct.RawLibrary.html
//! [`AbiHeaderRef`]: ./struct.AbiHeaderRef.html
//! [`RootModule`]: ./trait.RootModule.html
//! [`RootModule::initialize`]: ./trait.RootModule.html#method.initialization
//! [`&'static LibHeader`]: ./struct.LibHeader.html
use std::{
convert::Infallible,
mem,
path::{Path, PathBuf},
sync::atomic,
};
#[allow(unused_imports)]
use core_extensions::SelfOps;
use libloading::{Library as LibLoadingLibrary, Symbol as LLSymbol};
use crate::{
abi_stability::stable_abi_trait::StableAbi,
globals::{self, Globals},
marker_type::ErasedPrefix,
prefix_type::{PrefixRef, PrefixRefTrait},
sabi_types::{LateStaticRef, NulStr, VersionNumber, VersionStrings},
std_types::{RResult, RStr},
type_layout::TypeLayout,
};
pub mod c_abi_testing;
pub mod development_utils;
mod errors;
mod lib_header;
#[cfg(test)]
mod library_tests;
mod raw_library;
mod root_mod_trait;
#[doc(no_inline)]
pub use self::c_abi_testing::{CAbiTestingFns, C_ABI_TESTING_FNS};
pub use self::{
errors::{IntoRootModuleResult, LibraryError, RootModuleError},
lib_header::{AbiHeader, AbiHeaderRef, LibHeader},
raw_library::RawLibrary,
root_mod_trait::{
abi_header_from_path, abi_header_from_raw_library, lib_header_from_path,
lib_header_from_raw_library, RootModule, RootModuleConsts,
},
};
///////////////////////////////////////////////////////////////////////////////
/// What naming convention to expect when loading a library from a directory.
#[derive(Debug, Copy, Clone, PartialEq, Eq, Ord, PartialOrd, Hash)]
pub enum LibrarySuffix {
/// Loads a dynamic library at `<folder>/<name>.extension`
NoSuffix,
/// Loads a dynamic library at `<folder>/<name>-<pointer_size>.<extension>`
Suffix,
}
//////////////////////////////////////////////////////////////////////
/// The path a library is loaded from.
#[derive(Debug, Copy, Clone, PartialEq, Eq, Ord, PartialOrd, Hash)]
pub enum LibraryPath<'a> {
/// The full path to the dynamic library.
FullPath(&'a Path),
/// The path to the directory that contains the dynamic library.
Directory(&'a Path),
}
//////////////////////////////////////////////////////////////////////
/// Tells [`LibHeader::from_constructor`] whether to
/// include the layout of the root module for checking it when loaded.
pub enum CheckTypeLayout {
/// Include the layout of the root module
Yes,
/// Exclude the layout of the root module
No,
}
//////////////////////////////////////////////////////////////////////
/// Whether the ABI of a root module is checked.
#[repr(u8)]
#[derive(Debug, Copy, Clone, StableAbi)]
pub enum IsLayoutChecked {
/// The ABI is checked
Yes(&'static TypeLayout),
/// The ABI is not checked
No,
}
impl IsLayoutChecked {
/// Converts this into an `Option`.
///
/// `Ỳes` corresponds to `Some`, and `No` corresponds to `None`.
pub const fn into_option(self) -> Option<&'static TypeLayout> {
match self {
IsLayoutChecked::Yes(x) => Some(x),
IsLayoutChecked::No => None,
}
}
}
//////////////////////////////////////////////////////////////////////
/// The return type of the function that the
/// [`#[export_root_module]`](../attr.export_root_module.html) attribute outputs.
pub type RootModuleResult = RResult<PrefixRef<ErasedPrefix>, RootModuleError>;
//////////////////////////////////////////////////////////////////////
/// The static variables declared for some [`RootModule`] implementor.
/// [`RootModule`]: ./trait.RootModule.html
#[doc(hidden)]
pub struct RootModuleStatics<M> {
root_mod: LateStaticRef<M>,
raw_lib: LateStaticRef<&'static RawLibrary>,
}
impl<M> RootModuleStatics<M> {
///
/// # Safety
///
/// This must only be called from the `abi_stable::declare_root_module_statics` macro.
#[doc(hidden)]
#[inline]
pub const unsafe fn __private_new() -> Self {
Self {
root_mod: LateStaticRef::new(),
raw_lib: LateStaticRef::new(),
}
}
}
/// Implements the [`RootModule::root_module_statics`] associated function.
///
/// To define the associated function use:
/// `abi_stable::declare_root_module_statics!{TypeOfSelf}`.
/// Passing `Self` instead of `TypeOfSelf` won't work.
///
/// # Example
///
/// ```rust
/// use abi_stable::{
/// library::RootModule,
/// sabi_types::VersionStrings,
/// StableAbi,
/// };
///
/// #[repr(C)]
/// #[derive(StableAbi)]
/// #[sabi(kind(Prefix(prefix_ref = Module_Ref, prefix_fields = Module_Prefix)))]
/// pub struct Module{
/// pub first: u8,
/// #[sabi(last_prefix_field)]
/// pub second: u16,
/// pub third: u32,
/// }
/// impl RootModule for Module_Ref {
/// abi_stable::declare_root_module_statics!{Module_Ref}
/// const BASE_NAME: &'static str = "example_root_module";
/// const NAME: &'static str = "example_root_module";
/// const VERSION_STRINGS: VersionStrings = abi_stable::package_version_strings!();
/// }
///
/// # fn main(){}
/// ```
///
#[cfg_attr(
doctest,
doc = r###"
```rust
struct Foo;
impl Foo {
abi_stable::declare_root_module_statics!{Foo}
}
```
```rust
struct Foo;
impl Foo {
abi_stable::declare_root_module_statics!{(Foo)}
}
```
```compile_fail
struct Foo;
impl Foo {
abi_stable::declare_root_module_statics!{Self}
}
```
```compile_fail
struct Foo;
impl Foo {
abi_stable::declare_root_module_statics!{(Self)}
}
```
```compile_fail
struct Foo;
impl Foo {
abi_stable::declare_root_module_statics!{((Self))}
}
```
"###
)]
/// [`RootModule::root_module_statics`]:
/// ./library/trait.RootModule.html#tymethod.root_module_statics
#[macro_export]
macro_rules! declare_root_module_statics {
( ( $($stuff:tt)* ) ) => (
$crate::declare_root_module_statics!{$($stuff)*}
);
( Self ) => (
compile_error!{"Don't use `Self`, write the full type name"}
);
( $this:ty ) => (
#[inline]
fn root_module_statics()->&'static $crate::library::RootModuleStatics<$this>{
static _ROOT_MOD_STATICS:$crate::library::RootModuleStatics<$this>= unsafe{
$crate::library::RootModuleStatics::__private_new()
};
&_ROOT_MOD_STATICS
}
);
}
//////////////////////////////////////////////////////////////////////
abi_stable_derive::__const_mangled_root_module_loader_name! {}
/// The name of the `static` that contains the [`LibHeader`] of an abi_stable library.
///
/// There's also these alternatives to this constant:
/// - [`ROOT_MODULE_LOADER_NAME_WITH_NUL`]: this constant concatenated with `"\0"`
/// - [`ROOT_MODULE_LOADER_NAME_NULSTR`]: a [`NulStr`] equivalent of this constant
///
/// [`LibHeader`]: ./struct.LibHeader.html
/// [`AbiHeaderRef`]: ./struct.AbiHeaderRef.html
/// [`AbiHeaderRef::upgrade`]: ./struct.AbiHeaderRef.html#method.upgrade
/// [`ROOT_MODULE_LOADER_NAME_WITH_NUL`]: ./constant.ROOT_MODULE_LOADER_NAME_WITH_NUL.html
/// [`ROOT_MODULE_LOADER_NAME_NULSTR`]: ./constant.ROOT_MODULE_LOADER_NAME_NULSTR.html
/// [`NulStr`]: ../sabi_types/struct.NulStr.html
pub const ROOT_MODULE_LOADER_NAME: &str = PRIV_MANGLED_ROOT_MODULE_LOADER_NAME;
/// A nul-terminated equivalent of [`ROOT_MODULE_LOADER_NAME`].
///
/// [`ROOT_MODULE_LOADER_NAME`]: ./constant.ROOT_MODULE_LOADER_NAME.html
pub const ROOT_MODULE_LOADER_NAME_WITH_NUL: &str = PRIV_MANGLED_ROOT_MODULE_LOADER_NAME_NUL;
/// A [`NulStr`] equivalent of [`ROOT_MODULE_LOADER_NAME`].
///
/// [`ROOT_MODULE_LOADER_NAME`]: ./constant.ROOT_MODULE_LOADER_NAME.html
/// [`NulStr`]: ../sabi_types/struct.NulStr.html
pub const ROOT_MODULE_LOADER_NAME_NULSTR: NulStr<'_> =
NulStr::from_str(PRIV_MANGLED_ROOT_MODULE_LOADER_NAME_NUL);
//////////////////////////////////////////////////////////////////////
#[doc(hidden)]
pub fn __call_root_module_loader<T>(function: fn() -> T) -> RootModuleResult
where
T: IntoRootModuleResult,
{
type TheResult = Result<PrefixRef<ErasedPrefix>, RootModuleError>;
let res = ::std::panic::catch_unwind(|| -> TheResult {
let ret: T::Module = function().into_root_module_result()?;
let _ = <T::Module as RootModule>::load_module_with(|| Ok::<_, Infallible>(ret));
unsafe { ret.to_prefix_ref().cast::<ErasedPrefix>().piped(Ok) }
});
// We turn an unwinding panic into an error value
let flattened: TheResult = res.unwrap_or(Err(RootModuleError::Unwound));
RootModuleResult::from(flattened)
}
|
use super::*;
use proptest::collection::SizeRange;
use proptest::strategy::Strategy;
use crate::test::strategy::NON_EMPTY_RANGE_INCLUSIVE;
#[test]
fn without_list_right_returns_true() {
run!(
|arc_process| {
(
strategy::term::list::non_empty_maybe_improper(arc_process.clone()),
strategy::term(arc_process.clone())
.prop_filter("Right must not be list", |v| !v.is_non_empty_list()),
)
},
|(left, right)| {
prop_assert_eq!(result(left, right), true.into());
Ok(())
},
);
}
#[test]
fn with_same_list_right_returns_false() {
run!(
|arc_process| strategy::term::list::non_empty_maybe_improper(arc_process.clone()),
|operand| {
prop_assert_eq!(result(operand, operand), false.into());
Ok(())
},
);
}
#[test]
fn with_same_value_list_right_returns_false() {
run!(
|arc_process| {
let size_range: SizeRange = NON_EMPTY_RANGE_INCLUSIVE.clone().into();
proptest::collection::vec(strategy::term(arc_process.clone()), size_range).prop_map(
move |vec| match vec.len() {
1 => (
arc_process.list_from_slice(&vec),
arc_process.list_from_slice(&vec),
),
len => {
let last_index = len - 1;
(
arc_process
.improper_list_from_slice(&vec[0..last_index], vec[last_index]),
arc_process
.improper_list_from_slice(&vec[0..last_index], vec[last_index]),
)
}
},
)
},
|(left, right)| {
prop_assert_eq!(result(left, right), false.into());
Ok(())
},
);
}
#[test]
fn with_different_list_right_returns_true() {
run!(
|arc_process| {
(
strategy::term::list::non_empty_maybe_improper(arc_process.clone()),
strategy::term::list::non_empty_maybe_improper(arc_process.clone()),
)
.prop_filter("Lists must be different", |(left, right)| left != right)
},
|(left, right)| {
prop_assert_eq!(result(left, right), true.into());
Ok(())
},
);
}
|
// This file is Copyright its original authors, visible in version control
// history.
//
// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
// You may not use this file except in accordance with one or both of these
// licenses.
const APP_MAJOR: u8 = 0;
const APP_MINOR: u8 = 2;
const APP_PATCH: u8 = 1;
const APP_PRE_RELEASE: &str = "";
pub fn get_version() -> String {
let mut version = format!("{}.{}.{}", APP_MAJOR, APP_MINOR, APP_PATCH);
if !APP_PRE_RELEASE.is_empty() {
version = format!("{}-{}", version, APP_PRE_RELEASE);
}
version
}
|
use std::fmt::Debug;
use druid_table::{
column, AxisMeasurementType, CellCtx, CellRender, CellRenderExt, DataCompare, EditorFactory,
ShowHeadings, SortDirection, Table, TableAxis, TableBuilder, TextCell,
};
use druid::im::{vector, Vector};
use druid::kurbo::CircleSegment;
use druid::theme::PLACEHOLDER_COLOR;
use druid::widget::{
Button, Checkbox, CrossAxisAlignment, Flex, Label, MainAxisAlignment, Padding, RadioGroup,
SizedBox, Stepper, ViewSwitcher,
};
use druid::{
AppLauncher, Data, Env, KeyOrValue, Lens, LensExt, LocalizedString, PaintCtx, Point,
RenderContext, Widget, WidgetExt, WindowDesc,
};
use druid::{Color, Value};
use std::cmp::Ordering;
use std::f64::consts::PI;
const WINDOW_TITLE: LocalizedString<HelloState> = LocalizedString::new("Hello Table!");
#[derive(Clone, Data, Lens, Debug)]
struct HelloRow {
lang: String,
greeting: String,
westernised: String,
who_knows: f64,
}
impl HelloRow {
fn new(
lang: impl Into<String>,
greeting: impl Into<String>,
westernised: impl Into<String>,
percent: f64,
) -> HelloRow {
HelloRow {
lang: lang.into(),
greeting: greeting.into(),
westernised: westernised.into(),
who_knows: percent / 100.,
}
}
}
#[derive(Clone, Lens, Data, Debug)]
struct Settings {
show_headings: ShowHeadings,
border_thickness: f64,
row_fixed: bool,
col_fixed: bool,
}
impl PartialEq for Settings {
fn eq(&self, other: &Self) -> bool {
self.same(other)
}
}
#[derive(Clone, Data, Lens)]
struct HelloState {
items: Vector<HelloRow>,
settings: Settings,
}
struct PieCell {}
impl DataCompare<f64> for PieCell {
fn compare(&self, a: &f64, b: &f64) -> Ordering {
f64::partial_cmp(a, b).unwrap_or(Ordering::Equal)
}
}
impl CellRender<f64> for PieCell {
fn init(&mut self, _ctx: &mut PaintCtx, _env: &Env) {}
fn paint(&self, ctx: &mut PaintCtx, _cell: &CellCtx, data: &f64, _env: &Env) {
let rect = ctx.region().bounding_box().with_origin(Point::ORIGIN);
//ctx.stroke( rect, &Color::rgb(0x60, 0x0, 0x10), 2.);
let circle = CircleSegment::new(
rect.center(),
(f64::min(rect.height(), rect.width()) / 2.) - 2.,
0.,
0.,
2. * PI * *data,
);
ctx.fill(&circle, &Color::rgb8(0x0, 0xFF, 0x0));
ctx.stroke(&circle, &Color::BLACK, 1.0);
}
}
impl EditorFactory<f64> for PieCell {
fn make_editor(&mut self, _ctx: &CellCtx) -> Option<Box<dyn Widget<f64>>> {
None
}
}
fn build_main_widget() -> impl Widget<HelloState> {
// Need a wrapper widget to get selection/scroll events out of it
let row = || HelloRow::new("Japanese", "こんにちは", "Kon'nichiwa", 63.);
let buttons = Flex::column()
.cross_axis_alignment(CrossAxisAlignment::Start)
.with_child(decor(Label::new("Modify table")))
.with_child(
Flex::column()
.with_child(
Button::new("Add row")
.on_click(move |_, data: &mut Vector<HelloRow>, _| {
data.push_back(row());
})
.expand_width(),
)
.with_child(
Button::new("Remove row")
.on_click(|_, data: &mut Vector<HelloRow>, _| {
data.pop_back();
})
.expand_width(),
)
.padding(5.0),
)
.fix_width(200.0)
.lens(HelloState::items);
let headings_control = Flex::column()
.cross_axis_alignment(CrossAxisAlignment::Start)
.with_child(decor(Label::new("Headings to show")))
.with_child(RadioGroup::new(vec![
("Just cells", ShowHeadings::JustCells),
("Column headings", ShowHeadings::One(TableAxis::Columns)),
("Row headings", ShowHeadings::One(TableAxis::Rows)),
("Both", ShowHeadings::Both),
]))
.lens(HelloState::settings.then(Settings::show_headings));
let style = Flex::column()
.cross_axis_alignment(CrossAxisAlignment::Start)
.with_child(decor(Label::new("Style")))
.with_child(
Flex::row()
.with_child(Label::new("Border thickness"))
.with_flex_spacer(1.0)
.with_child(Label::new(|p: &f64, _: &Env| p.to_string()))
.with_child(Stepper::new().with_range(0., 20.0).with_step(0.5))
.lens(HelloState::settings.then(Settings::border_thickness)),
);
let measurements = Flex::column()
.cross_axis_alignment(CrossAxisAlignment::Start)
.with_child(decor(Label::new("Uniform axes")))
.with_child(Flex::row().with_child(Checkbox::new("Rows").lens(Settings::row_fixed)))
.with_child(Flex::row().with_child(Checkbox::new("Columns").lens(Settings::col_fixed)))
.lens(HelloState::settings);
let sidebar = Flex::column()
.main_axis_alignment(MainAxisAlignment::Start)
.cross_axis_alignment(CrossAxisAlignment::Start)
.with_child(group(buttons))
.with_child(group(headings_control))
.with_child(group(style))
.with_child(group(measurements))
.with_flex_spacer(1.)
.fix_width(200.0);
let vs = ViewSwitcher::new(
|ts: &HelloState, _| ts.settings.clone(),
|sh, _, _| Box::new(build_table(sh.clone()).lens(HelloState::items)),
)
.padding(10.);
Flex::row()
.cross_axis_alignment(CrossAxisAlignment::Start)
.with_child(sidebar)
.with_flex_child(vs, 1.)
}
fn decor<T: Data>(label: Label<T>) -> SizedBox<T> {
label
.padding(5.)
.background(PLACEHOLDER_COLOR)
.expand_width()
}
fn group<T: Data, W: Widget<T> + 'static>(w: W) -> Padding<T> {
w.border(Color::WHITE, 0.5).padding(5.)
}
fn build_table(settings: Settings) -> impl Widget<Vector<HelloRow>> {
let table_builder = TableBuilder::<HelloRow, Vector<HelloRow>>::new()
.measuring_axis(
TableAxis::Rows,
if settings.row_fixed {
AxisMeasurementType::Uniform
} else {
AxisMeasurementType::Individual
},
)
.measuring_axis(
TableAxis::Columns,
if settings.col_fixed {
AxisMeasurementType::Uniform
} else {
AxisMeasurementType::Individual
},
)
.headings(settings.show_headings)
.border(settings.border_thickness)
.with_column("Language", TextCell::new().lens(HelloRow::lang))
.with_column(
"Greeting",
TextCell::new().font_size(17.).lens(HelloRow::greeting),
)
.with_column(
"Westernised",
TextCell::new().font_size(17.).lens(HelloRow::westernised),
)
.with(
column("Who knows?", PieCell {}.lens(HelloRow::who_knows))
.sort(SortDirection::Ascending),
)
.with_column(
"Greeting 2 with very long column name",
TextCell::new()
.font_name(KeyOrValue::Concrete("Courier New".into()))
.lens(HelloRow::greeting),
)
.with_column(
"Greeting 3",
TextCell::new()
.text_color(Color::rgb8(0xD0, 0, 0))
.lens(HelloRow::greeting),
)
.with_column("Greeting 4", TextCell::new().lens(HelloRow::greeting))
.with_column("Greeting 5", TextCell::new().lens(HelloRow::greeting))
.with_column("Greeting 6", TextCell::new().lens(HelloRow::greeting));
let measures = table_builder.build_measures();
let table = Table::new_in_scope(table_builder.build_args(), measures);
table
}
pub fn main() {
// describe the main window
let main_window = WindowDesc::new(build_main_widget)
.title(WINDOW_TITLE)
.window_size((800.0, 500.0));
// create the initial app state
let initial_state = HelloState {
items: vector![
HelloRow::new("English", "Hello", "Hello", 99.1),
HelloRow::new("Français", "Bonjour", "Bonjour", 95.0),
HelloRow::new("Espanol", "Hola", "Hola", 95.0),
HelloRow::new("Mandarin", "你好", "nǐ hǎo", 85.),
HelloRow::new("Hindi", "नमस्ते", "namaste", 74.),
HelloRow::new("Arabic", "مرحبا", "marhabaan", 24.),
HelloRow::new("Portuguese", "olá", "olá", 30.),
HelloRow::new("Russian", "Привет", "Privet", 42.),
HelloRow::new("Japanese", "こんにちは", "Kon'nichiwa", 63.),
],
settings: Settings {
show_headings: ShowHeadings::Both,
border_thickness: 1.,
row_fixed: false,
col_fixed: false,
},
};
// start the application
AppLauncher::with_window(main_window)
.use_simple_logger()
.launch(initial_state)
.expect("Failed to launch application");
}
|
#![allow(unused_variables, non_upper_case_globals, non_snake_case, unused_unsafe, non_camel_case_types, dead_code, clippy::all)]
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy, :: core :: fmt :: Debug, :: core :: cmp :: PartialEq, :: core :: cmp :: Eq)]
#[repr(transparent)]
pub struct COMPRESSOR_HANDLE(pub isize);
impl ::core::default::Default for COMPRESSOR_HANDLE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
unsafe impl ::windows::core::Handle for COMPRESSOR_HANDLE {}
unsafe impl ::windows::core::Abi for COMPRESSOR_HANDLE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct COMPRESS_ALGORITHM(pub u32);
pub const COMPRESS_ALGORITHM_MSZIP: COMPRESS_ALGORITHM = COMPRESS_ALGORITHM(2u32);
pub const COMPRESS_ALGORITHM_XPRESS: COMPRESS_ALGORITHM = COMPRESS_ALGORITHM(3u32);
pub const COMPRESS_ALGORITHM_XPRESS_HUFF: COMPRESS_ALGORITHM = COMPRESS_ALGORITHM(4u32);
pub const COMPRESS_ALGORITHM_LZMS: COMPRESS_ALGORITHM = COMPRESS_ALGORITHM(5u32);
impl ::core::convert::From<u32> for COMPRESS_ALGORITHM {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for COMPRESS_ALGORITHM {
type Abi = Self;
}
impl ::core::ops::BitOr for COMPRESS_ALGORITHM {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for COMPRESS_ALGORITHM {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for COMPRESS_ALGORITHM {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for COMPRESS_ALGORITHM {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for COMPRESS_ALGORITHM {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
pub const COMPRESS_ALGORITHM_INVALID: u32 = 0u32;
pub const COMPRESS_ALGORITHM_MAX: u32 = 6u32;
pub const COMPRESS_ALGORITHM_NULL: u32 = 1u32;
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
pub struct COMPRESS_ALLOCATION_ROUTINES {
pub Allocate: ::core::option::Option<PFN_COMPRESS_ALLOCATE>,
pub Free: ::core::option::Option<PFN_COMPRESS_FREE>,
pub UserContext: *mut ::core::ffi::c_void,
}
impl COMPRESS_ALLOCATION_ROUTINES {}
impl ::core::default::Default for COMPRESS_ALLOCATION_ROUTINES {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for COMPRESS_ALLOCATION_ROUTINES {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("COMPRESS_ALLOCATION_ROUTINES").field("UserContext", &self.UserContext).finish()
}
}
impl ::core::cmp::PartialEq for COMPRESS_ALLOCATION_ROUTINES {
fn eq(&self, other: &Self) -> bool {
self.Allocate.map(|f| f as usize) == other.Allocate.map(|f| f as usize) && self.Free.map(|f| f as usize) == other.Free.map(|f| f as usize) && self.UserContext == other.UserContext
}
}
impl ::core::cmp::Eq for COMPRESS_ALLOCATION_ROUTINES {}
unsafe impl ::windows::core::Abi for COMPRESS_ALLOCATION_ROUTINES {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct COMPRESS_INFORMATION_CLASS(pub i32);
pub const COMPRESS_INFORMATION_CLASS_INVALID: COMPRESS_INFORMATION_CLASS = COMPRESS_INFORMATION_CLASS(0i32);
pub const COMPRESS_INFORMATION_CLASS_BLOCK_SIZE: COMPRESS_INFORMATION_CLASS = COMPRESS_INFORMATION_CLASS(1i32);
pub const COMPRESS_INFORMATION_CLASS_LEVEL: COMPRESS_INFORMATION_CLASS = COMPRESS_INFORMATION_CLASS(2i32);
impl ::core::convert::From<i32> for COMPRESS_INFORMATION_CLASS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for COMPRESS_INFORMATION_CLASS {
type Abi = Self;
}
pub const COMPRESS_RAW: u32 = 536870912u32;
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn CloseCompressor<'a, Param0: ::windows::core::IntoParam<'a, COMPRESSOR_HANDLE>>(compressorhandle: Param0) -> super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn CloseCompressor(compressorhandle: COMPRESSOR_HANDLE) -> super::super::Foundation::BOOL;
}
::core::mem::transmute(CloseCompressor(compressorhandle.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn CloseDecompressor(decompressorhandle: isize) -> super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn CloseDecompressor(decompressorhandle: isize) -> super::super::Foundation::BOOL;
}
::core::mem::transmute(CloseDecompressor(::core::mem::transmute(decompressorhandle)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn Compress<'a, Param0: ::windows::core::IntoParam<'a, COMPRESSOR_HANDLE>>(compressorhandle: Param0, uncompresseddata: *const ::core::ffi::c_void, uncompresseddatasize: usize, compressedbuffer: *mut ::core::ffi::c_void, compressedbuffersize: usize, compresseddatasize: *mut usize) -> super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn Compress(compressorhandle: COMPRESSOR_HANDLE, uncompresseddata: *const ::core::ffi::c_void, uncompresseddatasize: usize, compressedbuffer: *mut ::core::ffi::c_void, compressedbuffersize: usize, compresseddatasize: *mut usize) -> super::super::Foundation::BOOL;
}
::core::mem::transmute(Compress(compressorhandle.into_param().abi(), ::core::mem::transmute(uncompresseddata), ::core::mem::transmute(uncompresseddatasize), ::core::mem::transmute(compressedbuffer), ::core::mem::transmute(compressedbuffersize), ::core::mem::transmute(compresseddatasize)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn CreateCompressor(algorithm: COMPRESS_ALGORITHM, allocationroutines: *const COMPRESS_ALLOCATION_ROUTINES, compressorhandle: *mut isize) -> super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn CreateCompressor(algorithm: COMPRESS_ALGORITHM, allocationroutines: *const ::core::mem::ManuallyDrop<COMPRESS_ALLOCATION_ROUTINES>, compressorhandle: *mut isize) -> super::super::Foundation::BOOL;
}
::core::mem::transmute(CreateCompressor(::core::mem::transmute(algorithm), ::core::mem::transmute(allocationroutines), ::core::mem::transmute(compressorhandle)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn CreateDecompressor(algorithm: COMPRESS_ALGORITHM, allocationroutines: *const COMPRESS_ALLOCATION_ROUTINES, decompressorhandle: *mut isize) -> super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn CreateDecompressor(algorithm: COMPRESS_ALGORITHM, allocationroutines: *const ::core::mem::ManuallyDrop<COMPRESS_ALLOCATION_ROUTINES>, decompressorhandle: *mut isize) -> super::super::Foundation::BOOL;
}
::core::mem::transmute(CreateDecompressor(::core::mem::transmute(algorithm), ::core::mem::transmute(allocationroutines), ::core::mem::transmute(decompressorhandle)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn Decompress(decompressorhandle: isize, compresseddata: *const ::core::ffi::c_void, compresseddatasize: usize, uncompressedbuffer: *mut ::core::ffi::c_void, uncompressedbuffersize: usize, uncompresseddatasize: *mut usize) -> super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn Decompress(decompressorhandle: isize, compresseddata: *const ::core::ffi::c_void, compresseddatasize: usize, uncompressedbuffer: *mut ::core::ffi::c_void, uncompressedbuffersize: usize, uncompresseddatasize: *mut usize) -> super::super::Foundation::BOOL;
}
::core::mem::transmute(Decompress(::core::mem::transmute(decompressorhandle), ::core::mem::transmute(compresseddata), ::core::mem::transmute(compresseddatasize), ::core::mem::transmute(uncompressedbuffer), ::core::mem::transmute(uncompressedbuffersize), ::core::mem::transmute(uncompresseddatasize)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
pub type PFN_COMPRESS_ALLOCATE = unsafe extern "system" fn(usercontext: *const ::core::ffi::c_void, size: usize) -> *mut ::core::ffi::c_void;
pub type PFN_COMPRESS_FREE = unsafe extern "system" fn(usercontext: *const ::core::ffi::c_void, memory: *const ::core::ffi::c_void);
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn QueryCompressorInformation<'a, Param0: ::windows::core::IntoParam<'a, COMPRESSOR_HANDLE>>(compressorhandle: Param0, compressinformationclass: COMPRESS_INFORMATION_CLASS, compressinformation: *mut ::core::ffi::c_void, compressinformationsize: usize) -> super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn QueryCompressorInformation(compressorhandle: COMPRESSOR_HANDLE, compressinformationclass: COMPRESS_INFORMATION_CLASS, compressinformation: *mut ::core::ffi::c_void, compressinformationsize: usize) -> super::super::Foundation::BOOL;
}
::core::mem::transmute(QueryCompressorInformation(compressorhandle.into_param().abi(), ::core::mem::transmute(compressinformationclass), ::core::mem::transmute(compressinformation), ::core::mem::transmute(compressinformationsize)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn QueryDecompressorInformation(decompressorhandle: isize, compressinformationclass: COMPRESS_INFORMATION_CLASS, compressinformation: *mut ::core::ffi::c_void, compressinformationsize: usize) -> super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn QueryDecompressorInformation(decompressorhandle: isize, compressinformationclass: COMPRESS_INFORMATION_CLASS, compressinformation: *mut ::core::ffi::c_void, compressinformationsize: usize) -> super::super::Foundation::BOOL;
}
::core::mem::transmute(QueryDecompressorInformation(::core::mem::transmute(decompressorhandle), ::core::mem::transmute(compressinformationclass), ::core::mem::transmute(compressinformation), ::core::mem::transmute(compressinformationsize)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn ResetCompressor<'a, Param0: ::windows::core::IntoParam<'a, COMPRESSOR_HANDLE>>(compressorhandle: Param0) -> super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn ResetCompressor(compressorhandle: COMPRESSOR_HANDLE) -> super::super::Foundation::BOOL;
}
::core::mem::transmute(ResetCompressor(compressorhandle.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn ResetDecompressor(decompressorhandle: isize) -> super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn ResetDecompressor(decompressorhandle: isize) -> super::super::Foundation::BOOL;
}
::core::mem::transmute(ResetDecompressor(::core::mem::transmute(decompressorhandle)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SetCompressorInformation<'a, Param0: ::windows::core::IntoParam<'a, COMPRESSOR_HANDLE>>(compressorhandle: Param0, compressinformationclass: COMPRESS_INFORMATION_CLASS, compressinformation: *const ::core::ffi::c_void, compressinformationsize: usize) -> super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SetCompressorInformation(compressorhandle: COMPRESSOR_HANDLE, compressinformationclass: COMPRESS_INFORMATION_CLASS, compressinformation: *const ::core::ffi::c_void, compressinformationsize: usize) -> super::super::Foundation::BOOL;
}
::core::mem::transmute(SetCompressorInformation(compressorhandle.into_param().abi(), ::core::mem::transmute(compressinformationclass), ::core::mem::transmute(compressinformation), ::core::mem::transmute(compressinformationsize)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SetDecompressorInformation(decompressorhandle: isize, compressinformationclass: COMPRESS_INFORMATION_CLASS, compressinformation: *const ::core::ffi::c_void, compressinformationsize: usize) -> super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SetDecompressorInformation(decompressorhandle: isize, compressinformationclass: COMPRESS_INFORMATION_CLASS, compressinformation: *const ::core::ffi::c_void, compressinformationsize: usize) -> super::super::Foundation::BOOL;
}
::core::mem::transmute(SetDecompressorInformation(::core::mem::transmute(decompressorhandle), ::core::mem::transmute(compressinformationclass), ::core::mem::transmute(compressinformation), ::core::mem::transmute(compressinformationsize)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
|
#[macro_use]
extern crate clap;
extern crate error_chain;
extern crate futures;
extern crate tokio_core;
extern crate tokio_modbus;
extern crate tokio_serial;
extern crate tokio_timer;
extern crate plus485;
use std::{fs, process, io, thread};
use std::cell::RefCell;
use std::collections::BTreeMap;
use std::str::FromStr;
use std::time::Duration;
use error_chain::ChainedError;
use futures::{Stream, Future};
use futures::future::Loop;
use tokio_timer::Timeout;
use tokio_serial::{Serial, SerialPortSettings};
use tokio_modbus::ModbusClient;
use plus485::errors::*;
use plus485::data::{QualifiedRegister, Register, OutputFormat, Line};
const DOCUMENTATION: &'static str = r#"ABOUT LINE NUMBERS:
Once set using the command line parameter `-l`, `--line`, line numbers
persist to the arguments specified after the parameter itself, until
`-l none` is encountered. Here are some examples:
plus485 -l 1 --voltage -l 2,3 --current -R -l none --power ...
Reads `voltage` from line 1, `current` from line 1, 2 and 3.
`reactive-energy` has no line-specific equivalent, and as such it is
only read one time. Finally, `power` is also read from the
non-line-specific register.
plus485 -l 1 -V -l none -I -l 1,2,3 -PER ...
Reads `voltage` from line 1, `current` from the non-line-specific
register, `power` from line 1, 2, 3 and finally `energy` and
`reactive-energy` have no line-specific equivalent, and as such are
only read one time.
"#;
fn main() {
let args = clap_app!(plus485 =>
(@setting DeriveDisplayOrder)
(version: crate_version!())
(about: "Query information through modbus from Electrex PLUS-485 meters")
(author: "Roberto Frenna [https://roberto.frenna.pro]")
(after_help: DOCUMENTATION)
(@arg address: -a --address +takes_value default_value("1") {
// Ensures that the argument is an u8.
|s: String| s.parse::<u8>()
.map (|_| ())
.map_err (|_| "must be numeric, >= 0 and <= 255".to_string())
} "Address of the meter (must be numeric)")
(@arg serial_port: * {
// Ensures that the argument is a valid serial device.
|s: String| {
#[cfg(windows)]
let is_win32_port = s.starts_with ("COM");
#[cfg(not(windows))]
let is_win32_port = false;
if is_win32_port {
Ok(())
} else {
fs::metadata (s)
.map (|_| ())
.map_err (|_| "must be a serial device".to_string())
}
}
} "Serial port/device")
(@group format =>
(@arg compact: -c --compact
"Outputs data in the compact format (space-delimited, same order as arguments)")
(@arg metern: --metern alias[iec]
"Outputs data in IEC 62056 (metern-compatible) format (--iec)")
)
(@arg line: -l --line +takes_value +multiple +require_delimiter value_delimiter(",")
possible_value("1") possible_value("2") possible_value("3") possible_value("none")
"Line number.\nCan be specified multiple times (multiple values can be delimited \
with commas), propagates to values specified after it until 'none' is encountered")
(@group readings =>
(@attributes +multiple +required)
(@arg voltage: -V --voltage "Returns line voltage in volts (V)")
(@arg current: -I --current "Returns current in amperes (A)")
(@arg power: -P --power "Returns instantaneous power in watts (W)")
(@arg power_factor: --("power-factor") "Returns the power factor")
(@arg energy: -E --energy "Returns energy in watt-hours (Wh)")
(@arg reactive_energy: -R --("reactive-energy") "Returns reactive energy (varh)")
)
).get_matches();
// This will be the final list of registers to read.
let mut to_fetch = Vec::<QualifiedRegister>::new();
// Lines can be specified multiple times in-between reading flags. For example:
// plus485 -l 1 -V -l none -I -l 1,2,3 -PER /dev/ttyUSB0
// This means:
// - fetch the voltage from line 1
// - fetch the current from no particular line
// - fetch power, energy and reactive energy from all of the three lines.
// This tree map is only defined when we actually got line parameters, and maps the indices
// of the found `line` parameters to the specified argument.
// We're using a tree map because we need to be able to determine indices in a specific range,
// the one between the last "none" line and the index of a register (as passed by the user).
// E.g. (1, "one"), (2, "two"), ...
let line_map: Option<BTreeMap<usize, &str>> = args
.indices_of ("line")
// Zip indices with argument values. We can safely `unwrap()` values_of if we know that
// `indices_of` is not empty.
.map (|indices| indices.zip (args.values_of ("line").unwrap()).collect());
// This vector uses the same principle of `line_map`. It contains mappings (tuples) composed
// of register argument indexes and register names (as passed by the user).
// It is a vector because we do not need to index by key.
let mut register_map: Vec<(usize, &str)> =
["voltage", "current", "power", "power_factor", "energy", "reactive_energy"]
.into_iter()
// Filter out non-requested registers from this list and create the mappings, as specified
// before.
.filter_map (|reg_name| args.index_of (reg_name).map (|index| (index, *reg_name)))
.collect();
// Here comes the trick: sort the entire vector by the argument index. This ensures that
// `to_fetch` will be populated in order, as we want results to follow the order of the passed
// arguments.
register_map.sort_unstable_by (|a, b| a.0.cmp (&b.0));
// This holds the index of the last line argument which was "none". Consider the following
// arguments:
// -l 1 --voltage -l 2,3 --current -l none --power
// The first line argument specifies that we're interested in reading L1. The next argument
// specifies that we want to read the voltage from L1.
// Then, L2 and L3 are also specified, along with the `current` argument, which means that
// we want to read the current from all of the three lines.
// The next argument tells that we're discarding the previous `line` values, and that we want
// to read the generic (averaged) power value. This is why this variable is needed - we store
// the last time we found a `none` value to avoid re-using previous `line` values which are not
// valid anymore.
let mut last_none_index = 0;
for (register_index, register_name) in register_map {
let register = Register::from_str (register_name)
.expect ("register from register_name not OK");
// If this register does not allow line variations, just use Line::None.
if !register.has_line_variant() {
to_fetch.push (QualifiedRegister (register, Line::None));
} else if let Some(line_map) = line_map.as_ref() {
// Keep a temporary vec of QualifiedRegisters to allow clearing them if we find
// that `-l none` was specified.
let mut requested_registers = Vec::<QualifiedRegister>::new();
// Iterate from `-l` arguments specified between `last_none_index` and the index of
// this register argument.
for (line_index, line) in line_map.range (last_none_index..register_index) {
// &str -> Option<u8> -> Line
let line: Line = line.parse::<u8>().ok().into();
// If we got `-l none`, clear `requested_registers` and update `last_none_index`.
if let Line::None = line {
requested_registers.clear();
last_none_index = *line_index + 1;
}
// We're done - push QualifiedRegister to `requested_registers`.
requested_registers.push (QualifiedRegister (register, line))
}
// Merge `requested_registers` and `to_fetch`.
to_fetch.append (&mut requested_registers);
} else {
// Easy peasy if we don't have any `-l` argument.
to_fetch.push (QualifiedRegister (register, Line::None));
}
}
// We're done parsing arguments.
read_from_meter (&args, to_fetch);
}
fn read_from_meter(
args: &clap::ArgMatches,
mut to_fetch: Vec<QualifiedRegister>
) {
// Serial communication is unstable and sometimes dies/timeouts with no reasons.
// As such, there are two retry mechanisms implemented:
// - a basic timeout-then-retry implemented in read_from_meter_impl (up to 2 tries)
// - a mechanism which actually closes and reopens the serial interface after 100ms and
// tries to read the data again (up to 3 tries), implemented here.
let mut try_count = 1_u8;
// This RefCell keeps track of the already processed items - it allows to remove them from
// `to_fetch` before retrying.
let processed_items = RefCell::new (0);
let output_format = OutputFormat::from_args (&args);
// Keep calling `read_from_meter_impl` until we do not receive an error.
while let Err(error) = read_from_meter_impl (
&args, &to_fetch[..], &processed_items, &output_format
) {
match error {
// Catch timeout errors and - if we're within our limits - retry by establishing a
// brand new modbus instance.
Error(ErrorKind::Io(ref error), _)
if error.kind() == io::ErrorKind::TimedOut && try_count <= 3 =>
{
// Remove already processed items from `to_fetch`
to_fetch.drain (0..*processed_items.borrow());
*processed_items.borrow_mut() = 0;
try_count += 1;
// Give enough time to let the serial interface recover.
thread::sleep (Duration::from_millis (100));
},
// TODO: we may want to catch and retry on "broken pipe" errors too. They seem to
// happen quite frequently.
Error(ErrorKind::Io(_), _) => {
output_format.ensure_newline();
eprintln!("{}",
error.chain_err (|| "can't retrieve data from modbus").display_chain());
process::exit (1);
},
_ => {
output_format.ensure_newline();
eprintln!("{}", error.display_chain());
process::exit (1);
}
}
}
output_format.ensure_newline();
}
fn read_from_meter_impl(
args: &clap::ArgMatches,
to_fetch: &[QualifiedRegister],
processed_items: &RefCell<usize>,
output_format: &OutputFormat
) -> Result<()> {
// Configure the serial port we're going to use.
let settings = SerialPortSettings {
baud_rate: tokio_serial::BaudRate::Baud4800,
stop_bits: tokio_serial::StopBits::Two,
..Default::default()
};
// Create a tokio reactor.
let mut core = tokio_core::reactor::Core::new().chain_err (|| "can't create tokio reactor")?;
let handle = core.handle();
#[allow(unused_mut)] // for win32
let mut port = Serial::from_path_with_handle (
args.value_of ("serial_port").unwrap(), // this is safe - it's a mandatory argument
&settings,
&handle.new_tokio_handle()
).chain_err (|| "unable to open requested serial port")?;
#[cfg(unix)]
port.set_exclusive (false).chain_err (|| "unable to set port exclusivity")?;
let mut client: Option<tokio_modbus::Client> = None;
// Create the future.
let task = tokio_modbus::Client::connect_rtu (
port,
args.value_of ("address").unwrap().parse().unwrap(), // safe
&handle
).and_then (|local_client| {
// The following is an unfortunate, required hack due to the various nesting closures used
// to handle retries and so on:
// - directly using `client` is not possible as it would either cause a move on an FnMut
// closure (which is forbidden), or a borrow with an insufficient lifetime
// - using a RefCell would only be useful outside of this closure's scope, but we can't do
// it as the client is only defined at this step.
// Option<T> - initially None - allows us to define it here and then use client.as_ref()
// to obtain a valid borrow (without any kind of moving) inside the nested closures.
client = Some(local_client);
// We "convert" `to_fetch` to a stream of Future<Item = (), Error = io::Error> values.
// `for_each` executes each promises and most importantly only executes the next one when
// the previous is completed. Concurrent access does not work.
futures::stream::iter_ok::<_, io::Error>(to_fetch).for_each (|register| {
// To handle retries, loop until either we succeed or we reach the maximum number of
// tries. We pass `register` as an argument to avoid the moving issues yet again.
futures::future::loop_fn ((register, 1), |(register, tries)| {
// Try to read the requested register (and quantity) with a maximum timeout of
// 200ms.
Timeout::new (
client.as_ref().unwrap().read_input_registers (
register.number() as u16,
register.quantity() as u16
),
Duration::from_millis (200)
)
// Since this must return an io::Error, convert errors returned by tokio_timer
// to an appopriate type.
.map_err (|e|
if e.is_elapsed() {
io::ErrorKind::TimedOut.into()
} else if e.is_inner() {
e.into_inner().unwrap()
} else {
io::Error::new (io::ErrorKind::Other, e)
}
)
.then (move |val| {
match val {
// If we timed out and we are allowed to, return Loop::Continue and retry.
Err(ref error) if error.kind() == io::ErrorKind::TimedOut => {
if tries >= 2 {
// Otherwise, just propagate the `timed out` error.
Err(io::ErrorKind::TimedOut.into())
} else {
Ok(Loop::Continue((register, tries + 1)))
}
},
Err(error) => Err(error),
Ok(ref result) => {
// If we succeeded, display the read data using the requested
// `output_format` and stop the loop.
output_format.display (register.decode_value (result), register);
Ok(Loop::Break(()))
}
}
})
}).and_then (|_| {
// If and only if we successfully retrieved a value, increase the total number
// of processed items.
*processed_items.borrow_mut() += 1;
Ok(())
})
})
});
// Run the task.
core.run (task)?;
Ok(())
}
|
// Copied from the Tokio project
// Url: https://github.com/tokio-rs/tokio/blob/b42f21ec3e212ace25331d0c13889a45769e6006/tokio/src/runtime/park.rs
// Under the MIT License.
//
// See: https://github.com/tokio-rs/tokio/blob/master/LICENSE
use crate::loom::sync::atomic::{AtomicUsize, Ordering};
use crate::loom::sync::{Condvar, Mutex};
use crate::loom::thread;
const EMPTY: usize = 0;
const PARKED_CONDVAR: usize = 1;
const NOTIFIED: usize = 2;
#[repr(transparent)]
struct State(AtomicUsize);
impl State {
#[inline]
fn compare_exchange(&self, current: usize, new: usize) -> Result<usize, usize> {
self.0
.compare_exchange(current, new, Ordering::SeqCst, Ordering::SeqCst)
}
#[inline]
fn swap(&self, val: usize) -> usize {
self.0.swap(val, Ordering::SeqCst)
}
}
struct Inner {
/// Avoids entering the park if possible.
state: State,
/// Used to coordinate access to the condvar.
mutex: Mutex<()>,
/// Condvar to block on.
condvar: Condvar,
}
pub struct Parker {
inner: Inner,
}
impl Parker {
/// Construct a new parker.
pub(crate) fn new() -> Self {
Self {
inner: Inner {
state: State(AtomicUsize::new(EMPTY)),
mutex: Mutex::new(()),
condvar: Condvar::new(),
},
}
}
pub(crate) fn park(&self) {
self.inner.park()
}
pub(crate) fn unpark(&self) {
self.inner.unpark()
}
}
impl Inner {
/// Parks the current thread.
fn park(&self) {
for _ in 0..3 {
// If we were previously notified then we consume this notification and
// return quickly.
if self.state.compare_exchange(NOTIFIED, EMPTY).is_ok() {
return;
}
thread::yield_now();
}
self.park_condvar();
}
fn park_condvar(&self) {
// Otherwise we need to coordinate going to sleep
let mut m = self.mutex.lock().unwrap();
match self.state.compare_exchange(EMPTY, PARKED_CONDVAR) {
Ok(_) => {}
Err(NOTIFIED) => {
// We must read here, even though we know it will be `NOTIFIED`.
// This is because `unpark` may have been called again since we read
// `NOTIFIED` in the `compare_exchange` above. We must perform an
// acquire operation that synchronizes with that `unpark` to observe
// any writes it made before the call to unpark. To do that we must
// read from the write it made to `state`.
let old = self.state.swap(EMPTY);
debug_assert_eq!(old, NOTIFIED, "park state changed unexpectedly");
return;
}
Err(actual) => panic!("inconsistent park state; actual = {}", actual),
}
loop {
m = self.condvar.wait(m).unwrap();
if self.state.compare_exchange(NOTIFIED, EMPTY).is_ok() {
// got a notification
return;
}
// spurious wakeup, go back to sleep
}
}
fn unpark(&self) {
// To ensure the unparked thread will observe any writes we made before
// this call, we must perform a release operation that `park` can
// synchronize with. To do that we must write `NOTIFIED` even if `state`
// is already `NOTIFIED`. That is why this must be a swap rather than a
// compare-and-swap that returns if it reads `NOTIFIED` on failure.
match self.state.swap(NOTIFIED) {
EMPTY => {} // no one was waiting
NOTIFIED => {} // already unparked
PARKED_CONDVAR => self.unpark_condvar(),
actual => panic!("inconsistent state in unpark; actual = {}", actual),
}
}
fn unpark_condvar(&self) {
// There is a period between when the parked thread sets `state` to
// `PARKED` (or last checked `state` in the case of a spurious wake
// up) and when it actually waits on `cvar`. If we were to notify
// during this period it would be ignored and then when the parked
// thread went to sleep it would never wake up. Fortunately, it has
// `lock` locked at this stage so we can acquire `lock` to wait until
// it is ready to receive the notification.
//
// Releasing `lock` before the call to `notify_one` means that when the
// parked thread wakes it doesn't get woken only to have to wait for us
// to release `lock`.
drop(self.mutex.lock());
self.condvar.notify_one()
}
}
|
//! Utilities for handling layout operations via dbus.
//!
//! Contains mostly basic parsing methods that return `DBusResult`.
use uuid::Uuid;
use dbus::tree::MethodErr;
use super::{DBusResult};
use layout::{Direction, Layout, TreeGuard, lock_tree};
use rustwlc::{ResizeEdge, RESIZE_TOP, RESIZE_BOTTOM,
RESIZE_LEFT, RESIZE_RIGHT};
pub fn lock_tree_dbus() -> DBusResult<TreeGuard> {
match lock_tree() {
Ok(tree) => Ok(tree),
Err(err) => Err(MethodErr::failed(&format!("{:?}", err)))
}
}
/// Parses a uuid from a string, returning `MethodErr::invalid_arg`
/// if the uuid is invalid.
pub fn parse_uuid(arg: &'static str, text: &str) -> DBusResult<Option<Uuid>> {
if text == "" {
Ok(None)
} else {
match Uuid::parse_str(text) {
Ok(uuid) => Ok(Some(uuid)),
Err(reason) => Err(MethodErr::invalid_arg(
&format!("{}: {} is not a valid UUID: {:?}", arg, text, reason)))
}
}
}
/// Parses a `Direction` from a string, returning `MethodErr::invalid_arg`
/// if the string is invalid.
pub fn parse_direction(arg: &'static str, text: &str) -> DBusResult<Direction> {
match text.to_lowercase().as_str() {
"up" => Ok(Direction::Up),
"down" => Ok(Direction::Down),
"left" => Ok(Direction::Left),
"right" => Ok(Direction::Right),
_ => Err(MethodErr::invalid_arg(
&format!("{}: {} is not a valid direction. \
May be one of 'up', 'down', 'left', 'right'.", arg, text)))
}
}
pub fn parse_axis(arg: &'static str, text: &str) -> DBusResult<Layout> {
match text.to_lowercase().as_str() {
"vertical" => Ok(Layout::Vertical),
"horizontal" => Ok(Layout::Horizontal),
"tabbed" => Ok(Layout::Tabbed),
"stacked" => Ok(Layout::Stacked),
_ => Err(MethodErr::invalid_arg(
&format!("{}: {} is not a valid axis direction. \
May be either 'horizontal' or 'vertical'", arg, text)))
}
}
pub fn parse_edge(dir: &str) -> DBusResult<ResizeEdge> {
let result = Ok(match dir.to_lowercase().as_str() {
"up" => RESIZE_TOP,
"down" => RESIZE_BOTTOM,
"left" => RESIZE_LEFT,
"right" => RESIZE_RIGHT,
_ => return Err(MethodErr::invalid_arg(
&format!("{} is not a valid direction. \
May be one of 'up', 'down', 'left', 'right'.", dir)))
});
result
}
|
use crate::ast::{BinaryOperator, Expression, Program, Statement, UnaryOperator};
use crate::lexer::Lexer;
use crate::token::Token;
use crate::utils::{ParseError, Type};
type ParseResult<T> = Result<T, ParseError>;
pub struct Parser {
lexer: Lexer,
current_token: Token,
peek_token: Token,
errors: Vec<ParseError>,
}
impl Parser {
pub fn new(lexer: Lexer) -> Self {
let mut parser = Parser {
lexer,
current_token: Token::EOF,
peek_token: Token::EOF,
errors: Vec::new(),
};
parser.next_token();
parser.next_token();
parser
}
pub fn get_errors(&self) -> &[ParseError] {
&self.errors
}
pub fn parse_program(&mut self) -> Program {
let mut statements: Vec<Statement> = Vec::new();
while self.current_token != Token::EOF {
match self.parse_statement() {
Ok(stmt) => {
statements.push(stmt);
}
Err(err) => {
self.errors.push(err);
}
};
self.next_token();
}
Program { statements }
}
fn parse_statement(&mut self) -> ParseResult<Statement> {
match self.get_current_token() {
Token::Identifier(_) => self.parse_assignment(),
Token::Var => self.parse_new_assignment(),
Token::For => self.parse_for(),
Token::Assert => self.parse_assert(),
Token::Print => {
self.next_token();
let exp = self.parse_expression()?;
self.next_token();
self.expect_current_token(Token::SemiColon, ParseError::ExpectedSemiColon)?;
Ok(Statement::Print(exp))
}
Token::Read => {
self.next_token();
let identifier = self.parse_identifier()?;
self.next_token();
self.expect_current_token(Token::SemiColon, ParseError::ExpectedSemiColon)?;
Ok(Statement::Read(identifier))
}
other => Err(ParseError::UnexpectedToken(other)),
}
}
fn parse_for(&mut self) -> ParseResult<Statement> {
self.next_token();
let identifier = self.parse_identifier()?;
self.next_token();
self.expect_and_advance(Token::In, ParseError::ExpectedIn)?;
let exp1 = self.parse_expression()?;
self.next_token();
self.expect_and_advance(Token::Range, ParseError::ExpectedRange)?;
let exp2 = self.parse_expression()?;
self.next_token();
self.expect_and_advance(Token::Do, ParseError::ExpectedDo)?;
let mut stmts: Vec<Box<Statement>> = Vec::new();
while self.current_token != Token::End {
let stmt = self.parse_statement()?;
stmts.push(Box::new(stmt));
self.next_token();
}
self.next_token();
self.expect_and_advance(Token::For, ParseError::ExpectedFor)?;
self.expect_current_token(Token::SemiColon, ParseError::ExpectedSemiColon)?;
Ok(Statement::For(identifier, exp1, exp2, stmts))
}
fn parse_assignment(&mut self) -> ParseResult<Statement> {
let identifier = self.parse_identifier()?;
self.next_token();
self.expect_and_advance(Token::Assign, ParseError::ExpectedAssignment)?;
let exp = self.parse_expression()?;
self.next_token();
self.expect_current_token(Token::SemiColon, ParseError::ExpectedSemiColon)?;
Ok(Statement::Assignment(identifier, exp))
}
fn parse_new_assignment(&mut self) -> ParseResult<Statement> {
self.next_token();
let identifier = self.parse_identifier()?;
self.next_token();
self.expect_and_advance(Token::Colon, ParseError::ExpectedColon)?;
let type_def = match self.get_current_token() {
Token::BooleanType => Type::Boolean,
Token::IntegerType => Type::Integer,
Token::StringType => Type::String,
invalid => return Err(ParseError::ExpectedTypeDefinition(invalid)),
};
self.next_token();
if self.current_token == Token::SemiColon {
return Ok(Statement::VarInitialization(identifier, type_def));
}
self.expect_and_advance(Token::Assign, ParseError::ExpectedAssignment)?;
let exp = self.parse_expression()?;
self.next_token();
self.expect_current_token(Token::SemiColon, ParseError::ExpectedSemiColon)?;
Ok(Statement::NewAssignment(identifier, type_def, exp))
}
fn parse_assert(&mut self) -> ParseResult<Statement> {
self.next_token();
self.expect_and_advance(Token::LeftBracket, ParseError::ExpectedLeftBracket)?;
let exp = self.parse_expression()?;
self.next_token();
self.expect_current_token(Token::RightBracket, ParseError::ExpectedClosingBracket)?;
self.next_token();
self.expect_current_token(Token::SemiColon, ParseError::ExpectedSemiColon)?;
Ok(Statement::Assert(exp))
}
fn parse_expression(&mut self) -> ParseResult<Expression> {
match self.get_current_token() {
Token::Not => self.parse_unary(UnaryOperator::Not),
_ => self.parse_binary(),
}
}
fn parse_binary(&mut self) -> ParseResult<Expression> {
let left = self.parse_operand()?;
if self.is_end_of_exp() {
return Ok(left)
}
self.next_token();
let op = self.parse_op()?;
self.next_token();
let right = self.parse_operand()?;
let exp = Expression::Binary(Box::new(left), op, Box::new(right));
Ok(exp)
}
fn parse_unary(&mut self, op: UnaryOperator) -> ParseResult<Expression> {
self.next_token();
let exp = self.parse_binary()?;
let exp = Expression::Unary(op, Box::new(exp));
Ok(exp)
}
fn parse_operand(&mut self) -> ParseResult<Expression> {
let operand = match self.get_current_token() {
Token::Identifier(id) => Expression::Identifier(id),
Token::IntegerConstant(int) => Expression::IntegerConstant(int.parse::<i32>().unwrap()),
Token::StringValue(string) => Expression::StringValue(string),
Token::True => Expression::Boolean(true),
Token::False => Expression::Boolean(false),
Token::LeftBracket => {
self.next_token();
let exp = self.parse_expression()?;
self.next_token();
self.expect_current_token(Token::RightBracket, ParseError::ExpectedClosingBracket)?;
exp
}
invalid => return Err(ParseError::ExpectedOperand(invalid)),
};
Ok(operand)
}
fn parse_op(&mut self) -> ParseResult<BinaryOperator> {
match self.get_current_token() {
Token::Plus => Ok(BinaryOperator::Plus),
Token::Minus => Ok(BinaryOperator::Minus),
Token::Multiplication => Ok(BinaryOperator::Multiplication),
Token::Division => Ok(BinaryOperator::Division),
Token::Equals => Ok(BinaryOperator::Equals),
Token::LessThan => Ok(BinaryOperator::LessThan),
Token::GreaterThan => Ok(BinaryOperator::GreaterThan),
Token::And => Ok(BinaryOperator::And),
invalid => Err(ParseError::UnexpectedToken(invalid)),
}
}
fn parse_identifier(&mut self) -> ParseResult<String> {
match self.get_current_token() {
Token::Identifier(id) => Ok(id.to_string()),
invalid => Err(ParseError::ExpectedIdentifier(invalid.clone())),
}
}
fn is_end_of_exp(&self) -> bool {
match self.peek_token {
Token::SemiColon => true,
Token::RightBracket => true,
Token::Range => true,
Token::Do => true,
Token::End => true,
_ => false
}
}
fn next_token(&mut self) {
let next = self.peek_token.clone();
self.current_token = next;
self.peek_token = self.lexer.get_next_token();
}
fn get_current_token(&mut self) -> Token {
self.current_token.clone()
}
fn expect_and_advance(
&mut self,
expected: Token,
err: fn(Token) -> ParseError,
) -> ParseResult<()> {
self.expect_current_token(expected, err)?;
self.next_token();
Ok(())
}
fn expect_current_token(
&mut self,
expected: Token,
err: fn(Token) -> ParseError,
) -> ParseResult<()> {
if expected == self.current_token {
Ok(())
} else {
Err(err(self.get_current_token()))
}
}
}
#[cfg(test)]
mod tests {
use crate::ast::{BinaryOperator, Expression, Statement, UnaryOperator};
use crate::lexer::Lexer;
use crate::parser::Parser;
use crate::token::Token;
use crate::utils::{ParseError, Type};
#[test]
fn parse_assignment() -> Result<(), ParseError> {
let source = r#"
var x : int := 1 + 2;
x := x - 1;
var yY_1 : string := "hello";
var Zz2_ : bool;
"#;
let lexer = Lexer::new(source.to_string());
let mut parser = Parser::new(lexer);
let program = parser.parse_program();
let expected = vec![
Statement::NewAssignment(
"x".to_string(),
Type::Integer,
Expression::Binary(
Box::new(Expression::IntegerConstant(1)),
BinaryOperator::Plus,
Box::new(Expression::IntegerConstant(2)),
),
),
Statement::Assignment(
"x".to_string(),
Expression::Binary(
Box::new(Expression::Identifier("x".to_string())),
BinaryOperator::Minus,
Box::new(Expression::IntegerConstant(1)),
),
),
Statement::NewAssignment(
"yY_1".to_string(),
Type::String,
Expression::StringValue("hello".to_string()),
),
Statement::VarInitialization("Zz2_".to_string(), Type::Boolean),
];
assert_eq!(program.statements, expected);
Ok(())
}
#[test]
fn parse_print() -> Result<(), ParseError> {
let source = r#"
print "hello";
print (1 + 2);
print !true;
print 1 + (2 / (3 * 2));
print 1 = 1;
"#;
let lexer = Lexer::new(source.to_string());
let mut parser = Parser::new(lexer);
let program = parser.parse_program();
let expected = vec![
Statement::Print(Expression::StringValue("hello".to_string())),
Statement::Print(Expression::Binary(
Box::new(Expression::IntegerConstant(1)),
BinaryOperator::Plus,
Box::new(Expression::IntegerConstant(2)),
)),
Statement::Print(Expression::Unary(
UnaryOperator::Not,
Box::new(Expression::Boolean(true)),
)),
Statement::Print(Expression::Binary(
Box::new(Expression::IntegerConstant(1)),
BinaryOperator::Plus,
Box::new(Expression::Binary(
Box::new(Expression::IntegerConstant(2)),
BinaryOperator::Division,
Box::new(Expression::Binary(
Box::new(Expression::IntegerConstant(3)),
BinaryOperator::Multiplication,
Box::new(Expression::IntegerConstant(2)),
)),
)),
)),
Statement::Print(Expression::Binary(
Box::new(Expression::IntegerConstant(1)),
BinaryOperator::Equals,
Box::new(Expression::IntegerConstant(1)),
)),
];
assert_eq!(program.statements, expected);
Ok(())
}
#[test]
fn parse_for() -> Result<(), ParseError> {
let source = r#"
for x in 1..5 do
print x;
print "hello";
end for;
"#;
let lexer = Lexer::new(source.to_string());
let mut parser = Parser::new(lexer);
let program = parser.parse_program();
let expected = vec![Statement::For(
"x".to_string(),
Expression::IntegerConstant(1),
Expression::IntegerConstant(5),
vec![
Box::new(Statement::Print(Expression::Identifier("x".to_string()))),
Box::new(Statement::Print(Expression::StringValue(
"hello".to_string(),
))),
],
)];
println!("{}", expected[0]);
assert_eq!(program.statements, expected);
Ok(())
}
#[test]
fn report_error() {
let source = "print 1);";
let lexer = Lexer::new(source.to_string());
let mut parser = Parser::new(lexer);
parser.parse_program();
let errors = parser.get_errors();
assert_eq!(
true,
errors.contains(&ParseError::ExpectedSemiColon(Token::RightBracket))
);
}
}
|
use procon_reader::ProconReader;
fn main() {
let stdin = std::io::stdin();
let mut rd = ProconReader::new(stdin.lock());
let n: usize = rd.get();
let a: Vec<i32> = rd.get_vec(n * 2 - 1);
let lt = a.iter().filter(|&&x| x != -1 && x < a[0]).count();
let gt = a.iter().filter(|&&x| x != -1 && x > a[0]).count();
let eq = a.iter().filter(|&&x| x != -1 && x == a[0]).count();
let free = a.iter().filter(|&&x| x == -1).count();
let (lt, gt) = if lt >= gt { (lt, gt) } else { (gt, lt) };
if lt - gt > eq + free {
println!("No");
} else {
println!("Yes");
}
}
|
// Copyright 2021 Datafuse Labs.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use std::any::Any;
use std::sync::Arc;
use common_catalog::catalog_kind::CATALOG_DEFAULT;
use common_catalog::plan::DataSourcePlan;
use common_catalog::plan::PartStatistics;
use common_catalog::plan::Partitions;
use common_catalog::plan::PushDownInfo;
use common_exception::Result;
use common_expression::DataBlock;
use common_meta_app::schema::TableIdent;
use common_meta_app::schema::TableInfo;
use common_meta_app::schema::TableMeta;
use common_pipeline_core::processors::processor::ProcessorPtr;
use common_pipeline_sources::AsyncSource;
use common_pipeline_sources::AsyncSourcer;
use super::fuse_snapshot::FuseSnapshot;
use super::table_args::parse_func_history_args;
use crate::pipelines::processors::port::OutputPort;
use crate::pipelines::Pipeline;
use crate::sessions::TableContext;
use crate::table_functions::string_literal;
use crate::table_functions::TableArgs;
use crate::table_functions::TableFunction;
use crate::FuseTable;
use crate::Table;
const FUSE_FUNC_SNAPSHOT: &str = "fuse_snapshot";
pub struct FuseSnapshotTable {
table_info: TableInfo,
arg_database_name: String,
arg_table_name: String,
}
impl FuseSnapshotTable {
pub fn create(
database_name: &str,
table_func_name: &str,
table_id: u64,
table_args: TableArgs,
) -> Result<Arc<dyn TableFunction>> {
let (arg_database_name, arg_table_name) = parse_func_history_args(&table_args)?;
let engine = FUSE_FUNC_SNAPSHOT.to_owned();
let table_info = TableInfo {
ident: TableIdent::new(table_id, 0),
desc: format!("'{}'.'{}'", database_name, table_func_name),
name: table_func_name.to_string(),
meta: TableMeta {
schema: FuseSnapshot::schema(),
engine,
..Default::default()
},
..Default::default()
};
Ok(Arc::new(FuseSnapshotTable {
table_info,
arg_database_name,
arg_table_name,
}))
}
}
#[async_trait::async_trait]
impl Table for FuseSnapshotTable {
fn as_any(&self) -> &dyn Any {
self
}
fn get_table_info(&self) -> &TableInfo {
&self.table_info
}
async fn read_partitions(
&self,
_ctx: Arc<dyn TableContext>,
_push_downs: Option<PushDownInfo>,
) -> Result<(PartStatistics, Partitions)> {
Ok((PartStatistics::default(), Partitions::default()))
}
fn table_args(&self) -> Option<TableArgs> {
Some(TableArgs::new_positioned(vec![
string_literal(self.arg_database_name.as_str()),
string_literal(self.arg_table_name.as_str()),
]))
}
fn read_data(
&self,
ctx: Arc<dyn TableContext>,
plan: &DataSourcePlan,
pipeline: &mut Pipeline,
) -> Result<()> {
pipeline.add_source(
|output| {
FuseSnapshotSource::create(
ctx.clone(),
output,
self.arg_database_name.to_owned(),
self.arg_table_name.to_owned(),
plan.push_downs.as_ref().and_then(|extras| extras.limit),
)
},
1,
)?;
Ok(())
}
}
impl TableFunction for FuseSnapshotTable {
fn function_name(&self) -> &str {
self.name()
}
fn as_table<'a>(self: Arc<Self>) -> Arc<dyn Table + 'a>
where Self: 'a {
self
}
}
struct FuseSnapshotSource {
finish: bool,
ctx: Arc<dyn TableContext>,
arg_database_name: String,
arg_table_name: String,
limit: Option<usize>,
}
impl FuseSnapshotSource {
pub fn create(
ctx: Arc<dyn TableContext>,
output: Arc<OutputPort>,
arg_database_name: String,
arg_table_name: String,
limit: Option<usize>,
) -> Result<ProcessorPtr> {
AsyncSourcer::create(ctx.clone(), output, FuseSnapshotSource {
ctx,
finish: false,
arg_table_name,
arg_database_name,
limit,
})
}
}
#[async_trait::async_trait]
impl AsyncSource for FuseSnapshotSource {
const NAME: &'static str = "fuse_snapshot";
#[async_trait::unboxed_simple]
async fn generate(&mut self) -> Result<Option<DataBlock>> {
if self.finish {
return Ok(None);
}
self.finish = true;
let tenant_id = self.ctx.get_tenant();
let tbl = self
.ctx
.get_catalog(CATALOG_DEFAULT)?
.get_table(
tenant_id.as_str(),
self.arg_database_name.as_str(),
self.arg_table_name.as_str(),
)
.await?;
let tbl = FuseTable::try_from_table(tbl.as_ref())?;
Ok(Some(
FuseSnapshot::new(self.ctx.clone(), tbl)
.get_snapshots(self.limit)
.await?,
))
}
}
|
use std::cmp;
use std::iter;
use crate::span::{FileId, Location};
pub struct FileMap(pub Vec<SourceFile>);
impl FileMap {
pub fn new() -> FileMap {
FileMap(Vec::new())
}
pub fn add_file(&mut self, path: String, contents: String) -> &SourceFile {
let id = FileId(self.0.len());
self.0.push(SourceFile::new(id, path, contents));
self.get_file(id)
}
pub fn get_file(&self, id: FileId) -> &SourceFile {
&self.0[id.0]
}
}
pub struct SourceFile {
pub id: FileId,
pub path: String,
pub contents: String,
pub lines: Lines,
}
impl SourceFile {
pub fn new(id: FileId, path: String, contents: String) -> SourceFile {
let lines = Lines::new(&contents);
SourceFile {
id,
path,
contents,
lines,
}
}
pub fn contents(&self) -> &str {
&self.contents
}
/// Return the starting offset and a string copy of the lines surrounding
/// the span of the start and end offsets. Currently, "surrounding" means
/// including the 2 lines above and below the contents of the span (if they exist)
pub fn surrounding_lines(&self, start: usize, end: usize) -> (usize, String) {
let (start_line, end_line) = self.lines.surrounding_lines(start, end);
let start = self.lines.offset_at_line_number(start_line);
let end = self.lines.offset_at_line_end(end_line);
(start_line, self.contents[start..end].to_string())
}
}
#[derive(Clone, Debug)]
pub struct Lines {
pub line_offsets: Vec<usize>,
pub end: usize,
}
impl Lines {
pub fn new(data: &str) -> Lines {
let input_indices = data
.as_bytes()
.iter()
.enumerate()
.filter(|&(_, b)| *b == b'\n')
.map(|(i, _)| i + 1);
let line_offsets = iter::once(0).chain(input_indices).collect();
Lines {
line_offsets,
end: data.len(),
}
}
/// Return the byte offset of `line_number`
pub fn offset_at_line_number(&self, line_number: usize) -> usize {
assert!(
line_number <= self.max_line_num(),
"tried to access oob line"
);
self.line_offsets[line_number]
}
pub fn offset_at_line_end(&self, line_number: usize) -> usize {
assert!(
line_number <= self.max_line_num(),
"tried to access oob line"
);
self.line_offsets
.get(line_number + 1)
.map(|n| *n)
.unwrap_or(self.end)
}
/// Return the line number that this offset is a part of
pub fn line_number_at_offset(&self, offset: usize) -> usize {
let num_lines = self.line_offsets.len();
(0..num_lines)
.filter(|&i| self.line_offsets[i] > offset)
// the first remaining line will be 1 past the one containing the offset
.map(|i| i - 1)
.next()
.unwrap_or(num_lines - 1)
}
/// Convert an offset into a Location
pub fn location(&self, offset: usize) -> Option<Location> {
if offset <= self.end {
let line_index = self.line_number_at_offset(offset);
self.line_offsets
.get(line_index)
.map(|line_offset| Location {
line: line_index,
col: offset - line_offset,
absolute: offset,
})
} else {
None
}
}
/// Takes in a start and end offset, and returns the line numbers of the
/// lines surrounding the span of those two offsets. Currently, "surrounding"
/// means including two lines above and below it (if they exist)
pub fn surrounding_lines(&self, start: usize, end: usize) -> (usize, usize) {
(
self.line_number_at_offset(start).saturating_sub(2),
cmp::min(self.line_number_at_offset(end) + 2, self.max_line_num()),
)
}
pub fn max_line_num(&self) -> usize {
self.line_offsets.len() - 1
}
}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn test_to_lines() {
let lines = Lines::new("0123\n56\n89abc\nef");
assert_eq!(lines.line_offsets, vec![0, 5, 8, 14]);
assert_eq!(lines.end, 16);
}
#[test]
fn surrounding_lines() {
// 0 6 13 19 26 32
let lines = Lines::new("first\nsecond\nthird\nfourth\nfifth\nsixth");
assert_eq!(lines.line_offsets, vec![0, 6, 13, 19, 26, 32]);
assert_eq!(lines.line_number_at_offset(0), 0);
assert_eq!(lines.line_number_at_offset(2), 0);
assert_eq!(lines.surrounding_lines(0, 2), (0, 2));
assert_eq!(lines.line_number_at_offset(32), 5);
assert_eq!(lines.line_number_at_offset(34), 5);
assert_eq!(lines.surrounding_lines(32, 34), (3, 5));
assert_eq!(lines.surrounding_lines(0, 15), (0, 4));
assert_eq!(lines.surrounding_lines(13, 14), (0, 4));
assert_eq!(lines.surrounding_lines(13, 20), (0, 5));
assert_eq!(lines.surrounding_lines(13, 20), (0, 5));
assert_eq!(lines.surrounding_lines(1, 34), (0, 5));
}
#[test]
fn offset_to_line() {
// 0 6 13 19 26 32
let lines = Lines::new("first\nsecond\nthird\nfourth\nfifth\nsixth");
assert_eq!(lines.line_offsets, vec![0, 6, 13, 19, 26, 32]);
assert_eq!(lines.offset_at_line_number(0), 0);
assert_eq!(lines.offset_at_line_end(0), 6);
assert_eq!(lines.offset_at_line_number(2), 13);
assert_eq!(lines.offset_at_line_end(2), 19);
assert_eq!(lines.offset_at_line_number(5), 32);
assert_eq!(lines.offset_at_line_end(5), 37);
}
}
|
extern crate ansi_term;
extern crate crossbeam;
extern crate futures;
extern crate hyper;
extern crate hyper_tls;
extern crate image;
extern crate imageproc;
extern crate native_tls;
extern crate regex;
extern crate serde;
extern crate serde_json;
extern crate tokio_core;
extern crate rusttype;
#[macro_use]
extern crate lazy_static;
#[macro_use]
extern crate serde_derive;
use std::{env, thread};
use std::fs::File;
use std::io::Read;
mod connector;
mod statistics_server;
mod link_tree;
use connector::Connector;
use image::{Rgb, RgbImage};
use imageproc::drawing::draw_line_segment_mut;
use imageproc::drawing::draw_antialiased_line_segment;
use imageproc::drawing::draw_cross_mut;
use imageproc::drawing::draw_cubic_bezier_curve_mut;
use imageproc::drawing::draw_text_mut;
use rusttype::{FontCollection, Scale};
fn test() {
use imageproc::pixelops::interpolate;
let mut img = RgbImage::new(100, 100);
// let red = Rgb([255, 0, 0]);
// let green = Rgb([0, 255, 0]);
// We'll create an 800 pixel wide gradient image.
// let left_weight = |x| x as f32 / 800.0;
// let naive_blend = |x| interpolate(red, green, left_weight(x));
// let mut naive_image = ImageBuffer::new(800, 400);
// for y in 0..naive_image.height() {
// for x in 0..naive_image.width() {
// naive_image.put_pixel(x, y, naive_blend(x));
// }
// }
// naive_image.save("naive_blend.png").unwrap();
// let gamma = 2.2f32;
// let gamma_inv = 1.0 / gamma;
// let gamma_blend_channel = |l, r, w| {
// let l = (l as f32).powf(gamma);
// let r = (r as f32).powf(gamma);
// let s: f32 = l * w + r * (1.0 - w);
// s.powf(gamma_inv) as u8
// };
draw_line_segment_mut(
&mut img,
(5f32, 5f32), // start point
(95f32, 95f32), // end point
Rgb([69u8, 203u8, 133u8]), // RGB colors
);
// let color = image::Luma([2u8]);
draw_antialiased_line_segment(
&mut img,
(5i32, 8i32), // start point
(5i32, 100i32), // end point
Rgb([69u8, 203u8, 133u8]),
interpolate,
);
draw_cross_mut(&mut img, Rgb([69u8, 203u8, 133u8]), 34, 65);
draw_cubic_bezier_curve_mut(
&mut img,
(5f32, 8f32), // start point
(91f32, 100f32), // end point
(55f32, 1f32), // start point
(25f32, 100f32), // end point
Rgb([69u8, 203u8, 133u8]),
);
let height = 12.4;
let scale = Scale {
x: height * 1.0,
y: height,
};
let font = Vec::from(include_bytes!("DejaVuSans.ttf") as &[u8]);
let font = FontCollection::from_bytes(font).into_font().unwrap();
draw_text_mut(
&mut img,
Rgb([69u8, 203u8, 133u8]),
25u32,
55u32,
scale,
&font,
"Hello, world!",
);
img.save("fractal.png").unwrap();
// let width = 800;
// let height = 800;
// let mut imgbuf = image::ImageBuffer::new(width, height);
// let imgx = 800;
// let imgy = 800;
// let max_iterations = 256u16;
// let scalex = 4.0 / imgx as f32;
// let scaley = 4.0 / imgy as f32;
// // Create a new ImgBuf with width: imgx and height: imgy
// let mut imgbuf = image::ImageBuffer::new(imgx, imgy);
// // Iterate over the coordinates and pixels of the image
// // for (x, y, pixel) in imgbuf.enumerate_pixels_mut() {
// // let cy = y as f32 * scaley - 2.0;
// // let cx = x as f32 * scalex - 2.0;
// // let mut z = Complex::new(cx, cy);
// // let c = Complex::new(-0.4, 0.6);
// // let mut i = 0;
// // for t in 0..max_iterations {
// // if z.norm() > 3.0 {
// // break
// // }
// // z = z * z + c;
// // i = t;
// // }
// // // Create an 8bit pixel of type Luma and value i
// // // and assign in to the pixel at position (x, y)
// // *pixel = image::Luma([i as u8]);
// // }
// // Save the image as “fractal.png”
// let ref mut fout = File::create("fractal.png").unwrap();
// // We must indicate the image's color type and what format to save as
// image::ImageLuma8(imgbuf).save(fout, image::PNG).unwrap();
}
fn main() {
// test();
let mut raw_address: Option<String> = None;
let mut file_extensions: Vec<String> = vec![];
let mut depth: u32 = 5;
if env::args().len() > 1 {
let mut arg_iter = env::args().skip(1);
while let Some(x) = arg_iter.next() {
if x.eq("-i") {
file_extensions = get_ignored_file_extensions();
for x in &file_extensions {
println!("Ignoring: {}", x);
}
} else if x.eq("-d") {
match arg_iter.next() {
Some(x) => {
depth = x.parse().unwrap();
depth -= 1;
}
None => println!("-d: No argument specified."),
}
} else {
raw_address = Some(x.to_owned());
}
}
match raw_address {
Some(arg) => {
let address = parse_address(arg);
let thread = thread::spawn(move || {
Connector::new().run(&address, &file_extensions, &depth);
});
let _ = thread.join();
}
_ => println!("Missing argument"),
}
} else {
println!("Usage: bla-bla")
}
}
fn parse_address(raw_address: String) -> String {
if !(raw_address.contains("http://") || raw_address.contains("https://")) {
return format!("https://{}", raw_address);
}
raw_address
}
fn get_ignored_file_extensions() -> Vec<String> {
let filename = "ignored_extensions.txt";
let mut f = File::open(filename).expect("\"ignored_extensions.txt\" file not found.");
let mut contents = String::new();
f.read_to_string(&mut contents)
.expect("Something went wrong reading the file");
contents.split("\r\n").map(|s| s.to_owned()).collect()
}
|
// Copyright 2022 Datafuse Labs.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use std::sync::Arc;
use common_catalog::table_context::TableContext;
use common_exception::Result;
use once_cell::sync::Lazy;
use super::prune_unused_columns::UnusedColumnPruner;
use crate::optimizer::heuristic::decorrelate::decorrelate_subquery;
use crate::optimizer::rule::TransformResult;
use crate::optimizer::ColumnSet;
use crate::optimizer::RuleFactory;
use crate::optimizer::RuleID;
use crate::optimizer::SExpr;
use crate::BindContext;
use crate::MetadataRef;
pub static DEFAULT_REWRITE_RULES: Lazy<Vec<RuleID>> = Lazy::new(|| {
vec![
RuleID::NormalizeDisjunctiveFilter,
RuleID::NormalizeScalarFilter,
RuleID::EliminateFilter,
RuleID::EliminateEvalScalar,
RuleID::MergeFilter,
RuleID::MergeEvalScalar,
RuleID::PushDownFilterUnion,
RuleID::PushDownFilterAggregate,
RuleID::PushDownLimitUnion,
RuleID::RulePushDownLimitExpression,
RuleID::PushDownLimitSort,
RuleID::PushDownLimitAggregate,
RuleID::PushDownLimitOuterJoin,
RuleID::PushDownLimitScan,
RuleID::PushDownFilterSort,
RuleID::PushDownFilterEvalScalar,
RuleID::PushDownFilterJoin,
RuleID::FoldCountAggregate,
RuleID::SplitAggregate,
RuleID::PushDownFilterScan,
RuleID::PushDownPrewhere, /* PushDownPrwhere should be after all rules except PushDownFilterScan */
RuleID::PushDownSortScan, // PushDownFilterScan should be after PushDownPrewhere
]
});
/// A heuristic query optimizer. It will apply specific transformation rules in order and
/// implement the logical plans with default implementation rules.
pub struct HeuristicOptimizer {
_ctx: Arc<dyn TableContext>,
bind_context: Box<BindContext>,
metadata: MetadataRef,
}
impl HeuristicOptimizer {
pub fn new(
ctx: Arc<dyn TableContext>,
bind_context: Box<BindContext>,
metadata: MetadataRef,
) -> Self {
HeuristicOptimizer {
_ctx: ctx,
bind_context,
metadata,
}
}
fn pre_optimize(&mut self, s_expr: SExpr) -> Result<SExpr> {
let mut s_expr = s_expr;
if s_expr.contain_subquery() {
s_expr = decorrelate_subquery(self.metadata.clone(), s_expr)?;
}
// always pruner the unused columns before and after optimization
let pruner = UnusedColumnPruner::new(self.metadata.clone());
let require_columns: ColumnSet = self.bind_context.column_set();
pruner.remove_unused_columns(&s_expr, require_columns)
}
fn post_optimize(&mut self, s_expr: SExpr) -> Result<SExpr> {
let pruner = UnusedColumnPruner::new(self.metadata.clone());
let require_columns: ColumnSet = self.bind_context.column_set();
pruner.remove_unused_columns(&s_expr, require_columns)
}
pub fn optimize(&mut self, s_expr: SExpr) -> Result<SExpr> {
let pre_optimized = self.pre_optimize(s_expr)?;
let optimized = self.optimize_expression(&pre_optimized)?;
let post_optimized = self.post_optimize(optimized)?;
Ok(post_optimized)
}
fn optimize_expression(&self, s_expr: &SExpr) -> Result<SExpr> {
let mut optimized_children = Vec::with_capacity(s_expr.arity());
for expr in s_expr.children() {
optimized_children.push(self.optimize_expression(expr)?);
}
let optimized_expr = s_expr.replace_children(optimized_children);
let result = self.apply_transform_rules(&optimized_expr)?;
Ok(result)
}
/// Try to apply the rules to the expression.
/// Return the final result that no rule can be applied.
fn apply_transform_rules(&self, s_expr: &SExpr) -> Result<SExpr> {
let mut s_expr = s_expr.clone();
for rule_id in DEFAULT_REWRITE_RULES.iter() {
let rule = RuleFactory::create_rule(*rule_id, self.metadata.clone())?;
let mut state = TransformResult::new();
if s_expr.match_pattern(rule.pattern()) && !s_expr.applied_rule(&rule.id()) {
s_expr.set_applied_rule(&rule.id());
rule.apply(&s_expr, &mut state)?;
if !state.results().is_empty() {
// Recursive optimize the result
let result = &state.results()[0];
let optimized_result = self.optimize_expression(result)?;
return Ok(optimized_result);
}
}
}
Ok(s_expr.clone())
}
}
|
#[macro_use]
extern crate serde_derive;
extern crate docopt;
use docopt::Docopt;
extern crate serde_json;
use serde_json::Value;
extern crate tobiuo;
use tobiuo::{parse_dfa, simulate, simulate_nvn, CompressedState};
use std::fs::File;
use std::io::prelude::*;
const VERSION: &str = env!("CARGO_PKG_VERSION");
const USAGE: &str = "
tobiuo - yet another osakana simulator
Usage:
tobiuo 1v1 <player1-file> <player2-file> [--turns=<turns> | --all-turns]
tobiuo nvn <config-file> [--turns=<turns> | --all-turns]
tobiuo (-h | --help)
tobiuo --version
Options:
-h --help Show this.
--version Show version.
--turns=<turns> Number of turns (between 0 and 255) [default: 100].
";
#[derive(Debug, Deserialize)]
struct Args {
flag_turns: u8,
flag_all_turns: bool,
flag_version: bool,
arg_player1_file: String,
arg_player2_file: String,
arg_config_file: String,
cmd_1v1: bool,
cmd_nvn: bool,
}
fn read_file(filename: &str) -> String {
let mut contents = String::new();
File::open(filename)
.unwrap_or_else(|_| panic!("Error opening file {}", filename))
.read_to_string(&mut contents)
.unwrap_or_else(|_| panic!("Error reading file {}", filename));
contents
}
fn load_dfa(filename: &str) -> Vec<CompressedState> {
let contents = read_file(filename);
parse_dfa(&contents).expect(&format!("Error parsing readingfile {}", filename))
}
fn run(player1: &[CompressedState], player2: &[CompressedState], turns: u8) {
println!("{} turns:", turns);
let scores = simulate(player1, player2, turns);
println!("player1 score: {}", scores.0);
println!("player2 score: {}", scores.1);
}
fn parse_nvn_config(filename: &str) -> Vec<(String, Vec<CompressedState>, u16)> {
let contents = read_file(filename);
let v: Value = serde_json::from_str(&contents).expect("Error parsing config file");
let keypairs = match v {
Value::Object(keypairs) => keypairs,
_ => panic!("Config file is malformed"),
};
keypairs
.into_iter()
.map(|(filename, value)| {
let dfa = load_dfa(&filename);
let number = value
.as_u64()
.unwrap_or_else(|| panic!("Invalid number: {:?}", value))
as u16;
if number == 0 {
panic!("There should be at least 1 of each dfa");
}
(filename, dfa, number)
})
.collect()
}
fn run_nvn(states: &Vec<(String, Vec<CompressedState>, u16)>, turns: u8) {
println!("{} turns:", turns);
let scores = simulate_nvn(states, turns);
for i in 0..states.len() {
println!("{} ({}): {}", states[i].0, states[i].2, scores[i]);
}
}
fn main() {
let args: Args = Docopt::new(USAGE)
.and_then(|d| d.deserialize())
.unwrap_or_else(|e| e.exit());
if args.flag_version {
println!("tobiuo {}", VERSION);
} else if args.cmd_1v1 {
let player1 = load_dfa(&args.arg_player1_file);
let player2 = load_dfa(&args.arg_player2_file);
if args.flag_all_turns {
for turns in 95..=105 {
run(&player1, &player2, turns);
println!();
}
} else {
run(&player1, &player2, args.flag_turns);
}
} else if args.cmd_nvn {
let nvn_states = parse_nvn_config(&args.arg_config_file);
if args.flag_all_turns {
for turns in 95..=105 {
run_nvn(&nvn_states, turns);
println!();
}
} else {
run_nvn(&nvn_states, args.flag_turns);
}
} else {
panic!("Huh? This message should never be printed. Please contact author.");
}
// let test_uo = CompleteStr(include_str!("../test.uo"));
// println!("{:?}", dfa(test_uo));
}
|
#[cfg(feature = "Win32_Devices_Enumeration_Pnp")]
pub mod Pnp;
|
struct Todo {
id: i32,
body: String,
}
trait Crud {
fn add(&self, id: i32, body: String);
fn list(&self);
}
struct Todos {
todo: Vec<Todo>,
}
impl Crud for Todos {
fn add(&self, id: i32, body: String) {
self.todo.push(Todo { id: id, body: body });
}
fn list(&self) {
for todo in self.todo {
println!("id: {}, body: {}", todo.id, todo.body);
}
}
}
fn main() {
let todos: Todos = Todos { todo: Vec::new(), };
}
|
use abstutil::elapsed_seconds;
use ezgui::{EventCtx, GfxCtx, Line, ModalMenu, ScreenPt, Slider, Text};
use geom::Duration;
use std::time::Instant;
const ADJUST_SPEED: f64 = 0.1;
// TODO hardcoded cap for now...
const SPEED_CAP: f64 = 10.0 * 60.0;
pub struct SpeedControls {
slider: Slider,
state: State,
}
enum State {
Paused,
Running {
last_step: Instant,
speed_description: String,
last_measurement: Instant,
last_measurement_sim: Duration,
},
}
impl SpeedControls {
pub fn new(ctx: &mut EventCtx, top_left_at: Option<ScreenPt>) -> SpeedControls {
let mut slider = Slider::new(top_left_at);
slider.set_percent(ctx, 1.0 / SPEED_CAP);
SpeedControls {
slider,
state: State::Paused,
}
}
// Returns the amount of simulation time to step, if running.
pub fn event(
&mut self,
ctx: &mut EventCtx,
menu: &mut ModalMenu,
current_sim_time: Duration,
) -> Option<Duration> {
let desired_speed = self.desired_speed();
if desired_speed != SPEED_CAP && menu.action("speed up") {
self.slider
.set_percent(ctx, ((desired_speed + ADJUST_SPEED) / SPEED_CAP).min(1.0));
} else if desired_speed != 0.0 && menu.action("slow down") {
self.slider
.set_percent(ctx, ((desired_speed - ADJUST_SPEED) / SPEED_CAP).max(0.0));
} else if self.slider.event(ctx) {
// Keep going
}
match self.state {
State::Paused => {
if menu.action("pause/resume") {
let now = Instant::now();
self.state = State::Running {
last_step: now,
speed_description: "...".to_string(),
last_measurement: now,
last_measurement_sim: current_sim_time,
};
// Sorta hack to trigger EventLoopMode::Animation.
return Some(Duration::ZERO);
}
}
State::Running {
ref mut last_step,
ref mut speed_description,
ref mut last_measurement,
ref mut last_measurement_sim,
} => {
if menu.action("pause/resume") {
self.state = State::Paused;
} else if ctx.input.nonblocking_is_update_event() {
ctx.input.use_update_event();
let dt = Duration::seconds(elapsed_seconds(*last_step)) * desired_speed;
*last_step = Instant::now();
let dt_descr = Duration::seconds(elapsed_seconds(*last_measurement));
if dt_descr >= Duration::seconds(1.0) {
*speed_description = format!(
"{:.2}x",
(current_sim_time - *last_measurement_sim) / dt_descr
);
*last_measurement = *last_step;
*last_measurement_sim = current_sim_time;
}
return Some(dt);
}
}
}
None
}
pub fn draw(&self, g: &mut GfxCtx) {
let mut txt = Text::new();
if let State::Running {
ref speed_description,
..
} = self.state
{
txt.add(Line(format!(
"Speed: {} / desired {:.2}x",
speed_description,
self.desired_speed()
)));
} else {
txt.add(Line(format!(
"Speed: paused / desired {:.2}x",
self.desired_speed()
)));
}
self.slider.draw(g, Some(txt));
}
pub fn pause(&mut self) {
self.state = State::Paused;
}
pub fn is_paused(&self) -> bool {
match self.state {
State::Paused => true,
State::Running { .. } => false,
}
}
fn desired_speed(&self) -> f64 {
self.slider.get_percent() * SPEED_CAP
}
}
|
#![deny(improper_ctypes)]
use serde_json::Value;
use std::collections::BTreeMap;
use vector_wasm::{hostcall, Registration};
// This is **required**.
use std::convert::TryInto;
pub use vector_wasm::interop::*;
#[no_mangle]
pub extern "C" fn init() {
let _config = hostcall::config().unwrap();
Registration::transform().register().unwrap();
}
#[no_mangle]
pub extern "C" fn process(data: u32, length: u32) -> u32 {
let data = unsafe {
std::ptr::slice_from_raw_parts_mut(data as *mut u8, length.try_into().unwrap())
.as_mut()
.unwrap()
};
let mut event: BTreeMap<String, Value> = serde_json::from_slice(data).unwrap();
event.insert("new_field".into(), "new_value".into());
event.insert("new_field_2".into(), "new_value_2".into());
hostcall::emit(serde_json::to_vec(&event).unwrap()).unwrap();
1
}
#[no_mangle]
pub extern "C" fn shutdown() {}
|
//! Rust wrapper for [HWI](https://github.com/bitcoin-core/HWI/).
//!
//! # Example
//! ```
//! use hwi::{interface, types};
//! use hwi::error::Error;
//! use bitcoin::util::bip32::{ChildNumber, DerivationPath};
//!
//! fn main() -> Result<(), Error> {
//! let devices = interface::HWIDevice::enumerate()?;
//! let device = devices.first().unwrap();
//! let derivation_path = DerivationPath::from(vec![
//! ChildNumber::from_hardened_idx(44).unwrap(),
//! ChildNumber::from_normal_idx(0).unwrap(),
//! ]);
//!
//! let hwi_address = device.display_address_with_path(&derivation_path, types::HWIAddressType::Pkh, true)?;
//! println!("{}", hwi_address.address);
//! Ok(())
//! }
//! ```
#[macro_use]
extern crate strum_macros;
#[cfg(test)]
#[macro_use]
extern crate serial_test;
pub use interface::HWIDevice;
pub mod commands;
pub mod error;
pub mod interface;
pub mod types;
#[cfg(test)]
mod tests {
use crate::interface;
use crate::types;
use bitcoin::util::bip32::{ChildNumber, DerivationPath};
#[test]
#[serial]
fn test_enumerate() {
let devices = interface::HWIDevice::enumerate().unwrap();
assert!(devices.len() > 0);
}
fn get_first_device() -> interface::HWIDevice {
interface::HWIDevice::enumerate()
.unwrap()
.first()
.expect("No devices")
.clone()
}
#[test]
#[serial]
fn test_get_master_xpub() {
let device = get_first_device();
device.get_master_xpub(true).unwrap();
}
#[test]
#[serial]
fn test_get_xpub() {
let device = get_first_device();
let derivation_path = DerivationPath::from(vec![
ChildNumber::from_hardened_idx(44).unwrap(),
ChildNumber::from_normal_idx(0).unwrap(),
]);
device.get_xpub(&derivation_path, true).unwrap();
}
#[test]
#[serial]
fn test_sign_message() {
let device = get_first_device();
let derivation_path = DerivationPath::from(vec![
ChildNumber::from_hardened_idx(44).unwrap(),
ChildNumber::from_normal_idx(0).unwrap(),
]);
device
.sign_message("I love magical bitcoin wallet", &derivation_path, true)
.unwrap();
}
#[test]
#[serial]
fn test_get_descriptors() {
let device = get_first_device();
let account = Some(10);
let descriptor = device.get_descriptors(account, true).unwrap();
assert!(descriptor.internal.len() > 0);
assert!(descriptor.receive.len() > 0);
}
#[test]
#[serial]
fn test_display_address_with_desc() {
let device = get_first_device();
let descriptor = device.get_descriptors(None, true).unwrap();
let descriptor = descriptor.receive.first().unwrap();
// Seems like hwi doesn't support descriptors checksums
let descriptor = &descriptor.split("#").collect::<Vec<_>>()[0].to_string();
let descriptor = &descriptor.replace("*", "1"); // e.g. /0/* -> /0/1
device.display_address_with_desc(&descriptor, true).unwrap();
}
#[test]
#[serial]
fn test_display_address_with_path_pkh() {
let device = get_first_device();
let derivation_path = DerivationPath::from(vec![
ChildNumber::from_hardened_idx(44).unwrap(),
ChildNumber::from_normal_idx(0).unwrap(),
]);
device
.display_address_with_path(&derivation_path, types::HWIAddressType::Pkh, true)
.unwrap();
}
#[test]
#[serial]
fn test_display_address_with_path_shwpkh() {
let device = get_first_device();
let derivation_path = DerivationPath::from(vec![
ChildNumber::from_hardened_idx(44).unwrap(),
ChildNumber::from_normal_idx(0).unwrap(),
]);
device
.display_address_with_path(&derivation_path, types::HWIAddressType::ShWpkh, true)
.unwrap();
}
#[test]
#[serial]
fn test_display_address_with_path_wpkh() {
let device = get_first_device();
let derivation_path = DerivationPath::from(vec![
ChildNumber::from_hardened_idx(44).unwrap(),
ChildNumber::from_normal_idx(0).unwrap(),
]);
device
.display_address_with_path(&derivation_path, types::HWIAddressType::Wpkh, true)
.unwrap();
}
// TODO:
// #[test]
// #[serial]
// fn test_sign_tx() {
// }
#[test]
#[serial]
fn test_get_keypool() {
let device = get_first_device();
let keypool = true;
let internal = false;
let address_type = types::HWIAddressType::Pkh;
let account = Some(8);
let derivation_path = DerivationPath::from(vec![
ChildNumber::from_hardened_idx(44).unwrap(),
ChildNumber::from_normal_idx(0).unwrap(),
]);
let start = 1;
let end = 5;
device
.get_keypool(
keypool,
internal,
address_type,
account,
Some(&derivation_path),
start,
end,
true,
)
.unwrap();
let keypool = true;
let internal = true;
let address_type = types::HWIAddressType::Wpkh;
let account = None;
let start = 1;
let end = 8;
device
.get_keypool(
keypool,
internal,
address_type,
account,
None,
start,
end,
true,
)
.unwrap();
let keypool = false;
let internal = true;
let address_type = types::HWIAddressType::ShWpkh;
let account = Some(1);
let start = 0;
let end = 10;
device
.get_keypool(
keypool,
internal,
address_type,
account,
Some(&derivation_path),
start,
end,
true,
)
.unwrap();
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.