src/images/SkScaledBitmapSampler.cpp - Issue 1820503002: Delete SkImageDecoder

Side by Side Diff: src/images/SkScaledBitmapSampler.cpp

Issue 1820503002: Delete SkImageDecoder (Closed) Base URL: https://skia.googlesource.com/skia.git@fix-animator

Patch Set: Include SkImage Created 4 years, 9 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 * Copyright 2007 The Android Open Source Project

3 *

4 * Use of this source code is governed by a BSD-style license that can be

5 * found in the LICENSE file.

6 */

7

8

9 #include "SkScaledBitmapSampler.h"

10 #include "SkBitmap.h"

11 #include "SkColorPriv.h"

12 #include "SkDither.h"

13 #include "SkTypes.h"

14

15 // 8888

16

17 static bool Sample_Gray_D8888(void* SK_RESTRICT dstRow,

18 const uint8_t* SK_RESTRICT src,

19 int width, int deltaSrc, int, const SkPMColor[]) {

20 SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;

21 for (int x = 0; x < width; x++) {

22 dst[x] = SkPackARGB32(0xFF, src[0], src[0], src[0]);

23 src += deltaSrc;

24 }

25 return false;

26 }

27

28 static SkScaledBitmapSampler::RowProc

29 get_gray_to_8888_proc(const SkScaledBitmapSampler::Options& opts) {

30 // Dither, unpremul, and skipZeroes have no effect

31 return Sample_Gray_D8888;

32 }

33

34 static bool Sample_RGBx_D8888(void* SK_RESTRICT dstRow,

35 const uint8_t* SK_RESTRICT src,

36 int width, int deltaSrc, int, const SkPMColor[]) {

37 SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;

38 for (int x = 0; x < width; x++) {

39 dst[x] = SkPackARGB32(0xFF, src[0], src[1], src[2]);

40 src += deltaSrc;

41 }

42 return false;

43 }

44

45 static SkScaledBitmapSampler::RowProc

46 get_RGBx_to_8888_proc(const SkScaledBitmapSampler::Options& opts) {

47 // Dither, unpremul, and skipZeroes have no effect

48 return Sample_RGBx_D8888;

49 }

50

51 static bool Sample_RGBA_D8888(void* SK_RESTRICT dstRow,

52 const uint8_t* SK_RESTRICT src,

53 int width, int deltaSrc, int, const SkPMColor[]) {

54 SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;

55 unsigned alphaMask = 0xFF;

56 for (int x = 0; x < width; x++) {

57 unsigned alpha = src[3];

58 dst[x] = SkPreMultiplyARGB(alpha, src[0], src[1], src[2]);

59 src += deltaSrc;

60 alphaMask &= alpha;

61 }

62 return alphaMask != 0xFF;

63 }

64

65 static bool Sample_RGBA_D8888_Unpremul(void* SK_RESTRICT dstRow,

66 const uint8_t* SK_RESTRICT src,

67 int width, int deltaSrc, int,

68 const SkPMColor[]) {

69 uint32_t* SK_RESTRICT dst = reinterpret_cast<uint32_t*>(dstRow);

70 unsigned alphaMask = 0xFF;

71 for (int x = 0; x < width; x++) {

72 unsigned alpha = src[3];

73 dst[x] = SkPackARGB32NoCheck(alpha, src[0], src[1], src[2]);

74 src += deltaSrc;

75 alphaMask &= alpha;

76 }

77 return alphaMask != 0xFF;

78 }

79

80 static bool Sample_RGBA_D8888_SkipZ(void* SK_RESTRICT dstRow,

81 const uint8_t* SK_RESTRICT src,

82 int width, int deltaSrc, int,

83 const SkPMColor[]) {

84 SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;

85 unsigned alphaMask = 0xFF;

86 for (int x = 0; x < width; x++) {

87 unsigned alpha = src[3];

88 if (0 != alpha) {

89 dst[x] = SkPreMultiplyARGB(alpha, src[0], src[1], src[2]);

90 }

91 src += deltaSrc;

92 alphaMask &= alpha;

93 }

94 return alphaMask != 0xFF;

95 }

96

97 static SkScaledBitmapSampler::RowProc

98 get_RGBA_to_8888_proc(const SkScaledBitmapSampler::Options& opts) {

99 // Dither has no effect.

100 if (!opts.fPremultiplyAlpha) {

101 // We could check each component for a zero, at the expense of extra che cks.

102 // For now, just return unpremul.

103 return Sample_RGBA_D8888_Unpremul;

104 }

105 // Supply the versions that premultiply the colors

106 if (opts.fSkipZeros) {

107 return Sample_RGBA_D8888_SkipZ;

108 }

109 return Sample_RGBA_D8888;

110 }

111

112 // 565

