Commit 9db6f463 authored by Rémi Denis-Courmont's avatar Rémi Denis-Courmont
Browse files

vdpau: adjust video filter

This supports brightness, contrast, saturation and hue.
parent a3972541
......@@ -362,6 +362,7 @@ $Id$
* vcd: input module for accessing Video CDs
* vcdx: input module for accessing Video CDs with navigation & stills
* vda: VDADecoder hardware-accelerated decoding
* vdpau_adjust: VDPAU color adjust video filter
* vdpau_avcodec: VDPAU hardware-accelerated decoding
* vdpau_chroma: VDPAU hardware surfaces conversion and rendering
* vdpau_deinterlace: VDPAU deinterlacing video filter
......
......@@ -31,6 +31,11 @@ libvdpau_deinterlace_plugin_la_CFLAGS = $(AM_CFLAGS) # dummy
libvdpau_deinterlace_plugin_la_LIBADD = $(AM_LIBADD)
libvlc_LTLIBRARIES += libvdpau_deinterlace_plugin.la
libvdpau_adjust_plugin_la_SOURCES = adjust.c picture.c
libvdpau_adjust_plugin_la_CFLAGS = $(AM_CFLAGS) # dummy
libvdpau_adjust_plugin_la_LIBADD = $(AM_LIBADD)
libvlc_LTLIBRARIES += libvdpau_adjust_plugin.la
libvdpau_sharpen_plugin_la_SOURCES = sharpen.c picture.c
libvdpau_sharpen_plugin_la_CFLAGS = $(AM_CFLAGS) # dummy
libvdpau_sharpen_plugin_la_LIBADD = $(AM_LIBADD)
......
/*****************************************************************************
* adjust.c: VDPAU colour adjust video filter
*****************************************************************************
* Copyright (C) 2013 Rémi Denis-Courmont
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; either version 2.1 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
*****************************************************************************/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <stdlib.h>
#include <math.h>
#include <vlc_common.h>
#include <vlc_plugin.h>
#include <vlc_filter.h>
#include <vlc_atomic.h>
#include "vlc_vdpau.h"
struct filter_sys_t
{
atomic_uint_fast32_t brightness;
atomic_uint_fast32_t contrast;
atomic_uint_fast32_t saturation;
atomic_uint_fast32_t hue;
};
static inline void vlc_atomic_init_float(atomic_uint_fast32_t *var, float val)
{
union { uint32_t u; float f; } u;
u.f = val;
atomic_init(var, u.u);
}
static inline void vlc_atomic_store_float(atomic_uint_fast32_t *var, float val)
{
union { uint32_t u; float f; } u;
u.f = val;
atomic_store(var, u.u);
}
static inline float vlc_atomic_load_float(atomic_uint_fast32_t *var)
{
union { uint32_t u; float f; } u;
u.u = atomic_load(var);
return u.f;
}
static float vlc_to_vdp_brightness(float brightness)
{
brightness -= 1.f;
if (brightness > +1.f)
brightness = +1.f;
if (brightness < -1.f)
brightness = -1.f;
return brightness;
}
static int BrightnessCallback(vlc_object_t *obj, const char *varname,
vlc_value_t prev, vlc_value_t cur, void *data)
{
vlc_atomic_store_float(data, vlc_to_vdp_brightness(cur.f_float));
(void) obj; (void) varname; (void) prev;
return VLC_SUCCESS;
}
static float vlc_to_vdp_contrast(float contrast)
{
if (contrast > 10.f)
contrast = 10.f;
if (contrast < 0.f)
contrast = 0.f;
return contrast;
}
static int ContrastCallback(vlc_object_t *obj, const char *varname,
vlc_value_t prev, vlc_value_t cur, void *data)
{
vlc_atomic_store_float(data, vlc_to_vdp_contrast(cur.f_float));
(void) obj; (void) varname; (void) prev;
return VLC_SUCCESS;
}
#define vlc_to_vdp_saturation vlc_to_vdp_contrast
static int SaturationCallback(vlc_object_t *obj, const char *varname,
vlc_value_t prev, vlc_value_t cur, void *data)
{
vlc_atomic_store_float(data, vlc_to_vdp_saturation(cur.f_float));
(void) obj; (void) varname; (void) prev;
return VLC_SUCCESS;
}
static float vlc_to_vdp_hue(int hue)
{
hue %= 360;
if (hue > 180)
hue -= 360;
return (float)hue * (float)(M_PI / 180.);
}
static int HueCallback(vlc_object_t *obj, const char *varname,
vlc_value_t prev, vlc_value_t cur, void *data)
{
vlc_atomic_store_float(data, vlc_to_vdp_hue(cur.i_int));
(void) obj; (void) varname; (void) prev;
return VLC_SUCCESS;
}
static picture_t *Adjust(filter_t *filter, picture_t *pic)
{
filter_sys_t *sys = filter->p_sys;
vlc_vdp_video_field_t *f = pic->context;
if (unlikely(f == NULL))
return pic;
f->procamp.brightness = vlc_atomic_load_float(&sys->brightness);
f->procamp.contrast = vlc_atomic_load_float(&sys->contrast);
f->procamp.saturation = vlc_atomic_load_float(&sys->saturation);
f->procamp.hue = vlc_atomic_load_float(&sys->hue);
return pic;
}
static const char *const options[] = {
"brightness", "contrast", "saturation", "hue", NULL
};
static int Open(vlc_object_t *obj)
{
filter_t *filter = (filter_t *)obj;
if (filter->fmt_in.video.i_chroma != VLC_CODEC_VDPAU_VIDEO_422
&& filter->fmt_in.video.i_chroma != VLC_CODEC_VDPAU_VIDEO_420)
return VLC_EGENERIC;
if (!video_format_IsSimilar(&filter->fmt_in.video, &filter->fmt_out.video))
return VLC_EGENERIC;
filter_sys_t *sys = malloc(sizeof (*sys));
if (unlikely(sys == NULL))
return VLC_ENOMEM;
filter->pf_video_filter = Adjust;
filter->p_sys = sys;
config_ChainParse(filter, "", options, filter->p_cfg);
float f;
int i;
f = var_CreateGetFloatCommand(filter, "brightness");
var_AddCallback(filter, "brightness", BrightnessCallback,
&sys->brightness);
vlc_atomic_init_float(&sys->brightness, vlc_to_vdp_brightness(f));
f = var_CreateGetFloatCommand(filter, "contrast");
var_AddCallback(filter, "contrast", ContrastCallback, &sys->contrast);
vlc_atomic_init_float(&sys->contrast, vlc_to_vdp_contrast(f));
f = var_CreateGetFloatCommand(filter, "saturation");
var_AddCallback(filter, "saturation", SaturationCallback,
&sys->saturation);
vlc_atomic_init_float(&sys->saturation, vlc_to_vdp_saturation(f));
i = var_CreateGetIntegerCommand(filter, "hue");
var_AddCallback(filter, "hue", HueCallback, &sys->hue);
vlc_atomic_init_float(&sys->saturation, vlc_to_vdp_saturation(i));
return VLC_SUCCESS;
}
static void Close(vlc_object_t *obj)
{
filter_t *filter = (filter_t *)obj;
filter_sys_t *sys = filter->p_sys;
var_DelCallback(filter, "hue", HueCallback, &sys->hue);
var_DelCallback(filter, "saturation", SaturationCallback,
&sys->saturation);
var_DelCallback(filter, "contrast", ContrastCallback, &sys->contrast);
var_DelCallback(filter, "brightness", BrightnessCallback,
&sys->brightness);
free(sys);
}
vlc_module_begin()
set_description(N_("VDPAU adjust video filter"))
set_category(CAT_VIDEO)
set_subcategory(SUBCAT_VIDEO_VFILTER)
set_capability("video filter2", 0)
add_shortcut("adjust")
set_callbacks(Open, Close)
vlc_module_end()
......@@ -44,10 +44,18 @@ struct filter_sys_t
VdpYCbCrFormat format;
picture_t *(*import)(filter_t *, picture_t *);
picture_t *history[MAX_PAST + 1 + MAX_FUTURE];
struct
{
float brightness;
float contrast;
float saturation;
float hue;
} procamp;
};
/** Initialize the colour space conversion matrix */
static VdpStatus MixerSetupColors(filter_t *filter, VdpCSCMatrix *restrict csc)
static VdpStatus MixerSetupColors(filter_t *filter, const VdpProcamp *procamp,
VdpCSCMatrix *restrict csc)
{
filter_sys_t *sys = filter->p_sys;
VdpStatus err;
......@@ -55,11 +63,29 @@ static VdpStatus MixerSetupColors(filter_t *filter, VdpCSCMatrix *restrict csc)
? VDP_COLOR_STANDARD_ITUR_BT_709
: VDP_COLOR_STANDARD_ITUR_BT_601;
err = vdp_generate_csc_matrix(sys->vdp, NULL, std, csc);
err = vdp_generate_csc_matrix(sys->vdp, procamp, std, csc);
if (err != VDP_STATUS_OK)
{
msg_Err(filter, "video %s failure: %s", "color space matrix",
vdp_get_error_string(sys->vdp, err));
return err;
return err;
}
if (procamp != NULL)
{
sys->procamp.brightness = procamp->brightness;
sys->procamp.contrast = procamp->contrast;
sys->procamp.saturation = procamp->saturation;
sys->procamp.hue = procamp->hue;
}
else
{
sys->procamp.brightness = 0.f;
sys->procamp.contrast = 1.f;
sys->procamp.saturation = 1.f;
sys->procamp.hue = 0.f;
}
return VDP_STATUS_OK;
}
/** Create VDPAU video mixer */
......@@ -138,7 +164,7 @@ static VdpVideoMixer MixerCreate(filter_t *filter)
featc = 0;
if (MixerSetupColors(filter, &csc) == VDP_STATUS_OK)
if (MixerSetupColors(filter, NULL, &csc) == VDP_STATUS_OK)
{
attrv[attrc] = VDP_VIDEO_MIXER_ATTRIBUTE_CSC_MATRIX;
valv[attrc] = &csc;
......@@ -415,15 +441,28 @@ static picture_t *MixerRender(filter_t *filter, picture_t *src)
vdp_get_error_string(sys->vdp, err));
/* Configure mixer depending on upstream video filters */
const VdpVideoMixerAttribute attrs[] = {
VdpVideoMixerAttribute attrs[2] = {
VDP_VIDEO_MIXER_ATTRIBUTE_SHARPNESS_LEVEL,
};
const void *const values[] = {
const void *values[2] = {
&f->sharpen,
};
unsigned count = 1;
VdpCSCMatrix csc;
if ((sys->procamp.brightness != f->procamp.brightness
|| sys->procamp.contrast != f->procamp.contrast
|| sys->procamp.saturation != f->procamp.saturation
|| sys->procamp.hue != f->procamp.hue)
&& (MixerSetupColors(filter, &f->procamp, &csc) == VDP_STATUS_OK))
{
attrs[count] = VDP_VIDEO_MIXER_ATTRIBUTE_CSC_MATRIX;
values[count] = &csc;
count++;
}
err = vdp_video_mixer_set_attribute_values(sys->vdp, sys->mixer,
sizeof (attrs) / sizeof (attrs[0]), attrs, values);
count, attrs, values);
if (err != VDP_STATUS_OK)
msg_Err(filter, "video %s %s failure: %s", "mixer", "attributes",
vdp_get_error_string(sys->vdp, err));
......@@ -530,6 +569,11 @@ static int OutputOpen(vlc_object_t *obj)
for (unsigned i = 0; i < MAX_PAST + MAX_FUTURE; i++)
sys->history[i] = NULL;
sys->procamp.brightness = 0.f;
sys->procamp.contrast = 1.f;
sys->procamp.saturation = 1.f;
sys->procamp.hue = 0.f;
filter->pf_video_filter = MixerRender;
filter->pf_video_flush = Flush;
filter->p_sys = sys;
......
......@@ -24,6 +24,7 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <vlc_common.h>
#include <vlc_picture.h>
......@@ -52,6 +53,15 @@ static void SurfaceDestroy(void *opaque)
free(frame);
}
static const VdpProcamp procamp_default =
{
.struct_version = VDP_PROCAMP_VERSION,
.brightness = 0.f,
.contrast = 1.f,
.saturation = 1.f,
.hue = 0.f,
};
VdpStatus vlc_vdp_video_attach(vdp_t *vdp, VdpVideoSurface surface,
picture_t *pic)
{
......@@ -72,6 +82,7 @@ VdpStatus vlc_vdp_video_attach(vdp_t *vdp, VdpVideoSurface surface,
field->destroy = SurfaceDestroy;
field->frame = frame;
field->structure = VDP_VIDEO_MIXER_PICTURE_STRUCTURE_FRAME;
field->procamp = procamp_default;
field->sharpen = 0.f;
atomic_init(&frame->refs, 1);
......@@ -94,6 +105,7 @@ VdpStatus vlc_vdp_video_copy(picture_t *restrict dst, picture_t *restrict src)
fnew->destroy = SurfaceDestroy;
fnew->frame = frame;
fnew->structure = fold->structure;
fnew->procamp = fold->procamp;
fnew->sharpen = fold->sharpen;
atomic_fetch_add(&frame->refs, 1);
......
......@@ -259,6 +259,7 @@ typedef struct vlc_vdp_video_field
void (*destroy)(void *); /* must be first @ref picture_Release() */
vlc_vdp_video_frame_t *frame;
VdpVideoMixerPictureStructure structure;
VdpProcamp procamp;
float sharpen;
} vlc_vdp_video_field_t;
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment