FCam: processing/DNG.cpp Source File

00001 #include "DNG.h"
00002 #include "../Frame.h"
00003 #include "../Sensor.h"
00004 #include "../Lens.h"
00005 #include "../Flash.h"
00006 
00007 #include <fstream>
00008 #include <stdio.h>
00009 #include <string.h>
00010 #include <time.h>
00011 #include <sched.h>
00012 
00013 namespace FCam {
00014 
00015 
00016 #define INTEL_ORDER     "II"
00017 #define VERSION         42
00018 
00019     typedef struct tag_IFD {
00020     unsigned short   uTag;
00021     unsigned short   uType;
00022     unsigned         uCount;
00023     unsigned       uOffset;
00024     } IFD;
00025 
00026 // Type values
00027 #define TIFF_TYPE_BYTE      1
00028 #define TIFF_TYPE_ASCII     2
00029 #define TIFF_TYPE_SHORT     3
00030 #define TIFF_TYPE_LONG      4
00031 #define TIFF_TYPE_RATIONAL  5
00032 #define TIFF_TYPE_SBYTE     6
00033 #define TIFF_TYPE_UNDEFINED 7
00034 #define TIFF_TYPE_SSHORT    8
00035 #define TIFF_TYPE_SLONG     9
00036 #define TIFF_TYPE_SRATIONAL 10
00037 #define TIFF_TYPE_FLOAT     11
00038 #define TIFF_TYPE_DOUBLE    12
00039 
00040 // Tag values
00041 #define TIFF_TAG_NewSubFileType           254
00042 #define TIFF_TAG_ImageWidth           256
00043 #define TIFF_TAG_ImageLength              257
00044 #define TIFF_TAG_BitsPerSample            258
00045 #define TIFF_TAG_Compression              259
00046 #define TIFF_TAG_PhotometricInterpretation    262
00047 #define TIFF_TAG_Make                     271
00048 #define TIFF_TAG_Model                272
00049 #define TIFF_TAG_StripOffsets             273
00050 #define TIFF_TAG_Orientation              274
00051 #define TIFF_TAG_SamplesPerPixel          277
00052 #define TIFF_TAG_RowsPerStrip             278
00053 #define TIFF_TAG_StripByteCounts          279
00054 #define TIFF_TAG_PlanarConfiguration          284
00055 #define TIFF_TAG_ResolutionUnit           296
00056 #define TIFF_TAG_Software             305
00057 #define TIFF_TAG_DateTime             306
00058 
00059 #define TIFFEP_TAG_CFARepeatPatternDim      33421
00060 #define TIFFEP_TAG_CFAPattern           33422
00061 #define TIFFEP_TAG_Flash            37385
00062 #define TIFFEP_TAG_TIFFEPStandardID     37398
00063 
00064 #define DNG_TAG_DNGVersion          50706
00065 #define DNG_TAG_DNGBackwardVersion      50707
00066 #define DNG_TAG_UniqueCameraModel       50708
00067 #define DNG_TAG_LocalizedCameraModel        50709
00068 #define DNG_TAG_CFAPlaneColor           50710
00069 #define DNG_TAG_CFALayout           50711
00070 #define DNG_TAG_BlackLevelRepeatDim     50713
00071 #define DNG_TAG_BlackLevel          50714
00072 #define DNG_TAG_BlackLevelDeltaH        50715
00073 #define DNG_TAG_BlackLevelDeltaV        50716
00074 #define DNG_TAG_WhiteLevel          50717
00075 #define DNG_TAG_DefaultScale            50718
00076 #define DNG_TAG_DefaultCropOrigin       50719
00077 #define DNG_TAG_DefaultCropSize         50720
00078 #define DNG_TAG_ColorMatrix1            50721
00079 #define DNG_TAG_ColorMatrix2            50722
00080 #define DNG_TAG_CameraCalibration1      50723
00081 #define DNG_TAG_CameraCalibration2      50724
00082 #define DNG_TAG_ReductionMatrix1        50725
00083 #define DNG_TAG_ReductionMatrix2        50726
00084 #define DNG_TAG_AnalogBalance           50727
00085 #define DNG_TAG_AsShotNeutral           50728
00086 #define DNG_TAG_AsShotWhiteXY           50729
00087 #define DNG_TAG_BaselineExposure        50730
00088 #define DNG_TAG_BaselineNoise           50731
00089 #define DNG_TAG_BaselineSharpness       50732
00090 #define DNG_TAG_BayerGreenSplit         50733
00091 #define DNG_TAG_LinearResponseLimit     50734
00092 #define DNG_TAG_LensInfo            50736
00093 #define DNG_TAG_ChromaBlurRadius        50737
00094 #define DNG_TAG_AntiAliasStrength       50738
00095 #define DNG_TAG_ShadowScale         50739
00096 #define DNG_TAG_DNGPrivateData          50740
00097 #define DNG_TAG_MakerNoteSafety         50741
00098 #define DNG_TAG_CalibrationIlluminant1      50778
00099 #define DNG_TAG_CalibrationIlluminant2      50779
00100 #define DNG_TAG_BestQualityScale        50780
00101 #define DNG_TAG_ActiveArea          50829
00102 #define DNG_TAG_MaskedAreas         50830
00103 
00104 // tags from version 1.3.0.0
00105 #define DNG_TAG_NoiseProfile                    51041
00106 
00107     void saveDNG(Frame::Ptr frame, std::string filename, Lens *lens, Flash *flash) {
00108 
00109     printf("In writeDNG\n"); fflush(stdout);
00110     
00111     if (!frame) {
00112         fprintf(stderr, "Can't save a NULL frame\n");
00113         return;
00114     }
00115     if (!frame->image.data) {
00116         fprintf(stderr, "Can't save a frame without image data\n");
00117         return;
00118     }
00119     if (frame->image.type != FCam::RAW) {
00120         fprintf(stderr, "Can't save a non-RAW frame as DNG\n");
00121         return;
00122     }
00123     if (!frame->sensor) {
00124         fprintf(stderr, "Can't save a frame with a missing sensor\n");
00125         return;
00126     }
00127     if (frame->sensor->getBayerPattern() == Sensor::NotBayer) {
00128         fprintf(stderr, "Can't save non bayer-patterned sensor data\n");
00129         return;
00130     }
00131     
00132     FILE *hDNG = fopen(filename.c_str(),"w");
00133     if (hDNG==NULL) 
00134         return;
00135     
00136     unsigned width = frame->image.size.width;
00137     unsigned height = frame->image.size.height;
00138     
00139     // TIFF data layout calculations (64k strip for 16bit data)
00140     unsigned short uRowsPerStrip = (32 * 1024) / width;
00141     
00142     unsigned short uStripsPerImg = (height / uRowsPerStrip);
00143     if (height % uRowsPerStrip != 0) {
00144         uStripsPerImg++;
00145     }    
00146     
00147     const std::string &cameraManufacturer = frame->sensor->getManufacturer();
00148     const std::string &cameraModel = frame->sensor->getModel();
00149     const std::string cameraSoftware = "FCAM DNG Writer";   
00150 
00151     
00152     /***************************************************************************************************/
00153     
00154     // Write TIFF file header
00155     
00156     unsigned int dwWritten;
00157     char byteOrder[3] = {INTEL_ORDER};
00158     
00159     if ((dwWritten = fwrite(byteOrder, sizeof(char), 2, hDNG)) != 2) {
00160         fprintf( stderr, "\t** Error writing DNG - header byte order\n" );
00161         fclose(hDNG); 
00162         return;
00163     }
00164     
00165     unsigned short uVer = VERSION;
00166     if ((dwWritten = fwrite(&uVer, sizeof(unsigned short), 1, hDNG)) != 1) {
00167         fprintf( stderr, "\t** Error writing DNG - header file version\n" );
00168         fclose(hDNG);
00169         return;
00170     }
00171     
00172     unsigned uIFD0off = 0x00000008;
00173     if ((dwWritten = fwrite(&uIFD0off, sizeof(unsigned), 1, hDNG)) != 1) {
00174         fprintf( stderr, "\t** Error writing DNG - header IFD offset\n" );
00175         fclose(hDNG);
00176         return;
00177     }
00178     
00179     // Write IFD0
00180     // Maximum number of IFD0 tags is 49 - we deduct the ones we won't use
00181     // FIGURE OUT WHICH TAGS DNG ADDS BY DEFAULT!!!
00182     unsigned short uIFD0cnt = 49;
00183         
00184     // DNG accepts a bunch of useful calibration matrices. We should
00185     // get all these calibrated and put in good values, but for now
00186     // we'll just skip most of them
00187     
00188     // cameraCalibration matrices not supported - doubtful if we will
00189     uIFD0cnt-=2;
00190     
00191     // forward matrices not supported - doubtful if we will
00192     uIFD0cnt-=2;
00193     
00194     // asShotNeutral not yet supported
00195     uIFD0cnt-=1;
00196         
00197     if ((dwWritten = fwrite(&uIFD0cnt, sizeof(unsigned short), 1, hDNG)) != 1) {
00198         fprintf( stderr, "\t** Error writing DNG - header IFD count\n" );
00199         fclose(hDNG);
00200         return;
00201     }
00202     
00203     unsigned uDataOffset = 10;      // header + IFD0 count
00204     uDataOffset += uIFD0cnt * sizeof(IFD);
00205     uDataOffset += 4;               // Next IFD pointer
00206     
00207     
00208     /**************************************************************************************************/
00209       
00210     // write IFDs
00211     IFD ifd;
00212     
00213     // TIFF_TAG_NewSubFileType
00214     ifd.uTag = TIFF_TAG_NewSubFileType;
00215     ifd.uType = TIFF_TYPE_LONG;
00216     ifd.uCount = 1;
00217     ifd.uOffset = 0;    // 0 = main image
00218     
00219     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00220         fprintf( stderr, "\t** Error writing DNG - TIFF_TAG_NewSubFileType\n" );
00221         fclose(hDNG); 
00222         return;
00223     }
00224     
00225     // TIFF_TAG_ImageWidth
00226     ifd.uTag = TIFF_TAG_ImageWidth;
00227     ifd.uType = TIFF_TYPE_LONG;
00228     ifd.uCount = 1;
00229     ifd.uOffset = width;
00230     
00231     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00232         fprintf( stderr, "\t** Error writing DNG - TIFF_TAG_ImageWidth\n" );
00233         fclose(hDNG); 
00234         return;
00235     }
00236     
00237     // TIFF_TAG_ImageLength
00238     ifd.uTag = TIFF_TAG_ImageLength;
00239     ifd.uType = TIFF_TYPE_LONG;
00240     ifd.uCount = 1;
00241     ifd.uOffset = height;
00242     
00243     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {    
00244         fprintf( stderr, "\t** Error writing DNG - TIFF_TAG_ImageLength\n" );
00245         fclose(hDNG); 
00246         return;
00247     }
00248 
00249     // TIFF_TAG_BitsPerSample
00250     ifd.uTag = TIFF_TAG_BitsPerSample;
00251     ifd.uType = TIFF_TYPE_SHORT;
00252     ifd.uCount = 1;
00253     ifd.uOffset = 16;    // 16 bits per sample
00254     
00255     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00256     
00257         fprintf( stderr, "\t** Error writing DNG - TIFF_TAG_BitsPerSample\n" );
00258         fclose(hDNG); 
00259         return;
00260     }
00261     
00262     // TIFF_TAG_Compression
00263     ifd.uTag = TIFF_TAG_Compression;
00264     ifd.uType = TIFF_TYPE_SHORT;
00265     ifd.uCount = 1;
00266     ifd.uOffset = 1;        // 1 = uncompressed - BETTER COMPRESSION NEEDED
00267     
00268     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00269         fprintf( stderr, "\t** Error writing DNG - TIFF_TAG_Compression\n" );
00270         fclose(hDNG); 
00271         return;
00272     }
00273     
00274     // TIFF_TAG_PhotometricInterpretation
00275     ifd.uTag = TIFF_TAG_PhotometricInterpretation;
00276     ifd.uType = TIFF_TYPE_SHORT;
00277     ifd.uCount = 1;
00278     ifd.uOffset = 32803;        // 32803 = CFA
00279     
00280     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00281         fprintf( stderr, "\t** Error writing DNG - TIFF_TAG_PhotometricInterpretation\n" );
00282         fclose(hDNG); 
00283         return;
00284     }
00285     
00286     // TIFF_TAG_Make
00287     ifd.uTag = TIFF_TAG_Make;
00288     ifd.uType = TIFF_TYPE_ASCII;
00289     ifd.uCount = cameraManufacturer.size() + 1;
00290     ifd.uOffset = uDataOffset;
00291     uDataOffset += ifd.uCount;
00292     
00293     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00294         fprintf( stderr, "\t** Error writing DNG - TIFF_TAG_Make\n" );
00295         fclose(hDNG); 
00296         return;
00297     }
00298     
00299     // TIFF_TAG_Model
00300     ifd.uTag = TIFF_TAG_Model;
00301     ifd.uType = TIFF_TYPE_ASCII;
00302     ifd.uCount = cameraModel.size() + 1;
00303     ifd.uOffset = uDataOffset;
00304     uDataOffset += ifd.uCount;
00305     
00306     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00307         fprintf( stderr, "\t** Error writing DNG - TIFF_TAG_Model\n" );
00308         fclose(hDNG); 
00309         return;
00310     }
00311     
00312     // TIFF_TAG_StripOffsets
00313     ifd.uTag = TIFF_TAG_StripOffsets;
00314     ifd.uType = TIFF_TYPE_LONG;
00315     ifd.uCount = uStripsPerImg;
00316     ifd.uOffset = uDataOffset;
00317     uDataOffset += (uStripsPerImg * 4);
00318     
00319     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00320     
00321         fprintf( stderr, "\t** Error writing DNG - TIFF_TAG_StripOffsets\n" );
00322         fclose(hDNG); 
00323         return;
00324     }
00325     
00326     // TIFF_TAG_Orientation
00327     ifd.uTag = TIFF_TAG_Orientation;
00328     ifd.uType = TIFF_TYPE_SHORT;
00329     ifd.uCount = 1;
00330     ifd.uOffset = 1;          // 1 = normal "landscape" image
00331   
00332     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00333     
00334         fprintf( stderr, "\t** Error writing DNG - TIFF_TAG_Orientation\n" );
00335         fclose(hDNG); 
00336         return;
00337     }
00338     
00339     // TIFF_TAG_SamplesPerPixel
00340     ifd.uTag = TIFF_TAG_SamplesPerPixel;
00341     ifd.uType = TIFF_TYPE_SHORT;
00342     ifd.uCount = 1;
00343     ifd.uOffset = 1;           // 1 sample per pixel
00344     
00345     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {    
00346         fprintf( stderr, "\t** Error writing DNG - TIFF_TAG_SamplesPerPixel\n" );
00347         fclose(hDNG); 
00348         return;
00349     }
00350     
00351     // TIFF_TAG_RowsPerStrip
00352     ifd.uTag = TIFF_TAG_RowsPerStrip;
00353     ifd.uType = TIFF_TYPE_SHORT;
00354     ifd.uCount = 1;
00355     ifd.uOffset = uRowsPerStrip;
00356     
00357     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00358     
00359         fprintf( stderr, "\t** Error writing DNG - TIFF_TAG_RowsPerStrip\n" );
00360         fclose(hDNG); 
00361         return;
00362     }
00363     
00364     // TIFF_TAG_StripByteCounts
00365     ifd.uTag = TIFF_TAG_StripByteCounts;
00366     ifd.uType = TIFF_TYPE_SHORT;
00367     ifd.uCount = uStripsPerImg;
00368     ifd.uOffset = uDataOffset;
00369     uDataOffset += (uStripsPerImg * 2);
00370     
00371     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00372         fprintf( stderr, "\t** Error writing DNG - TIFF_TAG_StripByteCounts\n" );
00373         fclose(hDNG); 
00374         return;
00375     }
00376     
00377     // TIFF_TAG_PlanarConfiguration
00378     ifd.uTag = TIFF_TAG_PlanarConfiguration;
00379     ifd.uType = TIFF_TYPE_SHORT;
00380     ifd.uCount = 1;
00381     ifd.uOffset = 1;           // 1 = spec'd value for CFA image
00382     
00383     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00384         fprintf( stderr, "\t** Error writing DNG - TIFF_TAG_PlanarConfiguration\n" );
00385         fclose(hDNG); 
00386         return;
00387     }
00388     
00389     // TIFF_TAG_ResolutionUnit
00390     ifd.uTag = TIFF_TAG_ResolutionUnit;
00391     ifd.uType = TIFF_TYPE_SHORT;
00392     ifd.uCount = 1;
00393     ifd.uOffset = 2;           // 2 = inches
00394     
00395     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00396         fprintf( stderr, "\t** Error writing DNG - TIFF_TAG_ResolutionUnit\n" );
00397         fclose(hDNG); 
00398         return;
00399     }
00400     
00401     
00402     // TIFF_TAG_Software
00403     ifd.uTag = TIFF_TAG_Software;
00404     ifd.uType = TIFF_TYPE_ASCII;
00405     ifd.uCount = cameraSoftware.size()+1;
00406     ifd.uOffset = uDataOffset;
00407     uDataOffset += ifd.uCount;
00408     
00409     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00410         fprintf( stderr, "\t** Error writing DNG - TIFF_TAG_Software\n" );
00411         fclose(hDNG); 
00412         return;
00413     }
00414     
00415     // TIFF_TAG_DateTime
00416     ifd.uTag = TIFF_TAG_DateTime;
00417     ifd.uType = TIFF_TYPE_ASCII;
00418     ifd.uCount = 20;
00419     ifd.uOffset = uDataOffset;
00420     uDataOffset += 20;
00421     
00422     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00423         fprintf( stderr, "\t** Error writing DNG - TIFF_TAG_DateTime\n" );
00424         fclose(hDNG); 
00425         return;
00426     }
00427 
00428     // TIFFEP_TAG_CFARepeatPatternDim
00429     ifd.uTag = TIFFEP_TAG_CFARepeatPatternDim;
00430     ifd.uType = TIFF_TYPE_SHORT;
00431     ifd.uCount = 2;
00432     ifd.uOffset = 0x00020002;
00433     
00434     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00435         fprintf( stderr, "\t** Error writing DNG - TIFFEP_TAG_CFARepeatPatternDim\n" );
00436         fclose(hDNG); 
00437         return;
00438     }
00439 
00440     // TIFFEP_TAG_CFAPattern
00441     ifd.uTag = TIFFEP_TAG_CFAPattern;
00442     ifd.uType = TIFF_TYPE_BYTE;
00443     ifd.uCount = 4;
00444 
00445     switch(frame->sensor->getBayerPattern()) {
00446     case Sensor::RGGB:
00447         ifd.uOffset = 0x02010100;
00448         break;
00449     case Sensor::BGGR:
00450         ifd.uOffset = 0x00010102;
00451         break;
00452     case Sensor::GRBG:
00453         ifd.uOffset = 0x01020001;
00454         break;
00455     case Sensor::GBRG:
00456         ifd.uOffset = 0x01000201;
00457         break;
00458     case Sensor::NotBayer:
00459         // this was checked for above, so it's ok to panic
00460         fprintf(stderr, "Can't save non-bayer-patterned sensor data!\n");
00461         fclose(hDNG);
00462         return;
00463     }
00464     
00465     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {    
00466         fprintf( stderr, "\t** Error writing DNG - TIFFEP_TAG_CFAPattern\n" );
00467         fclose(hDNG); 
00468         return;
00469     }
00470     
00471     // TIFFEP_TAG_Flash
00472     unsigned short uFlashFlags = 0;
00473     // bit
00474     //       0  : 0 = flash didn't fire, 1 = flash fired
00475     //     21   : 00 = no strobe return detect, 01 = reserved, 10 = strobe return not detected, 11 = strobe return detected
00476     //   43     : 00 = unknown, 01 = compulsory flash, 10 = compulsory flash supress, 11 = auto mode
00477     //  5       : 0 = flash function present, 1 = no flash function
00478     // 6        : 0 = no red-eye reduction, 1 = red-eye reduction supported     
00479     if (flash && frame->tags(flash)) {
00480         // bits 0, 1, 2
00481         uFlashFlags = 7;
00482     }
00483 
00484     ifd.uTag = TIFFEP_TAG_Flash;
00485     ifd.uType = TIFF_TYPE_SHORT;
00486     ifd.uCount = 1;
00487     ifd.uOffset = uFlashFlags;
00488     
00489     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00490         fprintf( stderr, "\t** Error writing DNG - TIFFEP_TAG_Flash\n" );
00491         fclose(hDNG); 
00492         return;
00493     }
00494     
00495     // TIFFEP_TAG_TIFFEPStandardID
00496     ifd.uTag = TIFFEP_TAG_TIFFEPStandardID;
00497     ifd.uType = TIFF_TYPE_BYTE;
00498     ifd.uCount = 4;
00499     ifd.uOffset = 0x00000001;       // 1,0,0,0 - current TIFF/EP standard ID (4/2005)
00500     
00501     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00502         fprintf( stderr, "\t** Error writing DNG - TIFFEP_TAG_TIFFEPStandardID\n" );
00503         fclose(hDNG); 
00504         return;
00505     }
00506     
00507     // DNG_TAG_DNGVersion
00508     ifd.uTag = DNG_TAG_DNGVersion;
00509     ifd.uType = TIFF_TYPE_BYTE;
00510     ifd.uCount = 4;
00511     ifd.uOffset = 0x00000301;       // 1,3,0,0
00512     
00513     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00514         fprintf( stderr, "\t** Error writing DNG - DNG_TAG_DNGVersion\n" );
00515         fclose(hDNG); 
00516         return;
00517     }
00518     
00519     // DNG_TAG_DNGBackwardVersion
00520     ifd.uTag = DNG_TAG_DNGBackwardVersion;
00521     ifd.uType = TIFF_TYPE_BYTE;
00522     ifd.uCount = 4;
00523     ifd.uOffset = 0x00000101;       // 1,1,0,0
00524     
00525     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00526         fprintf( stderr, "\t** Error writing DNG - DNG_TAG_DNGBackwardVersion\n" );
00527         fclose(hDNG); 
00528         return;
00529     }
00530     
00531     // DNG_TAG_UniqueCameraModel
00532     ifd.uTag = DNG_TAG_UniqueCameraModel;
00533     ifd.uType = TIFF_TYPE_ASCII;
00534     ifd.uCount = cameraModel.size()+1;
00535     ifd.uOffset = uDataOffset;
00536     uDataOffset += cameraModel.size()+1;
00537     
00538     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00539         fprintf( stderr, "\t** Error writing DNG - DNG_TAG_UniqueCameraModel\n" );
00540         fclose(hDNG); 
00541         return;
00542     }
00543     
00544     // DNG_TAG_LocalizedCameraModel
00545     ifd.uTag = DNG_TAG_LocalizedCameraModel;
00546     ifd.uType = TIFF_TYPE_ASCII;
00547     ifd.uCount = cameraModel.size()+1;
00548     ifd.uOffset = uDataOffset;
00549     uDataOffset += cameraModel.size()+1;
00550     
00551     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00552         fprintf( stderr, "\t** Error writing DNG - DNG_TAG_LocalizedCameraModel\n" );
00553         fclose(hDNG); 
00554         return;
00555     }
00556     
00557     // DNG_TAG_CFAPlaneColor
00558     ifd.uTag = DNG_TAG_CFAPlaneColor;
00559     ifd.uType = TIFF_TYPE_BYTE;
00560     ifd.uCount = 3;
00561     ifd.uOffset = 0x00020100;   // {0, 1, 2}  :  0=red, 1=green, 2=blue
00562     
00563     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00564         fprintf( stderr, "\t** Error writing DNG - DNG_TAG_CFAPlaneColor\n" );
00565         fclose(hDNG); 
00566         return;
00567     }
00568     
00569     // DNG_TAG_CFALayout
00570     ifd.uTag = DNG_TAG_CFALayout;
00571     ifd.uType = TIFF_TYPE_SHORT;
00572     ifd.uCount = 1;
00573     ifd.uOffset = 1;           // 1= rectangular
00574     
00575     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00576         fprintf( stderr, "\t** Error writing DNG - DNG_TAG_CFALayout\n" );
00577         fclose(hDNG); 
00578         return;
00579     }
00580     
00581     // DNG_TAG_BlackLevelRepeatDim
00582     ifd.uTag = DNG_TAG_BlackLevelRepeatDim;
00583     ifd.uType = TIFF_TYPE_SHORT;
00584     ifd.uCount = 2;
00585     ifd.uOffset = 0x00020002;       // 2 x 2 defines blacklevel
00586     
00587     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00588         fprintf( stderr, "\t** Error writing DNG - DNG_TAG_BlackLevelRepeatDim\n" );
00589         fclose(hDNG); 
00590         return;
00591     }
00592 
00593     // DNG_TAG_BlackLevel
00594     ifd.uTag = DNG_TAG_BlackLevel;
00595     ifd.uType = TIFF_TYPE_SHORT;
00596     ifd.uCount = 4;
00597     ifd.uOffset = uDataOffset;
00598     uDataOffset += 8;
00599     
00600     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00601         fprintf( stderr, "\t** Error writing DNG - DNG_TAG_BlackLevel\n" );
00602         fclose(hDNG); 
00603         return;
00604     }
00605 
00606     // DNG_TAG_WhiteLevel
00607     ifd.uTag = DNG_TAG_WhiteLevel;
00608     ifd.uType = TIFF_TYPE_SHORT;
00609     ifd.uCount = 1;
00610     ifd.uOffset = frame->sensor->maxRawValue(); 
00611 
00612     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1)
00613         {
00614         fprintf( stderr, "\t** Error writing DNG - DNG_TAG_WhiteLevel\n" );
00615         fclose(hDNG); 
00616         return;
00617         }
00618 
00619     // DNG_TAG_DefaultScale
00620     ifd.uTag = DNG_TAG_DefaultScale;
00621     ifd.uType = TIFF_TYPE_RATIONAL;
00622     ifd.uCount = 2;
00623     ifd.uOffset = uDataOffset;
00624     uDataOffset += 16;
00625 
00626     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00627         fprintf( stderr, "\t** Error writing DNG - DNG_TAG_DefaultScale\n" );
00628         fclose(hDNG); 
00629         return;
00630     }
00631 
00632     // DNG_TAG_DefaultCropOrigin
00633     ifd.uTag = DNG_TAG_DefaultCropOrigin;
00634     ifd.uType = TIFF_TYPE_SHORT;
00635     ifd.uCount = 2;
00636     //  ifd.uOffset = (crop_area_x << 16) + crop_area_y;
00637     ifd.uOffset = 0; // zero for now
00638 
00639     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00640         fprintf( stderr, "\t** Error writing DNG - DNG_TAG_DefaultCropOrigin\n" );
00641         fclose(hDNG); 
00642         return;
00643     }
00644 
00645     // DNG_TAG_DefaultCropSize
00646     ifd.uTag = DNG_TAG_DefaultCropSize;
00647     ifd.uType = TIFF_TYPE_SHORT;
00648     ifd.uCount = 2;
00649     //  ifd.uOffset = (crop_area_height << 16) + crop_area_width;
00650     ifd.uCount = (height << 16) | width; // everything for now
00651 
00652     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00653         fprintf( stderr, "\t** Error writing DNG - DNG_TAG_DefaultCropSize\n" );
00654         fclose(hDNG); 
00655         return;
00656     }
00657 
00658     // DNG_TAG_ColorMatrix1
00659     ifd.uTag = DNG_TAG_ColorMatrix1;
00660     ifd.uType = TIFF_TYPE_SRATIONAL;
00661     ifd.uCount = 9;
00662     ifd.uOffset = uDataOffset;
00663     uDataOffset += ifd.uCount * 8;
00664 
00665     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00666         fprintf( stderr, "\t** Error writing DNG - DNG_TAG_ColorMatrix1\n" );
00667         fclose(hDNG); 
00668         return;
00669     }
00670 
00671     // DNG_TAG_ColorMatrix2
00672     ifd.uTag = DNG_TAG_ColorMatrix2;
00673     ifd.uType = TIFF_TYPE_SRATIONAL;
00674     ifd.uCount = 9;
00675     ifd.uOffset = uDataOffset;
00676     uDataOffset += ifd.uCount * 8;
00677     
00678     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00679         fprintf( stderr, "\t** Error writing DNG - DNG_TAG_ColorMatrix2\n" );
00680         fclose(hDNG); 
00681         return;
00682     }
00683     
00684     // DNG_TAG_AnalogBalance
00685     ifd.uTag = DNG_TAG_AnalogBalance;
00686     ifd.uType = TIFF_TYPE_RATIONAL;
00687     ifd.uCount = 3;
00688     ifd.uOffset = uDataOffset;
00689     uDataOffset += ifd.uCount * 8;
00690   
00691     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00692         fprintf( stderr, "\t** Error writing DNG - DNG_TAG_AnalogBalance\n" );
00693         fclose(hDNG); 
00694         return;
00695     }
00696 
00697     // DNG_TAG_BaselineSharpness
00698     ifd.uTag = DNG_TAG_BaselineSharpness;
00699     ifd.uType = TIFF_TYPE_RATIONAL;
00700     ifd.uCount = 1;
00701     ifd.uOffset = uDataOffset;
00702     uDataOffset += 8;
00703     
00704     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00705         fprintf( stderr, "\t** Error writing DNG - DNG_TAG_BaselineSharpness\n" );
00706         fclose(hDNG); 
00707         return;
00708     }
00709 
00710     // DNG_TAG_BayerGreenSplit
00711     ifd.uTag = DNG_TAG_BayerGreenSplit;
00712     ifd.uType = TIFF_TYPE_LONG;
00713     ifd.uCount = 1;
00714     ifd.uOffset = 0;        // 0 = no Bayer green split (not sure how true this is for our sensors)
00715     
00716     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00717         fprintf( stderr, "\t** Error writing DNG - DNG_TAG_BayerGreenSplit\n" );
00718         fclose(hDNG); 
00719         return;
00720     }
00721 
00722     // DNG_TAG_LinearResponseLimit
00723     ifd.uTag = DNG_TAG_LinearResponseLimit;
00724     ifd.uType = TIFF_TYPE_RATIONAL;
00725     ifd.uCount = 1;
00726     ifd.uOffset = uDataOffset;
00727     uDataOffset += 8;
00728     
00729     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00730         fprintf( stderr, "\t** Error writing DNG - DNG_TAG_LinearResponseLimit\n" );
00731         fclose(hDNG); 
00732         return;
00733     }
00734     
00735     // DNG_TAG_LensInfo
00736     ifd.uTag = DNG_TAG_LensInfo;
00737     ifd.uType = TIFF_TYPE_RATIONAL;
00738     ifd.uCount = 4;
00739     ifd.uOffset = uDataOffset;
00740     uDataOffset += 32;
00741     
00742     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00743         fprintf( stderr, "\t** Error writing DNG - DNG_TAG_LensInfo\n" );
00744         fclose(hDNG); 
00745         return;
00746     }
00747 
00748     // DNG_TAG_AntiAliasStrength
00749     ifd.uTag = DNG_TAG_AntiAliasStrength;
00750     ifd.uType = TIFF_TYPE_RATIONAL;
00751     ifd.uCount = 1;
00752     ifd.uOffset = uDataOffset;
00753     uDataOffset += 8;
00754     
00755     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00756         fprintf( stderr, "\t** Error writing DNG - DNG_TAG_AntiAliasStrength\n" );
00757         fclose(hDNG); 
00758         return;
00759     }
00760 
00761     // DNG_TAG_CalibrationIlluminant1
00762     ifd.uTag = DNG_TAG_CalibrationIlluminant1;
00763     ifd.uType = TIFF_TYPE_SHORT;
00764     ifd.uCount = 1;
00765     ifd.uOffset = 17;          // 17: Standard illuminant A
00766                                        // 21: D65/daylight illuminant
00767 
00768     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00769         fprintf( stderr, "\t** Error writing DNG - DNG_TAG_CalibrationIlluminant1\n" );
00770         fclose(hDNG); 
00771         return;
00772     }
00773 
00774     // DNG_TAG_CalibrationIlluminant2
00775     ifd.uTag = DNG_TAG_CalibrationIlluminant2;
00776     ifd.uType = TIFF_TYPE_SHORT;
00777     ifd.uCount = 1;
00778     ifd.uOffset = 21;
00779     // 17: Standard illuminant A
00780     // 21: D65/daylight illuminant
00781 
00782     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00783         fprintf( stderr, "\t** Error writing DNG - DNG_TAG_CalibrationIlluminant2\n" );
00784         fclose(hDNG); 
00785         return;
00786     }
00787 
00788     // DNG_TAG_BestQualityScale
00789     ifd.uTag = DNG_TAG_BestQualityScale;
00790     ifd.uType = TIFF_TYPE_RATIONAL;
00791     ifd.uCount = 1;
00792     ifd.uOffset = uDataOffset;
00793     uDataOffset += 8;
00794     
00795     if ((dwWritten = fwrite(&ifd, sizeof(IFD), 1, hDNG)) != 1) {
00796         fprintf( stderr, "\t** Error writing DNG - DNG_TAG_BestQualityScale\n" );
00797         fclose(hDNG); 
00798         return;
00799     }
00800 
00801     // Pointer to next IFD
00802     unsigned uNextIFD = 0x00000000;
00803     
00804     if ((dwWritten = fwrite(&uNextIFD, sizeof(unsigned), 1, hDNG)) != 1) {
00805         fprintf( stderr, "\t** Error writing DNG - next IFD pointer\n" );
00806         fclose(hDNG);
00807         return;
00808     }
00809 
00810 
00811     //---------------------------------------------------------------------------------------
00812     // Write image data that didn't go into IFD
00813     //
00814     
00815     // TIFF_TAG_Make
00816     
00817     if ((dwWritten =
00818          fwrite(cameraManufacturer.c_str(), sizeof(char), cameraManufacturer.size()+1, hDNG))
00819         != cameraManufacturer.size()+1) {
00820         fprintf( stderr, "\t** Error writing DNG - Make value\n" );
00821         fclose(hDNG); 
00822         return;
00823     }
00824 
00825 
00826     // TIFF_TAG_Model
00827     if ((dwWritten =
00828          fwrite(cameraModel.c_str(), sizeof(char), cameraModel.size()+1, hDNG))
00829         != cameraModel.size()+1)
00830         {
00831         fprintf( stderr, "\t** Error writing DNG - Model value\n" );
00832         fclose(hDNG); 
00833         return;
00834         }
00835 
00836   
00837     // TIFF_TAG_StripOffsets
00838     unsigned *stripOff = new unsigned[uStripsPerImg];
00839     stripOff[0] = uDataOffset;      // where image data will be written...
00840     for (short s=1; s<uStripsPerImg; s++)
00841         stripOff[s] = stripOff[s-1] + (uRowsPerStrip * width)*2;
00842     
00843     if ((dwWritten = fwrite(stripOff, sizeof(unsigned), uStripsPerImg, hDNG)) != uStripsPerImg) {
00844         fprintf( stderr, "\t** Error writing DNG - StripOffsets value\n" );
00845         delete [] stripOff;
00846         fclose(hDNG); 
00847         return;
00848     }
00849 
00850     delete [] stripOff;
00851 
00852     // TIFF_TAG_StripByteCounts
00853     
00854     unsigned short *stripCnt = new unsigned short[uStripsPerImg];
00855     int nRowsLeft = height;
00856     unsigned t = 0;
00857     while (nRowsLeft > 0) {
00858         if ((unsigned)nRowsLeft > uRowsPerStrip)
00859         stripCnt[t] = uRowsPerStrip * width*2;
00860         else
00861         stripCnt[t] = nRowsLeft * width*2;
00862         
00863         t++;
00864         nRowsLeft -= uRowsPerStrip;
00865     }
00866 
00867     if ((dwWritten = fwrite(stripCnt, sizeof(unsigned short), uStripsPerImg, hDNG)) != uStripsPerImg) {
00868         fprintf( stderr, "\t** Error writing DNG - StripOffsets value\n" );
00869         delete [] stripCnt;
00870         fclose(hDNG); 
00871         return;
00872     }
00873     
00874     delete [] stripCnt;
00875     
00876     
00877     // TIFF_TAG_Software
00878     
00879     if ((dwWritten =
00880          fwrite(cameraSoftware.c_str(), sizeof(char), cameraSoftware.size()+1, hDNG))
00881         != cameraSoftware.size()+1) {
00882         fprintf( stderr, "\t** Error writing DNG - Software value\n" );
00883         fclose(hDNG); 
00884         return;
00885     }
00886   
00887     // TIFF_TAG_DateTime
00888     char szDateTime[20];
00889     time_t time = frame->exposureStartTime.s();
00890     struct tm *tlocal = localtime(&time);
00891     snprintf( szDateTime,
00892           20,
00893           "%04hu:%02hu:%02hu %02hu:%02hu:%02hu",
00894           tlocal->tm_year+1900,
00895           tlocal->tm_mon,
00896           tlocal->tm_mday,
00897           tlocal->tm_hour,
00898           tlocal->tm_min,
00899           tlocal->tm_sec);
00900     szDateTime[20] = '\0';
00901 
00902     if ((dwWritten = fwrite(szDateTime, sizeof(char), 20, hDNG)) != 20) {
00903         fprintf( stderr, "\t** Error writing DNG - DateTime value\n" );
00904         fclose(hDNG); 
00905         return;
00906     }
00907   
00908 
00909     // DNG_TAG_UniqueCameraModel
00910     
00911     if ((dwWritten =
00912          fwrite(cameraModel.c_str(), sizeof(char), cameraModel.size()+1, hDNG))
00913         != cameraModel.size()+1) {
00914         fprintf( stderr, "\t** Error writing DNG - UniqueCameraModel value\n" );
00915         fclose(hDNG); 
00916         return;
00917     }
00918 
00919     // DNG_TAG_LocalizedCameraModel  = unique camera model
00920     if ((dwWritten =
00921          fwrite(cameraModel.c_str(), sizeof(char), cameraModel.size()+1, hDNG))
00922         != cameraModel.size()+1) {
00923         fprintf( stderr, "\t** Error writing DNG - LocalizedCameraModel value\n" );
00924         fclose(hDNG); 
00925         return;
00926     }
00927     
00928     
00929     // DNG_TAG_BlackLevel
00930     unsigned short uBlackLevel[4]; // {G, R, B, G}
00931     for (int i = 0; i < 4; i++) uBlackLevel[i] = frame->sensor->minRawValue();
00932     if ((dwWritten = fwrite(uBlackLevel, sizeof(unsigned short), 4, hDNG)) != 4) {
00933         fprintf( stderr, "\t** Error writing DNG - BlackLevel value\n" );
00934         fclose(hDNG); 
00935         return;
00936     }
00937 
00938   
00939     // DNG_TAG_DefaultScale
00940     unsigned ratDefaultScale[4];
00941     ratDefaultScale[0] = 1;     ratDefaultScale[2] = 1; // DefaultScaleH = 1.0
00942     ratDefaultScale[1] = 1;     ratDefaultScale[3] = 1; // DefaultScaleV = 1.0
00943 
00944     if ((dwWritten = fwrite(ratDefaultScale, sizeof(unsigned), 4, hDNG)) != 4) {
00945         fprintf( stderr, "\t** Error writing DNG - DefaultScale value\n" );
00946         fclose(hDNG); 
00947         return;
00948     } 
00949 
00950     // DNG_TAG_ColorMatrix1
00951     int sratColorMatrix[18];
00952 
00953     for (int i = 0; i < 9; i++) {
00954         sratColorMatrix[2*i] = frame->sensor->getXYZToRawColorMatrixTungsten()[i]*(1<<20);
00955         sratColorMatrix[2*i+1] = (1<<20);
00956     }
00957     if ((dwWritten = fwrite(sratColorMatrix, sizeof(int), 18, hDNG)) != 18) {
00958         fprintf( stderr, "\t** Error writing DNG - ColorMatrix1 values\n" );
00959         fclose(hDNG); 
00960         return;
00961     }
00962 
00963     // DNG_TAG_ColorMatrix2
00964   
00965     for (int i = 0; i < 9; i++) {
00966         sratColorMatrix[2*i] = frame->sensor->getXYZToRawColorMatrixDaylight()[i]*(1<<20);
00967         sratColorMatrix[2*i+1] = (1<<20);
00968     }
00969     if ((dwWritten = fwrite(sratColorMatrix, sizeof(int), 18, hDNG)) != 18) {
00970         fprintf( stderr, "\t** Error writing DNG - ColorMatrix2 values\n" );
00971         fclose(hDNG); 
00972         return;
00973     }
00974 
00975     // DNG_TAG_CameraCalibration1
00976     // DNG_TAG_CameraCalibration2
00977 
00978     // DNG_TAG_AnalogBalance
00979     unsigned ratAnalogBalance[6];
00980     
00981     // for now we only support global gain, not per-color channel gain
00982     ratAnalogBalance[0] = frame->gain*256;   ratAnalogBalance[1] = 256;
00983     ratAnalogBalance[2] = frame->gain*256;   ratAnalogBalance[3] = 256;
00984     ratAnalogBalance[4] = frame->gain*256;   ratAnalogBalance[5] = 256;
00985     
00986     if ((dwWritten = fwrite(ratAnalogBalance, sizeof(unsigned), 6, hDNG)) != 6) {
00987         fprintf( stderr, "\t** Error writing DNG - DNG_TAG_AnalogBalance values\n" );
00988         fclose(hDNG); 
00989         return;
00990     }
00991     
00992 
00993     // DNG_TAG_AsShotNeutral
00994 
00995     // DNG_TAG_BaselineSharpness
00996     unsigned ratBaseSharp[2];
00997     
00998     ratBaseSharp[0] = 2;
00999     ratBaseSharp[1] = 1;    
01000     
01001     if ((dwWritten = fwrite(ratBaseSharp, sizeof(unsigned), 2, hDNG)) != 2) {
01002         fprintf( stderr, "\t** Error writing DNG - BaselineSharpness value\n" );
01003         fclose(hDNG); 
01004         return;
01005     }
01006 
01007     // DNG_TAG_LinearResponseLimit
01008     unsigned ratLinearLimit[2];
01009     ratLinearLimit[0] = 1;
01010     ratLinearLimit[1] = 1;      // 1.0 = sensor is linear across whole range
01011     
01012     if ((dwWritten = fwrite(ratLinearLimit, sizeof(unsigned), 2, hDNG)) != 2) {
01013         fprintf( stderr, "\t** Error writing DNG - LinearResponseLimit value\n" );
01014         fclose(hDNG); 
01015         return;
01016     }
01017 
01018     // DNG_TAG_LensInfo
01019     // TODO: we should really set the actual lens params as well as the bounds
01020     unsigned ratLensInfo[8] = {0, 0, 0, 0, 0, 0, 0, 0};
01021     if (lens) {
01022         ratLensInfo[0] = (int)(lens->minZoom()*1000 + 0.5f);
01023         ratLensInfo[1] = 1000;
01024         ratLensInfo[2] = (int)(lens->maxZoom()*1000 + 0.5f);
01025         ratLensInfo[3] = 1000;
01026         // minimum F number at minimum zoom
01027         ratLensInfo[4] = (int)(lens->wideAperture(lens->minZoom())*1000 + 0.5f);
01028         ratLensInfo[5] = 1000;
01029         // minimum F number at maximum zoom
01030         ratLensInfo[6] = (int)(lens->wideAperture(lens->maxZoom())*1000 + 0.5f);
01031         ratLensInfo[7] = 1000;
01032     }
01033     
01034    
01035     if ((dwWritten = fwrite(ratLensInfo, sizeof(unsigned), 8, hDNG)) != 8) {
01036         fprintf( stderr, "\t** Error writing DNG - LensInfo value\n" );
01037         fclose(hDNG); 
01038         return;
01039     }
01040 
01041     // DNG_TAG_AntiAliasStrength
01042     unsigned ratAntiAlias[2];
01043     ratAntiAlias[0] = 0;
01044     ratAntiAlias[1] = 1;        // AntiAliasStrength = 0.0
01045 
01046     if ((dwWritten = fwrite(ratAntiAlias, sizeof(unsigned), 2, hDNG)) != 2) {   
01047         fprintf( stderr, "\t** Error writing DNG - AntiAliasStrength value\n" );
01048         fclose(hDNG); 
01049         return;
01050     }
01051 
01052 
01053     // DNG_TAG_BestQualityScale
01054     unsigned ratBestScale[2];
01055     ratBestScale[0] = 1;
01056     ratBestScale[1] = 1;        // BestQualityScale = 1.0
01057 
01058     if ((dwWritten = fwrite(ratBestScale, sizeof(unsigned), 2, hDNG)) != 2) {
01059         fprintf( stderr, "\t** Error writing DNG - BestQualityScale value\n" );
01060         fclose(hDNG); 
01061         return;
01062     }
01063 
01064     //
01065     // Write CFA image data
01066     //
01067 
01068     printf("Writing image data\n"); 
01069     fflush(stdout);
01070 
01071     if (fwrite(frame->image.data,sizeof(unsigned short),width*height,hDNG) != width*height) {
01072         fprintf( stderr, "\t** Error writing DNG - image data\n" );
01073         fclose(hDNG); 
01074         return;
01075     }
01076 
01077     printf("Done saving DNG\n"); fflush(stdout);
01078 
01079     fclose(hDNG); 
01080     }
01081 }