Coverage Report

Created: 2025-01-23 06:31

/src/dng_validate_fuzzer.cpp
Line
Count
Source (jump to first uncovered line)
1
/*****************************************************************************/
2
// Copyright 2006-2012 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_validate.cpp#2 $ */ 
10
/* $DateTime: 2012/06/14 20:24:41 $ */
11
/* $Change: 835078 $ */
12
/* $Author: tknoll $ */
13
14
// Process exit codes
15
// ------------------
16
//
17
// As usual, 0 indicates success.
18
//
19
// If an exception occurs, the exit code will be equal to:
20
//
21
//    DNG SDK error code - 100000 + 100
22
//
23
// For example, the error dng_error_memory, which has a DNG SDK error code of
24
// 100005, is returned as an exit code of 105.
25
//
26
// This convention accounts for the fact that the shell truncates process exit
27
// codes to 8 bits and that the exit code 1 is used by ASAN to signal that a
28
// memory error occurred (so mapping the first DNG SDK error code to an exit
29
// code of 1 would not be a good idea).
30
31
/*****************************************************************************/
32
33
#include "dng_color_space.h"
34
#include "dng_date_time.h"
35
#include "dng_exceptions.h"
36
#include "dng_file_stream.h"
37
#include "dng_globals.h"
38
#include "dng_host.h"
39
#include "dng_ifd.h"
40
#include "dng_image_writer.h"
41
#include "dng_info.h"
42
#include "dng_linearization_info.h"
43
#include "dng_mosaic_info.h"
44
#include "dng_negative.h"
45
#include "dng_preview.h"
46
#include "dng_render.h"
47
#include "dng_simple_image.h"
48
#include "dng_tag_codes.h"
49
#include "dng_tag_types.h"
50
#include "dng_tag_values.h"
51
52
#if qDNGUseXMP
53
#include "dng_xmp.h"
54
#include "dng_xmp_sdk.h"
55
#endif
56
57
/*****************************************************************************/
58
59
#if qDNGValidateTarget
60
    
61
/*****************************************************************************/
62
63
3.58k
#define kDNGValidateVersion "1.4"
64
    
65
/*****************************************************************************/
66
67
 bool gFourColorBayer = false;
68
    
69
 int32 gMosaicPlane = -1;
70
71
 uint32 gPreferredSize = 0;
72
 uint32 gMinimumSize   = 0;
73
 uint32 gMaximumSize   = 0;
74
75
 uint32 gProxyDNGSize = 0;
76
77
 const dng_color_space *gFinalSpace = &dng_space_sRGB::Get ();
78
79
 uint32 gFinalPixelType = ttByte;
80
81
 dng_string gDumpStage1;
82
 dng_string gDumpStage2;
83
 dng_string gDumpStage3;
84
 dng_string gDumpTIF;
85
 dng_string gDumpDNG;
86
87
/*****************************************************************************/
88
89
 dng_error_code dng_validate (const char *filename)