113

114 static bool Sample_Gray_D565(void* SK_RESTRICT dstRow,

115 const uint8_t* SK_RESTRICT src,

116 int width, int deltaSrc, int, const SkPMColor[]) {

117 uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;

118 for (int x = 0; x < width; x++) {

119 dst[x] = SkPack888ToRGB16(src[0], src[0], src[0]);

120 src += deltaSrc;

121 }

122 return false;

123 }

124

125 static bool Sample_Gray_D565_D(void* SK_RESTRICT dstRow,

126 const uint8_t* SK_RESTRICT src,

127 int width, int deltaSrc, int y, const SkPMColor[]) {

128 uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;

129 DITHER_565_SCAN(y);

130 for (int x = 0; x < width; x++) {

131 dst[x] = SkDitherRGBTo565(src[0], src[0], src[0], DITHER_VALUE(x));

132 src += deltaSrc;

133 }

134 return false;

135 }

136

137 static SkScaledBitmapSampler::RowProc

138 get_gray_to_565_proc(const SkScaledBitmapSampler::Options& opts) {

139 // Unpremul and skip zeroes make no difference

140 if (opts.fDither) {

141 return Sample_Gray_D565_D;

142 }

143 return Sample_Gray_D565;

144 }

145

146 static bool Sample_RGBx_D565(void* SK_RESTRICT dstRow,

147 const uint8_t* SK_RESTRICT src,

148 int width, int deltaSrc, int, const SkPMColor[]) {

149 uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;

150 for (int x = 0; x < width; x++) {

151 dst[x] = SkPack888ToRGB16(src[0], src[1], src[2]);

152 src += deltaSrc;

153 }

154 return false;

155 }

156

157 static bool Sample_RGBx_D565_D(void* SK_RESTRICT dstRow,

158 const uint8_t* SK_RESTRICT src,

159 int width, int deltaSrc, int y,

160 const SkPMColor[]) {

161 uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;

162 DITHER_565_SCAN(y);

163 for (int x = 0; x < width; x++) {

164 dst[x] = SkDitherRGBTo565(src[0], src[1], src[2], DITHER_VALUE(x));

165 src += deltaSrc;

166 }

167 return false;

168 }

169

170 static SkScaledBitmapSampler::RowProc

171 get_RGBx_to_565_proc(const SkScaledBitmapSampler::Options& opts) {

172 // Unpremul and skip zeroes make no difference

173 if (opts.fDither) {

174 return Sample_RGBx_D565_D;

175 }

176 return Sample_RGBx_D565;

177 }

178

179

180 static bool Sample_D565_D565(void* SK_RESTRICT dstRow,

181 const uint8_t* SK_RESTRICT src,

182 int width, int deltaSrc, int, const SkPMColor[]) {

183 uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;

184 uint16_t* SK_RESTRICT castedSrc = (uint16_t*) src;

185 for (int x = 0; x < width; x++) {

186 dst[x] = castedSrc[0];

187 castedSrc += deltaSrc >> 1;

188 }

189 return false;

190 }

191

192 static SkScaledBitmapSampler::RowProc

193 get_565_to_565_proc(const SkScaledBitmapSampler::Options& opts) {

194 // Unpremul, dither, and skip zeroes have no effect

195 return Sample_D565_D565;

196 }

197

198 // 4444

199

200 static bool Sample_Gray_D4444(void* SK_RESTRICT dstRow,

201 const uint8_t* SK_RESTRICT src,

202 int width, int deltaSrc, int, const SkPMColor[]) {

203 SkPMColor16* SK_RESTRICT dst = (SkPMColor16*)dstRow;

204 for (int x = 0; x < width; x++) {

205 unsigned gray = src[0] >> 4;

206 dst[x] = SkPackARGB4444(0xF, gray, gray, gray);

207 src += deltaSrc;

208 }

209 return false;

210 }

211

212 static bool Sample_Gray_D4444_D(void* SK_RESTRICT dstRow,

213 const uint8_t* SK_RESTRICT src,

214 int width, int deltaSrc, int y, const SkPMColor[]) {

215 SkPMColor16* SK_RESTRICT dst = (SkPMColor16*)dstRow;

216 DITHER_4444_SCAN(y);

217 for (int x = 0; x < width; x++) {

218 dst[x] = SkDitherARGB32To4444(0xFF, src[0], src[0], src[0],

219 DITHER_VALUE(x));

220 src += deltaSrc;

221 }

222 return false;

223 }

224

225 static SkScaledBitmapSampler::RowProc

226 get_gray_to_4444_proc(const SkScaledBitmapSampler::Options& opts) {

227 // Skip zeroes and unpremul make no difference

228 if (opts.fDither) {

229 return Sample_Gray_D4444_D;

230 }

231 return Sample_Gray_D4444;

232 }

