/**************************************************************************

This file contains T.4 decoding data

Contents are :

a) two binary trees for decoding MH fax run-length codes
b) one binary tree for decoding MR codes.
c) one lookup table of inverted characters

MH trees = one tree for white run lengths,  one tree for black run lengths.

All decodes for all trees start from the top.

For each node the first leaf is the offset from the root to the next
node if the current bit is 0,  and the second leaf is the offset to
the next node if the bit is 1.  A minus value is a terminator,  with a
run-length equal to the negation of the minus value.     

******************************************************************************/

#include "stdafx.h"
#include "TifHeader.h"
#include "huffman.h"

const int gWTree [][2] =
{
		{1, 80},          /* 0 */
		{40, 2},          /* 1 */
		{21, 3},          /* 2 */
		{4, -2},          /* 3 */
		{16, 5},          /* 4 */
		{10, 6},          /* 5 */
		{7, -256},        /* 6 */
		{9, 8},           /* 7 */
		{-1344, -1408},   /* 8 */
		{-1216, -1280},   /* 9 */
		{11, 13},         /* 10 */
		{-576, 12},       /* 11 */
		{-832, -896},     /* 12 */
		{14, 15},         /* 13 */
		{-960, -1024},    /* 14 */
		{-1088, -1152},   /* 15 */
		{-1664, 17},      /* 16 */
		{18, 19},         /* 17 */
		{-448, -512},     /* 18 */
		{20, -640},       /* 19 */
		{-704, -768},     /* 20 */
		{32, 22},         /* 21 */
		{23, 28},         /* 22 */
		{24, 26},         /* 23 */
		{-24, 25},        /* 24 */
		{-49, -50},       /* 25 */
		{27, -25},        /* 26 */
		{-51, -52},       /* 27 */
		{29, -192},       /* 28 */
		{30, 31},         /* 29 */
		{-55, -56},       /* 30 */
		{-57, -58},       /* 31 */
		{-11, 33},        /* 32 */
		{34, 36},         /* 33 */
		{-27, 35},        /* 34 */
		{-59, -60},       /* 35 */
		{37, -18},        /* 36 */
		{38, 39},         /* 37 */
		{-1472, -1536},   /* 38 */
		{-1600, -1728},   /* 39 */
		{59, 41},         /* 40 */
		{49, 42},         /* 41 */
		{43, -10},        /* 42 */
		{47, 44},         /* 43 */
		{46, 45},         /* 44 */
		{-320, -384},     /* 45 */
		{-63, 0},         /* 46 */
		{-28, 48},        /* 47 */
		{-61, -62},       /* 48 */
		{56, 50},         /* 49 */
		{53, 51},         /* 50 */
		{52, -21},        /* 51 */
		{-43, -44},       /* 52 */
		{55, 54},         /* 53 */
		{-41, -42},       /* 54 */
		{-39, -40},       /* 55 */
		{-12, 57},        /* 56 */
		{58, -26},        /* 57 */
		{-53, -54},       /* 58 */
		{70, 60},         /* 59 */
		{64, 61},         /* 60 */
		{62, -1},         /* 61 */
		{-19, 63},        /* 62 */
		{-31, -32},       /* 63 */
		{68, 65},         /* 64 */
		{67, 66},         /* 65 */
		{-37, -38},       /* 66 */
		{-35, -36},       /* 67 */
		{-20, 69},        /* 68 */
		{-33, -34},       /* 69 */
		{74, 71},         /* 70 */
		{72, -13},        /* 71 */
		{-23, 73},        /* 72 */
		{-47, -48},       /* 73 */
		{77, 75},         /* 74 */
		{76, -22},        /* 75 */
		{-45, -46},       /* 76 */
		{79, 78},         /* 77 */
		{-29, -30},       /* 78 */
		{OUREOL, BADRUN}, /* 79 */
		{86, 81},         /* 80 */
		{83, 82},         /* 81 */
		{-6, -7},         /* 82 */
		{-5, 84},         /* 83 */
		{85, -64},        /* 84 */
		{-14, -15},       /* 85 */
		{90, 87},         /* 86 */
		{88, -4},         /* 87 */
		{-9, 89},         /* 88 */
		{-16, -17},       /* 89 */
		{-3, 91},         /* 90 */
		{-128, -8}        /* 91 */
};