90
22.4k
  {
91
  
92
  //idating \"%s\"...\n", filename);
93
  
94
22.4k
  try
95
22.4k
    {
96
  
97
22.4k
    dng_file_stream stream (filename);
98
    
99
22.4k
    dng_host host;
100
    
101
22.4k
    host.SetPreferredSize (gPreferredSize);
102
22.4k
    host.SetMinimumSize   (gMinimumSize  );
103
22.4k
    host.SetMaximumSize   (gMaximumSize  );
104
    
105
22.4k
    host.ValidateSizes ();
106
    
107
22.4k
    if (host.MinimumSize ())
108
4.98k
      {
109
      
110
4.98k
      host.SetForPreview (true);
111
      
112
4.98k
      gDumpDNG.Clear ();
113
      
114
4.98k
      }
115
      
116
22.4k
    if (gDumpDNG.NotEmpty ())
117
17.2k
      {
118
      
119
17.2k
      host.SetSaveDNGVersion (dngVersion_SaveDefault);
120
      
121
17.2k
      host.SetSaveLinearDNG (false);
122
      
123
17.2k
      host.SetKeepOriginalFile (false);
124
      
125
17.2k
      }
126
      
127
    // Read into the negative.
128
    
129
22.4k
    AutoPtr<dng_negative> negative;
130
    
131
22.4k
      {
132
      
133
22.4k
      dng_info info;
134
      
135
22.4k
      info.Parse (host, stream);
136
      
137
22.4k
      info.PostParse (host);
138
      
139
22.4k
      if (!info.IsValidDNG ())
140
6.18k
        {
141
6.18k
        return dng_error_bad_format;
142
6.18k
        }
143
        
144
16.2k
      negative.Reset (host.Make_dng_negative ());
145
      
146
16.2k
      negative->Parse (host, stream, info);
147
      
148
16.2k
      negative->PostParse (host, stream, info);
149
      
150
16.2k
        {
151
        
152
16.2k
        dng_timer timer ("Raw image read time");
153
154
16.2k
        negative->ReadStage1Image (host, stream, info);
155
        
156
16.2k
        }
157
        
158
16.2k
      if (info.fMaskIndex != -1)
159
0
        {
160
        
161
0
        dng_timer timer ("Transparency mask read time");
162
163
0
        negative->ReadTransparencyMask (host, stream, info);
164
        
165
0
        }
166
        
167
16.2k
      negative->ValidateRawImageDigest (host);
168
        
169
16.2k
      }
170
           
171
    // Option to write stage 1 image.
172
      
173
16.2k
    if (gDumpStage1.NotEmpty ())
174
2.95k
      {
175
      
176
2.95k
      dng_file_stream stream2 (gDumpStage1.Get (), true);
177
      
178
2.95k
      const dng_image &stage1 = *negative->Stage1Image ();
179
      
180
2.95k
      dng_image_writer writer;
181
      
182
2.95k
      writer.WriteTIFF (host,
183
2.95k
                stream2,
184
2.95k
                stage1,
185
2.95k
                stage1.Planes () >= 3 ? piRGB 
186
2.95k
                            : piBlackIsZero);
187
188
2.95k
      gDumpStage1.Clear ();
189
      
190
2.95k
      }
191
      
192
    // Metadata.
193
      
194
16.2k
    negative->SynchronizeMetadata ();
195
    
196
    // Four color Bayer option.
197
    
198
16.2k
    if (gFourColorBayer)
199
2.89k
      {
200
2.89k
      negative->SetFourColorBayer ();
201
2.89k
      }
202
      
203
    // Build stage 2 image.
204
    
205
16.2k
      {
206
      
207
16.2k
      dng_timer timer ("Linearization time");
208
      
209
16.2k
      negative->BuildStage2Image (host);
210
                     
211
16.2k
      }
212
           
213
16.2k
    if (gDumpStage2.NotEmpty ())
214
2.75k
      {
215
      
216
2.75k
      dng_file_stream stream2 (gDumpStage2.Get (), true);
217
      
218
2.75k
      const dng_image &stage2 = *negative->Stage2Image ();
219
            
220
2.75k
      dng_image_writer writer;
221
      
222
2.75k
      writer.WriteTIFF (host,
223
2.75k
                stream2,
224
2.75k
                stage2,
225
2.75k
                stage2.Planes () >= 3 ? piRGB 
226
2.75k
                            : piBlackIsZero);
227
      
228
2.75k
      gDumpStage2.Clear ();
229
      
230
2.75k
      }
231
      
232
    // Build stage 3 image.
233
      
234
16.2k
      {
235
      
236
16.2k
      dng_timer timer ("Interpolate time");
237
    
238
16.2k
      negative->BuildStage3Image (host,
239
16.2k
                      gMosaicPlane);
240
              
241
16.2k
      }
242
      
243
    // Convert to proxy, if requested.
244
    
245
16.2k
    if (gProxyDNGSize)
246
3.50k
      {
247
      
248
3.50k
      dng_timer timer ("ConvertToProxy time");
249
      
250
3.50k
      dng_image_writer writer;
251
      
252
3.50k
      negative->ConvertToProxy (host,
253
3.50k
                    writer,
254
3.50k
                    gProxyDNGSize);
255
    
256
3.50k
      }
257
      
258
    // Flatten transparency, if required.
259
    
260
16.2k
    if (negative->NeedFlattenTransparency (host))
261
0
      {
262
      
263
0
      dng_timer timer ("FlattenTransparency time");
264
    
265
0
      negative->FlattenTransparency (host);
266
      
267
0
      }
268
      
269
16.2k
    if (gDumpStage3.NotEmpty ())
270
2.71k
      {
271
      
272
2.71k
      dng_file_stream stream2 (gDumpStage3.Get (), true);
273
      
274
2.71k
      const dng_image &stage3 = *negative->Stage3Image ();
275
      
276
2.71k
      dng_image_writer writer;
277
      
278
2.71k
      writer.WriteTIFF (host,
279
2.71k
                stream2,
280
2.71k
                stage3,
281
2.71k
                stage3.Planes () >= 3 ? piRGB 
282
2.71k
                            : piBlackIsZero);
283
      
284
2.71k
      gDumpStage3.Clear ();
285
      
286
2.71k
      }
287
      
288
    // Output DNG file if requested.
289
      
290
16.2k
    if (gDumpDNG.NotEmpty ())
291
2.97k
      {
292
      
293
      // Build the preview list.
294
      
295
2.97k
      dng_preview_list previewList;
296
      
297
2.97k
      dng_date_time_info dateTimeInfo;
298
      
299
2.97k
      CurrentDateTimeAndZone (dateTimeInfo);
300
                        
301
6.56k
      for (uint32 previewIndex = 0; previewIndex < 2; previewIndex++)
302
5.81k
        {
303
        
304
        // Skip preview if writing a compresssed main2 image to save space
305
        // in this example code.
306
        
307
5.81k
        if (negative->RawJPEGImage () != NULL && previewIndex > 0)
308
1.81k
          {
309
1.81k
          break;
310
1.81k
          }
311
          
312
        // Report timing.
313
      
314
3.99k
        dng_timer timer (previewIndex == 0 ? "Build thumbnail time"
315
3.99k
                           : "Build preview time");
316
        
317
        // Render a preview sized image.
318
        
319
3.99k
        AutoPtr<dng_image> previewImage;
320
        
321
3.99k
          {
322
          
323
3.99k
          dng_render render (host, *negative);
324
          
325
3.99k
          render.SetFinalSpace (negative->IsMonochrome () ? dng_space_GrayGamma22::Get ()
326
3.99k
                                  : dng_space_sRGB       ::Get ());
327
          
328
3.99k
          render.SetFinalPixelType (ttByte);
329
          
330
3.99k
          render.SetMaximumSize (previewIndex == 0 ? 256 : 1024);
331
        
332
3.99k
          previewImage.Reset (render.Render ());
333
        
334
3.99k
          }
335
          
336
        // Don't write the preview if it is same size as thumbnail.
337
        
338
3.99k
        if (previewIndex > 0 &&
339
3.99k
          Max_uint32 (previewImage->Bounds ().W (),
340
996
                previewImage->Bounds ().H ()) <= 256)
341
409
          {
342
409
          break;
343
409
          }
344
        
345
        // If we have compressed JPEG data, create a compressed thumbnail.  Otherwise
346
        // save a uncompressed thumbnail.
347
        
348
3.58k
        bool useCompressedPreview = (negative->RawJPEGImage () != NULL) ||
349
3.58k
                      (previewIndex > 0);
350
        
351
3.58k
        AutoPtr<dng_preview> preview (useCompressedPreview ?
352
2.40k
                        (dng_preview *) new dng_jpeg_preview :
353
3.58k
                        (dng_preview *) new dng_image_preview);
354
                        
355
        // Setup up preview info.
356
                  
357
3.58k
        preview->fInfo.fApplicationName   .Set ("dng_validate");
358
3.58k
        preview->fInfo.fApplicationVersion.Set (kDNGValidateVersion);
359
        
360
3.58k
        preview->fInfo.fSettingsName.Set ("Default");
361
362
3.58k
        preview->fInfo.fColorSpace = previewImage->Planes () == 1 ?
363
2.51k
                       previewColorSpace_GrayGamma22 :
364
3.58k
                       previewColorSpace_sRGB;
365
                      
366
3.58k
        preview->fInfo.fDateTime = dateTimeInfo.Encode_ISO_8601 ();
367
        
368
3.58k
        if (!useCompressedPreview)
369
1.02k
          {
370
          
371
1.02k
          dng_image_preview *imagePreview = dynamic_cast<dng_image_preview *> (preview.Get ());
372
        
373
1.02k
          imagePreview->fImage.Reset (previewImage.Release ());
374
          
375
1.02k
          }
376
          
377
2.56k
        else
378
2.56k
          {
379
380
2.56k
          dng_jpeg_preview *jpegPreview = dynamic_cast<dng_jpeg_preview *> (preview.Get ());
381
          
382
2.56k
          int32 quality = (previewIndex == 0 ? 8 : 5);
383
384
2.56k
          dng_image_writer writer;
385
          
386
2.56k
          writer.EncodeJPEGPreview (host,
387
2.56k
                          *previewImage,
388
2.56k
                          *jpegPreview,
389
2.56k
                        quality);
390
                      
391
2.56k
          }
392
    
393
3.58k
        previewList.Append (preview);
394
        
395
3.58k
        }
396
        
397
      // Write DNG file.
398
      
399
2.97k
      dng_file_stream stream2 (gDumpDNG.Get (), true);
400
      
401
2.97k
        {
402
        
403
2.97k
        dng_timer timer ("Write DNG time");
404
      
405
2.97k
        dng_image_writer writer;
406
      
407
2.97k
        writer.WriteDNG (host,
408
2.97k
                 stream2,
409
2.97k
                 *negative.Get (),
410
2.97k
                 &previewList,
411
2.97k
                 dngVersion_Current,
412
2.97k
                 false);
413
414
2.97k
        }
415
        
416
2.97k
      gDumpDNG.Clear ();
417
      
418
2.97k
      }
419
          
420
    // Output TIF file if requested.
421
      
422
16.2k
    if (gDumpTIF.NotEmpty ())
423
2.81k
      {
424
      
425
      // Render final image.
426
        
427
2.81k
      dng_render render (host, *negative);
428
      
429
2.81k
      render.SetFinalSpace     (*gFinalSpace   );
430
2.81k
      render.SetFinalPixelType (gFinalPixelType);
431
      
432
2.81k
      if (host.MinimumSize ())
433
441
        {
434
        
435
441
        dng_point stage3Size = negative->Stage3Image ()->Size ();
436
        
437
441
        render.SetMaximumSize (Max_uint32 (stage3Size.v,
438
441
                           stage3Size.h));
439
440
441
        }
441
      
442
2.81k
      AutoPtr<dng_image> finalImage;
443
      
444
2.81k
        {
445
        
446
2.81k
        dng_timer timer ("Render time");
447
      
448
2.81k
        finalImage.Reset (render.Render ());
449
        
450
2.81k
        }
451
        
452
2.81k
      finalImage->Rotate (negative->Orientation ());
453
      
454
      // Now that Camera Raw supports non-raw formats, we should
455
      // not keep any Camera Raw settings in the XMP around when
456
      // writing rendered files.
457
      
458
      #if qDNGUseXMP
459
      
460
      if (negative->GetXMP ())
461
        {
462
463
        negative->GetXMP ()->RemoveProperties (XMP_NS_CRS);
464
        negative->GetXMP ()->RemoveProperties (XMP_NS_CRSS);
465
        
466
        }
467
      
468
      #endif
469
      
470
      // Write TIF file.
471
      
472
2.81k
      dng_file_stream stream2 (gDumpTIF.Get (), true);
473
      
474
2.81k
        {
475
        
476
2.81k
        dng_timer timer ("Write TIFF time");
477
      
478
2.81k
        dng_image_writer writer;
479
      
480
2.81k
        writer.WriteTIFF (host,
481
2.81k
                  stream2,
482
2.81k
                  *finalImage.Get (),
483
2.81k
                  finalImage->Planes () >= 3 ? piRGB 
484
2.81k
                               : piBlackIsZero,
485
2.81k
                  ccUncompressed,
486
2.81k
                  negative.Get (),
487
2.81k
                  &render.FinalSpace ());
488
                  
489
2.81k
        }
490
        
491
2.81k
      gDumpTIF.Clear ();
492
      
493
2.81k
      }
494
          
495
16.2k
    }
496
  
497
22.4k
  catch (const dng_exception &except)
498
22.4k
    {
499
    
500
12.8k
    return except.ErrorCode ();
501
    
502
12.8k
    }
503
    
504
22.4k
  catch (...)
505
22.4k
    {
506
    
507
0
    return dng_error_unknown;
508
    
509
0
    }
510
    
511
  //idation complete\n");
512
  
513
3.43k
  return dng_error_none;
514
515
22.4k
  }