233

234 static bool Sample_RGBx_D4444(void* SK_RESTRICT dstRow,

235 const uint8_t* SK_RESTRICT src,

236 int width, int deltaSrc, int, const SkPMColor[]) {

237 SkPMColor16* SK_RESTRICT dst = (SkPMColor16*)dstRow;

238 for (int x = 0; x < width; x++) {

239 dst[x] = SkPackARGB4444(0xF, src[0] >> 4, src[1] >> 4, src[2] >> 4);

240 src += deltaSrc;

241 }

242 return false;

243 }

244

245 static bool Sample_RGBx_D4444_D(void* SK_RESTRICT dstRow,

246 const uint8_t* SK_RESTRICT src,

247 int width, int deltaSrc, int y, const SkPMColor[]) {

248 SkPMColor16* dst = (SkPMColor16*)dstRow;

249 DITHER_4444_SCAN(y);

250

251 for (int x = 0; x < width; x++) {

252 dst[x] = SkDitherARGB32To4444(0xFF, src[0], src[1], src[2],

253 DITHER_VALUE(x));

254 src += deltaSrc;

255 }

256 return false;

257 }

258

259 static SkScaledBitmapSampler::RowProc

260 get_RGBx_to_4444_proc(const SkScaledBitmapSampler::Options& opts) {

261 // Skip zeroes and unpremul make no difference

262 if (opts.fDither) {

263 return Sample_RGBx_D4444_D;

264 }

265 return Sample_RGBx_D4444;

266 }

267

268 static bool Sample_RGBA_D4444(void* SK_RESTRICT dstRow,

269 const uint8_t* SK_RESTRICT src,

270 int width, int deltaSrc, int, const SkPMColor[]) {

271 SkPMColor16* SK_RESTRICT dst = (SkPMColor16*)dstRow;

272 unsigned alphaMask = 0xFF;

273

274 for (int x = 0; x < width; x++) {

275 unsigned alpha = src[3];

276 SkPMColor c = SkPreMultiplyARGB(alpha, src[0], src[1], src[2]);

277 dst[x] = SkPixel32ToPixel4444(c);

278 src += deltaSrc;

279 alphaMask &= alpha;

280 }

281 return alphaMask != 0xFF;

282 }

283

284 static bool Sample_RGBA_D4444_SkipZ(void* SK_RESTRICT dstRow,

285 const uint8_t* SK_RESTRICT src,

286 int width, int deltaSrc, int,

287 const SkPMColor[]) {

288 SkPMColor16* SK_RESTRICT dst = (SkPMColor16*)dstRow;

289 unsigned alphaMask = 0xFF;

290

291 for (int x = 0; x < width; x++) {

292 unsigned alpha = src[3];

293 if (alpha != 0) {

294 SkPMColor c = SkPreMultiplyARGB(alpha, src[0], src[1], src[2]);

295 dst[x] = SkPixel32ToPixel4444(c);

296 }

297 src += deltaSrc;

298 alphaMask &= alpha;

299 }

300 return alphaMask != 0xFF;

301 }

302

303

304 static bool Sample_RGBA_D4444_D(void* SK_RESTRICT dstRow,

305 const uint8_t* SK_RESTRICT src,

306 int width, int deltaSrc, int y,

307 const SkPMColor[]) {

308 SkPMColor16* SK_RESTRICT dst = (SkPMColor16*)dstRow;

309 unsigned alphaMask = 0xFF;

310 DITHER_4444_SCAN(y);

311

312 for (int x = 0; x < width; x++) {

313 unsigned alpha = src[3];

314 SkPMColor c = SkPreMultiplyARGB(alpha, src[0], src[1], src[2]);

315 dst[x] = SkDitherARGB32To4444(c, DITHER_VALUE(x));

316 src += deltaSrc;

317 alphaMask &= alpha;

318 }

319 return alphaMask != 0xFF;

320 }

321

322 static bool Sample_RGBA_D4444_D_SkipZ(void* SK_RESTRICT dstRow,

323 const uint8_t* SK_RESTRICT src,

324 int width, int deltaSrc, int y,

325 const SkPMColor[]) {

326 SkPMColor16* SK_RESTRICT dst = (SkPMColor16*)dstRow;

327 unsigned alphaMask = 0xFF;

328 DITHER_4444_SCAN(y);

329

330 for (int x = 0; x < width; x++) {

331 unsigned alpha = src[3];

332 if (alpha != 0) {

333 SkPMColor c = SkPreMultiplyARGB(alpha, src[0], src[1], src[2]);

334 dst[x] = SkDitherARGB32To4444(c, DITHER_VALUE(x));

335 }

336 src += deltaSrc;

337 alphaMask &= alpha;

338 }

339 return alphaMask != 0xFF;

340 }

