Coverage Report

Created: 2025-01-23 06:31

/src/dng_sdk/source/dng_shared.cpp
Line
Count
Source (jump to first uncovered line)
1
/*****************************************************************************/
2
// Copyright 2006-2008 Adobe Systems Incorporated
3
// All Rights Reserved.
4
//
5
// NOTICE:  Adobe permits you to use, modify, and distribute this file in
6
// accordance with the terms of the Adobe license agreement accompanying it.
7
/*****************************************************************************/
8
9
/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_shared.cpp#2 $ */ 
10
/* $DateTime: 2012/06/14 20:24:41 $ */
11
/* $Change: 835078 $ */
12
/* $Author: tknoll $ */
13
14
/*****************************************************************************/
15
16
#include "dng_shared.h"
17
18
#include "dng_camera_profile.h"
19
#include "dng_exceptions.h"
20
#include "dng_globals.h"
21
#include "dng_memory.h"
22
#include "dng_parse_utils.h"
23
#include "dng_safe_arithmetic.h"
24
#include "dng_tag_codes.h"
25
#include "dng_tag_types.h"
26
#include "dng_tag_values.h"
27
#include "dng_utils.h"
28
                   
29
/*****************************************************************************/
30
31
dng_camera_profile_info::dng_camera_profile_info ()
32
33
5.19M
  : fBigEndian (false)
34
  
35
5.19M
  , fColorPlanes (0)
36
  
37
5.19M
  , fCalibrationIlluminant1 (lsUnknown)
38
5.19M
  , fCalibrationIlluminant2 (lsUnknown)
39
40
5.19M
  , fColorMatrix1 ()
41
5.19M
  , fColorMatrix2 ()
42
    
43
5.19M
  , fForwardMatrix1 ()
44
5.19M
  , fForwardMatrix2 ()
45
    
46
5.19M
  , fReductionMatrix1 ()
47
5.19M
  , fReductionMatrix2 ()
48
    
49
5.19M
  , fProfileCalibrationSignature ()
50
  
51
5.19M
  , fProfileName ()
52
  
53
5.19M
  , fProfileCopyright ()
54
55
5.19M
  , fEmbedPolicy (pepAllowCopying)
56
  
57
5.19M
  , fProfileHues (0)
58
5.19M
  , fProfileSats (0)
59
5.19M
  , fProfileVals (0)
60
61
5.19M
  , fHueSatDeltas1Offset (0)
62
5.19M
  , fHueSatDeltas1Count  (0)
63
64
5.19M
  , fHueSatDeltas2Offset (0)
65
5.19M
  , fHueSatDeltas2Count  (0)
66
67
5.19M
  , fHueSatMapEncoding (encoding_Linear)
68
  
69
5.19M
  , fLookTableHues (0)
70
5.19M
  , fLookTableSats (0)
71
5.19M
  , fLookTableVals (0)
72
    
73
5.19M
  , fLookTableOffset (0)
74
5.19M
  , fLookTableCount  (0)
75
76
5.19M
  , fLookTableEncoding (encoding_Linear)
77
78
5.19M
  , fBaselineExposureOffset (0, 100)
79
  
80
5.19M
  , fDefaultBlackRender (defaultBlackRender_Auto)
81
82
5.19M
  , fToneCurveOffset     (0)
83
5.19M
  , fToneCurveCount      (0)
84
  
85
5.19M
  , fUniqueCameraModel ()
86
87
5.19M
  {
88
  
89
5.19M
  }
90
                   
91
/*****************************************************************************/
92
93
dng_camera_profile_info::~dng_camera_profile_info ()
94
5.82M
  {
95
  
96
5.82M
  }
97
                   
98
/*****************************************************************************/
99
100
bool dng_camera_profile_info::ParseTag (dng_stream &stream,
101
                    uint32 parentCode,
102
                    uint32 tagCode,
103
                    uint32 tagType,
104
                    uint32 tagCount,
105
                    uint64 tagOffset)
