third_party/libpng/pngwtran.c - Issue 1599513004: XFA: Rename libpng to libpng16.

Side by Side Diff: third_party/libpng/pngwtran.c

Issue 1599513004: XFA: Rename libpng to libpng16. (Closed) Base URL: https://pdfium.googlesource.com/pdfium.git@xfa

Patch Set: Created 4 years, 11 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

OLD	NEW
	(Empty)
1

2 /* pngwtran.c - transforms the data in a row for PNG writers

3 *

4 * Last changed in libpng 1.6.18 [July 23, 2015]

5 * Copyright (c) 1998-2015 Glenn Randers-Pehrson

6 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

7 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

8 *

9 * This code is released under the libpng license.

10 * For conditions of distribution and use, see the disclaimer

11 * and license in png.h

12 */

13

14 #include "pngpriv.h"

15

16 #ifdef PNG_WRITE_SUPPORTED

17 #ifdef PNG_WRITE_TRANSFORMS_SUPPORTED

18

19 #ifdef PNG_WRITE_PACK_SUPPORTED

20 /* Pack pixels into bytes. Pass the true bit depth in bit_depth. The

21 * row_info bit depth should be 8 (one pixel per byte). The channels

22 * should be 1 (this only happens on grayscale and paletted images).

23 */

24 static void

25 png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)

26 {

27 png_debug(1, "in png_do_pack");

28

29 if (row_info->bit_depth == 8 &&

30 row_info->channels == 1)

31 {

32 switch ((int)bit_depth)

33 {

34 case 1:

35 {

36 png_bytep sp, dp;

37 int mask, v;

38 png_uint_32 i;

39 png_uint_32 row_width = row_info->width;

40

41 sp = row;

42 dp = row;

43 mask = 0x80;

44 v = 0;

45

46 for (i = 0; i < row_width; i++)

47 {

48 if (*sp != 0)

49 v \|= mask;

50

51 sp++;

52

53 if (mask > 1)

54 mask >>= 1;

55

56 else

57 {

58 mask = 0x80;

59 *dp = (png_byte)v;

60 dp++;

61 v = 0;

62 }

63 }

64

65 if (mask != 0x80)

66 *dp = (png_byte)v;

67

68 break;

69 }

70

71 case 2:

72 {

73 png_bytep sp, dp;

74 unsigned int shift;

75 int v;

76 png_uint_32 i;

77 png_uint_32 row_width = row_info->width;

78

79 sp = row;

80 dp = row;

81 shift = 6;

82 v = 0;

83

84 for (i = 0; i < row_width; i++)

85 {

86 png_byte value;

87

88 value = (png_byte)(*sp & 0x03);

89 v \|= (value << shift);

90

91 if (shift == 0)

92 {

93 shift = 6;

94 *dp = (png_byte)v;

95 dp++;

96 v = 0;

97 }

98

99 else

100 shift -= 2;

101

102 sp++;

103 }

104

105 if (shift != 6)

106 *dp = (png_byte)v;

107

108 break;

109 }

110

111 case 4:

112 {

113 png_bytep sp, dp;

114 unsigned int shift;

115 int v;

116 png_uint_32 i;

117 png_uint_32 row_width = row_info->width;

118

119 sp = row;

120 dp = row;

121 shift = 4;

122 v = 0;

123

124 for (i = 0; i < row_width; i++)

125 {

126 png_byte value;

127

128 value = (png_byte)(*sp & 0x0f);

129 v \|= (value << shift);

130

131 if (shift == 0)

132 {

133 shift = 4;

134 *dp = (png_byte)v;

135 dp++;

136 v = 0;

137 }

138

139 else

140 shift -= 4;

141

142 sp++;

143 }

144

145 if (shift != 4)

146 *dp = (png_byte)v;

147

148 break;

149 }

150

151 default:

152 break;

153 }

154

155 row_info->bit_depth = (png_byte)bit_depth;

156 row_info->pixel_depth = (png_byte)(bit_depth * row_info->channels);

157 row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,

158 row_info->width);

159 }

160 }

161 #endif

162

163 #ifdef PNG_WRITE_SHIFT_SUPPORTED

164 /* Shift pixel values to take advantage of whole range. Pass the

165 * true number of bits in bit_depth. The row should be packed

166 * according to row_info->bit_depth. Thus, if you had a row of

167 * bit depth 4, but the pixels only had values from 0 to 7, you

168 * would pass 3 as bit_depth, and this routine would translate the

169 * data to 0 to 15.

170 */

