ssim.c 18 KB
Newer Older
John Koleszar's avatar
John Koleszar committed
1
/*
2
 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
John Koleszar's avatar
John Koleszar committed
3
 *
4
 *  Use of this source code is governed by a BSD-style license
5 6
 *  that can be found in the LICENSE file in the root of the source
 *  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.
John Koleszar's avatar
John Koleszar committed
9 10
 */

11
#include <math.h>
12 13
#include "./vpx_dsp_rtcd.h"
#include "vpx_dsp/ssim.h"
14
#include "vpx_ports/mem.h"
John Koleszar's avatar
John Koleszar committed
15

16
void vpx_ssim_parms_16x16_c(const uint8_t *s, int sp, const uint8_t *r,
17 18 19
                            int rp, uint32_t *sum_s, uint32_t *sum_r,
                            uint32_t *sum_sq_s, uint32_t *sum_sq_r,
                            uint32_t *sum_sxr) {
John Koleszar's avatar
John Koleszar committed
20 21 22 23 24 25 26 27 28 29
  int i, j;
  for (i = 0; i < 16; i++, s += sp, r += rp) {
    for (j = 0; j < 16; j++) {
      *sum_s += s[j];
      *sum_r += r[j];
      *sum_sq_s += s[j] * s[j];
      *sum_sq_r += r[j] * r[j];
      *sum_sxr += s[j] * r[j];
    }
  }
30
}
31
void vpx_ssim_parms_8x8_c(const uint8_t *s, int sp, const uint8_t *r, int rp,
32 33 34
                          uint32_t *sum_s, uint32_t *sum_r,
                          uint32_t *sum_sq_s, uint32_t *sum_sq_r,
                          uint32_t *sum_sxr) {
John Koleszar's avatar
John Koleszar committed
35 36 37 38 39 40 41 42 43 44
  int i, j;
  for (i = 0; i < 8; i++, s += sp, r += rp) {
    for (j = 0; j < 8; j++) {
      *sum_s += s[j];
      *sum_r += r[j];
      *sum_sq_s += s[j] * s[j];
      *sum_sq_r += r[j] * r[j];
      *sum_sxr += s[j] * r[j];
    }
  }
45 46
}

47
#if CONFIG_VP9_HIGHBITDEPTH
48 49
void vpx_highbd_ssim_parms_8x8_c(const uint16_t *s, int sp,
                                 const uint16_t *r, int rp,
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65
                                 uint32_t *sum_s, uint32_t *sum_r,
                                 uint32_t *sum_sq_s, uint32_t *sum_sq_r,
                                 uint32_t *sum_sxr) {
  int i, j;
  for (i = 0; i < 8; i++, s += sp, r += rp) {
    for (j = 0; j < 8; j++) {
      *sum_s += s[j];
      *sum_r += r[j];
      *sum_sq_s += s[j] * s[j];
      *sum_sq_r += r[j] * r[j];
      *sum_sxr += s[j] * r[j];
    }
  }
}
#endif  // CONFIG_VP9_HIGHBITDEPTH

Jim Bankoski's avatar
Jim Bankoski committed
66 67
static const int64_t cc1 =  26634;  // (64^2*(.01*255)^2
static const int64_t cc2 = 239708;  // (64^2*(.03*255)^2
68

69 70 71
static double similarity(uint32_t sum_s, uint32_t sum_r,
                         uint32_t sum_sq_s, uint32_t sum_sq_r,
                         uint32_t sum_sxr, int count) {
John Koleszar's avatar
John Koleszar committed
72 73 74 75 76 77 78 79 80 81 82 83 84 85 86
  int64_t ssim_n, ssim_d;
  int64_t c1, c2;

  // scale the constants by number of pixels
  c1 = (cc1 * count * count) >> 12;
  c2 = (cc2 * count * count) >> 12;

  ssim_n = (2 * sum_s * sum_r + c1) * ((int64_t) 2 * count * sum_sxr -
                                       (int64_t) 2 * sum_s * sum_r + c2);

  ssim_d = (sum_s * sum_s + sum_r * sum_r + c1) *
           ((int64_t)count * sum_sq_s - (int64_t)sum_s * sum_s +
            (int64_t)count * sum_sq_r - (int64_t) sum_r * sum_r + c2);

  return ssim_n * 1.0 / ssim_d;
87 88
}