106
79.0M
  {
107
108
79.0M
  switch (tagCode)
109
79.0M
    {
110
      
111
69.0k
    case tcCalibrationIlluminant1:
112
69.0k
      {
113
      
114
69.0k
      CheckTagType (parentCode, tagCode, tagType, ttShort);
115
      
116
69.0k
      CheckTagCount (parentCode, tagCode, tagCount, 1);
117
      
118
69.0k
      fCalibrationIlluminant1 = stream.TagValue_uint32 (tagType);
119
      
120
      #if qDNGValidate
121
122
      if (gVerbose)
123
        {
124
        
125
        printf ("CalibrationIlluminant1: %s\n",
126
            LookupLightSource (fCalibrationIlluminant1));
127
        
128
        }
129
        
130
      #endif
131
        
132
69.0k
      break;
133
      
134
0
      }
135
      
136
6.27k
    case tcCalibrationIlluminant2:
137
6.27k
      {
138
      
139
6.27k
      CheckTagType (parentCode, tagCode, tagType, ttShort);
140
      
141
6.27k
      CheckTagCount (parentCode, tagCode, tagCount, 1);
142
      
143
6.27k
      fCalibrationIlluminant2 = stream.TagValue_uint32 (tagType);
144
      
145
      #if qDNGValidate
146
147
      if (gVerbose)
148
        {
149
        
150
        printf ("CalibrationIlluminant2: %s\n",
151
            LookupLightSource (fCalibrationIlluminant2));
152
        
153
        }
154
        
155
      #endif
156
        
157
6.27k
      break;
158
      
159
0
      }
160
161
152k
    case tcColorMatrix1:
162
152k
      {
163
      
164
152k
      CheckTagType (parentCode, tagCode, tagType, ttSRational);
165
      
166
152k
      if (fColorPlanes == 0)
167
111k
        {
168
      
169
111k
        fColorPlanes = Pin_uint32 (0, tagCount / 3, kMaxColorPlanes);
170
                  
171
111k
        }
172
        
173
152k
      if (!CheckColorImage (parentCode, tagCode, fColorPlanes))
174
19.1k
        return false;
175
        
176
133k
      if (!ParseMatrixTag (stream,
177
133k
                 parentCode,
178
133k
                 tagCode,
179
133k
                 tagType,
180
133k
                 tagCount,
181
133k
                 fColorPlanes,
182
133k
                 3,
183
133k
                 fColorMatrix1))
184
60.4k
        return false;
185
        
186
      #if qDNGValidate
187
      
188
      if (gVerbose)
189
        {
190
        
191
        printf ("ColorMatrix1:\n");
192
        
193
        DumpMatrix (fColorMatrix1);
194
                
195
        }
196
        
197
      #endif
198
        
199
72.6k
      break;
200
      
201
133k
      }
202
203
80.3k
    case tcColorMatrix2:
204
80.3k
      {
205
      
206
80.3k
      CheckTagType (parentCode, tagCode, tagType, ttSRational);
207
      
208
      // Kludge - Hasselblad FFF files are very DNG-like, but sometimes
209
      // only have a ColorMatrix2 tag and no ColorMatrix1 tag.
210
      
211
80.3k
      bool hasselbladHack = (fColorPlanes == 0);
212
      
213
80.3k
      if (hasselbladHack)
214
29.7k
        {
215
        
216
29.7k
        fColorPlanes = Pin_uint32 (0, tagCount / 3, kMaxColorPlanes);
217
        
218
        #if qDNGValidate
219
        
220
        ReportWarning ("ColorMatrix2 without ColorMatrix1");
221
        
222
        #endif
223
      
224
29.7k
        }
225
      
226
80.3k
      if (!CheckColorImage (parentCode, tagCode, fColorPlanes))
227
3.91k
        return false;
228
        
229
76.4k
      if (!ParseMatrixTag (stream,
230
76.4k
                 parentCode,
231
76.4k
                 tagCode,
232
76.4k
                 tagType,
233
76.4k
                 tagCount,
234
76.4k
                 fColorPlanes,
235
76.4k
                 3,
236
76.4k
                 fColorMatrix2))
237
40.2k
        return false;
238
        
239
      #if qDNGValidate
240
      
241
      if (gVerbose)
242
        {
243
        
244
        printf ("ColorMatrix2:\n");
245
        
246
        DumpMatrix (fColorMatrix2);
247
                
248
        }
249
        
250
      #endif
251
        
252
36.2k
      if (hasselbladHack)
253
7.60k
        {
254
        
255
7.60k
        fColorMatrix1 = fColorMatrix2;
256
        
257
7.60k
        fColorMatrix2 = dng_matrix ();
258
        
259
7.60k
        }
260
        
261
36.2k
      break;
262
      
263
76.4k
      }
264
265
34.1k
    case tcForwardMatrix1:
266
34.1k
      {
267
      
268
34.1k
      CheckTagType (parentCode, tagCode, tagType, ttSRational);
269
      
270
34.1k
      if (!CheckColorImage (parentCode, tagCode, fColorPlanes))
271
23.0k
        return false;
272
        
273
11.0k
      if (!ParseMatrixTag (stream,
274
11.0k
                 parentCode,
275
11.0k
                 tagCode,
276
11.0k
                 tagType,
277
11.0k
                 tagCount,
278
11.0k
                 3,
279
11.0k
                 fColorPlanes,
280
11.0k
                 fForwardMatrix1))
281
5.43k
        return false;
282
        
283
      #if qDNGValidate
284
      
285
      if (gVerbose)
286
        {
287
        
288
        printf ("ForwardMatrix1:\n");
289
        
290
        DumpMatrix (fForwardMatrix1);
291
                
292
        }
293
        
294
      #endif
295
        
296
5.65k
      break;
297
      
298
11.0k
      }
299
300
51.4k
    case tcForwardMatrix2:
301
51.4k
      {
302
      
303
51.4k
      CheckTagType (parentCode, tagCode, tagType, ttSRational);
304
      
305
51.4k
      if (!CheckColorImage (parentCode, tagCode, fColorPlanes))
306
39.2k
        return false;
307
        
308
12.1k
      if (!ParseMatrixTag (stream,
309
12.1k
                 parentCode,
310
12.1k
                 tagCode,
311
12.1k
                 tagType,
312
12.1k
                 tagCount,
313
12.1k
                 3,
314
12.1k
                 fColorPlanes,
315
12.1k
                 fForwardMatrix2))
316
4.52k
        return false;
317
        
318
      #if qDNGValidate
319
      
320
      if (gVerbose)
321
        {
322
        
323
        printf ("ForwardMatrix2:\n");
324
        
325
        DumpMatrix (fForwardMatrix2);
326
                
327
        }
328
        
329
      #endif
330
        
331
7.60k
      break;
332
      
333
12.1k
      }
334
335
22.6k
    case tcReductionMatrix1:
336
22.6k
      {
337
      
338
22.6k
      CheckTagType (parentCode, tagCode, tagType, ttSRational);
339
      
340
22.6k
      if (!CheckColorImage (parentCode, tagCode, fColorPlanes))
341
6.25k
        return false;
342
        
343
16.4k
      if (!ParseMatrixTag (stream,
344
16.4k
                 parentCode,
345
16.4k
                 tagCode,
346
16.4k
                 tagType,
347
16.4k
                 tagCount,
348
16.4k
                 3,
349
16.4k
                 fColorPlanes,
350
16.4k
                 fReductionMatrix1))
351
14.7k
        return false;
352
        
353
      #if qDNGValidate
354
      
355
      if (gVerbose)
356
        {
357
        
358
        printf ("ReductionMatrix1:\n");
359
        
360
        DumpMatrix (fReductionMatrix1);
361
                
362
        }
363
        
364
      #endif
365
        
366
1.63k
      break;
367
      
368
16.4k
      }
369
370
21.7k
    case tcReductionMatrix2:
371
21.7k
      {
372
      
373
21.7k
      CheckTagType (parentCode, tagCode, tagType, ttSRational);
374
      
375
21.7k
      if (!CheckColorImage (parentCode, tagCode, fColorPlanes))
376
10.9k
        return false;
377
        
378
10.7k
      if (!ParseMatrixTag (stream,
379
10.7k
                 parentCode,
380
10.7k
                 tagCode,
381
10.7k
                 tagType,
382
10.7k
                 tagCount,
383
10.7k
                 3,
384
10.7k
                 fColorPlanes,
385
10.7k
                 fReductionMatrix2))
386
9.01k
        return false;
387
        
388
      #if qDNGValidate
389
      
390
      if (gVerbose)
391
        {
392
        
393
        printf ("ReductionMatrix2:\n");
394
        
395
        DumpMatrix (fReductionMatrix2);
396
                
397
        }
398
        
399
      #endif
400
        
401
1.73k
      break;
402
      
403
10.7k
      }
404
405
24.6k
    case tcProfileCalibrationSignature:
406
24.6k
      {
407
408
24.6k
      CheckTagType (parentCode, tagCode, tagType, ttAscii, ttByte);
409
      
410
24.6k
      ParseStringTag (stream,
411
24.6k
              parentCode,
412
24.6k
              tagCode,
413
24.6k
              tagCount,
414
24.6k
              fProfileCalibrationSignature,
415
24.6k
              false);
416
      
417
      #if qDNGValidate
418
            
419
      if (gVerbose)
420
        {
421
        
422
        printf ("ProfileCalibrationSignature: ");
423
        
424
        DumpString (fProfileCalibrationSignature);
425
        
426
        printf ("\n");
427
        
428
        }
429
430
      #endif
431
      
432
24.6k
      break;
433
      
434
10.7k
      }
435
      
436
53.5k
    case tcProfileName:
437
53.5k
      {
438
      
439
53.5k
      CheckTagType (parentCode, tagCode, tagType, ttAscii, ttByte);
440
      
441
53.5k
      ParseStringTag (stream,
442
53.5k
              parentCode,
443
53.5k
              tagCode,
444
53.5k
              tagCount,
445
53.5k
              fProfileName,
446
53.5k
              false);
447
      
448
      #if qDNGValidate
449
      
450
      if (gVerbose)
451
        {
452
        
453
        printf ("ProfileName: ");
454
        
455
        DumpString (fProfileName);
456
        
457
        printf ("\n");
458
        
459
        }
460
        
461
      #endif
462
      
463
53.5k
      break;
464
      
465
10.7k
      }
466
      
467
7.67k
    case tcProfileCopyright:
468
7.67k
      {
469
470
7.67k
      CheckTagType (parentCode, tagCode, tagType, ttAscii, ttByte);
471
      
472
7.67k
      ParseStringTag (stream,
473
7.67k
              parentCode,
474
7.67k
              tagCode,
475
7.67k
              tagCount,
476
7.67k
              fProfileCopyright,
477
7.67k
              false);
478
      
479
      #if qDNGValidate
480
            
481
      if (gVerbose)
482
        {
483
        
484
        printf ("ProfileCopyright: ");
485
        
486
        DumpString (fProfileCopyright);
487
        
488
        printf ("\n");
489
        
490
        }
491
492
      #endif
493
      
494
7.67k
      break;
495
      
496
10.7k
      }
497
498
62.6k
    case tcProfileEmbedPolicy:
499
62.6k
      {
500
        
501
62.6k
      CheckTagType (parentCode, tagCode, tagType, ttLong);
502
      
503
62.6k
      CheckTagCount (parentCode, tagCode, tagCount, 1);
504
      
505
62.6k
      fEmbedPolicy = stream.TagValue_uint32 (tagType);
506
507
      #if qDNGValidate
508
509
      if (gVerbose)
510
        {
511
        
512
        const char *policy;
513
514
        switch (fEmbedPolicy)
515
          {
516
517
          case pepAllowCopying:
518
            policy = "Allow copying";
519
            break;
520
521
          case pepEmbedIfUsed:
522
            policy = "Embed if used";
523
            break;
524
525
          case pepEmbedNever:
526
            policy = "Embed never";
527
            break;
528
529
          case pepNoRestrictions:
530
            policy = "No restrictions";
531
            break;
532
533
          default:
534
            policy = "INVALID VALUE";
535
  
536
          }
537
538
        printf ("ProfileEmbedPolicy: %s\n", policy);
539
                
540
        }
541
542
      #endif
543
544
62.6k
      break;
545
      
546
10.7k
      }
547
548
407k
    case tcProfileHueSatMapDims:
549
407k
      {
550
        
551
407k
      CheckTagType (parentCode, tagCode, tagType, ttLong);
552
      
553
407k
      CheckTagCount (parentCode, tagCode, tagCount, 2, 3);
554
      
555
407k
      fProfileHues = stream.TagValue_uint32 (tagType);
556
407k
      fProfileSats = stream.TagValue_uint32 (tagType);
557
558
407k
      if (tagCount > 2)
559
377k
        fProfileVals = stream.TagValue_uint32 (tagType);
560
29.9k
      else
561
29.9k
        fProfileVals = 1;
562
      
563
      #if qDNGValidate
564
565
      if (gVerbose)
566
        {
567
        
568
        printf ("ProfileHueSatMapDims: Hues = %u, Sats = %u, Vals = %u\n",
569
            (unsigned) fProfileHues,
570
            (unsigned) fProfileSats,
571
            (unsigned) fProfileVals);
572
                
573
        }
574
        
575
      #endif
576
577
407k
      break;
578
      
579
10.7k
      }
580
581
81.9k
    case tcProfileHueSatMapData1:
582
81.9k
      {
583
584
81.9k
      if (!CheckTagType (parentCode, tagCode, tagType, ttFloat))
585
10.2k
        return false;
586
        
587
71.7k
      bool skipSat0 = (tagCount ==
588
71.7k
               SafeUint32Mult(fProfileHues,
589
71.7k
                      SafeUint32Sub(fProfileSats, 1u),
590
71.7k
                      fProfileVals,
591
71.7k
                      3u));
592
      
593
71.7k
      if (!skipSat0)
594
18.6k
        {
595
      
596
18.6k
        if (!CheckTagCount (parentCode, tagCode, tagCount,
597
18.6k
                  SafeUint32Mult(fProfileHues, fProfileSats, fProfileVals, 3)))
598
15.4k
          return false;
599
          
600
18.6k
        }
601
        
602
56.2k
      fBigEndian = stream.BigEndian ();
603
        
604
56.2k
      fHueSatDeltas1Offset = tagOffset;
605
56.2k
      fHueSatDeltas1Count  = tagCount;
606
      
607
      #if qDNGValidate
608
609
      if (gVerbose)
610
        {
611
        
612
        printf ("ProfileHueSatMapData1:\n");
613
        
614
        DumpHueSatMap (stream,
615
                 fProfileHues,
616
                 fProfileSats,
617
                 fProfileVals,
618
                 skipSat0);
619
          
620
        }
621
        
622
      #endif
623
624
56.2k
      break;
625
      
626
71.7k
      }
627
628
104k
    case tcProfileHueSatMapData2:
629
104k
      {
630
631
104k
      if (!CheckTagType (parentCode, tagCode, tagType, ttFloat))
632
57.7k
        return false;
633
      
634
47.1k
      bool skipSat0 = (tagCount ==
635
47.1k
               SafeUint32Mult(fProfileHues,
636
47.1k
                      SafeUint32Sub(fProfileSats, 1u),
637
47.1k
                      fProfileVals,
638
47.1k
                      3u));
639
      
640
47.1k
      if (!skipSat0)
641
26.4k
        {
642
      
643
26.4k
        if (!CheckTagCount (parentCode, tagCode, tagCount,
644
26.4k
                  SafeUint32Mult(fProfileHues, fProfileSats, fProfileVals, 3)))
645
22.9k
          return false;
646
          
647
26.4k
        }
648
      
649
24.1k
      fBigEndian = stream.BigEndian ();
650
        
651
24.1k
      fHueSatDeltas2Offset = tagOffset;
652
24.1k
      fHueSatDeltas2Count  = tagCount;
653
      
654
      #if qDNGValidate
655
656
      if (gVerbose)
657
        {
658
        
659
        printf ("ProfileHueSatMapData2:\n");
660
        
661
        DumpHueSatMap (stream,
662
                 fProfileHues,
663
                 fProfileSats,
664
                 fProfileVals,
665
                 skipSat0);
666
          
667
        }
668
        
669
      #endif
670
671
24.1k
      break;
672
      
673
47.1k
      }
674
675
1.68k
    case tcProfileHueSatMapEncoding:
676
1.68k
      {
677
678
1.68k
      CheckTagType (parentCode, tagCode, tagType, ttLong);
679
      
680
1.68k
      CheckTagCount (parentCode, tagCode, tagCount, 1);
681
      
682
1.68k
      fHueSatMapEncoding = stream.TagValue_uint32 (tagType);
683
684
      #if qDNGValidate
685
686
      if (gVerbose)
687
        {
688
        
689
        const char *encoding = NULL;
690
691
        switch (fHueSatMapEncoding)
692
          {
693
694
          case encoding_Linear:
695
            encoding = "Linear";
696
            break;
697
698
          case encoding_sRGB:
699
            encoding = "sRGB";
700
            break;
701
702
          default:
703
            encoding = "INVALID VALUE";
704
  
705
          }
706
707
        printf ("ProfileHueSatMapEncoding: %s\n", encoding);
708
                
709
        }
710
711
      #endif
712
713
1.68k
      break;
714
      
715
47.1k
      }
716
717
43.7k
    case tcProfileLookTableDims:
718
43.7k
      {
719
        
720
43.7k
      CheckTagType (parentCode, tagCode, tagType, ttLong);
721
      
722
43.7k
      CheckTagCount (parentCode, tagCode, tagCount, 2, 3);
723
      
724
43.7k
      fLookTableHues = stream.TagValue_uint32 (tagType);
725
43.7k
      fLookTableSats = stream.TagValue_uint32 (tagType);
726
727
43.7k
      if (tagCount > 2)
728
23.2k
        fLookTableVals = stream.TagValue_uint32 (tagType);
729
20.5k
      else
730
20.5k
        fLookTableVals = 1;
731
      
732
      #if qDNGValidate
733
734
      if (gVerbose)
735
        {
736
        
737
        printf ("ProfileLookTableDims: Hues = %u, Sats = %u, Vals = %u\n",
738
            (unsigned) fLookTableHues,
739
            (unsigned) fLookTableSats,
740
            (unsigned) fLookTableVals);
741
                
742
        }
743
        
744
      #endif
745
746
43.7k
      break;
747
      
748
47.1k
      }
749
750
30.0k
    case tcProfileLookTableData:
751
30.0k
      {
752
753
30.0k
      if (!CheckTagType (parentCode, tagCode, tagType, ttFloat))
754
11.7k
        return false;
755
      
756
18.3k
      bool skipSat0 = (tagCount ==
757
18.3k
               SafeUint32Mult(fLookTableHues,
758
18.3k
                      SafeUint32Sub(fLookTableSats, 1u),
759
18.3k
                      fLookTableVals,
760
18.3k
                      3u));
761
      
762
18.3k
      if (!skipSat0)
763
11.4k
        {
764
      
765
11.4k
        if (!CheckTagCount (parentCode, tagCode, tagCount,
766
11.4k
                  SafeUint32Mult(fLookTableHues,
767
11.4k
                          fLookTableSats,
768
11.4k
                          fLookTableVals, 3)))
769
6.31k
          return false;
770
          
771
11.4k
        }
772
      
773
12.0k
      fBigEndian = stream.BigEndian ();
774
        
775
12.0k
      fLookTableOffset = tagOffset;
776
12.0k
      fLookTableCount  = tagCount;
777
      
778
      #if qDNGValidate
779
780
      if (gVerbose)
781
        {
782
        
783
        printf ("ProfileLookTableData:\n");
784
        
785
        DumpHueSatMap (stream,
786
                 fLookTableHues,
787
                 fLookTableSats,
788
                 fLookTableVals,
789
                 skipSat0);
790
          
791
        }
792
        
793
      #endif
794
795
12.0k
      break;
796
      
797
18.3k
      }
798
799
2.49k
    case tcProfileLookTableEncoding:
800
2.49k
      {
801
802
2.49k
      CheckTagType (parentCode, tagCode, tagType, ttLong);
803
      
804
2.49k
      CheckTagCount (parentCode, tagCode, tagCount, 1);
805
      
806
2.49k
      fLookTableEncoding = stream.TagValue_uint32 (tagType);
807
808
      #if qDNGValidate
809
810
      if (gVerbose)
811
        {
812
        
813
        const char *encoding = NULL;
814
815
        switch (fLookTableEncoding)
816
          {
817
818
          case encoding_Linear:
819
            encoding = "Linear";
820
            break;
821
822
          case encoding_sRGB:
823
            encoding = "sRGB";
824
            break;
825
826
          default:
827
            encoding = "INVALID VALUE";
828
  
829
          }
830
831
        printf ("ProfileLookTableEncoding: %s\n", encoding);
832
                
833
        }
834
835
      #endif
836
837
2.49k
      break;
838
      
839
18.3k
      }
840
841
9.02k
    case tcBaselineExposureOffset:
842
9.02k
      {
843
      
844
9.02k
      CheckTagType (parentCode, tagCode, tagType, ttSRational);
845
      
846
9.02k
      CheckTagCount (parentCode, tagCode, tagCount, 1);
847
      
848
9.02k
      fBaselineExposureOffset = stream.TagValue_srational (tagType);
849
      
850
      #if qDNGValidate
851
      
852
      if (gVerbose)
853
        {
854
        
855
        printf ("BaselineExposureOffset: %+0.2f\n",
856
              fBaselineExposureOffset.As_real64 ());
857
              
858
        }
859
        
860
      #endif
861
        
862
9.02k
      break;
863
      
864
18.3k
      }
865
      
866
156k
    case tcDefaultBlackRender:
867
156k
      {
868
869
156k
      CheckTagType (parentCode, tagCode, tagType, ttLong);
870
      
871
156k
      CheckTagCount (parentCode, tagCode, tagCount, 1);
872
      
873
156k
      fDefaultBlackRender = stream.TagValue_uint32 (tagType);
874
875
      #if qDNGValidate
876
877
      if (gVerbose)
878
        {
879
        
880
        const char *setting = NULL;
881
882
        switch (fDefaultBlackRender)
883
          {
884
885
          case defaultBlackRender_Auto:
886
            setting = "Auto";
887
            break;
888
889
          case defaultBlackRender_None:
890
            setting = "None";
891
            break;
892
893
          default:
894
            setting = "INVALID VALUE";
895
  
896
          }
897
898
        printf ("DefaultBlackRender: %s\n", 
899
            setting);
900
                
901
        }
902
903
      #endif
904
905
156k
      break;
906
      
907
18.3k
      }
908
909
32.6k
    case tcProfileToneCurve:
910
32.6k
      {
911
        
912
32.6k
      if (!CheckTagType (parentCode, tagCode, tagType, ttFloat))
913
11.4k
        return false;
914
      
915
21.2k
      if (!CheckTagCount (parentCode, tagCode, tagCount, 4, tagCount))
916
928
        return false;
917
    
918
20.2k
      if ((tagCount & 1) != 0)
919
8.39k
        {
920
        
921
        #if qDNGValidate
922
        
923
          {
924
            
925
          char message [256];
926
          
927
          sprintf (message,
928
               "%s %s has odd count (%u)",
929
               LookupParentCode (parentCode),
930
               LookupTagCode (parentCode, tagCode),
931
               (unsigned) tagCount);
932
               
933
          ReportWarning (message);
934
                 
935
          }
936
          
937
        #endif
938
          
939
8.39k
        return false;
940
        
941
8.39k
        }
942
      
943
11.8k
      fBigEndian = stream.BigEndian ();
944
        
945
11.8k
      fToneCurveOffset = tagOffset;
946
11.8k
      fToneCurveCount  = tagCount;
947
      
948
      #if qDNGValidate
949
950
      if (gVerbose)
951
        {
952
        
953
        DumpTagValues (stream,
954
                 "Coord",
955
                 parentCode,
956
                 tagCode,
957
                 tagType,
958
                 tagCount);
959
          
960
                
961
        }
962
        
963
      #endif
964
965
11.8k
      break;
966
      
967
20.2k
      }
968
969
817k
    case tcUniqueCameraModel:
970
817k
      {
971
      
972
      // Note: This code is only used when parsing stand-alone
973
      // profiles.  The embedded profiles are assumed to be restricted
974
      // to the model they are embedded in.
975
      
976
817k
      CheckTagType (parentCode, tagCode, tagType, ttAscii);
977
      
978
817k
      ParseStringTag (stream,
979
817k
              parentCode,
980
817k
              tagCode,
981
817k
              tagCount,
982
817k
              fUniqueCameraModel,
983
817k
              false);
984
              
985
817k
      bool didTrim = fUniqueCameraModel.TrimTrailingBlanks ();
986
      
987
      #if qDNGValidate
988
      
989
      if (didTrim)
990
        {
991
        
992
        ReportWarning ("UniqueCameraModel string has trailing blanks");
993
        
994
        }
995
      
996
      if (gVerbose)
997
        {
998
        
999
        printf ("UniqueCameraModel: ");
1000
        
1001
        DumpString (fUniqueCameraModel);
1002
        
1003
        printf ("\n");
1004
        
1005
        }
1006
        
1007
      #else
1008
      
1009
817k
      (void) didTrim;   // Unused
1010
        
1011
817k
      #endif
1012
      
1013
817k
      break;
1014
      
1015
20.2k
      }
1016
1017
76.7M
    default:
1018
76.7M
      {
1019
      
1020
76.7M
      return false;
1021
      
1022
20.2k
      }
1023
      
1024
79.0M
    }
1025
1026
1.80M
  return true;
1027
  
1028
79.0M
  }
