/****************************************************************************/
// oe2.h
//
// Header for RDP field compression.
//
// Copyright (C) 1997-2000 Microsoft Corporation
/****************************************************************************/
#ifndef __OE2_H
#define __OE2_H


/****************************************************************************/
// Field compression (OE2) overview
//
// OE2 compression maintains a copy of each field value of the last order
// sent, plus other state information like the last bounding rectangle used
// and the last order type. OE2 encoding involves comparing a new display
// order to the last copy, and sending only the fields which have changed.
// Other specialized encoding occurs for certain fields declared to be of
// "coord" type, meaning that a one-byte delta can be sent instead of a
// 2-byte value, if the delta will fit into 8 bits.
//
// The wire format for OE2 encoded orders consists of the following fields:
//
// +------------+------+-------------+--------+----------------+
// | Ctrl flags | Type | Field flags | Bounds | Encoded Fields |
// +------------+------+-------------+--------+----------------+
//
// Control flags: Required byte, corresponding to a TS_ORDER_HEADER and
//     available flags. Always contains at least TS_STANDARD flag. These
//     flags describe the following encoding; flag meanings are discussed
//     below.
//
// Type: If TS_TYPE_CHANGE is present in the control flags, this is a one-
//     byte order type value. The initial value agreed-on by both server
//     and client is TS_ENC_PATBLT_ORDER.
//
// Field flags: One or more bytes, where the number of bytes is ceil(((number
//     of order fields) + 1) / 8). The "+ 1" in that equation is historical
//     and means that the first byte of field flags can only encompass 7
//     flag bits. The presence of these flags is also governed by the control
//     flags TS_ZERO_FIELD_BYTE_BIT0 and TS_ZERO_FIELD_BYTE_BIT1
//     (see at128.h description). The ordering of the bytes is as a DWORD
//     -- the low order byte is first. The field flags indicate the presence
//     of an order field in the encoded fields portion of the packet.
//     The ordering of the flags proceeds from 0x01 corresponding to the
//     first order field, 0x02 the second, 0x04 the third, etc.
//
// Bounds: The presence of this field is governed by the TS_BOUNDS control
//     flag, which indicates the order must have a bounding region applied.
//     If control flag TS_ZERO_BOUNDS_DELTAS is set, the bound rect to be
//     used is the same as the last bound rect used. Otherwise, the
//     bounds are encoded as an encoding description byte followed by one
//     or more encoded bounds. The description byte contains two flags
//     for each of the left, top, right, and bottom rect components.
//     One flag (TS_BOUND_XXX) indicates that the component is present
//     and encoded as a 2-byte Intel-ordering value. The other flag
//     (TS_BOUND_DELTA_XXX) indicates the component is present and encoded
//     as a one-byte value used as an offset (-128 to 127) from the previous
//     value of the component. If neither flag is present the component
//     value is the same as used last. The initial value for the bounds
//     agreed-on by both server and client is the zero rect (0, 0, 0, 0).
//
// Encoded fields: These are the encoded order field values whose presence
//     is governed by the field flags. The fields are encoded in order if
//     present. The control flag TS_DELTA_COORDINATES is set if all COORD
//     type fields in the order can be specified as a one-byte delta from
//     their last values. If a field is not present its value is the same
//     as the last value sent. The initial values the client and server
//     use for all fields is zero. See the order field description tables in
//     noe2disp.c for specific order information.
/****************************************************************************/


/****************************************************************************/
// Defines
/****************************************************************************/
#define MAX_BOUNDS_ENCODE_SIZE 9
#define MAX_REPLAY_CLIPPED_ORDER_SIZE (1 + MAX_BOUNDS_ENCODE_SIZE)

#define OE2_CONTROL_FLAGS_FIELD_SIZE    1
#define OE2_TYPE_FIELD_SIZE             1
#define OE2_MAX_FIELD_FLAG_BYTES        3

#define MAX_ENCODED_ORDER_PREFIX_BYTES (OE2_CONTROL_FLAGS_FIELD_SIZE +  \
        OE2_TYPE_FIELD_SIZE + OE2_MAX_FIELD_FLAG_BYTES +  \
        MAX_BOUNDS_ENCODE_SIZE)

// Max size: 1 control flag + 1 type change byte + num field flag bytes +
// 9 bounds bytes + fields.
#define MAX_ORDER_SIZE(_NumRects, _NumFieldFlagBytes, _MaxFieldSize) \
        (2 + (_NumFieldFlagBytes) + ((_NumRects == 0) ? 0 : 9) +  \
        (_MaxFieldSize))


/****************************************************************************/
// Types
/****************************************************************************/

