cs.h

freescale i.mx31 BSP CE5.0全部源码

//
// old Framing structure
//
typedef struct {
    union {
        ULONG       OptionsFlags;       // allocator options (create)
        ULONG       RequirementsFlags;  // allocation requirements (query)
    };
#if defined(_NTDDK_)
    POOL_TYPE   PoolType;
#else // !_NTDDK_
    ULONG       PoolType;
#endif // !_NTDDK_
    ULONG       Frames;     // total number of allowable outstanding frames
    ULONG       FrameSize;  // total size of frame
    ULONG       FileAlignment;
    ULONG       Reserved;
} CSALLOCATOR_FRAMING, *PCSALLOCATOR_FRAMING;

#ifndef UNDER_CE
#if defined(_NTDDK_)
typedef
PVOID
(*PFNCSDEFAULTALLOCATE)(
    IN PVOID Context
    );

typedef
VOID
(*PFNCSDEFAULTFREE)(
    IN PVOID Context,
    IN PVOID Buffer
    );

typedef
NTSTATUS
(*PFNCSINITIALIZEALLOCATOR)(
    IN PVOID InitialContext,
    IN PCSALLOCATOR_FRAMING AllocatorFraming,
    OUT PVOID* Context
    );

typedef
VOID
(*PFNCSDELETEALLOCATOR)(
    IN PVOID Context
    );
#endif // !_NTDDK_

#endif //#ifndef UNDER_CE

//
// new Framing structure, eventually will replace CSALLOCATOR_FRAMING.
// 
typedef struct {
    ULONG   MinFrameSize;
    ULONG   MaxFrameSize;
    ULONG   Stepping;
} CS_FRAMING_RANGE, *PCS_FRAMING_RANGE;


typedef struct {
    CS_FRAMING_RANGE  Range;
    ULONG             InPlaceWeight;
    ULONG             NotInPlaceWeight;
} CS_FRAMING_RANGE_WEIGHTED, *PCS_FRAMING_RANGE_WEIGHTED;


typedef struct {
    ULONG   RatioNumerator;      // compression/expansion ratio
    ULONG   RatioDenominator; 
    ULONG   RatioConstantMargin;
} CS_COMPRESSION, *PCS_COMPRESSION;


//
// Memory Types and Buses are repeated in each entry.
// Easiest to use but takes a little more memory than the varsize layout Pin\Memories\Buses\Ranges.
//
typedef struct {
    GUID                        MemoryType;
    GUID                        BusType;
    ULONG                       MemoryFlags;
    ULONG                       BusFlags;   
    ULONG                       Flags;   
    ULONG                       Frames;              // total number of allowable outstanding frames
    ULONG                       FileAlignment;
    ULONG                       MemoryTypeWeight;    // this memory type Weight pin-wide
    CS_FRAMING_RANGE            PhysicalRange;
    CS_FRAMING_RANGE_WEIGHTED   FramingRange; 
} CS_FRAMING_ITEM, *PCS_FRAMING_ITEM;


typedef struct {
    ULONG               CountItems;         // count of FramingItem-s below.
    ULONG               PinFlags;
    CS_COMPRESSION      OutputCompression;
    ULONG               PinWeight;          // this pin framing's Weight graph-wide
    CS_FRAMING_ITEM     FramingItem[1]; 
} CSALLOCATOR_FRAMING_EX, *PCSALLOCATOR_FRAMING_EX;


#ifndef UNDER_CE
//
// define memory type GUIDs
//
#define CSMEMORY_TYPE_WILDCARD          GUID_NULL
#define STATIC_CSMEMORY_TYPE_WILDCARD   STATIC_GUID_NULL

#define CSMEMORY_TYPE_DONT_CARE         GUID_NULL
#define STATIC_CSMEMORY_TYPE_DONT_CARE  STATIC_GUID_NULL

#define CS_TYPE_DONT_CARE           GUID_NULL
#define STATIC_CS_TYPE_DONT_CARE    STATIC_GUID_NULL
     
#define STATIC_CSMEMORY_TYPE_SYSTEM \
    0x091bb638L, 0x603f, 0x11d1, 0xb0, 0x67, 0x00, 0xa0, 0xc9, 0x06, 0x28, 0x02
DEFINE_GUIDSTRUCT("091bb638-603f-11d1-b067-00a0c9062802", CSMEMORY_TYPE_SYSTEM);
#define CSMEMORY_TYPE_SYSTEM  DEFINE_GUIDNAMED(CSMEMORY_TYPE_SYSTEM)

#define STATIC_CSMEMORY_TYPE_USER \
    0x8cb0fc28L, 0x7893, 0x11d1, 0xb0, 0x69, 0x00, 0xa0, 0xc9, 0x06, 0x28, 0x02
