modules/video_filter/puzzle_lib.c

   1 /*****************************************************************************
   2  * puzzle_lib.c : Useful functions used by puzzle game filter
   3  *****************************************************************************
   4  * Copyright (C) 2005-2009 VLC authors and VideoLAN
   5  * Copyright (C) 2013      Vianney Boyer
   6  * $Id$
   7  *
   8  * Authors: Antoine Cellerier <dionoea -at- videolan -dot- org>
   9  *          Vianney Boyer <vlcvboyer -at- gmail -dot- com>
  10  *
  11  * This program is free software; you can redistribute it and/or modify it
  12  * under the terms of the GNU Lesser General Public License as published by
  13  * the Free Software Foundation; either version 2.1 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  19  * GNU Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * along with this program; if not, write to the Free Software Foundation,
  23  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  24  *****************************************************************************/
  25
  26 /*****************************************************************************
  27  * Preamble
  28  *****************************************************************************/
  29
  30 #ifdef HAVE_CONFIG_H
  31 # include "config.h"
  32 #endif
  33 #include <math.h>
  34
  35 #include <vlc_common.h>
  36 #include <vlc_plugin.h>
  37 #include <vlc_filter.h>
  38 #include <vlc_picture.h>
  39 #include <vlc_rand.h>
  40
  41 #include "filter_picture.h"
  42
  43 #include "puzzle_lib.h"
  44
  45 const char *ppsz_shuffle_button[SHUFFLE_LINES] =
  46 {
  47 "ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo",
  48 "oooooooooooooo  oooooooooooooooooooooooooooo   oooooooo   oooooo  ooooooooooooooo",
  49 "oooooooooooooo  ooooooooooooooooooooooooooo  ooooooooo  oooooooo  ooooooooooooooo",
  50 "oooooooooooooo  ooooooooooooooooooooooooooo  ooooooooo  oooooooo  ooooooooooooooo",
  51 "oo     ooooooo  o    ooooooo  oooo  oooooo     oooooo     oooooo  oooooooo    ooo",
  52 "o  oooo oooooo   ooo  oooooo  oooo  ooooooo  ooooooooo  oooooooo  ooooooo  oo  oo",
  53 "o  ooooooooooo  oooo  oooooo  oooo  ooooooo  ooooooooo  oooooooo  oooooo  oooo  o",
  54 "o      ooooooo  oooo  oooooo  oooo  ooooooo  ooooooooo  oooooooo  oooooo        o",
  55 "oo      oooooo  oooo  oooooo  oooo  ooooooo  ooooooooo  oooooooo  oooooo  ooooooo",
  56 "oooooo  oooooo  oooo  oooooo  oooo  ooooooo  ooooooooo  oooooooo  oooooo  ooooooo",
  57 "o oooo  oooooo  oooo  oooooo  ooo   ooooooo  ooooooooo  oooooooo  ooooooo  oooo o",
  58 "oo     ooooooo  oooo  ooooooo    o  ooooooo  ooooooooo  oooooooo  oooooooo     oo",
  59 "ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo"
  60 };
  61
  62 const char *ppsz_rot_arrow_sign[ARROW_LINES] =
  63 {
  64 "    .ooo.    ",
  65 "   .o. .oo.  ",
  66 "  .o.    .o. ",
  67 " .o.      .o.",
  68 " o.        .o",
  69 ".o          .",
  70 ".o   .       ",
  71 " o. .o.      ",
  72 " .o..o.      ",
  73 "  o..o       ",
  74 "   .o.       ",
  75 "ooooo.       ",
  76 "  ..         "
  77 };
  78
  79 const char *ppsz_mir_arrow_sign[ARROW_LINES] =
  80 {
  81 "             ",
  82 "             ",
  83 "    .   .    ",
  84 "  .o.   .o.  ",
  85 " .o.     .o. ",
  86 ".o.       .o.",
  87 "ooooooooooooo",
  88 ".o.       .o.",
  89 " .o.     .o. ",
  90 "  .o.   .o.  ",
  91 "    .   .    ",
  92 "             ",
  93 "             "
  94 };
  95
  96 /*****************************************************************************
  97  * fill target image (clean memory)
  98  *****************************************************************************/
  99 void puzzle_preset_desk_background( picture_t *p_pic_out, uint8_t Y, uint8_t U, uint8_t V)
 100 {
 101     uint8_t i_c;
 102
 103     for( uint8_t i_plane = 0; i_plane < p_pic_out->i_planes; i_plane++ ) {
 104         if (i_plane == Y_PLANE)
 105             i_c = Y;
 106         else if (i_plane == U_PLANE)
 107             i_c = U;
 108         else if (i_plane == V_PLANE)
 109             i_c = V;
 110
 111         const int32_t i_dst_pitch = p_pic_out->p[i_plane].i_pitch;
 112         const int32_t i_dst_lines = p_pic_out->p[i_plane].i_lines;
 113
 114         uint8_t *p_dst = p_pic_out->p[i_plane].p_pixels;
 115
 116         for (int32_t y = 0; y < i_dst_lines; y++)
 117             memset(&p_dst[y * i_dst_pitch], i_c, i_dst_pitch);
 118     }
 119 }
 120
 121 /*****************************************************************************
 122  * draw the borders around the visible desk
 123  *****************************************************************************/
 124 void puzzle_draw_borders( filter_t *p_filter, picture_t *p_pic_in, picture_t *p_pic_out)
 125 {
 126     filter_sys_t *p_sys = p_filter->p_sys;
 127
 128     for( uint8_t i_plane = 0; i_plane < p_pic_out->i_planes; i_plane++ ) {
 129         const int32_t i_in_pitch      = p_sys->ps_pict_planes[i_plane].i_pitch;
 130         const int32_t i_out_pitch     = p_sys->ps_desk_planes[i_plane].i_pitch;
 131         const int32_t i_lines         = p_sys->ps_desk_planes[i_plane].i_lines;
 132         const int32_t i_visible_pitch = p_sys->ps_desk_planes[i_plane].i_visible_pitch;
 133         const int32_t i_border_pitch  = p_sys->ps_desk_planes[i_plane].i_border_width * p_sys->ps_desk_planes[i_plane].i_pixel_pitch;
 134         const int32_t i_border_lines  = p_sys->ps_desk_planes[i_plane].i_border_lines;
 135
 136         uint8_t *p_src = p_pic_in->p[i_plane].p_pixels;
 137         uint8_t *p_dst = p_pic_out->p[i_plane].p_pixels;
 138
 139         for (int32_t y = 0 ; y < i_border_lines; y++)
 140             memcpy( &p_dst[y * i_out_pitch], &p_src[y * i_in_pitch], i_visible_pitch);
 141
 142         for (int32_t y = i_lines - i_border_lines ; y < i_lines; y++)
 143             memcpy( &p_dst[y * i_out_pitch], &p_src[y * i_in_pitch], i_visible_pitch);
 144
 145         for (int32_t y = i_border_lines ; y < i_lines - i_border_lines; y++) {
 146             memcpy( &p_dst[y * i_out_pitch], &p_src[y * i_in_pitch], i_border_pitch);
 147             memcpy( &p_dst[y * i_out_pitch + i_visible_pitch - i_border_pitch], &p_src[y * i_in_pitch + i_visible_pitch - i_border_pitch], i_border_pitch);
 148         }
 149     }
 150 }
 151
 152 /*****************************************************************************
 153  * draw preview in a corner of the desk
 154  *****************************************************************************/
 155 void puzzle_draw_preview( filter_t *p_filter, picture_t *p_pic_in, picture_t *p_pic_out)
 156 {
 157     filter_sys_t *p_sys = p_filter->p_sys;
 158
 159     for( uint8_t  i_plane = 0; i_plane < p_pic_out->i_planes; i_plane++ ) {
 160         int32_t i_preview_offset = 0;
 161         int32_t i_preview_width  = p_sys->ps_desk_planes[i_plane].i_width * p_sys->s_current_param.i_preview_size / 100;
 162         int32_t i_preview_lines  = p_pic_out->p[i_plane].i_visible_lines * p_sys->s_current_param.i_preview_size / 100;
 163         int32_t i_pixel_pitch    = p_pic_out->p[i_plane].i_pixel_pitch;
 164
 165         const int32_t i_src_pitch  = p_pic_in->p[i_plane].i_pitch;
 166         const int32_t i_dst_pitch  = p_pic_out->p[i_plane].i_pitch;
 167
 168         uint8_t *p_src = p_pic_in->p[i_plane].p_pixels;
 169         uint8_t *p_dst = p_pic_out->p[i_plane].p_pixels;
 170
 171         switch ( p_sys->i_preview_pos ) {
 172         case 0:
 173             i_preview_offset = 0;
 174             break;
 175         case 1:
 176             i_preview_offset =
 177                 (p_sys->ps_desk_planes[i_plane].i_width - 1 - i_preview_width) * i_pixel_pitch;
 178             break;
 179         case 2:
 180             i_preview_offset =
 181                 (p_sys->ps_desk_planes[i_plane].i_width - 1 - i_preview_width) * i_pixel_pitch
 182                 + ((int32_t) ( p_sys->ps_desk_planes[i_plane].i_lines - 1 - i_preview_lines )) * i_dst_pitch;
 183             break;
 184         case 3:
 185             i_preview_offset = ((int32_t) ( p_sys->ps_desk_planes[i_plane].i_lines - 1 - i_preview_lines )) * i_dst_pitch;
 186             break;
 187         default:
 188             i_preview_offset = 0;
 189             break;
 190         }
 191
 192         for ( int32_t y = 0; y < i_preview_lines; y++ )
 193             for ( int32_t x = 0; x < i_preview_width; x++ )
 194                 memcpy( &p_dst[ y * i_dst_pitch + x * i_pixel_pitch + i_preview_offset ],
 195                         &p_src[ ( y * 100 / p_sys->s_current_param.i_preview_size ) * i_src_pitch
 196                                 + ( x * 100 / p_sys->s_current_param.i_preview_size ) * i_pixel_pitch ],
 197                         i_pixel_pitch );
 198     }
 199 }
 200
 201 /*****************************************************************************
 202  * draw sign/icon/symbol in the output picture
 203  *****************************************************************************/
 204 void puzzle_draw_sign(picture_t *p_pic_out, int32_t i_x, int32_t i_y, int32_t i_width, int32_t i_lines, const char **ppsz_sign, bool b_reverse)
 205 {
 206     plane_t *p_out = &p_pic_out->p[Y_PLANE];
 207     int32_t i_pixel_pitch    = p_pic_out->p[Y_PLANE].i_pixel_pitch;
 208
 209     uint8_t i_Y;
 210
 211     i_Y = ( p_out->p_pixels[ i_y * p_out->i_pitch + i_x ] >= 0x7F ) ? 0x00 : 0xFF;
 212
 213     for( int32_t y = 0; y < i_lines ; y++ )
 214         for( int32_t x = 0; x < i_width; x++ ) {
 215             int32_t i_dst_x = ( x + i_x ) * i_pixel_pitch;
 216             int32_t i_dst_y = y + i_y;
 217             if ( ppsz_sign[y][b_reverse?i_width-1-x:x] == 'o' ) {
 218                 if ((i_dst_x < p_out->i_visible_pitch) && (i_dst_y < p_out->i_visible_lines) && (i_dst_x >= 0 ) && (i_dst_y >= 0))
 219                     memset( &p_out->p_pixels[ i_dst_y * p_out->i_pitch + i_dst_x ],   i_Y,  p_out->i_pixel_pitch );
 220             }
 221             else if ( ppsz_sign[y][b_reverse?i_width-1-x:x] == '.' ) {
 222                 if ((i_dst_x < p_out->i_visible_pitch) && (i_dst_y < p_out->i_visible_lines) && (i_dst_x >= 0 ) && (i_dst_y >= 0))
 223                     p_out->p_pixels[ i_dst_y * p_out->i_pitch + i_dst_x ] = p_out->p_pixels[ i_dst_y * p_out->i_pitch + i_dst_x ] / 2 + i_Y / 2;
 224             }
 225         }
 226 }
 227
 228 /*****************************************************************************
 229  * draw outline rectangle in output picture
 230  *****************************************************************************/
 231 void puzzle_draw_rectangle(picture_t *p_pic_out, int32_t i_x, int32_t i_y, int32_t i_w, int32_t i_h, uint8_t i_Y, uint8_t i_U, uint8_t i_V )
 232 {
 233     uint8_t i_c;
 234
 235     for( uint8_t i_plane = 0; i_plane < p_pic_out->i_planes; i_plane++ ) {
 236         plane_t *p_oyp = &p_pic_out->p[i_plane];
 237         int32_t i_pixel_pitch    = p_pic_out->p[i_plane].i_pixel_pitch;
 238
 239         if (i_plane == Y_PLANE)
 240             i_c = i_Y;
 241         else if (i_plane == U_PLANE)
 242             i_c = i_U;
 243         else if (i_plane == V_PLANE)
 244             i_c = i_V;
 245
 246         int32_t i_x_min = (      i_x    * p_oyp->i_visible_pitch / p_pic_out->p[0].i_visible_pitch ) * i_pixel_pitch;
 247         int32_t i_x_max = ( (i_x + i_w) * p_oyp->i_visible_pitch / p_pic_out->p[0].i_visible_pitch ) * i_pixel_pitch;
 248         int32_t i_y_min =        i_y    * p_oyp->i_visible_lines / p_pic_out->p[0].i_visible_lines;
 249         int32_t i_y_max =   (i_y + i_h) * p_oyp->i_visible_lines / p_pic_out->p[0].i_visible_lines;
 250
 251         /* top line */
 252         memset( &p_oyp->p_pixels[i_y_min * p_oyp->i_pitch + i_x_min], i_c,  i_x_max - i_x_min);
 253
 254         /* left and right */
 255         for( int32_t i_dy = 1; i_dy < i_y_max - i_y_min - 1; i_dy++ ) {
 256             memset( &p_oyp->p_pixels[ (i_y_min + i_dy) * p_oyp->i_pitch + i_x_min ],   i_c,  p_oyp->i_pixel_pitch );
 257             memset( &p_oyp->p_pixels[(i_y_min + i_dy) * p_oyp->i_pitch + i_x_max - 1], i_c,  p_oyp->i_pixel_pitch );
 258         }
 259
 260         /* bottom line */
 261         memset( &p_oyp->p_pixels[(i_y_max - 1) * p_oyp->i_pitch + i_x_min], i_c,  i_x_max - i_x_min);
 262     }
 263 }
 264
 265 /*****************************************************************************
 266  * draw bold rectangle in output picture
 267  *****************************************************************************/
 268 void puzzle_fill_rectangle(picture_t *p_pic_out, int32_t i_x, int32_t i_y, int32_t i_w, int32_t i_h, uint8_t i_Y, uint8_t i_U, uint8_t i_V )
 269 {
 270     uint8_t i_c;
 271
 272     for( uint8_t i_plane = 0; i_plane < p_pic_out->i_planes; i_plane++ ) {
 273         plane_t *p_oyp = &p_pic_out->p[i_plane];
 274         int32_t i_pixel_pitch    = p_pic_out->p[i_plane].i_pixel_pitch;
 275
 276         if (i_plane == Y_PLANE)
 277             i_c = i_Y;
 278         else if (i_plane == U_PLANE)
 279             i_c = i_U;
 280         else if (i_plane == V_PLANE)
 281             i_c = i_V;
 282
 283         int32_t i_x_min = (     i_x     * p_oyp->i_visible_pitch / p_pic_out->p[0].i_visible_pitch ) * i_pixel_pitch;
 284         int32_t i_x_max = ( (i_x + i_w) * p_oyp->i_visible_pitch / p_pic_out->p[0].i_visible_pitch ) * i_pixel_pitch;
 285         int32_t i_y_min =       i_y     * p_oyp->i_visible_lines / p_pic_out->p[0].i_visible_lines;
 286         int32_t i_y_max =   (i_y + i_h) * p_oyp->i_visible_lines / p_pic_out->p[0].i_visible_lines;
 287
 288         for( int32_t i_dy = 0; i_dy < i_y_max - i_y_min; i_dy++ )
 289             memset( &p_oyp->p_pixels[(i_y_min + i_dy) * p_oyp->i_pitch + i_x_min], i_c,  i_x_max - i_x_min);
 290     }
 291 }