/src/theora/lib/tokenize.c

Source
/********************************************************************
 *                                                                  *
 * THIS FILE IS PART OF THE OggTheora SOFTWARE CODEC SOURCE CODE.   *
 * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
 * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
 * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
 *                                                                  *
 * THE Theora SOURCE CODE IS COPYRIGHT (C) 2002-2009,2025           *
 * by the Xiph.Org Foundation https://www.xiph.org/                 *
 *                                                                  *
 ********************************************************************

  function:

 ********************************************************************/
#include <stdlib.h>
#include <string.h>
#include "encint.h"



static unsigned char OC_DCT_EOB_TOKEN[31]={
  0,1,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5
};

static int oc_make_eob_token(int _run_count){
  return _run_count<32?OC_DCT_EOB_TOKEN[_run_count-1]:OC_DCT_REPEAT_RUN3_TOKEN;
}

static unsigned char OC_DCT_EOB_EB[31]={
  0,0,0,0,1,2,3,0,1,2,3,4,5,6,7,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
};

static int oc_make_eob_token_full(int _run_count,int *_eb){
  if(_run_count<32){
    *_eb=OC_DCT_EOB_EB[_run_count-1];
    return OC_DCT_EOB_TOKEN[_run_count-1];
  }
  else{
    *_eb=_run_count;
    return OC_DCT_REPEAT_RUN3_TOKEN;
  }
}

/*Returns the number of blocks ended by an EOB token.*/
static int oc_decode_eob_token(int _token,int _eb){
  return (0x20820C41U>>_token*5&0x1F)+_eb;
}

/*Some tables for fast construction of value tokens.*/

static const unsigned char OC_DCT_VALUE_TOKEN[1161]={
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,21,21,21,21,21,21,21,21,
  21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,
  21,21,21,21,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,
  19,19,19,19,19,19,19,19,18,18,18,18,17,17,16,15,14,13,12,10,
   7,
   9,11,13,14,15,16,17,17,18,18,18,18,19,19,19,19,19,19,19,19,
  20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,21,21,21,21,
  21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,
  21,21,21,21,21,21,21,21,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
  22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22
};

static const ogg_uint16_t OC_DCT_VALUE_EB[1161]={
  1023,1022,1021,1020,1019,1018,1017,1016,1015,1014,
  1013,1012,1011,1010,1009,1008,1007,1006,1005,1004,
  1003,1002,1001,1000, 999, 998, 997, 996, 995, 994,
   993, 992, 991, 990, 989, 988, 987, 986, 985, 984,
   983, 982, 981, 980, 979, 978, 977, 976, 975, 974,
   973, 972, 971, 970, 969, 968, 967, 966, 965, 964,
   963, 962, 961, 960, 959, 958, 957, 956, 955, 954,
   953, 952, 951, 950, 949, 948, 947, 946, 945, 944,
   943, 942, 941, 940, 939, 938, 937, 936, 935, 934,
   933, 932, 931, 930, 929, 928, 927, 926, 925, 924,
   923, 922, 921, 920, 919, 918, 917, 916, 915, 914,
   913, 912, 911, 910, 909, 908, 907, 906, 905, 904,
   903, 902, 901, 900, 899, 898, 897, 896, 895, 894,
   893, 892, 891, 890, 889, 888, 887, 886, 885, 884,
   883, 882, 881, 880, 879, 878, 877, 876, 875, 874,
   873, 872, 871, 870, 869, 868, 867, 866, 865, 864,
   863, 862, 861, 860, 859, 858, 857, 856, 855, 854,
   853, 852, 851, 850, 849, 848, 847, 846, 845, 844,
   843, 842, 841, 840, 839, 838, 837, 836, 835, 834,
   833, 832, 831, 830, 829, 828, 827, 826, 825, 824,
   823, 822, 821, 820, 819, 818, 817, 816, 815, 814,
   813, 812, 811, 810, 809, 808, 807, 806, 805, 804,
   803, 802, 801, 800, 799, 798, 797, 796, 795, 794,
   793, 792, 791, 790, 789, 788, 787, 786, 785, 784,
   783, 782, 781, 780, 779, 778, 777, 776, 775, 774,
   773, 772, 771, 770, 769, 768, 767, 766, 765, 764,
   763, 762, 761, 760, 759, 758, 757, 756, 755, 754,
   753, 752, 751, 750, 749, 748, 747, 746, 745, 744,
   743, 742, 741, 740, 739, 738, 737, 736, 735, 734,
   733, 732, 731, 730, 729, 728, 727, 726, 725, 724,
   723, 722, 721, 720, 719, 718, 717, 716, 715, 714,
   713, 712, 711, 710, 709, 708, 707, 706, 705, 704,
   703, 702, 701, 700, 699, 698, 697, 696, 695, 694,
   693, 692, 691, 690, 689, 688, 687, 686, 685, 684,
   683, 682, 681, 680, 679, 678, 677, 676, 675, 674,
   673, 672, 671, 670, 669, 668, 667, 666, 665, 664,
   663, 662, 661, 660, 659, 658, 657, 656, 655, 654,
   653, 652, 651, 650, 649, 648, 647, 646, 645, 644,
   643, 642, 641, 640, 639, 638, 637, 636, 635, 634,
   633, 632, 631, 630, 629, 628, 627, 626, 625, 624,
   623, 622, 621, 620, 619, 618, 617, 616, 615, 614,
   613, 612, 611, 610, 609, 608, 607, 606, 605, 604,
   603, 602, 601, 600, 599, 598, 597, 596, 595, 594,
   593, 592, 591, 590, 589, 588, 587, 586, 585, 584,
   583, 582, 581, 580, 579, 578, 577, 576, 575, 574,
   573, 572, 571, 570, 569, 568, 567, 566, 565, 564,
   563, 562, 561, 560, 559, 558, 557, 556, 555, 554,
   553, 552, 551, 550, 549, 548, 547, 546, 545, 544,
   543, 542, 541, 540, 539, 538, 537, 536, 535, 534,
   533, 532, 531, 530, 529, 528, 527, 526, 525, 524,
   523, 522, 521, 520, 519, 518, 517, 516, 515, 514,
   513, 512,  63,  62,  61,  60,  59,  58,  57,  56,
    55,  54,  53,  52,  51,  50,  49,  48,  47,  46,
    45,  44,  43,  42,  41,  40,  39,  38,  37,  36,
    35,  34,  33,  32,  31,  30,  29,  28,  27,  26,
    25,  24,  23,  22,  21,  20,  19,  18,  17,  16,
    15,  14,  13,  12,  11,  10,   9,   8,   7,   6,
     5,   4,   3,   2,   1,   1,   1,   1,   0,   0,
     0,
     0,   0,   0,   0,   0,   0,   0,   1,   0,   1,
     2,   3,   0,   1,   2,   3,   4,   5,   6,   7,
     0,   1,   2,   3,   4,   5,   6,   7,   8,   9,
    10,  11,  12,  13,  14,  15,   0,   1,   2,   3,
     4,   5,   6,   7,   8,   9,  10,  11,  12,  13,
    14,  15,  16,  17,  18,  19,  20,  21,  22,  23,
    24,  25,  26,  27,  28,  29,  30,  31,   0,   1,
     2,   3,   4,   5,   6,   7,   8,   9,  10,  11,
    12,  13,  14,  15,  16,  17,  18,  19,  20,  21,
    22,  23,  24,  25,  26,  27,  28,  29,  30,  31,
    32,  33,  34,  35,  36,  37,  38,  39,  40,  41,
    42,  43,  44,  45,  46,  47,  48,  49,  50,  51,
    52,  53,  54,  55,  56,  57,  58,  59,  60,  61,
    62,  63,  64,  65,  66,  67,  68,  69,  70,  71,
    72,  73,  74,  75,  76,  77,  78,  79,  80,  81,
    82,  83,  84,  85,  86,  87,  88,  89,  90,  91,
    92,  93,  94,  95,  96,  97,  98,  99, 100, 101,
   102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
   112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
   122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
   132, 133, 134, 135, 136, 137, 138, 139, 140, 141,
   142, 143, 144, 145, 146, 147, 148, 149, 150, 151,
   152, 153, 154, 155, 156, 157, 158, 159, 160, 161,
   162, 163, 164, 165, 166, 167, 168, 169, 170, 171,
   172, 173, 174, 175, 176, 177, 178, 179, 180, 181,
   182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
   192, 193, 194, 195, 196, 197, 198, 199, 200, 201,
   202, 203, 204, 205, 206, 207, 208, 209, 210, 211,
   212, 213, 214, 215, 216, 217, 218, 219, 220, 221,
   222, 223, 224, 225, 226, 227, 228, 229, 230, 231,
   232, 233, 234, 235, 236, 237, 238, 239, 240, 241,
   242, 243, 244, 245, 246, 247, 248, 249, 250, 251,
   252, 253, 254, 255, 256, 257, 258, 259, 260, 261,
   262, 263, 264, 265, 266, 267, 268, 269, 270, 271,
   272, 273, 274, 275, 276, 277, 278, 279, 280, 281,
   282, 283, 284, 285, 286, 287, 288, 289, 290, 291,
   292, 293, 294, 295, 296, 297, 298, 299, 300, 301,
   302, 303, 304, 305, 306, 307, 308, 309, 310, 311,
   312, 313, 314, 315, 316, 317, 318, 319, 320, 321,
   322, 323, 324, 325, 326, 327, 328, 329, 330, 331,
   332, 333, 334, 335, 336, 337, 338, 339, 340, 341,
   342, 343, 344, 345, 346, 347, 348, 349, 350, 351,
   352, 353, 354, 355, 356, 357, 358, 359, 360, 361,
   362, 363, 364, 365, 366, 367, 368, 369, 370, 371,
   372, 373, 374, 375, 376, 377, 378, 379, 380, 381,
   382, 383, 384, 385, 386, 387, 388, 389, 390, 391,
   392, 393, 394, 395, 396, 397, 398, 399, 400, 401,
   402, 403, 404, 405, 406, 407, 408, 409, 410, 411,
   412, 413, 414, 415, 416, 417, 418, 419, 420, 421,
   422, 423, 424, 425, 426, 427, 428, 429, 430, 431,
   432, 433, 434, 435, 436, 437, 438, 439, 440, 441,
   442, 443, 444, 445, 446, 447, 448, 449, 450, 451,
   452, 453, 454, 455, 456, 457, 458, 459, 460, 461,
   462, 463, 464, 465, 466, 467, 468, 469, 470, 471,
   472, 473, 474, 475, 476, 477, 478, 479, 480, 481,
   482, 483, 484, 485, 486, 487, 488, 489, 490, 491,
   492, 493, 494, 495, 496, 497, 498, 499, 500, 501,
   502, 503, 504, 505, 506, 507, 508, 509, 510, 511
};