516
517
/*****************************************************************************/
518
519
int main2 (int argc, char *argv [])
520
0
  {
521
  
522
0
  try
523
0
    {
524
525
0
    if (argc == 1)
526
0
      {
527
528
0
      fprintf (stderr,
529
0
           "\n"
530
0
           "dng_validate, version " kDNGValidateVersion " "
531
0
           #if qDNG64Bit
532
0
           "(64-bit)"
533
           #else
534
           "(32-bit)"
535
           #endif
536
0
           "\n"
537
0
           "Copyright 2005-2012 Adobe Systems, Inc.\n"
538
0
           "\n"
539
0
           "Usage:  %s [options] file1 file2 ...\n"
540
0
           "\n"
541
0
           "Valid options:\n"
542
0
           "-v            Verbose mode\n"
543
0
           "-d <num>      Dump line limit (implies -v)\n"
544
0
           "-b4           Use four-color Bayer interpolation\n"
545
0
           "-s <num>      Use this sample of multi-sample CFAs\n"
546
0
           "-size <num>   Preferred preview image size\n"
547
0
           "-min <num>    Minimum preview image size\n"
548
0
           "-max <num>    Maximum preview image size\n" 
549
0
           "-proxy <num>  Target size for proxy DNG\n"
550
0
           "-cs1          Color space: \"sRGB\" (default)\n"
551
0
           "-cs2          Color space: \"Adobe RGB\"\n"
552
0
           "-cs3          Color space: \"ProPhoto RGB\"\n"
553
0
           "-cs4          Color space: \"ColorMatch RGB\"\n"
554
0
           "-cs5          Color space: \"Gray Gamma 1.8\"\n"
555
0
           "-cs6          Color space: \"Gray Gamma 2.2\"\n"
556
0
           "-16           16-bits/channel output\n"
557
0
           "-1 <file>     Write stage 1 image to \"<file>.tif\"\n"
558
0
           "-2 <file>     Write stage 2 image to \"<file>.tif\"\n"
559
0
           "-3 <file>     Write stage 3 image to \"<file>.tif\"\n"
560
0
           "-tif <file>   Write TIF image to \"<file>.tif\"\n"
561
0
           "-dng <file>   Write DNG image to \"<file>.dng\"\n"
562
0
           "\n",
563
0
           argv [0]);
564
           
565
0
      return 1;
566
      
567
0
      }
568
      
569
0
    int index;
570
    
571
0
    for (index = 1; index < argc && argv [index] [0] == '-'; index++)
572
0
      {
573
      
574
0
      dng_string option;
575
      
576
0
      option.Set (&argv [index] [1]);
577
      
578
0
      if (option.Matches ("v", true))
579
0
        {
580
0
        gVerbose = true;
581
0
        }
582
        
583
0
      else if (option.Matches ("d", true))
584
0
        {
585
          
586
0
        gVerbose = true;
587
        
588
0
        gDumpLineLimit = 0;
589
        
590
0
        if (index + 1 < argc)
591
0
          {
592
0
          gDumpLineLimit = atoi (argv [++index]);
593
0
          }
594
          
595
0
        if (!gDumpLineLimit)
596
0
          {
597
0
          fprintf (stderr, "*** Invalid number after -d\n");
598
0
          return 1;
599
0
          }
600
          
601
0
        }
602
        
603
0
      else if (option.Matches ("s", true))
604
0
        {
605
        
606
0
        if (index + 1 < argc)
607
0
          {
608
0
          gMosaicPlane = atoi (argv [++index]);
609
0
          }
610
          
611
0
        else
612
0
          {
613
0
          fprintf (stderr, "*** Missing number after -s\n");
614
0
          return 1;
615
0
          }
616
          
617
0
        }
618
          
619
0
      else if (option.Matches ("b4", true))
620
0
        {
621
0
        gFourColorBayer = true;
622
0
        }
623
          
624
0
      else if (option.Matches ("size", true))
625
0
        {
626
        
627
0
        if (index + 1 < argc)
628
0
          {
629
0
          gPreferredSize = (uint32) atoi (argv [++index]);
630
0
          }
631
          
632
0
        else
633
0
          {
634
0
          fprintf (stderr, "*** Missing number after -size\n");
635
0
          return 1;
636
0
          }
637
          
638
0
        }
639
          
640
0
      else if (option.Matches ("min", true))
641
0
        {
642
        
643
0
        if (index + 1 < argc)
644
0
          {
645
0
          gMinimumSize = (uint32) atoi (argv [++index]);
646
0
          }
647
          
648
0
        else
649
0
          {
650
0
          fprintf (stderr, "*** Missing number after -min\n");
651
0
          return 1;
652
0
          }
653
          
654
0
        }
655
          
656
0
      else if (option.Matches ("max", true))
657
0
        {
658
        
659
0
        if (index + 1 < argc)
660
0
          {
661
0
          gMaximumSize = (uint32) atoi (argv [++index]);
662
0
          }
663
          
664
0
        else
665
0
          {
666
0
          fprintf (stderr, "*** Missing number after -max\n");
667
0
          return 1;
668
0
          }
669
          
670
0
        }
671
          
672
0
      else if (option.Matches ("proxy", true))
673
0
        {
674
        
675
0
        if (index + 1 < argc)
676
0
          {
677
0
          gProxyDNGSize = (uint32) atoi (argv [++index]);
678
0
          }
679
          
680
0
        else
681
0
          {
682
0
          fprintf (stderr, "*** Missing number after -proxy\n");
683
0
          return 1;
684
0
          }
685
686
0
        }
687
          
688
0
      else if (option.Matches ("cs1", true))
689
0
        {
690
        
691
0
        gFinalSpace = &dng_space_sRGB::Get ();
692
        
693
0
        }
694
          
695
0
      else if (option.Matches ("cs2", true))
696
0
        {
697
        
698
0
        gFinalSpace = &dng_space_AdobeRGB::Get ();
699
        
700
0
        }
701
          
702
0
      else if (option.Matches ("cs3", true))
703
0
        {
704
        
705
0
        gFinalSpace = &dng_space_ProPhoto::Get ();
706
        
707
0
        }
708
          
709
0
      else if (option.Matches ("cs4", true))
710
0
        {
711
        
712
0
        gFinalSpace = &dng_space_ColorMatch::Get ();
713
        
714
0
        }
715
          
716
0
      else if (option.Matches ("cs5", true))
717
0
        {
718
        
719
0
        gFinalSpace = &dng_space_GrayGamma18::Get ();
720
        
721
0
        }
722
          
723
0
      else if (option.Matches ("cs6", true))
724
0
        {
725
        
726
0
        gFinalSpace = &dng_space_GrayGamma22::Get ();
727
        
728
0
        }
729
          
730
0
      else if (option.Matches ("16"))
731
0
        {
732
        
733
0
        gFinalPixelType = ttShort;
734
        
735
0
        }
736
          
737
0
      else if (option.Matches ("1"))
738
0
        {
739
        
740
0
        gDumpStage1.Clear ();
741
        
742
0
        if (index + 1 < argc)
743
0
          {
744
0
          gDumpStage1.Set (argv [++index]);
745
0
          }
746
          
747
0
        if (gDumpStage1.IsEmpty () || gDumpStage1.StartsWith ("-"))
748
0
          {
749
0
          fprintf (stderr, "*** Missing file name after -1\n");
750
0
          return 1;
751
0
          }
752
        
753
0
        if (!gDumpStage1.EndsWith (".tif"))
754
0
          {
755
0
          gDumpStage1.Append (".tif");
756
0
          }
757
        
758
0
        }
759
          
760
0
      else if (option.Matches ("2"))
761
0
        {
762
        
763
0
        gDumpStage2.Clear ();
764
        
765
0
        if (index + 1 < argc)
766
0
          {
767
0
          gDumpStage2.Set (argv [++index]);
768
0
          }
769
          
770
0
        if (gDumpStage2.IsEmpty () || gDumpStage2.StartsWith ("-"))
771
0
          {
772
0
          fprintf (stderr, "*** Missing file name after -2\n");
773
0
          return 1;
774
0
          }
775
        
776
0
        if (!gDumpStage2.EndsWith (".tif"))
777
0
          {
778
0
          gDumpStage2.Append (".tif");
779
0
          }
780
        
781
0
        }
782
          
783
0
      else if (option.Matches ("3"))
784
0
        {
785
        
786
0
        gDumpStage3.Clear ();
787
        
788
0
        if (index + 1 < argc)
789
0
          {
790
0
          gDumpStage3.Set (argv [++index]);
791
0
          }
792
          
793
0
        if (gDumpStage3.IsEmpty () || gDumpStage3.StartsWith ("-"))
794
0
          {
795
0
          fprintf (stderr, "*** Missing file name after -3\n");
796
0
          return 1;
797
0
          }
798
        
799
0
        if (!gDumpStage3.EndsWith (".tif"))
800
0
          {
801
0
          gDumpStage3.Append (".tif");
802
0
          }
803
        
804
0
        }
805
        
806
0
      else if (option.Matches ("tif", true))
807
0
        {
808
        
809
0
        gDumpTIF.Clear ();
810
        
811
0
        if (index + 1 < argc)
812
0
          {
813
0
          gDumpTIF.Set (argv [++index]);
814
0
          }
815
          
816
0
        if (gDumpTIF.IsEmpty () || gDumpTIF.StartsWith ("-"))
817
0
          {
818
0
          fprintf (stderr, "*** Missing file name after -tif\n");
819
0
          return 1;
820
0
          }
821
        
822
0
        if (!gDumpTIF.EndsWith (".tif"))
823
0
          {
824
0
          gDumpTIF.Append (".tif");
825
0
          }
826
        
827
0
        }
828
        
829
0
      else if (option.Matches ("dng", true))
830
0
        {
831
        
832
0
        gDumpDNG.Clear ();
833
        
834
0
        if (index + 1 < argc)
835
0
          {
836
0
          gDumpDNG.Set (argv [++index]);
837
0
          }
838
          
839
0
        if (gDumpDNG.IsEmpty () || gDumpDNG.StartsWith ("-"))
840
0
          {
841
0
          fprintf (stderr, "*** Missing file name after -dng\n");
842
0
          return 1;
843
0
          }
844
        
845
0
        if (!gDumpDNG.EndsWith (".dng"))
846
0
          {
847
0
          gDumpDNG.Append (".dng");
848
0
          }
849
        
850
0
        }
851
        
852
0
      else
853
0
        {
854
0
        fprintf (stderr, "*** Unknown option \"-%s\"\n", option.Get ());
855
0
        return 1;
856
0
        }
857
        
858
0
      }
859
          
860
0
    if (index == argc)
861
0
      {
862
0
      fprintf (stderr, "*** No file specified\n");
863
0
      return 1;
864
0
      }
865
    
866
    #if qDNGUseXMP
867
      
868
    dng_xmp_sdk::InitializeSDK ();
869
    
870
    #endif
871
      
872
0
    int result = 0;
873
    
874
0
    while (index < argc)
875
0
      {
876
      
877
0
      dng_error_code error_code = dng_validate (argv [index++]);
878
0
      if (error_code != dng_error_none)
879
0
        {
880
        
881
0
        result = error_code - dng_error_unknown + 100;
882
        
883
0
        }
884
      
885
0
      }
886
    
887
    #if qDNGUseXMP
888
    
889
    dng_xmp_sdk::TerminateSDK ();
890
    
891
    #endif
892
      
893
0
    return result;
894
    
895
0
    }
896
    
897
0
  catch (...)
898
0
    {
899
    
900
0
    }
901
    
902
0
  fprintf (stderr, "*** Exception thrown in main2 routine\n");
903
  
904
0
  return 1;
905
  
906
0
  }
