/******************************************************************************
|
*
|
* Copyright (C) 2018 The Android Open Source Project
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at:
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*
|
*****************************************************************************
|
* Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
|
*/
|
/**
|
******************************************************************************
|
* @file ihevce_cabac.c
|
*
|
* @brief
|
* This file contains function definitions related to bitstream generation
|
*
|
* @author
|
* ittiam
|
*
|
* @List of Functions
|
* ihevce_cabac_reset()
|
* ihevce_cabac_init()
|
* ihevce_cabac_put_byte()
|
* ihevce_cabac_encode_bin()
|
* ihevce_cabac_encode_bypass_bin()
|
* ihevce_cabac_encode_terminate()
|
* ihevce_cabac_encode_tunary()
|
* ihevce_cabac_encode_tunary_bypass()
|
* ihevce_cabac_encode_bypass_bins()
|
* ihevce_cabac_encode_egk()
|
* ihevce_cabac_encode_trunc_rice()
|
* ihevce_cabac_encode_trunc_rice_ctxt()
|
* ihevce_cabac_flush()
|
* ihevce_cabac_ctxt_backup()
|
* ihevce_cabac_ctxt_row_init()
|
*
|
*******************************************************************************
|
*/
|
|
/*****************************************************************************/
|
/* File Includes */
|
/*****************************************************************************/
|
/* System include files */
|
#include <stdio.h>
|
#include <string.h>
|
#include <stdlib.h>
|
#include <assert.h>
|
#include <stdarg.h>
|
#include <math.h>
|
|
/* User include files */
|
#include "ihevc_typedefs.h"
|
#include "ihevc_debug.h"
|
#include "ihevc_macros.h"
|
#include "ihevc_platform_macros.h"
|
#include "ihevc_cabac_tables.h"
|
|
#include "ihevce_defs.h"
|
#include "ihevce_error_codes.h"
|
#include "ihevce_bitstream.h"
|
#include "ihevce_cabac.h"
|
|
#define TEST_CABAC_BITESTIMATE 0
|
|
/*****************************************************************************/
|
/* Function Definitions */
|
/*****************************************************************************/
|
|
/**
|
******************************************************************************
|
*
|
* @brief Resets the encoder cabac engine
|
*
|
* @par Description
|
* This routine needs to be called at start of dependent slice encode
|
*
|
* @param[inout] ps_cabac_ctxt
|
* pointer to cabac context (handle)
|
*
|
* @param[in] ps_bitstrm
|
* pointer to bitstream context (handle)
|
*
|
* @param[in] e_cabac_op_mode
|
* opertaing mode of cabac; put bits / compute bits mode @sa CABAC_OP_MODE
|
*
|
* @return success or failure error code
|
*
|
******************************************************************************
|
*/
|
WORD32
|
ihevce_cabac_reset(cab_ctxt_t *ps_cabac, bitstrm_t *ps_bitstrm, CABAC_OP_MODE e_cabac_op_mode)
|
{
|
/* Sanity checks */
|
ASSERT(ps_cabac != NULL);
|
ASSERT(
|
(e_cabac_op_mode == CABAC_MODE_ENCODE_BITS) ||
|
(e_cabac_op_mode == CABAC_MODE_COMPUTE_BITS));
|
|
ps_cabac->e_cabac_op_mode = e_cabac_op_mode;
|
|
if(CABAC_MODE_ENCODE_BITS == e_cabac_op_mode)
|
{
|
ASSERT(ps_bitstrm != NULL);
|
|
/* Bitstream context initialization */
|
ps_cabac->pu1_strm_buffer = ps_bitstrm->pu1_strm_buffer;
|
ps_cabac->u4_max_strm_size = ps_bitstrm->u4_max_strm_size;
|
/* When entropy sync is enabled start form fixed offset from point
|
* where slice header extension has ended to handle emulation prevention
|
* bytes during insertion of slice offset at end of frame */
|
if(1 == ps_cabac->i1_entropy_coding_sync_enabled_flag)
|
{
|
ps_cabac->u4_strm_buf_offset = ps_cabac->u4_first_slice_start_offset;
|
}
|
else
|
{
|
ps_cabac->u4_strm_buf_offset = ps_bitstrm->u4_strm_buf_offset;
|
}
|
ps_cabac->i4_zero_bytes_run = ps_bitstrm->i4_zero_bytes_run;
|
|
/* cabac engine initialization */
|
ps_cabac->u4_low = 0;
|
ps_cabac->u4_range = 510;
|
ps_cabac->u4_bits_gen = 0;
|
ps_cabac->u4_out_standing_bytes = 0;
|
}
|
else /* (CABAC_MODE_COMPUTE_BITS == e_cabac_op_mode) */
|
{
|
/* reset the bits estimated */
|
ps_cabac->u4_bits_estimated_q12 = 0;
|
|
/* reset the texture bits estimated */
|
ps_cabac->u4_texture_bits_estimated_q12 = 0;
|
|
/* Setting range to 0 switches off AEV_TRACE in compute bits mode */
|
ps_cabac->u4_range = 0;
|
}
|
|
return (IHEVCE_SUCCESS);
|
}
|
|
/**
|
******************************************************************************
|
*
|
* @brief Initializes the encoder cabac engine
|
*
|
* @par Description
|
* This routine needs to be called at start of slice/frame encode
|
*
|
* @param[inout] ps_cabac_ctxt
|
* pointer to cabac context (handle)
|
*
|
* @param[in] ps_bitstrm
|
* pointer to bitstream context (handle)
|
*
|
* @param[in] qp
|
* current slice qp
|
*
|
* @param[in] cabac_init_idc
|
* current slice init idc (range - [0- 2])*
|
*
|
* @param[in] e_cabac_op_mode
|
* opertaing mode of cabac; put bits / compute bits mode @sa CABAC_OP_MODE
|
*
|
* @return success or failure error code
|
*
|
******************************************************************************
|
*/
|
WORD32 ihevce_cabac_init(
|
cab_ctxt_t *ps_cabac,
|
bitstrm_t *ps_bitstrm,
|
WORD32 slice_qp,
|
WORD32 cabac_init_idc,
|
CABAC_OP_MODE e_cabac_op_mode)
|
{
|
/* Sanity checks */
|
ASSERT(ps_cabac != NULL);
|
ASSERT((slice_qp >= 0) && (slice_qp < IHEVC_MAX_QP));
|
ASSERT((cabac_init_idc >= 0) && (cabac_init_idc < 3));
|
ASSERT(
|
(e_cabac_op_mode == CABAC_MODE_ENCODE_BITS) ||
|
(e_cabac_op_mode == CABAC_MODE_COMPUTE_BITS));
|
|
ps_cabac->e_cabac_op_mode = e_cabac_op_mode;
|
|
if(CABAC_MODE_ENCODE_BITS == e_cabac_op_mode)
|
{
|
ASSERT(ps_bitstrm != NULL);
|
|
/* Bitstream context initialization */
|
ps_cabac->pu1_strm_buffer = ps_bitstrm->pu1_strm_buffer;
|
ps_cabac->u4_max_strm_size = ps_bitstrm->u4_max_strm_size;
|
/* When entropy sync is enabled start form fixed offset from point
|
* where slice header extension has ended to handle emulation prevention
|
* bytes during insertion of slice offset at end of frame */
|
if(1 == ps_cabac->i1_entropy_coding_sync_enabled_flag)
|
{
|
ps_cabac->u4_strm_buf_offset = ps_cabac->u4_first_slice_start_offset;
|
}
|
else
|
{
|
ps_cabac->u4_strm_buf_offset = ps_bitstrm->u4_strm_buf_offset;
|
}
|
ps_cabac->i4_zero_bytes_run = ps_bitstrm->i4_zero_bytes_run;
|
|
/* cabac engine initialization */
|
ps_cabac->u4_low = 0;
|
ps_cabac->u4_range = 510;
|
ps_cabac->u4_bits_gen = 0;
|
ps_cabac->u4_out_standing_bytes = 0;
|
|
/* reset the bits estimated */
|
ps_cabac->u4_bits_estimated_q12 = 0;
|
|
/* reset the texture bits estimated */
|
ps_cabac->u4_texture_bits_estimated_q12 = 0;
|
}
|
else /* (CABAC_MODE_COMPUTE_BITS == e_cabac_op_mode) */
|
{
|
/* reset the bits estimated */
|
ps_cabac->u4_bits_estimated_q12 = 0;
|
|
/* reset the texture bits estimated */
|
ps_cabac->u4_texture_bits_estimated_q12 = 0;
|
|
/* Setting range to 0 switches off AEV_TRACE in compute bits mode */
|
ps_cabac->u4_range = 0;
|
}
|
|
/* cabac context initialization based on init idc and slice qp */
|
COPY_CABAC_STATES(
|
ps_cabac->au1_ctxt_models,
|
&gau1_ihevc_cab_ctxts[cabac_init_idc][slice_qp][0],
|
IHEVC_CAB_CTXT_END);
|
|
return (IHEVCE_SUCCESS);
|
}
|
|
/**
|
******************************************************************************
|
*
|
* @brief Puts new byte (and outstanding bytes) into bitstream after cabac
|
* renormalization
|
*
|
* @par Description
|
* 1. Extract the leading byte of low(L)
|
* 2. If leading byte=0xff increment outstanding bytes and return
|
* (as the actual bits depend on carry propogation later)
|
* 3. If leading byte is not 0xff check for any carry propogation
|
* 4. Insert the carry (propogated in previous byte) along with outstanding
|
* bytes (if any) and leading byte
|
*
|
*
|
* @param[inout] ps_cabac
|
* pointer to cabac context (handle)
|
*
|
* @return success or failure error code
|
*
|
******************************************************************************
|
*/
|
WORD32 ihevce_cabac_put_byte(cab_ctxt_t *ps_cabac)
|
{
|
UWORD32 u4_low = ps_cabac->u4_low;
|
UWORD32 u4_bits_gen = ps_cabac->u4_bits_gen;
|
WORD32 lead_byte = u4_low >> (u4_bits_gen + CABAC_BITS - 8);
|
|
/* Sanity checks */
|
ASSERT((ps_cabac->u4_range >= 256) && (ps_cabac->u4_range < 512));
|
ASSERT((u4_bits_gen >= 8));
|
|
/* update bits generated and low after extracting leading byte */
|
u4_bits_gen -= 8;
|
ps_cabac->u4_low &= ((1 << (CABAC_BITS + u4_bits_gen)) - 1);
|
ps_cabac->u4_bits_gen = u4_bits_gen;
|
|
/************************************************************************/
|
/* 1. Extract the leading byte of low(L) */
|
/* 2. If leading byte=0xff increment outstanding bytes and return */
|
/* (as the actual bits depend on carry propogation later) */
|
/* 3. If leading byte is not 0xff check for any carry propogation */
|
/* 4. Insert the carry (propogated in previous byte) along with */
|
/* outstanding bytes (if any) and leading byte */
|
/************************************************************************/
|
if(lead_byte == 0xff)
|
{
|
/* actual bits depend on carry propogration */
|
ps_cabac->u4_out_standing_bytes++;
|
return (IHEVCE_SUCCESS);
|
}
|
else
|
{
|
/* carry = 1 => putbit(1); carry propogated due to L renorm */
|
WORD32 carry = (lead_byte >> 8) & 0x1;
|
UWORD8 *pu1_strm_buf = ps_cabac->pu1_strm_buffer;
|
UWORD32 u4_strm_buf_offset = ps_cabac->u4_strm_buf_offset;
|
WORD32 zero_run = ps_cabac->i4_zero_bytes_run;
|
UWORD32 u4_out_standing_bytes = ps_cabac->u4_out_standing_bytes;
|
|
/*********************************************************************/
|
/* Bitstream overflow check */
|
/* NOTE: corner case of epb bytes (max 2 for 32bit word) not handled */
|
/*********************************************************************/
|
if((u4_strm_buf_offset + u4_out_standing_bytes + 1) >= ps_cabac->u4_max_strm_size)
|
{
|
/* return without corrupting the buffer beyond its size */
|
return (IHEVCE_BITSTREAM_BUFFER_OVERFLOW);
|
}
|
|
/*********************************************************************/
|
/* Insert the carry propogated in previous byte */
|
/* */
|
/* Note : Do not worry about corruption into slice header align byte */
|
/* This is because the first bin cannot result in overflow */
|
/*********************************************************************/
|
if(carry)
|
{
|
/* CORNER CASE: if the previous data is 0x000003, then EPB will be inserted
|
and the data will become 0x00000303 and if the carry is present, it will
|
be added with the last byte and it will become 0x00000304 which is not correct
|
as per standard*/
|
/* so check for previous four bytes and if it is equal to 0x00000303
|
then subtract u4_strm_buf_offset by 1 */
|
if(pu1_strm_buf[u4_strm_buf_offset - 1] == 0x03 &&
|
pu1_strm_buf[u4_strm_buf_offset - 2] == 0x03 &&
|
pu1_strm_buf[u4_strm_buf_offset - 3] == 0x00 &&
|
pu1_strm_buf[u4_strm_buf_offset - 4] == 0x00)
|
{
|
u4_strm_buf_offset -= 1;
|
}
|
/* previous byte carry add will not result in overflow to */
|
/* u4_strm_buf_offset - 2 as we track 0xff as outstanding bytes */
|
pu1_strm_buf[u4_strm_buf_offset - 1] += carry;
|
zero_run = 0;
|
}
|
|
/* Insert outstanding bytes (if any) */
|
while(u4_out_standing_bytes)
|
{
|
UWORD8 u1_0_or_ff = carry ? 0 : 0xFF;
|
|
PUTBYTE_EPB(pu1_strm_buf, u4_strm_buf_offset, u1_0_or_ff, zero_run);
|
|
u4_out_standing_bytes--;
|
}
|
ps_cabac->u4_out_standing_bytes = 0;
|
|
/* Insert the leading byte */
|
lead_byte &= 0xFF;
|
PUTBYTE_EPB(pu1_strm_buf, u4_strm_buf_offset, lead_byte, zero_run);
|
|
/* update the state variables and return success */
|
ps_cabac->u4_strm_buf_offset = u4_strm_buf_offset;
|
ps_cabac->i4_zero_bytes_run = zero_run;
|
return (IHEVCE_SUCCESS);
|
}
|
}
|
|
/**
|
******************************************************************************
|
*
|
* @brief Codes a bypass bin (equi probable 0 / 1)
|
*
|
* @par Description
|
* After encoding bypass bin, bits gen incremented by 1 and bitstream generated
|
*
|
* @param[inout] ps_cabac : pointer to cabac context (handle)
|
*
|
* @param[in] bin : bypass bin(0/1) to be encoded
|
*
|
* @return success or failure error code
|
*
|
******************************************************************************
|
*/
|
WORD32 ihevce_cabac_encode_bypass_bin(cab_ctxt_t *ps_cabac, WORD32 bin)
|
{
|
UWORD32 u4_range = ps_cabac->u4_range;
|
UWORD32 u4_low = ps_cabac->u4_low;
|
|
if(CABAC_MODE_ENCODE_BITS == ps_cabac->e_cabac_op_mode)
|
{
|
/* Sanity checks */
|
ASSERT((u4_range >= 256) && (u4_range < 512));
|
ASSERT((bin == 0) || (bin == 1));
|
|
/*Compute bit always to populate the trace*/
|
/* increment bits generated by 1 */
|
ps_cabac->u4_bits_estimated_q12 += (1 << CABAC_FRAC_BITS_Q);
|
|
u4_low <<= 1;
|
/* add range if bin is 1 */
|
if(bin)
|
{
|
u4_low += u4_range;
|
}
|
|
/* 1 bit to be inserted in the bitstream */
|
ps_cabac->u4_bits_gen++;
|
ps_cabac->u4_low = u4_low;
|
|
/* generate stream when a byte is ready */
|
if(ps_cabac->u4_bits_gen > CABAC_BITS)
|
{
|
return (ihevce_cabac_put_byte(ps_cabac));
|
}
|
}
|
else /* (CABAC_MODE_COMPUTE_BITS == e_cabac_op_mode) */
|
{
|
/* increment bits generated by 1 */
|
ps_cabac->u4_bits_estimated_q12 += (1 << CABAC_FRAC_BITS_Q);
|
}
|
|
return (IHEVCE_SUCCESS);
|
}
|
|
/**
|
******************************************************************************
|
*
|
* @brief Codes a terminate bin (1:terminate 0:do not terminate)
|
*
|
* @par Description
|
* After encoding bypass bin, bits gen incremented by 1 and bitstream generated
|
*
|
* @param[inout] ps_cabac : pointer to cabac context (handle)
|
*
|
* @param[in] term_bin : (1:terminate 0:do not terminate)
|
*
|
* @return success or failure error code
|
*
|
******************************************************************************
|
*/
|
WORD32
|
ihevce_cabac_encode_terminate(cab_ctxt_t *ps_cabac, WORD32 term_bin, WORD32 i4_end_of_sub_strm)
|
{
|
UWORD32 u4_range = ps_cabac->u4_range;
|
UWORD32 u4_low = ps_cabac->u4_low;
|
UWORD32 u4_rlps;
|
WORD32 shift;
|
WORD32 error = IHEVCE_SUCCESS;
|
|
/* Sanity checks */
|
ASSERT((u4_range >= 256) && (u4_range < 512));
|
ASSERT((term_bin == 0) || (term_bin == 1));
|
|
/* term_bin = 1 has lps range = 2 */
|
u4_rlps = 2;
|
u4_range -= u4_rlps;
|
|
/* if terminate L is incremented by curR and R=2 */
|
if(term_bin)
|
{
|
/* lps path; L= L + R; R = RLPS */
|
u4_low += u4_range;
|
u4_range = u4_rlps;
|
}
|
|
/*****************************************************************/
|
/* Renormalization; calculate bits generated based on range(R) */
|
/* Note : 6 <= R < 512; R is 2 only for terminating encode */
|
/*****************************************************************/
|
GETRANGE(shift, u4_range);
|
shift = 9 - shift;
|
u4_low <<= shift;
|
u4_range <<= shift;
|
|
/* bits to be inserted in the bitstream */
|
ps_cabac->u4_bits_gen += shift;
|
ps_cabac->u4_range = u4_range;
|
ps_cabac->u4_low = u4_low;
|
|
/* generate stream when a byte is ready */
|
if(ps_cabac->u4_bits_gen > CABAC_BITS)
|
{
|
error = ihevce_cabac_put_byte(ps_cabac);
|
}
|
|
if(term_bin)
|
{
|
ihevce_cabac_flush(ps_cabac, i4_end_of_sub_strm);
|
}
|
|
/*Compute bit always to populate the trace*/
|
ps_cabac->u4_bits_estimated_q12 += gau2_ihevce_cabac_bin_to_bits[(62 << 1) | term_bin];
|
|
return (error);
|
}
|
|
/**
|
******************************************************************************
|
*
|
* @brief Encodes a truncated unary symbol associated with context model(s)
|
*
|
* @par Description
|
* Does binarization of tunary symbol as per sec 9.3.2.2 and does the cabac
|
* encoding of each bin. This is used for computing symbols like qp_delta,
|
* last_sig_coeff_prefix_x, last_sig_coeff_prefix_y.
|
*
|
* The context models associated with each bin is computed as :
|
* current bin context = "base context idx" + (bin_idx >> shift)
|
* where
|
* 1. "base context idx" is the base index for the syntax element
|
* 2. "bin_idx" is the current bin index of the unary code
|
* 3. "shift" is the shift factor associated with this syntax element
|
*
|
* @param[inout]ps_cabac
|
* pointer to cabac context (handle)
|
*
|
* @param[in] sym
|
* syntax element to be coded as truncated unary bins
|
*
|
* @param[in] c_max
|
* maximum value of sym (required for tunary binarization)
|
*
|
* @param[in] ctxt_index
|
* base context model index for this syntax element
|
*
|
* @param[in] ctxt_shift
|
* shift factor for context increments associated with this syntax element
|
*
|
* @param[in] ctxt_inc_max
|
* max value of context increment beyond which all bins will use same ctxt
|
*
|
* @return success or failure error code
|
*
|
******************************************************************************
|
*/
|
WORD32 ihevce_cabac_encode_tunary(
|
cab_ctxt_t *ps_cabac,
|
WORD32 sym,
|
WORD32 c_max,
|
WORD32 ctxt_index,
|
WORD32 ctxt_shift,
|
WORD32 ctxt_inc_max)
|
{
|
WORD32 bin_ctxt, i;
|
WORD32 error = IHEVCE_SUCCESS;
|
|
/* Sanity checks */
|
ASSERT(c_max > 0);
|
ASSERT((sym <= c_max) && (sym >= 0));
|
ASSERT((ctxt_index >= 0) && (ctxt_index < IHEVC_CAB_CTXT_END));
|
ASSERT((ctxt_index + (c_max >> ctxt_shift)) < IHEVC_CAB_CTXT_END);
|
|
/* Special case of sym= 0 */
|
if(0 == sym)
|
{
|
return (ihevce_cabac_encode_bin(ps_cabac, 0, ctxt_index));
|
}
|
|
/* write '1' bins */
|
for(i = 0; i < sym; i++)
|
{
|
/* TODO: encode bin to be inlined later */
|
bin_ctxt = ctxt_index + MIN((i >> ctxt_shift), ctxt_inc_max);
|
error |= ihevce_cabac_encode_bin(ps_cabac, 1, bin_ctxt);
|
}
|
|
/* write terminating 0 bin */
|
if(sym < c_max)
|
{
|
/* TODO: encode bin to be inlined later */
|
bin_ctxt = ctxt_index + MIN((i >> ctxt_shift), ctxt_inc_max);
|
error |= ihevce_cabac_encode_bin(ps_cabac, 0, bin_ctxt);
|
}
|
|
return (error);
|
}
|
|
/**
|
******************************************************************************
|
*
|
* @brief Encodes a syntax element as truncated unary bypass bins
|
*
|
* @par Description
|
* Does binarization of tunary symbol as per sec 9.3.2.2 and does the cabac
|
* encoding of each bin. This is used for computing symbols like merge_idx,
|
* mpm_idx etc
|
*
|
* @param[inout]ps_cabac
|
* pointer to cabac context (handle)
|
*
|
* @param[in] sym
|
* syntax element to be coded as truncated unary bins
|
*
|
* @param[in] c_max
|
* maximum value of sym (required for tunary binarization)
|
*
|
* @return success or failure error code
|
*
|
******************************************************************************
|
*/
|
WORD32 ihevce_cabac_encode_tunary_bypass(cab_ctxt_t *ps_cabac, WORD32 sym, WORD32 c_max)
|
{
|
WORD32 error = IHEVCE_SUCCESS;
|
WORD32 length;
|
WORD32 u4_bins;
|
|
/* Sanity checks */
|
ASSERT(c_max > 0);
|
ASSERT((sym <= c_max) && (sym >= 0));
|
|
if(sym < c_max)
|
{
|
/* unary code with (sym) '1's and terminating '0' bin */
|
length = (sym + 1);
|
u4_bins = (1 << length) - 2;
|
}
|
else
|
{
|
/* tunary code with (sym) '1's */
|
length = sym;
|
u4_bins = (1 << length) - 1;
|
}
|
|
/* Encode the tunary binarized code as bypass bins */
|
error = ihevce_cabac_encode_bypass_bins(ps_cabac, u4_bins, length);
|
|
return (error);
|
}
|
|
/**
|
******************************************************************************
|
*
|
* @brief Encodes a syntax element as kth order Exp-Golomb code (EGK)
|
*
|
* @par Description
|
* Does binarization of symbol as per sec 9.3.2.4 kth order Exp-Golomb(EGk)
|
* process and encodes the resulting bypass bins
|
*
|
* @param[inout]ps_cabac
|
* pointer to cabac context (handle)
|
*
|
* @param[in] u4_sym
|
* syntax element to be coded as EGK
|
*
|
* @param[in] k
|
* order of EGk
|
*
|
* @return success or failure error code
|
*
|
******************************************************************************
|
*/
|
WORD32 ihevce_cabac_encode_egk(cab_ctxt_t *ps_cabac, UWORD32 u4_sym, WORD32 k)
|
{
|
WORD32 num_bins, unary_length;
|
UWORD32 u4_sym_shiftk_plus1, u4_egk, u4_unary_bins;
|
|
WORD32 error = IHEVCE_SUCCESS;
|
|
/* Sanity checks */
|
ASSERT((k >= 0));
|
/* ASSERT(u4_sym >= (UWORD32)(1 << k)); */
|
|
/************************************************************************/
|
/* shift symbol by k bits to find unary code prefix (111110) */
|
/* Use GETRANGE to elminate the while loop in sec 9.3.2.4 of HEVC spec */
|
/************************************************************************/
|
u4_sym_shiftk_plus1 = (u4_sym >> k) + 1;
|
/* GETRANGE(unary_length, (u4_sym_shiftk_plus1 + 1)); */
|
GETRANGE(unary_length, u4_sym_shiftk_plus1);
|
|
/* unary code with (unary_length-1) '1's and terminating '0' bin */
|
u4_unary_bins = (1 << unary_length) - 2;
|
|
/* insert the symbol prefix of (unary lenght - 1) bins */
|
u4_egk = (u4_unary_bins << (unary_length - 1)) |
|
(u4_sym_shiftk_plus1 & ((1 << (unary_length - 1)) - 1));
|
|
/* insert last k bits of symbol in the end */
|
u4_egk = (u4_egk << k) | (u4_sym & ((1 << k) - 1));
|
|
/* length of the code = 2 *(unary_length - 1) + 1 + k */
|
num_bins = (2 * unary_length) - 1 + k;
|
|
/* Encode the egk binarized code as bypass bins */
|
error = ihevce_cabac_encode_bypass_bins(ps_cabac, u4_egk, num_bins);
|
|
return (error);
|
}
|
|
/**
|
******************************************************************************
|
*
|
* @brief Encodes a syntax element as truncated rice code (TR)
|
*
|
* @par Description
|
* Does binarization of symbol as per sec 9.3.2.3 Truncated Rice(TR)
|
* binarization process and encodes the resulting bypass bins
|
* This function ise used for coeff_abs_level_remaining coding when
|
* level is less than c_rice_max
|
*
|
* @param[inout]ps_cabac
|
* pointer to cabac context (handle)
|
*
|
* @param[in] u4_sym
|
* syntax element to be coded as truncated rice code
|
*
|
* @param[in] c_rice_param
|
* shift factor for truncated unary prefix coding of (u4_sym >> c_rice_param)
|
*
|
* @param[in] c_rice_max
|
* max symbol val below which a suffix is coded as (u4_sym%(1<<c_rice_param))
|
* This is currently (4 << c_rice_param) for coeff_abs_level_remaining
|
*
|
* @return success or failure error code
|
*
|
******************************************************************************
|
*/
|
WORD32 ihevce_cabac_encode_trunc_rice(
|
cab_ctxt_t *ps_cabac, UWORD32 u4_sym, WORD32 c_rice_param, WORD32 c_rice_max)
|
{
|
WORD32 num_bins, unary_length, u4_unary_bins;
|
UWORD32 u4_tr;
|
|
WORD32 error = IHEVCE_SUCCESS;
|
|
(void)c_rice_max;
|
/* Sanity checks */
|
ASSERT((c_rice_param >= 0));
|
ASSERT((UWORD32)c_rice_max > u4_sym);
|
|
/************************************************************************/
|
/* shift symbol by c_rice_param bits to find unary code prefix (111.10) */
|
/************************************************************************/
|
unary_length = (u4_sym >> c_rice_param) + 1;
|
|
/* unary code with (unary_length-1) '1's and terminating '0' bin */
|
u4_unary_bins = (1 << unary_length) - 2;
|
|
/* insert last c_rice_param bits of symbol in the end */
|
u4_tr = (u4_unary_bins << c_rice_param) | (u4_sym & ((1 << c_rice_param) - 1));
|
|
/* length of the code */
|
num_bins = unary_length + c_rice_param;
|
|
/* Encode the tr binarized code as bypass bins */
|
error = ihevce_cabac_encode_bypass_bins(ps_cabac, u4_tr, num_bins);
|
|
return (error);
|
}
|
|
/**
|
******************************************************************************
|
*
|
* @brief Flushes the cabac encoder engine as per section 9.3.4 figure 9-12
|
*
|
* @par Description
|
*
|
*
|
* @param[inout] ps_cabac
|
* pointer to cabac context (handle)
|
*
|
* @return success or failure error code
|
*
|
******************************************************************************
|
*/
|
WORD32 ihevce_cabac_flush(cab_ctxt_t *ps_cabac, WORD32 i4_end_of_sub_strm)
|
{
|
UWORD32 u4_low = ps_cabac->u4_low;
|
UWORD32 u4_bits_gen = ps_cabac->u4_bits_gen;
|
|
UWORD8 *pu1_strm_buf = ps_cabac->pu1_strm_buffer;
|
UWORD32 u4_strm_buf_offset = ps_cabac->u4_strm_buf_offset;
|
WORD32 zero_run = ps_cabac->i4_zero_bytes_run;
|
UWORD32 u4_out_standing_bytes = ps_cabac->u4_out_standing_bytes;
|
|
(void)i4_end_of_sub_strm;
|
/************************************************************************/
|
/* Insert the carry (propogated in previous byte) along with */
|
/* outstanding bytes (if any) and flush remaining bits */
|
/************************************************************************/
|
|
//TODO: Review this function
|
{
|
/* carry = 1 => putbit(1); carry propogated due to L renorm */
|
WORD32 carry = (u4_low >> (u4_bits_gen + CABAC_BITS)) & 0x1;
|
WORD32 last_byte;
|
WORD32 bits_left;
|
WORD32 rem_bits;
|
|
/*********************************************************************/
|
/* Bitstream overflow check */
|
/* NOTE: corner case of epb bytes (max 2 for 32bit word) not handled */
|
/*********************************************************************/
|
if((u4_strm_buf_offset + u4_out_standing_bytes + 1) >= ps_cabac->u4_max_strm_size)
|
{
|
/* return without corrupting the buffer beyond its size */
|
return (IHEVCE_BITSTREAM_BUFFER_OVERFLOW);
|
}
|
|
if(carry)
|
{
|
/* CORNER CASE: if the previous data is 0x000003, then EPB will be inserted
|
and the data will become 0x00000303 and if the carry is present, it will
|
be added with the last byte and it will become 0x00000304 which is not correct
|
as per standard*/
|
/* so check for previous four bytes and if it is equal to 0x00000303
|
then subtract u4_strm_buf_offset by 1 */
|
if(pu1_strm_buf[u4_strm_buf_offset - 1] == 0x03 &&
|
pu1_strm_buf[u4_strm_buf_offset - 2] == 0x03 &&
|
pu1_strm_buf[u4_strm_buf_offset - 3] == 0x00 &&
|
pu1_strm_buf[u4_strm_buf_offset - 4] == 0x00)
|
{
|
u4_strm_buf_offset -= 1;
|
}
|
/* previous byte carry add will not result in overflow to */
|
/* u4_strm_buf_offset - 2 as we track 0xff as outstanding bytes */
|
pu1_strm_buf[u4_strm_buf_offset - 1] += carry;
|
zero_run = 0;
|
}
|
|
/* Insert outstanding bytes (if any) */
|
while(u4_out_standing_bytes)
|
{
|
UWORD8 u1_0_or_ff = carry ? 0 : 0xFF;
|
|
PUTBYTE_EPB(pu1_strm_buf, u4_strm_buf_offset, u1_0_or_ff, zero_run);
|
|
u4_out_standing_bytes--;
|
}
|
|
/* clear the carry in low */
|
u4_low &= ((1 << (u4_bits_gen + CABAC_BITS)) - 1);
|
|
/* extract the remaining bits; */
|
/* includes additional msb bit of low as per Figure 9-12 */
|
bits_left = u4_bits_gen + 1;
|
rem_bits = (u4_low >> (u4_bits_gen + CABAC_BITS - bits_left));
|
|
if(bits_left >= 8)
|
{
|
last_byte = (rem_bits >> (bits_left - 8)) & 0xFF;
|
PUTBYTE_EPB(pu1_strm_buf, u4_strm_buf_offset, last_byte, zero_run);
|
bits_left -= 8;
|
}
|
|
/* insert last byte along with rbsp stop bit(1) and 0's in the end */
|
last_byte = (rem_bits << (8 - bits_left)) | (1 << (7 - bits_left));
|
last_byte &= 0xFF;
|
PUTBYTE_EPB(pu1_strm_buf, u4_strm_buf_offset, last_byte, zero_run);
|
|
/* update the state variables and return success */
|
ps_cabac->u4_strm_buf_offset = u4_strm_buf_offset;
|
ps_cabac->i4_zero_bytes_run = 0;
|
return (IHEVCE_SUCCESS);
|
}
|
}
|
|
/**
|
******************************************************************************
|
*
|
* @brief API to backup cabac ctxt at end of 2nd CTB row which is used to init
|
* context at start of every row
|
*
|
* @par Description
|
* API to backup cabac ctxt at end of 2nd CTB row which is used to init
|
* context at start of every row
|
*
|
* @param[inout] ps_cabac
|
* pointer to cabac context (handle)
|
*
|
* @return success or failure error code
|
*
|
******************************************************************************
|
*/
|
WORD32 ihevce_cabac_ctxt_backup(cab_ctxt_t *ps_cabac)
|
{
|
memcpy(
|
ps_cabac->au1_ctxt_models_top_right,
|
ps_cabac->au1_ctxt_models,
|
sizeof(ps_cabac->au1_ctxt_models));
|
return (IHEVCE_SUCCESS);
|
}
|
|
/**
|
******************************************************************************
|
*
|
* @brief Init cabac ctxt at every row start
|
*
|
* @par Description
|
* API to init cabac ctxt at start of every row when entropy sync is
|
* enabled
|
*
|
* @param[inout] ps_cabac
|
* pointer to cabac context (handle)
|
*
|
* @return success or failure error code
|
*
|
******************************************************************************
|
*/
|
WORD32 ihevce_cabac_ctxt_row_init(cab_ctxt_t *ps_cabac)
|
{
|
/* cabac engine initialization */
|
ps_cabac->u4_low = 0;
|
ps_cabac->u4_range = 510;
|
ps_cabac->u4_bits_gen = 0;
|
ps_cabac->u4_out_standing_bytes = 0;
|
ps_cabac->i4_zero_bytes_run = 0;
|
|
/*copy top right context as init context when starting to encode a row*/
|
COPY_CABAC_STATES(
|
ps_cabac->au1_ctxt_models, ps_cabac->au1_ctxt_models_top_right, IHEVC_CAB_CTXT_END);
|
|
return (IHEVCE_SUCCESS);
|
}
|
