modules/video_output/vmem.c

   1 /*****************************************************************************
   2  * vmem.c: memory video driver for vlc
   3  *****************************************************************************
   4  * Copyright (C) 2008 VLC authors and VideoLAN
   5  * Copyright (C) 2010 Rémi Denis-Courmont
   6  *
   7  * Authors: Sam Hocevar <sam@zoy.org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU Lesser General Public License as published by
  11  * the Free Software Foundation; either version 2.1 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17  * GNU Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public License
  20  * along with this program; if not, write to the Free Software Foundation,
  21  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27
  28 #ifdef HAVE_CONFIG_H
  29 # include "config.h"
  30 #endif
  31
  32 #include <assert.h>
  33
  34 #include <vlc_common.h>
  35 #include <vlc_plugin.h>
  36 #include <vlc_vout_display.h>
  37
  38 /*****************************************************************************
  39  * Module descriptor
  40  *****************************************************************************/
  41 #define T_WIDTH N_("Width")
  42 #define LT_WIDTH N_("Video memory buffer width.")
  43
  44 #define T_HEIGHT N_("Height")
  45 #define LT_HEIGHT N_("Video memory buffer height.")
  46
  47 #define T_PITCH N_("Pitch")
  48 #define LT_PITCH N_("Video memory buffer pitch in bytes.")
  49
  50 #define T_CHROMA N_("Chroma")
  51 #define LT_CHROMA N_("Output chroma for the memory image as a 4-character " \
  52                       "string, eg. \"RV32\".")
  53
  54 static int Open(vout_display_t *vd, const vout_display_cfg_t *cfg,
  55                 video_format_t *fmtp, vlc_video_context *context);
  56 static void Close(vout_display_t *vd);
  57
  58 vlc_module_begin()
  59     set_description(N_("Video memory output"))
  60     set_shortname(N_("Video memory"))
  61
  62     set_category(CAT_VIDEO)
  63     set_subcategory(SUBCAT_VIDEO_VOUT)
  64
  65     add_integer("vmem-width", 320, T_WIDTH, LT_WIDTH, false)
  66         change_private()
  67     add_integer("vmem-height", 200, T_HEIGHT, LT_HEIGHT, false)
  68         change_private()
  69     add_integer("vmem-pitch", 640, T_PITCH, LT_PITCH, false)
  70         change_private()
  71     add_string("vmem-chroma", "RV16", T_CHROMA, LT_CHROMA, true)
  72         change_private()
  73     add_obsolete_string("vmem-lock") /* obsoleted since 1.1.1 */
  74     add_obsolete_string("vmem-unlock") /* obsoleted since 1.1.1 */
  75     add_obsolete_string("vmem-data") /* obsoleted since 1.1.1 */
  76
  77     set_callback_display(Open, 0)
  78 vlc_module_end()
  79
  80 /*****************************************************************************
  81  * Local prototypes
  82  *****************************************************************************/
  83 typedef struct
  84 {
  85     void *id;
  86 } picture_sys_t;
  87
  88 /* NOTE: the callback prototypes must match those of LibVLC */
  89 struct vout_display_sys_t {
  90     void *opaque;
  91     void *pic_opaque;
  92     void *(*lock)(void *sys, void **plane);
  93     void (*unlock)(void *sys, void *id, void *const *plane);
  94     void (*display)(void *sys, void *id);
  95     void (*cleanup)(void *sys);
  96
  97     unsigned pitches[PICTURE_PLANE_MAX];
  98     unsigned lines[PICTURE_PLANE_MAX];
  99 };
 100
 101 typedef unsigned (*vlc_format_cb)(void **, char *, unsigned *, unsigned *,
 102                                   unsigned *, unsigned *);
 103
 104 static void           Prepare(vout_display_t *, picture_t *, subpicture_t *, vlc_tick_t);
 105 static void           Display(vout_display_t *, picture_t *);
 106 static int            Control(vout_display_t *, int);
 107
 108 static const struct vlc_display_operations ops = {
 109     Close, Prepare, Display, Control, NULL, NULL,
 110 };
 111
 112 /*****************************************************************************
 113  * Open: allocates video thread
 114  *****************************************************************************
 115  * This function allocates and initializes a vout method.
 116  *****************************************************************************/
 117 static int Open(vout_display_t *vd, const vout_display_cfg_t *cfg,
 118                 video_format_t *fmtp, vlc_video_context *context)
 119 {
 120     vout_display_sys_t *sys = malloc(sizeof(*sys));
 121     if (unlikely(!sys))
 122         return VLC_ENOMEM;
 123
 124     /* Get the callbacks */
 125     vlc_format_cb setup = var_InheritAddress(vd, "vmem-setup");
 126
 127     sys->lock = var_InheritAddress(vd, "vmem-lock");
 128     if (sys->lock == NULL) {
 129         msg_Err(vd, "missing lock callback");
 130         free(sys);
 131         return VLC_EGENERIC;
 132     }
 133     sys->unlock = var_InheritAddress(vd, "vmem-unlock");
 134     sys->display = var_InheritAddress(vd, "vmem-display");
 135     sys->cleanup = var_InheritAddress(vd, "vmem-cleanup");
 136     sys->opaque = var_InheritAddress(vd, "vmem-data");
 137
 138     /* Define the video format */
 139     video_format_t fmt;
 140     video_format_ApplyRotation(&fmt, vd->source);
 141
 142     if (setup != NULL) {
 143         char chroma[5];
 144
 145         memcpy(chroma, &fmt.i_chroma, 4);
 146         chroma[4] = '\0';
 147         memset(sys->pitches, 0, sizeof(sys->pitches));
 148         memset(sys->lines, 0, sizeof(sys->lines));
 149
 150         unsigned widths[2], heights[2];
 151         widths[0] = fmt.i_width;
 152         widths[1] = fmt.i_visible_width;
 153
 154         heights[0] = fmt.i_height;
 155         heights[1] = fmt.i_visible_height;
 156
 157         if (setup(&sys->opaque, chroma, widths, heights,
 158                            sys->pitches, sys->lines) == 0) {
 159             msg_Err(vd, "video format setup failure (no pictures)");
 160             free(sys);
 161             return VLC_EGENERIC;
 162         }
 163         fmt.i_chroma = vlc_fourcc_GetCodecFromString(VIDEO_ES, chroma);
 164         fmt.i_width = widths[0];
 165         fmt.i_height = heights[0];
 166
 167     } else {
 168         char *chroma = var_InheritString(vd, "vmem-chroma");
 169         fmt.i_chroma = vlc_fourcc_GetCodecFromString(VIDEO_ES, chroma);
 170         free(chroma);
 171
 172         fmt.i_width  = var_InheritInteger(vd, "vmem-width");
 173         fmt.i_height = var_InheritInteger(vd, "vmem-height");
 174         sys->pitches[0] = var_InheritInteger(vd, "vmem-pitch");
 175         sys->lines[0] = fmt.i_height;
 176         for (size_t i = 1; i < PICTURE_PLANE_MAX; i++)
 177         {
 178             sys->pitches[i] = sys->pitches[0];
 179             sys->lines[i] = sys->lines[0];
 180         }
 181         sys->cleanup = NULL;
 182     }
 183     fmt.i_x_offset = fmt.i_y_offset = 0;
 184     fmt.i_visible_width = fmt.i_width;
 185     fmt.i_visible_height = fmt.i_height;
 186
 187     if (!fmt.i_chroma) {
 188         msg_Err(vd, "vmem-chroma should be 4 characters long");
 189         free(sys);
 190         return VLC_EGENERIC;
 191     }
 192
 193     /* Define the bitmasks */
 194     switch (fmt.i_chroma)
 195     {
 196     case VLC_CODEC_RGB15:
 197         fmt.i_rmask = 0x001f;
 198         fmt.i_gmask = 0x03e0;
 199         fmt.i_bmask = 0x7c00;
 200         break;
 201     case VLC_CODEC_RGB16:
 202         fmt.i_rmask = 0x001f;
 203         fmt.i_gmask = 0x07e0;
 204         fmt.i_bmask = 0xf800;
 205         break;
 206     case VLC_CODEC_RGB24:
 207     case VLC_CODEC_RGB32:
 208         fmt.i_rmask = 0xff0000;
 209         fmt.i_gmask = 0x00ff00;
 210         fmt.i_bmask = 0x0000ff;
 211         break;
 212     default:
 213         fmt.i_rmask = 0;
 214         fmt.i_gmask = 0;
 215         fmt.i_bmask = 0;
 216         break;
 217     }
 218
 219     /* */
 220     *fmtp = fmt;
 221
 222     vd->sys     = sys;
 223     vd->ops     = &ops;
 224
 225     (void) cfg; (void) context;
 226     return VLC_SUCCESS;
 227 }
 228
 229 static void Close(vout_display_t *vd)
 230 {
 231     vout_display_sys_t *sys = vd->sys;
 232
 233     if (sys->cleanup)
 234         sys->cleanup(sys->opaque);
 235     free(sys);
 236 }
 237
 238 static void Prepare(vout_display_t *vd, picture_t *pic, subpicture_t *subpic,
 239                     vlc_tick_t date)
 240 {
 241     VLC_UNUSED(date);
 242     vout_display_sys_t *sys = vd->sys;
 243     picture_resource_t rsc = { .p_sys = NULL };
 244     void *planes[PICTURE_PLANE_MAX];
 245
 246     sys->pic_opaque = sys->lock(sys->opaque, planes);
 247
 248     picture_t *locked = picture_NewFromResource(vd->fmt, &rsc);
 249     if (likely(locked != NULL)) {
 250         for (unsigned i = 0; i < PICTURE_PLANE_MAX; i++) {
 251             locked->p[i].p_pixels = planes[i];
 252             locked->p[i].i_lines  = sys->lines[i];
 253             locked->p[i].i_pitch  = sys->pitches[i];
 254         }
 255
 256         picture_CopyPixels(locked, pic);
 257         picture_Release(locked);
 258     }
 259
 260     if (sys->unlock != NULL)
 261         sys->unlock(sys->opaque, sys->pic_opaque, planes);
 262
 263     (void) subpic;
 264 }
 265
 266 static void Display(vout_display_t *vd, picture_t *pic)
 267 {
 268     vout_display_sys_t *sys = vd->sys;
 269     VLC_UNUSED(pic);
 270
 271     if (sys->display != NULL)
 272         sys->display(sys->opaque, sys->pic_opaque);
 273 }
 274
 275 static int Control(vout_display_t *vd, int query)
 276 {
 277     (void) vd;
 278
 279     switch (query) {
 280         case VOUT_DISPLAY_CHANGE_DISPLAY_SIZE:
 281         case VOUT_DISPLAY_CHANGE_DISPLAY_FILLED:
 282         case VOUT_DISPLAY_CHANGE_ZOOM:
 283         case VOUT_DISPLAY_CHANGE_SOURCE_ASPECT:
 284         case VOUT_DISPLAY_CHANGE_SOURCE_CROP:
 285             return VLC_SUCCESS;
 286     }
 287     return VLC_EGENERIC;
 288 }