/*The first DCT coefficient that both has a smaller magnitude and gets coded
   with a different token.*/
static const ogg_int16_t OC_DCT_TRELLIS_ALT_VALUE[1161]={
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -68, -68, -68, -68, -68, -68, -68, -68,
   -68, -68, -36, -36, -36, -36, -36, -36, -36, -36,
   -36, -36, -36, -36, -36, -36, -36, -36, -36, -36,
   -36, -36, -36, -36, -36, -36, -36, -36, -36, -36,
   -36, -36, -36, -36, -20, -20, -20, -20, -20, -20,
   -20, -20, -20, -20, -20, -20, -20, -20, -20, -20,
   -12, -12, -12, -12, -12, -12, -12, -12,  -8,  -8,
    -8,  -8,  -6,  -6,  -5,  -4,  -3,  -2,  -1,   0,
     0,
     0,   1,   2,   3,   4,   5,   6,   6,   8,   8,
     8,   8,  12,  12,  12,  12,  12,  12,  12,  12,
    20,  20,  20,  20,  20,  20,  20,  20,  20,  20,
    20,  20,  20,  20,  20,  20,  36,  36,  36,  36,
    36,  36,  36,  36,  36,  36,  36,  36,  36,  36,
    36,  36,  36,  36,  36,  36,  36,  36,  36,  36,
    36,  36,  36,  36,  36,  36,  36,  36,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68,
    68,  68,  68,  68,  68,  68,  68,  68,  68,  68
};

#define OC_DCT_VALUE_TOKEN_PTR (OC_DCT_VALUE_TOKEN+580)
#define OC_DCT_VALUE_EB_PTR (OC_DCT_VALUE_EB+580)
#define OC_DCT_TRELLIS_ALT_VALUE_PTR (OC_DCT_TRELLIS_ALT_VALUE+580)

/*Some tables for fast construction of combo tokens.*/

static const unsigned char OC_DCT_RUN_CAT1_TOKEN[17]={
  23,24,25,26,27,28,28,28,28,29,29,29,29,29,29,29,29
};

static const unsigned char OC_DCT_RUN_CAT1_EB[17][2]={
  {0,1},{0,1},{0, 1},{0, 1},{0, 1},{0, 4},{1, 5},{2, 6},{3,7},
  {0,8},{1,9},{2,10},{3,11},{4,12},{5,13},{6,14},{7,15}
};

static const unsigned char OC_DCT_RUN_CAT2_EB[3][2][2]={
  { {0,1},{2,3} },{ {0,2},{4,6} },{ {1,3},{5,7} }
};

/*Token logging to allow a few fragments of efficient rollback.
  Late SKIP analysis is tied up in the tokenization process, so we need to be
   able to undo a fragment's tokens on a whim.*/

static const unsigned char OC_ZZI_HUFF_OFFSET[64]={
   0,16,16,16,16,16,32,32,
  32,32,32,32,32,32,32,48,
  48,48,48,48,48,48,48,48,
  48,48,48,48,64,64,64,64,
  64,64,64,64,64,64,64,64,
  64,64,64,64,64,64,64,64,
  64,64,64,64,64,64,64,64
};