const int gBTree[][2] =
{
      {2, 1},           /* 0 */
      {-3, -2},         /* 1 */
      {4, 3},           /* 2 */
      {-1, -4},         /* 3 */
      {6, 5},           /* 4 */
      {-6, -5},         /* 5 */
      {9, 7},           /* 6 */
      {8, -7},          /* 7 */
      {-9, -8},         /* 8 */
      {31, 10},         /* 9 */
      {30, 11},         /* 10 */
      {12, -12},        /* 11 */
      {23, 13},         /* 12 */
      {17, 14},         /* 13 */
      {15, 0},          /* 14 */
      {-21, 16},        /* 15 */
      {-42, -43},       /* 16 */
      {21, 18},         /* 17 */
      {20, 19},         /* 18 */
      {-38, -39},       /* 19 */
      {-36, -37},       /* 20 */
      {-20, 22},        /* 21 */
      {-34, -35},       /* 22 */
      {-15, 24},        /* 23 */
      {27, 25},         /* 24 */
      {26, -19},        /* 25 */
      {-28, -29},       /* 26 */
      {29, 28},         /* 27 */
      {-26, -27},       /* 28 */
      {-128, -192},     /* 29 */
      {-10, -11},       /* 30 */
      {57, 32},         /* 31 */
      {45, 33},         /* 32 */
      {34, -14},        /* 33 */
      {41, 35},         /* 34 */
      {38, 36},         /* 35 */
      {37, -22},        /* 36 */
      {-40, -41},       /* 37 */
      {40, 39},         /* 38 */
      {-32, -33},       /* 39 */
      {-30, -31},       /* 40 */
      {-17, 42},        /* 41 */
      {44, 43},         /* 42 */
      {-62, -63},       /* 43 */
      {-48, -49},       /* 44 */
      {-13, 46},        /* 45 */
      {51, 47},         /* 46 */
      {48, -16},        /* 47 */
      {50, 49},         /* 48 */
      {-61, -256},      /* 49 */
      {-57, -58},       /* 50 */
      {55, 52},         /* 51 */
      {54, 53},         /* 52 */
      {-46, -47},       /* 53 */
      {-44, -45},       /* 54 */
      {-23, 56},        /* 55 */
      {-50, -51},       /* 56 */
      {OUREOL, 58},     /* 57 */
      {75, 59},         /* 58 */
      {67, 60},         /* 59 */
      {61, -64},        /* 60 */
      {65, 62},         /* 61 */
      {64, 63},         /* 62 */
      {-1152, -1216},   /* 63 */
      {-1024, -1088},   /* 64 */
      {-54, 66},        /* 65 */
      {-896, -960},     /* 66 */
      {72, 68},         /* 67 */
      {71, 69},         /* 68 */
      {70, -53},        /* 69 */
      {-512, -576},     /* 70 */
      {-384, -448},     /* 71 */
      {-25, 73},        /* 72 */
      {74, -320},       /* 73 */
      {-1664, -1728},   /* 74 */
      {85, 76},         /* 75 */
      {80, 77},         /* 76 */
      {78, -24},        /* 77 */
      {-60, 79},        /* 78 */
      {-1536, -1600},   /* 79 */
      {83, 81},         /* 80 */
      {82, -59},        /* 81 */
      {-1408, -1472},   /* 82 */
      {-56, 84},        /* 83 */
      {-1280, -1344},   /* 84 */
      {-18, 86},        /* 85 */
      {89, 87},         /* 86 */
      {88, -55},        /* 87 */
      {-768, -832},     /* 88 */
      {-52, 90},        /* 89 */
      {-640, -704}      /* 90 */
};

const int gTwoTree [][2] =
{
      {1, VTMODE0},        /* 0 */
      {2, 3},              /* 1 */
      {4, HORZMODE},       /* 2 */
      {VTMODE1N, VTMODE1P},/* 3 */
      {5, PASSMODE},       /* 4 */
      {6, 7},              /* 5 */
      {8, 9},              /* 6 */
      {VTMODE2N, VTMODE2P},/* 7 */
      {OUREOL, BADRUN},    /* 8 */
      {VTMODE3N, VTMODE3P} /* 9 */
};

const unsigned char gBackward[256] =
{
   0x00,0x80,0x40,0xC0,0x20,0xA0,0x60,0xE0,0x10,0x90,0x50,0xD0,0x30,0xB0,0x70,0xF0,
   0x08,0x88,0x48,0xC8,0x28,0xA8,0x68,0xE8,0x18,0x98,0x58,0xD8,0x38,0xB8,0x78,0xF8,
   0x04,0x84,0x44,0xC4,0x24,0xA4,0x64,0xE4,0x14,0x94,0x54,0xD4,0x34,0xB4,0x74,0xF4,
   0x0C,0x8C,0x4C,0xCC,0x2C,0xAC,0x6C,0xEC,0x1C,0x9C,0x5C,0xDC,0x3C,0xBC,0x7C,0xFC,
   0x02,0x82,0x42,0xC2,0x22,0xA2,0x62,0xE2,0x12,0x92,0x52,0xD2,0x32,0xB2,0x72,0xF2,
   0x0A,0x8A,0x4A,0xCA,0x2A,0xAA,0x6A,0xEA,0x1A,0x9A,0x5A,0xDA,0x3A,0xBA,0x7A,0xFA,
   0x06,0x86,0x46,0xC6,0x26,0xA6,0x66,0xE6,0x16,0x96,0x56,0xD6,0x36,0xB6,0x76,0xF6,
   0x0E,0x8E,0x4E,0xCE,0x2E,0xAE,0x6E,0xEE,0x1E,0x9E,0x5E,0xDE,0x3E,0xBE,0x7E,0xFE,
   0x01,0x81,0x41,0xC1,0x21,0xA1,0x61,0xE1,0x11,0x91,0x51,0xD1,0x31,0xB1,0x71,0xF1,
   0x09,0x89,0x49,0xC9,0x29,0xA9,0x69,0xE9,0x19,0x99,0x59,0xD9,0x39,0xB9,0x79,0xF9,
   0x05,0x85,0x45,0xC5,0x25,0xA5,0x65,0xE5,0x15,0x95,0x55,0xD5,0x35,0xB5,0x75,0xF5,
   0x0D,0x8D,0x4D,0xCD,0x2D,0xAD,0x6D,0xED,0x1D,0x9D,0x5D,0xDD,0x3D,0xBD,0x7D,0xFD,
   0x03,0x83,0x43,0xC3,0x23,0xA3,0x63,0xE3,0x13,0x93,0x53,0xD3,0x33,0xB3,0x73,0xF3,
   0x0B,0x8B,0x4B,0xCB,0x2B,0xAB,0x6B,0xEB,0x1B,0x9B,0x5B,0xDB,0x3B,0xBB,0x7B,0xFB,
   0x07,0x87,0x47,0xC7,0x27,0xA7,0x67,0xE7,0x17,0x97,0x57,0xD7,0x37,0xB7,0x77,0xF7,
   0x0F,0x8F,0x4F,0xCF,0x2F,0xAF,0x6F,0xEF,0x1F,0x9F,0x5F,0xDF,0x3F,0xBF,0x7F,0xFF
};