89
static double ssim_8x8(const uint8_t *s, int sp, const uint8_t *r, int rp) {
90
  uint32_t sum_s = 0, sum_r = 0, sum_sq_s = 0, sum_sq_r = 0, sum_sxr = 0;
91
  vpx_ssim_parms_8x8(s, sp, r, rp, &sum_s, &sum_r, &sum_sq_s, &sum_sq_r,
92
                     &sum_sxr);
John Koleszar's avatar
John Koleszar committed
93
  return similarity(sum_s, sum_r, sum_sq_s, sum_sq_r, sum_sxr, 64);
94 95
}

96
#if CONFIG_VP9_HIGHBITDEPTH
97 98
static double highbd_ssim_8x8(const uint16_t *s, int sp, const uint16_t *r,
                              int rp, unsigned int bd) {
99 100
  uint32_t sum_s = 0, sum_r = 0, sum_sq_s = 0, sum_sq_r = 0, sum_sxr = 0;
  const int oshift = bd - 8;
101
  vpx_highbd_ssim_parms_8x8(s, sp, r, rp, &sum_s, &sum_r, &sum_sq_s, &sum_sq_r,
102 103 104 105 106 107 108 109 110 111
                            &sum_sxr);
  return similarity(sum_s >> oshift,
                    sum_r >> oshift,
                    sum_sq_s >> (2 * oshift),
                    sum_sq_r >> (2 * oshift),
                    sum_sxr >> (2 * oshift),
                    64);
}
#endif  // CONFIG_VP9_HIGHBITDEPTH

112 113 114
// We are using a 8x8 moving window with starting location of each 8x8 window
// on the 4x4 pixel grid. Such arrangement allows the windows to overlap
// block boundaries to penalize blocking artifacts.
115 116 117
static double vpx_ssim2(const uint8_t *img1, const uint8_t *img2,
                        int stride_img1, int stride_img2, int width,
                        int height) {
John Koleszar's avatar
John Koleszar committed
118 119 120 121 122
  int i, j;
  int samples = 0;
  double ssim_total = 0;

  // sample point start with each 4x4 location
123 124 125
  for (i = 0; i <= height - 8;
       i += 4, img1 += stride_img1 * 4, img2 += stride_img2 * 4) {
    for (j = 0; j <= width - 8; j += 4) {
126
      double v = ssim_8x8(img1 + j, stride_img1, img2 + j, stride_img2);
John Koleszar's avatar
John Koleszar committed
127 128
      ssim_total += v;
      samples++;
129
    }
John Koleszar's avatar
John Koleszar committed
130 131 132
  }
  ssim_total /= samples;
  return ssim_total;
133
}
134 135

#if CONFIG_VP9_HIGHBITDEPTH
136 137 138
static double vpx_highbd_ssim2(const uint8_t *img1, const uint8_t *img2,
                               int stride_img1, int stride_img2, int width,
                               int height, unsigned int bd) {
139 140 141 142
  int i, j;
  int samples = 0;
  double ssim_total = 0;

Deb Mukherjee's avatar
Deb Mukherjee committed
143 144 145 146 147
  // sample point start with each 4x4 location
  for (i = 0; i <= height - 8;
       i += 4, img1 += stride_img1 * 4, img2 += stride_img2 * 4) {
    for (j = 0; j <= width - 8; j += 4) {
      double v = highbd_ssim_8x8(CONVERT_TO_SHORTPTR(img1 + j), stride_img1,
148 149
                                 CONVERT_TO_SHORTPTR(img2 + j), stride_img2,
                                 bd);
Deb Mukherjee's avatar
Deb Mukherjee committed
150 151
      ssim_total += v;
      samples++;
152 153 154 155 156 157 158
    }
  }
  ssim_total /= samples;
  return ssim_total;
}
#endif  // CONFIG_VP9_HIGHBITDEPTH