static int oc_token_bits(oc_enc_ctx *_enc,int _huffi,int _zzi,int _token){
  return _enc->huff_codes[_huffi+OC_ZZI_HUFF_OFFSET[_zzi]][_token].nbits
   +OC_DCT_TOKEN_EXTRA_BITS[_token];
}

static void oc_enc_tokenlog_checkpoint(oc_enc_ctx *_enc,
 oc_token_checkpoint *_cp,int _pli,int _zzi){
  _cp->pli=_pli;
  _cp->zzi=_zzi;
  _cp->eob_run=_enc->eob_run[_pli][_zzi];
  _cp->ndct_tokens=_enc->ndct_tokens[_pli][_zzi];
}

void oc_enc_tokenlog_rollback(oc_enc_ctx *_enc,
 const oc_token_checkpoint *_stack,int _n){
  int i;
  for(i=_n;i-->0;){
    int pli;
    int zzi;
    pli=_stack[i].pli;
    zzi=_stack[i].zzi;
    _enc->eob_run[pli][zzi]=_stack[i].eob_run;
    _enc->ndct_tokens[pli][zzi]=_stack[i].ndct_tokens;
  }
}

static void oc_enc_token_log(oc_enc_ctx *_enc,
 int _pli,int _zzi,int _token,int _eb){
  ptrdiff_t ti;
  ti=_enc->ndct_tokens[_pli][_zzi]++;
  _enc->dct_tokens[_pli][_zzi][ti]=(unsigned char)_token;
  _enc->extra_bits[_pli][_zzi][ti]=(ogg_uint16_t)_eb;
}

static void oc_enc_eob_log(oc_enc_ctx *_enc,
 int _pli,int _zzi,int _run_count){
  int token;
  int eb;
  token=oc_make_eob_token_full(_run_count,&eb);
  oc_enc_token_log(_enc,_pli,_zzi,token,eb);
}


void oc_enc_tokenize_start(oc_enc_ctx *_enc){
  memset(_enc->ndct_tokens,0,sizeof(_enc->ndct_tokens));
  memset(_enc->eob_run,0,sizeof(_enc->eob_run));
  memset(_enc->dct_token_offs,0,sizeof(_enc->dct_token_offs));
  memset(_enc->dc_pred_last,0,sizeof(_enc->dc_pred_last));
}

typedef struct oc_quant_token oc_quant_token;

/*A single node in the Viterbi trellis.
  We maintain up to 2 of these per coefficient:
    - A token to code if the value is zero (EOB, zero run, or combo token).
    - A token to code if the value is not zero (DCT value token).*/
struct oc_quant_token{
  unsigned char next;
  signed char   token;
  ogg_int16_t   eb;
  ogg_uint32_t  cost;
  int           bits;
  int           qc;
};

/*Tokenizes the AC coefficients, possibly adjusting the quantization, and then
   dequantizes and de-zig-zags the result.
  The AC coefficients of _idct must be pre-initialized to zero.*/
