33 #define FF_BUFQUEUE_SIZE 129 41 #define SIZE FF_BUFQUEUE_SIZE 68 #define OFFSET(x) offsetof(ATADenoiseContext, x) 69 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM 70 #define VF AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM 133 if (!(s->
size & 1)) {
147 #define WFILTER_ROW(type, name) \ 148 static void fweight_row##name(const uint8_t *ssrc, uint8_t *ddst, \ 149 const uint8_t *ssrcf[SIZE], \ 150 int w, int mid, int size, \ 151 int thra, int thrb, const float *weights) \ 153 const type *src = (const type *)ssrc; \ 154 const type **srcf = (const type **)ssrcf; \ 155 type *dst = (type *)ddst; \ 157 for (int x = 0; x < w; x++) { \ 158 const int srcx = src[x]; \ 159 unsigned lsumdiff = 0, rsumdiff = 0; \ 160 unsigned ldiff, rdiff; \ 166 for (int j = mid - 1, i = mid + 1; j >= 0 && i < size; j--, i++) { \ 167 srcjx = srcf[j][x]; \ 169 ldiff = FFABS(srcx - srcjx); \ 171 if (ldiff > thra || \ 175 sum += srcjx * weights[j]; \ 176 wsum += weights[j]; \ 178 srcix = srcf[i][x]; \ 180 rdiff = FFABS(srcx - srcix); \ 182 if (rdiff > thra || \ 186 sum += srcix * weights[i]; \ 187 wsum += weights[i]; \ 190 dst[x] = lrintf(sum / wsum); \ 197 #define WFILTER_ROW_SERIAL(type, name) \ 198 static void fweight_row##name##_serial(const uint8_t *ssrc, uint8_t *ddst, \ 199 const uint8_t *ssrcf[SIZE], \ 200 int w, int mid, int size, \ 201 int thra, int thrb, \ 202 const float *weights) \ 204 const type *src = (const type *)ssrc; \ 205 const type **srcf = (const type **)ssrcf; \ 206 type *dst = (type *)ddst; \ 208 for (int x = 0; x < w; x++) { \ 209 const int srcx = src[x]; \ 210 unsigned lsumdiff = 0, rsumdiff = 0; \ 211 unsigned ldiff, rdiff; \ 217 for (int j = mid - 1; j >= 0; j--) { \ 218 srcjx = srcf[j][x]; \ 220 ldiff = FFABS(srcx - srcjx); \ 222 if (ldiff > thra || \ 226 sum += srcjx * weights[j]; \ 227 wsum += weights[j]; \ 230 for (int i = mid + 1; i < size; i++) { \ 231 srcix = srcf[i][x]; \ 233 rdiff = FFABS(srcx - srcix); \ 235 if (rdiff > thra || \ 239 sum += srcix * weights[i]; \ 240 wsum += weights[i]; \ 243 dst[x] = lrintf(sum / wsum); \ 250 #define FILTER_ROW(type, name) \ 251 static void filter_row##name(const uint8_t *ssrc, uint8_t *ddst, \ 252 const uint8_t *ssrcf[SIZE], \ 253 int w, int mid, int size, \ 254 int thra, int thrb, const float *weights) \ 256 const type *src = (const type *)ssrc; \ 257 const type **srcf = (const type **)ssrcf; \ 258 type *dst = (type *)ddst; \ 260 for (int x = 0; x < w; x++) { \ 261 const int srcx = src[x]; \ 262 unsigned lsumdiff = 0, rsumdiff = 0; \ 263 unsigned ldiff, rdiff; \ 264 unsigned sum = srcx; \ 268 for (int j = mid - 1, i = mid + 1; j >= 0 && i < size; j--, i++) { \ 269 srcjx = srcf[j][x]; \ 271 ldiff = FFABS(srcx - srcjx); \ 273 if (ldiff > thra || \ 279 srcix = srcf[i][x]; \ 281 rdiff = FFABS(srcx - srcix); \ 283 if (rdiff > thra || \ 290 dst[x] = (sum + ((r + l + 1) >> 1)) / (r + l + 1); \ 297 #define FILTER_ROW_SERIAL(type, name) \ 298 static void filter_row##name##_serial(const uint8_t *ssrc, uint8_t *ddst, \ 299 const uint8_t *ssrcf[SIZE], \ 300 int w, int mid, int size, \ 301 int thra, int thrb, \ 302 const float *weights) \ 304 const type *src = (const type *)ssrc; \ 305 const type **srcf = (const type **)ssrcf; \ 306 type *dst = (type *)ddst; \ 308 for (int x = 0; x < w; x++) { \ 309 const int srcx = src[x]; \ 310 unsigned lsumdiff = 0, rsumdiff = 0; \ 311 unsigned ldiff, rdiff; \ 312 unsigned sum = srcx; \ 316 for (int j = mid - 1; j >= 0; j--) { \ 317 srcjx = srcf[j][x]; \ 319 ldiff = FFABS(srcx - srcjx); \ 321 if (ldiff > thra || \ 328 for (int i = mid + 1; i < size; i++) { \ 329 srcix = srcf[i][x]; \ 331 rdiff = FFABS(srcx - srcix); \ 333 if (rdiff > thra || \ 340 dst[x] = (sum + ((r + l + 1) >> 1)) / (r + l + 1); \ 361 const int slice_start = (h * jobnr) / nb_jobs;
362 const int slice_end = (h * (jobnr+1)) / nb_jobs;
371 if (!((1 << p) & s->
planes)) {
373 w, slice_end - slice_start);
377 for (i = 0; i <
size; i++)
378 srcf[i] = data[i] + slice_start *
linesize[i];
380 for (y = slice_start; y <
slice_end; y++) {
386 for (i = 0; i <
size; i++)
412 if (depth == 8 && s->
sigma[p] == INT16_MAX)
414 else if (s->
sigma[p] == INT16_MAX)
416 else if (depth == 8 && s->
sigma[p] < INT16_MAX)
418 else if (s->
sigma[p] < INT16_MAX)
422 s->
thra[0] = s->
fthra[0] * (1 << depth) - 1;
423 s->
thra[1] = s->
fthra[1] * (1 << depth) - 1;
424 s->
thra[2] = s->
fthra[2] * (1 << depth) - 1;
425 s->
thrb[0] = s->
fthrb[0] * (1 << depth) - 1;
426 s->
thrb[1] = s->
fthrb[1] * (1 << depth) - 1;
427 s->
thrb[2] = s->
fthrb[2] * (1 << depth) - 1;
433 for (
int n = 1; n <= s->
radius; n++) {
455 for (i = 0; i < s->
mid; i++) {
482 for (i = 0; i < s->
size; i++) {
576 .
name =
"atadenoise",
579 .priv_class = &atadenoise_class,
static AVFrame * ff_bufqueue_get(struct FFBufQueue *queue)
Get the first buffer from the queue and remove it.
static int query_formats(AVFilterContext *ctx)
#define AV_PIX_FMT_YUVA422P16
#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.
ptrdiff_t const GLvoid * data
#define AV_PIX_FMT_YUVA420P10
#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.
Main libavfilter public API header.
int h
agreed upon image height
void(* filter_row[4])(const uint8_t *src, uint8_t *dst, const uint8_t **srcf, int w, int mid, int size, int thra, int thrb, const float *weight)
#define AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_YUV420P12
static int process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
void ff_atadenoise_init_x86(ATADenoiseDSPContext *dsp, int depth, int algorithm, const float *sigma)
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.
Structure holding the queue.
#define AV_PIX_FMT_GRAY10
const char * name
Pad name.
#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.
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
#define FILTER_ROW(type, name)
#define AV_PIX_FMT_YUVA420P9
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range...
static const AVFilterPad inputs[]
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
#define AVERROR_EOF
End of file.
#define AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUVA420P16
static const AVOption atadenoise_options[]
A filter pad used for either input or output.
A link between two filters.
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
static av_cold int init(AVFilterContext *ctx)
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
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. ...
int ff_filter_process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Generic processing of user supplied commands that are set in the same way as the filter options...
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
#define AV_PIX_FMT_GBRAP12
AVFILTER_DEFINE_CLASS(atadenoise)
#define AV_PIX_FMT_YUV444P10
#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 AV_PIX_FMT_YUV422P9
int(* filter_slice)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
uint8_t nb_components
The number of components each pixel has, (1-4)
#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...
#define AV_PIX_FMT_YUVA444P12
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 the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
AVFilterContext * src
source filter
#define AV_PIX_FMT_YUVA444P10
static void ff_bufqueue_discard_all(struct FFBufQueue *queue)
Unref and remove all buffers from the queue.
#define AV_PIX_FMT_YUV444P9
#define WFILTER_ROW(type, name)
#define AV_PIX_FMT_GBRP14
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
int format
agreed upon media format
#define AV_PIX_FMT_YUV420P16
static av_cold void uninit(AVFilterContext *ctx)
#define AV_PIX_FMT_YUV420P14
unsigned short available
number of available buffers
Used for passing data between threads.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
#define AV_PIX_FMT_GRAY14
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);return NULL;}return ac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
#define AV_PIX_FMT_YUV420P10
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Describe the class of an AVClass context structure.
const char * name
Filter name.
#define AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV420P9
#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
#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.
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
planar GBRA 4:4:4:4 32bpp
#define WFILTER_ROW_SERIAL(type, name)
#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
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
AVFilter ff_vf_atadenoise
AVFilterContext * dst
dest filter
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
static int request_frame(AVFilterLink *outlink)
static void ff_bufqueue_add(void *log, struct FFBufQueue *queue, AVFrame *buf)
Add a buffer to the queue.
static int config_input(AVFilterLink *inlink)
int ff_request_frame(AVFilterLink *link)
Request an input frame from the filter at the other end of the link.
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.
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 depth
Number of bits in the component.
#define FILTER_ROW_SERIAL(type, name)
AVPixelFormat
Pixel format.
#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 const AVFilterPad outputs[]
static AVFrame * ff_bufqueue_peek(struct FFBufQueue *queue, unsigned index)
Get a buffer from the queue without altering it.