OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2016 Google Inc. | 2 * Copyright 2016 Google Inc. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #include "SkColorSpace.h" | 8 #include "SkColorSpace.h" |
9 #include "SkColorSpace_Base.h" | 9 #include "SkColorSpace_Base.h" |
10 #include "SkColorSpacePriv.h" | 10 #include "SkColorSpacePriv.h" |
(...skipping 769 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
780 handle_invalid_gamma(&rType, &rData); | 780 handle_invalid_gamma(&rType, &rData); |
781 size_t alignedTagBytes = SkAlign4(tagBytes); | 781 size_t alignedTagBytes = SkAlign4(tagBytes); |
782 | 782 |
783 if ((3 * alignedTagBytes <= tagLen) && | 783 if ((3 * alignedTagBytes <= tagLen) && |
784 !memcmp(rTagPtr, rTagPtr + 1 * alignedTagBytes, tagBytes) && | 784 !memcmp(rTagPtr, rTagPtr + 1 * alignedTagBytes, tagBytes) && |
785 !memcmp(rTagPtr, rTagPtr + 2 * alignedTagBytes, tagBytes)) | 785 !memcmp(rTagPtr, rTagPtr + 2 * alignedTagBytes, tagBytes)) |
786 { | 786 { |
787 if (SkGammas::Type::kNamed_Type == rType) { | 787 if (SkGammas::Type::kNamed_Type == rType) { |
788 *gammaNamed = rData.fNamed; | 788 *gammaNamed = rData.fNamed; |
789 } else { | 789 } else { |
790 size_t allocSize = sizeof(SkGammas) + gamma_alloc_size(rType, rD
ata); | 790 size_t allocSize = sizeof(SkGammas); |
| 791 return_if_false(safe_add(allocSize, gamma_alloc_size(rType, rDat
a), &allocSize), |
| 792 "SkGammas struct is too large to allocate"); |
791 void* memory = sk_malloc_throw(allocSize); | 793 void* memory = sk_malloc_throw(allocSize); |
792 *gammas = sk_sp<SkGammas>(new (memory) SkGammas()); | 794 *gammas = sk_sp<SkGammas>(new (memory) SkGammas()); |
793 load_gammas(memory, 0, rType, &rData, rParams, rTagPtr); | 795 load_gammas(memory, 0, rType, &rData, rParams, rTagPtr); |
794 | 796 |
795 (*gammas)->fRedType = rType; | 797 (*gammas)->fRedType = rType; |
796 (*gammas)->fGreenType = rType; | 798 (*gammas)->fGreenType = rType; |
797 (*gammas)->fBlueType = rType; | 799 (*gammas)->fBlueType = rType; |
798 | 800 |
799 (*gammas)->fRedData = rData; | 801 (*gammas)->fRedData = rData; |
800 (*gammas)->fGreenData = rData; | 802 (*gammas)->fGreenData = rData; |
(...skipping 11 matching lines...) Expand all Loading... |
812 | 814 |
813 alignedTagBytes = SkAlign4(tagBytes); | 815 alignedTagBytes = SkAlign4(tagBytes); |
814 const uint8_t* bTagPtr = gTagPtr + alignedTagBytes; | 816 const uint8_t* bTagPtr = gTagPtr + alignedTagBytes; |
815 tagLen = tagLen > alignedTagBytes ? tagLen - alignedTagBytes : 0; | 817 tagLen = tagLen > alignedTagBytes ? tagLen - alignedTagBytes : 0; |
816 SkGammas::Data bData; | 818 SkGammas::Data bData; |
817 SkGammas::Params bParams; | 819 SkGammas::Params bParams; |
818 SkGammas::Type bType = parse_gamma(&bData, &bParams, &tagBytes, bTag
Ptr, | 820 SkGammas::Type bType = parse_gamma(&bData, &bParams, &tagBytes, bTag
Ptr, |
819 tagLen); | 821 tagLen); |
820 handle_invalid_gamma(&bType, &bData); | 822 handle_invalid_gamma(&bType, &bData); |
821 | 823 |
822 size_t allocSize = sizeof(SkGammas) + gamma_alloc_size(rType, rData) | 824 size_t allocSize = sizeof(SkGammas); |
823 + gamma_alloc_size(gType, gData) | 825 return_if_false(safe_add(allocSize, gamma_alloc_size(rType, rData),
&allocSize), |
824 + gamma_alloc_size(bType, bData)
; | 826 "SkGammas struct is too large to allocate"); |
| 827 return_if_false(safe_add(allocSize, gamma_alloc_size(gType, gData),
&allocSize), |
| 828 "SkGammas struct is too large to allocate"); |
| 829 return_if_false(safe_add(allocSize, gamma_alloc_size(bType, bData),
&allocSize), |
| 830 "SkGammas struct is too large to allocate"); |
825 void* memory = sk_malloc_throw(allocSize); | 831 void* memory = sk_malloc_throw(allocSize); |
826 *gammas = sk_sp<SkGammas>(new (memory) SkGammas()); | 832 *gammas = sk_sp<SkGammas>(new (memory) SkGammas()); |
827 | 833 |
828 uint32_t offset = 0; | 834 uint32_t offset = 0; |
829 (*gammas)->fRedType = rType; | 835 (*gammas)->fRedType = rType; |
830 offset += load_gammas(memory, offset, rType, &rData, rParams, rTagPt
r); | 836 offset += load_gammas(memory, offset, rType, &rData, rParams, rTagPt
r); |
831 | 837 |
832 (*gammas)->fGreenType = gType; | 838 (*gammas)->fGreenType = gType; |
833 offset += load_gammas(memory, offset, gType, &gData, gParams, gTagPt
r); | 839 offset += load_gammas(memory, offset, gType, &gData, gParams, gTagPt
r); |
834 | 840 |
(...skipping 128 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
963 if (tag_equals(r, g, base) && tag_equals(g, b, base)) { | 969 if (tag_equals(r, g, base) && tag_equals(g, b, base)) { |
964 SkGammas::Data data; | 970 SkGammas::Data data; |
965 SkGammas::Params params; | 971 SkGammas::Params params; |
966 SkGammas::Type type = | 972 SkGammas::Type type = |
967 parse_gamma(&data, ¶ms, &tagBytes, r->addr(b
ase), r->fLength); | 973 parse_gamma(&data, ¶ms, &tagBytes, r->addr(b
ase), r->fLength); |
968 handle_invalid_gamma(&type, &data); | 974 handle_invalid_gamma(&type, &data); |
969 | 975 |
970 if (SkGammas::Type::kNamed_Type == type) { | 976 if (SkGammas::Type::kNamed_Type == type) { |
971 gammaNamed = data.fNamed; | 977 gammaNamed = data.fNamed; |
972 } else { | 978 } else { |
973 size_t allocSize = sizeof(SkGammas) + gamma_alloc_si
ze(type, data); | 979 size_t allocSize = sizeof(SkGammas); |
| 980 if (!safe_add(allocSize, gamma_alloc_size(type, data
), &allocSize)) { |
| 981 return_null("SkGammas struct is too large to all
ocate"); |
| 982 } |
974 void* memory = sk_malloc_throw(allocSize); | 983 void* memory = sk_malloc_throw(allocSize); |
975 gammas = sk_sp<SkGammas>(new (memory) SkGammas()); | 984 gammas = sk_sp<SkGammas>(new (memory) SkGammas()); |
976 load_gammas(memory, 0, type, &data, params, r->addr(
base)); | 985 load_gammas(memory, 0, type, &data, params, r->addr(
base)); |
977 | 986 |
978 gammas->fRedType = type; | 987 gammas->fRedType = type; |
979 gammas->fGreenType = type; | 988 gammas->fGreenType = type; |
980 gammas->fBlueType = type; | 989 gammas->fBlueType = type; |
981 | 990 |
982 gammas->fRedData = data; | 991 gammas->fRedData = data; |
983 gammas->fGreenData = data; | 992 gammas->fGreenData = data; |
(...skipping 11 matching lines...) Expand all Loading... |
995 SkGammas::Type gType = | 1004 SkGammas::Type gType = |
996 parse_gamma(&gData, &gParams, &tagBytes, g->addr
(base), g->fLength); | 1005 parse_gamma(&gData, &gParams, &tagBytes, g->addr
(base), g->fLength); |
997 handle_invalid_gamma(&gType, &gData); | 1006 handle_invalid_gamma(&gType, &gData); |
998 | 1007 |
999 SkGammas::Data bData; | 1008 SkGammas::Data bData; |
1000 SkGammas::Params bParams; | 1009 SkGammas::Params bParams; |
1001 SkGammas::Type bType = | 1010 SkGammas::Type bType = |
1002 parse_gamma(&bData, &bParams, &tagBytes, b->addr
(base), b->fLength); | 1011 parse_gamma(&bData, &bParams, &tagBytes, b->addr
(base), b->fLength); |
1003 handle_invalid_gamma(&bType, &bData); | 1012 handle_invalid_gamma(&bType, &bData); |
1004 | 1013 |
1005 size_t allocSize = sizeof(SkGammas) + gamma_alloc_size(r
Type, rData) | 1014 size_t allocSize = sizeof(SkGammas); |
1006 + gamma_alloc_size(g
Type, gData) | 1015 if (!safe_add(allocSize, gamma_alloc_size(rType, rData),
&allocSize) || |
1007 + gamma_alloc_size(b
Type, bData); | 1016 !safe_add(allocSize, gamma_alloc_size(gType, gData),
&allocSize) || |
| 1017 !safe_add(allocSize, gamma_alloc_size(bType, bData),
&allocSize)) |
| 1018 { |
| 1019 return_null("SkGammas struct is too large to allocat
e"); |
| 1020 } |
1008 void* memory = sk_malloc_throw(allocSize); | 1021 void* memory = sk_malloc_throw(allocSize); |
1009 gammas = sk_sp<SkGammas>(new (memory) SkGammas()); | 1022 gammas = sk_sp<SkGammas>(new (memory) SkGammas()); |
1010 | 1023 |
1011 uint32_t offset = 0; | 1024 uint32_t offset = 0; |
1012 gammas->fRedType = rType; | 1025 gammas->fRedType = rType; |
1013 offset += load_gammas(memory, offset, rType, &rData, rPa
rams, | 1026 offset += load_gammas(memory, offset, rType, &rData, rPa
rams, |
1014 r->addr(base)); | 1027 r->addr(base)); |
1015 | 1028 |
1016 gammas->fGreenType = gType; | 1029 gammas->fGreenType = gType; |
1017 offset += load_gammas(memory, offset, gType, &gData, gPa
rams, | 1030 offset += load_gammas(memory, offset, gType, &gData, gPa
rams, |
(...skipping 267 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1285 ptr32[4] = SkEndian_SwapBE32(0x000116cc); | 1298 ptr32[4] = SkEndian_SwapBE32(0x000116cc); |
1286 ptr += kTAG_XYZ_Bytes; | 1299 ptr += kTAG_XYZ_Bytes; |
1287 | 1300 |
1288 // Write copyright tag | 1301 // Write copyright tag |
1289 memcpy(ptr, gEmptyTextTag, sizeof(gEmptyTextTag)); | 1302 memcpy(ptr, gEmptyTextTag, sizeof(gEmptyTextTag)); |
1290 | 1303 |
1291 // TODO (msarett): Should we try to hold onto the data so we can return imme
diately if | 1304 // TODO (msarett): Should we try to hold onto the data so we can return imme
diately if |
1292 // the client calls again? | 1305 // the client calls again? |
1293 return SkData::MakeFromMalloc(profile.release(), kICCProfileSize); | 1306 return SkData::MakeFromMalloc(profile.release(), kICCProfileSize); |
1294 } | 1307 } |
OLD | NEW |