907
  
908
/*****************************************************************************/
909
910
#endif
911
  
912
/*****************************************************************************/
913
/* Copyright 2021 Google LLC
914
Licensed under the Apache License, Version 2.0 (the "License");
915
you may not use this file except in compliance with the License.
916
You may obtain a copy of the License at
917
      http://www.apache.org/licenses/LICENSE-2.0
918
Unless required by applicable law or agreed to in writing, software
919
distributed under the License is distributed on an "AS IS" BASIS,
920
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
921
See the License for the specific language governing permissions and
922
limitations under the License.
923
*/
924
#include <fuzzer/FuzzedDataProvider.h>
925
#include <stdio.h>
926
#include <stdlib.h>
927
#include <unistd.h>
928
929
6.04k
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
930
6.04k
  FuzzedDataProvider provider(data, size);
931
932
  // Set the various sizes
933
6.04k
  gPreferredSize = provider.ConsumeIntegral<uint32_t>();
934
6.04k
  gMinimumSize = provider.ConsumeIntegral<uint32_t>();
935
6.04k
  gMaximumSize = provider.ConsumeIntegral<uint32_t>();
936
937
6.04k
  gDumpDNG.Clear();
938
6.04k
  char dumpDNGFilename[256];
939
6.04k
  if (provider.ConsumeBool()) {
940
2.78k
    sprintf(dumpDNGFilename, "/tmp/libfuzzer-dng.%d.dng", getpid());
941
2.78k
    gDumpDNG.Set(dumpDNGFilename); 
942
2.78k
  }
