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