1 /* 2 * Copyright (c) 2016, Alliance for Open Media. All rights reserved 3 * 4 * This source code is subject to the terms of the BSD 2 Clause License and 5 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License 6 * was not distributed with this source code in the LICENSE file, you can 7 * obtain it at www.aomedia.org/license/software. If the Alliance for Open 8 * Media Patent License 1.0 was not distributed with this source code in the 9 * PATENTS file, you can obtain it at www.aomedia.org/license/patent. 10 */ 11 12 #include <math.h> 13 14 #include "config/aom_dsp_rtcd.h" 15 16 #include "aom_dsp/quantize.h" 17 #include "aom_mem/aom_mem.h" 18 #include "aom_ports/mem.h" 19 20 #include "av1/common/idct.h" 21 #include "av1/common/quant_common.h" 22 #include "av1/common/scan.h" 23 #include "av1/common/seg_common.h" 24 25 #include "av1/encoder/av1_quantize.h" 26 #include "av1/encoder/encoder.h" 27 #include "av1/encoder/rd.h" 28 29 void av1_quantize_skip(intptr_t n_coeffs, tran_low_t *qcoeff_ptr, 30 tran_low_t *dqcoeff_ptr, uint16_t *eob_ptr) { 31 memset(qcoeff_ptr, 0, n_coeffs * sizeof(*qcoeff_ptr)); 32 memset(dqcoeff_ptr, 0, n_coeffs * sizeof(*dqcoeff_ptr)); 33 *eob_ptr = 0; 34 } 35 36 static void quantize_fp_helper_c( 37 const tran_low_t *coeff_ptr, intptr_t n_coeffs, const int16_t *zbin_ptr, 38 const int16_t *round_ptr, const int16_t *quant_ptr, 39 const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, 40 tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, 41 const int16_t *scan, const int16_t *iscan, const qm_val_t *qm_ptr, 42 const qm_val_t *iqm_ptr, int log_scale) { 43 int i, eob = -1; 44 const int rounding[2] = { ROUND_POWER_OF_TWO(round_ptr[0], log_scale), 45 ROUND_POWER_OF_TWO(round_ptr[1], log_scale) }; 46 // TODO(jingning) Decide the need of these arguments after the 47 // quantization process is completed. 48 (void)zbin_ptr; 49 (void)quant_shift_ptr; 50 (void)iscan; 51 52 memset(qcoeff_ptr, 0, n_coeffs * sizeof(*qcoeff_ptr)); 53 memset(dqcoeff_ptr, 0, n_coeffs * sizeof(*dqcoeff_ptr)); 54 55 if (qm_ptr == NULL && iqm_ptr == NULL) { 56 for (i = 0; i < n_coeffs; i++) { 57 const int rc = scan[i]; 58 const int32_t thresh = (int32_t)(dequant_ptr[rc != 0]); 59 const int coeff = coeff_ptr[rc]; 60 const int coeff_sign = (coeff >> 31); 61 int64_t abs_coeff = (coeff ^ coeff_sign) - coeff_sign; 62 int tmp32 = 0; 63 if ((abs_coeff << (1 + log_scale)) >= thresh) { 64 abs_coeff = 65 clamp64(abs_coeff + rounding[rc != 0], INT16_MIN, INT16_MAX); 66 tmp32 = (int)((abs_coeff * quant_ptr[rc != 0]) >> (16 - log_scale)); 67 if (tmp32) { 68 qcoeff_ptr[rc] = (tmp32 ^ coeff_sign) - coeff_sign; 69 const tran_low_t abs_dqcoeff = 70 (tmp32 * dequant_ptr[rc != 0]) >> log_scale; 71 dqcoeff_ptr[rc] = (abs_dqcoeff ^ coeff_sign) - coeff_sign; 72 } 73 } 74 if (tmp32) eob = i; 75 } 76 } else { 77 // Quantization pass: All coefficients with index >= zero_flag are 78 // skippable. Note: zero_flag can be zero. 79 for (i = 0; i < n_coeffs; i++) { 80 const int rc = scan[i]; 81 const int coeff = coeff_ptr[rc]; 82 const qm_val_t wt = qm_ptr ? qm_ptr[rc] : (1 << AOM_QM_BITS); 83 const qm_val_t iwt = iqm_ptr ? iqm_ptr[rc] : (1 << AOM_QM_BITS); 84 const int dequant = 85 (dequant_ptr[rc != 0] * iwt + (1 << (AOM_QM_BITS - 1))) >> 86 AOM_QM_BITS; 87 const int coeff_sign = (coeff >> 31); 88 int64_t abs_coeff = (coeff ^ coeff_sign) - coeff_sign; 89 int tmp32 = 0; 90 if (abs_coeff * wt >= 91 (dequant_ptr[rc != 0] << (AOM_QM_BITS - (1 + log_scale)))) { 92 abs_coeff += rounding[rc != 0]; 93 abs_coeff = clamp64(abs_coeff, INT16_MIN, INT16_MAX); 94 tmp32 = (int)((abs_coeff * wt * quant_ptr[rc != 0]) >> 95 (16 - log_scale + AOM_QM_BITS)); 96 qcoeff_ptr[rc] = (tmp32 ^ coeff_sign) - coeff_sign; 97 const tran_low_t abs_dqcoeff = (tmp32 * dequant) >> log_scale; 98 dqcoeff_ptr[rc] = (abs_dqcoeff ^ coeff_sign) - coeff_sign; 99 } 100 101 if (tmp32) eob = i; 102 } 103 } 104 *eob_ptr = eob + 1; 105 } 106 107 static void highbd_quantize_fp_helper_c( 108 const tran_low_t *coeff_ptr, intptr_t count, const int16_t *zbin_ptr, 109 const int16_t *round_ptr, const int16_t *quant_ptr, 110 const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, 111 tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, 112 const int16_t *scan, const int16_t *iscan, const qm_val_t *qm_ptr, 113 const qm_val_t *iqm_ptr, int log_scale) { 114 int i; 115 int eob = -1; 116 const int shift = 16 - log_scale; 117 // TODO(jingning) Decide the need of these arguments after the 118 // quantization process is completed. 119 (void)zbin_ptr; 120 (void)quant_shift_ptr; 121 (void)iscan; 122 123 if (qm_ptr || iqm_ptr) { 124 // Quantization pass: All coefficients with index >= zero_flag are 125 // skippable. Note: zero_flag can be zero. 126 for (i = 0; i < count; i++) { 127 const int rc = scan[i]; 128 const int coeff = coeff_ptr[rc]; 129 const qm_val_t wt = qm_ptr != NULL ? qm_ptr[rc] : (1 << AOM_QM_BITS); 130 const qm_val_t iwt = iqm_ptr != NULL ? iqm_ptr[rc] : (1 << AOM_QM_BITS); 131 const int dequant = 132 (dequant_ptr[rc != 0] * iwt + (1 << (AOM_QM_BITS - 1))) >> 133 AOM_QM_BITS; 134 const int coeff_sign = (coeff >> 31); 135 const int64_t abs_coeff = (coeff ^ coeff_sign) - coeff_sign; 136 int abs_qcoeff = 0; 137 if (abs_coeff * wt >= 138 (dequant_ptr[rc != 0] << (AOM_QM_BITS - (1 + log_scale)))) { 139 const int64_t tmp = 140 abs_coeff + ROUND_POWER_OF_TWO(round_ptr[rc != 0], log_scale); 141 abs_qcoeff = 142 (int)((tmp * quant_ptr[rc != 0] * wt) >> (shift + AOM_QM_BITS)); 143 qcoeff_ptr[rc] = (tran_low_t)((abs_qcoeff ^ coeff_sign) - coeff_sign); 144 const tran_low_t abs_dqcoeff = (abs_qcoeff * dequant) >> log_scale; 145 dqcoeff_ptr[rc] = (tran_low_t)((abs_dqcoeff ^ coeff_sign) - coeff_sign); 146 if (abs_qcoeff) eob = i; 147 } else { 148 qcoeff_ptr[rc] = 0; 149 dqcoeff_ptr[rc] = 0; 150 } 151 } 152 } else { 153 const int log_scaled_round_arr[2] = { 154 ROUND_POWER_OF_TWO(round_ptr[0], log_scale), 155 ROUND_POWER_OF_TWO(round_ptr[1], log_scale), 156 }; 157 for (i = 0; i < count; i++) { 158 const int rc = scan[i]; 159 const int coeff = coeff_ptr[rc]; 160 const int rc01 = (rc != 0); 161 const int coeff_sign = (coeff >> 31); 162 const int abs_coeff = (coeff ^ coeff_sign) - coeff_sign; 163 const int log_scaled_round = log_scaled_round_arr[rc01]; 164 if ((abs_coeff << (1 + log_scale)) >= dequant_ptr[rc01]) { 165 const int quant = quant_ptr[rc01]; 166 const int dequant = dequant_ptr[rc01]; 167 const int64_t tmp = (int64_t)abs_coeff + log_scaled_round; 168 const int abs_qcoeff = (int)((tmp * quant) >> shift); 169 qcoeff_ptr[rc] = (tran_low_t)((abs_qcoeff ^ coeff_sign) - coeff_sign); 170 const tran_low_t abs_dqcoeff = (abs_qcoeff * dequant) >> log_scale; 171 if (abs_qcoeff) eob = i; 172 dqcoeff_ptr[rc] = (tran_low_t)((abs_dqcoeff ^ coeff_sign) - coeff_sign); 173 } else { 174 qcoeff_ptr[rc] = 0; 175 dqcoeff_ptr[rc] = 0; 176 } 177 } 178 } 179 *eob_ptr = eob + 1; 180 } 181 182 void av1_quantize_fp_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, 183 const int16_t *zbin_ptr, const int16_t *round_ptr, 184 const int16_t *quant_ptr, const int16_t *quant_shift_ptr, 185 tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, 186 const int16_t *dequant_ptr, uint16_t *eob_ptr, 187 const int16_t *scan, const int16_t *iscan) { 188 quantize_fp_helper_c(coeff_ptr, n_coeffs, zbin_ptr, round_ptr, quant_ptr, 189 quant_shift_ptr, qcoeff_ptr, dqcoeff_ptr, dequant_ptr, 190 eob_ptr, scan, iscan, NULL, NULL, 0); 191 } 192 193 void av1_quantize_fp_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, 194 const int16_t *zbin_ptr, const int16_t *round_ptr, 195 const int16_t *quant_ptr, 196 const int16_t *quant_shift_ptr, 197 tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, 198 const int16_t *dequant_ptr, uint16_t *eob_ptr, 199 const int16_t *scan, const int16_t *iscan) { 200 quantize_fp_helper_c(coeff_ptr, n_coeffs, zbin_ptr, round_ptr, quant_ptr, 201 quant_shift_ptr, qcoeff_ptr, dqcoeff_ptr, dequant_ptr, 202 eob_ptr, scan, iscan, NULL, NULL, 1); 203 } 204 205 void av1_quantize_fp_64x64_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, 206 const int16_t *zbin_ptr, const int16_t *round_ptr, 207 const int16_t *quant_ptr, 208 const int16_t *quant_shift_ptr, 209 tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, 210 const int16_t *dequant_ptr, uint16_t *eob_ptr, 211 const int16_t *scan, const int16_t *iscan) { 212 quantize_fp_helper_c(coeff_ptr, n_coeffs, zbin_ptr, round_ptr, quant_ptr, 213 quant_shift_ptr, qcoeff_ptr, dqcoeff_ptr, dequant_ptr, 214 eob_ptr, scan, iscan, NULL, NULL, 2); 215 } 216 217 void av1_quantize_fp_facade(const tran_low_t *coeff_ptr, intptr_t n_coeffs, 218 const MACROBLOCK_PLANE *p, tran_low_t *qcoeff_ptr, 219 tran_low_t *dqcoeff_ptr, uint16_t *eob_ptr, 220 const SCAN_ORDER *sc, const QUANT_PARAM *qparam) { 221 const qm_val_t *qm_ptr = qparam->qmatrix; 222 const qm_val_t *iqm_ptr = qparam->iqmatrix; 223 if (qm_ptr != NULL && iqm_ptr != NULL) { 224 quantize_fp_helper_c(coeff_ptr, n_coeffs, p->zbin_QTX, p->round_fp_QTX, 225 p->quant_fp_QTX, p->quant_shift_QTX, qcoeff_ptr, 226 dqcoeff_ptr, p->dequant_QTX, eob_ptr, sc->scan, 227 sc->iscan, qm_ptr, iqm_ptr, qparam->log_scale); 228 } else { 229 switch (qparam->log_scale) { 230 case 0: 231 if (n_coeffs < 16) { 232 // TODO(jingning): Need SIMD implementation for smaller block size 233 // quantization. 234 quantize_fp_helper_c( 235 coeff_ptr, n_coeffs, p->zbin_QTX, p->round_fp_QTX, 236 p->quant_fp_QTX, p->quant_shift_QTX, qcoeff_ptr, dqcoeff_ptr, 237 p->dequant_QTX, eob_ptr, sc->scan, sc->iscan, NULL, NULL, 0); 238 } else { 239 av1_quantize_fp(coeff_ptr, n_coeffs, p->zbin_QTX, p->round_fp_QTX, 240 p->quant_fp_QTX, p->quant_shift_QTX, qcoeff_ptr, 241 dqcoeff_ptr, p->dequant_QTX, eob_ptr, sc->scan, 242 sc->iscan); 243 } 244 break; 245 case 1: 246 av1_quantize_fp_32x32(coeff_ptr, n_coeffs, p->zbin_QTX, p->round_fp_QTX, 247 p->quant_fp_QTX, p->quant_shift_QTX, qcoeff_ptr, 248 dqcoeff_ptr, p->dequant_QTX, eob_ptr, sc->scan, 249 sc->iscan); 250 break; 251 case 2: 252 av1_quantize_fp_64x64(coeff_ptr, n_coeffs, p->zbin_QTX, p->round_fp_QTX, 253 p->quant_fp_QTX, p->quant_shift_QTX, qcoeff_ptr, 254 dqcoeff_ptr, p->dequant_QTX, eob_ptr, sc->scan, 255 sc->iscan); 256 break; 257 default: assert(0); 258 } 259 } 260 } 261 262 void av1_quantize_b_facade(const tran_low_t *coeff_ptr, intptr_t n_coeffs, 263 const MACROBLOCK_PLANE *p, tran_low_t *qcoeff_ptr, 264 tran_low_t *dqcoeff_ptr, uint16_t *eob_ptr, 265 const SCAN_ORDER *sc, const QUANT_PARAM *qparam) { 266 const qm_val_t *qm_ptr = qparam->qmatrix; 267 const qm_val_t *iqm_ptr = qparam->iqmatrix; 268 if (qparam->use_quant_b_adapt) { 269 // TODO(sarahparker) These quantize_b optimizations need SIMD 270 // implementations 271 if (qm_ptr != NULL && iqm_ptr != NULL) { 272 quantize_b_adaptive_helper_c( 273 coeff_ptr, n_coeffs, p->zbin_QTX, p->round_QTX, p->quant_QTX, 274 p->quant_shift_QTX, qcoeff_ptr, dqcoeff_ptr, p->dequant_QTX, eob_ptr, 275 sc->scan, sc->iscan, qm_ptr, iqm_ptr, qparam->log_scale); 276 } else { 277 switch (qparam->log_scale) { 278 case 0: 279 aom_quantize_b_adaptive(coeff_ptr, n_coeffs, p->zbin_QTX, 280 p->round_QTX, p->quant_QTX, 281 p->quant_shift_QTX, qcoeff_ptr, dqcoeff_ptr, 282 p->dequant_QTX, eob_ptr, sc->scan, sc->iscan); 283 break; 284 case 1: 285 aom_quantize_b_32x32_adaptive( 286 coeff_ptr, n_coeffs, p->zbin_QTX, p->round_QTX, p->quant_QTX, 287 p->quant_shift_QTX, qcoeff_ptr, dqcoeff_ptr, p->dequant_QTX, 288 eob_ptr, sc->scan, sc->iscan); 289 break; 290 case 2: 291 aom_quantize_b_64x64_adaptive_c( 292 coeff_ptr, n_coeffs, p->zbin_QTX, p->round_QTX, p->quant_QTX, 293 p->quant_shift_QTX, qcoeff_ptr, dqcoeff_ptr, p->dequant_QTX, 294 eob_ptr, sc->scan, sc->iscan); 295 break; 296 default: assert(0); 297 } 298 } 299 } else { 300 if (qm_ptr != NULL && iqm_ptr != NULL) { 301 quantize_b_helper_c(coeff_ptr, n_coeffs, p->zbin_QTX, p->round_QTX, 302 p->quant_QTX, p->quant_shift_QTX, qcoeff_ptr, 303 dqcoeff_ptr, p->dequant_QTX, eob_ptr, sc->scan, 304 sc->iscan, qm_ptr, iqm_ptr, qparam->log_scale); 305 } else { 306 switch (qparam->log_scale) { 307 case 0: 308 aom_quantize_b(coeff_ptr, n_coeffs, p->zbin_QTX, p->round_QTX, 309 p->quant_QTX, p->quant_shift_QTX, qcoeff_ptr, 310 dqcoeff_ptr, p->dequant_QTX, eob_ptr, sc->scan, 311 sc->iscan); 312 break; 313 case 1: 314 aom_quantize_b_32x32(coeff_ptr, n_coeffs, p->zbin_QTX, p->round_QTX, 315 p->quant_QTX, p->quant_shift_QTX, qcoeff_ptr, 316 dqcoeff_ptr, p->dequant_QTX, eob_ptr, sc->scan, 317 sc->iscan); 318 break; 319 case 2: 320 aom_quantize_b_64x64(coeff_ptr, n_coeffs, p->zbin_QTX, p->round_QTX, 321 p->quant_QTX, p->quant_shift_QTX, qcoeff_ptr, 322 dqcoeff_ptr, p->dequant_QTX, eob_ptr, sc->scan, 323 sc->iscan); 324 break; 325 default: assert(0); 326 } 327 } 328 } 329 } 330 331 static void quantize_dc(const tran_low_t *coeff_ptr, int n_coeffs, 332 int skip_block, const int16_t *round_ptr, 333 const int16_t quant, tran_low_t *qcoeff_ptr, 334 tran_low_t *dqcoeff_ptr, const int16_t dequant_ptr, 335 uint16_t *eob_ptr, const qm_val_t *qm_ptr, 336 const qm_val_t *iqm_ptr, const int log_scale) { 337 const int rc = 0; 338 const int coeff = coeff_ptr[rc]; 339 const int coeff_sign = (coeff >> 31); 340 const int abs_coeff = (coeff ^ coeff_sign) - coeff_sign; 341 int64_t tmp; 342 int eob = -1; 343 int32_t tmp32; 344 int dequant; 345 346 memset(qcoeff_ptr, 0, n_coeffs * sizeof(*qcoeff_ptr)); 347 memset(dqcoeff_ptr, 0, n_coeffs * sizeof(*dqcoeff_ptr)); 348 349 if (!skip_block) { 350 const int wt = qm_ptr != NULL ? qm_ptr[rc] : (1 << AOM_QM_BITS); 351 const int iwt = iqm_ptr != NULL ? iqm_ptr[rc] : (1 << AOM_QM_BITS); 352 tmp = clamp(abs_coeff + ROUND_POWER_OF_TWO(round_ptr[rc != 0], log_scale), 353 INT16_MIN, INT16_MAX); 354 tmp32 = (int32_t)((tmp * wt * quant) >> (16 - log_scale + AOM_QM_BITS)); 355 qcoeff_ptr[rc] = (tmp32 ^ coeff_sign) - coeff_sign; 356 dequant = (dequant_ptr * iwt + (1 << (AOM_QM_BITS - 1))) >> AOM_QM_BITS; 357 const tran_low_t abs_dqcoeff = (tmp32 * dequant) >> log_scale; 358 dqcoeff_ptr[rc] = (tran_low_t)((abs_dqcoeff ^ coeff_sign) - coeff_sign); 359 if (tmp32) eob = 0; 360 } 361 *eob_ptr = eob + 1; 362 } 363 364 void av1_quantize_dc_facade(const tran_low_t *coeff_ptr, intptr_t n_coeffs, 365 const MACROBLOCK_PLANE *p, tran_low_t *qcoeff_ptr, 366 tran_low_t *dqcoeff_ptr, uint16_t *eob_ptr, 367 const SCAN_ORDER *sc, const QUANT_PARAM *qparam) { 368 // obsolete skip_block 369 const int skip_block = 0; 370 (void)sc; 371 assert(qparam->log_scale >= 0 && qparam->log_scale < (3)); 372 const qm_val_t *qm_ptr = qparam->qmatrix; 373 const qm_val_t *iqm_ptr = qparam->iqmatrix; 374 quantize_dc(coeff_ptr, (int)n_coeffs, skip_block, p->round_QTX, 375 p->quant_fp_QTX[0], qcoeff_ptr, dqcoeff_ptr, p->dequant_QTX[0], 376 eob_ptr, qm_ptr, iqm_ptr, qparam->log_scale); 377 } 378 379 void av1_highbd_quantize_fp_facade(const tran_low_t *coeff_ptr, 380 intptr_t n_coeffs, const MACROBLOCK_PLANE *p, 381 tran_low_t *qcoeff_ptr, 382 tran_low_t *dqcoeff_ptr, uint16_t *eob_ptr, 383 const SCAN_ORDER *sc, 384 const QUANT_PARAM *qparam) { 385 const qm_val_t *qm_ptr = qparam->qmatrix; 386 const qm_val_t *iqm_ptr = qparam->iqmatrix; 387 if (qm_ptr != NULL && iqm_ptr != NULL) { 388 highbd_quantize_fp_helper_c( 389 coeff_ptr, n_coeffs, p->zbin_QTX, p->round_fp_QTX, p->quant_fp_QTX, 390 p->quant_shift_QTX, qcoeff_ptr, dqcoeff_ptr, p->dequant_QTX, eob_ptr, 391 sc->scan, sc->iscan, qm_ptr, iqm_ptr, qparam->log_scale); 392 } else { 393 if (n_coeffs < 16) { 394 // TODO(jingning): Need SIMD implementation for smaller block size 395 // quantization. 396 av1_highbd_quantize_fp_c( 397 coeff_ptr, n_coeffs, p->zbin_QTX, p->round_fp_QTX, p->quant_fp_QTX, 398 p->quant_shift_QTX, qcoeff_ptr, dqcoeff_ptr, p->dequant_QTX, eob_ptr, 399 sc->scan, sc->iscan, qparam->log_scale); 400 return; 401 } 402 av1_highbd_quantize_fp(coeff_ptr, n_coeffs, p->zbin_QTX, p->round_fp_QTX, 403 p->quant_fp_QTX, p->quant_shift_QTX, qcoeff_ptr, 404 dqcoeff_ptr, p->dequant_QTX, eob_ptr, sc->scan, 405 sc->iscan, qparam->log_scale); 406 } 407 } 408 409 void av1_highbd_quantize_b_facade(const tran_low_t *coeff_ptr, 410 intptr_t n_coeffs, const MACROBLOCK_PLANE *p, 411 tran_low_t *qcoeff_ptr, 412 tran_low_t *dqcoeff_ptr, uint16_t *eob_ptr, 413 const SCAN_ORDER *sc, 414 const QUANT_PARAM *qparam) { 415 const qm_val_t *qm_ptr = qparam->qmatrix; 416 const qm_val_t *iqm_ptr = qparam->iqmatrix; 417 if (qparam->use_quant_b_adapt) { 418 if (qm_ptr != NULL && iqm_ptr != NULL) { 419 highbd_quantize_b_adaptive_helper_c( 420 coeff_ptr, n_coeffs, p->zbin_QTX, p->round_QTX, p->quant_QTX, 421 p->quant_shift_QTX, qcoeff_ptr, dqcoeff_ptr, p->dequant_QTX, eob_ptr, 422 sc->scan, sc->iscan, qm_ptr, iqm_ptr, qparam->log_scale); 423 } else { 424 switch (qparam->log_scale) { 425 case 0: 426 if (LIKELY(n_coeffs >= 8)) { 427 aom_highbd_quantize_b_adaptive_c( 428 coeff_ptr, n_coeffs, p->zbin_QTX, p->round_QTX, p->quant_QTX, 429 p->quant_shift_QTX, qcoeff_ptr, dqcoeff_ptr, p->dequant_QTX, 430 eob_ptr, sc->scan, sc->iscan); 431 } else { 432 // TODO(luoyi): Need SIMD (e.g. sse2) for smaller block size 433 // quantization 434 aom_highbd_quantize_b_adaptive_c( 435 coeff_ptr, n_coeffs, p->zbin_QTX, p->round_QTX, p->quant_QTX, 436 p->quant_shift_QTX, qcoeff_ptr, dqcoeff_ptr, p->dequant_QTX, 437 eob_ptr, sc->scan, sc->iscan); 438 } 439 break; 440 case 1: 441 aom_highbd_quantize_b_32x32_adaptive_c( 442 coeff_ptr, n_coeffs, p->zbin_QTX, p->round_QTX, p->quant_QTX, 443 p->quant_shift_QTX, qcoeff_ptr, dqcoeff_ptr, p->dequant_QTX, 444 eob_ptr, sc->scan, sc->iscan); 445 break; 446 case 2: 447 aom_highbd_quantize_b_64x64_adaptive_c( 448 coeff_ptr, n_coeffs, p->zbin_QTX, p->round_QTX, p->quant_QTX, 449 p->quant_shift_QTX, qcoeff_ptr, dqcoeff_ptr, p->dequant_QTX, 450 eob_ptr, sc->scan, sc->iscan); 451 break; 452 default: assert(0); 453 } 454 } 455 } else { 456 if (qm_ptr != NULL && iqm_ptr != NULL) { 457 highbd_quantize_b_helper_c(coeff_ptr, n_coeffs, p->zbin_QTX, p->round_QTX, 458 p->quant_QTX, p->quant_shift_QTX, qcoeff_ptr, 459 dqcoeff_ptr, p->dequant_QTX, eob_ptr, sc->scan, 460 sc->iscan, qm_ptr, iqm_ptr, qparam->log_scale); 461 } else { 462 switch (qparam->log_scale) { 463 case 0: 464 if (LIKELY(n_coeffs >= 8)) { 465 aom_highbd_quantize_b(coeff_ptr, n_coeffs, p->zbin_QTX, 466 p->round_QTX, p->quant_QTX, 467 p->quant_shift_QTX, qcoeff_ptr, dqcoeff_ptr, 468 p->dequant_QTX, eob_ptr, sc->scan, sc->iscan); 469 } else { 470 // TODO(luoyi): Need SIMD (e.g. sse2) for smaller block size 471 // quantization 472 aom_highbd_quantize_b_c( 473 coeff_ptr, n_coeffs, p->zbin_QTX, p->round_QTX, p->quant_QTX, 474 p->quant_shift_QTX, qcoeff_ptr, dqcoeff_ptr, p->dequant_QTX, 475 eob_ptr, sc->scan, sc->iscan); 476 } 477 break; 478 case 1: 479 aom_highbd_quantize_b_32x32( 480 coeff_ptr, n_coeffs, p->zbin_QTX, p->round_QTX, p->quant_QTX, 481 p->quant_shift_QTX, qcoeff_ptr, dqcoeff_ptr, p->dequant_QTX, 482 eob_ptr, sc->scan, sc->iscan); 483 break; 484 case 2: 485 aom_highbd_quantize_b_64x64( 486 coeff_ptr, n_coeffs, p->zbin_QTX, p->round_QTX, p->quant_QTX, 487 p->quant_shift_QTX, qcoeff_ptr, dqcoeff_ptr, p->dequant_QTX, 488 eob_ptr, sc->scan, sc->iscan); 489 break; 490 default: assert(0); 491 } 492 } 493 } 494 } 495 496 static INLINE void highbd_quantize_dc( 497 const tran_low_t *coeff_ptr, int n_coeffs, int skip_block, 498 const int16_t *round_ptr, const int16_t quant, tran_low_t *qcoeff_ptr, 499 tran_low_t *dqcoeff_ptr, const int16_t dequant_ptr, uint16_t *eob_ptr, 500 const qm_val_t *qm_ptr, const qm_val_t *iqm_ptr, const int log_scale) { 501 int eob = -1; 502 503 memset(qcoeff_ptr, 0, n_coeffs * sizeof(*qcoeff_ptr)); 504 memset(dqcoeff_ptr, 0, n_coeffs * sizeof(*dqcoeff_ptr)); 505 506 if (!skip_block) { 507 const qm_val_t wt = qm_ptr != NULL ? qm_ptr[0] : (1 << AOM_QM_BITS); 508 const qm_val_t iwt = iqm_ptr != NULL ? iqm_ptr[0] : (1 << AOM_QM_BITS); 509 const int coeff = coeff_ptr[0]; 510 const int coeff_sign = (coeff >> 31); 511 const int abs_coeff = (coeff ^ coeff_sign) - coeff_sign; 512 const int64_t tmp = abs_coeff + ROUND_POWER_OF_TWO(round_ptr[0], log_scale); 513 const int64_t tmpw = tmp * wt; 514 const int abs_qcoeff = 515 (int)((tmpw * quant) >> (16 - log_scale + AOM_QM_BITS)); 516 qcoeff_ptr[0] = (tran_low_t)((abs_qcoeff ^ coeff_sign) - coeff_sign); 517 const int dequant = 518 (dequant_ptr * iwt + (1 << (AOM_QM_BITS - 1))) >> AOM_QM_BITS; 519 520 const tran_low_t abs_dqcoeff = (abs_qcoeff * dequant) >> log_scale; 521 dqcoeff_ptr[0] = (tran_low_t)((abs_dqcoeff ^ coeff_sign) - coeff_sign); 522 if (abs_qcoeff) eob = 0; 523 } 524 *eob_ptr = eob + 1; 525 } 526 527 void av1_highbd_quantize_dc_facade(const tran_low_t *coeff_ptr, 528 intptr_t n_coeffs, const MACROBLOCK_PLANE *p, 529 tran_low_t *qcoeff_ptr, 530 tran_low_t *dqcoeff_ptr, uint16_t *eob_ptr, 531 const SCAN_ORDER *sc, 532 const QUANT_PARAM *qparam) { 533 // obsolete skip_block 534 const int skip_block = 0; 535 const qm_val_t *qm_ptr = qparam->qmatrix; 536 const qm_val_t *iqm_ptr = qparam->iqmatrix; 537 (void)sc; 538 539 highbd_quantize_dc(coeff_ptr, (int)n_coeffs, skip_block, p->round_QTX, 540 p->quant_fp_QTX[0], qcoeff_ptr, dqcoeff_ptr, 541 p->dequant_QTX[0], eob_ptr, qm_ptr, iqm_ptr, 542 qparam->log_scale); 543 } 544 545 void av1_highbd_quantize_fp_c(const tran_low_t *coeff_ptr, intptr_t count, 546 const int16_t *zbin_ptr, const int16_t *round_ptr, 547 const int16_t *quant_ptr, 548 const int16_t *quant_shift_ptr, 549 tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, 550 const int16_t *dequant_ptr, uint16_t *eob_ptr, 551 const int16_t *scan, const int16_t *iscan, 552 int log_scale) { 553 highbd_quantize_fp_helper_c(coeff_ptr, count, zbin_ptr, round_ptr, quant_ptr, 554 quant_shift_ptr, qcoeff_ptr, dqcoeff_ptr, 555 dequant_ptr, eob_ptr, scan, iscan, NULL, NULL, 556 log_scale); 557 } 558 559 static void invert_quant(int16_t *quant, int16_t *shift, int d) { 560 uint32_t t; 561 int l, m; 562 t = d; 563 for (l = 0; t > 1; l++) t >>= 1; 564 m = 1 + (1 << (16 + l)) / d; 565 *quant = (int16_t)(m - (1 << 16)); 566 *shift = 1 << (16 - l); 567 } 568 569 static int get_qzbin_factor(int q, aom_bit_depth_t bit_depth) { 570 const int quant = av1_dc_quant_Q3(q, 0, bit_depth); 571 switch (bit_depth) { 572 case AOM_BITS_8: return q == 0 ? 64 : (quant < 148 ? 84 : 80); 573 case AOM_BITS_10: return q == 0 ? 64 : (quant < 592 ? 84 : 80); 574 case AOM_BITS_12: return q == 0 ? 64 : (quant < 2368 ? 84 : 80); 575 default: 576 assert(0 && "bit_depth should be AOM_BITS_8, AOM_BITS_10 or AOM_BITS_12"); 577 return -1; 578 } 579 } 580 581 void av1_build_quantizer(aom_bit_depth_t bit_depth, int y_dc_delta_q, 582 int u_dc_delta_q, int u_ac_delta_q, int v_dc_delta_q, 583 int v_ac_delta_q, QUANTS *const quants, 584 Dequants *const deq) { 585 int i, q, quant_Q3, quant_QTX; 586 587 for (q = 0; q < QINDEX_RANGE; q++) { 588 const int qzbin_factor = get_qzbin_factor(q, bit_depth); 589 const int qrounding_factor = q == 0 ? 64 : 48; 590 591 for (i = 0; i < 2; ++i) { 592 int qrounding_factor_fp = 64; 593 // y quantizer setup with original coeff shift of Q3 594 quant_Q3 = i == 0 ? av1_dc_quant_Q3(q, y_dc_delta_q, bit_depth) 595 : av1_ac_quant_Q3(q, 0, bit_depth); 596 // y quantizer with TX scale 597 quant_QTX = i == 0 ? av1_dc_quant_QTX(q, y_dc_delta_q, bit_depth) 598 : av1_ac_quant_QTX(q, 0, bit_depth); 599 invert_quant(&quants->y_quant[q][i], &quants->y_quant_shift[q][i], 600 quant_QTX); 601 quants->y_quant_fp[q][i] = (1 << 16) / quant_QTX; 602 quants->y_round_fp[q][i] = (qrounding_factor_fp * quant_QTX) >> 7; 603 quants->y_zbin[q][i] = ROUND_POWER_OF_TWO(qzbin_factor * quant_QTX, 7); 604 quants->y_round[q][i] = (qrounding_factor * quant_QTX) >> 7; 605 deq->y_dequant_QTX[q][i] = quant_QTX; 606 deq->y_dequant_Q3[q][i] = quant_Q3; 607 608 // u quantizer setup with original coeff shift of Q3 609 quant_Q3 = i == 0 ? av1_dc_quant_Q3(q, u_dc_delta_q, bit_depth) 610 : av1_ac_quant_Q3(q, u_ac_delta_q, bit_depth); 611 // u quantizer with TX scale 612 quant_QTX = i == 0 ? av1_dc_quant_QTX(q, u_dc_delta_q, bit_depth) 613 : av1_ac_quant_QTX(q, u_ac_delta_q, bit_depth); 614 invert_quant(&quants->u_quant[q][i], &quants->u_quant_shift[q][i], 615 quant_QTX); 616 quants->u_quant_fp[q][i] = (1 << 16) / quant_QTX; 617 quants->u_round_fp[q][i] = (qrounding_factor_fp * quant_QTX) >> 7; 618 quants->u_zbin[q][i] = ROUND_POWER_OF_TWO(qzbin_factor * quant_QTX, 7); 619 quants->u_round[q][i] = (qrounding_factor * quant_QTX) >> 7; 620 deq->u_dequant_QTX[q][i] = quant_QTX; 621 deq->u_dequant_Q3[q][i] = quant_Q3; 622 623 // v quantizer setup with original coeff shift of Q3 624 quant_Q3 = i == 0 ? av1_dc_quant_Q3(q, v_dc_delta_q, bit_depth) 625 : av1_ac_quant_Q3(q, v_ac_delta_q, bit_depth); 626 // v quantizer with TX scale 627 quant_QTX = i == 0 ? av1_dc_quant_QTX(q, v_dc_delta_q, bit_depth) 628 : av1_ac_quant_QTX(q, v_ac_delta_q, bit_depth); 629 invert_quant(&quants->v_quant[q][i], &quants->v_quant_shift[q][i], 630 quant_QTX); 631 quants->v_quant_fp[q][i] = (1 << 16) / quant_QTX; 632 quants->v_round_fp[q][i] = (qrounding_factor_fp * quant_QTX) >> 7; 633 quants->v_zbin[q][i] = ROUND_POWER_OF_TWO(qzbin_factor * quant_QTX, 7); 634 quants->v_round[q][i] = (qrounding_factor * quant_QTX) >> 7; 635 deq->v_dequant_QTX[q][i] = quant_QTX; 636 deq->v_dequant_Q3[q][i] = quant_Q3; 637 } 638 639 for (i = 2; i < 8; i++) { // 8: SIMD width 640 quants->y_quant[q][i] = quants->y_quant[q][1]; 641 quants->y_quant_fp[q][i] = quants->y_quant_fp[q][1]; 642 quants->y_round_fp[q][i] = quants->y_round_fp[q][1]; 643 quants->y_quant_shift[q][i] = quants->y_quant_shift[q][1]; 644 quants->y_zbin[q][i] = quants->y_zbin[q][1]; 645 quants->y_round[q][i] = quants->y_round[q][1]; 646 deq->y_dequant_QTX[q][i] = deq->y_dequant_QTX[q][1]; 647 deq->y_dequant_Q3[q][i] = deq->y_dequant_Q3[q][1]; 648 649 quants->u_quant[q][i] = quants->u_quant[q][1]; 650 quants->u_quant_fp[q][i] = quants->u_quant_fp[q][1]; 651 quants->u_round_fp[q][i] = quants->u_round_fp[q][1]; 652 quants->u_quant_shift[q][i] = quants->u_quant_shift[q][1]; 653 quants->u_zbin[q][i] = quants->u_zbin[q][1]; 654 quants->u_round[q][i] = quants->u_round[q][1]; 655 deq->u_dequant_QTX[q][i] = deq->u_dequant_QTX[q][1]; 656 deq->u_dequant_Q3[q][i] = deq->u_dequant_Q3[q][1]; 657 quants->v_quant[q][i] = quants->u_quant[q][1]; 658 quants->v_quant_fp[q][i] = quants->v_quant_fp[q][1]; 659 quants->v_round_fp[q][i] = quants->v_round_fp[q][1]; 660 quants->v_quant_shift[q][i] = quants->v_quant_shift[q][1]; 661 quants->v_zbin[q][i] = quants->v_zbin[q][1]; 662 quants->v_round[q][i] = quants->v_round[q][1]; 663 deq->v_dequant_QTX[q][i] = deq->v_dequant_QTX[q][1]; 664 deq->v_dequant_Q3[q][i] = deq->v_dequant_Q3[q][1]; 665 } 666 } 667 } 668 669 void av1_init_quantizer(AV1_COMP *cpi) { 670 AV1_COMMON *const cm = &cpi->common; 671 QUANTS *const quants = &cpi->quants; 672 Dequants *const dequants = &cpi->dequants; 673 av1_build_quantizer(cm->seq_params.bit_depth, cm->y_dc_delta_q, 674 cm->u_dc_delta_q, cm->u_ac_delta_q, cm->v_dc_delta_q, 675 cm->v_ac_delta_q, quants, dequants); 676 } 677 678 void av1_init_plane_quantizers(const AV1_COMP *cpi, MACROBLOCK *x, 679 int segment_id) { 680 const AV1_COMMON *const cm = &cpi->common; 681 MACROBLOCKD *const xd = &x->e_mbd; 682 const QUANTS *const quants = &cpi->quants; 683 684 int current_qindex = AOMMAX( 685 0, AOMMIN(QINDEX_RANGE - 1, cpi->oxcf.deltaq_mode != NO_DELTA_Q 686 ? cm->base_qindex + xd->delta_qindex 687 : cm->base_qindex)); 688 const int qindex = av1_get_qindex(&cm->seg, segment_id, current_qindex); 689 const int rdmult = av1_compute_rd_mult(cpi, qindex + cm->y_dc_delta_q); 690 int qmlevel = (xd->lossless[segment_id] || cm->using_qmatrix == 0) 691 ? NUM_QM_LEVELS - 1 692 : cm->qm_y; 693 694 // Y 695 x->plane[0].quant_QTX = quants->y_quant[qindex]; 696 x->plane[0].quant_fp_QTX = quants->y_quant_fp[qindex]; 697 x->plane[0].round_fp_QTX = quants->y_round_fp[qindex]; 698 x->plane[0].quant_shift_QTX = quants->y_quant_shift[qindex]; 699 x->plane[0].zbin_QTX = quants->y_zbin[qindex]; 700 x->plane[0].round_QTX = quants->y_round[qindex]; 701 x->plane[0].dequant_QTX = cpi->dequants.y_dequant_QTX[qindex]; 702 memcpy(&xd->plane[0].seg_qmatrix[segment_id], cm->gqmatrix[qmlevel][0], 703 sizeof(cm->gqmatrix[qmlevel][0])); 704 memcpy(&xd->plane[0].seg_iqmatrix[segment_id], cm->giqmatrix[qmlevel][0], 705 sizeof(cm->giqmatrix[qmlevel][0])); 706 xd->plane[0].dequant_Q3 = cpi->dequants.y_dequant_Q3[qindex]; 707 708 // U 709 qmlevel = (xd->lossless[segment_id] || cm->using_qmatrix == 0) 710 ? NUM_QM_LEVELS - 1 711 : cm->qm_u; 712 { 713 x->plane[1].quant_QTX = quants->u_quant[qindex]; 714 x->plane[1].quant_fp_QTX = quants->u_quant_fp[qindex]; 715 x->plane[1].round_fp_QTX = quants->u_round_fp[qindex]; 716 x->plane[1].quant_shift_QTX = quants->u_quant_shift[qindex]; 717 x->plane[1].zbin_QTX = quants->u_zbin[qindex]; 718 x->plane[1].round_QTX = quants->u_round[qindex]; 719 x->plane[1].dequant_QTX = cpi->dequants.u_dequant_QTX[qindex]; 720 memcpy(&xd->plane[1].seg_qmatrix[segment_id], cm->gqmatrix[qmlevel][1], 721 sizeof(cm->gqmatrix[qmlevel][1])); 722 memcpy(&xd->plane[1].seg_iqmatrix[segment_id], cm->giqmatrix[qmlevel][1], 723 sizeof(cm->giqmatrix[qmlevel][1])); 724 x->plane[1].dequant_QTX = cpi->dequants.u_dequant_QTX[qindex]; 725 xd->plane[1].dequant_Q3 = cpi->dequants.u_dequant_Q3[qindex]; 726 } 727 // V 728 qmlevel = (xd->lossless[segment_id] || cm->using_qmatrix == 0) 729 ? NUM_QM_LEVELS - 1 730 : cm->qm_v; 731 { 732 x->plane[2].quant_QTX = quants->v_quant[qindex]; 733 x->plane[2].quant_fp_QTX = quants->v_quant_fp[qindex]; 734 x->plane[2].round_fp_QTX = quants->v_round_fp[qindex]; 735 x->plane[2].quant_shift_QTX = quants->v_quant_shift[qindex]; 736 x->plane[2].zbin_QTX = quants->v_zbin[qindex]; 737 x->plane[2].round_QTX = quants->v_round[qindex]; 738 x->plane[2].dequant_QTX = cpi->dequants.v_dequant_QTX[qindex]; 739 memcpy(&xd->plane[2].seg_qmatrix[segment_id], cm->gqmatrix[qmlevel][2], 740 sizeof(cm->gqmatrix[qmlevel][2])); 741 memcpy(&xd->plane[2].seg_iqmatrix[segment_id], cm->giqmatrix[qmlevel][2], 742 sizeof(cm->giqmatrix[qmlevel][2])); 743 x->plane[2].dequant_QTX = cpi->dequants.v_dequant_QTX[qindex]; 744 xd->plane[2].dequant_Q3 = cpi->dequants.v_dequant_Q3[qindex]; 745 } 746 x->skip_block = segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP); 747 x->qindex = qindex; 748 749 set_error_per_bit(x, rdmult); 750 751 av1_initialize_me_consts(cpi, x, qindex); 752 } 753 754 void av1_frame_init_quantizer(AV1_COMP *cpi) { 755 MACROBLOCK *const x = &cpi->td.mb; 756 MACROBLOCKD *const xd = &x->e_mbd; 757 av1_init_plane_quantizers(cpi, x, xd->mi[0]->segment_id); 758 } 759 760 void av1_set_quantizer(AV1_COMMON *cm, int q) { 761 // quantizer has to be reinitialized with av1_init_quantizer() if any 762 // delta_q changes. 763 cm->base_qindex = AOMMAX(cm->delta_q_info.delta_q_present_flag, q); 764 cm->y_dc_delta_q = 0; 765 cm->u_dc_delta_q = 0; 766 cm->u_ac_delta_q = 0; 767 cm->v_dc_delta_q = 0; 768 cm->v_ac_delta_q = 0; 769 cm->qm_y = aom_get_qmlevel(cm->base_qindex, cm->min_qmlevel, cm->max_qmlevel); 770 cm->qm_u = aom_get_qmlevel(cm->base_qindex + cm->u_ac_delta_q, 771 cm->min_qmlevel, cm->max_qmlevel); 772 773 if (!cm->seq_params.separate_uv_delta_q) 774 cm->qm_v = cm->qm_u; 775 else 776 cm->qm_v = aom_get_qmlevel(cm->base_qindex + cm->v_ac_delta_q, 777 cm->min_qmlevel, cm->max_qmlevel); 778 } 779 780 // Table that converts 0-63 Q-range values passed in outside to the Qindex 781 // range used internally. 782 static const int quantizer_to_qindex[] = { 783 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 784 52, 56, 60, 64, 68, 72, 76, 80, 84, 88, 92, 96, 100, 785 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144, 148, 152, 786 156, 160, 164, 168, 172, 176, 180, 184, 188, 192, 196, 200, 204, 787 208, 212, 216, 220, 224, 228, 232, 236, 240, 244, 249, 255, 788 }; 789 790 int av1_quantizer_to_qindex(int quantizer) { 791 return quantizer_to_qindex[quantizer]; 792 } 793 794 int av1_qindex_to_quantizer(int qindex) { 795 int quantizer; 796 797 for (quantizer = 0; quantizer < 64; ++quantizer) 798 if (quantizer_to_qindex[quantizer] >= qindex) return quantizer; 799 800 return 63; 801 } 802
