Subversion Repositories Scribus

Rev

Rev 25069 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
5977 jghali 1
/*
2
For general Scribus (>=1.3.2) copyright and licensing information please refer
3
to the COPYING file provided with the program. Following this notice may exist
4
a copyright and/or license notice that predates the release of Scribus 1.3.2
5
for which a new license (GPL+exception) is in place.
6
*/
12141 avox 7
#include <QByteArray>
8
#include <QDataStream>
9
#include <QDebug>
9970 fschmid 10
#include <QFile>
11
#include <QFileInfo>
24834 jghali 12
#include <QStringView>
10136 cbradney 13
 
14170 jghali 14
#include "cmsettings.h"
14491 jghali 15
#include "colormgmt/sccolormgmtengine.h"
13497 jghali 16
#include "scclocale.h"
5937 jghali 17
#include "scpaths.h"
18
#include "scribuscore.h"
19
#include "scimgdataloader_ps.h"
13503 cbradney 20
#include "sctextstream.h"
6759 fschmid 21
#include "prefsmanager.h"
6808 fschmid 22
#include "util.h"
10212 cbradney 23
#include "util_formats.h"
24
#include "util_ghostscript.h"
10203 cbradney 25
#include "util_math.h"
7196 fschmid 26
#include "scimage.h"
5937 jghali 27
 
6762 fschmid 28
extern "C"
29
{
30
#define XMD_H           // shut JPEGlib up
31
#if defined(Q_OS_UNIXWARE)
32
#  define HAVE_BOOLEAN  // libjpeg under Unixware seems to need this
33
#endif
34
#include <jpeglib.h>
35
#include <jerror.h>
18083 jghali 36
#include <csetjmp>
6762 fschmid 37
#undef HAVE_STDLIB_H
38
#ifdef const
39
#  undef const          // remove crazy C hackery in jconfig.h
40
#endif
41
}
42
 
24735 jghali 43
ScImgDataLoader_PS::ScImgDataLoader_PS()
5937 jghali 44
{
45
        initSupportedFormatList();
46
}
47
 
22635 craig 48
void ScImgDataLoader_PS::initialize()
20348 jghali 49
{
20691 craig 50
        m_doThumbnail = false;
51
        m_hasThumbnail = false;
20348 jghali 52
 
53
        ScImgDataLoader::initialize();
54
}
55
 
22635 craig 56
void ScImgDataLoader_PS::initSupportedFormatList()
5937 jghali 57
{
58
        m_supportedFormats.clear();
22635 craig 59
        m_supportedFormats<<"ps"<<"eps"<<"epsi";
5937 jghali 60
}
61
 
12141 avox 62
void ScImgDataLoader_PS::loadEmbeddedProfile(const QString& fn, int /* page */)
5937 jghali 63
{
64
        m_embeddedProfile.resize(0);
65
        m_profileComponents = 0;
6660 fschmid 66
        if ( !QFile::exists(fn) )
67
                return;
68
        QFile f(fn);
22306 craig 69
        if (!f.open(QIODevice::ReadOnly))
70
                return;
71
 
72
        QString tmp;
73
        QDataStream ts(&f);
74
        while (!ts.atEnd())
6660 fschmid 75
        {
22408 jghali 76
                tmp = readLineFromDataStream(ts);
22306 craig 77
                if (tmp.startsWith("%%BeginICCProfile:"))
6660 fschmid 78
                {
22306 craig 79
                        QByteArray psdata;
80
                        while (!ts.atEnd())
6660 fschmid 81
                        {
22408 jghali 82
                                tmp = readLineFromDataStream(ts);
22306 craig 83
                                for (int a = 2; a < tmp.length(); a += 2)
6660 fschmid 84
                                {
22306 craig 85
                                        bool ok;
24834 jghali 86
                                        ushort data = QStringView(tmp).sliced(a, 2).toUShort(&ok, 16);
22306 craig 87
                                        psdata.resize(psdata.size()+1);
88
                                        psdata[psdata.size()-1] = data;
89
                                }
90
                                if (tmp.startsWith("%%EndICCProfile"))
91
                                {
92
                                        ScColorMgmtEngine engine(ScCore->defaultEngine);
93
                                        ScColorProfile prof = engine.openProfileFromMem(psdata);
94
                                        if (prof)
6660 fschmid 95
                                        {
22306 craig 96
                                                if (prof.colorSpace() == ColorSpace_Rgb)
97
                                                        m_profileComponents = 3;
98
                                                if (prof.colorSpace() == ColorSpace_Cmyk)
99
                                                        m_profileComponents = 4;
100
                                                m_imageInfoRecord.profileName = prof.productDescription();
23537 jghali 101
                                                m_imageInfoRecord.embeddedProfileName = m_imageInfoRecord.profileName;
22306 craig 102
                                                m_imageInfoRecord.isEmbedded = true;
103
                                                m_embeddedProfile = psdata;
6660 fschmid 104
                                        }
22306 craig 105
                                        break;
6660 fschmid 106
                                }
107
                        }
108
                }
109
        }
5937 jghali 110
}
111
 
22635 craig 112
void ScImgDataLoader_PS::scanForFonts(const QString& fn)
6759 fschmid 113
{
22306 craig 114
        QFile f(fn);
115
        if (!f.open(QIODevice::ReadOnly))
116
                return;
117
        QDataStream ts(&f);
6759 fschmid 118
        QString tmp;
22306 craig 119
        while (!ts.atEnd())
6759 fschmid 120
        {
22408 jghali 121
                tmp = readLineFromDataStream(ts);
22306 craig 122
                if (tmp.startsWith("%%BeginFont:"))
6759 fschmid 123
                {
25069 craig 124
                        tmp.remove("%%BeginFont:");
22306 craig 125
                        ScTextStream ts2(&tmp, QIODevice::ReadOnly);
126
                        QString tmp2;
127
                        ts2 >> tmp2;
128
                        m_FontListe.removeAll(tmp2);
6759 fschmid 129
                }
130
        }
131
}
132
 