943
944
6.04k
  gDumpStage1.Clear();
945
6.04k
  char dumpStage1Filename[256];
946
6.04k
  if (provider.ConsumeBool()) {
947
2.20k
    sprintf(dumpStage1Filename, "/tmp/libfuzzer-stage1.%d.dng", getpid());
948
2.20k
    gDumpStage1.Set(dumpStage1Filename); 
949
2.20k
  }
950
  
951
952
6.04k
  gDumpStage2.Clear();
953
6.04k
  char dumpStage2Filename[256];
954
6.04k
  if (provider.ConsumeBool()) {
955
1.96k
    sprintf(dumpStage2Filename, "/tmp/libfuzzer-stage2.%d.dng", getpid());
956
1.96k
    gDumpStage2.Set(dumpStage2Filename); 
957
1.96k
  }
958
959
6.04k
  gDumpStage3.Clear();
960
6.04k
  char dumpStage3Filename[256];
961
6.04k
  if (provider.ConsumeBool()) {
962
2.08k
    sprintf(dumpStage3Filename, "/tmp/libfuzzer-stage3.%d.dng", getpid());
963
2.08k
    gDumpStage3.Set(dumpStage3Filename); 
964
2.08k
  }
965
966
6.04k
  gDumpTIF.Clear();
967
6.04k
  char dumpTifFilename[256];