1029
1030
/*****************************************************************************/
1031
1032
bool dng_camera_profile_info::ParseExtended (dng_stream &stream)
1033
5.06M
  {
1034
1035
5.06M
  try
1036
5.06M
    {
1037
    
1038
    // Offsets are relative to the start of this structure, not the entire file.
1039
1040
5.06M
    uint64 startPosition = stream.Position ();
1041
1042
    // Read header. Like a TIFF header, but with different magic number
1043
    // Plus all offsets are relative to the start of the IFD, not to the
1044
    // stream or file.
1045
1046
5.06M
    uint16 byteOrder = stream.Get_uint16 ();
1047
1048
5.06M
    if (byteOrder == byteOrderMM)
1049
452k
      fBigEndian = true;
1050
      
1051
4.60M
    else if (byteOrder == byteOrderII)
1052
1.32M
      fBigEndian = false;
1053
      
1054
3.27M
    else
1055
3.27M
      return false;
1056
1057
1.78M
    TempBigEndian setEndianness (stream, fBigEndian);
1058
1059
1.78M
    uint16 magicNumber = stream.Get_uint16 ();
1060
1061
1.78M
    if (magicNumber != magicExtendedProfile)
1062
785k
      {
1063
785k
      return false;
1064
785k
      }
1065
1066
997k
    uint32 offset = stream.Get_uint32 ();
1067
1068
997k
    stream.Skip (SafeUint32Sub(offset, 8u));
1069
1070
    // Start on IFD entries.
1071
1072
997k
    uint32 ifdEntries = stream.Get_uint16 ();
1073
  
1074
997k
    if (ifdEntries < 1)
1075
752
      {
1076
752
      return false;
1077
752
      }
1078
    
1079
80.1M
    for (uint32 tag_index = 0; tag_index < ifdEntries; tag_index++)
1080
79.1M
      {
1081
      
1082
79.1M
      stream.SetReadPosition (startPosition + 8 + 2 + tag_index * 12);
1083
      
1084
79.1M
      uint16 tagCode  = stream.Get_uint16 ();
1085
79.1M
      uint32 tagType  = stream.Get_uint16 ();
1086
79.1M
      uint32 tagCount = stream.Get_uint32 ();
1087
      
1088
79.1M
      uint64 tagOffset = stream.Position ();
1089
1090
79.1M
      if (SafeUint32Mult(TagTypeSize (tagType), tagCount) > 4)
1091
6.79M
        {
1092
1093
6.79M
        tagOffset = startPosition + stream.Get_uint32 ();
1094
1095
6.79M
        stream.SetReadPosition (tagOffset);
1096
1097
6.79M
        }
1098
        
1099
79.1M
      if (!ParseTag (stream,
1100
79.1M
               0,
1101
79.1M
               tagCode,
1102
79.1M
               tagType,
1103
79.1M
               tagCount,
1104
79.1M
               tagOffset))
1105
76.8M
        {
1106
        
1107
        #if qDNGValidate
1108
    
1109
        if (gVerbose)
1110
          {
1111
              
1112
          stream.SetReadPosition (tagOffset);
1113
        
1114
          printf ("*");
1115
            
1116
          DumpTagValues (stream,
1117
                   LookupTagType (tagType),
1118
                   0,
1119
                   tagCode,
1120
                   tagType,
1121
                   tagCount);
1122
          
1123
          }
1124
          
1125
        #endif
1126
1127
76.8M
        }
1128
1129
79.1M
      }
1130
      
1131
996k
    return true;
1132
1133
997k
    }
1134
    
1135
5.06M
  catch (...)
1136
5.06M
    {
1137
    
1138
    // Eat parsing errors.
1139
    
1140
612k
    }
1141
1142
612k
  return false;
1143
  
1144
5.06M
  }
1145
1146
/*****************************************************************************/
1147
1148
dng_shared::dng_shared ()
1149
  
1150
129k
  : fExifIFD       (0)
1151
129k
  , fGPSInfo       (0)
1152
129k
  , fInteroperabilityIFD (0)
1153
129k
  , fKodakDCRPrivateIFD  (0)
1154
129k
  , fKodakKDCPrivateIFD  (0)
1155
    
1156
129k
  , fXMPCount  (0)
1157
129k
  , fXMPOffset (0)
1158
    
1159
129k
  , fIPTC_NAA_Count  (0)
1160
129k
  , fIPTC_NAA_Offset (0)
1161
  
1162
129k
  , fMakerNoteCount  (0)
1163
129k
  , fMakerNoteOffset (0)
1164
129k
  , fMakerNoteSafety (0)
1165
  
1166
129k
  , fDNGVersion         (0)
1167
129k
  , fDNGBackwardVersion (0)
1168
  
1169
129k
  , fUniqueCameraModel    ()
1170
129k
  , fLocalizedCameraModel ()
1171
  
1172
129k
  , fCameraProfile ()
1173
  
1174
129k
  , fExtraCameraProfiles ()
1175
  
1176
129k
  , fCameraCalibration1 ()
1177
129k
  , fCameraCalibration2 ()
1178
    
1179
129k
  , fCameraCalibrationSignature  ()
1180
1181
129k
  , fAnalogBalance ()
1182
    
1183
129k
  , fAsShotNeutral ()
1184
    
1185
129k
  , fAsShotWhiteXY ()
1186
  
1187
129k
  , fBaselineExposure      (0, 1)
1188
129k
  , fBaselineNoise         (1, 1)
1189
129k
  , fNoiseReductionApplied (0, 0)
1190
129k
  , fBaselineSharpness     (1, 1)
1191
129k
  , fLinearResponseLimit   (1, 1)
1192
129k
  , fShadowScale           (1, 1)
1193
  
1194
129k
  , fHasBaselineExposure (false)
1195
129k
  , fHasShadowScale      (false)
1196
  
1197
129k
  , fDNGPrivateDataCount  (0)
1198
129k
  , fDNGPrivateDataOffset (0)
1199
  
1200
129k
  , fRawImageDigest    ()
1201
129k
  , fNewRawImageDigest ()
1202
  
1203
129k
  , fRawDataUniqueID ()
1204
  
1205
129k
  , fOriginalRawFileName ()
1206
    
1207
129k
  , fOriginalRawFileDataCount  (0)
1208
129k
  , fOriginalRawFileDataOffset (0)
1209
  
1210
129k
  , fOriginalRawFileDigest ()
1211
    
1212
129k
  , fAsShotICCProfileCount  (0)
1213
129k
  , fAsShotICCProfileOffset (0)
1214
  
1215
129k
  , fAsShotPreProfileMatrix ()
1216
    
1217
129k
  , fCurrentICCProfileCount  (0)
1218
129k
  , fCurrentICCProfileOffset (0)
1219
  
1220
129k
  , fCurrentPreProfileMatrix ()
1221
  
1222
129k
  , fColorimetricReference (crSceneReferred)
1223
1224
129k
  , fAsShotProfileName ()
1225
1226
129k
  , fNoiseProfile ()
1227
  
1228
129k
  , fOriginalDefaultFinalSize     ()
1229
129k
  , fOriginalBestQualityFinalSize ()
1230
    
1231
129k
  , fOriginalDefaultCropSizeH ()
1232
129k
  , fOriginalDefaultCropSizeV ()
1233
    
1234
129k
  {
1235
  
1236
129k
  }
1237
  
1238
/*****************************************************************************/
1239
1240
dng_shared::~dng_shared ()
1241
129k
  {
1242
  
1243
129k
  }
1244
    
1245
/*****************************************************************************/
1246
1247
bool dng_shared::ParseTag (dng_stream &stream,
1248
               dng_exif &exif,
1249
               uint32 parentCode,
1250
               bool /* isMainIFD */,
1251
               uint32 tagCode,
1252
               uint32 tagType,
1253
               uint32 tagCount,
1254
               uint64 tagOffset,
1255
               int64 /* offsetDelta */)
1256
2.06M
  {
1257
  
1258
2.06M
  if (parentCode == 0)
1259
877k
    {
1260
    
1261
877k
    if (Parse_ifd0 (stream,
1262
877k
            exif,
1263
877k
            parentCode,
1264
877k
            tagCode,
1265
877k
            tagType,
1266
877k
            tagCount,
1267
877k
            tagOffset))
1268
476k
      {
1269
      
1270
476k
      return true;
1271
      
1272
476k
      }
1273
1274
877k
    }
1275
    
1276
1.59M
  if (parentCode == 0 ||
1277
1.59M
    parentCode == tcExifIFD)
1278
469k
    {
1279
    
1280
469k
    if (Parse_ifd0_exif (stream,
1281
469k
               exif,
1282
469k
               parentCode,
1283
469k
               tagCode,
1284
469k
               tagType,
1285
469k
               tagCount,
1286
469k
               tagOffset))
1287
12.9k
      {
1288
      
1289
12.9k
      return true;
1290
      
1291
12.9k
      }
1292
1293
469k
    }
1294
    
1295
1.57M
  return false;
1296
    
1297
1.59M
  }