341

342 static SkScaledBitmapSampler::RowProc

343 get_RGBA_to_4444_proc(const SkScaledBitmapSampler::Options& opts) {

344 if (!opts.fPremultiplyAlpha) {

345 // Unpremultiplied is not supported for 4444

346 return nullptr;

347 }

348 if (opts.fSkipZeros) {

349 if (opts.fDither) {

350 return Sample_RGBA_D4444_D_SkipZ;

351 }

352 return Sample_RGBA_D4444_SkipZ;

353 }

354 if (opts.fDither) {

355 return Sample_RGBA_D4444_D;

356 }

357 return Sample_RGBA_D4444;

358 }

359

360 // Index

361

362 #define A32_MASK_IN_PLACE (SkPMColor)(SK_A32_MASK << SK_A32_SHIFT)

363

364 static bool Sample_Index_D8888(void* SK_RESTRICT dstRow,

365 const uint8_t* SK_RESTRICT src,

366 int width, int deltaSrc, int, const SkPMColor ctable[]) {

367

368 SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;

369 SkPMColor cc = A32_MASK_IN_PLACE;

370 for (int x = 0; x < width; x++) {

371 SkPMColor c = ctable[*src];

372 cc &= c;

373 dst[x] = c;

374 src += deltaSrc;

375 }

376 return cc != A32_MASK_IN_PLACE;

377 }

378

379 static bool Sample_Index_D8888_SkipZ(void* SK_RESTRICT dstRow,

380 const uint8_t* SK_RESTRICT src,

381 int width, int deltaSrc, int,

382 const SkPMColor ctable[]) {

383

384 SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;

385 SkPMColor cc = A32_MASK_IN_PLACE;

386 for (int x = 0; x < width; x++) {

387 SkPMColor c = ctable[*src];

388 cc &= c;

389 if (c != 0) {

390 dst[x] = c;

391 }

392 src += deltaSrc;

393 }

394 return cc != A32_MASK_IN_PLACE;

395 }

396

397 static SkScaledBitmapSampler::RowProc

398 get_index_to_8888_proc(const SkScaledBitmapSampler::Options& opts) {

399 // The caller is expected to have created the source colortable

400 // properly with respect to opts.fPremultiplyAlpha, so premul makes

401 // no difference here.

402 // Dither makes no difference

403 if (opts.fSkipZeros) {

404 return Sample_Index_D8888_SkipZ;

405 }

406 return Sample_Index_D8888;

407 }

408

409 static bool Sample_Index_D565(void* SK_RESTRICT dstRow,

410 const uint8_t* SK_RESTRICT src,

411 int width, int deltaSrc, int, const SkPMColor ctable[]) {

412

413 uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;

414 for (int x = 0; x < width; x++) {

415 dst[x] = SkPixel32ToPixel16(ctable[*src]);

416 src += deltaSrc;

417 }

418 return false;

419 }

420

421 static bool Sample_Index_D565_D(void* SK_RESTRICT dstRow,

422 const uint8_t* SK_RESTRICT src, int width,

423 int deltaSrc, int y, const SkPMColor ctable[]) {

424

425 uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;

426 DITHER_565_SCAN(y);

427

428 for (int x = 0; x < width; x++) {

429 SkPMColor c = ctable[*src];

430 dst[x] = SkDitherRGBTo565(SkGetPackedR32(c), SkGetPackedG32(c),

431 SkGetPackedB32(c), DITHER_VALUE(x));

432 src += deltaSrc;

433 }

434 return false;

435 }

436

437 static SkScaledBitmapSampler::RowProc

438 get_index_to_565_proc(const SkScaledBitmapSampler::Options& opts) {

439 // Unpremultiplied and skip zeroes make no difference

440 if (opts.fDither) {

441 return Sample_Index_D565_D;

442 }

443 return Sample_Index_D565;

444 }

445

446 static bool Sample_Index_D4444(void* SK_RESTRICT dstRow,

447 const uint8_t* SK_RESTRICT src, int width,

448 int deltaSrc, int y, const SkPMColor ctable[]) {

449

450 SkPMColor16* SK_RESTRICT dst = (SkPMColor16*)dstRow;

451 SkPMColor cc = A32_MASK_IN_PLACE;

452 for (int x = 0; x < width; x++) {

453 SkPMColor c = ctable[*src];

454 cc &= c;

455 dst[x] = SkPixel32ToPixel4444(c);

456 src += deltaSrc;

457 }

458 return cc != A32_MASK_IN_PLACE;

459 }

460

