sparrow.h

   1 /* Copyright (C) <2010> Douglas Bagnall <douglas@halo.gen.nz>
   2  *
   3  * This library is free software; you can redistribute it and/or
   4  * modify it under the terms of the GNU Library General Public
   5  * License as published by the Free Software Foundation; either
   6  * version 2 of the License, or (at your option) any later version.
   7  *
   8  * This library is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * Library General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU Library General Public
  14  * License along with this library; if not, write to the
  15  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  16  * Boston, MA 02111-1307, USA.
  17  */
  18 #ifndef __SPARROW_SPARROW_H__
  19 #define __SPARROW_SPARROW_H__
  20
  21 #include <stdlib.h>
  22 #include "gstsparrow.h"
  23 #include "sparrow_false_colour_lut.h"
  24 #include "sparrow_gamma_lut.h"
  25
  26 /* calibrate.c */
  27 INVISIBLE void init_find_self(GstSparrow *sparrow);
  28 INVISIBLE void init_pick_colour(GstSparrow *sparrow);
  29 INVISIBLE void init_wait_for_grid(GstSparrow *sparrow);
  30 INVISIBLE void init_find_grid(GstSparrow *sparrow);
  31 INVISIBLE void init_find_edges(GstSparrow *sparrow);
  32 INVISIBLE sparrow_state mode_find_self(GstSparrow *sparrow, guint8 *in, guint8 *out);
  33 INVISIBLE sparrow_state mode_pick_colour(GstSparrow *sparrow, guint8 *in, guint8 *out);
  34 INVISIBLE sparrow_state mode_wait_for_grid(GstSparrow *sparrow, guint8 *in, guint8 *out);
  35 INVISIBLE sparrow_state mode_find_grid(GstSparrow *sparrow, guint8 *in, guint8 *out);
  36 INVISIBLE sparrow_state mode_find_edges(GstSparrow *sparrow, guint8 *in, guint8 *out);
  37
  38 /* sparrow.c */
  39 INVISIBLE void debug_frame(GstSparrow *sparrow, guint8 *data, guint32 width, guint32 height);
  40 INVISIBLE void sparrow_rotate_history(GstSparrow *sparrow, GstBuffer *inbuf);
  41 INVISIBLE void sparrow_pre_init(GstSparrow *sparrow);
  42 INVISIBLE gboolean sparrow_init(GstSparrow *sparrow, GstCaps *incaps, GstCaps *outcaps);
  43 INVISIBLE void sparrow_transform(GstSparrow *sparrow, guint8 *in, guint8 *out);
  44 INVISIBLE void sparrow_finalise(GstSparrow *sparrow);
  45
  46 /*itworks.c*/
  47 INVISIBLE sparrow_state mode_process_frame(GstSparrow *sparrow, guint8 *in, guint8 *out);
  48
  49 /*floodfill.c */
  50 INVISIBLE void init_find_screen(GstSparrow *sparrow);
  51 INVISIBLE sparrow_state mode_find_screen(GstSparrow *sparrow, guint8 *in, guint8 *out);
  52
  53
  54 #define SPARROW_CALIBRATE_ON  1
  55
  56
  57 #define CALIBRATE_WAIT_SIGNAL_THRESHOLD 32
  58 #define ALIGNMENT 16
  59
  60
  61 /*memory allocation */
  62
  63 static inline __attribute__((malloc)) UNUSED void *
  64 malloc_or_die(size_t size){
  65   void *p = malloc(size);
  66   if (!p){
  67     GST_ERROR("malloc would not allocate %u bytes! seriously!\n", size);
  68     exit(EXIT_FAILURE);
  69   }
  70   return p;
  71 }
  72
  73 static inline __attribute__((malloc)) UNUSED void *
  74 malloc_aligned_or_die(size_t size){
  75   void *mem;
  76   int err = posix_memalign(&mem, ALIGNMENT, size);
  77   if (err){
  78     GST_ERROR("posix_memalign returned %d trying to allocate %u bytes aligned on %u byte boundaries\n",
  79         err, size, ALIGNMENT);
  80     exit(EXIT_FAILURE);
  81   }
  82   return mem;
  83 }
  84
  85 static inline __attribute__((malloc)) UNUSED void *
  86 zalloc_aligned_or_die(size_t size){
  87   void *mem = malloc_aligned_or_die(size);
  88   memset(mem, 0, size);
  89   return mem;
  90 }
  91
  92 /*RNG macros */
  93
  94 static inline UNUSED guint32
  95 rng_uniform_int(GstSparrow *sparrow, guint32 limit){
  96   double d = dsfmt_genrand_close_open(sparrow->dsfmt);
  97   double d2 = d * limit;
  98   guint32 i = (guint32)d2;
  99   return i;
 100 }
 101
 102 static inline UNUSED double
 103 rng_uniform_double(GstSparrow *sparrow, double limit){
 104     return dsfmt_genrand_close_open(sparrow->dsfmt) * limit;
 105 }
 106
 107 #define rng_uniform(sparrow) dsfmt_genrand_close_open((sparrow)->dsfmt)
 108
 109 #define RANDINT(sparrow, start, end)((start) + rng_uniform_int(sparrow, (end) - (start)))
 110
 111
 112 #define DISASTEROUS_CRASH(msg) GST_ERROR("DISASTER: %s\n%-25s  line %4d \n", (msg), __func__, __LINE__);
 113
 114
 115
 116 static inline guint32
 117 popcount64(guint64 x64)
 118 {
 119   guint32 x = x64 & (guint32)-1;
 120   guint32 y = x64 >> 32;
 121   x = x - ((x >> 1) & 0x55555555);
 122   y = y - ((y >> 1) & 0x55555555);
 123   x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
 124   y = (y & 0x33333333) + ((y >> 2) & 0x33333333);
 125   x = (x + (x >> 4)) & 0x0F0F0F0F;
 126   y = (y + (y >> 4)) & 0x0F0F0F0F;
 127   x = x + (x >> 8);
 128   y = y + (y >> 8);
 129   x = x + (x >> 16);
 130   y = y + (y >> 16);
 131   return (x + y) & 0x000000FF;
 132 }
 133
 134 static inline guint32
 135 hamming_distance64(guint64 a, guint64 b, guint64 mask){
 136   a &= mask;
 137   b &= mask;
 138   /* count where the two differ */
 139   return popcount64(a ^ b);
 140 }
 141
 142 static inline gint
 143 mask_to_shift(guint32 mask){
 144   /*mask is big-endian, so these numbers are reversed */
 145   switch(mask){
 146   case 0x000000ff:
 147     return 24;
 148   case 0x0000ff00:
 149     return 16;
 150   case 0x00ff0000:
 151     return 8;
 152   case 0xff000000:
 153     return 0;
 154   }
 155   GST_WARNING("mask not byte aligned: %x\n", mask);
 156   return 0;
 157 }
 158
 159 static inline IplImage *
 160 init_ipl_image(sparrow_format *dim){
 161   CvSize size = {dim->width, dim->height};
 162   IplImage* im = cvCreateImageHeader(size, IPL_DEPTH_8U, PIXSIZE);
 163   return cvInitImageHeader(im, size, IPL_DEPTH_8U, PIXSIZE, 0, 8);
 164 }
 165
 166
 167 #endif /* __SPARROW_SPARROW_H__ */