1298
1299
/*****************************************************************************/
1300
1301
// Parses tags that should only appear in IFD 0.
1302
1303
bool dng_shared::Parse_ifd0 (dng_stream &stream,
1304
               dng_exif & /* exif */,
1305
               uint32 parentCode,
1306
               uint32 tagCode,
1307
               uint32 tagType,
1308
               uint32 tagCount,
1309
               uint64 tagOffset)
1310
877k
  {
1311
  
1312
877k
  switch (tagCode)
1313
877k
    {
1314
      
1315
18.5k
    case tcXMP:
1316
18.5k
      {
1317
      
1318
18.5k
      CheckTagType (parentCode, tagCode, tagType, ttByte, ttUndefined);
1319
      
1320
18.5k
      fXMPCount  = tagCount;
1321
18.5k
      fXMPOffset = fXMPCount ? tagOffset : 0;
1322
      
1323
      #if qDNGValidate
1324
      
1325
      if (gVerbose)
1326
        {
1327
        
1328
        printf ("XMP: Count = %u, Offset = %u\n",
1329
            (unsigned) fXMPCount,
1330
            (unsigned) fXMPOffset);
1331
            
1332
        if (fXMPCount)
1333
          {
1334
            
1335
          DumpXMP (stream, fXMPCount);
1336
          
1337
          }
1338
            
1339
        }
1340
        
1341
      #endif
1342
        
1343
18.5k
      break;
1344
      
1345
0
      }
1346
1347
818
    case tcIPTC_NAA:
1348
818
      {
1349
      
1350
818
      CheckTagType (parentCode, tagCode, tagType, ttLong, ttAscii, ttUndefined);
1351
      
1352
818
      fIPTC_NAA_Count = SafeUint32Mult(tagCount,
1353
818
                              TagTypeSize(tagType));
1354
818
      fIPTC_NAA_Offset = fIPTC_NAA_Count ? tagOffset : 0;
1355
      
1356
      #if qDNGValidate
1357
      
1358
      if (gVerbose)
1359
        {
1360
        
1361
        printf ("IPTC/NAA: Count = %u, Offset = %u\n",
1362
            (unsigned) fIPTC_NAA_Count,
1363
            (unsigned) fIPTC_NAA_Offset);
1364
            
1365
        if (fIPTC_NAA_Count)
1366
          {
1367
            
1368
          DumpHexAscii (stream, fIPTC_NAA_Count);
1369
          
1370
          }
1371
          
1372
        // Compute and output the digest.
1373
        
1374
        dng_memory_data buffer (fIPTC_NAA_Count);
1375
        
1376
        stream.SetReadPosition (fIPTC_NAA_Offset);
1377
        
1378
        stream.Get (buffer.Buffer (), fIPTC_NAA_Count);
1379
        
1380
        const uint8 *data = buffer.Buffer_uint8 ();
1381
        
1382
        uint32 count = fIPTC_NAA_Count;
1383
        
1384
        // Method 1: Counting all bytes (this is correct).
1385
        
1386
          {
1387
          
1388
          dng_md5_printer printer;
1389
    
1390
          printer.Process (data, count);
1391
          
1392
          printf ("IPTCDigest: ");
1393
          
1394
          DumpFingerprint (printer.Result ());
1395
          
1396
          printf ("\n");
1397
          
1398
          }
1399
          
1400
        // Method 2: Ignoring zero padding.
1401
          
1402
          {
1403
          
1404
          uint32 removed = 0;
1405
      
1406
          while ((removed < 3) && (count > 0) && (data [count - 1] == 0))
1407
            {
1408
            removed++;
1409
            count--;
1410
            }
1411
            
1412
          if (removed != 0)
1413
            {
1414
          
1415
            dng_md5_printer printer;
1416
      
1417
            printer.Process (data, count);
1418
            
1419
            printf ("IPTCDigest (ignoring zero padding): ");
1420
            
1421
            DumpFingerprint (printer.Result ());
1422
            
1423
            printf ("\n");
1424
            
1425
            }
1426
          
1427
          }
1428
          
1429
        }
1430
        
1431
      #endif
1432
        
1433
818
      break;
1434
      
1435
0
      }
1436
1437
18.0k
    case tcExifIFD:
1438
18.0k
      {
1439
      
1440
18.0k
      CheckTagType (parentCode, tagCode, tagType, ttLong, ttIFD);
1441
      
1442
18.0k
      CheckTagCount (parentCode, tagCode, tagCount, 1);
1443
      
1444
18.0k
      fExifIFD = stream.TagValue_uint32 (tagType);
1445
      
1446
      #if qDNGValidate
1447
      
1448
      if (gVerbose)
1449
        {
1450
        printf ("ExifIFD: %u\n", (unsigned) fExifIFD);
1451
        }
1452
        
1453
      #endif
1454
        
1455
18.0k
      break;
1456
      
1457
0
      }
1458
    
1459
10.7k
    case tcGPSInfo:
1460
10.7k
      {
1461
      
1462
10.7k
      CheckTagType (parentCode, tagCode, tagType, ttLong, ttIFD);
1463
      
1464
10.7k
      CheckTagCount (parentCode, tagCode, tagCount, 1);
1465
      
1466
10.7k
      fGPSInfo = stream.TagValue_uint32 (tagType);
1467
      
1468
      #if qDNGValidate
1469
      
1470
      if (gVerbose)
1471
        {
1472
        printf ("GPSInfo: %u\n", (unsigned) fGPSInfo);
1473
        }
1474
        
1475
      #endif
1476
        
1477
10.7k
      break;
1478
      
1479
0
      }
1480
        
1481
605
    case tcKodakDCRPrivateIFD:
1482
605
      {
1483
      
1484
605
      CheckTagType (parentCode, tagCode, tagType, ttLong, ttIFD);
1485
      
1486
605
      CheckTagCount (parentCode, tagCode, tagCount, 1);
1487
      
1488
605
      fKodakDCRPrivateIFD = stream.TagValue_uint32 (tagType);
1489
      
1490
      #if qDNGValidate
1491
      
1492
      if (gVerbose)
1493
        {
1494
        printf ("KodakDCRPrivateIFD: %u\n", (unsigned) fKodakDCRPrivateIFD);
1495
        }
1496
        
1497
      #endif
1498
        
1499
605
      break;
1500
      
1501
0
      }
1502
    
1503
2.03k
    case tcKodakKDCPrivateIFD:
1504
2.03k
      {
1505
      
1506
2.03k
      CheckTagType (parentCode, tagCode, tagType, ttLong, ttIFD);
1507
      
1508
2.03k
      CheckTagCount (parentCode, tagCode, tagCount, 1);
1509
      
1510
2.03k
      fKodakKDCPrivateIFD = stream.TagValue_uint32 (tagType);
1511
      
1512
      #if qDNGValidate
1513
      
1514
      if (gVerbose)
1515
        {
1516
        printf ("KodakKDCPrivateIFD: %u\n", (unsigned) fKodakKDCPrivateIFD);
1517
        }
1518
        
1519
      #endif
1520
        
1521
2.03k
      break;
1522
      
1523
0
      }
1524
    
1525
100k
    case tcDNGVersion:
1526
100k
      {
1527
      
1528
100k
      CheckTagType (parentCode, tagCode, tagType, ttByte);
1529
      
1530
100k
      CheckTagCount (parentCode, tagCode, tagCount, 4);
1531
      
1532
100k
      uint32 b0 = stream.Get_uint8 ();
1533
100k
      uint32 b1 = stream.Get_uint8 ();
1534
100k
      uint32 b2 = stream.Get_uint8 ();
1535
100k
      uint32 b3 = stream.Get_uint8 ();
1536
      
1537
100k
      fDNGVersion = (b0 << 24) | (b1 << 16) | (b2 << 8) | b3;
1538
      
1539
      #if qDNGValidate
1540
      
1541
      if (gVerbose)
1542
        {
1543
        printf ("DNGVersion: %u.%u.%u.%u\n",
1544
            (unsigned) b0,
1545
            (unsigned) b1,
1546
            (unsigned) b2,
1547
            (unsigned) b3);
1548
        }
1549
        
1550
      #endif
1551
      
1552
100k
      break;
1553
      
1554
0
      }
1555
        
1556
31.1k
    case tcDNGBackwardVersion:
1557
31.1k
      {
1558
      
1559
31.1k
      CheckTagType (parentCode, tagCode, tagType, ttByte);
1560
      
1561
31.1k
      CheckTagCount (parentCode, tagCode, tagCount, 4);
1562
      
1563
31.1k
      uint32 b0 = stream.Get_uint8 ();
1564
31.1k
      uint32 b1 = stream.Get_uint8 ();
1565
31.1k
      uint32 b2 = stream.Get_uint8 ();
1566
31.1k
      uint32 b3 = stream.Get_uint8 ();
1567
      
1568
31.1k
      fDNGBackwardVersion = (b0 << 24) | (b1 << 16) | (b2 << 8) | b3;
1569
      
1570
      #if qDNGValidate
1571
      
1572
      if (gVerbose)
1573
        {
1574
        printf ("DNGBackwardVersion: %u.%u.%u.%u\n", 
1575
            (unsigned) b0, 
1576
            (unsigned) b1, 
1577
            (unsigned) b2, 
1578
            (unsigned) b3);
1579
        }
1580
        
1581
      #endif
1582
      
1583
31.1k
      break;
1584
      
1585
0
      }
1586
        
1587
20.4k
    case tcUniqueCameraModel:
1588
20.4k
      {
1589
      
1590
20.4k
      CheckTagType (parentCode, tagCode, tagType, ttAscii);
1591
      
1592
20.4k
      ParseStringTag (stream,
1593
20.4k
              parentCode,
1594
20.4k
              tagCode,
1595
20.4k
              tagCount,
1596
20.4k
              fUniqueCameraModel,
1597
20.4k
              false);
1598
              
1599
20.4k
      bool didTrim = fUniqueCameraModel.TrimTrailingBlanks ();
1600
      
1601
      #if qDNGValidate
1602
      
1603
      if (didTrim)
1604
        {
1605
        
1606
        ReportWarning ("UniqueCameraModel string has trailing blanks");
1607
        
1608
        }
1609
      
1610
      if (gVerbose)
1611
        {
1612
        
1613
        printf ("UniqueCameraModel: ");
1614
        
1615
        DumpString (fUniqueCameraModel);
1616
        
1617
        printf ("\n");
1618
        
1619
        }
1620
        
1621
      #else
1622
      
1623
20.4k
      (void) didTrim;   // Unused
1624
        
1625
20.4k
      #endif
1626
      
1627
20.4k
      break;
1628
      
1629
0
      }
1630
1631
2.03k
    case tcLocalizedCameraModel:
1632
2.03k
      {
1633
      
1634
2.03k
      CheckTagType (parentCode, tagCode, tagType, ttAscii, ttByte);
1635
      
1636
2.03k
      ParseStringTag (stream,
1637
2.03k
              parentCode,
1638
2.03k
              tagCode,
1639
2.03k
              tagCount,
1640
2.03k
              fLocalizedCameraModel,
1641
2.03k
              false);
1642
      
1643
2.03k
      bool didTrim = fLocalizedCameraModel.TrimTrailingBlanks ();
1644
      
1645
      #if qDNGValidate
1646
      
1647
      if (didTrim)
1648
        {
1649
        
1650
        ReportWarning ("LocalizedCameraModel string has trailing blanks");
1651
        
1652
        }
1653
      
1654
      if (gVerbose)
1655
        {
1656
        
1657
        printf ("LocalizedCameraModel: ");
1658
        
1659
        DumpString (fLocalizedCameraModel);
1660
        
1661
        printf ("\n");
1662
        
1663
        }
1664
        
1665
      #else
1666
      
1667
2.03k
      (void) didTrim;   // Unused
1668
        
1669
2.03k
      #endif
1670
      
1671
2.03k
      break;
1672
      
1673
0
      }
1674
      
1675
7.29k
    case tcCameraCalibration1:
1676
7.29k
      {
1677
      
1678
7.29k
      CheckTagType (parentCode, tagCode, tagType, ttSRational);
1679
      
1680
7.29k
      if (!CheckColorImage (parentCode, tagCode, fCameraProfile.fColorPlanes))
1681
2.94k
        return false;
1682
        
1683
4.35k
      if (!ParseMatrixTag (stream,
1684
4.35k
                 parentCode,
1685
4.35k
                 tagCode,
1686
4.35k
                 tagType,
1687
4.35k
                 tagCount,
1688
4.35k
                 fCameraProfile.fColorPlanes,
1689
4.35k
                 fCameraProfile.fColorPlanes,
1690
4.35k
                 fCameraCalibration1))
1691
1.03k
        return false;
1692
        
1693
      #if qDNGValidate
1694
      
1695
      if (gVerbose)
1696
        {
1697
        
1698
        printf ("CameraCalibration1:\n");
1699
        
1700
        DumpMatrix (fCameraCalibration1);
1701
                
1702
        }
1703
        
1704
      #endif
1705
        
1706
3.31k
      break;
1707
      
1708
4.35k
      }
1709
1710
3.31k
    case tcCameraCalibration2:
1711
2.99k
      {
1712
      
1713
2.99k
      CheckTagType (parentCode, tagCode, tagType, ttSRational);
1714
      
1715
2.99k
      if (!CheckColorImage (parentCode, tagCode, fCameraProfile.fColorPlanes))
1716
799
        return false;
1717
        
1718
2.19k
      if (!ParseMatrixTag (stream,
1719
2.19k
                 parentCode,
1720
2.19k
                 tagCode,
1721
2.19k
                 tagType,
1722
2.19k
                 tagCount,
1723
2.19k
                 fCameraProfile.fColorPlanes,
1724
2.19k
                 fCameraProfile.fColorPlanes,
1725
2.19k
                 fCameraCalibration2))
1726
1.42k
        return false;
1727
        
1728
      #if qDNGValidate
1729
      
1730
      if (gVerbose)
1731
        {
1732
        
1733
        printf ("CameraCalibration2:\n");
1734
        
1735
        DumpMatrix (fCameraCalibration2);
1736
                
1737
        }
1738
        
1739
      #endif
1740
        
1741
770
      break;
1742
      
1743
2.19k
      }
1744
1745
770
    case tcCameraCalibrationSignature:
1746
391
      {
1747
1748
391
      CheckTagType (parentCode, tagCode, tagType, ttAscii, ttByte);
1749
      
1750
391
      ParseStringTag (stream,
1751
391
              parentCode,
1752
391
              tagCode,
1753
391
              tagCount,
1754
391
              fCameraCalibrationSignature,
1755
391
              false);
1756
      
1757
      #if qDNGValidate
1758
            
1759
      if (gVerbose)
1760
        {
1761
        
1762
        printf ("CameraCalibrationSignature: ");
1763
        
1764
        DumpString (fCameraCalibrationSignature);
1765
        
1766
        printf ("\n");
1767
        
1768
        }
1769
1770
      #endif
1771
      
1772
391
      break;
1773
      
1774
2.19k
      }
1775
      
1776
31.3k
    case tcAnalogBalance:
1777
31.3k
      {
1778
      
1779
31.3k
      CheckTagType (parentCode, tagCode, tagType, ttRational);
1780
      
1781
      // Kludge - Hasselblad FFF files are very DNG-like, but sometimes
1782
      // they don't have any ColorMatrix tags.
1783
      
1784
31.3k
      bool hasselbladHack = (fDNGVersion == 0 &&
1785
31.3k
                   fCameraProfile.fColorPlanes == 0);
1786
      
1787
31.3k
      if (hasselbladHack)
1788
1.19k
        {
1789
        
1790
1.19k
        fCameraProfile.fColorPlanes = Pin_uint32 (0, tagCount, kMaxColorPlanes);
1791
        
1792
        #if qDNGValidate
1793
        
1794
        ReportWarning ("AnalogBalance without ColorMatrix1");
1795
        
1796
        #endif
1797
      
1798
1.19k
        }
1799
      
1800
31.3k
      if (!CheckColorImage (parentCode, tagCode, fCameraProfile.fColorPlanes))
1801
5.39k
        return false;
1802
        
1803
25.9k
      if (!ParseVectorTag (stream,
1804
25.9k
                 parentCode,
1805
25.9k
                 tagCode,
1806
25.9k
                 tagType,
1807
25.9k
                 tagCount,
1808
25.9k
                 fCameraProfile.fColorPlanes,
1809
25.9k
                 fAnalogBalance))
1810
16.7k
        return false;
1811
  
1812
      #if qDNGValidate
1813
      
1814
      if (gVerbose)
1815
        {
1816
        
1817
        printf ("AnalogBalance:");
1818
        
1819
        DumpVector (fAnalogBalance);
1820
                
1821
        }
1822
        
1823
      #endif
1824
        
1825
9.24k
      break;
1826
      
1827
25.9k
      }
1828
      
1829
15.8k
    case tcAsShotNeutral:
1830
15.8k
      {
1831
      
1832
15.8k
      CheckTagType (parentCode, tagCode, tagType, ttRational);
1833
      
1834
      // Kludge - Hasselblad FFF files are very DNG-like, but sometimes
1835
      // they don't have any ColorMatrix tags.
1836
      
1837
15.8k
      bool hasselbladHack = (fDNGVersion == 0 &&
1838
15.8k
                   fCameraProfile.fColorPlanes == 0);
1839
      
1840
15.8k
      if (hasselbladHack)
1841
1.19k
        {
1842
        
1843
1.19k
        fCameraProfile.fColorPlanes = Pin_uint32 (0, tagCount, kMaxColorPlanes);
1844
        
1845
        #if qDNGValidate
1846
        
1847
        ReportWarning ("AsShotNeutral without ColorMatrix1");
1848
        
1849
        #endif
1850
      
1851
1.19k
        }
1852
      
1853
15.8k
      if (!CheckColorImage (parentCode, tagCode, fCameraProfile.fColorPlanes))
1854
6.61k
        return false;
1855
        
1856
9.22k
      if (!ParseVectorTag (stream,
1857
9.22k
                 parentCode,
1858
9.22k
                 tagCode,
1859
9.22k
                 tagType,
1860
9.22k
                 tagCount,
1861
9.22k
                 fCameraProfile.fColorPlanes,
1862
9.22k
                 fAsShotNeutral))
1863
3.32k
        return false;
1864
  
1865
      #if qDNGValidate
1866
      
1867
      if (gVerbose)
1868
        {
1869
        
1870
        printf ("AsShotNeutral:");
1871
        
1872
        DumpVector (fAsShotNeutral);
1873
                
1874
        }
1875
        
1876
      #endif
1877
        
1878
5.89k
      break;
1879
      
1880
9.22k
      }
1881
      
1882
14.5k
    case tcAsShotWhiteXY:
1883
14.5k
      {
1884
      
1885
14.5k
      CheckTagType (parentCode, tagCode, tagType, ttRational);
1886
      
1887
14.5k
      if (!CheckColorImage (parentCode, tagCode, fCameraProfile.fColorPlanes))
1888
1.42k
        return false;
1889
        
1890
13.0k
      if (!CheckTagCount (parentCode, tagCode, tagCount, 2))
1891
2.96k
        return false;
1892
        
1893
10.1k
      fAsShotWhiteXY.x = stream.TagValue_real64 (tagType);
1894
10.1k
      fAsShotWhiteXY.y = stream.TagValue_real64 (tagType);
1895
      
1896
      #if qDNGValidate
1897
      
1898
      if (gVerbose)
1899
        {
1900
        
1901
        printf ("AsShotWhiteXY: %0.4f %0.4f\n",
1902
            fAsShotWhiteXY.x,
1903
            fAsShotWhiteXY.y);
1904
            
1905
        }
1906
        
1907
      #endif
1908
        
1909
10.1k
      break;
1910
      
1911
13.0k
      }
1912
      
1913
24.0k
    case tcBaselineExposure:
1914
24.0k
      {
1915
      
1916
24.0k
      CheckTagType (parentCode, tagCode, tagType, ttSRational);
1917
      
1918
24.0k
      CheckTagCount (parentCode, tagCode, tagCount, 1);
1919
      
1920
24.0k
      fBaselineExposure = stream.TagValue_srational (tagType);
1921
      
1922
24.0k
      fHasBaselineExposure = true;
1923
      
1924
      #if qDNGValidate
1925
      
1926
      if (gVerbose)
1927
        {
1928
        
1929
        printf ("BaselineExposure: %+0.2f\n",
1930
              fBaselineExposure.As_real64 ());
1931
              
1932
        }
1933
        
1934
      #endif
1935
        
1936
24.0k
      break;
1937
      
1938
13.0k
      }
1939
      
1940
16.3k
    case tcBaselineNoise:
1941
16.3k
      {
1942
      
1943
16.3k
      CheckTagType (parentCode, tagCode, tagType, ttRational);
1944
      
1945
16.3k
      CheckTagCount (parentCode, tagCode, tagCount, 1);
1946
      
1947
16.3k
      fBaselineNoise = stream.TagValue_urational (tagType);
1948
      
1949
      #if qDNGValidate
1950
1951
      if (gVerbose)
1952
        {
1953
        
1954
        printf ("BaselineNoise: %0.2f\n",
1955
            fBaselineNoise.As_real64 ());
1956
            
1957
        }
1958
        
1959
      #endif
1960
        
1961
16.3k
      break;
1962
      
1963
13.0k
      }
1964
      
1965
5.88k
    case tcNoiseReductionApplied:
1966
5.88k
      {
1967
      
1968
5.88k
      if (!CheckTagType (parentCode, tagCode, tagType, ttRational))
1969
996
        return false;
1970
      
1971
4.89k
      if (!CheckTagCount (parentCode, tagCode, tagCount, 1))
1972
215
        return false;
1973
      
1974
4.67k
      fNoiseReductionApplied = stream.TagValue_urational (tagType);
1975
      
1976
      #if qDNGValidate
1977
1978
      if (gVerbose)
1979
        {
1980
        
1981
        printf ("NoiseReductionApplied: %u/%u\n",
1982
            (unsigned) fNoiseReductionApplied.n,
1983
            (unsigned) fNoiseReductionApplied.d);
1984
            
1985
        }
1986
        
1987
      #endif
1988
        
1989
4.67k
      break;
1990
      
1991
4.89k
      }
1992
1993
4.20k
    case tcNoiseProfile:
1994
4.20k
      {
1995
1996
4.20k
      if (!CheckTagType (parentCode, tagCode, tagType, ttDouble))
1997
524
        return false;
1998
1999
      // Must be an even, positive number of doubles in a noise profile.
2000
      
2001
3.68k
      if (!tagCount || (tagCount & 1))
2002
458
        return false;
2003
2004
      // Determine number of planes (i.e., half the number of doubles).
2005
2006
3.22k
      const uint32 numPlanes = Pin_uint32 (0, 
2007
3.22k
                         tagCount >> 1, 
2008
3.22k
                         kMaxColorPlanes);
2009
2010
      // Parse the noise function parameters.
2011
2012
3.22k
      dng_std_vector<dng_noise_function> noiseFunctions;
2013
2014
14.6k
      for (uint32 i = 0; i < numPlanes; i++)
2015
11.3k
        {
2016
2017
11.3k
        const real64 scale  = stream.TagValue_real64 (tagType);
2018
11.3k
        const real64 offset = stream.TagValue_real64 (tagType);
2019
2020
11.3k
        noiseFunctions.push_back (dng_noise_function (scale, offset));
2021
2022
11.3k
        }
2023
2024
      // Store the noise profile.
2025
2026
3.22k
      fNoiseProfile = dng_noise_profile (noiseFunctions);
2027
2028
      // Debug.
2029
2030
      #if qDNGValidate
2031
2032
      if (gVerbose)
2033
        {
2034
        
2035
        printf ("NoiseProfile:\n");
2036
        
2037
        printf ("  Planes: %u\n", (unsigned) numPlanes);
2038
          
2039
        for (uint32 plane = 0; plane < numPlanes; plane++)
2040
          {
2041
2042
          printf ("  Noise function for plane %u: scale = %.8lf, offset = %.8lf\n",
2043
              (unsigned) plane,
2044
              noiseFunctions [plane].Scale  (),
2045
              noiseFunctions [plane].Offset ());
2046
2047
          }
2048
        
2049
        }
2050
2051
      #endif
2052
      
2053
3.22k
      break;
2054
      
2055
3.68k
      }
2056
      
2057
15.5k
    case tcBaselineSharpness:
2058
15.5k
      {
2059
      
2060
15.5k
      CheckTagType (parentCode, tagCode, tagType, ttRational);
2061
      
2062
15.5k
      CheckTagCount (parentCode, tagCode, tagCount, 1);
2063
      
2064
15.5k
      fBaselineSharpness = stream.TagValue_urational (tagType);
2065
      
2066
      #if qDNGValidate
2067
2068
      if (gVerbose)
2069
        {
2070
        
2071
        printf ("BaselineSharpness: %0.2f\n",
2072
              fBaselineSharpness.As_real64 ());
2073
        
2074
        }
2075
        
2076
      #endif
2077
        
2078
15.5k
      break;
2079
      
2080
3.68k
      }
2081
      
2082
13.6k
    case tcLinearResponseLimit:
2083
13.6k
      {
2084
      
2085
13.6k
      CheckTagType (parentCode, tagCode, tagType, ttRational);
2086
      
2087
13.6k
      CheckTagCount (parentCode, tagCode, tagCount, 1);
2088
      
2089
13.6k
      fLinearResponseLimit = stream.TagValue_urational (tagType);
2090
      
2091
      #if qDNGValidate
2092
2093
      if (gVerbose)
2094
        {
2095
        
2096
        printf ("LinearResponseLimit: %0.2f\n",
2097
            fLinearResponseLimit.As_real64 ());
2098
        
2099
        }
2100
        
2101
      #endif
2102
        
2103
13.6k
      break;
2104
      
2105
3.68k
      }
2106
      
2107
8.27k
    case tcShadowScale:
2108
8.27k
      {
2109
      
2110
8.27k
      CheckTagType (parentCode, tagCode, tagType, ttRational);
2111
      
2112
8.27k
      CheckTagCount (parentCode, tagCode, tagCount, 1);
2113
      
2114
8.27k
      fShadowScale = stream.TagValue_urational (tagType);
2115
      
2116
8.27k
      fHasShadowScale = true;
2117
      
2118
      #if qDNGValidate
2119
2120
      if (gVerbose)
2121
        {
2122
        
2123
        printf ("ShadowScale: %0.4f\n",
2124
            fShadowScale.As_real64 ());
2125
        
2126
        }
2127
        
2128
      #endif
2129
        
2130
8.27k
      break;
2131
      
2132
3.68k
      }
2133
      
2134
23.4k
    case tcDNGPrivateData:
2135
23.4k
      {
2136
      
2137
23.4k
      CheckTagType (parentCode, tagCode, tagType, ttByte);
2138
      
2139
23.4k
      fDNGPrivateDataCount  = tagCount;
2140
23.4k
      fDNGPrivateDataOffset = tagOffset;
2141
      
2142
      #if qDNGValidate
2143
2144
      if (gVerbose)
2145
        {
2146
        
2147
        printf ("DNGPrivateData: Count = %u, Offset = %u\n",
2148
            (unsigned) fDNGPrivateDataCount,
2149
            (unsigned) fDNGPrivateDataOffset);
2150
            
2151
        DumpHexAscii (stream, tagCount);
2152
        
2153
        }
2154
        
2155
      #endif
2156
      
2157
23.4k
      break;
2158
      
2159
3.68k
      }
2160
      
2161
3.56k
    case tcMakerNoteSafety:
2162
3.56k
      {
2163
      
2164
3.56k
      CheckTagType (parentCode, tagCode, tagType, ttShort);
2165
      
2166
3.56k
      CheckTagCount (parentCode, tagCode, tagCount, 1);
2167
      
2168
3.56k
      fMakerNoteSafety = stream.TagValue_uint32 (tagType);
2169
      
2170
      #if qDNGValidate
2171
2172
      if (gVerbose)
2173
        {
2174
        
2175
        printf ("MakerNoteSafety: %s\n",
2176
            LookupMakerNoteSafety (fMakerNoteSafety));
2177
        
2178
        }
2179
        
2180
      #endif
2181
      
2182
3.56k
      break;
2183
      
2184
3.68k
      }
2185
      
2186
8.09k
    case tcRawImageDigest:
2187
8.09k
      {
2188
      
2189
8.09k
      if (!CheckTagType (parentCode, tagCode, tagType, ttByte))
2190
254
        return false;
2191
        
2192
7.84k
      if (!CheckTagCount (parentCode, tagCode, tagCount, 16))
2193
1.11k
        return false;
2194
        
2195
6.73k
      stream.Get (fRawImageDigest.data, 16);
2196
        
2197
      #if qDNGValidate
2198
2199
      if (gVerbose)
2200
        {
2201
        
2202
        printf ("RawImageDigest: ");
2203
        
2204
        DumpFingerprint (fRawImageDigest);
2205
                  
2206
        printf ("\n");
2207
        
2208
        }
2209
        
2210
      #endif
2211
        
2212
6.73k
      break;
2213
      
2214
7.84k
      }
2215
      
2216
925
    case tcNewRawImageDigest:
2217
925
      {
2218
      
2219
925
      if (!CheckTagType (parentCode, tagCode, tagType, ttByte))
2220
113
        return false;
2221
        
2222
812
      if (!CheckTagCount (parentCode, tagCode, tagCount, 16))
2223
229
        return false;
2224
        
2225
583
      stream.Get (fNewRawImageDigest.data, 16);
2226
      
2227
      #if qDNGValidate
2228
2229
      if (gVerbose)
2230
        {
2231
        
2232
        printf ("NewRawImageDigest: ");
2233
        
2234
        DumpFingerprint (fNewRawImageDigest);
2235
                  
2236
        printf ("\n");
2237
        
2238
        }
2239
        
2240
      #endif
2241
        
2242
583
      break;
2243
      
2244
812
      }
2245
      
2246
16.9k
    case tcRawDataUniqueID:
2247
16.9k
      {
2248
      
2249
16.9k
      if (!CheckTagType (parentCode, tagCode, tagType, ttByte))
2250
2.33k
        return false;
2251
        
2252
14.5k
      if (!CheckTagCount (parentCode, tagCode, tagCount, 16))
2253
5.80k
        return false;
2254
        
2255
8.77k
      stream.Get (fRawDataUniqueID.data, 16);
2256
        
2257
      #if qDNGValidate
2258
2259
      if (gVerbose)
2260
        {
2261
        
2262
        printf ("RawDataUniqueID: ");
2263
        
2264
        DumpFingerprint (fRawDataUniqueID);
2265
                  
2266
        printf ("\n");
2267
        
2268
        }
2269
        
2270
      #endif
2271
        
2272
8.77k
      break;
2273
      
2274
14.5k
      }
2275
      
2276
956
    case tcOriginalRawFileName:
2277
956
      {
2278
      
2279
956
      CheckTagType (parentCode, tagCode, tagType, ttAscii, ttByte);
2280
      
2281
956
      ParseStringTag (stream,
2282
956
              parentCode,
2283
956
              tagCode,
2284
956
              tagCount,
2285
956
              fOriginalRawFileName,
2286
956
              false);
2287
      
2288
      #if qDNGValidate
2289
2290
      if (gVerbose)
2291
        {
2292
        
2293
        printf ("OriginalRawFileName: ");
2294
        
2295
        DumpString (fOriginalRawFileName);
2296
        
2297
        printf ("\n");
2298
        
2299
        }
2300
        
2301
      #endif
2302
      
2303
956
      break;
2304
      
2305
14.5k
      }
2306
      
2307
630
    case tcOriginalRawFileData:
2308
630
      {
2309
      
2310
630
      CheckTagType (parentCode, tagCode, tagType, ttUndefined);
2311
      
2312
630
      fOriginalRawFileDataCount  = tagCount;
2313
630
      fOriginalRawFileDataOffset = tagOffset;
2314
      
2315
      #if qDNGValidate
2316
2317
      if (gVerbose)
2318
        {
2319
        
2320
        printf ("OriginalRawFileData: Count = %u, Offset = %u\n",
2321
            (unsigned) fOriginalRawFileDataCount,
2322
            (unsigned) fOriginalRawFileDataOffset);
2323
            
2324
        DumpHexAscii (stream, tagCount);
2325
        
2326
        }
2327
        
2328
      #endif
2329
        
2330
630
      break;
2331
      
2332
14.5k
      }
2333
      
2334
1.23k
    case tcOriginalRawFileDigest:
2335
1.23k
      {
2336
      
2337
1.23k
      if (!CheckTagType (parentCode, tagCode, tagType, ttByte))
2338
307
        return false;
2339
        
2340
927
      if (!CheckTagCount (parentCode, tagCode, tagCount, 16))
2341
344
        return false;
2342
        
2343
583
      stream.Get (fOriginalRawFileDigest.data, 16);
2344
        
2345
      #if qDNGValidate
2346
2347
      if (gVerbose)
2348
        {
2349
        
2350
        printf ("OriginalRawFileDigest: ");
2351
        
2352
        DumpFingerprint (fOriginalRawFileDigest);
2353
                  
2354
        printf ("\n");
2355
        
2356
        }
2357
        
2358
      #endif
2359
        
2360
583
      break;
2361
      
2362
927
      }
2363
      
2364
169
    case tcAsShotICCProfile:
2365
169
      {
2366
      
2367
169
      CheckTagType (parentCode, tagCode, tagType, ttUndefined);
2368
      
2369
169
      fAsShotICCProfileCount  = tagCount;
2370
169
      fAsShotICCProfileOffset = tagOffset;
2371
      
2372
      #if qDNGValidate
2373
2374
      if (gVerbose)
2375
        {
2376
        
2377
        printf ("AsShotICCProfile: Count = %u, Offset = %u\n",
2378
            (unsigned) fAsShotICCProfileCount,
2379
            (unsigned) fAsShotICCProfileOffset);
2380
            
2381
        DumpHexAscii (stream, tagCount);
2382
        
2383
        }
2384
        
2385
      #endif
2386
        
2387
169
      break;
2388
      
2389
927
      }
2390
      
2391
5.04k
    case tcAsShotPreProfileMatrix:
2392
5.04k
      {
2393
      
2394
5.04k
      CheckTagType (parentCode, tagCode, tagType, ttSRational);
2395
      
2396
5.04k
      if (!CheckColorImage (parentCode, tagCode, fCameraProfile.fColorPlanes))
2397
2.19k
        return false;
2398
        
2399
2.84k
      uint32 rows = fCameraProfile.fColorPlanes;
2400
      
2401
2.84k
      if (tagCount == fCameraProfile.fColorPlanes * 3)
2402
265
        {
2403
265
        rows = 3;
2404
265
        }
2405
      
2406
2.84k
      if (!ParseMatrixTag (stream,
2407
2.84k
                 parentCode,
2408
2.84k
                 tagCode,
2409
2.84k
                 tagType,
2410
2.84k
                 tagCount,
2411
2.84k
                 rows,
2412
2.84k
                 fCameraProfile.fColorPlanes,
2413
2.84k
                 fAsShotPreProfileMatrix))
2414
2.46k
        return false;
2415
        
2416
      #if qDNGValidate
2417
2418
      if (gVerbose)
2419
        {
2420
        
2421
        printf ("AsShotPreProfileMatrix:\n");
2422
        
2423
        DumpMatrix (fAsShotPreProfileMatrix);
2424
                
2425
        }
2426
        
2427
      #endif
2428
        
2429
385
      break;
2430
      
2431
2.84k
      }
2432
      
2433
615
    case tcCurrentICCProfile:
2434
615
      {
2435
      
2436
615
      CheckTagType (parentCode, tagCode, tagType, ttUndefined);
2437
      
2438
615
      fCurrentICCProfileCount  = tagCount;
2439
615
      fCurrentICCProfileOffset = tagOffset;
2440
      
2441
      #if qDNGValidate
2442
2443
      if (gVerbose)
2444
        {
2445
        
2446
        printf ("CurrentICCProfile: Count = %u, Offset = %u\n",
2447
            (unsigned) fCurrentICCProfileCount,
2448
            (unsigned) fCurrentICCProfileOffset);
2449
            
2450
        DumpHexAscii (stream, tagCount);
2451
        
2452
        }
2453
        
2454
      #endif
2455
        
2456
615
      break;
2457
      
2458
2.84k
      }
2459
      
2460
27.6k
    case tcCurrentPreProfileMatrix:
2461
27.6k
      {
2462
      
2463
27.6k
      CheckTagType (parentCode, tagCode, tagType, ttSRational);
2464
      
2465
27.6k
      if (!CheckColorImage (parentCode, tagCode, fCameraProfile.fColorPlanes))
2466
14.8k
        return false;
2467
        
2468
12.8k
      uint32 rows = fCameraProfile.fColorPlanes;
2469
      
2470
12.8k
      if (tagCount == fCameraProfile.fColorPlanes * 3)
2471
5.03k
        {
2472
5.03k
        rows = 3;
2473
5.03k
        }
2474
      
2475
12.8k
      if (!ParseMatrixTag (stream,
2476
12.8k
                 parentCode,
2477
12.8k
                 tagCode,
2478
12.8k
                 tagType,
2479
12.8k
                 tagCount,
2480
12.8k
                 rows,
2481
12.8k
                 fCameraProfile.fColorPlanes,
2482
12.8k
                 fCurrentPreProfileMatrix))
2483
7.06k
        return false;
2484
        
2485
      #if qDNGValidate
2486
2487
      if (gVerbose)
2488
        {
2489
        
2490
        printf ("CurrentPreProfileMatrix:\n");
2491
        
2492
        DumpMatrix (fCurrentPreProfileMatrix);
2493
                
2494
        }
2495
        
2496
      #endif
2497
        
2498
5.77k
      break;
2499
      
2500
12.8k
      }
2501
      
2502
17.4k
    case tcColorimetricReference:
2503
17.4k
      {
2504
      
2505
17.4k
      CheckTagType (parentCode, tagCode, tagType, ttShort);
2506
      
2507
17.4k
      CheckTagCount (parentCode, tagCode, tagCount, 1);
2508
      
2509
17.4k
      fColorimetricReference = stream.TagValue_uint32 (tagType);
2510
      
2511
      #if qDNGValidate
2512
2513
      if (gVerbose)
2514
        {
2515
        
2516
        printf ("ColorimetricReference: %s\n",
2517
            LookupColorimetricReference (fColorimetricReference));
2518
        
2519
        }
2520
        
2521
      #endif
2522
        
2523
17.4k
      break;
2524
      
2525
12.8k
      }
2526
2527
10.3k
    case tcExtraCameraProfiles:
2528
10.3k
      {
2529
        
2530
10.3k
      CheckTagType (parentCode, tagCode, tagType, ttLong);
2531
      
2532
10.3k
      CheckTagCount (parentCode, tagCode, tagCount, 1, tagCount);
2533
      
2534
      #if qDNGValidate
2535
2536
      if (gVerbose)
2537
        {
2538
        
2539
        printf ("ExtraCameraProfiles: %u\n", (unsigned) tagCount);
2540
        
2541
        }
2542
        
2543
      #endif
2544
      
2545
10.3k
      fExtraCameraProfiles.reserve (tagCount);
2546
      
2547
5.07M
      for (uint32 index = 0; index < tagCount; index++)
2548
5.06M
        {
2549
        
2550
        #if qDNGValidate
2551
2552
        if (gVerbose)
2553
          {
2554
          
2555
          printf ("\nExtraCameraProfile [%u]:\n\n", (unsigned) index);
2556
          
2557
          }
2558
          
2559
        #endif
2560
      
2561
5.06M
        stream.SetReadPosition (tagOffset + index * 4);
2562
        
2563
5.06M
        uint32 profileOffset = stream.TagValue_uint32 (tagType);
2564
        
2565
5.06M
        dng_camera_profile_info profileInfo;
2566
        
2567
5.06M
        stream.SetReadPosition (profileOffset);
2568
        
2569
5.06M
        if (profileInfo.ParseExtended (stream))
2570
386k
          {
2571
          
2572
386k
          fExtraCameraProfiles.push_back (profileInfo);
2573
          
2574
386k
          }
2575
          
2576
4.68M
        else
2577
4.68M
          {
2578
          
2579
          #if qDNGValidate
2580
2581
          ReportWarning ("Unable to parse extra camera profile");
2582
          
2583
          #endif
2584
      
2585
4.68M
          }
2586
        
2587
5.06M
        }
2588
2589
      #if qDNGValidate
2590
2591
      if (gVerbose)
2592
        {
2593
        
2594
        printf ("\nDone with ExtraCameraProfiles\n\n");
2595
        
2596
        }
2597
        
2598
      #endif
2599
      
2600
10.3k
      break;
2601
      
2602
12.8k
      }
2603
      
2604
1.05k
    case tcAsShotProfileName:
2605
1.05k
      {
2606
            
2607
1.05k
      CheckTagType (parentCode, tagCode, tagType, ttAscii, ttByte);
2608
      
2609
1.05k
      ParseStringTag (stream,
2610
1.05k
              parentCode,
2611
1.05k
              tagCode,
2612
1.05k
              tagCount,
2613
1.05k
              fAsShotProfileName,
2614
1.05k
              false);
2615
      
2616
      #if qDNGValidate
2617
      
2618
      if (gVerbose)
2619
        {
2620
        
2621
        printf ("AsShotProfileName: ");
2622
        
2623
        DumpString (fAsShotProfileName);
2624
        
2625
        printf ("\n");
2626
        
2627
        }
2628
        
2629
      #endif
2630
      
2631
1.05k
      break;
2632
      
2633
12.8k
      }
2634
2635
1.28k
    case tcOriginalDefaultFinalSize:
2636
1.28k
      {
2637
      
2638
1.28k
      CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong);
2639
      
2640
1.28k
      if (!CheckTagCount (parentCode, tagCode, tagCount, 2))
2641
203
        return false;
2642
        
2643
1.07k
      fOriginalDefaultFinalSize.h = stream.TagValue_int32 (tagType);
2644
1.07k
      fOriginalDefaultFinalSize.v = stream.TagValue_int32 (tagType);
2645
      
2646
      #if qDNGValidate
2647
        
2648
      if (gVerbose)
2649
        {
2650
        
2651
        printf ("OriginalDefaultFinalSize: H = %d V = %d\n",
2652
            (int) fOriginalDefaultFinalSize.h,
2653
            (int) fOriginalDefaultFinalSize.v);
2654
            
2655
        }
2656
        
2657
      #endif
2658
      
2659
1.07k
      break;
2660
      
2661
1.28k
      }
2662
        
2663
973
    case tcOriginalBestQualityFinalSize:
2664
973
      {
2665
      
2666
973
      CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong);
2667
      
2668
973
      if (!CheckTagCount (parentCode, tagCode, tagCount, 2))
2669
177
        return false;
2670
        
2671
796
      fOriginalBestQualityFinalSize.h = stream.TagValue_int32 (tagType);
2672
796
      fOriginalBestQualityFinalSize.v = stream.TagValue_int32 (tagType);
2673
      
2674
      #if qDNGValidate
2675
        
2676
      if (gVerbose)
2677
        {
2678
        
2679
        printf ("OriginalBestQualityFinalSize: H = %d V = %d\n",
2680
            (int) fOriginalBestQualityFinalSize.h,
2681
            (int) fOriginalBestQualityFinalSize.v);
2682
            
2683
        }
2684
        
2685
      #endif
2686
      
2687
796
      break;
2688
      
2689
973
      }
