istereo: bc6db80aaa58 libs/libpng/pngwtran.c

istereo

view libs/libpng/pngwtran.c @ 32:bc6db80aaa58

stop the texture coordinates from growing to rediculous proportions

author	John Tsiombikas <nuclear@mutantstargoat.com>
date	Thu, 08 Sep 2011 21:22:44 +0300
parents
children

line source

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

3 *

4 * Last changed in libpng 1.2.9 April 14, 2006

5 * For conditions of distribution and use, see copyright notice in png.h

9 */

11 #define PNG_INTERNAL

12 #include "png.h"

13 #ifdef PNG_WRITE_SUPPORTED

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

16 * transformations is significant.

17 */

18 void /* PRIVATE */

19 png_do_write_transformations(png_structp png_ptr)

20 {

21 png_debug(1, "in png_do_write_transformations\n");

23 if (png_ptr == NULL)

24 return;

26 #if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)

27 if (png_ptr->transformations & PNG_USER_TRANSFORM)

28 if (png_ptr->write_user_transform_fn != NULL)

29 (*(png_ptr->write_user_transform_fn)) /* user write transform function */

30 (png_ptr, /* png_ptr */

31 &(png_ptr->row_info), /* row_info: */

32 /* png_uint_32 width; width of row */

33 /* png_uint_32 rowbytes; number of bytes in row */

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

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

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

37 /* png_byte pixel_depth; bits per pixel (depth*channels) */

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

39 #endif

40 #if defined(PNG_WRITE_FILLER_SUPPORTED)

41 if (png_ptr->transformations & PNG_FILLER)

42 png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,

43 png_ptr->flags);

44 #endif

45 #if defined(PNG_WRITE_PACKSWAP_SUPPORTED)

46 if (png_ptr->transformations & PNG_PACKSWAP)

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

48 #endif

49 #if defined(PNG_WRITE_PACK_SUPPORTED)

50 if (png_ptr->transformations & PNG_PACK)

51 png_do_pack(&(png_ptr->row_info), png_ptr->row_buf + 1,

52 (png_uint_32)png_ptr->bit_depth);

53 #endif

54 #if defined(PNG_WRITE_SWAP_SUPPORTED)

55 if (png_ptr->transformations & PNG_SWAP_BYTES)

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

57 #endif

58 #if defined(PNG_WRITE_SHIFT_SUPPORTED)

59 if (png_ptr->transformations & PNG_SHIFT)

60 png_do_shift(&(png_ptr->row_info), png_ptr->row_buf + 1,

61 &(png_ptr->shift));

62 #endif

63 #if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)

64 if (png_ptr->transformations & PNG_SWAP_ALPHA)

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

66 #endif

67 #if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)

68 if (png_ptr->transformations & PNG_INVERT_ALPHA)

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

70 #endif

71 #if defined(PNG_WRITE_BGR_SUPPORTED)

72 if (png_ptr->transformations & PNG_BGR)

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

74 #endif

75 #if defined(PNG_WRITE_INVERT_SUPPORTED)

76 if (png_ptr->transformations & PNG_INVERT_MONO)

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

78 #endif

79 }

81 #if defined(PNG_WRITE_PACK_SUPPORTED)

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

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

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

85 */

86 void /* PRIVATE */

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

88 {

89 png_debug(1, "in png_do_pack\n");

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

91 #if defined(PNG_USELESS_TESTS_SUPPORTED)

92 row != NULL && row_info != NULL &&

93 #endif

94 row_info->channels == 1)

95 {

96 switch ((int)bit_depth)

97 {

98 case 1:

99 {

100 png_bytep sp, dp;

101 int mask, v;

102 png_uint_32 i;

103 png_uint_32 row_width = row_info->width;

104

105 sp = row;

106 dp = row;

107 mask = 0x80;

108 v = 0;

109

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

111 {

112 if (*sp != 0)

113 v |= mask;

114 sp++;

115 if (mask > 1)

116 mask >>= 1;

117 else

118 {

119 mask = 0x80;

120 *dp = (png_byte)v;

121 dp++;

122 v = 0;

123 }

124 }

125 if (mask != 0x80)

126 *dp = (png_byte)v;

127 break;

128 }

129 case 2:

130 {

131 png_bytep sp, dp;

132 int shift, v;

133 png_uint_32 i;

134 png_uint_32 row_width = row_info->width;

135

136 sp = row;

137 dp = row;

138 shift = 6;

139 v = 0;

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

141 {

142 png_byte value;

143

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

145 v |= (value << shift);

146 if (shift == 0)

147 {

148 shift = 6;

149 *dp = (png_byte)v;

150 dp++;

151 v = 0;

152 }

153 else

154 shift -= 2;

155 sp++;

156 }

157 if (shift != 6)

158 *dp = (png_byte)v;

159 break;

160 }

161 case 4:

162 {

163 png_bytep sp, dp;

164 int shift, v;

165 png_uint_32 i;

166 png_uint_32 row_width = row_info->width;

167

168 sp = row;

169 dp = row;

170 shift = 4;

171 v = 0;

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

173 {

174 png_byte value;

175

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

177 v |= (value << shift);

178

179 if (shift == 0)

180 {

181 shift = 4;

182 *dp = (png_byte)v;

183 dp++;

184 v = 0;

185 }

186 else

187 shift -= 4;

188

189 sp++;

190 }

191 if (shift != 4)

192 *dp = (png_byte)v;

193 break;

194 }

195 }

196 row_info->bit_depth = (png_byte)bit_depth;

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

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

199 row_info->width);