22635 craig 133
bool ScImgDataLoader_PS::parseData(const QString& fn)
5937 jghali 134
{
6664 fschmid 135
        QString tmp, FarNam;
136
        ScColor cc;
137
        double x, y, b, h, c, m, k;
5937 jghali 138
        bool found = false;
20691 craig 139
        m_isDCS1 = false;
140
        m_isDCS2 = false;
141
        m_isDCS2multi = false;
142
        m_isPhotoshop = false;
143
        m_hasPhotoshopImageData = false;
144
        m_hasThumbnail = false;
145
        m_inTrailer = false;
146
        m_BBoxInTrailer = false;
147
        m_isRotated = false;
6669 fschmid 148
        int plateCount = 0;
7184 fschmid 149
        uint startPos = 0;
20691 craig 150
        m_FontListe.clear();
5937 jghali 151
        QFile f(fn);
8501 cbradney 152
        if (f.open(QIODevice::ReadOnly))
5937 jghali 153
        {
10561 fschmid 154
                QByteArray tempBuf(9, ' ');
155
                f.read(tempBuf.data(), 8);
16956 jghali 156
                if (getDouble(tempBuf.mid(0, 4), true) == 0xC5D0D3C6)
7196 fschmid 157
                {
7184 fschmid 158
                        startPos = getDouble(tempBuf.mid(4, 4), false);
20691 craig 159
                        if (m_doThumbnail)
7196 fschmid 160
                        {
10561 fschmid 161
                                f.seek(0);
162
                                QByteArray tmp2buf(29, ' ');
163
                                f.read(tmp2buf.data(), 28);
7196 fschmid 164
                                uint thumbStart = 0;
165
                                thumbStart = tmp2buf[20] & 0xff;
166
                                thumbStart |= (tmp2buf[21] << 8) & 0xff00;
167
                                thumbStart |= (tmp2buf[22] << 16) & 0xff0000;
168
                                thumbStart |= (tmp2buf[23] << 24) & 0xff000000;
169
                                uint thumbLen = 0;
170
                                thumbLen = tmp2buf[24] & 0xff;
171
                                thumbLen |= (tmp2buf[25] << 8) & 0xff00;
172
                                thumbLen |= (tmp2buf[26] << 16) & 0xff0000;
173
                                thumbLen |= (tmp2buf[27] << 24) & 0xff000000;
174
                                if (thumbLen != 0)
175
                                {
10561 fschmid 176
                                        QByteArray imgc(thumbLen, ' ');
177
                                        f.seek(thumbStart);
19730 fschmid 178
                                        f.read(imgc.data(), thumbLen);
21526 craig 179
                                        QString tmpFile = QDir::toNativeSeparators(ScPaths::tempFileDir() + "preview.tiff");
7196 fschmid 180
                                        QFile f2(tmpFile);
8501 cbradney 181
                                        if (f2.open(QIODevice::WriteOnly))
10561 fschmid 182
                                                f2.write(imgc.data(), thumbLen);
7196 fschmid 183
                                        f2.close();
184
                                        imgc.resize(0);
185
                                        ScImage thum;
22605 craig 186
                                        CMSettings cms(nullptr, "", Intent_Perceptual);
14467 jghali 187
                                        cms.allowColorManagement(false);
7196 fschmid 188
                                        bool mode = true;
14467 jghali 189
                                        if (thum.loadPicture(tmpFile, 1, cms, ScImage::RGBData, 72, &mode))
7196 fschmid 190
                                        {
191
                                                m_imageInfoRecord.exifDataValid = true;
192
                                                m_imageInfoRecord.exifInfo.thumbnail = thum.qImage().copy();
193
                                        }
10561 fschmid 194
                                        QFile::remove(tmpFile);
20691 craig 195
                                        m_hasThumbnail = true;
7196 fschmid 196
                                }
197
                        }
198
                }
6653 fschmid 199
                bool psFound = false;
12631 fschmid 200
                bool isAtend = false;
9991 fschmid 201
                QDataStream ts(&f);
202
                ts.device()->seek(startPos);
5937 jghali 203
                while (!ts.atEnd())
204
                {
22408 jghali 205
                        tmp = readLineFromDataStream(ts);
6669 fschmid 206
                        if (tmp.startsWith("%%Creator: "))
20691 craig 207
                                m_Creator = tmp.remove("%%Creator: ");
12141 avox 208
                        if (tmp.startsWith("%%Pages: "))
209
                        {
25069 craig 210
                                tmp.remove("%%Pages: ");
12141 avox 211
                                bool ok;
212
                                int pages = tmp.toInt( &ok );
213
                                if (ok)
214
                                        m_imageInfoRecord.numberOfPages = pages;
215
                        }
10829 fschmid 216
                        if (tmp.startsWith("%%Trailer"))
20691 craig 217
                                m_inTrailer = true;
5937 jghali 218
                        if (tmp.startsWith("%%BoundingBox:"))
219
                        {
220
                                found = true;
20691 craig 221
                                if (m_inTrailer)
222
                                        m_BBoxInTrailer = true;
223
                                m_BBox = tmp.remove("%%BoundingBox:");
5937 jghali 224
                        }
225
                        if (!found)
226
                        {
227
                                if (tmp.startsWith("%%BoundingBox"))
228
                                {
229
                                        found = true;
20691 craig 230
                                        if (m_inTrailer)
231
                                                m_BBoxInTrailer = true;
232
                                        m_BBox = tmp.remove("%%BoundingBox");
5937 jghali 233
                                }
234
                        }
14258 fschmid 235
                        if (tmp.startsWith("%%Orientation:"))
236
                        {
237
                                if (tmp.contains("Landscape"))
20691 craig 238
                                        m_isRotated = true;
14258 fschmid 239
                        }
6660 fschmid 240
                        if (tmp.startsWith("%%CyanPlate:"))
241
                        {
20691 craig 242
                                m_colorPlates.insert("Cyan", tmp.remove("%%CyanPlate: "));
243
                                m_isDCS1 = true;
6660 fschmid 244
                        }
245
                        if (tmp.startsWith("%%MagentaPlate:"))
246
                        {
20691 craig 247
                                m_colorPlates.insert("Magenta", tmp.remove("%%MagentaPlate: "));
248
                                m_isDCS1 = true;
6660 fschmid 249
                        }
250
                        if (tmp.startsWith("%%YellowPlate:"))
251
                        {
20691 craig 252
                                m_colorPlates.insert("Yellow", tmp.remove("%%YellowPlate: "));
253
                                m_isDCS1 = true;
6660 fschmid 254
                        }
255
                        if (tmp.startsWith("%%BlackPlate:"))
256
                        {
20691 craig 257
                                m_colorPlates.insert("Black", tmp.remove("%%BlackPlate: "));
258
                                m_isDCS1 = true;
6660 fschmid 259
                        }
6669 fschmid 260
                        if (tmp.startsWith("%%PlateFile: ("))
261
                        {
25069 craig 262
                                tmp.remove("%%PlateFile: (");
10517 cbradney 263
                                int endNam = tmp.indexOf(")");
6669 fschmid 264
                                QString plateNam = tmp.left(endNam);
25069 craig 265
                                tmp.remove(plateNam+")");
13497 jghali 266
                                ScTextStream ts2(&tmp, QIODevice::ReadOnly);
6670 fschmid 267
                                QString posStr, dummy, lenStr;
268
                                ts2 >> dummy >> posStr >> lenStr;
6672 fschmid 269
                                if (dummy == "EPS")
6669 fschmid 270
                                {
6672 fschmid 271
                                        if (posStr.startsWith("#"))
6669 fschmid 272
                                        {
25069 craig 273
                                                posStr.remove(0, 1);
6672 fschmid 274
                                                uint pos = posStr.toUInt();
275
                                                uint len = lenStr.toUInt();
276
                                                struct plateOffsets offs;
22635 craig 277
                                                if (m_Creator.contains("Photoshop Version 9"))  // This is very strange, it seems that there is a bug in PS 9 which writes weird entries
6672 fschmid 278
                                                {
279
                                                        pos -= (191 + plateCount * 83);
280
                                                        len -= 83;
281
                                                }
282
                                                offs.pos = pos;
283
                                                offs.len = len;
20691 craig 284
                                                m_colorPlates2.insert(plateNam, offs);
285
                                                m_isDCS2 = true;
6672 fschmid 286
                                                plateCount++;
6669 fschmid 287
                                        }
6672 fschmid 288
                                        else
289
                                        {
20691 craig 290
                                                m_colorPlates.insert(plateNam, lenStr);
291
                                                m_isDCS2 = true;
292
                                                m_isDCS2multi = true;
6672 fschmid 293
                                        }
6669 fschmid 294
                                }
295
                        }
6759 fschmid 296
                        if (tmp.startsWith("%%DocumentFonts:"))
297
                        {
25069 craig 298
                                tmp.remove("%%DocumentFonts:");
13497 jghali 299
                                ScTextStream ts2(&tmp, QIODevice::ReadOnly);
6759 fschmid 300
                                QString tmp2;
301
                                ts2 >> tmp2;
12631 fschmid 302
                                if (!tmp2.contains("(atend)"))
6759 fschmid 303
                                {
12631 fschmid 304
                                        if (!tmp2.isEmpty())
20691 craig 305
                                                m_FontListe.append(tmp2);
12631 fschmid 306
                                        while (!ts.atEnd())
6759 fschmid 307
                                        {
12631 fschmid 308
                                                uint oldPos = ts.device()->pos();
22408 jghali 309
                                                tmp = readLineFromDataStream(ts);
12631 fschmid 310
                                                if (!tmp.startsWith("%%+"))
311
                                                {
312
                                                        ts.device()->seek(oldPos);
313
                                                        break;
314
                                                }
25069 craig 315
                                                tmp.remove(0,3);
13497 jghali 316
                                                ScTextStream ts2(&tmp, QIODevice::ReadOnly);
12631 fschmid 317
                                                QString tmp2;
318
                                                ts2 >> tmp2;
319
                                                if (!tmp2.isEmpty())
20691 craig 320
                                                        m_FontListe.append(tmp2);
6759 fschmid 321
                                        }
322
                                }
12631 fschmid 323
                                else
324
                                        isAtend = true;
6759 fschmid 325
                        }
6664 fschmid 326
                        if (tmp.startsWith("%%CMYKCustomColor"))
327
                        {
25069 craig 328
                                tmp.remove(0,18);
13497 jghali 329
                                ScTextStream ts2(&tmp, QIODevice::ReadOnly);
6664 fschmid 330
                                ts2 >> c >> m >> y >> k;
10004 fschmid 331
                                FarNam = ts2.readAll();
10394 cbradney 332
                                FarNam = FarNam.trimmed();
25069 craig 333
                                FarNam.remove(0,1);
334
                                FarNam.remove(FarNam.length()-1,1);
6664 fschmid 335
                                cc = ScColor(static_cast<int>(255 * c), static_cast<int>(255 * m), static_cast<int>(255 * y), static_cast<int>(255 * k));
336
                                cc.setSpotColor(true);
20691 craig 337
                                m_CustColors.insert(FarNam, cc);
6664 fschmid 338
                                while (!ts.atEnd())
339
                                {
9991 fschmid 340
                                        uint oldPos = ts.device()->pos();
22408 jghali 341
                                        tmp = readLineFromDataStream(ts);
6664 fschmid 342
                                        if (!tmp.startsWith("%%+"))
6669 fschmid 343
                                        {
9991 fschmid 344
                                                ts.device()->seek(oldPos);
6664 fschmid 345
                                                break;
6669 fschmid 346
                                        }
6664 fschmid 347
                                        tmp = tmp.remove(0,3);
13497 jghali 348
                                        ScTextStream ts2(&tmp, QIODevice::ReadOnly);
6664 fschmid 349
                                        ts2 >> c >> m >> y >> k;
10004 fschmid 350
                                        FarNam = ts2.readAll();
10394 cbradney 351
                                        FarNam = FarNam.trimmed();
6664 fschmid 352
                                        FarNam = FarNam.remove(0,1);
353
                                        FarNam = FarNam.remove(FarNam.length()-1,1);
354
                                        cc = ScColor(static_cast<int>(255 * c), static_cast<int>(255 * m), static_cast<int>(255 * y), static_cast<int>(255 * k));
355
                                        cc.setSpotColor(true);
20691 craig 356
                                        m_CustColors.insert(FarNam, cc);
6664 fschmid 357
                                }
358
                        }
5937 jghali 359
                        if (tmp.startsWith("%%EndComments"))
6653 fschmid 360
                        {
361
                                while (!ts.atEnd())
362
                                {
22408 jghali 363
                                        tmp = readLineFromDataStream(ts);
6653 fschmid 364
                                        if ((!tmp.isEmpty()) && (!tmp.startsWith("%")))
365
                                        {
366
                                                psFound = true;
367
                                                break;
368
                                        }
6709 fschmid 369
                                        if (tmp.startsWith("%ImageData: "))
370
                                        {
20691 craig 371
                                                m_hasPhotoshopImageData = true;
6709 fschmid 372
                                                tmp.remove("%ImageData: ");
13497 jghali 373
                                                ScTextStream ts2(&tmp, QIODevice::ReadOnly);
20691 craig 374
                                                ts2 >> m_psXSize >> m_psYSize >> m_psDepth >> m_psMode >> m_psChannel >> m_psBlock >> m_psDataType >> m_psCommand;
375
                                                m_psCommand = m_psCommand.remove(0,1);
376
                                                m_psCommand = m_psCommand.remove(m_psCommand.length()-1,1);
6709 fschmid 377
                                        }
6653 fschmid 378
                                        if (tmp.startsWith("%BeginPhotoshop"))
379
                                        {
380
                                                QByteArray psdata;
381
                                                while (!ts.atEnd())
382
                                                {
22408 jghali 383
                                                        tmp = readLineFromDataStream(ts);
6653 fschmid 384
                                                        if (tmp.startsWith("%EndPhotoshop"))
385
                                                        {
8569 jghali 386
                                                                QDataStream strPhot( &psdata, QIODevice::ReadOnly);
6653 fschmid 387
                                                                strPhot.setByteOrder( QDataStream::BigEndian );
388
                                                                PSDHeader fakeHeader;
20691 craig 389
                                                                ScTextStream ts2(&m_BBox, QIODevice::ReadOnly);
6653 fschmid 390
                                                                ts2 >> x >> y >> b >> h;
6664 fschmid 391
                                                                fakeHeader.width = qRound(b);
392
                                                                fakeHeader.height = qRound(h);
24186 craig 393
                                                                parseResourceData(strPhot, fakeHeader, psdata.size());
22605 craig 394
                                                                m_imageInfoRecord.valid = (m_imageInfoRecord.PDSpathData.size()) > 0;
395
                                                                if (!m_imageInfoRecord.PDSpathData.empty())
12672 fschmid 396
                                                                {
13951 fschmid 397
                                                                        QTransform mm;
12672 fschmid 398
                                                                        mm.scale(m_imageInfoRecord.xres / 72.0, m_imageInfoRecord.yres / 72.0);
399
                                                                        QMap<QString, FPointArray>::Iterator it;
400
                                                                        for (it = m_imageInfoRecord.PDSpathData.begin(); it != m_imageInfoRecord.PDSpathData.end(); ++it)
401
                                                                        {
402
                                                                                it.value().map(mm);
403
                                                                        }
20248 fschmid 404
                                                                }
20691 craig 405
                                                                m_isPhotoshop = true;
6653 fschmid 406
                                                                break;
407
                                                        }
8569 jghali 408
                                                        for (int a = 2; a < tmp.length(); a += 2)
6653 fschmid 409
                                                        {
410
                                                                bool ok;
24834 jghali 411
                                                                ushort data = QStringView(tmp).sliced(a, 2).toUShort(&ok, 16);
6653 fschmid 412
                                                                psdata.resize(psdata.size()+1);
413
                                                                psdata[psdata.size()-1] = data;
414
                                                        }
415
                                                }
20691 craig 416
                                                if ((m_doThumbnail) && ((m_hasThumbnail) || (!m_imageInfoRecord.exifInfo.thumbnail.isNull())))
7196 fschmid 417
                                                        return true;
6653 fschmid 418
                                        }
6664 fschmid 419
                                        if (tmp.startsWith("%%BeginICCProfile:"))
420
                                        {
421
                                                QByteArray psdata;
422
                                                while (!ts.atEnd())
423
                                                {
22408 jghali 424
                                                        tmp = readLineFromDataStream(ts);
8569 jghali 425
                                                        for (int a = 2; a < tmp.length(); a += 2)
6664 fschmid 426
                                                        {
427
                                                                bool ok;
24834 jghali 428
                                                                ushort data = QStringView(tmp).sliced(a, 2).toUShort(&ok, 16);
6664 fschmid 429
                                                                psdata.resize(psdata.size()+1);
430
                                                                psdata[psdata.size()-1] = data;
431
                                                        }
432
                                                        if (tmp.startsWith("%%EndICCProfile"))
433
                                                        {
14491 jghali 434
                                                                ScColorMgmtEngine engine(ScCore->defaultEngine);
14170 jghali 435
                                                                ScColorProfile prof = engine.openProfileFromMem(psdata);
6664 fschmid 436
                                                                if (prof)
437
                                                                {
14772 jghali 438
                                                                        if (prof.colorSpace() == ColorSpace_Rgb)
6664 fschmid 439
                                                                                m_profileComponents = 3;
14772 jghali 440
                                                                        if (prof.colorSpace() == ColorSpace_Cmyk)
6664 fschmid 441
                                                                                m_profileComponents = 4;
14170 jghali 442
                                                                        m_imageInfoRecord.profileName = prof.productDescription();
6664 fschmid 443
                                                                        m_imageInfoRecord.isEmbedded = true;
14170 jghali 444
                                                                        m_embeddedProfile = psdata;
6664 fschmid 445
                                                                }
446
                                                                break;
447
                                                        }
448
                                                }
449
                                        }
6653 fschmid 450
                                        if (psFound)
451
                                                break;
452
                                }
453
                        }
24735 jghali 454
                        if (psFound && !isAtend)
5937 jghali 455
                                break;
456
                }
457
        }
458
        f.close();
20046 fschmid 459
        return true;
6660 fschmid 460
}
461
 
