vendor/windows-sys/src/Windows/Media/Core/mod.rs

   1 #[cfg(feature = "Media_Core_Preview")]
   2 pub mod Preview;
   3 #[doc = "*Required features: `\"Media_Core\"`*"]
   4 #[repr(transparent)]
   5 pub struct AudioDecoderDegradation(pub i32);
   6 impl AudioDecoderDegradation {
   7     pub const None: Self = Self(0i32);
   8     pub const DownmixTo2Channels: Self = Self(1i32);
   9     pub const DownmixTo6Channels: Self = Self(2i32);
  10     pub const DownmixTo8Channels: Self = Self(3i32);
  11 }
  12 impl ::core::marker::Copy for AudioDecoderDegradation {}
  13 impl ::core::clone::Clone for AudioDecoderDegradation {
  14     fn clone(&self) -> Self {
  15         *self
  16     }
  17 }
  18 #[doc = "*Required features: `\"Media_Core\"`*"]
  19 #[repr(transparent)]
  20 pub struct AudioDecoderDegradationReason(pub i32);
  21 impl AudioDecoderDegradationReason {
  22     pub const None: Self = Self(0i32);
  23     pub const LicensingRequirement: Self = Self(1i32);
  24     pub const SpatialAudioNotSupported: Self = Self(2i32);
  25 }
  26 impl ::core::marker::Copy for AudioDecoderDegradationReason {}
  27 impl ::core::clone::Clone for AudioDecoderDegradationReason {
  28     fn clone(&self) -> Self {
  29         *self
  30     }
  31 }
  32 pub type AudioStreamDescriptor = *mut ::core::ffi::c_void;
  33 pub type AudioTrack = *mut ::core::ffi::c_void;
  34 pub type AudioTrackOpenFailedEventArgs = *mut ::core::ffi::c_void;
  35 pub type AudioTrackSupportInfo = *mut ::core::ffi::c_void;
  36 pub type ChapterCue = *mut ::core::ffi::c_void;
  37 #[doc = "*Required features: `\"Media_Core\"`*"]
  38 #[repr(transparent)]
  39 pub struct CodecCategory(pub i32);
  40 impl CodecCategory {
  41     pub const Encoder: Self = Self(0i32);
  42     pub const Decoder: Self = Self(1i32);
  43 }
  44 impl ::core::marker::Copy for CodecCategory {}
  45 impl ::core::clone::Clone for CodecCategory {
  46     fn clone(&self) -> Self {
  47         *self
  48     }
  49 }
  50 pub type CodecInfo = *mut ::core::ffi::c_void;
  51 #[doc = "*Required features: `\"Media_Core\"`*"]
  52 #[repr(transparent)]
  53 pub struct CodecKind(pub i32);
  54 impl CodecKind {
  55     pub const Audio: Self = Self(0i32);
  56     pub const Video: Self = Self(1i32);
  57 }
  58 impl ::core::marker::Copy for CodecKind {}
  59 impl ::core::clone::Clone for CodecKind {
  60     fn clone(&self) -> Self {
  61         *self
  62     }
  63 }
  64 pub type CodecQuery = *mut ::core::ffi::c_void;
  65 pub type DataCue = *mut ::core::ffi::c_void;
  66 pub type FaceDetectedEventArgs = *mut ::core::ffi::c_void;
  67 pub type FaceDetectionEffect = *mut ::core::ffi::c_void;
  68 pub type FaceDetectionEffectDefinition = *mut ::core::ffi::c_void;
  69 pub type FaceDetectionEffectFrame = *mut ::core::ffi::c_void;
  70 #[doc = "*Required features: `\"Media_Core\"`*"]
  71 #[repr(transparent)]
  72 pub struct FaceDetectionMode(pub i32);
  73 impl FaceDetectionMode {
  74     pub const HighPerformance: Self = Self(0i32);
  75     pub const Balanced: Self = Self(1i32);
  76     pub const HighQuality: Self = Self(2i32);
  77 }
  78 impl ::core::marker::Copy for FaceDetectionMode {}
  79 impl ::core::clone::Clone for FaceDetectionMode {
  80     fn clone(&self) -> Self {
  81         *self
  82     }
  83 }
  84 pub type HighDynamicRangeControl = *mut ::core::ffi::c_void;
  85 pub type HighDynamicRangeOutput = *mut ::core::ffi::c_void;
  86 pub type IMediaCue = *mut ::core::ffi::c_void;
  87 pub type IMediaSource = *mut ::core::ffi::c_void;
  88 pub type IMediaStreamDescriptor = *mut ::core::ffi::c_void;
  89 pub type IMediaStreamDescriptor2 = *mut ::core::ffi::c_void;
  90 pub type IMediaTrack = *mut ::core::ffi::c_void;
  91 pub type ISingleSelectMediaTrackList = *mut ::core::ffi::c_void;
  92 pub type ITimedMetadataTrackProvider = *mut ::core::ffi::c_void;
  93 pub type ImageCue = *mut ::core::ffi::c_void;
  94 pub type InitializeMediaStreamSourceRequestedEventArgs = *mut ::core::ffi::c_void;
  95 pub type LowLightFusionResult = *mut ::core::ffi::c_void;
  96 pub type MediaBinder = *mut ::core::ffi::c_void;
  97 pub type MediaBindingEventArgs = *mut ::core::ffi::c_void;
  98 pub type MediaCueEventArgs = *mut ::core::ffi::c_void;
  99 #[doc = "*Required features: `\"Media_Core\"`*"]
 100 #[repr(transparent)]
 101 pub struct MediaDecoderStatus(pub i32);
 102 impl MediaDecoderStatus {
 103     pub const FullySupported: Self = Self(0i32);
 104     pub const UnsupportedSubtype: Self = Self(1i32);
 105     pub const UnsupportedEncoderProperties: Self = Self(2i32);
 106     pub const Degraded: Self = Self(3i32);
 107 }
 108 impl ::core::marker::Copy for MediaDecoderStatus {}
 109 impl ::core::clone::Clone for MediaDecoderStatus {
 110     fn clone(&self) -> Self {
 111         *self
 112     }
 113 }
 114 pub type MediaSource = *mut ::core::ffi::c_void;
 115 pub type MediaSourceAppServiceConnection = *mut ::core::ffi::c_void;
 116 pub type MediaSourceError = *mut ::core::ffi::c_void;
 117 pub type MediaSourceOpenOperationCompletedEventArgs = *mut ::core::ffi::c_void;
 118 #[doc = "*Required features: `\"Media_Core\"`*"]
 119 #[repr(transparent)]
 120 pub struct MediaSourceState(pub i32);
 121 impl MediaSourceState {
 122     pub const Initial: Self = Self(0i32);
 123     pub const Opening: Self = Self(1i32);
 124     pub const Opened: Self = Self(2i32);
 125     pub const Failed: Self = Self(3i32);
 126     pub const Closed: Self = Self(4i32);
 127 }
 128 impl ::core::marker::Copy for MediaSourceState {}
 129 impl ::core::clone::Clone for MediaSourceState {
 130     fn clone(&self) -> Self {
 131         *self
 132     }
 133 }
 134 pub type MediaSourceStateChangedEventArgs = *mut ::core::ffi::c_void;
 135 #[doc = "*Required features: `\"Media_Core\"`*"]
 136 #[repr(transparent)]
 137 pub struct MediaSourceStatus(pub i32);
 138 impl MediaSourceStatus {
 139     pub const FullySupported: Self = Self(0i32);
 140     pub const Unknown: Self = Self(1i32);
 141 }
 142 impl ::core::marker::Copy for MediaSourceStatus {}
 143 impl ::core::clone::Clone for MediaSourceStatus {
 144     fn clone(&self) -> Self {
 145         *self
 146     }
 147 }
 148 pub type MediaStreamSample = *mut ::core::ffi::c_void;
 149 pub type MediaStreamSamplePropertySet = *mut ::core::ffi::c_void;
 150 pub type MediaStreamSampleProtectionProperties = *mut ::core::ffi::c_void;
 151 pub type MediaStreamSource = *mut ::core::ffi::c_void;
 152 pub type MediaStreamSourceClosedEventArgs = *mut ::core::ffi::c_void;
 153 #[doc = "*Required features: `\"Media_Core\"`*"]
 154 #[repr(transparent)]
 155 pub struct MediaStreamSourceClosedReason(pub i32);
 156 impl MediaStreamSourceClosedReason {
 157     pub const Done: Self = Self(0i32);
 158     pub const UnknownError: Self = Self(1i32);
 159     pub const AppReportedError: Self = Self(2i32);
 160     pub const UnsupportedProtectionSystem: Self = Self(3i32);
 161     pub const ProtectionSystemFailure: Self = Self(4i32);
 162     pub const UnsupportedEncodingFormat: Self = Self(5i32);
 163     pub const MissingSampleRequestedEventHandler: Self = Self(6i32);
 164 }
 165 impl ::core::marker::Copy for MediaStreamSourceClosedReason {}
 166 impl ::core::clone::Clone for MediaStreamSourceClosedReason {
 167     fn clone(&self) -> Self {
 168         *self
 169     }
 170 }
 171 pub type MediaStreamSourceClosedRequest = *mut ::core::ffi::c_void;
 172 #[doc = "*Required features: `\"Media_Core\"`*"]
 173 #[repr(transparent)]
 174 pub struct MediaStreamSourceErrorStatus(pub i32);
 175 impl MediaStreamSourceErrorStatus {
 176     pub const Other: Self = Self(0i32);
 177     pub const OutOfMemory: Self = Self(1i32);
 178     pub const FailedToOpenFile: Self = Self(2i32);
 179     pub const FailedToConnectToServer: Self = Self(3i32);
 180     pub const ConnectionToServerLost: Self = Self(4i32);
 181     pub const UnspecifiedNetworkError: Self = Self(5i32);
 182     pub const DecodeError: Self = Self(6i32);
 183     pub const UnsupportedMediaFormat: Self = Self(7i32);
 184 }
 185 impl ::core::marker::Copy for MediaStreamSourceErrorStatus {}
 186 impl ::core::clone::Clone for MediaStreamSourceErrorStatus {
 187     fn clone(&self) -> Self {
 188         *self
 189     }
 190 }
 191 pub type MediaStreamSourceSampleRenderedEventArgs = *mut ::core::ffi::c_void;
 192 pub type MediaStreamSourceSampleRequest = *mut ::core::ffi::c_void;
 193 pub type MediaStreamSourceSampleRequestDeferral = *mut ::core::ffi::c_void;
 194 pub type MediaStreamSourceSampleRequestedEventArgs = *mut ::core::ffi::c_void;
 195 pub type MediaStreamSourceStartingEventArgs = *mut ::core::ffi::c_void;
 196 pub type MediaStreamSourceStartingRequest = *mut ::core::ffi::c_void;
 197 pub type MediaStreamSourceStartingRequestDeferral = *mut ::core::ffi::c_void;
 198 pub type MediaStreamSourceSwitchStreamsRequest = *mut ::core::ffi::c_void;
 199 pub type MediaStreamSourceSwitchStreamsRequestDeferral = *mut ::core::ffi::c_void;
 200 pub type MediaStreamSourceSwitchStreamsRequestedEventArgs = *mut ::core::ffi::c_void;
 201 #[doc = "*Required features: `\"Media_Core\"`*"]
 202 #[repr(transparent)]
 203 pub struct MediaTrackKind(pub i32);
 204 impl MediaTrackKind {
 205     pub const Audio: Self = Self(0i32);
 206     pub const Video: Self = Self(1i32);
 207     pub const TimedMetadata: Self = Self(2i32);
 208 }
 209 impl ::core::marker::Copy for MediaTrackKind {}
 210 impl ::core::clone::Clone for MediaTrackKind {
 211     fn clone(&self) -> Self {
 212         *self
 213     }
 214 }
 215 #[doc = "*Required features: `\"Media_Core\"`*"]
 216 #[repr(transparent)]
 217 pub struct MseAppendMode(pub i32);
 218 impl MseAppendMode {
 219     pub const Segments: Self = Self(0i32);
 220     pub const Sequence: Self = Self(1i32);
 221 }
 222 impl ::core::marker::Copy for MseAppendMode {}
 223 impl ::core::clone::Clone for MseAppendMode {
 224     fn clone(&self) -> Self {
 225         *self
 226     }
 227 }
 228 #[doc = "*Required features: `\"Media_Core\"`*"]
 229 #[repr(transparent)]
 230 pub struct MseEndOfStreamStatus(pub i32);
 231 impl MseEndOfStreamStatus {
 232     pub const Success: Self = Self(0i32);
 233     pub const NetworkError: Self = Self(1i32);
 234     pub const DecodeError: Self = Self(2i32);
 235     pub const UnknownError: Self = Self(3i32);
 236 }
 237 impl ::core::marker::Copy for MseEndOfStreamStatus {}
 238 impl ::core::clone::Clone for MseEndOfStreamStatus {
 239     fn clone(&self) -> Self {
 240         *self
 241     }
 242 }
 243 #[doc = "*Required features: `\"Media_Core\"`*"]
 244 #[repr(transparent)]
 245 pub struct MseReadyState(pub i32);
 246 impl MseReadyState {
 247     pub const Closed: Self = Self(0i32);
 248     pub const Open: Self = Self(1i32);
 249     pub const Ended: Self = Self(2i32);
 250 }
 251 impl ::core::marker::Copy for MseReadyState {}
 252 impl ::core::clone::Clone for MseReadyState {
 253     fn clone(&self) -> Self {
 254         *self
 255     }
 256 }
 257 pub type MseSourceBuffer = *mut ::core::ffi::c_void;
 258 pub type MseSourceBufferList = *mut ::core::ffi::c_void;
 259 pub type MseStreamSource = *mut ::core::ffi::c_void;
 260 #[repr(C)]
 261 #[doc = "*Required features: `\"Media_Core\"`, `\"Foundation\"`*"]
 262 #[cfg(feature = "Foundation")]
 263 pub struct MseTimeRange {
 264     pub Start: super::super::Foundation::TimeSpan,
 265     pub End: super::super::Foundation::TimeSpan,
 266 }
 267 #[cfg(feature = "Foundation")]
 268 impl ::core::marker::Copy for MseTimeRange {}
 269 #[cfg(feature = "Foundation")]
 270 impl ::core::clone::Clone for MseTimeRange {
 271     fn clone(&self) -> Self {
 272         *self
 273     }
 274 }
 275 pub type SceneAnalysisEffect = *mut ::core::ffi::c_void;
 276 pub type SceneAnalysisEffectDefinition = *mut ::core::ffi::c_void;
 277 pub type SceneAnalysisEffectFrame = *mut ::core::ffi::c_void;
 278 #[doc = "*Required features: `\"Media_Core\"`*"]
 279 #[repr(transparent)]
 280 pub struct SceneAnalysisRecommendation(pub i32);
 281 impl SceneAnalysisRecommendation {
 282     pub const Standard: Self = Self(0i32);
 283     pub const Hdr: Self = Self(1i32);
 284     pub const LowLight: Self = Self(2i32);
 285 }
 286 impl ::core::marker::Copy for SceneAnalysisRecommendation {}
 287 impl ::core::clone::Clone for SceneAnalysisRecommendation {
 288     fn clone(&self) -> Self {
 289         *self
 290     }
 291 }
 292 pub type SceneAnalyzedEventArgs = *mut ::core::ffi::c_void;
 293 pub type SpeechCue = *mut ::core::ffi::c_void;
 294 #[doc = "*Required features: `\"Media_Core\"`*"]
 295 #[repr(transparent)]
 296 pub struct TimedMetadataKind(pub i32);
 297 impl TimedMetadataKind {
 298     pub const Caption: Self = Self(0i32);
 299     pub const Chapter: Self = Self(1i32);
 300     pub const Custom: Self = Self(2i32);
 301     pub const Data: Self = Self(3i32);
 302     pub const Description: Self = Self(4i32);
 303     pub const Subtitle: Self = Self(5i32);
 304     pub const ImageSubtitle: Self = Self(6i32);
 305     pub const Speech: Self = Self(7i32);
 306 }
 307 impl ::core::marker::Copy for TimedMetadataKind {}
 308 impl ::core::clone::Clone for TimedMetadataKind {
 309     fn clone(&self) -> Self {
 310         *self
 311     }
 312 }
 313 pub type TimedMetadataStreamDescriptor = *mut ::core::ffi::c_void;
 314 pub type TimedMetadataTrack = *mut ::core::ffi::c_void;
 315 pub type TimedMetadataTrackError = *mut ::core::ffi::c_void;
 316 #[doc = "*Required features: `\"Media_Core\"`*"]
 317 #[repr(transparent)]
 318 pub struct TimedMetadataTrackErrorCode(pub i32);
 319 impl TimedMetadataTrackErrorCode {
 320     pub const None: Self = Self(0i32);
 321     pub const DataFormatError: Self = Self(1i32);
 322     pub const NetworkError: Self = Self(2i32);
 323     pub const InternalError: Self = Self(3i32);
 324 }
 325 impl ::core::marker::Copy for TimedMetadataTrackErrorCode {}
 326 impl ::core::clone::Clone for TimedMetadataTrackErrorCode {
 327     fn clone(&self) -> Self {
 328         *self
 329     }
 330 }
 331 pub type TimedMetadataTrackFailedEventArgs = *mut ::core::ffi::c_void;
 332 pub type TimedTextBouten = *mut ::core::ffi::c_void;
 333 #[doc = "*Required features: `\"Media_Core\"`*"]
 334 #[repr(transparent)]
 335 pub struct TimedTextBoutenPosition(pub i32);
 336 impl TimedTextBoutenPosition {
 337     pub const Before: Self = Self(0i32);
 338     pub const After: Self = Self(1i32);
 339     pub const Outside: Self = Self(2i32);
 340 }
 341 impl ::core::marker::Copy for TimedTextBoutenPosition {}
 342 impl ::core::clone::Clone for TimedTextBoutenPosition {
 343     fn clone(&self) -> Self {
 344         *self
 345     }
 346 }
 347 #[doc = "*Required features: `\"Media_Core\"`*"]
 348 #[repr(transparent)]
 349 pub struct TimedTextBoutenType(pub i32);
 350 impl TimedTextBoutenType {
 351     pub const None: Self = Self(0i32);
 352     pub const Auto: Self = Self(1i32);
 353     pub const FilledCircle: Self = Self(2i32);
 354     pub const OpenCircle: Self = Self(3i32);
 355     pub const FilledDot: Self = Self(4i32);
 356     pub const OpenDot: Self = Self(5i32);
 357     pub const FilledSesame: Self = Self(6i32);
 358     pub const OpenSesame: Self = Self(7i32);
 359 }
 360 impl ::core::marker::Copy for TimedTextBoutenType {}
 361 impl ::core::clone::Clone for TimedTextBoutenType {
 362     fn clone(&self) -> Self {
 363         *self
 364     }
 365 }
 366 pub type TimedTextCue = *mut ::core::ffi::c_void;
 367 #[doc = "*Required features: `\"Media_Core\"`*"]
 368 #[repr(transparent)]
 369 pub struct TimedTextDisplayAlignment(pub i32);
 370 impl TimedTextDisplayAlignment {
 371     pub const Before: Self = Self(0i32);
 372     pub const After: Self = Self(1i32);
 373     pub const Center: Self = Self(2i32);
 374 }
 375 impl ::core::marker::Copy for TimedTextDisplayAlignment {}
 376 impl ::core::clone::Clone for TimedTextDisplayAlignment {
 377     fn clone(&self) -> Self {
 378         *self
 379     }
 380 }
 381 #[repr(C)]
 382 #[doc = "*Required features: `\"Media_Core\"`*"]
 383 pub struct TimedTextDouble {
 384     pub Value: f64,
 385     pub Unit: TimedTextUnit,
 386 }
 387 impl ::core::marker::Copy for TimedTextDouble {}
 388 impl ::core::clone::Clone for TimedTextDouble {
 389     fn clone(&self) -> Self {
 390         *self
 391     }
 392 }
 393 #[doc = "*Required features: `\"Media_Core\"`*"]
 394 #[repr(transparent)]
 395 pub struct TimedTextFlowDirection(pub i32);
 396 impl TimedTextFlowDirection {
 397     pub const LeftToRight: Self = Self(0i32);
 398     pub const RightToLeft: Self = Self(1i32);
 399 }
 400 impl ::core::marker::Copy for TimedTextFlowDirection {}
 401 impl ::core::clone::Clone for TimedTextFlowDirection {
 402     fn clone(&self) -> Self {
 403         *self
 404     }
 405 }
 406 #[doc = "*Required features: `\"Media_Core\"`*"]
 407 #[repr(transparent)]
 408 pub struct TimedTextFontStyle(pub i32);
 409 impl TimedTextFontStyle {
 410     pub const Normal: Self = Self(0i32);
 411     pub const Oblique: Self = Self(1i32);
 412     pub const Italic: Self = Self(2i32);
 413 }
 414 impl ::core::marker::Copy for TimedTextFontStyle {}
 415 impl ::core::clone::Clone for TimedTextFontStyle {
 416     fn clone(&self) -> Self {
 417         *self
 418     }
 419 }
 420 pub type TimedTextLine = *mut ::core::ffi::c_void;
 421 #[doc = "*Required features: `\"Media_Core\"`*"]
 422 #[repr(transparent)]
 423 pub struct TimedTextLineAlignment(pub i32);
 424 impl TimedTextLineAlignment {
 425     pub const Start: Self = Self(0i32);
 426     pub const End: Self = Self(1i32);
 427     pub const Center: Self = Self(2i32);
 428 }
 429 impl ::core::marker::Copy for TimedTextLineAlignment {}
 430 impl ::core::clone::Clone for TimedTextLineAlignment {
 431     fn clone(&self) -> Self {
 432         *self
 433     }
 434 }
 435 #[repr(C)]
 436 #[doc = "*Required features: `\"Media_Core\"`*"]
 437 pub struct TimedTextPadding {
 438     pub Before: f64,
 439     pub After: f64,
 440     pub Start: f64,
 441     pub End: f64,
 442     pub Unit: TimedTextUnit,
 443 }
 444 impl ::core::marker::Copy for TimedTextPadding {}
 445 impl ::core::clone::Clone for TimedTextPadding {
 446     fn clone(&self) -> Self {
 447         *self
 448     }
 449 }
 450 #[repr(C)]
 451 #[doc = "*Required features: `\"Media_Core\"`*"]
 452 pub struct TimedTextPoint {
 453     pub X: f64,
 454     pub Y: f64,
 455     pub Unit: TimedTextUnit,
 456 }
 457 impl ::core::marker::Copy for TimedTextPoint {}
 458 impl ::core::clone::Clone for TimedTextPoint {
 459     fn clone(&self) -> Self {
 460         *self
 461     }
 462 }
 463 pub type TimedTextRegion = *mut ::core::ffi::c_void;
 464 pub type TimedTextRuby = *mut ::core::ffi::c_void;
 465 #[doc = "*Required features: `\"Media_Core\"`*"]
 466 #[repr(transparent)]
 467 pub struct TimedTextRubyAlign(pub i32);
 468 impl TimedTextRubyAlign {
 469     pub const Center: Self = Self(0i32);
 470     pub const Start: Self = Self(1i32);
 471     pub const End: Self = Self(2i32);
 472     pub const SpaceAround: Self = Self(3i32);
 473     pub const SpaceBetween: Self = Self(4i32);
 474     pub const WithBase: Self = Self(5i32);
 475 }
 476 impl ::core::marker::Copy for TimedTextRubyAlign {}
 477 impl ::core::clone::Clone for TimedTextRubyAlign {
 478     fn clone(&self) -> Self {
 479         *self
 480     }
 481 }
 482 #[doc = "*Required features: `\"Media_Core\"`*"]
 483 #[repr(transparent)]
 484 pub struct TimedTextRubyPosition(pub i32);
 485 impl TimedTextRubyPosition {
 486     pub const Before: Self = Self(0i32);
 487     pub const After: Self = Self(1i32);
 488     pub const Outside: Self = Self(2i32);
 489 }
 490 impl ::core::marker::Copy for TimedTextRubyPosition {}
 491 impl ::core::clone::Clone for TimedTextRubyPosition {
 492     fn clone(&self) -> Self {
 493         *self
 494     }
 495 }
 496 #[doc = "*Required features: `\"Media_Core\"`*"]
 497 #[repr(transparent)]
 498 pub struct TimedTextRubyReserve(pub i32);
 499 impl TimedTextRubyReserve {
 500     pub const None: Self = Self(0i32);
 501     pub const Before: Self = Self(1i32);
 502     pub const After: Self = Self(2i32);
 503     pub const Both: Self = Self(3i32);
 504     pub const Outside: Self = Self(4i32);
 505 }
 506 impl ::core::marker::Copy for TimedTextRubyReserve {}
 507 impl ::core::clone::Clone for TimedTextRubyReserve {
 508     fn clone(&self) -> Self {
 509         *self
 510     }
 511 }
 512 #[doc = "*Required features: `\"Media_Core\"`*"]
 513 #[repr(transparent)]
 514 pub struct TimedTextScrollMode(pub i32);
 515 impl TimedTextScrollMode {
 516     pub const Popon: Self = Self(0i32);
 517     pub const Rollup: Self = Self(1i32);
 518 }
 519 impl ::core::marker::Copy for TimedTextScrollMode {}
 520 impl ::core::clone::Clone for TimedTextScrollMode {
 521     fn clone(&self) -> Self {
 522         *self
 523     }
 524 }
 525 #[repr(C)]
 526 #[doc = "*Required features: `\"Media_Core\"`*"]
 527 pub struct TimedTextSize {
 528     pub Height: f64,
 529     pub Width: f64,
 530     pub Unit: TimedTextUnit,
 531 }
 532 impl ::core::marker::Copy for TimedTextSize {}
 533 impl ::core::clone::Clone for TimedTextSize {
 534     fn clone(&self) -> Self {
 535         *self
 536     }
 537 }
 538 pub type TimedTextSource = *mut ::core::ffi::c_void;
 539 pub type TimedTextSourceResolveResultEventArgs = *mut ::core::ffi::c_void;
 540 pub type TimedTextStyle = *mut ::core::ffi::c_void;
 541 pub type TimedTextSubformat = *mut ::core::ffi::c_void;
 542 #[doc = "*Required features: `\"Media_Core\"`*"]
 543 #[repr(transparent)]
 544 pub struct TimedTextUnit(pub i32);
 545 impl TimedTextUnit {
 546     pub const Pixels: Self = Self(0i32);
 547     pub const Percentage: Self = Self(1i32);
 548 }
 549 impl ::core::marker::Copy for TimedTextUnit {}
 550 impl ::core::clone::Clone for TimedTextUnit {
 551     fn clone(&self) -> Self {
 552         *self
 553     }
 554 }
 555 #[doc = "*Required features: `\"Media_Core\"`*"]
 556 #[repr(transparent)]
 557 pub struct TimedTextWeight(pub i32);
 558 impl TimedTextWeight {
 559     pub const Normal: Self = Self(400i32);
 560     pub const Bold: Self = Self(700i32);
 561 }
 562 impl ::core::marker::Copy for TimedTextWeight {}
 563 impl ::core::clone::Clone for TimedTextWeight {
 564     fn clone(&self) -> Self {
 565         *self
 566     }
 567 }
 568 #[doc = "*Required features: `\"Media_Core\"`*"]
 569 #[repr(transparent)]
 570 pub struct TimedTextWrapping(pub i32);
 571 impl TimedTextWrapping {
 572     pub const NoWrap: Self = Self(0i32);
 573     pub const Wrap: Self = Self(1i32);
 574 }
 575 impl ::core::marker::Copy for TimedTextWrapping {}
 576 impl ::core::clone::Clone for TimedTextWrapping {
 577     fn clone(&self) -> Self {
 578         *self
 579     }
 580 }
 581 #[doc = "*Required features: `\"Media_Core\"`*"]
 582 #[repr(transparent)]
 583 pub struct TimedTextWritingMode(pub i32);
 584 impl TimedTextWritingMode {
 585     pub const LeftRightTopBottom: Self = Self(0i32);
 586     pub const RightLeftTopBottom: Self = Self(1i32);
 587     pub const TopBottomRightLeft: Self = Self(2i32);
 588     pub const TopBottomLeftRight: Self = Self(3i32);
 589     pub const LeftRight: Self = Self(4i32);
 590     pub const RightLeft: Self = Self(5i32);
 591     pub const TopBottom: Self = Self(6i32);
 592 }
 593 impl ::core::marker::Copy for TimedTextWritingMode {}
 594 impl ::core::clone::Clone for TimedTextWritingMode {
 595     fn clone(&self) -> Self {
 596         *self
 597     }
 598 }
 599 pub type VideoStabilizationEffect = *mut ::core::ffi::c_void;
 600 pub type VideoStabilizationEffectDefinition = *mut ::core::ffi::c_void;
 601 pub type VideoStabilizationEffectEnabledChangedEventArgs = *mut ::core::ffi::c_void;
 602 #[doc = "*Required features: `\"Media_Core\"`*"]
 603 #[repr(transparent)]
 604 pub struct VideoStabilizationEffectEnabledChangedReason(pub i32);
 605 impl VideoStabilizationEffectEnabledChangedReason {
 606     pub const Programmatic: Self = Self(0i32);
 607     pub const PixelRateTooHigh: Self = Self(1i32);
 608     pub const RunningSlowly: Self = Self(2i32);
 609 }
 610 impl ::core::marker::Copy for VideoStabilizationEffectEnabledChangedReason {}
 611 impl ::core::clone::Clone for VideoStabilizationEffectEnabledChangedReason {
 612     fn clone(&self) -> Self {
 613         *self
 614     }
 615 }
 616 pub type VideoStreamDescriptor = *mut ::core::ffi::c_void;
 617 pub type VideoTrack = *mut ::core::ffi::c_void;
 618 pub type VideoTrackOpenFailedEventArgs = *mut ::core::ffi::c_void;
 619 pub type VideoTrackSupportInfo = *mut ::core::ffi::c_void;