modules/video_filter/croppadd.c

   1 /*****************************************************************************
   2  * croppadd.c: Crop/Padd image filter
   3  *****************************************************************************
   4  * Copyright (C) 2008 VLC authors and VideoLAN
   5  *
   6  * Authors: Antoine Cellerier <dionoea @t videolan dot org>
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU Lesser General Public License as published by
  10  * the Free Software Foundation; either version 2.1 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16  * GNU Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public License
  19  * along with this program; if not, write to the Free Software Foundation,
  20  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  21  *****************************************************************************/
  22
  23 /*****************************************************************************
  24  * Preamble
  25  *****************************************************************************/
  26 #ifdef HAVE_CONFIG_H
  27 # include "config.h"
  28 #endif
  29
  30 #include <limits.h> /* INT_MAX */
  31
  32 #include <vlc_common.h>
  33 #include <vlc_plugin.h>
  34 #include <vlc_filter.h>
  35 #include <vlc_picture.h>
  36 #include "filter_picture.h"
  37
  38 /****************************************************************************
  39  * Local prototypes
  40  ****************************************************************************/
  41 static int  OpenFilter ( vlc_object_t * );
  42 static void CloseFilter( vlc_object_t * );
  43
  44 static picture_t *Filter( filter_t *, picture_t * );
  45
  46 #define CROPTOP_TEXT N_( "Pixels to crop from top" )
  47 #define CROPTOP_LONGTEXT N_( \
  48     "Number of pixels to crop from the top of the image." )
  49 #define CROPBOTTOM_TEXT N_( "Pixels to crop from bottom" )
  50 #define CROPBOTTOM_LONGTEXT N_( \
  51     "Number of pixels to crop from the bottom of the image." )
  52 #define CROPLEFT_TEXT N_( "Pixels to crop from left" )
  53 #define CROPLEFT_LONGTEXT N_( \
  54     "Number of pixels to crop from the left of the image." )
  55 #define CROPRIGHT_TEXT N_( "Pixels to crop from right" )
  56 #define CROPRIGHT_LONGTEXT N_( \
  57     "Number of pixels to crop from the right of the image." )
  58
  59 #define PADDTOP_TEXT N_( "Pixels to padd to top" )
  60 #define PADDTOP_LONGTEXT N_( \
  61     "Number of pixels to padd to the top of the image after cropping." )
  62 #define PADDBOTTOM_TEXT N_( "Pixels to padd to bottom" )
  63 #define PADDBOTTOM_LONGTEXT N_( \
  64     "Number of pixels to padd to the bottom of the image after cropping." )
  65 #define PADDLEFT_TEXT N_( "Pixels to padd to left" )
  66 #define PADDLEFT_LONGTEXT N_( \
  67     "Number of pixels to padd to the left of the image after cropping." )
  68 #define PADDRIGHT_TEXT N_( "Pixels to padd to right" )
  69 #define PADDRIGHT_LONGTEXT N_( \
  70     "Number of pixels to padd to the right of the image after cropping." )
  71
  72 #define CFG_PREFIX "croppadd-"
  73
  74 /*****************************************************************************
  75  * Module descriptor
  76  *****************************************************************************/
  77 vlc_module_begin ()
  78     set_shortname( N_("Croppadd") )
  79     set_description( N_("Video cropping filter") )
  80     set_capability( "video filter", 0 )
  81     set_callbacks( OpenFilter, CloseFilter )
  82
  83     set_category( CAT_VIDEO )
  84     set_subcategory( SUBCAT_VIDEO_VFILTER );
  85
  86     set_section( N_("Crop"), NULL )
  87         add_integer_with_range( CFG_PREFIX "croptop", 0, 0, INT_MAX,
  88                                 CROPTOP_TEXT, CROPTOP_LONGTEXT, false )
  89         add_integer_with_range( CFG_PREFIX "cropbottom", 0, 0, INT_MAX,
  90                                 CROPBOTTOM_TEXT, CROPBOTTOM_LONGTEXT, false )
  91         add_integer_with_range( CFG_PREFIX "cropleft", 0, 0, INT_MAX,
  92                                 CROPLEFT_TEXT, CROPLEFT_LONGTEXT, false )
  93         add_integer_with_range( CFG_PREFIX "cropright", 0, 0, INT_MAX,
  94                                 CROPRIGHT_TEXT, CROPRIGHT_LONGTEXT, false )
  95
  96     set_section( N_("Padd"), NULL )
  97         add_integer_with_range( CFG_PREFIX "paddtop", 0, 0, INT_MAX,
  98                                 PADDTOP_TEXT, PADDTOP_LONGTEXT, false )
  99         add_integer_with_range( CFG_PREFIX "paddbottom", 0, 0, INT_MAX,
 100                                 PADDBOTTOM_TEXT, PADDBOTTOM_LONGTEXT, false )
 101         add_integer_with_range( CFG_PREFIX "paddleft", 0, 0, INT_MAX,
 102                                 PADDLEFT_TEXT, PADDLEFT_LONGTEXT, false )
 103         add_integer_with_range( CFG_PREFIX "paddright", 0, 0, INT_MAX,
 104                                 PADDRIGHT_TEXT, PADDRIGHT_LONGTEXT, false )
 105 vlc_module_end ()
 106
 107 static const char *const ppsz_filter_options[] = {
 108     "croptop", "cropbottom", "cropleft", "cropright",
 109     "paddtop", "paddbottom", "paddleft", "paddright",
 110     NULL
 111 };
 112
 113 typedef struct
 114 {
 115     int i_croptop;
 116     int i_cropbottom;
 117     int i_cropleft;
 118     int i_cropright;
 119     int i_paddtop;
 120     int i_paddbottom;
 121     int i_paddleft;
 122     int i_paddright;
 123 } filter_sys_t;
 124
 125 /*****************************************************************************
 126  * OpenFilter: probe the filter and return score
 127  *****************************************************************************/
 128 static int OpenFilter( vlc_object_t *p_this )
 129 {
 130     filter_t *p_filter = (filter_t*)p_this;
 131     filter_sys_t *p_sys;
 132
 133     if( !p_filter->b_allow_fmt_out_change )
 134     {
 135         msg_Err( p_filter, "Picture format change isn't allowed" );
 136         return VLC_EGENERIC;
 137     }
 138
 139     if( p_filter->fmt_in.video.i_chroma != p_filter->fmt_out.video.i_chroma )
 140     {
 141         msg_Err( p_filter, "Input and output chromas don't match" );
 142         /* In fact we don't really care about this since we're allowed
 143          * to change the output format ... FIXME? */
 144         return VLC_EGENERIC;
 145     }
 146
 147     const vlc_chroma_description_t *p_chroma =
 148         vlc_fourcc_GetChromaDescription( p_filter->fmt_in.video.i_chroma );
 149     if( p_chroma == NULL || p_chroma->plane_count == 0 )
 150     {
 151         msg_Err( p_filter, "Unknown input chroma %4.4s", p_filter->fmt_in.video.i_chroma?
 152                      (const char*)&p_filter->fmt_in.video.i_chroma : "xxxx" );
 153         return VLC_EGENERIC;
 154     }
 155
 156     p_filter->p_sys = (filter_sys_t *)malloc( sizeof( filter_sys_t ) );
 157     if( !p_filter->p_sys ) return VLC_ENOMEM;
 158
 159     config_ChainParse( p_filter, CFG_PREFIX, ppsz_filter_options,
 160                        p_filter->p_cfg );
 161
 162     p_sys = p_filter->p_sys;
 163 #define GET_OPTION( name ) \
 164     p_sys->i_ ## name = var_CreateGetInteger( p_filter, CFG_PREFIX #name ); \
 165     if( p_sys->i_ ## name & 1 ) \
 166         msg_Warn( p_filter, "Using even values for `" #name "' is recommended" );
 167     GET_OPTION( croptop )
 168     GET_OPTION( cropbottom )
 169     GET_OPTION( cropleft )
 170     GET_OPTION( cropright )
 171     GET_OPTION( paddtop )
 172     GET_OPTION( paddbottom )
 173     GET_OPTION( paddleft )
 174     GET_OPTION( paddright )
 175
 176     p_filter->fmt_out.video.i_height =
 177     p_filter->fmt_out.video.i_visible_height =
 178         p_filter->fmt_in.video.i_visible_height
 179         - p_sys->i_croptop - p_sys->i_cropbottom
 180         + p_sys->i_paddtop + p_sys->i_paddbottom;
 181
 182     p_filter->fmt_out.video.i_width =
 183     p_filter->fmt_out.video.i_visible_width =
 184         p_filter->fmt_in.video.i_visible_width
 185         - p_sys->i_cropleft - p_sys->i_cropright
 186         + p_sys->i_paddleft + p_sys->i_paddright;
 187
 188     p_filter->pf_video_filter = Filter;
 189
 190     msg_Dbg( p_filter, "Crop: Top: %d, Bottom: %d, Left: %d, Right: %d",
 191              p_sys->i_croptop, p_sys->i_cropbottom, p_sys->i_cropleft,
 192              p_sys->i_cropright );
 193     msg_Dbg( p_filter, "Padd: Top: %d, Bottom: %d, Left: %d, Right: %d",
 194              p_sys->i_paddtop, p_sys->i_paddbottom, p_sys->i_paddleft,
 195              p_sys->i_paddright );
 196     msg_Dbg( p_filter, "%dx%d -> %dx%d",
 197              p_filter->fmt_in.video.i_width,
 198              p_filter->fmt_in.video.i_height,
 199              p_filter->fmt_out.video.i_width,
 200              p_filter->fmt_out.video.i_height );
 201
 202     return VLC_SUCCESS;
 203 }
 204
 205 /*****************************************************************************
 206  * CloseFilter: clean up the filter
 207  *****************************************************************************/
 208 static void CloseFilter( vlc_object_t *p_this )
 209 {
 210     filter_t *p_filter = (filter_t *)p_this;
 211     free( p_filter->p_sys );
 212 }
 213
 214 /****************************************************************************
 215  * Filter: the whole thing
 216  ****************************************************************************/
 217 static picture_t *Filter( filter_t *p_filter, picture_t *p_pic )
 218 {
 219     filter_sys_t *p_sys = p_filter->p_sys;
 220     picture_t *p_outpic;
 221     int i_width, i_height, i_xcrop, i_ycrop,
 222         i_outwidth, i_outheight, i_xpadd, i_ypadd;
 223
 224     const int p_padd_color[] = { 0x00, 0x80, 0x80, 0xff };
 225
 226     if( !p_pic ) return NULL;
 227
 228     /* Request output picture */
 229     p_outpic = filter_NewPicture( p_filter );
 230     if( !p_outpic )
 231     {
 232         picture_Release( p_pic );
 233         return NULL;
 234     }
 235
 236     for( int i_plane = 0; i_plane < p_pic->i_planes; i_plane++ )
 237     /* p_pic and p_outpic have the same chroma/number of planes but that's
 238      * about it. */
 239     {
 240         plane_t *p_plane = p_pic->p+i_plane;
 241         plane_t *p_outplane = p_outpic->p+i_plane;
 242         uint8_t *p_in = p_plane->p_pixels;
 243         uint8_t *p_out = p_outplane->p_pixels;
 244         int i_pixel_pitch = p_plane->i_pixel_pitch;
 245         int i_padd_color = i_plane > 3 ? p_padd_color[0]
 246                                        : p_padd_color[i_plane];
 247
 248         /* These assignments assume that the first plane always has
 249          * a width and height equal to the picture's */
 250         i_width =     ( ( p_filter->fmt_in.video.i_visible_width
 251                           - p_sys->i_cropleft - p_sys->i_cropright )
 252                         * p_plane->i_visible_pitch )
 253                       / p_pic->p->i_visible_pitch;
 254         i_height =    ( ( p_filter->fmt_in.video.i_visible_height
 255                           - p_sys->i_croptop - p_sys->i_cropbottom )
 256                         * p_plane->i_visible_lines )
 257                       / p_pic->p->i_visible_lines;
 258         i_xcrop =     ( p_sys->i_cropleft * p_plane->i_visible_pitch)
 259                       / p_pic->p->i_visible_pitch;
 260         i_ycrop =     ( p_sys->i_croptop * p_plane->i_visible_lines)
 261                       / p_pic->p->i_visible_lines;
 262         i_outwidth =  ( p_filter->fmt_out.video.i_visible_width
 263                         * p_outplane->i_visible_pitch )
 264                       / p_outpic->p->i_visible_pitch;
 265         i_outheight = ( p_filter->fmt_out.video.i_visible_height
 266                         * p_outplane->i_visible_lines )
 267                       / p_outpic->p->i_visible_lines;
 268         i_xpadd =     ( p_sys->i_paddleft * p_outplane->i_visible_pitch )
 269                       / p_outpic->p->i_visible_pitch;
 270         i_ypadd =     ( p_sys->i_paddtop * p_outplane->i_visible_lines )
 271                        / p_outpic->p->i_visible_lines;
 272
 273         /* Crop the top */
 274         p_in += i_ycrop * p_plane->i_pitch;
 275
 276         /* Padd on the top */
 277         memset( p_out, i_padd_color, i_ypadd * p_outplane->i_pitch );
 278         p_out += i_ypadd * p_outplane->i_pitch;
 279
 280         for( int i_line = 0; i_line < i_height; i_line++ )
 281         {
 282             uint8_t *p_in_next = p_in + p_plane->i_pitch;
 283             uint8_t *p_out_next = p_out + p_outplane->i_pitch;
 284
 285             /* Crop on the left */
 286             p_in += i_xcrop * i_pixel_pitch;
 287
 288             /* Padd on the left */
 289             memset( p_out, i_padd_color, i_xpadd * i_pixel_pitch );
 290             p_out += i_xpadd * i_pixel_pitch;
 291
 292             /* Copy the image and crop on the right */
 293             memcpy( p_out, p_in, i_width * i_pixel_pitch );
 294             p_out += i_width * i_pixel_pitch;
 295             p_in += i_width * i_pixel_pitch;
 296
 297             /* Padd on the right */
 298             memset( p_out, i_padd_color,
 299                         ( i_outwidth - i_xpadd - i_width ) * i_pixel_pitch );
 300
 301             /* Got to begining of the next line */
 302             p_in = p_in_next;
 303             p_out = p_out_next;
 304         }
 305
 306         /* Padd on the bottom */
 307         memset( p_out, i_padd_color,
 308                  ( i_outheight - i_ypadd - i_height ) * p_outplane->i_pitch );
 309     }
 310
 311     return CopyInfoAndRelease( p_outpic, p_pic );
 312 }