vendor/windows-sys-0.28.0/src/Windows/Media/Capture/mod.rs

   1 #![allow(non_snake_case, non_camel_case_types, non_upper_case_globals, clashing_extern_declarations, clippy::all)]
   2 #[cfg(feature = "Media_Capture_Core")]
   3 pub mod Core;
   4 #[cfg(feature = "Media_Capture_Frames")]
   5 pub mod Frames;
   6 #[link(name = "windows")]
   7 extern "system" {}
   8 pub type AdvancedCapturedPhoto = *mut ::core::ffi::c_void;
   9 pub type AdvancedPhotoCapture = *mut ::core::ffi::c_void;
  10 pub type AppBroadcastBackgroundService = *mut ::core::ffi::c_void;
  11 pub type AppBroadcastBackgroundServiceSignInInfo = *mut ::core::ffi::c_void;
  12 pub type AppBroadcastBackgroundServiceStreamInfo = *mut ::core::ffi::c_void;
  13 #[repr(transparent)]
  14 pub struct AppBroadcastCameraCaptureState(pub i32);
  15 impl AppBroadcastCameraCaptureState {
  16     pub const Stopped: Self = Self(0i32);
  17     pub const Started: Self = Self(1i32);
  18     pub const Failed: Self = Self(2i32);
  19 }
  20 impl ::core::marker::Copy for AppBroadcastCameraCaptureState {}
  21 impl ::core::clone::Clone for AppBroadcastCameraCaptureState {
  22     fn clone(&self) -> Self {
  23         *self
  24     }
  25 }
  26 pub type AppBroadcastCameraCaptureStateChangedEventArgs = *mut ::core::ffi::c_void;
  27 #[repr(transparent)]
  28 pub struct AppBroadcastCameraOverlayLocation(pub i32);
  29 impl AppBroadcastCameraOverlayLocation {
  30     pub const TopLeft: Self = Self(0i32);
  31     pub const TopCenter: Self = Self(1i32);
  32     pub const TopRight: Self = Self(2i32);
  33     pub const MiddleLeft: Self = Self(3i32);
  34     pub const MiddleCenter: Self = Self(4i32);
  35     pub const MiddleRight: Self = Self(5i32);
  36     pub const BottomLeft: Self = Self(6i32);
  37     pub const BottomCenter: Self = Self(7i32);
  38     pub const BottomRight: Self = Self(8i32);
  39 }
  40 impl ::core::marker::Copy for AppBroadcastCameraOverlayLocation {}
  41 impl ::core::clone::Clone for AppBroadcastCameraOverlayLocation {
  42     fn clone(&self) -> Self {
  43         *self
  44     }
  45 }
  46 #[repr(transparent)]
  47 pub struct AppBroadcastCameraOverlaySize(pub i32);
  48 impl AppBroadcastCameraOverlaySize {
  49     pub const Small: Self = Self(0i32);
  50     pub const Medium: Self = Self(1i32);
  51     pub const Large: Self = Self(2i32);
  52 }
  53 impl ::core::marker::Copy for AppBroadcastCameraOverlaySize {}
  54 impl ::core::clone::Clone for AppBroadcastCameraOverlaySize {
  55     fn clone(&self) -> Self {
  56         *self
  57     }
  58 }
  59 #[repr(transparent)]
  60 pub struct AppBroadcastCaptureTargetType(pub i32);
  61 impl AppBroadcastCaptureTargetType {
  62     pub const AppView: Self = Self(0i32);
  63     pub const EntireDisplay: Self = Self(1i32);
  64 }
  65 impl ::core::marker::Copy for AppBroadcastCaptureTargetType {}
  66 impl ::core::clone::Clone for AppBroadcastCaptureTargetType {
  67     fn clone(&self) -> Self {
  68         *self
  69     }
  70 }
  71 #[repr(transparent)]
  72 pub struct AppBroadcastExitBroadcastModeReason(pub i32);
  73 impl AppBroadcastExitBroadcastModeReason {
  74     pub const NormalExit: Self = Self(0i32);
  75     pub const UserCanceled: Self = Self(1i32);
  76     pub const AuthorizationFail: Self = Self(2i32);
  77     pub const ForegroundAppActivated: Self = Self(3i32);
  78 }
  79 impl ::core::marker::Copy for AppBroadcastExitBroadcastModeReason {}
  80 impl ::core::clone::Clone for AppBroadcastExitBroadcastModeReason {
  81     fn clone(&self) -> Self {
  82         *self
  83     }
  84 }
  85 pub type AppBroadcastGlobalSettings = *mut ::core::ffi::c_void;
  86 pub type AppBroadcastHeartbeatRequestedEventArgs = *mut ::core::ffi::c_void;
  87 #[repr(transparent)]
  88 pub struct AppBroadcastMicrophoneCaptureState(pub i32);
  89 impl AppBroadcastMicrophoneCaptureState {
  90     pub const Stopped: Self = Self(0i32);
  91     pub const Started: Self = Self(1i32);
  92     pub const Failed: Self = Self(2i32);
  93 }
  94 impl ::core::marker::Copy for AppBroadcastMicrophoneCaptureState {}
  95 impl ::core::clone::Clone for AppBroadcastMicrophoneCaptureState {
  96     fn clone(&self) -> Self {
  97         *self
  98     }
  99 }
 100 pub type AppBroadcastMicrophoneCaptureStateChangedEventArgs = *mut ::core::ffi::c_void;
 101 pub type AppBroadcastPlugIn = *mut ::core::ffi::c_void;
 102 pub type AppBroadcastPlugInManager = *mut ::core::ffi::c_void;
 103 #[repr(transparent)]
 104 pub struct AppBroadcastPlugInState(pub i32);
 105 impl AppBroadcastPlugInState {
 106     pub const Unknown: Self = Self(0i32);
 107     pub const Initialized: Self = Self(1i32);
 108     pub const MicrosoftSignInRequired: Self = Self(2i32);
 109     pub const OAuthSignInRequired: Self = Self(3i32);
 110     pub const ProviderSignInRequired: Self = Self(4i32);
 111     pub const InBandwidthTest: Self = Self(5i32);
 112     pub const ReadyToBroadcast: Self = Self(6i32);
 113 }
 114 impl ::core::marker::Copy for AppBroadcastPlugInState {}
 115 impl ::core::clone::Clone for AppBroadcastPlugInState {
 116     fn clone(&self) -> Self {
 117         *self
 118     }
 119 }
 120 pub type AppBroadcastPlugInStateChangedEventArgs = *mut ::core::ffi::c_void;
 121 pub type AppBroadcastPreview = *mut ::core::ffi::c_void;
 122 #[repr(transparent)]
 123 pub struct AppBroadcastPreviewState(pub i32);
 124 impl AppBroadcastPreviewState {
 125     pub const Started: Self = Self(0i32);
 126     pub const Stopped: Self = Self(1i32);
 127     pub const Failed: Self = Self(2i32);
 128 }
 129 impl ::core::marker::Copy for AppBroadcastPreviewState {}
 130 impl ::core::clone::Clone for AppBroadcastPreviewState {
 131     fn clone(&self) -> Self {
 132         *self
 133     }
 134 }
 135 pub type AppBroadcastPreviewStateChangedEventArgs = *mut ::core::ffi::c_void;
 136 pub type AppBroadcastPreviewStreamReader = *mut ::core::ffi::c_void;
 137 pub type AppBroadcastPreviewStreamVideoFrame = *mut ::core::ffi::c_void;
 138 pub type AppBroadcastPreviewStreamVideoHeader = *mut ::core::ffi::c_void;
 139 pub type AppBroadcastProviderSettings = *mut ::core::ffi::c_void;
 140 pub type AppBroadcastServices = *mut ::core::ffi::c_void;
 141 #[repr(transparent)]
 142 pub struct AppBroadcastSignInResult(pub i32);
 143 impl AppBroadcastSignInResult {
 144     pub const Success: Self = Self(0i32);
 145     pub const AuthenticationFailed: Self = Self(1i32);
 146     pub const Unauthorized: Self = Self(2i32);
 147     pub const ServiceUnavailable: Self = Self(3i32);
 148     pub const Unknown: Self = Self(4i32);
 149 }
 150 impl ::core::marker::Copy for AppBroadcastSignInResult {}
 151 impl ::core::clone::Clone for AppBroadcastSignInResult {
 152     fn clone(&self) -> Self {
 153         *self
 154     }
 155 }
 156 #[repr(transparent)]
 157 pub struct AppBroadcastSignInState(pub i32);
 158 impl AppBroadcastSignInState {
 159     pub const NotSignedIn: Self = Self(0i32);
 160     pub const MicrosoftSignInInProgress: Self = Self(1i32);
 161     pub const MicrosoftSignInComplete: Self = Self(2i32);
 162     pub const OAuthSignInInProgress: Self = Self(3i32);
 163     pub const OAuthSignInComplete: Self = Self(4i32);
 164 }
 165 impl ::core::marker::Copy for AppBroadcastSignInState {}
 166 impl ::core::clone::Clone for AppBroadcastSignInState {
 167     fn clone(&self) -> Self {
 168         *self
 169     }
 170 }
 171 pub type AppBroadcastSignInStateChangedEventArgs = *mut ::core::ffi::c_void;
 172 pub type AppBroadcastState = *mut ::core::ffi::c_void;
 173 pub type AppBroadcastStreamAudioFrame = *mut ::core::ffi::c_void;
 174 pub type AppBroadcastStreamAudioHeader = *mut ::core::ffi::c_void;
 175 pub type AppBroadcastStreamReader = *mut ::core::ffi::c_void;
 176 #[repr(transparent)]
 177 pub struct AppBroadcastStreamState(pub i32);
 178 impl AppBroadcastStreamState {
 179     pub const Initializing: Self = Self(0i32);
 180     pub const StreamReady: Self = Self(1i32);
 181     pub const Started: Self = Self(2i32);
 182     pub const Paused: Self = Self(3i32);
 183     pub const Terminated: Self = Self(4i32);
 184 }
 185 impl ::core::marker::Copy for AppBroadcastStreamState {}
 186 impl ::core::clone::Clone for AppBroadcastStreamState {
 187     fn clone(&self) -> Self {
 188         *self
 189     }
 190 }
 191 pub type AppBroadcastStreamStateChangedEventArgs = *mut ::core::ffi::c_void;
 192 pub type AppBroadcastStreamVideoFrame = *mut ::core::ffi::c_void;
 193 pub type AppBroadcastStreamVideoHeader = *mut ::core::ffi::c_void;
 194 #[repr(transparent)]
 195 pub struct AppBroadcastTerminationReason(pub i32);
 196 impl AppBroadcastTerminationReason {
 197     pub const NormalTermination: Self = Self(0i32);
 198     pub const LostConnectionToService: Self = Self(1i32);
 199     pub const NoNetworkConnectivity: Self = Self(2i32);
 200     pub const ServiceAbort: Self = Self(3i32);
 201     pub const ServiceError: Self = Self(4i32);
 202     pub const ServiceUnavailable: Self = Self(5i32);
 203     pub const InternalError: Self = Self(6i32);
 204     pub const UnsupportedFormat: Self = Self(7i32);
 205     pub const BackgroundTaskTerminated: Self = Self(8i32);
 206     pub const BackgroundTaskUnresponsive: Self = Self(9i32);
 207 }
 208 impl ::core::marker::Copy for AppBroadcastTerminationReason {}
 209 impl ::core::clone::Clone for AppBroadcastTerminationReason {
 210     fn clone(&self) -> Self {
 211         *self
 212     }
 213 }
 214 pub type AppBroadcastTriggerDetails = *mut ::core::ffi::c_void;
 215 #[repr(transparent)]
 216 pub struct AppBroadcastVideoEncodingBitrateMode(pub i32);
 217 impl AppBroadcastVideoEncodingBitrateMode {
 218     pub const Custom: Self = Self(0i32);
 219     pub const Auto: Self = Self(1i32);
 220 }
 221 impl ::core::marker::Copy for AppBroadcastVideoEncodingBitrateMode {}
 222 impl ::core::clone::Clone for AppBroadcastVideoEncodingBitrateMode {
 223     fn clone(&self) -> Self {
 224         *self
 225     }
 226 }
 227 #[repr(transparent)]
 228 pub struct AppBroadcastVideoEncodingResolutionMode(pub i32);
 229 impl AppBroadcastVideoEncodingResolutionMode {
 230     pub const Custom: Self = Self(0i32);
 231     pub const Auto: Self = Self(1i32);
 232 }
 233 impl ::core::marker::Copy for AppBroadcastVideoEncodingResolutionMode {}
 234 impl ::core::clone::Clone for AppBroadcastVideoEncodingResolutionMode {
 235     fn clone(&self) -> Self {
 236         *self
 237     }
 238 }
 239 pub type AppBroadcastViewerCountChangedEventArgs = *mut ::core::ffi::c_void;
 240 pub type AppCapture = *mut ::core::ffi::c_void;
 241 pub type AppCaptureAlternateShortcutKeys = *mut ::core::ffi::c_void;
 242 pub type AppCaptureDurationGeneratedEventArgs = *mut ::core::ffi::c_void;
 243 pub type AppCaptureFileGeneratedEventArgs = *mut ::core::ffi::c_void;
 244 #[repr(transparent)]
 245 pub struct AppCaptureHistoricalBufferLengthUnit(pub i32);
 246 impl AppCaptureHistoricalBufferLengthUnit {
 247     pub const Megabytes: Self = Self(0i32);
 248     pub const Seconds: Self = Self(1i32);
 249 }
 250 impl ::core::marker::Copy for AppCaptureHistoricalBufferLengthUnit {}
 251 impl ::core::clone::Clone for AppCaptureHistoricalBufferLengthUnit {
 252     fn clone(&self) -> Self {
 253         *self
 254     }
 255 }
 256 #[repr(transparent)]
 257 pub struct AppCaptureMetadataPriority(pub i32);
 258 impl AppCaptureMetadataPriority {
 259     pub const Informational: Self = Self(0i32);
 260     pub const Important: Self = Self(1i32);
 261 }
 262 impl ::core::marker::Copy for AppCaptureMetadataPriority {}
 263 impl ::core::clone::Clone for AppCaptureMetadataPriority {
 264     fn clone(&self) -> Self {
 265         *self
 266     }
 267 }
 268 pub type AppCaptureMetadataWriter = *mut ::core::ffi::c_void;
 269 #[repr(transparent)]
 270 pub struct AppCaptureMicrophoneCaptureState(pub i32);
 271 impl AppCaptureMicrophoneCaptureState {
 272     pub const Stopped: Self = Self(0i32);
 273     pub const Started: Self = Self(1i32);
 274     pub const Failed: Self = Self(2i32);
 275 }
 276 impl ::core::marker::Copy for AppCaptureMicrophoneCaptureState {}
 277 impl ::core::clone::Clone for AppCaptureMicrophoneCaptureState {
 278     fn clone(&self) -> Self {
 279         *self
 280     }
 281 }
 282 pub type AppCaptureMicrophoneCaptureStateChangedEventArgs = *mut ::core::ffi::c_void;
 283 pub type AppCaptureRecordOperation = *mut ::core::ffi::c_void;
 284 #[repr(transparent)]
 285 pub struct AppCaptureRecordingState(pub i32);
 286 impl AppCaptureRecordingState {
 287     pub const InProgress: Self = Self(0i32);
 288     pub const Completed: Self = Self(1i32);
 289     pub const Failed: Self = Self(2i32);
 290 }
 291 impl ::core::marker::Copy for AppCaptureRecordingState {}
 292 impl ::core::clone::Clone for AppCaptureRecordingState {
 293     fn clone(&self) -> Self {
 294         *self
 295     }
 296 }
 297 pub type AppCaptureRecordingStateChangedEventArgs = *mut ::core::ffi::c_void;
 298 pub type AppCaptureServices = *mut ::core::ffi::c_void;
 299 pub type AppCaptureSettings = *mut ::core::ffi::c_void;
 300 pub type AppCaptureState = *mut ::core::ffi::c_void;
 301 #[repr(transparent)]
 302 pub struct AppCaptureVideoEncodingBitrateMode(pub i32);
 303 impl AppCaptureVideoEncodingBitrateMode {
 304     pub const Custom: Self = Self(0i32);
 305     pub const High: Self = Self(1i32);
 306     pub const Standard: Self = Self(2i32);
 307 }
 308 impl ::core::marker::Copy for AppCaptureVideoEncodingBitrateMode {}
 309 impl ::core::clone::Clone for AppCaptureVideoEncodingBitrateMode {
 310     fn clone(&self) -> Self {
 311         *self
 312     }
 313 }
 314 #[repr(transparent)]
 315 pub struct AppCaptureVideoEncodingFrameRateMode(pub i32);
 316 impl AppCaptureVideoEncodingFrameRateMode {
 317     pub const Standard: Self = Self(0i32);
 318     pub const High: Self = Self(1i32);
 319 }
 320 impl ::core::marker::Copy for AppCaptureVideoEncodingFrameRateMode {}
 321 impl ::core::clone::Clone for AppCaptureVideoEncodingFrameRateMode {
 322     fn clone(&self) -> Self {
 323         *self
 324     }
 325 }
 326 #[repr(transparent)]
 327 pub struct AppCaptureVideoEncodingResolutionMode(pub i32);
 328 impl AppCaptureVideoEncodingResolutionMode {
 329     pub const Custom: Self = Self(0i32);
 330     pub const High: Self = Self(1i32);
 331     pub const Standard: Self = Self(2i32);
 332 }
 333 impl ::core::marker::Copy for AppCaptureVideoEncodingResolutionMode {}
 334 impl ::core::clone::Clone for AppCaptureVideoEncodingResolutionMode {
 335     fn clone(&self) -> Self {
 336         *self
 337     }
 338 }
 339 pub type CameraCaptureUI = *mut ::core::ffi::c_void;
 340 #[repr(transparent)]
 341 pub struct CameraCaptureUIMaxPhotoResolution(pub i32);
 342 impl CameraCaptureUIMaxPhotoResolution {
 343     pub const HighestAvailable: Self = Self(0i32);
 344     pub const VerySmallQvga: Self = Self(1i32);
 345     pub const SmallVga: Self = Self(2i32);
 346     pub const MediumXga: Self = Self(3i32);
 347     pub const Large3M: Self = Self(4i32);
 348     pub const VeryLarge5M: Self = Self(5i32);
 349 }
 350 impl ::core::marker::Copy for CameraCaptureUIMaxPhotoResolution {}
 351 impl ::core::clone::Clone for CameraCaptureUIMaxPhotoResolution {
 352     fn clone(&self) -> Self {
 353         *self
 354     }
 355 }
 356 #[repr(transparent)]
 357 pub struct CameraCaptureUIMaxVideoResolution(pub i32);
 358 impl CameraCaptureUIMaxVideoResolution {
 359     pub const HighestAvailable: Self = Self(0i32);
 360     pub const LowDefinition: Self = Self(1i32);
 361     pub const StandardDefinition: Self = Self(2i32);
 362     pub const HighDefinition: Self = Self(3i32);
 363 }
 364 impl ::core::marker::Copy for CameraCaptureUIMaxVideoResolution {}
 365 impl ::core::clone::Clone for CameraCaptureUIMaxVideoResolution {
 366     fn clone(&self) -> Self {
 367         *self
 368     }
 369 }
 370 #[repr(transparent)]
 371 pub struct CameraCaptureUIMode(pub i32);
 372 impl CameraCaptureUIMode {
 373     pub const PhotoOrVideo: Self = Self(0i32);
 374     pub const Photo: Self = Self(1i32);
 375     pub const Video: Self = Self(2i32);
 376 }
 377 impl ::core::marker::Copy for CameraCaptureUIMode {}
 378 impl ::core::clone::Clone for CameraCaptureUIMode {
 379     fn clone(&self) -> Self {
 380         *self
 381     }
 382 }
 383 pub type CameraCaptureUIPhotoCaptureSettings = *mut ::core::ffi::c_void;
 384 #[repr(transparent)]
 385 pub struct CameraCaptureUIPhotoFormat(pub i32);
 386 impl CameraCaptureUIPhotoFormat {
 387     pub const Jpeg: Self = Self(0i32);
 388     pub const Png: Self = Self(1i32);
 389     pub const JpegXR: Self = Self(2i32);
 390 }
 391 impl ::core::marker::Copy for CameraCaptureUIPhotoFormat {}
 392 impl ::core::clone::Clone for CameraCaptureUIPhotoFormat {
 393     fn clone(&self) -> Self {
 394         *self
 395     }
 396 }
 397 pub type CameraCaptureUIVideoCaptureSettings = *mut ::core::ffi::c_void;
 398 #[repr(transparent)]
 399 pub struct CameraCaptureUIVideoFormat(pub i32);
 400 impl CameraCaptureUIVideoFormat {
 401     pub const Mp4: Self = Self(0i32);
 402     pub const Wmv: Self = Self(1i32);
 403 }
 404 impl ::core::marker::Copy for CameraCaptureUIVideoFormat {}
 405 impl ::core::clone::Clone for CameraCaptureUIVideoFormat {
 406     fn clone(&self) -> Self {
 407         *self
 408     }
 409 }
 410 pub type CapturedFrame = *mut ::core::ffi::c_void;
 411 pub type CapturedFrameControlValues = *mut ::core::ffi::c_void;
 412 pub type CapturedPhoto = *mut ::core::ffi::c_void;
 413 #[repr(transparent)]
 414 pub struct ForegroundActivationArgument(pub i32);
 415 impl ForegroundActivationArgument {
 416     pub const SignInRequired: Self = Self(0i32);
 417     pub const MoreSettings: Self = Self(1i32);
 418 }
 419 impl ::core::marker::Copy for ForegroundActivationArgument {}
 420 impl ::core::clone::Clone for ForegroundActivationArgument {
 421     fn clone(&self) -> Self {
 422         *self
 423     }
 424 }
 425 #[repr(transparent)]
 426 pub struct GameBarCommand(pub i32);
 427 impl GameBarCommand {
 428     pub const OpenGameBar: Self = Self(0i32);
 429     pub const RecordHistoricalBuffer: Self = Self(1i32);
 430     pub const ToggleStartStopRecord: Self = Self(2i32);
 431     pub const StartRecord: Self = Self(3i32);
 432     pub const StopRecord: Self = Self(4i32);
 433     pub const TakeScreenshot: Self = Self(5i32);
 434     pub const StartBroadcast: Self = Self(6i32);
 435     pub const StopBroadcast: Self = Self(7i32);
 436     pub const PauseBroadcast: Self = Self(8i32);
 437     pub const ResumeBroadcast: Self = Self(9i32);
 438     pub const ToggleStartStopBroadcast: Self = Self(10i32);
 439     pub const ToggleMicrophoneCapture: Self = Self(11i32);
 440     pub const ToggleCameraCapture: Self = Self(12i32);
 441     pub const ToggleRecordingIndicator: Self = Self(13i32);
 442 }
 443 impl ::core::marker::Copy for GameBarCommand {}
 444 impl ::core::clone::Clone for GameBarCommand {
 445     fn clone(&self) -> Self {
 446         *self
 447     }
 448 }
 449 #[repr(transparent)]
 450 pub struct GameBarCommandOrigin(pub i32);
 451 impl GameBarCommandOrigin {
 452     pub const ShortcutKey: Self = Self(0i32);
 453     pub const Cortana: Self = Self(1i32);
 454     pub const AppCommand: Self = Self(2i32);
 455 }
 456 impl ::core::marker::Copy for GameBarCommandOrigin {}
 457 impl ::core::clone::Clone for GameBarCommandOrigin {
 458     fn clone(&self) -> Self {
 459         *self
 460     }
 461 }
 462 pub type GameBarServices = *mut ::core::ffi::c_void;
 463 pub type GameBarServicesCommandEventArgs = *mut ::core::ffi::c_void;
 464 #[repr(transparent)]
 465 pub struct GameBarServicesDisplayMode(pub i32);
 466 impl GameBarServicesDisplayMode {
 467     pub const Windowed: Self = Self(0i32);
 468     pub const FullScreenExclusive: Self = Self(1i32);
 469 }
 470 impl ::core::marker::Copy for GameBarServicesDisplayMode {}
 471 impl ::core::clone::Clone for GameBarServicesDisplayMode {
 472     fn clone(&self) -> Self {
 473         *self
 474     }
 475 }
 476 pub type GameBarServicesManager = *mut ::core::ffi::c_void;
 477 pub type GameBarServicesManagerGameBarServicesCreatedEventArgs = *mut ::core::ffi::c_void;
 478 pub type GameBarServicesTargetInfo = *mut ::core::ffi::c_void;
 479 #[repr(transparent)]
 480 pub struct GameBarTargetCapturePolicy(pub i32);
 481 impl GameBarTargetCapturePolicy {
 482     pub const EnabledBySystem: Self = Self(0i32);
 483     pub const EnabledByUser: Self = Self(1i32);
 484     pub const NotEnabled: Self = Self(2i32);
 485     pub const ProhibitedBySystem: Self = Self(3i32);
 486     pub const ProhibitedByPublisher: Self = Self(4i32);
 487 }
 488 impl ::core::marker::Copy for GameBarTargetCapturePolicy {}
 489 impl ::core::clone::Clone for GameBarTargetCapturePolicy {
 490     fn clone(&self) -> Self {
 491         *self
 492     }
 493 }
 494 #[repr(transparent)]
 495 pub struct KnownVideoProfile(pub i32);
 496 impl KnownVideoProfile {
 497     pub const VideoRecording: Self = Self(0i32);
 498     pub const HighQualityPhoto: Self = Self(1i32);
 499     pub const BalancedVideoAndPhoto: Self = Self(2i32);
 500     pub const VideoConferencing: Self = Self(3i32);
 501     pub const PhotoSequence: Self = Self(4i32);
 502     pub const HighFrameRate: Self = Self(5i32);
 503     pub const VariablePhotoSequence: Self = Self(6i32);
 504     pub const HdrWithWcgVideo: Self = Self(7i32);
 505     pub const HdrWithWcgPhoto: Self = Self(8i32);
 506     pub const VideoHdr8: Self = Self(9i32);
 507     pub const CompressedCamera: Self = Self(10i32);
 508 }
 509 impl ::core::marker::Copy for KnownVideoProfile {}
 510 impl ::core::clone::Clone for KnownVideoProfile {
 511     fn clone(&self) -> Self {
 512         *self
 513     }
 514 }
 515 pub type LowLagMediaRecording = *mut ::core::ffi::c_void;
 516 pub type LowLagPhotoCapture = *mut ::core::ffi::c_void;
 517 pub type LowLagPhotoSequenceCapture = *mut ::core::ffi::c_void;
 518 pub type MediaCapture = *mut ::core::ffi::c_void;
 519 #[repr(transparent)]
 520 pub struct MediaCaptureDeviceExclusiveControlStatus(pub i32);
 521 impl MediaCaptureDeviceExclusiveControlStatus {
 522     pub const ExclusiveControlAvailable: Self = Self(0i32);
 523     pub const SharedReadOnlyAvailable: Self = Self(1i32);
 524 }
 525 impl ::core::marker::Copy for MediaCaptureDeviceExclusiveControlStatus {}
 526 impl ::core::clone::Clone for MediaCaptureDeviceExclusiveControlStatus {
 527     fn clone(&self) -> Self {
 528         *self
 529     }
 530 }
 531 pub type MediaCaptureDeviceExclusiveControlStatusChangedEventArgs = *mut ::core::ffi::c_void;
 532 pub type MediaCaptureFailedEventArgs = *mut ::core::ffi::c_void;
 533 pub type MediaCaptureFailedEventHandler = *mut ::core::ffi::c_void;
 534 pub type MediaCaptureFocusChangedEventArgs = *mut ::core::ffi::c_void;
 535 pub type MediaCaptureInitializationSettings = *mut ::core::ffi::c_void;
 536 #[repr(transparent)]
 537 pub struct MediaCaptureMemoryPreference(pub i32);
 538 impl MediaCaptureMemoryPreference {
 539     pub const Auto: Self = Self(0i32);
 540     pub const Cpu: Self = Self(1i32);
 541 }
 542 impl ::core::marker::Copy for MediaCaptureMemoryPreference {}
 543 impl ::core::clone::Clone for MediaCaptureMemoryPreference {
 544     fn clone(&self) -> Self {
 545         *self
 546     }
 547 }
 548 pub type MediaCapturePauseResult = *mut ::core::ffi::c_void;
 549 pub type MediaCaptureRelativePanelWatcher = *mut ::core::ffi::c_void;
 550 pub type MediaCaptureSettings = *mut ::core::ffi::c_void;
 551 #[repr(transparent)]
 552 pub struct MediaCaptureSharingMode(pub i32);
 553 impl MediaCaptureSharingMode {
 554     pub const ExclusiveControl: Self = Self(0i32);
 555     pub const SharedReadOnly: Self = Self(1i32);
 556 }
 557 impl ::core::marker::Copy for MediaCaptureSharingMode {}
 558 impl ::core::clone::Clone for MediaCaptureSharingMode {
 559     fn clone(&self) -> Self {
 560         *self
 561     }
 562 }
 563 pub type MediaCaptureStopResult = *mut ::core::ffi::c_void;
 564 #[repr(transparent)]
 565 pub struct MediaCaptureThermalStatus(pub i32);
 566 impl MediaCaptureThermalStatus {
 567     pub const Normal: Self = Self(0i32);
 568     pub const Overheated: Self = Self(1i32);
 569 }
 570 impl ::core::marker::Copy for MediaCaptureThermalStatus {}
 571 impl ::core::clone::Clone for MediaCaptureThermalStatus {
 572     fn clone(&self) -> Self {
 573         *self
 574     }
 575 }
 576 pub type MediaCaptureVideoProfile = *mut ::core::ffi::c_void;
 577 pub type MediaCaptureVideoProfileMediaDescription = *mut ::core::ffi::c_void;
 578 #[repr(transparent)]
 579 pub struct MediaCategory(pub i32);
 580 impl MediaCategory {
 581     pub const Other: Self = Self(0i32);
 582     pub const Communications: Self = Self(1i32);
 583     pub const Media: Self = Self(2i32);
 584     pub const GameChat: Self = Self(3i32);
 585     pub const Speech: Self = Self(4i32);
 586     pub const FarFieldSpeech: Self = Self(5i32);
 587     pub const UniformSpeech: Self = Self(6i32);
 588     pub const VoiceTyping: Self = Self(7i32);
 589 }
 590 impl ::core::marker::Copy for MediaCategory {}
 591 impl ::core::clone::Clone for MediaCategory {
 592     fn clone(&self) -> Self {
 593         *self
 594     }
 595 }
 596 #[repr(transparent)]
 597 pub struct MediaStreamType(pub i32);
 598 impl MediaStreamType {
 599     pub const VideoPreview: Self = Self(0i32);
 600     pub const VideoRecord: Self = Self(1i32);
 601     pub const Audio: Self = Self(2i32);
 602     pub const Photo: Self = Self(3i32);
 603     pub const Metadata: Self = Self(4i32);
 604 }
 605 impl ::core::marker::Copy for MediaStreamType {}
 606 impl ::core::clone::Clone for MediaStreamType {
 607     fn clone(&self) -> Self {
 608         *self
 609     }
 610 }
 611 pub type OptionalReferencePhotoCapturedEventArgs = *mut ::core::ffi::c_void;
 612 #[repr(transparent)]
 613 pub struct PhotoCaptureSource(pub i32);
 614 impl PhotoCaptureSource {
 615     pub const Auto: Self = Self(0i32);
 616     pub const VideoPreview: Self = Self(1i32);
 617     pub const Photo: Self = Self(2i32);
 618 }
 619 impl ::core::marker::Copy for PhotoCaptureSource {}
 620 impl ::core::clone::Clone for PhotoCaptureSource {
 621     fn clone(&self) -> Self {
 622         *self
 623     }
 624 }
 625 pub type PhotoCapturedEventArgs = *mut ::core::ffi::c_void;
 626 pub type PhotoConfirmationCapturedEventArgs = *mut ::core::ffi::c_void;
 627 #[repr(transparent)]
 628 pub struct PowerlineFrequency(pub i32);
 629 impl PowerlineFrequency {
 630     pub const Disabled: Self = Self(0i32);
 631     pub const FiftyHertz: Self = Self(1i32);
 632     pub const SixtyHertz: Self = Self(2i32);
 633     pub const Auto: Self = Self(3i32);
 634 }
 635 impl ::core::marker::Copy for PowerlineFrequency {}
 636 impl ::core::clone::Clone for PowerlineFrequency {
 637     fn clone(&self) -> Self {
 638         *self
 639     }
 640 }
 641 pub type RecordLimitationExceededEventHandler = *mut ::core::ffi::c_void;
 642 pub type ScreenCapture = *mut ::core::ffi::c_void;
 643 pub type SourceSuspensionChangedEventArgs = *mut ::core::ffi::c_void;
 644 #[repr(transparent)]
 645 pub struct StreamingCaptureMode(pub i32);
 646 impl StreamingCaptureMode {
 647     pub const AudioAndVideo: Self = Self(0i32);
 648     pub const Audio: Self = Self(1i32);
 649     pub const Video: Self = Self(2i32);
 650 }
 651 impl ::core::marker::Copy for StreamingCaptureMode {}
 652 impl ::core::clone::Clone for StreamingCaptureMode {
 653     fn clone(&self) -> Self {
 654         *self
 655     }
 656 }
 657 #[repr(transparent)]
 658 pub struct VideoDeviceCharacteristic(pub i32);
 659 impl VideoDeviceCharacteristic {
 660     pub const AllStreamsIndependent: Self = Self(0i32);
 661     pub const PreviewRecordStreamsIdentical: Self = Self(1i32);
 662     pub const PreviewPhotoStreamsIdentical: Self = Self(2i32);
 663     pub const RecordPhotoStreamsIdentical: Self = Self(3i32);
 664     pub const AllStreamsIdentical: Self = Self(4i32);
 665 }
 666 impl ::core::marker::Copy for VideoDeviceCharacteristic {}
 667 impl ::core::clone::Clone for VideoDeviceCharacteristic {
 668     fn clone(&self) -> Self {
 669         *self
 670     }
 671 }
 672 #[repr(transparent)]
 673 pub struct VideoRotation(pub i32);
 674 impl VideoRotation {
 675     pub const None: Self = Self(0i32);
 676     pub const Clockwise90Degrees: Self = Self(1i32);
 677     pub const Clockwise180Degrees: Self = Self(2i32);
 678     pub const Clockwise270Degrees: Self = Self(3i32);
 679 }
 680 impl ::core::marker::Copy for VideoRotation {}
 681 impl ::core::clone::Clone for VideoRotation {
 682     fn clone(&self) -> Self {
 683         *self
 684     }
 685 }
 686 pub type VideoStreamConfiguration = *mut ::core::ffi::c_void;
 687 #[repr(C)]
 688 pub struct WhiteBalanceGain {
 689     pub R: f64,
 690     pub G: f64,
 691     pub B: f64,
 692 }
 693 impl ::core::marker::Copy for WhiteBalanceGain {}
 694 impl ::core::clone::Clone for WhiteBalanceGain {
 695     fn clone(&self) -> Self {
 696         *self
 697     }
 698 }