mobileprint/previewgen/util/main.c

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