mobileprint/previewgen/util/main.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <sys/stat.h>
   4 #include <sys/types.h>
   5 #include <unistd.h>
   6
   7 #include <page_preview.h>
   8 #include <paper_size.h>
   9 #include <pgen_debug.h>
  10 #include <preview_coords.h>
  11
  12
  13 void show_help()
  14 {
  15         printf("Usage: previewgen-tool cmd ...\n"
  16                 "Commands:"
  17                 "\n"
  18                 "help - show help\n"
  19                 "\n"
  20                 "init img - generate PDF for image\n"
  21                 "Arguments:\n"
  22                 "\tfname1 ... fnameN outfname_pdf ppdfname\n"
  23                 "\tpaper_name paper_s_x paper_s_y\n"
  24                 "\tav_s_x av_s_y orientation n_up\n"
  25                 "\tscale_type scale_zoom scale_w scale_h\n"
  26                 "\tis_grayscale\n"
  27                 "\n"
  28                 "init pdf - generate PDF for PDF\n"
  29                 "Arguments:\n"
  30                 "\tfname toutfname_pdf ppdfname\n"
  31                 "\tpaper_name paper_s_x paper_s_y\n"
  32                 "\torientation n_up\n"
  33                 "\tscale_type scale_zoom scale_w scale_h\n"
  34                 "\tis_grayscale\n"
  35                 "\n"
  36                 "empty_gen - generate empty page image\n"
  37                 "Arguments:\n"
  38                 "\toutfname_ppm paper_s_x paper_s_y av_s_x av_s_y\n"
  39                 "\tshadow_x shadow_y is_rotate90\n"
  40                 "\n"
  41                 "gen - generate page image for PDF\n"
  42                 "Arguments:\n"
  43                 "\tfname page pages_count outfname_ppm\n"
  44                 "\tpaper_s_x paper_s_y av_s_x av_s_y\n"
  45                 "\tshadow_x shadow_y is_rotate90 is_grayscale\n"
  46                 "\n"
  47                 "pagegen - generate single page image for PDF\n"
  48                 "\tfname page outfname_ppm\n"
  49                 "\tpaper_s_x paper_s_y av_s_x av_s_y\n"
  50                 "\tshadow_x shadow_y is_rotate90 is_grayscale\n"
  51                 );
  52 }
  53
  54
  55 int parse_page_orientation(char *str, enum page_orientation *res)
  56 {
  57         if (NULL == str || NULL == res) {
  58                 printf("ERROR in orientation string\n");
  59                 return -1;
  60         }
  61
  62         if (strcasecmp(str, "portrait") == 0) {
  63                 *res = PAGE_ORIENTATION_PORTRAIT;
  64                 return 0;
  65         }
  66         if (strcasecmp(str, "landscape") == 0) {
  67                 *res = PAGE_ORIENTATION_LANDSCAPE;
  68                 return 0;
  69         }
  70
  71         return -1;
  72 }
  73
  74
  75 int parse_scale_type(char *str, enum page_scale_type *res)
  76 {
  77         if (NULL == str || NULL == res) {
  78                 printf("ERROR in scale type string\n");
  79                 return -1;
  80         }
  81
  82         if (strcasecmp(str, "fit_to_paper") == 0) {
  83                 *res = SCALE_FIT_TO_PAPER;
  84                 return 0;
  85         }
  86         if (strcasecmp(str, "custom") == 0) {
  87                 *res = SCALE_CUSTOM;
  88                 return 0;
  89         }
  90         if (strcasecmp(str, "relative") == 0) {
  91                 *res = SCALE_RELATIVE;
  92                 return 0;
  93         }
  94         if (strcasecmp(str, "original") == 0) {
  95                 *res = SCALE_ORIGINAL;
  96                 return 0;
  97         }
  98
  99         printf("ERROR in scale type string\n");
 100         return -1;
 101 }
 102
 103
 104 void destroy_str_list(char **str_list, int list_len)
 105 {
 106         int i;
 107         PGEN_RET_IF(NULL == str_list || list_len <= 0 || NULL == str_list[0],
 108                         "Argument error");
 109         for (i = 0; i < list_len; ++i) {
 110                 PGEN_IF_FREE_MEM(str_list[i]);
 111         }
 112 }
 113
 114
 115 void remove_tmp_files(char **const files, int files_count)
 116 {
 117         int i;
 118         PGEN_RET_IF(NULL == files || files_count <= 0 || NULL == files[0],
 119                         "Arguments error");
 120         for (i = 0; i <= files_count; ++i)
 121                 unlink(files[i]);
 122 }
 123
 124
 125 int process_init_img_files(int argc, char *argv[])
 126 {
 127         char **fnames;
 128         int files_count;
 129         char *outfname;
 130         char *ppd_fname;
 131         struct paper_size_pts paper_size;
 132         struct size_px av_size;
 133         enum page_orientation orientation;
 134         int n_up;
 135         struct page_scale scale;
 136         int is_grayscale;
 137
 138         char **tmp_fnames;
 139         int len;
 140         char *tmp_str;
 141
 142         int res;
 143         int is_err = 0;
 144         int pages_count;
 145         int i;
 146
 147         if (argc < 15) {
 148                 printf("ERROR in init img arguments count\n");
 149                 return -1;
 150         }
 151         PGEN_DEBUG("argc: %d", argc);
 152
 153         fnames = argv;
 154         files_count = argc - 15;
 155         i = argc - 15 - 1;
 156         outfname = argv[i + 1];
 157         ppd_fname = argv[i + 2];
 158
 159         PGEN_DEBUG("files_count: %d", files_count);
 160         PGEN_DEBUG("outfname: %s", outfname);
 161         PGEN_DEBUG("i: %d", i);
 162
 163         paper_size.name = argv[i + 3];
 164         paper_size.s.x = atof(argv[i + 4]);
 165         paper_size.s.y = atof(argv[i + 5]);
 166
 167         av_size.x = atoi(argv[i + 6]);
 168         av_size.y = atoi(argv[i + 7]);
 169
 170         PGEN_DEBUG("orientation: %s", argv[i + 8]);
 171         if (parse_page_orientation(argv[i + 8], &orientation) < 0)
 172                 return -1;
 173
 174         n_up = atoi(argv[i + 9]);
 175
 176         PGEN_DEBUG("scale_type");
 177         if (parse_scale_type(argv[i + 10], &(scale.type)) < 0)
 178                 return -1;
 179         scale.zoom = atoi(argv[i + 11]);
 180         scale.w = atof(argv[i + 12]);
 181         scale.h = atof(argv[i + 13]);
 182
 183         is_grayscale = atoi(argv[i + 14]);
 184
 185         if (files_count < 1 || files_count > 9999) {
 186                 printf("Files count ERROR\n");
 187                 return -1;
 188         }
 189
 190         /* TODO: downscale each image file */
 191         /* generate temporary names based on pid */
 192         tmp_fnames = (char**)calloc(files_count + 1, sizeof(char*));
 193         for (i = 0; i < files_count; ++i) {
 194                 len = sizeof(PREVIEW_TEMP_DIR
 195                                 "/convert_tmp_XXXXXXXX_XXXX.ppm");
 196                 tmp_str = (char*)malloc(sizeof(char) * (len + 1));
 197                 if (NULL == tmp_str) {
 198                         is_err = 1;
 199                         break;
 200                 }
 201                 tmp_str[len] = '\0';
 202                 snprintf(tmp_str, len, PREVIEW_TEMP_DIR
 203                                 "/convert_tmp_%08X_%04d.ppm", getpid(), i + 1);
 204                 tmp_fnames[i] = tmp_str;
 205         }
 206         if (is_err) {
 207                 destroy_str_list(tmp_fnames, files_count);
 208                 PGEN_IF_FREE_MEM(tmp_fnames);
 209                 printf("ERROR: out of memory\n");
 210                 return -1;
 211         }
 212
 213         for (i = 0; i < files_count; ++i) {
 214                 res = process_image_downscale(
 215                                 fnames[i], tmp_fnames[i], &av_size);
 216                 if (res < 0) {
 217                         printf("ERROR in image downscale\n");
 218                         is_err = 1;
 219                         break;
 220                 }
 221         }
 222         if (is_err) {
 223                 remove_tmp_files(tmp_fnames, files_count);
 224                 destroy_str_list(tmp_fnames, files_count);
 225                 PGEN_IF_FREE_MEM(tmp_fnames);
 226                 return -1;
 227         }
 228
 229         /* convert to pdf */
 230         if (files_count > 1)
 231                 res = img_files2pdf_preview_pages(tmp_fnames, files_count,
 232                                 outfname, ppd_fname, &paper_size, &av_size,
 233                                 orientation, n_up, &scale, is_grayscale);
 234         else
 235                 res = img2pdf_preview_pages(tmp_fnames[0], outfname, ppd_fname,
 236                                 &paper_size, &av_size, orientation, n_up,
 237                                 &scale, is_grayscale);
 238
 239         /* remove temporary files */
 240         remove_tmp_files(tmp_fnames, files_count);
 241         destroy_str_list(tmp_fnames, files_count);
 242         PGEN_IF_FREE_MEM(tmp_fnames);
 243
 244         if (res < 0) {
 245                 printf("ERROR in init img\n");
 246                 return -1;
 247         } else {
 248                 PGEN_DEBUG("PDF generation OK");
 249         }
 250         pages_count = get_pdf_pages_count(outfname);
 251         printf("init img: pages count: %d\n", pages_count);
 252
 253         return res;
 254 }
 255
 256
 257 int process_init_pdf(int argc, char *argv[])
 258 {
 259         char *fname;
 260         char *outfname;
 261         char *ppd_fname;
 262         struct paper_size_pts paper_size;
 263         enum page_orientation orientation;
 264         int n_up;
 265         struct page_scale scale;
 266         int is_grayscale;
 267
 268         int res;
 269         int pages_count;
 270
 271         if (argc < 13) {
 272                 printf("ERROR in init pdf arguments count\n");
 273                 return -1;
 274         }
 275
 276         fname = argv[0];
 277         outfname = argv[1];
 278         ppd_fname = argv[2];
 279
 280         paper_size.name = argv[3];
 281         paper_size.s.x = atof(argv[4]);
 282         paper_size.s.y = atof(argv[5]);
 283
 284         if (parse_page_orientation(argv[6], &orientation) < 0)
 285                 return -1;
 286
 287         n_up = atoi(argv[7]);
 288
 289         if (parse_scale_type(argv[8], &(scale.type)) < 0)
 290                 return -1;
 291         scale.zoom = atoi(argv[9]);
 292         scale.w = atof(argv[10]);
 293         scale.h = atof(argv[11]);
 294
 295         is_grayscale = atoi(argv[12]);
 296
 297
 298         res = pdf2pdf_preview_pages(fname, outfname, ppd_fname,
 299                         &paper_size, orientation, n_up,
 300                         &scale, is_grayscale);
 301         if (res < 0) {
 302                 printf("ERROR in init pdf\n");
 303                 return -1;
 304         }
 305         pages_count = get_pdf_pages_count(outfname);
 306         printf("init pdf: pages count: %d\n", pages_count);
 307         return 0;
 308 }
 309
 310
 311 int process_gen(int argc, char *argv[])
 312 {
 313         char *fname;
 314         int page;
 315         int pages_count;
 316         char *outfname_ppm;
 317         struct size_pts paper_size;
 318         struct size_px av_size;
 319         struct size_px shadow_size;
 320         int is_rotate90;
 321         int is_grayscale;
 322
 323         struct preview_page_req settings_req;
 324         struct preview_settings_px settings_px;
 325
 326         int res;
 327
 328
 329         if (argc < 12) {
 330                 printf("ERROR in gen arguments count\n");
 331                 return -1;
 332         }
 333
 334         fname = argv[0];
 335         page = atoi(argv[1]);
 336         pages_count = atoi(argv[2]);
 337         outfname_ppm = argv[3];
 338
 339         paper_size.x = atof(argv[4]);
 340         paper_size.y = atof(argv[5]);
 341
 342         av_size.x = atoi(argv[6]);
 343         av_size.y = atoi(argv[7]);
 344
 345         shadow_size.x = atoi(argv[8]);
 346         shadow_size.y = atoi(argv[9]);
 347
 348         is_rotate90 = atoi(argv[10]);
 349         is_grayscale = atoi(argv[11]);
 350
 351
 352         settings_req.paper_size = paper_size;
 353         settings_req.available_size_px = av_size;
 354         settings_req.shadow_offset = shadow_size;
 355         settings_req.is_rotate90 = is_rotate90;
 356         settings_req.is_grayscale = is_grayscale;
 357
 358         if (get_preview_settings(&settings_req, &settings_px) < 0) {
 359                 printf("ERROR in settings\n");
 360                 return -1;
 361         }
 362
 363         res = save_pdf_preview_page_image_w_np_fname(fname, page, pages_count,
 364                         &settings_px, outfname_ppm);
 365         if (res <= 0) {
 366                 printf("ERROR in preview image generation\n");
 367                 return -1;
 368         }
 369         printf("OK\n");
 370         return 0;
 371 }
 372
 373
 374 int process_pagegen(int argc, char *argv[])
 375 {
 376         char *pdf_fname;
 377         char *outfname_ppm;
 378         int page;
 379         struct size_pts paper_size;
 380         struct size_px av_size;
 381         struct size_px shadow_size;
 382         int is_rotate90;
 383         int is_grayscale;
 384
 385         struct preview_page_req settings_req;
 386
 387         int res;
 388
 389
 390         if (argc < 11) {
 391                 printf("ERROR in gen arguments count\n");
 392                 return -1;
 393         }
 394
 395         pdf_fname = argv[0];
 396         page = atoi(argv[1]);
 397         outfname_ppm = argv[2];
 398
 399         paper_size.x = atof(argv[3]);
 400         paper_size.y = atof(argv[4]);
 401
 402         av_size.x = atoi(argv[5]);
 403         av_size.y = atoi(argv[6]);
 404
 405         shadow_size.x = atoi(argv[7]);
 406         shadow_size.y = atoi(argv[8]);
 407
 408         is_rotate90 = atoi(argv[9]);
 409         is_grayscale = atoi(argv[10]);
 410
 411
 412         settings_req.paper_size = paper_size;
 413         settings_req.available_size_px = av_size;
 414         settings_req.shadow_offset = shadow_size;
 415         settings_req.is_rotate90 = is_rotate90;
 416         settings_req.is_grayscale = is_grayscale;
 417
 418         /*if (get_preview_settings(&settings_req, &settings_px) < 0) {
 419                 printf("ERROR in settings\n");
 420                 return -1;
 421         }*/
 422
 423         res = save_pdf_preview_page_image(pdf_fname, page,
 424                         &settings_req, outfname_ppm);
 425         if (res <= 0) {
 426                 printf("ERROR in preview page image generation\n");
 427                 return -1;
 428         }
 429         printf("OK\n");
 430         return 0;
 431 }
 432
 433
 434 int process_empty_gen(int argc, char *argv[])
 435 {
 436         char *outfname_ppm;
 437         struct size_pts paper_size;
 438         struct size_px av_size;
 439         struct size_px shadow_size;
 440         int is_rotate90;
 441
 442         struct preview_page_req settings_req;
 443
 444         int res;
 445
 446
 447         if (argc < 8) {
 448                 printf("ERROR in empty_gen arguments count\n");
 449                 return -1;
 450         }
 451
 452         outfname_ppm = argv[0];
 453
 454         paper_size.x = atof(argv[1]);
 455         paper_size.y = atof(argv[2]);
 456
 457         av_size.x = atoi(argv[3]);
 458         av_size.y = atoi(argv[4]);
 459
 460         shadow_size.x = atoi(argv[5]);
 461         shadow_size.y = atoi(argv[6]);
 462
 463         is_rotate90 = atoi(argv[7]);
 464
 465         settings_req.paper_size = paper_size;
 466         settings_req.available_size_px = av_size;
 467         settings_req.shadow_offset = shadow_size;
 468         settings_req.is_rotate90 = is_rotate90;
 469         settings_req.is_grayscale = 0;
 470
 471
 472         res = save_empty_preview_page_image(&settings_req, outfname_ppm);
 473         if (res <= 0) {
 474                 printf("ERROR in preview page image generation\n");
 475                 return -1;
 476         }
 477         printf("OK\n");
 478
 479         return 0;
 480 }
 481
 482
 483 int process_cmd(int argc, char *argv[])
 484 {
 485         if (strcasecmp("init", argv[1]) == 0) {
 486                 if (argc <= 2) {
 487                         printf("ERROR in init cmd usage\n");
 488                         return -1;
 489                 }
 490                 if (strcasecmp("img", argv[2]) == 0)
 491                         return process_init_img_files(argc - 2, &(argv[3]));
 492                 if (strcasecmp("pdf", argv[2]) == 0)
 493                         return process_init_pdf(argc - 2, &(argv[3]));
 494                 printf("ERROR in init cmd usage\n");
 495                 return -1;
 496         }
 497
 498         if (strcasecmp("gen", argv[1]) == 0)
 499                 return process_gen(argc - 1, &(argv[2]));
 500
 501         if (strcasecmp("pagegen", argv[1]) == 0)
 502                 return process_pagegen(argc - 1, &(argv[2]));
 503
 504         if (strcasecmp("empty_gen", argv[1]) == 0)
 505                 return process_empty_gen(argc - 1, &(argv[2]));
 506
 507         return 0;
 508 }
 509
 510
 511 int main(int argc, char *argv[])
 512 {
 513         int res;
 514         int ret;
 515         int errsv;
 516
 517         if (argc <= 1) {
 518                 printf("ERROR: no arguments, type help for usage\n");
 519                 return 1;
 520         }
 521
 522         if (strcasecmp("help", argv[1]) == 0) {
 523                 show_help();
 524                 return 0;
 525         }
 526
 527         ret = mkdir(PREVIEW_TEMP_DIR, 0777);
 528         errsv = errno;
 529         if (ret < 0 && errsv != EEXIST) {
 530                 printf("Failed to mkdir temporary directory " PREVIEW_TEMP_DIR
 531                                 ", errno = %d\n", errsv);
 532                 return 1;
 533         }
 534
 535         evas_init();
 536         res = process_cmd(argc, argv);
 537         evas_shutdown();
 538         if (res < 0) {
 539                 printf("Arguments ERROR\n");
 540                 return 1;
 541         }
 542
 543         return 0;
 544 }
 545