159 160
double vpx_calc_ssim(const YV12_BUFFER_CONFIG *source,
                     const YV12_BUFFER_CONFIG *dest,
161
                     double *weight) {
John Koleszar's avatar
John Koleszar committed
162 163
  double a, b, c;
  double ssimv;
164

165
  a = vpx_ssim2(source->y_buffer, dest->y_buffer,
166 167
                source->y_stride, dest->y_stride,
                source->y_crop_width, source->y_crop_height);
168

169
  b = vpx_ssim2(source->u_buffer, dest->u_buffer,
170 171
                source->uv_stride, dest->uv_stride,
                source->uv_crop_width, source->uv_crop_height);
172

173
  c = vpx_ssim2(source->v_buffer, dest->v_buffer,
174 175
                source->uv_stride, dest->uv_stride,
                source->uv_crop_width, source->uv_crop_height);
176

John Koleszar's avatar
John Koleszar committed
177
  ssimv = a * .8 + .1 * (b + c);
178

John Koleszar's avatar
John Koleszar committed
179
  *weight = 1;
180

John Koleszar's avatar
John Koleszar committed
181
  return ssimv;
182 183
}

184 185
double vpx_calc_ssimg(const YV12_BUFFER_CONFIG *source,
                      const YV12_BUFFER_CONFIG *dest,
186
                      double *ssim_y, double *ssim_u, double *ssim_v) {
John Koleszar's avatar
John Koleszar committed
187 188 189
  double ssim_all = 0;
  double a, b, c;

190
  a = vpx_ssim2(source->y_buffer, dest->y_buffer,
191 192
                source->y_stride, dest->y_stride,
                source->y_crop_width, source->y_crop_height);
John Koleszar's avatar
John Koleszar committed
193

194
  b = vpx_ssim2(source->u_buffer, dest->u_buffer,
195 196
                source->uv_stride, dest->uv_stride,
                source->uv_crop_width, source->uv_crop_height);
John Koleszar's avatar
John Koleszar committed
197

198
  c = vpx_ssim2(source->v_buffer, dest->v_buffer,
199 200
                source->uv_stride, dest->uv_stride,
                source->uv_crop_width, source->uv_crop_height);
John Koleszar's avatar
John Koleszar committed
201 202 203 204 205 206
  *ssim_y = a;
  *ssim_u = b;
  *ssim_v = c;
  ssim_all = (a * 4 + b + c) / 6;

  return ssim_all;
Johann's avatar
Johann committed
207
}
208

209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237
// traditional ssim as per: http://en.wikipedia.org/wiki/Structural_similarity
//
// Re working out the math ->
//
// ssim(x,y) =  (2*mean(x)*mean(y) + c1)*(2*cov(x,y)+c2) /
//   ((mean(x)^2+mean(y)^2+c1)*(var(x)+var(y)+c2))
//
// mean(x) = sum(x) / n
//
// cov(x,y) = (n*sum(xi*yi)-sum(x)*sum(y))/(n*n)
//
// var(x) = (n*sum(xi*xi)-sum(xi)*sum(xi))/(n*n)
//
// ssim(x,y) =
//   (2*sum(x)*sum(y)/(n*n) + c1)*(2*(n*sum(xi*yi)-sum(x)*sum(y))/(n*n)+c2) /
//   (((sum(x)*sum(x)+sum(y)*sum(y))/(n*n) +c1) *
//    ((n*sum(xi*xi) - sum(xi)*sum(xi))/(n*n)+
//     (n*sum(yi*yi) - sum(yi)*sum(yi))/(n*n)+c2)))
//
// factoring out n*n
//
// ssim(x,y) =
//   (2*sum(x)*sum(y) + n*n*c1)*(2*(n*sum(xi*yi)-sum(x)*sum(y))+n*n*c2) /
//   (((sum(x)*sum(x)+sum(y)*sum(y)) + n*n*c1) *
//    (n*sum(xi*xi)-sum(xi)*sum(xi)+n*sum(yi*yi)-sum(yi)*sum(yi)+n*n*c2))
//
// Replace c1 with n*n * c1 for the final step that leads to this code:
// The final step scales by 12 bits so we don't lose precision in the constants.