968
6.04k
  if (provider.ConsumeBool()) {
969
2.46k
    sprintf(dumpTifFilename, "/tmp/libfuzzer-tif.%d.tif", getpid());
970
2.46k
    gDumpTIF.Set(dumpTifFilename); 
971
2.46k
  }
972
973
6.04k
  gProxyDNGSize = provider.ConsumeIntegral<uint32_t>();
974
6.04k
  gMosaicPlane = provider.ConsumeIntegral<int32_t>();
975
976
977
6.04k
  gFourColorBayer = provider.ConsumeBool();
978
979
6.04k
  switch (provider.ConsumeIntegralInRange(0, 7)) {
980
2.81k
    case 0:
981
2.81k
      gFinalSpace = &dng_space_sRGB::Get ();
982
2.81k
      break;
983
650
    case 1:
984
650
      gFinalSpace = &dng_space_AdobeRGB::Get ();
985
650
      break;
986
472
    case 2:
987
472
      gFinalSpace = &dng_space_ProPhoto::Get ();
988
472
      break;
989
334
    case 3:
990
334
      gFinalSpace = &dng_space_ColorMatch::Get ();
991
334
      break;
992
349
    case 4:
993
349
      gFinalSpace = &dng_space_GrayGamma18::Get ();
994
349
      break;
995
310
    case 5:
996
310
      gFinalSpace = &dng_space_GrayGamma22::Get ();
997
310
      break;
998
1.11k
    default:
999
1.11k
      gFinalSpace = &dng_space_sRGB::Get ();
1000
1.11k
      break;
1001
6.04k
  }
1002
1003
6.04k
  char filename[256];
1004
6.04k
  sprintf(filename, "/tmp/libfuzzer.%d", getpid());
1005
6.04k
  std::string restData = provider.ConsumeRemainingBytesAsString();
1006
6.04k
  if (restData.size() > 0) {
1007
6.04k
    FILE *fp = fopen(filename, "wb");
1008
6.04k
    if (!fp) {
1009
0
        return 0;
1010
0
    }
1011
6.04k
    fwrite(restData.c_str(), restData.size(), 1, fp);
1012
6.04k
    fclose(fp);
1013
1014
    // Target
1015
6.04k
    dng_validate(filename);
1016
1017
    // cleanup file
1018
6.04k
    unlink(filename);
1019
6.04k
  }
1020
6.04k
  return 0;
1021
6.04k
}