12141 avox 462
bool ScImgDataLoader_PS::loadPicture(const QString& fn, int page, int gsRes, bool thumbnail)
6660 fschmid 463
{
20046 fschmid 464
        double x = 0;
465
        double y = 0;
466
        double b = 0;
467
        double h = 0;
6660 fschmid 468
        bool found = false;
24735 jghali 469
 
470
        QFileInfo fi(fn);
6660 fschmid 471
        if (!fi.exists())
472
                return false;
10561 fschmid 473
        QString ext = fi.suffix().toLower();
6808 fschmid 474
        if (ext.isEmpty())
475
                ext = getImageType(fn);
24735 jghali 476
 
21526 craig 477
        QString tmpFile = QDir::toNativeSeparators(ScPaths::tempFileDir() + QString("sc%1.png").arg(qMax(1, page)));
478
        QString tmpFiles = QDir::toNativeSeparators(ScPaths::tempFileDir() + "sc%d.png");
16577 craig 479
        QString picFile = QDir::toNativeSeparators(fn);
24735 jghali 480
 
6660 fschmid 481
        float xres = gsRes;
482
        float yres = gsRes;
483
 
484
        initialize();
12141 avox 485
 
11331 jghali 486
        m_imageInfoRecord.type = ImageTypeEPS;
6660 fschmid 487
        m_imageInfoRecord.exifDataValid = false;
12141 avox 488
        m_imageInfoRecord.numberOfPages = 1; // will be overwritten by parse()
20691 craig 489
        m_doThumbnail = thumbnail;
490
        m_colorPlates2.clear();
491
        m_colorPlates.clear();
492
        m_CustColors.clear();
493
        m_CustColors.insert("Cyan", ScColor(255, 0, 0, 0));
494
        m_CustColors.insert("Magenta", ScColor(0, 255, 0, 0));
495
        m_CustColors.insert("Yellow", ScColor(0, 0, 255, 0));
496
        m_CustColors.insert("Black", ScColor(0, 0, 0, 255));
6660 fschmid 497
        found = parseData(fn);
20691 craig 498
        if (m_FontListe.count() != 0)
6759 fschmid 499
        {
500
                scanForFonts(fn);
20691 craig 501
                if (m_FontListe.count() != 0)
6759 fschmid 502
                {
503
                        bool missing = false;
25070 craig 504
                        QString missingF;
20691 craig 505
                        for (int fo = 0; fo < m_FontListe.count(); fo++)
6759 fschmid 506
                        {
23060 craig 507
                                if (!PrefsManager::instance().appPrefs.fontPrefs.AvailFonts.contains(m_FontListe[fo]))
6759 fschmid 508
                                {
509
                                        missing = true;
20691 craig 510
                                        missingF += m_FontListe[fo]+"\n";
6759 fschmid 511
                                }
512
                        }
513
                        if (missing)
514
                        {
12631 fschmid 515
                                m_message = QObject::tr("The Font(s):\n%1 are not embedded or available for Scribus.\nThey might be replaced by \"Courier\", depending how your Ghostscript is configured.\nTherefore the image may be not correct").arg(missingF);
6759 fschmid 516
                                m_msgType = warningMsg;
517
                        }
518
                }
519
        }
6716 fschmid 520
        if ((thumbnail) && (m_imageInfoRecord.exifDataValid) && (!m_imageInfoRecord.exifInfo.thumbnail.isNull()))
6653 fschmid 521
        {
20691 craig 522
                ScTextStream ts2(&m_BBox, QIODevice::ReadOnly);
6653 fschmid 523
                ts2 >> x >> y >> b >> h;
6664 fschmid 524
                m_imageInfoRecord.exifInfo.width = qRound(b);
525
                m_imageInfoRecord.exifInfo.height = qRound(h);
6653 fschmid 526
                m_image = m_imageInfoRecord.exifInfo.thumbnail;
24735 jghali 527
                if (m_isPhotoshop && m_hasPhotoshopImageData)
6709 fschmid 528
                {
20691 craig 529
                        m_imageInfoRecord.exifInfo.width = m_psXSize;
530
                        m_imageInfoRecord.exifInfo.height = m_psYSize;
11331 jghali 531
                        m_imageInfoRecord.type = ImageType7;
20691 craig 532
                        if (m_psMode == 4)
6716 fschmid 533
                        {
11331 jghali 534
                                m_imageInfoRecord.colorspace = ColorSpaceCMYK;
7175 fschmid 535
                                QRgb *s;
536
                                unsigned char cc, cm, cy, ck;
22723 jghali 537
                                for (int yit = 0; yit < m_image.height(); ++yit)
6716 fschmid 538
                                {
7175 fschmid 539
                                        s = (QRgb*)(m_image.scanLine( yit ));
22723 jghali 540
                                        for (int xit = 0; xit < m_image.width(); ++xit)
6716 fschmid 541
                                        {
7175 fschmid 542
                                                cc = 255 - qRed(*s);
543
                                                cm = 255 - qGreen(*s);
544
                                                cy = 255 - qBlue(*s);
8562 jghali 545
                                                ck = qMin(qMin(cc, cm), cy);
6716 fschmid 546
                                                *s = qRgba(cc-ck,cm-ck,cy-ck,ck);
547
                                                s++;
548
                                        }
549
                                }
550
                        }
6709 fschmid 551
                        else
11331 jghali 552
                                m_imageInfoRecord.colorspace = ColorSpaceRGB;
6709 fschmid 553
                }
6716 fschmid 554
                else
11331 jghali 555
                        m_imageInfoRecord.colorspace = ColorSpaceRGB;
12141 avox 556
                m_imageInfoRecord.actualPageNumber = page;
15128 jghali 557
                m_pixelFormat = Format_BGRA_8;
6653 fschmid 558
                return true;
559
        }
5937 jghali 560
        if (found)
561
        {
20691 craig 562
                if (m_isDCS1)
6660 fschmid 563
                        loadDCS1(fn, gsRes);
20691 craig 564
                else if (m_isDCS2)
6669 fschmid 565
                        loadDCS2(fn, gsRes);
24735 jghali 566
                else if (m_isPhotoshop && m_hasPhotoshopImageData)
6709 fschmid 567
                        loadPhotoshop(fn, gsRes);
6664 fschmid 568
                else if ((!m_imageInfoRecord.isEmbedded) || ((m_imageInfoRecord.isEmbedded) && (m_profileComponents == 3)))
6660 fschmid 569
                {
20691 craig 570
                        ScTextStream ts2(&m_BBox, QIODevice::ReadOnly);
6660 fschmid 571
                        ts2 >> x >> y >> b >> h;
572
                        QStringList args;
573
                        xres = gsRes;
574
                        yres = gsRes;
10136 cbradney 575
                        if (extensionIndicatesEPS(ext))
10829 fschmid 576
                        {
20691 craig 577
                                if (!m_BBoxInTrailer)
10829 fschmid 578
                                        args.append("-dEPSCrop");
579
                        }
6660 fschmid 580
                        args.append("-r"+QString::number(gsRes));
12141 avox 581
                        args.append("-sOutputFile="+tmpFiles);
6660 fschmid 582
                        args.append(picFile);
10829 fschmid 583
                        h = h * gsRes / 72.0;
6660 fschmid 584
                        int retg = callGS(args);
585
                        if (retg == 0)
5937 jghali 586
                        {
6660 fschmid 587
                                m_image.load(tmpFile);
24735 jghali 588
                                if ((extensionIndicatesEPS(ext) && m_BBoxInTrailer) || m_isRotated)
5937 jghali 589
                                {
10829 fschmid 590
                                        int ex = qRound(x * gsRes / 72.0);
591
                                        int ey = qRound(m_image.height() - h);
592
                                        int ew = qRound((b - x) * gsRes / 72.0);
593
                                        int eh = qRound(h - y * gsRes / 72.0);
594
                                        m_image = m_image.copy(ex, ey, ew, eh);
595
                                }
24735 jghali 596
                                if (!ScCore->havePNGAlpha() || m_isRotated)
10829 fschmid 597
                                {
6660 fschmid 598
                                        int wi = m_image.width();
599
                                        int hi = m_image.height();
24735 jghali 600
                                        QRgb alphaFF = qRgba(255, 255, 255, 255);
601
                                        QRgb alpha00 = qRgba(255, 255, 255,   0);
7175 fschmid 602
                                        QRgb *s;
22721 jghali 603
                                        for (int yi = 0; yi < hi; ++yi)
5937 jghali 604
                                        {
7175 fschmid 605
                                                s = (QRgb*)(m_image.scanLine( yi ));
22721 jghali 606
                                                for (int xi = 0; xi < wi; ++xi)
6660 fschmid 607
                                                {
22721 jghali 608
                                                        if ((*s) == alphaFF)
6660 fschmid 609
                                                                (*s) &= alpha00;
610
                                                        s++;
611
                                                }
5937 jghali 612
                                        }
613
                                }
12141 avox 614
 
24735 jghali 615
                                QStringList files("sc*.png");
21526 craig 616
                                files = QDir(ScPaths::tempFileDir()).entryList(files);
12141 avox 617
                                for (int i=0; i < files.count(); ++i)
21526 craig 618
                                        QFile::remove(QDir::toNativeSeparators(ScPaths::tempFileDir() + files[i]));
12141 avox 619
 
10136 cbradney 620
                                if (extensionIndicatesEPS(ext))
6660 fschmid 621
                                {
622
                                        m_imageInfoRecord.BBoxX = static_cast<int>(x);
623
                                        m_imageInfoRecord.BBoxH = static_cast<int>(h);
624
                                }
625
                                else
626
                                {
627
                                        m_imageInfoRecord.BBoxX = 0;
628
                                        m_imageInfoRecord.BBoxH = m_image.height();
629
                                }
18194 fschmid 630
                                m_imageInfoRecord.xres = gsRes;
631
                                m_imageInfoRecord.yres = gsRes;
6664 fschmid 632
                                if ((m_imageInfoRecord.isEmbedded) && (m_profileComponents == 3))
11331 jghali 633
                                        m_imageInfoRecord.type = ImageType7;
634
                                m_imageInfoRecord.colorspace = ColorSpaceRGB;
6660 fschmid 635
                                m_image.setDotsPerMeterX ((int) (xres / 0.0254));
636
                                m_image.setDotsPerMeterY ((int) (yres / 0.0254));
15128 jghali 637
                                m_pixelFormat = Format_BGRA_8;
5937 jghali 638
                        }
6660 fschmid 639
                }
6664 fschmid 640
                else
641
                {
20691 craig 642
                        ScTextStream ts2(&m_BBox, QIODevice::ReadOnly);
6664 fschmid 643
                        ts2 >> x >> y >> b >> h;
644
                        h = h * gsRes / 72.0;
645
                        QStringList args;
646
                        xres = gsRes;
647
                        yres = gsRes;
10136 cbradney 648
                        if (extensionIndicatesEPS(ext))
6664 fschmid 649
                                args.append("-dEPSCrop");
650
                        args.append("-dGrayValues=256");
651
                        args.append("-r"+QString::number(gsRes));
12141 avox 652
                        args.append("-sOutputFile="+tmpFiles);
6664 fschmid 653
                        args.append(picFile);
12141 avox 654
//                      qDebug() << "scimgdataloader_ps:" << args;
20046 fschmid 655
                        int retg = callGS(args);
6664 fschmid 656
                        if (retg == 0)
657
                        {
20046 fschmid 658
                                m_image.load(tmpFile);
659
                                x = 0;
660
                                b = m_image.width() / gsRes * 72.0;
661
                                h = m_image.height() / gsRes * 72.0;
662
                        }
663
                        retg = callGS(args, "bitcmyk");
664
                        if (retg == 0)
665
                        {
10561 fschmid 666
                                m_image = QImage( qRound(b * gsRes / 72.0), qRound(h * gsRes / 72.0), QImage::Format_ARGB32 );
6669 fschmid 667
                                m_image.fill(qRgba(0, 0, 0, 0));
6664 fschmid 668
                                int w = qRound(b * gsRes / 72.0);
669
                                int w2 = 4*w;
670
                                int h2 = qRound(h * gsRes / 72.0);
671
                                uint *p;
672
                                int cyan, magenta, yellow, black;
10561 fschmid 673
                                QByteArray imgc(w2, ' ');
6664 fschmid 674
                                QFile f(tmpFile);
8501 cbradney 675
                                if (f.open(QIODevice::ReadOnly))
6664 fschmid 676
                                {
677
                                        for (int y=0; y < h2; ++y )
678
                                        {
679
                                                p = (uint *)m_image.scanLine( y );
10561 fschmid 680
                                                f.read(imgc.data(), w2);
6664 fschmid 681
                                                for (int x=0; x < w2; x += 4 )
682
                                                {
683
                                                        cyan = uchar(imgc[x]);
684
                                                        magenta = uchar(imgc[x + 1]);
685
                                                        yellow = uchar(imgc[x + 2]);
686
                                                        black = uchar(imgc[x + 3]);
687
                                                        *p = qRgba(cyan, magenta, yellow, black);
688
                                                        p++;
689
                                                }
690
                                        }
691
                                        f.close();
692
                                }
12141 avox 693
 
24735 jghali 694
                                QStringList files("sc*.png");
21526 craig 695
                                files = QDir(ScPaths::tempFileDir()).entryList(files);
12141 avox 696
                                for (int i=0; i < files.count(); ++i)
21526 craig 697
                                        QFile::remove(QDir::toNativeSeparators(ScPaths::tempFileDir() + files[i]));
12141 avox 698
 
10136 cbradney 699
                                if (extensionIndicatesEPS(ext))
6664 fschmid 700
                                {
701
                                        m_imageInfoRecord.BBoxX = static_cast<int>(x);
702
                                        m_imageInfoRecord.BBoxH = static_cast<int>(h);
703
                                }
704
                                else
705
                                {
706
                                        m_imageInfoRecord.BBoxX = 0;
707
                                        m_imageInfoRecord.BBoxH = m_image.height();
708
                                }
18194 fschmid 709
                                m_imageInfoRecord.xres = gsRes;
710
                                m_imageInfoRecord.yres = gsRes;
11331 jghali 711
                                m_imageInfoRecord.colorspace = ColorSpaceCMYK;
712
                                m_imageInfoRecord.type = ImageType7;
6664 fschmid 713
                                m_image.setDotsPerMeterX ((int) (xres / 0.0254));
714
                                m_image.setDotsPerMeterY ((int) (yres / 0.0254));
16352 fschmid 715
                                m_pixelFormat = Format_YMCK_8;
6664 fschmid 716
                        }
12141 avox 717
                        else
718
                        {
719
                                qDebug() << "Ghostscript returned result" << retg;
720
                        }
6664 fschmid 721
                }
12141 avox 722
                m_imageInfoRecord.actualPageNumber = page;
6660 fschmid 723
                return true;
724
        }
725
        return false;
726
}
727
 
