Commit 80b82269 authored by Angie Chiang's avatar Angie Chiang

Add lv_map transform coefficient coding function

Change-Id: I70c3659940b5090f030c795df5148ac508e19d2d
parent 971a5963
......@@ -54,6 +54,8 @@ AV1_CX_SRCS-yes += encoder/block.h
AV1_CX_SRCS-yes += encoder/bitstream.h
AV1_CX_SRCS-yes += encoder/encodemb.h
AV1_CX_SRCS-yes += encoder/encodemv.h
AV1_CX_SRCS-$(CONFIG_LV_MAP) += encoder/encodetxb.c
AV1_CX_SRCS-$(CONFIG_LV_MAP) += encoder/encodetxb.h
AV1_CX_SRCS-yes += encoder/extend.h
AV1_CX_SRCS-yes += encoder/firstpass.h
AV1_CX_SRCS-yes += encoder/lookahead.c
......
......@@ -933,6 +933,15 @@ static INLINE TX_SIZE get_uv_tx_size(const MB_MODE_INFO *mbmi,
return uv_txsize;
}
static INLINE TX_SIZE get_tx_size(int plane, const MACROBLOCKD *xd,
int block_idx) {
const MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
const MACROBLOCKD_PLANE *pd = &xd->plane[plane];
const TX_SIZE tx_size = plane ? get_uv_tx_size(mbmi, pd) : mbmi->tx_size;
(void)block_idx;
return tx_size;
}
static INLINE BLOCK_SIZE
get_plane_block_size(BLOCK_SIZE bsize, const struct macroblockd_plane *pd) {
return ss_size_lookup[bsize][pd->subsampling_x][pd->subsampling_y];
......
/*
* Copyright (c) 2017, Alliance for Open Media. All rights reserved
*
* This source code is subject to the terms of the BSD 2 Clause License and
* the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
* was not distributed with this source code in the LICENSE file, you can
* obtain it at www.aomedia.org/license/software. If the Alliance for Open
* Media Patent License 1.0 was not distributed with this source code in the
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
*/
#include "av1/common/scan.h"
#include "av1/common/txb_common.h"
#include "av1/encoder/encodetxb.h"
static void write_golomb(aom_writer *w, int level) {
int x = level + 1;
int i = x;
int length = 0;
while (i) {
i >>= 1;
++length;
}
assert(length > 0);
for (i = 0; i < length - 1; ++i) aom_write_bit(w, 0);
for (i = length - 1; i >= 0; --i) aom_write_bit(w, (x >> i) & 0x01);
}
void av1_write_coeffs_txb(const AV1_COMMON *const cm, MACROBLOCKD *xd,
aom_writer *w, int block, int plane,
const tran_low_t *tcoeff, uint16_t eob,
TXB_CTX *txb_ctx) {
aom_prob *nz_map;
aom_prob *eob_flag;
MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
const PLANE_TYPE plane_type = (plane == 0) ? PLANE_TYPE_Y : PLANE_TYPE_UV;
const TX_SIZE tx_size = get_tx_size(plane, xd, block);
const TX_TYPE tx_type = get_tx_type(plane_type, xd, block, tx_size);
const SCAN_ORDER *const scan_order =
get_scan(cm, tx_size, tx_type, is_inter_block(mbmi));
const int16_t *scan = scan_order->scan;
int c;
int is_nz;
const int bwl = b_width_log2_lookup[txsize_to_bsize[tx_size]] + 2;
const int seg_eob = 16 << (tx_size << 1);
uint8_t txb_mask[32 * 32] = { 0 };
uint16_t update_eob = 0;
aom_write(w, eob == 0, cm->fc->txb_skip[tx_size][txb_ctx->txb_skip_ctx]);
if (eob == 0) return;
nz_map = cm->fc->nz_map[tx_size][plane_type];
eob_flag = cm->fc->eob_flag[tx_size][plane_type];
for (c = 0; c < eob; ++c) {
int coeff_ctx = get_nz_map_ctx(tcoeff, txb_mask, scan[c], bwl);
int eob_ctx = get_eob_ctx(tcoeff, scan[c], bwl);
tran_low_t v = tcoeff[scan[c]];
is_nz = (v != 0);
if (c == seg_eob - 1) break;
aom_write(w, is_nz, nz_map[coeff_ctx]);
if (is_nz) {
aom_write(w, c == (eob - 1), eob_flag[eob_ctx]);
}
txb_mask[scan[c]] = 1;
}
int i;
for (i = 0; i < NUM_BASE_LEVELS; ++i) {
aom_prob *coeff_base = cm->fc->coeff_base[tx_size][plane_type][i];
update_eob = 0;
for (c = eob - 1; c >= 0; --c) {
tran_low_t v = tcoeff[scan[c]];
tran_low_t level = abs(v);
int sign = (v < 0) ? 1 : 0;
int ctx;
if (level <= i) continue;
ctx = get_base_ctx(tcoeff, scan[c], bwl, i + 1);
if (level == i + 1) {
aom_write(w, 1, coeff_base[ctx]);
if (c == 0) {
aom_write(w, sign, cm->fc->dc_sign[plane_type][txb_ctx->dc_sign_ctx]);
} else {
aom_write_bit(w, sign);
}
continue;
}
aom_write(w, 0, coeff_base[ctx]);
update_eob = AOMMAX(update_eob, c);
}
}
for (c = update_eob; c >= 0; --c) {
tran_low_t v = tcoeff[scan[c]];
tran_low_t level = abs(v);
int sign = (v < 0) ? 1 : 0;
int idx;
int ctx;
if (level <= NUM_BASE_LEVELS) continue;
if (c == 0) {
aom_write(w, sign, cm->fc->dc_sign[plane_type][txb_ctx->dc_sign_ctx]);
} else {
aom_write_bit(w, sign);
}
// level is above 1.
ctx = get_level_ctx(tcoeff, scan[c], bwl);
for (idx = 0; idx < COEFF_BASE_RANGE; ++idx) {
if (level == (idx + 1 + NUM_BASE_LEVELS)) {
aom_write(w, 1, cm->fc->coeff_lps[tx_size][plane_type][ctx]);
break;
}
aom_write(w, 0, cm->fc->coeff_lps[tx_size][plane_type][ctx]);
}
if (idx < COEFF_BASE_RANGE) continue;
// use 0-th order Golomb code to handle the residual level.
write_golomb(w, level - COEFF_BASE_RANGE - 1 - NUM_BASE_LEVELS);
}
}
/*
* Copyright (c) 2017, Alliance for Open Media. All rights reserved
*
* This source code is subject to the terms of the BSD 2 Clause License and
* the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
* was not distributed with this source code in the LICENSE file, you can
* obtain it at www.aomedia.org/license/software. If the Alliance for Open
* Media Patent License 1.0 was not distributed with this source code in the
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
*/
#ifndef ENCODETXB_H_
#define ENCODETXB_H_
#include "./aom_config.h"
#include "av1/common/blockd.h"
#include "av1/common/onyxc_int.h"
#include "aom_dsp/bitwriter.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct txb_ctx {
int txb_skip_ctx;
int dc_sign_ctx;
} TXB_CTX;
void av1_write_coeffs_txb(const AV1_COMMON *const cm, MACROBLOCKD *xd,
aom_writer *w, int block, int plane,
const tran_low_t *tcoeff, uint16_t eob,
TXB_CTX *txb_ctx);
#ifdef __cplusplus
}
#endif
#endif // COEFFS_CODING_H_
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment