-
Notifications
You must be signed in to change notification settings - Fork 6
/
IddCx.h
3615 lines (3238 loc) · 120 KB
/
IddCx.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*++
Copyright (c) Microsoft Corporation. All Rights Reserved
Module Name:
IddCx.h
Abstract:
Indirect Displays class extension and the client driver interface.
Environment:
User-mode Driver Framework
--*/
#ifndef DXVA2_API_DEFINED
#define DXVA2_API_DEFINED
#endif
#ifndef DO_NOT_USE_DIRECTX_OR_DXVA2
#define DO_NOT_USE_DIRECTX_OR_DXVA2
#endif
#include <Opmapi.h>
#include <Dxgi.h>
#include <d3d11_4.h>
//
// NOTE: This header is generated by stubwork. Please make any
// modifications to the corresponding template files
// (.x or .y) and use stubwork to regenerate the header
//
#ifndef _IDDCX_H_
#define _IDDCX_H_
#ifndef WDF_EXTERN_C
#ifdef __cplusplus
#define WDF_EXTERN_C extern "C"
#define WDF_EXTERN_C_START extern "C" {
#define WDF_EXTERN_C_END }
#else
#define WDF_EXTERN_C
#define WDF_EXTERN_C_START
#define WDF_EXTERN_C_END
#endif
#endif
WDF_EXTERN_C_START
#ifndef WDFAPI
#error Include WDF.H first
#endif
// Disable warning 'nonstandard extension used : nameless struct/union'
#pragma warning(push)
#pragma warning(disable : 4201)
// DDI Version model
// -----------------
// The interface version model will be based on structure versions, when a DDI call/OS callback needs to be updated
// the version of that callback we be incremented along with any structures used, for example if v1 of a call was :
//
// void SomeDDICall(IDDCX_ADAPTER hOsAdapterContext, IDARG_IN_SOME_DDI* pInArgs);
//
// and the functionality/params needed to be changed then the following would be added:
//
// void SomeDDICall2(IDDCX_ADAPTER hOsAdapterContext, IDARG_IN_SOME_DDI2* pInArgs);
//
// and the DDI function table structure would be updated to IDDCX_DDI2 which would have SomeDDICall replaced with
// SomeDDICall2. At the same time a new create interface v2 would be used by a driver
// IDDCX Version model
// -------------------
// In order for drivers to know precisely which version of IddCx the driver is running the driver can call the
// IddCxGetVersion() callback. This helps if IddCx bug that effect behavior are fixed and released within a given OS release,
// for example if a IddCx bug was fixed in the Windows 10 Creators Update after release and the driver needed to know if the
// IddCx being used had that fix they could use IddCxGetVersion()
#define IDDCX_VERSION_RS3 0x1200
#define IDDCX_VERSION_RS4 0x1300
#define IDDCX_VERSION_RS5 0x1380
#define IDDCX_VERSION_19H1 0x1400
#define IDDCX_VERSION_VIBRAINIUM 0x1500
#define IDDCX_VERSION_MANGANESE 0x1600
#define IDDCX_VERSION_IRON 0x1700
#define IDDCX_VERSION_COBALT 0x1800
#define IDDCX_VERSION_LATEST IDDCX_VERSION_COBALT
// Timeout detection and recovery
// ------------------------------
// The OS will monitor the drivers processing of frames and if it detects the driver is not making forward progress it will
// take action to ensure the desktop is not effected.
// The OS will monitor the driver in two ways :
//
// 1) Ensure that each OS->driver call does not take longer than 10 seconds
// 2) Ensure that a driver reports that it has finished process a given frame within 10 seconds, that is that the driver does
// not call FinishedProcessingFrame() within 10 seconds of the new frame ready event is triggered
//
// In the event of a timeout being detected then the OS will call the UMDF BugCheck() call which will cause the UMDF host
// process to terminate and restart subject to UMDF device restart policy.
/// <summary>
/// Opaque reference to a WDF indirect display adapter object
/// </summary>
DECLARE_HANDLE(IDDCX_ADAPTER);
/// <summary>
/// Opaque reference to a WDF indirect display monitor object
/// </summary>
DECLARE_HANDLE(IDDCX_MONITOR);
/// <summary>
/// Opaque reference to a WDF indirect display swap-chain object.
/// </summary>
DECLARE_HANDLE(IDDCX_SWAPCHAIN);
/// <summary>
/// Opaque reference to a WDF indirect display OPM output protection context
/// </summary>
DECLARE_HANDLE(IDDCX_OPMCTX);
#pragma region Enum Declarations
/// <summary>
/// Enum used to indicates how a given supported feature is implemented
/// </summary>
enum IDDCX_FEATURE_IMPLEMENTATION : UINT
{
IDDCX_FEATURE_IMPLEMENTATION_UNINITIALIZED = 0,
/// <summary>
/// The feature is not implemented
/// </summary>
IDDCX_FEATURE_IMPLEMENTATION_NONE = 1,
/// <summary>
/// The feature is implemented and hardware is used in the implementation. For example, the adapter
/// display pipeline blends the hardware cursor image into the signal sent to the monitor.
/// </summary>
IDDCX_FEATURE_IMPLEMENTATION_HARDWARE = 2,
/// <summary>
/// The feature is implemented and software is used in the implementation. For example, the driver
/// support hardware cursor by blending the cursor image into the display pixels as part of the processing.
/// </summary>
IDDCX_FEATURE_IMPLEMENTATION_SOFTWARE = 3,
};
/// <summary>
/// Enum used to indicates the link type for transmission of the video data
/// </summary>
enum IDDCX_TRANSMISSION_TYPE : UINT
{
IDDCX_TRANSMISSION_TYPE_UNINITIALIZED = 0,
/// <summary>
/// Video data is being transmitted over wired USB
/// </summary>
IDDCX_TRANSMISSION_TYPE_WIRED_USB = 0x1,
/// <summary>
/// Video data is being transmitted over wired Miracast link
/// </summary>
IDDCX_TRANSMISSION_TYPE_WIRED_MIRACAST = 0x2,
/// <summary>
/// Video data is being transmitted over a wired connect not already described
/// </summary>
IDDCX_TRANSMISSION_TYPE_WIRED_OTHER = 0x3,
/// <summary>
/// Video data is being transmitted over wireless MA-USB
/// </summary>
IDDCX_TRANSMISSION_TYPE_WIRELESS_MAUSB = 0x4,
/// <summary>
/// Video data is being transmitted over wireless network not using MA-USB but the device
/// is enumerated on the USB bus
/// </summary>
IDDCX_TRANSMISSION_TYPE_WIRELESS_USB_OTHER = 0x5,
/// <summary>
/// Video data is being transmitted over a WiFi wireless network
/// </summary>
IDDCX_TRANSMISSION_TYPE_WIRELESS_WIFI_OTHER = 0x6,
/// <summary>
/// Video data is being transmitted over wireless Miracast link
/// </summary>
IDDCX_TRANSMISSION_TYPE_WIRELESS_MIRACAST = 0x7,
/// <summary>
/// Video data is being transmitted over a non-WiFi wireless network not described above
/// </summary>
IDDCX_TRANSMISSION_TYPE_WIRELESS_OTHER = 0x8,
/// <summary>
/// Video data is being transmitted over TCP/UDP/IP network not described above
/// </summary>
IDDCX_TRANSMISSION_TYPE_NETWORK_OTHER = 0x9,
/// <summary>
/// Video data is being transmitted over a link type that is not covered by the above defines
/// </summary>
IDDCX_TRANSMISSION_TYPE_OTHER = 0xFFFFFFFF,
};
/// <summary>
/// Specifies boolean flags for an indirect display adapter.
/// </summary>
enum IDDCX_ADAPTER_FLAGS : UINT
{
IDDCX_ADAPTER_FLAGS_NONE = 0,
/// <summary>
/// Indirect display automatically support OS virtual modes, this means mode changes can be
/// performed seamlessly by OS using DWM scaling on a per frame basis without any display mode
/// change. The disadvantage of this is that when a smaller desktop mode is used by the user the
/// desktop image provided to the driver to process will be bigger than the desktop size hence
/// wasting some encode and transmit bandwidth. This value is used to indicate to the OS that the
/// smallest possible desktop surface size should be used when the desktop mode is changed.
/// Typically a solution that has a large processing overhead or limited transmission bandwidth will
/// use this flag reduce the desktop image size to process as much as possible.Note setting this flag
/// will result in a mode change each time the desktop resolution is changed.
/// </summary>
IDDCX_ADAPTER_FLAGS_USE_SMALLEST_MODE = 1,
/// <summary>
/// Indicates if the driver can utilize move regions provided by the OS in addition to dirty rects when
/// encoding the image. The driver should only set this to TRUE if it will use the move regions as it does
/// cost additional resource for the OS to generate these.
/// If driver sets this to FALSE the OS will convert all move regions in to dirty rects
/// </summary>
IDDCX_ADAPTER_FLAGS_CAN_USE_MOVE_REGIONS = 2,
/// <summary>
/// Indicates if the driver is a remote session driver supporting remote session monitors rather than console
/// session monitors. A remote session driver cannot support console session monitors and console session driver
/// cannot support remote session monitors.
/// </summary>
IDDCX_ADAPTER_FLAGS_REMOTE_SESSION_DRIVER = 4,
/// <summary>
/// Indicates that the driver perfers physically contiguous memory to be used for swap chain buffers allowing
// the driver to directly scan out the buffers and eliminating the need for an intermediate copy.
/// </summary>
IDDCX_ADAPTER_FLAGS_PREFER_PHYSICALLY_CONTIGUOUS = 8,
/// <summary>
/// Indicates that the remote driver wants to receive all cursor position changes rather than just the
/// procedural moves. Only valid if IDDCX_ADAPTER_FLAGS_REMOTE_SESSION_DRIVER is set
/// </summary>
IDDCX_ADAPTER_FLAGS_REMOTE_ALL_CURSOR_POSITION = 16,
/// <summary>
/// Indicates that driver prefers more accurate dirty rects even if it costs slightly more CPU usage to track them
/// </summary>
IDDCX_ADAPTER_FLAGS_PREFER_PRECISE_PRESENT_REGIONS = 32,
};
DEFINE_ENUM_FLAG_OPERATORS(IDDCX_ADAPTER_FLAGS);
/// <summary>
/// Used to describe the monitor description
/// </summary>
enum IDDCX_MONITOR_DESCRIPTION_TYPE : UINT
{
IDDCX_MONITOR_DESCRIPTION_TYPE_UNINITIALIZED = 0,
/// <summary>
/// The monitor description is EDID or no EDID description available
/// If the monitor has no description then IDDCX_MONITOR_DESCRIPTION_TYPE_EDID shall be used with zero description size
/// and null pointer for data
/// </summary>
IDDCX_MONITOR_DESCRIPTION_TYPE_EDID = 1,
/// <summary>
/// For the monitors with DisplayID and EDID
/// The monitor description starts with DisplayID followed by EDID without any padding in between
/// EDID should contain all available data blocks and shall be present
/// The call to connect monitor will fail if DisplayID is missing or invalid, or if EDID is missing
/// </summary>
IDDCX_MONITOR_DESCRIPTION_TYPE_DISPLAYID_AND_EDID = 2,
};
/// <summary>
/// Used to describe a mode the monitor supports based on the monitor description.
/// </summary>
enum IDDCX_MONITOR_MODE_ORIGIN : UINT
{
IDDCX_MONITOR_MODE_ORIGIN_UNINITIALIZED = 0,
/// <summary>
/// Indicates that the driver added this mode from directly processing the monitor description
/// </summary>
IDDCX_MONITOR_MODE_ORIGIN_MONITORDESCRIPTOR = 1,
/// <summary>
/// Indicates that the driver did not add this mode as a direct resolution of processing the modes
/// supported by the monitor but because of separate additional knowledge it has about the monitor
/// </summary>
IDDCX_MONITOR_MODE_ORIGIN_DRIVER = 2,
};
/// <summary>
/// Describes why the driver is calling to update the mode list
/// </summary>
enum IDDCX_UPDATE_REASON : UINT
{
IDDCX_UPDATE_REASON_UNINITIALIZED = 0,
/// <summary>
/// The mode list is changing due to power constraints on the host system changed
/// </summary>
IDDCX_UPDATE_REASON_POWER_CONSTRAINTS = 1,
/// <summary>
/// The mode list is changing due to changes in bandwidth between the system and the indirect display device
/// </summary>
IDDCX_UPDATE_REASON_HOST_LINK_BANDWIDTH = 2,
/// <summary>
/// The mode list is changing due to changes in bandwidth the indirect display device and the monitor
/// </summary>
IDDCX_UPDATE_REASON_DISPLAY_LINK_BANDWIDTH = 3,
/// <summary>
/// The mode list is changing due to constraints of the product when in a new configuration
/// </summary>
IDDCX_UPDATE_REASON_CONFIGURATION_CONSTRAINTS = 4,
/// <summary>
/// The mode list is changing due to another reason not listed above
/// </summary>
IDDCX_UPDATE_REASON_OTHER = 5,
};
enum IDDCX_PATH_FLAGS : UINT
{
IDDCX_PATH_FLAGS_NONE = 0,
/// <summary>
/// Indicates if this path has changed
/// </summary>
IDDCX_PATH_FLAGS_CHANGED = 1,
/// <summary>
/// Indicates if this path is active
/// </summary>
IDDCX_PATH_FLAGS_ACTIVE = 2,
};
/// <summary>
/// Describes what type of support a driver has for the given Xor cursor format.
/// If driver cannot support a particular monochrome Xor or color Xor cursor it can use the
/// IDDCX_XOR_CURSOR_SUPPORT_EMULATION value to indicate to the OS that it
/// should use it's Xor emulation algorithm to convert the Xor image to alpha cursor and have the
/// driver accelerate that. This emulation places a solid border around the cursor image so it
/// can be seen in solid color regions of the screen. The advantages of this is that is allows
/// the Xor cursor to be hardware accelerated when the adapter cannot support Xor, this is very
/// useful on high latency solutions as this typically allows driver to send the cursor information
/// over a sideband channel to reduce the latency. The disadvantage is that the user will notice a
/// visual difference due to the emulation. The recommendation is not to use this on a low latency
/// solution where falling back to software cursor will not impact the mouse latency for the
/// user (<50ms) and will result in a better visible experience. On a high latency solution where
/// the cursor data can be transmitted independently of the desktop image it is recommended to use
/// this flag to allow hardware cursor and hence lower the mouse movement latency.
/// </summary>
enum IDDCX_XOR_CURSOR_SUPPORT : UINT
{
IDDCX_XOR_CURSOR_SUPPORT_UNINITIALIZED = 0,
/// <summary>
/// Driver does not support this Xor cursor type at all, all cursors of this type will be drawn into the desktop image by
/// the OS
/// </summary>
IDDCX_XOR_CURSOR_SUPPORT_NONE = 1,
/// <summary>
/// Driver does support this Xor cursor type
/// </summary>
IDDCX_XOR_CURSOR_SUPPORT_FULL = 2,
/// <summary>
/// The driver does not support this Xor cursor type but driver wants OS to convert the Xor cursor into a alpha cursor,
/// see comment above
/// </summary>
IDDCX_XOR_CURSOR_SUPPORT_EMULATION = 3,
};
/// <summary>
/// Describes the type of cursor
/// </summary>
enum IDDCX_CURSOR_SHAPE_TYPE : UINT
{
IDDCX_CURSOR_SHAPE_TYPE_UNINITIALIZED = 0,
/// <summary>
/// Indicates this is a masked-color cursor shape
/// </summary>
IDDCX_CURSOR_SHAPE_TYPE_MASKED_COLOR = 1,
/// <summary>
/// Indicates this is a 32bpp alpha cursor
/// </summary>
IDDCX_CURSOR_SHAPE_TYPE_ALPHA = 2,
};
/// <summary>
/// Defines the processing status of the frame
/// </summary>
enum IDDCX_FRAME_STATUS : UINT
{
IDDCX_FRAME_STATUS_UNINITIALIZED = 0,
/// <summary>
/// Indicates that the frame was processed completely and sent to the device
/// </summary>
IDDCX_FRAME_STATUS_COMPLETED = 1,
/// <summary>
/// Indicates that the driver stopped processing this frame to start on a newer frame, this normally
/// happens if it is taking a long time to process/transmit the frame
/// </summary>
IDDCX_FRAME_STATUS_DROPPED = 2,
/// <summary>
/// Indicates that the driver stopped processing this frame because driver hit an internal error
/// </summary>
IDDCX_FRAME_STATUS_ERROR = 3,
};
/// <summary>
/// Defines the type of frame processing step
/// </summary>
enum IDDCX_FRAME_STATISTICS_STEP_TYPE : UINT
{
IDDCX_FRAME_STATISTICS_STEP_TYPE_UNINITIALIZED = 0,
/// <summary>
/// Used to mark the start of a color convert operation
/// </summary>
IDDCX_FRAME_STATISTICS_STEP_TYPE_COLOR_CONVERT_START = 0x1,
/// <summary>
/// Used to mark the end of a color convert operation
/// </summary>
IDDCX_FRAME_STATISTICS_STEP_TYPE_COLOR_CONVERT_END = 0x2,
/// <summary>
/// Used to mark the start of a encode operation
/// </summary>
IDDCX_FRAME_STATISTICS_STEP_TYPE_ENCODE_START = 0x3,
/// <summary>
/// Used to mark the end of a encode operation
/// </summary>
IDDCX_FRAME_STATISTICS_STEP_TYPE_ENCODE_END = 0x4,
/// <summary>
/// Used to mark the start of a encrypt operation
/// </summary>
IDDCX_FRAME_STATISTICS_STEP_TYPE_ENCRYPT_START = 0x5,
/// <summary>
/// Used to mark the end of a encrypt operation
/// </summary>
IDDCX_FRAME_STATISTICS_STEP_TYPE_ENCRYPT_END = 0x6,
/// <summary>
/// Used to mark the start of a mux'ing operation
/// </summary>
IDDCX_FRAME_STATISTICS_STEP_TYPE_MUX_START = 0x7,
/// <summary>
/// Used to mark the end of a mux'ing operation
/// </summary>
IDDCX_FRAME_STATISTICS_STEP_TYPE_MUX_END = 0x8,
/// <summary>
/// Driver defined processing steps points.
/// There are 256 single point events defined that the driver can use, each just records a single QPC time
/// Valid driver values valid 0x100 - 0x1FF
/// </summary>
IDDCX_FRAME_STATISTICS_STEP_TYPE_DRIVER_DEFINED_1 = 0x100,
IDDCX_FRAME_STATISTICS_STEP_TYPE_DRIVER_DEFINED_2 = 0x101,
IDDCX_FRAME_STATISTICS_STEP_TYPE_DRIVER_DEFINED_3 = 0x102,
IDDCX_FRAME_STATISTICS_STEP_TYPE_DRIVER_DEFINED_4 = 0x103,
IDDCX_FRAME_STATISTICS_STEP_TYPE_DRIVER_DEFINED_5 = 0x104,
IDDCX_FRAME_STATISTICS_STEP_TYPE_DRIVER_DEFINED_6 = 0x105,
IDDCX_FRAME_STATISTICS_STEP_TYPE_DRIVER_DEFINED_7 = 0x106,
IDDCX_FRAME_STATISTICS_STEP_TYPE_DRIVER_DEFINED_8 = 0x107,
IDDCX_FRAME_STATISTICS_STEP_TYPE_DRIVER_DEFINED_9 = 0x108,
IDDCX_FRAME_STATISTICS_STEP_TYPE_DRIVER_DEFINED_10 = 0x109,
IDDCX_FRAME_STATISTICS_STEP_TYPE_DRIVER_DEFINED_256 = 0x1FF,
/// <summary>
/// Driver defined processing step intervals.
/// There are 256 different intervals each with a start and end point defined.
/// It is invalid to report either start or end without the other or for the start
/// step to have a QPC time after the QPC time in the end step
/// Valid start step values are 0x200 - 0x2FFF
/// Valid end step values are 0x300 - 0x3FFF
/// </summary>
IDDCX_FRAME_STATISTICS_STEP_TYPE_DRIVER_DEFINED_START_INTERVAL_1 = 0x200,
IDDCX_FRAME_STATISTICS_STEP_TYPE_DRIVER_DEFINED_END_INTERVAL_1 = 0x300,
IDDCX_FRAME_STATISTICS_STEP_TYPE_DRIVER_DEFINED_START_INTERVAL_2 = 0x201,
IDDCX_FRAME_STATISTICS_STEP_TYPE_DRIVER_DEFINED_END_INTERVAL_2 = 0x301,
IDDCX_FRAME_STATISTICS_STEP_TYPE_DRIVER_DEFINED_START_INTERVAL_3 = 0x202,
IDDCX_FRAME_STATISTICS_STEP_TYPE_DRIVER_DEFINED_END_INTERVAL_3 = 0x302,
IDDCX_FRAME_STATISTICS_STEP_TYPE_DRIVER_DEFINED_START_INTERVAL_256 = 0x2FF,
IDDCX_FRAME_STATISTICS_STEP_TYPE_DRIVER_DEFINED_END_INTERVAL_256 = 0x3FF,
};
enum IDDCX_FRAME_STATISTICS_FLAGS : UINT
{
IDDCX_FRAME_STATISTICS_FLAGS_NONE = 0,
/// <summary>
/// If set indicates that the driver reduced the color fidelity of the desktop image while processing
/// and transmitting this frame
/// </summary>
IDDCX_FRAME_STATISTICS_FLAGS_REDUCED_COLOR_FIDELITY = 1,
};
/// <summary>
/// The type of gamma ramp being set
/// </summary>
enum IDDCX_GAMMARAMP_TYPE : UINT
{
IDDCX_GAMMARAMP_TYPE_UNINITIALIZED = 0,
/// <summary>
/// The gamma ramp is the default ramp
/// </summary>
IDDCX_GAMMARAMP_TYPE_DEFAULT = 1,
/// <summary>
/// Indicates that the gamma lookup table contains three arrays, one each for the red, green, and blue color channels.
/// Each array has 256 16-bit values.
/// </summary>
IDDCX_GAMMARAMP_TYPE_RGB256x3x16 = 2,
};
#pragma endregion
// Defines the function table used to indirectly call class extension functions.
typedef VOID (*PFN_IDD_CX)(VOID);
extern PFN_IDD_CX IddFunctions[];
// Forward-declare the driver globals structure, which contains system-defined per-driver data.
typedef struct IDD_DRIVER_GLOBALS IDD_DRIVER_GLOBALS, *PIDD_DRIVER_GLOBALS;
#include "IddCxFuncEnum.h"
#pragma region Forward Declarations
// Structures need to be referenced by the event callbacks
struct IDD_CX_CLIENT_CONFIG;
struct IDDCX_ENDPOINT_VERSION;
struct IDDCX_ENDPOINT_DIAGNOSTIC_INFO;
struct IDDCX_ADAPTER_CAPS;
struct IDARG_IN_ADAPTER_INIT_FINISHED;
struct IDARG_IN_ADAPTER_INIT;
struct IDARG_OUT_ADAPTER_INIT;
struct IDDCX_MONITOR_DESCRIPTION;
struct IDDCX_MONITOR_INFO;
struct IDARG_IN_MONITORCREATE;
struct IDARG_OUT_MONITORCREATE;
struct IDARG_OUT_MONITORARRIVAL;
struct IDDCX_MONITOR_MODE;
struct IDARG_IN_PARSEMONITORDESCRIPTION;
struct IDARG_OUT_PARSEMONITORDESCRIPTION;
struct IDARG_IN_GETDEFAULTDESCRIPTIONMODES;
struct IDARG_OUT_GETDEFAULTDESCRIPTIONMODES;
struct IDDCX_TARGET_MODE;
struct IDARG_IN_QUERYTARGETMODES;
struct IDARG_OUT_QUERYTARGETMODES;
struct IDARG_IN_UPDATEMODES;
struct IDARG_IN_MAXDISPLAYPIPELINERATE;
struct IDDCX_PATH;
struct IDARG_IN_COMMITMODES;
struct IDDCX_CURSOR_CAPS;
struct IDARG_IN_SETUP_HWCURSOR;
struct IDDCX_CURSOR_SHAPE_INFO;
struct IDARG_IN_QUERY_HWCURSOR;
struct IDARG_OUT_QUERY_HWCURSOR;
struct IDARG_IN_SETSWAPCHAIN;
struct IDDCX_METADATA;
struct IDARG_IN_SWAPCHAINSETDEVICE;
struct IDARG_OUT_RELEASEANDACQUIREBUFFER;
struct IDARG_IN_GETDIRTYRECTS;
struct IDARG_OUT_GETDIRTYRECTS;
struct IDDCX_MOVEREGION;
struct IDARG_IN_GETMOVEREGIONS;
struct IDARG_OUT_GETMOVEREGIONS;
struct IDDCX_FRAME_STATISTICS_STEP;
struct IDDCX_FRAME_STATISTICS;
struct IDARG_IN_REPORTFRAMESTATISTICS;
struct IDARG_IN_I2C_TRANSMIT;
struct IDARG_IN_SET_GAMMARAMP;
struct IDARG_IN_I2C_RECEIVE;
struct IDARG_IN_OPM_GET_CERTIFICATE_SIZE;
struct IDARG_OUT_OPM_GET_CERTIFICATE_SIZE;
struct IDARG_IN_OPM_GET_CERTIFICATE;
struct IDARG_IN_OPM_CREATE_PROTECTED_OUTPUT;
struct IDDCX_OPM_GET_RANDOM_NUMBER;
struct IDARG_OUT_OPM_GET_RANDOM_NUMBER;
struct IDDCX_OPM_ENCRYPTED_INITIALIZATION_PARAMETERS;
struct IDARG_IN_OPM_SET_SIGNING_KEY_AND_SEQUENCE_NUMBERS;
struct IDARG_IN_OPM_GET_INFOMATION;
struct IDDCX_OPM_GET_INFO_PARAMETERS;
struct IDDCX_OPM_REQUESTED_INFORMATION;
struct IDARG_OUT_OPM_GET_INFOMATION;
struct IDDCX_OPM_CONFIGURE_PARAMETERS;
struct IDARG_IN_OPM_CONFIGURE_PROTECTED_OUTPUT;
struct IDARG_OUT_GETVERSION;
struct IDARG_IN_REPORTCRITICALERROR;
struct IDARG_IN_SETSRMLIST;
struct IDARG_IN_GETSRMLISTVERSION;
struct IDARG_OUT_GETSRMLISTVERSION;
struct IDARG_IN_ADAPTERSETRENDERADAPTER;
struct IDDCX_DISPLAYCONFIGPATH;
struct IDARG_IN_ADAPTERDISPLAYCONFIGUPDATE;
struct IDARG_OUT_MONITORGETPHYSICALSIZE;
struct IDDCX_SYSTEM_BUFFER_INFO;
struct IDARG_OUT_RELEASEANDACQUIRESYSTEMBUFFER;
#pragma endregion
#pragma region Driver Callback Definitions
#pragma region Device Callbacks
/// <summary>
/// Driver DDI function that is called by the OS when an IO control request needs processing by the driver.
/// </summary>
typedef
_Function_class_(EVT_IDD_CX_DEVICE_IO_CONTROL)
_IRQL_requires_same_
VOID
NTAPI
EVT_IDD_CX_DEVICE_IO_CONTROL(
_In_
WDFDEVICE Device,
_In_
WDFREQUEST Request,
_In_
size_t OutputBufferLength,
_In_
size_t InputBufferLength,
_In_
ULONG IoControlCode
);
typedef EVT_IDD_CX_DEVICE_IO_CONTROL *PFN_IDD_CX_DEVICE_IO_CONTROL;
/// <summary>
/// A driver DDI function that OS calls to request the driver to parse a monitor description into a list of modes
/// the monitor supports
/// </summary>
/// <param name="pInArgs">Input arguments of function</param>
/// <param name="pOutArgs">Output arguments of function</param>
/// <returns>If the routine succeeds it return STATUS_SUCCESS otherwise an appropriate error code</returns>
typedef
_Function_class_(EVT_IDD_CX_PARSE_MONITOR_DESCRIPTION)
_IRQL_requires_same_
NTSTATUS
NTAPI
EVT_IDD_CX_PARSE_MONITOR_DESCRIPTION(
_In_
const IDARG_IN_PARSEMONITORDESCRIPTION* pInArgs,
_Out_
IDARG_OUT_PARSEMONITORDESCRIPTION* pOutArgs
);
typedef EVT_IDD_CX_PARSE_MONITOR_DESCRIPTION *PFN_IDD_CX_PARSE_MONITOR_DESCRIPTION;
#pragma endregion
#pragma region Adapter Callbacks
/// <summary>
/// A driver DDI that is called by the OS to inform the driver that the adapter initialization has completed. The
/// initialization may have failed, so the driver should check the parameters for the adapter status and handle
/// failures appropriately (possibly by reporting a device failure).
/// </summary>
typedef
_Function_class_(EVT_IDD_CX_ADAPTER_INIT_FINISHED)
_IRQL_requires_same_
NTSTATUS
NTAPI
EVT_IDD_CX_ADAPTER_INIT_FINISHED(
_In_
IDDCX_ADAPTER AdapterObject,
_In_
const IDARG_IN_ADAPTER_INIT_FINISHED* pInArgs
);
typedef EVT_IDD_CX_ADAPTER_INIT_FINISHED *PFN_IDD_CX_ADAPTER_INIT_FINISHED;
/// <summary>
/// A driver DDI that is called by OS to inform the driver of a mode change for monitors on the adapter.
/// The OS always provides the IDDCX_PATH for every connected monitor even if it is not active and the OS
/// indicates which paths have changed. If a path is marked not active then we expect that whole display pipeline for
/// that path to be powered off and no signal is sent to the monitor
///
/// NOTE : When a new path is committed the driver should program the display pipeline to display a black
/// image until the first frame is ready to be displayed(ie WDDM visibility should be off until
/// first frame is ready to be displayed and then the visibility should be turned on).
/// </summary>
/// <param name="hDriverAdapterContext">The handle the driver provides so the OS can reference the adapter when calling the driver</param>
/// <param name="pInArgs">Input arguments of function</param>
/// <returns>If the routine succeeds it return STATUS_SUCCESS otherwise an appropriate error code</returns>
typedef
_Function_class_(EVT_IDD_CX_ADAPTER_COMMIT_MODES)
_IRQL_requires_same_
NTSTATUS
NTAPI
EVT_IDD_CX_ADAPTER_COMMIT_MODES(
_In_
IDDCX_ADAPTER AdapterObject,
_In_
const IDARG_IN_COMMITMODES* pInArgs
);
typedef EVT_IDD_CX_ADAPTER_COMMIT_MODES *PFN_IDD_CX_ADAPTER_COMMIT_MODES;
#pragma endregion
#pragma region Monitor Callbacks
/// <summary>
/// A driver DDI function that OS calls to request the driver provide the default monitor mode list for the
/// specified monitor. This DDI is called when a monitor without a description is connected.
/// </summary>
/// <param name="MonitorObject">The monitor object that is having default modes generated</param>
/// <param name="pInArgs">Input arguments of function</param>
/// <param name="pOutArgs">Output arguments of function</param>
/// <returns>If the routine succeeds it return STATUS_SUCCESS otherwise an appropriate error code</returns>
/// <remarks>
/// The driver must create at least one monitor mode for the monitor description.
/// </remarks>
typedef
_Function_class_(EVT_IDD_CX_MONITOR_GET_DEFAULT_DESCRIPTION_MODES)
_IRQL_requires_same_
NTSTATUS
NTAPI
EVT_IDD_CX_MONITOR_GET_DEFAULT_DESCRIPTION_MODES(
_In_
IDDCX_MONITOR MonitorObject,
_In_
const IDARG_IN_GETDEFAULTDESCRIPTIONMODES* pInArgs,
_Out_
IDARG_OUT_GETDEFAULTDESCRIPTIONMODES* pOutArgs
);
typedef EVT_IDD_CX_MONITOR_GET_DEFAULT_DESCRIPTION_MODES *PFN_IDD_CX_MONITOR_GET_DEFAULT_DESCRIPTION_MODES;
/// <summary>
/// A driver DDI function that OS calls to get a list of target modes supported by the driver for a monitor
/// connected to the endpoint.
/// </summary>
/// <param name="MonitorObject">The monitor object whose modes are being queried</param>
/// <param name="pInArgs">Input arguments of function</param>
/// <param name="pOutArgs">Output arguments of function</param>
/// <returns>If the routine succeeds it return STATUS_SUCCESS otherwise an appropriate error code</returns>
typedef
_Function_class_(EVT_IDD_CX_MONITOR_QUERY_TARGET_MODES)
_IRQL_requires_same_
NTSTATUS
NTAPI
EVT_IDD_CX_MONITOR_QUERY_TARGET_MODES(
_In_
IDDCX_MONITOR MonitorObject,
_In_
const IDARG_IN_QUERYTARGETMODES* pInArgs,
_Out_
IDARG_OUT_QUERYTARGETMODES* pOutArgs
);
typedef EVT_IDD_CX_MONITOR_QUERY_TARGET_MODES *PFN_IDD_CX_MONITOR_QUERY_TARGET_MODES;
/// <summary>
/// Driver DDI function that is called by OS inform the driver of a mode change for monitors on the adapter.
///
/// NOTE : The resolution of the surfaces in the swapchain will always be the same resolution as the target mode set and
/// format will be one of the formats supported by the driver but the format of each acquired buffer may
/// change frame to frame between the formats supported and the driver should check the format of each buffer acquired.
/// </summary>
/// <param name="hDriverAdapterContext">The handle the driver provides so the OS can reference the adapter when calling the driver</param>
/// <param name="pInArgs">Input arguments of function</param>
/// <returns>If the routine succeeds it return STATUS_SUCCESS otherwise an appropriate error code</returns>
typedef
_Function_class_(EVT_IDD_CX_MONITOR_ASSIGN_SWAPCHAIN)
_IRQL_requires_same_
NTSTATUS
NTAPI
EVT_IDD_CX_MONITOR_ASSIGN_SWAPCHAIN(
_In_
IDDCX_MONITOR MonitorObject,
_In_
const IDARG_IN_SETSWAPCHAIN* pInArgs
);
typedef EVT_IDD_CX_MONITOR_ASSIGN_SWAPCHAIN *PFN_IDD_CX_MONITOR_ASSIGN_SWAPCHAIN;
/// <summary>
/// Driver DDI function that is called by OS inform the driver that a swapchain associated with a monitor is not
/// valid anymore
/// </summary>
/// <param name="MonitorObject">The monitor whose swap-chain is no longer valid.</param>
/// <returns>If the routine succeeds it return STATUS_SUCCESS otherwise an appropriate error code</returns>
typedef
_Function_class_(EVT_IDD_CX_MONITOR_UNASSIGN_SWAPCHAIN)
_IRQL_requires_same_
NTSTATUS
NTAPI
EVT_IDD_CX_MONITOR_UNASSIGN_SWAPCHAIN(
_In_
IDDCX_MONITOR MonitorObject
);
typedef EVT_IDD_CX_MONITOR_UNASSIGN_SWAPCHAIN *PFN_IDD_CX_MONITOR_UNASSIGN_SWAPCHAIN;
/// <summary>
/// Driver DDI function that is called by OS to returns data received from an I2C device in a monitor
/// </summary>
/// <param name="MonitorObject">A handle to monitor object to send I2C data.</param>
/// <param name="pInArgs">Input arguments of function</param>
/// <returns>If the routine succeeds it return STATUS_SUCCESS otherwise an appropriate error code</returns>
/// <remarks>
/// The data is transmitted to an I2C device in the monitor that is connected to path specified by PathIdx
/// I2CTransmitDataToDisplay is responsible for signaling the I2C start condition, sending the I2C address, sending the
/// data in the buffer, checking for acknowledgments from the receiver, and signaling the stop condition.For details
/// about the I2C bus, see the I2C Bus Specification, published by Philips Semiconductors.The specification defines a
/// protocol for initiating I2C communication, reading and writing bytes over the I2C data line, and terminating I2C
/// communication.
///
/// I2CTransmitDataToDisplay is required to transmit data to an I2C device that has address 0x6E but is permitted to
/// refuse to transmit data to any I2C device that has a different address.
///
/// I2CTransmitDataToDisplay is permitted to block if another part of the display driver or graphics hardware is using
/// the specified monitor's I2C bus. It is also permitted to block if the display driver is using the I2C bus to send or
/// receive High-bandwidth Digital Content Protection (HDCP) data.
///
/// If the display adapter supports HDCP, the I2CTransmitDataToDisplay function must refuse to send data to an I2C device
/// if the device has an I2C address that is used by HDCP.
///
/// I2CTransmitDataToDisplay must never transmit data to an I2C device on the display adapter.That is, this function can
/// transmit data to an I2C device in a monitor that is connected to the display adapter, but not to an I2C device that
/// is on the display adapter itself.
/// </remarks>
typedef
_Function_class_(EVT_IDD_CX_MONITOR_I2C_TRANSMIT)
_IRQL_requires_same_
NTSTATUS
NTAPI
EVT_IDD_CX_MONITOR_I2C_TRANSMIT(
_In_
IDDCX_MONITOR MonitorObject,
_In_
const IDARG_IN_I2C_TRANSMIT* pInArgs
);
typedef EVT_IDD_CX_MONITOR_I2C_TRANSMIT *PFN_IDD_CX_MONITOR_I2C_TRANSMIT;
/// <summary>
/// Driver DDI function that is called by OS to returns data received from an I2C device in a monitor
/// </summary>
/// <param name="MonitorObject">A handle to monitor object to receive I2C data from.</param>
/// <param name="pInArgs">Input arguments of function</param>
/// <returns>If the routine succeeds it return STATUS_SUCCESS otherwise an appropriate error code</returns>
/// <remarks>
/// The data is received from an I2C device in the monitor that is connected to path specified by PathIdx
/// I2CReceiveDataFromDisplay function is responsible for signaling the I2C start condition, sending the I2C address,
/// receiving the data from the I2C device, sending acknowledgments, and signaling the stop condition.
/// For details about the I2C bus, see the I2C Bus Specification, published by Philips Semiconductors.
/// The specification defines a protocol for initiating I2C communication, reading and writing bytes over the I2C data
/// line, and terminating I2C communication. (This resource may not be available in some languages and countries.)
///
/// I2CReceiveDataFromDisplay is required to receive data from an I2C device that has address 0x6F but is
/// permitted to refuse to receive data from any I2C device that has a different address.
///
/// I2CReceiveDataFromDisplay is permitted to block if another part of the display driver or graphics hardware is
/// using the specified monitor's I2C bus. It is also permitted to block if the display driver is using the I2C
/// bus to send or receive High-bandwidth Digital Content Protection (HDCP) data.
///
/// If the display adapter supports HDCP, I2CReceiveDataFromDisplay must refuse to receive data from an I2C device if the
/// device has an I2C address that is used by HDCP.
///
/// I2CReceiveDataFromDisplay must never receive data from an I2C device on the display adapter.That is, this function
/// can receive data from an I2C device in a monitor that is connected to the display adapter, but not from an I2C
/// device that is on the display adapter itself.
/// </remarks>
typedef
_Function_class_(EVT_IDD_CX_MONITOR_I2C_RECEIVE)
_IRQL_requires_same_
NTSTATUS
NTAPI
EVT_IDD_CX_MONITOR_I2C_RECEIVE(
_In_
IDDCX_MONITOR MonitorObject,
_In_
const IDARG_IN_I2C_RECEIVE* pInArgs
);
typedef EVT_IDD_CX_MONITOR_I2C_RECEIVE *PFN_IDD_CX_MONITOR_I2C_RECEIVE;
/// <summary>
/// Driver DDI function that is called by OS to set a gamma ramp on the specified monitor
/// </summary>
/// <param name="MonitorObject">This is the context for the monitor this gamma call is intended for</param>
/// <param name="pInArgs">Input arguments of function</param>
/// <returns>If the routine succeeds it return STATUS_SUCCESS otherwise an appropriate error code</returns>
/// <remarks>
/// If the driver implements this DDI then this implies the driver support the gamma functionality
/// </remarks>
typedef
_Function_class_(EVT_IDD_CX_MONITOR_SET_GAMMA_RAMP)
_IRQL_requires_same_
NTSTATUS
NTAPI
EVT_IDD_CX_MONITOR_SET_GAMMA_RAMP(
_In_
IDDCX_MONITOR MonitorObject,
_In_
const IDARG_IN_SET_GAMMARAMP* pInArgs
);
typedef EVT_IDD_CX_MONITOR_SET_GAMMA_RAMP *PFN_IDD_CX_MONITOR_SET_GAMMA_RAMP;
/// <summary>
/// Driver DDI function that is called by OS to get the size of a OPM certificate
/// </summary>
/// <param name="AdapterObject">This is the context for the adapter this OPM call is intended for</param>
/// <param name="pInArgs">Input arguments of function</param>
/// <param name="pOutArgs">Output arguments of function</param>
/// <returns>If the routine succeeds it return STATUS_SUCCESS otherwise an appropriate error code</returns>
typedef
_Function_class_(EVT_IDD_CX_MONITOR_OPM_GET_CERTIFICATE_SIZE)
_IRQL_requires_same_
NTSTATUS
NTAPI
EVT_IDD_CX_MONITOR_OPM_GET_CERTIFICATE_SIZE(
_In_
IDDCX_ADAPTER AdapterObject,
_In_
const IDARG_IN_OPM_GET_CERTIFICATE_SIZE* pInArgs,
_Out_
IDARG_OUT_OPM_GET_CERTIFICATE_SIZE* pOutArgs
);
typedef EVT_IDD_CX_MONITOR_OPM_GET_CERTIFICATE_SIZE *PFN_IDD_CX_MONITOR_OPM_GET_CERTIFICATE_SIZE;
/// <summary>
/// Driver DDI function that is called by OS to get a OPM certificate
/// </summary>
/// <param name="AdapterObject">This is the context for the adapter this OPM call is intended for</param>
/// <param name="pInArgs">Input arguments of function</param>
/// <returns>If the routine succeeds it return STATUS_SUCCESS otherwise an appropriate error code</returns>
typedef
_Function_class_(EVT_IDD_CX_MONITOR_OPM_GET_CERTIFICATE)
_IRQL_requires_same_
NTSTATUS
NTAPI
EVT_IDD_CX_MONITOR_OPM_GET_CERTIFICATE(
_In_
IDDCX_ADAPTER AdapterObject,
_In_
const IDARG_IN_OPM_GET_CERTIFICATE* pInArgs
);
typedef EVT_IDD_CX_MONITOR_OPM_GET_CERTIFICATE *PFN_IDD_CX_MONITOR_OPM_GET_CERTIFICATE;
/// <summary>
/// Driver DDI function that is called by OS to create a OPM protected output context
/// </summary>
/// <param name="MonitorObject">This is the context for the monitor this OPM context should be created on</param>
/// <param name="OpmCxtObject">This is the context for the OPM context this call is for</param>
/// <param name="pInArgs">Input arguments of function</param>
/// <returns>If the routine succeeds it return STATUS_SUCCESS otherwise an appropriate error code</returns>
typedef
_Function_class_(EVT_IDD_CX_MONITOR_OPM_CREATE_PROTECTED_OUTPUT)
_IRQL_requires_same_
NTSTATUS
NTAPI
EVT_IDD_CX_MONITOR_OPM_CREATE_PROTECTED_OUTPUT(
_In_
IDDCX_MONITOR MonitorObject,
_In_
IDDCX_OPMCTX OpmCxtObject,
_In_
const IDARG_IN_OPM_CREATE_PROTECTED_OUTPUT* pInArgs
);
typedef EVT_IDD_CX_MONITOR_OPM_CREATE_PROTECTED_OUTPUT *PFN_IDD_CX_MONITOR_OPM_CREATE_PROTECTED_OUTPUT;
/// <summary>
/// Driver DDI function that is called by OS get a OPM random number
/// </summary>
/// <param name="OpmCxtObject">This is the context for the OPM context this call is for</param>
/// <param name="pInArgs">Input arguments of function</param>
/// <returns>If the routine succeeds it return STATUS_SUCCESS otherwise an appropriate error code</returns>
typedef
_Function_class_(EVT_IDD_CX_MONITOR_OPM_GET_RANDOM_NUMBER)
_IRQL_requires_same_
NTSTATUS
NTAPI
EVT_IDD_CX_MONITOR_OPM_GET_RANDOM_NUMBER(
_In_
IDDCX_OPMCTX OpmCxtObject,
_Out_
IDARG_OUT_OPM_GET_RANDOM_NUMBER* pOutArgs
);
typedef EVT_IDD_CX_MONITOR_OPM_GET_RANDOM_NUMBER *PFN_IDD_CX_MONITOR_OPM_GET_RANDOM_NUMBER;
/// <summary>
/// Driver DDI function that is called by OS to set signing key and sequence number
/// </summary>
/// <param name="OpmCxtObject">This is the context for the OPM context this call is for</param>
/// <param name="pInArgs">Input arguments of function</param>
/// <returns>If the routine succeeds it return STATUS_SUCCESS otherwise an appropriate error code</returns>
typedef
_Function_class_(EVT_IDD_CX_MONITOR_OPM_SET_SIGNING_KEY_AND_SEQUENCE_NUMBERS)
_IRQL_requires_same_
NTSTATUS
NTAPI
EVT_IDD_CX_MONITOR_OPM_SET_SIGNING_KEY_AND_SEQUENCE_NUMBERS(
_In_
IDDCX_OPMCTX OpmCxtObject,
_In_
const IDARG_IN_OPM_SET_SIGNING_KEY_AND_SEQUENCE_NUMBERS* pInArgs
);
typedef EVT_IDD_CX_MONITOR_OPM_SET_SIGNING_KEY_AND_SEQUENCE_NUMBERS *PFN_IDD_CX_MONITOR_OPM_SET_SIGNING_KEY_AND_SEQUENCE_NUMBERS;
/// <summary>
/// Driver DDI function that is called by OS to get OPM information
/// </summary>
/// <param name="OpmCxtObject">This is the context for the OPM context this call is for</param>
/// <param name="pInArgs">Input arguments of function</param>
/// <param name="pOutArgs">Output arguments of function</param>