src/vp9_probs.c

   1 /*
   2  * Copyright © 2016 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the
   6  * "Software"), to deal in the Software without restriction, including
   7  * without limitation the rights to use, copy, modify, merge, publish,
   8  * distribute, sub license, and/or sell copies of the Software, and to
   9  * permit persons to whom the Software is furnished to do so, subject to
  10  * the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the
  13  * next paragraph) shall be included in all copies or substantial portions
  14  * of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  19  * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
  20  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  21  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  22  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  *
  24  * Authors:
  25  *    Zhao Yakui <yakui.zhao@intel.com>
  26  */
  27 /*
  28  * This file defines some vp9 probability tables, and
  29  * they are ported from libvpx (https://github.com/webmproject/libvpx/).
  30  * The original copyright and licence statement as below.
  31  */
  32
  33 /*
  34  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
  35  *
  36  *  Use of this source code is governed by a BSD-style license
  37  *  that can be found in the LICENSE file in the root of the source
  38  *  tree. An additional intellectual property rights grant can be found
  39  *  in the file PATENTS.  All contributing project authors may
  40  *  be found in the AUTHORS file in the root of the source tree.
  41  */
  42 #include <stdio.h>
  43 #include <stdint.h>
  44 #include <string.h>
  45 #include "vp9_probs.h"
  46 #include "i965_drv_video.h"
  47 #include <stdlib.h>
  48
  49 struct tx_probs default_tx_probs = {
  50     { { 100 },
  51     { 66  } },
  52
  53     { { 20, 152 },
  54     { 15, 101 } },
  55
  56     { { 3, 136, 37 },
  57     { 5, 52,  13 } },
  58 };
  59
  60 vp9_prob default_skip_probs[SKIP_CONTEXTS] = {
  61   192, 128, 64
  62 };
  63
  64 vp9_prob default_inter_mode_probs[INTER_MODE_CONTEXTS]
  65                                               [INTER_MODES - 1] = {
  66   {2,       173,   34},  // 0 = both zero mv
  67   {7,       145,   85},  // 1 = one zero mv + one a predicted mv
  68   {7,       166,   63},  // 2 = two predicted mvs
  69   {7,       94,    66},  // 3 = one predicted/zero and one new mv
  70   {8,       64,    46},  // 4 = two new mvs
  71   {17,      81,    31},  // 5 = one intra neighbour + x
  72   {25,      29,    30},  // 6 = two intra neighbours
  73 };
  74
  75 vp9_prob default_switchable_interp_prob[SWITCHABLE_FILTER_CONTEXTS][SWITCHABLE_FILTERS - 1] = {
  76     { 235, 162, },
  77     { 36, 255, },
  78     { 34, 3, },
  79     { 149, 144, },
  80 };
  81
  82 vp9_prob default_intra_inter_p[INTRA_INTER_CONTEXTS] = {
  83   9, 102, 187, 225
  84 };
  85
  86 vp9_prob default_comp_inter_p[COMP_INTER_CONTEXTS] = {
  87   239, 183, 119,  96,  41
  88 };
  89
  90 vp9_prob default_single_ref_p[REF_CONTEXTS][2] = {
  91   {  33,  16 },
  92   {  77,  74 },
  93   { 142, 142 },
  94   { 172, 170 },
  95   { 238, 247 }
  96 };
  97
  98 vp9_prob default_comp_ref_p[REF_CONTEXTS] = {
  99   50, 126, 123, 221, 226
 100 };
 101
 102 vp9_prob vp9_kf_uv_mode_prob[INTRA_MODES][INTRA_MODES - 1] = {
 103   { 144,  11,  54, 157, 195, 130,  46,  58, 108 },  // y = dc
 104   { 118,  15, 123, 148, 131, 101,  44,  93, 131 },  // y = v
 105   { 113,  12,  23, 188, 226, 142,  26,  32, 125 },  // y = h
 106   { 120,  11,  50, 123, 163, 135,  64,  77, 103 },  // y = d45
 107   { 113,   9,  36, 155, 111, 157,  32,  44, 161 },  // y = d135
 108   { 116,   9,  55, 176,  76,  96,  37,  61, 149 },  // y = d117
 109   { 115,   9,  28, 141, 161, 167,  21,  25, 193 },  // y = d153
 110   { 120,  12,  32, 145, 195, 142,  32,  38,  86 },  // y = d207
 111   { 116,  12,  64, 120, 140, 125,  49, 115, 121 },  // y = d63
 112   { 102,  19,  66, 162, 182, 122,  35,  59, 128 }   // y = tm
 113 };
 114
 115 vp9_prob default_if_y_probs[BLOCK_SIZE_GROUPS][INTRA_MODES - 1] = {
 116   {  65,  32,  18, 144, 162, 194,  41,  51,  98 },  // block_size < 8x8
 117   { 132,  68,  18, 165, 217, 196,  45,  40,  78 },  // block_size < 16x16
 118   { 173,  80,  19, 176, 240, 193,  64,  35,  46 },  // block_size < 32x32
 119   { 221, 135,  38, 194, 248, 121,  96,  85,  29 }   // block_size >= 32x32
 120 };
 121
 122 vp9_prob default_if_uv_probs[INTRA_MODES][INTRA_MODES - 1] = {
 123   { 120,   7,  76, 176, 208, 126,  28,  54, 103 },  // y = dc
 124   {  48,  12, 154, 155, 139,  90,  34, 117, 119 },  // y = v
 125   {  67,   6,  25, 204, 243, 158,  13,  21,  96 },  // y = h
 126   {  97,   5,  44, 131, 176, 139,  48,  68,  97 },  // y = d45
 127   {  83,   5,  42, 156, 111, 152,  26,  49, 152 },  // y = d135
 128   {  80,   5,  58, 178,  74,  83,  33,  62, 145 },  // y = d117
 129   {  86,   5,  32, 154, 192, 168,  14,  22, 163 },  // y = d153
 130   {  85,   5,  32, 156, 216, 148,  19,  29,  73 },  // y = d207
 131   {  77,   7,  64, 116, 132, 122,  37, 126, 120 },  // y = d63
 132   { 101,  21, 107, 181, 192, 103,  19,  67, 125 }   // y = tm
 133 };
 134
 135 vp9_prob default_seg_tree_probs[SEG_TREE_PROBS] = {
 136     255, 255, 255, 255, 255, 255, 255
 137 };
 138
 139 vp9_prob default_seg_pred_probs[PREDICTION_PROBS] = {
 140     255, 255, 255
 141 };
 142
 143 vp9_prob vp9_kf_partition_probs[PARTITION_CONTEXTS]
 144                                      [PARTITION_TYPES - 1] = {
 145   // 8x8 -> 4x4
 146   { 158,  97,  94 },  // a/l both not split
 147   {  93,  24,  99 },  // a split, l not split
 148   {  85, 119,  44 },  // l split, a not split
 149   {  62,  59,  67 },  // a/l both split
 150   // 16x16 -> 8x8
 151   { 149,  53,  53 },  // a/l both not split
 152   {  94,  20,  48 },  // a split, l not split
 153   {  83,  53,  24 },  // l split, a not split
 154   {  52,  18,  18 },  // a/l both split
 155   // 32x32 -> 16x16
 156   { 150,  40,  39 },  // a/l both not split
 157   {  78,  12,  26 },  // a split, l not split
 158   {  67,  33,  11 },  // l split, a not split
 159   {  24,   7,   5 },  // a/l both split
 160   // 64x64 -> 32x32
 161   { 174,  35,  49 },  // a/l both not split
 162   {  68,  11,  27 },  // a split, l not split
 163   {  57,  15,   9 },  // l split, a not split
 164   {  12,   3,   3 },  // a/l both split
 165 };
 166
 167 vp9_prob default_partition_probs[PARTITION_CONTEXTS]
 168                                              [PARTITION_TYPES - 1] = {
 169   // 8x8 -> 4x4
 170   { 199, 122, 141 },  // a/l both not split
 171   { 147,  63, 159 },  // a split, l not split
 172   { 148, 133, 118 },  // l split, a not split
 173   { 121, 104, 114 },  // a/l both split
 174   // 16x16 -> 8x8
 175   { 174,  73,  87 },  // a/l both not split
 176   {  92,  41,  83 },  // a split, l not split
 177   {  82,  99,  50 },  // l split, a not split
 178   {  53,  39,  39 },  // a/l both split
 179   // 32x32 -> 16x16
 180   { 177,  58,  59 },  // a/l both not split
 181   {  68,  26,  63 },  // a split, l not split
 182   {  52,  79,  25 },  // l split, a not split
 183   {  17,  14,  12 },  // a/l both split
 184   // 64x64 -> 32x32
 185   { 222,  34,  30 },  // a/l both not split
 186   {  72,  16,  44 },  // a split, l not split
 187   {  58,  32,  12 },  // l split, a not split
 188   {  10,   7,   6 },  // a/l both split
 189 };
 190
 191 //Rearranged the values for better usage
 192 nmv_context default_nmv_context = {
 193   {32, 64, 96},
 194   {
 195     { // Vertical component
 196       128,                                                  // sign
 197       {224, 144, 192, 168, 192, 176, 192, 198, 198, 245},   // class
 198       {216},                                                // class0
 199       {136, 140, 148, 160, 176, 192, 224, 234, 234, 240},   // bits
 200     },
 201     { // Horizontal component
 202       128,                                                  // sign
 203       {216, 128, 176, 160, 176, 176, 192, 198, 198, 208},   // class
 204       {208},                                                // class0
 205       {136, 140, 148, 160, 176, 192, 224, 234, 234, 240},   // bits
 206     }
 207   },
 208   {{128, 128, 64}, {96, 112, 64}},                      // class0_fp0
 209   {64, 96, 64},                                         // fp0
 210   {{128, 128, 64}, {96, 112, 64}},                      // class0_fp1
 211   {64, 96, 64},                                         // fp1
 212   {160, 128},                                           // class0_hp bit
 213   {160, 128}                                            // hp
 214
 215 };
 216
 217 //Rearranged the coeff probs for better usage
 218 vp9_prob default_coef_probs_4x4[COEFF_PROB_SIZE][COEFF_PROB_NUM] = {
 219     // Y plane - Intra
 220     // Band 0
 221     { 195,  29, 183 }, {  84,  49, 136 }, {   8,  42,  71 },
 222     // Band 1
 223     {  31, 107, 169 }, {  35,  99, 159 }, {  17,  82, 140 },
 224     {   8,  66, 114 }, {   2,  44,  76 }, {   1,  19,  32 },
 225     // Band 2
 226     {  40, 132, 201 }, {  29, 114, 187 }, {  13,  91, 157 },
 227     {   7,  75, 127 }, {   3,  58,  95 }, {   1,  28,  47 },
 228     // Band 3
 229     {  69, 142, 221 }, {  42, 122, 201 }, {  15,  91, 159 },
 230     {   6,  67, 121 }, {   1,  42,  77 }, {   1,  17,  31 },
 231     // Band 4
 232     { 102, 148, 228 }, {  67, 117, 204 }, {  17,  82, 154 },
 233     {   6,  59, 114 }, {   2,  39,  75 }, {   1,  15,  29 },
 234     // Band 5
 235     { 156,  57, 233 }, { 119,  57, 212 }, {  58,  48, 163 },
 236     {  29,  40, 124 }, {  12,  30,  81 }, {   3,  12,  31 },
 237
 238     // Y plane - Inter
 239     // Band 0
 240     { 191, 107, 226 }, { 124, 117, 204 }, {  25,  99, 155 },
 241     // Band 1
 242     {  29, 148, 210 }, {  37, 126, 194 }, {   8,  93, 157 },
 243     {   2,  68, 118 }, {   1,  39,  69 }, {   1,  17,  33 },
 244     // Band 2
 245     {  41, 151, 213 }, {  27, 123, 193 }, {   3,  82, 144 },
 246     {   1,  58, 105 }, {   1,  32,  60 }, {   1,  13,  26 },
 247     // Band 3
 248     {  59, 159, 220 }, {  23, 126, 198 }, {   4,  88, 151 },
 249     {   1,  66, 114 }, {   1,  38,  71 }, {   1,  18,  34 },
 250     // Band 4
 251     { 114, 136, 232 }, {  51, 114, 207 }, {  11,  83, 155 },
 252     {   3,  56, 105 }, {   1,  33,  65 }, {   1,  17,  34 },
 253     // Band 5
 254     { 149,  65, 234 }, { 121,  57, 215 }, {  61,  49, 166 },
 255     {  28,  36, 114 }, {  12,  25,  76 }, {   3,  16,  42 },
 256
 257     // UV plane - Intra
 258     // Band 0
 259     { 214,  49, 220 }, { 132,  63, 188 }, {  42,  65, 137 },
 260     // Band 1
 261     {  85, 137, 221 }, { 104, 131, 216 }, {  49, 111, 192 },
 262     {  21,  87, 155 }, {   2,  49,  87 }, {   1,  16,  28 },
 263     // Band 2
 264     {  89, 163, 230 }, {  90, 137, 220 }, {  29, 100, 183 },
 265     {  10,  70, 135 }, {   2,  42,  81 }, {   1,  17,  33 },
 266     // Band 3
 267     { 108, 167, 237 }, {  55, 133, 222 }, {  15,  97, 179 },
 268     {   4,  72, 135 }, {   1,  45,  85 }, {   1,  19,  38 },
 269     // Band 4
 270     { 124, 146, 240 }, {  66, 124, 224 }, {  17,  88, 175 },
 271     {   4,  58, 122 }, {   1,  36,  75 }, {   1,  18,  37 },
 272     //  Band 5
 273     { 141,  79, 241 }, { 126,  70, 227 }, {  66,  58, 182 },
 274     {  30,  44, 136 }, {  12,  34,  96 }, {   2,  20,  47 },
 275
 276     // UV plane - Inter
 277     // Band 0
 278     { 229,  99, 249 }, { 143, 111, 235 }, {  46, 109, 192 },
 279     // Band 1
 280     {  82, 158, 236 }, {  94, 146, 224 }, {  25, 117, 191 },
 281     {   9,  87, 149 }, {   3,  56,  99 }, {   1,  33,  57 },
 282     // Band 2
 283     {  83, 167, 237 }, {  68, 145, 222 }, {  10, 103, 177 },
 284     {   2,  72, 131 }, {   1,  41,  79 }, {   1,  20,  39 },
 285     // Band 3
 286     {  99, 167, 239 }, {  47, 141, 224 }, {  10, 104, 178 },
 287     {   2,  73, 133 }, {   1,  44,  85 }, {   1,  22,  47 },
 288     // Band 4
 289     { 127, 145, 243 }, {  71, 129, 228 }, {  17,  93, 177 },
 290     {   3,  61, 124 }, {   1,  41,  84 }, {   1,  21,  52 },
 291     // Band 5
 292     { 157,  78, 244 }, { 140,  72, 231 }, {  69,  58, 184 },
 293     {  31,  44, 137 }, {  14,  38, 105 }, {   8,  23,  61 }
 294 };
 295
 296 vp9_prob default_coef_probs_8x8[COEFF_PROB_SIZE][COEFF_PROB_NUM] = {
 297     // Y plane - Intra
 298     // Band 0
 299     { 125,  34, 187 }, {  52,  41, 133 }, {   6,  31,  56 },
 300     // Band 1
 301     {  37, 109, 153 }, {  51, 102, 147 }, {  23,  87, 128 },
 302     {   8,  67, 101 }, {   1,  41,  63 }, {   1,  19,  29 },
 303     // Band 2
 304     {  31, 154, 185 }, {  17, 127, 175 }, {   6,  96, 145 },
 305     {   2,  73, 114 }, {   1,  51,  82 }, {   1,  28,  45 },
 306     // Band 3
 307     {  23, 163, 200 }, {  10, 131, 185 }, {   2,  93, 148 },
 308     {   1,  67, 111 }, {   1,  41,  69 }, {   1,  14,  24 },
 309     // Band 4
 310     {  29, 176, 217 }, {  12, 145, 201 }, {   3, 101, 156 },
 311     {   1,  69, 111 }, {   1,  39,  63 }, {   1,  14,  23 },
 312     // Band 5
 313     {  57, 192, 233 }, {  25, 154, 215 }, {   6, 109, 167 },
 314     {   3,  78, 118 }, {   1,  48,  69 }, {   1,  21,  29 },
 315
 316     // Y plane - Inter
 317     // Band 0
 318     { 202, 105, 245 }, { 108, 106, 216 }, {  18,  90, 144 },
 319     // Band 1
 320     {  33, 172, 219 }, {  64, 149, 206 }, {  14, 117, 177 },
 321     {   5,  90, 141 }, {   2,  61,  95 }, {   1,  37,  57 },
 322     // Band 2
 323     {  33, 179, 220 }, {  11, 140, 198 }, {   1,  89, 148 },
 324     {   1,  60, 104 }, {   1,  33,  57 }, {   1,  12,  21 },
 325     // Band 3
 326     {  30, 181, 221 }, {   8, 141, 198 }, {   1,  87, 145 },
 327     {   1,  58, 100 }, {   1,  31,  55 }, {   1,  12,  20 },
 328     // Band 4
 329     {  32, 186, 224 }, {   7, 142, 198 }, {   1,  86, 143 },
 330     {   1,  58, 100 }, {   1,  31,  55 }, {   1,  12,  22 },
 331     // Band 5
 332     {  57, 192, 227 }, {  20, 143, 204 }, {   3,  96, 154 },
 333     {   1,  68, 112 }, {   1,  42,  69 }, {   1,  19,  32 },
 334
 335     // UV plane - Intra
 336     // Band 0
 337     { 212,  35, 215 }, { 113,  47, 169 }, {  29,  48, 105 },
 338     // Band 1
 339     {  74, 129, 203 }, { 106, 120, 203 }, {  49, 107, 178 },
 340     {  19,  84, 144 }, {   4,  50,  84 }, {   1,  15,  25 },
 341     // Band 2
 342     {  71, 172, 217 }, {  44, 141, 209 }, {  15, 102, 173 },
 343     {   6,  76, 133 }, {   2,  51,  89 }, {   1,  24,  42 },
 344     // Band 3
 345     {  64, 185, 231 }, {  31, 148, 216 }, {   8, 103, 175 },
 346     {   3,  74, 131 }, {   1,  46,  81 }, {   1,  18,  30 },
 347     // Band 4
 348     {  65, 196, 235 }, {  25, 157, 221 }, {   5, 105, 174 },
 349     {   1,  67, 120 }, {   1,  38,  69 }, {   1,  15,  30 },
 350     // Band 5
 351     {  65, 204, 238 }, {  30, 156, 224 }, {   7, 107, 177 },
 352     {   2,  70, 124 }, {   1,  42,  73 }, {   1,  18,  34 },
 353
 354     // UV Plane - Inter
 355     // Band 0
 356     { 225,  86, 251 }, { 144, 104, 235 }, {  42,  99, 181 },
 357     // Band 1
 358     {  85, 175, 239 }, { 112, 165, 229 }, {  29, 136, 200 },
 359     {  12, 103, 162 }, {   6,  77, 123 }, {   2,  53,  84 },
 360     // Band 2
 361     {  75, 183, 239 }, {  30, 155, 221 }, {   3, 106, 171 },
 362     {   1,  74, 128 }, {   1,  44,  76 }, {   1,  17,  28 },
 363     // Band 3
 364     {  73, 185, 240 }, {  27, 159, 222 }, {   2, 107, 172 },
 365     {   1,  75, 127 }, {   1,  42,  73 }, {   1,  17,  29 },
 366     // Band 4
 367     {  62, 190, 238 }, {  21, 159, 222 }, {   2, 107, 172 },
 368     {   1,  72, 122 }, {   1,  40,  71 }, {   1,  18,  32 },
 369     // Band 5
 370     {  61, 199, 240 }, {  27, 161, 226 }, {   4, 113, 180 },
 371     {   1,  76, 129 }, {   1,  46,  80 }, {   1,  23,  41 }
 372 };
 373
 374 vp9_prob default_coef_probs_16x16[COEFF_PROB_SIZE][COEFF_PROB_NUM] = {
 375     // Y plane - Intra
 376     // Band 0
 377     {   7,  27, 153 }, {   5,  30,  95 }, {   1,  16,  30 },
 378     // Band 1
 379     {  50,  75, 127 }, {  57,  75, 124 }, {  27,  67, 108 },
 380     {  10,  54,  86 }, {   1,  33,  52 }, {   1,  12,  18 },
 381     // Band 2
 382     {  43, 125, 151 }, {  26, 108, 148 }, {   7,  83, 122 },
 383     {   2,  59,  89 }, {   1,  38,  60 }, {   1,  17,  27 },
 384     // Band 3
 385     {  23, 144, 163 }, {  13, 112, 154 }, {   2,  75, 117 },
 386     {   1,  50,  81 }, {   1,  31,  51 }, {   1,  14,  23 },
 387     // Band 4
 388     {  18, 162, 185 }, {   6, 123, 171 }, {   1,  78, 125 },
 389     {   1,  51,  86 }, {   1,  31,  54 }, {   1,  14,  23 },
 390     // Band 5
 391     {  15, 199, 227 }, {   3, 150, 204 }, {   1,  91, 146 },
 392     {   1,  55,  95 }, {   1,  30,  53 }, {   1,  11,  20 },
 393
 394     // Y plane - Inter
 395     // Band 0
 396     {  19,  55, 240 }, {  19,  59, 196 }, {   3,  52, 105 },
 397     // Band 1
 398     {  41, 166, 207 }, { 104, 153, 199 }, {  31, 123, 181 },
 399     {  14, 101, 152 }, {   5,  72, 106 }, {   1,  36,  52 },
 400     // Band 2
 401     {  35, 176, 211 }, {  12, 131, 190 }, {   2,  88, 144 },
 402     {   1,  60, 101 }, {   1,  36,  60 }, {   1,  16,  28 },
 403     // Band 3
 404     {  28, 183, 213 }, {   8, 134, 191 }, {   1,  86, 142 },
 405     {   1,  56,  96 }, {   1,  30,  53 }, {   1,  12,  20 },
 406     // Band 4
 407     {  20, 190, 215 }, {   4, 135, 192 }, {   1,  84, 139 },
 408     {   1,  53,  91 }, {   1,  28,  49 }, {   1,  11,  20 },
 409     // Band 5
 410     {  13, 196, 216 }, {   2, 137, 192 }, {   1,  86, 143 },
 411     {   1,  57,  99 }, {   1,  32,  56 }, {   1,  13,  24 },
 412
 413     // UV plane - Intra
 414     // Band 0
 415     { 211,  29, 217 }, {  96,  47, 156 }, {  22,  43,  87 },
 416     // Band 1
 417     {  78, 120, 193 }, { 111, 116, 186 }, {  46, 102, 164 },
 418     {  15,  80, 128 }, {   2,  49,  76 }, {   1,  18,  28 },
 419     // Band 2
 420     {  71, 161, 203 }, {  42, 132, 192 }, {  10,  98, 150 },
 421     {   3,  69, 109 }, {   1,  44,  70 }, {   1,  18,  29 },
 422     // Band 3
 423     {  57, 186, 211 }, {  30, 140, 196 }, {   4,  93, 146 },
 424     {   1,  62, 102 }, {   1,  38,  65 }, {   1,  16,  27 },
 425     // Band 4
 426     {  47, 199, 217 }, {  14, 145, 196 }, {   1,  88, 142 },
 427     {   1,  57,  98 }, {   1,  36,  62 }, {   1,  15,  26 },
 428     // Band 5
 429     {  26, 219, 229 }, {   5, 155, 207 }, {   1,  94, 151 },
 430     {   1,  60, 104 }, {   1,  36,  62 }, {   1,  16,  28 },
 431
 432     // UV plane - Inter
 433     // Band 0
 434     { 233,  29, 248 }, { 146,  47, 220 }, {  43,  52, 140 },
 435     // Band 1
 436     { 100, 163, 232 }, { 179, 161, 222 }, {  63, 142, 204 },
 437     {  37, 113, 174 }, {  26,  89, 137 }, {  18,  68,  97 },
 438     // Band 2
 439     {  85, 181, 230 }, {  32, 146, 209 }, {   7, 100, 164 },
 440     {   3,  71, 121 }, {   1,  45,  77 }, {   1,  18,  30 },
 441     // Band 3
 442     {  65, 187, 230 }, {  20, 148, 207 }, {   2,  97, 159 },
 443     {   1,  68, 116 }, {   1,  40,  70 }, {   1,  14,  29 },
 444     // Band 4
 445     {  40, 194, 227 }, {   8, 147, 204 }, {   1,  94, 155 },
 446     {   1,  65, 112 }, {   1,  39,  66 }, {   1,  14,  26 },
 447     // Band 5
 448     {  16, 208, 228 }, {   3, 151, 207 }, {   1,  98, 160 },
 449     {   1,  67, 117 }, {   1,  41,  74 }, {   1,  17,  31 }
 450 };
 451
 452 vp9_prob default_coef_probs_32x32[COEFF_PROB_SIZE][COEFF_PROB_NUM] = {
 453     // Y plane - Intra
 454     // Band 0
 455     {  17,  38, 140 }, {   7,  34,  80 }, {   1,  17,  29 },
 456     // Band 1
 457     {  37,  75, 128 }, {  41,  76, 128 }, {  26,  66, 116 },
 458     {  12,  52,  94 }, {   2,  32,  55 }, {   1,  10,  16 },
 459     // Band 2
 460     {  50, 127, 154 }, {  37, 109, 152 }, {  16,  82, 121 },
 461     {   5,  59,  85 }, {   1,  35,  54 }, {   1,  13,  20 },
 462     //Band 3
 463     {  40, 142, 167 }, {  17, 110, 157 }, {   2,  71, 112 },
 464     {   1,  44,  72 }, {   1,  27,  45 }, {   1,  11,  17 },
 465     // Band 4
 466     {  30, 175, 188 }, {   9, 124, 169 }, {   1,  74, 116 },
 467     {   1,  48,  78 }, {   1,  30,  49 }, {   1,  11,  18 },
 468     // Band 5
 469     {  10, 222, 223 }, {   2, 150, 194 }, {   1,  83, 128 },
 470     {   1,  48,  79 }, {   1,  27,  45 }, {   1,  11,  17 },
 471
 472     // Y plane - Inter
 473     // Band 0
 474     {  36,  41, 235 }, {  29,  36, 193 }, {  10,  27, 111 },
 475     // Band 1
 476     {  85, 165, 222 }, { 177, 162, 215 }, { 110, 135, 195 },
 477     {  57, 113, 168 }, {  23,  83, 120 }, {  10,  49,  61 },
 478     // Band 2
 479     {  85, 190, 223 }, {  36, 139, 200 }, {   5,  90, 146 },
 480     {   1,  60, 103 }, {   1,  38,  65 }, {   1,  18,  30 },
 481     // Band 3
 482     {  72, 202, 223 }, {  23, 141, 199 }, {   2,  86, 140 },
 483     {   1,  56,  97 }, {   1,  36,  61 }, {   1,  16,  27 },
 484     // Band 4
 485     {  55, 218, 225 }, {  13, 145, 200 }, {   1,  86, 141 },
 486     {   1,  57,  99 }, {   1,  35,  61 }, {   1,  13,  22 },
 487     // Band 5
 488     {  15, 235, 212 }, {   1, 132, 184 }, {   1,  84, 139 },
 489     {   1,  57,  97 }, {   1,  34,  56 }, {   1,  14,  23 },
 490
 491     // UV plane - Intra
 492     // Band 0
 493     { 181,  21, 201 }, {  61,  37, 123 }, {  10,  38,  71 },
 494     // Band 1
 495     {  47, 106, 172 }, {  95, 104, 173 }, {  42,  93, 159 },
 496     {  18,  77, 131 }, {   4,  50,  81 }, {   1,  17,  23 },
 497     // Band 2
 498     {  62, 147, 199 }, {  44, 130, 189 }, {  28, 102, 154 },
 499     {  18,  75, 115 }, {   2,  44,  65 }, {   1,  12,  19 },
 500     // Band 3
 501     {  55, 153, 210 }, {  24, 130, 194 }, {   3,  93, 146 },
 502     {   1,  61,  97 }, {   1,  31,  50 }, {   1,  10,  16 },
 503     // Band 4
 504     {  49, 186, 223 }, {  17, 148, 204 }, {   1,  96, 142 },
 505     {   1,  53,  83 }, {   1,  26,  44 }, {   1,  11,  17 },
 506     // Band 5
 507     {  13, 217, 212 }, {   2, 136, 180 }, {   1,  78, 124 },
 508     {   1,  50,  83 }, {   1,  29,  49 }, {   1,  14,  23 },
 509
 510     // UV plane - Inter
 511     // Band 0
 512     { 197,  13, 247 }, {  82,  17, 222 }, {  25,  17, 162 },
 513     // Band 1
 514     { 126, 186, 247 }, { 234, 191, 243 }, { 176, 177, 234 },
 515     { 104, 158, 220 }, {  66, 128, 186 }, {  55,  90, 137 },
 516     // Band 2
 517     { 111, 197, 242 }, {  46, 158, 219 }, {   9, 104, 171 },
 518     {   2,  65, 125 }, {   1,  44,  80 }, {   1,  17,  91 },
 519     // Band 3
 520     { 104, 208, 245 }, {  39, 168, 224 }, {   3, 109, 162 },
 521     {   1,  79, 124 }, {   1,  50, 102 }, {   1,  43, 102 },
 522     // Band 4
 523     {  84, 220, 246 }, {  31, 177, 231 }, {   2, 115, 180 },
 524     {   1,  79, 134 }, {   1,  55,  77 }, {   1,  60,  79 },
 525     // Band 5
 526     {  43, 243, 240 }, {   8, 180, 217 }, {   1, 115, 166 },
 527     {   1,  84, 121 }, {   1,  51,  67 }, {   1,  16,   6 }
 528
 529 };
 530
 531 #define FC_INTRA_OFFSET      0
 532 #define FC_INTRA_SIZE        1664
 533
 534 #define FC_INTER_OFFSET      1664
 535 #define FC_INTER_SIZE        384
 536
 537 #define FC_SKIP_OFFSET       1664
 538 #define FC_SKIP_SIZE         3
 539
 540 void intel_init_default_vp9_probs(FRAME_CONTEXT *frame_context)
 541 {
 542     if (!frame_context)
 543         return;
 544
 545     frame_context->tx_probs = default_tx_probs;
 546     //dummy 52
 547     memcpy(frame_context->coeff_probs4x4, default_coef_probs_4x4,
 548            sizeof(default_coef_probs_4x4));
 549     memcpy(frame_context->coeff_probs8x8, default_coef_probs_8x8,
 550            sizeof(default_coef_probs_8x8));
 551     memcpy(frame_context->coeff_probs16x16, default_coef_probs_16x16,
 552            sizeof(default_coef_probs_16x16));
 553     memcpy(frame_context->coeff_probs32x32, default_coef_probs_32x32,
 554            sizeof(default_coef_probs_16x16));
 555     //dummy 16
 556     memcpy(frame_context->skip_probs, default_skip_probs,
 557            sizeof(default_skip_probs));
 558     memcpy(frame_context->inter_mode_probs, default_inter_mode_probs,
 559            sizeof(default_inter_mode_probs));
 560     memcpy(frame_context->switchable_interp_prob,
 561            default_switchable_interp_prob,
 562            sizeof(default_switchable_interp_prob));
 563     memcpy(frame_context->intra_inter_prob, default_intra_inter_p,
 564            sizeof(default_intra_inter_p));
 565     memcpy(frame_context->comp_inter_prob, default_comp_inter_p,
 566            sizeof(default_comp_inter_p));
 567     memcpy(frame_context->single_ref_prob, default_single_ref_p,
 568            sizeof(default_single_ref_p));
 569     memcpy(frame_context->comp_ref_prob, default_comp_ref_p,
 570            sizeof(default_comp_ref_p));
 571     memcpy(frame_context->y_mode_prob, default_if_y_probs,
 572            sizeof(default_if_y_probs));
 573     memcpy(frame_context->partition_prob, default_partition_probs,
 574            sizeof(default_partition_probs));
 575     frame_context->nmvc = default_nmv_context;
 576     //dummy 47
 577     memcpy(frame_context->uv_mode_prob, default_if_uv_probs,
 578            sizeof(default_if_uv_probs));
 579     memcpy(frame_context->seg_tree_probs, default_seg_tree_probs,
 580            sizeof(default_seg_tree_probs));
 581     memcpy(frame_context->seg_pred_probs, default_seg_pred_probs,
 582            sizeof(default_seg_pred_probs));
 583     return;
 584 }
 585
 586
 587 void intel_vp9_copy_frame_context(FRAME_CONTEXT *dst,
 588                                   FRAME_CONTEXT *src,
 589                                   bool inter_flag)
 590 {
 591     unsigned char *fc_dst, *fc_src;
 592
 593     if (!dst || !src)
 594         return;
 595
 596     fc_dst = (unsigned char *)dst;
 597     fc_src = (unsigned char *)src;
 598     /* update the prob related with tx_mode/tx_coeff */
 599     memcpy(fc_dst + FC_INTRA_OFFSET, fc_src + FC_INTRA_OFFSET, FC_INTRA_SIZE);
 600
 601     if (inter_flag) {
 602         /* update the prob related with inter-frame */
 603         memcpy(fc_dst + FC_INTER_OFFSET, fc_src + FC_INTER_OFFSET, FC_INTER_SIZE);
 604     } else {
 605         memcpy(fc_dst + FC_SKIP_OFFSET, fc_src + FC_SKIP_OFFSET, FC_SKIP_SIZE);
 606     }
 607 }
 608
 609 void intel_update_intra_frame_context(FRAME_CONTEXT *frame_context)
 610 {
 611     if (!frame_context)
 612         return;
 613
 614     memcpy(frame_context->partition_prob, vp9_kf_partition_probs,
 615            sizeof(vp9_kf_partition_probs));
 616
 617     memcpy(frame_context->uv_mode_prob, vp9_kf_uv_mode_prob,
 618            sizeof(vp9_kf_uv_mode_prob));
 619
 620 }
 621
 622 struct vp9_write_bit_buffer {
 623     uint8_t *bit_buffer;
 624     int bit_offset;
 625 };
 626
 627 static
 628 void vp9_wb_write_bit(struct vp9_write_bit_buffer *wb, int bit)
 629 {
 630     const int off = wb->bit_offset;
 631     const int p = off / 8;
 632     const int q = 7 - off % 8;
 633     if (q == 7) {
 634         wb->bit_buffer[p] = bit << q;
 635     } else {
 636         wb->bit_buffer[p] &= ~(1 << q);
 637         wb->bit_buffer[p] |= bit << q;
 638     }
 639     wb->bit_offset = off + 1;
 640 }
 641
 642 static
 643 void vp9_wb_write_literal(struct vp9_write_bit_buffer *wb, int data, int bits)
 644 {
 645     int bit;
 646     for (bit = bits - 1; bit >= 0; bit--)
 647         vp9_wb_write_bit(wb, (data >> bit) & 1);
 648 }
 649
 650 static
 651 void write_bitdepth_colorspace_sampling(int codec_profile,
 652                                         struct vp9_write_bit_buffer *wb)
 653 {
 654     int profile = VAProfileVP9Profile0;
 655     profile = profile + 0;
 656
 657     if (codec_profile >= (VAProfileVP9Profile0 + 2)) {
 658         /* the bit-depth will be added for VP9Profile2/3 */
 659         /* this will be added later */
 660     }
 661
 662     /* Add the default color-space */
 663     vp9_wb_write_literal(wb, 0, 3);
 664     vp9_wb_write_bit(wb, 0);  // 0: [16, 235] (i.e. xvYCC), 1: [0, 255]
 665
 666     /* the sampling_x/y will be added for VP9Profile1/2/3 later */
 667 }
 668
 669 #define    MAX_TILE_WIDTH_B64    64
 670 #define    MIN_TILE_WIDTH_B64    4
 671
 672 static int get_min_log2_tile_cols(const int sb_cols) {
 673     int min_log2 = 0;
 674
 675     while ((MAX_TILE_WIDTH_B64 << min_log2) < sb_cols)
 676         ++min_log2;
 677
 678     return min_log2;
 679 }
 680
 681 static int get_max_log2_tile_cols(const int sb_cols) {
 682     int max_log2 = 1;
 683
 684     while ((sb_cols >> max_log2) >= MIN_TILE_WIDTH_B64)
 685         ++max_log2;
 686
 687     return max_log2 - 1;
 688 }
 689
 690
 691 bool intel_write_uncompressed_header(struct encode_state *encode_state,
 692                                      int codec_profile,
 693                                      char *header_data,
 694                                      int *header_length,
 695                                      vp9_header_bitoffset *header_bitoffset)
 696 {
 697 #define    VP9_SYNC_CODE_0    0x49
 698 #define    VP9_SYNC_CODE_1    0x83
 699 #define    VP9_SYNC_CODE_2    0x42
 700
 701 #define    VP9_FRAME_MARKER   0x2
 702
 703 #define    REFS_PER_FRAME     3
 704
 705 #define    REF_FRAMES_LOG2    3
 706 #define    REF_FRAMES         (1 << REF_FRAMES_LOG2)
 707
 708 #define    VP9_KEY_FRAME      0
 709
 710     VAEncPictureParameterBufferVP9 *pic_param;
 711     VAEncMiscParameterTypeVP9PerSegmantParam *seg_param = NULL;
 712     struct vp9_write_bit_buffer *wb, vp9_wb;
 713
 714     if (!encode_state->pic_param_ext || !encode_state->pic_param_ext->buffer)
 715         return false;
 716
 717     if (!header_data || !header_bitoffset || !header_length)
 718         return false;
 719
 720     memset(header_bitoffset, 0, sizeof(vp9_header_bitoffset));
 721
 722     pic_param = (VAEncPictureParameterBufferVP9 *)encode_state->pic_param_ext->buffer;
 723
 724     if (encode_state->q_matrix)
 725         seg_param = (VAEncMiscParameterTypeVP9PerSegmantParam *) encode_state->q_matrix->buffer;
 726
 727     vp9_wb.bit_buffer = (uint8_t *)header_data;
 728     vp9_wb.bit_offset = 0;
 729     wb = &vp9_wb;
 730     vp9_wb_write_literal(wb, VP9_FRAME_MARKER, 2);
 731
 732     if (codec_profile == VAProfileVP9Profile0) {
 733         vp9_wb_write_literal(wb, 0, 2);
 734     } else {
 735          /* Other VP9Profile1/2/3 will be added later */
 736     }
 737
 738     vp9_wb_write_bit(wb, 0);  // show_existing_frame
 739     vp9_wb_write_bit(wb, pic_param->pic_flags.bits.frame_type);
 740     vp9_wb_write_bit(wb, pic_param->pic_flags.bits.show_frame);
 741     vp9_wb_write_bit(wb, pic_param->pic_flags.bits.error_resilient_mode);
 742
 743     if (pic_param->pic_flags.bits.frame_type == VP9_KEY_FRAME) {
 744         vp9_wb_write_literal(wb, VP9_SYNC_CODE_0, 8);
 745         vp9_wb_write_literal(wb, VP9_SYNC_CODE_1, 8);
 746         vp9_wb_write_literal(wb, VP9_SYNC_CODE_2, 8);
 747
 748         write_bitdepth_colorspace_sampling(codec_profile, wb);
 749
 750         /* write the encoded frame size */
 751         vp9_wb_write_literal(wb, pic_param->frame_width_dst - 1, 16);
 752         vp9_wb_write_literal(wb, pic_param->frame_height_dst - 1, 16);
 753         /* write display size */
 754         if ((pic_param->frame_width_dst != pic_param->frame_width_src) ||
 755             (pic_param->frame_height_dst != pic_param->frame_height_src)) {
 756             vp9_wb_write_bit(wb, 1);
 757             vp9_wb_write_literal(wb, pic_param->frame_width_src - 1, 16);
 758             vp9_wb_write_literal(wb, pic_param->frame_height_src - 1, 16);
 759         } else
 760             vp9_wb_write_bit(wb, 0);
 761     } else {
 762         /* for the non-Key frame */
 763         if (!pic_param->pic_flags.bits.show_frame)
 764             vp9_wb_write_bit(wb, pic_param->pic_flags.bits.intra_only);
 765
 766         if (!pic_param->pic_flags.bits.error_resilient_mode)
 767             vp9_wb_write_literal(wb, pic_param->pic_flags.bits.reset_frame_context, 2);
 768
 769         if (pic_param->pic_flags.bits.intra_only) {
 770             vp9_wb_write_literal(wb, VP9_SYNC_CODE_0, 8);
 771             vp9_wb_write_literal(wb, VP9_SYNC_CODE_1, 8);
 772             vp9_wb_write_literal(wb, VP9_SYNC_CODE_2, 8);
 773
 774             /* Add the bit_depth for VP9Profile1/2/3 */
 775             /* write the refreshed_frame_flags */
 776             vp9_wb_write_literal(wb, pic_param->refresh_frame_flags, REF_FRAMES);
 777             /* write the encoded frame size */
 778             vp9_wb_write_literal(wb, pic_param->frame_width_dst - 1, 16);
 779             vp9_wb_write_literal(wb, pic_param->frame_height_dst - 1, 16);
 780             /* write display size */
 781             if ((pic_param->frame_width_dst != pic_param->frame_width_src) ||
 782                 (pic_param->frame_height_dst != pic_param->frame_height_src)) {
 783                 vp9_wb_write_bit(wb, 1);
 784                 vp9_wb_write_literal(wb, pic_param->frame_width_src - 1, 16);
 785                 vp9_wb_write_literal(wb, pic_param->frame_height_src - 1, 16);
 786             } else
 787                 vp9_wb_write_bit(wb, 0);
 788
 789         } else {
 790             /* The refresh_frame_map is  for the next frame so that it can select Last/Godlen/Alt ref_index */
 791             /*
 792             if ((pic_param->ref_flags.bits.ref_frame_ctrl_l0) & (1 << 0))
 793                 refresh_flags = 1 << pic_param->ref_flags.bits.ref_last_idx;
 794             if ((pic_param->ref_flags.bits.ref_frame_ctrl_l0) & (1 << 0))
 795                 refresh_flags = 1 << pic_param->ref_flags.bits.ref_last_idx;
 796             if ((pic_param->ref_flags.bits.ref_frame_ctrl_l0) & (1 << 0))
 797                 refresh_flags = 1 << pic_param->ref_flags.bits.ref_last_idx;
 798             */
 799             vp9_wb_write_literal(wb, pic_param->refresh_frame_flags, REF_FRAMES);
 800
 801             vp9_wb_write_literal(wb, pic_param->ref_flags.bits.ref_last_idx, REF_FRAMES_LOG2);
 802             vp9_wb_write_bit(wb, pic_param->ref_flags.bits.ref_last_sign_bias);
 803             vp9_wb_write_literal(wb, pic_param->ref_flags.bits.ref_gf_idx, REF_FRAMES_LOG2);
 804             vp9_wb_write_bit(wb, pic_param->ref_flags.bits.ref_gf_sign_bias);
 805             vp9_wb_write_literal(wb, pic_param->ref_flags.bits.ref_arf_idx, REF_FRAMES_LOG2);
 806             vp9_wb_write_bit(wb, pic_param->ref_flags.bits.ref_arf_sign_bias);
 807
 808             /* write three bits with zero so that it can parse width/height directly */
 809             vp9_wb_write_literal(wb, 0, 3);
 810             vp9_wb_write_literal(wb, pic_param->frame_width_dst - 1, 16);
 811             vp9_wb_write_literal(wb, pic_param->frame_height_dst - 1, 16);
 812
 813             /* write display size */
 814             if ((pic_param->frame_width_dst != pic_param->frame_width_src) ||
 815                 (pic_param->frame_height_dst != pic_param->frame_height_src)) {
 816
 817                 vp9_wb_write_bit(wb, 1);
 818                 vp9_wb_write_literal(wb, pic_param->frame_width_src - 1, 16);
 819                 vp9_wb_write_literal(wb, pic_param->frame_height_src - 1, 16);
 820             } else
 821                 vp9_wb_write_bit(wb, 0);
 822
 823             vp9_wb_write_bit(wb, pic_param->pic_flags.bits.allow_high_precision_mv);
 824
 825 #define    SWITCHABLE_FILTER    4
 826 #define    FILTER_MASK          3
 827
 828             if (pic_param->pic_flags.bits.mcomp_filter_type == SWITCHABLE_FILTER)
 829                 vp9_wb_write_bit(wb, 1);
 830             else {
 831                 const int filter_to_literal[4] = { 1, 0, 2, 3 };
 832                 uint8_t filter_flag = pic_param->pic_flags.bits.mcomp_filter_type;
 833                 filter_flag = filter_flag & FILTER_MASK;
 834                 vp9_wb_write_bit(wb, 0);
 835                 vp9_wb_write_literal(wb, filter_to_literal[filter_flag], 2);
 836             }
 837         }
 838     }
 839
 840     /* write refresh_frame_context/paralle frame_decoding */
 841     if (!pic_param->pic_flags.bits.error_resilient_mode) {
 842         vp9_wb_write_bit(wb, pic_param->pic_flags.bits.refresh_frame_context);
 843         vp9_wb_write_bit(wb, pic_param->pic_flags.bits.frame_parallel_decoding_mode);
 844     }
 845
 846     vp9_wb_write_literal(wb, pic_param->pic_flags.bits.frame_context_idx, 2);
 847
 848     /* write loop filter */
 849     header_bitoffset->bit_offset_lf_level = wb->bit_offset;
 850     vp9_wb_write_literal(wb, pic_param->filter_level, 6);
 851     vp9_wb_write_literal(wb, pic_param->sharpness_level, 3);
 852
 853     {
 854         int i, mode_flag;
 855
 856         vp9_wb_write_bit(wb, 1);
 857         vp9_wb_write_bit(wb, 1);
 858         header_bitoffset->bit_offset_ref_lf_delta = wb->bit_offset;
 859         for (i = 0; i < 4; i++) {
 860             /*
 861              * This check is skipped to prepare the bit_offset_lf_ref
 862             if (pic_param->ref_lf_delta[i] == 0) {
 863                 vp9_wb_write_bit(wb, 0);
 864                 continue;
 865             }
 866              */
 867
 868             vp9_wb_write_bit(wb, 1);
 869             mode_flag = pic_param->ref_lf_delta[i];
 870             if (mode_flag >=0) {
 871                 vp9_wb_write_literal(wb, mode_flag & (0x3F), 6);
 872                 vp9_wb_write_bit(wb, 0);
 873             } else {
 874                 mode_flag = -mode_flag;
 875                 vp9_wb_write_literal(wb, mode_flag & (0x3F), 6);
 876                 vp9_wb_write_bit(wb, 1);
 877             }
 878         }
 879
 880         header_bitoffset->bit_offset_mode_lf_delta = wb->bit_offset;
 881         for (i = 0; i < 2; i++) {
 882             /*
 883              * This check is skipped to prepare the bit_offset_lf_ref
 884             if (pic_param->mode_lf_delta[i] == 0) {
 885                 vp9_wb_write_bit(wb, 0);
 886                 continue;
 887             }
 888              */
 889             vp9_wb_write_bit(wb, 1);
 890             mode_flag = pic_param->mode_lf_delta[i];
 891             if (mode_flag >=0) {
 892                 vp9_wb_write_literal(wb, mode_flag & (0x3F), 6);
 893                 vp9_wb_write_bit(wb, 0);
 894             } else {
 895                 mode_flag = -mode_flag;
 896                 vp9_wb_write_literal(wb, mode_flag & (0x3F), 6);
 897                 vp9_wb_write_bit(wb, 1);
 898             }
 899         }
 900     }
 901
 902     /* write basic quantizer */
 903     header_bitoffset->bit_offset_qindex = wb->bit_offset;
 904     vp9_wb_write_literal(wb, pic_param->luma_ac_qindex, 8);
 905     if (pic_param->luma_dc_qindex_delta) {
 906         int delta_q = pic_param->luma_dc_qindex_delta;
 907         vp9_wb_write_bit(wb, 1);
 908         vp9_wb_write_literal(wb, abs(delta_q), 4);
 909         vp9_wb_write_bit(wb, delta_q < 0);
 910     } else
 911         vp9_wb_write_bit(wb, 0);
 912
 913     if (pic_param->chroma_dc_qindex_delta) {
 914         int delta_q = pic_param->chroma_dc_qindex_delta;
 915         vp9_wb_write_bit(wb, 1);
 916         vp9_wb_write_literal(wb, abs(delta_q), 4);
 917         vp9_wb_write_bit(wb, delta_q < 0);
 918     } else
 919         vp9_wb_write_bit(wb, 0);
 920
 921     if (pic_param->chroma_ac_qindex_delta) {
 922         int delta_q = pic_param->chroma_ac_qindex_delta;
 923         vp9_wb_write_bit(wb, 1);
 924         vp9_wb_write_literal(wb, abs(delta_q), 4);
 925         vp9_wb_write_bit(wb, delta_q < 0);
 926     } else
 927         vp9_wb_write_bit(wb, 0);
 928
 929     vp9_wb_write_bit(wb, pic_param->pic_flags.bits.segmentation_enabled);
 930     if (pic_param->pic_flags.bits.segmentation_enabled) {
 931         int i;
 932
 933 #define VP9_MAX_PROB    255
 934         vp9_wb_write_bit(wb, pic_param->pic_flags.bits.segmentation_update_map);
 935         if (pic_param->pic_flags.bits.segmentation_update_map) {
 936
 937             header_bitoffset->bit_offset_segmentation = wb->bit_offset;
 938             /* write the seg_tree_probs */
 939             /* segment_tree_probs/segment_pred_probs are not passed.
 940              * So the hard-coded prob is writen
 941              */
 942             for (i = 0; i < 7; i++) {
 943                 vp9_wb_write_bit(wb, 1);
 944                 vp9_wb_write_literal(wb, VP9_MAX_PROB, 8);
 945             }
 946
 947             vp9_wb_write_bit(wb, pic_param->pic_flags.bits.segmentation_temporal_update);
 948             if (pic_param->pic_flags.bits.segmentation_temporal_update) {
 949                 for (i = 0; i < 3; i++) {
 950                     vp9_wb_write_bit(wb, 1);
 951                     vp9_wb_write_literal(wb, VP9_MAX_PROB, 8);
 952                 }
 953             }
 954         }
 955
 956         /* write the segment_data info */
 957         if (seg_param == NULL) {
 958             vp9_wb_write_bit(wb, 0);
 959         } else {
 960             VAEncSegParamVP9 *seg_data;
 961             int seg_delta;
 962
 963             /* update_data */
 964             vp9_wb_write_bit(wb, 1);
 965             /* abs_delta should be zero */
 966             vp9_wb_write_bit(wb, 0);
 967             for (i = 0; i < 8; i++) {
 968                 seg_data = &seg_param->seg_data[i];
 969
 970                 /* The segment qindex delta */
 971                 /* This check is skipped */
 972                 /* if (seg_data->segment_qindex_delta != 0) */
 973                 if (1) {
 974                     vp9_wb_write_bit(wb, 1);
 975                     seg_delta = seg_data->segment_qindex_delta;
 976                     vp9_wb_write_literal(wb, abs(seg_delta), 8);
 977                     vp9_wb_write_bit(wb, seg_delta < 0);
 978                 } else
 979                     vp9_wb_write_bit(wb, 0);
 980
 981                 /* The segment lf delta */
 982                 /* if (seg_data->segment_lf_level_delta != 0) */
 983                 if (1) {
 984                     vp9_wb_write_bit(wb, 1);
 985                     seg_delta = seg_data->segment_lf_level_delta;
 986                     vp9_wb_write_literal(wb, abs(seg_delta), 6);
 987                     vp9_wb_write_bit(wb, seg_delta < 0);
 988                 } else
 989                     vp9_wb_write_bit(wb, 0);
 990
 991                 /* segment reference flag */
 992                 vp9_wb_write_bit(wb, seg_data->seg_flags.bits.segment_reference_enabled);
 993                 if (seg_data->seg_flags.bits.segment_reference_enabled)
 994                 {
 995                     vp9_wb_write_literal(wb, seg_data->seg_flags.bits.segment_reference, 2);
 996                 }
 997
 998                 /* segment skip flag */
 999                 vp9_wb_write_bit(wb, seg_data->seg_flags.bits.segment_reference_skipped);
1000             }
1001         }
1002     }
1003
1004     /* write tile info */
1005     {
1006         int sb_cols = (pic_param->frame_width_dst + 63) / 64;
1007         int min_log2_tile_cols, max_log2_tile_cols;
1008         int col_data;
1009
1010         /* write tile column info */
1011         min_log2_tile_cols = get_min_log2_tile_cols(sb_cols);
1012         max_log2_tile_cols = get_max_log2_tile_cols(sb_cols);
1013
1014         col_data = pic_param->log2_tile_columns - min_log2_tile_cols;
1015         while(col_data--) {
1016             vp9_wb_write_bit(wb, 1);
1017         }
1018         if (pic_param->log2_tile_columns < max_log2_tile_cols)
1019             vp9_wb_write_bit(wb, 0);
1020
1021         /* write tile row info */
1022         vp9_wb_write_bit(wb, pic_param->log2_tile_rows);
1023         if (pic_param->log2_tile_rows)
1024             vp9_wb_write_bit(wb, (pic_param->log2_tile_rows != 1));
1025     }
1026
1027     /* get the bit_offset of the first partition size */
1028     header_bitoffset->bit_offset_first_partition_size = wb->bit_offset;
1029
1030     /* reserve the space for writing the first partitions ize */
1031     vp9_wb_write_literal(wb, 0, 16);
1032
1033     *header_length = (wb->bit_offset + 7) / 8;
1034
1035     return true;
1036 }