200 }

201 }

202 #endif

203

204 #if defined(PNG_WRITE_SHIFT_SUPPORTED)

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

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

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

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

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

210 * data to 0 to 15.

211 */

212 void /* PRIVATE */

213 png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)

214 {

215 png_debug(1, "in png_do_shift\n");

216 #if defined(PNG_USELESS_TESTS_SUPPORTED)

217 if (row != NULL && row_info != NULL &&

218 #else

219 if (

220 #endif

221 row_info->color_type != PNG_COLOR_TYPE_PALETTE)

222 {

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

224 int channels = 0;

225

226 if (row_info->color_type & PNG_COLOR_MASK_COLOR)

227 {

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

229 shift_dec[channels] = bit_depth->red;

230 channels++;

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

232 shift_dec[channels] = bit_depth->green;

233 channels++;

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

235 shift_dec[channels] = bit_depth->blue;

236 channels++;

237 }

238 else

239 {

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

241 shift_dec[channels] = bit_depth->gray;

242 channels++;

243 }

244 if (row_info->color_type & PNG_COLOR_MASK_ALPHA)

245 {

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

247 shift_dec[channels] = bit_depth->alpha;

248 channels++;

249 }

250

251 /* with low row depths, could only be grayscale, so one channel */

252 if (row_info->bit_depth < 8)

253 {

254 png_bytep bp = row;

255 png_uint_32 i;

256 png_byte mask;

257 png_uint_32 row_bytes = row_info->rowbytes;

258

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

260 mask = 0x55;

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

262 mask = 0x11;

263 else

264 mask = 0xff;

265

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

267 {

268 png_uint_16 v;

269 int j;

270

271 v = *bp;

272 *bp = 0;

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

274 {

275 if (j > 0)

276 *bp |= (png_byte)((v << j) & 0xff);

277 else

278 *bp |= (png_byte)((v >> (-j)) & mask);

279 }

280 }

281 }

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

283 {

284 png_bytep bp = row;

285 png_uint_32 i;

286 png_uint_32 istop = channels * row_info->width;

287

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

289 {

290

291 png_uint_16 v;

292 int j;

293 int c = (int)(i%channels);

294

295 v = *bp;

296 *bp = 0;

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

298 {

299 if (j > 0)

300 *bp |= (png_byte)((v << j) & 0xff);

301 else

302 *bp |= (png_byte)((v >> (-j)) & 0xff);

303 }

304 }

305 }

306 else

307 {

308 png_bytep bp;

309 png_uint_32 i;

310 png_uint_32 istop = channels * row_info->width;

311

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

313 {

314 int c = (int)(i%channels);

315 png_uint_16 value, v;

316 int j;

317

318 v = (png_uint_16)(((png_uint_16)(*bp) << 8) + *(bp + 1));

319 value = 0;

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

321 {

322 if (j > 0)

323 value |= (png_uint_16)((v << j) & (png_uint_16)0xffff);

324 else

325 value |= (png_uint_16)((v >> (-j)) & (png_uint_16)0xffff);

326 }

327 *bp++ = (png_byte)(value >> 8);

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

329 }

330 }

331 }

332 }

333 #endif

334

335 #if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)

336 void /* PRIVATE */

337 png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)

338 {

339 png_debug(1, "in png_do_write_swap_alpha\n");

340 #if defined(PNG_USELESS_TESTS_SUPPORTED)

341 if (row != NULL && row_info != NULL)

342 #endif

343 {

344 if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

345 {

346 /* This converts from ARGB to RGBA */

347 if (row_info->bit_depth == 8)

348 {

349 png_bytep sp, dp;

350 png_uint_32 i;

351 png_uint_32 row_width = row_info->width;

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

353 {

354 png_byte save = *(sp++);

355 *(dp++) = *(sp++);

356 *(dp++) = *(sp++);

357 *(dp++) = *(sp++);

358 *(dp++) = save;

359 }

360 }

361 /* This converts from AARRGGBB to RRGGBBAA */

362 else

363 {

364 png_bytep sp, dp;

365 png_uint_32 i;

366 png_uint_32 row_width = row_info->width;

367

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

369 {

370 png_byte save[2];

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

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

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

374 *(dp++) = *(sp++);

375 *(dp++) = *(sp++);

376 *(dp++) = *(sp++);

377 *(dp++) = *(sp++);

378 *(dp++) = *(sp++);

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

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

381 }

382 }

383 }

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

385 {

386 /* This converts from AG to GA */

387 if (row_info->bit_depth == 8)

388 {

389 png_bytep sp, dp;

390 png_uint_32 i;

391 png_uint_32 row_width = row_info->width;

392

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

394 {

395 png_byte save = *(sp++);

396 *(dp++) = *(sp++);

397 *(dp++) = save;

398 }

399 }

400 /* This converts from AAGG to GGAA */

401 else

402 {

403 png_bytep sp, dp;

404 png_uint_32 i;

405 png_uint_32 row_width = row_info->width;

406

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

408 {

409 png_byte save[2];

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

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

412 *(dp++) = *(sp++);

413 *(dp++) = *(sp++);

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

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

416 }

417 }

418 }

419 }

420 }