2690
        
2691
828
    case tcOriginalDefaultCropSize:
2692
828
      {
2693
      
2694
828
      CheckTagType (parentCode, tagCode, tagType, ttShort, ttLong, ttRational);
2695
      
2696
828
      if (!CheckTagCount (parentCode, tagCode, tagCount, 2))
2697
298
        return false;
2698
        
2699
530
      fOriginalDefaultCropSizeH = stream.TagValue_urational (tagType);
2700
530
      fOriginalDefaultCropSizeV = stream.TagValue_urational (tagType);
2701
      
2702
      #if qDNGValidate
2703
        
2704
      if (gVerbose)
2705
        {
2706
        
2707
        printf ("OriginalDefaultCropSize: H = %0.2f V = %0.2f\n",
2708
            fOriginalDefaultCropSizeH.As_real64 (),
2709
            fOriginalDefaultCropSizeV.As_real64 ());
2710
            
2711
        }
2712
        
2713
      #endif
2714
      
2715
530
      break;
2716
      
2717
828
      }
2718
      
2719
390k
    default:
2720
390k
      {
2721
      
2722
      // The main camera profile tags also appear in IFD 0
2723
      
2724
390k
      return fCameraProfile.ParseTag (stream,
2725
390k
                      parentCode,
2726
390k
                      tagCode,
2727
390k
                      tagType,
2728
390k
                      tagCount,
2729
390k
                      tagOffset);
2730
      
2731
828
      }