22635 craig 728
void ScImgDataLoader_PS::loadPhotoshop(const QString& fn, int gsRes)
6709 fschmid 729
{
20691 craig 730
        if ((m_psDataType >= 1) && (m_psDataType <= 6) && ((m_psMode == 3) || (m_psMode == 4)))
6760 fschmid 731
        {
732
                loadPhotoshopBinary(fn);
733
                return;
734
        }
6709 fschmid 735
        QStringList args;
24735 jghali 736
        QFileInfo fi(fn);
10561 fschmid 737
        QString ext = fi.suffix().toLower();
21526 craig 738
        QString tmpFile = QDir::toNativeSeparators(ScPaths::tempFileDir() + "sc1.png");
6709 fschmid 739
        int retg;
22573 jghali 740
        int GsVersion;
741
        getNumericGSVersion(GsVersion);
20691 craig 742
        ScTextStream ts2(&m_BBox, QIODevice::ReadOnly);
22306 craig 743
        double x, y, b, h;
6709 fschmid 744
        ts2 >> x >> y >> b >> h;
745
        h = h * gsRes / 72.0;
10136 cbradney 746
        if (extensionIndicatesEPS(ext))
6709 fschmid 747
                args.append("-dEPSCrop");
20691 craig 748
        if (m_psMode == 4)
6709 fschmid 749
                args.append("-dGrayValues=256");
22573 jghali 750
        if (GsVersion >= 853)
6709 fschmid 751
                args.append("-dNOPSICC");               // prevent GS from applying an embedded ICC profile as it will be applied later on in ScImage.
752
        args.append("-r"+QString::number(gsRes));
12141 avox 753
        args.append("-sOutputFile=" + tmpFile);
16577 craig 754
        args.append(QDir::toNativeSeparators(fn));
20691 craig 755
        if (m_psMode == 4)
6709 fschmid 756
                retg = callGS(args, "bitcmyk");
757
        else
758
                retg = callGS(args);
759
        if (retg == 0)
760
        {
20691 craig 761
                if (m_psMode == 4)
6709 fschmid 762
                {
10561 fschmid 763
                        m_image = QImage( qRound(b * gsRes / 72.0), qRound(h * gsRes / 72.0), QImage::Format_ARGB32 );
6709 fschmid 764
                        m_image.fill(qRgba(0, 0, 0, 0));
765
                        int w = qRound(b * gsRes / 72.0);
766
                        int w2 = 4*w;
767
                        int h2 = qRound(h * gsRes / 72.0);
768
                        uint *p;
769
                        int cyan, magenta, yellow, black;
10561 fschmid 770
                        QByteArray imgc(w2, ' ');
6709 fschmid 771
                        QFile f(tmpFile);
8501 cbradney 772
                        if (f.open(QIODevice::ReadOnly))
6709 fschmid 773
                        {
774
                                for (int y=0; y < h2; ++y )
775
                                {
776
                                        p = (uint *)m_image.scanLine( y );
10561 fschmid 777
                                        f.read(imgc.data(), w2);
6709 fschmid 778
                                        for (int x=0; x < w2; x += 4 )
779
                                        {
780
                                                cyan = uchar(imgc[x]);
781
                                                magenta = uchar(imgc[x + 1]);
782
                                                yellow = uchar(imgc[x + 2]);
783
                                                black = uchar(imgc[x + 3]);
784
                                                *p = qRgba(cyan, magenta, yellow, black);
785
                                                p++;
786
                                        }
787
                                }
788
                                f.close();
789
                        }
11331 jghali 790
                        m_imageInfoRecord.colorspace = ColorSpaceCMYK;
791
                        m_imageInfoRecord.type = ImageType7;
16352 fschmid 792
                        m_pixelFormat = Format_YMCK_8;
6709 fschmid 793
                }
794
                else
795
                {
796
                        m_image.load(tmpFile);
10829 fschmid 797
                        if (!ScCore->havePNGAlpha())
6709 fschmid 798
                        {
799
                                int wi = m_image.width();
800
                                int hi = m_image.height();
7175 fschmid 801
                                QRgb alphaFF = qRgba(255,255,255,255);
802
                                QRgb alpha00 = qRgba(255,255,255,  0);
803
                                QRgb *s;
22721 jghali 804
                                for (int yi = 0; yi < hi; ++yi)
6709 fschmid 805
                                {
7175 fschmid 806
                                        s = (QRgb*)(m_image.scanLine( yi ));
22721 jghali 807
                                        for (int xi = 0; xi < wi; ++xi)
6709 fschmid 808
                                        {
22721 jghali 809
                                                if ((*s) == alphaFF)
6709 fschmid 810
                                                        (*s) &= alpha00;
811
                                                s++;
812
                                        }
813
                                }
814
                        }
11331 jghali 815
                        m_imageInfoRecord.type = ImageType7;
816
                        m_imageInfoRecord.colorspace = ColorSpaceRGB;
15128 jghali 817
                        m_pixelFormat = Format_BGRA_8;
6709 fschmid 818
                }
12141 avox 819
 
10561 fschmid 820
                QFile::remove(tmpFile);
12141 avox 821
 
10136 cbradney 822
                if (extensionIndicatesEPS(ext))
6709 fschmid 823
                {
824
                        m_imageInfoRecord.BBoxX = static_cast<int>(x);
825
                        m_imageInfoRecord.BBoxH = static_cast<int>(h);
826
                }
827
                else
828
                {
829
                        m_imageInfoRecord.BBoxX = 0;
830
                        m_imageInfoRecord.BBoxH = m_image.height();
831
                }
832
                m_image.setDotsPerMeterX ((int) (m_imageInfoRecord.xres / 0.0254));
833
                m_image.setDotsPerMeterY ((int) (m_imageInfoRecord.yres / 0.0254));
834
        }
12141 avox 835
        else
836
        {
837
                qDebug() << "Ghostscript returned result" << retg;
838
        }
6709 fschmid 839
}
840
 