int oc_enc_tokenize_ac(oc_enc_ctx *_enc,int _pli,ptrdiff_t _fragi,
 ogg_int16_t *_idct,const ogg_int16_t *_qdct,
 const ogg_uint16_t *_dequant,const ogg_int16_t *_dct,
 int _zzi,oc_token_checkpoint **_stack,int _lambda,int _acmin){
  oc_token_checkpoint *stack;
  ogg_int64_t          zflags;
  ogg_int64_t          nzflags;
  ogg_int64_t          best_flags;
  ogg_uint32_t         d2_accum[64];
  oc_quant_token       tokens[64][2];
  ogg_uint16_t        *eob_run;
  const unsigned char *dct_fzig_zag;
  ogg_uint32_t         cost;
  int                  bits;
  int                  eob;
  int                  token;
  int                  eb;
  int                  next;
  int                  huffi;
  int                  zzi;
  int                  ti;
  int                  zzj;
  int                  qc;
  huffi=_enc->huff_idxs[_enc->state.frame_type][1][_pli+1>>1];
  eob_run=_enc->eob_run[_pli];
  memset(tokens[0],0,sizeof(tokens[0]));
  best_flags=nzflags=0;
  zflags=1;
  d2_accum[0]=0;
  zzj=64;
  for(zzi=OC_MINI(_zzi,63);zzi>0;zzi--){
    ogg_uint32_t best_cost;
    int          best_bits=INT_MAX;
    int          best_next=INT_MAX;
    int          best_token=INT_MAX;
    int          best_eb=INT_MAX;
    int          best_qc=INT_MAX;
    ogg_uint32_t d2;
    int          dq;
    int          qc_m;
    int          e;
    int          c;
    int          s;
    int          tj;
    qc=_qdct[zzi];
    s=-(qc<0);
    qc_m=qc+s^s;
    c=_dct[zzi];
    /*The hard case: try a zero run.*/
    if(qc_m<=1){
      ogg_uint32_t sum_d2;
      int          nzeros;
      int          dc_reserve;
      if(!qc_m){
        /*Skip runs that are already quantized to zeros.
          If we considered each zero coefficient in turn, we might
           theoretically find a better way to partition long zero runs (e.g.,
           a run of > 17 zeros followed by a 1 might be better coded as a short
           zero run followed by a combo token, rather than the longer zero
           token followed by a 1 value token), but zeros are so common that
           this becomes very computationally expensive (quadratic instead of
           linear in the number of coefficients), for a marginal gain.*/
        while(zzi>1&&!_qdct[zzi-1])zzi--;
        /*The distortion of coefficients originally quantized to zero is
           treated as zero (since we'll never quantize them to anything else).*/
        d2=0;
      }
      else{
        d2=c*(ogg_int32_t)c;
        c=c+s^s;
      }
      eob=eob_run[zzi];
      nzeros=zzj-zzi;
      zzj&=63;
      sum_d2=d2+d2_accum[zzj];
      d2_accum[zzi]=sum_d2;
      /*We reserve 1 spot for combo run tokens that start in the 1st AC stack
         to ensure they can be extended to include the DC coefficient if
         necessary; this greatly simplifies stack-rewriting later on.*/
      dc_reserve=zzi+62>>6;
      best_cost=0xFFFFFFFF;
      for(;;){
        if(nzflags>>zzj&1){
          int val;
          int val_s;
          int zzk;
          int tk;
          next=tokens[zzj][1].next;
          tk=next&1;
          zzk=next>>1;
          /*Try a pure zero run to this point.*/
          token=OC_DCT_SHORT_ZRL_TOKEN+(nzeros+55>>6);
          bits=oc_token_bits(_enc,huffi,zzi,token);
          d2=sum_d2-d2_accum[zzj];
          cost=d2+_lambda*bits+tokens[zzj][1].cost;
          if(cost<=best_cost){
            best_next=(zzj<<1)+1;
            best_token=token;
            best_eb=nzeros-1;
            best_cost=cost;
            best_bits=bits+tokens[zzj][1].bits;
            best_qc=0;
          }
          if(nzeros<17+dc_reserve){
            val=_qdct[zzj];
            val_s=-(val<0);
            val=val+val_s^val_s;
            if(val<=2){
              /*Try a +/- 1 combo token.*/
              token=OC_DCT_RUN_CAT1_TOKEN[nzeros-1];
              eb=OC_DCT_RUN_CAT1_EB[nzeros-1][-val_s];
              e=_dct[zzj]-(_dequant[zzj]+val_s^val_s);
              d2=e*(ogg_int32_t)e+sum_d2-d2_accum[zzj];
              bits=oc_token_bits(_enc,huffi,zzi,token);
              cost=d2+_lambda*bits+tokens[zzk][tk].cost;
              if(cost<=best_cost){
                best_next=next;
                best_token=token;
                best_eb=eb;
                best_cost=cost;
                best_bits=bits+tokens[zzk][tk].bits;
                best_qc=1+val_s^val_s;
              }
            }
            if(nzeros<3+dc_reserve&&2<=val&&val<=4){
              int sval;
              /*Try a +/- 2/3 combo token.*/
              token=OC_DCT_RUN_CAT2A+(nzeros>>1);
              bits=oc_token_bits(_enc,huffi,zzi,token);
              val=2+(val>2);
              sval=val+val_s^val_s;
              e=_dct[zzj]-_dequant[zzj]*sval;
              d2=e*(ogg_int32_t)e+sum_d2-d2_accum[zzj];
              cost=d2+_lambda*bits+tokens[zzk][tk].cost;
              if(cost<=best_cost){
                best_cost=cost;
                best_bits=bits+tokens[zzk][tk].bits;
                best_next=next;
                best_token=token;
                best_eb=OC_DCT_RUN_CAT2_EB[nzeros-1][-val_s][val-2];
                best_qc=sval;
              }
            }
          }
          /*zzj can't be coded as a zero, so stop trying to extend the run.*/
          if(!(zflags>>zzj&1))break;
        }
        /*We could try to consider _all_ potentially non-zero coefficients, but
           if we already found a bunch of them not worth coding, it's fairly
           unlikely they would now be worth coding from this position; skipping
           them saves a lot of work.*/
        zzj=(tokens[zzj][0].next>>1)-(tokens[zzj][0].qc!=0)&63;
        if(zzj==0){
          /*We made it all the way to the end of the block; try an EOB token.*/
          if(eob<4095){
            bits=oc_token_bits(_enc,huffi,zzi,oc_make_eob_token(eob+1))
             -(eob>0?oc_token_bits(_enc,huffi,zzi,oc_make_eob_token(eob)):0);
          }
          else bits=oc_token_bits(_enc,huffi,zzi,OC_DCT_EOB1_TOKEN);
          cost=sum_d2+bits*_lambda;
          /*If the best route so far is still a pure zero run to the end of the
             block, force coding it as an EOB.
            Even if it's not optimal for this block, it has a good chance of
             getting combined with an EOB token from subsequent blocks, saving
             bits overall.*/
          if(cost<=best_cost||best_token<=OC_DCT_ZRL_TOKEN&&zzi+best_eb==63){
            best_next=0;
            /*This token is just a marker; in reality we may not emit any
               tokens, but update eob_run[] instead.*/
            best_token=OC_DCT_EOB1_TOKEN;
            best_eb=0;
            best_cost=cost;
            best_bits=bits;
            best_qc=0;
          }
          break;
        }
        nzeros=zzj-zzi;
      }
      tokens[zzi][0].next=(unsigned char)best_next;
      tokens[zzi][0].token=(signed char)best_token;
      tokens[zzi][0].eb=(ogg_int16_t)best_eb;
      tokens[zzi][0].cost=best_cost;
      tokens[zzi][0].bits=best_bits;
      tokens[zzi][0].qc=best_qc;
      zflags|=(ogg_int64_t)1<<zzi;
      if(qc_m){
        dq=_dequant[zzi];
        if(zzi<_acmin)_lambda=0;
        e=dq-c;
        d2=e*(ogg_int32_t)e;
        token=OC_ONE_TOKEN-s;
        bits=oc_token_bits(_enc,huffi,zzi,token);
        zzj=zzi+1&63;
        tj=best_flags>>zzj&1;
        next=(zzj<<1)+tj;
        tokens[zzi][1].next=(unsigned char)next;
        tokens[zzi][1].token=(signed char)token;
        tokens[zzi][1].eb=0;
        tokens[zzi][1].cost=d2+_lambda*bits+tokens[zzj][tj].cost;
        tokens[zzi][1].bits=bits+tokens[zzj][tj].bits;
        tokens[zzi][1].qc=1+s^s;
        nzflags|=(ogg_int64_t)1<<zzi;
        best_flags|=
         (ogg_int64_t)(tokens[zzi][1].cost<tokens[zzi][0].cost)<<zzi;
      }
    }
    else{
      int alt_qc;
      eob=eob_run[zzi];
      if(zzi<_acmin)_lambda=0;
      dq=_dequant[zzi];
      /*No zero run can extend past this point.*/
      d2_accum[zzi]=0;
      e=qc*dq-c;
      d2=e*(ogg_int32_t)e;
      best_token=*(OC_DCT_VALUE_TOKEN_PTR+qc);
      best_bits=oc_token_bits(_enc,huffi,zzi,best_token);
      best_cost=d2+_lambda*best_bits;
      alt_qc=*(OC_DCT_TRELLIS_ALT_VALUE_PTR+qc);
      e=alt_qc*dq-c;
      d2=e*(ogg_int32_t)e;
      token=*(OC_DCT_VALUE_TOKEN_PTR+alt_qc);
      bits=oc_token_bits(_enc,huffi,zzi,token);
      cost=d2+_lambda*bits;
      if(cost<best_cost){
        best_token=token;
        best_bits=bits;
        best_cost=cost;
        qc=alt_qc;
      }
      zzj=zzi+1&63;
      tj=best_flags>>zzj&1;
      next=(zzj<<1)+tj;
      tokens[zzi][1].next=(unsigned char)next;
      tokens[zzi][1].token=(signed char)best_token;
      tokens[zzi][1].eb=*(OC_DCT_VALUE_EB_PTR+qc);
      tokens[zzi][1].cost=best_cost+tokens[zzj][tj].cost;
      tokens[zzi][1].bits=best_bits+tokens[zzj][tj].bits;
      tokens[zzi][1].qc=qc;
      nzflags|=(ogg_int64_t)1<<zzi;
      best_flags|=(ogg_int64_t)1<<zzi;
    }
    zzj=zzi;
  }
  /*Emit the tokens from the best path through the trellis.*/
  stack=*_stack;
  dct_fzig_zag=_enc->state.opt_data.dct_fzig_zag;
  zzi=1;
  ti=best_flags>>1&1;
  bits=tokens[zzi][ti].bits;
  do{
    oc_enc_tokenlog_checkpoint(_enc,stack++,_pli,zzi);
    eob=eob_run[zzi];
    if(tokens[zzi][ti].token<OC_NDCT_EOB_TOKEN_MAX){
      if(++eob>=4095){
        oc_enc_token_log(_enc,_pli,zzi,OC_DCT_REPEAT_RUN3_TOKEN,eob);
        eob=0;
      }
      eob_run[zzi]=eob;
      /*We don't include the actual EOB cost for this block in the return value.
        It is very likely to eventually be spread over several blocks, and
         including it more harshly penalizes the first few blocks in a long EOB
         run.
        Omitting it here gives a small PSNR and SSIM gain.*/
      bits-=tokens[zzi][ti].bits;
      zzi=_zzi;
      break;
    }
    /*Emit pending EOB run if any.*/
    if(eob>0){
      oc_enc_eob_log(_enc,_pli,zzi,eob);
      eob_run[zzi]=0;
    }
    oc_enc_token_log(_enc,_pli,zzi,tokens[zzi][ti].token,tokens[zzi][ti].eb);
    next=tokens[zzi][ti].next;
    qc=tokens[zzi][ti].qc;
    zzj=(next>>1)-1&63;
    /*TODO: It may be worth saving the dequantized coefficient in the trellis
       above; we had to compute it to measure the error anyway.*/
    _idct[dct_fzig_zag[zzj]]=(ogg_int16_t)(qc*(int)_dequant[zzj]);
    zzi=next>>1;
    ti=next&1;
  }
  while(zzi);
  *_stack=stack;
  return bits;
}

