BaseTools: Add DevicePath support for PCD values

[mirror_edk2.git] / BaseTools / Source / C / BrotliCompress / enc / command.h

/* Copyright 2013 Google Inc. All Rights Reserved.\r
\r
   Distributed under MIT license.\r
   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT\r
*/\r
\r
/* This class models a sequence of literals and a backward reference copy. */\r
\r
#ifndef BROTLI_ENC_COMMAND_H_\r
#define BROTLI_ENC_COMMAND_H_\r
\r
#include "../common/types.h"\r
#include "../common/port.h"\r
#include "./fast_log.h"\r
#include "./prefix.h"\r
\r
#if defined(__cplusplus) || defined(c_plusplus)\r
extern "C" {\r
#endif\r
\r
static uint32_t kInsBase[] =   { 0, 1, 2, 3, 4, 5, 6, 8, 10, 14, 18, 26, 34, 50,\r
    66, 98, 130, 194, 322, 578, 1090, 2114, 6210, 22594 };\r
static uint32_t kInsExtra[] =  { 0, 0, 0, 0, 0, 0, 1, 1,  2,  2,  3,  3,  4,  4,\r
    5,   5,   6,   7,   8,   9,   10,   12,   14,    24 };\r
static uint32_t kCopyBase[] =  { 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 18, 22, 30,\r
    38, 54,  70, 102, 134, 198, 326,   582, 1094,  2118 };\r
static uint32_t kCopyExtra[] = { 0, 0, 0, 0, 0, 0, 0, 0,  1,  1,  2,  2,  3,  3,\r
     4,  4,   5,   5,   6,   7,   8,     9,   10,    24 };\r
\r
static BROTLI_INLINE uint16_t GetInsertLengthCode(size_t insertlen) {\r
  if (insertlen < 6) {\r
    return (uint16_t)insertlen;\r
  } else if (insertlen < 130) {\r
    uint32_t nbits = Log2FloorNonZero(insertlen - 2) - 1u;\r
    return (uint16_t)((nbits << 1) + ((insertlen - 2) >> nbits) + 2);\r
  } else if (insertlen < 2114) {\r
    return (uint16_t)(Log2FloorNonZero(insertlen - 66) + 10);\r
  } else if (insertlen < 6210) {\r
    return 21u;\r
  } else if (insertlen < 22594) {\r
    return 22u;\r
  } else {\r
    return 23u;\r
  }\r
}\r
\r
static BROTLI_INLINE uint16_t GetCopyLengthCode(size_t copylen) {\r
  if (copylen < 10) {\r
    return (uint16_t)(copylen - 2);\r
  } else if (copylen < 134) {\r
    uint32_t nbits = Log2FloorNonZero(copylen - 6) - 1u;\r
    return (uint16_t)((nbits << 1) + ((copylen - 6) >> nbits) + 4);\r
  } else if (copylen < 2118) {\r
    return (uint16_t)(Log2FloorNonZero(copylen - 70) + 12);\r
  } else {\r
    return 23u;\r
  }\r
}\r
\r
static BROTLI_INLINE uint16_t CombineLengthCodes(\r
    uint16_t inscode, uint16_t copycode, BROTLI_BOOL use_last_distance) {\r
  uint16_t bits64 =\r
      (uint16_t)((copycode & 0x7u) | ((inscode & 0x7u) << 3));\r
  if (use_last_distance && inscode < 8 && copycode < 16) {\r
    return (copycode < 8) ? bits64 : (bits64 | 64);\r
  } else {\r
    /* "To convert an insert-and-copy length code to an insert length code and\r
       a copy length code, the following table can be used" */\r
    static const uint16_t cells[9] = { 128u, 192u, 384u, 256u, 320u, 512u,\r
                                       448u, 576u, 640u };\r
    return cells[(copycode >> 3) + 3 * (inscode >> 3)] | bits64;\r
  }\r
}\r
\r
static BROTLI_INLINE void GetLengthCode(size_t insertlen, size_t copylen,\r
                                        BROTLI_BOOL use_last_distance,\r
                                        uint16_t* code) {\r
  uint16_t inscode = GetInsertLengthCode(insertlen);\r
  uint16_t copycode = GetCopyLengthCode(copylen);\r
  *code = CombineLengthCodes(inscode, copycode, use_last_distance);\r
}\r
\r
static BROTLI_INLINE uint32_t GetInsertBase(uint16_t inscode) {\r
  return kInsBase[inscode];\r
}\r
\r
static BROTLI_INLINE uint32_t GetInsertExtra(uint16_t inscode) {\r
  return kInsExtra[inscode];\r
}\r
\r
static BROTLI_INLINE uint32_t GetCopyBase(uint16_t copycode) {\r
  return kCopyBase[copycode];\r
}\r
\r
static BROTLI_INLINE uint32_t GetCopyExtra(uint16_t copycode) {\r
  return kCopyExtra[copycode];\r
}\r
\r
typedef struct Command {\r
  uint32_t insert_len_;\r
  /* Stores copy_len in low 24 bits and copy_len XOR copy_code in high 8 bit. */\r
  uint32_t copy_len_;\r
  uint32_t dist_extra_;\r
  uint16_t cmd_prefix_;\r
  uint16_t dist_prefix_;\r
} Command;\r
\r
/* distance_code is e.g. 0 for same-as-last short code, or 16 for offset 1. */\r
static BROTLI_INLINE void InitCommand(Command* self, size_t insertlen,\r
    size_t copylen, size_t copylen_code, size_t distance_code) {\r
  self->insert_len_ = (uint32_t)insertlen;\r
  self->copy_len_ = (uint32_t)(copylen | ((copylen_code ^ copylen) << 24));\r
  /* The distance prefix and extra bits are stored in this Command as if\r
     npostfix and ndirect were 0, they are only recomputed later after the\r
     clustering if needed. */\r
  PrefixEncodeCopyDistance(\r
      distance_code, 0, 0, &self->dist_prefix_, &self->dist_extra_);\r
  GetLengthCode(\r
      insertlen, copylen_code, TO_BROTLI_BOOL(self->dist_prefix_ == 0),\r
      &self->cmd_prefix_);\r
}\r
\r
static BROTLI_INLINE void InitInsertCommand(Command* self, size_t insertlen) {\r
  self->insert_len_ = (uint32_t)insertlen;\r
  self->copy_len_ = 4 << 24;\r
  self->dist_extra_ = 0;\r
  self->dist_prefix_ = 16;\r
  GetLengthCode(insertlen, 4, BROTLI_FALSE, &self->cmd_prefix_);\r
}\r
\r
static BROTLI_INLINE uint32_t CommandDistanceCode(const Command* self) {\r
  if (self->dist_prefix_ < 16) {\r
    return self->dist_prefix_;\r
  } else {\r
    uint32_t nbits = self->dist_extra_ >> 24;\r
    uint32_t extra = self->dist_extra_ & 0xffffff;\r
    uint32_t prefix = self->dist_prefix_ - 12u - 2u * nbits;\r
    return (prefix << nbits) + extra + 12;\r
  }\r
}\r
\r
static BROTLI_INLINE uint32_t CommandDistanceContext(const Command* self) {\r
  uint32_t r = self->cmd_prefix_ >> 6;\r
  uint32_t c = self->cmd_prefix_ & 7;\r
  if ((r == 0 || r == 2 || r == 4 || r == 7) && (c <= 2)) {\r
    return c;\r
  }\r
  return 3;\r
}\r
\r
static BROTLI_INLINE uint32_t CommandCopyLen(const Command* self) {\r
  return self->copy_len_ & 0xFFFFFF;\r
}\r
\r
static BROTLI_INLINE uint32_t CommandCopyLenCode(const Command* self) {\r
  return (self->copy_len_ & 0xFFFFFF) ^ (self->copy_len_ >> 24);\r
}\r
\r
#if defined(__cplusplus) || defined(c_plusplus)\r
}  /* extern "C" */\r
#endif\r
\r
#endif  /* BROTLI_ENC_COMMAND_H_ */\r