22635 craig 841
void ScImgDataLoader_PS::decodeA85(QByteArray &psdata, const QString& tmp)
6762 fschmid 842
{
843
        uchar byte;
844
        ushort data;
845
        unsigned long sum = 0;
12141 avox 846
        int quintet = 0;
8569 jghali 847
        for (int c = 0; c < tmp.length(); c++)
6762 fschmid 848
        {
8569 jghali 849
                byte = QChar(tmp.at(c)).cell();
6762 fschmid 850
                if (byte >= '!' && byte <= 'u')
851
                {
852
                        sum = sum * 85 + ((unsigned long)byte - '!');
853
                        quintet++;
854
                        if (quintet == 5)
855
                        {
856
                                psdata.resize(psdata.size()+4);
857
                                data = sum >> 24;
858
                                psdata[psdata.size()-4] = data;
859
                                data = (sum >> 16) & 0xFF;
860
                                psdata[psdata.size()-3] = data;
861
                                data = (sum >> 8) & 0xFF;
862
                                psdata[psdata.size()-2] = data;
863
                                data = sum & 0xFF;
864
                                psdata[psdata.size()-1] = data;
865
                                quintet = 0;
866
                                sum = 0;
12141 avox 867
                        }
6762 fschmid 868
                }
869
                else if (byte == 'z')
870
                {
871
                        psdata.resize(psdata.size()+4);
872
                        psdata[psdata.size()-4] = 0;
873
                        psdata[psdata.size()-3] = 0;
874
                        psdata[psdata.size()-2] = 0;
875
                        psdata[psdata.size()-1] = 0;
876
                }
877
                else if (byte == '~')
878
                {
879
                        if (quintet)
880
                        {
881
                                int i;
882
                                for (i = 0; i < 5 - quintet; i++)
883
                                        sum *= 85;
884
                                if (quintet > 1)
885
                                        sum += (0xFFFFFF >> ((quintet - 2) * 8));
886
                                for (i = 0; i < quintet - 1; i++)
887
                                {
888
                                        data = (sum >> (24 - 8 * i)) & 0xFF;
889
                                        psdata.resize(psdata.size()+1);
890
                                        psdata[psdata.size()-1] = data;
891
                                }
892
                        }
893
                        break;
894
                }
895
        }
896
}
897
 
898
typedef struct my_error_mgr
899
{
900
        struct jpeg_error_mgr pub;            /* "public" fields */
901
        jmp_buf setjmp_buffer;  /* for return to caller */
902
} *my_error_ptr;
903
 
904
static void my_error_exit (j_common_ptr cinfo)
905
{
906
        my_error_ptr myerr = (my_error_ptr) cinfo->err;
907
        (*cinfo->err->output_message) (cinfo);
908
        longjmp (myerr->setjmp_buffer, 1);
909
}
910
 
22635 craig 911
bool ScImgDataLoader_PS::loadPSjpeg(const QString& fn)
6762 fschmid 912
{
913
        if (!QFile::exists(fn))
914
                return false;
915
        struct jpeg_decompress_struct cinfo;
22635 craig 916
        struct my_error_mgr jerr;
917
        FILE *infile;
6762 fschmid 918
        cinfo.err = jpeg_std_error (&jerr.pub);
919
        jerr.pub.error_exit = my_error_exit;
22518 craig 920
        infile = nullptr;
6762 fschmid 921
        if (setjmp (jerr.setjmp_buffer))
922
        {
923
                jpeg_destroy_decompress (&cinfo);
924
                if (infile)
925
                        fclose (infile);
926
                return false;
927
        }
928
        jpeg_create_decompress (&cinfo);
20720 jghali 929
#if defined(Q_OS_WIN32)
22518 craig 930
        if ((infile = _wfopen((const wchar_t*) fn.utf16(), L"rb")) == nullptr)
20720 jghali 931
                return false;
932
#else
22518 craig 933
        if ((infile = fopen (fn.toLocal8Bit(), "rb")) == nullptr)
6762 fschmid 934
                return false;
20720 jghali 935
#endif
6762 fschmid 936
        jpeg_stdio_src(&cinfo, infile);
937
        jpeg_read_header(&cinfo, true);
938
        jpeg_start_decompress(&cinfo);
939
        if ( cinfo.output_components == 3 || cinfo.output_components == 4)
10561 fschmid 940
                m_image = QImage( cinfo.output_width, cinfo.output_height, QImage::Format_ARGB32 );
6762 fschmid 941
        else if ( cinfo.output_components == 1 )
942
        {
10561 fschmid 943
                m_image = QImage( cinfo.output_width, cinfo.output_height, QImage::Format_Indexed8 );
18194 fschmid 944
                m_image.setColorCount(256);
6762 fschmid 945
                for (int i=0; i<256; i++)
946
                        m_image.setColor(i, qRgb(i,i,i));
947
        }
948
        if (!m_image.isNull())
949
        {
10561 fschmid 950
                uchar* data = m_image.bits();
951
                int bpl = m_image.bytesPerLine();
6762 fschmid 952
                while (cinfo.output_scanline < cinfo.output_height)
10561 fschmid 953
                {
954
                        uchar *d = data + cinfo.output_scanline * bpl;
955
                        (void) jpeg_read_scanlines(&cinfo, &d, 1);
956
                }
6762 fschmid 957
                if ( cinfo.output_components == 3 )
958
                {
7175 fschmid 959
                        uchar *in;
960
                        QRgb *out;
6762 fschmid 961
                        for (uint j=0; j<cinfo.output_height; j++)
962
                        {
7175 fschmid 963
                                in = m_image.scanLine(j) + cinfo.output_width * 3;
964
                                out = (QRgb*) m_image.scanLine(j);
6762 fschmid 965
                                for (uint i=cinfo.output_width; i--; )
966
                                {
967
                                        in -= 3;
968
                                        out[i] = qRgb(in[0], in[1], in[2]);
969
                                }
970
                        }
15128 jghali 971
                        m_pixelFormat = Format_BGRA_8;
6762 fschmid 972
                }
973
                if ( cinfo.output_components == 4 )
974
                {
7175 fschmid 975
                        QRgb *ptr;
976
                        unsigned char c, m, y ,k;
977
                        unsigned char *p;
6762 fschmid 978
                        for (int i = 0; i < m_image.height(); i++)
979
                        {
7175 fschmid 980
                                ptr = (QRgb*)  m_image.scanLine(i);
6762 fschmid 981
                                if ((cinfo.jpeg_color_space == JCS_YCCK) || ((cinfo.jpeg_color_space == JCS_CMYK) && (cinfo.saw_Adobe_marker)))
982
                                {
983
                                        for (int j = 0; j <  m_image.width(); j++)
984
                                        {
7175 fschmid 985
                                                p = (unsigned char *) ptr;
6762 fschmid 986
                                                c = p[0];
987
                                                m = p[1];
988
                                                y =  p[2];
989
                                                k =  p[3];
990
                                                *ptr = qRgba(c, m, y, k);
991
                                                ptr++;
992
                                        }
993
                                }
994
                                else
995
                                {
996
                                        for (int j = 0; j <  m_image.width(); j++)
997
                                        {
7175 fschmid 998
                                                p = (unsigned char *) ptr;
6762 fschmid 999
                                                c = p[0];
1000
                                                m = p[1];
1001
                                                y =  p[2];
1002
                                                k =  p[3];
1003
                                                *ptr = qRgba(y, m, c, k);
1004
                                                ptr++;
1005
                                        }
1006
                                }
1007
                        }
16352 fschmid 1008
                        m_pixelFormat = Format_YMCK_8;
6762 fschmid 1009
                }
1010
                if ( cinfo.output_components == 1 )
1011
                {
10561 fschmid 1012
                        QImage tmpImg = m_image.convertToFormat(QImage::Format_ARGB32);
1013
                        m_image = QImage( cinfo.output_width, cinfo.output_height, QImage::Format_ARGB32 );
7175 fschmid 1014
                        QRgb *s;
1015
                        QRgb *d;
22723 jghali 1016
                        for (int yi=0; yi < tmpImg.height(); ++yi)
6762 fschmid 1017
                        {
7175 fschmid 1018
                                s = (QRgb*)(tmpImg.scanLine( yi ));
1019
                                d = (QRgb*)(m_image.scanLine( yi ));
22723 jghali 1020
                                for (int xi=0; xi < tmpImg.width(); ++xi)
6762 fschmid 1021
                                {
1022
                                        (*d) = (*s);
1023
                                        s++;
1024
                                        d++;
1025
                                }
1026
                        }
15128 jghali 1027
                        m_pixelFormat = Format_BGRA_8;
6762 fschmid 1028
                }
1029
        }
1030
        (void) jpeg_finish_decompress(&cinfo);
1031
        fclose (infile);
1032
        jpeg_destroy_decompress (&cinfo);
1033
        return (!m_image.isNull());
1034
}
1035
 
22635 craig 1036
bool ScImgDataLoader_PS::loadPSjpeg(const QString& fn, QImage &tmpImg)
7195 fschmid 1037
{
1038
        if (!QFile::exists(fn))
1039
                return false;
1040
        struct jpeg_decompress_struct cinfo;
1041
        struct my_error_mgr         jerr;
1042
        FILE     *infile;
1043
        cinfo.err = jpeg_std_error (&jerr.pub);
1044
        jerr.pub.error_exit = my_error_exit;
22518 craig 1045
        infile = nullptr;
7195 fschmid 1046
        if (setjmp (jerr.setjmp_buffer))
1047
        {
1048
                jpeg_destroy_decompress (&cinfo);
1049
                if (infile)
1050
                        fclose (infile);
1051
                return false;
1052
        }
1053
        jpeg_create_decompress (&cinfo);
20720 jghali 1054
#if defined(Q_OS_WIN32)
22518 craig 1055
        if ((infile = _wfopen((const wchar_t*) fn.utf16(), L"rb")) == nullptr)
20720 jghali 1056
                return false;
1057
#else
22518 craig 1058
        if ((infile = fopen (fn.toLocal8Bit(), "rb")) == nullptr)
7195 fschmid 1059
                return false;
20720 jghali 1060
#endif
7195 fschmid 1061
        jpeg_stdio_src(&cinfo, infile);
1062
        jpeg_read_header(&cinfo, true);
1063
        jpeg_start_decompress(&cinfo);
1064
        if ( cinfo.output_components == 3 || cinfo.output_components == 4)
10561 fschmid 1065
                tmpImg = QImage( cinfo.output_width, cinfo.output_height, QImage::Format_ARGB32 );
7195 fschmid 1066
        else if ( cinfo.output_components == 1 )
1067
        {
10561 fschmid 1068
                tmpImg = QImage( cinfo.output_width, cinfo.output_height, QImage::Format_Indexed8 );
18194 fschmid 1069
                m_image.setColorCount(256);
7195 fschmid 1070
                for (int i=0; i<256; i++)
1071
                        tmpImg.setColor(i, qRgb(i,i,i));
15128 jghali 1072
                m_pixelFormat = Format_GRAY_8;
7195 fschmid 1073
        }
1074
        if (!tmpImg.isNull())
1075
        {
10561 fschmid 1076
                uchar* data = tmpImg.bits();
1077
                int bpl = tmpImg.bytesPerLine();
7195 fschmid 1078
                while (cinfo.output_scanline < cinfo.output_height)
10561 fschmid 1079
                {
1080
                        uchar *d = data + cinfo.output_scanline * bpl;
1081
                        (void) jpeg_read_scanlines(&cinfo, &d, 1);
1082
                }
7195 fschmid 1083
                if ( cinfo.output_components == 3 )
1084
                {
1085
                        uchar *in;
1086
                        QRgb *out;
1087
                        for (uint j=0; j<cinfo.output_height; j++)
1088
                        {
1089
                                in = tmpImg.scanLine(j) + cinfo.output_width * 3;
1090
                                out = (QRgb*) tmpImg.scanLine(j);
1091
                                for (uint i=cinfo.output_width; i--; )
1092
                                {
1093
                                        in -= 3;
1094
                                        out[i] = qRgb(in[0], in[1], in[2]);
1095
                                }
1096
                        }
15128 jghali 1097
                        m_pixelFormat = Format_BGRA_8;
7195 fschmid 1098
                }
1099
                if ( cinfo.output_components == 4 )
1100
                {
1101
                        QRgb *ptr;
1102
                        unsigned char c, m, y ,k;
1103
                        unsigned char *p;
1104
                        for (int i = 0; i < tmpImg.height(); i++)
1105
                        {
1106
                                ptr = (QRgb*)  tmpImg.scanLine(i);
1107
                                if ((cinfo.jpeg_color_space == JCS_YCCK) || ((cinfo.jpeg_color_space == JCS_CMYK) && (cinfo.saw_Adobe_marker)))
1108
                                {
1109
                                        for (int j = 0; j <  tmpImg.width(); j++)
1110
                                        {
1111
                                                p = (unsigned char *) ptr;
1112
                                                c = p[0];
1113
                                                m = p[1];
1114
                                                y =  p[2];
1115
                                                k =  p[3];
1116
                                                *ptr = qRgba(c, m, y, k);
1117
                                                ptr++;
1118
                                        }
1119
                                }
1120
                                else
1121
                                {
1122
                                        for (int j = 0; j <  tmpImg.width(); j++)
1123
                                        {
1124
                                                p = (unsigned char *) ptr;
1125
                                                c = p[0];
1126
                                                m = p[1];
1127
                                                y =  p[2];
1128
                                                k =  p[3];
1129
                                                *ptr = qRgba(y, m, c, k);
1130
                                                ptr++;
1131
                                        }
1132
                                }
1133
                        }
16352 fschmid 1134
                        m_pixelFormat = Format_YMCK_8;
7195 fschmid 1135
                }
1136
                if ( cinfo.output_components == 1 )
1137
                {
10561 fschmid 1138
                        QImage tmpImg2 = tmpImg.convertToFormat(QImage::Format_ARGB32);
1139
                        tmpImg = QImage( cinfo.output_width, cinfo.output_height, QImage::Format_ARGB32 );
7195 fschmid 1140
                        QRgb *s;
1141
                        QRgb *d;
22723 jghali 1142
                        for (int yi=0; yi < tmpImg2.height(); ++yi)
7195 fschmid 1143
                        {
1144
                                s = (QRgb*)(tmpImg2.scanLine( yi ));
1145
                                d = (QRgb*)(tmpImg.scanLine( yi ));
22723 jghali 1146
                                for (int xi=0; xi < tmpImg2.width(); ++xi)
7195 fschmid 1147
                                {
1148
                                        (*d) = (*s);
1149
                                        s++;
1150
                                        d++;
1151
                                }
1152
                        }
1153
                }
1154
        }
1155
        (void) jpeg_finish_decompress(&cinfo);
1156
        fclose (infile);
1157
        jpeg_destroy_decompress (&cinfo);
1158
        return (!tmpImg.isNull());
1159
}
1160
 
