QRScanner/mobile/jni/pdf/pdf-op-buffer.c

   1 #include "pdf-interpret-imp.h"
   2
   3 typedef struct pdf_buffer_state_s
   4 {
   5         fz_context *ctx;
   6         fz_buffer *buffer;
   7         fz_output *out;
   8 }
   9 pdf_buffer_state;
  10
  11 static void
  12 put_hexstring(pdf_csi *csi, fz_output *out)
  13 {
  14         int i;
  15
  16         fz_printf(out, "<");
  17         for (i = 0; i < csi->string_len; i++)
  18                 fz_printf(out, "%02x", csi->string[i]);
  19         fz_printf(out, ">");
  20 }
  21
  22 static void
  23 put_string(pdf_csi *csi, fz_output *out)
  24 {
  25         int i;
  26
  27         for (i=0; i < csi->string_len; i++)
  28                 if (csi->string[i] < 32 || csi->string[i] >= 127)
  29                         break;
  30         if (i < csi->string_len)
  31                 put_hexstring(csi, out);
  32         else
  33         {
  34                 fz_printf(out, "(");
  35                 for (i = 0; i < csi->string_len; i++)
  36                 {
  37                         char c = csi->string[i];
  38                         switch (c)
  39                         {
  40                         case '(':
  41                                 fz_printf(out, "\\(");
  42                                 break;
  43                         case ')':
  44                                 fz_printf(out, "\\)");
  45                                 break;
  46                         case '\\':
  47                                 fz_printf(out, "\\\\");
  48                                 break;
  49                         default:
  50                                 fz_printf(out, "%c", csi->string[i]);
  51                                 break;
  52                         }
  53                 }
  54                 fz_printf(out, ")");
  55         }
  56 }
  57
  58 static void
  59 put_string_or_obj(pdf_csi *csi, fz_output *out)
  60 {
  61         if (csi->string_len)
  62                 put_string(csi, out);
  63         else
  64                 pdf_output_obj(out, csi->obj, 1);
  65 }
  66
  67 static void
  68 pdf_buffer_dquote(pdf_csi *csi, void *state_)
  69 {
  70         pdf_buffer_state *state = (pdf_buffer_state *)state_;
  71
  72         fz_printf(state->out, "%f %f ", csi->stack[0], csi->stack[1]);
  73         put_string_or_obj(csi, state->out);
  74         fz_printf(state->out, " \"\n");
  75 }
  76
  77 static void
  78 pdf_buffer_squote(pdf_csi *csi, void *state_)
  79 {
  80         pdf_buffer_state *state = (pdf_buffer_state *)state_;
  81
  82         put_string_or_obj(csi, state->out);
  83         fz_printf(state->out, " \'\n");
  84 }
  85
  86 static void
  87 pdf_buffer_B(pdf_csi *csi, void *state_)
  88 {
  89         pdf_buffer_state *state = (pdf_buffer_state *)state_;
  90
  91         fz_printf(state->out, "B\n");
  92 }
  93
  94 static void
  95 pdf_buffer_Bstar(pdf_csi *csi, void *state_)
  96 {
  97         pdf_buffer_state *state = (pdf_buffer_state *)state_;
  98
  99         fz_printf(state->out, "B*\n");
 100 }
 101
 102 static void
 103 pdf_buffer_BDC(pdf_csi *csi, void *state_)
 104 {
 105         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 106
 107         fz_printf(state->out, "/%s ", csi->name);
 108         pdf_output_obj(state->out, csi->obj, 1);
 109         fz_printf(state->out, " BDC\n");
 110 }
 111
 112 static void
 113 pdf_buffer_BI(pdf_csi *csi, void *state_)
 114 {
 115         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 116         int len, i;
 117         unsigned char *data;
 118         fz_compressed_buffer *cbuf;
 119         fz_buffer *buffer;
 120         const char *match;
 121         const char *match2;
 122         pdf_obj *filter;
 123         fz_context *ctx = csi->doc->ctx;
 124
 125         if (csi->img == NULL)
 126                 return;
 127         cbuf = csi->img->buffer;
 128         if (cbuf == NULL)
 129                 return;
 130         buffer = cbuf->buffer;
 131         if (buffer == NULL)
 132                 return;
 133
 134         /* Tweak the /Filter entry in csi->obj to match the buffer params */
 135         switch (cbuf->params.type)
 136         {
 137         case FZ_IMAGE_JPEG:
 138                 match = "DCTDecode";
 139                 match2 = "DCT";
 140                 break;
 141         case FZ_IMAGE_FAX:
 142                 match = "CCITTFaxDecode";
 143                 match2 = "CCF";
 144                 break;
 145         case FZ_IMAGE_RAW:
 146                 match = NULL;
 147                 match2 = NULL;
 148                 break;
 149         case FZ_IMAGE_RLD:
 150                 match = "RunLengthDecode";
 151                 match2 = "RL";
 152                 break;
 153         case FZ_IMAGE_FLATE:
 154                 match = "FlateDecode";
 155                 match2 = "Fl";
 156                 break;
 157         case FZ_IMAGE_LZW:
 158                 match = "LZWDecode";
 159                 match2 = "LZW";
 160                 break;
 161         default:
 162                 fz_warn(ctx, "Unsupported type (%d) of inline image", cbuf->params.type);
 163                 return;
 164         }
 165
 166         filter = pdf_dict_gets(csi->obj, "Filter");
 167         if (filter == NULL)
 168                 filter = pdf_dict_gets(csi->obj, "F");
 169         if (match == NULL)
 170         {
 171                 /* Remove any filter entry (e.g. Ascii85Decode) */
 172                 if (filter)
 173                 {
 174                         pdf_dict_dels(csi->obj, "Filter");
 175                         pdf_dict_dels(csi->obj, "F");
 176                 }
 177                 pdf_dict_dels(csi->obj, "DecodeParms");
 178                 pdf_dict_dels(csi->obj, "DP");
 179         }
 180         else if (pdf_is_array(filter))
 181         {
 182                 int l = pdf_array_len(filter);
 183                 pdf_obj *o = (l == 0 ? NULL : pdf_array_get(filter, l-1));
 184                 const char *fil = pdf_to_name(o);
 185
 186                 if (l == 0 || (strcmp(fil, match) && strcmp(fil, match2)))
 187                 {
 188                         fz_warn(ctx, "Unexpected Filter configuration in inline image");
 189                         return;
 190                 }
 191                 pdf_dict_puts(csi->obj, "F", o);
 192
 193                 o = pdf_dict_gets(csi->obj, "DecodeParms");
 194                 if (o == NULL)
 195                         o = pdf_dict_gets(csi->obj, "DP");
 196                 if (o)
 197                 {
 198                         o = pdf_array_get(o, l-1);
 199                         if (o)
 200                                 pdf_dict_puts(csi->obj, "DP", o);
 201                         else
 202                                 pdf_dict_dels(csi->obj, "DP");
 203                         pdf_dict_dels(csi->obj, "DecodeParms");
 204                 }
 205         }
 206         else
 207         {
 208                 /* It's a singleton. It must be correct */
 209         }
 210
 211         fz_printf(state->out, "BI\n");
 212
 213         len = pdf_dict_len(csi->obj);
 214         for (i = 0; i < len; i++)
 215         {
 216                 pdf_output_obj(state->out, pdf_dict_get_key(csi->obj, i), 1);
 217                 pdf_output_obj(state->out, pdf_dict_get_val(csi->obj, i), 1);
 218         }
 219         fz_printf(state->out, "ID\n");
 220
 221         buffer = csi->img->buffer->buffer;
 222         len = buffer->len;
 223         data = buffer->data;
 224         for (i = 0; i < len; i++)
 225         {
 226                 fz_printf(state->out, "%c", data[i]);
 227         }
 228
 229         fz_printf(state->out, "\nEI\n");
 230 }
 231
 232 static void
 233 pdf_buffer_BMC(pdf_csi *csi, void *state_)
 234 {
 235         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 236
 237         fz_printf(state->out, "/%s BMC\n", csi->name);
 238 }
 239
 240 static void
 241 pdf_buffer_BT(pdf_csi *csi, void *state_)
 242 {
 243         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 244
 245         fz_printf(state->out, "BT\n");
 246 }
 247
 248 static void
 249 pdf_buffer_BX(pdf_csi *csi, void *state_)
 250 {
 251         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 252
 253         fz_printf(state->out, "BX\n");
 254 }
 255
 256 static void
 257 pdf_buffer_CS(pdf_csi *csi, void *state_)
 258 {
 259         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 260
 261         fz_printf(state->out, "/%s CS\n", csi->name);
 262 }
 263
 264 static void
 265 pdf_buffer_DP(pdf_csi *csi, void *state_)
 266 {
 267         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 268
 269         fz_printf(state->out, "/%s ", csi->name);
 270         pdf_output_obj(state->out, csi->obj, 1);
 271         fz_printf(state->out, " DP\n");
 272 }
 273
 274 static void
 275 pdf_buffer_EMC(pdf_csi *csi, void *state_)
 276 {
 277         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 278
 279         fz_printf(state->out, "EMC\n");
 280 }
 281
 282 static void
 283 pdf_buffer_ET(pdf_csi *csi, void *state_)
 284 {
 285         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 286
 287         fz_printf(state->out, "ET\n");
 288 }
 289
 290 static void
 291 pdf_buffer_EX(pdf_csi *csi, void *state_)
 292 {
 293         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 294
 295         fz_printf(state->out, "EX\n");
 296 }
 297
 298 static void
 299 pdf_buffer_F(pdf_csi *csi, void *state_)
 300 {
 301         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 302
 303         fz_printf(state->out, "F\n");
 304 }
 305
 306 static void
 307 pdf_buffer_G(pdf_csi *csi, void *state_)
 308 {
 309         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 310
 311         fz_printf(state->out, "%f G\n", csi->stack[0]);
 312 }
 313
 314 static void
 315 pdf_buffer_J(pdf_csi *csi, void *state_)
 316 {
 317         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 318
 319         fz_printf(state->out, "%d J\n", (int)csi->stack[0]);
 320 }
 321
 322 static void
 323 pdf_buffer_K(pdf_csi *csi, void *state_)
 324 {
 325         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 326
 327         fz_printf(state->out, "%f %f %f %f K\n", csi->stack[0],
 328                 csi->stack[1], csi->stack[2], csi->stack[3]);
 329 }
 330
 331 static void
 332 pdf_buffer_M(pdf_csi *csi, void *state_)
 333 {
 334         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 335
 336         fz_printf(state->out, "%f M\n", csi->stack[0]);
 337 }
 338
 339 static void
 340 pdf_buffer_MP(pdf_csi *csi, void *state_)
 341 {
 342         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 343
 344         fz_printf(state->out, "/%s MP\n", csi->name);
 345 }
 346
 347 static void
 348 pdf_buffer_Q(pdf_csi *csi, void *state_)
 349 {
 350         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 351
 352         fz_printf(state->out, "Q\n");
 353 }
 354
 355 static void
 356 pdf_buffer_RG(pdf_csi *csi, void *state_)
 357 {
 358         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 359
 360         fz_printf(state->out, "%f %f %f RG\n", csi->stack[0], csi->stack[1], csi->stack[2]);
 361 }
 362
 363 static void
 364 pdf_buffer_S(pdf_csi *csi, void *state_)
 365 {
 366         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 367
 368         fz_printf(state->out, "S\n");
 369 }
 370
 371 static void
 372 pdf_buffer_SC(pdf_csi *csi, void *state_)
 373 {
 374         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 375         int i;
 376
 377         for (i = 0; i < csi->top; i++)
 378                 fz_printf(state->out, "%f ", csi->stack[i]);
 379         fz_printf(state->out, "SC\n");
 380 }
 381
 382 static void
 383 pdf_buffer_SCN(pdf_csi *csi, void *state_)
 384 {
 385         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 386         int i;
 387
 388         for (i = 0; i < csi->top; i++)
 389                 fz_printf(state->out, "%f ", csi->stack[i]);
 390         if (csi->name[0])
 391                 fz_printf(state->out, "/%s ", csi->name);
 392         fz_printf(state->out, "SCN\n");
 393 }
 394
 395 static void
 396 pdf_buffer_Tstar(pdf_csi *csi, void *state_)
 397 {
 398         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 399
 400         fz_printf(state->out, "T*\n");
 401 }
 402
 403 static void
 404 pdf_buffer_TD(pdf_csi *csi, void *state_)
 405 {
 406         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 407
 408         fz_printf(state->out, "%f %f TD\n", csi->stack[0], csi->stack[1]);
 409 }
 410
 411 static void
 412 pdf_buffer_TJ(pdf_csi *csi, void *state_)
 413 {
 414         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 415
 416         pdf_output_obj(state->out, csi->obj, 1);
 417         fz_printf(state->out, " TJ\n");
 418 }
 419
 420 static void
 421 pdf_buffer_TL(pdf_csi *csi, void *state_)
 422 {
 423         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 424
 425         fz_printf(state->out, "%f TL\n", csi->stack[0]);
 426 }
 427
 428 static void
 429 pdf_buffer_Tc(pdf_csi *csi, void *state_)
 430 {
 431         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 432
 433         fz_printf(state->out, "%f Tc\n", csi->stack[0]);
 434 }
 435
 436 static void
 437 pdf_buffer_Td(pdf_csi *csi, void *state_)
 438 {
 439         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 440
 441         fz_printf(state->out, "%f %f Td\n", csi->stack[0], csi->stack[1]);
 442 }
 443
 444 static void
 445 pdf_buffer_Tj(pdf_csi *csi, void *state_)
 446 {
 447         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 448
 449         put_string_or_obj(csi, state->out);
 450         fz_printf(state->out, " Tj\n");
 451 }
 452
 453 static void
 454 pdf_buffer_Tm(pdf_csi *csi, void *state_)
 455 {
 456         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 457
 458         fz_printf(state->out, "%f %f %f %f %f %f Tm\n",
 459                 csi->stack[0], csi->stack[1], csi->stack[2],
 460                 csi->stack[3], csi->stack[4], csi->stack[5]);
 461 }
 462
 463 static void
 464 pdf_buffer_Tr(pdf_csi *csi, void *state_)
 465 {
 466         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 467
 468         fz_printf(state->out, "%f Tr\n", csi->stack[0]);
 469 }
 470
 471 static void
 472 pdf_buffer_Ts(pdf_csi *csi, void *state_)
 473 {
 474         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 475
 476         fz_printf(state->out, "%f Ts\n", csi->stack[0]);
 477 }
 478
 479 static void
 480 pdf_buffer_Tw(pdf_csi *csi, void *state_)
 481 {
 482         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 483
 484         fz_printf(state->out, "%f Tw\n", csi->stack[0]);
 485 }
 486
 487 static void
 488 pdf_buffer_Tz(pdf_csi *csi, void *state_)
 489 {
 490         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 491
 492         fz_printf(state->out, "%f Tz\n", csi->stack[0]);
 493 }
 494
 495 static void
 496 pdf_buffer_W(pdf_csi *csi, void *state_)
 497 {
 498         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 499
 500         fz_printf(state->out, "W\n");
 501 }
 502
 503 static void
 504 pdf_buffer_Wstar(pdf_csi *csi, void *state_)
 505 {
 506         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 507
 508         fz_printf(state->out, "W*\n");
 509 }
 510
 511 static void
 512 pdf_buffer_b(pdf_csi *csi, void *state_)
 513 {
 514         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 515
 516         fz_printf(state->out, "b\n");
 517 }
 518
 519 static void
 520 pdf_buffer_bstar(pdf_csi *csi, void *state_)
 521 {
 522         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 523
 524         fz_printf(state->out, "b*\n");
 525 }
 526
 527 static void
 528 pdf_buffer_c(pdf_csi *csi, void *state_)
 529 {
 530         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 531
 532         fz_printf(state->out, "%f %f %f %f %f %f c\n",
 533                 csi->stack[0], csi->stack[1], csi->stack[2],
 534                 csi->stack[3], csi->stack[4], csi->stack[5]);
 535 }
 536
 537 static void
 538 pdf_buffer_cm(pdf_csi *csi, void *state_)
 539 {
 540         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 541
 542         fz_printf(state->out, "%f %f %f %f %f %f cm\n",
 543                 csi->stack[0], csi->stack[1], csi->stack[2],
 544                 csi->stack[3], csi->stack[4], csi->stack[5]);
 545 }
 546
 547 static void
 548 pdf_buffer_cs(pdf_csi *csi, void *state_)
 549 {
 550         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 551
 552         fz_printf(state->out, "/%s cs\n", csi->name);
 553 }
 554
 555 static void
 556 pdf_buffer_d(pdf_csi *csi, void *state_)
 557 {
 558         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 559
 560         pdf_output_obj(state->out, csi->obj, 1);
 561         fz_printf(state->out, " %f d\n", csi->stack[0]);
 562 }
 563
 564 static void
 565 pdf_buffer_d0(pdf_csi *csi, void *state_)
 566 {
 567         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 568
 569         fz_printf(state->out, "%f %f d0\n", csi->stack[0], csi->stack[1]);
 570 }
 571
 572 static void
 573 pdf_buffer_d1(pdf_csi *csi, void *state_)
 574 {
 575         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 576
 577         fz_printf(state->out, "%f %f %f %f %f %f d1\n",
 578                 csi->stack[0], csi->stack[1], csi->stack[2],
 579                 csi->stack[3], csi->stack[4], csi->stack[5]);
 580 }
 581
 582 static void
 583 pdf_buffer_f(pdf_csi *csi, void *state_)
 584 {
 585         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 586
 587         fz_printf(state->out, "f\n");
 588 }
 589
 590 static void
 591 pdf_buffer_fstar(pdf_csi *csi, void *state_)
 592 {
 593         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 594
 595         fz_printf(state->out, "f*\n");
 596 }
 597
 598 static void
 599 pdf_buffer_g(pdf_csi *csi, void *state_)
 600 {
 601         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 602
 603         fz_printf(state->out, "%f g\n", csi->stack[0]);
 604 }
 605
 606 static void
 607 pdf_buffer_h(pdf_csi *csi, void *state_)
 608 {
 609         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 610
 611         fz_printf(state->out, "h\n");
 612 }
 613
 614 static void
 615 pdf_buffer_i(pdf_csi *csi, void *state_)
 616 {
 617         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 618
 619         fz_printf(state->out, "%f i\n", csi->stack[0]);
 620 }
 621
 622 static void
 623 pdf_buffer_j(pdf_csi *csi, void *state_)
 624 {
 625         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 626
 627         fz_printf(state->out, "%d j\n", (int)csi->stack[0]);
 628 }
 629
 630 static void
 631 pdf_buffer_k(pdf_csi *csi, void *state_)
 632 {
 633         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 634
 635         fz_printf(state->out, "%f %f %f %f k\n", csi->stack[0],
 636                 csi->stack[1], csi->stack[2], csi->stack[3]);
 637 }
 638
 639 static void
 640 pdf_buffer_l(pdf_csi *csi, void *state_)
 641 {
 642         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 643
 644         fz_printf(state->out, "%f %f l\n", csi->stack[0], csi->stack[1]);
 645 }
 646
 647 static void
 648 pdf_buffer_m(pdf_csi *csi, void *state_)
 649 {
 650         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 651
 652         fz_printf(state->out, "%f %f m\n", csi->stack[0], csi->stack[1]);
 653 }
 654
 655 static void
 656 pdf_buffer_n(pdf_csi *csi, void *state_)
 657 {
 658         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 659
 660         fz_printf(state->out, "n\n");
 661 }
 662
 663 static void
 664 pdf_buffer_q(pdf_csi *csi, void *state_)
 665 {
 666         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 667
 668         fz_printf(state->out, "q\n");
 669 }
 670
 671 static void
 672 pdf_buffer_re(pdf_csi *csi, void *state_)
 673 {
 674         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 675
 676         fz_printf(state->out, "%f %f %f %f re\n", csi->stack[0],
 677                 csi->stack[1], csi->stack[2], csi->stack[3]);
 678 }
 679
 680 static void
 681 pdf_buffer_rg(pdf_csi *csi, void *state_)
 682 {
 683         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 684
 685         fz_printf(state->out, "%f %f %f rg\n",
 686                 csi->stack[0], csi->stack[1], csi->stack[2]);
 687 }
 688
 689 static void
 690 pdf_buffer_ri(pdf_csi *csi, void *state_)
 691 {
 692         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 693
 694         fz_printf(state->out, "/%s ri\n", csi->name);
 695 }
 696
 697 static void
 698 pdf_buffer_s(pdf_csi *csi, void *state_)
 699 {
 700         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 701
 702         fz_printf(state->out, "s\n");
 703 }
 704
 705 static void
 706 pdf_buffer_sc(pdf_csi *csi, void *state_)
 707 {
 708         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 709         int i;
 710
 711         for (i = 0; i < csi->top; i++)
 712                 fz_printf(state->out, "%f ", csi->stack[i]);
 713         fz_printf(state->out, "sc\n");
 714 }
 715
 716 static void
 717 pdf_buffer_scn(pdf_csi *csi, void *state_)
 718 {
 719         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 720         int i;
 721
 722         for (i = 0; i < csi->top; i++)
 723                 fz_printf(state->out, "%f ", csi->stack[i]);
 724         if (csi->name[0])
 725                 fz_printf(state->out, "/%s ", csi->name);
 726         fz_printf(state->out, "scn\n");
 727 }
 728
 729 static void
 730 pdf_buffer_v(pdf_csi *csi, void *state_)
 731 {
 732         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 733
 734         fz_printf(state->out, "%f %f %f %f v\n", csi->stack[0],
 735                 csi->stack[1], csi->stack[2], csi->stack[3]);
 736 }
 737
 738 static void
 739 pdf_buffer_w(pdf_csi *csi, void *state_)
 740 {
 741         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 742
 743         fz_printf(state->out, "%f w\n", csi->stack[0]);
 744 }
 745
 746 static void
 747 pdf_buffer_y(pdf_csi *csi, void *state_)
 748 {
 749         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 750
 751         fz_printf(state->out, "%f %f %f %f y\n", csi->stack[0],
 752                 csi->stack[1], csi->stack[2], csi->stack[3]);
 753 }
 754
 755 static void
 756 pdf_buffer_Do(pdf_csi *csi, void *state_)
 757 {
 758         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 759
 760         fz_printf(state->out, "/%s Do\n", csi->name);
 761 }
 762
 763 static void
 764 pdf_buffer_Tf(pdf_csi *csi, void *state_)
 765 {
 766         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 767
 768         fz_printf(state->out, "/%s %f Tf\n", csi->name, csi->stack[0]);
 769 }
 770
 771 static void
 772 pdf_buffer_gs(pdf_csi *csi, void *state_)
 773 {
 774         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 775
 776         fz_printf(state->out, "/%s gs\n", csi->name);
 777 }
 778
 779 static void
 780 pdf_buffer_sh(pdf_csi *csi, void *state_)
 781 {
 782         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 783
 784         fz_printf(state->out, "/%s sh\n", csi->name);
 785 }
 786
 787 static void
 788 free_processor_buffer(pdf_csi *csi, void *state_)
 789 {
 790         pdf_buffer_state *state = (pdf_buffer_state *)state_;
 791         fz_context *ctx = state->ctx;
 792
 793         fz_close_output(state->out);
 794         fz_free(ctx, state);
 795 }
 796
 797 static void
 798 process_annot(pdf_csi *csi, void *state, pdf_obj *resources, pdf_annot *annot)
 799 {
 800         fz_context *ctx = csi->doc->ctx;
 801         pdf_xobject *xobj = annot->ap;
 802
 803         /* Avoid infinite recursion */
 804         if (xobj == NULL || pdf_mark_obj(xobj->me))
 805                 return;
 806
 807         fz_try(ctx)
 808         {
 809                 if (xobj->resources)
 810                         resources = xobj->resources;
 811
 812                 pdf_process_contents_object(csi, resources, xobj->contents);
 813         }
 814         fz_always(ctx)
 815         {
 816                 pdf_unmark_obj(xobj->me);
 817         }
 818         fz_catch(ctx)
 819         {
 820                 fz_rethrow(ctx);
 821         }
 822 }
 823
 824 static void
 825 process_stream(pdf_csi *csi, void *state, pdf_lexbuf *buf)
 826 {
 827         pdf_process_stream(csi, buf);
 828 }
 829
 830 static void
 831 process_contents(pdf_csi *csi, void *state, pdf_obj *resources, pdf_obj *contents)
 832 {
 833         pdf_process_contents_object(csi, resources, contents);
 834 }
 835
 836 static const pdf_processor pdf_processor_buffer =
 837 {
 838         {
 839         pdf_buffer_dquote,
 840         pdf_buffer_squote,
 841         pdf_buffer_B,
 842         pdf_buffer_Bstar,
 843         pdf_buffer_BDC,
 844         pdf_buffer_BI,
 845         pdf_buffer_BMC,
 846         pdf_buffer_BT,
 847         pdf_buffer_BX,
 848         pdf_buffer_CS,
 849         pdf_buffer_DP,
 850         pdf_buffer_EMC,
 851         pdf_buffer_ET,
 852         pdf_buffer_EX,
 853         pdf_buffer_F,
 854         pdf_buffer_G,
 855         pdf_buffer_J,
 856         pdf_buffer_K,
 857         pdf_buffer_M,
 858         pdf_buffer_MP,
 859         pdf_buffer_Q,
 860         pdf_buffer_RG,
 861         pdf_buffer_S,
 862         pdf_buffer_SC,
 863         pdf_buffer_SCN,
 864         pdf_buffer_Tstar,
 865         pdf_buffer_TD,
 866         pdf_buffer_TJ,
 867         pdf_buffer_TL,
 868         pdf_buffer_Tc,
 869         pdf_buffer_Td,
 870         pdf_buffer_Tj,
 871         pdf_buffer_Tm,
 872         pdf_buffer_Tr,
 873         pdf_buffer_Ts,
 874         pdf_buffer_Tw,
 875         pdf_buffer_Tz,
 876         pdf_buffer_W,
 877         pdf_buffer_Wstar,
 878         pdf_buffer_b,
 879         pdf_buffer_bstar,
 880         pdf_buffer_c,
 881         pdf_buffer_cm,
 882         pdf_buffer_cs,
 883         pdf_buffer_d,
 884         pdf_buffer_d0,
 885         pdf_buffer_d1,
 886         pdf_buffer_f,
 887         pdf_buffer_fstar,
 888         pdf_buffer_g,
 889         pdf_buffer_h,
 890         pdf_buffer_i,
 891         pdf_buffer_j,
 892         pdf_buffer_k,
 893         pdf_buffer_l,
 894         pdf_buffer_m,
 895         pdf_buffer_n,
 896         pdf_buffer_q,
 897         pdf_buffer_re,
 898         pdf_buffer_rg,
 899         pdf_buffer_ri,
 900         pdf_buffer_s,
 901         pdf_buffer_sc,
 902         pdf_buffer_scn,
 903         pdf_buffer_v,
 904         pdf_buffer_w,
 905         pdf_buffer_y,
 906         pdf_buffer_Do,
 907         pdf_buffer_Tf,
 908         pdf_buffer_gs,
 909         pdf_buffer_sh,
 910         free_processor_buffer
 911         },
 912         process_annot,
 913         process_stream,
 914         process_contents
 915 };
 916
 917 pdf_process *pdf_process_buffer(pdf_process *process, fz_context *ctx, fz_buffer *buffer)
 918 {
 919         fz_output *out = fz_new_output_with_buffer(ctx, buffer);
 920         pdf_buffer_state *p = NULL;
 921
 922         fz_var(p);
 923
 924         fz_try(ctx)
 925         {
 926                 p = fz_malloc_struct(ctx, pdf_buffer_state);
 927                 p->buffer = buffer;
 928                 p->out = out;
 929                 p->ctx = ctx;
 930         }
 931         fz_catch(ctx)
 932         {
 933                 fz_close_output(out);
 934                 fz_rethrow(ctx);
 935         }
 936
 937         process->state = p;
 938         process->processor = &pdf_processor_buffer;
 939         return process;
 940 }