/* * Copyright (c) 2010 The WebM project authors. All Rights Reserved. * * Use of this source code is governed by a BSD-style license * that can be found in the LICENSE file in the root of the source * tree. An additional intellectual property rights grant can be found * in the file PATENTS. All contributing project authors may * be found in the AUTHORS file in the root of the source tree. */ #include "./vpx_config.h" #include "./vpx_dsp_rtcd.h" #include "vp9/common/vp9_loopfilter.h" #include "vp9/common/vp9_onyxc_int.h" #include "vp9/common/vp9_reconinter.h" #include "vpx_dsp/vpx_dsp_common.h" #include "vpx_mem/vpx_mem.h" #include "vpx_ports/mem.h" #include "vp9/common/vp9_seg_common.h" // 64 bit masks for left transform size. Each 1 represents a position where // we should apply a loop filter across the left border of an 8x8 block // boundary. // // In the case of TX_16X16-> ( in low order byte first we end up with // a mask that looks like this // // 10101010 // 10101010 // 10101010 // 10101010 // 10101010 // 10101010 // 10101010 // 10101010 // // A loopfilter should be applied to every other 8x8 horizontally. static const uint64_t left_64x64_txform_mask[TX_SIZES] = …; // 64 bit masks for above transform size. Each 1 represents a position where // we should apply a loop filter across the top border of an 8x8 block // boundary. // // In the case of TX_32x32 -> ( in low order byte first we end up with // a mask that looks like this // // 11111111 // 00000000 // 00000000 // 00000000 // 11111111 // 00000000 // 00000000 // 00000000 // // A loopfilter should be applied to every other 4 the row vertically. static const uint64_t above_64x64_txform_mask[TX_SIZES] = …; // 64 bit masks for prediction sizes (left). Each 1 represents a position // where left border of an 8x8 block. These are aligned to the right most // appropriate bit, and then shifted into place. // // In the case of TX_16x32 -> ( low order byte first ) we end up with // a mask that looks like this : // // 10000000 // 10000000 // 10000000 // 10000000 // 00000000 // 00000000 // 00000000 // 00000000 static const uint64_t left_prediction_mask[BLOCK_SIZES] = …; // 64 bit mask to shift and set for each prediction size. static const uint64_t above_prediction_mask[BLOCK_SIZES] = …; // 64 bit mask to shift and set for each prediction size. A bit is set for // each 8x8 block that would be in the left most block of the given block // size in the 64x64 block. static const uint64_t size_mask[BLOCK_SIZES] = …; // These are used for masking the left and above borders. static const uint64_t left_border = …; static const uint64_t above_border = …; // 16 bit masks for uv transform sizes. static const uint16_t left_64x64_txform_mask_uv[TX_SIZES] = …; static const uint16_t above_64x64_txform_mask_uv[TX_SIZES] = …; // 16 bit left mask to shift and set for each uv prediction size. static const uint16_t left_prediction_mask_uv[BLOCK_SIZES] = …; // 16 bit above mask to shift and set for uv each prediction size. static const uint16_t above_prediction_mask_uv[BLOCK_SIZES] = …; // 64 bit mask to shift and set for each uv prediction size static const uint16_t size_mask_uv[BLOCK_SIZES] = …; static const uint16_t left_border_uv = …; static const uint16_t above_border_uv = …; static const int mode_lf_lut[MB_MODE_COUNT] = …; static void update_sharpness(loop_filter_info_n *lfi, int sharpness_lvl) { … } static uint8_t get_filter_level(const loop_filter_info_n *lfi_n, const MODE_INFO *mi) { … } void vp9_loop_filter_init(VP9_COMMON *cm) { … } void vp9_loop_filter_frame_init(VP9_COMMON *cm, int default_filt_lvl) { … } static void filter_selectively_vert_row2( int subsampling_factor, uint8_t *s, int pitch, unsigned int mask_16x16, unsigned int mask_8x8, unsigned int mask_4x4, unsigned int mask_4x4_int, const loop_filter_thresh *lfthr, const uint8_t *lfl) { … } #if CONFIG_VP9_HIGHBITDEPTH static void highbd_filter_selectively_vert_row2( int subsampling_factor, uint16_t *s, int pitch, unsigned int mask_16x16, unsigned int mask_8x8, unsigned int mask_4x4, unsigned int mask_4x4_int, const loop_filter_thresh *lfthr, const uint8_t *lfl, int bd) { … } #endif // CONFIG_VP9_HIGHBITDEPTH static void filter_selectively_horiz( uint8_t *s, int pitch, unsigned int mask_16x16, unsigned int mask_8x8, unsigned int mask_4x4, unsigned int mask_4x4_int, const loop_filter_thresh *lfthr, const uint8_t *lfl) { … } #if CONFIG_VP9_HIGHBITDEPTH static void highbd_filter_selectively_horiz( uint16_t *s, int pitch, unsigned int mask_16x16, unsigned int mask_8x8, unsigned int mask_4x4, unsigned int mask_4x4_int, const loop_filter_thresh *lfthr, const uint8_t *lfl, int bd) { … } #endif // CONFIG_VP9_HIGHBITDEPTH // This function ors into the current lfm structure, where to do loop // filters for the specific mi we are looking at. It uses information // including the block_size_type (32x16, 32x32, etc.), the transform size, // whether there were any coefficients encoded, and the loop filter strength // block we are currently looking at. Shift is used to position the // 1's we produce. static void build_masks(const loop_filter_info_n *const lfi_n, const MODE_INFO *mi, const int shift_y, const int shift_uv, LOOP_FILTER_MASK *lfm) { … } // This function does the same thing as the one above with the exception that // it only affects the y masks. It exists because for blocks < 16x16 in size, // we only update u and v masks on the first block. static void build_y_mask(const loop_filter_info_n *const lfi_n, const MODE_INFO *mi, const int shift_y, LOOP_FILTER_MASK *lfm) { … } void vp9_adjust_mask(VP9_COMMON *const cm, const int mi_row, const int mi_col, LOOP_FILTER_MASK *lfm) { … } // This function sets up the bit masks for the entire 64x64 region represented // by mi_row, mi_col. void vp9_setup_mask(VP9_COMMON *const cm, const int mi_row, const int mi_col, MODE_INFO **mi8x8, const int mode_info_stride, LOOP_FILTER_MASK *lfm) { … } static void filter_selectively_vert( uint8_t *s, int pitch, unsigned int mask_16x16, unsigned int mask_8x8, unsigned int mask_4x4, unsigned int mask_4x4_int, const loop_filter_thresh *lfthr, const uint8_t *lfl) { … } #if CONFIG_VP9_HIGHBITDEPTH static void highbd_filter_selectively_vert( uint16_t *s, int pitch, unsigned int mask_16x16, unsigned int mask_8x8, unsigned int mask_4x4, unsigned int mask_4x4_int, const loop_filter_thresh *lfthr, const uint8_t *lfl, int bd) { … } #endif // CONFIG_VP9_HIGHBITDEPTH void vp9_filter_block_plane_non420(VP9_COMMON *cm, struct macroblockd_plane *plane, MODE_INFO **mi_8x8, int mi_row, int mi_col) { … } void vp9_filter_block_plane_ss00(VP9_COMMON *const cm, struct macroblockd_plane *const plane, int mi_row, LOOP_FILTER_MASK *lfm) { … } void vp9_filter_block_plane_ss11(VP9_COMMON *const cm, struct macroblockd_plane *const plane, int mi_row, LOOP_FILTER_MASK *lfm) { … } static void loop_filter_rows(YV12_BUFFER_CONFIG *frame_buffer, VP9_COMMON *cm, struct macroblockd_plane planes[MAX_MB_PLANE], int start, int stop, int y_only) { … } void vp9_loop_filter_frame(YV12_BUFFER_CONFIG *frame, VP9_COMMON *cm, MACROBLOCKD *xd, int frame_filter_level, int y_only, int partial_frame) { … } // Used by the encoder to build the loopfilter masks. // TODO(slavarnway): Do the encoder the same way the decoder does it and // build the masks in line as part of the encode process. void vp9_build_mask_frame(VP9_COMMON *cm, int frame_filter_level, int partial_frame) { … } // 8x8 blocks in a superblock. A "1" represents the first block in a 16x16 // or greater area. static const uint8_t first_block_in_16x16[8][8] = …; // This function sets up the bit masks for a block represented // by mi_row, mi_col in a 64x64 region. // TODO(SJL): This function only works for yv12. void vp9_build_mask(VP9_COMMON *cm, const MODE_INFO *mi, int mi_row, int mi_col, int bw, int bh) { … } void vp9_loop_filter_data_reset( LFWorkerData *lf_data, YV12_BUFFER_CONFIG *frame_buffer, struct VP9Common *cm, const struct macroblockd_plane planes[MAX_MB_PLANE]) { … } void vp9_reset_lfm(VP9_COMMON *const cm) { … } int vp9_loop_filter_worker(void *arg1, void *unused) { … }
Codebase Browser
chromium