mirror of
https://github.com/ultravideo/uvg266.git
synced 2024-11-30 20:54:07 +00:00
7836ff6ec9
Removes functions kvz_coefficients_calc_abs, kvz_intra_rdo_cost_compare and kvz_rdo_cost_intra which are no longer used.
438 lines
16 KiB
C
438 lines
16 KiB
C
#ifndef CU_H_
|
|
#define CU_H_
|
|
/*****************************************************************************
|
|
* This file is part of Kvazaar HEVC encoder.
|
|
*
|
|
* Copyright (C) 2013-2015 Tampere University of Technology and others (see
|
|
* COPYING file).
|
|
*
|
|
* Kvazaar is free software: you can redistribute it and/or modify it under
|
|
* the terms of the GNU Lesser General Public License as published by the
|
|
* Free Software Foundation; either version 2.1 of the License, or (at your
|
|
* option) any later version.
|
|
*
|
|
* Kvazaar is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
* FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for
|
|
* more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with Kvazaar. If not, see <http://www.gnu.org/licenses/>.
|
|
****************************************************************************/
|
|
|
|
/**
|
|
* \ingroup DataStructures
|
|
* \file
|
|
* Coding Unit data structure and related functions.
|
|
*/
|
|
|
|
#include "global.h" // IWYU pragma: keep
|
|
#include "image.h"
|
|
#include "kvazaar.h"
|
|
|
|
|
|
//Cu stuff
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// CONSTANTS
|
|
|
|
typedef enum {
|
|
CU_NOTSET = 0,
|
|
CU_INTRA = 1,
|
|
CU_INTER = 2,
|
|
CU_PCM = 3,
|
|
} cu_type_t;
|
|
|
|
typedef enum {
|
|
SIZE_2Nx2N = 0,
|
|
SIZE_2NxN = 1,
|
|
SIZE_Nx2N = 2,
|
|
SIZE_NxN = 3,
|
|
SIZE_2NxnU = 4,
|
|
SIZE_2NxnD = 5,
|
|
SIZE_nLx2N = 6,
|
|
SIZE_nRx2N = 7,
|
|
} part_mode_t;
|
|
|
|
extern const uint8_t kvz_part_mode_num_parts[];
|
|
extern const uint8_t kvz_part_mode_offsets[][4][2];
|
|
extern const uint8_t kvz_part_mode_sizes[][4][2];
|
|
|
|
/**
|
|
* \brief Get the x coordinate of a PU.
|
|
*
|
|
* \param part_mode partition mode of the containing CU
|
|
* \param cu_width width of the containing CU
|
|
* \param cu_x x coordinate of the containing CU
|
|
* \param i number of the PU
|
|
* \return location of the left edge of the PU
|
|
*/
|
|
#define PU_GET_X(part_mode, cu_width, cu_x, i) \
|
|
((cu_x) + kvz_part_mode_offsets[(part_mode)][(i)][0] * (cu_width) / 4)
|
|
|
|
/**
|
|
* \brief Get the y coordinate of a PU.
|
|
*
|
|
* \param part_mode partition mode of the containing CU
|
|
* \param cu_width width of the containing CU
|
|
* \param cu_y y coordinate of the containing CU
|
|
* \param i number of the PU
|
|
* \return location of the top edge of the PU
|
|
*/
|
|
#define PU_GET_Y(part_mode, cu_width, cu_y, i) \
|
|
((cu_y) + kvz_part_mode_offsets[(part_mode)][(i)][1] * (cu_width) / 4)
|
|
|
|
/**
|
|
* \brief Get the width of a PU.
|
|
*
|
|
* \param part_mode partition mode of the containing CU
|
|
* \param cu_width width of the containing CU
|
|
* \param i number of the PU
|
|
* \return width of the PU
|
|
*/
|
|
#define PU_GET_W(part_mode, cu_width, i) \
|
|
(kvz_part_mode_sizes[(part_mode)][(i)][0] * (cu_width) / 4)
|
|
|
|
/**
|
|
* \brief Get the height of a PU.
|
|
*
|
|
* \param part_mode partition mode of the containing CU
|
|
* \param cu_width width of the containing CU
|
|
* \param i number of the PU
|
|
* \return height of the PU
|
|
*/
|
|
#define PU_GET_H(part_mode, cu_width, i) \
|
|
(kvz_part_mode_sizes[(part_mode)][(i)][1] * (cu_width) / 4)
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// TYPES
|
|
|
|
typedef struct {
|
|
int x;
|
|
int y;
|
|
} vector2d_t;
|
|
|
|
/**
|
|
* \brief Struct for CU info
|
|
*/
|
|
typedef struct
|
|
{
|
|
uint8_t type : 2; //!< \brief block type, one of cu_type_t values
|
|
uint8_t depth : 3; //!< \brief depth / size of this block
|
|
uint8_t part_size : 3; //!< \brief partition mode, one of part_mode_t values
|
|
uint8_t tr_depth : 3; //!< \brief transform depth
|
|
uint8_t skipped : 1; //!< \brief flag to indicate this block is skipped
|
|
uint8_t merged : 1; //!< \brief flag to indicate this block is merged
|
|
uint8_t merge_idx : 3; //!< \brief merge index
|
|
|
|
uint16_t cbf;
|
|
|
|
union {
|
|
struct {
|
|
int8_t mode;
|
|
int8_t mode_chroma;
|
|
int8_t tr_skip; //!< \brief transform skip flag
|
|
} intra;
|
|
struct {
|
|
int16_t mv[2][2]; // \brief Motion vectors for L0 and L1
|
|
uint8_t mv_ref[2]; // \brief Index of the encoder_control.ref array.
|
|
uint8_t mv_cand0 : 3; // \brief selected MV candidate
|
|
uint8_t mv_cand1 : 3; // \brief selected MV candidate
|
|
uint8_t mv_dir : 2; // \brief Probably describes if mv_ref is L0, L1 or both (bi-pred)
|
|
} inter;
|
|
};
|
|
} cu_info_t;
|
|
|
|
#define CU_GET_MV_CAND(cu_info_ptr, reflist) \
|
|
(((reflist) == 0) ? (cu_info_ptr)->inter.mv_cand0 : (cu_info_ptr)->inter.mv_cand1)
|
|
|
|
#define CU_SET_MV_CAND(cu_info_ptr, reflist, value) \
|
|
do { \
|
|
if ((reflist) == 0) { \
|
|
(cu_info_ptr)->inter.mv_cand0 = (value); \
|
|
} else { \
|
|
(cu_info_ptr)->inter.mv_cand1 = (value); \
|
|
} \
|
|
} while (0)
|
|
|
|
#define CHECKPOINT_CU(prefix_str, cu) CHECKPOINT(prefix_str " type=%d depth=%d part_size=%d tr_depth=%d coded=%d " \
|
|
"skipped=%d merged=%d merge_idx=%d cbf.y=%d cbf.u=%d cbf.v=%d " \
|
|
"intra[0].cost=%u intra[0].bitcost=%u intra[0].mode=%d intra[0].mode_chroma=%d intra[0].tr_skip=%d " \
|
|
"intra[1].cost=%u intra[1].bitcost=%u intra[1].mode=%d intra[1].mode_chroma=%d intra[1].tr_skip=%d " \
|
|
"intra[2].cost=%u intra[2].bitcost=%u intra[2].mode=%d intra[2].mode_chroma=%d intra[2].tr_skip=%d " \
|
|
"intra[3].cost=%u intra[3].bitcost=%u intra[3].mode=%d intra[3].mode_chroma=%d intra[3].tr_skip=%d " \
|
|
"inter.cost=%u inter.bitcost=%u inter.mv[0]=%d inter.mv[1]=%d inter.mvd[0]=%d inter.mvd[1]=%d " \
|
|
"inter.mv_cand=%d inter.mv_ref=%d inter.mv_dir=%d inter.mode=%d" \
|
|
, (cu).type, (cu).depth, (cu).part_size, (cu).tr_depth, (cu).coded, \
|
|
(cu).skipped, (cu).merged, (cu).merge_idx, (cu).cbf.y, (cu).cbf.u, (cu).cbf.v, \
|
|
(cu).intra[0].cost, (cu).intra[0].bitcost, (cu).intra[0].mode, (cu).intra[0].mode_chroma, (cu).intra[0].tr_skip, \
|
|
(cu).intra[1].cost, (cu).intra[1].bitcost, (cu).intra[1].mode, (cu).intra[1].mode_chroma, (cu).intra[1].tr_skip, \
|
|
(cu).intra[2].cost, (cu).intra[2].bitcost, (cu).intra[2].mode, (cu).intra[2].mode_chroma, (cu).intra[2].tr_skip, \
|
|
(cu).intra[3].cost, (cu).intra[3].bitcost, (cu).intra[3].mode, (cu).intra[3].mode_chroma, (cu).intra[3].tr_skip, \
|
|
(cu).inter.cost, (cu).inter.bitcost, (cu).inter.mv[0], (cu).inter.mv[1], (cu).inter.mvd[0], (cu).inter.mvd[1], \
|
|
(cu).inter.mv_cand, (cu).inter.mv_ref, (cu).inter.mv_dir, (cu).inter.mode)
|
|
|
|
typedef struct {
|
|
cu_info_t *data; //!< \brief cu array
|
|
int32_t width; //!< \brief width of the array in pixels
|
|
int32_t height; //!< \brief height of the array in pixels
|
|
int32_t refcount; //!< \brief number of references to this cu_array
|
|
} cu_array_t;
|
|
|
|
cu_array_t * kvz_cu_array_alloc(int width, int height);
|
|
int kvz_cu_array_free(cu_array_t *cua);
|
|
cu_info_t* kvz_cu_array_at(cu_array_t *cua, unsigned x_px, unsigned y_px);
|
|
const cu_info_t* kvz_cu_array_at_const(const cu_array_t *cua, unsigned x_px, unsigned y_px);
|
|
void kvz_cu_array_copy(cu_array_t* dst, int dst_x, int dst_y,
|
|
const cu_array_t* src, int src_x, int src_y,
|
|
int width, int height);
|
|
|
|
|
|
/**
|
|
* \brief Return the 7 lowest-order bits of the pixel coordinate.
|
|
*
|
|
* The 7 lower-order bits correspond to the distance from the left or top edge
|
|
* of the containing LCU.
|
|
*/
|
|
#define SUB_SCU(xy) ((xy) & (LCU_WIDTH - 1))
|
|
|
|
#define LCU_CU_WIDTH 16
|
|
#define LCU_T_CU_WIDTH (LCU_CU_WIDTH + 1)
|
|
#define LCU_CU_OFFSET (LCU_T_CU_WIDTH + 1)
|
|
#define SCU_WIDTH (LCU_WIDTH / LCU_CU_WIDTH)
|
|
|
|
// Width from top left of the LCU, so +1 for ref buffer size.
|
|
#define LCU_REF_PX_WIDTH (LCU_WIDTH + LCU_WIDTH / 2)
|
|
|
|
/**
|
|
* Top and left intra reference pixels for LCU.
|
|
* - Intra needs maximum of 32 to the right and down from LCU border.
|
|
* - First pixel is the top-left pixel.
|
|
*/
|
|
typedef struct {
|
|
kvz_pixel y[LCU_REF_PX_WIDTH + 1];
|
|
kvz_pixel u[LCU_REF_PX_WIDTH / 2 + 1];
|
|
kvz_pixel v[LCU_REF_PX_WIDTH / 2 + 1];
|
|
} lcu_ref_px_t;
|
|
|
|
typedef struct {
|
|
coeff_t y[LCU_LUMA_SIZE];
|
|
coeff_t u[LCU_CHROMA_SIZE];
|
|
coeff_t v[LCU_CHROMA_SIZE];
|
|
} lcu_coeff_t;
|
|
|
|
|
|
typedef struct {
|
|
lcu_ref_px_t top_ref; //!< Reference pixels from adjacent LCUs.
|
|
lcu_ref_px_t left_ref; //!< Reference pixels from adjacent LCUs.
|
|
lcu_yuv_t ref; //!< LCU reference pixels
|
|
lcu_yuv_t rec; //!< LCU reconstructed pixels
|
|
/**
|
|
* We get the coefficients as a byproduct of doing reconstruction during the
|
|
* search. It might be more efficient to recalculate the final coefficients
|
|
* once we know the final modes rather than copying them.
|
|
*/
|
|
lcu_coeff_t coeff; //!< LCU coefficients
|
|
|
|
/**
|
|
* A 17x17 CU array, plus the top right reference CU.
|
|
* - Top reference CUs at indices [0,16] (row 0).
|
|
* - Left reference CUs at indices 17*n where n is in [0,16] (column 0).
|
|
* - All CUs of this LCU at indices 17*y + x where x,y are in [1,16].
|
|
* - Top right reference CU at the last index.
|
|
*
|
|
* The figure below shows how the indices map to CU locations.
|
|
*
|
|
\verbatim
|
|
|
|
.-- left reference CUs
|
|
v
|
|
0 | 1 2 . . . 16 | 289 <-- top reference CUs
|
|
-----+--------------------+----
|
|
17 | 18 19 . . . 33 |
|
|
34 | 35 36 . . . 50 <-- this LCU
|
|
. | . . . . |
|
|
. | . . . . |
|
|
. | . . . . |
|
|
272 | 273 274 . . . 288 |
|
|
-----+--------------------+----
|
|
|
|
\endverbatim
|
|
*/
|
|
cu_info_t cu[LCU_T_CU_WIDTH * LCU_T_CU_WIDTH + 1];
|
|
} lcu_t;
|
|
|
|
void kvz_cu_array_copy_from_lcu(cu_array_t* dst, int dst_x, int dst_y, const lcu_t *src);
|
|
|
|
/**
|
|
* \brief Return pointer to the top right reference CU.
|
|
*/
|
|
#define LCU_GET_TOP_RIGHT_CU(lcu) \
|
|
(&(lcu)->cu[LCU_T_CU_WIDTH * LCU_T_CU_WIDTH])
|
|
|
|
/**
|
|
* \brief Return pointer to the CU containing a given pixel.
|
|
*
|
|
* \param lcu pointer to the containing LCU
|
|
* \param x_px x-coordinate relative to the upper left corner of the LCU
|
|
* \param y_px y-coordinate relative to the upper left corner of the LCU
|
|
* \return pointer to the CU at coordinates (x_px, y_px)
|
|
*/
|
|
#define LCU_GET_CU_AT_PX(lcu, x_px, y_px) \
|
|
(&(lcu)->cu[LCU_CU_OFFSET + ((x_px) >> 2) + ((y_px) >> 2) * LCU_T_CU_WIDTH])
|
|
|
|
#define CHECKPOINT_LCU(prefix_str, lcu) do { \
|
|
CHECKPOINT_CU(prefix_str " cu[0]", (lcu).cu[0]); \
|
|
CHECKPOINT_CU(prefix_str " cu[1]", (lcu).cu[1]); \
|
|
CHECKPOINT_CU(prefix_str " cu[2]", (lcu).cu[2]); \
|
|
CHECKPOINT_CU(prefix_str " cu[3]", (lcu).cu[3]); \
|
|
CHECKPOINT_CU(prefix_str " cu[4]", (lcu).cu[4]); \
|
|
CHECKPOINT_CU(prefix_str " cu[5]", (lcu).cu[5]); \
|
|
CHECKPOINT_CU(prefix_str " cu[6]", (lcu).cu[6]); \
|
|
CHECKPOINT_CU(prefix_str " cu[7]", (lcu).cu[7]); \
|
|
CHECKPOINT_CU(prefix_str " cu[8]", (lcu).cu[8]); \
|
|
CHECKPOINT_CU(prefix_str " cu[9]", (lcu).cu[9]); \
|
|
CHECKPOINT_CU(prefix_str " cu[10]", (lcu).cu[10]); \
|
|
CHECKPOINT_CU(prefix_str " cu[11]", (lcu).cu[11]); \
|
|
CHECKPOINT_CU(prefix_str " cu[12]", (lcu).cu[12]); \
|
|
CHECKPOINT_CU(prefix_str " cu[13]", (lcu).cu[13]); \
|
|
CHECKPOINT_CU(prefix_str " cu[14]", (lcu).cu[14]); \
|
|
CHECKPOINT_CU(prefix_str " cu[15]", (lcu).cu[15]); \
|
|
CHECKPOINT_CU(prefix_str " cu[16]", (lcu).cu[16]); \
|
|
CHECKPOINT_CU(prefix_str " cu[17]", (lcu).cu[17]); \
|
|
CHECKPOINT_CU(prefix_str " cu[18]", (lcu).cu[18]); \
|
|
CHECKPOINT_CU(prefix_str " cu[19]", (lcu).cu[19]); \
|
|
CHECKPOINT_CU(prefix_str " cu[20]", (lcu).cu[20]); \
|
|
CHECKPOINT_CU(prefix_str " cu[21]", (lcu).cu[21]); \
|
|
CHECKPOINT_CU(prefix_str " cu[22]", (lcu).cu[22]); \
|
|
CHECKPOINT_CU(prefix_str " cu[23]", (lcu).cu[23]); \
|
|
CHECKPOINT_CU(prefix_str " cu[24]", (lcu).cu[24]); \
|
|
CHECKPOINT_CU(prefix_str " cu[25]", (lcu).cu[25]); \
|
|
CHECKPOINT_CU(prefix_str " cu[26]", (lcu).cu[26]); \
|
|
CHECKPOINT_CU(prefix_str " cu[27]", (lcu).cu[27]); \
|
|
CHECKPOINT_CU(prefix_str " cu[28]", (lcu).cu[28]); \
|
|
CHECKPOINT_CU(prefix_str " cu[29]", (lcu).cu[29]); \
|
|
CHECKPOINT_CU(prefix_str " cu[30]", (lcu).cu[30]); \
|
|
CHECKPOINT_CU(prefix_str " cu[31]", (lcu).cu[31]); \
|
|
CHECKPOINT_CU(prefix_str " cu[32]", (lcu).cu[32]); \
|
|
CHECKPOINT_CU(prefix_str " cu[33]", (lcu).cu[33]); \
|
|
CHECKPOINT_CU(prefix_str " cu[34]", (lcu).cu[34]); \
|
|
CHECKPOINT_CU(prefix_str " cu[35]", (lcu).cu[35]); \
|
|
CHECKPOINT_CU(prefix_str " cu[36]", (lcu).cu[36]); \
|
|
CHECKPOINT_CU(prefix_str " cu[37]", (lcu).cu[37]); \
|
|
CHECKPOINT_CU(prefix_str " cu[38]", (lcu).cu[38]); \
|
|
CHECKPOINT_CU(prefix_str " cu[39]", (lcu).cu[39]); \
|
|
CHECKPOINT_CU(prefix_str " cu[40]", (lcu).cu[40]); \
|
|
CHECKPOINT_CU(prefix_str " cu[41]", (lcu).cu[41]); \
|
|
CHECKPOINT_CU(prefix_str " cu[42]", (lcu).cu[42]); \
|
|
CHECKPOINT_CU(prefix_str " cu[43]", (lcu).cu[43]); \
|
|
CHECKPOINT_CU(prefix_str " cu[44]", (lcu).cu[44]); \
|
|
CHECKPOINT_CU(prefix_str " cu[45]", (lcu).cu[45]); \
|
|
CHECKPOINT_CU(prefix_str " cu[46]", (lcu).cu[46]); \
|
|
CHECKPOINT_CU(prefix_str " cu[47]", (lcu).cu[47]); \
|
|
CHECKPOINT_CU(prefix_str " cu[48]", (lcu).cu[48]); \
|
|
CHECKPOINT_CU(prefix_str " cu[49]", (lcu).cu[49]); \
|
|
CHECKPOINT_CU(prefix_str " cu[50]", (lcu).cu[50]); \
|
|
CHECKPOINT_CU(prefix_str " cu[51]", (lcu).cu[51]); \
|
|
CHECKPOINT_CU(prefix_str " cu[52]", (lcu).cu[52]); \
|
|
CHECKPOINT_CU(prefix_str " cu[53]", (lcu).cu[53]); \
|
|
CHECKPOINT_CU(prefix_str " cu[54]", (lcu).cu[54]); \
|
|
CHECKPOINT_CU(prefix_str " cu[55]", (lcu).cu[55]); \
|
|
CHECKPOINT_CU(prefix_str " cu[56]", (lcu).cu[56]); \
|
|
CHECKPOINT_CU(prefix_str " cu[57]", (lcu).cu[57]); \
|
|
CHECKPOINT_CU(prefix_str " cu[58]", (lcu).cu[58]); \
|
|
CHECKPOINT_CU(prefix_str " cu[59]", (lcu).cu[59]); \
|
|
CHECKPOINT_CU(prefix_str " cu[60]", (lcu).cu[60]); \
|
|
CHECKPOINT_CU(prefix_str " cu[61]", (lcu).cu[61]); \
|
|
CHECKPOINT_CU(prefix_str " cu[62]", (lcu).cu[62]); \
|
|
CHECKPOINT_CU(prefix_str " cu[63]", (lcu).cu[63]); \
|
|
CHECKPOINT_CU(prefix_str " cu[64]", (lcu).cu[64]); \
|
|
CHECKPOINT_CU(prefix_str " cu[65]", (lcu).cu[65]); \
|
|
CHECKPOINT_CU(prefix_str " cu[66]", (lcu).cu[66]); \
|
|
CHECKPOINT_CU(prefix_str " cu[67]", (lcu).cu[67]); \
|
|
CHECKPOINT_CU(prefix_str " cu[68]", (lcu).cu[68]); \
|
|
CHECKPOINT_CU(prefix_str " cu[69]", (lcu).cu[69]); \
|
|
CHECKPOINT_CU(prefix_str " cu[70]", (lcu).cu[70]); \
|
|
CHECKPOINT_CU(prefix_str " cu[71]", (lcu).cu[71]); \
|
|
CHECKPOINT_CU(prefix_str " cu[72]", (lcu).cu[72]); \
|
|
CHECKPOINT_CU(prefix_str " cu[73]", (lcu).cu[73]); \
|
|
CHECKPOINT_CU(prefix_str " cu[74]", (lcu).cu[74]); \
|
|
CHECKPOINT_CU(prefix_str " cu[75]", (lcu).cu[75]); \
|
|
CHECKPOINT_CU(prefix_str " cu[76]", (lcu).cu[76]); \
|
|
CHECKPOINT_CU(prefix_str " cu[77]", (lcu).cu[77]); \
|
|
CHECKPOINT_CU(prefix_str " cu[78]", (lcu).cu[78]); \
|
|
CHECKPOINT_CU(prefix_str " cu[79]", (lcu).cu[79]); \
|
|
CHECKPOINT_CU(prefix_str " cu[80]", (lcu).cu[80]); \
|
|
CHECKPOINT_CU(prefix_str " cu[81]", (lcu).cu[81]); \
|
|
} while(0)
|
|
|
|
|
|
void kvz_coefficients_blit(const coeff_t *orig, coeff_t *dst,
|
|
unsigned width, unsigned height,
|
|
unsigned orig_stride, unsigned dst_stride);
|
|
|
|
#define NUM_CBF_DEPTHS 5
|
|
static const uint16_t cbf_masks[NUM_CBF_DEPTHS] = { 0x1f, 0x0f, 0x07, 0x03, 0x1 };
|
|
|
|
/**
|
|
* Check if CBF in a given level >= depth is true.
|
|
*/
|
|
static INLINE int cbf_is_set(uint16_t cbf, int depth, color_t plane)
|
|
{
|
|
return (cbf & (cbf_masks[depth] << (NUM_CBF_DEPTHS * plane))) != 0;
|
|
}
|
|
|
|
/**
|
|
* Check if CBF in a given level >= depth is true.
|
|
*/
|
|
static INLINE int cbf_is_set_any(uint16_t cbf, int depth)
|
|
{
|
|
return cbf_is_set(cbf, depth, COLOR_Y) ||
|
|
cbf_is_set(cbf, depth, COLOR_U) ||
|
|
cbf_is_set(cbf, depth, COLOR_V);
|
|
}
|
|
|
|
/**
|
|
* Set CBF in a level to true.
|
|
*/
|
|
static INLINE void cbf_set(uint16_t *cbf, int depth, color_t plane)
|
|
{
|
|
// Return value of the bit corresponding to the level.
|
|
*cbf |= (0x10 >> depth) << (NUM_CBF_DEPTHS * plane);
|
|
}
|
|
|
|
/**
|
|
* Set CBF in a level to true if it is set at a lower level in any of
|
|
* the child_cbfs.
|
|
*/
|
|
static INLINE void cbf_set_conditionally(uint16_t *cbf, uint16_t child_cbfs[3], int depth, color_t plane)
|
|
{
|
|
bool child_cbf_set = cbf_is_set(child_cbfs[0], depth + 1, plane) ||
|
|
cbf_is_set(child_cbfs[1], depth + 1, plane) ||
|
|
cbf_is_set(child_cbfs[2], depth + 1, plane);
|
|
if (child_cbf_set) {
|
|
cbf_set(cbf, depth, plane);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set CBF in a levels <= depth to false.
|
|
*/
|
|
static INLINE void cbf_clear(uint16_t *cbf, int depth, color_t plane)
|
|
{
|
|
*cbf &= ~(cbf_masks[depth] << (NUM_CBF_DEPTHS * plane));
|
|
}
|
|
|
|
/**
|
|
* Copy cbf flags.
|
|
*/
|
|
static INLINE void cbf_copy(uint16_t *cbf, uint16_t src, color_t plane)
|
|
{
|
|
cbf_clear(cbf, 0, plane);
|
|
*cbf |= src & (cbf_masks[0] << (NUM_CBF_DEPTHS * plane));
|
|
}
|
|
|
|
#define GET_SPLITDATA(CU,curDepth) ((CU)->depth > curDepth)
|
|
#define SET_SPLITDATA(CU,flag) { (CU)->split=(flag); }
|
|
|
|
#endif
|