238
static double ssimv_similarity(const Ssimv *sv, int64_t n) {
239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268
  // Scale the constants by number of pixels.
  const int64_t c1 = (cc1 * n * n) >> 12;
  const int64_t c2 = (cc2 * n * n) >> 12;

  const double l = 1.0 * (2 * sv->sum_s * sv->sum_r + c1) /
      (sv->sum_s * sv->sum_s + sv->sum_r * sv->sum_r + c1);

  // Since these variables are unsigned sums, convert to double so
  // math is done in double arithmetic.
  const double v = (2.0 * n * sv->sum_sxr - 2 * sv->sum_s * sv->sum_r + c2)
      / (n * sv->sum_sq_s - sv->sum_s * sv->sum_s + n * sv->sum_sq_r
         - sv->sum_r * sv->sum_r + c2);

  return l * v;
}

// The first term of the ssim metric is a luminance factor.
//
// (2*mean(x)*mean(y) + c1)/ (mean(x)^2+mean(y)^2+c1)
//
// This luminance factor is super sensitive to the dark side of luminance
// values and completely insensitive on the white side.  check out 2 sets
// (1,3) and (250,252) the term gives ( 2*1*3/(1+9) = .60
// 2*250*252/ (250^2+252^2) => .99999997
//
// As a result in this tweaked version of the calculation in which the
// luminance is taken as percentage off from peak possible.
//
// 255 * 255 - (sum_s - sum_r) / count * (sum_s - sum_r) / count
//
269
static double ssimv_similarity2(const Ssimv *sv, int64_t n) {
270 271 272 273 274 275 276 277 278 279 280 281 282 283 284
  // Scale the constants by number of pixels.
  const int64_t c1 = (cc1 * n * n) >> 12;
  const int64_t c2 = (cc2 * n * n) >> 12;

  const double mean_diff = (1.0 * sv->sum_s - sv->sum_r) / n;
  const double l = (255 * 255 - mean_diff * mean_diff + c1) / (255 * 255 + c1);

  // Since these variables are unsigned, sums convert to double so
  // math is done in double arithmetic.
  const double v = (2.0 * n * sv->sum_sxr - 2 * sv->sum_s * sv->sum_r + c2)
      / (n * sv->sum_sq_s - sv->sum_s * sv->sum_s +
         n * sv->sum_sq_r - sv->sum_r * sv->sum_r + c2);

  return l * v;
}
285 286
static void ssimv_parms(uint8_t *img1, int img1_pitch, uint8_t *img2,
                        int img2_pitch, Ssimv *sv) {
287
  vpx_ssim_parms_8x8(img1, img1_pitch, img2, img2_pitch,
288 289 290 291
                     &sv->sum_s, &sv->sum_r, &sv->sum_sq_s, &sv->sum_sq_r,
                     &sv->sum_sxr);
}