421 #endif

422

423 #if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)

424 void /* PRIVATE */

425 png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)

426 {

427 png_debug(1, "in png_do_write_invert_alpha\n");

428 #if defined(PNG_USELESS_TESTS_SUPPORTED)

429 if (row != NULL && row_info != NULL)

430 #endif

431 {

432 if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

433 {

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

435 if (row_info->bit_depth == 8)

436 {

437 png_bytep sp, dp;

438 png_uint_32 i;

439 png_uint_32 row_width = row_info->width;

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

441 {

442 /* does nothing

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

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

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

446 */

447 sp+=3; dp = sp;

448 *(dp++) = (png_byte)(255 - *(sp++));

449 }

450 }

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

452 else

453 {

454 png_bytep sp, dp;

455 png_uint_32 i;

456 png_uint_32 row_width = row_info->width;

457

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

459 {

460 /* does nothing

461 *(dp++) = *(sp++);

462 *(dp++) = *(sp++);

463 *(dp++) = *(sp++);

464 *(dp++) = *(sp++);

465 *(dp++) = *(sp++);

466 *(dp++) = *(sp++);

467 */

468 sp+=6; dp = sp;

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

470 *(dp++) = (png_byte)(255 - *(sp++));

471 }

472 }

473 }

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

475 {

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

477 if (row_info->bit_depth == 8)

478 {

479 png_bytep sp, dp;

480 png_uint_32 i;

481 png_uint_32 row_width = row_info->width;

482

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

484 {

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

486 *(dp++) = (png_byte)(255 - *(sp++));

487 }

488 }

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

490 else

491 {

492 png_bytep sp, dp;

493 png_uint_32 i;

494 png_uint_32 row_width = row_info->width;

495

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

497 {

498 /* does nothing

499 *(dp++) = *(sp++);

500 *(dp++) = *(sp++);

501 */

502 sp+=2; dp = sp;

503 *(dp++) = (png_byte)(255 - *(sp++));

504 *(dp++) = (png_byte)(255 - *(sp++));

505 }

506 }

507 }

508 }

509 }

510 #endif

511

512 #if defined(PNG_MNG_FEATURES_SUPPORTED)

513 /* undoes intrapixel differencing */

514 void /* PRIVATE */

515 png_do_write_intrapixel(png_row_infop row_info, png_bytep row)

516 {

517 png_debug(1, "in png_do_write_intrapixel\n");

518 if (

519 #if defined(PNG_USELESS_TESTS_SUPPORTED)

520 row != NULL && row_info != NULL &&

521 #endif

522 (row_info->color_type & PNG_COLOR_MASK_COLOR))

523 {

524 int bytes_per_pixel;

525 png_uint_32 row_width = row_info->width;

526 if (row_info->bit_depth == 8)

527 {

528 png_bytep rp;

529 png_uint_32 i;

530

531 if (row_info->color_type == PNG_COLOR_TYPE_RGB)

532 bytes_per_pixel = 3;

533 else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

534 bytes_per_pixel = 4;

535 else

536 return;

537

538 for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)

539 {

540 *(rp) = (png_byte)((*rp - *(rp+1))&0xff);

541 *(rp+2) = (png_byte)((*(rp+2) - *(rp+1))&0xff);

542 }

543 }

544 else if (row_info->bit_depth == 16)

545 {

546 png_bytep rp;

547 png_uint_32 i;

548

549 if (row_info->color_type == PNG_COLOR_TYPE_RGB)

550 bytes_per_pixel = 6;

551 else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

552 bytes_per_pixel = 8;

553 else

554 return;

555

556 for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)

557 {

558 png_uint_32 s0 = (*(rp ) << 8) | *(rp+1);

559 png_uint_32 s1 = (*(rp+2) << 8) | *(rp+3);

560 png_uint_32 s2 = (*(rp+4) << 8) | *(rp+5);

561 png_uint_32 red = (png_uint_32)((s0 - s1) & 0xffffL);

562 png_uint_32 blue = (png_uint_32)((s2 - s1) & 0xffffL);

563 *(rp ) = (png_byte)((red >> 8) & 0xff);

564 *(rp+1) = (png_byte)(red & 0xff);

565 *(rp+4) = (png_byte)((blue >> 8) & 0xff);

566 *(rp+5) = (png_byte)(blue & 0xff);

567 }

568 }

569 }

570 }

571 #endif /* PNG_MNG_FEATURES_SUPPORTED */

572 #endif /* PNG_WRITE_SUPPORTED */