[vlc-commits] hw: coreimage: add filters

Victorien Le Couviour--Tuffet git at videolan.org
Thu Jul 13 17:38:36 CEST 2017


vlc | branch: master | Victorien Le Couviour--Tuffet <victorien.lecouviour.tuffet at gmail.com> | Thu Jul 13 15:29:13 2017 +0200| [3ba7de2ed2de1b57b8b8ab84afe2b0887c4b6e69] | committer: Jean-Baptiste Kempf

hw: coreimage: add filters

adjust / invert / posterize / sepia / sharpen

Signed-off-by: Jean-Baptiste Kempf <jb at videolan.org>

> http://git.videolan.org/gitweb.cgi/vlc.git/?a=commit;h=3ba7de2ed2de1b57b8b8ab84afe2b0887c4b6e69
---

 NEWS                              |   1 +
 modules/MODULES_LIST              |   1 +
 modules/video_filter/Makefile.am  |  11 +
 modules/video_filter/ci_filters.m | 671 ++++++++++++++++++++++++++++++++++++++
 modules/video_output/macosx.m     |   4 +
 5 files changed, 688 insertions(+)

diff --git a/NEWS b/NEWS
index c61a2b2a0d..0046c89fd2 100644
--- a/NEWS
+++ b/NEWS
@@ -181,6 +181,7 @@ Video filter:
  * Added 9-bit and 10-bit support to image adjust filter
  * New edge detection filter uses the Sobel operator to detect edges
  * Hardware accelerated deinterlacing/adjust/sharpen/chroma with VA-API
+ * Hardware accelerated adjust/invert/posterize/sepia/sharpen with CoreImage
 
 Stream Output:
  * Chromecast output module
diff --git a/modules/MODULES_LIST b/modules/MODULES_LIST
index 28b266a2ec..510cc4af36 100644
--- a/modules/MODULES_LIST
+++ b/modules/MODULES_LIST
@@ -78,6 +78,7 @@ $Id$
  * chorus_flanger: Basic chorus/flanger/variable delay audio filter
  * chroma_omx: OMX Development Layer chroma conversions
  * chroma_yuv_neon: ARM NEON video chroma conversion
+ * ci_filters: CoreImage hardware-accelerated adjust/invert/posterize/sepia/sharpen filters
  * clone: Clone video filter
  * colorthres:  Theshold color based on similarity to reference color Video filter
  * compressor: Dynamic range compressor
diff --git a/modules/video_filter/Makefile.am b/modules/video_filter/Makefile.am
index a46eb3ce89..5c27a8a26d 100644
--- a/modules/video_filter/Makefile.am
+++ b/modules/video_filter/Makefile.am
@@ -107,6 +107,17 @@ video_filter_LTLIBRARIES = \
 	libpuzzle_plugin.la \
 	librotate_plugin.la
 
+if HAVE_OSX
+# MacOSX hardware video filters
+libci_filters_plugin_la_SOURCES = video_filter/ci_filters.m codec/vt_utils.c codec/vt_utils.h
+libci_filters_plugin_la_CFLAGS = $(AM_CFLAGS)
+libci_filters_plugin_la_LDFLAGS = $(AM_LDFLAGS) -rpath '$(video_filterdir)' \
+	-Wl,-framework,Foundation -Wl,-framework,CoreGraphics -Wl,-framework,CoreImage -Wl,-framework,CoreVideo
+
+video_filter_LTLIBRARIES += \
+	libci_filters_plugin.la
+endif
+
 libdeinterlace_plugin_la_SOURCES = \
 	video_filter/deinterlace/deinterlace.c video_filter/deinterlace/deinterlace.h \
         video_filter/deinterlace/mmx.h \