2732
      
2733
877k
    }
2734
2735
397k
  return true;
2736
  
2737
877k
  }
2738
  
2739
/*****************************************************************************/
2740
2741
// Parses tags that should only appear in IFD 0 or EXIF IFD.
2742
2743
bool dng_shared::Parse_ifd0_exif (dng_stream &stream,
2744
                  dng_exif & /* exif */,
2745
                      uint32 parentCode,
2746
                      uint32 tagCode,
2747
                      uint32 tagType,
2748
                      uint32 tagCount,
2749
                      uint64 tagOffset)
2750
469k
  {
2751
  
2752
469k
  switch (tagCode)
2753
469k
    {
2754
    
2755
11.4k
    case tcMakerNote:
2756
11.4k
      {
2757
      
2758
11.4k
      CheckTagType (parentCode, tagCode, tagType, ttUndefined);
2759
      
2760
11.4k
      fMakerNoteCount  = tagCount;
2761
11.4k
      fMakerNoteOffset = tagOffset;
2762
      
2763
      #if qDNGValidate
2764
2765
      if (gVerbose)
2766
        {
2767
        
2768
        printf ("MakerNote: Count = %u, Offset = %u\n",
2769
            (unsigned) fMakerNoteCount,
2770
            (unsigned) fMakerNoteOffset);
2771
            
2772
        DumpHexAscii (stream, tagCount);
2773
        
2774
        }
2775
        
2776
      #endif
2777
        
2778
11.4k
      break;
2779
      
2780
0
      }
2781
      
2782
1.52k
    case tcInteroperabilityIFD:
2783
1.52k
      {
2784
      
2785
1.52k
      CheckTagType (parentCode, tagCode, tagType, ttLong, ttIFD);
2786
      
2787
1.52k
      CheckTagCount (parentCode, tagCode, tagCount, 1);
2788
      
2789
1.52k
      fInteroperabilityIFD = stream.TagValue_uint32 (tagType);
2790
      
2791
      #if qDNGValidate
2792
2793
      if (gVerbose)
2794
        {
2795
        printf ("InteroperabilityIFD: %u\n", (unsigned) fInteroperabilityIFD);
2796
        }
2797
        
2798
      #endif
2799
      
2800
1.52k
      break;
2801
      
2802
0
      }
2803
      
2804
456k
    default:
2805
456k
      {
2806
      
2807
456k
      return false;
2808
      
2809
0
      }
2810
      
2811
469k
    }
2812
    
2813
12.9k
  return true;
2814
  
2815
469k
  }