/*Simplistic R/D tokenizer.
  The AC coefficients of _idct must be pre-initialized to zero.
  This could be made more accurate by using more sophisticated
   rate predictions for zeros.
  It could be made faster by switching from R/D decisions to static
   lambda-derived rounding biases.*/
int oc_enc_tokenize_ac_fast(oc_enc_ctx *_enc,int _pli,ptrdiff_t _fragi,
 ogg_int16_t *_idct,const ogg_int16_t *_qdct,
 const ogg_uint16_t *_dequant,const ogg_int16_t *_dct,
 int _zzi,oc_token_checkpoint **_stack,int _lambda,int _acmin){
  const unsigned char *dct_fzig_zag;
  ogg_uint16_t        *eob_run;
  oc_token_checkpoint *stack;
  int                  huffi;
  int                  zzi;
  int                  zzj;
  int                  zzk;
  int                  total_bits;
  int                  zr[4];
  stack=*_stack;
  total_bits=0;
  /*The apparent bit-cost of coding a zero from observing the trellis
     quantizer is pre-combined with lambda.
    Four predictive cases are considered: the last optimized value is zero (+2)
     or non-zero and the non-optimized value is zero (+1) or non-zero.*/
  zr[0]=3*_lambda>>1;
  zr[1]=_lambda;
  zr[2]=4*_lambda;
  zr[3]=7*_lambda>>1;
  eob_run=_enc->eob_run[_pli];
  dct_fzig_zag=_enc->state.opt_data.dct_fzig_zag;
  huffi=_enc->huff_idxs[_enc->state.frame_type][1][_pli+1>>1];
  for(zzj=zzi=1;zzj<_zzi&&!_qdct[zzj];zzj++);
  while(zzj<_zzi){
    int v;
    int d0;
    int d1;
    int sign;
    int k;
    int eob;
    int dq0;
    int dq1;
    int dd0;
    int dd1;
    int next_zero;
    int eob_bits;
    int dct_fzig_zzj;
    dct_fzig_zzj=dct_fzig_zag[zzj];
    v=_dct[zzj];
    d0=_qdct[zzj];
    eob=eob_run[zzi];
    for(zzk=zzj+1;zzk<_zzi&&!_qdct[zzk];zzk++);
    next_zero=zzk-zzj+62>>6;
    dq0=d0*_dequant[zzj];
    dd0=dq0-v;
    dd0*=dd0;
    sign=-(d0<0);
    k=d0+sign^sign;
    d1=(k-(zzj>_acmin))+sign^sign;
    dq1=d1*_dequant[zzj];
    dd1=dq1-v;
    dd1*=dd1;
    /*The cost of ending an eob run is included when the alternative is to
       extend this eob run.
      A per qi/zzi weight would probably be useful.
      Including it in the overall tokenization cost was not helpful.
      The same is true at the far end of the zero run plus token case.*/
    if(eob>0&&d1==0&&zzk==_zzi){
      eob_bits=oc_token_bits(_enc,huffi,zzi,OC_DCT_EOB1_TOKEN);
    }
    else eob_bits=0;
    if(zzj==zzi){
      /*No active zero run.*/
      int best_token;
      int best_eb;
      int token;
      int best_bits;
      int bits;
      int cost;
      best_token=*(OC_DCT_VALUE_TOKEN_PTR+d0);
      best_bits=oc_token_bits(_enc,huffi,zzi,best_token);
      if(d1!=0){
        token=*(OC_DCT_VALUE_TOKEN_PTR+d1);
        bits=oc_token_bits(_enc,huffi,zzi,token);
        cost=dd1+(bits+eob_bits)*_lambda;
      }
      else{
        token=bits=0;
        cost=dd1+zr[next_zero];
      }
      if((dd0+(best_bits+eob_bits)*_lambda)>cost){
        _idct[dct_fzig_zzj]=dq1;
        if(d1==0){
          zzj=zzk;
          continue;
        }
        best_bits=bits;
        best_token=token;
        best_eb=*(OC_DCT_VALUE_EB_PTR+d1);
      }
      else{
        best_eb=*(OC_DCT_VALUE_EB_PTR+d0);
        _idct[dct_fzig_zzj]=dq0;
      }
      oc_enc_tokenlog_checkpoint(_enc,stack++,_pli,zzi);
      if(eob>0){
        oc_enc_eob_log(_enc,_pli,zzi,eob);
        eob_run[zzi]=0;
      }
      oc_enc_token_log(_enc,_pli,zzi,best_token,best_eb);
      total_bits+=best_bits;
    }
    else{
      int d;
      int dc_reserve;
      int best_token;
      int best_eb;
      int best_bits;
      int best_cost;
      int best_bits1;
      int best_token1;
      int best_eb1;
      int zr_bits;
      int eob2;
      int eob_bits2;
      int bits;
      int token;
      int nzeros;
      nzeros=zzj-zzi;
      dc_reserve=zzi+62>>6;
      /*A zero run, followed by the value alone.*/
      best_token=best_token1=OC_DCT_SHORT_ZRL_TOKEN+(nzeros+55>>6);
      best_eb=best_eb1=nzeros-1;
      eob2=eob_run[zzj];
      eob_bits2=eob2>0?oc_token_bits(_enc,huffi,zzj,OC_DCT_EOB1_TOKEN):0;
      zr_bits=oc_token_bits(_enc,huffi,zzi,best_token)+eob_bits2;
      best_bits=zr_bits
       +oc_token_bits(_enc,huffi,zzj,*(OC_DCT_VALUE_TOKEN_PTR+d0));
      d=d0;
      best_bits1=0;
      if(d1!=0){
        best_bits1=zr_bits
         +oc_token_bits(_enc,huffi,zzj,*(OC_DCT_VALUE_TOKEN_PTR+d1));
      }
      if(nzeros<17+dc_reserve){
        if(k<=2){
          /*+/- 1 combo token.*/
          token=OC_DCT_RUN_CAT1_TOKEN[nzeros-1];
          bits=oc_token_bits(_enc,huffi,zzi,token);
          if(k==2&&bits<=best_bits1){
            best_bits1=bits;
            best_token1=token;
            best_eb1=OC_DCT_RUN_CAT1_EB[nzeros-1][-sign];
          }
          if(k==1&&bits<=best_bits){
            best_bits=bits;
            best_token=token;
            best_eb=OC_DCT_RUN_CAT1_EB[nzeros-1][-sign];
          }
        }
        if(nzeros<3+dc_reserve&&2<=k&&k<=4){
          /*+/- 2/3 combo token.*/
          token=OC_DCT_RUN_CAT2A+(nzeros>>1);
          bits=oc_token_bits(_enc,huffi,zzi,token);
          if(k==4&&bits<=best_bits1){
            best_bits1=bits;
            best_token1=token;
            best_eb1=OC_DCT_RUN_CAT2_EB[nzeros-1][-sign][1];
          }
          if(k!=4&&bits<=best_bits){
            best_bits=bits;
            best_token=token;
            best_eb=OC_DCT_RUN_CAT2_EB[nzeros-1][-sign][k-2];
          }
        }
      }
      best_cost=dd0+(best_bits+eob_bits)*_lambda;
      if(d1==0&&(dd1+zr[2+next_zero])<=best_cost){
        zzj=zzk;
        continue;
      }
      if(d1!=0&&dd1+(best_bits1+eob_bits)*_lambda<best_cost){
        best_bits=best_bits1;
        best_token=best_token1;
        best_eb=best_eb1;
        d=d1;
        _idct[dct_fzig_zzj]=dq1;
      }
      else _idct[dct_fzig_zzj]=dq0;
      oc_enc_tokenlog_checkpoint(_enc,stack++,_pli,zzi);
      if(eob){
        oc_enc_eob_log(_enc,_pli,zzi,eob);
        eob_run[zzi]=0;
      }
      oc_enc_token_log(_enc,_pli,zzi,best_token,best_eb);
      /*If a zero run won vs. the combo token we still need to code this
         value.*/
      if(best_token<=OC_DCT_ZRL_TOKEN){
        oc_enc_tokenlog_checkpoint(_enc,stack++,_pli,zzj);
        if(eob2){
          oc_enc_eob_log(_enc,_pli,zzj,eob2);
          /*The cost of any EOB run we disrupted is ignored because doing so
             improved PSNR/SSIM by a small amount.*/
          best_bits-=eob_bits2;
          eob_run[zzj]=0;
        }
        oc_enc_token_log(_enc,_pli,zzj,
         *(OC_DCT_VALUE_TOKEN_PTR+d),*(OC_DCT_VALUE_EB_PTR+d));
      }
      total_bits+=best_bits;
    }
    zzi=zzj+1;
    zzj=zzk;
  }
  /*Code an EOB run to complete this block.
    The cost of the EOB run is not included in the total as explained in
     in a comment in the trellis tokenizer above.*/
  if(zzi<64){
    int eob;
    eob=eob_run[zzi]+1;
    oc_enc_tokenlog_checkpoint(_enc,stack++,_pli,zzi);
    if(eob>=4095){
      oc_enc_token_log(_enc,_pli,zzi,OC_DCT_REPEAT_RUN3_TOKEN,eob);
      eob=0;
    }
    eob_run[zzi]=eob;
  }
  *_stack=stack;
  return total_bits;
}

