| /* |
| * This file is part of FFmpeg. |
| * |
| * FFmpeg 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. |
| * |
| * FFmpeg 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 Lesser General Public |
| * License along with FFmpeg; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| */ |
| |
| /** |
| * @file |
| *@brief IntraX8 frame subdecoder image manipulation routines |
| */ |
| |
| #include "intrax8dsp.h" |
| #include "libavutil/common.h" |
| |
| /* |
| * area positions, #3 is 1 pixel only, other are 8 pixels |
| * |66666666| |
| * 3|44444444|55555555| |
| * - -+--------+--------+ |
| * 1 2|XXXXXXXX| |
| * 1 2|XXXXXXXX| |
| * 1 2|XXXXXXXX| |
| * 1 2|XXXXXXXX| |
| * 1 2|XXXXXXXX| |
| * 1 2|XXXXXXXX| |
| * 1 2|XXXXXXXX| |
| * 1 2|XXXXXXXX| |
| * ^-start |
| */ |
| |
| #define area1 (0) |
| #define area2 (8) |
| #define area3 (8 + 8) |
| #define area4 (8 + 8 + 1) |
| #define area5 (8 + 8 + 1 + 8) |
| #define area6 (8 + 8 + 1 + 16) |
| |
| /** |
| Collect statistics and prepare the edge pixels required by the other spatial compensation functions. |
| |
| * @param src pointer to the beginning of the processed block |
| * @param dst pointer to emu_edge, edge pixels are stored the way other compensation routines do. |
| * @param linesize byte offset between 2 vertical pixels in the source image |
| * @param range pointer to the variable where the edge pixel range is to be stored (max-min values) |
| * @param psum pointer to the variable where the edge pixel sum is to be stored |
| * @param edges Informs this routine that the block is on an image border, so it has to interpolate the missing edge pixels. |
| and some of the edge pixels should be interpolated, the flag has the following meaning: |
| 1 - mb_x==0 - first block in the row, interpolate area #1,#2,#3; |
| 2 - mb_y==0 - first row, interpolate area #3,#4,#5,#6; |
| note: 1|2 - mb_x==mb_y==0 - first block, use 0x80 value for all areas; |
| 4 - mb_x>= (mb_width-1) last block in the row, interpolate area #5; |
| -*/ |
| static void x8_setup_spatial_compensation(uint8_t *src, uint8_t *dst, |
| ptrdiff_t stride, int *range, |
| int *psum, int edges) |
| { |
| uint8_t *ptr; |
| int sum; |
| int i; |
| int min_pix, max_pix; |
| uint8_t c; |
| |
| if ((edges & 3) == 3) { |
| *psum = 0x80 * (8 + 1 + 8 + 2); |
| *range = 0; |
| memset(dst, 0x80, 16 + 1 + 16 + 8); |
| /* this triggers flat_dc for sure. flat_dc avoids all (other) |
| * prediction modes, but requires dc_level decoding. */ |
| return; |
| } |
| |
| min_pix = 256; |
| max_pix = -1; |
| |
| sum = 0; |
| |
| if (!(edges & 1)) { // (mb_x != 0) // there is previous block on this row |
| ptr = src - 1; // left column, area 2 |
| for (i = 7; i >= 0; i--) { |
| c = *(ptr - 1); // area1, same mb as area2, no need to check |
| dst[area1 + i] = c; |
| c = *ptr; |
| |
| sum += c; |
| min_pix = FFMIN(min_pix, c); |
| max_pix = FFMAX(max_pix, c); |
| dst[area2 + i] = c; |
| |
| ptr += stride; |
| } |
| } |
| |
| if (!(edges & 2)) { // (mb_y != 0) // there is row above |
| ptr = src - stride; // top line |
| for (i = 0; i < 8; i++) { |
| c = *(ptr + i); |
| sum += c; |
| min_pix = FFMIN(min_pix, c); |
| max_pix = FFMAX(max_pix, c); |
| } |
| if (edges & 4) { // last block on the row? |
| memset(dst + area5, c, 8); // set with last pixel fr |
| memcpy(dst + area4, ptr, 8); |
| } else { |
| memcpy(dst + area4, ptr, 16); // both area4 and 5 |
| } |
| // area6 always present in the above block |
| memcpy(dst + area6, ptr - stride, 8); |
| } |
| // now calculate the stuff we need |
| if (edges & 3) { // mb_x ==0 || mb_y == 0) { |
| int avg = (sum + 4) >> 3; |
| |
| if (edges & 1) // (mb_x == 0) { // implies mb_y !=0 |
| memset(dst + area1, avg, 8 + 8 + 1); // areas 1, 2, 3 are averaged |
| else // implies y == 0 x != 0 |
| memset(dst + area3, avg, 1 + 16 + 8); // areas 3, 4, 5, 6 |
| |
| sum += avg * 9; |
| } else { |
| // the edge pixel, in the top line and left column |
| uint8_t c = *(src - 1 - stride); |
| dst[area3] = c; |
| sum += c; |
| // edge pixel is not part of min/max |
| } |
| *range = max_pix - min_pix; |
| sum += *(dst + area5) + *(dst + area5 + 1); |
| *psum = sum; |
| } |
| |
| static const uint16_t zero_prediction_weights[64 * 2] = { |
| 640, 640, 669, 480, 708, 354, 748, 257, |
| 792, 198, 760, 143, 808, 101, 772, 72, |
| 480, 669, 537, 537, 598, 416, 661, 316, |
| 719, 250, 707, 185, 768, 134, 745, 97, |
| 354, 708, 416, 598, 488, 488, 564, 388, |
| 634, 317, 642, 241, 716, 179, 706, 132, |
| 257, 748, 316, 661, 388, 564, 469, 469, |
| 543, 395, 571, 311, 655, 238, 660, 180, |
| 198, 792, 250, 719, 317, 634, 395, 543, |
| 469, 469, 507, 380, 597, 299, 616, 231, |
| 161, 855, 206, 788, 266, 710, 340, 623, |
| 411, 548, 455, 455, 548, 366, 576, 288, |
| 122, 972, 159, 914, 211, 842, 276, 758, |
| 341, 682, 389, 584, 483, 483, 520, 390, |
| 110, 1172, 144, 1107, 193, 1028, 254, 932, |
| 317, 846, 366, 731, 458, 611, 499, 499, |
| }; |
| |
| static void spatial_compensation_0(uint8_t *src, uint8_t *dst, ptrdiff_t stride) |
| { |
| int i, j; |
| int x, y; |
| unsigned int p; // power divided by 2 |
| int a; |
| uint16_t left_sum[2][8] = { { 0 } }; |
| uint16_t top_sum[2][8] = { { 0 } }; |
| |
| for (i = 0; i < 8; i++) { |
| a = src[area2 + 7 - i] << 4; |
| for (j = 0; j < 8; j++) { |
| p = abs(i - j); |
| left_sum[p & 1][j] += a >> (p >> 1); |
| } |
| } |
| |
| for (i = 0; i < 8; i++) { |
| a = src[area4 + i] << 4; |
| for (j = 0; j < 8; j++) { |
| p = abs(i - j); |
| top_sum[p & 1][j] += a >> (p >> 1); |
| } |
| } |
| for (; i < 10; i++) { |
| a = src[area4 + i] << 4; |
| for (j = 5; j < 8; j++) { |
| p = abs(i - j); |
| top_sum[p & 1][j] += a >> (p >> 1); |
| } |
| } |
| for (; i < 12; i++) { |
| a = src[area4 + i] << 4; |
| for (j = 7; j < 8; j++) { |
| p = abs(i - j); |
| top_sum[p & 1][j] += a >> (p >> 1); |
| } |
| } |
| |
| for (i = 0; i < 8; i++) { |
| top_sum[0][i] += (top_sum[1][i] * 181 + 128) >> 8; // 181 is sqrt(2)/2 |
| left_sum[0][i] += (left_sum[1][i] * 181 + 128) >> 8; |
| } |
| for (y = 0; y < 8; y++) { |
| for (x = 0; x < 8; x++) |
| dst[x] = ((uint32_t) top_sum[0][x] * zero_prediction_weights[y * 16 + x * 2 + 0] + |
| (uint32_t) left_sum[0][y] * zero_prediction_weights[y * 16 + x * 2 + 1] + |
| 0x8000) >> 16; |
| dst += stride; |
| } |
| } |
| |
| static void spatial_compensation_1(uint8_t *src, uint8_t *dst, ptrdiff_t stride) |
| { |
| int x, y; |
| |
| for (y = 0; y < 8; y++) { |
| for (x = 0; x < 8; x++) |
| dst[x] = src[area4 + FFMIN(2 * y + x + 2, 15)]; |
| dst += stride; |
| } |
| } |
| |
| static void spatial_compensation_2(uint8_t *src, uint8_t *dst, ptrdiff_t stride) |
| { |
| int x, y; |
| |
| for (y = 0; y < 8; y++) { |
| for (x = 0; x < 8; x++) |
| dst[x] = src[area4 + 1 + y + x]; |
| dst += stride; |
| } |
| } |
| |
| static void spatial_compensation_3(uint8_t *src, uint8_t *dst, ptrdiff_t stride) |
| { |
| int x, y; |
| |
| for (y = 0; y < 8; y++) { |
| for (x = 0; x < 8; x++) |
| dst[x] = src[area4 + ((y + 1) >> 1) + x]; |
| dst += stride; |
| } |
| } |
| |
| static void spatial_compensation_4(uint8_t *src, uint8_t *dst, ptrdiff_t stride) |
| { |
| int x, y; |
| |
| for (y = 0; y < 8; y++) { |
| for (x = 0; x < 8; x++) |
| dst[x] = (src[area4 + x] + src[area6 + x] + 1) >> 1; |
| dst += stride; |
| } |
| } |
| |
| static void spatial_compensation_5(uint8_t *src, uint8_t *dst, ptrdiff_t stride) |
| { |
| int x, y; |
| |
| for (y = 0; y < 8; y++) { |
| for (x = 0; x < 8; x++) { |
| if (2 * x - y < 0) |
| dst[x] = src[area2 + 9 + 2 * x - y]; |
| else |
| dst[x] = src[area4 + x - ((y + 1) >> 1)]; |
| } |
| dst += stride; |
| } |
| } |
| |
| static void spatial_compensation_6(uint8_t *src, uint8_t *dst, ptrdiff_t stride) |
| { |
| int x, y; |
| |
| for (y = 0; y < 8; y++) { |
| for (x = 0; x < 8; x++) |
| dst[x] = src[area3 + x - y]; |
| dst += stride; |
| } |
| } |
| |
| static void spatial_compensation_7(uint8_t *src, uint8_t *dst, ptrdiff_t stride) |
| { |
| int x, y; |
| |
| for (y = 0; y < 8; y++) { |
| for (x = 0; x < 8; x++) { |
| if (x - 2 * y > 0) |
| dst[x] = (src[area3 - 1 + x - 2 * y] + src[area3 + x - 2 * y] + 1) >> 1; |
| else |
| dst[x] = src[area2 + 8 - y + (x >> 1)]; |
| } |
| dst += stride; |
| } |
| } |
| |
| static void spatial_compensation_8(uint8_t *src, uint8_t *dst, ptrdiff_t stride) |
| { |
| int x, y; |
| |
| for (y = 0; y < 8; y++) { |
| for (x = 0; x < 8; x++) |
| dst[x] = (src[area1 + 7 - y] + src[area2 + 7 - y] + 1) >> 1; |
| dst += stride; |
| } |
| } |
| |
| static void spatial_compensation_9(uint8_t *src, uint8_t *dst, ptrdiff_t stride) |
| { |
| int x, y; |
| |
| for (y = 0; y < 8; y++) { |
| for (x = 0; x < 8; x++) |
| dst[x] = src[area2 + 6 - FFMIN(x + y, 6)]; |
| dst += stride; |
| } |
| } |
| |
| static void spatial_compensation_10(uint8_t *src, uint8_t *dst, ptrdiff_t stride) |
| { |
| int x, y; |
| |
| for (y = 0; y < 8; y++) { |
| for (x = 0; x < 8; x++) |
| dst[x] = (src[area2 + 7 - y] * (8 - x) + src[area4 + x] * x + 4) >> 3; |
| dst += stride; |
| } |
| } |
| |
| static void spatial_compensation_11(uint8_t *src, uint8_t *dst, ptrdiff_t stride) |
| { |
| int x, y; |
| |
| for (y = 0; y < 8; y++) { |
| for (x = 0; x < 8; x++) |
| dst[x] = (src[area2 + 7 - y] * y + src[area4 + x] * (8 - y) + 4) >> 3; |
| dst += stride; |
| } |
| } |
| |
| static void x8_loop_filter(uint8_t *ptr, const ptrdiff_t a_stride, |
| const ptrdiff_t b_stride, int quant) |
| { |
| int i, t; |
| int p0, p1, p2, p3, p4, p5, p6, p7, p8, p9; |
| int ql = (quant + 10) >> 3; |
| |
| for (i = 0; i < 8; i++, ptr += b_stride) { |
| p0 = ptr[-5 * a_stride]; |
| p1 = ptr[-4 * a_stride]; |
| p2 = ptr[-3 * a_stride]; |
| p3 = ptr[-2 * a_stride]; |
| p4 = ptr[-1 * a_stride]; |
| p5 = ptr[0]; |
| p6 = ptr[1 * a_stride]; |
| p7 = ptr[2 * a_stride]; |
| p8 = ptr[3 * a_stride]; |
| p9 = ptr[4 * a_stride]; |
| |
| t = (FFABS(p1 - p2) <= ql) + |
| (FFABS(p2 - p3) <= ql) + |
| (FFABS(p3 - p4) <= ql) + |
| (FFABS(p4 - p5) <= ql); |
| |
| // You need at least 1 to be able to reach a total score of 6. |
| if (t > 0) { |
| t += (FFABS(p5 - p6) <= ql) + |
| (FFABS(p6 - p7) <= ql) + |
| (FFABS(p7 - p8) <= ql) + |
| (FFABS(p8 - p9) <= ql) + |
| (FFABS(p0 - p1) <= ql); |
| if (t >= 6) { |
| int min, max; |
| |
| min = max = p1; |
| min = FFMIN(min, p3); |
| max = FFMAX(max, p3); |
| min = FFMIN(min, p5); |
| max = FFMAX(max, p5); |
| min = FFMIN(min, p8); |
| max = FFMAX(max, p8); |
| if (max - min < 2 * quant) { // early stop |
| min = FFMIN(min, p2); |
| max = FFMAX(max, p2); |
| min = FFMIN(min, p4); |
| max = FFMAX(max, p4); |
| min = FFMIN(min, p6); |
| max = FFMAX(max, p6); |
| min = FFMIN(min, p7); |
| max = FFMAX(max, p7); |
| if (max - min < 2 * quant) { |
| ptr[-2 * a_stride] = (4 * p2 + 3 * p3 + 1 * p7 + 4) >> 3; |
| ptr[-1 * a_stride] = (3 * p2 + 3 * p4 + 2 * p7 + 4) >> 3; |
| ptr[0] = (2 * p2 + 3 * p5 + 3 * p7 + 4) >> 3; |
| ptr[1 * a_stride] = (1 * p2 + 3 * p6 + 4 * p7 + 4) >> 3; |
| continue; |
| } |
| } |
| } |
| } |
| { |
| int x, x0, x1, x2; |
| int m; |
| |
| x0 = (2 * p3 - 5 * p4 + 5 * p5 - 2 * p6 + 4) >> 3; |
| if (FFABS(x0) < quant) { |
| x1 = (2 * p1 - 5 * p2 + 5 * p3 - 2 * p4 + 4) >> 3; |
| x2 = (2 * p5 - 5 * p6 + 5 * p7 - 2 * p8 + 4) >> 3; |
| |
| x = FFABS(x0) - FFMIN(FFABS(x1), FFABS(x2)); |
| m = p4 - p5; |
| |
| if (x > 0 && (m ^ x0) < 0) { |
| int32_t sign; |
| |
| sign = m >> 31; |
| m = (m ^ sign) - sign; // abs(m) |
| m >>= 1; |
| |
| x = 5 * x >> 3; |
| |
| if (x > m) |
| x = m; |
| |
| x = (x ^ sign) - sign; |
| |
| ptr[-1 * a_stride] -= x; |
| ptr[0] += x; |
| } |
| } |
| } |
| } |
| } |
| |
| static void x8_h_loop_filter(uint8_t *src, ptrdiff_t stride, int qscale) |
| { |
| x8_loop_filter(src, stride, 1, qscale); |
| } |
| |
| static void x8_v_loop_filter(uint8_t *src, ptrdiff_t stride, int qscale) |
| { |
| x8_loop_filter(src, 1, stride, qscale); |
| } |
| |
| av_cold void ff_intrax8dsp_init(IntraX8DSPContext *dsp) |
| { |
| dsp->h_loop_filter = x8_h_loop_filter; |
| dsp->v_loop_filter = x8_v_loop_filter; |
| dsp->setup_spatial_compensation = x8_setup_spatial_compensation; |
| dsp->spatial_compensation[0] = spatial_compensation_0; |
| dsp->spatial_compensation[1] = spatial_compensation_1; |
| dsp->spatial_compensation[2] = spatial_compensation_2; |
| dsp->spatial_compensation[3] = spatial_compensation_3; |
| dsp->spatial_compensation[4] = spatial_compensation_4; |
| dsp->spatial_compensation[5] = spatial_compensation_5; |
| dsp->spatial_compensation[6] = spatial_compensation_6; |
| dsp->spatial_compensation[7] = spatial_compensation_7; |
| dsp->spatial_compensation[8] = spatial_compensation_8; |
| dsp->spatial_compensation[9] = spatial_compensation_9; |
| dsp->spatial_compensation[10] = spatial_compensation_10; |
| dsp->spatial_compensation[11] = spatial_compensation_11; |
| } |