2816
                 
2817
/*****************************************************************************/
2818
2819
void dng_shared::PostParse (dng_host & /* host */,
2820
              dng_exif & /* exif */)
2821
89.4k
  {
2822
  
2823
  // Fill in default values for DNG images.
2824
  
2825
89.4k
  if (fDNGVersion != 0)
2826
63.0k
    {
2827
    
2828
    // Support for DNG versions before 1.0.0.0.
2829
    
2830
63.0k
    if (fDNGVersion < dngVersion_1_0_0_0)
2831
13.8k
      {
2832
      
2833
      #if qDNGValidate
2834
      
2835
      ReportWarning ("DNGVersion less than 1.0.0.0");
2836
             
2837
      #endif
2838
      
2839
      // The CalibrationIlluminant tags were added just before
2840
      // DNG version 1.0.0.0, and were hardcoded before that.
2841
      
2842
13.8k
      fCameraProfile.fCalibrationIlluminant1 = lsStandardLightA;
2843
13.8k
      fCameraProfile.fCalibrationIlluminant2 = lsD65;
2844
      
2845
13.8k
      fDNGVersion = dngVersion_1_0_0_0;
2846
2847
13.8k
      }
2848
    
2849
    // Default value for DNGBackwardVersion tag.
2850
    
2851
63.0k
    if (fDNGBackwardVersion == 0)
2852
48.5k
      {
2853
      
2854
48.5k
      fDNGBackwardVersion = fDNGVersion & 0xFFFF0000;
2855
      
2856
48.5k
      }
2857
  
2858
    // Check DNGBackwardVersion value.
2859
    
2860
63.0k
    if (fDNGBackwardVersion < dngVersion_1_0_0_0)
2861
2.80k
      {
2862
      
2863
      #if qDNGValidate
2864
      
2865
      ReportWarning ("DNGBackwardVersion less than 1.0.0.0");
2866
             
2867
      #endif
2868
      
2869
2.80k
      fDNGBackwardVersion = dngVersion_1_0_0_0;
2870
        
2871
2.80k
      }
2872
2873
63.0k
    if (fDNGBackwardVersion > fDNGVersion)
2874
3.57k
      {
2875
      
2876
      #if qDNGValidate
2877
      
2878
      ReportWarning ("DNGBackwardVersion > DNGVersion");
2879
             
2880
      #endif
2881
      
2882
3.57k
      fDNGBackwardVersion = fDNGVersion;
2883
          
2884
3.57k
      }
2885
2886
    // Check UniqueCameraModel.
2887
    
2888
63.0k
    if (fUniqueCameraModel.IsEmpty ())
2889
56.5k
      {
2890
      
2891
      #if qDNGValidate
2892
      
2893
      ReportWarning ("Missing or invalid UniqueCameraModel");
2894
             
2895
      #endif
2896
      
2897
56.5k
      fUniqueCameraModel.Set ("Digital Negative");
2898
      
2899
56.5k
      }
2900
    
2901
    // If we don't know the color depth yet, it must be a monochrome DNG.
2902
    
2903
63.0k
    if (fCameraProfile.fColorPlanes == 0)
2904
43.8k
      {
2905
      
2906
43.8k
      fCameraProfile.fColorPlanes = 1;
2907
      
2908
43.8k
      }
2909
      
2910
    // Check color info.
2911
    
2912
63.0k
    if (fCameraProfile.fColorPlanes > 1)
2913
19.2k
      {
2914
      
2915
      // Check illuminant pair.
2916
      
2917
19.2k
      if (fCameraProfile.fColorMatrix2.NotEmpty ())
2918
758
        {
2919
        
2920
758
        if (fCameraProfile.fCalibrationIlluminant1 == lsUnknown ||
2921
758
          (fCameraProfile.fCalibrationIlluminant2 == lsUnknown ||
2922
698
          (fCameraProfile.fCalibrationIlluminant1 == fCameraProfile.fCalibrationIlluminant2)))
2923
206
          {
2924
            
2925
          #if qDNGValidate
2926
      
2927
          ReportWarning ("Invalid CalibrationIlluminant pair");
2928
                 
2929
          #endif
2930
                 
2931
206
          fCameraProfile.fColorMatrix2 = dng_matrix ();
2932
        
2933
206
          }
2934
2935
758
        }
2936
        
2937
      // If the colorimetric reference is the ICC profile PCS, then the
2938
      // data must already be white balanced.  The "AsShotWhiteXY" is required
2939
      // to be the ICC Profile PCS white point.
2940
      
2941
19.2k
      if (fColorimetricReference == crICCProfilePCS)
2942
4.84k
        {
2943
        
2944
4.84k
        if (fAsShotNeutral.NotEmpty ())
2945
19
          {
2946
          
2947
          #if qDNGValidate
2948
        
2949
          ReportWarning ("AsShotNeutral not allowed for this "
2950
                   "ColorimetricReference value");
2951
                 
2952
          #endif
2953
          
2954
19
          fAsShotNeutral.Clear ();
2955
          
2956
19
          }
2957
          
2958
4.84k
        dng_xy_coord pcs = PCStoXY ();
2959
        
2960
        #if qDNGValidate
2961
          
2962
        if (fAsShotWhiteXY.IsValid ())
2963
          {
2964
          
2965
          if (Abs_real64 (fAsShotWhiteXY.x - pcs.x) > 0.01 ||
2966
            Abs_real64 (fAsShotWhiteXY.y - pcs.y) > 0.01)
2967
            {
2968
            
2969
            ReportWarning ("AsShotWhiteXY does not match the ICC Profile PCS");
2970
2971
            }
2972
            
2973
          }
2974
                   
2975
        #endif
2976
        
2977
4.84k
        fAsShotWhiteXY = pcs;
2978
2979
4.84k
        }
2980
        
2981
14.4k
      else
2982
14.4k
        {
2983
        
2984
        // Warn if both AsShotNeutral and AsShotWhiteXY are specified.
2985
          
2986
14.4k
        if (fAsShotNeutral.NotEmpty () && fAsShotWhiteXY.IsValid ())
2987
25
          {
2988
            
2989
          #if qDNGValidate
2990
        
2991
          ReportWarning ("Both AsShotNeutral and AsShotWhiteXY included");
2992
                 
2993
          #endif
2994
          
2995
25
          fAsShotWhiteXY = dng_xy_coord ();
2996
                   
2997
25
          }
2998
          
2999
        // Warn if neither AsShotNeutral nor AsShotWhiteXY are specified.
3000
          
3001
        #if qDNGValidate
3002
        
3003
        if (fAsShotNeutral.IsEmpty () && !fAsShotWhiteXY.IsValid ())
3004
          {
3005
          
3006
          ReportWarning ("Neither AsShotNeutral nor AsShotWhiteXY included",
3007
                   "legal but not recommended");
3008
                 
3009
          }
3010
              
3011
        #endif
3012
          
3013
14.4k
        }
3014
        
3015
      // Default values of calibration signatures are required for legacy
3016
      // compatiblity.
3017
3018
19.2k
      if (fCameraProfile.fCalibrationIlluminant1 == lsStandardLightA &&
3019
19.2k
        fCameraProfile.fCalibrationIlluminant2 == lsD65            &&
3020
19.2k
        fCameraCalibration1.Rows () == fCameraProfile.fColorPlanes &&
3021
19.2k
        fCameraCalibration1.Cols () == fCameraProfile.fColorPlanes &&
3022
19.2k
        fCameraCalibration2.Rows () == fCameraProfile.fColorPlanes &&
3023
19.2k
        fCameraCalibration2.Cols () == fCameraProfile.fColorPlanes &&
3024
19.2k
        fCameraCalibrationSignature.IsEmpty ()                     &&
3025
19.2k
        fCameraProfile.fProfileCalibrationSignature.IsEmpty ()     )
3026
12
        {
3027
3028
12
        fCameraCalibrationSignature.Set (kAdobeCalibrationSignature);
3029
          
3030
12
        fCameraProfile.fProfileCalibrationSignature.Set (kAdobeCalibrationSignature);
3031
3032
12
        }
3033
3034
19.2k
      }
3035
      
3036
    // Check BaselineNoise.
3037
3038
63.0k
    if (fBaselineNoise.As_real64 () <= 0.0)
3039
812
      {
3040
      
3041
      #if qDNGValidate
3042
      
3043
      ReportWarning ("Invalid BaselineNoise");
3044
             
3045
      #endif
3046
      
3047
812
      fBaselineNoise = dng_urational (1, 1);
3048
               
3049
812
      }
3050
      
3051
    // Check BaselineSharpness.
3052
    
3053
63.0k
    if (fBaselineSharpness.As_real64 () <= 0.0)
3054
1.01k
      {
3055
      
3056
      #if qDNGValidate
3057
      
3058
      ReportWarning ("Invalid BaselineSharpness");
3059
             
3060
      #endif
3061
      
3062
1.01k
      fBaselineSharpness = dng_urational (1, 1);
3063
               
3064
1.01k
      }
3065
3066
    // Check NoiseProfile.
3067
3068
63.0k
    if (!fNoiseProfile.IsValid () && fNoiseProfile.NumFunctions () != 0)
3069
134
      {
3070
      
3071
      #if qDNGValidate
3072
      
3073
      ReportWarning ("Invalid NoiseProfile");
3074
             
3075
      #endif
3076
      
3077
134
      fNoiseProfile = dng_noise_profile ();
3078
               
3079
134
      }
3080
      
3081
    // Check LinearResponseLimit.
3082
    
3083
63.0k
    if (fLinearResponseLimit.As_real64 () < 0.5 ||
3084
63.0k
      fLinearResponseLimit.As_real64 () > 1.0)
3085
3.93k
      {
3086
      
3087
      #if qDNGValidate
3088
      
3089
      ReportWarning ("Invalid LinearResponseLimit");
3090
             
3091
      #endif
3092
      
3093
3.93k
      fLinearResponseLimit = dng_urational (1, 1);
3094
               
3095
3.93k
      }
3096
      
3097
    // Check ShadowScale.
3098
    
3099
63.0k
    if (fShadowScale.As_real64 () <= 0.0)
3100
483
      {
3101
      
3102
      #if qDNGValidate
3103
      
3104
      ReportWarning ("Invalid ShadowScale");
3105
             
3106
      #endif
3107
               
3108
483
      fShadowScale = dng_urational (1, 1);
3109
               
3110
483
      }
3111
    
3112
63.0k
    }
3113
  
3114
89.4k
  }