void oc_enc_pred_dc_frag_rows(oc_enc_ctx *_enc,
 int _pli,int _fragy0,int _frag_yend){
  const oc_fragment_plane *fplane;
  const oc_fragment       *frags;
  ogg_int16_t             *frag_dc;
  ptrdiff_t                fragi;
  int                     *pred_last;
  int                      nhfrags;
  int                      fragx;
  int                      fragy;
  fplane=_enc->state.fplanes+_pli;
  frags=_enc->state.frags;
  frag_dc=_enc->frag_dc;
  pred_last=_enc->dc_pred_last[_pli];
  nhfrags=fplane->nhfrags;
  fragi=fplane->froffset+_fragy0*nhfrags;
  for(fragy=_fragy0;fragy<_frag_yend;fragy++){
    if(fragy==0){
      /*For the first row, all of the cases reduce to just using the previous
         predictor for the same reference frame.*/
      for(fragx=0;fragx<nhfrags;fragx++,fragi++){
        if(frags[fragi].coded){
          int refi;
          refi=frags[fragi].refi;
          frag_dc[fragi]=(ogg_int16_t)(frags[fragi].dc-pred_last[refi]);
          pred_last[refi]=frags[fragi].dc;
        }
      }
    }
    else{
      const oc_fragment *u_frags;
      int                l_ref;
      int                ul_ref;
      int                u_ref;
      u_frags=frags-nhfrags;
      l_ref=-1;
      ul_ref=-1;
      u_ref=u_frags[fragi].refi;
      for(fragx=0;fragx<nhfrags;fragx++,fragi++){
        int ur_ref;
        if(fragx+1>=nhfrags)ur_ref=-1;
        else ur_ref=u_frags[fragi+1].refi;
        if(frags[fragi].coded){
          int pred;
          int refi;
          refi=frags[fragi].refi;
          /*We break out a separate case based on which of our neighbors use
             the same reference frames.
            This is somewhat faster than trying to make a generic case which
             handles all of them, since it reduces lots of poorly predicted
             jumps to one switch statement, and also lets a number of the
             multiplications be optimized out by strength reduction.*/
          switch((l_ref==refi)|(ul_ref==refi)<<1|
           (u_ref==refi)<<2|(ur_ref==refi)<<3){
            default:pred=pred_last[refi];break;
            case  1:
            case  3:pred=frags[fragi-1].dc;break;
            case  2:pred=u_frags[fragi-1].dc;break;
            case  4:
            case  6:
            case 12:pred=u_frags[fragi].dc;break;
            case  5:pred=(frags[fragi-1].dc+u_frags[fragi].dc)/2;break;
            case  8:pred=u_frags[fragi+1].dc;break;
            case  9:
            case 11:
            case 13:{
              pred=(75*frags[fragi-1].dc+53*u_frags[fragi+1].dc)/128;
            }break;
            case 10:pred=(u_frags[fragi-1].dc+u_frags[fragi+1].dc)/2;break;
            case 14:{
              pred=(3*(u_frags[fragi-1].dc+u_frags[fragi+1].dc)
               +10*u_frags[fragi].dc)/16;
            }break;
            case  7:
            case 15:{
              int p0;
              int p1;
              int p2;
              p0=frags[fragi-1].dc;
              p1=u_frags[fragi-1].dc;
              p2=u_frags[fragi].dc;
              pred=(29*(p0+p2)-26*p1)/32;
              if(abs(pred-p2)>128)pred=p2;
              else if(abs(pred-p0)>128)pred=p0;
              else if(abs(pred-p1)>128)pred=p1;
            }break;
          }
          frag_dc[fragi]=(ogg_int16_t)(frags[fragi].dc-pred);
          pred_last[refi]=frags[fragi].dc;
          l_ref=refi;
        }
        else l_ref=-1;
        ul_ref=u_ref;
        u_ref=ur_ref;
      }
    }
  }
}

