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",
953 pad.
name =
"reference";
979 if (src->
w != ref->
w ||
982 "(size %dx%d) do not match the corresponding " 983 "second input link %s parameters (%dx%d) ",
1068 .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.
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
the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the ff_outlink_frame_wanted() function.If this function returns true
#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 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
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.
#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
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
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)
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
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
static const struct @324 planes[]
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
#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.
they must not be accessed directly The fifo field contains the frames that are queued in the input for processing by the filter The status_in and status_out fields contains the queued status(EOF or error) of the link
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
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
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)