DEFINE_GUIDSTRUCT("8cb0fc28-7893-11d1-b069-00a0c9062802", CSMEMORY_TYPE_USER);
#define CSMEMORY_TYPE_USER  DEFINE_GUIDNAMED(CSMEMORY_TYPE_USER)

#define STATIC_CSMEMORY_TYPE_KERNEL_PAGED \
    0xd833f8f8L, 0x7894, 0x11d1, 0xb0, 0x69, 0x00, 0xa0, 0xc9, 0x06, 0x28, 0x02
DEFINE_GUIDSTRUCT("d833f8f8-7894-11d1-b069-00a0c9062802", CSMEMORY_TYPE_KERNEL_PAGED);
#define CSMEMORY_TYPE_KERNEL_PAGED  DEFINE_GUIDNAMED(CSMEMORY_TYPE_KERNEL_PAGED)

#define STATIC_CSMEMORY_TYPE_KERNEL_NONPAGED \
    0x4a6d5fc4L, 0x7895, 0x11d1, 0xb0, 0x69, 0x00, 0xa0, 0xc9, 0x06, 0x28, 0x02
DEFINE_GUIDSTRUCT("4a6d5fc4-7895-11d1-b069-00a0c9062802", CSMEMORY_TYPE_KERNEL_NONPAGED);
#define CSMEMORY_TYPE_KERNEL_NONPAGED  DEFINE_GUIDNAMED(CSMEMORY_TYPE_KERNEL_NONPAGED)

// old CS clients did not specify the device memory type
#define STATIC_CSMEMORY_TYPE_DEVICE_UNKNOWN \
    0x091bb639L, 0x603f, 0x11d1, 0xb0, 0x67, 0x00, 0xa0, 0xc9, 0x06, 0x28, 0x02
DEFINE_GUIDSTRUCT("091bb639-603f-11d1-b067-00a0c9062802", CSMEMORY_TYPE_DEVICE_UNKNOWN);
#define CSMEMORY_TYPE_DEVICE_UNKNOWN DEFINE_GUIDNAMED(CSMEMORY_TYPE_DEVICE_UNKNOWN)

#endif //#ifndef UNDER_CE

//
// Helper framing macros.
//
#define DECLARE_SIMPLE_FRAMING_EX(FramingExName, MemoryType, Flags, Frames, Alignment, MinFrameSize, MaxFrameSize) \
    const CSALLOCATOR_FRAMING_EX FramingExName = \
    {\
        1, \
        0, \
        {\
            1, \
            1, \
            0 \
        }, \
        0, \
        {\
            {\
                MemoryType, \
                STATIC_CS_TYPE_DONT_CARE, \
                0, \
                0, \
                Flags, \
                Frames, \
                Alignment, \
                0, \
                {\
                    0, \
                    (ULONG)-1, \
                    1 \
                }, \
                {\
                    {\
                        MinFrameSize, \
                        MaxFrameSize, \
                        1 \
                    }, \
                    0, \
                    0  \
                }\
            }\
        }\
    }

#define SetDefaultCsCompression(CsCompressionPointer) \
{\
    CsCompressionPointer->RatioNumerator = 1;\
    CsCompressionPointer->RatioDenominator = 1;\
    CsCompressionPointer->RatioConstantMargin = 0;\
}

#define SetDontCareCsFramingRange(CsFramingRangePointer) \
{\
    CsFramingRangePointer->MinFrameSize = 0;\
    CsFramingRangePointer->MaxFrameSize = (ULONG) -1;\
    CsFramingRangePointer->Stepping = 1;\
}

#define SetCsFramingRange(CsFramingRangePointer, P_MinFrameSize, P_MaxFrameSize) \
{\
    CsFramingRangePointer->MinFrameSize = P_MinFrameSize;\
    CsFramingRangePointer->MaxFrameSize = P_MaxFrameSize;\
    CsFramingRangePointer->Stepping = 1;\
}

#define SetCsFramingRangeWeighted(CsFramingRangeWeightedPointer, P_MinFrameSize, P_MaxFrameSize) \
{\
    CS_FRAMING_RANGE *CsFramingRange = &CsFramingRangeWeightedPointer->Range;\
    SetCsFramingRange(CsFramingRange, P_MinFrameSize, P_MaxFrameSize);\
    CsFramingRangeWeightedPointer->InPlaceWeight = 0;\
    CsFramingRangeWeightedPointer->NotInPlaceWeight = 0;\
}