461 static bool Sample_Index_D4444_D(void* SK_RESTRICT dstRow,

462 const uint8_t* SK_RESTRICT src, int width,

463 int deltaSrc, int y, const SkPMColor ctable[]) {

464

465 SkPMColor16* SK_RESTRICT dst = (SkPMColor16*)dstRow;

466 SkPMColor cc = A32_MASK_IN_PLACE;

467 DITHER_4444_SCAN(y);

468

469 for (int x = 0; x < width; x++) {

470 SkPMColor c = ctable[*src];

471 cc &= c;

472 dst[x] = SkDitherARGB32To4444(c, DITHER_VALUE(x));

473 src += deltaSrc;

474 }

475 return cc != A32_MASK_IN_PLACE;

476 }

477

478 static bool Sample_Index_D4444_SkipZ(void* SK_RESTRICT dstRow,

479 const uint8_t* SK_RESTRICT src, int width,

480 int deltaSrc, int y, const SkPMColor ctable []) {

481

482 SkPMColor16* SK_RESTRICT dst = (SkPMColor16*)dstRow;

483 SkPMColor cc = A32_MASK_IN_PLACE;

484 for (int x = 0; x < width; x++) {

485 SkPMColor c = ctable[*src];

486 cc &= c;

487 if (c != 0) {

488 dst[x] = SkPixel32ToPixel4444(c);

489 }

490 src += deltaSrc;

491 }

492 return cc != A32_MASK_IN_PLACE;

493 }

494

495 static bool Sample_Index_D4444_D_SkipZ(void* SK_RESTRICT dstRow,

496 const uint8_t* SK_RESTRICT src, int width ,

497 int deltaSrc, int y, const SkPMColor ctab le[]) {

498

499 SkPMColor16* SK_RESTRICT dst = (SkPMColor16*)dstRow;

500 SkPMColor cc = A32_MASK_IN_PLACE;

501 DITHER_4444_SCAN(y);

502

503 for (int x = 0; x < width; x++) {

504 SkPMColor c = ctable[*src];

505 cc &= c;

506 if (c != 0) {

507 dst[x] = SkDitherARGB32To4444(c, DITHER_VALUE(x));

508 }

509 src += deltaSrc;

510 }

511 return cc != A32_MASK_IN_PLACE;

512 }

513

514 static SkScaledBitmapSampler::RowProc

515 get_index_to_4444_proc(const SkScaledBitmapSampler::Options& opts) {

516 // Unpremul not allowed

517 if (!opts.fPremultiplyAlpha) {

518 return nullptr;

519 }

520 if (opts.fSkipZeros) {

521 if (opts.fDither) {

522 return Sample_Index_D4444_D_SkipZ;

523 }

524 return Sample_Index_D4444_SkipZ;

525 }

526 if (opts.fDither) {

527 return Sample_Index_D4444_D;

528 }

529 return Sample_Index_D4444;

530 }

531

532 static bool Sample_Index_DI(void* SK_RESTRICT dstRow,

533 const uint8_t* SK_RESTRICT src,

534 int width, int deltaSrc, int, const SkPMColor[]) {

535 if (1 == deltaSrc) {

536 memcpy(dstRow, src, width);

537 } else {

538 uint8_t* SK_RESTRICT dst = (uint8_t*)dstRow;

539 for (int x = 0; x < width; x++) {

540 dst[x] = src[0];

541 src += deltaSrc;

542 }

543 }

544 return false;

545 }

546

547 static SkScaledBitmapSampler::RowProc

548 get_index_to_index_proc(const SkScaledBitmapSampler::Options& opts) {

549 // Unpremul not allowed

550 if (!opts.fPremultiplyAlpha) {

551 return nullptr;

552 }

553 // Ignore dither and skip zeroes

554 return Sample_Index_DI;

555 }

556

557 // A8

558 static bool Sample_Gray_DA8(void* SK_RESTRICT dstRow,

559 const uint8_t* SK_RESTRICT src,

560 int width, int deltaSrc, int,

561 const SkPMColor[]) {

562 // Sampling Gray to A8 uses the same function as Index to Index8,

563 // except we assume that there is alpha for speed, since an A8

564 // bitmap with no alpha is not interesting.

565 (void) Sample_Index_DI(dstRow, src, width, deltaSrc, /* y unused */ 0,

566 /* ctable unused */ nullptr);

567 return true;

568 }

569

570 static SkScaledBitmapSampler::RowProc

571 get_gray_to_A8_proc(const SkScaledBitmapSampler::Options& opts) {

572 if (!opts.fPremultiplyAlpha) {

573 return nullptr;

574 }

575 // Ignore skip and dither.

576 return Sample_Gray_DA8;

577 }

578

579 typedef SkScaledBitmapSampler::RowProc (*RowProcChooser)(const SkScaledBitmapSam pler::Options&);

580 ///////////////////////////////////////////////////////////////////////////////