diff --git a/modules/video_filter/ci_filters.m b/modules/video_filter/ci_filters.m
new file mode 100644
index 0000000000..6f39000803
--- /dev/null
+++ b/modules/video_filter/ci_filters.m
@@ -0,0 +1,671 @@
+/*****************************************************************************
+ * ci_filters.m: Video filters for MacOSX OpenGL video output
+ *****************************************************************************
+ * Copyright © 2017 VLC authors, VideoLAN and VideoLabs
+ *
+ * Author: Victorien Le Couviour--Tuffet <victorien.lecouviour.tuffet at gmail.com>
+ *
+ * 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 <assert.h>
+
+#include <vlc_common.h>
+#include <vlc_atomic.h>
+#include <vlc_filter.h>
+#include <vlc_picture.h>
+#include <vlc_plugin.h>
+#include <vlc_modules.h>
+#include "filter_picture.h"
+#include "vt_utils.h"
+
+#include <AppKit/NSOpenGL.h>
+#include <CoreImage/CIContext.h>
+#include <CoreImage/CIImage.h>
+#include <CoreImage/CIFilter.h>
+#include <CoreImage/CIVector.h>
+
+enum    filter_type
+{
+    FILTER_NONE = -1,
+    FILTER_ADJUST_HUE,
+    FILTER_ADJUST_COLOR_CONTROLS,
+    FILTER_ADJUST_GAMMA,
+    FILTER_INVERT,
+    FILTER_POSTERIZE,
+    FILTER_SEPIA,
+    FILTER_SHARPEN,
+    NUM_FILTERS,
+    NUM_MAX_EQUIVALENT_VLC_FILTERS = 3
+};
+
+#define NUM_FILTER_PARAM_MAX    4
+
+struct  filter_chain
+{
+    enum filter_type            filter;
+    CIFilter *                  ci_filter;
+    vlc_atomic_float            ci_params[NUM_FILTER_PARAM_MAX];
+    struct filter_chain *       next;
+};
+
+struct  ci_filters_ctx
+{
+    CVPixelBufferPoolRef        cvpx_pool;
+    video_format_t              cvpx_pool_fmt;
+    CVPixelBufferPoolRef        outconv_cvpx_pool;
+    CIContext *                 ci_ctx;
+    CGColorSpaceRef             color_space;
+    struct filter_chain *       fchain;
+    filter_t *                  src_converter;
+    filter_t *                  dst_converter;
+};
+
+struct filter_sys_t
+{
+    char const *                psz_filter;
+    struct ci_filters_ctx *     ctx;
+};
+
+struct  range
+{
+    float       min;
+    float       max;
+};
+
+struct  filter_desc
+{
+    struct
+    {
+        char const *            vlc;
+        NSString *              ci;
+    } const             name_desc;
+
+    struct      filter_param_desc
+    {
+        char const *            vlc;
+        NSString *              ci;
+        struct
+        {
+            struct range    vlc;
+            struct range    ci;
+        }                       ranges[2];
+        int                     vlc_type;
+    } const             param_descs[NUM_FILTER_PARAM_MAX];
+};
+
+static struct filter_desc       filter_desc_table[] =
+{
+    [FILTER_ADJUST_HUE] =
+    {
+        { "adjust", @"CIHueAdjust" },
+        {
+            { "hue", @"inputAngle", {{{-180.f, +180.f}, {+3.f, -3.f}}}, VLC_VAR_FLOAT }
+        }
+    },
+    [FILTER_ADJUST_COLOR_CONTROLS] =
+    {
+        { "adjust", @"CIColorControls" },
+        {
+            { "contrast",   @"inputContrast",   {{{.0f, 2.f}, {.0f, 2.f}}},   VLC_VAR_FLOAT },
+            { "brightness", @"inputBrightness", {{{.0f, 2.f}, {-1.f, +1.f}}}, VLC_VAR_FLOAT },
+            { "saturation", @"inputSaturation", {{{.0f, 3.f}, {.0f, 2.7f}}},  VLC_VAR_FLOAT }
+        }
+    },
+    [FILTER_ADJUST_GAMMA] =
+    {
+        { "adjust", @"CIGammaAdjust" },
+        {
+            { "gamma", @"inputPower", {{{.01f, 1.f}, {10.f, 1.f}}, {{1.f, 10.f}, {1.f, .01f}}}, VLC_VAR_FLOAT }
+        }
+    },
+    [FILTER_INVERT] =
+    {
+        { "invert", @"CIColorInvert" }
+    },
+    [FILTER_POSTERIZE] =
+    {
+        { "posterize", @"CIColorPosterize" },
+        {
+            { "posterize-level", @"inputLevels", {{{2.f, 256.f}, {2.f, 256.f}}}, VLC_VAR_INTEGER }
+        }
+    },
+    [FILTER_SEPIA] =
+    {
+        { "sepia", @"CISepiaTone" },
+        {
+            { "sepia-intensity", @"inputIntensity", {{{.0f, 255.f}, {.0f, 1.f}}}, VLC_VAR_INTEGER }
+        }
+    },
+    [FILTER_SHARPEN] =
+    {
+        { "sharpen", @"CISharpenLuminance" },
+        {
+            { "sharpen-sigma", @"inputSharpness", {{{.0f, 2.f}, {.0f, 5.f}}}, VLC_VAR_FLOAT }
+        }
+    }
+};
+
+#define GET_CI_VALUE(vlc_value, vlc_range, ci_range)               \
+    ((vlc_value - vlc_range.min) * (ci_range.max - ci_range.min) / \
+     (vlc_range.max - vlc_range.min) + ci_range.min)
+
+static struct filter_chain *
+filter_chain_AddFilter(struct filter_chain **fchain, enum filter_type filter)
+{
+    struct filter_chain *elem = calloc(1, sizeof(*elem));
+    if (!elem)
+        return NULL;
+    elem->filter = filter;
+
+    if (!*fchain)
+        *fchain = elem;
+    else
+    {
+        struct filter_chain *it = *fchain;
+        while (it->next) it = it->next;
+        it->next = elem;
+    }
+
+    return elem;
+}
+
+static void
+filter_chain_RemoveFilter(struct filter_chain **fchain,
+                          enum filter_type filter)
+{
+    struct filter_chain *prev = NULL;
+    struct filter_chain *to_del;
+
+    for (to_del = *fchain; to_del && to_del->filter != filter;
+         to_del = to_del->next)
+        prev = to_del;
+    assert(to_del);
+    if (!prev)
+        *fchain = to_del->next;
+    else
+        prev->next = to_del->next;
+
+    free(to_del);
+}
+
+static void
+filter_desc_table_GetFilterTypes
+(char const *vlc_filter_name,
+ enum filter_type filter_types[NUM_MAX_EQUIVALENT_VLC_FILTERS])
+{
+    int j = 0;
+    for (int i = 0; i < NUM_FILTERS; ++i)
+        if (!strcmp(filter_desc_table[i].name_desc.vlc, vlc_filter_name))
+        {
+            assert(j < NUM_MAX_EQUIVALENT_VLC_FILTERS);
+            filter_types[j++] = i;
+        }
+    assert(j);
+    while (j < NUM_MAX_EQUIVALENT_VLC_FILTERS)
+        filter_types[j++] = FILTER_NONE;
+}
+
+static inline NSString *
+filter_desc_table_GetFilterName(enum filter_type type)
+{ assert(type < NUM_FILTERS);
+    return filter_desc_table[type].name_desc.ci;
+}
+
+static float
+filter_ConvertParam(float f_vlc_val,
+                    struct filter_param_desc const *param_desc)
+{
+    struct range clip_range = { param_desc->ranges[0].vlc.min,
+                                param_desc->ranges[1].vlc.max
+                                ? param_desc->ranges[1].vlc.max
+                                : param_desc->ranges[0].vlc.max };
+    f_vlc_val = VLC_CLIP(f_vlc_val, clip_range.min, clip_range.max);
+
+    unsigned int range_idx;
+    for (range_idx = 0; range_idx < 2; ++range_idx)
+        if (f_vlc_val >= param_desc->ranges[range_idx].vlc.min &&
+            f_vlc_val <= param_desc->ranges[range_idx].vlc.max)
+            break;
+    assert(range_idx < 2);
+
+    return GET_CI_VALUE(f_vlc_val,
+                        param_desc->ranges[range_idx].vlc,
+                        param_desc->ranges[range_idx].ci);
+}
+
+static int
+ParamsCallback(vlc_object_t *obj,
+               char const *psz_var,
+               vlc_value_t oldval, vlc_value_t newval,
+               void *p_data)
+{
+    VLC_UNUSED(obj); VLC_UNUSED(oldval);
+    struct filter_chain *filter = p_data;
+    struct filter_param_desc const *filter_param_descs =
+        filter_desc_table[filter->filter].param_descs;
+
+    unsigned int i = 0;
+    while (i < NUM_FILTER_PARAM_MAX &&
+           strcmp(filter_param_descs[i].vlc, psz_var))
+        ++i;
+    assert(i < NUM_FILTER_PARAM_MAX);
+
+    float new_vlc_val;
+    if (filter_param_descs[i].vlc_type == VLC_VAR_FLOAT)
+        new_vlc_val = newval.f_float;
+    else if (filter_param_descs[i].vlc_type == VLC_VAR_INTEGER)
+        new_vlc_val = newval.i_int;
+    else
+        vlc_assert_unreachable();
+
+    vlc_atomic_store_float(filter->ci_params + i,
+                           filter_ConvertParam(new_vlc_val,
+                                               filter_param_descs + i));
+
+    return VLC_SUCCESS;
+}
+
+static picture_t *
+Filter(filter_t *filter, picture_t *src)
+{
+    struct ci_filters_ctx *ctx = filter->p_sys->ctx;
+    enum filter_type filter_types[NUM_MAX_EQUIVALENT_VLC_FILTERS];
+
+    filter_desc_table_GetFilterTypes(filter->p_sys->psz_filter, filter_types);
+    if (ctx->fchain->filter != filter_types[0])
+        return src;
+
+    if (ctx->src_converter)
+    {
+        src = ctx->src_converter->pf_video_filter(ctx->src_converter, src);
+        if (!src)
+            return NULL;
+    }
+
+    picture_t *dst = picture_NewFromFormat(&ctx->cvpx_pool_fmt);
+    if (!dst)
+        goto error;
+
+    CVPixelBufferRef cvpx = cvpxpool_get_cvpx(ctx->cvpx_pool);
+    if (!cvpx)
+        goto error;
+
+    if (cvpxpic_attach(dst, cvpx))
+    {
+        CFRelease(cvpx);
+        goto error;
+    }
+
+    CIImage *ci_img = [CIImage imageWithCVImageBuffer: cvpxpic_get_ref(src)];
+    if (!ci_img)
+        goto error;
+
+    for (struct filter_chain *fchain = ctx->fchain;
+         fchain; fchain = fchain->next)
+    {
+        [fchain->ci_filter setValue: ci_img
+                             forKey: kCIInputImageKey];
+
+        for (unsigned int i = 0; i < NUM_FILTER_PARAM_MAX &&
+                 filter_desc_table[fchain->filter].param_descs[i].vlc; ++i)
+        {
+            NSString *ci_param_name =
+                filter_desc_table[fchain->filter].param_descs[i].ci;
+            float ci_value = vlc_atomic_load_float(fchain->ci_params + i);
+
+            [fchain->ci_filter setValue: [NSNumber numberWithFloat: ci_value]
+                                 forKey: ci_param_name];
+        }
+
+        ci_img = [fchain->ci_filter valueForKey: kCIOutputImageKey];
+    }
+
+    [ctx->ci_ctx render: ci_img
+            toIOSurface: CVPixelBufferGetIOSurface(cvpx)
+                 bounds: [ci_img extent]
+             colorSpace: ctx->color_space];
+
+    CopyInfoAndRelease(dst, src);
+
+    if (ctx->dst_converter)
+    {
+        dst = ctx->dst_converter->pf_video_filter(ctx->dst_converter, dst);
+        if (!dst)
+            return NULL;
+    }
+
+    return dst;
+
+error:
+    if (dst)
+        picture_Release(dst);
+    picture_Release(src);
+    return NULL;
+}
+
+static void
+Open_FilterInit(vlc_object_t *obj, struct filter_chain *filter)
+{
+    struct filter_param_desc const *filter_param_descs =
+        filter_desc_table[filter->filter].param_descs;
+    NSString *ci_filter_name = filter_desc_table_GetFilterName(filter->filter);
+
+    filter->ci_filter = [CIFilter filterWithName: ci_filter_name];
+
+    for (int i = 0; i < NUM_FILTER_PARAM_MAX && filter_param_descs[i].vlc; ++i)
+    {
+        NSString *ci_param_name = filter_param_descs[i].ci;
+        char const *vlc_param_name = filter_param_descs[i].vlc;
+
+        float vlc_param_val;
+        if (filter_param_descs[i].vlc_type == VLC_VAR_FLOAT)
+            vlc_param_val = var_CreateGetFloatCommand(obj, vlc_param_name);
+        else if (filter_param_descs[i].vlc_type == VLC_VAR_INTEGER)
+            vlc_param_val =
+                (float)var_CreateGetIntegerCommand(obj, vlc_param_name);
+        else
+            vlc_assert_unreachable();
+
+        vlc_atomic_init_float(filter->ci_params + i,
+                              filter_ConvertParam(vlc_param_val,
+                                                  filter_param_descs + i));
+
+        var_AddCallback(obj, filter_param_descs[i].vlc,
+                        ParamsCallback, filter);
+    }
+}
+
+static int
+Open_CreateFilters
+(vlc_object_t *obj, struct filter_chain **p_last_filter,
+ enum filter_type filter_types[NUM_MAX_EQUIVALENT_VLC_FILTERS])
+{
+    struct filter_chain *new_filter;
+
+    for (unsigned int i = 0;
+         i < NUM_MAX_EQUIVALENT_VLC_FILTERS
+             && filter_types[i] != FILTER_NONE; ++i)
+    {
+        new_filter = filter_chain_AddFilter(p_last_filter, filter_types[i]);
+        if (!new_filter)
+            return VLC_EGENERIC;
+        p_last_filter = &new_filter;
+        Open_FilterInit(obj, new_filter);
+    }
+
+    return VLC_SUCCESS;
+}
+
+static picture_t *
+CVPX_buffer_new(filter_t *converter)
+{
+    CVPixelBufferPoolRef pool = converter->owner.sys;
+    CVPixelBufferRef cvpx = cvpxpool_get_cvpx(pool);
+    if (!cvpx)
+        return NULL;
+
+    picture_t *pic = picture_NewFromFormat(&converter->fmt_out.video);
+    if (!pic || cvpxpic_attach(pic, cvpx))
+    {
+        CFRelease(cvpx);
+        return NULL;
+    }
+
+    return pic;
+}
+
+static int
+Open_AddConverters(filter_t *filter, struct ci_filters_ctx *ctx)
+{
+    ctx->src_converter = vlc_object_create(filter, sizeof(filter_t));
+    if (!ctx->src_converter)
+        goto error;
+
+    ctx->src_converter->fmt_in = filter->fmt_in;
+    ctx->src_converter->fmt_out = filter->fmt_in;
+    ctx->src_converter->fmt_out.i_codec = VLC_CODEC_CVPX_NV12;
+    ctx->src_converter->fmt_out.video.i_chroma = VLC_CODEC_CVPX_NV12;
+
+    video_format_Copy(&ctx->cvpx_pool_fmt, &filter->fmt_in.video);
+    ctx->cvpx_pool_fmt.i_chroma = VLC_CODEC_CVPX_NV12;
+    ctx->cvpx_pool = cvpxpool_create(&ctx->cvpx_pool_fmt, 3);
+    if (!ctx->cvpx_pool)
+        goto error;
+
+    ctx->src_converter->owner.sys = ctx->cvpx_pool;
+    ctx->src_converter->owner.video.buffer_new = CVPX_buffer_new;
+
+    ctx->src_converter->p_module =
+        module_need(ctx->src_converter, "video converter", NULL, false);
+    if (!ctx->src_converter->p_module)
+        goto error;
+
+    ctx->dst_converter = vlc_object_create(filter, sizeof(filter_t));
+    if (!ctx->dst_converter)
+        goto error;
+
+    ctx->dst_converter->fmt_in = filter->fmt_out;
+    ctx->dst_converter->fmt_out = filter->fmt_out;
+    ctx->dst_converter->fmt_in.i_codec = VLC_CODEC_CVPX_NV12;
+    ctx->dst_converter->fmt_in.video.i_chroma = VLC_CODEC_CVPX_NV12;
+
+    ctx->outconv_cvpx_pool =
+        cvpxpool_create(&filter->fmt_out.video, 2);
+    if (!ctx->outconv_cvpx_pool)
+        goto error;
+
+    ctx->dst_converter->owner.sys = ctx->outconv_cvpx_pool;
+    ctx->dst_converter->owner.video.buffer_new = CVPX_buffer_new;
+
+    ctx->dst_converter->p_module =
+        module_need(ctx->dst_converter, "video converter", NULL, false);
+    if (!ctx->dst_converter->p_module)
+        goto error;
+
+    return VLC_SUCCESS;
+
+error:
+    if (ctx->dst_converter)
+    {
+        if (ctx->dst_converter->p_module)
+            module_unneed(ctx->dst_converter, ctx->dst_converter->p_module);
+        vlc_object_release(ctx->dst_converter);
+        if (ctx->outconv_cvpx_pool)
+            CVPixelBufferPoolRelease(ctx->outconv_cvpx_pool);
+    }
+    if (ctx->src_converter)
+    {
+        if (ctx->src_converter->p_module)
+            module_unneed(ctx->src_converter, ctx->src_converter->p_module);
+        vlc_object_release(ctx->src_converter);
+    }
+    return VLC_EGENERIC;
+}
+
+#if MAC_OS_X_VERSION_MIN_ALLOWED <= MAC_OS_X_VERSION_10_11
+const CFStringRef kCGColorSpaceITUR_709 = CFSTR("kCGColorSpaceITUR_709");
+#endif
+
+static int
+Open(vlc_object_t *obj, char const *psz_filter)
+{
+    filter_t *filter = (filter_t *)obj;
+
+    filter->p_sys = calloc(1, sizeof(filter_sys_t));
+    if (!filter->p_sys)
+        return VLC_ENOMEM;
+
+    enum filter_type filter_types[NUM_MAX_EQUIVALENT_VLC_FILTERS];
+    filter_desc_table_GetFilterTypes(psz_filter, filter_types);
+
+    struct ci_filters_ctx *ctx = var_InheritAddress(filter, "ci-filters-ctx");
+    if (!ctx)
+    {
+        ctx = calloc(1, sizeof(*ctx));
+        if (!ctx)
+            goto error;
+
+        if (filter->fmt_in.video.i_chroma != VLC_CODEC_CVPX_NV12)
+        {
+            ctx->color_space =
+                CGColorSpaceCreateWithName(kCGColorSpaceITUR_709);
+            if (Open_AddConverters(filter, ctx))
+                goto error;
+        }
+
+        NSOpenGLContext *context =
+            var_InheritAddress(filter, "macosx-ns-opengl-context");
+        assert(context);
+
+        ctx->ci_ctx = [CIContext contextWithCGLContext: [context CGLContextObj]
+                                           pixelFormat: nil
+                                            colorSpace: nil
+                                               options: nil];
+        if (!ctx->ci_ctx)
+            goto error;
+
+        if (!ctx->cvpx_pool)
+        {
+            ctx->cvpx_pool_fmt = filter->fmt_out.video;
+            ctx->cvpx_pool = cvpxpool_create(&ctx->cvpx_pool_fmt, 2);
+            if (!ctx->cvpx_pool)
+                goto error;
+        }
+
+        if (Open_CreateFilters(obj, &ctx->fchain, filter_types))
+            goto error;
+
+        var_Create(filter->obj.parent, "ci-filters-ctx", VLC_VAR_ADDRESS);
+        var_SetAddress(filter->obj.parent, "ci-filters-ctx", ctx);
+    }
+    else if (Open_CreateFilters(obj, &ctx->fchain, filter_types))
+        goto error;
+
+    filter->p_sys->psz_filter = psz_filter;
+    filter->p_sys->ctx = ctx;
+
+    filter->pf_video_filter = Filter;
+
+    return VLC_SUCCESS;
+
+error:
+    if (ctx)
+    {
+        if (ctx->color_space)
+            CGColorSpaceRelease(ctx->color_space);
+        if (ctx->cvpx_pool)
+            CVPixelBufferPoolRelease(ctx->cvpx_pool);
+        free(ctx);
+    }
+    free(filter->p_sys);
+    return VLC_EGENERIC;
+}
+
+static int
+OpenAdjust(vlc_object_t *obj)
+{
+    return Open(obj, "adjust");
+}
+
+static int
+OpenInvert(vlc_object_t *obj)
+{
+    return Open(obj, "invert");
+}
+
+static int
+OpenPosterize(vlc_object_t *obj)
+{
+    return Open(obj, "posterize");
+}
+
+static int
+OpenSepia(vlc_object_t *obj)
+{
+    return Open(obj, "sepia");
+}
+
+static int
+OpenSharpen(vlc_object_t *obj)
+{
+    return Open(obj, "sharpen");
+}
+
+static void
+Close(vlc_object_t *obj)
+{
+    filter_t *filter = (filter_t *)obj;
+    struct ci_filters_ctx *ctx = filter->p_sys->ctx;
+    enum filter_type filter_types[NUM_MAX_EQUIVALENT_VLC_FILTERS];
+
+    filter_desc_table_GetFilterTypes(filter->p_sys->psz_filter, filter_types);
+    for (unsigned int i = 0;
+         i < NUM_MAX_EQUIVALENT_VLC_FILTERS && filter_types[i] != FILTER_NONE;
+         ++i)
+        filter_chain_RemoveFilter(&ctx->fchain, filter_types[i]);
+
+    if (!ctx->fchain)
+    {
+        if (ctx->dst_converter)
+        {
+            module_unneed(ctx->dst_converter, ctx->dst_converter->p_module);
+            vlc_object_release(ctx->dst_converter);
+            CVPixelBufferPoolRelease(ctx->outconv_cvpx_pool);
+        }
+        if (ctx->src_converter)
+        {
+            module_unneed(ctx->src_converter, ctx->src_converter->p_module);
+            vlc_object_release(ctx->src_converter);
+        }
+        if (ctx->color_space)
+            CGColorSpaceRelease(ctx->color_space);
+        CVPixelBufferPoolRelease(ctx->cvpx_pool);
+        free(ctx);
+        var_Destroy(filter->obj.parent, "ci-filters-ctx");
+    }
+    free(filter->p_sys);
+}
+
+vlc_module_begin()
+    set_capability("video filter", 0)
+    set_category(CAT_VIDEO)
+    set_subcategory(SUBCAT_VIDEO_VFILTER)
+    set_description(N_("Mac OS X hardware video filters"))
+
+    add_submodule()
+    set_callbacks(OpenAdjust, Close)
+    add_shortcut("adjust")
+
+    add_submodule()
+    set_callbacks(OpenInvert, Close)
+    add_shortcut("invert")
+
+    add_submodule()
+    set_callbacks(OpenPosterize, Close)
+    add_shortcut("posterize")
+
+    add_submodule()
+    set_callbacks(OpenSepia, Close)
+    add_shortcut("sepia")
+
+    add_submodule()
+    set_callbacks(OpenSharpen, Close)
+    add_shortcut("sharpen")
+vlc_module_end()
diff --git a/modules/video_output/macosx.m b/modules/video_output/macosx.m
index 587e13baed..3fa35c592d 100644
--- a/modules/video_output/macosx.m
+++ b/modules/video_output/macosx.m
@@ -277,6 +277,9 @@ static int Open (vlc_object_t *this)
         sys->gl->swap = OpenglSwap;
         sys->gl->getProcAddress = OurGetProcAddress;
 
+        var_Create(vd->obj.parent, "macosx-ns-opengl-context", VLC_VAR_ADDRESS);
+        var_SetAddress(vd->obj.parent, "macosx-ns-opengl-context", [sys->glView openGLContext]);
+
         const vlc_fourcc_t *subpicture_chromas;
 
         if (vlc_gl_MakeCurrent(sys->gl) != VLC_SUCCESS)
@@ -340,6 +343,7 @@ void Close (vlc_object_t *this)
                                       withObject:nil
                                    waitUntilDone:NO];
 
+        var_Destroy(vd->obj.parent, "macosx-ns-opengl-context");
         if (sys->vgl != NULL)
         {
             vlc_gl_MakeCurrent(sys->gl);



More information about the vlc-commits mailing list