src/transform.h

   1 /*
   2  *  transform.h
   3  *
   4  *  Copyright (C) Georg Martius - June 2007 - 2011
   5  *   georg dot martius at web dot de
   6  *
   7  *  This file is part of vid.stab video stabilization library
   8  *
   9  *  vid.stab is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License,
  11  *  as published by the Free Software Foundation; either version 2, or
  12  *  (at your option) any later version.
  13  *
  14  *  vid.stab is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with GNU Make; see the file COPYING.  If not, write to
  21  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  22  *
  23  */
  24 #ifndef __TRANSFORM_H
  25 #define __TRANSFORM_H
  26
  27 #include <math.h>
  28 #include <libgen.h>
  29 #include "transformtype.h"
  30 #include "frameinfo.h"
  31 #include "vidstabdefines.h"
  32 #ifdef TESTING
  33 #include "transformfloat.h"
  34 #endif
  35
  36
  37 typedef struct _vstransformations {
  38     VSTransform* ts; // array of transformations
  39     int current;   // index to current transformation
  40     int len;       // length of trans array
  41     short warned_end; // whether we warned that there is no transform left
  42 } VSTransformations;
  43
  44 typedef struct _vsslidingavgtrans {
  45     VSTransform avg; // average transformation
  46     VSTransform accum; // accumulator for relative to absolute conversion
  47     double zoomavg;     // average zoom value
  48     short initialized; // whether it was initialized or not
  49 } VSSlidingAvgTrans;
  50
  51
  52 /// interpolation types
  53 typedef enum { VS_Zero, VS_Linear, VS_BiLinear, VS_BiCubic, VS_NBInterPolTypes} VSInterpolType;
  54
  55 /// returns a name for the interpolation type
  56 const char* getInterpolationTypeName(VSInterpolType type);
  57
  58 typedef enum { VSKeepBorder = 0, VSCropBorder } VSBorderType;
  59 typedef enum { VSOptimalL1 = 0, VSGaussian, VSAvg } VSCamPathAlgo;
  60
  61 /**
  62  * interpolate: general interpolation function pointer for one channel image data
  63  *              for fixed point numbers/calculations
  64  * Parameters:
  65  *             rv: destination pixel (call by reference)
  66  *            x,y: the source coordinates in the image img. Note this
  67  *                 are real-value coordinates (in fixed point format 24.8),
  68  *                 that's why we interpolate
  69  *            img: source image
  70  *   width,height: dimension of image
  71  *            def: default value if coordinates are out of range
  72  * Return value:  None
  73  */
  74 typedef void (*vsInterpolateFun)(uint8_t *rv, int32_t x, int32_t y,
  75                                  const uint8_t *img, int linesize,
  76                                  int width, int height, uint8_t def);
  77
  78 typedef struct _VSTransformConfig {
  79
  80     /* whether to consider transforms as relative (to previous frame)
  81      * or absolute transforms
  82      */
  83     int            relative;
  84     /* number of frames (forward and backward)
  85      * to use for smoothing transforms */
  86     int            smoothing;
  87     VSBorderType   crop;        // 1: black bg, 0: keep border from last frame(s)
  88     int            invert;      // 1: invert transforms, 0: nothing
  89     double         zoom;        // percentage to zoom: 0->no zooming 10:zoom in 10%
  90     int            optZoom;     // 2: optimal adaptive zoom 1: optimal static zoom, 0: nothing
  91     double         zoomSpeed;   // for adaptive zoom: zoom per frame in percent
  92     VSInterpolType interpolType; // type of interpolation: 0->Zero,1->Lin,2->BiLin,3->Sqr
  93     int            maxShift;    // maximum number of pixels we will shift
  94     double         maxAngle;    // maximum angle in rad
  95     const char*    modName;     // module name (used for logging)
  96     int            verbose;     // level of logging
  97     // if 1 then the simple but fast method to termine the global motion is used
  98     int            simpleMotionCalculation;
  99     int            storeTransforms; // stores calculated transforms to file
 100     int            smoothZoom;   // if 1 the zooming is also smoothed. Typically not recommended.
 101     VSCamPathAlgo  camPathAlgo;  // algorithm to use for camera path optimization
 102 } VSTransformConfig;
 103
 104 typedef struct _VSTransformData {
 105     VSFrameInfo fiSrc;
 106     VSFrameInfo fiDest;
 107
 108     VSFrame src;         // copy of the current frame buffer
 109     VSFrame destbuf;     // pointer to an additional buffer or
 110                          // to the destination buffer (depending on crop)
 111     VSFrame dest;        // pointer to the destination buffer
 112
 113     short srcMalloced;   // 1 if the source buffer was internally malloced
 114
 115     vsInterpolateFun interpolate; // pointer to interpolation function
 116 #ifdef TESTING
 117     _FLT(vsInterpolateFun) _FLT(interpolate);
 118 #endif
 119
 120     /* Options */
 121     VSTransformConfig conf;
 122
 123     int initialized; // 1 if initialized and 2 if configured
 124 } VSTransformData;
 125
 126
 127 static const char vs_transform_help[] = ""
 128     "Overview\n"
 129     "    Reads a file with transform information for each frame\n"
 130     "     and applies them. See also filter stabilize.\n"
 131     "Options\n"
 132     "    'input'     path to the file used to read the transforms\n"
 133     "                (def: inputfile.trf)\n"
 134     "    'smoothing' number of frames*2 + 1 used for lowpass filtering \n"
 135     "                used for stabilizing (def: 10)\n"
 136     "    'maxshift'  maximal number of pixels to translate image\n"
 137     "                (def: -1 no limit)\n"
 138     "    'maxangle'  maximal angle in rad to rotate image (def: -1 no limit)\n"
 139     "    'crop'      0: keep border (def), 1: black background\n"
 140     "    'invert'    1: invert transforms(def: 0)\n"
 141     "    'relative'  consider transforms as 0: absolute, 1: relative (def)\n"
 142     "    'zoom'      percentage to zoom >0: zoom in, <0 zoom out (def: 0)\n"
 143     "    'optzoom'   0: nothing, 1: determine optimal static zoom (def)\n"
 144     "                i.e. no (or only little) border should be visible.\n"
 145     "                2: determine optimal adaptive zoom\n"
 146     "                Note that the value given at 'zoom' is added to the \n"
 147     "                here calculated one\n"
 148     "    'zoomspeed' for adaptive zoom: zoom per frame in percent \n"
 149     "    'interpol'  type of interpolation: 0: no interpolation, \n"
 150     "                1: linear (horizontal), 2: bi-linear (def), \n"
 151     "                3: bi-cubic\n"
 152     "    'sharpen'   amount of sharpening: 0: no sharpening (def: 0.8)\n"
 153     "                uses filter unsharp with 5x5 matrix\n"
 154     "    'tripod'    virtual tripod mode (=relative=0:smoothing=0)\n"
 155     "    'help'      print this help message\n";
 156
 157 /** returns the default config
 158  */
 159 VSTransformConfig vsTransformGetDefaultConfig(const char* modName);
 160
 161 /** initialized the VSTransformData structure using the config and allocates memory
 162  *  for the frames and stuff
 163  *  @return VS_OK on success otherwise VS_ERROR
 164  */
 165 int vsTransformDataInit(VSTransformData* td, const VSTransformConfig* conf,
 166                         const VSFrameInfo* fi_src, const VSFrameInfo* fi_dest);
 167
 168
 169 /** Deletes internal data structures.
 170  * In order to use the VSTransformData again, you have to call vsTransformDataInit
 171  */
 172 void vsTransformDataCleanup(VSTransformData* td);
 173
 174 /// returns the current config
 175 void vsTransformGetConfig(VSTransformConfig* conf, const VSTransformData* td);
 176
 177 /// returns the frame info for the src
 178 const VSFrameInfo* vsTransformGetSrcFrameInfo(const VSTransformData* td);
 179 /// returns the frame info for the dest
 180 const VSFrameInfo* vsTransformGetDestFrameInfo(const VSTransformData* td);
 181
 182
 183 /// initializes VSTransformations structure
 184 void vsTransformationsInit(VSTransformations* trans);
 185 /// deletes VSTransformations internal memory
 186 void vsTransformationsCleanup(VSTransformations* trans);
 187
 188 /// return next Transform and increases internal counter
 189 VSTransform vsGetNextTransform(const VSTransformData* td, VSTransformations* trans);
 190
 191 /** preprocesses the list of transforms all at once. Here the deshaking is calculated!
 192  */
 193 int vsPreprocessTransforms(VSTransformData* td, VSTransformations* trans);
 194
 195 /**
 196  * vsLowPassTransforms: single step smoothing of transforms, using only the past.
 197  *  see also vsPreprocessTransforms. */
 198 VSTransform vsLowPassTransforms(VSTransformData* td, VSSlidingAvgTrans* mem,
 199                             const VSTransform* trans);
 200
 201 /** call this function to prepare for a next transformation (transformPacked/transformPlanar)
 202     and supply the src frame buffer and the frame to write to. These can be the same pointer
 203     for an inplace operation (working on framebuffer directly)
 204  */
 205 int vsTransformPrepare(VSTransformData* td, const VSFrame* src, VSFrame* dest);
 206
 207 /// does the actual transformation
 208 int vsDoTransform(VSTransformData* td, VSTransform t);
 209
 210
 211 /** call this function to finish the transformation of a frame (transformPacked/transformPlanar)
 212  */
 213 int vsTransformFinish(VSTransformData* td);
 214
 215
 216 #endif
 217
 218 /*
 219  * Local variables:
 220  *   c-file-style: "stroustrup"
 221  *   c-file-offsets: ((case-label . *) (statement-case-intro . *))
 222  *   indent-tabs-mode: nil
 223  * End:
 224  *
 225  * vim: expandtab shiftwidth=4:
 226  */