| /* |
| * Copyright 2020 Google LLC |
| * |
| */ |
| |
| /* |
| * Copyright (c) 2020, 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. |
| */ |
| |
| cbuffer IntraDataCommon : register(b0) { |
| int4 cb_planes[3]; |
| int4 cb_flags; |
| int4 cb_filter[5][8][2]; |
| int4 cb_mode_params_lut[16][7]; |
| int4 cb_sm_weight_arrays[128]; |
| }; |
| |
| cbuffer PSSLIntraSRT : register(b1) { |
| int4 cb_counts0; |
| int4 cb_counts1; |
| uint cb_wi_count; |
| int cb_pass_offset; |
| }; |
| |
| ByteAddressBuffer pred_blocks : register(t0); |
| ByteAddressBuffer residuals : register(t1); |
| ByteAddressBuffer wedge_mask : register(t2); |
| RWByteAddressBuffer dst_frame : register(u0); |
| |
| #define Dir1 1 |
| #define Dir2 2 |
| #define Dir3 3 |
| #define SmoothV 4 |
| #define SmoothH 8 |
| |
| #define MODE_PAETH 11 |
| #define MODE_INTRA_BC 12 |
| #define MODE_FILTER 13 |
| #define MODE_DC 14 |
| #define MODE_CFL 15 |
| |
| #define NeedAboveShift 4 |
| #define NeedRightShift 5 |
| #define NeedLeftShift 6 |
| #define NeedBotShift 7 |
| #define NeedAboveLeftShift 8 |
| #define FilterAboveLeftFlag 0x200 |
| #define NeedAboveLeftLUT 0x08ff |
| // intra bc: |
| #define SubpelBits 4 |
| #define FilterLineShift 3 |
| #define OutputShift 11 |
| #define OffsetBits 19 |
| #define SumAddHor (1 << 14) |
| #define SumAddVert ((1 << OffsetBits) + (1 << (OutputShift - 1))) |
| #define OutputSub ((1 << (OffsetBits - OutputShift)) + (1 << (OffsetBits - OutputShift - 1))) |
| |
| groupshared int above[64 * 20]; |
| groupshared int left[64 * 20]; |
| |
| int compute_bc(int p0, int p1, int p2, int p3, int fh, int fv) { |
| int l0 = ((1 << 14) + p0 * fh + p1 * (128 - fh) + (1 << (FilterLineShift - 1))) >> FilterLineShift; |
| int l1 = ((1 << 14) + p2 * fh + p3 * (128 - fh) + (1 << (FilterLineShift - 1))) >> FilterLineShift; |
| int output = SumAddVert + l0 * fv + l1 * (128 - fv); |
| return clamp((output >> OutputShift) - OutputSub, 0, 1023); |
| } |
| |
| uint compute_cfl_pixel(int dc, int value) { |
| value = (value < 0) ? -((-value + (1 << 5)) >> 6) : ((value + (1 << 5)) >> 6); |
| return clamp(dc + value, 0, 1023); |
| } |
| |
| int intra_inter_blend(int mask, int intra, int inter) { |
| return clamp((intra * mask + inter * (64 - mask) + 32) >> 6, 0, 1023); |
| } |
| #define WG_SIZE 256 |
| [numthreads(WG_SIZE, 1, 1)] void main(uint3 thread |
| : SV_DispatchThreadID) { |
| int4 counts0 = cb_counts0; |
| int4 counts1 = cb_counts1; |
| int bsize_log = 10; |
| int offset = cb_pass_offset; |
| int threadx = thread.x; |
| uint3 block = uint3(0, 0, 0); |
| int wi_count = 0; |
| int wi = 1024; |
| if (thread.x < cb_wi_count) { |
| if (threadx >= (counts0.x << 10)) { |
| offset += cb_counts0.x; |
| threadx -= counts0.x << 10; |
| bsize_log = 9; |
| if (threadx >= (counts0.y << 9)) { |
| offset += cb_counts0.y; |
| threadx -= counts0.y << 9; |
| bsize_log = 8; |
| if (threadx >= (counts0.z << 8)) { |
| offset += cb_counts0.z; |
| threadx -= counts0.z << 8; |
| bsize_log = 7; |
| if (threadx >= (counts0.w << 7)) { |
| offset += cb_counts0.w; |
| threadx -= counts0.w << 7; |
| bsize_log = 6; |
| if (threadx >= (counts1.x << 6)) { |
| offset += cb_counts1.x; |
| threadx -= counts1.x << 6; |
| bsize_log = 5; |
| if (threadx >= (counts1.y << 5)) { |
| offset += cb_counts1.y; |
| threadx -= counts1.y << 5; |
| bsize_log = 4; |
| if (threadx >= (counts1.z << 4)) { |
| offset += cb_counts1.z; |
| threadx -= counts1.z << 4; |
| bsize_log = 3; |
| if (threadx >= (counts1.w << 3)) { |
| offset += cb_counts1.w; |
| threadx -= counts1.w << 3; |
| bsize_log = 2; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| int block_index = offset + (threadx >> bsize_log); |
| block = pred_blocks.Load3(block_index << 4); |
| wi_count = min(WG_SIZE, 1 << bsize_log); |
| wi = thread.x & (wi_count - 1); |
| } |
| const int bw_log = block.y & 7; // 0..4 |
| const int bw = 4 << bw_log; |
| const int bh = 1 << (bsize_log - bw_log); |
| |
| int bx = (block.x & 0xffff) << 2; |
| int by = (block.x >> 16) << 2; |
| |
| const int plane = (block.y >> 3) & 3; |
| const int above_available = ((block.y >> 10) & 63) << 1; |
| const int left_available = ((block.y >> 16) & 63) << 2; |
| |
| const int mode = (block.y >> 6) & 15; |
| |
| const int mode_angle = (block.y >> 28) & 7; |
| int4 params = cb_mode_params_lut[mode][mode_angle]; |
| |
| // block.y bits: |
| // 0 3 bw_log |
| // 3 2 plane |
| // 5 1 non skip |
| // 6 4 mode |
| // all mods except intra_bc: |
| // 10 6 above_available |
| // 16 6 left_available |
| // dir mode params: |
| // 22 2 upsample |
| // 24 2 edge_filter above |
| // 26 2 edge_filter left |
| // 28 3 mode_angle |
| // 31 1 inter_intra? |
| // CFL: |
| // 22 4 alpha |
| // |
| // block.z |
| // intra_bc - mv |
| // inter-intra - coef. table indexes; |
| // filter - bh_log | filter_mode; |
| // block.w - reserved; (prob. used for sorting); |
| |
| const int stride = cb_planes[plane].x; |
| const int corner = cb_planes[plane].y + ((bx << 1) - 4) + (by - 1) * stride; |
| |
| const int loc_base = (((thread.x & (WG_SIZE - 1)) - wi) >> 2) * 20 + 2; |
| int above_count = ((params.z >> NeedAboveShift) & 1) * bw + ((params.z >> NeedRightShift) & 1) * bh; |
| |
| if (wi < (above_count >> 1) || wi == 0) { |
| int addr = corner + 4 + 4 * min(wi, above_available - 1); |
| uint pixels = |
| above_available ? dst_frame.Load(addr) : left_available ? dst_frame.Load(corner + stride) : 0x01ff0000; |
| if (wi >= above_available) pixels = (pixels & 0xffff0000) | (pixels >> 16); |
| above[loc_base + (wi << 1) + 0] = (pixels >> 0) & 1023; |
| above[loc_base + (wi << 1) + 1] = (pixels >> 16) & 1023; |
| } |
| |
| // Left: |
| GroupMemoryBarrierWithGroupSync(); |
| |
| int left_count = ((params.z >> NeedLeftShift) & 1) * bh + ((params.z >> NeedBotShift) & 1) * bw; |
| |
| if (wi < left_count || wi == 0) { |
| const int addr = corner + (min(wi, left_available - 1) + 1) * stride; |
| left[loc_base + wi] = left_available ? (dst_frame.Load(addr) >> 16) : above_available ? above[loc_base] : 513; |
| } |
| if (wi < (left_count - wi_count)) { |
| const int addr = corner + (min(wi + wi_count, left_available - 1) + 1) * stride; |
| left[loc_base + wi + wi_count] = |
| left_available ? (dst_frame.Load(addr) >> 16) : above_available ? above[loc_base] : 513; |
| } |
| |
| GroupMemoryBarrierWithGroupSync(); |
| |
| const int need_aboveleft = (params.z >> NeedAboveLeftShift) & 1; |
| if (wi == 0 && need_aboveleft) { |
| uint t = above[loc_base]; |
| uint l = left[loc_base]; |
| uint topleft = (left_available && above_available) ? (dst_frame.Load(corner) >> 16) |
| : left_available ? l : above_available ? t : 512; |
| |
| if ((params.z & FilterAboveLeftFlag) && (bw + bh >= 24) && cb_flags.x) |
| topleft = ((l + t) * 5 + topleft * 6 + 8) >> 4; |
| |
| above[loc_base - 1] = topleft; |
| left[loc_base - 1] = topleft; |
| above[loc_base - 2] = topleft; |
| left[loc_base - 2] = topleft; |
| } |
| |
| GroupMemoryBarrierWithGroupSync(); |
| |
| int dir_mode = mode < MODE_DC; |
| int upsample_above = (block.y >> 22) & dir_mode; |
| int upsample_left = (block.y >> 23) & dir_mode; |
| |
| int filter_count = 0; |
| if (above_available && ((params.z >> NeedAboveShift) & 1)) { |
| filter_count = min(above_available << 2, bw) + ((params.z >> NeedRightShift) & 1) * bh + need_aboveleft - 1; |
| } |
| int edge_filter = (block.y >> 24) & ((wi < filter_count && dir_mode) * 3); |
| |
| int sum0 = 8; |
| int sum1 = 8; |
| const int wi1 = wi + wi_count; |
| if (edge_filter) { |
| edge_filter <<= 2; |
| const int base = loc_base - need_aboveleft; |
| const int last = filter_count; |
| //{ 0, 4, 8, 4, 0 }, { 0, 5, 6, 5, 0 }, { 2, 4, 4, 4, 2 } |
| sum0 += above[base + max(wi - 1, 0)] * ((0x2000 >> edge_filter) & 15); |
| sum0 += above[base + (wi + 0)] * ((0x4540 >> edge_filter) & 15); |
| sum0 += above[base + (wi + 1)] * ((0x4680 >> edge_filter) & 15); |
| sum0 += above[base + min(wi + 2, last)] * ((0x4540 >> edge_filter) & 15); |
| sum0 += above[base + min(wi + 3, last)] * ((0x2000 >> edge_filter) & 15); |
| if (wi1 < filter_count) // rare, some mods for 4x4, 8x4, 4x8 blocks |
| { |
| sum1 += above[base + max(wi1 - 1, 0)] * ((0x2000 >> edge_filter) & 15); |
| sum1 += above[base + (wi1 + 0)] * ((0x4540 >> edge_filter) & 15); |
| sum1 += above[base + (wi1 + 1)] * ((0x4680 >> edge_filter) & 15); |
| sum1 += above[base + min(wi1 + 2, last)] * ((0x4540 >> edge_filter) & 15); |
| sum1 += above[base + min(wi1 + 3, last)] * ((0x2000 >> edge_filter) & 15); |
| } |
| } |
| GroupMemoryBarrierWithGroupSync(); |
| if (edge_filter) { |
| above[loc_base + wi] = sum0 >> 4; |
| if (wi1 < filter_count) { |
| above[loc_base + wi1] = sum1 >> 4; |
| } |
| } |
| |
| if (left_available && ((params.z >> NeedLeftShift) & 1)) { |
| filter_count = min(left_available, bh) + ((params.z >> NeedBotShift) & 1) * bw + need_aboveleft - 1; |
| } |
| edge_filter = (block.y >> 26) & ((wi < filter_count && dir_mode) * 3); |
| if (edge_filter) { |
| sum0 = 8; |
| sum1 = 8; |
| edge_filter *= 4; |
| const int base = loc_base - need_aboveleft; |
| const int last = filter_count; |
| sum0 += left[base + max(wi - 1, 0)] * ((0x2000 >> edge_filter) & 15); |
| sum0 += left[base + (wi + 0)] * ((0x4540 >> edge_filter) & 15); |
| sum0 += left[base + (wi + 1)] * ((0x4680 >> edge_filter) & 15); |
| sum0 += left[base + min(wi + 2, last)] * ((0x4540 >> edge_filter) & 15); |
| sum0 += left[base + min(wi + 3, last)] * ((0x2000 >> edge_filter) & 15); |
| if (wi1 < filter_count) { |
| sum1 += left[base + max(wi1 - 1, 0)] * ((0x2000 >> edge_filter) & 15); |
| sum1 += left[base + (wi1 + 0)] * ((0x4540 >> edge_filter) & 15); |
| sum1 += left[base + (wi1 + 1)] * ((0x4680 >> edge_filter) & 15); |
| sum1 += left[base + min(wi1 + 2, last)] * ((0x4540 >> edge_filter) & 15); |
| sum1 += left[base + min(wi1 + 3, last)] * ((0x2000 >> edge_filter) & 15); |
| } |
| } |
| GroupMemoryBarrierWithGroupSync(); |
| if (edge_filter) { |
| left[loc_base + wi] = sum0 >> 4; |
| if (wi1 < filter_count) { |
| left[loc_base + wi1] = sum1 >> 4; |
| } |
| } |
| |
| GroupMemoryBarrierWithGroupSync(); |
| |
| int p0 = 0, p1 = 0, p2 = 0, p3 = 0, p4 = 0; |
| int do_upsample = upsample_above && wi < (above_count >> 1); |
| if (do_upsample) { |
| p0 = above[loc_base + wi * 2 - 2]; |
| p1 = above[loc_base + wi * 2 - 1]; |
| p2 = above[loc_base + wi * 2 + 0]; |
| p3 = above[loc_base + wi * 2 + 1]; |
| p4 = above[loc_base + min(wi * 2 + 2, above_count - 1)]; |
| } |
| GroupMemoryBarrierWithGroupSync(); |
| if (do_upsample) { |
| above[loc_base - 1 + wi * 4] = clamp((-p0 + 9 * p1 + 9 * p2 - p3 + 8) >> 4, 0, 1023); |
| above[loc_base + 0 + wi * 4] = p2; |
| above[loc_base + 1 + wi * 4] = clamp((-p1 + 9 * p2 + 9 * p3 - p4 + 8) >> 4, 0, 1023); |
| above[loc_base + 2 + wi * 4] = p3; |
| } |
| |
| do_upsample = upsample_left && wi < (left_count >> 1); |
| if (do_upsample) { |
| p0 = left[loc_base + wi * 2 - 2]; |
| p1 = left[loc_base + wi * 2 - 1]; |
| p2 = left[loc_base + wi * 2 + 0]; |
| p3 = left[loc_base + wi * 2 + 1]; |
| p4 = left[loc_base + min(wi * 2 + 2, left_count - 1)]; |
| } |
| GroupMemoryBarrierWithGroupSync(); |
| if (do_upsample) { |
| left[loc_base - 1 + wi * 4] = clamp((-p0 + 9 * p1 + 9 * p2 - p3 + 8) >> 4, 0, 1023); |
| left[loc_base + 0 + wi * 4] = p2; |
| left[loc_base + 1 + wi * 4] = clamp((-p1 + 9 * p2 + 9 * p3 - p4 + 8) >> 4, 0, 1023); |
| left[loc_base + 2 + wi * 4] = p3; |
| } |
| GroupMemoryBarrierWithGroupSync(); |
| |
| // int x0 = (wi & ((1 << bw_log) - 1)) << 2; |
| // int y = wi >> bw_log; |
| int x0 = (thread.x & ((1 << bw_log) - 1)) << 2; |
| int y = (thread.x & ((1 << bsize_log) - 1)) >> bw_log; |
| |
| uint2 pixels = uint2(0, 0); |
| if (mode == MODE_INTRA_BC) { |
| int mv = (int)block.z; |
| int mvx = bx + x0 + ((mv) >> (16 + SubpelBits)); |
| int mvy = by + y + ((mv << 16) >> (16 + SubpelBits)); |
| const int filt_h = 128 >> ((mv >> 19) & 1); |
| const int filt_v = 128 >> ((mv >> 3) & 1); |
| int addr = cb_planes[plane].y + (mvx << 1) + mvy * stride; |
| uint3 ref0, ref1 = 0; |
| |
| const uint shift = (addr & 2) << 3; |
| addr &= ~3; |
| ref0 = dst_frame.Load3(addr); |
| ref0.x = (ref0.x >> shift) | ((ref0.y << (24 - shift)) << 8); |
| ref0.y = (ref0.y >> shift) | ((ref0.z << (24 - shift)) << 8); |
| ref0.z = ref0.z >> shift; |
| |
| if (filt_v != 128) { |
| ref1 = dst_frame.Load3(addr + stride); |
| ref1.x = (ref1.x >> shift) | ((ref1.y << (24 - shift)) << 8); |
| ref1.y = (ref1.y >> shift) | ((ref1.z << (24 - shift)) << 8); |
| ref1.z = ref1.z >> shift; |
| } |
| |
| pixels.x = (compute_bc((ref0.x >> 0) & 1023, (ref0.x >> 16) & 1023, (ref1.x >> 0) & 1023, (ref1.x >> 16) & 1023, |
| filt_h, filt_v) |
| << 0) | |
| (compute_bc((ref0.x >> 16) & 1023, (ref0.y >> 0) & 1023, (ref1.x >> 8) & 1023, (ref1.y >> 0) & 1023, |
| filt_h, filt_v) |
| << 16); |
| pixels.y = (compute_bc((ref0.y >> 0) & 1023, (ref0.y >> 16) & 1023, (ref1.y >> 0) & 1023, (ref1.y >> 16) & 1023, |
| filt_h, filt_v) |
| << 0) | |
| (compute_bc((ref0.y >> 16) & 1023, (ref0.z >> 0) & 1023, (ref1.y >> 16) & 1023, (ref1.z >> 0) & 1023, |
| filt_h, filt_v) |
| << 16); |
| } |
| |
| uint dc = 0; |
| if (mode >= MODE_DC) { |
| uint count = 0; |
| // todo: maybe some optization here? |
| if (above_available) { |
| for (int i = 0; i < bw; ++i) dc += above[loc_base + i]; |
| count += bw; |
| } |
| if (left_available) { |
| for (int i = 0; i < bh; ++i) dc += left[loc_base + i]; |
| count += bh; |
| } |
| dc += count >> 1; |
| dc = count ? dc / count : 512; |
| |
| pixels.x = dc | (dc << 16); |
| pixels.y = pixels.x; |
| } |
| |
| GroupMemoryBarrierWithGroupSync(); |
| |
| int4 luma = 0; |
| if (mode == MODE_CFL) { |
| const int max_y = (block.z >> 16) - 2; |
| const int y_stride = cb_planes[0].x; |
| const int luma_y = min((by + y) << 1, max_y); |
| |
| // const int max_x = (block.z & 0xffff) - 4; |
| // const int luma_x = (bx + x0) << 1; |
| // int y_offset = cb_planes[0].y + min(luma_x, max_x) + luma_y * y_stride; |
| const int max_x = ((block.z & 0xffff) << 1) - 8; |
| const int luma_x = (bx + x0) << 2; |
| int y_offset = cb_planes[0].y + min(luma_x, max_x) + luma_y * y_stride; |
| |
| uint4 luma0 = dst_frame.Load4(y_offset); |
| uint4 luma1 = dst_frame.Load4(y_offset + y_stride); |
| |
| if (luma_x >= max_x) { |
| luma0.zw = luma0.yy; |
| luma1.zw = luma1.yy; |
| if (luma_x > max_x) { |
| luma0.x = luma0.y; |
| luma1.x = luma1.y; |
| } |
| } |
| |
| luma.x = ((luma0.x >> 0) & 1023) + ((luma0.x >> 16) & 1023) + ((luma1.x >> 0) & 1023) + ((luma1.x >> 16) & 1023); |
| luma.y = ((luma0.y >> 0) & 1023) + ((luma0.y >> 16) & 1023) + ((luma1.y >> 0) & 1023) + ((luma1.y >> 16) & 1023); |
| luma.z = ((luma0.z >> 0) & 1023) + ((luma0.z >> 16) & 1023) + ((luma1.z >> 0) & 1023) + ((luma1.z >> 16) & 1023); |
| luma.w = ((luma0.w >> 0) & 1023) + ((luma0.w >> 16) & 1023) + ((luma1.w >> 0) & 1023) + ((luma1.w >> 16) & 1023); |
| luma <<= 1; |
| above[loc_base + wi] = luma.x + luma.y + luma.z + luma.w; |
| } |
| |
| GroupMemoryBarrierWithGroupSync(); |
| |
| if (mode == MODE_CFL) // reduce |
| { |
| int count = wi_count >> 2; |
| // max cfl block 32x32 / 4(pixels) = 256 wi (wi_count); |
| // count = 256wi / 4 = up to 64wi == wavefront size, => we can use GroupMemoryBarrier(); |
| int ofs = loc_base + wi * 4; |
| if (wi < count) { |
| int sum = above[ofs + 0] + above[ofs + 1] + above[ofs + 2] + above[ofs + 3]; |
| GroupMemoryBarrier(); |
| above[loc_base + wi] = sum; |
| GroupMemoryBarrier(); |
| } |
| ofs = loc_base + wi * 2; |
| count >>= 1; |
| while (wi < count) { |
| int sum = above[ofs + 0] + above[ofs + 1]; |
| GroupMemoryBarrier(); |
| above[loc_base + wi] = sum; |
| GroupMemoryBarrier(); |
| count >>= 1; |
| } |
| } |
| |
| GroupMemoryBarrierWithGroupSync(); |
| if (thread.x >= cb_wi_count) return; |
| |
| if (mode == MODE_CFL) { |
| int avrg = (above[loc_base] + (2 << bsize_log)) >> (bsize_log + 2); |
| int alpha = ((block.y >> 22) & 63) - 16; |
| pixels.x = compute_cfl_pixel(dc, (luma.x - avrg) * alpha); |
| pixels.x |= compute_cfl_pixel(dc, (luma.y - avrg) * alpha) << 16; |
| pixels.y = compute_cfl_pixel(dc, (luma.z - avrg) * alpha); |
| pixels.y |= compute_cfl_pixel(dc, (luma.w - avrg) * alpha) << 16; |
| } |
| |
| if (mode < MODE_INTRA_BC) { |
| const int frac_bits_x = 6 - upsample_above; |
| const int frac_bits_y = 6 - upsample_left; |
| const int min_base_x = -(1 << upsample_above); |
| |
| above_count <<= upsample_above; |
| left_count <<= upsample_left; |
| uint topleft = above[loc_base - 1]; |
| |
| for (int i = 0; i < 4; ++i) { |
| int x = i + x0; |
| ////1: |
| // int offset_x = (1 + y) * dx; |
| // int base_x = offset_x >> frac_bits_x; |
| // |
| ////2: |
| // int offset_x = (x << 6) - (y + 1) * dx; |
| // const int base_x = offset_x >> frac_bits_x; |
| // |
| // int offset_y = (y << 6) - (x + 1) * dy; |
| // const int base_y = offset_y >> frac_bits_y; |
| // |
| ////3: |
| // int offset_y = (1 + x) * dy; |
| // int base_y = offset_x >> frac_bits_x; |
| // |
| // int shift_y = ((offset_y << upsample_above) & 0x3F) >> 1; |
| // int shift_x = ((offset_x << upsample_above) & 0x3F) >> 1; |
| // Note: for non dir modes: |
| // dx = 0; dy = 0; upsample_above = 0; upsample_left = 0; |
| |
| const int offset_x = (x << 6) + (y + 1) * params.x; |
| const int offset_y = (y << 6) + (x + 1) * params.y; |
| const int shift_x = ((offset_x << upsample_above) & 0x3F) >> 1; |
| const int shift_y = ((offset_y << upsample_left) & 0x3F) >> 1; |
| |
| // Note: shift_x = 0 & shift_y = 0 if (dx == 0) & (dy == 0); |
| // maybe this can be used to simplify weight calc; |
| |
| const int base_x = offset_x >> frac_bits_x; |
| int l0 = left[loc_base + clamp(offset_y >> frac_bits_y, -2, left_count - 1)]; |
| int l1 = left[loc_base + clamp((offset_y >> frac_bits_y) + 1, -2, left_count - 1)]; |
| int t0 = above[loc_base + clamp(base_x, -2, above_count - 1)]; |
| int t1 = above[loc_base + clamp(base_x + 1, -2, above_count - 1)]; |
| |
| // switch(mode) |
| //{ |
| // case (SMOOTH_V | SMOOTH_H): |
| // w_t0 = *(sm_weight_arrays + bh + y); |
| // w_l0 = *(sm_weight_arrays + bw + x); |
| // |
| // case SMOOTH_V: |
| // w_t0 = *(sm_weight_arrays + bh + y); |
| // |
| // case SMOOTH_H: |
| // w_l0 = *(sm_weight_arrays + bw + x); |
| // |
| // case V: |
| // case DIR_1: |
| // w_t0 = 32 - shift_x; |
| // |
| // case H: |
| // case DIR_3: |
| // w_l0 = 32 - shift_y; |
| // |
| // case MODE_PAETH: |
| // int base = t0 + l0 - topleft; |
| // int diff_t = abs(t0 - base); |
| // int diff_l = abs(l0 - base); |
| // int diff_tl = abs(topleft - base); |
| // w_t0 = diff_t < diff_l && diff_t < diff_tl; |
| // w_l0 = diff_l < diff_t && diff_l < diff_tl; |
| //}; |
| |
| int mode_info = params.z & 15; |
| if (mode_info == Dir2) // eliminate dir2 |
| mode_info = base_x >= min_base_x ? Dir1 : Dir3; |
| |
| int w_t0 = (mode_info & SmoothV) ? cb_sm_weight_arrays[bh + y].x : (mode_info == Dir1) ? (32 - shift_x) : 0; |
| int w_l0 = (mode_info & SmoothH) ? cb_sm_weight_arrays[bw + x].x : (mode_info == Dir3) ? (32 - shift_y) : 0; |
| |
| if (mode == MODE_PAETH) { |
| int diff_t = topleft - l0; |
| int diff_l = topleft - t0; |
| int diff_tl = abs(diff_t + diff_l); |
| diff_t = abs(diff_t); |
| diff_l = abs(diff_l); |
| w_l0 = diff_l <= diff_t && diff_l <= diff_tl; |
| w_t0 = diff_t < diff_l && diff_t <= diff_tl; |
| w_l0 <<= 5; |
| w_t0 <<= 5; |
| } |
| |
| int w_tl = (mode == MODE_PAETH) ? (32 - w_t0 - w_l0) : 0; |
| int w_l1 = (mode_info == Dir3) ? shift_y : 0; |
| int w_t1 = (mode_info == Dir1) ? shift_x : 0; |
| int w_b = (mode_info & SmoothV) ? 0x100 - w_t0 : 0; |
| int w_r = (mode_info & SmoothH) ? 0x100 - w_l0 : 0; |
| |
| int sum = w_tl * topleft + w_b * left[loc_base + bh - 1] + w_r * above[loc_base + bw - 1] + w_l0 * l0 + |
| w_t0 * t0 + w_l1 * l1 + w_t1 * t1; |
| |
| sum += 1 << (params.w - 1); |
| sum >>= params.w; |
| int val = clamp(sum, 0, 1023) << ((i & 1) * 16); |
| if (i & 2) |
| pixels.y |= val; |
| else |
| pixels.x |= val; |
| } |
| } |
| |
| const int addr = corner + 4 + (x0 << 1) + (y + 1) * stride; |
| if (block.y & 0x80000000) // inter-intra |
| { |
| int wedge_addr = (block.z << 6) + x0 + y * bw; |
| uint wedge = wedge_mask.Load(wedge_addr); |
| uint2 inter = dst_frame.Load2(addr); |
| |
| pixels.x = intra_inter_blend((wedge >> 0) & 255, (pixels.x >> 0) & 1023, (inter.x >> 0) & 1023) | |
| (intra_inter_blend((wedge >> 8) & 255, (pixels.x >> 16) & 1023, (inter.x >> 16) & 1023) << 16); |
| pixels.y = intra_inter_blend((wedge >> 16) & 255, (pixels.y >> 0) & 1023, (inter.y >> 0) & 1023) | |
| (intra_inter_blend((wedge >> 24) & 255, (pixels.y >> 16) & 1023, (inter.y >> 16) & 1023) << 16); |
| } |
| |
| if (block.y & (1 << 5)) { |
| const int res_stride = cb_planes[plane].z; |
| const int res_addr = cb_planes[plane].w + ((bx + x0) << 1) + (by + y) * res_stride; |
| int2 res = residuals.Load2(res_addr); |
| pixels.x = clamp((int)((pixels.x >> 0) & 1023) + (int)((res.x << 16) >> 16), 0, 1023) | |
| (clamp((int)((pixels.x >> 16) & 1023) + (int)(res.x >> 16), 0, 1023) << 16); |
| pixels.y = clamp((int)((pixels.y >> 0) & 1023) + (int)((res.y << 16) >> 16), 0, 1023) | |
| (clamp((int)((pixels.y >> 16) & 1023) + (int)(res.y >> 16), 0, 1023) << 16); |
| } |
| |
| dst_frame.Store2(addr, pixels); |
| } |
