Go to the documentation of this file.
56 #define OFFSET(x) offsetof(BilateralContext, x)
57 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
98 float inv_sigma_range;
100 s->depth =
desc->comp[0].depth;
101 inv_sigma_range = 1.0f / (
s->sigmaR * ((1 <<
s->depth) - 1));
104 for (
int i = 0;
i < (1 <<
s->depth);
i++)
105 s->range_table[
i] =
expf(-
i * inv_sigma_range);
108 s->planewidth[0] =
s->planewidth[3] =
inlink->w;
110 s->planeheight[0] =
s->planeheight[3] =
inlink->h;
127 !
s->slice_factor_a ||
128 !
s->slice_factor_a ||
136 #define BILATERAL(type, name) \
137 static void bilateral_##name(BilateralContext *s, const uint8_t *ssrc, uint8_t *ddst, \
138 float sigma_spatial, float sigma_range, \
139 int width, int height, int src_linesize, int dst_linesize) \
141 type *dst = (type *)ddst; \
142 const type *src = (const type *)ssrc; \
143 float *img_out_f = s->img_out_f, *img_temp = s->img_temp; \
144 float *map_factor_a = s->map_factor_a, *map_factor_b = s->map_factor_b; \
145 float *slice_factor_a = s->slice_factor_a, *slice_factor_b = s->slice_factor_b; \
146 float *line_factor_a = s->line_factor_a, *line_factor_b = s->line_factor_b; \
147 float *range_table = s->range_table; \
148 float alpha = expf(-sqrtf(2.f) / (sigma_spatial * width)); \
149 float ypr, ycr, *ycy, *ypy, *xcy, fp, fc; \
150 float inv_alpha_ = 1 - alpha; \
151 float *ycf, *ypf, *xcf, *in_factor; \
152 const type *tcy, *tpy; \
155 for (int y = 0; y < height; y++) { \
156 float *temp_factor_x, *temp_x = &img_temp[y * width]; \
157 const type *in_x = &src[y * src_linesize]; \
158 const type *texture_x = &src[y * src_linesize]; \
161 *temp_x++ = ypr = *in_x++; \
162 tpr = *texture_x++; \
164 temp_factor_x = &map_factor_a[y * width]; \
165 *temp_factor_x++ = fp = 1; \
167 for (int x = 1; x < width; x++) { \
168 float weight, alpha_; \
170 type tcr = *texture_x++; \
171 type dr = abs(tcr - tpr); \
174 weight = range_table[range_dist]; \
175 alpha_ = weight*alpha; \
176 *temp_x++ = ycr = inv_alpha_*(*in_x++) + alpha_*ypr; \
179 *temp_factor_x++ = fc = inv_alpha_ + alpha_ * fp; \
182 --temp_x; *temp_x = 0.5f*((*temp_x) + (*--in_x)); \
183 tpr = *--texture_x; \
186 --temp_factor_x; *temp_factor_x = 0.5f*((*temp_factor_x) + 1); \
189 for (int x = width - 2; x >= 0; x--) { \
190 type tcr = *--texture_x; \
191 type dr = abs(tcr - tpr); \
192 int range_dist = dr; \
193 float weight = range_table[range_dist]; \
194 float alpha_ = weight * alpha; \
196 ycr = inv_alpha_ * (*--in_x) + alpha_ * ypr; \
197 --temp_x; *temp_x = 0.5f*((*temp_x) + ycr); \
201 fc = inv_alpha_ + alpha_*fp; \
203 *temp_factor_x = 0.5f*((*temp_factor_x) + fc); \
207 memcpy(img_out_f, img_temp, sizeof(float) * width); \
209 alpha = expf(-sqrtf(2.f) / (sigma_spatial * height)); \
210 inv_alpha_ = 1 - alpha; \
211 in_factor = map_factor_a; \
212 memcpy(map_factor_b, in_factor, sizeof(float) * width); \
213 for (int y = 1; y < height; y++) { \
214 tpy = &src[(y - 1) * src_linesize]; \
215 tcy = &src[y * src_linesize]; \
216 xcy = &img_temp[y * width]; \
217 ypy = &img_out_f[(y - 1) * width]; \
218 ycy = &img_out_f[y * width]; \
220 xcf = &in_factor[y * width]; \
221 ypf = &map_factor_b[(y - 1) * width]; \
222 ycf = &map_factor_b[y * width]; \
223 for (int x = 0; x < width; x++) { \
224 type dr = abs((*tcy++) - (*tpy++)); \
225 int range_dist = dr; \
226 float weight = range_table[range_dist]; \
227 float alpha_ = weight*alpha; \
229 *ycy++ = inv_alpha_*(*xcy++) + alpha_*(*ypy++); \
230 *ycf++ = inv_alpha_*(*xcf++) + alpha_*(*ypf++); \
234 ycf = line_factor_a; \
235 ypf = line_factor_b; \
236 memcpy(ypf, &in_factor[h1 * width], sizeof(float) * width); \
237 for (int x = 0; x < width; x++) \
238 map_factor_b[h1 * width + x] = 0.5f*(map_factor_b[h1 * width + x] + ypf[x]); \
240 ycy = slice_factor_a; \
241 ypy = slice_factor_b; \
242 memcpy(ypy, &img_temp[h1 * width], sizeof(float) * width); \
243 for (int x = 0, k = 0; x < width; x++) { \
244 int idx = h1 * width + x; \
245 img_out_f[idx] = 0.5f*(img_out_f[idx] + ypy[k++]) / map_factor_b[h1 * width + x]; \
248 for (int y = h1 - 1; y >= 0; y--) { \
249 float *ycf_, *ypf_, *factor_; \
250 float *ycy_, *ypy_, *out_; \
252 tpy = &src[(y + 1) * src_linesize]; \
253 tcy = &src[y * src_linesize]; \
254 xcy = &img_temp[y * width]; \
257 out_ = &img_out_f[y * width]; \
259 xcf = &in_factor[y * width]; \
262 factor_ = &map_factor_b[y * width]; \
263 for (int x = 0; x < width; x++) { \
264 type dr = abs((*tcy++) - (*tpy++)); \
265 int range_dist = dr; \
266 float weight = range_table[range_dist]; \
267 float alpha_ = weight*alpha; \
268 float ycc, fcc = inv_alpha_*(*xcf++) + alpha_*(*ypf_++); \
271 *factor_ = 0.5f * (*factor_ + fcc); \
273 ycc = inv_alpha_*(*xcy++) + alpha_*(*ypy_++); \
275 *out_ = 0.5f * (*out_ + ycc) / (*factor_); \
280 memcpy(ypy, ycy, sizeof(float) * width); \
281 memcpy(ypf, ycf, sizeof(float) * width); \
284 for (int i = 0; i < height; i++) \
285 for (int j = 0; j < width; j++) \
286 dst[j + i * dst_linesize] = img_out_f[i * width + j]; \
306 for (
int plane = 0; plane <
s->nb_planes; plane++) {
307 if (!(
s->planes & (1 << plane))) {
309 in->data[plane],
in->linesize[plane],
310 s->planewidth[plane] * ((
s->depth + 7) / 8),
s->planeheight[plane]);
315 bilateral_byte(
s,
in->data[plane],
out->data[plane],
s->sigmaS,
s->sigmaR,
316 s->planewidth[plane],
s->planeheight[plane],
317 in->linesize[plane],
out->linesize[plane]);
319 bilateral_word(
s,
in->data[plane],
out->data[plane],
s->sigmaS,
s->sigmaR,
320 s->planewidth[plane],
s->planeheight[plane],
321 in->linesize[plane] / 2,
out->linesize[plane] / 2);
364 .priv_class = &bilateral_class,
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
#define AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_GBRAP16
AVPixelFormat
Pixel format.
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_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
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
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
#define AV_PIX_FMT_YUVA422P9
This structure describes decoded (raw) audio or video data.
#define AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUV420P10
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
const char * name
Filter name.
A link between two filters.
#define AV_PIX_FMT_YUVA422P10
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.
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
#define AV_PIX_FMT_YUVA420P9
#define AV_PIX_FMT_GBRP14
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
#define AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUV422P9
static av_cold void uninit(AVFilterContext *ctx)
#define AV_PIX_FMT_GRAY16
A filter pad used for either input or output.
#define AV_PIX_FMT_YUV444P10
@ AV_PIX_FMT_YUVJ411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
#define AV_PIX_FMT_YUV422P16
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
#define AV_PIX_FMT_GBRAP10
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
static int config_input(AVFilterLink *inlink)
#define AV_PIX_FMT_GBRAP12
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
#define AV_PIX_FMT_YUV444P16
#define AV_CEIL_RSHIFT(a, b)
static const AVFilterPad outputs[]
static enum AVPixelFormat pix_fmts[]
#define AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_GRAY14
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
AVFILTER_DEFINE_CLASS(bilateral)
static const AVOption bilateral_options[]
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
#define AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GBRP16
Describe the class of an AVClass context structure.
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
#define AV_PIX_FMT_YUV422P10
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
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
#define BILATERAL(type, name)
static const AVFilterPad bilateral_inputs[]
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
#define AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV444P12
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
#define AV_PIX_FMT_YUVA444P10
#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
Some filters support a generic "enable" expression option that can be used to enable or disable a fil...
static const struct @315 planes[]
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 i(width, name, range_min, range_max)
int w
agreed upon image width
#define AV_PIX_FMT_GBRP12
@ AV_PIX_FMT_YUVJ440P
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
const char * name
Pad name.
#define AV_PIX_FMT_YUV444P9
static const AVFilterPad bilateral_outputs[]
#define AV_PIX_FMT_YUVA444P9
#define AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV422P14
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
int h
agreed upon image height
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
#define flags(name, subs,...)
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
#define AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_GRAY12
static int query_formats(AVFilterContext *ctx)
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
#define AV_PIX_FMT_YUV420P14