Make GfxColorSpace::parse and friends return unique_ptr
diff --git a/poppler/CairoOutputDev.cc b/poppler/CairoOutputDev.cc
index 4fac308..08f695e 100644
--- a/poppler/CairoOutputDev.cc
+++ b/poppler/CairoOutputDev.cc
@@ -16,7 +16,7 @@
//
// Copyright (C) 2005-2008 Jeff Muizelaar <jeff@infidigm.net>
// Copyright (C) 2005, 2006 Kristian Høgsberg <krh@redhat.com>
-// Copyright (C) 2005, 2009, 2012, 2017-2021, 2023 Albert Astals Cid <aacid@kde.org>
+// Copyright (C) 2005, 2009, 2012, 2017-2021, 2023, 2024 Albert Astals Cid <aacid@kde.org>
// Copyright (C) 2005 Nickolay V. Shmyrev <nshmyrev@yandex.ru>
// Copyright (C) 2006-2011, 2013, 2014, 2017, 2018 Carlos Garcia Campos <carlosgc@gnome.org>
// Copyright (C) 2008 Carl Worth <cworth@cworth.org>
@@ -3188,7 +3188,6 @@
char *strBuffer;
int len;
Object obj;
- GfxColorSpace *colorSpace;
StreamKind strKind = str->getKind();
const char *mime_type;
cairo_status_t status;
@@ -3228,7 +3227,7 @@
}
obj = str->getDict()->lookup("ColorSpace");
- colorSpace = GfxColorSpace::parse(nullptr, &obj, this, state);
+ std::unique_ptr<GfxColorSpace> colorSpace = GfxColorSpace::parse(nullptr, &obj, this, state);
// colorspace in stream dict may be different from colorspace in jpx
// data
@@ -3239,7 +3238,6 @@
// only embed mime data for gray, rgb, and cmyk colorspaces.
if (colorSpace) {
GfxColorSpaceMode mode = colorSpace->getMode();
- delete colorSpace;
switch (mode) {
case csDeviceGray:
case csCalGray:
diff --git a/poppler/Gfx.cc b/poppler/Gfx.cc
index d8dd533..539fa4d 100644
--- a/poppler/Gfx.cc
+++ b/poppler/Gfx.cc
@@ -14,7 +14,7 @@
// under GPL version 2 or later
//
// Copyright (C) 2005 Jonathan Blandford <jrb@redhat.com>
-// Copyright (C) 2005-2013, 2015-2022 Albert Astals Cid <aacid@kde.org>
+// Copyright (C) 2005-2013, 2015-2022, 2024 Albert Astals Cid <aacid@kde.org>
// Copyright (C) 2006 Thorkild Stray <thorkild@ifi.uio.no>
// Copyright (C) 2006 Kristian Høgsberg <krh@redhat.com>
// Copyright (C) 2006-2011 Carlos Garcia Campos <carlosgc@gnome.org>
@@ -1143,7 +1143,7 @@
if (obj3.isStream()) {
Object obj4 = obj3.streamGetDict()->lookup("Group");
if (obj4.isDict()) {
- GfxColorSpace *blendingColorSpace = nullptr;
+ std::unique_ptr<GfxColorSpace> blendingColorSpace;
Object obj5 = obj4.dictLookup("CS");
if (!obj5.isNull()) {
blendingColorSpace = GfxColorSpace::parse(res, &obj5, out, state);
@@ -1160,8 +1160,7 @@
}
}
}
- doSoftMask(&obj3, alpha, blendingColorSpace, isolated, knockout, softMaskTransferFunc, &backdropColor);
- delete blendingColorSpace;
+ doSoftMask(&obj3, alpha, blendingColorSpace.get(), isolated, knockout, softMaskTransferFunc, &backdropColor);
} else {
error(errSyntaxError, getPos(), "Invalid soft mask in ExtGState - missing group");
}
@@ -1303,18 +1302,17 @@
void Gfx::opSetFillGray(Object args[], int numArgs)
{
GfxColor color;
- GfxColorSpace *colorSpace = nullptr;
+ std::unique_ptr<GfxColorSpace> colorSpace;
state->setFillPattern(nullptr);
Object obj = res->lookupColorSpace("DefaultGray");
if (!obj.isNull()) {
colorSpace = GfxColorSpace::parse(res, &obj, out, state);
}
- if (colorSpace == nullptr || colorSpace->getNComps() > 1) {
- delete colorSpace;
+ if (!colorSpace || colorSpace->getNComps() > 1) {
colorSpace = state->copyDefaultGrayColorSpace();
}
- state->setFillColorSpace(colorSpace);
+ state->setFillColorSpace(std::move(colorSpace));
out->updateFillColorSpace(state);
color.c[0] = dblToCol(args[0].getNum());
state->setFillColor(&color);
@@ -1324,17 +1322,17 @@
void Gfx::opSetStrokeGray(Object args[], int numArgs)
{
GfxColor color;
- GfxColorSpace *colorSpace = nullptr;
+ std::unique_ptr<GfxColorSpace> colorSpace;
state->setStrokePattern(nullptr);
Object obj = res->lookupColorSpace("DefaultGray");
if (!obj.isNull()) {
colorSpace = GfxColorSpace::parse(res, &obj, out, state);
}
- if (colorSpace == nullptr) {
+ if (!colorSpace) {
colorSpace = state->copyDefaultGrayColorSpace();
}
- state->setStrokeColorSpace(colorSpace);
+ state->setStrokeColorSpace(std::move(colorSpace));
out->updateStrokeColorSpace(state);
color.c[0] = dblToCol(args[0].getNum());
state->setStrokeColor(&color);
@@ -1344,18 +1342,18 @@
void Gfx::opSetFillCMYKColor(Object args[], int numArgs)
{
GfxColor color;
- GfxColorSpace *colorSpace = nullptr;
+ std::unique_ptr<GfxColorSpace> colorSpace;
int i;
Object obj = res->lookupColorSpace("DefaultCMYK");
if (!obj.isNull()) {
colorSpace = GfxColorSpace::parse(res, &obj, out, state);
}
- if (colorSpace == nullptr) {
+ if (!colorSpace) {
colorSpace = state->copyDefaultCMYKColorSpace();
}
state->setFillPattern(nullptr);
- state->setFillColorSpace(colorSpace);
+ state->setFillColorSpace(std::move(colorSpace));
out->updateFillColorSpace(state);
for (i = 0; i < 4; ++i) {
color.c[i] = dblToCol(args[i].getNum());
@@ -1367,7 +1365,7 @@
void Gfx::opSetStrokeCMYKColor(Object args[], int numArgs)
{
GfxColor color;
- GfxColorSpace *colorSpace = nullptr;
+ std::unique_ptr<GfxColorSpace> colorSpace;
int i;
state->setStrokePattern(nullptr);
@@ -1375,10 +1373,10 @@
if (!obj.isNull()) {
colorSpace = GfxColorSpace::parse(res, &obj, out, state);
}
- if (colorSpace == nullptr) {
+ if (!colorSpace) {
colorSpace = state->copyDefaultCMYKColorSpace();
}
- state->setStrokeColorSpace(colorSpace);
+ state->setStrokeColorSpace(std::move(colorSpace));
out->updateStrokeColorSpace(state);
for (i = 0; i < 4; ++i) {
color.c[i] = dblToCol(args[i].getNum());
@@ -1389,7 +1387,7 @@
void Gfx::opSetFillRGBColor(Object args[], int numArgs)
{
- GfxColorSpace *colorSpace = nullptr;
+ std::unique_ptr<GfxColorSpace> colorSpace;
GfxColor color;
int i;
@@ -1398,11 +1396,10 @@
if (!obj.isNull()) {
colorSpace = GfxColorSpace::parse(res, &obj, out, state);
}
- if (colorSpace == nullptr || colorSpace->getNComps() > 3) {
- delete colorSpace;
+ if (!colorSpace || colorSpace->getNComps() > 3) {
colorSpace = state->copyDefaultRGBColorSpace();
}
- state->setFillColorSpace(colorSpace);
+ state->setFillColorSpace(std::move(colorSpace));
out->updateFillColorSpace(state);
for (i = 0; i < 3; ++i) {
color.c[i] = dblToCol(args[i].getNum());
@@ -1413,7 +1410,7 @@
void Gfx::opSetStrokeRGBColor(Object args[], int numArgs)
{
- GfxColorSpace *colorSpace = nullptr;
+ std::unique_ptr<GfxColorSpace> colorSpace;
GfxColor color;
int i;
@@ -1422,10 +1419,10 @@
if (!obj.isNull()) {
colorSpace = GfxColorSpace::parse(res, &obj, out, state);
}
- if (colorSpace == nullptr) {
+ if (!colorSpace) {
colorSpace = state->copyDefaultRGBColorSpace();
}
- state->setStrokeColorSpace(colorSpace);
+ state->setStrokeColorSpace(std::move(colorSpace));
out->updateStrokeColorSpace(state);
for (i = 0; i < 3; ++i) {
color.c[i] = dblToCol(args[i].getNum());
@@ -1436,7 +1433,7 @@
void Gfx::opSetFillColorSpace(Object args[], int numArgs)
{
- GfxColorSpace *colorSpace;
+ std::unique_ptr<GfxColorSpace> colorSpace;
GfxColor color;
Object obj = res->lookupColorSpace(args[0].getName());
@@ -1447,9 +1444,9 @@
}
if (colorSpace) {
state->setFillPattern(nullptr);
- state->setFillColorSpace(colorSpace);
+ state->setFillColorSpace(std::move(colorSpace));
out->updateFillColorSpace(state);
- colorSpace->getDefaultColor(&color);
+ state->getFillColorSpace()->getDefaultColor(&color);
state->setFillColor(&color);
out->updateFillColor(state);
} else {
@@ -1459,7 +1456,7 @@
void Gfx::opSetStrokeColorSpace(Object args[], int numArgs)
{
- GfxColorSpace *colorSpace;
+ std::unique_ptr<GfxColorSpace> colorSpace;
GfxColor color;
state->setStrokePattern(nullptr);
@@ -1470,9 +1467,9 @@
colorSpace = GfxColorSpace::parse(res, &obj, out, state);
}
if (colorSpace) {
- state->setStrokeColorSpace(colorSpace);
+ state->setStrokeColorSpace(std::move(colorSpace));
out->updateStrokeColorSpace(state);
- colorSpace->getDefaultColor(&color);
+ state->getStrokeColorSpace()->getDefaultColor(&color);
state->setStrokeColor(&color);
out->updateStrokeColor(state);
} else {
@@ -1979,7 +1976,6 @@
void Gfx::doTilingPatternFill(GfxTilingPattern *tPat, bool stroke, bool eoFill, bool text)
{
GfxPatternColorSpace *patCS;
- GfxColorSpace *cs;
GfxColor color;
GfxState *savedState;
double xMin, yMin, xMax, yMax, x, y, x1, y1;
@@ -2048,7 +2044,8 @@
// Adobe's behavior
state->setFillPattern(nullptr);
state->setStrokePattern(nullptr);
- if (tPat->getPaintType() == 2 && (cs = patCS->getUnder())) {
+ if (tPat->getPaintType() == 2 && patCS->getUnder()) {
+ GfxColorSpace *cs = patCS->getUnder();
state->setFillColorSpace(cs->copy());
out->updateFillColorSpace(state);
state->setStrokeColorSpace(cs->copy());
@@ -2061,12 +2058,11 @@
out->updateFillColor(state);
out->updateStrokeColor(state);
} else {
- cs = new GfxDeviceGrayColorSpace();
- state->setFillColorSpace(cs);
- cs->getDefaultColor(&color);
+ state->setFillColorSpace(std::make_unique<GfxDeviceGrayColorSpace>());
+ state->getFillColorSpace()->getDefaultColor(&color);
state->setFillColor(&color);
out->updateFillColorSpace(state);
- state->setStrokeColorSpace(new GfxDeviceGrayColorSpace());
+ state->setStrokeColorSpace(std::make_unique<GfxDeviceGrayColorSpace>());
state->setStrokeColor(&color);
out->updateStrokeColorSpace(state);
}
@@ -4169,7 +4165,6 @@
StreamColorSpaceMode csMode;
bool mask;
bool invert;
- GfxColorSpace *colorSpace, *maskColorSpace;
bool haveColorKeyMask, haveExplicitMask, haveSoftMask;
int maskColors[2 * gfxColorMaxComps] = {};
int maskWidth, maskHeight;
@@ -4323,6 +4318,8 @@
obj1 = std::move(obj2);
}
}
+ std::unique_ptr<GfxColorSpace> colorSpace;
+
if (!obj1.isNull()) {
char *tempIntent = nullptr;
Object objIntent = dict->lookup("Intent");
@@ -4341,26 +4338,24 @@
} else if (csMode == streamCSDeviceGray) {
Object objCS = res->lookupColorSpace("DefaultGray");
if (objCS.isNull()) {
- colorSpace = new GfxDeviceGrayColorSpace();
+ colorSpace = std::make_unique<GfxDeviceGrayColorSpace>();
} else {
colorSpace = GfxColorSpace::parse(res, &objCS, out, state);
}
} else if (csMode == streamCSDeviceRGB) {
Object objCS = res->lookupColorSpace("DefaultRGB");
if (objCS.isNull()) {
- colorSpace = new GfxDeviceRGBColorSpace();
+ colorSpace = std::make_unique<GfxDeviceRGBColorSpace>();
} else {
colorSpace = GfxColorSpace::parse(res, &objCS, out, state);
}
} else if (csMode == streamCSDeviceCMYK) {
Object objCS = res->lookupColorSpace("DefaultCMYK");
if (objCS.isNull()) {
- colorSpace = new GfxDeviceCMYKColorSpace();
+ colorSpace = std::make_unique<GfxDeviceCMYKColorSpace>();
} else {
colorSpace = GfxColorSpace::parse(res, &objCS, out, state);
}
- } else {
- colorSpace = nullptr;
}
if (!colorSpace) {
goto err1;
@@ -4369,7 +4364,7 @@
if (obj1.isNull()) {
obj1 = dict->lookup("D");
}
- GfxImageColorMap colorMap(bits, &obj1, colorSpace);
+ GfxImageColorMap colorMap(bits, &obj1, std::move(colorSpace));
if (!colorMap.isOk()) {
goto err1;
}
@@ -4467,25 +4462,24 @@
if (!obj1.isName("DeviceGray") && !obj1.isName("G")) {
goto err1;
}
- maskColorSpace = new GfxDeviceGrayColorSpace();
obj1 = maskDict->lookup("Decode");
if (obj1.isNull()) {
obj1 = maskDict->lookup("D");
}
- maskColorMap = std::make_unique<GfxImageColorMap>(maskBits, &obj1, maskColorSpace);
+ maskColorMap = std::make_unique<GfxImageColorMap>(maskBits, &obj1, std::make_unique<GfxDeviceGrayColorSpace>());
if (!maskColorMap->isOk()) {
goto err1;
}
// handle the Matte entry
obj1 = maskDict->lookup("Matte");
if (obj1.isArray()) {
- if (obj1.getArray()->getLength() != colorSpace->getNComps()) {
- error(errSyntaxError, -1, "Matte entry should have {0:d} components but has {1:d}", colorSpace->getNComps(), obj1.getArray()->getLength());
+ if (obj1.getArray()->getLength() != colorMap.getColorSpace()->getNComps()) {
+ error(errSyntaxError, -1, "Matte entry should have {0:d} components but has {1:d}", colorMap.getColorSpace()->getNComps(), obj1.getArray()->getLength());
} else if (maskWidth != width || maskHeight != height) {
error(errSyntaxError, -1, "Softmask with matte entry {0:d} x {1:d} must have same geometry as the image {2:d} x {3:d}", maskWidth, maskHeight, width, height);
} else {
GfxColor matteColor;
- for (i = 0; i < colorSpace->getNComps(); i++) {
+ for (i = 0; i < colorMap.getColorSpace()->getNComps(); i++) {
Object obj2 = obj1.getArray()->get(i);
if (!obj2.isNum()) {
error(errSyntaxError, -1, "Matte entry {0:d} should be a number but it's of type {1:d}", i, obj2.getType());
@@ -4494,7 +4488,7 @@
}
matteColor.c[i] = dblToCol(obj2.getNum());
}
- if (i == colorSpace->getNComps()) {
+ if (i == colorMap.getColorSpace()->getNComps()) {
maskColorMap->setMatteColor(&matteColor);
}
}
@@ -4678,7 +4672,6 @@
{
Dict *dict;
bool transpGroup, isolated, knockout;
- GfxColorSpace *blendingColorSpace;
double m[6], bbox[4];
Dict *resDict;
bool ocSaved;
@@ -4748,7 +4741,7 @@
// check for a transparency group
transpGroup = isolated = knockout = false;
- blendingColorSpace = nullptr;
+ std::unique_ptr<GfxColorSpace> blendingColorSpace;
obj1 = dict->lookup("Group");
if (obj1.isDict()) {
Object obj2 = obj1.dictLookup("S");
@@ -4770,11 +4763,7 @@
}
// draw it
- drawForm(str, resDict, m, bbox, transpGroup, false, blendingColorSpace, isolated, knockout);
-
- if (blendingColorSpace) {
- delete blendingColorSpace;
- }
+ drawForm(str, resDict, m, bbox, transpGroup, false, blendingColorSpace.get(), isolated, knockout);
ocState = ocSaved;
}
@@ -5306,7 +5295,7 @@
if (border && border->getWidth() > 0 && (!aColor || aColor->getSpace() != AnnotColor::colorTransparent)) {
if (state->getStrokeColorSpace()->getMode() != csDeviceRGB) {
state->setStrokePattern(nullptr);
- state->setStrokeColorSpace(new GfxDeviceRGBColorSpace());
+ state->setStrokeColorSpace(std::make_unique<GfxDeviceRGBColorSpace>());
out->updateStrokeColorSpace(state);
}
double r, g, b;
diff --git a/poppler/GfxState.cc b/poppler/GfxState.cc
index cbb3fea..91544d9 100644
--- a/poppler/GfxState.cc
+++ b/poppler/GfxState.cc
@@ -16,7 +16,7 @@
// Copyright (C) 2005 Kristian Høgsberg <krh@redhat.com>
// Copyright (C) 2006, 2007 Jeff Muizelaar <jeff@infidigm.net>
// Copyright (C) 2006, 2010 Carlos Garcia Campos <carlosgc@gnome.org>
-// Copyright (C) 2006-2022 Albert Astals Cid <aacid@kde.org>
+// Copyright (C) 2006-2022, 2024 Albert Astals Cid <aacid@kde.org>
// Copyright (C) 2009, 2012 Koji Otani <sho@bbr.jp>
// Copyright (C) 2009, 2011-2016, 2020, 2023 Thomas Freitag <Thomas.Freitag@alfa.de>
// Copyright (C) 2009, 2019 Christian Persch <chpe@gnome.org>
@@ -219,53 +219,51 @@
GfxColorSpace::~GfxColorSpace() { }
-GfxColorSpace *GfxColorSpace::parse(GfxResources *res, Object *csObj, OutputDev *out, GfxState *state, int recursion)
+std::unique_ptr<GfxColorSpace> GfxColorSpace::parse(GfxResources *res, Object *csObj, OutputDev *out, GfxState *state, int recursion)
{
- GfxColorSpace *cs;
Object obj1;
if (recursion > colorSpaceRecursionLimit) {
error(errSyntaxError, -1, "Loop detected in color space objects");
- return nullptr;
+ return {};
}
- cs = nullptr;
if (csObj->isName()) {
if (csObj->isName("DeviceGray") || csObj->isName("G")) {
if (res != nullptr) {
Object objCS = res->lookupColorSpace("DefaultGray");
if (objCS.isNull()) {
- cs = state->copyDefaultGrayColorSpace();
+ return state->copyDefaultGrayColorSpace();
} else {
- cs = GfxColorSpace::parse(nullptr, &objCS, out, state);
+ return GfxColorSpace::parse(nullptr, &objCS, out, state);
}
} else {
- cs = state->copyDefaultGrayColorSpace();
+ return state->copyDefaultGrayColorSpace();
}
} else if (csObj->isName("DeviceRGB") || csObj->isName("RGB")) {
if (res != nullptr) {
Object objCS = res->lookupColorSpace("DefaultRGB");
if (objCS.isNull()) {
- cs = state->copyDefaultRGBColorSpace();
+ return state->copyDefaultRGBColorSpace();
} else {
- cs = GfxColorSpace::parse(nullptr, &objCS, out, state);
+ return GfxColorSpace::parse(nullptr, &objCS, out, state);
}
} else {
- cs = state->copyDefaultRGBColorSpace();
+ return state->copyDefaultRGBColorSpace();
}
} else if (csObj->isName("DeviceCMYK") || csObj->isName("CMYK")) {
if (res != nullptr) {
Object objCS = res->lookupColorSpace("DefaultCMYK");
if (objCS.isNull()) {
- cs = state->copyDefaultCMYKColorSpace();
+ return state->copyDefaultCMYKColorSpace();
} else {
- cs = GfxColorSpace::parse(nullptr, &objCS, out, state);
+ return GfxColorSpace::parse(nullptr, &objCS, out, state);
}
} else {
- cs = state->copyDefaultCMYKColorSpace();
+ return state->copyDefaultCMYKColorSpace();
}
} else if (csObj->isName("Pattern")) {
- cs = new GfxPatternColorSpace(nullptr);
+ return std::make_unique<GfxPatternColorSpace>(nullptr);
} else {
error(errSyntaxWarning, -1, "Bad color space '{0:s}'", csObj->getName());
}
@@ -275,51 +273,51 @@
if (res != nullptr) {
Object objCS = res->lookupColorSpace("DefaultGray");
if (objCS.isNull()) {
- cs = state->copyDefaultGrayColorSpace();
+ return state->copyDefaultGrayColorSpace();
} else {
- cs = GfxColorSpace::parse(nullptr, &objCS, out, state);
+ return GfxColorSpace::parse(nullptr, &objCS, out, state);
}
} else {
- cs = state->copyDefaultGrayColorSpace();
+ return state->copyDefaultGrayColorSpace();
}
} else if (obj1.isName("DeviceRGB") || obj1.isName("RGB")) {
if (res != nullptr) {
Object objCS = res->lookupColorSpace("DefaultRGB");
if (objCS.isNull()) {
- cs = state->copyDefaultRGBColorSpace();
+ return state->copyDefaultRGBColorSpace();
} else {
- cs = GfxColorSpace::parse(nullptr, &objCS, out, state);
+ return GfxColorSpace::parse(nullptr, &objCS, out, state);
}
} else {
- cs = state->copyDefaultRGBColorSpace();
+ return state->copyDefaultRGBColorSpace();
}
} else if (obj1.isName("DeviceCMYK") || obj1.isName("CMYK")) {
if (res != nullptr) {
Object objCS = res->lookupColorSpace("DefaultCMYK");
if (objCS.isNull()) {
- cs = state->copyDefaultCMYKColorSpace();
+ return state->copyDefaultCMYKColorSpace();
} else {
- cs = GfxColorSpace::parse(nullptr, &objCS, out, state);
+ return GfxColorSpace::parse(nullptr, &objCS, out, state);
}
} else {
- cs = state->copyDefaultCMYKColorSpace();
+ return state->copyDefaultCMYKColorSpace();
}
} else if (obj1.isName("CalGray")) {
- cs = GfxCalGrayColorSpace::parse(csObj->getArray(), state);
+ return GfxCalGrayColorSpace::parse(csObj->getArray(), state);
} else if (obj1.isName("CalRGB")) {
- cs = GfxCalRGBColorSpace::parse(csObj->getArray(), state);
+ return GfxCalRGBColorSpace::parse(csObj->getArray(), state);
} else if (obj1.isName("Lab")) {
- cs = GfxLabColorSpace::parse(csObj->getArray(), state);
+ return GfxLabColorSpace::parse(csObj->getArray(), state);
} else if (obj1.isName("ICCBased")) {
- cs = GfxICCBasedColorSpace::parse(csObj->getArray(), out, state, recursion);
+ return GfxICCBasedColorSpace::parse(csObj->getArray(), out, state, recursion);
} else if (obj1.isName("Indexed") || obj1.isName("I")) {
- cs = GfxIndexedColorSpace::parse(res, csObj->getArray(), out, state, recursion);
+ return GfxIndexedColorSpace::parse(res, csObj->getArray(), out, state, recursion);
} else if (obj1.isName("Separation")) {
- cs = GfxSeparationColorSpace::parse(res, csObj->getArray(), out, state, recursion);
+ return GfxSeparationColorSpace::parse(res, csObj->getArray(), out, state, recursion);
} else if (obj1.isName("DeviceN")) {
- cs = GfxDeviceNColorSpace::parse(res, csObj->getArray(), out, state, recursion);
+ return GfxDeviceNColorSpace::parse(res, csObj->getArray(), out, state, recursion);
} else if (obj1.isName("Pattern")) {
- cs = GfxPatternColorSpace::parse(res, csObj->getArray(), out, state, recursion);
+ return GfxPatternColorSpace::parse(res, csObj->getArray(), out, state, recursion);
} else {
error(errSyntaxWarning, -1, "Bad color space");
}
@@ -329,34 +327,34 @@
if (res != nullptr) {
Object objCS = res->lookupColorSpace("DefaultGray");
if (objCS.isNull()) {
- cs = state->copyDefaultGrayColorSpace();
+ return state->copyDefaultGrayColorSpace();
} else {
- cs = GfxColorSpace::parse(nullptr, &objCS, out, state);
+ return GfxColorSpace::parse(nullptr, &objCS, out, state);
}
} else {
- cs = state->copyDefaultGrayColorSpace();
+ return state->copyDefaultGrayColorSpace();
}
} else if (obj1.isName("DeviceRGB")) {
if (res != nullptr) {
Object objCS = res->lookupColorSpace("DefaultRGB");
if (objCS.isNull()) {
- cs = state->copyDefaultRGBColorSpace();
+ return state->copyDefaultRGBColorSpace();
} else {
- cs = GfxColorSpace::parse(nullptr, &objCS, out, state);
+ return GfxColorSpace::parse(nullptr, &objCS, out, state);
}
} else {
- cs = state->copyDefaultRGBColorSpace();
+ return state->copyDefaultRGBColorSpace();
}
} else if (obj1.isName("DeviceCMYK")) {
if (res != nullptr) {
Object objCS = res->lookupColorSpace("DefaultCMYK");
if (objCS.isNull()) {
- cs = state->copyDefaultCMYKColorSpace();
+ return state->copyDefaultCMYKColorSpace();
} else {
- cs = GfxColorSpace::parse(nullptr, &objCS, out, state);
+ return GfxColorSpace::parse(nullptr, &objCS, out, state);
}
} else {
- cs = state->copyDefaultCMYKColorSpace();
+ return state->copyDefaultCMYKColorSpace();
}
} else {
error(errSyntaxWarning, -1, "Bad color space dict'");
@@ -364,10 +362,10 @@
} else {
error(errSyntaxWarning, -1, "Bad color space - expected name or array or dict");
}
- return cs;
+ return {};
}
-void GfxColorSpace::createMapping(std::vector<GfxSeparationColorSpace *> *separationList, int maxSepComps)
+void GfxColorSpace::createMapping(std::vector<std::unique_ptr<GfxSeparationColorSpace>> *separationList, int maxSepComps)
{
return;
}
@@ -527,9 +525,9 @@
GfxDeviceGrayColorSpace::~GfxDeviceGrayColorSpace() { }
-GfxColorSpace *GfxDeviceGrayColorSpace::copy() const
+std::unique_ptr<GfxColorSpace> GfxDeviceGrayColorSpace::copy() const
{
- return new GfxDeviceGrayColorSpace();
+ return std::make_unique<GfxDeviceGrayColorSpace>();
}
void GfxDeviceGrayColorSpace::getGray(const GfxColor *color, GfxGray *gray) const
@@ -626,11 +624,9 @@
GfxCalGrayColorSpace::~GfxCalGrayColorSpace() { }
-GfxColorSpace *GfxCalGrayColorSpace::copy() const
+std::unique_ptr<GfxColorSpace> GfxCalGrayColorSpace::copy() const
{
- GfxCalGrayColorSpace *cs;
-
- cs = new GfxCalGrayColorSpace();
+ auto cs = std::make_unique<GfxCalGrayColorSpace>();
cs->whiteX = whiteX;
cs->whiteY = whiteY;
cs->whiteZ = whiteZ;
@@ -718,17 +714,16 @@
Z = -0.00802913 * rho_in + 0.04166125 * gamma_in + 1.05519788 * beta_in;
}
-GfxColorSpace *GfxCalGrayColorSpace::parse(Array *arr, GfxState *state)
+std::unique_ptr<GfxColorSpace> GfxCalGrayColorSpace::parse(Array *arr, GfxState *state)
{
- GfxCalGrayColorSpace *cs;
Object obj1, obj2;
obj1 = arr->get(1);
if (!obj1.isDict()) {
error(errSyntaxWarning, -1, "Bad CalGray color space");
- return nullptr;
+ return {};
}
- cs = new GfxCalGrayColorSpace();
+ auto cs = std::make_unique<GfxCalGrayColorSpace>();
obj2 = obj1.dictLookup("WhitePoint");
if (obj2.isArray() && obj2.arrayGetLength() == 3) {
cs->whiteX = obj2.arrayGet(0).getNumWithDefaultValue(1);
@@ -882,9 +877,9 @@
GfxDeviceRGBColorSpace::~GfxDeviceRGBColorSpace() { }
-GfxColorSpace *GfxDeviceRGBColorSpace::copy() const
+std::unique_ptr<GfxColorSpace> GfxDeviceRGBColorSpace::copy() const
{
- return new GfxDeviceRGBColorSpace();
+ return std::make_unique<GfxDeviceRGBColorSpace>();
}
void GfxDeviceRGBColorSpace::getGray(const GfxColor *color, GfxGray *gray) const
@@ -1045,12 +1040,11 @@
GfxCalRGBColorSpace::~GfxCalRGBColorSpace() { }
-GfxColorSpace *GfxCalRGBColorSpace::copy() const
+std::unique_ptr<GfxColorSpace> GfxCalRGBColorSpace::copy() const
{
- GfxCalRGBColorSpace *cs;
int i;
- cs = new GfxCalRGBColorSpace();
+ auto cs = std::make_unique<GfxCalRGBColorSpace>();
cs->whiteX = whiteX;
cs->whiteY = whiteY;
cs->whiteZ = whiteZ;
@@ -1069,18 +1063,17 @@
return cs;
}
-GfxColorSpace *GfxCalRGBColorSpace::parse(Array *arr, GfxState *state)
+std::unique_ptr<GfxColorSpace> GfxCalRGBColorSpace::parse(Array *arr, GfxState *state)
{
- GfxCalRGBColorSpace *cs;
Object obj1, obj2;
int i;
obj1 = arr->get(1);
if (!obj1.isDict()) {
error(errSyntaxWarning, -1, "Bad CalRGB color space");
- return nullptr;
+ return {};
}
- cs = new GfxCalRGBColorSpace();
+ auto cs = std::make_unique<GfxCalRGBColorSpace>();
obj2 = obj1.dictLookup("WhitePoint");
if (obj2.isArray() && obj2.arrayGetLength() == 3) {
cs->whiteX = obj2.arrayGet(0).getNumWithDefaultValue(1);
@@ -1252,9 +1245,9 @@
GfxDeviceCMYKColorSpace::~GfxDeviceCMYKColorSpace() { }
-GfxColorSpace *GfxDeviceCMYKColorSpace::copy() const
+std::unique_ptr<GfxColorSpace> GfxDeviceCMYKColorSpace::copy() const
{
- return new GfxDeviceCMYKColorSpace();
+ return std::make_unique<GfxDeviceCMYKColorSpace>();
}
void GfxDeviceCMYKColorSpace::getGray(const GfxColor *color, GfxGray *gray) const
@@ -1392,11 +1385,9 @@
GfxLabColorSpace::~GfxLabColorSpace() { }
-GfxColorSpace *GfxLabColorSpace::copy() const
+std::unique_ptr<GfxColorSpace> GfxLabColorSpace::copy() const
{
- GfxLabColorSpace *cs;
-
- cs = new GfxLabColorSpace();
+ auto cs = std::make_unique<GfxLabColorSpace>();
cs->whiteX = whiteX;
cs->whiteY = whiteY;
cs->whiteZ = whiteZ;
@@ -1413,17 +1404,16 @@
return cs;
}
-GfxColorSpace *GfxLabColorSpace::parse(Array *arr, GfxState *state)
+std::unique_ptr<GfxColorSpace> GfxLabColorSpace::parse(Array *arr, GfxState *state)
{
- GfxLabColorSpace *cs;
Object obj1, obj2;
obj1 = arr->get(1);
if (!obj1.isDict()) {
error(errSyntaxWarning, -1, "Bad Lab color space");
- return nullptr;
+ return {};
}
- cs = new GfxLabColorSpace();
+ auto cs = std::make_unique<GfxLabColorSpace>();
bool ok = true;
obj2 = obj1.dictLookup("WhitePoint");
if (obj2.isArray() && obj2.arrayGetLength() == 3) {
@@ -1450,8 +1440,7 @@
#ifdef USE_CMS
cs->transform = nullptr;
#endif
- delete cs;
- return nullptr;
+ return {};
}
#ifdef USE_CMS
@@ -1648,10 +1637,9 @@
// GfxICCBasedColorSpace
//------------------------------------------------------------------------
-GfxICCBasedColorSpace::GfxICCBasedColorSpace(int nCompsA, GfxColorSpace *altA, const Ref *iccProfileStreamA)
+GfxICCBasedColorSpace::GfxICCBasedColorSpace(int nCompsA, std::unique_ptr<GfxColorSpace> &&altA, const Ref *iccProfileStreamA) : alt(std::move(altA))
{
nComps = nCompsA;
- alt = altA;
iccProfileStream = *iccProfileStreamA;
rangeMin[0] = rangeMin[1] = rangeMin[2] = rangeMin[3] = 0;
rangeMax[0] = rangeMax[1] = rangeMax[2] = rangeMax[3] = 1;
@@ -1664,7 +1652,6 @@
GfxICCBasedColorSpace::~GfxICCBasedColorSpace()
{
- delete alt;
#ifdef USE_CMS
if (psCSA) {
gfree(psCSA);
@@ -1672,12 +1659,16 @@
#endif
}
-GfxColorSpace *GfxICCBasedColorSpace::copy() const
+std::unique_ptr<GfxColorSpace> GfxICCBasedColorSpace::copy() const
{
- GfxICCBasedColorSpace *cs;
+ return copyAsOwnType();
+}
+
+std::unique_ptr<GfxICCBasedColorSpace> GfxICCBasedColorSpace::copyAsOwnType() const
+{
int i;
- cs = new GfxICCBasedColorSpace(nComps, alt->copy(), &iccProfileStream);
+ auto cs = std::make_unique<GfxICCBasedColorSpace>(nComps, alt->copy(), &iccProfileStream);
for (i = 0; i < 4; ++i) {
cs->rangeMin[i] = rangeMin[i];
cs->rangeMax[i] = rangeMax[i];
@@ -1690,18 +1681,16 @@
return cs;
}
-GfxColorSpace *GfxICCBasedColorSpace::parse(Array *arr, OutputDev *out, GfxState *state, int recursion)
+std::unique_ptr<GfxColorSpace> GfxICCBasedColorSpace::parse(Array *arr, OutputDev *out, GfxState *state, int recursion)
{
- GfxICCBasedColorSpace *cs;
int nCompsA;
- GfxColorSpace *altA;
Dict *dict;
Object obj1, obj2;
int i;
if (arr->getLength() < 2) {
error(errSyntaxError, -1, "Bad ICCBased color space");
- return nullptr;
+ return {};
}
const Object &obj1Ref = arr->getNF(1);
const Ref iccProfileStreamA = obj1Ref.isRef() ? obj1Ref.getRef() : Ref::INVALID();
@@ -1709,7 +1698,7 @@
// check cache
if (out && iccProfileStreamA != Ref::INVALID()) {
if (auto *item = out->getIccColorSpaceCache()->lookup(iccProfileStreamA)) {
- cs = static_cast<GfxICCBasedColorSpace *>(item->copy());
+ std::unique_ptr<GfxICCBasedColorSpace> cs = item->copyAsOwnType();
int transformIntent = cs->getIntent();
int cmsIntent = INTENT_RELATIVE_COLORIMETRIC;
if (state != nullptr) {
@@ -1718,7 +1707,6 @@
if (transformIntent == cmsIntent) {
return cs;
}
- delete cs;
}
}
#endif
@@ -1739,16 +1727,17 @@
nCompsA = 4;
}
obj2 = dict->lookup("Alternate");
+ std::unique_ptr<GfxColorSpace> altA;
if (obj2.isNull() || !(altA = GfxColorSpace::parse(nullptr, &obj2, out, state, recursion + 1))) {
switch (nCompsA) {
case 1:
- altA = new GfxDeviceGrayColorSpace();
+ altA = std::make_unique<GfxDeviceGrayColorSpace>();
break;
case 3:
- altA = new GfxDeviceRGBColorSpace();
+ altA = std::make_unique<GfxDeviceRGBColorSpace>();
break;
case 4:
- altA = new GfxDeviceCMYKColorSpace();
+ altA = std::make_unique<GfxDeviceCMYKColorSpace>();
break;
default:
error(errSyntaxWarning, -1, "Bad ICCBased color space - invalid N");
@@ -1757,10 +1746,9 @@
}
if (altA->getNComps() != nCompsA) {
error(errSyntaxWarning, -1, "Bad ICCBased color space - N doesn't match alt color space");
- delete altA;
- return nullptr;
+ return {};
}
- cs = new GfxICCBasedColorSpace(nCompsA, altA, &iccProfileStreamA);
+ auto cs = std::make_unique<GfxICCBasedColorSpace>(nCompsA, std::move(altA), &iccProfileStreamA);
obj2 = dict->lookup("Range");
if (obj2.isArray() && obj2.arrayGetLength() == 2 * nCompsA) {
for (i = 0; i < nCompsA; ++i) {
@@ -1773,8 +1761,7 @@
obj1 = arr->get(1);
if (!obj1.isStream()) {
error(errSyntaxWarning, -1, "Bad ICCBased color space (stream)");
- delete cs;
- return nullptr;
+ return {};
}
Stream *iccStream = obj1.getStream();
@@ -1788,7 +1775,7 @@
}
// put this colorSpace into cache
if (out && iccProfileStreamA != Ref::INVALID()) {
- out->getIccColorSpaceCache()->put(iccProfileStreamA, static_cast<GfxICCBasedColorSpace *>(cs->copy()));
+ out->getIccColorSpaceCache()->put(iccProfileStreamA, cs->copyAsOwnType());
}
#endif
return cs;
@@ -2339,9 +2326,8 @@
// GfxIndexedColorSpace
//------------------------------------------------------------------------
-GfxIndexedColorSpace::GfxIndexedColorSpace(GfxColorSpace *baseA, int indexHighA)
+GfxIndexedColorSpace::GfxIndexedColorSpace(std::unique_ptr<GfxColorSpace> &&baseA, int indexHighA) : base(std::move(baseA))
{
- base = baseA;
indexHigh = indexHighA;
lookup = (unsigned char *)gmallocn((indexHigh + 1) * base->getNComps(), sizeof(unsigned char));
overprintMask = base->getOverprintMask();
@@ -2349,22 +2335,20 @@
GfxIndexedColorSpace::~GfxIndexedColorSpace()
{
- delete base;
gfree(lookup);
}
-GfxColorSpace *GfxIndexedColorSpace::copy() const
+std::unique_ptr<GfxColorSpace> GfxIndexedColorSpace::copy() const
{
- GfxIndexedColorSpace *cs;
- cs = new GfxIndexedColorSpace(base->copy(), indexHigh);
+ auto cs = std::make_unique<GfxIndexedColorSpace>(base->copy(), indexHigh);
memcpy(cs->lookup, lookup, (indexHigh + 1) * base->getNComps() * sizeof(unsigned char));
return cs;
}
-GfxColorSpace *GfxIndexedColorSpace::parse(GfxResources *res, Array *arr, OutputDev *out, GfxState *state, int recursion)
+std::unique_ptr<GfxColorSpace> GfxIndexedColorSpace::parse(GfxResources *res, Array *arr, OutputDev *out, GfxState *state, int recursion)
{
- GfxColorSpace *baseA;
+ std::unique_ptr<GfxColorSpace> baseA;
int indexHighA;
Object obj1;
const char *s;
@@ -2377,13 +2361,12 @@
obj1 = arr->get(1);
if (!(baseA = GfxColorSpace::parse(res, &obj1, out, state, recursion + 1))) {
error(errSyntaxWarning, -1, "Bad Indexed color space (base color space)");
- return nullptr;
+ return {};
}
obj1 = arr->get(2);
if (!obj1.isInt()) {
error(errSyntaxWarning, -1, "Bad Indexed color space (hival)");
- delete baseA;
- return nullptr;
+ return {};
}
indexHighA = obj1.getInt();
if (indexHighA < 0 || indexHighA > 255) {
@@ -2399,9 +2382,9 @@
}
error(errSyntaxWarning, -1, "Bad Indexed color space (invalid indexHigh value, was {0:d} using {1:d} to try to recover)", previousValue, indexHighA);
}
- GfxIndexedColorSpace *cs = new GfxIndexedColorSpace(baseA, indexHighA);
+ auto cs = std::make_unique<GfxIndexedColorSpace>(std::move(baseA), indexHighA);
obj1 = arr->get(3);
- const int n = baseA->getNComps();
+ const int n = cs->getBase()->getNComps();
if (obj1.isStream()) {
obj1.streamReset();
for (i = 0; i <= indexHighA; ++i) {
@@ -2430,8 +2413,7 @@
return cs;
err3:
- delete cs;
- return nullptr;
+ return {};
}
GfxColor *GfxIndexedColorSpace::mapColorToBase(const GfxColor *color, GfxColor *baseColor) const
@@ -2589,10 +2571,9 @@
// GfxSeparationColorSpace
//------------------------------------------------------------------------
-GfxSeparationColorSpace::GfxSeparationColorSpace(GooString *nameA, GfxColorSpace *altA, Function *funcA)
+GfxSeparationColorSpace::GfxSeparationColorSpace(GooString *nameA, std::unique_ptr<GfxColorSpace> &&altA, Function *funcA) : alt(std::move(altA))
{
name = nameA;
- alt = altA;
func = funcA;
nonMarking = !name->cmp("None");
if (!name->cmp("Cyan")) {
@@ -2608,10 +2589,9 @@
}
}
-GfxSeparationColorSpace::GfxSeparationColorSpace(GooString *nameA, GfxColorSpace *altA, Function *funcA, bool nonMarkingA, unsigned int overprintMaskA, int *mappingA)
+GfxSeparationColorSpace::GfxSeparationColorSpace(GooString *nameA, std::unique_ptr<GfxColorSpace> &&altA, Function *funcA, bool nonMarkingA, unsigned int overprintMaskA, int *mappingA) : alt(std::move(altA))
{
name = nameA;
- alt = altA;
func = funcA;
nonMarking = nonMarkingA;
overprintMask = overprintMaskA;
@@ -2621,28 +2601,33 @@
GfxSeparationColorSpace::~GfxSeparationColorSpace()
{
delete name;
- delete alt;
delete func;
if (mapping != nullptr) {
gfree(mapping);
}
}
-GfxColorSpace *GfxSeparationColorSpace::copy() const
+std::unique_ptr<GfxColorSpace> GfxSeparationColorSpace::copy() const
+{
+ return copyAsOwnType();
+}
+
+std::unique_ptr<GfxSeparationColorSpace> GfxSeparationColorSpace::copyAsOwnType() const
{
int *mappingA = nullptr;
if (mapping != nullptr) {
mappingA = (int *)gmalloc(sizeof(int));
*mappingA = *mapping;
}
- return new GfxSeparationColorSpace(name->copy(), alt->copy(), func->copy(), nonMarking, overprintMask, mappingA);
+ auto cs = new GfxSeparationColorSpace(name->copy(), alt->copy(), func->copy(), nonMarking, overprintMask, mappingA);
+ return std::unique_ptr<GfxSeparationColorSpace>(cs);
}
//~ handle the 'All' and 'None' colorants
-GfxColorSpace *GfxSeparationColorSpace::parse(GfxResources *res, Array *arr, OutputDev *out, GfxState *state, int recursion)
+std::unique_ptr<GfxColorSpace> GfxSeparationColorSpace::parse(GfxResources *res, Array *arr, OutputDev *out, GfxState *state, int recursion)
{
GooString *nameA;
- GfxColorSpace *altA;
+ std::unique_ptr<GfxColorSpace> altA;
Function *funcA;
Object obj1;
@@ -2663,24 +2648,22 @@
}
obj1 = arr->get(3);
if (!(funcA = Function::parse(&obj1))) {
- goto err4;
+ goto err3;
}
if (funcA->getInputSize() != 1) {
error(errSyntaxWarning, -1, "Bad SeparationColorSpace function");
goto err5;
}
if (altA->getNComps() <= funcA->getOutputSize()) {
- return new GfxSeparationColorSpace(nameA, altA, funcA);
+ return std::make_unique<GfxSeparationColorSpace>(nameA, std::move(altA), funcA);
}
err5:
delete funcA;
-err4:
- delete altA;
err3:
delete nameA;
err1:
- return nullptr;
+ return {};
}
void GfxSeparationColorSpace::getGray(const GfxColor *color, GfxGray *gray) const
@@ -2782,7 +2765,7 @@
color->c[0] = gfxColorComp1;
}
-void GfxSeparationColorSpace::createMapping(std::vector<GfxSeparationColorSpace *> *separationList, int maxSepComps)
+void GfxSeparationColorSpace::createMapping(std::vector<std::unique_ptr<GfxSeparationColorSpace>> *separationList, int maxSepComps)
{
if (nonMarking) {
return;
@@ -2804,7 +2787,7 @@
default:
unsigned int newOverprintMask = 0x10;
for (std::size_t i = 0; i < separationList->size(); i++) {
- GfxSeparationColorSpace *sepCS = (*separationList)[i];
+ const std::unique_ptr<GfxSeparationColorSpace> &sepCS = (*separationList)[i];
if (!sepCS->getName()->cmp(name)) {
if (sepCS->getFunc()->hasDifferentResultSet(func)) {
error(errSyntaxWarning, -1, "Different functions found for '{0:t}', convert immediately", name);
@@ -2825,7 +2808,7 @@
return;
}
*mapping = separationList->size() + 4;
- separationList->push_back((GfxSeparationColorSpace *)copy());
+ separationList->push_back(copyAsOwnType());
overprintMask = newOverprintMask;
break;
}
@@ -2835,9 +2818,9 @@
// GfxDeviceNColorSpace
//------------------------------------------------------------------------
-GfxDeviceNColorSpace::GfxDeviceNColorSpace(int nCompsA, std::vector<std::string> &&namesA, GfxColorSpace *altA, Function *funcA, std::vector<GfxSeparationColorSpace *> *sepsCSA) : nComps(nCompsA), names(std::move(namesA))
+GfxDeviceNColorSpace::GfxDeviceNColorSpace(int nCompsA, std::vector<std::string> &&namesA, std::unique_ptr<GfxColorSpace> &&altA, Function *funcA, std::vector<std::unique_ptr<GfxSeparationColorSpace>> *sepsCSA)
+ : nComps(nCompsA), names(std::move(namesA)), alt(std::move(altA))
{
- alt = altA;
func = funcA;
sepsCS = sepsCSA;
nonMarking = true;
@@ -2863,11 +2846,10 @@
}
}
-GfxDeviceNColorSpace::GfxDeviceNColorSpace(int nCompsA, const std::vector<std::string> &namesA, GfxColorSpace *altA, Function *funcA, std::vector<GfxSeparationColorSpace *> *sepsCSA, int *mappingA, bool nonMarkingA,
- unsigned int overprintMaskA)
- : nComps(nCompsA), names(namesA)
+GfxDeviceNColorSpace::GfxDeviceNColorSpace(int nCompsA, const std::vector<std::string> &namesA, std::unique_ptr<GfxColorSpace> &&altA, Function *funcA, std::vector<std::unique_ptr<GfxSeparationColorSpace>> *sepsCSA, int *mappingA,
+ bool nonMarkingA, unsigned int overprintMaskA)
+ : nComps(nCompsA), names(namesA), alt(std::move(altA))
{
- alt = altA;
func = funcA;
sepsCS = sepsCSA;
mapping = mappingA;
@@ -2877,26 +2859,22 @@
GfxDeviceNColorSpace::~GfxDeviceNColorSpace()
{
- delete alt;
delete func;
- for (auto entry : *sepsCS) {
- delete entry;
- }
delete sepsCS;
if (mapping != nullptr) {
gfree(mapping);
}
}
-GfxColorSpace *GfxDeviceNColorSpace::copy() const
+std::unique_ptr<GfxColorSpace> GfxDeviceNColorSpace::copy() const
{
int *mappingA = nullptr;
- auto sepsCSA = new std::vector<GfxSeparationColorSpace *>();
+ auto sepsCSA = new std::vector<std::unique_ptr<GfxSeparationColorSpace>>();
sepsCSA->reserve(sepsCS->size());
- for (const GfxSeparationColorSpace *scs : *sepsCS) {
+ for (const std::unique_ptr<GfxSeparationColorSpace> &scs : *sepsCS) {
if (likely(scs != nullptr)) {
- sepsCSA->push_back((GfxSeparationColorSpace *)scs->copy());
+ sepsCSA->push_back(scs->copyAsOwnType());
}
}
if (mapping != nullptr) {
@@ -2905,18 +2883,19 @@
mappingA[i] = mapping[i];
}
}
- return new GfxDeviceNColorSpace(nComps, names, alt->copy(), func->copy(), sepsCSA, mappingA, nonMarking, overprintMask);
+ auto cs = new GfxDeviceNColorSpace(nComps, names, alt->copy(), func->copy(), sepsCSA, mappingA, nonMarking, overprintMask);
+ return std::unique_ptr<GfxDeviceNColorSpace>(cs);
}
//~ handle the 'None' colorant
-GfxColorSpace *GfxDeviceNColorSpace::parse(GfxResources *res, Array *arr, OutputDev *out, GfxState *state, int recursion)
+std::unique_ptr<GfxColorSpace> GfxDeviceNColorSpace::parse(GfxResources *res, Array *arr, OutputDev *out, GfxState *state, int recursion)
{
int nCompsA;
std::vector<std::string> namesA;
- GfxColorSpace *altA;
+ std::unique_ptr<GfxColorSpace> altA;
Function *funcA;
Object obj1;
- auto separationList = new std::vector<GfxSeparationColorSpace *>();
+ auto separationList = new std::vector<std::unique_ptr<GfxSeparationColorSpace>>();
if (arr->getLength() != 4 && arr->getLength() != 5) {
error(errSyntaxWarning, -1, "Bad DeviceN color space");
@@ -2948,7 +2927,7 @@
}
obj1 = arr->get(3);
if (!(funcA = Function::parse(&obj1))) {
- goto err4;
+ goto err1;
}
if (arr->getLength() == 5) {
obj1 = arr->get(4);
@@ -2963,9 +2942,9 @@
for (int i = 0; i < colorants->getLength(); i++) {
Object obj3 = colorants->getVal(i);
if (obj3.isArray()) {
- GfxSeparationColorSpace *cs = (GfxSeparationColorSpace *)GfxSeparationColorSpace::parse(res, obj3.getArray(), out, state, recursion);
+ auto cs = GfxSeparationColorSpace::parse(res, obj3.getArray(), out, state, recursion);
if (cs) {
- separationList->push_back(cs);
+ separationList->push_back(std::unique_ptr<GfxSeparationColorSpace>(static_cast<GfxSeparationColorSpace *>(cs.release())));
}
} else {
error(errSyntaxWarning, -1, "Bad DeviceN color space (colorant value entry is not an Array)");
@@ -2976,13 +2955,11 @@
}
if (likely(nCompsA >= funcA->getInputSize() && altA->getNComps() <= funcA->getOutputSize())) {
- return new GfxDeviceNColorSpace(nCompsA, std::move(namesA), altA, funcA, separationList);
+ return std::make_unique<GfxDeviceNColorSpace>(nCompsA, std::move(namesA), std::move(altA), funcA, separationList);
}
err5:
delete funcA;
-err4:
- delete altA;
err1:
delete separationList;
return nullptr;
@@ -3065,7 +3042,7 @@
}
}
-void GfxDeviceNColorSpace::createMapping(std::vector<GfxSeparationColorSpace *> *separationList, int maxSepComps)
+void GfxDeviceNColorSpace::createMapping(std::vector<std::unique_ptr<GfxSeparationColorSpace>> *separationList, int maxSepComps)
{
if (nonMarking) { // None
return;
@@ -3094,7 +3071,7 @@
if (nComps == 1) {
sepFunc = func;
} else {
- for (const GfxSeparationColorSpace *sepCS : *sepsCS) {
+ for (const std::unique_ptr<GfxSeparationColorSpace> &sepCS : *sepsCS) {
if (!sepCS->getName()->cmp(names[i])) {
sepFunc = sepCS->getFunc();
break;
@@ -3102,7 +3079,7 @@
}
}
for (std::size_t j = 0; j < separationList->size(); j++) {
- GfxSeparationColorSpace *sepCS = (*separationList)[j];
+ const std::unique_ptr<GfxSeparationColorSpace> &sepCS = (*separationList)[j];
if (!sepCS->getName()->cmp(names[i])) {
if (sepFunc != nullptr && sepCS->getFunc()->hasDifferentResultSet(sepFunc)) {
error(errSyntaxWarning, -1, "Different functions found for '{0:s}', convert immediately", names[i].c_str());
@@ -3129,12 +3106,12 @@
mapping[i] = separationList->size() + 4;
newOverprintMask |= startOverprintMask;
if (nComps == 1) {
- separationList->push_back(new GfxSeparationColorSpace(new GooString(names[i]), alt->copy(), func->copy()));
+ separationList->push_back(std::make_unique<GfxSeparationColorSpace>(new GooString(names[i]), alt->copy(), func->copy()));
} else {
- for (const GfxSeparationColorSpace *sepCS : *sepsCS) {
+ for (const std::unique_ptr<GfxSeparationColorSpace> &sepCS : *sepsCS) {
if (!sepCS->getName()->cmp(names[i])) {
found = true;
- separationList->push_back((GfxSeparationColorSpace *)sepCS->copy());
+ separationList->push_back(sepCS->copyAsOwnType());
break;
}
}
@@ -3156,43 +3133,32 @@
// GfxPatternColorSpace
//------------------------------------------------------------------------
-GfxPatternColorSpace::GfxPatternColorSpace(GfxColorSpace *underA)
+GfxPatternColorSpace::GfxPatternColorSpace(std::unique_ptr<GfxColorSpace> &&underA) : under(std::move(underA)) { }
+
+GfxPatternColorSpace::~GfxPatternColorSpace() { }
+
+std::unique_ptr<GfxColorSpace> GfxPatternColorSpace::copy() const
{
- under = underA;
+ return std::make_unique<GfxPatternColorSpace>(under ? under->copy() : nullptr);
}
-GfxPatternColorSpace::~GfxPatternColorSpace()
+std::unique_ptr<GfxColorSpace> GfxPatternColorSpace::parse(GfxResources *res, Array *arr, OutputDev *out, GfxState *state, int recursion)
{
- if (under) {
- delete under;
- }
-}
-
-GfxColorSpace *GfxPatternColorSpace::copy() const
-{
- return new GfxPatternColorSpace(under ? under->copy() : nullptr);
-}
-
-GfxColorSpace *GfxPatternColorSpace::parse(GfxResources *res, Array *arr, OutputDev *out, GfxState *state, int recursion)
-{
- GfxPatternColorSpace *cs;
- GfxColorSpace *underA;
Object obj1;
if (arr->getLength() != 1 && arr->getLength() != 2) {
error(errSyntaxWarning, -1, "Bad Pattern color space");
- return nullptr;
+ return {};
}
- underA = nullptr;
+ std::unique_ptr<GfxColorSpace> underA;
if (arr->getLength() == 2) {
obj1 = arr->get(1);
if (!(underA = GfxColorSpace::parse(res, &obj1, out, state, recursion + 1))) {
error(errSyntaxWarning, -1, "Bad Pattern color space (underlying color space)");
- return nullptr;
+ return {};
}
}
- cs = new GfxPatternColorSpace(underA);
- return cs;
+ return std::make_unique<GfxPatternColorSpace>(std::move(underA));
}
void GfxPatternColorSpace::getGray(const GfxColor *color, GfxGray *gray) const
@@ -3429,7 +3395,6 @@
GfxShading::GfxShading(int typeA)
{
type = static_cast<ShadingType>(typeA);
- colorSpace = nullptr;
}
GfxShading::GfxShading(const GfxShading *shading)
@@ -3449,12 +3414,7 @@
hasBBox = shading->hasBBox;
}
-GfxShading::~GfxShading()
-{
- if (colorSpace) {
- delete colorSpace;
- }
-}
+GfxShading::~GfxShading() = default;
GfxShading *GfxShading::parse(GfxResources *res, Object *obj, OutputDev *out, GfxState *state)
{
@@ -5570,10 +5530,8 @@
// GfxImageColorMap
//------------------------------------------------------------------------
-GfxImageColorMap::GfxImageColorMap(int bitsA, Object *decode, GfxColorSpace *colorSpaceA)
+GfxImageColorMap::GfxImageColorMap(int bitsA, Object *decode, std::unique_ptr<GfxColorSpace> &&colorSpaceA) : colorSpace(std::move(colorSpaceA))
{
- GfxIndexedColorSpace *indexedCS;
- GfxSeparationColorSpace *sepCS;
int maxPixel, indexHigh;
unsigned char *indexedLookup;
const Function *sepFunc;
@@ -5586,8 +5544,6 @@
ok = true;
useMatte = false;
- colorSpace = colorSpaceA;
-
// initialize
for (k = 0; k < gfxColorMaxComps; ++k) {
lookup[k] = nullptr;
@@ -5657,11 +5613,11 @@
nComps2 = 0;
useByteLookup = false;
switch (colorSpace->getMode()) {
- case csIndexed:
+ case csIndexed: {
// Note that indexHigh may not be the same as maxPixel --
// Distiller will remove unused palette entries, resulting in
// indexHigh < maxPixel.
- indexedCS = (GfxIndexedColorSpace *)colorSpace;
+ GfxIndexedColorSpace *indexedCS = (GfxIndexedColorSpace *)colorSpace.get();
colorSpace2 = indexedCS->getBase();
indexHigh = indexedCS->getIndexHigh();
nComps2 = colorSpace2->getNComps();
@@ -5689,8 +5645,9 @@
}
}
break;
- case csSeparation:
- sepCS = (GfxSeparationColorSpace *)colorSpace;
+ }
+ case csSeparation: {
+ GfxSeparationColorSpace *sepCS = (GfxSeparationColorSpace *)colorSpace.get();
colorSpace2 = sepCS->getAlt();
nComps2 = colorSpace2->getNComps();
sepFunc = sepCS->getFunc();
@@ -5710,6 +5667,7 @@
}
}
break;
+ }
default:
if ((!decode->isNull() || maxPixel != 255) && (colorSpace->useGetGrayLine() || (colorSpace->useGetRGBLine() && !decode->isNull()) || colorSpace->useGetCMYKLine() || colorSpace->useGetDeviceNLine())) {
byte_lookup = (unsigned char *)gmallocn((maxPixel + 1), nComps);
@@ -5763,13 +5721,13 @@
memcpy(lookup[k], colorMap->lookup[k], n * sizeof(GfxColorComp));
}
if (colorSpace->getMode() == csIndexed) {
- colorSpace2 = ((GfxIndexedColorSpace *)colorSpace)->getBase();
+ colorSpace2 = ((GfxIndexedColorSpace *)colorSpace.get())->getBase();
for (k = 0; k < nComps2; ++k) {
lookup2[k] = (GfxColorComp *)gmallocn(n, sizeof(GfxColorComp));
memcpy(lookup2[k], colorMap->lookup2[k], n * sizeof(GfxColorComp));
}
} else if (colorSpace->getMode() == csSeparation) {
- colorSpace2 = ((GfxSeparationColorSpace *)colorSpace)->getAlt();
+ colorSpace2 = ((GfxSeparationColorSpace *)colorSpace.get())->getAlt();
for (k = 0; k < nComps2; ++k) {
lookup2[k] = (GfxColorComp *)gmallocn(n, sizeof(GfxColorComp));
memcpy(lookup2[k], colorMap->lookup2[k], n * sizeof(GfxColorComp));
@@ -5797,7 +5755,6 @@
{
int i;
- delete colorSpace;
for (i = 0; i < gfxColorMaxComps; ++i) {
gfree(lookup[i]);
gfree(lookup2[i]);
@@ -6490,8 +6447,8 @@
pageHeight = ky * (py2 - py1);
}
- fillColorSpace = new GfxDeviceGrayColorSpace();
- strokeColorSpace = new GfxDeviceGrayColorSpace();
+ fillColorSpace = std::make_unique<GfxDeviceGrayColorSpace>();
+ strokeColorSpace = std::make_unique<GfxDeviceGrayColorSpace>();
fillColor.c[0] = 0;
strokeColor.c[0] = 0;
fillPattern = nullptr;
@@ -6569,18 +6526,6 @@
{
int i;
- if (fillColorSpace) {
- delete fillColorSpace;
- }
- if (strokeColorSpace) {
- delete strokeColorSpace;
- }
- if (fillPattern) {
- delete fillPattern;
- }
- if (strokePattern) {
- delete strokePattern;
- }
for (i = 0; i < 4; ++i) {
if (transfer[i]) {
delete transfer[i];
@@ -6590,10 +6535,6 @@
// this gets set to NULL by restore()
delete path;
}
-
- delete defaultGrayColorSpace;
- delete defaultRGBColorSpace;
- delete defaultCMYKColorSpace;
}
// Used for copy();
@@ -6612,12 +6553,10 @@
pageHeight = state->pageHeight;
rotate = state->rotate;
- fillColorSpace = state->fillColorSpace;
- if (fillColorSpace) {
+ if (state->fillColorSpace) {
fillColorSpace = state->fillColorSpace->copy();
}
- strokeColorSpace = state->strokeColorSpace;
- if (strokeColorSpace) {
+ if (state->strokeColorSpace) {
strokeColorSpace = state->strokeColorSpace->copy();
}
fillColor = state->fillColor;
@@ -6916,20 +6855,14 @@
clipYMax += ty;
}
-void GfxState::setFillColorSpace(GfxColorSpace *colorSpace)
+void GfxState::setFillColorSpace(std::unique_ptr<GfxColorSpace> &&colorSpace)
{
- if (fillColorSpace) {
- delete fillColorSpace;
- }
- fillColorSpace = colorSpace;
+ fillColorSpace = std::move(colorSpace);
}
-void GfxState::setStrokeColorSpace(GfxColorSpace *colorSpace)
+void GfxState::setStrokeColorSpace(std::unique_ptr<GfxColorSpace> &&colorSpace)
{
- if (strokeColorSpace) {
- delete strokeColorSpace;
- }
- strokeColorSpace = colorSpace;
+ strokeColorSpace = std::move(colorSpace);
}
void GfxState::setFillPattern(GfxPattern *pattern)
diff --git a/poppler/GfxState.h b/poppler/GfxState.h
index 8ff98ec..4bf2b8f 100644
--- a/poppler/GfxState.h
+++ b/poppler/GfxState.h
@@ -17,7 +17,7 @@
// Copyright (C) 2006, 2007 Jeff Muizelaar <jeff@infidigm.net>
// Copyright (C) 2006 Carlos Garcia Campos <carlosgc@gnome.org>
// Copyright (C) 2009 Koji Otani <sho@bbr.jp>
-// Copyright (C) 2009-2011, 2013, 2016-2022 Albert Astals Cid <aacid@kde.org>
+// Copyright (C) 2009-2011, 2013, 2016-2022, 2024 Albert Astals Cid <aacid@kde.org>
// Copyright (C) 2010 Christian Feuersänger <cfeuersaenger@googlemail.com>
// Copyright (C) 2011 Andrea Canciani <ranma42@gmail.com>
// Copyright (C) 2011-2014, 2016, 2020 Thomas Freitag <Thomas.Freitag@alfa.de>
@@ -255,11 +255,11 @@
GfxColorSpace(const GfxColorSpace &) = delete;
GfxColorSpace &operator=(const GfxColorSpace &other) = delete;
- virtual GfxColorSpace *copy() const = 0;
+ virtual std::unique_ptr<GfxColorSpace> copy() const = 0;
virtual GfxColorSpaceMode getMode() const = 0;
// Construct a color space. Returns nullptr if unsuccessful.
- static GfxColorSpace *parse(GfxResources *res, Object *csObj, OutputDev *out, GfxState *state, int recursion = 0);
+ static std::unique_ptr<GfxColorSpace> parse(GfxResources *res, Object *csObj, OutputDev *out, GfxState *state, int recursion = 0);
// Convert to gray, RGB, or CMYK.
virtual void getGray(const GfxColor *color, GfxGray *gray) const = 0;
@@ -274,7 +274,7 @@
virtual void getDeviceNLine(unsigned char * /*in*/, unsigned char * /*out*/, int /*length*/) { error(errInternal, -1, "GfxColorSpace::getDeviceNLine this should not happen"); }
// create mapping for spot colorants
- virtual void createMapping(std::vector<GfxSeparationColorSpace *> *separationList, int maxSepComps);
+ virtual void createMapping(std::vector<std::unique_ptr<GfxSeparationColorSpace>> *separationList, int maxSepComps);
int *getMapping() const { return mapping; }
// Does this ColorSpace support getRGBLine?
@@ -323,7 +323,7 @@
public:
GfxDeviceGrayColorSpace();
~GfxDeviceGrayColorSpace() override;
- GfxColorSpace *copy() const override;
+ std::unique_ptr<GfxColorSpace> copy() const override;
GfxColorSpaceMode getMode() const override { return csDeviceGray; }
void getGray(const GfxColor *color, GfxGray *gray) const override;
@@ -357,11 +357,11 @@
public:
GfxCalGrayColorSpace();
~GfxCalGrayColorSpace() override;
- GfxColorSpace *copy() const override;
+ std::unique_ptr<GfxColorSpace> copy() const override;
GfxColorSpaceMode getMode() const override { return csCalGray; }
// Construct a CalGray color space. Returns nullptr if unsuccessful.
- static GfxColorSpace *parse(Array *arr, GfxState *state);
+ static std::unique_ptr<GfxColorSpace> parse(Array *arr, GfxState *state);
void getGray(const GfxColor *color, GfxGray *gray) const override;
void getRGB(const GfxColor *color, GfxRGB *rgb) const override;
@@ -399,7 +399,7 @@
public:
GfxDeviceRGBColorSpace();
~GfxDeviceRGBColorSpace() override;
- GfxColorSpace *copy() const override;
+ std::unique_ptr<GfxColorSpace> copy() const override;
GfxColorSpaceMode getMode() const override { return csDeviceRGB; }
void getGray(const GfxColor *color, GfxGray *gray) const override;
@@ -433,11 +433,11 @@
public:
GfxCalRGBColorSpace();
~GfxCalRGBColorSpace() override;
- GfxColorSpace *copy() const override;
+ std::unique_ptr<GfxColorSpace> copy() const override;
GfxColorSpaceMode getMode() const override { return csCalRGB; }
// Construct a CalRGB color space. Returns nullptr if unsuccessful.
- static GfxColorSpace *parse(Array *arr, GfxState *state);
+ static std::unique_ptr<GfxColorSpace> parse(Array *arr, GfxState *state);
void getGray(const GfxColor *color, GfxGray *gray) const override;
void getRGB(const GfxColor *color, GfxRGB *rgb) const override;
@@ -479,7 +479,7 @@
public:
GfxDeviceCMYKColorSpace();
~GfxDeviceCMYKColorSpace() override;
- GfxColorSpace *copy() const override;
+ std::unique_ptr<GfxColorSpace> copy() const override;
GfxColorSpaceMode getMode() const override { return csDeviceCMYK; }
void getGray(const GfxColor *color, GfxGray *gray) const override;
@@ -510,11 +510,11 @@
public:
GfxLabColorSpace();
~GfxLabColorSpace() override;
- GfxColorSpace *copy() const override;
+ std::unique_ptr<GfxColorSpace> copy() const override;
GfxColorSpaceMode getMode() const override { return csLab; }
// Construct a Lab color space. Returns nullptr if unsuccessful.
- static GfxColorSpace *parse(Array *arr, GfxState *state);
+ static std::unique_ptr<GfxColorSpace> parse(Array *arr, GfxState *state);
void getGray(const GfxColor *color, GfxGray *gray) const override;
void getRGB(const GfxColor *color, GfxRGB *rgb) const override;
@@ -555,13 +555,15 @@
class POPPLER_PRIVATE_EXPORT GfxICCBasedColorSpace : public GfxColorSpace
{
public:
- GfxICCBasedColorSpace(int nCompsA, GfxColorSpace *altA, const Ref *iccProfileStreamA);
+ GfxICCBasedColorSpace(int nCompsA, std::unique_ptr<GfxColorSpace> &&altA, const Ref *iccProfileStreamA);
~GfxICCBasedColorSpace() override;
- GfxColorSpace *copy() const override;
+ std::unique_ptr<GfxColorSpace> copy() const override;
GfxColorSpaceMode getMode() const override { return csICCBased; }
+ std::unique_ptr<GfxICCBasedColorSpace> copyAsOwnType() const;
+
// Construct an ICCBased color space. Returns nullptr if unsuccessful.
- static GfxColorSpace *parse(Array *arr, OutputDev *out, GfxState *state, int recursion);
+ static std::unique_ptr<GfxColorSpace> parse(Array *arr, OutputDev *out, GfxState *state, int recursion);
void getGray(const GfxColor *color, GfxGray *gray) const override;
void getRGB(const GfxColor *color, GfxRGB *rgb) const override;
@@ -583,7 +585,7 @@
void getDefaultRanges(double *decodeLow, double *decodeRange, int maxImgPixel) const override;
// ICCBased-specific access.
- GfxColorSpace *getAlt() { return alt; }
+ GfxColorSpace *getAlt() { return alt.get(); }
Ref getRef() { return iccProfileStream; }
#ifdef USE_CMS
char *getPostScriptCSA();
@@ -594,7 +596,7 @@
private:
int nComps; // number of color components (1, 3, or 4)
- GfxColorSpace *alt; // alternate color space
+ std::unique_ptr<GfxColorSpace> alt; // alternate color space
double rangeMin[4]; // min values for each component
double rangeMax[4]; // max values for each component
Ref iccProfileStream; // the ICC profile
@@ -614,13 +616,13 @@
class GfxIndexedColorSpace : public GfxColorSpace
{
public:
- GfxIndexedColorSpace(GfxColorSpace *baseA, int indexHighA);
+ GfxIndexedColorSpace(std::unique_ptr<GfxColorSpace> &&baseA, int indexHighA);
~GfxIndexedColorSpace() override;
- GfxColorSpace *copy() const override;
+ std::unique_ptr<GfxColorSpace> copy() const override;
GfxColorSpaceMode getMode() const override { return csIndexed; }
// Construct an Indexed color space. Returns nullptr if unsuccessful.
- static GfxColorSpace *parse(GfxResources *res, Array *arr, OutputDev *out, GfxState *state, int recursion);
+ static std::unique_ptr<GfxColorSpace> parse(GfxResources *res, Array *arr, OutputDev *out, GfxState *state, int recursion);
void getGray(const GfxColor *color, GfxGray *gray) const override;
void getRGB(const GfxColor *color, GfxRGB *rgb) const override;
@@ -642,15 +644,15 @@
void getDefaultRanges(double *decodeLow, double *decodeRange, int maxImgPixel) const override;
// Indexed-specific access.
- GfxColorSpace *getBase() { return base; }
+ GfxColorSpace *getBase() { return base.get(); }
int getIndexHigh() const { return indexHigh; }
unsigned char *getLookup() { return lookup; }
GfxColor *mapColorToBase(const GfxColor *color, GfxColor *baseColor) const;
unsigned int getOverprintMask() const { return base->getOverprintMask(); }
- void createMapping(std::vector<GfxSeparationColorSpace *> *separationList, int maxSepComps) override { base->createMapping(separationList, maxSepComps); }
+ void createMapping(std::vector<std::unique_ptr<GfxSeparationColorSpace>> *separationList, int maxSepComps) override { base->createMapping(separationList, maxSepComps); }
private:
- GfxColorSpace *base; // base color space
+ std::unique_ptr<GfxColorSpace> base; // base color space
int indexHigh; // max pixel value
unsigned char *lookup; // lookup table
};
@@ -662,20 +664,22 @@
class GfxSeparationColorSpace : public GfxColorSpace
{
public:
- GfxSeparationColorSpace(GooString *nameA, GfxColorSpace *altA, Function *funcA);
+ GfxSeparationColorSpace(GooString *nameA, std::unique_ptr<GfxColorSpace> &&altA, Function *funcA);
~GfxSeparationColorSpace() override;
- GfxColorSpace *copy() const override;
+ std::unique_ptr<GfxColorSpace> copy() const override;
GfxColorSpaceMode getMode() const override { return csSeparation; }
+ std::unique_ptr<GfxSeparationColorSpace> copyAsOwnType() const;
+
// Construct a Separation color space. Returns nullptr if unsuccessful.
- static GfxColorSpace *parse(GfxResources *res, Array *arr, OutputDev *out, GfxState *state, int recursion);
+ static std::unique_ptr<GfxColorSpace> parse(GfxResources *res, Array *arr, OutputDev *out, GfxState *state, int recursion);
void getGray(const GfxColor *color, GfxGray *gray) const override;
void getRGB(const GfxColor *color, GfxRGB *rgb) const override;
void getCMYK(const GfxColor *color, GfxCMYK *cmyk) const override;
void getDeviceN(const GfxColor *color, GfxColor *deviceN) const override;
- void createMapping(std::vector<GfxSeparationColorSpace *> *separationList, int maxSepComps) override;
+ void createMapping(std::vector<std::unique_ptr<GfxSeparationColorSpace>> *separationList, int maxSepComps) override;
int getNComps() const override { return 1; }
void getDefaultColor(GfxColor *color) const override;
@@ -684,14 +688,14 @@
// Separation-specific access.
const GooString *getName() const { return name; }
- GfxColorSpace *getAlt() { return alt; }
+ GfxColorSpace *getAlt() { return alt.get(); }
const Function *getFunc() const { return func; }
private:
- GfxSeparationColorSpace(GooString *nameA, GfxColorSpace *altA, Function *funcA, bool nonMarkingA, unsigned int overprintMaskA, int *mappingA);
+ GfxSeparationColorSpace(GooString *nameA, std::unique_ptr<GfxColorSpace> &&altA, Function *funcA, bool nonMarkingA, unsigned int overprintMaskA, int *mappingA);
GooString *name; // colorant name
- GfxColorSpace *alt; // alternate color space
+ std::unique_ptr<GfxColorSpace> alt; // alternate color space
Function *func; // tint transform (into alternate color space)
bool nonMarking;
};
@@ -703,20 +707,20 @@
class GfxDeviceNColorSpace : public GfxColorSpace
{
public:
- GfxDeviceNColorSpace(int nCompsA, std::vector<std::string> &&namesA, GfxColorSpace *alt, Function *func, std::vector<GfxSeparationColorSpace *> *sepsCS);
+ GfxDeviceNColorSpace(int nCompsA, std::vector<std::string> &&namesA, std::unique_ptr<GfxColorSpace> &&alt, Function *func, std::vector<std::unique_ptr<GfxSeparationColorSpace>> *sepsCS);
~GfxDeviceNColorSpace() override;
- GfxColorSpace *copy() const override;
+ std::unique_ptr<GfxColorSpace> copy() const override;
GfxColorSpaceMode getMode() const override { return csDeviceN; }
// Construct a DeviceN color space. Returns nullptr if unsuccessful.
- static GfxColorSpace *parse(GfxResources *res, Array *arr, OutputDev *out, GfxState *state, int recursion);
+ static std::unique_ptr<GfxColorSpace> parse(GfxResources *res, Array *arr, OutputDev *out, GfxState *state, int recursion);
void getGray(const GfxColor *color, GfxGray *gray) const override;
void getRGB(const GfxColor *color, GfxRGB *rgb) const override;
void getCMYK(const GfxColor *color, GfxCMYK *cmyk) const override;
void getDeviceN(const GfxColor *color, GfxColor *deviceN) const override;
- void createMapping(std::vector<GfxSeparationColorSpace *> *separationList, int maxSepComps) override;
+ void createMapping(std::vector<std::unique_ptr<GfxSeparationColorSpace>> *separationList, int maxSepComps) override;
int getNComps() const override { return nComps; }
void getDefaultColor(GfxColor *color) const override;
@@ -725,18 +729,19 @@
// DeviceN-specific access.
const std::string &getColorantName(int i) const { return names[i]; }
- GfxColorSpace *getAlt() { return alt; }
+ GfxColorSpace *getAlt() { return alt.get(); }
const Function *getTintTransformFunc() const { return func; }
private:
- GfxDeviceNColorSpace(int nCompsA, const std::vector<std::string> &namesA, GfxColorSpace *alt, Function *func, std::vector<GfxSeparationColorSpace *> *sepsCSA, int *mappingA, bool nonMarkingA, unsigned int overprintMaskA);
+ GfxDeviceNColorSpace(int nCompsA, const std::vector<std::string> &namesA, std::unique_ptr<GfxColorSpace> &&alt, Function *func, std::vector<std::unique_ptr<GfxSeparationColorSpace>> *sepsCSA, int *mappingA, bool nonMarkingA,
+ unsigned int overprintMaskA);
const int nComps; // number of components
const std::vector<std::string> names; // colorant names
- GfxColorSpace *alt; // alternate color space
+ std::unique_ptr<GfxColorSpace> alt; // alternate color space
Function *func; // tint transform (into alternate color space)
bool nonMarking;
- std::vector<GfxSeparationColorSpace *> *sepsCS; // list of separation cs for spot colorants;
+ std::vector<std::unique_ptr<GfxSeparationColorSpace>> *sepsCS; // list of separation cs for spot colorants;
};
//------------------------------------------------------------------------
@@ -746,13 +751,13 @@
class GfxPatternColorSpace : public GfxColorSpace
{
public:
- explicit GfxPatternColorSpace(GfxColorSpace *underA);
+ explicit GfxPatternColorSpace(std::unique_ptr<GfxColorSpace> &&underA);
~GfxPatternColorSpace() override;
- GfxColorSpace *copy() const override;
+ std::unique_ptr<GfxColorSpace> copy() const override;
GfxColorSpaceMode getMode() const override { return csPattern; }
// Construct a Pattern color space. Returns nullptr if unsuccessful.
- static GfxColorSpace *parse(GfxResources *res, Array *arr, OutputDev *out, GfxState *state, int recursion);
+ static std::unique_ptr<GfxColorSpace> parse(GfxResources *res, Array *arr, OutputDev *out, GfxState *state, int recursion);
void getGray(const GfxColor *color, GfxGray *gray) const override;
void getRGB(const GfxColor *color, GfxRGB *rgb) const override;
@@ -763,11 +768,10 @@
void getDefaultColor(GfxColor *color) const override;
// Pattern-specific access.
- GfxColorSpace *getUnder() { return under; }
+ GfxColorSpace *getUnder() { return under.get(); }
private:
- GfxColorSpace *under; // underlying color space (for uncolored
- // patterns)
+ std::unique_ptr<GfxColorSpace> under; // underlying color space (for uncolored patterns)
};
//------------------------------------------------------------------------
@@ -881,7 +885,7 @@
virtual GfxShading *copy() const = 0;
ShadingType getType() const { return type; }
- GfxColorSpace *getColorSpace() { return colorSpace; }
+ GfxColorSpace *getColorSpace() { return colorSpace.get(); }
const GfxColor *getBackground() const { return &background; }
bool getHasBackground() const { return hasBackground; }
void getBBox(double *xMinA, double *yMinA, double *xMaxA, double *yMaxA) const
@@ -899,7 +903,7 @@
ShadingType type;
bool hasBackground;
bool hasBBox;
- GfxColorSpace *colorSpace;
+ std::unique_ptr<GfxColorSpace> colorSpace;
GfxColor background;
double bbox_xMin, bbox_yMin, bbox_xMax, bbox_yMax;
};
@@ -1200,7 +1204,7 @@
{
public:
// Constructor.
- GfxImageColorMap(int bitsA, Object *decode, GfxColorSpace *colorSpaceA);
+ GfxImageColorMap(int bitsA, Object *decode, std::unique_ptr<GfxColorSpace> &&colorSpaceA);
// Destructor.
~GfxImageColorMap();
@@ -1215,7 +1219,7 @@
bool isOk() const { return ok; }
// Get the color space.
- GfxColorSpace *getColorSpace() { return colorSpace; }
+ GfxColorSpace *getColorSpace() { return colorSpace.get(); }
// Get stream decoding info.
int getNumPixelComps() const { return nComps; }
@@ -1253,7 +1257,7 @@
private:
explicit GfxImageColorMap(const GfxImageColorMap *colorMap);
- GfxColorSpace *colorSpace; // the image color space
+ std::unique_ptr<GfxColorSpace> colorSpace; // the image color space
int bits; // bits per component
int nComps; // number of components in a pixel
GfxColorSpace *colorSpace2; // secondary color space
@@ -1500,8 +1504,8 @@
void getFillDeviceN(GfxColor *deviceN) { fillColorSpace->getDeviceN(&fillColor, deviceN); }
void getStrokeCMYK(GfxCMYK *cmyk) { strokeColorSpace->getCMYK(&strokeColor, cmyk); }
void getStrokeDeviceN(GfxColor *deviceN) { strokeColorSpace->getDeviceN(&strokeColor, deviceN); }
- GfxColorSpace *getFillColorSpace() { return fillColorSpace; }
- GfxColorSpace *getStrokeColorSpace() { return strokeColorSpace; }
+ GfxColorSpace *getFillColorSpace() { return fillColorSpace.get(); }
+ GfxColorSpace *getStrokeColorSpace() { return strokeColorSpace.get(); }
GfxPattern *getFillPattern() { return fillPattern; }
GfxPattern *getStrokePattern() { return strokePattern; }
GfxBlendMode getBlendMode() const { return blendMode; }
@@ -1583,8 +1587,8 @@
void setCTM(double a, double b, double c, double d, double e, double f);
void concatCTM(double a, double b, double c, double d, double e, double f);
void shiftCTMAndClip(double tx, double ty);
- void setFillColorSpace(GfxColorSpace *colorSpace);
- void setStrokeColorSpace(GfxColorSpace *colorSpace);
+ void setFillColorSpace(std::unique_ptr<GfxColorSpace> &&colorSpace);
+ void setStrokeColorSpace(std::unique_ptr<GfxColorSpace> &&colorSpace);
void setFillColor(const GfxColor *color) { fillColor = *color; }
void setStrokeColor(const GfxColor *color) { strokeColor = *color; }
void setFillPattern(GfxPattern *pattern);
@@ -1631,34 +1635,34 @@
static GfxLCMSProfilePtr sRGBProfile;
#endif
- void setDefaultGrayColorSpace(GfxColorSpace *cs) { defaultGrayColorSpace = cs; }
+ void setDefaultGrayColorSpace(std::unique_ptr<GfxColorSpace> &&cs) { defaultGrayColorSpace = std::move(cs); }
- void setDefaultRGBColorSpace(GfxColorSpace *cs) { defaultRGBColorSpace = cs; }
+ void setDefaultRGBColorSpace(std::unique_ptr<GfxColorSpace> &&cs) { defaultRGBColorSpace = std::move(cs); }
- void setDefaultCMYKColorSpace(GfxColorSpace *cs) { defaultCMYKColorSpace = cs; }
+ void setDefaultCMYKColorSpace(std::unique_ptr<GfxColorSpace> &&cs) { defaultCMYKColorSpace = std::move(cs); }
- GfxColorSpace *copyDefaultGrayColorSpace()
+ std::unique_ptr<GfxColorSpace> copyDefaultGrayColorSpace()
{
if (defaultGrayColorSpace) {
return defaultGrayColorSpace->copy();
}
- return new GfxDeviceGrayColorSpace();
+ return std::make_unique<GfxDeviceGrayColorSpace>();
}
- GfxColorSpace *copyDefaultRGBColorSpace()
+ std::unique_ptr<GfxColorSpace> copyDefaultRGBColorSpace()
{
if (defaultRGBColorSpace) {
return defaultRGBColorSpace->copy();
}
- return new GfxDeviceRGBColorSpace();
+ return std::make_unique<GfxDeviceRGBColorSpace>();
}
- GfxColorSpace *copyDefaultCMYKColorSpace()
+ std::unique_ptr<GfxColorSpace> copyDefaultCMYKColorSpace()
{
if (defaultCMYKColorSpace) {
return defaultCMYKColorSpace->copy();
}
- return new GfxDeviceCMYKColorSpace();
+ return std::make_unique<GfxDeviceCMYKColorSpace>();
}
// Add to path.
@@ -1711,8 +1715,8 @@
double pageWidth, pageHeight; // page size (pixels)
int rotate; // page rotation angle
- GfxColorSpace *fillColorSpace; // fill color space
- GfxColorSpace *strokeColorSpace; // stroke color space
+ std::unique_ptr<GfxColorSpace> fillColorSpace; // fill color space
+ std::unique_ptr<GfxColorSpace> strokeColorSpace; // stroke color space
GfxColor fillColor; // fill color
GfxColor strokeColor; // stroke color
GfxPattern *fillPattern; // fill pattern
@@ -1770,9 +1774,9 @@
static GfxLCMSProfilePtr XYZProfile;
#endif
- GfxColorSpace *defaultGrayColorSpace;
- GfxColorSpace *defaultRGBColorSpace;
- GfxColorSpace *defaultCMYKColorSpace;
+ std::unique_ptr<GfxColorSpace> defaultGrayColorSpace;
+ std::unique_ptr<GfxColorSpace> defaultRGBColorSpace;
+ std::unique_ptr<GfxColorSpace> defaultCMYKColorSpace;
};
#endif
diff --git a/poppler/OutputDev.h b/poppler/OutputDev.h
index 35ab9bc..1287d22 100644
--- a/poppler/OutputDev.h
+++ b/poppler/OutputDev.h
@@ -19,7 +19,7 @@
// Copyright (C) 2007, 2011, 2017, 2021, 2023 Adrian Johnson <ajohnson@redneon.com>
// Copyright (C) 2009-2013, 2015 Thomas Freitag <Thomas.Freitag@alfa.de>
// Copyright (C) 2009, 2011 Carlos Garcia Campos <carlosgc@gnome.org>
-// Copyright (C) 2009, 2012, 2013, 2018, 2019, 2021 Albert Astals Cid <aacid@kde.org>
+// Copyright (C) 2009, 2012, 2013, 2018, 2019, 2021, 2024 Albert Astals Cid <aacid@kde.org>
// Copyright (C) 2010 Christian Feuersänger <cfeuersaenger@googlemail.com>
// Copyright (C) 2012 Fabio D'Urso <fabiodurso@hotmail.it>
// Copyright (C) 2012 William Bader <williambader@hotmail.com>
@@ -142,27 +142,27 @@
auto invalidref = Ref::INVALID();
if (defaultGrayProfile) {
- auto cs = new GfxICCBasedColorSpace(1, new GfxDeviceGrayColorSpace(), &invalidref);
+ auto cs = std::make_unique<GfxICCBasedColorSpace>(1, std::make_unique<GfxDeviceGrayColorSpace>(), &invalidref);
cs->setProfile(defaultGrayProfile);
cs->buildTransforms(state); // needs to happen after state->setDisplayProfile has been called
- state->setDefaultGrayColorSpace(cs);
+ state->setDefaultGrayColorSpace(std::move(cs));
}
if (defaultRGBProfile) {
- auto cs = new GfxICCBasedColorSpace(3, new GfxDeviceRGBColorSpace(), &invalidref);
+ auto cs = std::make_unique<GfxICCBasedColorSpace>(3, std::make_unique<GfxDeviceRGBColorSpace>(), &invalidref);
cs->setProfile(defaultRGBProfile);
cs->buildTransforms(state); // needs to happen after state->setDisplayProfile has been called
- state->setDefaultRGBColorSpace(cs);
+ state->setDefaultRGBColorSpace(std::move(cs));
}
if (defaultCMYKProfile) {
- auto cs = new GfxICCBasedColorSpace(4, new GfxDeviceCMYKColorSpace(), &invalidref);
+ auto cs = std::make_unique<GfxICCBasedColorSpace>(4, std::make_unique<GfxDeviceCMYKColorSpace>(), &invalidref);
cs->setProfile(defaultCMYKProfile);
cs->buildTransforms(state); // needs to happen after state->setDisplayProfile has been called
- state->setDefaultCMYKColorSpace(cs);
+ state->setDefaultCMYKColorSpace(std::move(cs));
}
#endif
}
diff --git a/poppler/Page.cc b/poppler/Page.cc
index d871110..6b441d8 100644
--- a/poppler/Page.cc
+++ b/poppler/Page.cc
@@ -15,7 +15,7 @@
//
// Copyright (C) 2005 Kristian Høgsberg <krh@redhat.com>
// Copyright (C) 2005 Jeff Muizelaar <jeff@infidigm.net>
-// Copyright (C) 2005-2013, 2016-2023 Albert Astals Cid <aacid@kde.org>
+// Copyright (C) 2005-2013, 2016-2024 Albert Astals Cid <aacid@kde.org>
// Copyright (C) 2006-2008 Pino Toscano <pino@kde.org>
// Copyright (C) 2006 Nickolay V. Shmyrev <nshmyrev@yandex.ru>
// Copyright (C) 2006 Scott Turner <scotty1024@mac.com>
@@ -636,7 +636,6 @@
int width, height, bits;
Object obj1;
Dict *dict;
- GfxColorSpace *colorSpace;
Stream *str;
GfxImageColorMap *colorMap;
@@ -678,7 +677,7 @@
// This will set a sRGB profile for ICC-based colorspaces.
auto pdfrectangle = std::make_shared<PDFRectangle>();
auto state = std::make_shared<GfxState>(72.0, 72.0, pdfrectangle.get(), 0, false);
- colorSpace = GfxColorSpace::parse(nullptr, &obj1, nullptr, state.get());
+ std::unique_ptr<GfxColorSpace> colorSpace = GfxColorSpace::parse(nullptr, &obj1, nullptr, state.get());
if (!colorSpace) {
fprintf(stderr, "Error: Cannot parse color space\n");
return false;
@@ -688,7 +687,7 @@
if (obj1.isNull()) {
obj1 = dict->lookup("D");
}
- colorMap = new GfxImageColorMap(bits, &obj1, colorSpace);
+ colorMap = new GfxImageColorMap(bits, &obj1, std::move(colorSpace));
if (!colorMap->isOk()) {
fprintf(stderr, "Error: invalid colormap\n");
delete colorMap;
diff --git a/poppler/PopplerCache.h b/poppler/PopplerCache.h
index 68db153..b291309 100644
--- a/poppler/PopplerCache.h
+++ b/poppler/PopplerCache.h
@@ -5,7 +5,7 @@
// This file is licensed under the GPLv2 or later
//
// Copyright (C) 2009 Koji Otani <sho@bbr.jp>
-// Copyright (C) 2009, 2010, 2017, 2018, 2021 Albert Astals Cid <aacid@kde.org>
+// Copyright (C) 2009, 2010, 2017, 2018, 2021, 2024 Albert Astals Cid <aacid@kde.org>
// Copyright (C) 2010 Carlos Garcia Campos <carlosgc@gnome.org>
// Copyright (C) 2018 Adam Reichold <adam.reichold@t-online.de>
//
@@ -58,6 +58,16 @@
entries.emplace(entries.begin(), key, std::unique_ptr<Item> { item });
}
+ /* The key and item pointers ownership is taken by the cache */
+ void put(const Key &key, std::unique_ptr<Item> &&item)
+ {
+ if (entries.size() == entries.capacity()) {
+ entries.pop_back();
+ }
+
+ entries.emplace(entries.begin(), key, std::move(item));
+ }
+
private:
std::vector<std::pair<Key, std::unique_ptr<Item>>> entries;
};
diff --git a/poppler/SplashOutputDev.cc b/poppler/SplashOutputDev.cc
index 1aa1b2f..83ed0a4 100644
--- a/poppler/SplashOutputDev.cc
+++ b/poppler/SplashOutputDev.cc
@@ -3539,7 +3539,7 @@
Object maskDecode(new Array((xref) ? xref : doc->getXRef()));
maskDecode.arrayAdd(Object(maskInvert ? 0 : 1));
maskDecode.arrayAdd(Object(maskInvert ? 1 : 0));
- maskColorMap = new GfxImageColorMap(1, &maskDecode, new GfxDeviceGrayColorSpace());
+ maskColorMap = new GfxImageColorMap(1, &maskDecode, std::make_unique<GfxDeviceGrayColorSpace>());
drawSoftMaskedImage(state, ref, str, width, height, colorMap, interpolate, maskStr, maskWidth, maskHeight, maskColorMap, maskInterpolate);
delete maskColorMap;
diff --git a/poppler/TextOutputDev.cc b/poppler/TextOutputDev.cc
index 471bdce..aa2d835 100644
--- a/poppler/TextOutputDev.cc
+++ b/poppler/TextOutputDev.cc
@@ -4692,7 +4692,7 @@
out->startPage(0, state, nullptr);
out->setDefaultCTM(state->getCTM());
- state->setFillColorSpace(new GfxDeviceRGBColorSpace());
+ state->setFillColorSpace(std::make_unique<GfxDeviceRGBColorSpace>());
state->setFillColor(box_color);
out->updateFillColor(state);
}
diff --git a/splash/Splash.cc b/splash/Splash.cc
index 86cae28..8f20733 100644
--- a/splash/Splash.cc
+++ b/splash/Splash.cc
@@ -5157,7 +5157,7 @@
if (src->getSeparationList()->size() > bitmap->getSeparationList()->size()) {
for (x = bitmap->getSeparationList()->size(); x < (int)src->getSeparationList()->size(); x++) {
- bitmap->getSeparationList()->push_back((GfxSeparationColorSpace *)((*src->getSeparationList())[x])->copy());
+ bitmap->getSeparationList()->push_back(((*src->getSeparationList())[x])->copyAsOwnType());
}
}
if (src->alpha) {
diff --git a/splash/SplashBitmap.cc b/splash/SplashBitmap.cc
index af4a622..8896102 100644
--- a/splash/SplashBitmap.cc
+++ b/splash/SplashBitmap.cc
@@ -11,7 +11,7 @@
// All changes made under the Poppler project to this file are licensed
// under GPL version 2 or later
//
-// Copyright (C) 2006, 2009, 2010, 2012, 2015, 2018, 2019, 2021, 2022 Albert Astals Cid <aacid@kde.org>
+// Copyright (C) 2006, 2009, 2010, 2012, 2015, 2018, 2019, 2021, 2022, 2024 Albert Astals Cid <aacid@kde.org>
// Copyright (C) 2007 Ilmari Heikkinen <ilmari.heikkinen@gmail.com>
// Copyright (C) 2009 Shen Liang <shenzhuxi@gmail.com>
// Copyright (C) 2009 Stefan Thomas <thomas@eload24.com>
@@ -53,7 +53,7 @@
// SplashBitmap
//------------------------------------------------------------------------
-SplashBitmap::SplashBitmap(int widthA, int heightA, int rowPadA, SplashColorMode modeA, bool alphaA, bool topDown, const std::vector<GfxSeparationColorSpace *> *separationListA)
+SplashBitmap::SplashBitmap(int widthA, int heightA, int rowPadA, SplashColorMode modeA, bool alphaA, bool topDown, const std::vector<std::unique_ptr<GfxSeparationColorSpace>> *separationListA)
{
width = widthA;
height = heightA;
@@ -122,10 +122,10 @@
} else {
alpha = nullptr;
}
- separationList = new std::vector<GfxSeparationColorSpace *>();
+ separationList = new std::vector<std::unique_ptr<GfxSeparationColorSpace>>();
if (separationListA != nullptr) {
- for (const GfxSeparationColorSpace *separation : *separationListA) {
- separationList->push_back((GfxSeparationColorSpace *)separation->copy());
+ for (const std::unique_ptr<GfxSeparationColorSpace> &separation : *separationListA) {
+ separationList->push_back(separation->copyAsOwnType());
}
}
}
@@ -160,9 +160,6 @@
}
}
gfree(alpha);
- for (auto entry : *separationList) {
- delete entry;
- }
delete separationList;
}
@@ -453,7 +450,7 @@
GfxCMYK cmyk;
GfxColor input;
input.c[0] = byteToCol(col[i + 4]);
- GfxSeparationColorSpace *sepCS = (GfxSeparationColorSpace *)((*separationList)[i]);
+ const std::unique_ptr<GfxSeparationColorSpace> &sepCS = (*separationList)[i];
sepCS->getCMYK(&input, &cmyk);
col[0] = colToByte(cmyk.c);
col[1] = colToByte(cmyk.m);
@@ -506,7 +503,7 @@
GfxCMYK cmyk;
GfxColor input;
input.c[0] = byteToCol(col[i + 4]);
- GfxSeparationColorSpace *sepCS = (GfxSeparationColorSpace *)((*separationList)[i]);
+ const std::unique_ptr<GfxSeparationColorSpace> &sepCS = (*separationList)[i];
sepCS->getCMYK(&input, &cmyk);
col[0] = colToByte(cmyk.c);
col[1] = colToByte(cmyk.m);
@@ -629,7 +626,7 @@
GfxCMYK cmyk;
GfxColor input;
input.c[0] = byteToCol(col[i + 4]);
- GfxSeparationColorSpace *sepCS = (GfxSeparationColorSpace *)((*separationList)[i]);
+ const std::unique_ptr<GfxSeparationColorSpace> &sepCS = (*separationList)[i];
sepCS->getCMYK(&input, &cmyk);
col[0] = colToByte(cmyk.c);
col[1] = colToByte(cmyk.m);
diff --git a/splash/SplashBitmap.h b/splash/SplashBitmap.h
index 2d7cf41..367d9fe 100644
--- a/splash/SplashBitmap.h
+++ b/splash/SplashBitmap.h
@@ -13,7 +13,7 @@
//
// Copyright (C) 2007 Ilmari Heikkinen <ilmari.heikkinen@gmail.com>
// Copyright (C) 2009 Shen Liang <shenzhuxi@gmail.com>
-// Copyright (C) 2009, 2012, 2018, 2021, 2022 Albert Astals Cid <aacid@kde.org>
+// Copyright (C) 2009, 2012, 2018, 2021, 2022, 2024 Albert Astals Cid <aacid@kde.org>
// Copyright (C) 2009 Stefan Thomas <thomas@eload24.com>
// Copyright (C) 2010, 2017 Adrian Johnson <ajohnson@redneon.com>
// Copyright (C) 2010 Harry Roberts <harry.roberts@midnight-labs.org>
@@ -36,6 +36,7 @@
#include "SplashTypes.h"
#include "poppler_private_export.h"
#include <cstdio>
+#include <memory>
#include <string>
#include <vector>
@@ -53,7 +54,7 @@
// color mode <modeA>. Rows will be padded out to a multiple of
// <rowPad> bytes. If <topDown> is false, the bitmap will be stored
// upside-down, i.e., with the last row first in memory.
- SplashBitmap(int widthA, int heightA, int rowPad, SplashColorMode modeA, bool alphaA, bool topDown = true, const std::vector<GfxSeparationColorSpace *> *separationList = nullptr);
+ SplashBitmap(int widthA, int heightA, int rowPad, SplashColorMode modeA, bool alphaA, bool topDown = true, const std::vector<std::unique_ptr<GfxSeparationColorSpace>> *separationList = nullptr);
static SplashBitmap *copy(const SplashBitmap *src);
~SplashBitmap();
@@ -69,10 +70,10 @@
SplashColorMode getMode() const { return mode; }
SplashColorPtr getDataPtr() { return data; }
unsigned char *getAlphaPtr() { return alpha; }
- std::vector<GfxSeparationColorSpace *> *getSeparationList() { return separationList; }
+ std::vector<std::unique_ptr<GfxSeparationColorSpace>> *getSeparationList() { return separationList; }
SplashColorConstPtr getDataPtr() const { return data; }
const unsigned char *getAlphaPtr() const { return alpha; }
- const std::vector<GfxSeparationColorSpace *> *getSeparationList() const { return separationList; }
+ const std::vector<std::unique_ptr<GfxSeparationColorSpace>> *getSeparationList() const { return separationList; }
SplashError writePNMFile(char *fileName);
SplashError writePNMFile(FILE *f);
@@ -119,7 +120,7 @@
SplashColorPtr data; // pointer to row zero of the color data
unsigned char *alpha; // pointer to row zero of the alpha data
// (always top-down)
- std::vector<GfxSeparationColorSpace *> *separationList; // list of spot colorants and their mapping functions
+ std::vector<std::unique_ptr<GfxSeparationColorSpace>> *separationList; // list of spot colorants and their mapping functions
friend class Splash;