22635 craig 1161
void ScImgDataLoader_PS::loadPhotoshopBinary(const QString& fn)
6760 fschmid 1162
{
7195 fschmid 1163
        double x, y, b, h;
20691 craig 1164
        ScTextStream ts2(&m_BBox, QIODevice::ReadOnly);
7195 fschmid 1165
        ts2 >> x >> y >> b >> h;
22306 craig 1166
        QString tmpFile(QDir::toNativeSeparators(ScPaths::tempFileDir() + "sc1.jpg"));
6762 fschmid 1167
        QFile f2(tmpFile);
6760 fschmid 1168
        QString tmp;
20691 craig 1169
        m_image = QImage(m_psXSize, m_psYSize, QImage::Format_ARGB32);
6760 fschmid 1170
        m_image.fill(qRgba(0, 0, 0, 0));
20691 craig 1171
        m_imageInfoRecord.xres = qRound(m_psXSize / b * 72.0);
1172
        m_imageInfoRecord.yres = qRound(m_psYSize / h * 72.0);
6760 fschmid 1173
        QByteArray psdata;
1174
        QFile f(fn);
1175
        int yCount = 0;
21980 craig 1176
        if (!f.open(QIODevice::ReadOnly))
6760 fschmid 1177
        {
21980 craig 1178
                qDebug()<<"Failed to open QFile f in ScImgDataLoader_PS::loadPhotoshopBinary";
1179
                return;
1180
        }
1181
        if (m_psDataType > 2)
1182
        {
1183
                if (!f2.open(QIODevice::WriteOnly))
6762 fschmid 1184
                {
21980 craig 1185
                        qDebug()<<"Failed to open QFile f2 in ScImgDataLoader_PS::loadPhotoshopBinary";
1186
                        return;
6762 fschmid 1187
                }
21980 craig 1188
        }
1189
        QDataStream ts(&f);
1190
        while (!ts.atEnd())
1191
        {
22408 jghali 1192
                tmp = readLineFromDataStream(ts);
21980 craig 1193
                if (tmp == m_psCommand)
6760 fschmid 1194
                {
21980 craig 1195
                        if (m_psDataType == 1)
6760 fschmid 1196
                        {
21980 craig 1197
                                QRgb *p;
1198
                                uchar cc, cm, cy, ck;
1199
                                for (int yh = 0; yh < m_image.height(); ++yh )
6760 fschmid 1200
                                {
21980 craig 1201
                                        if (m_psMode == 4)
1202
                                                psdata.resize(m_psXSize * (4 + m_psChannel));
1203
                                        else
1204
                                                psdata.resize(m_psXSize * (3 + m_psChannel));
1205
                                        f.read(psdata.data(), psdata.size());
1206
                                        p = (QRgb *)m_image.scanLine( yh );
1207
                                        for (int xh = 0; xh < m_image.width(); ++xh )
6761 fschmid 1208
                                        {
21980 craig 1209
                                                cc = psdata[xh];
1210
                                                cm = psdata[m_psXSize+xh];
1211
                                                cy = psdata[m_psXSize*2+xh];
1212
                                                ck = psdata[m_psXSize*3+xh];
20691 craig 1213
                                                if (m_psMode == 4)
21980 craig 1214
                                                        *p = qRgba(cc, cm, cy, ck);
6761 fschmid 1215
                                                else
21980 craig 1216
                                                        *p = qRgba(cc, cm, cy, 255);
1217
                                                p++;
6761 fschmid 1218
                                        }
6760 fschmid 1219
                                }
21980 craig 1220
                        }
1221
                        else if (m_psDataType > 1)
1222
                        {
1223
                                while (!ts.atEnd())
6760 fschmid 1224
                                {
22408 jghali 1225
                                        tmp = readLineFromDataStream(ts);
21980 craig 1226
                                        if ((tmp.isEmpty()) || (tmp.startsWith("%%EndBinary")))
1227
                                                break;
1228
                                        if (m_psDataType == 2)
6760 fschmid 1229
                                        {
21980 craig 1230
                                                for (int a = 0; a < tmp.length(); a += 2)
6760 fschmid 1231
                                                {
21980 craig 1232
                                                        bool ok;
24834 jghali 1233
                                                        ushort data = QStringView(tmp).sliced(a, 2).toUShort(&ok, 16);
21980 craig 1234
                                                        psdata.resize(psdata.size()+1);
1235
                                                        psdata[psdata.size()-1] = data;
6760 fschmid 1236
                                                }
1237
                                        }
21980 craig 1238
                                        else
6760 fschmid 1239
                                        {
21980 craig 1240
                                                decodeA85(psdata, tmp);
1241
                                                f2.write(psdata.data(), psdata.size());
1242
                                                psdata.resize(0);
6762 fschmid 1243
                                        }
21980 craig 1244
                                }
1245
                                if (m_psDataType > 2)
1246
                                {
1247
                                        f2.close();
1248
                                        loadPSjpeg(tmpFile);
1249
                                        QFile::remove(tmpFile);
1250
                                }
1251
                                else
1252
                                {
1253
                                        QRgb *p;
1254
                                        uchar cc, cm, cy, ck;
1255
                                        for (int yh = 0; yh < m_image.height(); ++yh )
6762 fschmid 1256
                                        {
21980 craig 1257
                                                p = (QRgb *)m_image.scanLine( yh );
1258
                                                for (int xh = 0; xh < m_image.width(); ++xh )
6761 fschmid 1259
                                                {
21980 craig 1260
                                                        cc = psdata[yCount+xh];
1261
                                                        cm = psdata[yCount+m_psXSize+xh];
1262
                                                        cy = psdata[yCount+m_psXSize*2+xh];
1263
                                                        if (m_psMode == 4)
6762 fschmid 1264
                                                        {
21980 craig 1265
                                                                ck = psdata[yCount+m_psXSize*3+xh];
1266
                                                                *p = qRgba(cc, cm, cy, ck);
6762 fschmid 1267
                                                        }
6761 fschmid 1268
                                                        else
21980 craig 1269
                                                                *p = qRgba(cc, cm, cy, 255);
1270
                                                        p++;
6761 fschmid 1271
                                                }
21980 craig 1272
                                                if (m_psMode == 4)
1273
                                                        yCount += m_psXSize * (4 + m_psChannel);
1274
                                                else
1275
                                                        yCount += m_psXSize * (3 + m_psChannel);
6760 fschmid 1276
                                        }
1277
                                }
1278
                        }
21980 craig 1279
                        if (m_psMode == 4)
1280
                        {
1281
                                m_imageInfoRecord.colorspace = ColorSpaceCMYK;
1282
                                m_pixelFormat = Format_YMCK_8;
1283
                        }
1284
                        else
1285
                        {
1286
                                m_imageInfoRecord.colorspace = ColorSpaceRGB;
1287
                                m_pixelFormat = Format_BGRA_8;
1288
                        }
1289
                        m_imageInfoRecord.type  = ImageType7;
1290
                        m_imageInfoRecord.BBoxX = 0;
1291
                        m_imageInfoRecord.BBoxH = m_image.height();
1292
                        m_image.setDotsPerMeterX ((int) (m_imageInfoRecord.xres / 0.0254));
1293
                        m_image.setDotsPerMeterY ((int) (m_imageInfoRecord.yres / 0.0254));
1294
                        f.close();
1295
                        return;
6760 fschmid 1296
                }
1297
        }
21980 craig 1298
        f.close();
6760 fschmid 1299
}
1300
 
