src.c

   1 /* fswebcam - FireStorm.cx's webcam generator                */
   2 /*===========================================================*/
   3 /* Copyright (C)2005-2009 Philip Heron <phil@firestorm.cx>   */
   4 /*                                                           */
   5 /* This program is distributed under the terms of the GNU    */
   6 /* General Public License, version 2. You may use, modify,   */
   7 /* and redistribute it under the terms of this license. A    */
   8 /* copy should be included with this source.                 */
   9
  10 #ifdef HAVE_CONFIG_H
  11 #include "config.h"
  12 #endif
  13
  14 #include <stdlib.h>
  15 #include <time.h>
  16 #include <string.h>
  17 #include <sys/stat.h>
  18 #include <errno.h>
  19 #include "parse.h"
  20 #include "src.h"
  21 #include "log.h"
  22
  23 #ifdef HAVE_V4L2
  24 extern src_mod_t src_v4l2;
  25 #endif
  26 #ifdef HAVE_V4L1
  27 extern src_mod_t src_v4l1;
  28 #endif
  29 extern src_mod_t src_file;
  30 extern src_mod_t src_raw;
  31 extern src_mod_t src_test;
  32
  33 /* Modules should be listed here in order of preference. */
  34 src_mod_t* src_mod[] = {
  35 #ifdef HAVE_V4L2
  36         &src_v4l2,
  37 #endif
  38 #ifdef HAVE_V4L1
  39         &src_v4l1,
  40 #endif
  41         &src_file,
  42         &src_raw,
  43         &src_test,
  44         0
  45 };
  46
  47 /* Supported palette types. */
  48 src_palette_t src_palette[] = {
  49         { "PNG" },
  50         { "JPEG" },
  51         { "MJPEG" },
  52         { "RGB32" },
  53         { "BGR32" },
  54         { "RGB24" },
  55         { "BGR24" },
  56         { "YUYV" },
  57         { "UYVY" },
  58         { "YUV420P" },
  59         { "NV12MB" },
  60         { "BAYER" },
  61         { "SGBRG8" },
  62         { "RGB565" },
  63         { "RGB555" },
  64         { "GREY" },
  65         { NULL }
  66 };
  67
  68 int src_open(src_t *src, char *source)
  69 {
  70         int i;
  71         size_t sl;
  72         char *s;
  73         struct stat st;
  74
  75         if(!source)
  76         {
  77                 ERROR("No source was specified.");
  78                 return(-1);
  79         }
  80
  81         sl = strlen(source) + 1;
  82         s = malloc(sl);
  83         if(!s)
  84         {
  85                 ERROR("Out of memory.");
  86                 return(-1);
  87         }
  88
  89         /* Get the first part of the source. */
  90         if(argncpy(s, sl, source, ":", 0, 0))
  91         {
  92                 ERROR("No source was specified.");
  93                 free(s);
  94                 return(-1);
  95         }
  96
  97         /* Check if it's a source name. */
  98         i = 0;
  99         while(src_mod[i])
 100         {
 101                 if(!strcasecmp(s, src_mod[i]->name))
 102                 {
 103                         INFO(">>> Using '%s' source module.", src_mod[i]->name);
 104
 105                         src->type = i;
 106                         src->source = NULL;
 107
 108                         if(!argncpy(s, sl, source, ":", 1, 0)) src->source = s;
 109                         else free(s);
 110
 111                         i = src_mod[src->type]->open(src);
 112                         if(i < 0)
 113                         {
 114                                 free(s);
 115                                 return(-1);
 116                         }
 117
 118                         return(0);
 119                 }
 120
 121                 i++;
 122         }
 123
 124         /* No source type was specified. If the name is that of a file or
 125          * device we can check each source until we find one that works. */
 126         if(stat(s, &st))
 127         {
 128                 ERROR("stat: %s", strerror(errno));
 129                 free(s);
 130                 return(-1);
 131         }
 132
 133         i = 0;
 134         src->source = s;
 135
 136         while(src_mod[i])
 137         {
 138                 int r = src_mod[i]->flags;
 139
 140                 if(S_ISCHR(st.st_mode) && r & SRC_TYPE_DEVICE) r = -1;
 141                 else if(!S_ISCHR(st.st_mode) && r & SRC_TYPE_FILE) r = -1;
 142                 else r = 0;
 143
 144                 if(r)
 145                 {
 146                         MSG("Trying source module %s...", src_mod[i]->name);
 147
 148                         src->type = i;
 149                         r = src_mod[src->type]->open(src);
 150
 151                         if(r != -2) return(r);
 152                 }
 153
 154                 i++;
 155         }
 156
 157         ERROR("Unable to find a source module that can read %s.", source);
 158
 159         free(s);
 160
 161         return(-1);
 162 }
 163
 164 int src_close(src_t *src)
 165 {
 166         int r;
 167
 168         if(src->captured_frames)
 169         {
 170                 double seconds =
 171                    (src->tv_last.tv_sec  + src->tv_last.tv_usec  / 1000000.0) -
 172                    (src->tv_first.tv_sec + src->tv_first.tv_usec / 1000000.0);
 173
 174                 /* Display FPS if enough frames where captured. */
 175                 if(src->captured_frames == 1)
 176                 {
 177                         MSG("Captured frame in %0.2f seconds.", seconds);
 178                 }
 179                 else if(src->captured_frames < 3)
 180                 {
 181                         MSG("Captured %i frames in %0.2f seconds.",
 182                             src->captured_frames, seconds);
 183                 }
 184                 else
 185                 {
 186                         MSG("Captured %i frames in %0.2f seconds. (%i fps)",
 187                             src->captured_frames, seconds,
 188                             (int) (src->captured_frames / seconds));
 189                 }
 190         }
 191
 192         r = src_mod[src->type]->close(src);
 193
 194         if(src->source) free(src->source);
 195
 196         return(r);
 197 }
 198
 199 int src_grab(src_t *src)
 200 {
 201         int r = src_mod[src->type]->grab(src);
 202
 203         if(!r)
 204         {
 205                 if(!src->captured_frames) gettimeofday(&src->tv_first, NULL);
 206                 gettimeofday(&src->tv_last, NULL);
 207
 208                 src->captured_frames++;
 209         }
 210
 211         return(r);
 212 }
 213
 214 /* Pointers are great things. Terrible things yes, but great. */
 215 /* These work but are very ugly and will be re-written soon. */
 216
 217 int src_set_option(src_option_t ***options, char *name, char *value)
 218 {
 219         src_option_t **opts, *opt;
 220         int count;
 221
 222         if(!options) return(-1);
 223         if(!*options)
 224         {
 225                 *options = malloc(sizeof(src_option_t *));
 226                 if(!*options)
 227                 {
 228                         ERROR("Out of memory.");
 229                         return(-1);
 230                 }
 231
 232                 *options[0] = NULL;
 233         }
 234
 235         count = 0;
 236         opts = *options;
 237         while(*opts)
 238         {
 239                 if((*opts)->name) if(!strcasecmp(name, (*opts)->name)) break;
 240                 opts++;
 241                 count++;
 242         }
 243
 244         if(!*opts)
 245         {
 246                 void *new;
 247
 248                 opt = (src_option_t *) malloc(sizeof(src_option_t));
 249                 if(!opt)
 250                 {
 251                         ERROR("Out of memory.");
 252                         return(-1);
 253                 }
 254
 255                 new = realloc(*options, sizeof(src_option_t *) * (count + 2));
 256                 if(!new)
 257                 {
 258                         free(opt);
 259                         ERROR("Out of memory.");
 260                         return(-1);
 261                 }
 262
 263                 *options = (src_option_t **) new;
 264                 (*options)[count++] = opt;
 265                 (*options)[count++] = NULL;
 266
 267                 opt->name = strdup(name);
 268                 opt->value = NULL;
 269         }
 270         else opt = *opts;
 271
 272         if(opt->value)
 273         {
 274                 free(opt->value);
 275                 opt->value = NULL;
 276         }
 277         if(value) opt->value = strdup(value);
 278
 279         return(0);
 280 }
 281
 282 int src_get_option_by_number(src_option_t **opt, int number,
 283                              char **name, char **value)
 284 {
 285         int i;
 286
 287         if(!opt || !name || !value) return(-1);
 288
 289         i = 0;
 290         while(*opt)
 291         {
 292                 if(i == number)
 293                 {
 294                         *name  = (*opt)->name;
 295                         *value = (*opt)->value;
 296                         return(0);
 297                 }
 298
 299                 i++;
 300         }
 301
 302         return(-1);
 303 }
 304
 305 int src_get_option_by_name(src_option_t **opt, char *name, char **value)
 306 {
 307         if(!opt || !name || !value) return(-1);
 308
 309         while(*opt)
 310         {
 311                 if((*opt)->name)
 312                 {
 313                         if(!strcasecmp(name, (*opt)->name))
 314                         {
 315                                 *value = (*opt)->value;
 316                                 return(0);
 317                         }
 318                 }
 319
 320                 opt++;
 321         }
 322
 323         return(-1);
 324 }
 325
 326 int src_free_options(src_option_t ***options)
 327 {
 328         src_option_t **opts;
 329
 330         if(!options || !*options) return(-1);
 331
 332         opts = *options;
 333         while(*opts)
 334         {
 335                 if((*opts)->name)  free((*opts)->name);
 336                 if((*opts)->value) free((*opts)->value);
 337
 338                 free(*opts);
 339
 340                 opts++;
 341         }
 342
 343         free(*options);
 344         *options = NULL;
 345
 346         return(0);
 347 }
 348