src_file.c

   1 /* fswebcam - FireStorm.cx's webcam generator                */
   2 /*===========================================================*/
   3 /* Copyright (C)2005-2006 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 <stdio.h>
  15 #include <stdlib.h>
  16 #include <string.h>
  17 #include <errno.h>
  18 #include <sys/stat.h>
  19 #include "src.h"
  20 #include "log.h"
  21
  22 typedef struct {
  23
  24         FILE *f;
  25
  26         uint8_t *start;
  27         size_t length;
  28
  29 } src_file_t;
  30
  31 int src_file_open_jpeg(src_t *src)
  32 {
  33         src_file_t *s = (src_file_t *) src->state;
  34         uint8_t *p;
  35
  36         src->palette = SRC_PAL_JPEG;
  37
  38         /* Scan the JPEG segments for the SOF, which contains
  39          * the width and height of the image. */
  40
  41         p = s->start + 2;
  42
  43         while(p - s->start < src->length - 3)
  44         {
  45                 uint8_t  header;
  46                 uint16_t length;
  47
  48                 /* Check for the segment marker. */
  49                 if(*(p++) != 0xFF)
  50                 {
  51                         ERROR("Segment marker not found,");
  52                         return(-1);
  53                 }
  54
  55                 header = *(p++);
  56                 length = (p[0] << 8) + p[1];
  57
  58                 /* Verify the full segment is present. */
  59                 if((p - s->start) + length >= s->length)
  60                 {
  61                         ERROR("Incomplete segment.");
  62                         return(-1);
  63                 }
  64
  65                 if(header == 0xC0) /* SOF */
  66                 {
  67                         uint16_t width  = (p[5] << 8) + p[6];
  68                         uint16_t height = (p[3] << 8) + p[4];
  69
  70                         if(src->width != width ||
  71                            src->height != height)
  72                         {
  73                                 MSG("Adjusting resolution to %ix%i.",
  74                                     width, height);
  75
  76                                 src->width = width;
  77                                 src->height = height;
  78                         }
  79
  80                         return(0);
  81                 }
  82
  83                 if(header == 0xD9 || /* EOI */
  84                    header == 0xDA)   /* SOS */
  85                 {
  86                         WARN("%s: Unable to read resolution.", src->source);
  87                         return(-1);
  88                 }
  89
  90                 p += length;
  91         }
  92
  93         return(0);
  94 }
  95
  96 int src_file_open_png(src_t *src)
  97 {
  98         src_file_t *s = (src_file_t *) src->state;
  99         uint32_t width, height;
 100         uint8_t *p;
 101
 102         src->palette = SRC_PAL_PNG;
 103
 104         if(s->length < 24)
 105         {
 106                 ERROR("%s: Unexpected end of file.", src->source);
 107                 return(-1);
 108         }
 109
 110         p = s->start + 12;
 111
 112         if(strncmp((char *) p, "IHDR", 4))
 113         {
 114                 ERROR("%s: IHDR chunk must be first.", src->source);
 115                 return(-1);
 116         }
 117
 118         p += 4;
 119
 120         width  = (p[0] << 24) + (p[1] << 16) + (p[2] << 8) + p[3];
 121         height = (p[4] << 24) + (p[5] << 16) + (p[6] << 8) + p[7];
 122
 123         if(src->width  != width ||
 124            src->height != height)
 125         {
 126                 MSG("Adjusting resolution to %ix%i.",
 127                     width, height);
 128
 129                 src->width = width;
 130                 src->height = height;
 131         }
 132
 133         return(0);
 134 }
 135
 136 int src_file_open(src_t *src)
 137 {
 138         src_file_t *s;
 139         struct stat st;
 140         size_t size;
 141
 142         s = calloc(sizeof(src_file_t), 1);
 143         if(!s)
 144         {
 145                 ERROR("Out of memory.");
 146                 return(-2);
 147         }
 148
 149         src->state = (void *) s;
 150
 151         /* Get the file's size in bytes. */
 152         if(stat(src->source, &st) == -1)
 153         {
 154                 ERROR("Error accessing file %s", src->source);
 155                 ERROR("stat: %s", strerror(errno));
 156                 free(s);
 157                 return(-2);
 158         }
 159
 160         s->f = fopen(src->source, "rb");
 161         if(!s->f)
 162         {
 163                 ERROR("Error opening file %s", src->source);
 164                 ERROR("fopen: %s", strerror(errno));
 165                 free(s);
 166                 return(-2);
 167         }
 168
 169         /* Allocate memory for the file. */
 170         s->length = st.st_size;
 171         s->start = (uint8_t *) malloc(s->length);
 172         if(!s->start)
 173         {
 174                 ERROR("Out of memory.");
 175                 fclose(s->f);
 176                 free(s);
 177                 return(-1);
 178         }
 179
 180         /* Read the entire file into memory. */
 181         size = 0;
 182         while(!feof(s->f) && size < s->length)
 183                 size += fread(s->start, 1, s->length, s->f);
 184
 185         fclose(s->f);
 186         s->f = NULL;
 187
 188         if(size != s->length)
 189         {
 190                 ERROR("Error reading file. Read %i bytes of %i byte file.",
 191                       size, s->length);
 192                 free(s->start);
 193                 free(s);
 194                 return(-1);
 195         }
 196
 197         src->length = s->length;
 198         src->img    = s->start;
 199
 200         /* Test for a JPEG file. */
 201         if(s->start[0] == 0xFF && s->start[1] == 0xD8)
 202         {
 203                 MSG("%s: Loading JPEG file.", src->source);
 204
 205                 if(src_file_open_jpeg(src))
 206                 {
 207                         src_close(src);
 208                         return(-1);
 209                 }
 210
 211                 return(0);
 212         }
 213
 214         /* Test for a PNG file. */
 215         if(s->start[0] == 0x89 && s->start[1] == 0x50 &&
 216            s->start[2] == 0x4e && s->start[3] == 0x47)
 217         {
 218                 MSG("%s: Loading PNG file.", src->source);
 219
 220                 if(src_file_open_png(src))
 221                 {
 222                         src_close(src);
 223                         return(-1);
 224                 }
 225
 226                 return(0);
 227         }
 228
 229         ERROR("%s: Unknown file format.", src->source);
 230         src_close(src);
 231
 232         return(-2);
 233 }
 234
 235 int src_file_close(src_t *src)
 236 {
 237         src_file_t *s = (src_file_t *) src->state;
 238
 239         if(s->f) fclose(s->f);
 240         free(s->start);
 241         free(s);
 242
 243         return(0);
 244 }
 245
 246 int src_file_grab(src_t *src)
 247 {
 248         return(0);
 249 }
 250
 251 src_mod_t src_file = {
 252         "file", SRC_TYPE_FILE,
 253         src_file_open,
 254         src_file_close,
 255         src_file_grab
 256 };
 257