22635 craig 1301
void ScImgDataLoader_PS::loadPhotoshopBinary(const QString& fn, QImage &tmpImg)
7195 fschmid 1302
{
1303
        double x, y, b, h;
20691 craig 1304
        ScTextStream ts2(&m_BBox, QIODevice::ReadOnly);
7195 fschmid 1305
        ts2 >> x >> y >> b >> h;
21526 craig 1306
        QString tmpFile = QDir::toNativeSeparators(ScPaths::tempFileDir() + "sc1.jpg");
7195 fschmid 1307
        QFile f2(tmpFile);
1308
        QString tmp;
20691 craig 1309
        tmpImg = QImage(m_psXSize, m_psYSize, QImage::Format_ARGB32);
7195 fschmid 1310
        tmpImg.fill(qRgba(0, 0, 0, 0));
1311
        QByteArray psdata;
1312
        QFile f(fn);
1313
        int yCount = 0;
8501 cbradney 1314
        if (f.open(QIODevice::ReadOnly))
7195 fschmid 1315
        {
20691 craig 1316
                if (m_psDataType > 2)
7195 fschmid 1317
                {
8501 cbradney 1318
                        f2.open(QIODevice::WriteOnly);
7195 fschmid 1319
                }
9991 fschmid 1320
                QDataStream ts(&f);
7195 fschmid 1321
                while (!ts.atEnd())
1322
                {
22408 jghali 1323
                        tmp = readLineFromDataStream(ts);
20691 craig 1324
                        if (tmp == m_psCommand)
7195 fschmid 1325
                        {
20691 craig 1326
                                if (m_psDataType == 1)
7195 fschmid 1327
                                {
1328
                                        QRgb *p;
1329
                                        uchar cc, cm, cy, ck;
7211 fschmid 1330
                                        for (int yh = 0; yh < tmpImg.height(); ++yh )
7195 fschmid 1331
                                        {
20691 craig 1332
                                                if (m_psMode == 4)
1333
                                                        psdata.resize(m_psXSize * (4 + m_psChannel));
7195 fschmid 1334
                                                else
20691 craig 1335
                                                        psdata.resize(m_psXSize * (3 + m_psChannel));
10561 fschmid 1336
                                                f.read(psdata.data(), psdata.size());
7211 fschmid 1337
                                                p = (QRgb *)tmpImg.scanLine( yh );
1338
                                                for (int xh = 0; xh < tmpImg.width(); ++xh )
7195 fschmid 1339
                                                {
7211 fschmid 1340
                                                        cc = psdata[xh];
20691 craig 1341
                                                        cm = psdata[m_psXSize+xh];
1342
                                                        cy = psdata[m_psXSize*2+xh];
1343
                                                        if (m_psMode == 4)
7211 fschmid 1344
                                                        {
20691 craig 1345
                                                                ck = psdata[m_psXSize*3+xh];
7195 fschmid 1346
                                                                *p = qRgba(cc, cm, cy, ck);
7211 fschmid 1347
                                                        }
7195 fschmid 1348
                                                        else
1349
                                                                *p = qRgba(cc, cm, cy, 255);
1350
                                                        p++;
1351
                                                }
1352
                                        }
1353
                                }
20691 craig 1354
                                else if (m_psDataType > 1)
7195 fschmid 1355
                                {
1356
                                        while (!ts.atEnd())
1357
                                        {
22408 jghali 1358
                                                tmp = readLineFromDataStream(ts);
7195 fschmid 1359
                                                if ((tmp.isEmpty()) || (tmp.startsWith("%%EndBinary")))
1360
                                                        break;
20691 craig 1361
                                                if (m_psDataType == 2)
7195 fschmid 1362
                                                {
8569 jghali 1363
                                                        for (int a = 0; a < tmp.length(); a += 2)
7195 fschmid 1364
                                                        {
1365
                                                                bool ok;
24834 jghali 1366
                                                                ushort data = QStringView(tmp).sliced(a, 2).toUShort(&ok, 16);
7195 fschmid 1367
                                                                psdata.resize(psdata.size()+1);
1368
                                                                psdata[psdata.size()-1] = data;
1369
                                                        }
1370
                                                }
1371
                                                else
1372
                                                {
1373
                                                        decodeA85(psdata, tmp);
10561 fschmid 1374
                                                        f2.write(psdata.data(), psdata.size());
7195 fschmid 1375
                                                        psdata.resize(0);
1376
                                                }
1377
                                        }
20691 craig 1378
                                        if (m_psDataType > 2)
7195 fschmid 1379
                                        {
1380
                                                f2.close();
1381
                                                loadPSjpeg(tmpFile, tmpImg);
10561 fschmid 1382
                                                QFile::remove(tmpFile);
7195 fschmid 1383
                                        }
1384
                                        else
1385
                                        {
1386
                                                QRgb *p;
1387
                                                uchar cc, cm, cy, ck;
7211 fschmid 1388
                                                for (int yh = 0; yh < tmpImg.height(); ++yh )
7195 fschmid 1389
                                                {
7211 fschmid 1390
                                                        p = (QRgb *)tmpImg.scanLine( yh );
1391
                                                        for (int xh = 0; xh < tmpImg.width(); ++xh )
7195 fschmid 1392
                                                        {
7211 fschmid 1393
                                                                cc = psdata[yCount+xh];
20691 craig 1394
                                                                cm = psdata[yCount+m_psXSize+xh];
1395
                                                                cy = psdata[yCount+m_psXSize*2+xh];
1396
                                                                if (m_psMode == 4)
7211 fschmid 1397
                                                                {
20691 craig 1398
                                                                        ck = psdata[yCount+m_psXSize*3+xh];
7195 fschmid 1399
                                                                        *p = qRgba(cc, cm, cy, ck);
7211 fschmid 1400
                                                                }
7195 fschmid 1401
                                                                else
1402
                                                                        *p = qRgba(cc, cm, cy, 255);
1403
                                                                p++;
1404
                                                        }
20691 craig 1405
                                                        if (m_psMode == 4)
1406
                                                                yCount += m_psXSize * (4 + m_psChannel);
7195 fschmid 1407
                                                        else
20691 craig 1408
                                                                yCount += m_psXSize * (3 + m_psChannel);
7195 fschmid 1409
                                                }
1410
                                        }
1411
                                }
7211 fschmid 1412
                                f.close();
1413
                                return;
7195 fschmid 1414
                        }
1415
                }
1416
                f.close();
1417
        }
1418
}
1419
 
22635 craig 1420
void ScImgDataLoader_PS::loadDCS2(const QString& fn, int gsRes)
6669 fschmid 1421
{
1422
        QStringList args;
1423
        double x, y, b, h;
22635 craig 1424
        QFileInfo fi(fn);
10561 fschmid 1425
        QString ext = fi.suffix().toLower();
21526 craig 1426
        QString tmpFile = QDir::toNativeSeparators(ScPaths::tempFileDir() + "sc1.png");
1427
        QString tmpFile2 = QDir::toNativeSeparators(ScPaths::tempFileDir() + "tmp.eps");
10561 fschmid 1428
        QString baseFile = fi.absolutePath();
16577 craig 1429
        QString picFile = QDir::toNativeSeparators(fn);
6669 fschmid 1430
        float xres = gsRes;
1431
        float yres = gsRes;
20691 craig 1432
        ScTextStream ts2(&m_BBox, QIODevice::ReadOnly);
6669 fschmid 1433
        ts2 >> x >> y >> b >> h;
1434
        xres = gsRes;
1435
        yres = gsRes;
24735 jghali 1436
        if (m_isPhotoshop && m_hasPhotoshopImageData)
7195 fschmid 1437
        {
20691 craig 1438
                m_image = QImage(m_psXSize, m_psYSize, QImage::Format_ARGB32);
1439
                xres = m_psXSize / b * 72.0;
1440
                yres = m_psYSize / h * 72.0;
7195 fschmid 1441
        }
1442
        else
10561 fschmid 1443
                m_image = QImage( qRound(b * gsRes / 72.0), qRound(h * gsRes / 72.0), QImage::Format_ARGB32 );
6669 fschmid 1444
        m_image.fill(qRgba(0, 0, 0, 0));
20691 craig 1445
        if (!m_isDCS2multi)
6669 fschmid 1446
        {
20691 craig 1447
                for (QMap<QString, plateOffsets>::Iterator it = m_colorPlates2.begin(); it != m_colorPlates2.end(); ++it)
6669 fschmid 1448
                {
10561 fschmid 1449
                        QByteArray imgc(it.value().len, ' ');
6670 fschmid 1450
                        QFile f(picFile);
8501 cbradney 1451
                        if (f.open(QIODevice::ReadOnly))
6670 fschmid 1452
                        {
10561 fschmid 1453
                                f.seek(it.value().pos);
19730 fschmid 1454
                                f.read(imgc.data(), it.value().len);
6670 fschmid 1455
                        }
1456
                        f.close();
1457
                        QFile f2(tmpFile2);
8501 cbradney 1458
                        if (f2.open(QIODevice::WriteOnly))
10561 fschmid 1459
                                f2.write(imgc.data(), it.value().len);
6670 fschmid 1460
                        f2.close();
1461
                        imgc.resize(0);
24735 jghali 1462
                        if (m_isPhotoshop && m_hasPhotoshopImageData)
6670 fschmid 1463
                        {
1464
                                QImage tmpImg;
7195 fschmid 1465
                                loadPhotoshopBinary(tmpFile2, tmpImg);
20691 craig 1466
                                blendImages(tmpImg, m_CustColors[it.key()]);
6670 fschmid 1467
                        }
7195 fschmid 1468
                        else
1469
                        {
1470
                                args.append("-dEPSCrop");
1471
                                args.append("-r"+QString::number(gsRes));
1472
                                args.append("-sOutputFile="+tmpFile);
1473
                                args.append(tmpFile2);
1474
                                int retg = callGS(args);
1475
                                if (retg == 0)
1476
                                {
1477
                                        QImage tmpImg;
1478
                                        tmpImg.load(tmpFile);
20691 craig 1479
                                        blendImages(tmpImg, m_CustColors[it.key()]);
10561 fschmid 1480
                                        QFile::remove(tmpFile);
7195 fschmid 1481
                                }
1482
                        }
10561 fschmid 1483
                        QFile::remove(tmpFile2);
6669 fschmid 1484
                }
6670 fschmid 1485
        }
1486
        else
1487
        {
20691 craig 1488
                for (QMap<QString, QString>::Iterator it = m_colorPlates.begin(); it != m_colorPlates.end(); ++it)
6669 fschmid 1489
                {
16577 craig 1490
                        tmpFile2 = QDir::toNativeSeparators(baseFile+"/"+it.value());
24735 jghali 1491
                        if (m_isPhotoshop && m_hasPhotoshopImageData)
6670 fschmid 1492
                        {
1493
                                QImage tmpImg;
7195 fschmid 1494
                                loadPhotoshopBinary(tmpFile2, tmpImg);
20691 craig 1495
                                blendImages(tmpImg, m_CustColors[it.key()]);
6670 fschmid 1496
                        }
7195 fschmid 1497
                        else
1498
                        {
1499
                                args.append("-dEPSCrop");
1500
                                args.append("-r"+QString::number(gsRes));
1501
                                args.append("-sOutputFile="+tmpFile);
1502
                                args.append(tmpFile2);
1503
                                int retg = callGS(args);
1504
                                if (retg == 0)
1505
                                {
1506
                                        QImage tmpImg;
1507
                                        tmpImg.load(tmpFile);
20691 craig 1508
                                        blendImages(tmpImg, m_CustColors[it.key()]);
10561 fschmid 1509
                                        QFile::remove(tmpFile);
7195 fschmid 1510
                                }
1511
                                args.clear();
1512
                        }
6669 fschmid 1513
                }
1514
        }
10136 cbradney 1515
        if (extensionIndicatesEPS(ext))
6669 fschmid 1516
        {
1517
                m_imageInfoRecord.BBoxX = static_cast<int>(x);
1518
                m_imageInfoRecord.BBoxH = static_cast<int>(h);
1519
        }
1520
        else
1521
        {
1522
                m_imageInfoRecord.BBoxX = 0;
1523
                m_imageInfoRecord.BBoxH = m_image.height();
1524
        }
7195 fschmid 1525
        m_imageInfoRecord.xres = qRound(xres);
1526
        m_imageInfoRecord.yres = qRound(yres);
11331 jghali 1527
        m_imageInfoRecord.colorspace = ColorSpaceCMYK;
1528
        m_imageInfoRecord.type = ImageType7;
6669 fschmid 1529
        m_image.setDotsPerMeterX ((int) (xres / 0.0254));
1530
        m_image.setDotsPerMeterY ((int) (yres / 0.0254));
16352 fschmid 1531
        m_pixelFormat = Format_YMCK_8;
6669 fschmid 1532
}
1533
 
