QRScanner/mobile/jni/pdf/pdf-function.c

   1 #include "mupdf/pdf.h"
   2
   3 typedef struct psobj_s psobj;
   4
   5 enum
   6 {
   7         SAMPLE = 0,
   8         EXPONENTIAL = 2,
   9         STITCHING = 3,
  10         POSTSCRIPT = 4
  11 };
  12
  13 typedef struct pdf_function_s pdf_function;
  14
  15 struct pdf_function_s
  16 {
  17         fz_function base;
  18         int type;                               /* 0=sample 2=exponential 3=stitching 4=postscript */
  19         float domain[FZ_FN_MAXM][2];    /* even index : min value, odd index : max value */
  20         float range[FZ_FN_MAXN][2];     /* even index : min value, odd index : max value */
  21         int has_range;
  22
  23         union
  24         {
  25                 struct {
  26                         unsigned short bps;
  27                         int size[FZ_FN_MAXM];
  28                         float encode[FZ_FN_MAXM][2];
  29                         float decode[FZ_FN_MAXN][2];
  30                         float *samples;
  31                 } sa;
  32
  33                 struct {
  34                         float n;
  35                         float c0[FZ_FN_MAXN];
  36                         float c1[FZ_FN_MAXN];
  37                 } e;
  38
  39                 struct {
  40                         int k;
  41                         fz_function **funcs; /* k */
  42                         float *bounds; /* k - 1 */
  43                         float *encode; /* k * 2 */
  44                 } st;
  45
  46                 struct {
  47                         psobj *code;
  48                         int cap;
  49                 } p;
  50         } u;
  51 };
  52
  53 #define RADIAN 57.2957795
  54
  55 static inline float lerp(float x, float xmin, float xmax, float ymin, float ymax)
  56 {
  57         if (xmin == xmax)
  58                 return ymin;
  59         if (ymin == ymax)
  60                 return ymin;
  61         return ymin + (x - xmin) * (ymax - ymin) / (xmax - xmin);
  62 }
  63
  64 /*
  65  * PostScript calculator
  66  */
  67
  68 enum { PS_BOOL, PS_INT, PS_REAL, PS_OPERATOR, PS_BLOCK };
  69
  70 enum
  71 {
  72         PS_OP_ABS, PS_OP_ADD, PS_OP_AND, PS_OP_ATAN, PS_OP_BITSHIFT,
  73         PS_OP_CEILING, PS_OP_COPY, PS_OP_COS, PS_OP_CVI, PS_OP_CVR,
  74         PS_OP_DIV, PS_OP_DUP, PS_OP_EQ, PS_OP_EXCH, PS_OP_EXP,
  75         PS_OP_FALSE, PS_OP_FLOOR, PS_OP_GE, PS_OP_GT, PS_OP_IDIV, PS_OP_IF,
  76         PS_OP_IFELSE, PS_OP_INDEX, PS_OP_LE, PS_OP_LN, PS_OP_LOG, PS_OP_LT,
  77         PS_OP_MOD, PS_OP_MUL, PS_OP_NE, PS_OP_NEG, PS_OP_NOT, PS_OP_OR,
  78         PS_OP_POP, PS_OP_RETURN, PS_OP_ROLL, PS_OP_ROUND, PS_OP_SIN,
  79         PS_OP_SQRT, PS_OP_SUB, PS_OP_TRUE, PS_OP_TRUNCATE, PS_OP_XOR
  80 };
  81
  82 static char *ps_op_names[] =
  83 {
  84         "abs", "add", "and", "atan", "bitshift", "ceiling", "copy",
  85         "cos", "cvi", "cvr", "div", "dup", "eq", "exch", "exp",
  86         "false", "floor", "ge", "gt", "idiv", "if", "ifelse", "index", "le", "ln",
  87         "log", "lt", "mod", "mul", "ne", "neg", "not", "or", "pop", "return",
  88         "roll", "round", "sin", "sqrt", "sub", "true", "truncate", "xor"
  89 };
  90
  91 struct psobj_s
  92 {
  93         int type;
  94         union
  95         {
  96                 int b;                          /* boolean (stack only) */
  97                 int i;                          /* integer (stack and code) */
  98                 float f;                        /* real (stack and code) */
  99                 int op;                         /* operator (code only) */
 100                 int block;                      /* if/ifelse block pointer (code only) */
 101         } u;
 102 };
 103
 104 typedef struct ps_stack_s ps_stack;
 105
 106 struct ps_stack_s
 107 {
 108         psobj stack[100];
 109         int sp;
 110 };
 111
 112 #ifndef NDEBUG
 113 void
 114 pdf_debug_ps_stack(ps_stack *st)
 115 {
 116         int i;
 117
 118         printf("stack: ");
 119
 120         for (i = 0; i < st->sp; i++)
 121         {
 122                 switch (st->stack[i].type)
 123                 {
 124                 case PS_BOOL:
 125                         if (st->stack[i].u.b)
 126                                 printf("true ");
 127                         else
 128                                 printf("false ");
 129                         break;
 130
 131                 case PS_INT:
 132                         printf("%d ", st->stack[i].u.i);
 133                         break;
 134
 135                 case PS_REAL:
 136                         printf("%g ", st->stack[i].u.f);
 137                         break;
 138                 }
 139         }
 140         printf("\n");
 141
 142 }
 143 #endif
 144
 145 static void
 146 ps_init_stack(ps_stack *st)
 147 {
 148         memset(st->stack, 0, sizeof(st->stack));
 149         st->sp = 0;
 150 }
 151
 152 static inline int ps_overflow(ps_stack *st, int n)
 153 {
 154         return n < 0 || st->sp + n >= nelem(st->stack);
 155 }
 156
 157 static inline int ps_underflow(ps_stack *st, int n)
 158 {
 159         return n < 0 || st->sp - n < 0;
 160 }
 161
 162 static inline int ps_is_type(ps_stack *st, int t)
 163 {
 164         return !ps_underflow(st, 1) && st->stack[st->sp - 1].type == t;
 165 }
 166
 167 static inline int ps_is_type2(ps_stack *st, int t)
 168 {
 169         return !ps_underflow(st, 2) && st->stack[st->sp - 1].type == t && st->stack[st->sp - 2].type == t;
 170 }
 171
 172 static void
 173 ps_push_bool(ps_stack *st, int b)
 174 {
 175         if (!ps_overflow(st, 1))
 176         {
 177                 st->stack[st->sp].type = PS_BOOL;
 178                 st->stack[st->sp].u.b = b;
 179                 st->sp++;
 180         }
 181 }
 182
 183 static void
 184 ps_push_int(ps_stack *st, int n)
 185 {
 186         if (!ps_overflow(st, 1))
 187         {
 188                 st->stack[st->sp].type = PS_INT;
 189                 st->stack[st->sp].u.i = n;
 190                 st->sp++;
 191         }
 192 }
 193
 194 static void
 195 ps_push_real(ps_stack *st, float n)
 196 {
 197         if (!ps_overflow(st, 1))
 198         {
 199                 st->stack[st->sp].type = PS_REAL;
 200                 if (isnan(n))
 201                 {
 202                         /* Push 1.0, as it's a small known value that won't
 203                          * cause a divide by 0. Same reason as in fz_atof. */
 204                         n = 1.0;
 205                 }
 206                 st->stack[st->sp].u.f = fz_clamp(n, -FLT_MAX, FLT_MAX);
 207                 st->sp++;
 208         }
 209 }
 210
 211 static int
 212 ps_pop_bool(ps_stack *st)
 213 {
 214         if (!ps_underflow(st, 1))
 215         {
 216                 if (ps_is_type(st, PS_BOOL))
 217                         return st->stack[--st->sp].u.b;
 218         }
 219         return 0;
 220 }
 221
 222 static int
 223 ps_pop_int(ps_stack *st)
 224 {
 225         if (!ps_underflow(st, 1))
 226         {
 227                 if (ps_is_type(st, PS_INT))
 228                         return st->stack[--st->sp].u.i;
 229                 if (ps_is_type(st, PS_REAL))
 230                         return st->stack[--st->sp].u.f;
 231         }
 232         return 0;
 233 }
 234
 235 static float
 236 ps_pop_real(ps_stack *st)
 237 {
 238         if (!ps_underflow(st, 1))
 239         {
 240                 if (ps_is_type(st, PS_INT))
 241                         return st->stack[--st->sp].u.i;
 242                 if (ps_is_type(st, PS_REAL))
 243                         return st->stack[--st->sp].u.f;
 244         }
 245         return 0;
 246 }
 247
 248 static void
 249 ps_copy(ps_stack *st, int n)
 250 {
 251         if (!ps_underflow(st, n) && !ps_overflow(st, n))
 252         {
 253                 memcpy(st->stack + st->sp, st->stack + st->sp - n, n * sizeof(psobj));
 254                 st->sp += n;
 255         }
 256 }
 257
 258 static void
 259 ps_roll(ps_stack *st, int n, int j)
 260 {
 261         psobj tmp;
 262         int i;
 263
 264         if (ps_underflow(st, n) || j == 0 || n == 0)
 265                 return;
 266
 267         if (j >= 0)
 268         {
 269                 j %= n;
 270         }
 271         else
 272         {
 273                 j = -j % n;
 274                 if (j != 0)
 275                         j = n - j;
 276         }
 277
 278         for (i = 0; i < j; i++)
 279         {
 280                 tmp = st->stack[st->sp - 1];
 281                 memmove(st->stack + st->sp - n + 1, st->stack + st->sp - n, n * sizeof(psobj));
 282                 st->stack[st->sp - n] = tmp;
 283         }
 284 }
 285
 286 static void
 287 ps_index(ps_stack *st, int n)
 288 {
 289         if (!ps_overflow(st, 1) && !ps_underflow(st, n))
 290         {
 291                 st->stack[st->sp] = st->stack[st->sp - n - 1];
 292                 st->sp++;
 293         }
 294 }
 295
 296 static void
 297 ps_run(fz_context *ctx, psobj *code, ps_stack *st, int pc)
 298 {
 299         int i1, i2;
 300         float r1, r2;
 301         int b1, b2;
 302
 303         while (1)
 304         {
 305                 switch (code[pc].type)
 306                 {
 307                 case PS_INT:
 308                         ps_push_int(st, code[pc++].u.i);
 309                         break;
 310
 311                 case PS_REAL:
 312                         ps_push_real(st, code[pc++].u.f);
 313                         break;
 314
 315                 case PS_OPERATOR:
 316                         switch (code[pc++].u.op)
 317                         {
 318                         case PS_OP_ABS:
 319                                 if (ps_is_type(st, PS_INT))
 320                                         ps_push_int(st, abs(ps_pop_int(st)));
 321                                 else
 322                                         ps_push_real(st, fabsf(ps_pop_real(st)));
 323                                 break;
 324
 325                         case PS_OP_ADD:
 326                                 if (ps_is_type2(st, PS_INT)) {
 327                                         i2 = ps_pop_int(st);
 328                                         i1 = ps_pop_int(st);
 329                                         ps_push_int(st, i1 + i2);
 330                                 }
 331                                 else {
 332                                         r2 = ps_pop_real(st);
 333                                         r1 = ps_pop_real(st);
 334                                         ps_push_real(st, r1 + r2);
 335                                 }
 336                                 break;
 337
 338                         case PS_OP_AND:
 339                                 if (ps_is_type2(st, PS_INT)) {
 340                                         i2 = ps_pop_int(st);
 341                                         i1 = ps_pop_int(st);
 342                                         ps_push_int(st, i1 & i2);
 343                                 }
 344                                 else {
 345                                         b2 = ps_pop_bool(st);
 346                                         b1 = ps_pop_bool(st);
 347                                         ps_push_bool(st, b1 && b2);
 348                                 }
 349                                 break;
 350
 351                         case PS_OP_ATAN:
 352                                 r2 = ps_pop_real(st);
 353                                 r1 = ps_pop_real(st);
 354                                 r1 = atan2f(r1, r2) * RADIAN;
 355                                 if (r1 < 0)
 356                                         r1 += 360;
 357                                 ps_push_real(st, r1);
 358                                 break;
 359
 360                         case PS_OP_BITSHIFT:
 361                                 i2 = ps_pop_int(st);
 362                                 i1 = ps_pop_int(st);
 363                                 if (i2 > 0 && i2 < 8 * sizeof (i2))
 364                                         ps_push_int(st, i1 << i2);
 365                                 else if (i2 < 0 && i2 > -8 * (int)sizeof (i2))
 366                                         ps_push_int(st, (int)((unsigned int)i1 >> -i2));
 367                                 else
 368                                         ps_push_int(st, i1);
 369                                 break;
 370
 371                         case PS_OP_CEILING:
 372                                 r1 = ps_pop_real(st);
 373                                 ps_push_real(st, ceilf(r1));
 374                                 break;
 375
 376                         case PS_OP_COPY:
 377                                 ps_copy(st, ps_pop_int(st));
 378                                 break;
 379
 380                         case PS_OP_COS:
 381                                 r1 = ps_pop_real(st);
 382                                 ps_push_real(st, cosf(r1/RADIAN));
 383                                 break;
 384
 385                         case PS_OP_CVI:
 386                                 ps_push_int(st, ps_pop_int(st));
 387                                 break;
 388
 389                         case PS_OP_CVR:
 390                                 ps_push_real(st, ps_pop_real(st));
 391                                 break;
 392
 393                         case PS_OP_DIV:
 394                                 r2 = ps_pop_real(st);
 395                                 r1 = ps_pop_real(st);
 396                                 if (fabsf(r2) >= FLT_EPSILON)
 397                                         ps_push_real(st, r1 / r2);
 398                                 else
 399                                         ps_push_real(st, DIV_BY_ZERO(r1, r2, -FLT_MAX, FLT_MAX));
 400                                 break;
 401
 402                         case PS_OP_DUP:
 403                                 ps_copy(st, 1);
 404                                 break;
 405
 406                         case PS_OP_EQ:
 407                                 if (ps_is_type2(st, PS_BOOL)) {
 408                                         b2 = ps_pop_bool(st);
 409                                         b1 = ps_pop_bool(st);
 410                                         ps_push_bool(st, b1 == b2);
 411                                 }
 412                                 else if (ps_is_type2(st, PS_INT)) {
 413                                         i2 = ps_pop_int(st);
 414                                         i1 = ps_pop_int(st);
 415                                         ps_push_bool(st, i1 == i2);
 416                                 }
 417                                 else {
 418                                         r2 = ps_pop_real(st);
 419                                         r1 = ps_pop_real(st);
 420                                         ps_push_bool(st, r1 == r2);
 421                                 }
 422                                 break;
 423
 424                         case PS_OP_EXCH:
 425                                 ps_roll(st, 2, 1);
 426                                 break;
 427
 428                         case PS_OP_EXP:
 429                                 r2 = ps_pop_real(st);
 430                                 r1 = ps_pop_real(st);
 431                                 ps_push_real(st, powf(r1, r2));
 432                                 break;
 433
 434                         case PS_OP_FALSE:
 435                                 ps_push_bool(st, 0);
 436                                 break;
 437
 438                         case PS_OP_FLOOR:
 439                                 r1 = ps_pop_real(st);
 440                                 ps_push_real(st, floorf(r1));
 441                                 break;
 442
 443                         case PS_OP_GE:
 444                                 if (ps_is_type2(st, PS_INT)) {
 445                                         i2 = ps_pop_int(st);
 446                                         i1 = ps_pop_int(st);
 447                                         ps_push_bool(st, i1 >= i2);
 448                                 }
 449                                 else {
 450                                         r2 = ps_pop_real(st);
 451                                         r1 = ps_pop_real(st);
 452                                         ps_push_bool(st, r1 >= r2);
 453                                 }
 454                                 break;
 455
 456                         case PS_OP_GT:
 457                                 if (ps_is_type2(st, PS_INT)) {
 458                                         i2 = ps_pop_int(st);
 459                                         i1 = ps_pop_int(st);
 460                                         ps_push_bool(st, i1 > i2);
 461                                 }
 462                                 else {
 463                                         r2 = ps_pop_real(st);
 464                                         r1 = ps_pop_real(st);
 465                                         ps_push_bool(st, r1 > r2);
 466                                 }
 467                                 break;
 468
 469                         case PS_OP_IDIV:
 470                                 i2 = ps_pop_int(st);
 471                                 i1 = ps_pop_int(st);
 472                                 if (i2 != 0)
 473                                         ps_push_int(st, i1 / i2);
 474                                 else
 475                                         ps_push_int(st, DIV_BY_ZERO(i1, i2, INT_MIN, INT_MAX));
 476                                 break;
 477
 478                         case PS_OP_INDEX:
 479                                 ps_index(st, ps_pop_int(st));
 480                                 break;
 481
 482                         case PS_OP_LE:
 483                                 if (ps_is_type2(st, PS_INT)) {
 484                                         i2 = ps_pop_int(st);
 485                                         i1 = ps_pop_int(st);
 486                                         ps_push_bool(st, i1 <= i2);
 487                                 }
 488                                 else {
 489                                         r2 = ps_pop_real(st);
 490                                         r1 = ps_pop_real(st);
 491                                         ps_push_bool(st, r1 <= r2);
 492                                 }
 493                                 break;
 494
 495                         case PS_OP_LN:
 496                                 r1 = ps_pop_real(st);
 497                                 /* Bug 692941 - logf as separate statement */
 498                                 r2 = logf(r1);
 499                                 ps_push_real(st, r2);
 500                                 break;
 501
 502                         case PS_OP_LOG:
 503                                 r1 = ps_pop_real(st);
 504                                 ps_push_real(st, log10f(r1));
 505                                 break;
 506
 507                         case PS_OP_LT:
 508                                 if (ps_is_type2(st, PS_INT)) {
 509                                         i2 = ps_pop_int(st);
 510                                         i1 = ps_pop_int(st);
 511                                         ps_push_bool(st, i1 < i2);
 512                                 }
 513                                 else {
 514                                         r2 = ps_pop_real(st);
 515                                         r1 = ps_pop_real(st);
 516                                         ps_push_bool(st, r1 < r2);
 517                                 }
 518                                 break;
 519
 520                         case PS_OP_MOD:
 521                                 i2 = ps_pop_int(st);
 522                                 i1 = ps_pop_int(st);
 523                                 if (i2 != 0)
 524                                         ps_push_int(st, i1 % i2);
 525                                 else
 526                                         ps_push_int(st, DIV_BY_ZERO(i1, i2, INT_MIN, INT_MAX));
 527                                 break;
 528
 529                         case PS_OP_MUL:
 530                                 if (ps_is_type2(st, PS_INT)) {
 531                                         i2 = ps_pop_int(st);
 532                                         i1 = ps_pop_int(st);
 533                                         ps_push_int(st, i1 * i2);
 534                                 }
 535                                 else {
 536                                         r2 = ps_pop_real(st);
 537                                         r1 = ps_pop_real(st);
 538                                         ps_push_real(st, r1 * r2);
 539                                 }
 540                                 break;
 541
 542                         case PS_OP_NE:
 543                                 if (ps_is_type2(st, PS_BOOL)) {
 544                                         b2 = ps_pop_bool(st);
 545                                         b1 = ps_pop_bool(st);
 546                                         ps_push_bool(st, b1 != b2);
 547                                 }
 548                                 else if (ps_is_type2(st, PS_INT)) {
 549                                         i2 = ps_pop_int(st);
 550                                         i1 = ps_pop_int(st);
 551                                         ps_push_bool(st, i1 != i2);
 552                                 }
 553                                 else {
 554                                         r2 = ps_pop_real(st);
 555                                         r1 = ps_pop_real(st);
 556                                         ps_push_bool(st, r1 != r2);
 557                                 }
 558                                 break;
 559
 560                         case PS_OP_NEG:
 561                                 if (ps_is_type(st, PS_INT))
 562                                         ps_push_int(st, -ps_pop_int(st));
 563                                 else
 564                                         ps_push_real(st, -ps_pop_real(st));
 565                                 break;
 566
 567                         case PS_OP_NOT:
 568                                 if (ps_is_type(st, PS_BOOL))
 569                                         ps_push_bool(st, !ps_pop_bool(st));
 570                                 else
 571                                         ps_push_int(st, ~ps_pop_int(st));
 572                                 break;
 573
 574                         case PS_OP_OR:
 575                                 if (ps_is_type2(st, PS_BOOL)) {
 576                                         b2 = ps_pop_bool(st);
 577                                         b1 = ps_pop_bool(st);
 578                                         ps_push_bool(st, b1 || b2);
 579                                 }
 580                                 else {
 581                                         i2 = ps_pop_int(st);
 582                                         i1 = ps_pop_int(st);
 583                                         ps_push_int(st, i1 | i2);
 584                                 }
 585                                 break;
 586
 587                         case PS_OP_POP:
 588                                 if (!ps_underflow(st, 1))
 589                                         st->sp--;
 590                                 break;
 591
 592                         case PS_OP_ROLL:
 593                                 i2 = ps_pop_int(st);
 594                                 i1 = ps_pop_int(st);
 595                                 ps_roll(st, i1, i2);
 596                                 break;
 597
 598                         case PS_OP_ROUND:
 599                                 if (!ps_is_type(st, PS_INT)) {
 600                                         r1 = ps_pop_real(st);
 601                                         ps_push_real(st, (r1 >= 0) ? floorf(r1 + 0.5f) : ceilf(r1 - 0.5f));
 602                                 }
 603                                 break;
 604
 605                         case PS_OP_SIN:
 606                                 r1 = ps_pop_real(st);
 607                                 ps_push_real(st, sinf(r1/RADIAN));
 608                                 break;
 609
 610                         case PS_OP_SQRT:
 611                                 r1 = ps_pop_real(st);
 612                                 ps_push_real(st, sqrtf(r1));
 613                                 break;
 614
 615                         case PS_OP_SUB:
 616                                 if (ps_is_type2(st, PS_INT)) {
 617                                         i2 = ps_pop_int(st);
 618                                         i1 = ps_pop_int(st);
 619                                         ps_push_int(st, i1 - i2);
 620                                 }
 621                                 else {
 622                                         r2 = ps_pop_real(st);
 623                                         r1 = ps_pop_real(st);
 624                                         ps_push_real(st, r1 - r2);
 625                                 }
 626                                 break;
 627
 628                         case PS_OP_TRUE:
 629                                 ps_push_bool(st, 1);
 630                                 break;
 631
 632                         case PS_OP_TRUNCATE:
 633                                 if (!ps_is_type(st, PS_INT)) {
 634                                         r1 = ps_pop_real(st);
 635                                         ps_push_real(st, (r1 >= 0) ? floorf(r1) : ceilf(r1));
 636                                 }
 637                                 break;
 638
 639                         case PS_OP_XOR:
 640                                 if (ps_is_type2(st, PS_BOOL)) {
 641                                         b2 = ps_pop_bool(st);
 642                                         b1 = ps_pop_bool(st);
 643                                         ps_push_bool(st, b1 ^ b2);
 644                                 }
 645                                 else {
 646                                         i2 = ps_pop_int(st);
 647                                         i1 = ps_pop_int(st);
 648                                         ps_push_int(st, i1 ^ i2);
 649                                 }
 650                                 break;
 651
 652                         case PS_OP_IF:
 653                                 b1 = ps_pop_bool(st);
 654                                 if (b1)
 655                                         ps_run(ctx, code, st, code[pc + 1].u.block);
 656                                 pc = code[pc + 2].u.block;
 657                                 break;
 658
 659                         case PS_OP_IFELSE:
 660                                 b1 = ps_pop_bool(st);
 661                                 if (b1)
 662                                         ps_run(ctx, code, st, code[pc + 1].u.block);
 663                                 else
 664                                         ps_run(ctx, code, st, code[pc + 0].u.block);
 665                                 pc = code[pc + 2].u.block;
 666                                 break;
 667
 668                         case PS_OP_RETURN:
 669                                 return;
 670
 671                         default:
 672                                 fz_warn(ctx, "foreign operator in calculator function");
 673                                 return;
 674                         }
 675                         break;
 676
 677                 default:
 678                         fz_warn(ctx, "foreign object in calculator function");
 679                         return;
 680                 }
 681         }
 682 }
 683
 684 static void
 685 resize_code(fz_context *ctx, pdf_function *func, int newsize)
 686 {
 687         if (newsize >= func->u.p.cap)
 688         {
 689                 int new_cap = func->u.p.cap + 64;
 690                 func->u.p.code = fz_resize_array(ctx, func->u.p.code, new_cap, sizeof(psobj));
 691                 func->u.p.cap = new_cap;
 692         }
 693 }
 694
 695 static void
 696 parse_code(pdf_function *func, fz_stream *stream, int *codeptr, pdf_lexbuf *buf)
 697 {
 698         pdf_token tok;
 699         int opptr, elseptr, ifptr;
 700         int a, b, mid, cmp;
 701         fz_context *ctx = stream->ctx;
 702
 703         while (1)
 704         {
 705                 tok = pdf_lex(stream, buf);
 706
 707                 switch (tok)
 708                 {
 709                 case PDF_TOK_EOF:
 710                         fz_throw(ctx, FZ_ERROR_GENERIC, "truncated calculator function");
 711
 712                 case PDF_TOK_INT:
 713                         resize_code(ctx, func, *codeptr);
 714                         func->u.p.code[*codeptr].type = PS_INT;
 715                         func->u.p.code[*codeptr].u.i = buf->i;
 716                         ++*codeptr;
 717                         break;
 718
 719                 case PDF_TOK_TRUE:
 720                         resize_code(ctx, func, *codeptr);
 721                         func->u.p.code[*codeptr].type = PS_BOOL;
 722                         func->u.p.code[*codeptr].u.b = 1;
 723                         ++*codeptr;
 724                         break;
 725
 726                 case PDF_TOK_FALSE:
 727                         resize_code(ctx, func, *codeptr);
 728                         func->u.p.code[*codeptr].type = PS_BOOL;
 729                         func->u.p.code[*codeptr].u.b = 0;
 730                         ++*codeptr;
 731                         break;
 732
 733                 case PDF_TOK_REAL:
 734                         resize_code(ctx, func, *codeptr);
 735                         func->u.p.code[*codeptr].type = PS_REAL;
 736                         func->u.p.code[*codeptr].u.f = buf->f;
 737                         ++*codeptr;
 738                         break;
 739
 740                 case PDF_TOK_OPEN_BRACE:
 741                         opptr = *codeptr;
 742                         *codeptr += 4;
 743
 744                         resize_code(ctx, func, *codeptr);
 745
 746                         ifptr = *codeptr;
 747                         parse_code(func, stream, codeptr, buf);
 748
 749                         tok = pdf_lex(stream, buf);
 750
 751                         if (tok == PDF_TOK_OPEN_BRACE)
 752                         {
 753                                 elseptr = *codeptr;
 754                                 parse_code(func, stream, codeptr, buf);
 755
 756                                 tok = pdf_lex(stream, buf);
 757                         }
 758                         else
 759                         {
 760                                 elseptr = -1;
 761                         }
 762
 763                         if (tok != PDF_TOK_KEYWORD)
 764                                 fz_throw(ctx, FZ_ERROR_GENERIC, "missing keyword in 'if-else' context");
 765
 766                         if (!strcmp(buf->scratch, "if"))
 767                         {
 768                                 if (elseptr >= 0)
 769                                         fz_throw(ctx, FZ_ERROR_GENERIC, "too many branches for 'if'");
 770                                 func->u.p.code[opptr].type = PS_OPERATOR;
 771                                 func->u.p.code[opptr].u.op = PS_OP_IF;
 772                                 func->u.p.code[opptr+2].type = PS_BLOCK;
 773                                 func->u.p.code[opptr+2].u.block = ifptr;
 774                                 func->u.p.code[opptr+3].type = PS_BLOCK;
 775                                 func->u.p.code[opptr+3].u.block = *codeptr;
 776                         }
 777                         else if (!strcmp(buf->scratch, "ifelse"))
 778                         {
 779                                 if (elseptr < 0)
 780                                         fz_throw(ctx, FZ_ERROR_GENERIC, "not enough branches for 'ifelse'");
 781                                 func->u.p.code[opptr].type = PS_OPERATOR;
 782                                 func->u.p.code[opptr].u.op = PS_OP_IFELSE;
 783                                 func->u.p.code[opptr+1].type = PS_BLOCK;
 784                                 func->u.p.code[opptr+1].u.block = elseptr;
 785                                 func->u.p.code[opptr+2].type = PS_BLOCK;
 786                                 func->u.p.code[opptr+2].u.block = ifptr;
 787                                 func->u.p.code[opptr+3].type = PS_BLOCK;
 788                                 func->u.p.code[opptr+3].u.block = *codeptr;
 789                         }
 790                         else
 791                         {
 792                                 fz_throw(ctx, FZ_ERROR_GENERIC, "unknown keyword in 'if-else' context: '%s'", buf->scratch);
 793                         }
 794                         break;
 795
 796                 case PDF_TOK_CLOSE_BRACE:
 797                         resize_code(ctx, func, *codeptr);
 798                         func->u.p.code[*codeptr].type = PS_OPERATOR;
 799                         func->u.p.code[*codeptr].u.op = PS_OP_RETURN;
 800                         ++*codeptr;
 801                         return;
 802
 803                 case PDF_TOK_KEYWORD:
 804                         cmp = -1;
 805                         a = -1;
 806                         b = nelem(ps_op_names);
 807                         while (b - a > 1)
 808                         {
 809                                 mid = (a + b) / 2;
 810                                 cmp = strcmp(buf->scratch, ps_op_names[mid]);
 811                                 if (cmp > 0)
 812                                         a = mid;
 813                                 else if (cmp < 0)
 814                                         b = mid;
 815                                 else
 816                                         a = b = mid;
 817                         }
 818                         if (cmp != 0)
 819                                 fz_throw(ctx, FZ_ERROR_GENERIC, "unknown operator: '%s'", buf->scratch);
 820                         if (a == PS_OP_IFELSE)
 821                                 fz_throw(ctx, FZ_ERROR_GENERIC, "illegally positioned ifelse operator in function");
 822                         if (a == PS_OP_IF)
 823                                 fz_throw(ctx, FZ_ERROR_GENERIC, "illegally positioned if operator in function");
 824
 825                         resize_code(ctx, func, *codeptr);
 826                         func->u.p.code[*codeptr].type = PS_OPERATOR;
 827                         func->u.p.code[*codeptr].u.op = a;
 828                         ++*codeptr;
 829                         break;
 830
 831                 default:
 832                         fz_throw(ctx, FZ_ERROR_GENERIC, "calculator function syntax error");
 833                 }
 834         }
 835 }
 836
 837 static void
 838 load_postscript_func(pdf_function *func, pdf_document *doc, pdf_obj *dict, int num, int gen)
 839 {
 840         fz_stream *stream = NULL;
 841         int codeptr;
 842         pdf_lexbuf buf;
 843         pdf_token tok;
 844         fz_context *ctx = doc->ctx;
 845         int locked = 0;
 846
 847         pdf_lexbuf_init(ctx, &buf, PDF_LEXBUF_SMALL);
 848
 849         fz_var(stream);
 850         fz_var(locked);
 851
 852         fz_try(ctx)
 853         {
 854                 stream = pdf_open_stream(doc, num, gen);
 855
 856                 tok = pdf_lex(stream, &buf);
 857                 if (tok != PDF_TOK_OPEN_BRACE)
 858                 {
 859                         fz_throw(ctx, FZ_ERROR_GENERIC, "stream is not a calculator function");
 860                 }
 861
 862                 func->u.p.code = NULL;
 863                 func->u.p.cap = 0;
 864
 865                 codeptr = 0;
 866                 parse_code(func, stream, &codeptr, &buf);
 867         }
 868         fz_always(ctx)
 869         {
 870                 fz_close(stream);
 871                 pdf_lexbuf_fin(&buf);
 872         }
 873         fz_catch(ctx)
 874         {
 875                 fz_rethrow_message(ctx, "cannot parse calculator function (%d %d R)", num, gen);
 876         }
 877
 878         func->base.size += func->u.p.cap * sizeof(psobj);
 879 }
 880
 881 static void
 882 eval_postscript_func(fz_context *ctx, pdf_function *func, const float *in, float *out)
 883 {
 884         ps_stack st;
 885         float x;
 886         int i;
 887
 888         ps_init_stack(&st);
 889
 890         for (i = 0; i < func->base.m; i++)
 891         {
 892                 x = fz_clamp(in[i], func->domain[i][0], func->domain[i][1]);
 893                 ps_push_real(&st, x);
 894         }
 895
 896         ps_run(ctx, func->u.p.code, &st, 0);
 897
 898         for (i = func->base.n - 1; i >= 0; i--)
 899         {
 900                 x = ps_pop_real(&st);
 901                 out[i] = fz_clamp(x, func->range[i][0], func->range[i][1]);
 902         }
 903 }
 904
 905 /*
 906  * Sample function
 907  */
 908
 909 #define MAX_SAMPLE_FUNCTION_SIZE (100 << 20)
 910
 911 static void
 912 load_sample_func(pdf_function *func, pdf_document *doc, pdf_obj *dict, int num, int gen)
 913 {
 914         fz_context *ctx = doc->ctx;
 915         fz_stream *stream;
 916         pdf_obj *obj;
 917         int samplecount;
 918         int bps;
 919         int i;
 920
 921         fz_var(stream);
 922
 923         func->u.sa.samples = NULL;
 924
 925         obj = pdf_dict_gets(dict, "Size");
 926         if (pdf_array_len(obj) < func->base.m)
 927                 fz_throw(ctx, FZ_ERROR_GENERIC, "too few sample function dimension sizes");
 928         if (pdf_array_len(obj) > func->base.m)
 929                 fz_warn(ctx, "too many sample function dimension sizes");
 930         for (i = 0; i < func->base.m; i++)
 931         {
 932                 func->u.sa.size[i] = pdf_to_int(pdf_array_get(obj, i));
 933                 if (func->u.sa.size[i] <= 0)
 934                 {
 935                         fz_warn(ctx, "non-positive sample function dimension size");
 936                         func->u.sa.size[i] = 1;
 937                 }
 938         }
 939
 940         obj = pdf_dict_gets(dict, "BitsPerSample");
 941         func->u.sa.bps = bps = pdf_to_int(obj);
 942
 943         for (i = 0; i < func->base.m; i++)
 944         {
 945                 func->u.sa.encode[i][0] = 0;
 946                 func->u.sa.encode[i][1] = func->u.sa.size[i] - 1;
 947         }
 948         obj = pdf_dict_gets(dict, "Encode");
 949         if (pdf_is_array(obj))
 950         {
 951                 int ranges = fz_mini(func->base.m, pdf_array_len(obj) / 2);
 952                 if (ranges != func->base.m)
 953                         fz_warn(ctx, "wrong number of sample function input mappings");
 954
 955                 for (i = 0; i < ranges; i++)
 956                 {
 957                         func->u.sa.encode[i][0] = pdf_to_real(pdf_array_get(obj, i * 2 + 0));
 958                         func->u.sa.encode[i][1] = pdf_to_real(pdf_array_get(obj, i * 2 + 1));
 959                 }
 960         }
 961
 962         for (i = 0; i < func->base.n; i++)
 963         {
 964                 func->u.sa.decode[i][0] = func->range[i][0];
 965                 func->u.sa.decode[i][1] = func->range[i][1];
 966         }
 967
 968         obj = pdf_dict_gets(dict, "Decode");
 969         if (pdf_is_array(obj))
 970         {
 971                 int ranges = fz_mini(func->base.n, pdf_array_len(obj) / 2);
 972                 if (ranges != func->base.n)
 973                         fz_warn(ctx, "wrong number of sample function output mappings");
 974
 975                 for (i = 0; i < ranges; i++)
 976                 {
 977                         func->u.sa.decode[i][0] = pdf_to_real(pdf_array_get(obj, i * 2 + 0));
 978                         func->u.sa.decode[i][1] = pdf_to_real(pdf_array_get(obj, i * 2 + 1));
 979                 }
 980         }
 981
 982         for (i = 0, samplecount = func->base.n; i < func->base.m; i++)
 983                 samplecount *= func->u.sa.size[i];
 984
 985         if (samplecount > MAX_SAMPLE_FUNCTION_SIZE)
 986                 fz_throw(ctx, FZ_ERROR_GENERIC, "sample function too large");
 987
 988         func->u.sa.samples = fz_malloc_array(ctx, samplecount, sizeof(float));
 989         func->base.size += samplecount * sizeof(float);
 990
 991         stream = pdf_open_stream(doc, num, gen);
 992
 993         fz_try(ctx)
 994         {
 995                 /* read samples */
 996                 for (i = 0; i < samplecount; i++)
 997                 {
 998                         unsigned int x;
 999                         float s;
1000
1001                         if (fz_is_eof_bits(stream))
1002                                 fz_throw(ctx, FZ_ERROR_GENERIC, "truncated sample function stream");
1003
1004                         switch (bps)
1005                         {
1006                         case 1: s = fz_read_bits(stream, 1); break;
1007                         case 2: s = fz_read_bits(stream, 2) / 3.0f; break;
1008                         case 4: s = fz_read_bits(stream, 4) / 15.0f; break;
1009                         case 8: s = fz_read_byte(stream) / 255.0f; break;
1010                         case 12: s = fz_read_bits(stream, 12) / 4095.0f; break;
1011                         case 16:
1012                                 x = fz_read_byte(stream) << 8;
1013                                 x |= fz_read_byte(stream);
1014                                 s = x / 65535.0f;
1015                                 break;
1016                         case 24:
1017                                 x = fz_read_byte(stream) << 16;
1018                                 x |= fz_read_byte(stream) << 8;
1019                                 x |= fz_read_byte(stream);
1020                                 s = x / 16777215.0f;
1021                                 break;
1022                         case 32:
1023                                 x = fz_read_byte(stream) << 24;
1024                                 x |= fz_read_byte(stream) << 16;
1025                                 x |= fz_read_byte(stream) << 8;
1026                                 x |= fz_read_byte(stream);
1027                                 s = x / 4294967295.0f;
1028                                 break;
1029                         default:
1030                                 fz_throw(ctx, FZ_ERROR_GENERIC, "sample stream bit depth %d unsupported", bps);
1031                         }
1032
1033                         func->u.sa.samples[i] = s;
1034                 }
1035         }
1036         fz_always(ctx)
1037         {
1038                 fz_close(stream);
1039         }
1040         fz_catch(ctx)
1041         {
1042                 fz_rethrow(ctx);
1043         }
1044 }
1045
1046 static float
1047 interpolate_sample(pdf_function *func, int *scale, int *e0, int *e1, float *efrac, int dim, int idx)
1048 {
1049         float a, b;
1050         int idx0, idx1;
1051
1052         idx0 = e0[dim] * scale[dim] + idx;
1053         idx1 = e1[dim] * scale[dim] + idx;
1054
1055         if (dim == 0)
1056         {
1057                 a = func->u.sa.samples[idx0];
1058                 b = func->u.sa.samples[idx1];
1059         }
1060         else
1061         {
1062                 a = interpolate_sample(func, scale, e0, e1, efrac, dim - 1, idx0);
1063                 b = interpolate_sample(func, scale, e0, e1, efrac, dim - 1, idx1);
1064         }
1065
1066         return a + (b - a) * efrac[dim];
1067 }
1068
1069 static void
1070 eval_sample_func(fz_context *ctx, pdf_function *func, const float *in, float *out)
1071 {
1072         int e0[FZ_FN_MAXM], e1[FZ_FN_MAXM], scale[FZ_FN_MAXM];
1073         float efrac[FZ_FN_MAXM];
1074         float x;
1075         int i;
1076
1077         /* encode input coordinates */
1078         for (i = 0; i < func->base.m; i++)
1079         {
1080                 x = fz_clamp(in[i], func->domain[i][0], func->domain[i][1]);
1081                 x = lerp(x, func->domain[i][0], func->domain[i][1],
1082                         func->u.sa.encode[i][0], func->u.sa.encode[i][1]);
1083                 x = fz_clamp(x, 0, func->u.sa.size[i] - 1);
1084                 e0[i] = floorf(x);
1085                 e1[i] = ceilf(x);
1086                 efrac[i] = x - floorf(x);
1087         }
1088
1089         scale[0] = func->base.n;
1090         for (i = 1; i < func->base.m; i++)
1091                 scale[i] = scale[i - 1] * func->u.sa.size[i-1];
1092
1093         for (i = 0; i < func->base.n; i++)
1094         {
1095                 if (func->base.m == 1)
1096                 {
1097                         float a = func->u.sa.samples[e0[0] * func->base.n + i];
1098                         float b = func->u.sa.samples[e1[0] * func->base.n + i];
1099
1100                         float ab = a + (b - a) * efrac[0];
1101
1102                         out[i] = lerp(ab, 0, 1, func->u.sa.decode[i][0], func->u.sa.decode[i][1]);
1103                         out[i] = fz_clamp(out[i], func->range[i][0], func->range[i][1]);
1104                 }
1105
1106                 else if (func->base.m == 2)
1107                 {
1108                         int s0 = func->base.n;
1109                         int s1 = s0 * func->u.sa.size[0];
1110
1111                         float a = func->u.sa.samples[e0[0] * s0 + e0[1] * s1 + i];
1112                         float b = func->u.sa.samples[e1[0] * s0 + e0[1] * s1 + i];
1113                         float c = func->u.sa.samples[e0[0] * s0 + e1[1] * s1 + i];
1114                         float d = func->u.sa.samples[e1[0] * s0 + e1[1] * s1 + i];
1115
1116                         float ab = a + (b - a) * efrac[0];
1117                         float cd = c + (d - c) * efrac[0];
1118                         float abcd = ab + (cd - ab) * efrac[1];
1119
1120                         out[i] = lerp(abcd, 0, 1, func->u.sa.decode[i][0], func->u.sa.decode[i][1]);
1121                         out[i] = fz_clamp(out[i], func->range[i][0], func->range[i][1]);
1122                 }
1123
1124                 else
1125                 {
1126                         x = interpolate_sample(func, scale, e0, e1, efrac, func->base.m - 1, i);
1127                         out[i] = lerp(x, 0, 1, func->u.sa.decode[i][0], func->u.sa.decode[i][1]);
1128                         out[i] = fz_clamp(out[i], func->range[i][0], func->range[i][1]);
1129                 }
1130         }
1131 }
1132
1133 /*
1134  * Exponential function
1135  */
1136
1137 static void
1138 load_exponential_func(fz_context *ctx, pdf_function *func, pdf_obj *dict)
1139 {
1140         pdf_obj *obj;
1141         int i;
1142
1143         if (func->base.m > 1)
1144                 fz_warn(ctx, "exponential functions have at most one input");
1145         func->base.m = 1;
1146
1147         obj = pdf_dict_gets(dict, "N");
1148         func->u.e.n = pdf_to_real(obj);
1149
1150         /* See exponential functions (PDF 1.7 section 3.9.2) */
1151         if (func->u.e.n != (int) func->u.e.n)
1152         {
1153                 /* If N is non-integer, input values may never be negative */
1154                 for (i = 0; i < func->base.m; i++)
1155                         if (func->domain[i][0] < 0 || func->domain[i][1] < 0)
1156                                 fz_warn(ctx, "exponential function input domain includes illegal negative input values");
1157         }
1158         else if (func->u.e.n < 0)
1159         {
1160                 /* if N is negative, input values may never be zero */
1161                 for (i = 0; i < func->base.m; i++)
1162                         if (func->domain[i][0] == 0 || func->domain[i][1] == 0 ||
1163                                 (func->domain[i][0] < 0 && func->domain[i][1] > 0))
1164                                 fz_warn(ctx, "exponential function input domain includes illegal input value zero");
1165         }
1166
1167         for (i = 0; i < func->base.n; i++)
1168         {
1169                 func->u.e.c0[i] = 0;
1170                 func->u.e.c1[i] = 1;
1171         }
1172
1173         obj = pdf_dict_gets(dict, "C0");
1174         if (pdf_is_array(obj))
1175         {
1176                 int ranges = fz_mini(func->base.n, pdf_array_len(obj));
1177                 if (ranges != func->base.n)
1178                         fz_warn(ctx, "wrong number of C0 constants for exponential function");
1179
1180                 for (i = 0; i < ranges; i++)
1181                         func->u.e.c0[i] = pdf_to_real(pdf_array_get(obj, i));
1182         }
1183
1184         obj = pdf_dict_gets(dict, "C1");
1185         if (pdf_is_array(obj))
1186         {
1187                 int ranges = fz_mini(func->base.n, pdf_array_len(obj));
1188                 if (ranges != func->base.n)
1189                         fz_warn(ctx, "wrong number of C1 constants for exponential function");
1190
1191                 for (i = 0; i < ranges; i++)
1192                         func->u.e.c1[i] = pdf_to_real(pdf_array_get(obj, i));
1193         }
1194 }
1195
1196 static void
1197 eval_exponential_func(fz_context *ctx, pdf_function *func, float in, float *out)
1198 {
1199         float x = in;
1200         float tmp;
1201         int i;
1202
1203         x = fz_clamp(x, func->domain[0][0], func->domain[0][1]);
1204
1205         /* Default output is zero, which is suitable for violated constraints */
1206         if ((func->u.e.n != (int)func->u.e.n && x < 0) || (func->u.e.n < 0 && x == 0))
1207                 return;
1208
1209         tmp = powf(x, func->u.e.n);
1210         for (i = 0; i < func->base.n; i++)
1211         {
1212                 out[i] = func->u.e.c0[i] + tmp * (func->u.e.c1[i] - func->u.e.c0[i]);
1213                 if (func->has_range)
1214                         out[i] = fz_clamp(out[i], func->range[i][0], func->range[i][1]);
1215         }
1216 }
1217
1218 /*
1219  * Stitching function
1220  */
1221
1222 static void
1223 load_stitching_func(pdf_function *func, pdf_document *doc, pdf_obj *dict)
1224 {
1225         fz_context *ctx = doc->ctx;
1226         fz_function **funcs;
1227         pdf_obj *obj;
1228         pdf_obj *sub;
1229         pdf_obj *num;
1230         int k;
1231         int i;
1232
1233         func->u.st.k = 0;
1234
1235         if (func->base.m > 1)
1236                 fz_warn(ctx, "stitching functions have at most one input");
1237         func->base.m = 1;
1238
1239         obj = pdf_dict_gets(dict, "Functions");
1240         if (!pdf_is_array(obj))
1241                 fz_throw(ctx, FZ_ERROR_GENERIC, "stitching function has no input functions");
1242
1243         fz_try(ctx)
1244         {
1245                 pdf_mark_obj(obj);
1246                 k = pdf_array_len(obj);
1247
1248                 func->u.st.funcs = fz_malloc_array(ctx, k, sizeof(fz_function*));
1249                 func->u.st.bounds = fz_malloc_array(ctx, k - 1, sizeof(float));
1250                 func->u.st.encode = fz_malloc_array(ctx, k * 2, sizeof(float));
1251                 funcs = func->u.st.funcs;
1252
1253                 for (i = 0; i < k; i++)
1254                 {
1255                         sub = pdf_array_get(obj, i);
1256                         funcs[i] = pdf_load_function(doc, sub, 1, func->base.n);
1257
1258                         func->base.size += fz_function_size(funcs[i]);
1259                         func->u.st.k ++;
1260
1261                         if (funcs[i]->m != func->base.m)
1262                                 fz_warn(ctx, "wrong number of inputs for sub function %d", i);
1263                         if (funcs[i]->n != func->base.n)
1264                                 fz_warn(ctx, "wrong number of outputs for sub function %d", i);
1265                 }
1266         }
1267         fz_always(ctx)
1268         {
1269                 pdf_unmark_obj(obj);
1270         }
1271         fz_catch(ctx)
1272         {
1273                 fz_rethrow(ctx);
1274         }
1275
1276         obj = pdf_dict_gets(dict, "Bounds");
1277         if (!pdf_is_array(obj))
1278                 fz_throw(ctx, FZ_ERROR_GENERIC, "stitching function has no bounds");
1279         {
1280                 if (pdf_array_len(obj) < k - 1)
1281                         fz_throw(ctx, FZ_ERROR_GENERIC, "too few subfunction boundaries");
1282                 if (pdf_array_len(obj) > k)
1283                         fz_warn(ctx, "too many subfunction boundaries");
1284
1285                 for (i = 0; i < k - 1; i++)
1286                 {
1287                         num = pdf_array_get(obj, i);
1288                         func->u.st.bounds[i] = pdf_to_real(num);
1289                         if (i && func->u.st.bounds[i - 1] > func->u.st.bounds[i])
1290                                 fz_throw(ctx, FZ_ERROR_GENERIC, "subfunction %d boundary out of range", i);
1291                 }
1292
1293                 if (k > 1 && (func->domain[0][0] > func->u.st.bounds[0] ||
1294                         func->domain[0][1] < func->u.st.bounds[k - 2]))
1295                         fz_warn(ctx, "subfunction boundaries outside of input mapping");
1296         }
1297
1298         for (i = 0; i < k; i++)
1299         {
1300                 func->u.st.encode[i * 2 + 0] = 0;
1301                 func->u.st.encode[i * 2 + 1] = 0;
1302         }
1303
1304         obj = pdf_dict_gets(dict, "Encode");
1305         if (pdf_is_array(obj))
1306         {
1307                 int ranges = fz_mini(k, pdf_array_len(obj) / 2);
1308                 if (ranges != k)
1309                         fz_warn(ctx, "wrong number of stitching function input mappings");
1310
1311                 for (i = 0; i < ranges; i++)
1312                 {
1313                         func->u.st.encode[i * 2 + 0] = pdf_to_real(pdf_array_get(obj, i * 2 + 0));
1314                         func->u.st.encode[i * 2 + 1] = pdf_to_real(pdf_array_get(obj, i * 2 + 1));
1315                 }
1316         }
1317 }
1318
1319 static void
1320 eval_stitching_func(fz_context *ctx, pdf_function *func, float in, float *out)
1321 {
1322         float low, high;
1323         int k = func->u.st.k;
1324         float *bounds = func->u.st.bounds;
1325         int i;
1326
1327         in = fz_clamp(in, func->domain[0][0], func->domain[0][1]);
1328
1329         for (i = 0; i < k - 1; i++)
1330         {
1331                 if (in < bounds[i])
1332                         break;
1333         }
1334
1335         if (i == 0 && k == 1)
1336         {
1337                 low = func->domain[0][0];
1338                 high = func->domain[0][1];
1339         }
1340         else if (i == 0)
1341         {
1342                 low = func->domain[0][0];
1343                 high = bounds[0];
1344         }
1345         else if (i == k - 1)
1346         {
1347                 low = bounds[k - 2];
1348                 high = func->domain[0][1];
1349         }
1350         else
1351         {
1352                 low = bounds[i - 1];
1353                 high = bounds[i];
1354         }
1355
1356         in = lerp(in, low, high, func->u.st.encode[i * 2 + 0], func->u.st.encode[i * 2 + 1]);
1357
1358         fz_eval_function(ctx, func->u.st.funcs[i], &in, 1, out, func->u.st.funcs[i]->n);
1359 }
1360
1361 /*
1362  * Common
1363  */
1364
1365 static void
1366 pdf_free_function_imp(fz_context *ctx, fz_storable *func_)
1367 {
1368         pdf_function *func = (pdf_function *)func_;
1369         int i;
1370
1371         switch (func->type)
1372         {
1373         case SAMPLE:
1374                 fz_free(ctx, func->u.sa.samples);
1375                 break;
1376         case EXPONENTIAL:
1377                 break;
1378         case STITCHING:
1379                 for (i = 0; i < func->u.st.k; i++)
1380                         fz_drop_function(ctx, func->u.st.funcs[i]);
1381                 fz_free(ctx, func->u.st.funcs);
1382                 fz_free(ctx, func->u.st.bounds);
1383                 fz_free(ctx, func->u.st.encode);
1384                 break;
1385         case POSTSCRIPT:
1386                 fz_free(ctx, func->u.p.code);
1387                 break;
1388         }
1389         fz_free(ctx, func);
1390 }
1391
1392 static void
1393 pdf_eval_function(fz_context *ctx, fz_function *func_, const float *in, float *out)
1394 {
1395         pdf_function *func = (pdf_function *)func_;
1396
1397         switch (func->type)
1398         {
1399         case SAMPLE: eval_sample_func(ctx, func, in, out); break;
1400         case EXPONENTIAL: eval_exponential_func(ctx, func, *in, out); break;
1401         case STITCHING: eval_stitching_func(ctx, func, *in, out); break;
1402         case POSTSCRIPT: eval_postscript_func(ctx, func, in, out); break;
1403         }
1404 }
1405
1406 /*
1407  * Debugging prints
1408  */
1409
1410 #ifndef NDEBUG
1411 static void
1412 pdf_debug_indent(char *prefix, int level, char *suffix)
1413 {
1414         int i;
1415
1416         printf("%s", prefix);
1417
1418         for (i = 0; i < level; i++)
1419                 printf("\t");
1420
1421         printf("%s", suffix);
1422 }
1423
1424 static void
1425 pdf_debug_ps_func_code(psobj *funccode, psobj *code, int level)
1426 {
1427         int eof, wasop;
1428
1429         pdf_debug_indent("", level, "{");
1430
1431         /* Print empty blocks as { }, instead of separating braces on different lines. */
1432         if (code->type == PS_OPERATOR && code->u.op == PS_OP_RETURN)
1433         {
1434                 printf(" } ");
1435                 return;
1436         }
1437
1438         pdf_debug_indent("\n", ++level, "");
1439
1440         eof = 0;
1441         wasop = 0;
1442         while (!eof)
1443         {
1444                 switch (code->type)
1445                 {
1446                 case PS_INT:
1447                         if (wasop)
1448                                 pdf_debug_indent("\n", level, "");
1449
1450                         printf("%d ", code->u.i);
1451                         wasop = 0;
1452                         code++;
1453                         break;
1454
1455                 case PS_REAL:
1456                         if (wasop)
1457                                 pdf_debug_indent("\n", level, "");
1458
1459                         printf("%g ", code->u.f);
1460                         wasop = 0;
1461                         code++;
1462                         break;
1463
1464                 case PS_OPERATOR:
1465                         if (code->u.op == PS_OP_RETURN)
1466                         {
1467                                 printf("\n");
1468                                 eof = 1;
1469                         }
1470                         else if (code->u.op == PS_OP_IF)
1471                         {
1472                                 printf("\n");
1473                                 pdf_debug_ps_func_code(funccode, &funccode[(code + 2)->u.block], level);
1474
1475                                 printf("%s", ps_op_names[code->u.op]);
1476                                 code = &funccode[(code + 3)->u.block];
1477                                 if (code->type != PS_OPERATOR || code->u.op != PS_OP_RETURN)
1478                                         pdf_debug_indent("\n", level, "");
1479
1480                                 wasop = 0;
1481                         }
1482                         else if (code->u.op == PS_OP_IFELSE)
1483                         {
1484                                 printf("\n");
1485                                 pdf_debug_ps_func_code(funccode, &funccode[(code + 2)->u.block], level);
1486
1487                                 printf("\n");
1488                                 pdf_debug_ps_func_code(funccode, &funccode[(code + 1)->u.block], level);
1489
1490                                 printf("%s", ps_op_names[code->u.op]);
1491                                 code = &funccode[(code + 3)->u.block];
1492                                 if (code->type != PS_OPERATOR || code->u.op != PS_OP_RETURN)
1493                                         pdf_debug_indent("\n", level, "");
1494
1495                                 wasop = 0;
1496                         }
1497                         else
1498                         {
1499                                 printf("%s ", ps_op_names[code->u.op]);
1500                                 code++;
1501                                 wasop = 1;
1502                         }
1503                         break;
1504                 }
1505         }
1506
1507         pdf_debug_indent("", --level, "} ");
1508 }
1509
1510 static void
1511 pdf_debug_function_imp(fz_function *func_, int level)
1512 {
1513         int i;
1514         pdf_function *func = (pdf_function *)func_;
1515
1516         pdf_debug_indent("", level, "function {\n");
1517
1518         pdf_debug_indent("", ++level, "");
1519         switch (func->type)
1520         {
1521         case SAMPLE:
1522                 printf("sampled");
1523                 break;
1524         case EXPONENTIAL:
1525                 printf("exponential");
1526                 break;
1527         case STITCHING:
1528                 printf("stitching");
1529                 break;
1530         case POSTSCRIPT:
1531                 printf("postscript");
1532                 break;
1533         }
1534
1535         pdf_debug_indent("\n", level, "");
1536         printf("%d input -> %d output\n", func->base.m, func->base.n);
1537
1538         pdf_debug_indent("", level, "domain ");
1539         for (i = 0; i < func->base.m; i++)
1540                 printf("%g %g ", func->domain[i][0], func->domain[i][1]);
1541         printf("\n");
1542
1543         if (func->has_range)
1544         {
1545                 pdf_debug_indent("", level, "range ");
1546                 for (i = 0; i < func->base.n; i++)
1547                         printf("%g %g ", func->range[i][0], func->range[i][1]);
1548                 printf("\n");
1549         }
1550
1551         switch (func->type)
1552         {
1553         case SAMPLE:
1554                 pdf_debug_indent("", level, "");
1555                 printf("bps: %d\n", func->u.sa.bps);
1556
1557                 pdf_debug_indent("", level, "");
1558                 printf("size: [ ");
1559                 for (i = 0; i < func->base.m; i++)
1560                         printf("%d ", func->u.sa.size[i]);
1561                 printf("]\n");
1562
1563                 pdf_debug_indent("", level, "");
1564                 printf("encode: [ ");
1565                 for (i = 0; i < func->base.m; i++)
1566                         printf("%g %g ", func->u.sa.encode[i][0], func->u.sa.encode[i][1]);
1567                 printf("]\n");
1568
1569                 pdf_debug_indent("", level, "");
1570                 printf("decode: [ ");
1571                 for (i = 0; i < func->base.m; i++)
1572                         printf("%g %g ", func->u.sa.decode[i][0], func->u.sa.decode[i][1]);
1573                 printf("]\n");
1574                 break;
1575
1576         case EXPONENTIAL:
1577                 pdf_debug_indent("", level, "");
1578                 printf("n: %g\n", func->u.e.n);
1579
1580                 pdf_debug_indent("", level, "");
1581                 printf("c0: [ ");
1582                 for (i = 0; i < func->base.n; i++)
1583                         printf("%g ", func->u.e.c0[i]);
1584                 printf("]\n");
1585
1586                 pdf_debug_indent("", level, "");
1587                 printf("c1: [ ");
1588                 for (i = 0; i < func->base.n; i++)
1589                         printf("%g ", func->u.e.c1[i]);
1590                 printf("]\n");
1591                 break;
1592
1593         case STITCHING:
1594                 pdf_debug_indent("", level, "");
1595                 printf("%d functions\n", func->u.st.k);
1596
1597                 pdf_debug_indent("", level, "");
1598                 printf("bounds: [ ");
1599                 for (i = 0; i < func->u.st.k - 1; i++)
1600                         printf("%g ", func->u.st.bounds[i]);
1601                 printf("]\n");
1602
1603                 pdf_debug_indent("", level, "");
1604                 printf("encode: [ ");
1605                 for (i = 0; i < func->u.st.k * 2; i++)
1606                         printf("%g ", func->u.st.encode[i]);
1607                 printf("]\n");
1608
1609                 for (i = 0; i < func->u.st.k; i++)
1610                         pdf_debug_function_imp(func->u.st.funcs[i], level);
1611                 break;
1612
1613         case POSTSCRIPT:
1614                 pdf_debug_ps_func_code(func->u.p.code, func->u.p.code, level);
1615                 printf("\n");
1616                 break;
1617         }
1618
1619         pdf_debug_indent("", --level, "}\n");
1620 }
1621
1622 void
1623 pdf_debug_function(fz_function *func)
1624 {
1625         pdf_debug_function_imp(func, 0);
1626 }
1627 #endif
1628
1629 fz_function *
1630 pdf_load_function(pdf_document *doc, pdf_obj *dict, int in, int out)
1631 {
1632         fz_context *ctx = doc->ctx;
1633         pdf_function *func;
1634         pdf_obj *obj;
1635         int i;
1636
1637         if (pdf_obj_marked(dict))
1638                 fz_throw(ctx, FZ_ERROR_GENERIC, "Recursion in function definition");
1639
1640         if ((func = pdf_find_item(ctx, pdf_free_function_imp, dict)) != NULL)
1641         {
1642                 return (fz_function *)func;
1643         }
1644
1645         func = fz_malloc_struct(ctx, pdf_function);
1646         FZ_INIT_STORABLE(&func->base, 1, pdf_free_function_imp);
1647         func->base.size = sizeof(*func);
1648         func->base.evaluate = pdf_eval_function;
1649 #ifndef NDEBUG
1650         func->base.debug = pdf_debug_function;
1651 #endif
1652
1653         obj = pdf_dict_gets(dict, "FunctionType");
1654         func->type = pdf_to_int(obj);
1655
1656         /* required for all */
1657         obj = pdf_dict_gets(dict, "Domain");
1658         func->base.m = fz_clampi(pdf_array_len(obj) / 2, 1, FZ_FN_MAXM);
1659         for (i = 0; i < func->base.m; i++)
1660         {
1661                 func->domain[i][0] = pdf_to_real(pdf_array_get(obj, i * 2 + 0));
1662                 func->domain[i][1] = pdf_to_real(pdf_array_get(obj, i * 2 + 1));
1663         }
1664
1665         /* required for type0 and type4, optional otherwise */
1666         obj = pdf_dict_gets(dict, "Range");
1667         if (pdf_is_array(obj))
1668         {
1669                 func->has_range = 1;
1670                 func->base.n = fz_clampi(pdf_array_len(obj) / 2, 1, FZ_FN_MAXN);
1671                 for (i = 0; i < func->base.n; i++)
1672                 {
1673                         func->range[i][0] = pdf_to_real(pdf_array_get(obj, i * 2 + 0));
1674                         func->range[i][1] = pdf_to_real(pdf_array_get(obj, i * 2 + 1));
1675                 }
1676         }
1677         else
1678         {
1679                 func->has_range = 0;
1680                 func->base.n = out;
1681         }
1682
1683         if (func->base.m != in)
1684                 fz_warn(ctx, "wrong number of function inputs");
1685         if (func->base.n != out)
1686                 fz_warn(ctx, "wrong number of function outputs");
1687
1688         fz_try(ctx)
1689         {
1690                 switch (func->type)
1691                 {
1692                 case SAMPLE:
1693                         load_sample_func(func, doc, dict, pdf_to_num(dict), pdf_to_gen(dict));
1694                         break;
1695
1696                 case EXPONENTIAL:
1697                         load_exponential_func(ctx, func, dict);
1698                         break;
1699
1700                 case STITCHING:
1701                         load_stitching_func(func, doc, dict);
1702                         break;
1703
1704                 case POSTSCRIPT:
1705                         load_postscript_func(func, doc, dict, pdf_to_num(dict), pdf_to_gen(dict));
1706                         break;
1707
1708                 default:
1709                         fz_throw(ctx, FZ_ERROR_GENERIC, "unknown function type (%d %d R)", pdf_to_num(dict), pdf_to_gen(dict));
1710                 }
1711
1712                 pdf_store_item(ctx, dict, func, func->base.size);
1713         }
1714         fz_catch(ctx)
1715         {
1716                 int type = func->type;
1717                 fz_drop_function(ctx, (fz_function *)func);
1718                 fz_rethrow_message(ctx, "cannot load %s function (%d %d R)",
1719                                         type == SAMPLE ? "sampled" :
1720                                         type == EXPONENTIAL ? "exponential" :
1721                                         type == STITCHING ? "stitching" :
1722                                         type == POSTSCRIPT ? "calculator" :
1723                                         "unknown",
1724                                         pdf_to_num(dict), pdf_to_gen(dict));
1725         }
1726
1727         return (fz_function *)func;
1728 }