Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

hevc: simplify SAO computation, delay from one row its computation

Browse Source 
(cherry picked from commit f2c5f647cec786df26f442a85e6d685a131a50c9)

Signed-off-by: Michael Niedermayer <michaelni@gmx.at>
pull/77/merge
Mickaël Raulet 11 years ago committed by Michael Niedermayer
parent d595361593
commit 1241eb8870
6 changed files with 194 additions and 453 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      libavcodec/hevc.c
  2. 2
      libavcodec/hevc.h
  3. 225
      libavcodec/hevc_filter.c
  4. 12
      libavcodec/hevcdsp.c
  5. 15
      libavcodec/hevcdsp.h
  6. 389
      libavcodec/hevcdsp_template.c

4
libavcodec/hevc.c
Unescape View File

@ -2092,7 +2092,7 @@ static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
if (x_ctb + ctb_size >= s->sps->width && if (x_ctb + ctb_size >= s->sps->width &&
y_ctb + ctb_size >= s->sps->height) y_ctb + ctb_size >= s->sps->height)
ff_hevc_hls_filter(s, x_ctb, y_ctb); ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
return ctb_addr_ts; return ctb_addr_ts;
} }
@ -2167,7 +2167,7 @@ static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int
} }
if ((x_ctb+ctb_size) >= s->sps->width && (y_ctb+ctb_size) >= s->sps->height ) { if ((x_ctb+ctb_size) >= s->sps->width && (y_ctb+ctb_size) >= s->sps->height ) {
ff_hevc_hls_filter(s, x_ctb, y_ctb); ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP); ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
return ctb_addr_ts; return ctb_addr_ts;
} }

2
libavcodec/hevc.h
Unescape View File

@ -1001,7 +1001,7 @@ void ff_hevc_deblocking_boundary_strengths(HEVCContext *s, int x0, int y0,
int log2_trafo_size); int log2_trafo_size);
int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s); int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s);
int ff_hevc_cu_qp_delta_abs(HEVCContext *s); int ff_hevc_cu_qp_delta_abs(HEVCContext *s);
void ff_hevc_hls_filter(HEVCContext *s, int x, int y); void ff_hevc_hls_filter(HEVCContext *s, int x, int y, int ctb_size);
void ff_hevc_hls_filters(HEVCContext *s, int x_ctb, int y_ctb, int ctb_size); void ff_hevc_hls_filters(HEVCContext *s, int x_ctb, int y_ctb, int ctb_size);
void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0, void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0,
int log2_trafo_size, enum ScanType scan_idx, int log2_trafo_size, enum ScanType scan_idx,

225
libavcodec/hevc_filter.c
Unescape View File

