git.sesse.net Git - mlt/blob - src/modules/motion_est/filter_crop_detect.c

   1 /**
   2  *      /brief Crop Detection filter
   3  *
   4  *      /author Zachary Drew, Copyright 2005
   5  *
   6  *      inspired by mplayer's cropdetect filter
   7  *
   8  *      Note: The goemetry generated is zero-indexed and is inclusive of the end values
   9  *
  10  *      Options:
  11  *      -filter crop_detect debug=1                     // Visualize crop
  12  *      -filter crop_detect frequency=25                // Detect the crop once a second
  13  *      -filter crop_detect frequency=0                 // Never detect unless the producer changes
  14  *      -filter crop_detect thresh=100                  // Changes the threshold (default = 25)
  15  *
  16  * This program is free software; you can redistribute it and/or modify
  17  * it under the terms of the GNU General Public License as published by
  18  * the Free Software Foundation; either version 2 of the License, or
  19  * (at your option) any later version.
  20  *
  21  * This program is distributed in the hope that it will be useful,
  22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24  * GNU General Public License for more details.
  25  *
  26  * You should have received a copy of the GNU General Public License
  27  * along with this program; if not, write to the Free Software Foundation,
  28  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  29  */
  30
  31 #define DEBUG
  32 #define DEFAULT_THRESH 20
  33
  34 #include <framework/mlt.h>
  35
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <math.h>
  39 #include <string.h>
  40 #include "arrow_code.h"
  41
  42 #define ABS(a) ((a) >= 0 ? (a) : (-(a)))
  43
  44 // Image stack(able) method
  45 static int filter_get_image( mlt_frame this, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
  46 {
  47
  48         // Get the filter object and properties
  49         mlt_filter filter = mlt_frame_pop_service( this );
  50         mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
  51
  52         // Get the new image
  53         int error = mlt_frame_get_image( this, image, format, width, height, 1 );
  54
  55         if( error != 0 ) {
  56                 mlt_properties_debug( MLT_FRAME_PROPERTIES(this), "error after mlt_frame_get_image()", stderr );
  57                 return error;
  58         }
  59
  60         // Parameter that describes how often to check for the crop
  61         int frequency = mlt_properties_get_int( properties, "frequency");
  62
  63         // Producers may start with blank footage, by default we will skip, oh, 5 frames unless overridden
  64         int skip = mlt_properties_get_int( properties, "skip");
  65
  66         // The result
  67         mlt_geometry_item bounds = mlt_properties_get_data( properties, "bounds", NULL );
  68
  69         // Initialize if needed
  70         if( bounds == NULL ) {
  71                 bounds = calloc( 1, sizeof( struct mlt_geometry_item_s ) );
  72                 bounds->w = *width;
  73                 bounds->h = *height;
  74                 mlt_properties_set_data( properties, "bounds", bounds, sizeof( struct mlt_geometry_item_s ), free, NULL );
  75         }
  76
  77         // For periodic detection (with offset of 'skip')
  78         if( frequency == 0 || (int)(mlt_frame_get_position(this)+skip) % frequency  != 0)
  79         {
  80                 // Inject in stream
  81                 mlt_properties_set_data( MLT_FRAME_PROPERTIES(this), "bounds", bounds, sizeof( struct mlt_geometry_item_s ), NULL, NULL );
  82
  83                 return 0;
  84         }
  85
  86
  87         // There is no way to detect a crop for sure, so make up an arbitrary one
  88         int thresh = mlt_properties_get_int( properties, "thresh" );
  89
  90         *format = mlt_image_yuv422;
  91         int xstride = 2;
  92         int ystride = 2 * *width;
  93
  94         int x, y, average_brightness, deviation; // Scratch variables
  95         uint8_t *q;
  96
  97         // Top crop
  98         for( y = 0; y < *height/2; y++ ) {
  99                 bounds->y = y;
 100                 average_brightness = 0;
 101                 deviation = 0;
 102                 q = *image + y*ystride;
 103                 for( x = 0; x < *width; x++ )
 104                         average_brightness += q[x*xstride];
 105
 106                 average_brightness /= *width;
 107
 108                 for( x = 0; x < *width; x++ )
 109                         deviation += abs(average_brightness - q[x*xstride]);
 110
 111                 if( deviation*10 >= thresh * *width )
 112                         break;
 113         }
 114
 115         // Bottom crop
 116         for( y = *height - 1; y >= *height/2; y-- ) {
 117                 bounds->h = y;
 118                 average_brightness = 0;
 119                 deviation = 0;
 120                 q = *image + y*ystride;
 121                 for( x = 0; x < *width; x++ )
 122                         average_brightness += q[x*xstride];
 123
 124                 average_brightness /= *width;
 125
 126                 for( x = 0; x < *width; x++ )
 127                         deviation += abs(average_brightness - q[x*xstride]);
 128
 129                 if( deviation*10 >= thresh * *width)
 130                         break;
 131         }
 132
 133         // Left crop
 134         for( x = 0; x < *width/2; x++ ) {
 135                 bounds->x = x;
 136                 average_brightness = 0;
 137                 deviation = 0;
 138                 q = *image + x*xstride;
 139                 for( y = 0; y < *height; y++ )
 140                         average_brightness += q[y*ystride];
 141
 142                 average_brightness /= *height;
 143
 144                 for( y = 0; y < *height; y++ )
 145                         deviation += abs(average_brightness - q[y*ystride]);
 146
 147                 if( deviation*10 >= thresh * *width )
 148                         break;
 149         }
 150
 151         // Right crop
 152         for( x = *width - 1; x >= *width/2; x-- ) {
 153                 bounds->w = x;
 154                 average_brightness = 0;
 155                 deviation = 0;
 156                 q = *image + x*xstride;
 157                 for( y = 0; y < *height; y++ )
 158                         average_brightness += q[y*ystride];
 159
 160                 average_brightness /= *height;
 161
 162                 for( y = 0; y < *height; y++ )
 163                         deviation += abs(average_brightness - q[y*ystride]);
 164
 165                 if( deviation*10 >= thresh * *width )
 166                         break;
 167         }
 168
 169         /* Debug: Draw arrows to show crop */
 170         if( mlt_properties_get_int( properties, "debug") == 1 )
 171         {
 172                 init_arrows( format, *width, *height );
 173
 174                 draw_arrow(*image, bounds->x, *height/2, bounds->x+50, *height/2, 100);
 175                 draw_arrow(*image, *width/2, bounds->y, *width/2, bounds->y+50, 100);
 176                 draw_arrow(*image, bounds->w, *height/2, bounds->w-50, *height/2, 100);
 177                 draw_arrow(*image, *width/2, bounds->h, *width/2, bounds->h-50, 100);
 178                 draw_arrow(*image, bounds->x, bounds->y, bounds->x+40, bounds->y+30, 100);
 179                 draw_arrow(*image, bounds->x, bounds->h, bounds->x+40, bounds->h-30, 100);
 180                 draw_arrow(*image, bounds->w, bounds->y, bounds->w-40, bounds->y+30, 100);
 181                 draw_arrow(*image, bounds->w, bounds->h, bounds->w-40, bounds->h-30, 100);
 182         }
 183
 184         // Convert to width and correct indexing
 185         bounds->w -= bounds->x - 1;
 186         bounds->h -= bounds->y - 1;
 187
 188         if( mlt_properties_get_int( properties, "debug") == 1 )
 189                 fprintf(stderr, "Top:%f Left:%f Width:%f Height:%f\n", bounds->y, bounds->x, bounds->w, bounds->h);
 190
 191         /* inject into frame */
 192         mlt_properties_set_data( MLT_FRAME_PROPERTIES(this), "bounds", bounds, sizeof( struct mlt_geometry_item_s ), NULL, NULL );
 193
 194         return error;
 195 }
 196
 197
 198
 199 /** Filter processing.
 200 */
 201
 202 static mlt_frame filter_process( mlt_filter this, mlt_frame frame )
 203 {
 204
 205         // Put the filter object somewhere we can find it
 206         mlt_frame_push_service( frame, this);
 207
 208         // Push the frame filter
 209         mlt_frame_push_get_image( frame, filter_get_image );
 210
 211         return frame;
 212 }
 213
 214 /** Constructor for the filter.
 215 */
 216 mlt_filter filter_crop_detect_init( mlt_profile profile, mlt_service_type type, const char *id, char *arg )
 217 {
 218         mlt_filter this = mlt_filter_new( );
 219         if ( this != NULL )
 220         {
 221                 this->process = filter_process;
 222
 223                 /* defaults */
 224                 mlt_properties_set_int( MLT_FILTER_PROPERTIES(this), "frequency", 1);
 225                 mlt_properties_set_int( MLT_FILTER_PROPERTIES(this), "thresh", 5);
 226                 mlt_properties_set_int( MLT_FILTER_PROPERTIES(this), "clip", 5);
 227                 mlt_properties_set_int( MLT_FILTER_PROPERTIES(this), "former_producer_id", -1);
 228
 229         }
 230
 231         return this;
 232 }
 233
 234 /** This source code will self destruct in 5...4...3...
 235 */
 236