// INT_FMT_FIELD: Const data definitions for table-based OE2 order translation.
// Describes the source intermediate and destination wire data formats.
//
// FieldPos: Byte offset into the source intermediate format for the field.
// FieldUnencodedLen: Length of the source field.
// FieldEncodedLen: Length of the destination field (wore format).
// FieldSigned: Flag for signed field value.
// FieldType: Descriptor that specifies how to translate the field.
typedef struct
{
    unsigned FieldPos;
    unsigned FieldUnencodedLen;
    unsigned FieldEncodedLen;
    BOOL     FieldSigned;
    unsigned FieldType;
} INT_FMT_FIELD;
typedef INT_FMT_FIELD const *PINT_FMT_FIELD;


/****************************************************************************/
// Prototypes and inlines
/****************************************************************************/
void OE2_Reset(void);
void OE2_EncodeBounds(BYTE *, BYTE **, RECTL *);
unsigned OE2_CheckZeroFlagBytes(BYTE *, BYTE *, unsigned, unsigned);
void OE2_TableEncodeOrderFields(BYTE *, PUINT32_UA, BYTE **, PINT_FMT_FIELD,
        unsigned, BYTE *, BYTE *);
unsigned OE2_EncodeOrder(BYTE *, unsigned, unsigned, BYTE *, BYTE *,
        PINT_FMT_FIELD, RECTL *);


/****************************************************************************/
// OE2_EncodeOrderType
//
// Used by order encoding paths to encode the order type byte if different
// from the last order.
//
// void OE2_EncodeOrderType(
//         BYTE *pControlFlags,
//         BYTE **ppBuffer,
//         unsigned OrderType);
/****************************************************************************/
#define OE2_EncodeOrderType(_pControlFlags, _ppBuffer, _OrderType)  \
{  \
    if (oe2LastOrderType != (_OrderType)) {  \
        *(_pControlFlags) |= TS_TYPE_CHANGE;  \
        **(_ppBuffer) = (BYTE)(_OrderType);  \
        (*(_ppBuffer))++;  \
        oe2LastOrderType = (_OrderType);  \
    }  \
}


/****************************************************************************/
// OE2_CheckOneZeroFlagByte
//
// 1-field-flag-byte version of OE2_CheckZeroFlagBytes(), optimizes out the
// generalized loop.
/****************************************************************************/
__inline unsigned OE2_CheckOneZeroFlagByte(
        BYTE *pControlFlags,
        BYTE *pFieldFlag,
        unsigned PostFlagsDataLength)
{
    if (*pFieldFlag != 0) {
        return 0;
    }
    else {
        *pControlFlags |= (1 << TS_ZERO_FIELD_COUNT_SHIFT);
        memmove(pFieldFlag, pFieldFlag + 1, PostFlagsDataLength);
        return 1;
    }
}


/****************************************************************************/
// OE2_CheckTwoZeroFlagBytes
//
// 2-field-flag-byte version of OE2_CheckZeroFlagBytes(), optimizes out the
// generalized loop.
/****************************************************************************/
__inline unsigned OE2_CheckTwoZeroFlagBytes(
        BYTE *pControlFlags,
        BYTE *pFieldFlags,
        unsigned PostFlagsDataLength)
{
    if (pFieldFlags[1] != 0) {
        return 0;
    }
    else if (pFieldFlags[0] != 0) {
        *pControlFlags |= (1 << TS_ZERO_FIELD_COUNT_SHIFT);
        memmove(pFieldFlags + 1, pFieldFlags + 2, PostFlagsDataLength);
        return 1;
    }
    else {
        *pControlFlags |= (2 << TS_ZERO_FIELD_COUNT_SHIFT);
        memmove(pFieldFlags, pFieldFlags + 2, PostFlagsDataLength);
        return 2;
    }
}


/****************************************************************************/
// OE2_EmitClippedReplayOrder
//
// Creates a "play-it-again" order -- same order type and all fields
// the same as previous, except with a different bound rect.
//
// void OE2_EmitClippedReplayOrder(
//         BYTE **ppBuffer,
//         unsigned NumFieldFlagBytes,
//         RECTL *pClipRect)
/****************************************************************************/
#define OE2_EmitClippedReplayOrder(_ppBuffer, _NumFieldFlagBytes, _pClipRect) \
{  \
    BYTE *pBuffer = *(_ppBuffer);  \
\
    /* Control flags are primary order plus all field flags bytes zero. */  \
    *pBuffer++ = TS_STANDARD | TS_BOUNDS |  \
            ((_NumFieldFlagBytes) << TS_ZERO_FIELD_COUNT_SHIFT);  \
\
    /* Construct the new bounds rect just after this. */  \
    OE2_EncodeBounds(pBuffer - 1, &pBuffer, (_pClipRect));  \
\
    *(_ppBuffer) = pBuffer;  \
}



#endif  // __OE2_H