Attachment #262653 for bug #355091

View | Details | Raw Unified | Return to bug 355091 | Differences between
Collapse All | Expand All




    if ((info_p = png_create_info_struct(png_p)) == NULL)
        pdftex_fail("libpng: png_create_info_struct() failed");
    img_png_info_ptr(idict) = info_p;
    if (setjmp(png_jmpbuf(png_p)))
        pdftex_fail("libpng: internal error");
    png_init_io(png_p, img_file(idict));
    png_read_info(png_p, info_p);

        png_set_tRNS_to_alpha(png_p);
    }
    /* alpha channel support  */
    if (pdf->minor_version < 4 && png_get_color_type (png_p, info_p) | PNG_COLOR_MASK_ALPHA)
        png_set_strip_alpha(png_p);
    /* 16bit depth support */
    if (pdf->minor_version < 5)
        pdf->image_hicolor = 0;
    if ((png_get_bit_depth (png_p, info_p) == 16) && (pdf->image_hicolor == 0))
        png_set_strip_16(png_p);
    /* gamma support */
    if (pdf->image_apply_gamma) {

    /* reset structure */
    png_read_update_info(png_p, info_p);
    /* resolution support */
    img_xsize(idict) = (int) png_get_image_width (png_p, info_p);
    img_ysize(idict) = (int) png_get_image_height (png_p, info_p);
    if (png_get_valid(png_p, info_p, PNG_INFO_pHYs)) {
        img_xres(idict) =
            round(0.0254 * (double) png_get_x_pixels_per_meter(png_p, info_p));
        img_yres(idict) =
            round(0.0254 * (double) png_get_y_pixels_per_meter(png_p, info_p));
    }
    switch (png_get_color_type (png_p, info_p)) {
    case PNG_COLOR_TYPE_PALETTE:
        img_procset(idict) |= PROCSET_IMAGE_C | PROCSET_IMAGE_I;
        break;

        img_procset(idict) |= PROCSET_IMAGE_C;
        break;
    default:
        pdftex_fail("unsupported type of color_type <%i>", (int)png_get_color_type (png_p, info_p));
    }
    img_colordepth(idict) = png_get_bit_depth (png_p, info_p);
    if (readtype == IMG_CLOSEINBETWEEN)
        close_and_cleanup_png(idict);
}

#define write_simple_pixel(r)    pdf_quick_out(pdf,*r++)

