//
// to build a version that does not support compression, commen out
// this define.
//
#define	COMPRESSION	1

// when we pick up a frame, the coherency layer tells us
// about the frame...
// !!!!! NOTE: This is NOT an enumeration !!!!!!
// Look carefully at the code before you change these values.
#define FRAME_NOT_COMPRESSED	   			0
#define FRAME_IS_FLUSH_FRAME	   			1
#define FRAME_NEEDS_DECOMPRESSION  			2
#define FRAME_NEEDS_DECOMPRESSION_FLUSHING  3

//
// Set LSB if SW compression is ON
//
#define	COMPRESSION_V1						1

typedef UCHAR		FRAME_TYPE;
typedef UCHAR		FRAME_TICKET;

//
// ISDN pads to 60, so we need 60-14 worth of data
// before it is worth it to compress it!  probably even more than that!
//
#define MINIMUM_COMPRESSED_PACKET_SIZE	(60-14)

#define COMPRESSED_HAS_REFERENCES	1
#define COMPRESSED_NO_REFERENCES	2
#define UNCOMPRESSED				3
#define COMPRESSED					4	// generic compressed

// BUG BUG should probably read this value from coherency code.
// we give one byte to coherency
#define COHERENCY_LENGTH 1

typedef ULONG  FRAME_ID;

// !!!! NOTE !!!!
// TransmittedUncompressed are the number of bytes that the compressor
// saw BEFORE attempting to compress the data (top end)
// TransmitCompressed is the bottom end of the compressor which
// is equal to the amount of bytes the compressor spat out (after compression)
// This only counts bytes that went THROUGH the compression mechanism
// Small frames and multi-cast frames (typically) do not get compressed.
typedef struct COMPRESSION_STATS COMPRESSION_STATS, *PCOMPRESSION_STATS;
struct COMPRESSION_STATS {
	ULONG		BytesTransmittedUncompressed;	// Compression info only
	ULONG		BytesReceivedUncompressed;      // Compression info only
	ULONG		BytesTransmittedCompressed;     // Compression info only
	ULONG		BytesReceivedCompressed;        // Compression info only
};

typedef struct ASYNC_CONNECTION ASYNC_CONNECTION, *PASYNC_CONNECTION;
typedef struct ASYNC_FRAME ASYNC_FRAME, *PASYNC_FRAME;

typedef
VOID
(*PCOHERENT_DONE_FUNC) (
    IN PASYNC_CONNECTION	pAsyncConnection,
    IN PASYNC_FRAME			pAsyncFrame);


struct ASYNC_CONNECTION {
	// For me..
	PVOID			pAsyncInfo;				// Back ptr.

	// For compression
	ULONG			CompressionLength;		// Length of Compression struct
	PVOID			CompressionContext;		// Ptr to the Compression struct

	COMPRESSION_STATS CompressionStats;

	// For coherency
	ULONG			CoherencyLength;		// Length of coherency struct
	PVOID			CoherencyContext;		// Ptr to coherency struct

	NDIS_SPIN_LOCK	CompMutex;				// Non-paged pool mutex

	// These two values hold the size requested by the compression
	// and coherent modules for their internal structures.
	ULONG	CompressStructSize;
	ULONG	CoherentStructSize;


};

struct ASYNC_FRAME {
//---------------------------------------------------------------------------
	// !!!!!!!! NOTE !!!!!!!!
	// The FrameListEntry field must be first to
	// dequeue things up properly so don't put anything
	// in front of it or suffer severe crashes.
	LIST_ENTRY		FrameListEntry;			// Used to queue up frames from
											// the soon to be famous frame pool
    // this frame's ID
	FRAME_ID		FrameID;

	// For Dougie
	// Should Decompressed Frame can be non-paged??
	// i.e. Should I queue a worker thred to decompress??
	UINT			DecompressedFrameLength;// Length of decompressed frame
	PUCHAR			DecompressedFrame;		// Ptr to the decompressed 'frame'
											// valid only after decompression

	// NOTE: If the frame is not compressed, the compressed fields
	// are still valid when passed to Dave.
	UINT			CompressedFrameLength;	// Length of compressed frame
	PUCHAR			CompressedFrame;		// Ptr to the compressed 'frame'
											// valid only after compression
											// or just before decompression

	PNDIS_PACKET	CompressionPacket;		// Valid just before compression	
											// this is the packet passed down.
											// Use NdisQueryPacket.

	PASYNC_CONNECTION	Connection;			// back ptr to connection struct

	// For Coherency
	PUCHAR			CoherencyFrame;			// Ptr to coherency frame
	PCOHERENT_DONE_FUNC	CoherentDone;		// function ptr to call when done
											// sending frame

};

// APIs to Compressor
VOID
CoherentDeliverFrame(
	PASYNC_CONNECTION	pConnection,
	PASYNC_FRAME		pFrame,
	FRAME_TYPE			FrameType);

VOID
CoherentGetPipeline(
	PASYNC_CONNECTION	pConnection,
	PULONG 				plUnsent);


// APIs to Transport/Network layer
VOID
CoherentSendFrame(
	PASYNC_CONNECTION	pConnection,
	PASYNC_FRAME		pFrame,
	FRAME_TYPE			FrameType);


ULONG
CoherentSizeOfStruct( );

VOID
CoherentInitStruct(
	PVOID				pCoherentStruct);

// upcalls API's from Transport/Network layer
VOID
CoherentReceiveFrame(
	PASYNC_CONNECTION	pConnection,
	PASYNC_FRAME		pFrame);

VOID
CoherentDeliverFrameDone(
	PASYNC_CONNECTION	pConnection,
	PASYNC_FRAME		pFrame);



ULONG
CompressSizeOfStruct(
	IN  ULONG			SendMode,	// Compression
	IN	ULONG			RecvMode, 	// Decompression
	IN  ULONG			lfsz,	// Largest frame size
	OUT PULONG			lcfsz);	// Size of compression into buffer

VOID
CompressInitStruct(
	ULONG				SendMode,	// Compression
	ULONG				RecvMode,	// Decompression
	PUCHAR				memptr,
	PNDIS_SPIN_LOCK		pMutex);	// Must be in non-paged pool

VOID
CompressFlush(
	PASYNC_CONNECTION	pAsyncConnection);

VOID
CompressFrame(
	PASYNC_FRAME		pAsyncFrame);

VOID
DecompressFrame(
	PASYNC_CONNECTION	pAsyncConnection,
	PASYNC_FRAME		pAsyncFrame,
	BOOLEAN				FlushBuffer);