171 static void

172 png_do_shift(png_row_infop row_info, png_bytep row,

173 png_const_color_8p bit_depth)

174 {

175 png_debug(1, "in png_do_shift");

176

177 if (row_info->color_type != PNG_COLOR_TYPE_PALETTE)

178 {

179 int shift_start[4], shift_dec[4];

180 int channels = 0;

181

182 if ((row_info->color_type & PNG_COLOR_MASK_COLOR) != 0)

183 {

184 shift_start[channels] = row_info->bit_depth - bit_depth->red;

185 shift_dec[channels] = bit_depth->red;

186 channels++;

187

188 shift_start[channels] = row_info->bit_depth - bit_depth->green;

189 shift_dec[channels] = bit_depth->green;

190 channels++;

191

192 shift_start[channels] = row_info->bit_depth - bit_depth->blue;

193 shift_dec[channels] = bit_depth->blue;

194 channels++;

195 }

196

197 else

198 {

199 shift_start[channels] = row_info->bit_depth - bit_depth->gray;

200 shift_dec[channels] = bit_depth->gray;

201 channels++;

202 }

203

204 if ((row_info->color_type & PNG_COLOR_MASK_ALPHA) != 0)

205 {

206 shift_start[channels] = row_info->bit_depth - bit_depth->alpha;

207 shift_dec[channels] = bit_depth->alpha;

208 channels++;

209 }

210

211 /* With low row depths, could only be grayscale, so one channel */

212 if (row_info->bit_depth < 8)

213 {

214 png_bytep bp = row;

215 png_size_t i;

216 unsigned int mask;

217 png_size_t row_bytes = row_info->rowbytes;

218

219 if (bit_depth->gray == 1 && row_info->bit_depth == 2)

220 mask = 0x55;

221

222 else if (row_info->bit_depth == 4 && bit_depth->gray == 3)

223 mask = 0x11;

224

225 else

226 mask = 0xff;

227

228 for (i = 0; i < row_bytes; i++, bp++)

229 {

230 int j;

231 unsigned int v, out;

232

233 v = *bp;

234 out = 0;

235

236 for (j = shift_start[0]; j > -shift_dec[0]; j -= shift_dec[0])

237 {

238 if (j > 0)

239 out \|= v << j;

240

241 else

242 out \|= (v >> (-j)) & mask;

243 }

244

245 *bp = (png_byte)(out & 0xff);

246 }

247 }

248

249 else if (row_info->bit_depth == 8)

250 {

251 png_bytep bp = row;

252 png_uint_32 i;

253 png_uint_32 istop = channels * row_info->width;

254

255 for (i = 0; i < istop; i++, bp++)

256 {

257

258 const unsigned int c = i%channels;

259 int j;

260 unsigned int v, out;

261

262 v = *bp;

263 out = 0;

264

265 for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])

266 {

267 if (j > 0)

268 out \|= v << j;

269

270 else

271 out \|= v >> (-j);

272 }

273

274 *bp = (png_byte)(out & 0xff);

275 }

276 }

277

278 else

279 {

280 png_bytep bp;

281 png_uint_32 i;

282 png_uint_32 istop = channels * row_info->width;

283

284 for (bp = row, i = 0; i < istop; i++)

285 {

286 const unsigned int c = i%channels;

287 int j;

288 unsigned int value, v;

289

290 v = png_get_uint_16(bp);

291 value = 0;

292

293 for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])

294 {

295 if (j > 0)

296 value \|= v << j;

297

298 else

299 value \|= v >> (-j);

300 }

301 *bp++ = (png_byte)((value >> 8) & 0xff);

302 *bp++ = (png_byte)(value & 0xff);

303 }

304 }

305 }

306 }

307 #endif

308

309 #ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED

310 static void

311 png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)