581

582 #include "SkScaledBitmapSampler.h"

583

584 SkScaledBitmapSampler::SkScaledBitmapSampler(int width, int height,

585 int sampleSize) {

586 fCTable = nullptr;

587 fDstRow = nullptr;

588 fRowProc = nullptr;

589

590 if (width <= 0 \|\| height <= 0) {

591 sk_throw();

592 }

593

594 SkDEBUGCODE(fSampleMode = kUninitialized_SampleMode);

595

596 if (sampleSize <= 1) {

597 fScaledWidth = width;

598 fScaledHeight = height;

599 fX0 = fY0 = 0;

600 fDX = fDY = 1;

601 return;

602 }

603

604 int dx = SkMin32(sampleSize, width);

605 int dy = SkMin32(sampleSize, height);

606

607 fScaledWidth = width / dx;

608 fScaledHeight = height / dy;

609

610 SkASSERT(fScaledWidth > 0);

611 SkASSERT(fScaledHeight > 0);

612

613 fX0 = dx >> 1;

614 fY0 = dy >> 1;

615

616 SkASSERT(fX0 >= 0 && fX0 < width);

617 SkASSERT(fY0 >= 0 && fY0 < height);

618

619 fDX = dx;

620 fDY = dy;

621

622 SkASSERT(fDX > 0 && (fX0 + fDX * (fScaledWidth - 1)) < width);

623 SkASSERT(fDY > 0 && (fY0 + fDY * (fScaledHeight - 1)) < height);

624 }

625

626 bool SkScaledBitmapSampler::begin(SkBitmap* dst, SrcConfig sc,

627 const Options& opts,

628 const SkPMColor ctable[]) {

629 static const RowProcChooser gProcChoosers[] = {

630 get_gray_to_8888_proc,

631 get_RGBx_to_8888_proc,

632 get_RGBA_to_8888_proc,

633 get_index_to_8888_proc,

634 nullptr, // 565 to 8888

635

636 get_gray_to_565_proc,

637 get_RGBx_to_565_proc,

638 get_RGBx_to_565_proc, // The source alpha will be ignored.

639 get_index_to_565_proc,

640 get_565_to_565_proc,

641

642 get_gray_to_4444_proc,

643 get_RGBx_to_4444_proc,

644 get_RGBA_to_4444_proc,

645 get_index_to_4444_proc,

646 nullptr, // 565 to 4444

647

648 nullptr, // gray to index

649 nullptr, // rgbx to index

650 nullptr, // rgba to index

651 get_index_to_index_proc,

652 nullptr, // 565 to index

653

654 get_gray_to_A8_proc,

655 nullptr, // rgbx to a8

656 nullptr, // rgba to a8

657 nullptr, // index to a8

658 nullptr, // 565 to a8

659 };

660

661 // The jump between dst configs in the table

662 static const int gProcDstConfigSpan = 5;

663 static_assert(SK_ARRAY_COUNT(gProcChoosers) == 5 * gProcDstConfigSpan,

664 "gProcs_has_the_wrong_number_of_entries");

665

666 fCTable = ctable;

667

668 int index = 0;

669 switch (sc) {

670 case SkScaledBitmapSampler::kGray:

671 fSrcPixelSize = 1;

672 index += 0;

673 break;

674 case SkScaledBitmapSampler::kRGB:

675 fSrcPixelSize = 3;

676 index += 1;

677 break;

678 case SkScaledBitmapSampler::kRGBX:

679 fSrcPixelSize = 4;

680 index += 1;

681 break;

682 case SkScaledBitmapSampler::kRGBA:

683 fSrcPixelSize = 4;

684 index += 2;

685 break;

686 case SkScaledBitmapSampler::kIndex:

687 fSrcPixelSize = 1;

688 index += 3;

689 break;

690 case SkScaledBitmapSampler::kRGB_565:

691 fSrcPixelSize = 2;

692 index += 4;

693 break;

694 default:

695 return false;

696 }

697

698 switch (dst->colorType()) {

699 case kN32_SkColorType:

700 index += 0 * gProcDstConfigSpan;

701 break;

702 case kRGB_565_SkColorType:

703 index += 1 * gProcDstConfigSpan;

704 break;

705 case kARGB_4444_SkColorType:

706 index += 2 * gProcDstConfigSpan;

707 break;

708 case kIndex_8_SkColorType:

709 index += 3 * gProcDstConfigSpan;

710 break;

711 case kAlpha_8_SkColorType:

712 index += 4 * gProcDstConfigSpan;

713 break;

714 default:

715 return false;

716 }

717

718 RowProcChooser chooser = gProcChoosers[index];

719 if (nullptr == chooser) {

720 fRowProc = nullptr;

721 } else {

722 fRowProc = chooser(opts);

723 }

724 fDstRow = (char*)dst->getPixels();

725 fDstRowBytes = dst->rowBytes();

726 fCurrY = 0;

727 return fRowProc != nullptr;

728 }

