1 /* Copyright (C) <2010> Douglas Bagnall <douglas@halo.gen.nz>
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.
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.
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.
20 #include "gstsparrow.h"
25 /* static functions (via `make cproto`) */
26 static void change_state(GstSparrow
*sparrow
, sparrow_state state
);
29 /* set up whatever debugging methods are enabled */
31 init_debug(GstSparrow
*sparrow
){
32 if (!sparrow
->debug_frame
){
33 sparrow
->debug_frame
= malloc_aligned_or_die(MAX(sparrow
->in
.size
, sparrow
->out
.size
));
38 /*seed with -1 for automatic seed choice */
39 static void rng_init(GstSparrow
*sparrow
, guint32 seed
){
40 GST_DEBUG("in RNG init\n");
41 if (seed
== (guint32
)-1){
42 /* XXX should really use /dev/urandom */
43 seed
= rand() ^ (int)&(sparrow
);
44 GST_DEBUG("Real seed %u\n", seed
);
49 dsfmt_init_gen_rand(sparrow
->dsfmt
, seed
);
50 dsfmt_gen_rand_all(sparrow
->dsfmt
);
51 GST_DEBUG("RNG seeded with %u\n", seed
);
54 /** debugging: write frames out somewhere. **/
56 /*spit out the frame as a ppm image */
58 ppm_dump(sparrow_format
*rgb
, guint8
*data
, guint32 width
, guint32 height
, char *name
)
61 FILE *fh
= fopen(name
, "w");
62 guint32 size
= width
* height
;
63 fprintf(fh
, "P6\n%u %u\n255\n", width
, height
);
64 /* 4 cases: xBGR xRGB BGRx RGBx
65 need to convert to 24bit R G B
66 XX maybe could optimise some cases?
68 guint32
*p
= (guint32
*)data
;
69 for (i
= 0; i
< size
; i
++){
70 putc((*p
>> rgb
->rshift
) & 255, fh
);
71 putc((*p
>> rgb
->gshift
) & 255, fh
);
72 putc((*p
>> rgb
->bshift
) & 255, fh
);
80 #define PPM_FILENAME_TEMPLATE "/tmp/sparrow_%05d.ppm"
81 #define PPM_FILENAME_LENGTH (sizeof(PPM_FILENAME_TEMPLATE) + 10)
84 debug_frame(GstSparrow
*sparrow
, guint8
*data
, guint32 width
, guint32 height
){
86 char name
[PPM_FILENAME_LENGTH
];
87 int res
= snprintf(name
, PPM_FILENAME_LENGTH
, PPM_FILENAME_TEMPLATE
, sparrow
->frame_count
);
89 ppm_dump(&(sparrow
->in
), data
, width
, height
, name
);
94 /** interpret gst attributes **/
96 /* Extract a colour (R,G,B) bitmask from gobject */
97 static guint32
get_mask(GstStructure
*s
, char *mask_name
){
99 int res
= gst_structure_get_int(s
, mask_name
, &mask
);
101 GST_WARNING("No mask for '%s' !\n", mask_name
);
103 return (guint32
)mask
;
107 extract_caps(sparrow_format
*im
, GstCaps
*caps
)
109 GstStructure
*s
= gst_caps_get_structure (caps
, 0);
110 gst_structure_get_int(s
, "width", &(im
->width
));
111 gst_structure_get_int(s
, "height", &(im
->height
));
112 im
->rshift
= mask_to_shift(get_mask(s
, "red_mask"));
113 im
->gshift
= mask_to_shift(get_mask(s
, "green_mask"));
114 im
->bshift
= mask_to_shift(get_mask(s
, "blue_mask"));
115 /* recalculate shifts as little-endian */
116 im
->rmask
= 0xff << im
->rshift
;
117 im
->gmask
= 0xff << im
->gshift
;
118 im
->bmask
= 0xff << im
->bshift
;
120 im
->pixcount
= im
->width
* im
->height
;
121 im
->size
= im
->pixcount
* PIXSIZE
;
122 im
->colours
[SPARROW_WHITE
] = im
->rmask
| im
->gmask
| im
->bmask
;
123 im
->colours
[SPARROW_GREEN
] = im
->gmask
;
124 im
->colours
[SPARROW_MAGENTA
] = im
->rmask
| im
->bmask
;
126 GST_DEBUG("\ncaps:\n%" GST_PTR_FORMAT
, caps
);
127 GST_DEBUG("shifts: r %u g %u b %u\n", im
->rshift
, im
->gshift
, im
->bshift
);
128 GST_DEBUG("dimensions: w %u h %u pix %u size %u\n", im
->width
, im
->height
,
129 im
->pixcount
, im
->size
);
134 /*Most functions below here are called from gstsparrow.c and are NOT static */
137 sparrow_rotate_history(GstSparrow
*sparrow
, GstBuffer
*inbuf
){
138 if (sparrow
->in_buffer
){
139 gst_buffer_unref(sparrow
->prev_buffer
);
140 sparrow
->prev_buffer
= sparrow
->in_buffer
;
141 sparrow
->prev_frame
= sparrow
->in_frame
;
143 gst_buffer_ref(inbuf
);
144 sparrow
->in_buffer
= inbuf
;
146 sparrow
->in_frame
= GST_BUFFER_DATA(inbuf
);
149 /* called by gst_sparrow_init(). The source/sink capabilities (and commandline
150 arguments[?]) are unknown at this stage, so there isn't much useful to do
153 sparrow_pre_init(GstSparrow
*sparrow
){
156 /* called by gst_sparrow_set_caps(). This sets up everything after gstreamer
157 has worked out what the pipeline will look like.
160 sparrow_init(GstSparrow
*sparrow
, GstCaps
*incaps
, GstCaps
*outcaps
){
161 change_state(sparrow
, SPARROW_INIT
);
162 extract_caps(&(sparrow
->in
), incaps
);
163 extract_caps(&(sparrow
->out
), outcaps
);
164 sparrow_format
*in
= &(sparrow
->in
);
166 sparrow
->work_frame
= zalloc_aligned_or_die(in
->size
);
167 sparrow
->dsfmt
= zalloc_aligned_or_die(sizeof(dsfmt_t
));
168 sparrow
->screenmask
= malloc_aligned_or_die(in
->pixcount
);
171 size_t point_memsize
= (sizeof(sparrow_map_point_t
) * sparrow
->out
.pixcount
/ LINE_PERIOD
) + 1;
172 size_t row_memsize
= sizeof(sparrow_map_row_t
) * sparrow
->out
.height
+ 1;
173 sparrow
->map
.point_mem
= malloc_aligned_or_die(point_memsize
);
174 sparrow
->map
.rows
= zalloc_aligned_or_die(row_memsize
);
176 size_t lutsize
= sizeof(sparrow_map_lut_t
) * sparrow
->out
.pixcount
;
177 sparrow
->map_lut
= malloc_aligned_or_die(lutsize
);
180 sparrow
->prev_buffer
= gst_buffer_new_and_alloc(in
->size
);
181 sparrow
->prev_frame
= GST_BUFFER_DATA(sparrow
->prev_buffer
);
182 memset(sparrow
->prev_frame
, 0, in
->size
);
184 sparrow
->timer_start
.tv_sec
= 0;
185 sparrow
->timer_stop
.tv_sec
= 0;
188 rng_init(sparrow
, sparrow
->rng_seed
);
194 if (sparrow
->rng_seed
& 2){/*XXX need better test */
195 sparrow
->colour
= sparrow
->out
.colours
[SPARROW_GREEN
];
198 sparrow
->colour
= sparrow
->out
.colours
[SPARROW_MAGENTA
];
201 sparrow
->timer_log
= (sparrow
->use_timer
) ? fopen(TIMER_LOG_FILE
, "w") : NULL
;
202 change_state(sparrow
, SPARROW_NEXT_STATE
);
207 sparrow_finalise(GstSparrow
*sparrow
)
209 free(sparrow
->work_frame
);
210 free(sparrow
->dsfmt
);
211 free(sparrow
->screenmask
);
213 free(sparrow
->map
.point_mem
);
214 free(sparrow
->map
.rows
);
216 free(sparrow
->map_lut
);
220 if (sparrow
->timer_log
){
221 fclose(sparrow
->timer_log
);
224 //cvReleaseImageHeader(IplImage** image)
228 /* initialisation functions and sparrow_transform() use this to set up a new
231 change_state(GstSparrow
*sparrow
, sparrow_state state
)
233 switch(sparrow
->state
){
234 case SPARROW_FIND_SELF
:
235 finalise_find_self(sparrow
);
237 case SPARROW_FIND_SCREEN
:
238 finalise_find_screen(sparrow
);
240 case SPARROW_FIND_EDGES
:
241 finalise_find_edges(sparrow
);
244 finalise_process_frame(sparrow
);
249 GST_DEBUG("change_state got unknown state: %d\n", state
);
251 if (state
== SPARROW_NEXT_STATE
){
252 state
= sparrow
->state
+ 1;
255 case SPARROW_FIND_SELF
:
256 init_find_self(sparrow
);
258 case SPARROW_FIND_SCREEN
:
259 init_find_screen(sparrow
);
261 case SPARROW_FIND_EDGES
:
262 init_find_edges(sparrow
);
268 GST_DEBUG("change_state got unknown state: %d\n", state
);
270 sparrow
->state
= state
;
274 /*called by gst_sparrow_transform_ip every frame.
276 decide what to do based on sparrow->state. All the processing is done in a
277 "mode_*" function, which returns a state or SPARROW_STATUS_QUO. If a state
278 is returned, then change_state() is called to initialise the state, even if
279 it is the current state (so states can use this to reset).
282 sparrow_transform(GstSparrow
*sparrow
, guint8
*in
, guint8
*out
)
284 sparrow_state new_state
;
286 TIMER_START(sparrow
);
288 switch(sparrow
->state
){
289 case SPARROW_FIND_SELF
:
290 new_state
= mode_find_self(sparrow
, in
, out
);
292 case SPARROW_FIND_SCREEN
:
293 new_state
= mode_find_screen(sparrow
, in
, out
);
295 case SPARROW_FIND_EDGES
:
296 new_state
= mode_find_edges(sparrow
, in
, out
);
299 new_state
= mode_process_frame(sparrow
, in
, out
);
301 sparrow
->frame_count
++;
302 if (new_state
!= SPARROW_STATUS_QUO
){
303 change_state(sparrow
, new_state
);