312 {

313 png_debug(1, "in png_do_write_swap_alpha");

314

315 {

316 if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

317 {

318 if (row_info->bit_depth == 8)

319 {

320 /* This converts from ARGB to RGBA */

321 png_bytep sp, dp;

322 png_uint_32 i;

323 png_uint_32 row_width = row_info->width;

324

325 for (i = 0, sp = dp = row; i < row_width; i++)

326 {

327 png_byte save = *(sp++);

328 (dp++) = (sp++);

329 (dp++) = (sp++);

330 (dp++) = (sp++);

331 *(dp++) = save;

332 }

333 }

334

335 #ifdef PNG_WRITE_16BIT_SUPPORTED

336 else

337 {

338 /* This converts from AARRGGBB to RRGGBBAA */

339 png_bytep sp, dp;

340 png_uint_32 i;

341 png_uint_32 row_width = row_info->width;

342

343 for (i = 0, sp = dp = row; i < row_width; i++)

344 {

345 png_byte save[2];

346 save[0] = *(sp++);

347 save[1] = *(sp++);

348 (dp++) = (sp++);

349 (dp++) = (sp++);

350 (dp++) = (sp++);

351 (dp++) = (sp++);

352 (dp++) = (sp++);

353 (dp++) = (sp++);

354 *(dp++) = save[0];

355 *(dp++) = save[1];

356 }

357 }

358 #endif /* WRITE_16BIT */

359 }

360

361 else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

362 {

363 if (row_info->bit_depth == 8)

364 {

365 /* This converts from AG to GA */

366 png_bytep sp, dp;

367 png_uint_32 i;

368 png_uint_32 row_width = row_info->width;

369

370 for (i = 0, sp = dp = row; i < row_width; i++)

371 {

372 png_byte save = *(sp++);

373 (dp++) = (sp++);

374 *(dp++) = save;

375 }

376 }

377

378 #ifdef PNG_WRITE_16BIT_SUPPORTED

379 else

380 {

381 /* This converts from AAGG to GGAA */

382 png_bytep sp, dp;

383 png_uint_32 i;

384 png_uint_32 row_width = row_info->width;

385

386 for (i = 0, sp = dp = row; i < row_width; i++)

387 {

388 png_byte save[2];

389 save[0] = *(sp++);

390 save[1] = *(sp++);

391 (dp++) = (sp++);

392 (dp++) = (sp++);

393 *(dp++) = save[0];

394 *(dp++) = save[1];

395 }

396 }

397 #endif /* WRITE_16BIT */

398 }

399 }

400 }

401 #endif

402

403 #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED

404 static void

405 png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)

406 {

407 png_debug(1, "in png_do_write_invert_alpha");

408

409 {

410 if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

411 {

412 if (row_info->bit_depth == 8)

413 {

414 /* This inverts the alpha channel in RGBA */

415 png_bytep sp, dp;

416 png_uint_32 i;

417 png_uint_32 row_width = row_info->width;

418

419 for (i = 0, sp = dp = row; i < row_width; i++)

420 {

421 /* Does nothing

422 (dp++) = (sp++);

423 (dp++) = (sp++);

424 (dp++) = (sp++);

425 */

426 sp+=3; dp = sp;

427 dp = (png_byte)(255 - (sp++));

428 }

429 }

430

431 #ifdef PNG_WRITE_16BIT_SUPPORTED

432 else

433 {

434 /* This inverts the alpha channel in RRGGBBAA */

435 png_bytep sp, dp;

436 png_uint_32 i;

437 png_uint_32 row_width = row_info->width;

438

439 for (i = 0, sp = dp = row; i < row_width; i++)

440 {

441 /* Does nothing

442 (dp++) = (sp++);

443 (dp++) = (sp++);

444 (dp++) = (sp++);

445 (dp++) = (sp++);

446 (dp++) = (sp++);

447 (dp++) = (sp++);

448 */

449 sp+=6; dp = sp;

450 (dp++) = (png_byte)(255 - (sp++));

451 dp = (png_byte)(255 - (sp++));

452 }

453 }

454 #endif /* WRITE_16BIT */

455 }

456

457 else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

458 {

459 if (row_info->bit_depth == 8)

460 {

461 /* This inverts the alpha channel in GA */

462 png_bytep sp, dp;

463 png_uint_32 i;

464 png_uint_32 row_width = row_info->width;

465

466 for (i = 0, sp = dp = row; i < row_width; i++)

467 {

468 (dp++) = (sp++);

469 (dp++) = (png_byte)(255 - (sp++));

470 }

471 }

472

473 #ifdef PNG_WRITE_16BIT_SUPPORTED

474 else

475 {

476 /* This inverts the alpha channel in GGAA */

477 png_bytep sp, dp;

478 png_uint_32 i;

479 png_uint_32 row_width = row_info->width;

480

481 for (i = 0, sp = dp = row; i < row_width; i++)

482 {

483 /* Does nothing

484 (dp++) = (sp++);

485 (dp++) = (sp++);

486 */

487 sp+=2; dp = sp;

488 (dp++) = (png_byte)(255 - (sp++));

489 dp = (png_byte)(255 - (sp++));

490 }

491 }

492 #endif /* WRITE_16BIT */

493 }

494 }

495 }