292
double vpx_get_ssim_metrics(uint8_t *img1, int img1_pitch,
293 294 295 296 297 298 299 300 301 302 303 304
                            uint8_t *img2, int img2_pitch,
                            int width, int height,
                            Ssimv *sv2, Metrics *m,
                            int do_inconsistency) {
  double dssim_total = 0;
  double ssim_total = 0;
  double ssim2_total = 0;
  double inconsistency_total = 0;
  int i, j;
  int c = 0;
  double norm;
  double old_ssim_total = 0;
305
  vpx_clear_system_state();
306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453
  // We can sample points as frequently as we like start with 1 per 4x4.
  for (i = 0; i < height; i += 4,
       img1 += img1_pitch * 4, img2 += img2_pitch * 4) {
    for (j = 0; j < width; j += 4, ++c) {
      Ssimv sv = {0};
      double ssim;
      double ssim2;
      double dssim;
      uint32_t var_new;
      uint32_t var_old;
      uint32_t mean_new;
      uint32_t mean_old;
      double ssim_new;
      double ssim_old;

      // Not sure there's a great way to handle the edge pixels
      // in ssim when using a window. Seems biased against edge pixels
      // however you handle this. This uses only samples that are
      // fully in the frame.
      if (j + 8 <= width && i + 8 <= height) {
        ssimv_parms(img1 + j, img1_pitch, img2 + j, img2_pitch, &sv);
      }

      ssim = ssimv_similarity(&sv, 64);
      ssim2 = ssimv_similarity2(&sv, 64);

      sv.ssim = ssim2;

      // dssim is calculated to use as an actual error metric and
      // is scaled up to the same range as sum square error.
      // Since we are subsampling every 16th point maybe this should be
      // *16 ?
      dssim = 255 * 255 * (1 - ssim2) / 2;

      // Here I introduce a new error metric: consistency-weighted
      // SSIM-inconsistency.  This metric isolates frames where the
      // SSIM 'suddenly' changes, e.g. if one frame in every 8 is much
      // sharper or blurrier than the others. Higher values indicate a
      // temporally inconsistent SSIM. There are two ideas at work:
      //
      // 1) 'SSIM-inconsistency': the total inconsistency value
      // reflects how much SSIM values are changing between this
      // source / reference frame pair and the previous pair.
      //
      // 2) 'consistency-weighted': weights de-emphasize areas in the
      // frame where the scene content has changed. Changes in scene
      // content are detected via changes in local variance and local
      // mean.
      //
      // Thus the overall measure reflects how inconsistent the SSIM
      // values are, over consistent regions of the frame.
      //
      // The metric has three terms:
      //
      // term 1 -> uses change in scene Variance to weight error score
      //  2 * var(Fi)*var(Fi-1) / (var(Fi)^2+var(Fi-1)^2)
      //  larger changes from one frame to the next mean we care
      //  less about consistency.
      //
      // term 2 -> uses change in local scene luminance to weight error
      //  2 * avg(Fi)*avg(Fi-1) / (avg(Fi)^2+avg(Fi-1)^2)
      //  larger changes from one frame to the next mean we care
      //  less about consistency.
      //
      // term3 -> measures inconsistency in ssim scores between frames
      //   1 - ( 2 * ssim(Fi)*ssim(Fi-1)/(ssim(Fi)^2+sssim(Fi-1)^2).
      //
      // This term compares the ssim score for the same location in 2
      // subsequent frames.
      var_new = sv.sum_sq_s - sv.sum_s * sv.sum_s / 64;
      var_old = sv2[c].sum_sq_s - sv2[c].sum_s * sv2[c].sum_s / 64;
      mean_new = sv.sum_s;
      mean_old = sv2[c].sum_s;
      ssim_new = sv.ssim;
      ssim_old = sv2[c].ssim;

      if (do_inconsistency) {
        // We do the metric once for every 4x4 block in the image. Since
        // we are scaling the error to SSE for use in a psnr calculation
        // 1.0 = 4x4x255x255 the worst error we can possibly have.
        static const double kScaling = 4. * 4 * 255 * 255;

        // The constants have to be non 0 to avoid potential divide by 0
        // issues other than that they affect kind of a weighting between
        // the terms.  No testing of what the right terms should be has been
        // done.
        static const double c1 = 1, c2 = 1, c3 = 1;

        // This measures how much consistent variance is in two consecutive
        // source frames. 1.0 means they have exactly the same variance.
        const double variance_term = (2.0 * var_old * var_new + c1) /
            (1.0 * var_old * var_old + 1.0 * var_new * var_new + c1);

        // This measures how consistent the local mean are between two
        // consecutive frames. 1.0 means they have exactly the same mean.
        const double mean_term = (2.0 * mean_old * mean_new + c2) /
            (1.0 * mean_old * mean_old + 1.0 * mean_new * mean_new + c2);

        // This measures how consistent the ssims of two
        // consecutive frames is. 1.0 means they are exactly the same.
        double ssim_term = pow((2.0 * ssim_old * ssim_new + c3) /
                               (ssim_old * ssim_old + ssim_new * ssim_new + c3),
                               5);

        double this_inconsistency;

        // Floating point math sometimes makes this > 1 by a tiny bit.
        // We want the metric to scale between 0 and 1.0 so we can convert
        // it to an snr scaled value.
        if (ssim_term > 1)
          ssim_term = 1;

        // This converts the consistency metric to an inconsistency metric
        // ( so we can scale it like psnr to something like sum square error.
        // The reason for the variance and mean terms is the assumption that
        // if there are big changes in the source we shouldn't penalize
        // inconsistency in ssim scores a bit less as it will be less visible
        // to the user.
        this_inconsistency = (1 - ssim_term) * variance_term * mean_term;

        this_inconsistency *= kScaling;
        inconsistency_total += this_inconsistency;
      }
      sv2[c] = sv;
      ssim_total += ssim;
      ssim2_total += ssim2;
      dssim_total += dssim;

      old_ssim_total += ssim_old;
    }
    old_ssim_total += 0;
  }

  norm = 1. / (width / 4) / (height / 4);
  ssim_total *= norm;
  ssim2_total *= norm;
  m->ssim2 = ssim2_total;
  m->ssim = ssim_total;
  if (old_ssim_total == 0)
    inconsistency_total = 0;

  m->ssimc = inconsistency_total;

  m->dssim = dssim_total;
  return inconsistency_total;
}


