42 #define GREY_EDGE "greyedge" 44 #define SQRT3 1.73205080757 47 #define MAX_DIFF_ORD 2 48 #define MAX_META_DATA 4 55 #define INDEX_NORM INDEX_DX 92 #define OFFSET(x) offsetof(ColorConstancyContext, x) 93 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM 95 #define GINDX(s, i) ( (i) - ((s) >> 2) ) 114 double sigma = s->
sigma;
118 for (i = 0; i <= difford; ++
i) {
121 for (; i >= 0; --
i) {
134 for (i = 0; i < filtersize; ++
i) {
135 s->
gauss[0][
i] =
exp(- pow(
GINDX(filtersize, i), 2.) / (2 * sigma * sigma)) / ( sqrt(2 *
M_PI) * sigma );
138 for (i = 0; i < filtersize; ++
i) {
146 for (i = 0; i < filtersize; ++
i) {
148 sum1 += s->
gauss[1][i] *
GINDX(filtersize, i);
151 for (i = 0; i < filtersize; ++
i) {
159 for (i = 0; i < filtersize; ++
i) {
160 s->
gauss[2][
i] = ( pow(
GINDX(filtersize, i), 2) / pow(sigma, 4) - 1/pow(sigma, 2) )
162 sum1 += s->
gauss[2][i];
166 for (i = 0; i < filtersize; ++
i) {
167 s->
gauss[2][
i] -= sum1 / (filtersize);
168 sum2 += (0.5 *
GINDX(filtersize, i) *
GINDX(filtersize, i) * s->
gauss[2][
i]);
170 for (i = 0; i < filtersize ; ++
i) {
192 for (b = 0; b < nb_buff; ++
b) {
220 for (b = 0; b <= nb_buff; ++
b) {
223 if (!td->
data[b][p]) {
232 #define CLAMP(x, mx) av_clip((x), 0, (mx-1)) 233 #define INDX2D(r, c, w) ( (r) * (w) + (c) ) 234 #define GAUSS(s, sr, sc, sls, sh, sw, g) ( (s)[ INDX2D(CLAMP((sr), (sh)), CLAMP((sc), (sw)), (sls)) ] * (g) ) 259 const double *gauss = s->
gauss[ord];
273 slice_start = (height * jobnr ) / nb_jobs;
274 slice_end = (height * (jobnr + 1)) / nb_jobs;
277 for (c = 0; c <
width; ++
c) {
278 dst[
INDX2D(r, c, width)] = 0;
279 for (g = 0; g < filtersize; ++
g) {
281 in_linesize, height, width, gauss[g]);
288 slice_start = (width * jobnr ) / nb_jobs;
289 slice_end = (width * (jobnr + 1)) / nb_jobs;
293 dst[
INDX2D(r, c, width)] = 0;
294 for (g = 0; g < filtersize; ++
g) {
296 width, height, width, gauss[g]);
321 const int difford = s->
difford;
327 const int64_t numpixels = width * (int64_t)height;
328 const int slice_start = (numpixels * jobnr ) / nb_jobs;
329 const int slice_end = (numpixels * (jobnr+1)) / nb_jobs;
337 norm[
i] = sqrt( pow(dx[i], 2) + pow(dy[i], 2));
342 norm[
i] = sqrt( pow(dx[i], 2) + 4 * pow(dxy[i], 2) + pow(dy[i], 2) );
364 int src,
int dst,
int dim,
int nb_threads) {
450 const int slice_start = (height * jobnr) / nb_jobs;
451 const int slice_end = (height * (jobnr+1)) / nb_jobs;
460 for (c = 0; c <
width; ++
c) {
462 * (img_data[
INDX2D(r, c, in_linesize)] < thresh) );
467 for (c = 0; c <
width; ++
c) {
468 dst[jobnr] += ( pow(
fabs(src[
INDX2D(r, c, width)] / 255.), minknorm)
469 * (img_data[
INDX2D(r, c, in_linesize)] < thresh) );
492 double *white = s->
white;
510 for (job = 0; job < nb_jobs; ++job) {
517 for (job = 0; job < nb_jobs; ++job) {
520 white[
plane] = pow(white[plane], 1./minknorm);
536 double abs_val = pow( pow(light[0], 2.0) + pow(light[1], 2.0) + pow(light[2], 2.0), 0.5);
602 const int64_t numpixels = width * (int64_t)height;
603 const int slice_start = (numpixels * jobnr) / nb_jobs;
604 const int slice_end = (numpixels * (jobnr+1)) / nb_jobs;
654 const double break_off_sigma = 3.0;
655 double sigma = s->
sigma;
658 if (!
floor(break_off_sigma * sigma + 0.5) && s->
difford) {
659 av_log(ctx,
AV_LOG_ERROR,
"floor(%f * sigma) must be > 0 when difford > 0.\n", break_off_sigma);
716 for (i = 0; i <= difford; ++
i) {
739 #if CONFIG_GREYEDGE_FILTER 741 static const AVOption greyedge_options[] = {
754 .priv_class = &greyedge_class,
757 .
inputs = colorconstancy_inputs,
758 .
outputs = colorconstancy_outputs,
static void chromatic_adaptation(AVFilterContext *ctx, AVFrame *in, AVFrame *out)
Main control function for correcting scene illumination based on estimated illumination.
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
Main libavfilter public API header.
int h
agreed upon image height
static void av_always_inline get_deriv(AVFilterContext *ctx, ThreadData *td, int ord, int dir, int src, int dst, int dim, int nb_threads)
Utility function for setting up differentiation data/metadata.
int minknorm
= 0 : getMax instead
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
static const AVFilterPad colorconstancy_outputs[]
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
static __device__ float floor(float a)
#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
Some filters support a generic "enable" expression option that can be used to enable or disable a fil...
const char * name
Pad name.
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
static int illumination_estimation(AVFilterContext *ctx, AVFrame *in)
Redirects to corresponding algorithm estimation function and performs normalization after estimation...
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
A filter pad used for either input or output.
static const AVFilterPad colorconstancy_inputs[]
A link between two filters.
#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.
static __device__ float fabs(float a)
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_LOG_DEBUG
Stuff which is only useful for libav* developers.
int w
agreed upon image width
static int set_gauss(AVFilterContext *ctx)
Sets gauss filters used for calculating gauss derivatives.
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
static int config_props(AVFilterLink *inlink)
Common struct for all algorithms contexts.
static void cleanup_derivative_buffers(ThreadData *td, int nb_buff, int nb_planes)
Frees up buffers used by grey edge for storing derivatives final and intermidiate results...
#define GAUSS(s, sr, sc, sls, sh, sw, g)
double * data[MAX_DATA][NUM_PLANES]
static const AVFilterPad outputs[]
int format
agreed upon media format
static void normalize_light(double *light)
Normalizes estimated illumination since only illumination vector direction is required for color cons...
static av_cold void uninit(AVFilterContext *ctx)
static int setup_derivative_buffers(AVFilterContext *ctx, ThreadData *td)
Allocates buffers used by grey edge for storing derivatives final and intermidiate results...
static int slice_get_derivative(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Slice calculation of gaussian derivatives.
int meta_data[MAX_META_DATA]
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Used for passing data between threads.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
static int diagonal_transformation(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Performs simple correction via diagonal transformation model.
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data 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
Describe the class of an AVClass context structure.
double * gauss[MAX_DIFF_ORD+1]
const char * name
Filter name.
AVFilterLink ** outputs
array of pointers to output links
static enum AVPixelFormat pix_fmts[]
#define flags(name, subs,...)
AVFilterInternal * internal
An opaque struct for libavfilter internal use.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static int get_derivative(AVFilterContext *ctx, ThreadData *td)
Main control function for calculating gaussian derivatives.
avfilter_execute_func * execute
static int filter_grey_edge(AVFilterContext *ctx, AVFrame *in)
Main control function for grey edge algorithm.
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
AVFilterContext * dst
dest filter
#define AVFILTER_DEFINE_CLASS(fname)
const AVPixFmtDescriptor * desc
static int filter_slice_grey_edge(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Slice function for grey edge algorithm that does partial summing/maximizing of gaussian derivatives...
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
static int query_formats(AVFilterContext *ctx)
AVPixelFormat
Pixel format.
static int slice_normalize(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Slice Frobius normalization of gaussian derivatives.
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
#define AV_CEIL_RSHIFT(a, b)
void * av_mallocz_array(size_t nmemb, size_t size)