forked from ImpulseAdventure/JPEGsnoop
-
Notifications
You must be signed in to change notification settings - Fork 0
/
DecodePs.cpp
2983 lines (2606 loc) · 99 KB
/
DecodePs.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
// JPEGsnoop - JPEG Image Decoder & Analysis Utility
// Copyright (C) 2017 - Calvin Hass
// http://www.impulseadventure.com/photo/jpeg-snoop.html
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
#include "stdafx.h"
#include "DecodePs.h"
#include "snoop.h"
#include "JPEGsnoop.h" // for m_pAppConfig get
#include "WindowBuf.h"
// Forward declarations
struct tsIptcField asIptcFields[];
struct tsBimRecord asBimRecords[];
struct tsBimEnum asBimEnums[];
CDecodePs::CDecodePs(CwindowBuf* pWBuf,CDocLog* pLog)
{
// Save copies of class pointers
m_pWBuf = pWBuf;
m_pLog = pLog;
// HACK
// Only select a single layer to decode into the DIB
// FIXME: Need to allow user control over this setting
m_bDisplayLayer = false;
m_nDisplayLayerInd = 0;
m_bDisplayImage = true;
// Ideally this would be passed by constructor, but simply access
// directly for now.
CJPEGsnoopApp* pApp;
pApp = (CJPEGsnoopApp*)AfxGetApp();
m_pAppConfig = pApp->m_pAppConfig;
Reset();
}
void CDecodePs::Reset()
{
m_bPsd = false;
m_nQualitySaveAs = 0;
m_nQualitySaveForWeb = 0;
m_bAbort = false;
}
CDecodePs::~CDecodePs(void)
{
}
// Provide a short-hand alias for the m_pWBuf buffer
// INPUT:
// - offset File offset to read from
// - bClean Forcibly disables any redirection to Fake DHT table
//
// POST:
// - m_pLog
//
// RETURN:
// - Byte from file
//
BYTE CDecodePs::Buf(unsigned long offset,bool bClean=false)
{
return m_pWBuf->Buf(offset,bClean);
}
// Determine if the file is a Photoshop PSD
// If so, parse the headers. Generally want to start at start of file (nPos=0).
bool CDecodePs::DecodePsd(unsigned long nPos,CDIB* pDibTemp,unsigned &nWidth,unsigned &nHeight)
{
CString strTmp;
m_bPsd = false;
CString strSig;
unsigned nVer;
strSig = m_pWBuf->BufReadStrn(nPos,4); nPos+=4;
nVer = m_pWBuf->BufRdAdv2(nPos,PS_BSWAP);
if ((strSig == _T("8BPS")) && (nVer == 1)) {
m_bPsd = true;
m_pLog->AddLine(_T(""));
m_pLog->AddLineHdr(_T("*** Photoshop PSD File Decoding ***"));
m_pLog->AddLine(_T("Decoding Photoshop format..."));
m_pLog->AddLine(_T(""));
} else {
return false;
}
// Rewind back to header (signature)
nPos-=6;
bool bDecOk = true;
tsImageInfo sImageInfo;
PhotoshopParseFileHeader(nPos,3,&sImageInfo);
nWidth = sImageInfo.nImageWidth;
nHeight = sImageInfo.nImageHeight;
PhotoshopParseColorModeSection(nPos,3);
if (bDecOk)
bDecOk &= PhotoshopParseImageResourcesSection(nPos,3);
if (bDecOk)
bDecOk &= PhotoshopParseLayerMaskInfo(nPos,3,pDibTemp);
if (bDecOk) {
unsigned char* pDibBits = NULL;
#ifdef PS_IMG_DEC_EN
if ((pDibTemp) && (m_bDisplayImage)) {
// Allocate the device-independent bitmap (DIB)
// - Although we are creating a 32-bit DIB, it should also
// work to run in 16- and 8-bit modes
// Start by killing old DIB since we might be changing its dimensions
pDibTemp->Kill();
// Allocate the new DIB
bool bDibOk = pDibTemp->CreateDIB(nWidth,nHeight,32);
// Should only return false if already exists or failed to allocate
if (bDibOk) {
// Fetch the actual pixel array
pDibBits = (unsigned char*) ( pDibTemp->GetDIBBitArray() );
}
}
#endif
bDecOk &= PhotoshopParseImageData(nPos,3,&sImageInfo,pDibBits);
PhotoshopParseReportFldOffset(3,_T("Image data decode complete:"),nPos);
}
PhotoshopParseReportNote(3,_T(""));
if (bDecOk) {
} else {
m_pLog->AddLineErr(_T("ERROR: There was a problem during decode. Aborting."));
return false;
}
return true;
}
// Locate a field ID in the constant 8BIM / Image Resource array
//
// INPUT:
// - nBimId = Image Resource ID (16-bit unsigned)
// OUTPUT:
// - nFldInd = Index into asBimRecords[] array
// RETURN:
// - Returns true if ID was found in array
// NOTE:
// - The constant struct array depends on BIM_T_END as a terminator for the list
//
bool CDecodePs::FindBimRecord(unsigned nBimId,unsigned &nFldInd)
{
unsigned nInd=0;
bool bDone=false;
bool bFound=false;
while (!bDone) {
if (asBimRecords[nInd].eBimType == BIM_T_END) {
bDone = true;
} else {
// Support detection of code ranges
unsigned nCodeStart = asBimRecords[nInd].nCode;
unsigned nCodeEnd = asBimRecords[nInd].nCodeEnd;
if ((nCodeEnd == 0) && (nCodeStart == nBimId)) {
// Match with single code (ie. not ranged entry)
bDone = true;
bFound = true;
} else if ((nCodeEnd != 0) && (nCodeStart <= nBimId) && (nCodeEnd >= nBimId)) {
// Match with code in ranged entry
bDone = true;
bFound = true;
} else {
nInd++;
}
}
}
if (bFound) {
nFldInd = nInd;
}
return bFound;
}
// Search the constant array of IPTC fields for the Record:DataSet index
//
// OUTPUT:
// - nFldInd = The index into the array of the located entry (if found)
// RETURN
// - Successfully found the Record:DataSet value
//
bool CDecodePs::LookupIptcField(unsigned nRecord,unsigned nDataSet,unsigned &nFldInd)
{
unsigned nInd=0;
bool bDone=false;
bool bFound=false;
while (!bDone) {
if (asIptcFields[nInd].eFldType == IPTC_T_END) {
bDone = true;
} else {
if ((asIptcFields[nInd].nRecord == nRecord) && (asIptcFields[nInd].nDataSet == nDataSet)) {
bDone = true;
bFound = true;
} else {
nInd++;
}
}
}
if (bFound) {
nFldInd = nInd;
}
return bFound;
}
// Generate the custom-formatted string representing the IPTC field name and value
//
// INPUT:
// - eIptcType = Enumeration representing the IPTC field type
// - nFldCnt = The number of elements in this field to report
// - nPos = The starting file offset for this field
// RETURN:
// - The IPTC formattted string
// NOTE:
// - The IPTC field type is used to determine how to represent the input values
//
CString CDecodePs::DecodeIptcValue(teIptcType eIptcType,unsigned nFldCnt,unsigned long nPos)
{
//unsigned nFldInd = 0;
unsigned nInd;
unsigned nVal;
CString strField = _T("");
CString strByte = _T("");
CString strVal = _T("");
switch (eIptcType) {
case IPTC_T_NUM:
case IPTC_T_NUM1:
case IPTC_T_NUM2:
nVal = m_pWBuf->BufX(nPos,nFldCnt,PS_BSWAP); nPos+=nFldCnt;
nPos += nFldCnt;
strVal.Format(_T("%u"),nVal);
break;
case IPTC_T_HEX:
strVal = _T("[");
for (nInd=0;nInd<nFldCnt;nInd++) {
strByte.Format(_T("0x%02X "),Buf(nPos++));
strVal += strByte;
}
strVal += _T("]");
break;
case IPTC_T_STR:
strVal = _T("\"");
for (nInd=0;nInd<nFldCnt;nInd++) {
strByte.Format(_T("%c"),Buf(nPos++));
strVal += strByte;
}
strVal += _T("\"");
break;
case IPTC_T_UNK:
strVal = _T("???");
default:
break;
}
return strVal;
}
// Decode the IPTC metadata segment
// INPUT:
// nLen : Length of the 8BIM:IPTC resource data
void CDecodePs::DecodeIptc(unsigned long &nPos,unsigned nLen,unsigned nIndent)
{
CString strIndent;
CString strTmp;
CString strIptcTypeName;
CString strIptcField;
CString strIptcVal;
CString strByte;
unsigned long nPosStart;
bool bDone;
unsigned nTagMarker,nRecordNumber,nDataSetNumber,nDataFieldCnt;
strIndent = PhotoshopParseIndent(nIndent);
nPosStart = nPos;
bDone = true;
if (nPos <= nPosStart+nLen) {
// TODO: Should probably check to see if we have at least 5 bytes?
bDone = false;
}
while (!bDone) {
nTagMarker = Buf(nPos+0);
nRecordNumber = Buf(nPos+1);
nDataSetNumber = Buf(nPos+2);
nDataFieldCnt = Buf(nPos+3)*256 + Buf(nPos+4);
nPos+=5;
if (nTagMarker == 0x1C) {
unsigned nFldInd;
teIptcType eIptcType;
if (LookupIptcField(nRecordNumber,nDataSetNumber,nFldInd)) {
strIptcField.Format(_T("%-35s"),(LPCTSTR)asIptcFields[nFldInd].strFldName);
eIptcType = asIptcFields[nFldInd].eFldType;
} else {
strIptcField.Format(_T("%-35s"),_T("?"));
eIptcType = IPTC_T_UNK;
}
strIptcVal = DecodeIptcValue(eIptcType,nDataFieldCnt,nPos);
strTmp.Format(_T("%sIPTC [%03u:%03u] %s = %s"),
(LPCTSTR)strIndent,nRecordNumber,nDataSetNumber,(LPCTSTR)strIptcField,(LPCTSTR)strIptcVal);
m_pLog->AddLine(strTmp);
nPos += nDataFieldCnt;
} else {
// Unknown Tag Marker
// I have seen at least one JPEG file that had an IPTC block with all zeros.
// In this example, the TagMarker check for 0x1C would fail.
// Since we don't know how to parse it, abort now.
strTmp.Format(_T("ERROR: Unknown IPTC TagMarker [0x%02X] @ 0x%08X. Skipping parsing."),nTagMarker,nPos-5);
m_pLog->AddLineErr(strTmp);
#ifdef DEBUG_LOG
CString strDebug;
strDebug.Format(_T("## File=[%-100s] Block=[%-10s] Error=[%s]\n"),(LPCTSTR)m_pAppConfig->strCurFname,
_T("PsDecode"),(LPCTSTR)strTmp);
OutputDebugString(strDebug);
#endif
// Adjust length to end
nPos = nPosStart + nLen;
// Now abort
bDone = true;
}
if (nPos >= nPosStart+nLen) {
bDone = true;
}
}
}
// Create indent string
// - Returns a sequence of spaces according to the indent level
CString CDecodePs::PhotoshopParseIndent(unsigned nIndent)
{
CString strIndent = _T("");
for (unsigned nInd=0;nInd<nIndent;nInd++) {
strIndent += _T(" ");
}
return strIndent;
}
// Get ASCII string according to Photoshop format
// - String length prefix
// - If length is 0 then fixed 4-character string
// - Otherwise it is defined length string (no terminator required)
CString CDecodePs::PhotoshopParseGetLStrAsc(unsigned long &nPos)
{
unsigned nStrLen;
CString strVal = _T("");
nStrLen = m_pWBuf->BufRdAdv4(nPos,PS_BSWAP);
if (nStrLen!=0) {
strVal = m_pWBuf->BufReadStrn(nPos,nStrLen);
nPos += nStrLen;
} else {
// 4 byte string
strVal.Format(_T("%c%c%c%c"),Buf(nPos+0),Buf(nPos+1),Buf(nPos+2),Buf(nPos+3));
nPos+=4;
}
return strVal;
}
// Read a UNICODE string starting at nPos according to Photoshop Unicode string format
// - Start with 4 byte length
// - Follow with UNICODE string
// OUTPUT:
// - The byte offset to advance the file pointer
// RETURN:
// - Unicode string
CString CDecodePs::PhotoshopParseGetBimLStrUni(unsigned long nPos,unsigned &nPosOffset)
{
CString strVal;
unsigned nStrLenActual,nStrLenTrunc;
BYTE anStrBuf[(PS_MAX_UNICODE_STRLEN+1)*2];
wchar_t acStrBuf[(PS_MAX_UNICODE_STRLEN+1)];
BYTE nChVal;
nPosOffset = 0;
nStrLenActual = m_pWBuf->BufX(nPos+nPosOffset,4,PS_BSWAP);
nPosOffset+=4;
nStrLenTrunc = nStrLenActual;
// Initialize return
strVal = _T("");
if (nStrLenTrunc>0) {
// Read unicode bytes into byte array
// Truncate the string, leaving room for terminator
if (nStrLenTrunc>PS_MAX_UNICODE_STRLEN) {
nStrLenTrunc = PS_MAX_UNICODE_STRLEN;
}
for (unsigned nInd=0;nInd<nStrLenTrunc;nInd++) {
// Reverse the order of the bytes
nChVal = Buf(nPos+nPosOffset+(nInd*2)+0);
anStrBuf[(nInd*2)+1] = nChVal;
nChVal = Buf(nPos+nPosOffset+(nInd*2)+1);
anStrBuf[(nInd*2)+0] = nChVal;
}
// TODO: Replace with call to ByteStr2Unicode()
// Ensure it is terminated
anStrBuf[nStrLenTrunc*2+0] = 0;
anStrBuf[nStrLenTrunc*2+1] = 0;
// Copy into unicode string
// Ensure that it is terminated first!
lstrcpyW(acStrBuf,(LPCWSTR)anStrBuf);
// Copy into CString
strVal = acStrBuf;
}
// Update the file position offset
nPosOffset += nStrLenActual*2;
// Return
return strVal;
}
// Display a formatted note line
// - Apply the current indent level (nIndent)
void CDecodePs::PhotoshopParseReportNote(unsigned nIndent,CString strNote)
{
CString strIndent;
CString strLine;
strIndent = PhotoshopParseIndent(nIndent);
strLine.Format(_T("%s%-50s"),(LPCTSTR)strIndent,(LPCTSTR)strNote);
m_pLog->AddLine(strLine);
}
// Display a formatted numeric field with optional units string
// - Report the value with the field name (strField) and current indent level (nIndent)
void CDecodePs::PhotoshopParseReportFldNum(unsigned nIndent,CString strField,unsigned nVal,CString strUnits)
{
CString strIndent;
CString strVal;
CString strLine;
strIndent = PhotoshopParseIndent(nIndent);
strVal.Format(_T("%u"),nVal);
strLine.Format(_T("%s%-50s = %s %s"),(LPCTSTR)strIndent,(LPCTSTR)strField,(LPCTSTR)strVal,(LPCTSTR)strUnits);
m_pLog->AddLine(strLine);
}
// Display a formatted boolean field
// - Report the value with the field name (strField) and current indent level (nIndent)
void CDecodePs::PhotoshopParseReportFldBool(unsigned nIndent,CString strField,unsigned nVal)
{
CString strIndent;
CString strVal;
CString strLine;
strIndent = PhotoshopParseIndent(nIndent);
strVal = (nVal!=0)? _T("true") : _T("false");
strLine.Format(_T("%s%-50s = %s"),(LPCTSTR)strIndent,(LPCTSTR)strField,(LPCTSTR)strVal);
m_pLog->AddLine(strLine);
}
//
// Display a formatted hexadecimal field
// - Report the value with the field name (strField) and current indent level (nIndent)
// - Depending on the length of the buffer, either report the hex value in-line with
// the field name or else start a new row and begin a hex dump
// - Also report the ASCII representation alongside the hex dump
//
// INPUT:
// - nIndent = Current indent level for reporting
// - strField = Field name
// - nPosStart = Field byte array file position start
// - nLen = Field byte array length
//
void CDecodePs::PhotoshopParseReportFldHex(unsigned nIndent,CString strField,unsigned long nPosStart,unsigned nLen)
{
CString strIndent;
unsigned nByte;
CString strPrefix;
CString strByteHex;
CString strByteAsc;
CString strValHex;
CString strValAsc;
CString strLine;
strIndent = PhotoshopParseIndent(nIndent);
if (nLen == 0) {
// Print out the header row, but no data will be shown
strLine.Format(_T("%s%-50s = "),(LPCTSTR)strIndent,(LPCTSTR)strField);
m_pLog->AddLine(strLine);
// Nothing to report, exit now
return;
} else if (nLen <= PS_HEX_MAX_INLINE) {
// Define prefix for row
strPrefix.Format(_T("%s%-50s = "),(LPCTSTR)strIndent,(LPCTSTR)strField);
} else {
// Print out header row
strLine.Format(_T("%s%-50s ="),(LPCTSTR)strIndent,(LPCTSTR)strField);
m_pLog->AddLine(strLine);
// Define prefix for next row
strPrefix.Format(_T("%s"),(LPCTSTR)strIndent);
}
// Build up the hex string
// Limit to PS_HEX_TOTAL bytes
unsigned nRowOffset = 0;
bool bDone = false;
unsigned nLenClip;
nLenClip = min(nLen,PS_HEX_TOTAL);
strValHex = _T("");
strValAsc = _T("");
while (!bDone) {
// Have we reached the end of the data we wish to display?
if (nRowOffset>=nLenClip) {
bDone = true;
} else {
// Reset the cumulative hex/ascii value strings
strValHex = _T("");
strValAsc = _T("");
// Build the hex/ascii value strings
for (unsigned nInd=0;nInd<PS_HEX_MAX_ROW;nInd++) {
if ((nRowOffset+nInd)<nLenClip) {
nByte = m_pWBuf->Buf(nPosStart+nRowOffset+nInd);
strByteHex.Format(_T("%02X "),nByte);
// Only display printable characters
if (isprint(nByte)) {
strByteAsc.Format(_T("%c"),nByte);
} else {
strByteAsc = _T(".");
}
} else {
// Pad out to end of row
strByteHex.Format(_T(" "));
strByteAsc = _T(" ");
}
// Build up the strings
strValHex += strByteHex;
strValAsc += strByteAsc;
}
// Generate the line with Hex and ASCII representations
strLine.Format(_T("%s | 0x%s | %s"),(LPCTSTR)strPrefix,(LPCTSTR)strValHex,(LPCTSTR)strValAsc);
m_pLog->AddLine(strLine);
// Now increment file offset
nRowOffset += PS_HEX_MAX_ROW;
}
}
// If we had to clip the display length, then show ellipsis now
if (nLenClip < nLen) {
strLine.Format(_T("%s | ..."),(LPCTSTR)strPrefix);
m_pLog->AddLine(strLine);
}
}
CString CDecodePs::PhotoshopDispHexWord(unsigned nVal)
{
CString strValHex;
CString strValAsc;
unsigned nByte;
CString strByteHex;
CString strByteAsc;
CString strLine;
// Reset the cumulative hex/ascii value strings
strValHex = _T("");
strValAsc = _T("");
// Build the hex/ascii value strings
for (unsigned nInd=0;nInd<=3;nInd++) {
nByte = (nVal & 0xFF000000) >> 24;
nVal <<= 8;
strByteHex.Format(_T("%02X "),nByte);
// Only display printable characters
if (isprint(nByte)) {
strByteAsc.Format(_T("%c"),nByte);
} else {
strByteAsc = _T(".");
}
// Build up the strings
strValHex += strByteHex;
strValAsc += strByteAsc;
}
// Generate the line with Hex and ASCII representations
strLine.Format(_T("0x%s | %s"),(LPCTSTR)strValHex,(LPCTSTR)strValAsc);
return strLine;
}
// Look up the enumerated constant (nVal) for the specified field (eEnumField)
// - Returns "" if the field wasn't found
CString CDecodePs::PhotoshopParseLookupEnum(teBimEnumField eEnumField,unsigned nVal)
{
CString strVal = _T("");
// Find the enum value
bool bDone = false;
bool bFound = false;
unsigned nEnumInd=0;
while (!bDone) {
if (asBimEnums[nEnumInd].eBimEnum == eEnumField) {
if (asBimEnums[nEnumInd].nVal == nVal) {
bDone = true;
bFound = true;
strVal = asBimEnums[nEnumInd].strVal;
}
}
if (asBimEnums[nEnumInd].eBimEnum == BIM_T_ENUM_END) {
bDone = true;
}
if (!bDone) {
nEnumInd++;
}
}
// If enum wasn't found, then replace by hex value
if (!bFound) {
CString strWord = PhotoshopDispHexWord(nVal);
strVal.Format(_T("? [%s]"),(LPCTSTR)strWord);
}
return strVal;
}
// Display a formatted enumerated type field
// - Look up enumerated constant (nVal) for the given field (eEnumField)
// - Report the value with the field name (strField) and current indent level (nIndent)
void CDecodePs::PhotoshopParseReportFldEnum(unsigned nIndent,CString strField,teBimEnumField eEnumField,unsigned nVal)
{
CString strIndent;
CString strVal;
CString strLine;
strIndent = PhotoshopParseIndent(nIndent);
strVal = PhotoshopParseLookupEnum(eEnumField,nVal);
strLine.Format(_T("%s%-50s = %s"),(LPCTSTR)strIndent,(LPCTSTR)strField,(LPCTSTR)strVal);
m_pLog->AddLine(strLine);
}
// Display a formatted fixed-point field
// - Convert a 32-bit unsigned integer into Photoshop fixed point
// - Assume fixed point representation is 16-bit integer : 16-bit fraction
// - Report the value with the field name (strField) and current indent level (nIndent)
void CDecodePs::PhotoshopParseReportFldFixPt(unsigned nIndent,CString strField,unsigned nVal,CString strUnits)
{
CString strIndent;
CString strVal;
CString strLine;
float fVal;
fVal = (nVal / (float)65536.0);
strIndent = PhotoshopParseIndent(nIndent);
strVal.Format(_T("%.f"),fVal);
strLine.Format(_T("%s%-50s = %s %s"),(LPCTSTR)strIndent,(LPCTSTR)strField,(LPCTSTR)strVal,(LPCTSTR)strUnits);
m_pLog->AddLine(strLine);
}
// Display a formatted fixed-point field
// - Convert a 32-bit unsigned integer into Photoshop floating point
// - Report the value with the field name (strField) and current indent level (nIndent)
void CDecodePs::PhotoshopParseReportFldFloatPt(unsigned nIndent,CString strField,unsigned nVal,CString strUnits)
{
CString strIndent;
CString strVal;
CString strLine;
float fVal;
// Convert 4 byte unsigned int to floating-point
// TODO: Need to check this since Photoshop web spec doesn't
// indicate how floating points are stored.
union tUnionTmp
{
BYTE nVal[4];
float fVal;
};
tUnionTmp myUnion;
// NOTE: Empirically determined the byte order for double representation
myUnion.nVal[3] = static_cast<BYTE>((nVal & 0xFF000000)>>24);
myUnion.nVal[2] = static_cast<BYTE>((nVal & 0x00FF0000)>>16);
myUnion.nVal[1] = static_cast<BYTE>((nVal & 0x0000FF00)>>8);
myUnion.nVal[0] = static_cast<BYTE>((nVal & 0x000000FF)>>0);
fVal = myUnion.fVal;
strIndent = PhotoshopParseIndent(nIndent);
strVal.Format(_T("%.5f"),fVal);
strLine.Format(_T("%s%-50s = %s %s"),(LPCTSTR)strIndent,(LPCTSTR)strField,(LPCTSTR)strVal,(LPCTSTR)strUnits);
m_pLog->AddLine(strLine);
}
// Display a formatted double-precision floating-point field
// - Convert two 32-bit unsigned integers into Photoshop double-precision floating point
// - Report the value with the field name (strField) and current indent level (nIndent)
void CDecodePs::PhotoshopParseReportFldDoublePt(unsigned nIndent,CString strField,unsigned nVal1,unsigned nVal2,CString strUnits)
{
CString strIndent;
CString strVal;
CString strLine;
double dVal;
// Convert 2x4 byte unsigned int to double-point
// TODO: Need to check this since Photoshop web spec doesn't
// indicate how double points are stored.
union tUnionTmp
{
BYTE nVal[8];
double dVal;
};
tUnionTmp myUnion;
// NOTE: Empirically determined the byte order for double representation
myUnion.nVal[7] = static_cast<BYTE>((nVal1 & 0xFF000000)>>24);
myUnion.nVal[6] = static_cast<BYTE>((nVal1 & 0x00FF0000)>>16);
myUnion.nVal[5] = static_cast<BYTE>((nVal1 & 0x0000FF00)>>8);
myUnion.nVal[4] = static_cast<BYTE>((nVal1 & 0x000000FF)>>0);
myUnion.nVal[3] = static_cast<BYTE>((nVal2 & 0xFF000000)>>24);
myUnion.nVal[2] = static_cast<BYTE>((nVal2 & 0x00FF0000)>>16);
myUnion.nVal[1] = static_cast<BYTE>((nVal2 & 0x0000FF00)>>8);
myUnion.nVal[0] = static_cast<BYTE>((nVal2 & 0x000000FF)>>0);
dVal = myUnion.dVal;
strIndent = PhotoshopParseIndent(nIndent);
strVal.Format(_T("%.5f"),dVal);
strLine.Format(_T("%s%-50s = %s %s"),(LPCTSTR)strIndent,(LPCTSTR)strField,(LPCTSTR)strVal,(LPCTSTR)strUnits);
m_pLog->AddLine(strLine);
}
// Display a formatted string field
// - Report the value with the field name (strField) and current indent level (nIndent)
void CDecodePs::PhotoshopParseReportFldStr(unsigned nIndent,CString strField,CString strVal)
{
CString strIndent;
CString strLine;
strIndent = PhotoshopParseIndent(nIndent);
strLine.Format(_T("%s%-50s = \"%s\""),(LPCTSTR)strIndent,(LPCTSTR)strField,(LPCTSTR)strVal);
m_pLog->AddLine(strLine);
}
// Display a formatted file offset field
// - Report the offset with the field name (strField) and current indent level (nIndent)
void CDecodePs::PhotoshopParseReportFldOffset(unsigned nIndent,CString strField,unsigned long nOffset)
{
CString strIndent;
CString strLine;
strIndent = PhotoshopParseIndent(nIndent);
strLine.Format(_T("%s%-50s @ 0x%08X"),(LPCTSTR)strIndent,(LPCTSTR)strField,nOffset);
m_pLog->AddLine(strLine);
}
// Parse the Photoshop IRB Thumbnail Resource
// - NOTE: Returned nPos doesn't take into account JFIF data
void CDecodePs::PhotoshopParseThumbnailResource(unsigned long &nPos,unsigned nIndent)
{
unsigned nVal;
nVal = m_pWBuf->BufRdAdv4(nPos,PS_BSWAP);
PhotoshopParseReportFldNum(nIndent,_T("Format"),nVal,_T(""));
nVal = m_pWBuf->BufRdAdv4(nPos,PS_BSWAP);
PhotoshopParseReportFldNum(nIndent,_T("Width of thumbnail"),nVal,_T("pixels"));
nVal = m_pWBuf->BufRdAdv4(nPos,PS_BSWAP);
PhotoshopParseReportFldNum(nIndent,_T("Height of thumbnail"),nVal,_T("pixels"));
nVal = m_pWBuf->BufRdAdv4(nPos,PS_BSWAP);
PhotoshopParseReportFldNum(nIndent,_T("Widthbytes"),nVal,_T("bytes"));
nVal = m_pWBuf->BufRdAdv4(nPos,PS_BSWAP);
PhotoshopParseReportFldNum(nIndent,_T("Total size"),nVal,_T("bytes"));
nVal = m_pWBuf->BufRdAdv4(nPos,PS_BSWAP);
PhotoshopParseReportFldNum(nIndent,_T("Size after compression"),nVal,_T("bytes"));
nVal = m_pWBuf->BufRdAdv2(nPos,PS_BSWAP);
PhotoshopParseReportFldNum(nIndent,_T("Bits per pixel"),nVal,_T("bits"));
nVal = m_pWBuf->BufRdAdv2(nPos,PS_BSWAP);
PhotoshopParseReportFldNum(nIndent,_T("Number of planes"),nVal,_T(""));
PhotoshopParseReportFldOffset(nIndent,_T("JFIF data"),nPos);
// NOTE: nPos doesn't take into account JFIF data!
}
// Parse the Photoshop IRB Version Info
// INPUT:
// - nPos = File position at start of block
// - nIndent = Indent level for formatted output
// OUTPUT:
// - nPos = File position after reading the block
//
void CDecodePs::PhotoshopParseVersionInfo(unsigned long &nPos,unsigned nIndent)
{
unsigned nVal;
CString strVal;
unsigned nPosOffset;
nVal = m_pWBuf->BufRdAdv4(nPos,PS_BSWAP);
PhotoshopParseReportFldNum(nIndent,_T("Version"),nVal,_T(""));
nVal = m_pWBuf->BufRdAdv1(nPos,PS_BSWAP);
PhotoshopParseReportFldNum(nIndent,_T("hasRealMergedData"),nVal,_T(""));
strVal = PhotoshopParseGetBimLStrUni(nPos,nPosOffset); nPos+=nPosOffset;
PhotoshopParseReportFldStr(nIndent,_T("Writer name"),strVal);
strVal = PhotoshopParseGetBimLStrUni(nPos,nPosOffset); nPos+=nPosOffset;
PhotoshopParseReportFldStr(nIndent,_T("Reader name"),strVal);
nVal = m_pWBuf->BufRdAdv4(nPos,PS_BSWAP);
PhotoshopParseReportFldNum(nIndent,_T("File version"),nVal,_T(""));
}
// Parse the Photoshop IRB Print Scale
// INPUT:
// - nPos = File position at start of block
// - nIndent = Indent level for formatted output
// OUTPUT:
// - nPos = File position after reading the block
//
void CDecodePs::PhotoshopParsePrintScale(unsigned long &nPos,unsigned nIndent)
{
unsigned nVal;
CString strVal;
nVal = m_pWBuf->BufRdAdv2(nPos,PS_BSWAP);
PhotoshopParseReportFldEnum(nIndent,_T("Style"),BIM_T_ENUM_PRINT_SCALE_STYLE,nVal);
nVal = m_pWBuf->BufRdAdv4(nPos,PS_BSWAP);
PhotoshopParseReportFldFloatPt(nIndent,_T("X location"),nVal,_T(""));
nVal = m_pWBuf->BufRdAdv4(nPos,PS_BSWAP);
PhotoshopParseReportFldFloatPt(nIndent,_T("Y location"),nVal,_T(""));
nVal = m_pWBuf->BufRdAdv4(nPos,PS_BSWAP);
PhotoshopParseReportFldFloatPt(nIndent,_T("Scale"),nVal,_T(""));
}
// Parse the Photoshop IRB Global Angle
// INPUT:
// - nPos = File position at start of block
// - nIndent = Indent level for formatted output
// OUTPUT:
// - nPos = File position after reading the block
//
void CDecodePs::PhotoshopParseGlobalAngle(unsigned long &nPos,unsigned nIndent)
{
unsigned nVal;
CString strVal;
nVal = m_pWBuf->BufRdAdv4(nPos,PS_BSWAP);
PhotoshopParseReportFldNum(nIndent,_T("Global Angle"),nVal,_T("degrees"));
}
// Parse the Photoshop IRB Global Altitude
// INPUT:
// - nPos = File position at start of block
// - nIndent = Indent level for formatted output
// OUTPUT:
// - nPos = File position after reading the block
//
void CDecodePs::PhotoshopParseGlobalAltitude(unsigned long &nPos,unsigned nIndent)
{
unsigned nVal;
CString strVal;
nVal = m_pWBuf->BufRdAdv4(nPos,PS_BSWAP);
PhotoshopParseReportFldNum(nIndent,_T("Global Altitude"),nVal,_T(""));
}
// Parse the Photoshop IRB Print Flags
// INPUT:
// - nPos = File position at start of block
// - nIndent = Indent level for formatted output
// OUTPUT:
// - nPos = File position after reading the block
//
void CDecodePs::PhotoshopParsePrintFlags(unsigned long &nPos,unsigned nIndent)
{
unsigned nVal;
CString strVal;
nVal = m_pWBuf->BufRdAdv1(nPos,PS_BSWAP);
PhotoshopParseReportFldBool(nIndent,_T("Labels"),nVal);
nVal = m_pWBuf->BufRdAdv1(nPos,PS_BSWAP);
PhotoshopParseReportFldBool(nIndent,_T("Crop marks"),nVal);
nVal = m_pWBuf->BufRdAdv1(nPos,PS_BSWAP);
PhotoshopParseReportFldBool(nIndent,_T("Color bars"),nVal);
nVal = m_pWBuf->BufRdAdv1(nPos,PS_BSWAP);
PhotoshopParseReportFldBool(nIndent,_T("Registration marks"),nVal);
nVal = m_pWBuf->BufRdAdv1(nPos,PS_BSWAP);
PhotoshopParseReportFldBool(nIndent,_T("Negative"),nVal);
nVal = m_pWBuf->BufRdAdv1(nPos,PS_BSWAP);
PhotoshopParseReportFldBool(nIndent,_T("Flip"),nVal);
nVal = m_pWBuf->BufRdAdv1(nPos,PS_BSWAP);
PhotoshopParseReportFldBool(nIndent,_T("Interpolate"),nVal);
nVal = m_pWBuf->BufRdAdv1(nPos,PS_BSWAP);
PhotoshopParseReportFldBool(nIndent,_T("Caption"),nVal);
nVal = m_pWBuf->BufRdAdv1(nPos,PS_BSWAP);
PhotoshopParseReportFldBool(nIndent,_T("Print flags"),nVal);
}
// Parse the Photoshop IRB Print Flags Information
// INPUT:
// - nPos = File position at start of block
// - nIndent = Indent level for formatted output
// OUTPUT:
// - nPos = File position after reading the block
//
void CDecodePs::PhotoshopParsePrintFlagsInfo(unsigned long &nPos,unsigned nIndent)
{
unsigned nVal;
CString strVal;
nVal = m_pWBuf->BufRdAdv2(nPos,PS_BSWAP);
PhotoshopParseReportFldNum(nIndent,_T("Version"),nVal,_T(""));
nVal = m_pWBuf->BufRdAdv1(nPos,PS_BSWAP);
PhotoshopParseReportFldNum(nIndent,_T("Center crop marks"),nVal,_T(""));
nVal = m_pWBuf->BufRdAdv1(nPos,PS_BSWAP);
PhotoshopParseReportFldNum(nIndent,_T("Reserved"),nVal,_T(""));
nVal = m_pWBuf->BufRdAdv4(nPos,PS_BSWAP);
PhotoshopParseReportFldNum(nIndent,_T("Bleed width value"),nVal,_T(""));
nVal = m_pWBuf->BufRdAdv2(nPos,PS_BSWAP);
PhotoshopParseReportFldNum(nIndent,_T("Bleed width scale"),nVal,_T(""));
}
// Parse the Photoshop IRB Copyright Flag
// INPUT:
// - nPos = File position at start of block
// - nIndent = Indent level for formatted output
// OUTPUT:
// - nPos = File position after reading the block
//
void CDecodePs::PhotoshopParseCopyrightFlag(unsigned long &nPos,unsigned nIndent)
{
unsigned nVal;
CString strVal;
nVal = m_pWBuf->BufRdAdv1(nPos,PS_BSWAP);
PhotoshopParseReportFldBool(nIndent,_T("Copyright flag"),nVal);
}
// Parse the Photoshop IRB Aspect Ratio
// INPUT:
// - nPos = File position at start of block
// - nIndent = Indent level for formatted output
// OUTPUT:
// - nPos = File position after reading the block
//
void CDecodePs::PhotoshopParsePixelAspectRatio(unsigned long &nPos,unsigned nIndent)
{
unsigned nVal,nVal1,nVal2;
CString strVal;
nVal = m_pWBuf->BufRdAdv4(nPos,PS_BSWAP);
PhotoshopParseReportFldNum(nIndent,_T("Version"),nVal,_T(""));
nVal1 = m_pWBuf->BufRdAdv4(nPos,PS_BSWAP);
nVal2 = m_pWBuf->BufRdAdv4(nPos,PS_BSWAP);
PhotoshopParseReportFldDoublePt(nIndent,_T("X/Y Ratio"),nVal1,nVal2,_T(""));
}
// Parse the Photoshop IRB Document-Specific Seed
// INPUT:
// - nPos = File position at start of block
// - nIndent = Indent level for formatted output
// OUTPUT:
// - nPos = File position after reading the block
//
void CDecodePs::PhotoshopParseDocSpecificSeed(unsigned long &nPos,unsigned nIndent)
{
unsigned nVal;
CString strVal;
nVal = m_pWBuf->BufRdAdv4(nPos,PS_BSWAP);
PhotoshopParseReportFldNum(nIndent,_T("Base value"),nVal,_T(""));
}
// Parse the Photoshop IRB Grid and Guides