454
#if CONFIG_VP9_HIGHBITDEPTH
455 456
double vpx_highbd_calc_ssim(const YV12_BUFFER_CONFIG *source,
                            const YV12_BUFFER_CONFIG *dest,
Deb Mukherjee's avatar
Deb Mukherjee committed
457
                            double *weight, unsigned int bd) {
458 459 460
  double a, b, c;
  double ssimv;

461
  a = vpx_highbd_ssim2(source->y_buffer, dest->y_buffer,
462
                       source->y_stride, dest->y_stride,
Deb Mukherjee's avatar
Deb Mukherjee committed
463
                       source->y_crop_width, source->y_crop_height, bd);
464

465
  b = vpx_highbd_ssim2(source->u_buffer, dest->u_buffer,
466
                       source->uv_stride, dest->uv_stride,
Deb Mukherjee's avatar
Deb Mukherjee committed
467
                       source->uv_crop_width, source->uv_crop_height, bd);
468

469
  c = vpx_highbd_ssim2(source->v_buffer, dest->v_buffer,
470
                       source->uv_stride, dest->uv_stride,
Deb Mukherjee's avatar
Deb Mukherjee committed
471
                       source->uv_crop_width, source->uv_crop_height, bd);
472 473 474 475 476 477 478 479

  ssimv = a * .8 + .1 * (b + c);

  *weight = 1;

  return ssimv;
}

480 481
double vpx_highbd_calc_ssimg(const YV12_BUFFER_CONFIG *source,
                             const YV12_BUFFER_CONFIG *dest, double *ssim_y,
Deb Mukherjee's avatar
Deb Mukherjee committed
482
                             double *ssim_u, double *ssim_v, unsigned int bd) {
483 484 485
  double ssim_all = 0;
  double a, b, c;

486
  a = vpx_highbd_ssim2(source->y_buffer, dest->y_buffer,
487
                       source->y_stride, dest->y_stride,
Deb Mukherjee's avatar
Deb Mukherjee committed
488
                       source->y_crop_width, source->y_crop_height, bd);
489

490
  b = vpx_highbd_ssim2(source->u_buffer, dest->u_buffer,
491
                       source->uv_stride, dest->uv_stride,
Deb Mukherjee's avatar
Deb Mukherjee committed
492
                       source->uv_crop_width, source->uv_crop_height, bd);
493

494
  c = vpx_highbd_ssim2(source->v_buffer, dest->v_buffer,
495
                       source->uv_stride, dest->uv_stride,
Deb Mukherjee's avatar
Deb Mukherjee committed
496
                       source->uv_crop_width, source->uv_crop_height, bd);
497 498 499 500 501 502 503 504
  *ssim_y = a;
  *ssim_u = b;
  *ssim_v = c;
  ssim_all = (a * 4 + b + c) / 6;

  return ssim_all;
}
#endif  // CONFIG_VP9_HIGHBITDEPTH