#define INITIALIZE_SIMPLE_FRAMING_EX(FramingExPointer, P_MemoryType, P_Flags, P_Frames, P_Alignment, P_MinFrameSize, P_MaxFrameSize) \
{\
    CS_COMPRESSION *CsCompression = &FramingExPointer->OutputCompression;\
    CS_FRAMING_RANGE *CsFramingRange = &FramingExPointer->FramingItem[0].PhysicalRange;\
    CS_FRAMING_RANGE_WEIGHTED *CsFramingRangeWeighted = &FramingExPointer->FramingItem[0].FramingRange;\
    FramingExPointer->CountItems = 1;\
    FramingExPointer->PinFlags = 0;\
    SetDefaultCsCompression(CsCompression);\
    FramingExPointer->PinWeight = 0;\
    FramingExPointer->FramingItem[0].MemoryType = P_MemoryType;\
    FramingExPointer->FramingItem[0].BusType = CS_TYPE_DONT_CARE;\
    FramingExPointer->FramingItem[0].MemoryFlags = 0;\
    FramingExPointer->FramingItem[0].BusFlags = 0;\
    FramingExPointer->FramingItem[0].Flags = P_Flags;\
    FramingExPointer->FramingItem[0].Frames = P_Frames;\
    FramingExPointer->FramingItem[0].FileAlignment = P_Alignment;\
    FramingExPointer->FramingItem[0].MemoryTypeWeight = 0;\
    SetDontCareCsFramingRange(CsFramingRange);\
    SetCsFramingRangeWeighted(CsFramingRangeWeighted, P_MinFrameSize, P_MaxFrameSize);\
}


#ifndef UNDER_CE
// CSEVENTSETID_StreamAllocator: {75D95571-073C-11d0-A161-0020AFD156E4}

#define STATIC_CSEVENTSETID_StreamAllocator\
    0x75d95571L, 0x073c, 0x11d0, 0xa1, 0x61, 0x00, 0x20, 0xaf, 0xd1, 0x56, 0xe4
DEFINE_GUIDSTRUCT("75d95571-073c-11d0-a161-0020afd156e4", CSEVENTSETID_StreamAllocator);
#define CSEVENTSETID_StreamAllocator DEFINE_GUIDNAMED(CSEVENTSETID_StreamAllocator)

typedef enum {
    CSEVENT_STREAMALLOCATOR_INTERNAL_FREEFRAME,
    CSEVENT_STREAMALLOCATOR_FREEFRAME
} CSEVENT_STREAMALLOCATOR;

#define STATIC_CSMETHODSETID_StreamAllocator\
    0xcf6e4341L, 0xec87, 0x11cf, 0xa1, 0x30, 0x00, 0x20, 0xaf, 0xd1, 0x56, 0xe4
DEFINE_GUIDSTRUCT("cf6e4341-ec87-11cf-a130-0020afd156e4", CSMETHODSETID_StreamAllocator);
#define CSMETHODSETID_StreamAllocator DEFINE_GUIDNAMED(CSMETHODSETID_StreamAllocator)

typedef enum {
    CSMETHOD_STREAMALLOCATOR_ALLOC,
    CSMETHOD_STREAMALLOCATOR_FREE
} CSMETHOD_STREAMALLOCATOR;

#define DEFINE_CSMETHOD_ITEM_STREAMALLOCATOR_ALLOC(Handler)\
    DEFINE_CSMETHOD_ITEM(\
        CSMETHOD_STREAMALLOCATOR_ALLOC,\
        CSMETHOD_TYPE_WRITE,\
        (Handler),\
        sizeof(CSMETHOD),\
        sizeof(PVOID),\
        NULL)

#define DEFINE_CSMETHOD_ITEM_STREAMALLOCATOR_FREE(Handler)\
    DEFINE_CSMETHOD_ITEM(\
        CSMETHOD_STREAMALLOCATOR_FREE,\
        CSMETHOD_TYPE_READ,\
        (Handler),\
        sizeof(CSMETHOD),\
        sizeof(PVOID),\
        NULL)

#define DEFINE_CSMETHOD_ALLOCATORSET(AllocatorSet, MethodAlloc, MethodFree)\
DEFINE_CSMETHOD_TABLE(AllocatorSet) {\
    DEFINE_CSMETHOD_ITEM_STREAMALLOCATOR_ALLOC(MethodAlloc),\
    DEFINE_CSMETHOD_ITEM_STREAMALLOCATOR_FREE(MethodFree)\
}

#define STATIC_CSPROPSETID_StreamAllocator\
    0xcf6e4342L, 0xec87, 0x11cf, 0xa1, 0x30, 0x00, 0x20, 0xaf, 0xd1, 0x56, 0xe4
DEFINE_GUIDSTRUCT("cf6e4342-ec87-11cf-a130-0020afd156e4", CSPROPSETID_StreamAllocator);
#define CSPROPSETID_StreamAllocator DEFINE_GUIDNAMED(CSPROPSETID_StreamAllocator)

#if defined(_NTDDK_)
typedef enum {
    CSPROPERTY_STREAMALLOCATOR_FUNCTIONTABLE,
    CSPROPERTY_STREAMALLOCATOR_STATUS
} CSPROPERTY_STREAMALLOCATOR;