#define write_noninterlaced(outmac)                      \
    for (i = 0; i < (int)png_get_image_height (png_p, info_p); i++) {          \
    png_read_row(png_p, row, NULL);                      \
    r = row;                                             \
    k = (int)png_get_rowbytes (png_p, info_p);				 \
    while(k > 0) {                                       \
        l = (k > pdf->buf_size)? pdf->buf_size : k;      \
                pdf_room(pdf,l);                         \

        }

#define write_interlaced(outmac)                         \
    for (i = 0; i < (int)png_get_image_height (png_p, info_p); i++) {          \
            row = rows[i];                               \
            k = (int)png_get_rowbytes (png_p, info_p);			 \
            while(k > 0) {                               \
                l = (k > pdf->buf_size)?pdf->buf_size: k;\
                pdf_room(pdf,l);                         \

    png_infop info_p = img_png_info_ptr(idict);
    png_bytep row, r, *rows;
    int palette_objnum = 0;
    png_colorp palette;
    int num_palette;

    png_get_PLTE(png_p, info_p, &palette, &num_palette);

    if (img_colorspace(idict) != 0) {
        pdf_printf(pdf, "%i 0 R\n", (int) img_colorspace(idict));
    } else {
        palette_objnum = pdf_create_obj(pdf, obj_type_others, 0);
        pdf_printf(pdf, "[/Indexed /DeviceRGB %i %i 0 R]\n",
                   num_palette - 1, (int) palette_objnum);
    }
    pdf_begin_stream(pdf);
    if (png_get_interlace_type (png_p, info_p) == PNG_INTERLACE_NONE) {
        row = xtalloc(png_get_rowbytes (png_p, info_p), png_byte);
        write_noninterlaced(write_simple_pixel(r));
        xfree(row);
    } else {
        if (png_get_image_height (png_p, info_p) * png_get_rowbytes (png_p, info_p) >= 10240000L)
            pdftex_warn
                ("large interlaced PNG might cause out of memory (use non-interlaced PNG to fix this)");
        rows = xtalloc(png_get_image_height (png_p, info_p), png_bytep);
        for (i = 0; (unsigned) i < png_get_image_height (png_p, info_p); i++)
            rows[i] = xtalloc(png_get_rowbytes (png_p, info_p), png_byte);
        png_read_image(png_p, rows);
        write_interlaced(write_simple_pixel(row));
        xfree(rows);

    if (palette_objnum > 0) {
        pdf_begin_dict(pdf, palette_objnum, 0);
        pdf_begin_stream(pdf);
        for (i = 0; (unsigned) i < num_palette; i++) {
            pdf_room(pdf, 3);
            pdf_quick_out(pdf, palette[i].red);
            pdf_quick_out(pdf, palette[i].green);
            pdf_quick_out(pdf, palette[i].blue);
        }
        pdf_end_stream(pdf);
    }

        pdf_puts(pdf, "/DeviceGray\n");
    }
    pdf_begin_stream(pdf);
    if (png_get_interlace_type (png_p, info_p) == PNG_INTERLACE_NONE) {
        row = xtalloc(png_get_rowbytes (png_p, info_p), png_byte);
        write_noninterlaced(write_simple_pixel(r));
        xfree(row);
    } else {
        if (png_get_image_height (png_p, info_p) * png_get_rowbytes (png_p, info_p) >= 10240000L)
            pdftex_warn
                ("large interlaced PNG might cause out of memory (use non-interlaced PNG to fix this)");
        rows = xtalloc(png_get_image_height (png_p, info_p), png_bytep);
        for (i = 0; (unsigned) i < png_get_image_height (png_p, info_p); i++)
            rows[i] = xtalloc(png_get_rowbytes (png_p, info_p), png_byte);
        png_read_image(png_p, rows);
        write_interlaced(write_simple_pixel(row));
        xfree(rows);

    png_bytep smask;
    int smask_ptr = 0;
    int smask_size = 0;
    png_byte bitdepth;
    if (img_colorspace(idict) != 0) {
        pdf_printf(pdf, "%i 0 R\n", (int) img_colorspace(idict));
    } else {

    }
    smask_objnum = pdf_create_obj(pdf, obj_type_others, 0);
    pdf_printf(pdf, "/SMask %i 0 R\n", (int) smask_objnum);
    smask_size = (int) ((png_get_rowbytes (png_p, info_p) / 2) * png_get_image_height (png_p, info_p));
    smask = xtalloc((unsigned) smask_size, png_byte);
    pdf_begin_stream(pdf);
    if (png_get_interlace_type (png_p, info_p) == PNG_INTERLACE_NONE) {
        row = xtalloc(png_get_rowbytes (png_p, info_p), png_byte);
        if ((png_get_bit_depth (png_p, info_p) == 16) && (pdf->image_hicolor != 0)) {
            write_noninterlaced(write_gray_pixel_16(r));
        } else {
            write_noninterlaced(write_gray_pixel_8(r));
        }
        xfree(row);
    } else {
        if (png_get_image_height (png_p, info_p) * png_get_rowbytes (png_p, info_p) >= 10240000L)
            pdftex_warn
                ("large interlaced PNG might cause out of memory (use non-interlaced PNG to fix this)");
        rows = xtalloc(png_get_image_height (png_p, info_p), png_bytep);
        for (i = 0; (unsigned) i < png_get_image_height (png_p, info_p); i++)
            rows[i] = xtalloc(png_get_rowbytes (png_p, info_p), png_byte);
        png_read_image(png_p, rows);
        if ((png_get_bit_depth (png_p, info_p) == 16) && (pdf->image_hicolor != 0)) {
            write_interlaced(write_gray_pixel_16(row));
        } else {
            write_interlaced(write_gray_pixel_8(row));

    pdf_end_stream(pdf);
    pdf_flush(pdf);
    /* now write the Smask object */
    bitdepth = png_get_bit_depth (png_p, info_p);
    pdf_begin_dict(pdf, smask_objnum, 0);
    pdf_puts(pdf, "/Type /XObject\n/Subtype /Image\n");
    if (img_attr(idict) != NULL && strlen(img_attr(idict)) > 0)
        pdf_printf(pdf, "%s\n", img_attr(idict));
    pdf_printf(pdf, "/Width %u\n/Height %i\n/BitsPerComponent %u\n",
               png_get_image_width (png_p, info_p),
               png_get_image_height (png_p, info_p), 
               (bitdepth == 16 ? 8 : bitdepth));
    pdf_puts(pdf, "/ColorSpace /DeviceGray\n");
    pdf_begin_stream(pdf);
    for (i = 0; i < smask_size; i++) {

        pdf_puts(pdf, "/DeviceRGB\n");
    }
    pdf_begin_stream(pdf);
    if (png_get_interlace_type (png_p, info_p) == PNG_INTERLACE_NONE) {
        row = xtalloc(png_get_rowbytes (png_p, info_p), png_byte);
        write_noninterlaced(write_simple_pixel(r));
        xfree(row);
    } else {
        if (png_get_image_height (png_p, info_p) * png_get_rowbytes (png_p, info_p) >= 10240000L)
            pdftex_warn
                ("large interlaced PNG might cause out of memory (use non-interlaced PNG to fix this)");
        rows = xtalloc(png_get_image_height (png_p, info_p), png_bytep);
        for (i = 0; (unsigned) i < png_get_image_height (png_p, info_p); i++)
            rows[i] = xtalloc(png_get_rowbytes (png_p, info_p), png_byte);
        png_read_image(png_p, rows);
        write_interlaced(write_simple_pixel(row));
        xfree(rows);

    png_bytep smask;
    int smask_ptr = 0;
    int smask_size = 0;
    png_byte bitdepth;
    if (img_colorspace(idict) != 0) {
        pdf_printf(pdf, "%i 0 R\n", (int) img_colorspace(idict));
    } else {

    }
    smask_objnum = pdf_create_obj(pdf, obj_type_others, 0);
    pdf_printf(pdf, "/SMask %i 0 R\n", (int) smask_objnum);
    smask_size = (int) ((png_get_rowbytes (png_p, info_p) / 4) * png_get_image_height (png_p, info_p));
    smask = xtalloc((unsigned) smask_size, png_byte);
    pdf_begin_stream(pdf);
    if (png_get_interlace_type (png_p, info_p) == PNG_INTERLACE_NONE) {
        row = xtalloc(png_get_rowbytes (png_p, info_p), png_byte);
        if ((png_get_bit_depth (png_p, info_p) == 16) && (pdf->image_hicolor != 0)) {
            write_noninterlaced(write_rgb_pixel_16(r));
        } else {
            write_noninterlaced(write_rgb_pixel_8(r));
        }
        xfree(row);
    } else {
        if (png_get_image_height (png_p, info_p) * png_get_rowbytes (png_p, info_p) >= 10240000L)
            pdftex_warn
                ("large interlaced PNG might cause out of memory (use non-interlaced PNG to fix this)");
        rows = xtalloc(png_get_image_height (png_p, info_p), png_bytep);
        for (i = 0; (unsigned) i < png_get_image_height (png_p, info_p); i++)
            rows[i] = xtalloc(png_get_rowbytes (png_p, info_p), png_byte);
        png_read_image(png_p, rows);
        if ((png_get_bit_depth (png_p, info_p) == 16) && (pdf->image_hicolor != 0)) {
            write_interlaced(write_rgb_pixel_16(row));
        } else {
            write_interlaced(write_rgb_pixel_8(row));

    pdf_flush(pdf);
    /* now write the Smask object */
    if (smask_objnum > 0) {
        bitdepth = png_get_bit_depth (png_p, info_p);
        pdf_begin_dict(pdf, smask_objnum, 0);
        pdf_puts(pdf, "/Type /XObject\n/Subtype /Image\n");
        if (img_attr(idict) != NULL && strlen(img_attr(idict)) > 0)
            pdf_printf(pdf, "%s\n", img_attr(idict));
        pdf_printf(pdf, "/Width %u\n/Height %u\n/BitsPerComponent %i\n",
                   png_get_image_width (png_p, info_p),
                   png_get_image_height (png_p, info_p), 
                   (bitdepth == 16 ? 8 : bitdepth));
        pdf_puts(pdf, "/ColorSpace /DeviceGray\n");
        pdf_begin_stream(pdf);
        for (i = 0; i < smask_size; i++) {

    assert(idict != NULL);
    png_p = img_png_png_ptr(idict);
    info_p = img_png_info_ptr(idict);
    fp = (FILE *) png_get_io_ptr (png_p);
    /* 1st pass to find overall stream /Length */
    if (fseek(fp, 8, SEEK_SET) != 0)
        pdftex_fail("writepng: fseek in PNG file failed");

               "/Filter/FlateDecode\n"
               "/DecodeParms<<"
               "/Colors %d"
               "/Columns %u"
               "/BitsPerComponent %i"
               "/Predictor 10>>\n>>\nstream\n", streamlength,
               png_get_color_type (png_p, info_p) == 2 ? 3 : 1,
               png_get_image_width (png_p, info_p), 
               png_get_bit_depth (png_p, info_p));
    /* 2nd pass to copy data */
    endflag = false;
    if (fseek(fp, 8, SEEK_SET) != 0)

    pdf_puts(pdf, "/Type /XObject\n/Subtype /Image\n");
    if (img_attr(idict) != NULL && strlen(img_attr(idict)) > 0)
        pdf_printf(pdf, "%s\n", img_attr(idict));
    pdf_printf(pdf, "/Width %u\n/Height %u\n/BitsPerComponent %u\n",
               png_get_image_width (png_p, info_p),
               png_get_image_height (png_p, info_p), 
               png_get_bit_depth (png_p, info_p));
    pdf_puts(pdf, "/ColorSpace ");
    checked_gamma = 1.0;
    if (pdf->image_apply_gamma) {

    }
    /* the switching between |info_p| and |png_p| queries has been trial and error.
     */
    if (pdf->minor_version > 1 
           && png_get_interlace_type (png_p, info_p) == PNG_INTERLACE_NONE 
        &&!(png_get_color_type (png_p, info_p) == PNG_COLOR_TYPE_GRAY_ALPHA ||
            png_get_color_type (png_p, info_p) == PNG_COLOR_TYPE_RGB_ALPHA)
        && ((pdf->image_hicolor != 0) || (png_get_bit_depth (png_p, info_p) <= 8))
        && (checked_gamma <= 1.01 && checked_gamma > 0.99)
        ) {
        png_colorp palette;
        int num_palette;

        png_get_PLTE(png_p, info_p, &palette, &num_palette);
        if (img_colorspace(idict) != 0) {
            pdf_printf(pdf, "%i 0 R\n", (int) img_colorspace(idict));
        } else {
            switch (png_get_color_type (png_p, info_p)) {
            case PNG_COLOR_TYPE_PALETTE:
                palette_objnum = pdf_create_obj(pdf, obj_type_others, 0);
                pdf_printf(pdf, "[/Indexed /DeviceRGB %i %i 0 R]\n",
                           num_palette - 1, (int) palette_objnum);
                           (int) palette_objnum);
                break;
            case PNG_COLOR_TYPE_GRAY:
                pdf_puts(pdf, "/DeviceGray\n");

        if (palette_objnum > 0) {
            pdf_begin_dict(pdf, palette_objnum, 0);
            pdf_begin_stream(pdf);
            for (i = 0; (unsigned) i < num_palette; i++) {
                pdf_room(pdf, 3);
                pdf_quick_out(pdf, palette[i].red);
                pdf_quick_out(pdf, palette[i].green);
                pdf_quick_out(pdf, palette[i].blue);
            }
            pdf_end_stream(pdf);
        }

            if ((pdf->image_apply_gamma != 0) &&
                (checked_gamma > 1.01 || checked_gamma < 0.99))
                tex_printf("gamma delta=%lf ", checked_gamma);
            if ((png_get_color_type (png_p, info_p) != PNG_COLOR_TYPE_GRAY)
                && (png_get_color_type (png_p, info_p) != PNG_COLOR_TYPE_RGB)
                && (png_get_color_type (png_p, info_p) != PNG_COLOR_TYPE_PALETTE))
                && (info_p->color_type != PNG_COLOR_TYPE_RGB)
                && (info_p->color_type != PNG_COLOR_TYPE_PALETTE))
                tex_printf("colortype ");
            if (pdf->minor_version <= 1)
                tex_printf("version=%d ", pdf->minor_version);
            if (png_get_interlace_type (png_p, info_p) != PNG_INTERLACE_NONE)
                tex_printf("interlaced ");
            if (png_get_bit_depth (png_p, info_p) > 8)
                tex_printf("bitdepth=%d ", png_get_bit_depth (png_p, info_p));
            if (png_get_valid(png_p, info_p, PNG_INFO_tRNS))
                tex_printf("simple transparancy ");
        }
        switch (png_get_color_type (png_p, info_p)) {
        case PNG_COLOR_TYPE_PALETTE:
            write_png_palette(pdf, idict);
            break;

            break;
        default:
            pdftex_fail("unsupported type of color_type <%i>",
                        png_get_color_type (png_p, info_p));
        }
    }
    pdf_flush(pdf);

Return to bug 355091