demos/spiv/image_list.c

   1 /*****************************************************************************
   2  * This file is part of gfxprim library.                                     *
   3  *                                                                           *
   4  * Gfxprim is free software; you can redistribute it and/or                  *
   5  * modify it under the terms of the GNU Lesser General Public                *
   6  * License as published by the Free Software Foundation; either              *
   7  * version 2.1 of the License, or (at your option) any later version.        *
   8  *                                                                           *
   9  * Gfxprim is distributed in the hope that it will be useful,                *
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  12  * Lesser General Public License for more details.                           *
  13  *                                                                           *
  14  * You should have received a copy of the GNU Lesser General Public          *
  15  * License along with gfxprim; if not, write to the Free Software            *
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor,                        *
  17  * Boston, MA  02110-1301  USA                                               *
  18  *                                                                           *
  19  * Copyright (C) 2009-2013 Cyril Hrubis <metan@ucw.cz>                       *
  20  *                                                                           *
  21  *****************************************************************************/
  22
  23 #include <sys/types.h>
  24 #include <sys/stat.h>
  25 #include <unistd.h>
  26 #include <dirent.h>
  27 #include <stdlib.h>
  28 #include <errno.h>
  29 #include <string.h>
  30
  31 #include <loaders/GP_Loader.h>
  32 #include <core/GP_Debug.h>
  33
  34 #include "image_list.h"
  35
  36 struct image_list {
  37         /* list we got from the app */
  38         const char **args;
  39         unsigned int cur_arg;
  40         unsigned int max_arg;
  41         /* counters for files in corresponding arg */
  42         int *arg_file_counts;
  43
  44         /* path to the currently loaded image */
  45         char path[1024];
  46         int path_loaded:1;
  47
  48         /* directory handling */
  49         int in_dir:1;
  50
  51         int cur_file;
  52         int max_file;
  53         struct dirent **dir_files;
  54 };
  55
  56 static int dir_cmp(const struct dirent **a, const struct dirent **b)
  57 {
  58         return strcasecmp((*a)->d_name, (*b)->d_name);
  59 }
  60
  61 static int dir_filter(const struct dirent *d)
  62 {
  63         /* Ignore some filenames */
  64         if (!strcmp(d->d_name, "."))
  65                 return 0;
  66
  67         if (!strcmp(d->d_name, ".."))
  68                 return 0;
  69
  70         //TODO: filter out directories
  71
  72         if (!GP_LoaderByFilename(d->d_name))
  73                 return 0;
  74
  75         GP_DEBUG(4, "Adding file '%s'", d->d_name);
  76
  77         return 1;
  78 }
  79
  80 static void try_load_dir(struct image_list *self)
  81 {
  82         struct stat sb;
  83         const char *path = self->args[self->cur_arg];
  84
  85         if (stat(path, &sb)) {
  86                 GP_WARN("Failed to stat '%s': %s", path, strerror(errno));
  87                 return;
  88         }
  89
  90         if (!(sb.st_mode & S_IFDIR)) {
  91                 self->arg_file_counts[self->cur_arg] = 1;
  92                 return;
  93         }
  94
  95         GP_DEBUG(1, "Loading directory '%s' content.", path);
  96
  97         int ret = scandir(path, &self->dir_files, dir_filter, dir_cmp);
  98
  99         if (ret == -1) {
 100                 GP_WARN("Failed to scandir '%s': %s", path, strerror(errno));
 101                 return;
 102         }
 103
 104         if (self->arg_file_counts[self->cur_arg] != ret) {
 105                 GP_DEBUG(1, "Updating arg counter to %i", ret);
 106                 self->arg_file_counts[self->cur_arg] = ret;
 107         }
 108
 109         if (ret == 0) {
 110                 GP_DEBUG(1, "There are no files in '%s'", path);
 111                 return;
 112         }
 113
 114         self->max_file = ret;
 115         self->cur_file = 0;
 116         self->in_dir = 1;
 117 }
 118
 119 static void exit_dir(struct image_list *self)
 120 {
 121         int i;
 122
 123         GP_DEBUG(1, "Freeing directory '%s' content.",
 124                  self->args[self->cur_arg]);
 125
 126         for (i = 0; i < self->max_file; i++)
 127                 free(self->dir_files[i]);
 128
 129         free(self->dir_files);
 130
 131         self->in_dir = 0;
 132 }
 133
 134 static void next_img(struct image_list *self)
 135 {
 136         if (self->in_dir) {
 137                 if (++self->cur_file == self->max_file) {
 138                         exit_dir(self);
 139                 } else {
 140                         self->path_loaded = 0;
 141                         return;
 142                 }
 143         }
 144
 145         if (++self->cur_arg == self->max_arg)
 146                 self->cur_arg = 0;
 147
 148         try_load_dir(self);
 149
 150         self->path_loaded = 0;
 151 }
 152
 153 static void prev_img(struct image_list *self)
 154 {
 155         if (self->in_dir) {
 156                 if (self->cur_file-- == 0) {
 157                         exit_dir(self);
 158                 } else {
 159                         self->path_loaded = 0;
 160                         return;
 161                 }
 162         }
 163
 164         /* If we are at first image -> wrap around argv */
 165         if (self->cur_arg == 0)
 166                 self->cur_arg = self->max_arg - 1;
 167         else
 168                 self->cur_arg--;
 169
 170         try_load_dir(self);
 171
 172         /* if in directory, select last image in it */
 173         if (self->in_dir)
 174                 self->cur_file = self->max_file - 1;
 175
 176         self->path_loaded = 0;
 177 }
 178
 179 /*
 180  * Sets current image, if we are in directory.
 181  */
 182 static void set_dir_cur_img(struct image_list *self, int img)
 183 {
 184         if (!self->in_dir) {
 185                 GP_BUG("Not in directory at %s",
 186                        self->args[self->cur_arg]);
 187                 return;
 188         }
 189
 190         if (img < 0 || img >= self->max_file) {
 191                 GP_BUG("Invalid image index %i", img);
 192                 return;
 193         }
 194
 195         /* allready there */
 196         if (self->cur_file == img)
 197                 return;
 198
 199         self->cur_file = img;
 200         self->path_loaded = 0;
 201 }
 202
 203 /*
 204  * Returns current argument from arg list we are in.
 205  *
 206  * Either it's image file or directory.
 207  */
 208 static const char *cur_arg(struct image_list *self)
 209 {
 210         return self->args[self->cur_arg];
 211 }
 212
 213 /*
 214  * Sets current argument from arg list.
 215  */
 216 static void set_cur_arg(struct image_list *self, int arg)
 217 {
 218         if (arg < 0 || arg >= (int)self->max_arg) {
 219                 GP_BUG("Invalid argument index %i", arg);
 220                 return;
 221         }
 222
 223         if (self->in_dir) {
 224                 if ((int)self->cur_arg != arg) {
 225                         exit_dir(self);
 226                         self->cur_arg = arg;
 227                         self->path_loaded = 0;
 228                         try_load_dir(self);
 229                 } else {
 230                         set_dir_cur_img(self, 0);
 231                 }
 232                 return;
 233         }
 234
 235         if ((int)self->cur_arg == arg)
 236                 return;
 237
 238         self->cur_arg = arg;
 239         self->path_loaded = 0;
 240
 241         try_load_dir(self);
 242 }
 243
 244 static void load_path(struct image_list *self)
 245 {
 246         if (self->in_dir) {
 247                 //TODO: eliminate double /
 248                 snprintf(self->path, sizeof(self->path), "%s/%s",
 249                          cur_arg(self),
 250                          self->dir_files[self->cur_file]->d_name);
 251
 252         } else {
 253                 snprintf(self->path, sizeof(self->path), "%s", cur_arg(self));
 254         }
 255
 256         self->path_loaded = 1;
 257 }
 258
 259 const char *image_list_move(struct image_list *self, int direction)
 260 {
 261         GP_DEBUG(2, "Moving list by %i", direction);
 262
 263         int i;
 264
 265         for (i = 0; i < direction; i++)
 266                 next_img(self);
 267
 268         for (i = 0; i > direction; i--)
 269                 prev_img(self);
 270
 271         return image_list_img_path(self);
 272 }
 273
 274 const char *image_list_dir_move(struct image_list *self, int direction)
 275 {
 276         if (!self->in_dir) {
 277                 GP_DEBUG(2, "Not in directory");
 278                 return image_list_move(self, direction);
 279         }
 280
 281         if (direction > 0) {
 282                 if (self->cur_file == self->max_file - 1) {
 283                         GP_DEBUG(2, "Moving after dir '%s'", cur_arg(self));
 284                         next_img(self);
 285                 } else {
 286                         GP_DEBUG(2, "Moving to last image in dir '%s'",
 287                                  cur_arg(self));
 288                         set_dir_cur_img(self, self->max_file - 1);
 289                 }
 290         } else {
 291                 if (self->cur_file == 0) {
 292                         GP_DEBUG(2, "Moving before dir '%s'", cur_arg(self));
 293                         prev_img(self);
 294                 } else {
 295                         GP_DEBUG(2, "Moving to first image in dir '%s'",
 296                                  cur_arg(self));
 297                         set_dir_cur_img(self, 0);
 298                 }
 299         }
 300
 301         return image_list_img_path(self);
 302 }
 303
 304 const char *image_list_first(struct image_list *self)
 305 {
 306         GP_DEBUG(2, "Moving to the first image in the list");
 307
 308         set_cur_arg(self, 0);
 309
 310         if (self->in_dir)
 311                 set_dir_cur_img(self, 0);
 312
 313         return image_list_img_path(self);
 314 }
 315
 316 const char *image_list_last(struct image_list *self)
 317 {
 318         GP_DEBUG(2, "Moving to the last image in the list");
 319
 320         set_cur_arg(self, self->max_arg - 1);
 321
 322         if (self->in_dir)
 323                 set_dir_cur_img(self, self->max_file - 1);
 324
 325         return image_list_img_path(self);
 326 }
 327
 328 static unsigned int count_img_to(struct image_list *self, unsigned int arg_to)
 329 {
 330         unsigned int cur_arg = self->cur_arg;
 331         unsigned int cur_file = self->cur_file;
 332         unsigned int count = 0, i;
 333
 334         for (i = 0; i < arg_to; i++) {
 335                 /* cache number of images in arg */
 336                 if (self->arg_file_counts[i] == -1)
 337                         set_cur_arg(self, i);
 338
 339                 /*
 340                  * if the counter is still at -1
 341                  * directory couldn't be loaded
 342                  */
 343                 if (self->arg_file_counts[i] != -1)
 344                         count += self->arg_file_counts[i];
 345         }
 346
 347         /* restore the original position */
 348         set_cur_arg(self, cur_arg);
 349
 350         if (self->in_dir)
 351                 set_dir_cur_img(self, cur_file);
 352
 353         return count;
 354 }
 355
 356 unsigned int image_list_count(struct image_list *self)
 357 {
 358         return count_img_to(self, self->max_arg);
 359 }
 360
 361 unsigned int image_list_pos(struct image_list *self)
 362 {
 363         if (!self->in_dir)
 364                 return count_img_to(self, self->cur_arg);
 365
 366         return count_img_to(self, self->cur_arg) +  self->cur_file;
 367 }
 368
 369 unsigned int image_list_dir_count(struct image_list *self)
 370 {
 371         if (!self->in_dir)
 372                 return 0;
 373
 374         return self->max_file;
 375 }
 376
 377 unsigned int image_list_dir_pos(struct image_list *self)
 378 {
 379         if (!self->in_dir)
 380                 return 0;
 381
 382         return self->cur_file;
 383 }
 384
 385 struct image_list *image_list_create(const char *args[])
 386 {
 387         struct image_list *self;
 388         size_t file_count_size;
 389         unsigned int i;
 390
 391         GP_DEBUG(1, "Creating image list");
 392
 393         self = malloc(sizeof(struct image_list));
 394
 395         if (self == NULL) {
 396                 GP_WARN("Malloc failed");
 397                 return NULL;
 398         }
 399
 400         self->args = args;
 401         self->cur_arg = 0;
 402
 403         self->path_loaded = 0;
 404
 405         self->dir_files = 0;
 406         self->in_dir = 0;
 407
 408         self->max_arg = 0;
 409         while (args[++self->max_arg] != NULL);
 410
 411         file_count_size = self->max_arg * sizeof(int);
 412         self->arg_file_counts = malloc(file_count_size);
 413
 414         if (self->arg_file_counts == NULL) {
 415                 GP_WARN("Malloc failed");
 416                 free(self);
 417                 return NULL;
 418         }
 419
 420         for (i = 0; i < self->max_arg; i++)
 421                 self->arg_file_counts[i] = -1;
 422
 423         try_load_dir(self);
 424
 425         return self;
 426 }
 427
 428 void image_list_destroy(struct image_list *self)
 429 {
 430         if (self->in_dir)
 431                 exit_dir(self);
 432
 433         free(self->arg_file_counts);
 434         free(self);
 435 }
 436
 437 const char *image_list_img_path(struct image_list *self)
 438 {
 439         if (!self->path_loaded)
 440                 load_path(self);
 441
 442         GP_DEBUG(2, "Returning path '%s'", self->path);
 443
 444         return self->path;
 445 }