729

730 bool SkScaledBitmapSampler::begin(SkBitmap* dst, SrcConfig sc,

731 const SkImageDecoder& decoder,

732 const SkPMColor ctable[]) {

733 return this->begin(dst, sc, Options(decoder), ctable);

734 }

735

736 bool SkScaledBitmapSampler::next(const uint8_t* SK_RESTRICT src) {

737 SkASSERT(kInterlaced_SampleMode != fSampleMode);

738 SkDEBUGCODE(fSampleMode = kConsecutive_SampleMode);

739 SkASSERT((unsigned)fCurrY < (unsigned)fScaledHeight);

740

741 bool hadAlpha = fRowProc(fDstRow, src + fX0 * fSrcPixelSize, fScaledWidth,

742 fDX * fSrcPixelSize, fCurrY, fCTable);

743 fDstRow += fDstRowBytes;

744 fCurrY += 1;

745 return hadAlpha;

746 }

747

748 bool SkScaledBitmapSampler::sampleInterlaced(const uint8_t* SK_RESTRICT src, int srcY) {

749 SkASSERT(kConsecutive_SampleMode != fSampleMode);

750 SkDEBUGCODE(fSampleMode = kInterlaced_SampleMode);

751 // Any line that should be a part of the destination can be created by the f ormula:

752 // fY0 + (some multiplier) * fDY

753 // so if srcY - fY0 is not an integer multiple of fDY that srcY will be skip ped.

754 const int srcYMinusY0 = srcY - fY0;

755 if (srcYMinusY0 % fDY != 0) {

756 // This line is not part of the output, so return false for alpha, since we have

757 // not added an alpha to the output.

758 return false;

759 }

760 // Unlike in next(), where the data is used sequentially, this function skip s around,

761 // so fDstRow and fCurrY are never updated. fDstRow must always be the start ing point

762 // of the destination bitmap's pixels, which is used to calculate the destin ation row

763 // each time this function is called.

764 const int dstY = srcYMinusY0 / fDY;

765 if (dstY >= fScaledHeight) {

766 return false;

767 }

768 char* dstRow = fDstRow + dstY * fDstRowBytes;

769 return fRowProc(dstRow, src + fX0 * fSrcPixelSize, fScaledWidth,

770 fDX * fSrcPixelSize, dstY, fCTable);

771 }

772

773 #ifdef SK_DEBUG

774 // The following code is for a test to ensure that changing the method to get th e right row proc

775 // did not change the row proc unintentionally. Tested by ImageDecodingTest.cpp

776

777 // friend of SkScaledBitmapSampler solely for the purpose of accessing fRowProc.

778 class RowProcTester {

779 public:

780 static SkScaledBitmapSampler::RowProc getRowProc(const SkScaledBitmapSampler & sampler) {

781 return sampler.fRowProc;

782 }

783 };

784

785

786 // Table showing the expected RowProc for each combination of inputs.

787 // Table formated as follows:

788 // Each group of 5 consecutive rows represents sampling from a single

789 // SkScaledBitmapSampler::SrcConfig.

790 // Within each set, each row represents a different destination SkBitmap::Config

791 // Each column represents a different combination of dither and unpremul.

792 // D = dither ~D = no dither

793 // U = unpremul ~U = no unpremul

794 // ~D~U D~U ~DU DU

