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
  25 /* calibrate.c */
  26 INVISIBLE void init_find_self(GstSparrow *sparrow);
  27 INVISIBLE sparrow_state mode_find_self(GstSparrow *sparrow, guint8 *in, guint8 *out);
  28 INVISIBLE void finalise_find_self(GstSparrow *sparrow);
  29
  30 /* edges.c */
  31 INVISIBLE void init_find_edges(GstSparrow *sparrow);
  32 INVISIBLE sparrow_state mode_find_edges(GstSparrow *sparrow, guint8 *in, guint8 *out);
  33 INVISIBLE void finalise_find_edges(GstSparrow *sparrow);
  34
  35 /* floodfill.c */
  36 INVISIBLE void init_find_screen(GstSparrow *sparrow);
  37 INVISIBLE sparrow_state mode_find_screen(GstSparrow *sparrow, guint8 *in, guint8 *out);
  38 INVISIBLE void finalise_find_screen(GstSparrow *sparrow);
  39
  40 /* play.c */
  41 INVISIBLE void init_play(GstSparrow *sparrow);
  42 INVISIBLE sparrow_state mode_play(GstSparrow *sparrow, guint8 *in, guint8 *out);
  43 INVISIBLE void finalise_play(GstSparrow *sparrow);
  44
  45 /* sparrow.c */
  46 INVISIBLE void debug_frame(GstSparrow *sparrow, guint8 *data, guint32 width, guint32 height, int pixsize);
  47 INVISIBLE void sparrow_pre_init(GstSparrow *sparrow);
  48 INVISIBLE gboolean sparrow_init(GstSparrow *sparrow, GstCaps *incaps, GstCaps *outcaps);
  49 INVISIBLE void sparrow_transform(GstSparrow *sparrow, guint8 *in, guint8 *out);
  50 INVISIBLE void sparrow_finalise(GstSparrow *sparrow);
  51 INVISIBLE void ppm_dump(sparrow_format *rgb, guint8 *data, guint32 width, guint32 height, const char *name);
  52 INVISIBLE void pgm_dump(guint8 *data, guint32 width, guint32 height, const char *name);
  53
  54
  55 /* jpeg_src.c */
  56 INVISIBLE void decompress_buffer(struct jpeg_decompress_struct *cinfo, guint8 *src,
  57     int size, guint8 *dest, int *width, int *height);
  58 INVISIBLE void begin_reading_jpeg(GstSparrow *sparrow, guint8* src, int size);
  59 INVISIBLE void read_one_line(GstSparrow *sparrow, guint8* dest);
  60 INVISIBLE void finish_reading_jpeg(GstSparrow *sparrow);
  61 INVISIBLE void init_jpeg_src(GstSparrow *sparrow);
  62 INVISIBLE void finalise_jpeg_src(GstSparrow *sparrow);
  63
  64
  65
  66 /*load_images.c */
  67 INVISIBLE sparrow_shared_t * sparrow_get_shared(void);
  68 INVISIBLE void maybe_load_images(GstSparrow *sparrow);
  69 INVISIBLE void maybe_unload_images(GstSparrow *sparrow);
  70 INVISIBLE void maybe_load_index(GstSparrow *sparrow);
  71 INVISIBLE void maybe_unload_index(GstSparrow *sparrow);
  72
  73
  74 #define SPARROW_CALIBRATE_ON  1
  75
  76 #define MAYBE_DEBUG_IPL(ipl)((sparrow->debug) ?                         \
  77       debug_frame(sparrow, (guint8*)(ipl)->imageData, (ipl)->width,     \
  78           (ipl)->height, (ipl)->nChannels):(void)0)
  79
  80
  81 #define CALIBRATE_ON_MIN_T 2
  82 #define CALIBRATE_ON_MAX_T 7
  83 #define CALIBRATE_OFF_MIN_T 2
  84 #define CALIBRATE_OFF_MAX_T 9
  85 #define CALIBRATE_MAX_T MAX(CALIBRATE_OFF_MAX_T, CALIBRATE_ON_MAX_T)
  86
  87 /*memory allocation */
  88 #define ALIGNMENT 16
  89
  90 static inline __attribute__((malloc)) UNUSED void *
  91 malloc_or_die(size_t size){
  92   void *p = malloc(size);
  93   if (!p){
  94     GST_ERROR("malloc would not allocate %u bytes! seriously!\n", size);
  95     exit(EXIT_FAILURE);
  96   }
  97   return p;
  98 }
  99
 100 static inline __attribute__((malloc)) UNUSED void *
 101 malloc_aligned_or_die(size_t size){
 102   void *mem;
 103   int err = posix_memalign(&mem, ALIGNMENT, size);
 104   if (err){
 105     GST_ERROR("posix_memalign returned %d trying to allocate %u bytes aligned on %u byte boundaries\n",
 106         err, size, ALIGNMENT);
 107     exit(EXIT_FAILURE);
 108   }
 109   return mem;
 110 }
 111
 112 static inline __attribute__((malloc)) UNUSED void *
 113 zalloc_aligned_or_die(size_t size){
 114   void *mem = malloc_aligned_or_die(size);
 115   memset(mem, 0, size);
 116   return mem;
 117 }
 118
 119 static inline __attribute__((malloc)) UNUSED void *
 120 zalloc_or_die(size_t size){
 121   void *mem = calloc(size, 1);
 122   if (!mem){
 123     GST_ERROR("calloc would not allocate %u bytes!\n", size);
 124     exit(EXIT_FAILURE);
 125   }
 126   return mem;
 127 }
 128
 129 /*RNG macros */
 130
 131 static inline UNUSED guint32
 132 rng_uniform_int(GstSparrow *sparrow, guint32 limit){
 133   double d = dsfmt_genrand_close_open(sparrow->dsfmt);
 134   double d2 = d * limit;
 135   guint32 i = (guint32)d2;
 136   return i;
 137 }
 138
 139 static inline UNUSED double
 140 rng_uniform_double(GstSparrow *sparrow, double limit){
 141     return dsfmt_genrand_close_open(sparrow->dsfmt) * limit;
 142 }
 143
 144 #define rng_uniform(sparrow) dsfmt_genrand_close_open((sparrow)->dsfmt)
 145
 146 #define RANDINT(sparrow, start, end)((start) + rng_uniform_int(sparrow, (end) - (start)))
 147
 148
 149 #define DISASTEROUS_CRASH(msg) GST_ERROR("DISASTER: %s\n%-25s  line %4d \n", (msg), __func__, __LINE__);
 150
 151 static inline guint32
 152 popcount32(guint32 x)
 153 {
 154   x = x - ((x >> 1) & 0x55555555);
 155   x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
 156   x = (x + (x >> 4)) & 0x0F0F0F0F;
 157   x = x + (x >> 8);
 158   x = x + (x >> 16);
 159   return x & 0x000000FF;
 160 }
 161
 162
 163 /*XXX optimised for 32 bit!*/
 164 static inline guint32
 165 popcount64(guint64 x64)
 166 {
 167   guint32 x = x64 & (guint32)-1;
 168   guint32 y = x64 >> 32;
 169   x = x - ((x >> 1) & 0x55555555);
 170   y = y - ((y >> 1) & 0x55555555);
 171   x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
 172   y = (y & 0x33333333) + ((y >> 2) & 0x33333333);
 173   x = (x + (x >> 4)) & 0x0F0F0F0F;
 174   y = (y + (y >> 4)) & 0x0F0F0F0F;
 175   x = x + (x >> 8);
 176   y = y + (y >> 8);
 177   x = x + (x >> 16);
 178   y = y + (y >> 16);
 179   return (x + y) & 0x000000FF;
 180 }
 181
 182 static inline guint32
 183 hamming_distance64(guint64 a, guint64 b, guint64 mask){
 184   a &= mask;
 185   b &= mask;
 186   /* count where the two differ */
 187   return popcount64(a ^ b);
 188 }
 189
 190 static inline gint
 191 mask_to_shift(guint32 mask){
 192   /*mask is big-endian, so these numbers are reversed */
 193   switch(mask){
 194   case 0x000000ff:
 195     return 24;
 196   case 0x0000ff00:
 197     return 16;
 198   case 0x00ff0000:
 199     return 8;
 200   case 0xff000000:
 201     return 0;
 202   }
 203   GST_WARNING("mask not byte aligned: %x\n", mask);
 204   return 0;
 205 }
 206
 207 static inline IplImage *
 208 init_ipl_image(sparrow_format *dim, int channels){
 209   CvSize size = {dim->width, dim->height};
 210   IplImage* im = cvCreateImageHeader(size, IPL_DEPTH_8U, channels);
 211   return cvInitImageHeader(im, size, IPL_DEPTH_8U, channels, 0, 8);
 212 }
 213
 214 #define SPARROW_IMAGE_DIR "/home/douglas/sparrow/content/jpg"
 215
 216 #endif /* __SPARROW_SPARROW_H__ */