research.m1stereo.tv/gitweb/ - melted/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 || (mlt_frame_get_position(this)+skip) % frequency != 0)
  79         {
  80
  81                 // Inject in stream
  82                 mlt_properties_set_data( MLT_FRAME_PROPERTIES(this), "bounds", bounds, sizeof( struct mlt_geometry_item_s ), NULL, NULL );
  83
  84                 return 0;
  85         }
  86
  87
  88         // There is no way to detect a crop for sure, so make up an arbitrary one
  89         int thresh = mlt_properties_get_int( properties, "thresh" );
  90
  91         int xstride, ystride;
  92
  93         switch( *format ) {
  94                 case mlt_image_yuv422:
  95                         xstride = 2;
  96                         ystride = 2 * *width;
  97                         break;
  98                 default:
  99                         fprintf(stderr, "image format not supported by filter_crop_detect\n");
 100                         return -1;
 101         }
 102
 103         int x, y, average_brightness, deviation; // Scratch variables
 104         uint8_t *q;
 105
 106         // Top crop
 107         for( y = 0; y < *height/2; y++ ) {
 108                 bounds->y = y;
 109                 average_brightness = 0;
 110                 deviation = 0;
 111                 q = *image + y*ystride;
 112                 for( x = 0; x < *width; x++ )
 113                         average_brightness += q[x*xstride];
 114
 115                 average_brightness /= *width;
 116
 117                 for( x = 0; x < *width; x++ )
 118                         deviation += abs(average_brightness - q[x*xstride]);
 119
 120                 if( deviation*10 >= thresh * *width )
 121                         break;
 122         }
 123
 124         // Bottom crop
 125         for( y = *height - 1; y >= *height/2; y-- ) {
 126                 bounds->h = y;
 127                 average_brightness = 0;
 128                 deviation = 0;
 129                 q = *image + y*ystride;
 130                 for( x = 0; x < *width; x++ )
 131                         average_brightness += q[x*xstride];
 132
 133                 average_brightness /= *width;
 134
 135                 for( x = 0; x < *width; x++ )
 136                         deviation += abs(average_brightness - q[x*xstride]);
 137
 138                 if( deviation*10 >= thresh * *width)
 139                         break;
 140         }
 141
 142         // Left crop
 143         for( x = 0; x < *width/2; x++ ) {
 144                 bounds->x = x;
 145                 average_brightness = 0;
 146                 deviation = 0;
 147                 q = *image + x*xstride;
 148                 for( y = 0; y < *height; y++ )
 149                         average_brightness += q[y*ystride];
 150
 151                 average_brightness /= *height;
 152
 153                 for( y = 0; y < *height; y++ )
 154                         deviation += abs(average_brightness - q[y*ystride]);
 155
 156                 if( deviation*10 >= thresh * *width )
 157                         break;
 158         }
 159
 160         // Right crop
 161         for( x = *width - 1; x >= *width/2; x-- ) {
 162                 bounds->w = x;
 163                 average_brightness = 0;
 164                 deviation = 0;
 165                 q = *image + x*xstride;
 166                 for( y = 0; y < *height; y++ )
 167                         average_brightness += q[y*ystride];
 168
 169                 average_brightness /= *height;
 170
 171                 for( y = 0; y < *height; y++ )
 172                         deviation += abs(average_brightness - q[y*ystride]);
 173
 174                 if( deviation*10 >= thresh * *width )
 175                         break;
 176         }
 177
 178         /* Debug: Draw arrows to show crop */
 179         if( mlt_properties_get_int( properties, "debug") == 1 )
 180         {
 181                 init_arrows( format, *width, *height );
 182
 183                 draw_arrow(*image, bounds->x, *height/2, bounds->x+50, *height/2, 100);
 184                 draw_arrow(*image, *width/2, bounds->y, *width/2, bounds->y+50, 100);
 185                 draw_arrow(*image, bounds->w, *height/2, bounds->w-50, *height/2, 100);
 186                 draw_arrow(*image, *width/2, bounds->h, *width/2, bounds->h-50, 100);
 187                 draw_arrow(*image, bounds->x, bounds->y, bounds->x+40, bounds->y+30, 100);
 188                 draw_arrow(*image, bounds->x, bounds->h, bounds->x+40, bounds->h-30, 100);
 189                 draw_arrow(*image, bounds->w, bounds->y, bounds->w-40, bounds->y+30, 100);
 190                 draw_arrow(*image, bounds->w, bounds->h, bounds->w-40, bounds->h-30, 100);
 191         }
 192
 193         // Convert to width and correct indexing
 194         bounds->w -= bounds->x - 1;
 195         bounds->h -= bounds->y - 1;
 196
 197         if( mlt_properties_get_int( properties, "debug") == 1 )
 198                 fprintf(stderr, "Top:%f Left:%f Width:%f Height:%f\n", bounds->y, bounds->x, bounds->w, bounds->h);
 199
 200         /* inject into frame */
 201         mlt_properties_set_data( MLT_FRAME_PROPERTIES(this), "bounds", bounds, sizeof( struct mlt_geometry_item_s ), NULL, NULL );
 202
 203         return error;
 204 }
 205
 206
 207
 208 /** Filter processing.
 209 */
 210
 211 static mlt_frame filter_process( mlt_filter this, mlt_frame frame )
 212 {
 213
 214         // Put the filter object somewhere we can find it
 215         mlt_frame_push_service( frame, this);
 216
 217         // Push the frame filter
 218         mlt_frame_push_get_image( frame, filter_get_image );
 219
 220         return frame;
 221 }
 222
 223 /** Constructor for the filter.
 224 */
 225 mlt_filter filter_crop_detect_init( char *arg )
 226 {
 227         mlt_filter this = mlt_filter_new( );
 228         if ( this != NULL )
 229         {
 230                 this->process = filter_process;
 231
 232                 /* defaults */
 233                 mlt_properties_set_int( MLT_FILTER_PROPERTIES(this), "frequency", 1);
 234                 mlt_properties_set_int( MLT_FILTER_PROPERTIES(this), "thresh", 5);
 235                 mlt_properties_set_int( MLT_FILTER_PROPERTIES(this), "clip", 5);
 236                 mlt_properties_set_int( MLT_FILTER_PROPERTIES(this), "former_producer_id", -1);
 237
 238         }
 239
 240         return this;
 241 }
 242
 243 /** This source code will self destruct in 5...4...3...
 244 */
 245