modules/video_output/caca.c

   1 /*****************************************************************************
   2  * caca.c: Color ASCII Art "vout display" module using libcaca
   3  *****************************************************************************
   4  * Copyright (C) 2003-2009 VLC authors and VideoLAN
   5  * $Id$
   6  *
   7  * Authors: Sam Hocevar <sam@zoy.org>
   8  *          Laurent Aimar <fenrir _AT_ videolan _DOT_ org>
   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 /*****************************************************************************
  26  * Preamble
  27  *****************************************************************************/
  28
  29 #ifdef HAVE_CONFIG_H
  30 # include "config.h"
  31 #endif
  32
  33 #include <stdnoreturn.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <vlc_common.h>
  37 #include <vlc_block.h>
  38 #include <vlc_plugin.h>
  39 #include <vlc_vout_display.h>
  40 #include <vlc_picture_pool.h>
  41 #if !defined(_WIN32) && !defined(__APPLE__)
  42 # ifdef X_DISPLAY_MISSING
  43 #  error Xlib required due to XInitThreads
  44 # endif
  45 # include <vlc_xlib.h>
  46 #endif
  47
  48 #include <caca.h>
  49
  50 /* */
  51 struct vout_display_sys_t {
  52     cucul_canvas_t *cv;
  53     caca_display_t *dp;
  54     cucul_dither_t *dither;
  55
  56     picture_pool_t *pool;
  57     block_fifo_t *fifo;
  58     vlc_thread_t thread;
  59
  60     vlc_tick_t cursor_timeout;
  61     vlc_tick_t cursor_deadline;
  62 };
  63
  64 noreturn static void *VoutDisplayEventKeyDispatch(void *data)
  65 {
  66     vout_display_t *vd = data;
  67     vout_display_sys_t *sys = vd->sys;
  68     block_fifo_t *fifo = sys->fifo;
  69
  70     for (;;) {
  71         block_t *event = block_FifoGet(fifo);
  72
  73         int cancel = vlc_savecancel();
  74         int key;
  75
  76         memcpy(&key, event->p_buffer, sizeof (key));
  77         block_Release(event);
  78         vout_window_ReportKeyPress(vd->cfg->window, key);
  79         vlc_restorecancel(cancel);
  80     }
  81 }
  82
  83 static void VoutDisplayEventKey(vout_display_sys_t *sys, int key)
  84 {
  85     block_t *event = block_Alloc(sizeof (key));
  86     if (likely(event != NULL)) {
  87         memcpy(event->p_buffer, &key, sizeof (key));
  88         block_FifoPut(sys->fifo, event);
  89     }
  90 }
  91
  92 /**
  93  * Return a pool of direct buffers
  94  */
  95 static picture_pool_t *Pool(vout_display_t *vd, unsigned count)
  96 {
  97     vout_display_sys_t *sys = vd->sys;
  98
  99     if (!sys->pool)
 100         sys->pool = picture_pool_NewFromFormat(&vd->fmt, count);
 101     return sys->pool;
 102 }
 103
 104 /**
 105  * Compute the place in canvas unit.
 106  */
 107 static void Place(vout_display_t *vd, vout_display_place_t *place)
 108 {
 109     vout_display_sys_t *sys = vd->sys;
 110
 111     vout_display_PlacePicture(place, &vd->source, vd->cfg, false);
 112
 113     const int canvas_width   = cucul_get_canvas_width(sys->cv);
 114     const int canvas_height  = cucul_get_canvas_height(sys->cv);
 115     const int display_width  = caca_get_display_width(sys->dp);
 116     const int display_height = caca_get_display_height(sys->dp);
 117
 118     if (display_width > 0 && display_height > 0) {
 119         place->x      =  place->x      * canvas_width  / display_width;
 120         place->y      =  place->y      * canvas_height / display_height;
 121         place->width  = (place->width  * canvas_width  + display_width/2)  / display_width;
 122         place->height = (place->height * canvas_height + display_height/2) / display_height;
 123     } else {
 124         place->x = 0;
 125         place->y = 0;
 126         place->width  = canvas_width;
 127         place->height = display_height;
 128     }
 129 }
 130
 131 static void Manage(vout_display_t *vd);
 132
 133 /**
 134  * Prepare a picture for display */
 135 static void Prepare(vout_display_t *vd, picture_t *picture,
 136                     subpicture_t *subpicture, vlc_tick_t date)
 137 {
 138     Manage(vd);
 139     VLC_UNUSED(date);
 140
 141     vout_display_sys_t *sys = vd->sys;
 142
 143     if (!sys->dither) {
 144         /* Create the libcaca dither object */
 145         sys->dither = cucul_create_dither(32,
 146                                             vd->source.i_visible_width,
 147                                             vd->source.i_visible_height,
 148                                             picture->p[0].i_pitch,
 149                                             vd->fmt.i_rmask,
 150                                             vd->fmt.i_gmask,
 151                                             vd->fmt.i_bmask,
 152                                             0x00000000);
 153
 154         if (!sys->dither) {
 155             msg_Err(vd, "could not create libcaca dither object");
 156             return;
 157         }
 158     }
 159
 160     vout_display_place_t place;
 161     Place(vd, &place);
 162
 163     cucul_set_color_ansi(sys->cv, CUCUL_COLOR_DEFAULT, CUCUL_COLOR_BLACK);
 164     cucul_clear_canvas(sys->cv);
 165
 166     const int crop_offset = vd->source.i_y_offset * picture->p->i_pitch +
 167                             vd->source.i_x_offset * picture->p->i_pixel_pitch;
 168     cucul_dither_bitmap(sys->cv, place.x, place.y,
 169                         place.width, place.height,
 170                         sys->dither,
 171                         &picture->p->p_pixels[crop_offset]);
 172     VLC_UNUSED(subpicture);
 173 }
 174
 175 /**
 176  * Display a picture
 177  */
 178 static void PictureDisplay(vout_display_t *vd, picture_t *picture, subpicture_t *subpicture)
 179 {
 180     vout_display_sys_t *sys = vd->sys;
 181
 182     caca_refresh_display(sys->dp);
 183     picture_Release(picture);
 184     VLC_UNUSED(subpicture);
 185 }
 186
 187 /**
 188  * Control for vout display
 189  */
 190 static int Control(vout_display_t *vd, int query, va_list args)
 191 {
 192     vout_display_sys_t *sys = vd->sys;
 193
 194     (void) args;
 195
 196     switch (query) {
 197     case VOUT_DISPLAY_CHANGE_DISPLAY_SIZE:
 198     case VOUT_DISPLAY_CHANGE_ZOOM:
 199     case VOUT_DISPLAY_CHANGE_DISPLAY_FILLED:
 200     case VOUT_DISPLAY_CHANGE_SOURCE_ASPECT:
 201         return VLC_EGENERIC;
 202
 203     case VOUT_DISPLAY_CHANGE_SOURCE_CROP:
 204         if (sys->dither)
 205             cucul_free_dither(sys->dither);
 206         sys->dither = NULL;
 207         return VLC_SUCCESS;
 208
 209     default:
 210         msg_Err(vd, "Unsupported query in vout display caca");
 211         return VLC_EGENERIC;
 212     }
 213 }
 214
 215 /* */
 216 static const struct {
 217     int caca;
 218     int vlc;
 219 } keys[] = {
 220
 221     { CACA_KEY_CTRL_A,  KEY_MODIFIER_CTRL | 'a' },
 222     { CACA_KEY_CTRL_B,  KEY_MODIFIER_CTRL | 'b' },
 223     { CACA_KEY_CTRL_C,  KEY_MODIFIER_CTRL | 'c' },
 224     { CACA_KEY_CTRL_D,  KEY_MODIFIER_CTRL | 'd' },
 225     { CACA_KEY_CTRL_E,  KEY_MODIFIER_CTRL | 'e' },
 226     { CACA_KEY_CTRL_F,  KEY_MODIFIER_CTRL | 'f' },
 227     { CACA_KEY_CTRL_G,  KEY_MODIFIER_CTRL | 'g' },
 228     { CACA_KEY_BACKSPACE, KEY_BACKSPACE },
 229     { CACA_KEY_TAB,     KEY_TAB },
 230     { CACA_KEY_CTRL_J,  KEY_MODIFIER_CTRL | 'j' },
 231     { CACA_KEY_CTRL_K,  KEY_MODIFIER_CTRL | 'k' },
 232     { CACA_KEY_CTRL_L,  KEY_MODIFIER_CTRL | 'l' },
 233     { CACA_KEY_RETURN,  KEY_ENTER },
 234
 235     { CACA_KEY_CTRL_N,  KEY_MODIFIER_CTRL | 'n' },
 236     { CACA_KEY_CTRL_O,  KEY_MODIFIER_CTRL | 'o' },
 237     { CACA_KEY_CTRL_P,  KEY_MODIFIER_CTRL | 'p' },
 238     { CACA_KEY_CTRL_Q,  KEY_MODIFIER_CTRL | 'q' },
 239     { CACA_KEY_CTRL_R,  KEY_MODIFIER_CTRL | 'r' },
 240
 241     { CACA_KEY_PAUSE,   -1 },
 242     { CACA_KEY_CTRL_T,  KEY_MODIFIER_CTRL | 't' },
 243     { CACA_KEY_CTRL_U,  KEY_MODIFIER_CTRL | 'u' },
 244     { CACA_KEY_CTRL_V,  KEY_MODIFIER_CTRL | 'v' },
 245     { CACA_KEY_CTRL_W,  KEY_MODIFIER_CTRL | 'w' },
 246     { CACA_KEY_CTRL_X,  KEY_MODIFIER_CTRL | 'x' },
 247     { CACA_KEY_CTRL_Y,  KEY_MODIFIER_CTRL | 'y' },
 248     { CACA_KEY_CTRL_Z,  KEY_MODIFIER_CTRL | 'z' },
 249
 250     { CACA_KEY_ESCAPE,  KEY_ESC },
 251     { CACA_KEY_DELETE,  KEY_DELETE },
 252
 253     { CACA_KEY_F1,      KEY_F1 },
 254     { CACA_KEY_F2,      KEY_F2 },
 255     { CACA_KEY_F3,      KEY_F3 },
 256     { CACA_KEY_F4,      KEY_F4 },
 257     { CACA_KEY_F5,      KEY_F5 },
 258     { CACA_KEY_F6,      KEY_F6 },
 259     { CACA_KEY_F7,      KEY_F7 },
 260     { CACA_KEY_F8,      KEY_F8 },
 261     { CACA_KEY_F9,      KEY_F9 },
 262     { CACA_KEY_F10,     KEY_F10 },
 263     { CACA_KEY_F11,     KEY_F11 },
 264     { CACA_KEY_F12,     KEY_F12 },
 265     { CACA_KEY_F13,     -1 },
 266     { CACA_KEY_F14,     -1 },
 267     { CACA_KEY_F15,     -1 },
 268
 269     { CACA_KEY_UP,      KEY_UP },
 270     { CACA_KEY_DOWN,    KEY_DOWN },
 271     { CACA_KEY_LEFT,    KEY_LEFT },
 272     { CACA_KEY_RIGHT,   KEY_RIGHT },
 273
 274     { CACA_KEY_INSERT,  KEY_INSERT },
 275     { CACA_KEY_HOME,    KEY_HOME },
 276     { CACA_KEY_END,     KEY_END },
 277     { CACA_KEY_PAGEUP,  KEY_PAGEUP },
 278     { CACA_KEY_PAGEDOWN,KEY_PAGEDOWN },
 279
 280     /* */
 281     { -1, -1 }
 282 };
 283
 284 static const struct {
 285     int caca;
 286     int vlc;
 287 } mouses[] = {
 288     { 1, MOUSE_BUTTON_LEFT },
 289     { 2, MOUSE_BUTTON_CENTER },
 290     { 3, MOUSE_BUTTON_RIGHT },
 291     { 4, MOUSE_BUTTON_WHEEL_UP },
 292     { 5, MOUSE_BUTTON_WHEEL_DOWN },
 293
 294     /* */
 295     { -1, -1 }
 296 };
 297
 298 #define INVALID_DEADLINE  INT64_MAX
 299
 300 /**
 301  * Proccess pending event
 302  */
 303 static void Manage(vout_display_t *vd)
 304 {
 305     vout_display_sys_t *sys = vd->sys;
 306
 307     if (sys->cursor_deadline != INVALID_DEADLINE && sys->cursor_deadline < vlc_tick_now()) {
 308         caca_set_mouse(sys->dp, 0);
 309         sys->cursor_deadline = INVALID_DEADLINE;
 310     }
 311
 312     struct caca_event ev;
 313     while (caca_get_event(sys->dp, CACA_EVENT_ANY, &ev, 0) > 0) {
 314         switch (caca_get_event_type(&ev)) {
 315         case CACA_EVENT_KEY_PRESS: {
 316             const int caca = caca_get_event_key_ch(&ev);
 317
 318             for (int i = 0; keys[i].caca != -1; i++) {
 319                 if (keys[i].caca == caca) {
 320                     const int vlc = keys[i].vlc;
 321
 322                     if (vlc >= 0)
 323                         VoutDisplayEventKey(sys, vlc);
 324                     return;
 325                 }
 326             }
 327             if (caca >= 0x20 && caca <= 0x7f) {
 328                 VoutDisplayEventKey(sys, caca);
 329                 return;
 330             }
 331             break;
 332         }
 333         case CACA_EVENT_RESIZE:
 334             break;
 335         case CACA_EVENT_MOUSE_MOTION:
 336             caca_set_mouse(sys->dp, 1);
 337             sys->cursor_deadline = vlc_tick_now() + sys->cursor_timeout;
 338             vout_window_ReportMouseMoved(vd->cfg->window,
 339                                          caca_get_event_mouse_x(&ev),
 340                                          caca_get_event_mouse_y(&ev));
 341             break;
 342         case CACA_EVENT_MOUSE_PRESS:
 343         case CACA_EVENT_MOUSE_RELEASE: {
 344             caca_set_mouse(sys->dp, 1);
 345             sys->cursor_deadline = vlc_tick_now() + sys->cursor_timeout;
 346
 347             const int caca = caca_get_event_mouse_button(&ev);
 348             for (int i = 0; mouses[i].caca != -1; i++) {
 349                 if (mouses[i].caca == caca) {
 350                     if (caca_get_event_type(&ev) == CACA_EVENT_MOUSE_PRESS)
 351                         vout_window_ReportMousePressed(vd->cfg->window,
 352                                                        mouses[i].vlc);
 353                     else
 354                         vout_window_ReportMouseReleased(vd->cfg->window,
 355                                                         mouses[i].vlc);
 356                     return;
 357                 }
 358             }
 359             break;
 360         }
 361         case CACA_EVENT_QUIT:
 362             vout_window_ReportClose(vd->cfg->window);
 363             break;
 364         default:
 365             break;
 366         }
 367     }
 368 }
 369
 370 /**
 371  * This function initializes libcaca vout method.
 372  */
 373 static int Open(vlc_object_t *object)
 374 {
 375     vout_display_t *vd = (vout_display_t *)object;
 376     vout_display_sys_t *sys;
 377
 378     if (vout_display_IsWindowed(vd))
 379         return VLC_EGENERIC;
 380 #if !defined(__APPLE__) && !defined(_WIN32)
 381 # ifndef X_DISPLAY_MISSING
 382     if (!vlc_xlib_init(object))
 383         return VLC_EGENERIC;
 384 # endif
 385 #endif
 386
 387 #if defined(_WIN32)
 388     CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
 389     SMALL_RECT rect;
 390     COORD coord;
 391     HANDLE hstdout;
 392
 393     if (!AllocConsole()) {
 394         msg_Err(vd, "cannot create console");
 395         return VLC_EGENERIC;
 396     }
 397
 398     hstdout =
 399         CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,
 400                                   FILE_SHARE_READ | FILE_SHARE_WRITE,
 401                                   NULL, CONSOLE_TEXTMODE_BUFFER, NULL);
 402     if (!hstdout || hstdout == INVALID_HANDLE_VALUE) {
 403         msg_Err(vd, "cannot create screen buffer");
 404         FreeConsole();
 405         return VLC_EGENERIC;
 406     }
 407
 408     if (!SetConsoleActiveScreenBuffer(hstdout)) {
 409         msg_Err(vd, "cannot set active screen buffer");
 410         FreeConsole();
 411         return VLC_EGENERIC;
 412     }
 413
 414     coord = GetLargestConsoleWindowSize(hstdout);
 415     msg_Dbg(vd, "SetConsoleWindowInfo: %ix%i", coord.X, coord.Y);
 416
 417     /* Force size for now */
 418     coord.X = 100;
 419     coord.Y = 40;
 420
 421     if (!SetConsoleScreenBufferSize(hstdout, coord))
 422         msg_Warn(vd, "SetConsoleScreenBufferSize %i %i",
 423                   coord.X, coord.Y);
 424
 425     /* Get the current screen buffer size and window position. */
 426     if (GetConsoleScreenBufferInfo(hstdout, &csbiInfo)) {
 427         rect.Top = 0; rect.Left = 0;
 428         rect.Right = csbiInfo.dwMaximumWindowSize.X - 1;
 429         rect.Bottom = csbiInfo.dwMaximumWindowSize.Y - 1;
 430         if (!SetConsoleWindowInfo(hstdout, TRUE, &rect))
 431             msg_Dbg(vd, "SetConsoleWindowInfo failed: %ix%i",
 432                      rect.Right, rect.Bottom);
 433     }
 434 #endif
 435
 436     /* Allocate structure */
 437     vd->sys = sys = calloc(1, sizeof(*sys));
 438     if (!sys)
 439         goto error;
 440
 441     sys->cv = cucul_create_canvas(0, 0);
 442     if (!sys->cv) {
 443         msg_Err(vd, "cannot initialize libcucul");
 444         goto error;
 445     }
 446
 447     const char *driver = NULL;
 448 #ifdef __APPLE__
 449     // Make sure we don't try to open a window.
 450     driver = "ncurses";
 451 #endif
 452
 453     sys->dp = caca_create_display_with_driver(sys->cv, driver);
 454     if (!sys->dp) {
 455         msg_Err(vd, "cannot initialize libcaca");
 456         goto error;
 457     }
 458
 459     char *title = var_InheritString(vd, "video-title");
 460     caca_set_display_title(sys->dp,
 461         (title != NULL) ? title : VOUT_TITLE "(Colour AsCii Art)");
 462     free(title);
 463
 464     block_fifo_t *fifo = block_FifoNew();
 465     if (likely(fifo != NULL)) {
 466         sys->fifo = fifo;
 467
 468         if (vlc_clone(&sys->thread, VoutDisplayEventKeyDispatch, vd,
 469                       VLC_THREAD_PRIORITY_LOW)) {
 470             block_FifoRelease(fifo);
 471             sys->fifo = NULL;
 472         }
 473     }
 474
 475     sys->cursor_timeout = VLC_TICK_FROM_MS( var_InheritInteger(vd, "mouse-hide-timeout") );
 476     sys->cursor_deadline = INVALID_DEADLINE;
 477
 478     /* Fix format */
 479     video_format_t fmt = vd->fmt;
 480     if (fmt.i_chroma != VLC_CODEC_RGB32) {
 481         fmt.i_chroma = VLC_CODEC_RGB32;
 482         fmt.i_rmask = 0x00ff0000;
 483         fmt.i_gmask = 0x0000ff00;
 484         fmt.i_bmask = 0x000000ff;
 485     }
 486
 487     /* Setup vout_display now that everything is fine */
 488     vd->fmt = fmt;
 489
 490     vd->pool    = Pool;
 491     vd->prepare = Prepare;
 492     vd->display = PictureDisplay;
 493     vd->control = Control;
 494
 495     /* Fix initial state */
 496     caca_refresh_display(sys->dp);
 497
 498     return VLC_SUCCESS;
 499
 500 error:
 501     if (sys) {
 502         if (sys->pool)
 503             picture_pool_Release(sys->pool);
 504         if (sys->dither)
 505             cucul_free_dither(sys->dither);
 506         if (sys->dp)
 507             caca_free_display(sys->dp);
 508         if (sys->cv)
 509             cucul_free_canvas(sys->cv);
 510
 511         free(sys);
 512     }
 513 #if defined(_WIN32)
 514     FreeConsole();
 515 #endif
 516     return VLC_EGENERIC;
 517 }
 518
 519 /**
 520  * Close a libcaca video output
 521  */
 522 static void Close(vlc_object_t *object)
 523 {
 524     vout_display_t *vd = (vout_display_t *)object;
 525     vout_display_sys_t *sys = vd->sys;
 526
 527     if (sys->fifo != NULL) {
 528         vlc_cancel(sys->thread);
 529         vlc_join(sys->thread, NULL);
 530         block_FifoRelease(sys->fifo);
 531     }
 532     if (sys->pool)
 533         picture_pool_Release(sys->pool);
 534     if (sys->dither)
 535         cucul_free_dither(sys->dither);
 536     caca_free_display(sys->dp);
 537     cucul_free_canvas(sys->cv);
 538
 539 #if defined(_WIN32)
 540     FreeConsole();
 541 #endif
 542
 543     free(sys);
 544 }
 545
 546 /*****************************************************************************
 547  * Module descriptor
 548  *****************************************************************************/
 549 vlc_module_begin()
 550     set_shortname("Caca")
 551     set_category(CAT_VIDEO)
 552     set_subcategory(SUBCAT_VIDEO_VOUT)
 553     set_description(N_("Color ASCII art video output"))
 554     set_capability("vout display", 15)
 555     set_callbacks(Open, Close)
 556 vlc_module_end()