#define DEFINE_CSPROPERTY_ITEM_STREAMALLOCATOR_FUNCTIONTABLE(Handler)\
    DEFINE_CSPROPERTY_ITEM(\
        CSPROPERTY_STREAMALLOCATOR_FUNCTIONTABLE,\
        (Handler),\
        sizeof(CSPROPERTY),\
        sizeof(CSSTREAMALLOCATOR_FUNCTIONTABLE),\
        NULL, NULL, 0, NULL, NULL, 0)
        
#define DEFINE_CSPROPERTY_ITEM_STREAMALLOCATOR_STATUS(Handler)\
    DEFINE_CSPROPERTY_ITEM(\
        CSPROPERTY_STREAMALLOCATOR_STATUS,\
        (Handler),\
        sizeof(CSPROPERTY),\
        sizeof(CSSTREAMALLOCATOR_STATUS),\
        NULL, NULL, 0, NULL, NULL, 0)

#define DEFINE_CSPROPERTY_ALLOCATORSET(AllocatorSet, PropFunctionTable, PropStatus)\
DEFINE_CSPROPERTY_TABLE(AllocatorSet) {\
    DEFINE_CSPROPERTY_ITEM_STREAMALLOCATOR_STATUS(PropStatus),\
    DEFINE_CSPROPERTY_ITEM_STREAMALLOCATOR_FUNCTIONTABLE(PropFunctionTable)\
}

typedef
NTSTATUS
(*PFNALLOCATOR_ALLOCATEFRAME)(
    IN PFILE_OBJECT FileObject,
    PVOID *Frame
    );

typedef
VOID
(*PFNALLOCATOR_FREEFRAME)(
    IN PFILE_OBJECT FileObject,
    IN PVOID Frame
    );

typedef struct {
    PFNALLOCATOR_ALLOCATEFRAME  AllocateFrame;
    PFNALLOCATOR_FREEFRAME      FreeFrame;
} CSSTREAMALLOCATOR_FUNCTIONTABLE, *PCSSTREAMALLOCATOR_FUNCTIONTABLE;
#endif // defined(_NTDDK_)

typedef struct {
    CSALLOCATOR_FRAMING Framing;
    ULONG               AllocatedFrames;
    ULONG               Reserved;
} CSSTREAMALLOCATOR_STATUS, *PCSSTREAMALLOCATOR_STATUS;

typedef struct {
    CSALLOCATOR_FRAMING_EX Framing;
    ULONG                  AllocatedFrames;
    ULONG                  Reserved;
} CSSTREAMALLOCATOR_STATUS_EX, *PCSSTREAMALLOCATOR_STATUS_EX;

#endif //#ifndef UNDER_CE

#define CSSTREAM_HEADER_OPTIONSF_SPLICEPOINT        0x00000001
#define CSSTREAM_HEADER_OPTIONSF_PREROLL            0x00000002
#define CSSTREAM_HEADER_OPTIONSF_DATADISCONTINUITY  0x00000004
#define CSSTREAM_HEADER_OPTIONSF_TYPECHANGED        0x00000008
#define CSSTREAM_HEADER_OPTIONSF_TIMEVALID          0x00000010
#define CSSTREAM_HEADER_OPTIONSF_TIMEDISCONTINUITY  0x00000040
#define CSSTREAM_HEADER_OPTIONSF_FLUSHONPAUSE       0x00000080
#define CSSTREAM_HEADER_OPTIONSF_DURATIONVALID      0x00000100
#define CSSTREAM_HEADER_OPTIONSF_ENDOFSTREAM        0x00000200
#define CSSTREAM_HEADER_OPTIONSF_LOOPEDDATA         0x80000000

typedef struct {
    LONGLONG    Time;
    ULONG       Numerator;
    ULONG       Denominator;
} CSTIME, *PCSTIME;


typedef struct {
    ULONG       Size;
    ULONG       TypeSpecificFlags;
    CSTIME      PresentationTime;
    LONGLONG    Duration;
    ULONG       FrameExtent;
    ULONG       DataUsed;
    PVOID       Data;
    ULONG       OptionsFlags;
#if _WIN64
    ULONG       Reserved;
#endif
} CSSTREAM_HEADER, *PCSSTREAM_HEADER;

#ifndef UNDER_CE
#define STATIC_CSPROPSETID_StreamInterface\
    0x1fdd8ee1L, 0x9cd3, 0x11d0, 0x82, 0xaa, 0x00, 0x00, 0xf8, 0x22, 0xfe, 0x8a
DEFINE_GUIDSTRUCT("1fdd8ee1-9cd3-11d0-82aa-0000f822fe8a", CSPROPSETID_StreamInterface);
#define CSPROPSETID_StreamInterface DEFINE_GUIDNAMED(CSPROPSETID_StreamInterface)