vp8/encoder/bitstream.c

   1 /*
   2  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11
  12 #include "header.h"
  13 #include "encodemv.h"
  14 #include "entropymode.h"
  15 #include "findnearmv.h"
  16 #include "mcomp.h"
  17 #include "systemdependent.h"
  18 #include <assert.h>
  19 #include <stdio.h>
  20 #include "pragmas.h"
  21 #include "vpx_mem/vpx_mem.h"
  22 #include "bitstream.h"
  23
  24 const int vp8cx_base_skip_false_prob[128] =
  25 {
  26     255, 255, 255, 255, 255, 255, 255, 255,
  27     255, 255, 255, 255, 255, 255, 255, 255,
  28     255, 255, 255, 255, 255, 255, 255, 255,
  29     255, 255, 255, 255, 255, 255, 255, 255,
  30     255, 255, 255, 255, 255, 255, 255, 255,
  31     255, 255, 255, 255, 255, 255, 255, 255,
  32     255, 255, 255, 255, 255, 255, 255, 255,
  33     251, 248, 244, 240, 236, 232, 229, 225,
  34     221, 217, 213, 208, 204, 199, 194, 190,
  35     187, 183, 179, 175, 172, 168, 164, 160,
  36     157, 153, 149, 145, 142, 138, 134, 130,
  37     127, 124, 120, 117, 114, 110, 107, 104,
  38     101, 98,  95,  92,  89,  86,  83, 80,
  39     77,  74,  71,  68,  65,  62,  59, 56,
  40     53,  50,  47,  44,  41,  38,  35, 32,
  41     30,  28,  26,  24,  22,  20,  18, 16,
  42 };
  43 #ifdef VP8REF
  44 #define __int64 long long
  45 #endif
  46
  47 #if defined(SECTIONBITS_OUTPUT)
  48 unsigned __int64 Sectionbits[500];
  49 #endif
  50
  51 #ifdef ENTROPY_STATS
  52 int intra_mode_stats[10][10][10];
  53 static unsigned int tree_update_hist [BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [vp8_coef_tokens-1] [2];
  54 extern unsigned int active_section;
  55 #endif
  56
  57 #ifdef MODE_STATS
  58 int count_mb_seg[4] = { 0, 0, 0, 0 };
  59 #endif
  60
  61 #if CONFIG_BIG_ENDIAN
  62 # define make_endian_16(a)  \
  63     (((unsigned int)(a & 0xff)) << 8) | (((unsigned int)(a & 0xff00)) >> 8)
  64 # define make_endian_32(a)                              \
  65     (((unsigned int)(a & 0xff)) << 24)    | (((unsigned int)(a & 0xff00)) << 8) |   \
  66     (((unsigned int)(a & 0xff0000)) >> 8) | (((unsigned int)(a & 0xff000000)) >> 24)
  67 #else
  68 # define make_endian_16(a)  a
  69 # define make_endian_32(a)  a
  70 #endif
  71
  72 static void update_mode(
  73     vp8_writer *const w,
  74     int n,
  75     vp8_token tok               [/* n */],
  76     vp8_tree tree,
  77     vp8_prob Pnew               [/* n-1 */],
  78     vp8_prob Pcur               [/* n-1 */],
  79     unsigned int bct            [/* n-1 */] [2],
  80     const unsigned int num_events[/* n */]
  81 )
  82 {
  83     unsigned int new_b = 0, old_b = 0;
  84     int i = 0;
  85
  86     vp8_tree_probs_from_distribution(
  87         n--, tok, tree,
  88         Pnew, bct, num_events,
  89         256, 1
  90     );
  91
  92     do
  93     {
  94         new_b += vp8_cost_branch(bct[i], Pnew[i]);
  95         old_b += vp8_cost_branch(bct[i], Pcur[i]);
  96     }
  97     while (++i < n);
  98
  99     if (new_b + (n << 8) < old_b)
 100     {
 101         int i = 0;
 102
 103         vp8_write_bit(w, 1);
 104
 105         do
 106         {
 107             const vp8_prob p = Pnew[i];
 108
 109             vp8_write_literal(w, Pcur[i] = p ? p : 1, 8);
 110         }
 111         while (++i < n);
 112     }
 113     else
 114         vp8_write_bit(w, 0);
 115 }
 116
 117 static void update_mbintra_mode_probs(VP8_COMP *cpi)
 118 {
 119     VP8_COMMON *const x = & cpi->common;
 120
 121     vp8_writer *const w = & cpi->bc;
 122
 123     {
 124         vp8_prob Pnew   [VP8_YMODES-1];
 125         unsigned int bct [VP8_YMODES-1] [2];
 126
 127         update_mode(
 128             w, VP8_YMODES, vp8_ymode_encodings, vp8_ymode_tree,
 129             Pnew, x->fc.ymode_prob, bct, (unsigned int *)cpi->ymode_count
 130         );
 131     }
 132     {
 133         vp8_prob Pnew   [VP8_UV_MODES-1];
 134         unsigned int bct [VP8_UV_MODES-1] [2];
 135
 136         update_mode(
 137             w, VP8_UV_MODES, vp8_uv_mode_encodings, vp8_uv_mode_tree,
 138             Pnew, x->fc.uv_mode_prob, bct, (unsigned int *)cpi->uv_mode_count
 139         );
 140     }
 141 }
 142
 143 static void write_ymode(vp8_writer *bc, int m, const vp8_prob *p)
 144 {
 145     vp8_write_token(bc, vp8_ymode_tree, p, vp8_ymode_encodings + m);
 146 }
 147
 148 static void kfwrite_ymode(vp8_writer *bc, int m, const vp8_prob *p)
 149 {
 150     vp8_write_token(bc, vp8_kf_ymode_tree, p, vp8_kf_ymode_encodings + m);
 151 }
 152
 153 static void write_uv_mode(vp8_writer *bc, int m, const vp8_prob *p)
 154 {
 155     vp8_write_token(bc, vp8_uv_mode_tree, p, vp8_uv_mode_encodings + m);
 156 }
 157
 158
 159 static void write_bmode(vp8_writer *bc, int m, const vp8_prob *p)
 160 {
 161     vp8_write_token(bc, vp8_bmode_tree, p, vp8_bmode_encodings + m);
 162 }
 163
 164 static void write_split(vp8_writer *bc, int x)
 165 {
 166     vp8_write_token(
 167         bc, vp8_mbsplit_tree, vp8_mbsplit_probs, vp8_mbsplit_encodings + x
 168     );
 169 }
 170
 171 static const unsigned int norm[256] =
 172 {
 173     0, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 174     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 175     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 176     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 177     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 178     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 179     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 180     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 181 };
 182
 183 static void pack_tokens_c(vp8_writer *w, const TOKENEXTRA *p, int xcount)
 184 {
 185     const TOKENEXTRA *const stop = p + xcount;
 186     unsigned int split;
 187     unsigned int shift;
 188     int count = w->count;
 189     unsigned int range = w->range;
 190     unsigned int lowvalue = w->lowvalue;
 191
 192     while (p < stop)
 193     {
 194         const int t = p->Token;
 195         vp8_token *const a = vp8_coef_encodings + t;
 196         const vp8_extra_bit_struct *const b = vp8_extra_bits + t;
 197         int i = 0;
 198         const unsigned char *pp = p->context_tree;
 199         int v = a->value;
 200         int n = a->Len;
 201
 202         if (p->skip_eob_node)
 203         {
 204             n--;
 205             i = 2;
 206         }
 207
 208         do
 209         {
 210             const int bb = (v >> --n) & 1;
 211             split = 1 + (((range - 1) * pp[i>>1]) >> 8);
 212             i = vp8_coef_tree[i+bb];
 213
 214             if (bb)
 215             {
 216                 lowvalue += split;
 217                 range = range - split;
 218             }
 219             else
 220             {
 221                 range = split;
 222             }
 223
 224             shift = norm[range];
 225             range <<= shift;
 226             count += shift;
 227
 228             if (count >= 0)
 229             {
 230                 int offset = shift - count;
 231
 232                 if ((lowvalue << (offset - 1)) & 0x80000000)
 233                 {
 234                     int x = w->pos - 1;
 235
 236                     while (x >= 0 && w->buffer[x] == 0xff)
 237                     {
 238                         w->buffer[x] = (unsigned char)0;
 239                         x--;
 240                     }
 241
 242                     w->buffer[x] += 1;
 243                 }
 244
 245                 w->buffer[w->pos++] = (lowvalue >> (24 - offset));
 246                 lowvalue <<= offset;
 247                 shift = count;
 248                 lowvalue &= 0xffffff;
 249                 count -= 8 ;
 250             }
 251
 252             lowvalue <<= shift;
 253         }
 254         while (n);
 255
 256
 257         if (b->base_val)
 258         {
 259             const int e = p->Extra, L = b->Len;
 260
 261             if (L)
 262             {
 263                 const unsigned char *pp = b->prob;
 264                 int v = e >> 1;
 265                 int n = L;              /* number of bits in v, assumed nonzero */
 266                 int i = 0;
 267
 268                 do
 269                 {
 270                     const int bb = (v >> --n) & 1;
 271                     split = 1 + (((range - 1) * pp[i>>1]) >> 8);
 272                     i = b->tree[i+bb];
 273
 274                     if (bb)
 275                     {
 276                         lowvalue += split;
 277                         range = range - split;
 278                     }
 279                     else
 280                     {
 281                         range = split;
 282                     }
 283
 284                     shift = norm[range];
 285                     range <<= shift;
 286                     count += shift;
 287
 288                     if (count >= 0)
 289                     {
 290                         int offset = shift - count;
 291
 292                         if ((lowvalue << (offset - 1)) & 0x80000000)
 293                         {
 294                             int x = w->pos - 1;
 295
 296                             while (x >= 0 && w->buffer[x] == 0xff)
 297                             {
 298                                 w->buffer[x] = (unsigned char)0;
 299                                 x--;
 300                             }
 301
 302                             w->buffer[x] += 1;
 303                         }
 304
 305                         w->buffer[w->pos++] = (lowvalue >> (24 - offset));
 306                         lowvalue <<= offset;
 307                         shift = count;
 308                         lowvalue &= 0xffffff;
 309                         count -= 8 ;
 310                     }
 311
 312                     lowvalue <<= shift;
 313                 }
 314                 while (n);
 315             }
 316
 317
 318             {
 319
 320                 split = (range + 1) >> 1;
 321
 322                 if (e & 1)
 323                 {
 324                     lowvalue += split;
 325                     range = range - split;
 326                 }
 327                 else
 328                 {
 329                     range = split;
 330                 }
 331
 332                 range <<= 1;
 333
 334                 if ((lowvalue & 0x80000000))
 335                 {
 336                     int x = w->pos - 1;
 337
 338                     while (x >= 0 && w->buffer[x] == 0xff)
 339                     {
 340                         w->buffer[x] = (unsigned char)0;
 341                         x--;
 342                     }
 343
 344                     w->buffer[x] += 1;
 345
 346                 }
 347
 348                 lowvalue  <<= 1;
 349
 350                 if (!++count)
 351                 {
 352                     count = -8;
 353                     w->buffer[w->pos++] = (lowvalue >> 24);
 354                     lowvalue &= 0xffffff;
 355                 }
 356             }
 357
 358         }
 359
 360         ++p;
 361     }
 362
 363     w->count = count;
 364     w->lowvalue = lowvalue;
 365     w->range = range;
 366
 367 }
 368
 369 static void write_partition_size(unsigned char *cx_data, int size)
 370 {
 371     signed char csize;
 372
 373     csize = size & 0xff;
 374     *cx_data = csize;
 375     csize = (size >> 8) & 0xff;
 376     *(cx_data + 1) = csize;
 377     csize = (size >> 16) & 0xff;
 378     *(cx_data + 2) = csize;
 379
 380 }
 381
 382 static void pack_tokens_into_partitions_c(VP8_COMP *cpi, unsigned char *cx_data, int num_part, int *size)
 383 {
 384
 385     int i;
 386     unsigned char *ptr = cx_data;
 387     unsigned int shift;
 388     vp8_writer *w = &cpi->bc2;
 389     *size = 3 * (num_part - 1);
 390     ptr = cx_data + (*size);
 391
 392     for (i = 0; i < num_part; i++)
 393     {
 394         vp8_start_encode(w, ptr);
 395         {
 396             unsigned int split;
 397             int count = w->count;
 398             unsigned int range = w->range;
 399             unsigned int lowvalue = w->lowvalue;
 400             int mb_row;
 401
 402             for (mb_row = i; mb_row < cpi->common.mb_rows; mb_row += num_part)
 403             {
 404                 TOKENEXTRA *p    = cpi->tplist[mb_row].start;
 405                 TOKENEXTRA *stop = cpi->tplist[mb_row].stop;
 406
 407                 while (p < stop)
 408                 {
 409                     const int t = p->Token;
 410                     vp8_token *const a = vp8_coef_encodings + t;
 411                     const vp8_extra_bit_struct *const b = vp8_extra_bits + t;
 412                     int i = 0;
 413                     const unsigned char *pp = p->context_tree;
 414                     int v = a->value;
 415                     int n = a->Len;
 416
 417                     if (p->skip_eob_node)
 418                     {
 419                         n--;
 420                         i = 2;
 421                     }
 422
 423                     do
 424                     {
 425                         const int bb = (v >> --n) & 1;
 426                         split = 1 + (((range - 1) * pp[i>>1]) >> 8);
 427                         i = vp8_coef_tree[i+bb];
 428
 429                         if (bb)
 430                         {
 431                             lowvalue += split;
 432                             range = range - split;
 433                         }
 434                         else
 435                         {
 436                             range = split;
 437                         }
 438
 439                         shift = norm[range];
 440                         range <<= shift;
 441                         count += shift;
 442
 443                         if (count >= 0)
 444                         {
 445                             int offset = shift - count;
 446
 447                             if ((lowvalue << (offset - 1)) & 0x80000000)
 448                             {
 449                                 int x = w->pos - 1;
 450
 451                                 while (x >= 0 && w->buffer[x] == 0xff)
 452                                 {
 453                                     w->buffer[x] = (unsigned char)0;
 454                                     x--;
 455                                 }
 456
 457                                 w->buffer[x] += 1;
 458                             }
 459
 460                             w->buffer[w->pos++] = (lowvalue >> (24 - offset));
 461                             lowvalue <<= offset;
 462                             shift = count;
 463                             lowvalue &= 0xffffff;
 464                             count -= 8 ;
 465                         }
 466
 467                         lowvalue <<= shift;
 468                     }
 469                     while (n);
 470
 471
 472                     if (b->base_val)
 473                     {
 474                         const int e = p->Extra, L = b->Len;
 475
 476                         if (L)
 477                         {
 478                             const unsigned char *pp = b->prob;
 479                             int v = e >> 1;
 480                             int n = L;              /* number of bits in v, assumed nonzero */
 481                             int i = 0;
 482
 483                             do
 484                             {
 485                                 const int bb = (v >> --n) & 1;
 486                                 split = 1 + (((range - 1) * pp[i>>1]) >> 8);
 487                                 i = b->tree[i+bb];
 488
 489                                 if (bb)
 490                                 {
 491                                     lowvalue += split;
 492                                     range = range - split;
 493                                 }
 494                                 else
 495                                 {
 496                                     range = split;
 497                                 }
 498
 499                                 shift = norm[range];
 500                                 range <<= shift;
 501                                 count += shift;
 502
 503                                 if (count >= 0)
 504                                 {
 505                                     int offset = shift - count;
 506
 507                                     if ((lowvalue << (offset - 1)) & 0x80000000)
 508                                     {
 509                                         int x = w->pos - 1;
 510
 511                                         while (x >= 0 && w->buffer[x] == 0xff)
 512                                         {
 513                                             w->buffer[x] = (unsigned char)0;
 514                                             x--;
 515                                         }
 516
 517                                         w->buffer[x] += 1;
 518                                     }
 519
 520                                     w->buffer[w->pos++] = (lowvalue >> (24 - offset));
 521                                     lowvalue <<= offset;
 522                                     shift = count;
 523                                     lowvalue &= 0xffffff;
 524                                     count -= 8 ;
 525                                 }
 526
 527                                 lowvalue <<= shift;
 528                             }
 529                             while (n);
 530                         }
 531
 532                         {
 533                             split = (range + 1) >> 1;
 534
 535                             if (e & 1)
 536                             {
 537                                 lowvalue += split;
 538                                 range = range - split;
 539                             }
 540                             else
 541                             {
 542                                 range = split;
 543                             }
 544
 545                             range <<= 1;
 546
 547                             if ((lowvalue & 0x80000000))
 548                             {
 549                                 int x = w->pos - 1;
 550
 551                                 while (x >= 0 && w->buffer[x] == 0xff)
 552                                 {
 553                                     w->buffer[x] = (unsigned char)0;
 554                                     x--;
 555                                 }
 556
 557                                 w->buffer[x] += 1;
 558
 559                             }
 560
 561                             lowvalue  <<= 1;
 562
 563                             if (!++count)
 564                             {
 565                                 count = -8;
 566                                 w->buffer[w->pos++] = (lowvalue >> 24);
 567                                 lowvalue &= 0xffffff;
 568                             }
 569                         }
 570
 571                     }
 572
 573                     ++p;
 574                 }
 575             }
 576
 577             w->count    = count;
 578             w->lowvalue = lowvalue;
 579             w->range    = range;
 580
 581         }
 582
 583         vp8_stop_encode(w);
 584         *size +=   w->pos;
 585
 586         if (i < (num_part - 1))
 587         {
 588             write_partition_size(cx_data, w->pos);
 589             cx_data += 3;
 590             ptr += w->pos;
 591         }
 592     }
 593 }
 594
 595
 596 static void pack_mb_row_tokens_c(VP8_COMP *cpi, vp8_writer *w)
 597 {
 598
 599     unsigned int split;
 600     int count = w->count;
 601     unsigned int range = w->range;
 602     unsigned int lowvalue = w->lowvalue;
 603     unsigned int shift;
 604     int mb_row;
 605
 606     for (mb_row = 0; mb_row < cpi->common.mb_rows; mb_row++)
 607     {
 608         TOKENEXTRA *p    = cpi->tplist[mb_row].start;
 609         TOKENEXTRA *stop = cpi->tplist[mb_row].stop;
 610
 611         while (p < stop)
 612         {
 613             const int t = p->Token;
 614             vp8_token *const a = vp8_coef_encodings + t;
 615             const vp8_extra_bit_struct *const b = vp8_extra_bits + t;
 616             int i = 0;
 617             const unsigned char *pp = p->context_tree;
 618             int v = a->value;
 619             int n = a->Len;
 620
 621             if (p->skip_eob_node)
 622             {
 623                 n--;
 624                 i = 2;
 625             }
 626
 627             do
 628             {
 629                 const int bb = (v >> --n) & 1;
 630                 split = 1 + (((range - 1) * pp[i>>1]) >> 8);
 631                 i = vp8_coef_tree[i+bb];
 632
 633                 if (bb)
 634                 {
 635                     lowvalue += split;
 636                     range = range - split;
 637                 }
 638                 else
 639                 {
 640                     range = split;
 641                 }
 642
 643                 shift = norm[range];
 644                 range <<= shift;
 645                 count += shift;
 646
 647                 if (count >= 0)
 648                 {
 649                     int offset = shift - count;
 650
 651                     if ((lowvalue << (offset - 1)) & 0x80000000)
 652                     {
 653                         int x = w->pos - 1;
 654
 655                         while (x >= 0 && w->buffer[x] == 0xff)
 656                         {
 657                             w->buffer[x] = (unsigned char)0;
 658                             x--;
 659                         }
 660
 661                         w->buffer[x] += 1;
 662                     }
 663
 664                     w->buffer[w->pos++] = (lowvalue >> (24 - offset));
 665                     lowvalue <<= offset;
 666                     shift = count;
 667                     lowvalue &= 0xffffff;
 668                     count -= 8 ;
 669                 }
 670
 671                 lowvalue <<= shift;
 672             }
 673             while (n);
 674
 675
 676             if (b->base_val)
 677             {
 678                 const int e = p->Extra, L = b->Len;
 679
 680                 if (L)
 681                 {
 682                     const unsigned char *pp = b->prob;
 683                     int v = e >> 1;
 684                     int n = L;              /* number of bits in v, assumed nonzero */
 685                     int i = 0;
 686
 687                     do
 688                     {
 689                         const int bb = (v >> --n) & 1;
 690                         split = 1 + (((range - 1) * pp[i>>1]) >> 8);
 691                         i = b->tree[i+bb];
 692
 693                         if (bb)
 694                         {
 695                             lowvalue += split;
 696                             range = range - split;
 697                         }
 698                         else
 699                         {
 700                             range = split;
 701                         }
 702
 703                         shift = norm[range];
 704                         range <<= shift;
 705                         count += shift;
 706
 707                         if (count >= 0)
 708                         {
 709                             int offset = shift - count;
 710
 711                             if ((lowvalue << (offset - 1)) & 0x80000000)
 712                             {
 713                                 int x = w->pos - 1;
 714
 715                                 while (x >= 0 && w->buffer[x] == 0xff)
 716                                 {
 717                                     w->buffer[x] = (unsigned char)0;
 718                                     x--;
 719                                 }
 720
 721                                 w->buffer[x] += 1;
 722                             }
 723
 724                             w->buffer[w->pos++] = (lowvalue >> (24 - offset));
 725                             lowvalue <<= offset;
 726                             shift = count;
 727                             lowvalue &= 0xffffff;
 728                             count -= 8 ;
 729                         }
 730
 731                         lowvalue <<= shift;
 732                     }
 733                     while (n);
 734                 }
 735
 736                 {
 737                     split = (range + 1) >> 1;
 738
 739                     if (e & 1)
 740                     {
 741                         lowvalue += split;
 742                         range = range - split;
 743                     }
 744                     else
 745                     {
 746                         range = split;
 747                     }
 748
 749                     range <<= 1;
 750
 751                     if ((lowvalue & 0x80000000))
 752                     {
 753                         int x = w->pos - 1;
 754
 755                         while (x >= 0 && w->buffer[x] == 0xff)
 756                         {
 757                             w->buffer[x] = (unsigned char)0;
 758                             x--;
 759                         }
 760
 761                         w->buffer[x] += 1;
 762
 763                     }
 764
 765                     lowvalue  <<= 1;
 766
 767                     if (!++count)
 768                     {
 769                         count = -8;
 770                         w->buffer[w->pos++] = (lowvalue >> 24);
 771                         lowvalue &= 0xffffff;
 772                     }
 773                 }
 774
 775             }
 776
 777             ++p;
 778         }
 779     }
 780
 781     w->count = count;
 782     w->lowvalue = lowvalue;
 783     w->range = range;
 784
 785 }
 786
 787 static void write_mv_ref
 788 (
 789     vp8_writer *w, MB_PREDICTION_MODE m, const vp8_prob *p
 790 )
 791 {
 792
 793     assert(NEARESTMV <= m  &&  m <= SPLITMV);
 794
 795     vp8_write_token(w, vp8_mv_ref_tree, p,
 796                     vp8_mv_ref_encoding_array - NEARESTMV + m);
 797 }
 798
 799 static void write_sub_mv_ref
 800 (
 801     vp8_writer *w, B_PREDICTION_MODE m, const vp8_prob *p
 802 )
 803 {
 804     assert(LEFT4X4 <= m  &&  m <= NEW4X4);
 805
 806     vp8_write_token(w, vp8_sub_mv_ref_tree, p,
 807                     vp8_sub_mv_ref_encoding_array - LEFT4X4 + m);
 808 }
 809
 810 static void write_mv
 811 (
 812     vp8_writer *w, const MV *mv, const MV *ref, const MV_CONTEXT *mvc
 813 )
 814 {
 815     MV e;
 816     e.row = mv->row - ref->row;
 817     e.col = mv->col - ref->col;
 818
 819     vp8_encode_motion_vector(w, &e, mvc);
 820 }
 821
 822 static void write_mb_features(vp8_writer *w, const MB_MODE_INFO *mi, const MACROBLOCKD *x)
 823 {
 824     // Encode the MB segment id.
 825     if (x->segmentation_enabled && x->update_mb_segmentation_map)
 826     {
 827         switch (mi->segment_id)
 828         {
 829         case 0:
 830             vp8_write(w, 0, x->mb_segment_tree_probs[0]);
 831             vp8_write(w, 0, x->mb_segment_tree_probs[1]);
 832             break;
 833         case 1:
 834             vp8_write(w, 0, x->mb_segment_tree_probs[0]);
 835             vp8_write(w, 1, x->mb_segment_tree_probs[1]);
 836             break;
 837         case 2:
 838             vp8_write(w, 1, x->mb_segment_tree_probs[0]);
 839             vp8_write(w, 0, x->mb_segment_tree_probs[2]);
 840             break;
 841         case 3:
 842             vp8_write(w, 1, x->mb_segment_tree_probs[0]);
 843             vp8_write(w, 1, x->mb_segment_tree_probs[2]);
 844             break;
 845
 846             // TRAP.. This should not happen
 847         default:
 848             vp8_write(w, 0, x->mb_segment_tree_probs[0]);
 849             vp8_write(w, 0, x->mb_segment_tree_probs[1]);
 850             break;
 851         }
 852     }
 853 }
 854
 855
 856 static void pack_inter_mode_mvs(VP8_COMP *const cpi)
 857 {
 858     VP8_COMMON *const pc = & cpi->common;
 859     vp8_writer *const w = & cpi->bc;
 860     const MV_CONTEXT *mvc = pc->fc.mvc;
 861
 862     const int *const rfct = cpi->count_mb_ref_frame_usage;
 863     const int rf_intra = rfct[INTRA_FRAME];
 864     const int rf_inter = rfct[LAST_FRAME] + rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME];
 865
 866     MODE_INFO *m = pc->mi, *ms;
 867     const int mis = pc->mode_info_stride;
 868     int mb_row = -1;
 869
 870     int prob_last_coded;
 871     int prob_gf_coded;
 872     int prob_skip_false = 0;
 873     ms = pc->mi - 1;
 874
 875     cpi->mb.partition_info = cpi->mb.pi;
 876
 877     // Calculate the probabilities to be used to code the reference frame based on actual useage this frame
 878     if (!(cpi->prob_intra_coded = rf_intra * 255 / (rf_intra + rf_inter)))
 879         cpi->prob_intra_coded = 1;
 880
 881     prob_last_coded = rf_inter ? (rfct[LAST_FRAME] * 255) / rf_inter : 128;
 882
 883     if (!prob_last_coded)
 884         prob_last_coded = 1;
 885
 886     prob_gf_coded = (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME])
 887                     ? (rfct[GOLDEN_FRAME] * 255) / (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME]) : 128;
 888
 889     if (!prob_gf_coded)
 890         prob_gf_coded = 1;
 891
 892
 893 #ifdef ENTROPY_STATS
 894     active_section = 1;
 895 #endif
 896
 897     if (pc->mb_no_coeff_skip)
 898     {
 899         prob_skip_false = cpi->skip_false_count * 256 / (cpi->skip_false_count + cpi->skip_true_count);
 900
 901         if (prob_skip_false <= 1)
 902             prob_skip_false = 1;
 903
 904         if (prob_skip_false > 255)
 905             prob_skip_false = 255;
 906
 907         cpi->prob_skip_false = prob_skip_false;
 908         vp8_write_literal(w, prob_skip_false, 8);
 909     }
 910
 911     vp8_write_literal(w, cpi->prob_intra_coded, 8);
 912     vp8_write_literal(w, prob_last_coded, 8);
 913     vp8_write_literal(w, prob_gf_coded, 8);
 914
 915     update_mbintra_mode_probs(cpi);
 916
 917     vp8_write_mvprobs(cpi);
 918
 919     while (++mb_row < pc->mb_rows)
 920     {
 921         int mb_col = -1;
 922
 923         while (++mb_col < pc->mb_cols)
 924         {
 925             const MB_MODE_INFO *const mi = & m->mbmi;
 926             const MV_REFERENCE_FRAME rf = mi->ref_frame;
 927             const MB_PREDICTION_MODE mode = mi->mode;
 928
 929             MACROBLOCKD *xd = &cpi->mb.e_mbd;
 930
 931             // Distance of Mb to the various image edges.
 932             // These specified to 8th pel as they are always compared to MV values that are in 1/8th pel units
 933             xd->mb_to_left_edge = -((mb_col * 16) << 3);
 934             xd->mb_to_right_edge = ((pc->mb_cols - 1 - mb_col) * 16) << 3;
 935             xd->mb_to_top_edge = -((mb_row * 16)) << 3;
 936             xd->mb_to_bottom_edge = ((pc->mb_rows - 1 - mb_row) * 16) << 3;
 937
 938 #ifdef ENTROPY_STATS
 939             active_section = 9;
 940 #endif
 941
 942             if (cpi->mb.e_mbd.update_mb_segmentation_map)
 943                 write_mb_features(w, mi, &cpi->mb.e_mbd);
 944
 945             if (pc->mb_no_coeff_skip)
 946                 vp8_encode_bool(w, m->mbmi.mb_skip_coeff, prob_skip_false);
 947
 948             if (rf == INTRA_FRAME)
 949             {
 950                 vp8_write(w, 0, cpi->prob_intra_coded);
 951 #ifdef ENTROPY_STATS
 952                 active_section = 6;
 953 #endif
 954                 write_ymode(w, mode, pc->fc.ymode_prob);
 955
 956                 if (mode == B_PRED)
 957                 {
 958                     int j = 0;
 959
 960                     do
 961                         write_bmode(w, m->bmi[j].mode, pc->fc.bmode_prob);
 962
 963                     while (++j < 16);
 964                 }
 965
 966                 write_uv_mode(w, mi->uv_mode, pc->fc.uv_mode_prob);
 967             }
 968             else    /* inter coded */
 969             {
 970                 MV best_mv;
 971                 vp8_prob mv_ref_p [VP8_MVREFS-1];
 972
 973                 vp8_write(w, 1, cpi->prob_intra_coded);
 974
 975                 if (rf == LAST_FRAME)
 976                     vp8_write(w, 0, prob_last_coded);
 977                 else
 978                 {
 979                     vp8_write(w, 1, prob_last_coded);
 980                     vp8_write(w, (rf == GOLDEN_FRAME) ? 0 : 1, prob_gf_coded);
 981                 }
 982
 983                 {
 984                     MV n1, n2;
 985                     int ct[4];
 986
 987                     vp8_find_near_mvs(xd, m, &n1, &n2, &best_mv, ct, rf, cpi->common.ref_frame_sign_bias);
 988                     vp8_mv_ref_probs(mv_ref_p, ct);
 989
 990 #ifdef ENTROPY_STATS
 991                     accum_mv_refs(mode, ct);
 992 #endif
 993
 994                 }
 995
 996 #ifdef ENTROPY_STATS
 997                 active_section = 3;
 998 #endif
 999
1000                 write_mv_ref(w, mode, mv_ref_p);
1001
1002                 switch (mode)   /* new, split require MVs */
1003                 {
1004                 case NEWMV:
1005
1006 #ifdef ENTROPY_STATS
1007                     active_section = 5;
1008 #endif
1009
1010                     write_mv(w, &mi->mv.as_mv, &best_mv, mvc);
1011                     break;
1012
1013                 case SPLITMV:
1014                 {
1015                     int j = 0;
1016
1017 #ifdef MODE_STATS
1018                     ++count_mb_seg [mi->partitioning];
1019 #endif
1020
1021                     write_split(w, mi->partitioning);
1022
1023                     do
1024                     {
1025                         const B_MODE_INFO *const b = cpi->mb.partition_info->bmi + j;
1026                         const int *const  L = vp8_mbsplits [mi->partitioning];
1027                         int k = -1;  /* first block in subset j */
1028                         int mv_contz;
1029
1030                         while (j != L[++k])
1031                             if (k >= 16)
1032                                 assert(0);
1033
1034                         mv_contz = vp8_mv_cont
1035                                    (&(vp8_left_bmi(m, k)->mv.as_mv),
1036                                     &(vp8_above_bmi(m, k, mis)->mv.as_mv));
1037                         write_sub_mv_ref(w, b->mode, vp8_sub_mv_ref_prob2 [mv_contz]); //pc->fc.sub_mv_ref_prob);
1038
1039                         if (b->mode == NEW4X4)
1040                         {
1041 #ifdef ENTROPY_STATS
1042                             active_section = 11;
1043 #endif
1044                             write_mv(w, &b->mv.as_mv, &best_mv, (const MV_CONTEXT *) mvc);
1045                         }
1046                     }
1047                     while (++j < cpi->mb.partition_info->count);
1048                 }
1049                 break;
1050                 default:
1051                     break;
1052                 }
1053             }
1054
1055             ++m;
1056             cpi->mb.partition_info++;
1057         }
1058
1059         ++m;  /* skip L prediction border */
1060         cpi->mb.partition_info++;
1061     }
1062 }
1063
1064
1065 static void write_kfmodes(VP8_COMP *cpi)
1066 {
1067     vp8_writer *const bc = & cpi->bc;
1068     const VP8_COMMON *const c = & cpi->common;
1069     /* const */
1070     MODE_INFO *m = c->mi;
1071
1072     int mb_row = -1;
1073     int prob_skip_false = 0;
1074
1075     if (c->mb_no_coeff_skip)
1076     {
1077         prob_skip_false = cpi->skip_false_count * 256 / (cpi->skip_false_count + cpi->skip_true_count);
1078
1079         if (prob_skip_false <= 1)
1080             prob_skip_false = 1;
1081
1082         if (prob_skip_false >= 255)
1083             prob_skip_false = 255;
1084
1085         cpi->prob_skip_false = prob_skip_false;
1086         vp8_write_literal(bc, prob_skip_false, 8);
1087     }
1088
1089     while (++mb_row < c->mb_rows)
1090     {
1091         int mb_col = -1;
1092
1093         while (++mb_col < c->mb_cols)
1094         {
1095             const int ym = m->mbmi.mode;
1096
1097             if (cpi->mb.e_mbd.update_mb_segmentation_map)
1098                 write_mb_features(bc, &m->mbmi, &cpi->mb.e_mbd);
1099
1100             if (c->mb_no_coeff_skip)
1101                 vp8_encode_bool(bc, m->mbmi.mb_skip_coeff, prob_skip_false);
1102
1103             kfwrite_ymode(bc, ym, c->kf_ymode_prob);
1104
1105             if (ym == B_PRED)
1106             {
1107                 const int mis = c->mode_info_stride;
1108                 int i = 0;
1109
1110                 do
1111                 {
1112                     const B_PREDICTION_MODE A = vp8_above_bmi(m, i, mis)->mode;
1113                     const B_PREDICTION_MODE L = vp8_left_bmi(m, i)->mode;
1114                     const int bm = m->bmi[i].mode;
1115
1116 #ifdef ENTROPY_STATS
1117                     ++intra_mode_stats [A] [L] [bm];
1118 #endif
1119
1120                     write_bmode(bc, bm, c->kf_bmode_prob [A] [L]);
1121                 }
1122                 while (++i < 16);
1123             }
1124
1125             write_uv_mode(bc, (m++)->mbmi.uv_mode, c->kf_uv_mode_prob);
1126         }
1127
1128         m++;    // skip L prediction border
1129     }
1130 }
1131 int vp8_estimate_entropy_savings(VP8_COMP *cpi)
1132 {
1133     int i = 0;
1134     int savings = 0;
1135
1136     const int *const rfct = cpi->count_mb_ref_frame_usage;
1137     const int rf_intra = rfct[INTRA_FRAME];
1138     const int rf_inter = rfct[LAST_FRAME] + rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME];
1139     int new_intra, new_last, gf_last, oldtotal, newtotal;
1140     int ref_frame_cost[MAX_REF_FRAMES];
1141
1142     vp8_clear_system_state(); //__asm emms;
1143
1144     if (cpi->common.frame_type != KEY_FRAME)
1145     {
1146         if (!(new_intra = rf_intra * 255 / (rf_intra + rf_inter)))
1147             new_intra = 1;
1148
1149         new_last = rf_inter ? (rfct[LAST_FRAME] * 255) / rf_inter : 128;
1150
1151         gf_last = (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME])
1152                   ? (rfct[GOLDEN_FRAME] * 255) / (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME]) : 128;
1153
1154         // new costs
1155         ref_frame_cost[INTRA_FRAME]   = vp8_cost_zero(new_intra);
1156         ref_frame_cost[LAST_FRAME]    = vp8_cost_one(new_intra)
1157                                         + vp8_cost_zero(new_last);
1158         ref_frame_cost[GOLDEN_FRAME]  = vp8_cost_one(new_intra)
1159                                         + vp8_cost_one(new_last)
1160                                         + vp8_cost_zero(gf_last);
1161         ref_frame_cost[ALTREF_FRAME]  = vp8_cost_one(new_intra)
1162                                         + vp8_cost_one(new_last)
1163                                         + vp8_cost_one(gf_last);
1164
1165         newtotal =
1166             rfct[INTRA_FRAME] * ref_frame_cost[INTRA_FRAME] +
1167             rfct[LAST_FRAME] * ref_frame_cost[LAST_FRAME] +
1168             rfct[GOLDEN_FRAME] * ref_frame_cost[GOLDEN_FRAME] +
1169             rfct[ALTREF_FRAME] * ref_frame_cost[ALTREF_FRAME];
1170
1171
1172         // old costs
1173         ref_frame_cost[INTRA_FRAME]   = vp8_cost_zero(cpi->prob_intra_coded);
1174         ref_frame_cost[LAST_FRAME]    = vp8_cost_one(cpi->prob_intra_coded)
1175                                         + vp8_cost_zero(cpi->prob_last_coded);
1176         ref_frame_cost[GOLDEN_FRAME]  = vp8_cost_one(cpi->prob_intra_coded)
1177                                         + vp8_cost_one(cpi->prob_last_coded)
1178                                         + vp8_cost_zero(cpi->prob_gf_coded);
1179         ref_frame_cost[ALTREF_FRAME]  = vp8_cost_one(cpi->prob_intra_coded)
1180                                         + vp8_cost_one(cpi->prob_last_coded)
1181                                         + vp8_cost_one(cpi->prob_gf_coded);
1182
1183         oldtotal =
1184             rfct[INTRA_FRAME] * ref_frame_cost[INTRA_FRAME] +
1185             rfct[LAST_FRAME] * ref_frame_cost[LAST_FRAME] +
1186             rfct[GOLDEN_FRAME] * ref_frame_cost[GOLDEN_FRAME] +
1187             rfct[ALTREF_FRAME] * ref_frame_cost[ALTREF_FRAME];
1188
1189         savings += (oldtotal - newtotal) / 256;
1190     }
1191
1192
1193     do
1194     {
1195         int j = 0;
1196
1197         do
1198         {
1199             int k = 0;
1200
1201             do
1202             {
1203                 /* at every context */
1204
1205                 /* calc probs and branch cts for this frame only */
1206                 //vp8_prob new_p           [vp8_coef_tokens-1];
1207                 //unsigned int branch_ct   [vp8_coef_tokens-1] [2];
1208
1209                 int t = 0;      /* token/prob index */
1210
1211                 vp8_tree_probs_from_distribution(
1212                     vp8_coef_tokens, vp8_coef_encodings, vp8_coef_tree,
1213                     cpi->frame_coef_probs [i][j][k], cpi->frame_branch_ct [i][j][k], cpi->coef_counts [i][j][k],
1214                     256, 1
1215                 );
1216
1217                 do
1218                 {
1219                     const unsigned int *ct  = cpi->frame_branch_ct [i][j][k][t];
1220                     const vp8_prob newp = cpi->frame_coef_probs [i][j][k][t];
1221
1222                     const vp8_prob old = cpi->common.fc.coef_probs [i][j][k][t];
1223                     const vp8_prob upd = vp8_coef_update_probs [i][j][k][t];
1224
1225                     const int old_b = vp8_cost_branch(ct, old);
1226                     const int new_b = vp8_cost_branch(ct, newp);
1227
1228                     const int update_b = 8 +
1229                                          ((vp8_cost_one(upd) - vp8_cost_zero(upd)) >> 8);
1230
1231                     const int s = old_b - new_b - update_b;
1232
1233                     if (s > 0)
1234                         savings += s;
1235
1236
1237                 }
1238                 while (++t < vp8_coef_tokens - 1);
1239
1240
1241             }
1242             while (++k < PREV_COEF_CONTEXTS);
1243         }
1244         while (++j < COEF_BANDS);
1245     }
1246     while (++i < BLOCK_TYPES);
1247
1248     return savings;
1249 }
1250
1251 static void update_coef_probs(VP8_COMP *cpi)
1252 {
1253     int i = 0;
1254     vp8_writer *const w = & cpi->bc;
1255     int savings = 0;
1256
1257     vp8_clear_system_state(); //__asm emms;
1258
1259
1260     do
1261     {
1262         int j = 0;
1263
1264         do
1265         {
1266             int k = 0;
1267
1268             do
1269             {
1270                 //note: use result from vp8_estimate_entropy_savings, so no need to call vp8_tree_probs_from_distribution here.
1271                 /* at every context */
1272
1273                 /* calc probs and branch cts for this frame only */
1274                 //vp8_prob new_p           [vp8_coef_tokens-1];
1275                 //unsigned int branch_ct   [vp8_coef_tokens-1] [2];
1276
1277                 int t = 0;      /* token/prob index */
1278
1279                 //vp8_tree_probs_from_distribution(
1280                 //    vp8_coef_tokens, vp8_coef_encodings, vp8_coef_tree,
1281                 //    new_p, branch_ct, (unsigned int *)cpi->coef_counts [i][j][k],
1282                 //    256, 1
1283                 //    );
1284
1285                 do
1286                 {
1287                     const unsigned int *ct  = cpi->frame_branch_ct [i][j][k][t];
1288                     const vp8_prob newp = cpi->frame_coef_probs [i][j][k][t];
1289
1290                     vp8_prob *Pold = cpi->common.fc.coef_probs [i][j][k] + t;
1291                     const vp8_prob old = *Pold;
1292                     const vp8_prob upd = vp8_coef_update_probs [i][j][k][t];
1293
1294                     const int old_b = vp8_cost_branch(ct, old);
1295                     const int new_b = vp8_cost_branch(ct, newp);
1296
1297                     const int update_b = 8 +
1298                                          ((vp8_cost_one(upd) - vp8_cost_zero(upd)) >> 8);
1299
1300                     const int s = old_b - new_b - update_b;
1301                     const int u = s > 0 ? 1 : 0;
1302
1303                     vp8_write(w, u, upd);
1304
1305
1306 #ifdef ENTROPY_STATS
1307                     ++ tree_update_hist [i][j][k][t] [u];
1308 #endif
1309
1310                     if (u)
1311                     {
1312                         /* send/use new probability */
1313
1314                         *Pold = newp;
1315                         vp8_write_literal(w, newp, 8);
1316
1317                         savings += s;
1318
1319                     }
1320
1321                 }
1322                 while (++t < vp8_coef_tokens - 1);
1323
1324                 /* Accum token counts for generation of default statistics */
1325 #ifdef ENTROPY_STATS
1326                 t = 0;
1327
1328                 do
1329                 {
1330                     context_counters [i][j][k][t] += cpi->coef_counts [i][j][k][t];
1331                 }
1332                 while (++t < vp8_coef_tokens);
1333
1334 #endif
1335
1336             }
1337             while (++k < PREV_COEF_CONTEXTS);
1338         }
1339         while (++j < COEF_BANDS);
1340     }
1341     while (++i < BLOCK_TYPES);
1342
1343 }
1344 #ifdef PACKET_TESTING
1345 FILE *vpxlogc = 0;
1346 #endif
1347
1348 static void put_delta_q(vp8_writer *bc, int delta_q)
1349 {
1350     if (delta_q != 0)
1351     {
1352         vp8_write_bit(bc, 1);
1353         vp8_write_literal(bc, abs(delta_q), 4);
1354
1355         if (delta_q < 0)
1356             vp8_write_bit(bc, 1);
1357         else
1358             vp8_write_bit(bc, 0);
1359     }
1360     else
1361         vp8_write_bit(bc, 0);
1362 }
1363
1364 void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, unsigned long *size)
1365 {
1366     int i, j;
1367     VP8_HEADER oh;
1368     VP8_COMMON *const pc = & cpi->common;
1369     vp8_writer *const bc = & cpi->bc;
1370     MACROBLOCKD *const xd = & cpi->mb.e_mbd;
1371     int extra_bytes_packed = 0;
1372
1373     unsigned char *cx_data = dest;
1374     const int *mb_feature_data_bits;
1375
1376     oh.show_frame = (int) pc->show_frame;
1377     oh.type = (int)pc->frame_type;
1378     oh.version = pc->version;
1379
1380     mb_feature_data_bits = vp8_mb_feature_data_bits;
1381     cx_data += 3;
1382
1383 #if defined(SECTIONBITS_OUTPUT)
1384     Sectionbits[active_section = 1] += sizeof(VP8_HEADER) * 8 * 256;
1385 #endif
1386
1387     //vp8_kf_default_bmode_probs() is called in vp8_setup_key_frame() once for each
1388     //K frame before encode frame. pc->kf_bmode_prob doesn't get changed anywhere
1389     //else. No need to call it again here. --yw
1390     //vp8_kf_default_bmode_probs( pc->kf_bmode_prob);
1391
1392     // every keyframe send startcode, width, height, scale factor, clamp and color type
1393     if (oh.type == KEY_FRAME)
1394     {
1395         // Start / synch code
1396         cx_data[0] = 0x9D;
1397         cx_data[1] = 0x01;
1398         cx_data[2] = 0x2a;
1399
1400         *((unsigned short *)(cx_data + 3)) = make_endian_16((pc->horiz_scale << 14) | pc->Width);
1401         *((unsigned short *)(cx_data + 5)) = make_endian_16((pc->vert_scale << 14) | pc->Height);
1402
1403         extra_bytes_packed = 7;
1404         cx_data += extra_bytes_packed ;
1405
1406         vp8_start_encode(bc, cx_data);
1407
1408         // signal clr type
1409         vp8_write_bit(bc, pc->clr_type);
1410         vp8_write_bit(bc, pc->clamp_type);
1411
1412     }
1413     else
1414         vp8_start_encode(bc, cx_data);
1415
1416
1417     // Signal whether or not Segmentation is enabled
1418     vp8_write_bit(bc, (xd->segmentation_enabled) ? 1 : 0);
1419
1420     // Indicate which features are enabled
1421     if (xd->segmentation_enabled)
1422     {
1423         // Signal whether or not the segmentation map is being updated.
1424         vp8_write_bit(bc, (xd->update_mb_segmentation_map) ? 1 : 0);
1425         vp8_write_bit(bc, (xd->update_mb_segmentation_data) ? 1 : 0);
1426
1427         if (xd->update_mb_segmentation_data)
1428         {
1429             signed char Data;
1430
1431             vp8_write_bit(bc, (xd->mb_segement_abs_delta) ? 1 : 0);
1432
1433             // For each segmentation feature (Quant and loop filter level)
1434             for (i = 0; i < MB_LVL_MAX; i++)
1435             {
1436                 // For each of the segments
1437                 for (j = 0; j < MAX_MB_SEGMENTS; j++)
1438                 {
1439                     Data = xd->segment_feature_data[i][j];
1440
1441                     // Frame level data
1442                     if (Data)
1443                     {
1444                         vp8_write_bit(bc, 1);
1445
1446                         if (Data < 0)
1447                         {
1448                             Data = - Data;
1449                             vp8_write_literal(bc, Data, mb_feature_data_bits[i]);
1450                             vp8_write_bit(bc, 1);
1451                         }
1452                         else
1453                         {
1454                             vp8_write_literal(bc, Data, mb_feature_data_bits[i]);
1455                             vp8_write_bit(bc, 0);
1456                         }
1457                     }
1458                     else
1459                         vp8_write_bit(bc, 0);
1460                 }
1461             }
1462         }
1463
1464         if (xd->update_mb_segmentation_map)
1465         {
1466             // Write the probs used to decode the segment id for each macro block.
1467             for (i = 0; i < MB_FEATURE_TREE_PROBS; i++)
1468             {
1469                 int Data = xd->mb_segment_tree_probs[i];
1470
1471                 if (Data != 255)
1472                 {
1473                     vp8_write_bit(bc, 1);
1474                     vp8_write_literal(bc, Data, 8);
1475                 }
1476                 else
1477                     vp8_write_bit(bc, 0);
1478             }
1479         }
1480     }
1481
1482     // Code to determine whether or not to update the scan order.
1483     vp8_write_bit(bc, pc->filter_type);
1484     vp8_write_literal(bc, pc->filter_level, 6);
1485     vp8_write_literal(bc, pc->sharpness_level, 3);
1486
1487     // Write out loop filter deltas applied at the MB level based on mode or ref frame (if they are enabled).
1488     vp8_write_bit(bc, (xd->mode_ref_lf_delta_enabled) ? 1 : 0);
1489
1490     if (xd->mode_ref_lf_delta_enabled)
1491     {
1492         // Do the deltas need to be updated
1493         int send_update = xd->mode_ref_lf_delta_update
1494                           || cpi->oxcf.error_resilient_mode;
1495
1496         vp8_write_bit(bc, send_update);
1497         if (send_update)
1498         {
1499             int Data;
1500
1501             // Send update
1502             for (i = 0; i < MAX_REF_LF_DELTAS; i++)
1503             {
1504                 Data = xd->ref_lf_deltas[i];
1505
1506                 // Frame level data
1507                 if (xd->ref_lf_deltas[i] != xd->last_ref_lf_deltas[i]
1508                     || cpi->oxcf.error_resilient_mode)
1509                 {
1510                     xd->last_ref_lf_deltas[i] = xd->ref_lf_deltas[i];
1511                     vp8_write_bit(bc, 1);
1512
1513                     if (Data > 0)
1514                     {
1515                         vp8_write_literal(bc, (Data & 0x3F), 6);
1516                         vp8_write_bit(bc, 0);    // sign
1517                     }
1518                     else
1519                     {
1520                         Data = -Data;
1521                         vp8_write_literal(bc, (Data & 0x3F), 6);
1522                         vp8_write_bit(bc, 1);    // sign
1523                     }
1524                 }
1525                 else
1526                     vp8_write_bit(bc, 0);
1527             }
1528
1529             // Send update
1530             for (i = 0; i < MAX_MODE_LF_DELTAS; i++)
1531             {
1532                 Data = xd->mode_lf_deltas[i];
1533
1534                 if (xd->mode_lf_deltas[i] != xd->last_mode_lf_deltas[i]
1535                     || cpi->oxcf.error_resilient_mode)
1536                 {
1537                     xd->last_mode_lf_deltas[i] = xd->mode_lf_deltas[i];
1538                     vp8_write_bit(bc, 1);
1539
1540                     if (Data > 0)
1541                     {
1542                         vp8_write_literal(bc, (Data & 0x3F), 6);
1543                         vp8_write_bit(bc, 0);    // sign
1544                     }
1545                     else
1546                     {
1547                         Data = -Data;
1548                         vp8_write_literal(bc, (Data & 0x3F), 6);
1549                         vp8_write_bit(bc, 1);    // sign
1550                     }
1551                 }
1552                 else
1553                     vp8_write_bit(bc, 0);
1554             }
1555         }
1556     }
1557
1558     //signal here is multi token partition is enabled
1559     vp8_write_literal(bc, pc->multi_token_partition, 2);
1560
1561     // Frame Qbaseline quantizer index
1562     vp8_write_literal(bc, pc->base_qindex, 7);
1563
1564     // Transmit Dc, Second order and Uv quantizer delta information
1565     put_delta_q(bc, pc->y1dc_delta_q);
1566     put_delta_q(bc, pc->y2dc_delta_q);
1567     put_delta_q(bc, pc->y2ac_delta_q);
1568     put_delta_q(bc, pc->uvdc_delta_q);
1569     put_delta_q(bc, pc->uvac_delta_q);
1570
1571     // When there is a key frame all reference buffers are updated using the new key frame
1572     if (pc->frame_type != KEY_FRAME)
1573     {
1574         // Should the GF or ARF be updated using the transmitted frame or buffer
1575         vp8_write_bit(bc, pc->refresh_golden_frame);
1576         vp8_write_bit(bc, pc->refresh_alt_ref_frame);
1577
1578         // If not being updated from current frame should either GF or ARF be updated from another buffer
1579         if (!pc->refresh_golden_frame)
1580             vp8_write_literal(bc, pc->copy_buffer_to_gf, 2);
1581
1582         if (!pc->refresh_alt_ref_frame)
1583             vp8_write_literal(bc, pc->copy_buffer_to_arf, 2);
1584
1585         // Indicate reference frame sign bias for Golden and ARF frames (always 0 for last frame buffer)
1586         vp8_write_bit(bc, pc->ref_frame_sign_bias[GOLDEN_FRAME]);
1587         vp8_write_bit(bc, pc->ref_frame_sign_bias[ALTREF_FRAME]);
1588     }
1589
1590     vp8_write_bit(bc, pc->refresh_entropy_probs);
1591
1592     if (pc->frame_type != KEY_FRAME)
1593         vp8_write_bit(bc, pc->refresh_last_frame);
1594
1595 #ifdef ENTROPY_STATS
1596
1597     if (pc->frame_type == INTER_FRAME)
1598         active_section = 0;
1599     else
1600         active_section = 7;
1601
1602 #endif
1603
1604     vp8_clear_system_state();  //__asm emms;
1605
1606     //************************************************
1607     // save a copy for later refresh
1608     {
1609         vpx_memcpy(&cpi->common.lfc, &cpi->common.fc, sizeof(cpi->common.fc));
1610     }
1611
1612     update_coef_probs(cpi);
1613
1614 #ifdef ENTROPY_STATS
1615     active_section = 2;
1616 #endif
1617
1618     // Write out the mb_no_coeff_skip flag
1619     vp8_write_bit(bc, pc->mb_no_coeff_skip);
1620
1621     if (pc->frame_type == KEY_FRAME)
1622     {
1623         write_kfmodes(cpi);
1624
1625 #ifdef ENTROPY_STATS
1626         active_section = 8;
1627 #endif
1628     }
1629     else
1630     {
1631         pack_inter_mode_mvs(cpi);
1632
1633 #ifdef ENTROPY_STATS
1634         active_section = 1;
1635 #endif
1636     }
1637
1638     vp8_stop_encode(bc);
1639
1640
1641     if (pc->multi_token_partition != ONE_PARTITION)
1642     {
1643         int num_part;
1644         int asize;
1645         num_part = 1 << pc->multi_token_partition;
1646
1647         pack_tokens_into_partitions(cpi, cx_data + bc->pos, num_part, &asize);
1648
1649         oh.first_partition_length_in_bytes = cpi->bc.pos;
1650
1651         *size = cpi->bc.pos + VP8_HEADER_SIZE + asize + extra_bytes_packed;
1652     }
1653     else
1654     {
1655         vp8_start_encode(&cpi->bc2, cx_data + bc->pos);
1656
1657 #if CONFIG_MULTITHREAD
1658         if (cpi->b_multi_threaded)
1659             pack_mb_row_tokens(cpi, &cpi->bc2);
1660         else
1661 #endif
1662             pack_tokens(&cpi->bc2, cpi->tok, cpi->tok_count);
1663
1664         vp8_stop_encode(&cpi->bc2);
1665         oh.first_partition_length_in_bytes = cpi->bc.pos ;
1666         *size = cpi->bc2.pos + cpi->bc.pos + VP8_HEADER_SIZE + extra_bytes_packed;
1667     }
1668
1669 #if CONFIG_BIG_ENDIAN
1670     {
1671         int v = (oh.first_partition_length_in_bytes << 5) |
1672                 (oh.show_frame << 4) |
1673                 (oh.version << 1) |
1674                 oh.type;
1675
1676         v = make_endian_32(v);
1677         vpx_memcpy(dest, &v, 3);
1678     }
1679 #else
1680     vpx_memcpy(dest, &oh, 3);
1681 #endif
1682 }
1683
1684 #ifdef ENTROPY_STATS
1685 void print_tree_update_probs()
1686 {
1687     int i, j, k, l;
1688     FILE *f = fopen("context.c", "a");
1689     int Sum;
1690     fprintf(f, "\n/* Update probabilities for token entropy tree. */\n\n");
1691     fprintf(f, "const vp8_prob tree_update_probs[BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [vp8_coef_tokens-1] = {\n");
1692
1693     for (i = 0; i < BLOCK_TYPES; i++)
1694     {
1695         fprintf(f, "  { \n");
1696
1697         for (j = 0; j < COEF_BANDS; j++)
1698         {
1699             fprintf(f, "    {\n");
1700
1701             for (k = 0; k < PREV_COEF_CONTEXTS; k++)
1702             {
1703                 fprintf(f, "      {");
1704
1705                 for (l = 0; l < MAX_ENTROPY_TOKENS - 1; l++)
1706                 {
1707                     Sum = tree_update_hist[i][j][k][l][0] + tree_update_hist[i][j][k][l][1];
1708
1709                     if (Sum > 0)
1710                     {
1711                         if (((tree_update_hist[i][j][k][l][0] * 255) / Sum) > 0)
1712                             fprintf(f, "%3ld, ", (tree_update_hist[i][j][k][l][0] * 255) / Sum);
1713                         else
1714                             fprintf(f, "%3ld, ", 1);
1715                     }
1716                     else
1717                         fprintf(f, "%3ld, ", 128);
1718                 }
1719
1720                 fprintf(f, "},\n");
1721             }
1722
1723             fprintf(f, "    },\n");
1724         }
1725
1726         fprintf(f, "  },\n");
1727     }
1728
1729     fprintf(f, "};\n");
1730     fclose(f);
1731 }
1732 #endif