Source code
Revision control
Copy as Markdown
Other Tools
/*
* Copyright © 2018, Niklas Haas
* Copyright © 2018, VideoLAN and dav1d authors
* Copyright © 2018, Two Orioles, LLC
* Copyright © 2021, Martin Storsjo
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "src/cpu.h"
#include "src/filmgrain.h"
#include "asm-offsets.h"
CHECK_OFFSET(Dav1dFilmGrainData, seed, FGD_SEED);
CHECK_OFFSET(Dav1dFilmGrainData, ar_coeff_lag, FGD_AR_COEFF_LAG);
CHECK_OFFSET(Dav1dFilmGrainData, ar_coeffs_y, FGD_AR_COEFFS_Y);
CHECK_OFFSET(Dav1dFilmGrainData, ar_coeffs_uv, FGD_AR_COEFFS_UV);
CHECK_OFFSET(Dav1dFilmGrainData, ar_coeff_shift, FGD_AR_COEFF_SHIFT);
CHECK_OFFSET(Dav1dFilmGrainData, grain_scale_shift, FGD_GRAIN_SCALE_SHIFT);
CHECK_OFFSET(Dav1dFilmGrainData, scaling_shift, FGD_SCALING_SHIFT);
CHECK_OFFSET(Dav1dFilmGrainData, uv_mult, FGD_UV_MULT);
CHECK_OFFSET(Dav1dFilmGrainData, uv_luma_mult, FGD_UV_LUMA_MULT);
CHECK_OFFSET(Dav1dFilmGrainData, uv_offset, FGD_UV_OFFSET);
CHECK_OFFSET(Dav1dFilmGrainData, clip_to_restricted_range, FGD_CLIP_TO_RESTRICTED_RANGE);
void BF(dav1d_generate_grain_y, neon)(entry buf[][GRAIN_WIDTH],
const Dav1dFilmGrainData *const data
HIGHBD_DECL_SUFFIX);
#define GEN_GRAIN_UV(suff) \
void BF(dav1d_generate_grain_uv_ ## suff, neon)(entry buf[][GRAIN_WIDTH], \
const entry buf_y[][GRAIN_WIDTH], \
const Dav1dFilmGrainData *const data, \
const intptr_t uv \
HIGHBD_DECL_SUFFIX)
GEN_GRAIN_UV(420);
GEN_GRAIN_UV(422);
GEN_GRAIN_UV(444);
// Use ptrdiff_t instead of int for the last few parameters, to get the
// same layout of parameters on the stack across platforms.
void BF(dav1d_fgy_32x32, neon)(pixel *const dst,
const pixel *const src,
const ptrdiff_t stride,
const uint8_t scaling[SCALING_SIZE],
const int scaling_shift,
const entry grain_lut[][GRAIN_WIDTH],
const int offsets[][2],
const int h, const ptrdiff_t clip,
const ptrdiff_t type
HIGHBD_DECL_SUFFIX);
static void fgy_32x32xn_neon(pixel *const dst_row, const pixel *const src_row,
const ptrdiff_t stride,
const Dav1dFilmGrainData *const data, const size_t pw,
const uint8_t scaling[SCALING_SIZE],
const entry grain_lut[][GRAIN_WIDTH],
const int bh, const int row_num HIGHBD_DECL_SUFFIX)
{
const int rows = 1 + (data->overlap_flag && row_num > 0);
// seed[0] contains the current row, seed[1] contains the previous
unsigned seed[2];
for (int i = 0; i < rows; i++) {
seed[i] = data->seed;
seed[i] ^= (((row_num - i) * 37 + 178) & 0xFF) << 8;
seed[i] ^= (((row_num - i) * 173 + 105) & 0xFF);
}
int offsets[2 /* col offset */][2 /* row offset */];
// process this row in FG_BLOCK_SIZE^2 blocks
for (unsigned bx = 0; bx < pw; bx += FG_BLOCK_SIZE) {
if (data->overlap_flag && bx) {
// shift previous offsets left
for (int i = 0; i < rows; i++)
offsets[1][i] = offsets[0][i];
}
// update current offsets
for (int i = 0; i < rows; i++)
offsets[0][i] = get_random_number(8, &seed[i]);
int type = 0;
if (data->overlap_flag && row_num)
type |= 1; /* overlap y */
if (data->overlap_flag && bx)
type |= 2; /* overlap x */
BF(dav1d_fgy_32x32, neon)(dst_row + bx, src_row + bx, stride,
scaling, data->scaling_shift,
grain_lut, offsets, bh,
data->clip_to_restricted_range, type
HIGHBD_TAIL_SUFFIX);
}
}
// Use ptrdiff_t instead of int for the last few parameters, to get the
// parameters on the stack with the same layout across platforms.
#define FGUV(nm, sx, sy) \
void BF(dav1d_fguv_32x32_##nm, neon)(pixel *const dst, \
const pixel *const src, \
const ptrdiff_t stride, \
const uint8_t scaling[SCALING_SIZE], \
const Dav1dFilmGrainData *const data, \
const entry grain_lut[][GRAIN_WIDTH], \
const pixel *const luma_row, \
const ptrdiff_t luma_stride, \
const int offsets[][2], \
const ptrdiff_t h, const ptrdiff_t uv, \
const ptrdiff_t is_id, \
const ptrdiff_t type \
HIGHBD_DECL_SUFFIX); \
static void \
fguv_32x32xn_##nm##_neon(pixel *const dst_row, const pixel *const src_row, \
const ptrdiff_t stride, const Dav1dFilmGrainData *const data, \
const size_t pw, const uint8_t scaling[SCALING_SIZE], \
const entry grain_lut[][GRAIN_WIDTH], const int bh, \
const int row_num, const pixel *const luma_row, \
const ptrdiff_t luma_stride, const int uv, const int is_id \
HIGHBD_DECL_SUFFIX) \
{ \
const int rows = 1 + (data->overlap_flag && row_num > 0); \
\
/* seed[0] contains the current row, seed[1] contains the previous */ \
unsigned seed[2]; \
for (int i = 0; i < rows; i++) { \
seed[i] = data->seed; \
seed[i] ^= (((row_num - i) * 37 + 178) & 0xFF) << 8; \
seed[i] ^= (((row_num - i) * 173 + 105) & 0xFF); \
} \
\
int offsets[2 /* col offset */][2 /* row offset */]; \
\
/* process this row in FG_BLOCK_SIZE^2 blocks (subsampled) */ \
for (unsigned bx = 0; bx < pw; bx += FG_BLOCK_SIZE >> sx) { \
if (data->overlap_flag && bx) { \
/* shift previous offsets left */ \
for (int i = 0; i < rows; i++) \
offsets[1][i] = offsets[0][i]; \
} \
\
/* update current offsets */ \
for (int i = 0; i < rows; i++) \
offsets[0][i] = get_random_number(8, &seed[i]); \
\
int type = 0; \
if (data->overlap_flag && row_num) \
type |= 1; /* overlap y */ \
if (data->overlap_flag && bx) \
type |= 2; /* overlap x */ \
if (data->chroma_scaling_from_luma) \
type |= 4; \
\
BF(dav1d_fguv_32x32_##nm, neon)(dst_row + bx, src_row + bx, stride, \
scaling, data, grain_lut, \
luma_row + (bx << sx), luma_stride, \
offsets, bh, uv, is_id, type \
HIGHBD_TAIL_SUFFIX); \
} \
}
FGUV(420, 1, 1);
FGUV(422, 1, 0);
FGUV(444, 0, 0);
static ALWAYS_INLINE void film_grain_dsp_init_arm(Dav1dFilmGrainDSPContext *const c) {
const unsigned flags = dav1d_get_cpu_flags();
if (!(flags & DAV1D_ARM_CPU_FLAG_NEON)) return;
c->generate_grain_y = BF(dav1d_generate_grain_y, neon);
c->generate_grain_uv[DAV1D_PIXEL_LAYOUT_I420 - 1] = BF(dav1d_generate_grain_uv_420, neon);
c->generate_grain_uv[DAV1D_PIXEL_LAYOUT_I422 - 1] = BF(dav1d_generate_grain_uv_422, neon);
c->generate_grain_uv[DAV1D_PIXEL_LAYOUT_I444 - 1] = BF(dav1d_generate_grain_uv_444, neon);
c->fgy_32x32xn = fgy_32x32xn_neon;
c->fguv_32x32xn[DAV1D_PIXEL_LAYOUT_I420 - 1] = fguv_32x32xn_420_neon;
c->fguv_32x32xn[DAV1D_PIXEL_LAYOUT_I422 - 1] = fguv_32x32xn_422_neon;
c->fguv_32x32xn[DAV1D_PIXEL_LAYOUT_I444 - 1] = fguv_32x32xn_444_neon;
}