496 #endif

497

498 /* Transform the data according to the user's wishes. The order of

499 * transformations is significant.

500 */

501 void /* PRIVATE */

502 png_do_write_transformations(png_structrp png_ptr, png_row_infop row_info)

503 {

504 png_debug(1, "in png_do_write_transformations");

505

506 if (png_ptr == NULL)

507 return;

508

509 #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED

510 if ((png_ptr->transformations & PNG_USER_TRANSFORM) != 0)

511 if (png_ptr->write_user_transform_fn != NULL)

512 ((png_ptr->write_user_transform_fn)) / User write transform

513 function */

514 (png_ptr, /* png_ptr */

515 row_info, /* row_info: */

516 /* png_uint_32 width; width of row */

517 /* png_size_t rowbytes; number of bytes in row */

518 /* png_byte color_type; color type of pixels */

519 /* png_byte bit_depth; bit depth of samples */

520 /* png_byte channels; number of channels (1-4) */

521 /* png_byte pixel_depth; bits per pixel (depthchannels) /

522 png_ptr->row_buf + 1); /* start of pixel data for row */

523 #endif

524

525 #ifdef PNG_WRITE_FILLER_SUPPORTED

526 if ((png_ptr->transformations & PNG_FILLER) != 0)

527 png_do_strip_channel(row_info, png_ptr->row_buf + 1,

528 !(png_ptr->flags & PNG_FLAG_FILLER_AFTER));

529 #endif

530

531 #ifdef PNG_WRITE_PACKSWAP_SUPPORTED

532 if ((png_ptr->transformations & PNG_PACKSWAP) != 0)

533 png_do_packswap(row_info, png_ptr->row_buf + 1);

534 #endif

535

536 #ifdef PNG_WRITE_PACK_SUPPORTED

537 if ((png_ptr->transformations & PNG_PACK) != 0)

538 png_do_pack(row_info, png_ptr->row_buf + 1,

539 (png_uint_32)png_ptr->bit_depth);

540 #endif

541

542 #ifdef PNG_WRITE_SWAP_SUPPORTED

543 # ifdef PNG_16BIT_SUPPORTED

544 if ((png_ptr->transformations & PNG_SWAP_BYTES) != 0)

545 png_do_swap(row_info, png_ptr->row_buf + 1);

546 # endif

547 #endif

548

549 #ifdef PNG_WRITE_SHIFT_SUPPORTED

550 if ((png_ptr->transformations & PNG_SHIFT) != 0)

551 png_do_shift(row_info, png_ptr->row_buf + 1,

552 &(png_ptr->shift));

553 #endif

554

555 #ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED

556 if ((png_ptr->transformations & PNG_SWAP_ALPHA) != 0)

557 png_do_write_swap_alpha(row_info, png_ptr->row_buf + 1);

558 #endif

559

560 #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED

561 if ((png_ptr->transformations & PNG_INVERT_ALPHA) != 0)

562 png_do_write_invert_alpha(row_info, png_ptr->row_buf + 1);

563 #endif

564

565 #ifdef PNG_WRITE_BGR_SUPPORTED

566 if ((png_ptr->transformations & PNG_BGR) != 0)

567 png_do_bgr(row_info, png_ptr->row_buf + 1);

568 #endif

569

570 #ifdef PNG_WRITE_INVERT_SUPPORTED

571 if ((png_ptr->transformations & PNG_INVERT_MONO) != 0)

572 png_do_invert(row_info, png_ptr->row_buf + 1);

573 #endif

574 }

575 #endif /* WRITE_TRANSFORMS */

576 #endif /* WRITE */

OLD	NEW

« no previous file with comments | « third_party/libpng/pngwrite.c ('k') | third_party/libpng/pngwutil.c » ('j') | no next file with comments »