47 #define MAX_NB_THREADS 32 118 int y,
int x,
int block_size,
float *
dst);
123 int plane,
int nb_jobs);
127 int y,
int x,
int plane,
int jobnr);
130 #define OFFSET(x) offsetof(BM3DContext, x) 131 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM 133 {
"sigma",
"set denoising strength",
135 {
"block",
"set log2(size) of local patch",
137 {
"bstep",
"set sliding step for processing blocks",
139 {
"group",
"set maximal number of similar blocks",
141 {
"range",
"set block matching range",
143 {
"mstep",
"set step for block matching",
145 {
"thmse",
"set threshold of mean square error for block matching",
147 {
"hdthr",
"set hard threshold for 3D transfer domain",
149 {
"estim",
"set filtering estimation mode",
151 {
"basic",
"basic estimate",
153 {
"final",
"final estimate",
155 {
"ref",
"have reference stream",
157 {
"planes",
"set planes to filter",
202 search_range = search_range / search_step * search_step;
204 if (pos == plane_boundary) {
205 search_boundary = plane_boundary;
206 }
else if (pos > plane_boundary) {
207 search_boundary = pos - search_range;
209 while (search_boundary < plane_boundary) {
210 search_boundary += search_step;
213 search_boundary = pos + search_range;
215 while (search_boundary > plane_boundary) {
216 search_boundary -= search_step;
223 static int search_boundary(
int plane_boundary,
int search_range,
int search_step,
int vertical,
int y,
int x)
225 return do_search_boundary(vertical ? y : x, plane_boundary, search_range, search_step);
237 const uint8_t *srcp = src + pos->
y * src_stride + pos->
x;
238 const uint8_t *refp = src + r_y * src_stride + r_x;
243 for (y = 0; y < block_size; y++) {
244 for (x = 0; x < block_size; x++) {
245 double temp = refp[
x] - srcp[
x];
258 const uint16_t *srcp = (uint16_t *)src + pos->
y * src_stride / 2 + pos->
x;
259 const uint16_t *refp = (uint16_t *)src + r_y * src_stride / 2 + r_x;
264 for (y = 0; y < block_size; y++) {
265 for (x = 0; x < block_size; x++) {
266 double temp = refp[
x] - srcp[
x];
270 srcp += src_stride / 2;
271 refp += src_stride / 2;
278 const PosCode *search_pos,
int search_size,
float th_mse,
279 int r_y,
int r_x,
int plane,
int jobnr)
283 double distMul = 1. / MSE2SSE;
284 double th_sse = th_mse * MSE2SSE;
287 for (i = 0; i < search_size; i++) {
291 dist = s->
do_block_ssd(s, &pos, src, src_stride, r_y, r_x);
294 if (dist <= th_sse && dist != 0) {
295 const double score = dist * distMul;
316 int exclude_cur_pos,
int plane,
int jobnr)
330 for (j = t; j <=
b; j +=
step) {
331 for (i = l; i <=
r; i +=
step) {
334 if (exclude_cur_pos > 0 && j == y && i == x) {
344 if (exclude_cur_pos == 1) {
356 int j,
int i,
int plane,
int jobnr)
373 int y,
int x,
int block_size,
float *
dst)
378 for (j = 0; j < block_size; j++) {
384 int y,
int x,
int block_size,
float *
dst)
386 const uint16_t *
src = (uint16_t *)srcp + y * src_linesize / 2 + x;
389 for (j = 0; j < block_size; j++) {
396 int y,
int x,
int plane,
int jobnr)
410 float den_weight, num_weight;
414 for (k = 0; k < nb_match_blocks; k++) {
418 for (i = 0; i < block_size; i++) {
419 s->
get_block_row(src, src_linesize, y + i, x, block_size, bufferh + block_size * i);
423 for (i = 0; i < block_size; i++) {
424 for (j = 0; j < block_size; j++) {
425 bufferv[i * block_size + j] = bufferh[j * block_size +
i];
430 for (i = 0; i < block_size; i++) {
431 memcpy(buffer + k * buffer_linesize + i * block_size,
432 bufferv + i * block_size, block_size * 4);
436 for (i = 0; i < block_size; i++) {
437 for (j = 0; j < block_size; j++) {
438 for (k = 0; k < nb_match_blocks; k++)
439 bufferz[k] = buffer[buffer_linesize * k + i * block_size + j];
442 bufferz += pgroup_size;
447 threshold[1] = threshold[0] * sqrtf(2.
f);
448 threshold[2] = threshold[0] * 2.f;
449 threshold[3] = threshold[0] * sqrtf(8.
f);
452 for (i = 0; i < block_size; i++) {
453 for (j = 0; j < block_size; j++) {
454 for (k = 0; k < nb_match_blocks; k++) {
455 const float thresh = threshold[(j == 0) + (i == 0) + (k == 0)];
457 if (bufferz[k] > thresh || bufferz[k] < -thresh) {
463 bufferz += pgroup_size;
469 for (i = 0; i < block_size; i++) {
470 for (j = 0; j < block_size; j++) {
473 for (k = 0; k < nb_match_blocks; k++) {
474 buffer[buffer_linesize * k + i * block_size + j] = bufferz[k];
476 bufferz += pgroup_size;
480 den_weight = retained < 1 ? 1.f : 1.f / retained;
481 num_weight = den_weight;
484 for (k = 0; k < nb_match_blocks; k++) {
485 float *num = sc->
num + y * width +
x;
486 float *den = sc->
den + y * width +
x;
488 for (i = 0; i < block_size; i++) {
489 memcpy(bufferv + i * block_size,
490 buffer + k * buffer_linesize + i * block_size,
494 for (i = 0; i < block_size; i++) {
496 for (j = 0; j < block_size; j++) {
497 bufferh[j * block_size +
i] = bufferv[i * block_size + j];
501 for (i = 0; i < block_size; i++) {
503 for (j = 0; j < block_size; j++) {
504 num[j] += bufferh[i * block_size + j] * num_weight;
505 den[j] += den_weight;
515 int y,
int x,
int plane,
int jobnr)
533 float den_weight, num_weight;
537 for (k = 0; k < nb_match_blocks; k++) {
541 for (i = 0; i < block_size; i++) {
542 s->
get_block_row(src, src_linesize, y + i, x, block_size, bufferh + block_size * i);
543 s->
get_block_row(ref, ref_linesize, y + i, x, block_size, rbufferh + block_size * i);
548 for (i = 0; i < block_size; i++) {
549 for (j = 0; j < block_size; j++) {
550 bufferv[i * block_size + j] = bufferh[j * block_size +
i];
551 rbufferv[i * block_size + j] = rbufferh[j * block_size +
i];
557 for (i = 0; i < block_size; i++) {
558 memcpy(buffer + k * buffer_linesize + i * block_size,
559 bufferv + i * block_size, block_size * 4);
560 memcpy(rbuffer + k * buffer_linesize + i * block_size,
561 rbufferv + i * block_size, block_size * 4);
565 for (i = 0; i < block_size; i++) {
566 for (j = 0; j < block_size; j++) {
567 for (k = 0; k < nb_match_blocks; k++) {
568 bufferz[k] = buffer[buffer_linesize * k + i * block_size + j];
569 rbufferz[k] = rbuffer[buffer_linesize * k + i * block_size + j];
571 if (group_size > 1) {
575 bufferz += pgroup_size;
576 rbufferz += pgroup_size;
583 for (i = 0; i < block_size; i++) {
584 for (j = 0; j < block_size; j++) {
585 for (k = 0; k < nb_match_blocks; k++) {
586 const float ref_sqr = rbufferz[k] * rbufferz[k];
587 float wiener_coef = ref_sqr / (ref_sqr + sigma_sqr);
589 if (
isnan(wiener_coef))
591 bufferz[k] *= wiener_coef;
592 l2_wiener += wiener_coef * wiener_coef;
594 bufferz += pgroup_size;
595 rbufferz += pgroup_size;
601 for (i = 0; i < block_size; i++) {
602 for (j = 0; j < block_size; j++) {
605 for (k = 0; k < nb_match_blocks; k++) {
606 buffer[buffer_linesize * k + i * block_size + j] = bufferz[k];
608 bufferz += pgroup_size;
612 l2_wiener =
FFMAX(l2_wiener, 1e-15
f);
613 den_weight = 1.f / l2_wiener;
614 num_weight = den_weight;
616 for (k = 0; k < nb_match_blocks; k++) {
617 float *num = sc->
num + y * width +
x;
618 float *den = sc->
den + y * width +
x;
620 for (i = 0; i < block_size; i++) {
621 memcpy(bufferv + i * block_size,
622 buffer + k * buffer_linesize + i * block_size,
626 for (i = 0; i < block_size; i++) {
628 for (j = 0; j < block_size; j++) {
629 bufferh[j * block_size +
i] = bufferv[i * block_size + j];
633 for (i = 0; i < block_size; i++) {
635 for (j = 0; j < block_size; j++) {
636 num[j] += bufferh[i * block_size + j] * num_weight;
637 den[j] += den_weight;
646 int plane,
int nb_jobs)
652 for (i = 0; i <
height; i++) {
653 for (j = 0; j <
width; j++) {
658 for (k = 0; k < nb_jobs; k++) {
660 float num = sc->
num[i * width + j];
661 float den = sc->
den[i * width + j];
667 dstp[j] = av_clip_uint8(
lrintf(sum_num / sum_den));
673 int plane,
int nb_jobs)
677 const int depth = s->
depth;
680 for (i = 0; i <
height; i++) {
681 for (j = 0; j <
width; j++) {
682 uint16_t *dstp = (uint16_t *)dst + i * dst_linesize / 2;
686 for (k = 0; k < nb_jobs; k++) {
688 float num = sc->
num[i * width + j];
689 float den = sc->
den[i * width + j];
715 const int slice_start = (((height + block_step - 1) / block_step) * jobnr / nb_jobs) * block_step;
716 const int slice_end = (jobnr == nb_jobs - 1) ? block_pos_bottom + block_step :
717 (((height + block_step - 1) / block_step) * (jobnr + 1) / nb_jobs) * block_step;
723 for (j = slice_start; j <
slice_end; j += block_step) {
724 if (j > block_pos_bottom) {
725 j = block_pos_bottom;
728 for (i = 0; i < block_pos_right + block_step; i += block_step) {
729 if (i > block_pos_right) {
736 ref, ref_linesize, j, i, plane, jobnr);
772 s->
do_output(s, (*out)->data[p], (*out)->linesize[p], p, nb_jobs);
778 #define SQR(x) ((x) * (x)) 796 for (group_bits = 4; 1 << group_bits < s->
group_size; group_bits++);
939 av_log(ctx,
AV_LOG_WARNING,
"mstep: %d can't be bigger than block matching range. Changing to %d.\n",
987 if (src->
w != ref->
w ||
990 "(size %dx%d) do not match the corresponding " 991 "second input link %s parameters (%dx%d) ",
1079 .priv_class = &bm3d_class,
int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
Take a frame from the link's FIFO and update the link's stats.
#define AV_PIX_FMT_YUVA422P16
static int filter_frame(AVFilterContext *ctx, AVFrame **out, AVFrame *in, AVFrame *ref)
#define AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUVA422P9
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
This structure describes decoded (raw) audio or video data.
static void do_output(BM3DContext *s, uint8_t *dst, int dst_linesize, int plane, int nb_jobs)
#define AV_PIX_FMT_YUVA420P10
AVFILTER_DEFINE_CLASS(bm3d)
#define AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_YUVA422P10
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
#define AV_LOG_WARNING
Something somehow does not look correct.
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Main libavfilter public API header.
static int search_boundary(int plane_boundary, int search_range, int search_step, int vertical, int y, int x)
int h
agreed upon image height
#define AVFILTER_FLAG_DYNAMIC_INPUTS
The number of the filter inputs is not determined just by AVFilter.inputs.
DCTContext * av_dct_init(int nbits, enum DCTTransformType type)
Set up DCT.
#define AV_PIX_FMT_GBRP10
SliceContext slices[MAX_NB_THREADS]
enum AVMediaType type
AVFilterPad type.
#define AV_PIX_FMT_YUV420P12
int ff_framesync_configure(FFFrameSync *fs)
Configure a frame sync structure.
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
int is_disabled
the enabled state from the last expression evaluation
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
static void ff_outlink_set_status(AVFilterLink *link, int status, int64_t pts)
Set the status field of a link from the source filter.
void ff_inlink_request_frame(AVFilterLink *link)
Mark that a frame is wanted on the link.
static int ff_outlink_frame_wanted(AVFilterLink *link)
Test if a frame is wanted on an output link.
enum FFFrameSyncExtMode before
Extrapolation mode for timestamps before the first frame.
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
#define AV_PIX_FMT_GRAY10
static void get_block_row(const uint8_t *srcp, int src_linesize, int y, int x, int block_size, float *dst)
static const AVFilterPad bm3d_outputs[]
const char * name
Pad name.
AVFilterContext * parent
Parent filter context.
#define AV_PIX_FMT_GRAY12
AVFilterLink ** inputs
array of pointers to input links
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
void(* get_block_row)(const uint8_t *srcp, int src_linesize, int y, int x, int block_size, float *dst)
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
static const AVOption bm3d_options[]
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
#define fs(width, name, subs,...)
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
FFFrameSyncIn * in
Pointer to array of inputs.
#define AV_PIX_FMT_YUVA420P9
static void do_output16(BM3DContext *s, uint8_t *dst, int dst_linesize, int plane, int nb_jobs)
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range...
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
#define AV_PIX_FMT_YUV444P16
enum FFFrameSyncExtMode after
Extrapolation mode for timestamps after the last frame.
static void get_block_row16(const uint8_t *srcp, int src_linesize, int y, int x, int block_size, float *dst)
static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
#define AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUVA420P16
#define FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink)
Forward the status on an output link to an input link.
A filter pad used for either input or output.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
A link between two filters.
int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
Test and acknowledge the change of status on the link.
AVFilterPad * input_pads
array of input pads
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
#define i(width, name, range_min, range_max)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
void ff_framesync_uninit(FFFrameSync *fs)
Free all memory currently allocated.
AVRational frame_rate
Frame rate of the stream on the link, or 1/0 if unknown or variable; if left to 0/0, will be automatically copied from the first input of the source filter if it exists.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
void * priv
private data for use by the filter
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
#define AV_PIX_FMT_YUVA444P16
AVRational time_base
Define the time base used by the PTS of the frames/samples which will pass through this link...
#define AV_PIX_FMT_GBRAP12
simple assert() macros that are a bit more flexible than ISO C assert().
AVRational time_base
Time base for the incoming frames.
int ff_framesync_activate(FFFrameSync *fs)
Examine the frames in the filter's input and try to produce output.
#define AV_PIX_FMT_YUV444P10
int(* on_event)(struct FFFrameSync *fs)
Callback called when a frame event is ready.
#define AV_PIX_FMT_GBRAP16
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
int w
agreed upon image width
#define FFDIFFSIGN(x, y)
Comparator.
#define AV_PIX_FMT_YUV422P9
static const struct @315 planes[]
int(* config_props)(AVFilterLink *link)
Link configuration callback.
#define AV_PIX_FMT_GBRP16
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
unsigned nb_inputs
number of input pads
#define AV_PIX_FMT_GRAY16
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
void(* block_filtering)(struct BM3DContext *s, const uint8_t *src, int src_linesize, const uint8_t *ref, int ref_linesize, int y, int x, int plane, int jobnr)
#define AV_PIX_FMT_YUVA444P12
static av_cold int init(AVFilterContext *ctx)
static int cmp_scores(const void *a, const void *b)
static void do_block_matching_multi(BM3DContext *s, const uint8_t *src, int src_stride, int src_range, const PosCode *search_pos, int search_size, float th_mse, int r_y, int r_x, int plane, int jobnr)
AVRational time_base
Time base for the output events.
double(* do_block_ssd)(struct BM3DContext *s, PosCode *pos, const uint8_t *src, int src_stride, int r_y, int r_x)
AVFilterContext * src
source filter
#define AV_PIX_FMT_YUVA444P10
static int process_frame(FFFrameSync *fs)
static const AVFilterPad inputs[]
void * opaque
Opaque pointer, not used by the API.
#define AV_PIX_FMT_YUV444P9
static double do_block_ssd(BM3DContext *s, PosCode *pos, const uint8_t *src, int src_stride, int r_y, int r_x)
#define AV_PIX_FMT_GBRP14
static int do_search_boundary(int pos, int plane_boundary, int search_range, int search_step)
static const AVFilterPad outputs[]
int format
agreed upon media format
static int activate(AVFilterContext *ctx)
#define AV_PIX_FMT_YUV420P16
static double do_block_ssd16(BM3DContext *s, PosCode *pos, const uint8_t *src, int src_stride, int r_y, int r_x)
#define AV_PIX_FMT_YUV420P14
char * av_strdup(const char *s)
Duplicate a string.
typedef void(RENAME(mix_any_func_type))
Used for passing data between threads.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
int ff_framesync_init(FFFrameSync *fs, AVFilterContext *parent, unsigned nb_in)
Initialize a frame sync structure.
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
static av_cold void uninit(AVFilterContext *ctx)
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
#define AV_PIX_FMT_GRAY14
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
void av_dct_end(DCTContext *s)
#define AV_PIX_FMT_YUV420P10
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
unsigned sync
Synchronization level: frames on input at the highest sync level will generate output frame events...
Describe the class of an AVClass context structure.
void(* do_output)(struct BM3DContext *s, uint8_t *dst, int dst_linesize, int plane, int nb_jobs)
const char * name
Filter name.
#define AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV420P9
AVRational sample_aspect_ratio
agreed upon sample aspect ratio
#define AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will have its filter_frame() c...
AVFilterLink ** outputs
array of pointers to output links
static enum AVPixelFormat pix_fmts[]
#define AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_GBRP12
#define flags(name, subs,...)
AVFilterInternal * internal
An opaque struct for libavfilter internal use.
#define AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV444P12
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
PosPairCode match_blocks[256]
planar GBRA 4:4:4:4 32bpp
#define AV_PIX_FMT_YUVA444P9
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
avfilter_execute_func * execute
void av_dct_calc(DCTContext *s, FFTSample *data)
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Completely stop all streams with this one.
static void final_block_filtering(BM3DContext *s, const uint8_t *src, int src_linesize, const uint8_t *ref, int ref_linesize, int y, int x, int plane, int jobnr)
AVFilterContext * dst
dest filter
static void block_matching(BM3DContext *s, const uint8_t *ref, int ref_linesize, int j, int i, int plane, int jobnr)
const AVPixFmtDescriptor * desc
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
static int config_input(AVFilterLink *inlink)
static void block_matching_multi(BM3DContext *s, const uint8_t *ref, int ref_linesize, int y, int x, int exclude_cur_pos, int plane, int jobnr)
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
static int query_formats(AVFilterContext *ctx)
void av_image_copy_plane(uint8_t *dst, int dst_linesize, const uint8_t *src, int src_linesize, int bytewidth, int height)
Copy image plane from src to dst.
PosCode * search_positions
int ff_framesync_get_frame(FFFrameSync *fs, unsigned in, AVFrame **rframe, unsigned get)
Get the current frame in an input.
int depth
Number of bits in the component.
AVPixelFormat
Pixel format.
mode
Use these values in ebur128_init (or'ed).
#define AV_PIX_FMT_YUV422P16
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
#define AV_PIX_FMT_YUVA422P12
#define AV_CEIL_RSHIFT(a, b)
static int ff_insert_inpad(AVFilterContext *f, unsigned index, AVFilterPad *p)
Insert a new input pad for the filter.
static av_always_inline av_const unsigned av_clip_uintp2_c(int a, int p)
Clip a signed integer to an unsigned power of two range.
static int config_output(AVFilterLink *outlink)
static void basic_block_filtering(BM3DContext *s, const uint8_t *src, int src_linesize, const uint8_t *ref, int ref_linesize, int y, int x, int plane, int jobnr)