3115
                 
3116
/*****************************************************************************/
3117
3118
bool dng_shared::IsValidDNG ()
3119
85.5k
  {
3120
  
3121
  // Check DNGVersion value.
3122
  
3123
85.5k
  if (fDNGVersion < dngVersion_1_0_0_0)
3124
26.1k
    {
3125
    
3126
    #if qDNGValidate
3127
    
3128
    if (fDNGVersion != dngVersion_None)
3129
      {
3130
3131
      ReportError ("Invalid DNGVersion");
3132
3133
      }
3134
           
3135
    #if qDNGValidateTarget
3136
    
3137
    else
3138
      {
3139
3140
      ReportError ("Missing DNGVersion");
3141
3142
      }
3143
      
3144
    #endif
3145
    
3146
    #endif
3147
           
3148
26.1k
    return false;
3149
      
3150
26.1k
    }
3151
    
3152
  // Check DNGBackwardVersion value.
3153
  
3154
59.4k
  if (fDNGBackwardVersion > dngVersion_Current)
3155
5.29k
    {
3156
    
3157
    #if qDNGValidate
3158
    
3159
    ReportError ("DNGBackwardVersion (or DNGVersion) is too high");
3160
    
3161
    #endif
3162
    
3163
5.29k
    ThrowUnsupportedDNG ();
3164
      
3165
5.29k
    }
3166
    
3167
  // Check color transform info.
3168
  
3169
59.4k
  if (fCameraProfile.fColorPlanes > 1)
3170
17.3k
    {
3171
    
3172
    // CameraCalibration1 is optional, but it must be valid if present.
3173
    
3174
17.3k
    if (fCameraCalibration1.Cols () != 0 ||
3175
17.3k
      fCameraCalibration1.Rows () != 0)
3176
428
      {
3177
      
3178
428
      if (fCameraCalibration1.Cols () != fCameraProfile.fColorPlanes ||
3179
428
        fCameraCalibration1.Rows () != fCameraProfile.fColorPlanes)
3180
0
        {
3181
        
3182
        #if qDNGValidate
3183
    
3184
        ReportError ("CameraCalibration1 is wrong size");
3185
               
3186
        #endif
3187
3188
0
        return false;
3189
        
3190
0
        }
3191
        
3192
      // Make sure it is invertable.
3193
      
3194
428
      try
3195
428
        {
3196
        
3197
428
        (void) Invert (fCameraCalibration1);
3198
        
3199
428
        }
3200
        
3201
428
      catch (...)
3202
428
        {
3203
        
3204
        #if qDNGValidate
3205
    
3206
        ReportError ("CameraCalibration1 is not invertable");
3207
               
3208
        #endif
3209
               
3210
40
        return false;
3211
      
3212
40
        }
3213
        
3214
428
      }
3215
    
3216
    // CameraCalibration2 is optional, but it must be valid if present.
3217
    
3218
17.2k
    if (fCameraCalibration2.Cols () != 0 ||
3219
17.2k
      fCameraCalibration2.Rows () != 0)
3220
112
      {
3221
      
3222
112
      if (fCameraCalibration2.Cols () != fCameraProfile.fColorPlanes ||
3223
112
        fCameraCalibration2.Rows () != fCameraProfile.fColorPlanes)
3224
0
        {
3225
        
3226
        #if qDNGValidate
3227
    
3228
        ReportError ("CameraCalibration2 is wrong size");
3229
               
3230
        #endif
3231
3232
0
        return false;
3233
        
3234
0
        }
3235
      
3236
      // Make sure it is invertable.
3237
      
3238
112
      try
3239
112
        {
3240
        
3241
112
        (void) Invert (fCameraCalibration2);
3242
        
3243
112
        }
3244
        
3245
112
      catch (...)
3246
112
        {
3247
        
3248
        #if qDNGValidate
3249
  
3250
        ReportError ("CameraCalibration2 is not invertable");
3251
               
3252
        #endif
3253
               
3254
28
        return false;
3255
      
3256
28
        }
3257
          
3258
112
      }
3259
      
3260
    // Check analog balance
3261
    
3262
17.2k
    dng_matrix analogBalance;
3263
    
3264
17.2k
    if (fAnalogBalance.NotEmpty ())
3265
4.73k
      {
3266
      
3267
4.73k
      analogBalance = fAnalogBalance.AsDiagonal ();
3268
      
3269
4.73k
      try
3270
4.73k
        {
3271
        
3272
4.73k
        (void) Invert (analogBalance);
3273
        
3274
4.73k
        }
3275
        
3276
4.73k
      catch (...)
3277
4.73k
        {
3278
        
3279
        #if qDNGValidate
3280
    
3281
        ReportError ("AnalogBalance is not invertable");
3282
               
3283
        #endif
3284
               
3285
181
        return false;
3286
      
3287
181
        }
3288
        
3289
4.73k
      }
3290
        
3291
17.2k
    }
3292
      
3293
59.2k
  return true;
3294
  
3295
59.4k
  }
3296
  
3297
/*****************************************************************************/