795 SkScaledBitmapSampler::RowProc gTestProcs[] = {

796 // Gray

797 Sample_Gray_DA8, Sample_Gray_DA8, nullptr, n ullptr, // to A8

798 nullptr, nullptr, nullptr, nullptr, // to Index8

799 Sample_Gray_D565, Sample_Gray_D565_D, Sample_Gray_D565, Samp le_Gray_D565_D, // to 565

800 Sample_Gray_D4444, Sample_Gray_D4444_D, Sample_Gray_D4444, Samp le_Gray_D4444_D, // to 4444

801 Sample_Gray_D8888, Sample_Gray_D8888, Sample_Gray_D8888, Samp le_Gray_D8888, // to 8888

802 // Index

803 nullptr, nullptr, nullptr, nullptr, // to A8

804 Sample_Index_DI, Sample_Index_DI, nullptr, n ullptr, // to Index8

805 Sample_Index_D565, Sample_Index_D565_D, Sample_Index_D565, Samp le_Index_D565_D, // to 565

806 Sample_Index_D4444, Sample_Index_D4444_D, nullptr, n ullptr, // to 4444

807 Sample_Index_D8888, Sample_Index_D8888, Sample_Index_D8888, Samp le_Index_D8888, // to 8888

808 // RGB

809 nullptr, nullptr, nullptr, nullptr, // to A8

810 nullptr, nullptr, nullptr, nullptr, // to Index8

811 Sample_RGBx_D565, Sample_RGBx_D565_D, Sample_RGBx_D565, Samp le_RGBx_D565_D, // to 565

812 Sample_RGBx_D4444, Sample_RGBx_D4444_D, Sample_RGBx_D4444, Samp le_RGBx_D4444_D, // to 4444

813 Sample_RGBx_D8888, Sample_RGBx_D8888, Sample_RGBx_D8888, Samp le_RGBx_D8888, // to 8888

814 // RGBx is the same as RGB

815 nullptr, nullptr, nullptr, nullptr, // to A8

816 nullptr, nullptr, nullptr, nullptr, // to Index8

817 Sample_RGBx_D565, Sample_RGBx_D565_D, Sample_RGBx_D565, Samp le_RGBx_D565_D, // to 565

818 Sample_RGBx_D4444, Sample_RGBx_D4444_D, Sample_RGBx_D4444, Samp le_RGBx_D4444_D, // to 4444

819 Sample_RGBx_D8888, Sample_RGBx_D8888, Sample_RGBx_D8888, Samp le_RGBx_D8888, // to 8888

820 // RGBA

821 nullptr, nullptr, nullptr, nullptr, // to A8

822 nullptr, nullptr, nullptr, nullptr, // to Index8

823 Sample_RGBx_D565, Sample_RGBx_D565_D, Sample_RGBx_D565, Samp le_RGBx_D565_D, // to 565

824 Sample_RGBA_D4444, Sample_RGBA_D4444_D, nullptr, n ullptr, // to 4444

825 Sample_RGBA_D8888, Sample_RGBA_D8888, Sample_RGBA_D8888_Unpremul, Samp le_RGBA_D8888_Unpremul, // to 8888

826 // RGB_565

827 nullptr, nullptr, nullptr, nullptr, // to A8

828 nullptr, nullptr, nullptr, nullptr, // to Index8

829 Sample_D565_D565, Sample_D565_D565, Sample_D565_D565, Samp le_D565_D565, // to 565

830 nullptr, nullptr, nullptr, nullptr, // to 4444

831 nullptr, nullptr, nullptr, nullptr, // to 8888

832 };

833

834 // Dummy class that allows instantiation of an ImageDecoder, so begin can query its fields.

835 class DummyDecoder : public SkImageDecoder {

836 public:

837 DummyDecoder() {}

838 protected:

839 Result onDecode(SkStream, SkBitmap, SkImageDecoder::Mode) override {

840 return kFailure;

841 }

842 };

843

844 void test_row_proc_choice();

845 void test_row_proc_choice() {

846 const SkColorType colorTypes[] = {

847 kAlpha_8_SkColorType, kIndex_8_SkColorType, kRGB_565_SkColorType, kARGB_ 4444_SkColorType,

848 kN32_SkColorType

849 };

850

851 SkBitmap dummyBitmap;

852 DummyDecoder dummyDecoder;

853 size_t procCounter = 0;

854 for (int sc = SkScaledBitmapSampler::kGray; sc <= SkScaledBitmapSampler::kRG B_565; ++sc) {

855 for (size_t c = 0; c < SK_ARRAY_COUNT(colorTypes); ++c) {

856 for (int unpremul = 0; unpremul <= 1; ++unpremul) {

857 for (int dither = 0; dither <= 1; ++dither) {

858 // Arbitrary width/height/sampleSize to allow SkScaledBitmap Sampler to

859 // be considered valid.

860 SkScaledBitmapSampler sampler(10, 10, 1);

861 dummyBitmap.setInfo(SkImageInfo::Make(10, 10,

862 colorTypes[c], kPremul _SkAlphaType));

863 dummyDecoder.setDitherImage(SkToBool(dither));

864 dummyDecoder.setRequireUnpremultipliedColors(SkToBool(unprem ul));

865 sampler.begin(&dummyBitmap, (SkScaledBitmapSampler::SrcConfi g) sc,

866 dummyDecoder);

867 SkScaledBitmapSampler::RowProc expected = gTestProcs[procCou nter];

868 SkScaledBitmapSampler::RowProc actual = RowProcTester::getRo wProc(sampler);

869 SkASSERT(expected == actual);

870 procCounter++;

871 }

872 }

873 }

874 }

875 SkASSERT(SK_ARRAY_COUNT(gTestProcs) == procCounter);

876 }

877 #endif // SK_DEBUG

OLD	NEW

« no previous file with comments | « src/images/SkScaledBitmapSampler.h ('k') | src/images/bmpdecoderhelper.h » ('j') | no next file with comments »