22635 craig 1534
void ScImgDataLoader_PS::loadDCS1(const QString& fn, int gsRes)
6660 fschmid 1535
{
1536
        QStringList args;
1537
        double x, y, b, h;
24735 jghali 1538
        QFileInfo fi(fn);
10561 fschmid 1539
        QString ext = fi.suffix().toLower();
21526 craig 1540
        QString tmpFile = QDir::toNativeSeparators(ScPaths::tempFileDir() + "sc1.png");
10561 fschmid 1541
        QString baseFile = fi.absolutePath();
6660 fschmid 1542
        QString picFile;
1543
        float xres = gsRes;
1544
        float yres = gsRes;
20691 craig 1545
        ScTextStream ts2(&m_BBox, QIODevice::ReadOnly);
6660 fschmid 1546
        ts2 >> x >> y >> b >> h;
1547
        xres = gsRes;
1548
        yres = gsRes;
10561 fschmid 1549
        m_image = QImage( qRound(b * gsRes / 72.0), qRound(h * gsRes / 72.0), QImage::Format_ARGB32 );
6669 fschmid 1550
        m_image.fill(qRgba(0, 0, 0, 0));
10136 cbradney 1551
        bool isEncapPS=extensionIndicatesEPS(ext);
1552
        if (isEncapPS)
6660 fschmid 1553
                args.append("-dEPSCrop");
1554
        args.append("-r"+QString::number(gsRes));
1555
        args.append("-sOutputFile="+tmpFile);
20691 craig 1556
        picFile = QDir::toNativeSeparators(baseFile+"/"+m_colorPlates["Cyan"]);
6660 fschmid 1557
        args.append(picFile);
1558
        int retg = callGS(args);
1559
        if (retg == 0)
1560
        {
1561
                QImage tmpImg;
1562
                tmpImg.load(tmpFile);
1563
                blendImages(tmpImg, ScColor(255, 0, 0, 0));
10561 fschmid 1564
                QFile::remove(tmpFile);
6660 fschmid 1565
        }
1566
        args.clear();
1567
 
10136 cbradney 1568
        if (isEncapPS)
6660 fschmid 1569
                args.append("-dEPSCrop");
1570
        args.append("-r"+QString::number(gsRes));
1571
        args.append("-sOutputFile="+tmpFile);
20691 craig 1572
        picFile = QDir::toNativeSeparators(baseFile+"/"+m_colorPlates["Magenta"]);
6660 fschmid 1573
        args.append(picFile);
1574
        retg = callGS(args);
1575
        if (retg == 0)
1576
        {
1577
                QImage tmpImg;
1578
                tmpImg.load(tmpFile);
1579
                blendImages(tmpImg, ScColor(0, 255, 0, 0));
10561 fschmid 1580
                QFile::remove(tmpFile);
6660 fschmid 1581
        }
1582
        args.clear();
1583
 
10136 cbradney 1584
        if (isEncapPS)
6660 fschmid 1585
                args.append("-dEPSCrop");
1586
        args.append("-r"+QString::number(gsRes));
1587
        args.append("-sOutputFile="+tmpFile);
20691 craig 1588
        picFile = QDir::toNativeSeparators(baseFile+"/"+m_colorPlates["Yellow"]);
6660 fschmid 1589
        args.append(picFile);
1590
        retg = callGS(args);
1591
        if (retg == 0)
1592
        {
1593
                QImage tmpImg;
1594
                tmpImg.load(tmpFile);
1595
                blendImages(tmpImg, ScColor(0, 0, 255, 0));
10561 fschmid 1596
                QFile::remove(tmpFile);
6660 fschmid 1597
        }
1598
        args.clear();
1599
 
10136 cbradney 1600
        if (isEncapPS)
6660 fschmid 1601
                args.append("-dEPSCrop");
1602
        args.append("-r"+QString::number(gsRes));
1603
        args.append("-sOutputFile="+tmpFile);
20691 craig 1604
        picFile = QDir::toNativeSeparators(baseFile+"/"+m_colorPlates["Black"]);
6660 fschmid 1605
        args.append(picFile);
1606
        retg = callGS(args);
1607
        if (retg == 0)
1608
        {
1609
                QImage tmpImg;
1610
                tmpImg.load(tmpFile);
1611
                blendImages(tmpImg, ScColor(0, 0, 0, 255));
10561 fschmid 1612
                QFile::remove(tmpFile);
6660 fschmid 1613
        }
1614
        args.clear();
1615
 
10136 cbradney 1616
        if (isEncapPS)
6660 fschmid 1617
        {
1618
                m_imageInfoRecord.BBoxX = static_cast<int>(x);
1619
                m_imageInfoRecord.BBoxH = static_cast<int>(h);
1620
        }
1621
        else
1622
        {
1623
                m_imageInfoRecord.BBoxX = 0;
1624
                m_imageInfoRecord.BBoxH = m_image.height();
1625
        }
18194 fschmid 1626
        m_imageInfoRecord.xres = gsRes;
1627
        m_imageInfoRecord.yres = gsRes;
11331 jghali 1628
        m_imageInfoRecord.colorspace = ColorSpaceCMYK;
1629
        m_imageInfoRecord.type = ImageType7;
6660 fschmid 1630
        m_image.setDotsPerMeterX ((int) (xres / 0.0254));
1631
        m_image.setDotsPerMeterY ((int) (yres / 0.0254));
16352 fschmid 1632
        m_pixelFormat = Format_YMCK_8;
6660 fschmid 1633
}
1634
 
24735 jghali 1635
void ScImgDataLoader_PS::blendImages(QImage &source, const ScColor& col)
6660 fschmid 1636
{
1637
        int h = source.height();
1638
        int w = source.width();
1639
        int cyan, c, m, yc, k, cc, mm, yy, kk;
1640
        col.getCMYK(&c, &m, &yc, &k);
7175 fschmid 1641
        QRgb *p;
1642
        QRgb *pq;
6660 fschmid 1643
        for (int y=0; y < h; ++y )
1644
        {
7175 fschmid 1645
                p = (QRgb *)m_image.scanLine( y );
1646
                pq = (QRgb *)source.scanLine( y );
6660 fschmid 1647
                for (int x=0; x < w; ++x )
1648
                {
1649
                        cyan = 255 - qRed(*pq);
1650
                        if (cyan != 0)
5937 jghali 1651
                        {
8562 jghali 1652
                                (c == 0) ? cc = qRed(*p) : cc = qMin(c * cyan / 255 + qRed(*p), 255);
1653
                                (m == 0) ? mm = qGreen(*p) : mm = qMin(m * cyan / 255 + qGreen(*p), 255);
1654
                                (yc == 0) ? yy = qBlue(*p) : yy = qMin(yc * cyan / 255 + qBlue(*p), 255);
1655
                                (k == 0) ? kk = qAlpha(*p) : kk = qMin(k * cyan / 255 + qAlpha(*p), 255);
6660 fschmid 1656
                                *p = qRgba(cc, mm, yy, kk);
5937 jghali 1657
                        }
6660 fschmid 1658
                        p++;
1659
                        pq++;
5937 jghali 1660
                }
1661
        }
1662
}
1663
 
12141 avox 1664
bool ScImgDataLoader_PS::preloadAlphaChannel(const QString& fn, int page, int gsRes, bool& hasAlpha)
5937 jghali 1665
{
1666
        float xres, yres;
12141 avox 1667
 
5937 jghali 1668
        initialize();
12141 avox 1669
 
11468 fschmid 1670
        hasAlpha = false;
24735 jghali 1671
        QFileInfo fi(fn);
5937 jghali 1672
        if (!fi.exists())
11468 fschmid 1673
                return false;
10561 fschmid 1674
        QString ext = fi.suffix().toLower();
21526 craig 1675
        QString tmpFile = QDir::toNativeSeparators(ScPaths::tempFileDir() + QString("sc%1.png").arg(qMax(1, page)));
1676
        QString tmpFiles = QDir::toNativeSeparators(ScPaths::tempFileDir() + "sc%d.png");
16577 craig 1677
        QString picFile = QDir::toNativeSeparators(fn);
5937 jghali 1678
        double x, y, b, h;
1679
        bool found = false;
10829 fschmid 1680
        found = parseData(fn);
5937 jghali 1681
        if (found)
1682
        {
20691 craig 1683
                ScTextStream ts2(&m_BBox, QIODevice::ReadOnly);
5937 jghali 1684
                ts2 >> x >> y >> b >> h;
1685
                h = h * gsRes / 72.0;
1686
                QStringList args;
1687
                xres = gsRes;
1688
                yres = gsRes;
10136 cbradney 1689
                if (extensionIndicatesEPS(ext))
10829 fschmid 1690
                {
20691 craig 1691
                        if (!m_BBoxInTrailer)
10829 fschmid 1692
                                args.append("-dEPSCrop");
1693
                }
5937 jghali 1694
                args.append("-r"+QString::number(gsRes));
12141 avox 1695
                args.append("-sOutputFile="+tmpFiles);
5937 jghali 1696
                args.append(picFile);
12141 avox 1697
//              qDebug() << "scimgdataloader_ps(alpha):" << args;
5937 jghali 1698
                int retg = callGS(args);
1699
                if (retg == 0)
1700
                {
1701
                        m_image.load(tmpFile);
20691 craig 1702
                        if ((extensionIndicatesEPS(ext) && m_BBoxInTrailer) || (m_isRotated))
5937 jghali 1703
                        {
10829 fschmid 1704
                                int ex = qRound(x * gsRes / 72.0);
1705
                                int ey = qRound(m_image.height() - h);
1706
                                int ew = qRound((b - x) * gsRes / 72.0);
1707
                                int eh = qRound(h - y * gsRes / 72.0);
1708
                                m_image = m_image.copy(ex, ey, ew, eh);
1709
                        }
20691 craig 1710
                        if ((!ScCore->havePNGAlpha()) || (m_isRotated))
10829 fschmid 1711
                        {
5937 jghali 1712
                                int wi = m_image.width();
1713
                                int hi = m_image.height();
7175 fschmid 1714
                                QRgb alphaFF = qRgba(255,255,255,255);
1715
                                QRgb alpha00 = qRgba(255,255,255,  0);
1716
                                QRgb *s;
22721 jghali 1717
                                for (int yi = 0; yi < hi; ++yi)
5937 jghali 1718
                                {
22721 jghali 1719
                                        s = (QRgb*)(m_image.scanLine(yi));
1720
                                        for (int xi = 0; xi < wi; ++xi)
5937 jghali 1721
                                        {
22721 jghali 1722
                                                if ((*s) == alphaFF)
5937 jghali 1723
                                                        (*s) &= alpha00;
1724
                                                s++;
1725
                                        }
1726
                                }
1727
                        }
12141 avox 1728
 
24735 jghali 1729
                        QStringList files("sc*.png");
21526 craig 1730
                        files = QDir(ScPaths::tempFileDir()).entryList(files);
12141 avox 1731
                        for (int i=0; i < files.count(); ++i)
21526 craig 1732
                                QFile::remove(QDir::toNativeSeparators(ScPaths::tempFileDir() + files[i]));
12141 avox 1733
 
11468 fschmid 1734
                        hasAlpha = true;
12141 avox 1735
                        m_imageInfoRecord.actualPageNumber = page;
14258 fschmid 1736
                        m_imageInfoRecord.type = ImageTypeEPS;
1737
                        m_imageInfoRecord.colorspace = ColorSpaceRGB;
1738
                        m_image.setDotsPerMeterX ((int) (xres / 0.0254));
1739
                        m_image.setDotsPerMeterY ((int) (yres / 0.0254));
11468 fschmid 1740
                        return true;
5937 jghali 1741
                }
22605 craig 1742
                qDebug() << "Ghostscript returned result" << retg;
11468 fschmid 1743
                return false;
5937 jghali 1744
        }
12141 avox 1745
        m_imageInfoRecord.actualPageNumber = page;
11468 fschmid 1746
        return true;
5937 jghali 1747
}