void oc_enc_tokenize_dc_frag_list(oc_enc_ctx *_enc,int _pli,
 const ptrdiff_t *_coded_fragis,ptrdiff_t _ncoded_fragis,
 int _prev_ndct_tokens1,int _prev_eob_run1){
  const ogg_int16_t *frag_dc;
  ptrdiff_t          fragii;
  unsigned char     *dct_tokens0;
  unsigned char     *dct_tokens1;
  ogg_uint16_t      *extra_bits0;
  ogg_uint16_t      *extra_bits1;
  ptrdiff_t          ti0;
  ptrdiff_t          ti1r;
  ptrdiff_t          ti1w;
  int                eob_run0;
  int                eob_run1;
  int                neobs1;
  int                token;
  int                eb;
  int                token1=OC_DCT_ZRL_TOKEN;
  int                eb1=INT_MAX;
  /*Return immediately if there are no coded fragments; otherwise we'd flush
     any trailing EOB run into the AC 1 list and never read it back out.*/
  if(_ncoded_fragis<=0)return;
  frag_dc=_enc->frag_dc;
  dct_tokens0=_enc->dct_tokens[_pli][0];
  dct_tokens1=_enc->dct_tokens[_pli][1];
  extra_bits0=_enc->extra_bits[_pli][0];
  extra_bits1=_enc->extra_bits[_pli][1];
  ti0=_enc->ndct_tokens[_pli][0];
  ti1w=ti1r=_prev_ndct_tokens1;
  eob_run0=_enc->eob_run[_pli][0];
  /*Flush any trailing EOB run for the 1st AC coefficient.
    This is needed to allow us to track tokens to the end of the list.*/
  eob_run1=_enc->eob_run[_pli][1];
  if(eob_run1>0)oc_enc_eob_log(_enc,_pli,1,eob_run1);
  /*If there was an active EOB run at the start of the 1st AC stack, read it
     in and decode it.*/
  if(_prev_eob_run1>0){
    token1=dct_tokens1[ti1r];
    eb1=extra_bits1[ti1r];
    ti1r++;
    eob_run1=oc_decode_eob_token(token1,eb1);
    /*Consume the portion of the run that came before these fragments.*/
    neobs1=eob_run1-_prev_eob_run1;
  }
  else eob_run1=neobs1=0;
  for(fragii=0;fragii<_ncoded_fragis;fragii++){
    int val;
    /*All tokens in the 1st AC coefficient stack are regenerated as the DC
       coefficients are produced.
      This can be done in-place; stack 1 cannot get larger.*/
    if(!neobs1){
      /*There's no active EOB run in stack 1; read the next token.*/
      token1=dct_tokens1[ti1r];
      eb1=extra_bits1[ti1r];
      ti1r++;
      if(token1<OC_NDCT_EOB_TOKEN_MAX){
        neobs1=oc_decode_eob_token(token1,eb1);
        /*It's an EOB run; add it to the current (inactive) one.
          Because we may have moved entries to stack 0, we may have an
           opportunity to merge two EOB runs in stack 1.*/
        eob_run1+=neobs1;
      }
    }
    val=frag_dc[_coded_fragis[fragii]];
    if(val){
      /*There was a non-zero DC value, so there's no alteration to stack 1
         for this fragment; just code the stack 0 token.*/
      /*Flush any pending EOB run.*/
      if(eob_run0>0){
        token=oc_make_eob_token_full(eob_run0,&eb);
        dct_tokens0[ti0]=(unsigned char)token;
        extra_bits0[ti0]=(ogg_uint16_t)eb;
        ti0++;
        eob_run0=0;
      }
      dct_tokens0[ti0]=*(OC_DCT_VALUE_TOKEN_PTR+val);
      extra_bits0[ti0]=*(OC_DCT_VALUE_EB_PTR+val);
      ti0++;
    }
    else{
      /*Zero DC value; that means the entry in stack 1 might need to be coded
         from stack 0.
        This requires a stack 1 fixup.*/
      if(neobs1>0){
        /*We're in the middle of an active EOB run in stack 1.
          Move it to stack 0.*/
        if(++eob_run0>=4095){
          dct_tokens0[ti0]=OC_DCT_REPEAT_RUN3_TOKEN;
          extra_bits0[ti0]=eob_run0;
          ti0++;
          eob_run0=0;
        }
        eob_run1--;
      }
      else{
        /*No active EOB run in stack 1, so we can't extend one in stack 0.
          Flush it if we've got it.*/
        if(eob_run0>0){
          token=oc_make_eob_token_full(eob_run0,&eb);
          dct_tokens0[ti0]=(unsigned char)token;
          extra_bits0[ti0]=(ogg_uint16_t)eb;
          ti0++;
          eob_run0=0;
        }
        /*Stack 1 token is one of: a pure zero run token, a single
           coefficient token, or a zero run/coefficient combo token.
          A zero run token is expanded and moved to token stack 0, and the
           stack 1 entry dropped.
          A single coefficient value may be transformed into combo token that
           is moved to stack 0, or if it cannot be combined, it is left alone
           and a single length-1 zero run is emitted in stack 0.
          A combo token is extended and moved to stack 0.
          During AC coding, we restrict the run lengths on combo tokens for
           stack 1 to guarantee we can extend them.*/
        switch(token1){
          case OC_DCT_SHORT_ZRL_TOKEN:{
            if(eb1<7){
              dct_tokens0[ti0]=OC_DCT_SHORT_ZRL_TOKEN;
              extra_bits0[ti0]=(ogg_uint16_t)(eb1+1);
              ti0++;
              /*Don't write the AC coefficient back out.*/
              continue;
            }
            /*Fall through.*/
          }
          case OC_DCT_ZRL_TOKEN:{
            dct_tokens0[ti0]=OC_DCT_ZRL_TOKEN;
            extra_bits0[ti0]=(ogg_uint16_t)(eb1+1);
            ti0++;
            /*Don't write the AC coefficient back out.*/
          }continue;
          case OC_ONE_TOKEN:
          case OC_MINUS_ONE_TOKEN:{
            dct_tokens0[ti0]=OC_DCT_RUN_CAT1A;
            extra_bits0[ti0]=(ogg_uint16_t)(token1-OC_ONE_TOKEN);
            ti0++;
            /*Don't write the AC coefficient back out.*/
          }continue;
          case OC_TWO_TOKEN:
          case OC_MINUS_TWO_TOKEN:{
            dct_tokens0[ti0]=OC_DCT_RUN_CAT2A;
            extra_bits0[ti0]=(ogg_uint16_t)(token1-OC_TWO_TOKEN<<1);
            ti0++;
            /*Don't write the AC coefficient back out.*/
          }continue;
          case OC_DCT_VAL_CAT2:{
            dct_tokens0[ti0]=OC_DCT_RUN_CAT2A;
            extra_bits0[ti0]=(ogg_uint16_t)((eb1<<1)+1);
            ti0++;
            /*Don't write the AC coefficient back out.*/
          }continue;
          case OC_DCT_RUN_CAT1A:
          case OC_DCT_RUN_CAT1A+1:
          case OC_DCT_RUN_CAT1A+2:
          case OC_DCT_RUN_CAT1A+3:{
            dct_tokens0[ti0]=(unsigned char)(token1+1);
            extra_bits0[ti0]=(ogg_uint16_t)eb1;
            ti0++;
            /*Don't write the AC coefficient back out.*/
          }continue;
          case OC_DCT_RUN_CAT1A+4:{
            dct_tokens0[ti0]=OC_DCT_RUN_CAT1B;
            extra_bits0[ti0]=(ogg_uint16_t)(eb1<<2);
            ti0++;
            /*Don't write the AC coefficient back out.*/
          }continue;
          case OC_DCT_RUN_CAT1B:{
            if((eb1&3)<3){
              dct_tokens0[ti0]=OC_DCT_RUN_CAT1B;
              extra_bits0[ti0]=(ogg_uint16_t)(eb1+1);
              ti0++;
              /*Don't write the AC coefficient back out.*/
              continue;
            }
            eb1=((eb1&4)<<1)-1;
            /*Fall through.*/
          }
          case OC_DCT_RUN_CAT1C:{
            dct_tokens0[ti0]=OC_DCT_RUN_CAT1C;
            extra_bits0[ti0]=(ogg_uint16_t)(eb1+1);
            ti0++;
            /*Don't write the AC coefficient back out.*/
          }continue;
          case OC_DCT_RUN_CAT2A:{
            eb1=(eb1<<1)-1;
            /*Fall through.*/
          }
          case OC_DCT_RUN_CAT2B:{
            dct_tokens0[ti0]=OC_DCT_RUN_CAT2B;
            extra_bits0[ti0]=(ogg_uint16_t)(eb1+1);
            ti0++;
            /*Don't write the AC coefficient back out.*/
          }continue;
        }
        /*We can't merge tokens, write a short zero run and keep going.*/
        dct_tokens0[ti0]=OC_DCT_SHORT_ZRL_TOKEN;
        extra_bits0[ti0]=0;
        ti0++;
      }
    }
    if(!neobs1){
      /*Flush any (inactive) EOB run.*/
      if(eob_run1>0){
        token=oc_make_eob_token_full(eob_run1,&eb);
        dct_tokens1[ti1w]=(unsigned char)token;
        extra_bits1[ti1w]=(ogg_uint16_t)eb;
        ti1w++;
        eob_run1=0;
      }
      /*There's no active EOB run, so log the current token.*/
      dct_tokens1[ti1w]=(unsigned char)token1;
      extra_bits1[ti1w]=(ogg_uint16_t)eb1;
      ti1w++;
    }
    else{
      /*Otherwise consume one EOB from the current run.*/
      neobs1--;
      /*If we have more than 4095 EOBs outstanding in stack1, flush the run.*/
      if(eob_run1-neobs1>=4095){
        dct_tokens1[ti1w]=OC_DCT_REPEAT_RUN3_TOKEN;
        extra_bits1[ti1w]=4095;
        ti1w++;
        eob_run1-=4095;
      }
    }
  }
  /*Save the current state.*/
  _enc->ndct_tokens[_pli][0]=ti0;
  _enc->ndct_tokens[_pli][1]=ti1w;
  _enc->eob_run[_pli][0]=eob_run0;
  _enc->eob_run[_pli][1]=eob_run1;
}