@ -153,129 +153,97 @@ static void copy_CTB(uint8_t *dst, uint8_t *src,
static void sao_filter_CTB(HEVCContext *s, int x, int y) static void sao_filter_CTB(HEVCContext *s, int x, int y)
{ {
// TODO: This should be easily parallelizable int c_idx;
// TODO: skip CBs when (cu_transquant_bypass_flag || (pcm_loop_filter_disable_flag && pcm_flag))
int c_idx = 0;
int class = 1, class_index;
int edges[4]; // 0 left 1 top 2 right 3 bottom int edges[4]; // 0 left 1 top 2 right 3 bottom
SAOParams *sao[4]; int x_ctb = x >> s->sps->log2_ctb_size;
int classes[4]; int y_ctb = y >> s->sps->log2_ctb_size;
int x_shift = 0, y_shift = 0; int ctb_addr_rs = y_ctb * s->sps->ctb_width + x_ctb;
int x_ctb = x >> s->sps->log2_ctb_size; int ctb_addr_ts = s->pps->ctb_addr_rs_to_ts[ctb_addr_rs];
int y_ctb = y >> s->sps->log2_ctb_size; SAOParams *sao = &CTB(s->sao, x_ctb, y_ctb);
int ctb_addr_rs = y_ctb * s->sps->ctb_width + x_ctb;
int ctb_addr_ts = s->pps->ctb_addr_rs_to_ts[ctb_addr_rs];
// flags indicating unfilterable edges // flags indicating unfilterable edges
uint8_t vert_edge[] = { 0, 0, 0, 0 }; uint8_t vert_edge[] = { 0, 0 };
uint8_t horiz_edge[] = { 0, 0, 0, 0 }; uint8_t horiz_edge[] = { 0, 0 };
uint8_t diag_edge[] = { 0, 0, 0, 0 }; uint8_t diag_edge[] = { 0, 0, 0, 0 };
uint8_t lfase[3]; // current, above, left uint8_t lfase = CTB(s->filter_slice_edges, x_ctb, y_ctb);
uint8_t no_tile_filter = s->pps->tiles_enabled_flag && uint8_t no_tile_filter = s->pps->tiles_enabled_flag &&
!s->pps->loop_filter_across_tiles_enabled_flag; !s->pps->loop_filter_across_tiles_enabled_flag;
uint8_t left_tile_edge = 0; uint8_t restore = no_tile_filter || !lfase;
uint8_t up_tile_edge = 0; uint8_t left_tile_edge = 0;
uint8_t right_tile_edge = 0;
sao[0] = &CTB(s->sao, x_ctb, y_ctb); uint8_t up_tile_edge = 0;
uint8_t bottom_tile_edge = 0;
edges[0] = x_ctb == 0; edges[0] = x_ctb == 0;
edges[1] = y_ctb == 0; edges[1] = y_ctb == 0;
edges[2] = x_ctb == s->sps->ctb_width - 1; edges[2] = x_ctb == s->sps->ctb_width - 1;
edges[3] = y_ctb == s->sps->ctb_height - 1; edges[3] = y_ctb == s->sps->ctb_height - 1;
lfase[0] = CTB(s->filter_slice_edges, x_ctb, y_ctb);
classes[0] = 0;
if (!edges[0]) {
left_tile_edge = no_tile_filter && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[s->pps->ctb_addr_rs_to_ts[ctb_addr_rs-1]];
sao[class] = &CTB(s->sao, x_ctb - 1, y_ctb);
vert_edge[0] = (!lfase[0] && CTB(s->tab_slice_address, x_ctb, y_ctb) != CTB(s->tab_slice_address, x_ctb - 1, y_ctb)) || left_tile_edge;
vert_edge[2] = vert_edge[0];
lfase[2] = CTB(s->filter_slice_edges, x_ctb - 1, y_ctb);
classes[class] = 2;
class++;
x_shift = 8;
}
if (!edges[1]) {
up_tile_edge = no_tile_filter && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[s->pps->ctb_addr_rs_to_ts[ctb_addr_rs - s->sps->ctb_width]];
sao[class] = &CTB(s->sao, x_ctb, y_ctb - 1);
horiz_edge[0] = (!lfase[0] && CTB(s->tab_slice_address, x_ctb, y_ctb) != CTB(s->tab_slice_address, x_ctb, y_ctb - 1)) || up_tile_edge;
horiz_edge[1] = horiz_edge[0];
lfase[1] = CTB(s->filter_slice_edges, x_ctb, y_ctb - 1);
classes[class] = 1;
class++;
y_shift = 4;
if (restore) {
if (!edges[0]) { if (!edges[0]) {
classes[class] = 3; left_tile_edge = no_tile_filter && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[s->pps->ctb_addr_rs_to_ts[ctb_addr_rs-1]];
sao[class] = &CTB(s->sao, x_ctb - 1, y_ctb - 1); vert_edge[0] = (!lfase && CTB(s->tab_slice_address, x_ctb, y_ctb) != CTB(s->tab_slice_address, x_ctb - 1, y_ctb)) || left_tile_edge;
class++; }
if (!edges[2]) {
// Tile check here is done current CTB row/col, not above/left like you'd expect, right_tile_edge = no_tile_filter && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[s->pps->ctb_addr_rs_to_ts[ctb_addr_rs+1]];
//but that is because the tile boundary always extends through the whole pic vert_edge[1] = (!lfase && CTB(s->tab_slice_address, x_ctb, y_ctb) != CTB(s->tab_slice_address, x_ctb + 1, y_ctb)) || right_tile_edge;
vert_edge[1] = (!lfase[1] && CTB(s->tab_slice_address, x_ctb, y_ctb - 1) != CTB(s->tab_slice_address, x_ctb - 1, y_ctb - 1)) || left_tile_edge; }
vert_edge[3] = vert_edge[1]; if (!edges[1]) {
horiz_edge[2] = (!lfase[2] && CTB(s->tab_slice_address, x_ctb - 1, y_ctb) != CTB(s->tab_slice_address, x_ctb - 1, y_ctb - 1)) || up_tile_edge; up_tile_edge = no_tile_filter && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[s->pps->ctb_addr_rs_to_ts[ctb_addr_rs - s->sps->ctb_width]];
horiz_edge[3] = horiz_edge[2]; horiz_edge[0] = (!lfase && CTB(s->tab_slice_address, x_ctb, y_ctb) != CTB(s->tab_slice_address, x_ctb, y_ctb - 1)) || up_tile_edge;
diag_edge[0] = (!lfase[0] && CTB(s->tab_slice_address, x_ctb, y_ctb) != CTB(s->tab_slice_address, x_ctb - 1, y_ctb - 1)) || left_tile_edge || up_tile_edge; }
diag_edge[3] = diag_edge[0]; if (!edges[3]) {
bottom_tile_edge = no_tile_filter && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[s->pps->ctb_addr_rs_to_ts[ctb_addr_rs + s->sps->ctb_width]];
// Does left CTB comes after above CTB? horiz_edge[1] = (!lfase && CTB(s->tab_slice_address, x_ctb, y_ctb) != CTB(s->tab_slice_address, x_ctb, y_ctb + 1)) || bottom_tile_edge;
if (CTB(s->tab_slice_address, x_ctb - 1, y_ctb) > }
CTB(s->tab_slice_address, x_ctb, y_ctb - 1)) { if (!edges[0] && !edges[1]) {
diag_edge[2] = !lfase[2] || left_tile_edge || up_tile_edge; diag_edge[0] = (!lfase && CTB(s->tab_slice_address, x_ctb, y_ctb) != CTB(s->tab_slice_address, x_ctb - 1, y_ctb - 1)) || left_tile_edge || up_tile_edge;
diag_edge[1] = diag_edge[2]; }
} else if (CTB(s->tab_slice_address, x_ctb - 1, y_ctb) < if (!edges[1] && !edges[2]) {
CTB(s->tab_slice_address, x_ctb, y_ctb - 1)) { diag_edge[1] = (!lfase && CTB(s->tab_slice_address, x_ctb, y_ctb) != CTB(s->tab_slice_address, x_ctb + 1, y_ctb - 1)) || right_tile_edge || up_tile_edge;
diag_edge[1] = !lfase[1] || left_tile_edge || up_tile_edge; }
diag_edge[2] = diag_edge[1]; if (!edges[2] && !edges[3]) {
} else { diag_edge[2] = (!lfase && CTB(s->tab_slice_address, x_ctb, y_ctb) != CTB(s->tab_slice_address, x_ctb + 1, y_ctb + 1)) || right_tile_edge || bottom_tile_edge;
// Same slice, only consider tiles }
diag_edge[2] = left_tile_edge || up_tile_edge; if (!edges[0] && !edges[3]) {
diag_edge[1] = diag_edge[2]; diag_edge[3] = (!lfase && CTB(s->tab_slice_address, x_ctb, y_ctb) != CTB(s->tab_slice_address, x_ctb - 1, y_ctb + 1)) || left_tile_edge || bottom_tile_edge;
}
} }
} }
for (c_idx = 0; c_idx < 3; c_idx++) { for (c_idx = 0; c_idx < 3; c_idx++) {
int chroma = c_idx ? 1 : 0; int x0 = x >> s->sps->hshift[c_idx];
int x0 = x >> chroma; int y0 = y >> s->sps->vshift[c_idx];
int y0 = y >> chroma; int stride = s->frame->linesize[c_idx];
int stride = s->frame->linesize[c_idx]; int ctb_size_h = (1 << (s->sps->log2_ctb_size)) >> s->sps->hshift[c_idx];
int ctb_size = (1 << (s->sps->log2_ctb_size)) >> s->sps->hshift[c_idx]; int ctb_size_v = (1 << (s->sps->log2_ctb_size)) >> s->sps->vshift[c_idx];
int width = FFMIN(ctb_size, int width = FFMIN(ctb_size_h,
(s->sps->width >> s->sps->hshift[c_idx]) - x0); (s->sps->width >> s->sps->hshift[c_idx]) - x0);
int height = FFMIN(ctb_size, int height = FFMIN(ctb_size_v,
(s->sps->height >> s->sps->vshift[c_idx]) - y0); (s->sps->height >> s->sps->vshift[c_idx]) - y0);
uint8_t *src = &s->frame->data[c_idx][y0 * stride + (x0 << s->sps->pixel_shift)]; uint8_t *src = &s->frame->data[c_idx][y0 * stride + (x0 << s->sps->pixel_shift)];
uint8_t *dst = &s->sao_frame->data[c_idx][y0 * stride + (x0 << s->sps->pixel_shift)]; uint8_t *dst = &s->sao_frame->data[c_idx][y0 * stride + (x0 << s->sps->pixel_shift)];
int offset = (y_shift >> chroma) * stride + ((x_shift >> chroma) << s->sps->pixel_shift);
switch (sao->type_idx[c_idx]) {
copy_CTB(dst - offset, src - offset, case SAO_BAND:
(edges[2] ? width + (x_shift >> chroma) : width) << s->sps->pixel_shift, s->hevcdsp.sao_band_filter(dst, src,
(edges[3] ? height + (y_shift >> chroma) : height), stride); stride,
sao,
for (class_index = 0; class_index < class; class_index++) { edges, width,
height, c_idx);
switch (sao[class_index]->type_idx[c_idx]) { break;
case SAO_BAND: case SAO_EDGE:
s->hevcdsp.sao_band_filter[classes[class_index]](dst, src, s->hevcdsp.sao_edge_filter[restore](dst, src,
stride, stride,
sao[class_index], sao,
edges, width, edges, width,
height, c_idx); height, c_idx,
break; vert_edge,
case SAO_EDGE: horiz_edge,
s->hevcdsp.sao_edge_filter[classes[class_index]](dst, src, diag_edge);
stride, break;
sao[class_index], default :
edges, width, copy_CTB(dst, src, width << s->sps->pixel_shift, height, stride);
height, c_idx, break;
vert_edge[classes[class_index]],
horiz_edge[classes[class_index]],
diag_edge[classes[class_index]]);
break;
}
} }
} }
} }
@ -661,22 +629,41 @@ void ff_hevc_deblocking_boundary_strengths(HEVCContext *s, int x0, int y0,
#undef CB #undef CB
#undef CR #undef CR
void ff_hevc_hls_filter(HEVCContext *s, int x, int y) void ff_hevc_hls_filter(HEVCContext *s, int x, int y, int ctb_size)
{ {
deblocking_filter_CTB(s, x, y); deblocking_filter_CTB(s, x, y);
if (s->sps->sao_enabled) if (s->sps->sao_enabled) {
sao_filter_CTB(s, x, y); int x_end = x >= s->sps->width - ctb_size;
int y_end = y >= s->sps->height - ctb_size;
if (y && x)
sao_filter_CTB(s, x - ctb_size, y - ctb_size);
if (x && y_end)
sao_filter_CTB(s, x - ctb_size, y);
if (y && x_end) {
sao_filter_CTB(s, x, y - ctb_size);
if (s->threads_type & FF_THREAD_FRAME )
ff_thread_report_progress(&s->ref->tf, y - ctb_size, 0);
}
if (x_end && y_end) {
sao_filter_CTB(s, x , y);
if (s->threads_type & FF_THREAD_FRAME )
ff_thread_report_progress(&s->ref->tf, y, 0);
}
} else {
if (y && x >= s->sps->width - ctb_size)
if (s->threads_type & FF_THREAD_FRAME )
ff_thread_report_progress(&s->ref->tf, y, 0);
}
} }
void ff_hevc_hls_filters(HEVCContext *s, int x_ctb, int y_ctb, int ctb_size) void ff_hevc_hls_filters(HEVCContext *s, int x_ctb, int y_ctb, int ctb_size)
{ {
int x_end = x_ctb >= s->sps->width - ctb_size;
int y_end = y_ctb >= s->sps->height - ctb_size;
if (y_ctb && x_ctb) if (y_ctb && x_ctb)
ff_hevc_hls_filter(s, x_ctb - ctb_size, y_ctb - ctb_size); ff_hevc_hls_filter(s, x_ctb - ctb_size, y_ctb - ctb_size, ctb_size);
if (y_ctb && x_ctb >= s->sps->width - ctb_size) { if (y_ctb && x_end)
ff_hevc_hls_filter(s, x_ctb, y_ctb - ctb_size); ff_hevc_hls_filter(s, x_ctb, y_ctb - ctb_size, ctb_size);
if (s->threads_type == FF_THREAD_FRAME ) if (x_ctb && y_end)
ff_thread_report_progress(&s->ref->tf, y_ctb - ctb_size, 0); ff_hevc_hls_filter(s, x_ctb - ctb_size, y_ctb, ctb_size);
}
if (x_ctb && y_ctb >= s->sps->height - ctb_size)
ff_hevc_hls_filter(s, x_ctb - ctb_size, y_ctb);
} }

12
libavcodec/hevcdsp.c
Unescape View File

@ -207,15 +207,9 @@ void ff_hevc_dsp_init(HEVCDSPContext *hevcdsp, int bit_depth)
hevcdsp->transform_dc_add[2] = FUNC(transform_16x16_dc_add, depth); \ hevcdsp->transform_dc_add[2] = FUNC(transform_16x16_dc_add, depth); \
hevcdsp->transform_dc_add[3] = FUNC(transform_32x32_dc_add, depth); \ hevcdsp->transform_dc_add[3] = FUNC(transform_32x32_dc_add, depth); \
\ \
hevcdsp->sao_band_filter[0] = FUNC(sao_band_filter_0, depth); \ hevcdsp->sao_band_filter = FUNC(sao_band_filter_0, depth); \
hevcdsp->sao_band_filter[1] = FUNC(sao_band_filter_1, depth); \ hevcdsp->sao_edge_filter[0] = FUNC(sao_edge_filter_0, depth); \
hevcdsp->sao_band_filter[2] = FUNC(sao_band_filter_2, depth); \ hevcdsp->sao_edge_filter[1] = FUNC(sao_edge_filter_1, depth); \
hevcdsp->sao_band_filter[3] = FUNC(sao_band_filter_3, depth); \
\
hevcdsp->sao_edge_filter[0] = FUNC(sao_edge_filter_0, depth); \
hevcdsp->sao_edge_filter[1] = FUNC(sao_edge_filter_1, depth); \
hevcdsp->sao_edge_filter[2] = FUNC(sao_edge_filter_2, depth); \
hevcdsp->sao_edge_filter[3] = FUNC(sao_edge_filter_3, depth); \
\ \
QPEL_FUNCS(depth); \ QPEL_FUNCS(depth); \
QPEL_UNI_FUNCS(depth); \ QPEL_UNI_FUNCS(depth); \

15
libavcodec/hevcdsp.h
Unescape View File

@ -54,13 +54,14 @@ typedef struct HEVCDSPContext {
void (*transform_dc_add[4])(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride); void (*transform_dc_add[4])(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride);
void (*sao_band_filter[4])(uint8_t *dst, uint8_t *src, ptrdiff_t stride, void (*sao_band_filter)(uint8_t *_dst, uint8_t *_src, ptrdiff_t _stride,
struct SAOParams *sao, int *borders, struct SAOParams *sao, int *borders,
int width, int height, int c_idx); int width, int height, int c_idx);
void (*sao_edge_filter[4])(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
struct SAOParams *sao, int *borders, int width, void (*sao_edge_filter[2])(uint8_t *_dst, uint8_t *_src, ptrdiff_t _stride,
int height, int c_idx, uint8_t vert_edge, struct SAOParams *sao, int *borders, int _width,
uint8_t horiz_edge, uint8_t diag_edge); int _height, int c_idx, uint8_t *vert_edge,
uint8_t *horiz_edge, uint8_t *diag_edge);
void (*put_hevc_qpel[10][2][2])(int16_t *dst, ptrdiff_t dststride, uint8_t *src, ptrdiff_t srcstride, void (*put_hevc_qpel[10][2][2])(int16_t *dst, ptrdiff_t dststride, uint8_t *src, ptrdiff_t srcstride,
int height, intptr_t mx, intptr_t my, int width); int height, intptr_t mx, intptr_t my, int width);

389
libavcodec/hevcdsp_template.c
Unescape View File

@ -294,133 +294,87 @@ TRANSFORM_DC_ADD( 8)
TRANSFORM_DC_ADD(16) TRANSFORM_DC_ADD(16)
TRANSFORM_DC_ADD(32) TRANSFORM_DC_ADD(32)
static void FUNC(sao_band_filter_0)(uint8_t *_dst, uint8_t *_src,
static void FUNC(sao_band_filter)(uint8_t *_dst, uint8_t *_src,
ptrdiff_t stride, SAOParams *sao, ptrdiff_t stride, SAOParams *sao,
int *borders, int width, int height, int *borders, int width, int height,
int c_idx, int class) int c_idx)
{ {
pixel *dst = (pixel *)_dst; pixel *dst = (pixel *)_dst;
pixel *src = (pixel *)_src; pixel *src = (pixel *)_src;
int offset_table[32] = { 0 }; int offset_table[32] = { 0 };
int k, y, x; int k, y, x;
int chroma = !!c_idx;
int shift = BIT_DEPTH - 5; int shift = BIT_DEPTH - 5;
int *sao_offset_val = sao->offset_val[c_idx]; int *sao_offset_val = sao->offset_val[c_idx];
int sao_left_class = sao->band_position[c_idx]; int sao_left_class = sao->band_position[c_idx];
int init_y = 0, init_x = 0;
stride /= sizeof(pixel); stride /= sizeof(pixel);
switch (class) {
case 0:
if (!borders[2])
width -= (8 >> chroma) + 2;
if (!borders[3])
height -= (4 >> chroma) + 2;
break;
case 1:
init_y = -(4 >> chroma) - 2;
if (!borders[2])
width -= (8 >> chroma) + 2;
height = (4 >> chroma) + 2;
break;
case 2:
init_x = -(8 >> chroma) - 2;
width = (8 >> chroma) + 2;
if (!borders[3])
height -= (4 >> chroma) + 2;
break;
case 3:
init_y = -(4 >> chroma) - 2;
init_x = -(8 >> chroma) - 2;
width = (8 >> chroma) + 2;
height = (4 >> chroma) + 2;
break;
}
dst = dst + (init_y * stride + init_x);
src = src + (init_y * stride + init_x);
for (k = 0; k < 4; k++) for (k = 0; k < 4; k++)
offset_table[(k + sao_left_class) & 31] = sao_offset_val[k + 1]; offset_table[(k + sao_left_class) & 31] = sao_offset_val[k + 1];
for (y = 0; y < height; y++) { for (y = 0; y < height; y++) {
for (x = 0; x < width; x++) for (x = 0; x < width; x++)
dst[x] = av_clip_pixel(src[x] + offset_table[src[x] >> shift]); dst[x] = av_clip_pixel(src[x] + offset_table[av_clip_pixel(src[x] >> shift)]);
dst += stride; dst += stride;
src += stride; src += stride;
} }
} }
static void FUNC(sao_band_filter_0)(uint8_t *dst, uint8_t *src, #define CMP(a, b) ((a) > (b) ? 1 : ((a) == (b) ? 0 : -1))
ptrdiff_t stride, SAOParams *sao,
int *borders, int width, int height,
int c_idx)
{
FUNC(sao_band_filter)(dst, src, stride, sao, borders,
width, height, c_idx, 0);
}
static void FUNC(sao_band_filter_1)(uint8_t *dst, uint8_t *src, static void FUNC(sao_edge_filter)(uint8_t *_dst, uint8_t *_src,
ptrdiff_t stride, SAOParams *sao, ptrdiff_t stride, SAOParams *sao,
int *borders, int width, int height, int width, int height,
int c_idx) int c_idx, int init_x, int init_y) {
{
FUNC(sao_band_filter)(dst, src, stride, sao, borders,
width, height, c_idx, 1);
}
static void FUNC(sao_band_filter_2)(uint8_t *dst, uint8_t *src, static const uint8_t edge_idx[] = { 1, 2, 0, 3, 4 };
ptrdiff_t stride, SAOParams *sao, static const int8_t pos[4][2][2] = {
int *borders, int width, int height, { { -1, 0 }, { 1, 0 } }, // horizontal
int c_idx) { { 0, -1 }, { 0, 1 } }, // vertical
{ { { -1, -1 }, { 1, 1 } }, // 45 degree
FUNC(sao_band_filter)(dst, src, stride, sao, borders, { { 1, -1 }, { -1, 1 } }, // 135 degree
width, height, c_idx, 2); };
} int *sao_offset_val = sao->offset_val[c_idx];
int sao_eo_class = sao->eo_class[c_idx];
pixel *dst = (pixel *)_dst;
pixel *src = (pixel *)_src;
static void FUNC(sao_band_filter_3)(uint8_t *_dst, uint8_t *_src, int y_stride = init_y * stride;
ptrdiff_t stride, SAOParams *sao, int pos_0_0 = pos[sao_eo_class][0][0];
int *borders, int width, int height, int pos_0_1 = pos[sao_eo_class][0][1];
int c_idx) int pos_1_0 = pos[sao_eo_class][1][0];
{ int pos_1_1 = pos[sao_eo_class][1][1];
FUNC(sao_band_filter)(_dst, _src, stride, sao, borders, int x, y;
width, height, c_idx, 3);
int y_stride_0_1 = (init_y + pos_0_1) * stride;
int y_stride_1_1 = (init_y + pos_1_1) * stride;
for (y = init_y; y < height; y++) {
for (x = init_x; x < width; x++) {
int diff0 = CMP(src[x + y_stride], src[x + pos_0_0 + y_stride_0_1]);
int diff1 = CMP(src[x + y_stride], src[x + pos_1_0 + y_stride_1_1]);
int offset_val = edge_idx[2 + diff0 + diff1];
dst[x + y_stride] = av_clip_pixel(src[x + y_stride] + sao_offset_val[offset_val]);
}
y_stride += stride;
y_stride_0_1 += stride;
y_stride_1_1 += stride;
}
} }
static void FUNC(sao_edge_filter_0)(uint8_t *_dst, uint8_t *_src, static void FUNC(sao_edge_filter_0)(uint8_t *_dst, uint8_t *_src,
ptrdiff_t stride, SAOParams *sao, ptrdiff_t stride, SAOParams *sao,
int *borders, int _width, int _height, int *borders, int _width, int _height,
int c_idx, uint8_t vert_edge, int c_idx, uint8_t *vert_edge,
uint8_t horiz_edge, uint8_t diag_edge) uint8_t *horiz_edge, uint8_t *diag_edge)
{ {
int x, y; int x, y;
pixel *dst = (pixel *)_dst; pixel *dst = (pixel *)_dst;
pixel *src = (pixel *)_src; pixel *src = (pixel *)_src;
int chroma = !!c_idx;
int *sao_offset_val = sao->offset_val[c_idx]; int *sao_offset_val = sao->offset_val[c_idx];
int sao_eo_class = sao->eo_class[c_idx]; int sao_eo_class = sao->eo_class[c_idx];
int init_x = 0, init_y = 0, width = _width, height = _height; int init_x = 0, init_y = 0, width = _width, height = _height;
static const int8_t pos[4][2][2] = {
{ { -1, 0 }, { 1, 0 } }, // horizontal
{ { 0, -1 }, { 0, 1 } }, // vertical
{ { -1, -1 }, { 1, 1 } }, // 45 degree
{ { 1, -1 }, { -1, 1 } }, // 135 degree
};
static const uint8_t edge_idx[] = { 1, 2, 0, 3, 4 };
#define CMP(a, b) ((a) > (b) ? 1 : ((a) == (b) ? 0 : -1))
stride /= sizeof(pixel); stride /= sizeof(pixel);
if (!borders[2])
width -= (8 >> chroma) + 2;
if (!borders[3])
height -= (4 >> chroma) + 2;
dst = dst + (init_y * stride + init_x);
src = src + (init_y * stride + init_x);
init_y = init_x = 0;
if (sao_eo_class != SAO_EO_VERT) { if (sao_eo_class != SAO_EO_VERT) {
if (borders[0]) { if (borders[0]) {
int offset_val = sao_offset_val[0]; int offset_val = sao_offset_val[0];
@ -456,78 +410,25 @@ static void FUNC(sao_edge_filter_0)(uint8_t *_dst, uint8_t *_src,
height--; height--;
} }
} }
{
int y_stride = init_y * stride;
int pos_0_0 = pos[sao_eo_class][0][0];
int pos_0_1 = pos[sao_eo_class][0][1];
int pos_1_0 = pos[sao_eo_class][1][0];
int pos_1_1 = pos[sao_eo_class][1][1];
int y_stride_0_1 = (init_y + pos_0_1) * stride;
int y_stride_1_1 = (init_y + pos_1_1) * stride;
for (y = init_y; y < height; y++) {
for (x = init_x; x < width; x++) {
int diff0 = CMP(src[x + y_stride], src[x + pos_0_0 + y_stride_0_1]);
int diff1 = CMP(src[x + y_stride], src[x + pos_1_0 + y_stride_1_1]);
int offset_val = edge_idx[2 + diff0 + diff1];
dst[x + y_stride] = av_clip_pixel(src[x + y_stride] + sao_offset_val[offset_val]);
}
y_stride += stride;
y_stride_0_1 += stride;
y_stride_1_1 += stride;
}
}
{ FUNC(sao_edge_filter)((uint8_t *)dst, (uint8_t *)src, stride, sao, width, height, c_idx, init_x, init_y);
// Restore pixels that can't be modified
int save_upper_left = !diag_edge && sao_eo_class == SAO_EO_135D && !borders[0] && !borders[1];
if (vert_edge && sao_eo_class != SAO_EO_VERT)
for (y = init_y+save_upper_left; y< height; y++)
dst[y*stride] = src[y*stride];
if(horiz_edge && sao_eo_class != SAO_EO_HORIZ)
for(x = init_x+save_upper_left; x<width; x++)
dst[x] = src[x];
if(diag_edge && sao_eo_class == SAO_EO_135D)
dst[0] = src[0];
}
#undef CMP
} }
static void FUNC(sao_edge_filter_1)(uint8_t *_dst, uint8_t *_src, static void FUNC(sao_edge_filter_1)(uint8_t *_dst, uint8_t *_src,
ptrdiff_t stride, SAOParams *sao, ptrdiff_t stride, SAOParams *sao,
int *borders, int _width, int _height, int *borders, int _width, int _height,
int c_idx, uint8_t vert_edge, int c_idx, uint8_t *vert_edge,
uint8_t horiz_edge, uint8_t diag_edge) uint8_t *horiz_edge, uint8_t *diag_edge)
{ {
int x, y; int x, y;
pixel *dst = (pixel *)_dst; pixel *dst = (pixel *)_dst;
pixel *src = (pixel *)_src; pixel *src = (pixel *)_src;
int chroma = !!c_idx;
int *sao_offset_val = sao->offset_val[c_idx]; int *sao_offset_val = sao->offset_val[c_idx];
int sao_eo_class = sao->eo_class[c_idx]; int sao_eo_class = sao->eo_class[c_idx];
int init_x = 0, init_y = 0, width = _width, height = _height; int init_x = 0, init_y = 0, width = _width, height = _height;
static const int8_t pos[4][2][2] = {
{ { -1, 0 }, { 1, 0 } }, // horizontal
{ { 0, -1 }, { 0, 1 } }, // vertical
{ { -1, -1 }, { 1, 1 } }, // 45 degree
{ { 1, -1 }, { -1, 1 } }, // 135 degree
};
static const uint8_t edge_idx[] = { 1, 2, 0, 3, 4 };
#define CMP(a, b) ((a) > (b) ? 1 : ((a) == (b) ? 0 : -1))
stride /= sizeof(pixel); stride /= sizeof(pixel);
init_y = -(4 >> chroma) - 2;
if (!borders[2])
width -= (8 >> chroma) + 2;
height = (4 >> chroma) + 2;
dst = dst + (init_y * stride + init_x);
src = src + (init_y * stride + init_x);
init_y = init_x = 0;
if (sao_eo_class != SAO_EO_VERT) { if (sao_eo_class != SAO_EO_VERT) {
if (borders[0]) { if (borders[0]) {
int offset_val = sao_offset_val[0]; int offset_val = sao_offset_val[0];
@ -548,78 +449,6 @@ static void FUNC(sao_edge_filter_1)(uint8_t *_dst, uint8_t *_src,
width--; width--;
} }
} }
{
int y_stride = init_y * stride;
int pos_0_0 = pos[sao_eo_class][0][0];
int pos_0_1 = pos[sao_eo_class][0][1];
int pos_1_0 = pos[sao_eo_class][1][0];
int pos_1_1 = pos[sao_eo_class][1][1];
int y_stride_0_1 = (init_y + pos_0_1) * stride;
int y_stride_1_1 = (init_y + pos_1_1) * stride;
for (y = init_y; y < height; y++) {
for (x = init_x; x < width; x++) {
int diff0 = CMP(src[x + y_stride], src[x + pos_0_0 + y_stride_0_1]);
int diff1 = CMP(src[x + y_stride], src[x + pos_1_0 + y_stride_1_1]);
int offset_val = edge_idx[2 + diff0 + diff1];
dst[x + y_stride] = av_clip_pixel(src[x + y_stride] + sao_offset_val[offset_val]);
}
y_stride += stride;
y_stride_0_1 += stride;
y_stride_1_1 += stride;
}
}
{
// Restore pixels that can't be modified
int save_lower_left = !diag_edge && sao_eo_class == SAO_EO_45D && !borders[0];
if(vert_edge && sao_eo_class != SAO_EO_VERT)
for(y = init_y; y< height-save_lower_left; y++)
dst[y*stride] = src[y*stride];
if(horiz_edge && sao_eo_class != SAO_EO_HORIZ)
for(x = init_x+save_lower_left; x<width; x++)
dst[(height-1)*stride+x] = src[(height-1)*stride+x];
if(diag_edge && sao_eo_class == SAO_EO_45D)
dst[stride*(height-1)] = src[stride*(height-1)];
}
#undef CMP
}
static void FUNC(sao_edge_filter_2)(uint8_t *_dst, uint8_t *_src,
ptrdiff_t stride, SAOParams *sao,
int *borders, int _width, int _height,
int c_idx, uint8_t vert_edge,
uint8_t horiz_edge, uint8_t diag_edge)
{
int x, y;
pixel *dst = (pixel *)_dst;
pixel *src = (pixel *)_src;
int chroma = !!c_idx;
int *sao_offset_val = sao->offset_val[c_idx];
int sao_eo_class = sao->eo_class[c_idx];
int init_x = 0, init_y = 0, width = _width, height = _height;
static const int8_t pos[4][2][2] = {
{ { -1, 0 }, { 1, 0 } }, // horizontal
{ { 0, -1 }, { 0, 1 } }, // vertical
{ { -1, -1 }, { 1, 1 } }, // 45 degree
{ { 1, -1 }, { -1, 1 } }, // 135 degree
};
static const uint8_t edge_idx[] = { 1, 2, 0, 3, 4 };
#define CMP(a, b) ((a) > (b) ? 1 : ((a) == (b) ? 0 : -1))
stride /= sizeof(pixel);
init_x = -(8 >> chroma) - 2;
width = (8 >> chroma) + 2;
if (!borders[3])
height -= (4 >> chroma) + 2;
dst = dst + (init_y * stride + init_x);
src = src + (init_y * stride + init_x);
init_y = init_x = 0;
if (sao_eo_class != SAO_EO_HORIZ) { if (sao_eo_class != SAO_EO_HORIZ) {
if (borders[1]) { if (borders[1]) {
int offset_val = sao_offset_val[0]; int offset_val = sao_offset_val[0];
@ -635,117 +464,47 @@ static void FUNC(sao_edge_filter_2)(uint8_t *_dst, uint8_t *_src,
height--; height--;
} }
} }
{
int y_stride = init_y * stride;
int pos_0_0 = pos[sao_eo_class][0][0];
int pos_0_1 = pos[sao_eo_class][0][1];
int pos_1_0 = pos[sao_eo_class][1][0];
int pos_1_1 = pos[sao_eo_class][1][1];
int y_stride_0_1 = (init_y + pos_0_1) * stride;
int y_stride_1_1 = (init_y + pos_1_1) * stride;
for (y = init_y; y < height; y++) {
for (x = init_x; x < width; x++) {
int diff0 = CMP(src[x + y_stride], src[x + pos_0_0 + y_stride_0_1]);
int diff1 = CMP(src[x + y_stride], src[x + pos_1_0 + y_stride_1_1]);
int offset_val = edge_idx[2 + diff0 + diff1];
dst[x + y_stride] = av_clip_pixel(src[x + y_stride] + sao_offset_val[offset_val]);
}
y_stride += stride;
y_stride_0_1 += stride;
y_stride_1_1 += stride;
}
}
{ FUNC(sao_edge_filter)((uint8_t *)dst, (uint8_t *)src, stride, sao, width, height, c_idx, init_x, init_y);
// Restore pixels that can't be modified
int save_upper_right = !diag_edge && sao_eo_class == SAO_EO_45D && !borders[1];
if(vert_edge && sao_eo_class != SAO_EO_VERT)
for(y = init_y+save_upper_right; y< height; y++)
dst[y*stride+width-1] = src[y*stride+width-1];
if(horiz_edge && sao_eo_class != SAO_EO_HORIZ)
for(x = init_x; x<width-save_upper_right; x++)
dst[x] = src[x];
if(diag_edge && sao_eo_class == SAO_EO_45D)
dst[width-1] = src[width-1];
}
#undef CMP
}
static void FUNC(sao_edge_filter_3)(uint8_t *_dst, uint8_t *_src,
ptrdiff_t stride, SAOParams *sao,
int *borders, int _width, int _height,
int c_idx, uint8_t vert_edge,
uint8_t horiz_edge, uint8_t diag_edge)
{
int x, y;
pixel *dst = (pixel *)_dst;
pixel *src = (pixel *)_src;
int chroma = !!c_idx;
int *sao_offset_val = sao->offset_val[c_idx];
int sao_eo_class = sao->eo_class[c_idx];
int init_x = 0, init_y = 0, width = _width, height = _height;
static const int8_t pos[4][2][2] = {
{ { -1, 0 }, { 1, 0 } }, // horizontal
{ { 0, -1 }, { 0, 1 } }, // vertical
{ { -1, -1 }, { 1, 1 } }, // 45 degree
{ { 1, -1 }, { -1, 1 } }, // 135 degree
};
static const uint8_t edge_idx[] = { 1, 2, 0, 3, 4 };
#define CMP(a, b) ((a) > (b) ? 1 : ((a) == (b) ? 0 : -1))
stride /= sizeof(pixel);
init_y = -(4 >> chroma) - 2;
init_x = -(8 >> chroma) - 2;
width = (8 >> chroma) + 2;
height = (4 >> chroma) + 2;
dst = dst + (init_y * stride + init_x);
src = src + (init_y * stride + init_x);
init_y = init_x = 0;
{ {
int y_stride = init_y * stride; int save_upper_left = !diag_edge[0] && sao_eo_class == SAO_EO_135D && !borders[0] && !borders[1];
int pos_0_0 = pos[sao_eo_class][0][0]; int save_upper_right = !diag_edge[1] && sao_eo_class == SAO_EO_45D && !borders[1] && !borders[2];
int pos_0_1 = pos[sao_eo_class][0][1]; int save_lower_right = !diag_edge[2] && sao_eo_class == SAO_EO_135D && !borders[2] && !borders[3];
int pos_1_0 = pos[sao_eo_class][1][0]; int save_lower_left = !diag_edge[3] && sao_eo_class == SAO_EO_45D && !borders[0] && !borders[3];
int pos_1_1 = pos[sao_eo_class][1][1];
int y_stride_0_1 = (init_y + pos_0_1) * stride;
int y_stride_1_1 = (init_y + pos_1_1) * stride;
for (y = init_y; y < height; y++) {
for (x = init_x; x < width; x++) {
int diff0 = CMP(src[x + y_stride], src[x + pos_0_0 + y_stride_0_1]);
int diff1 = CMP(src[x + y_stride], src[x + pos_1_0 + y_stride_1_1]);
int offset_val = edge_idx[2 + diff0 + diff1];
dst[x + y_stride] = av_clip_pixel(src[x + y_stride] + sao_offset_val[offset_val]);
}
y_stride += stride;
y_stride_0_1 += stride;
y_stride_1_1 += stride;
}
}
{
// Restore pixels that can't be modified // Restore pixels that can't be modified
int save_lower_right = !diag_edge && sao_eo_class == SAO_EO_135D; if(vert_edge[0] && sao_eo_class != SAO_EO_VERT) {
if(vert_edge && sao_eo_class != SAO_EO_VERT) for(y = init_y+save_upper_left; y< height-save_lower_left; y++)
for(y = init_y; y< height-save_lower_right; y++) dst[y*stride] = src[y*stride];
}
if(vert_edge[1] && sao_eo_class != SAO_EO_VERT) {
for(y = init_y+save_upper_right; y< height-save_lower_right; y++)
dst[y*stride+width-1] = src[y*stride+width-1]; dst[y*stride+width-1] = src[y*stride+width-1];
if(horiz_edge && sao_eo_class != SAO_EO_HORIZ) }
for(x = init_x; x<width-save_lower_right; x++)
if(horiz_edge[0] && sao_eo_class != SAO_EO_HORIZ) {
for(x = init_x+save_upper_left; x < width-save_upper_right; x++)
dst[x] = src[x];
}
if(horiz_edge[1] && sao_eo_class != SAO_EO_HORIZ) {
for(x = init_x+save_lower_left; x < width-save_lower_right; x++)
dst[(height-1)*stride+x] = src[(height-1)*stride+x]; dst[(height-1)*stride+x] = src[(height-1)*stride+x];
if(diag_edge && sao_eo_class == SAO_EO_135D) }
if(diag_edge[0] && sao_eo_class == SAO_EO_135D)
dst[0] = src[0];
if(diag_edge[1] && sao_eo_class == SAO_EO_45D)
dst[width-1] = src[width-1];
if(diag_edge[2] && sao_eo_class == SAO_EO_135D)
dst[stride*(height-1)+width-1] = src[stride*(height-1)+width-1]; dst[stride*(height-1)+width-1] = src[stride*(height-1)+width-1];
if(diag_edge[3] && sao_eo_class == SAO_EO_45D)
dst[stride*(height-1)] = src[stride*(height-1)];
} }
#undef CMP
} }
#undef CMP
#undef SET #undef SET
#undef SCALE #undef SCALE
#undef ADD_AND_SCALE #undef ADD_AND_SCALE

Write Preview
Loading…
Cancel
Save