modules/video_chroma/cvpx.c

   1 /*****************************************************************************
   2  * cvpx.c: core video buffer to picture converter
   3  *****************************************************************************
   4  * Copyright (C) 2015-2017 VLC authors, VideoLAN and VideoLabs
   5  *
   6  * Authors: Felix Paul Kühne <fkuehne at videolan dot org>
   7  *          Thomas Guillem <thomas@gllm.fr>
   8  *          Victorien Le Couviour--Tuffet <victorien.lecouiour.tuffet@gmail.com>
   9  *
  10  * This program is free software; you can redistribute it and/or modify it
  11  * under the terms of the GNU Lesser General Public License as published by
  12  * the Free Software Foundation; either version 2.1 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18  * GNU Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public License
  21  * along with this program; if not, write to the Free Software Foundation,
  22  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 #include <QuartzCore/QuartzCore.h>
  26
  27 #ifdef HAVE_CONFIG_H
  28 # include "config.h"
  29 #endif
  30
  31 #include <TargetConditionals.h>
  32
  33 #include <vlc_common.h>
  34 #include <vlc_plugin.h>
  35 #include <vlc_filter.h>
  36 #include <vlc_picture.h>
  37 #include <vlc_modules.h>
  38 #include "../codec/vt_utils.h"
  39
  40 static int Open(vlc_object_t *);
  41 static void Close(vlc_object_t *);
  42
  43 #if !TARGET_OS_IPHONE
  44 static int Open_CVPX_to_CVPX(vlc_object_t *);
  45 static void Close_CVPX_to_CVPX(vlc_object_t *);
  46 #endif
  47
  48 vlc_module_begin ()
  49     set_description("Conversions from/to CoreVideo buffers")
  50     set_capability("video converter", 10)
  51     set_callbacks(Open, Close)
  52
  53 #if TARGET_OS_IPHONE
  54 vlc_module_end ()
  55
  56 struct filter_sys_t
  57 {
  58     filter_t *p_sw_filter;
  59     CVPixelBufferPoolRef pool;
  60 };
  61
  62 #else
  63     add_submodule()
  64     set_description("Conversions between CoreVideo buffers")
  65     set_callbacks(Open_CVPX_to_CVPX, Close_CVPX_to_CVPX)
  66 vlc_module_end ()
  67
  68 struct filter_sys_t
  69 {
  70     union
  71     {
  72         struct
  73         {
  74             filter_t *p_sw_filter;
  75             CVPixelBufferPoolRef pool;
  76         };
  77
  78         VTPixelTransferSessionRef vttransfer;
  79     };
  80 };
  81 #endif
  82
  83 /********************************
  84  * CVPX to/from I420 conversion *
  85  ********************************/
  86
  87 static picture_t *CVPX_TO_I420_Filter(filter_t *p_filter, picture_t *src)
  88 {
  89     filter_sys_t *p_sys = p_filter->p_sys;
  90     filter_t *p_sw_filter = p_sys->p_sw_filter;
  91     assert(p_sw_filter != NULL);
  92     picture_t *dst = NULL;
  93
  94     picture_t *src_sw =
  95         cvpxpic_create_mapped(&p_sw_filter->fmt_in.video, cvpxpic_get_ref(src),
  96                               true);
  97
  98     if (!src_sw)
  99     {
 100         picture_Release(src);
 101         return NULL;
 102     }
 103     picture_CopyProperties(src_sw, src);
 104     picture_Release(src);
 105
 106     dst = p_sw_filter->pf_video_filter(p_sw_filter, src_sw);
 107
 108     return dst;
 109 }
 110
 111 static picture_t *CVPX_buffer_new(filter_t *p_sw_filter)
 112 {
 113     filter_t *p_filter = p_sw_filter->owner.sys;
 114     filter_sys_t *p_sys = p_filter->p_sys;
 115
 116     CVPixelBufferRef cvpx = cvpxpool_get_cvpx(p_sys->pool);
 117     if (cvpx == NULL)
 118         return NULL;
 119
 120     picture_t *pic =
 121         cvpxpic_create_mapped(&p_sw_filter->fmt_out.video, cvpx, false);
 122     CFRelease(cvpx);
 123     return pic;
 124 }
 125
 126 static picture_t *I420_TO_CVPX_Filter(filter_t *p_filter, picture_t *src)
 127 {
 128     filter_sys_t *p_sys = p_filter->p_sys;
 129     filter_t *p_sw_filter = p_sys->p_sw_filter;
 130
 131     picture_t *sw_dst = p_sw_filter->pf_video_filter(p_sw_filter, src);
 132     if (sw_dst == NULL)
 133         return NULL;
 134
 135     return cvpxpic_unmap(sw_dst);
 136 }
 137
 138 static void Close(vlc_object_t *obj)
 139 {
 140     filter_t *p_filter = (filter_t *)obj;
 141     filter_sys_t *p_sys = p_filter->p_sys;
 142
 143     if (p_sys->p_sw_filter != NULL)
 144     {
 145         module_unneed(p_sys->p_sw_filter, p_sys->p_sw_filter->p_module);
 146         vlc_object_release(p_sys->p_sw_filter);
 147     }
 148
 149     if (p_sys->pool != NULL)
 150         CVPixelBufferPoolRelease(p_sys->pool);
 151     free(p_sys);
 152 }
 153
 154 static int Open(vlc_object_t *obj)
 155 {
 156     filter_t *p_filter = (filter_t *)obj;
 157
 158     if (p_filter->fmt_in.video.i_height != p_filter->fmt_out.video.i_height
 159         || p_filter->fmt_in.video.i_width != p_filter->fmt_out.video.i_width)
 160         return VLC_EGENERIC;
 161
 162 #define CASE_CVPX_INPUT(x) \
 163     case VLC_CODEC_CVPX_##x: \
 164         if (p_filter->fmt_out.video.i_chroma != VLC_CODEC_I420) \
 165             return VLC_EGENERIC; \
 166         p_filter->pf_video_filter = CVPX_TO_I420_Filter; \
 167         i_sw_filter_in_chroma = VLC_CODEC_##x; \
 168         i_sw_filter_out_chroma = VLC_CODEC_I420; \
 169         sw_filter_owner = p_filter->owner; \
 170         b_need_pool = false;
 171
 172 #define CASE_CVPX_OUTPUT(x) \
 173     case VLC_CODEC_CVPX_##x: \
 174         if (p_filter->fmt_in.video.i_chroma != VLC_CODEC_I420) \
 175             return VLC_EGENERIC; \
 176         p_filter->pf_video_filter = I420_TO_CVPX_Filter; \
 177         i_sw_filter_in_chroma = VLC_CODEC_I420; \
 178         i_sw_filter_out_chroma = VLC_CODEC_##x; \
 179         sw_filter_owner.sys = p_filter; \
 180         sw_filter_owner.video.buffer_new = CVPX_buffer_new; \
 181         b_need_pool = true;
 182
 183     bool b_need_pool;
 184     vlc_fourcc_t i_sw_filter_in_chroma = 0, i_sw_filter_out_chroma = 0;
 185     filter_owner_t sw_filter_owner = {};
 186     switch (p_filter->fmt_in.video.i_chroma)
 187     {
 188         CASE_CVPX_INPUT(NV12)
 189             break;
 190         CASE_CVPX_INPUT(UYVY)
 191             break;
 192         CASE_CVPX_INPUT(I420)
 193             break;
 194         default:
 195             switch (p_filter->fmt_out.video.i_chroma)
 196             {
 197                 CASE_CVPX_OUTPUT(NV12)
 198                     break;
 199                 CASE_CVPX_OUTPUT(UYVY)
 200                     break;
 201                 CASE_CVPX_OUTPUT(I420)
 202                     break;
 203                 default:
 204                     return VLC_EGENERIC;
 205             }
 206     }
 207
 208     filter_sys_t *p_sys = p_filter->p_sys = malloc(sizeof(filter_sys_t));
 209
 210     if (unlikely(!p_sys))
 211         return VLC_ENOMEM;
 212
 213     p_sys->p_sw_filter = NULL;
 214     p_sys->pool = NULL;
 215
 216     if (b_need_pool
 217      && (p_sys->pool = cvpxpool_create(&p_filter->fmt_out.video, 3)) == NULL)
 218         goto error;
 219
 220     filter_t *p_sw_filter = vlc_object_create(p_filter, sizeof(filter_t));
 221     if (unlikely(p_sw_filter == NULL))
 222         goto error;
 223
 224     p_sw_filter->fmt_in = p_filter->fmt_in;
 225     p_sw_filter->fmt_out = p_filter->fmt_out;
 226     p_sw_filter->fmt_in.i_codec = p_sw_filter->fmt_in.video.i_chroma
 227                                 = i_sw_filter_in_chroma;
 228     p_sw_filter->fmt_out.i_codec = p_sw_filter->fmt_out.video.i_chroma
 229                                  = i_sw_filter_out_chroma;
 230
 231     p_sw_filter->owner = sw_filter_owner;
 232     p_sw_filter->p_module = module_need(p_sw_filter, "video converter",
 233                                         NULL, false);
 234     if (p_sw_filter->p_module == NULL)
 235     {
 236         vlc_object_release(p_sw_filter);
 237         goto error;
 238     }
 239     p_sys->p_sw_filter = p_sw_filter;
 240
 241
 242     return VLC_SUCCESS;
 243
 244 error:
 245     Close(obj);
 246     return VLC_EGENERIC;
 247 #undef CASE_CVPX_INPUT
 248 #undef CASE_CVPX_OUTPUT
 249 }
 250
 251 /***************************
 252  * CVPX to CVPX conversion *
 253  ***************************/
 254
 255 #if !TARGET_OS_IPHONE
 256
 257 static picture_t *
 258 Filter(filter_t *filter, picture_t *src)
 259 {
 260     CVPixelBufferRef src_cvpx = cvpxpic_get_ref(src);
 261     assert(src_cvpx);
 262
 263     picture_t *dst = filter_NewPicture(filter);
 264     if (!dst)
 265     {
 266         picture_Release(src);
 267         return NULL;
 268     }
 269
 270     CVPixelBufferRef dst_cvpx = cvpxpic_get_ref(dst);
 271     assert(dst_cvpx);
 272
 273     if (VTPixelTransferSessionTransferImage(filter->p_sys->vttransfer,
 274                                             src_cvpx, dst_cvpx) != noErr)
 275     {
 276         picture_Release(dst);
 277         picture_Release(src);
 278         return NULL;
 279     }
 280
 281     picture_CopyProperties(dst, src);
 282     picture_Release(src);
 283     return dst;
 284 }
 285
 286 static vlc_fourcc_t const supported_chromas[] = { VLC_CODEC_CVPX_BGRA,
 287                                                   VLC_CODEC_CVPX_I420,
 288                                                   VLC_CODEC_CVPX_NV12,
 289                                                   VLC_CODEC_CVPX_UYVY };
 290
 291 static int
 292 Open_CVPX_to_CVPX(vlc_object_t *obj)
 293 {
 294     filter_t *filter = (filter_t *)obj;
 295
 296     unsigned int i;
 297 #define CHECK_CHROMA(fourcc) \
 298     i = 0; \
 299     while (i < ARRAY_SIZE(supported_chromas) && \
 300            fourcc != supported_chromas[i]) \
 301         ++i; \
 302     if (i == ARRAY_SIZE(supported_chromas)) \
 303         return VLC_EGENERIC; \
 304
 305     CHECK_CHROMA(filter->fmt_in.video.i_chroma)
 306     CHECK_CHROMA(filter->fmt_out.video.i_chroma)
 307 #undef CHECK_CHROMA
 308
 309     filter->p_sys = calloc(1, sizeof(filter_sys_t));
 310     if (!filter->p_sys)
 311         return VLC_ENOMEM;
 312
 313     if (VTPixelTransferSessionCreate(NULL, &filter->p_sys->vttransfer)
 314         != noErr)
 315     {
 316         free(filter->p_sys);
 317         return VLC_EGENERIC;
 318     }
 319
 320     filter->pf_video_filter = Filter;
 321
 322     return VLC_SUCCESS;
 323 }
 324
 325 static void
 326 Close_CVPX_to_CVPX(vlc_object_t *obj)
 327 {
 328     filter_t *filter = (filter_t *)obj;
 329
 330     VTPixelTransferSessionInvalidate(filter->p_sys->vttransfer);
 331     CFRelease(filter->p_sys->vttransfer);
 332     free(filter->p_sys);
 333 }
 334
 335 #endif