/*Final EOB run welding.*/
void oc_enc_tokenize_finish(oc_enc_ctx *_enc){
  int pli;
  int zzi;
  /*Emit final EOB runs.*/
  for(pli=0;pli<3;pli++)for(zzi=0;zzi<64;zzi++){
    int eob_run;
    eob_run=_enc->eob_run[pli][zzi];
    if(eob_run>0)oc_enc_eob_log(_enc,pli,zzi,eob_run);
  }
  /*Merge the final EOB run of one token list with the start of the next, if
     possible.*/
  for(zzi=0;zzi<64;zzi++)for(pli=0;pli<3;pli++){
    int       old_tok1;
    int       old_tok2;
    int       old_eb1;
    int       old_eb2;
    int       new_tok;
    int       new_eb;
    int       zzj;
    int       plj;
    ptrdiff_t ti=-1;
    int       run_count;
    /*Make sure this coefficient has tokens at all.*/
    if(_enc->ndct_tokens[pli][zzi]<=0)continue;
    /*Ensure the first token is an EOB run.*/
    old_tok2=_enc->dct_tokens[pli][zzi][0];
    if(old_tok2>=OC_NDCT_EOB_TOKEN_MAX)continue;
    /*Search for a previous coefficient that has any tokens at all.*/
    old_tok1=OC_NDCT_EOB_TOKEN_MAX;
    for(zzj=zzi,plj=pli;zzj>=0;zzj--){
      while(plj-->0){
        ti=_enc->ndct_tokens[plj][zzj]-1;
        if(ti>=_enc->dct_token_offs[plj][zzj]){
          old_tok1=_enc->dct_tokens[plj][zzj][ti];
          break;
        }
      }
      if(plj>=0)break;
      plj=3;
    }
    /*Ensure its last token was an EOB run.*/
    if(old_tok1>=OC_NDCT_EOB_TOKEN_MAX)continue;
    /*Pull off the associated extra bits, if any, and decode the runs.*/
    old_eb1=_enc->extra_bits[plj][zzj][ti];
    old_eb2=_enc->extra_bits[pli][zzi][0];
    run_count=oc_decode_eob_token(old_tok1,old_eb1)
     +oc_decode_eob_token(old_tok2,old_eb2);
    /*We can't possibly combine these into one run.
      It might be possible to split them more optimally, but we'll just leave
       them as-is.*/
    if(run_count>=4096)continue;
    /*We CAN combine them into one run.*/
    new_tok=oc_make_eob_token_full(run_count,&new_eb);
    _enc->dct_tokens[plj][zzj][ti]=(unsigned char)new_tok;
    _enc->extra_bits[plj][zzj][ti]=(ogg_uint16_t)new_eb;
    _enc->dct_token_offs[pli][zzi]++;
  }
}

Coverage Report

Created: 2026-04-01 07:42