← Back to branch summary

~ubuntu-branches/debian/sid/gdal/sid

« back to all changes in this revision

Viewing changes to frmts/gtiff/libtiff/tif_dirread.c

  • Committer: Package Import Robot
  • Author(s): Francesco Paolo Lovergine
  • Date: 2012-05-07 15:04:42 UTC
  • mfrom: (5.5.16 experimental)
  • Revision ID: package-import@ubuntu.com-20120507150442-2eks97loeh6rq005
Tags: 1.9.0-1
* Ready for sid, starting transition.
* All symfiles updated to latest builds.
* Added dh_numpy call in debian/rules to depend on numpy ABI.
* Policy bumped to 3.9.3, no changes required.

Show diffs side-by-side

added added

removed removed

Lines of Context:
frmts/gtiff/libtiff/tif_dirread.c
1
 
/* $Id: tif_dirread.c,v 1.155 2009-10-29 20:04:07 bfriesen Exp $ */
 
1
/* $Id: tif_dirread.c,v 1.172 2011-12-09 03:29:10 fwarmerdam Exp $ */
2
2
 
3
3
/*
4
4
 * Copyright (c) 1988-1997 Sam Leffler
67
67
static enum TIFFReadDirEntryErr TIFFReadDirEntryShort(TIFF* tif, TIFFDirEntry* direntry, uint16* value);
68
68
static enum TIFFReadDirEntryErr TIFFReadDirEntryLong(TIFF* tif, TIFFDirEntry* direntry, uint32* value);
69
69
static enum TIFFReadDirEntryErr TIFFReadDirEntryLong8(TIFF* tif, TIFFDirEntry* direntry, uint64* value);
70
 
#ifdef notdef
71
70
static enum TIFFReadDirEntryErr TIFFReadDirEntryFloat(TIFF* tif, TIFFDirEntry* direntry, float* value);
72
 
#endif
73
71
static enum TIFFReadDirEntryErr TIFFReadDirEntryDouble(TIFF* tif, TIFFDirEntry* direntry, double* value);
74
72
static enum TIFFReadDirEntryErr TIFFReadDirEntryIfd8(TIFF* tif, TIFFDirEntry* direntry, uint64* value);
75
73
 
87
85
static enum TIFFReadDirEntryErr TIFFReadDirEntryIfd8Array(TIFF* tif, TIFFDirEntry* direntry, uint64** value);
88
86
 
89
87
static enum TIFFReadDirEntryErr TIFFReadDirEntryPersampleShort(TIFF* tif, TIFFDirEntry* direntry, uint16* value);
 
88
#if 0
90
89
static enum TIFFReadDirEntryErr TIFFReadDirEntryPersampleDouble(TIFF* tif, TIFFDirEntry* direntry, double* value);
 
90
#endif
91
91
 
92
92
static void TIFFReadDirEntryCheckedByte(TIFF* tif, TIFFDirEntry* direntry, uint8* value);
93
93
static void TIFFReadDirEntryCheckedSbyte(TIFF* tif, TIFFDirEntry* direntry, int8* value);
530
530
        }
531
531
}
532
532
 
533
 
#ifdef notdef
534
533
static enum TIFFReadDirEntryErr TIFFReadDirEntryFloat(TIFF* tif, TIFFDirEntry* direntry, float* value)
535
534
{
536
535
        enum TIFFReadDirEntryErr err;
586
585
                                err=TIFFReadDirEntryCheckedLong8(tif,direntry,&m);
587
586
                                if (err!=TIFFReadDirEntryErrOk)
588
587
                                        return(err);
 
588
#if defined(__WIN32__) && (_MSC_VER < 1500)
 
589
                                /*
 
590
                                 * XXX: MSVC 6.0 does not support conversion
 
591
                                 * of 64-bit integers into floating point
 
592
                                 * values.
 
593
                                 */
 
594
                                *value = _TIFFUInt64ToFloat(m);
 
595
#else
589
596
                                *value=(float)m;
 
597
#endif
590
598
                                return(TIFFReadDirEntryErrOk);
591
599
                        }
592
600
                case TIFF_SLONG8:
632
640
                        return(TIFFReadDirEntryErrType);
633
641
        }
634
642
}
635
 
#endif /* def notdef */
636
643
 
637
644
static enum TIFFReadDirEntryErr TIFFReadDirEntryDouble(TIFF* tif, TIFFDirEntry* direntry, double* value)
638
645
{
2731
2738
        uint16* m;
2732
2739
        uint16* na;
2733
2740
        uint16 nb;
2734
 
        if (direntry->tdir_count!=(uint64)tif->tif_dir.td_samplesperpixel)
 
2741
        if (direntry->tdir_count<(uint64)tif->tif_dir.td_samplesperpixel)
2735
2742
                return(TIFFReadDirEntryErrCount);
2736
2743
        err=TIFFReadDirEntryShortArray(tif,direntry,&m);
2737
2744
        if (err!=TIFFReadDirEntryErrOk)
2753
2760
        return(err);
2754
2761
}
2755
2762
 
 
2763
#if 0
2756
2764
static enum TIFFReadDirEntryErr TIFFReadDirEntryPersampleDouble(TIFF* tif, TIFFDirEntry* direntry, double* value)
2757
2765
{
2758
2766
        enum TIFFReadDirEntryErr err;
2759
2767
        double* m;
2760
2768
        double* na;
2761
2769
        uint16 nb;
2762
 
        if (direntry->tdir_count!=(uint64)tif->tif_dir.td_samplesperpixel)
 
2770
        if (direntry->tdir_count<(uint64)tif->tif_dir.td_samplesperpixel)
2763
2771
                return(TIFFReadDirEntryErrCount);
2764
2772
        err=TIFFReadDirEntryDoubleArray(tif,direntry,&m);
2765
2773
        if (err!=TIFFReadDirEntryErrOk)
2780
2788
        _TIFFfree(m);
2781
2789
        return(err);
2782
2790
}
 
2791
#endif
2783
2792
 
2784
2793
static void TIFFReadDirEntryCheckedByte(TIFF* tif, TIFFDirEntry* direntry, uint8* value)
2785
2794
{
2796
2805
static void TIFFReadDirEntryCheckedShort(TIFF* tif, TIFFDirEntry* direntry, uint16* value)
2797
2806
{
2798
2807
        *value = direntry->tdir_offset.toff_short;
2799
 
        //*value=*(uint16*)(&direntry->tdir_offset);
 
2808
        /* *value=*(uint16*)(&direntry->tdir_offset); */
2800
2809
        if (tif->tif_flags&TIFF_SWAB)
2801
2810
                TIFFSwabShort(value);
2802
2811
}
3414
3423
        TIFFDirEntry* dp;
3415
3424
        uint16 di;
3416
3425
        const TIFFField* fip;
3417
 
        uint32 fii;
 
3426
        uint32 fii=FAILED_FII;
3418
3427
        toff_t nextdiroff;
3419
3428
        tif->tif_diroff=tif->tif_nextdiroff;
3420
3429
        if (!TIFFCheckDirOffset(tif,tif->tif_nextdiroff))
3430
3439
                return 0;
3431
3440
        }
3432
3441
        TIFFReadDirectoryCheckOrder(tif,dir,dircount);
 
3442
        {
 
3443
                TIFFDirEntry* ma;
 
3444
                uint16 mb;
 
3445
                for (ma=dir, mb=0; mb<dircount; ma++, mb++)
 
3446
                {
 
3447
                        TIFFDirEntry* na;
 
3448
                        uint16 nb;
 
3449
                        for (na=ma+1, nb=mb+1; nb<dircount; na++, nb++)
 
3450
                        {
 
3451
                                if (ma->tdir_tag==na->tdir_tag)
 
3452
                                        na->tdir_tag=IGNORE;
 
3453
                        }
 
3454
                }
 
3455
        }
3433
3456
        tif->tif_flags &= ~TIFF_BEENWRITING;    /* reset before new dir */
3434
3457
        tif->tif_flags &= ~TIFF_BUF4WRITE;      /* reset before new dir */
3435
3458
        /* free any old stuff and reinit */
3569
3592
        if ((tif->tif_dir.td_compression==COMPRESSION_OJPEG)&&
3570
3593
            (tif->tif_dir.td_planarconfig==PLANARCONFIG_SEPARATE))
3571
3594
        {
 
3595
        if (!_TIFFFillStriles(tif))
 
3596
            goto bad;
3572
3597
                dp=TIFFReadDirectoryFindEntry(tif,dir,dircount,TIFFTAG_STRIPOFFSETS);
3573
3598
                if ((dp!=0)&&(dp->tdir_count==1))
3574
3599
                {
3664
3689
                                                err=TIFFReadDirEntryPersampleShort(tif,dp,&value);
3665
3690
                                        if (err!=TIFFReadDirEntryErrOk)
3666
3691
                                        {
3667
 
                                                TIFFReadDirEntryOutputErr(tif,err,module,TIFFFieldWithTag(tif,dp->tdir_tag)->field_name,0);
 
3692
                        fip = TIFFFieldWithTag(tif,dp->tdir_tag);
 
3693
                                                TIFFReadDirEntryOutputErr(tif,err,module,fip ? fip->field_name : "unknown tagname",0);
3668
3694
                                                goto bad;
3669
3695
                                        }
3670
3696
                                        if (!TIFFSetField(tif,dp->tdir_tag,value))
3674
3700
                        case TIFFTAG_SMINSAMPLEVALUE:
3675
3701
                        case TIFFTAG_SMAXSAMPLEVALUE:
3676
3702
                                {
3677
 
                                        double value;
 
3703
 
 
3704
                                        double *data;
3678
3705
                                        enum TIFFReadDirEntryErr err;
3679
 
                                        err=TIFFReadDirEntryPersampleDouble(tif,dp,&value);
 
3706
                                        uint32 saved_flags;
 
3707
                                        int m;
 
3708
                                        if (dp->tdir_count != (uint64)tif->tif_dir.td_samplesperpixel)
 
3709
                                                err = TIFFReadDirEntryErrCount;
 
3710
                                        else
 
3711
                                                err = TIFFReadDirEntryDoubleArray(tif, dp, &data);
3680
3712
                                        if (err!=TIFFReadDirEntryErrOk)
3681
3713
                                        {
3682
 
                                                TIFFReadDirEntryOutputErr(tif,err,module,TIFFFieldWithTag(tif,dp->tdir_tag)->field_name,0);
 
3714
                        fip = TIFFFieldWithTag(tif,dp->tdir_tag);
 
3715
                                                TIFFReadDirEntryOutputErr(tif,err,module,fip ? fip->field_name : "unknown tagname",0);
3683
3716
                                                goto bad;
3684
3717
                                        }
3685
 
                                        if (!TIFFSetField(tif,dp->tdir_tag,value))
 
3718
                                        saved_flags = tif->tif_flags;
 
3719
                                        tif->tif_flags |= TIFF_PERSAMPLE;
 
3720
                                        m = TIFFSetField(tif,dp->tdir_tag,data);
 
3721
                                        tif->tif_flags = saved_flags;
 
3722
                                        _TIFFfree(data);
 
3723
                                        if (!m)
3686
3724
                                                goto bad;
3687
3725
                                }
3688
3726
                                break;
3689
3727
                        case TIFFTAG_STRIPOFFSETS:
3690
3728
                        case TIFFTAG_TILEOFFSETS:
 
3729
#if defined(DEFER_STRILE_LOAD)
 
3730
                                _TIFFmemcpy( &(tif->tif_dir.td_stripoffset_entry),
 
3731
                                             dp, sizeof(TIFFDirEntry) );
 
3732
#else                          
3691
3733
                                if (!TIFFFetchStripThing(tif,dp,tif->tif_dir.td_nstrips,&tif->tif_dir.td_stripoffset))  
3692
3734
                                        goto bad;
 
3735
#endif                                
3693
3736
                                break;
3694
3737
                        case TIFFTAG_STRIPBYTECOUNTS:
3695
3738
                        case TIFFTAG_TILEBYTECOUNTS:
 
3739
#if defined(DEFER_STRILE_LOAD)
 
3740
                                _TIFFmemcpy( &(tif->tif_dir.td_stripbytecount_entry),
 
3741
                                             dp, sizeof(TIFFDirEntry) );
 
3742
#else                          
3696
3743
                                if (!TIFFFetchStripThing(tif,dp,tif->tif_dir.td_nstrips,&tif->tif_dir.td_stripbytecount))  
3697
3744
                                        goto bad;
 
3745
#endif                                
3698
3746
                                break;
3699
3747
                        case TIFFTAG_COLORMAP:
3700
3748
                        case TIFFTAG_TRANSFERFUNCTION:
3703
3751
                                        uint32 countpersample;
3704
3752
                                        uint32 countrequired;
3705
3753
                                        uint32 incrementpersample;
3706
 
                                        uint16* value;
 
3754
                                        uint16* value=NULL;
3707
3755
                                        countpersample=(1L<<tif->tif_dir.td_bitspersample);
3708
3756
                                        if ((dp->tdir_tag==TIFFTAG_TRANSFERFUNCTION)&&(dp->tdir_count==(uint64)countpersample))
3709
3757
                                        {
3720
3768
                                        else
3721
3769
                                                err=TIFFReadDirEntryShortArray(tif,dp,&value);
3722
3770
                                        if (err!=TIFFReadDirEntryErrOk)
3723
 
                                                TIFFReadDirEntryOutputErr(tif,err,module,TIFFFieldWithTag(tif,dp->tdir_tag)->field_name,1);
 
3771
                    {
 
3772
                        fip = TIFFFieldWithTag(tif,dp->tdir_tag);
 
3773
                                                TIFFReadDirEntryOutputErr(tif,err,module,fip ? fip->field_name : "unknown tagname",1);
 
3774
                    }
3724
3775
                                        else
3725
3776
                                        {
3726
3777
                                                TIFFSetField(tif,dp->tdir_tag,value,value+incrementpersample,value+2*incrementpersample);
3793
3844
                }
3794
3845
                if (!TIFFFieldSet(tif,FIELD_SAMPLESPERPIXEL))
3795
3846
                {
3796
 
                        if ((tif->tif_dir.td_photometric==PHOTOMETRIC_RGB)
3797
 
                            || (tif->tif_dir.td_photometric==PHOTOMETRIC_YCBCR))
 
3847
                        if (tif->tif_dir.td_photometric==PHOTOMETRIC_RGB)
3798
3848
                        {
3799
3849
                                TIFFWarningExt(tif->tif_clientdata,module,
3800
3850
                                    "SamplesPerPixel tag is missing, "
3802
3852
                                if (!TIFFSetField(tif,TIFFTAG_SAMPLESPERPIXEL,3))
3803
3853
                                        goto bad;
3804
3854
                        }
 
3855
                        if (tif->tif_dir.td_photometric==PHOTOMETRIC_YCBCR)
 
3856
                        {
 
3857
                                TIFFWarningExt(tif->tif_clientdata,module,
 
3858
                                    "SamplesPerPixel tag is missing, "
 
3859
                                    "applying correct SamplesPerPixel value of 3");
 
3860
                                if (!TIFFSetField(tif,TIFFTAG_SAMPLESPERPIXEL,3))
 
3861
                                        goto bad;
 
3862
                        }
3805
3863
                        else if ((tif->tif_dir.td_photometric==PHOTOMETRIC_MINISWHITE)
3806
3864
                                 || (tif->tif_dir.td_photometric==PHOTOMETRIC_MINISBLACK))
3807
3865
                        {
3808
 
                                TIFFWarningExt(tif->tif_clientdata,module,
3809
 
                                    "SamplesPerPixel tag is missing, "
3810
 
                                    "assuming correct SamplesPerPixel value is 1");
 
3866
                                /*
 
3867
                                 * SamplesPerPixel tag is missing, but is not required
 
3868
                                 * by spec.  Assume correct SamplesPerPixel value of 1.
 
3869
                                 */
3811
3870
                                if (!TIFFSetField(tif,TIFFTAG_SAMPLESPERPIXEL,1))
3812
3871
                                        goto bad;
3813
3872
                        }
3818
3877
         */
3819
3878
        if (tif->tif_dir.td_photometric == PHOTOMETRIC_PALETTE &&
3820
3879
            !TIFFFieldSet(tif, FIELD_COLORMAP)) {
3821
 
                MissingRequired(tif, "Colormap");
3822
 
                goto bad;
 
3880
                if ( tif->tif_dir.td_bitspersample>=8 && tif->tif_dir.td_samplesperpixel==3)
 
3881
                        tif->tif_dir.td_photometric = PHOTOMETRIC_RGB;
 
3882
                else if (tif->tif_dir.td_bitspersample>=8)
 
3883
                        tif->tif_dir.td_photometric = PHOTOMETRIC_MINISBLACK;
 
3884
                else {
 
3885
                        MissingRequired(tif, "Colormap");
 
3886
                        goto bad;
 
3887
                }
3823
3888
        }
3824
3889
        /*
3825
3890
         * OJPEG hack:
3872
3937
                       tif->tif_dir.td_stripbytecount[0] < TIFFScanlineSize64(tif) * tif->tif_dir.td_imagelength) )
3873
3938
 
3874
3939
                } else if (tif->tif_dir.td_nstrips == 1
 
3940
                           && _TIFFFillStriles(tif)
3875
3941
                           && tif->tif_dir.td_stripoffset[0] != 0
3876
3942
                           && BYTECOUNTLOOKSBAD) {
3877
3943
                        /*
3885
3951
                            TIFFFieldWithTag(tif,TIFFTAG_STRIPBYTECOUNTS)->field_name);
3886
3952
                        if(EstimateStripByteCounts(tif, dir, dircount) < 0)
3887
3953
                            goto bad;
 
3954
 
 
3955
#if !defined(DEFER_STRILE_LOAD)
3888
3956
                } else if (tif->tif_dir.td_planarconfig == PLANARCONFIG_CONTIG
3889
3957
                           && tif->tif_dir.td_nstrips > 2
3890
3958
                           && tif->tif_dir.td_compression == COMPRESSION_NONE
3896
3964
                         * absolutely wrong values (it can be equal to
3897
3965
                         * StripOffset array, for example). Catch this case
3898
3966
                         * here.
 
3967
                         *
 
3968
                         * We avoid this check if deferring strile loading
 
3969
                         * as it would always force us to load the strip/tile
 
3970
                         * information.
3899
3971
                         */
3900
3972
                        TIFFWarningExt(tif->tif_clientdata, module,
3901
3973
                            "Wrong \"%s\" field, ignoring and calculating from imagelength",
3902
3974
                            TIFFFieldWithTag(tif,TIFFTAG_STRIPBYTECOUNTS)->field_name);
3903
3975
                        if (EstimateStripByteCounts(tif, dir, dircount) < 0)
3904
3976
                            goto bad;
 
3977
#endif /* !defined(DEFER_STRILE_LOAD) */                        
3905
3978
                }
3906
3979
        }
3907
3980
        if (dir)
3921
3994
         * bytecounts array. See also comments for TIFFAppendToStrip()
3922
3995
         * function in tif_write.c.
3923
3996
         */
 
3997
#if !defined(DEFER_STRILE_LOAD)        
3924
3998
        if (tif->tif_dir.td_nstrips > 1) {
3925
3999
                uint32 strip;
3926
4000
 
3933
4007
                        }
3934
4008
                }
3935
4009
        }
 
4010
#endif /* !defined(DEFER_STRILE_LOAD) */
 
4011
        
3936
4012
        /*
3937
4013
         * An opportunity for compression mode dependent tag fixup
3938
4014
         */
3951
4027
            (tif->tif_dir.td_nstrips==1)&&
3952
4028
            (tif->tif_dir.td_compression==COMPRESSION_NONE)&&  
3953
4029
            ((tif->tif_flags&(TIFF_STRIPCHOP|TIFF_ISTILED))==TIFF_STRIPCHOP))
 
4030
    {
 
4031
        if ( !_TIFFFillStriles(tif) || !tif->tif_dir.td_stripbytecount )
 
4032
            return 0;
3954
4033
                ChopUpSingleUncompressedStrip(tif);
 
4034
    }
3955
4035
 
3956
4036
        /*
3957
4037
         * Clear the dirty directory flag. 
4190
4270
        TIFFDirectory *td = &tif->tif_dir;
4191
4271
        uint32 strip;
4192
4272
 
 
4273
    _TIFFFillStriles( tif );
 
4274
 
4193
4275
        if (td->td_stripbytecount)
4194
4276
                _TIFFfree(td->td_stripbytecount);
4195
4277
        td->td_stripbytecount = (uint64*)
4323
4405
CheckDirCount(TIFF* tif, TIFFDirEntry* dir, uint32 count)
4324
4406
{
4325
4407
        if ((uint64)count > dir->tdir_count) {
 
4408
        const TIFFField* fip = TIFFFieldWithTag(tif, dir->tdir_tag);
4326
4409
                TIFFWarningExt(tif->tif_clientdata, tif->tif_name,
4327
4410
        "incorrect count for field \"%s\" (" TIFF_UINT64_FORMAT ", expecting %u); tag ignored",
4328
 
                    TIFFFieldWithTag(tif, dir->tdir_tag)->field_name,
 
4411
                    fip ? fip->field_name : "unknown tagname",
4329
4412
                    dir->tdir_count, count);
4330
4413
                return (0);
4331
4414
        } else if ((uint64)count < dir->tdir_count) {
 
4415
        const TIFFField* fip = TIFFFieldWithTag(tif, dir->tdir_tag);
4332
4416
                TIFFWarningExt(tif->tif_clientdata, tif->tif_name,
4333
4417
        "incorrect count for field \"%s\" (" TIFF_UINT64_FORMAT ", expecting %u); tag trimmed",
4334
 
                    TIFFFieldWithTag(tif, dir->tdir_tag)->field_name,
 
4418
                    fip ? fip->field_name : "unknown tagname",
4335
4419
                    dir->tdir_count, count);
 
4420
                dir->tdir_count = count;
4336
4421
                return (1);
4337
4422
        }
4338
4423
        return (1);
4502
4587
                        dircount16 = (uint16)dircount64;
4503
4588
                        dirsize = 20;
4504
4589
                }
 
4590
                if (dircount16 == 0 )
 
4591
                {
 
4592
                        TIFFErrorExt(tif->tif_clientdata, module,
 
4593
                                     "Sanity check on directory count failed, zero tag directories not supported");
 
4594
                        return 0;
 
4595
                }
4505
4596
                origdir = _TIFFCheckMalloc(tif, dircount16,
4506
4597
                                                dirsize,
4507
4598
                                                "to read TIFF directory");
4599
4690
        static const char module[] = "TIFFFetchNormalTag";
4600
4691
        enum TIFFReadDirEntryErr err;
4601
4692
        uint32 fii;
4602
 
        const TIFFField* fip;
 
4693
        const TIFFField* fip = NULL;
4603
4694
        TIFFReadDirectoryFindFieldInfo(tif,dp->tdir_tag,&fii);
4604
4695
        if( fii == FAILED_FII )
4605
4696
        {
4717
4808
                                }
4718
4809
                        }
4719
4810
                        break;
 
4811
                case TIFF_SETGET_FLOAT:
 
4812
                        {
 
4813
                                float data;
 
4814
                                assert(fip->field_readcount==1);
 
4815
                                assert(fip->field_passcount==0);
 
4816
                                err=TIFFReadDirEntryFloat(tif,dp,&data);
 
4817
                                if (err==TIFFReadDirEntryErrOk)
 
4818
                                {
 
4819
                                        if (!TIFFSetField(tif,dp->tdir_tag,data))
 
4820
                                                return(0);
 
4821
                                }
 
4822
                        }
 
4823
                        break;
4720
4824
                case TIFF_SETGET_DOUBLE:
4721
4825
                        {
4722
4826
                                double data;
5235
5339
        }
5236
5340
        if (err!=TIFFReadDirEntryErrOk)
5237
5341
        {
5238
 
                TIFFReadDirEntryOutputErr(tif,err,module,fip->field_name,recover);
 
5342
                TIFFReadDirEntryOutputErr(tif,err,module,fip ? fip->field_name : "unknown tagname",recover);
5239
5343
                return(0);
5240
5344
        }
5241
5345
        return(1);
5254
5358
        err=TIFFReadDirEntryLong8Array(tif,dir,&data);
5255
5359
        if (err!=TIFFReadDirEntryErrOk)
5256
5360
        {
5257
 
                TIFFReadDirEntryOutputErr(tif,err,module,TIFFFieldWithTag(tif,dir->tdir_tag)->field_name,0);
 
5361
        const TIFFField* fip = TIFFFieldWithTag(tif,dir->tdir_tag); 
 
5362
                TIFFReadDirEntryOutputErr(tif,err,module,fip ? fip->field_name : "unknown tagname",0);
5258
5363
                return(0);
5259
5364
        }
5260
5365
        if (dir->tdir_count!=(uint64)nstrips)
5261
5366
        {
5262
5367
                uint64* resizeddata;
5263
5368
                resizeddata=(uint64*)_TIFFCheckMalloc(tif,nstrips,sizeof(uint64),"for strip array");
5264
 
                if (resizeddata==0)
 
5369
                if (resizeddata==0) {
 
5370
                        _TIFFfree(data);
5265
5371
                        return(0);
 
5372
                }
5266
5373
                if (dir->tdir_count<(uint64)nstrips)
5267
5374
                {
5268
5375
                        _TIFFmemcpy(resizeddata,data,(uint32)dir->tdir_count*sizeof(uint64));
5286
5393
        static const char module[] = "TIFFFetchSubjectDistance";
5287
5394
        enum TIFFReadDirEntryErr err;
5288
5395
        UInt64Aligned_t m;
 
5396
    m.l=0;
5289
5397
        assert(sizeof(double)==8);
5290
5398
        assert(sizeof(uint64)==8);
5291
5399
        assert(sizeof(uint32)==4);
5431
5539
        td->td_stripbytecountsorted = 1;
5432
5540
}
5433
5541
 
 
5542
int _TIFFFillStriles( TIFF *tif )
 
5543
{
 
5544
#if defined(DEFER_STRILE_LOAD)
 
5545
        register TIFFDirectory *td = &tif->tif_dir;
 
5546
        int return_value = 1;
 
5547
 
 
5548
        if( td->td_stripoffset != NULL )
 
5549
                return 1;
 
5550
 
 
5551
        if( td->td_stripoffset_entry.tdir_count == 0 )
 
5552
                return 0;
 
5553
 
 
5554
        if (!TIFFFetchStripThing(tif,&(td->td_stripoffset_entry),
 
5555
                                 td->td_nstrips,&td->td_stripoffset))
 
5556
        {
 
5557
                return_value = 0;
 
5558
        }
 
5559
 
 
5560
        if (!TIFFFetchStripThing(tif,&(td->td_stripbytecount_entry),
 
5561
                                 td->td_nstrips,&td->td_stripbytecount))
 
5562
        {
 
5563
                return_value = 0;
 
5564
        }
 
5565
 
 
5566
        _TIFFmemset( &(td->td_stripoffset_entry), 0, sizeof(TIFFDirEntry));
 
5567
        _TIFFmemset( &(td->td_stripbytecount_entry), 0, sizeof(TIFFDirEntry));
 
5568
 
 
5569
        if (tif->tif_dir.td_nstrips > 1 && return_value == 1 ) {
 
5570
                uint32 strip;
 
5571
 
 
5572
                tif->tif_dir.td_stripbytecountsorted = 1;
 
5573
                for (strip = 1; strip < tif->tif_dir.td_nstrips; strip++) {
 
5574
                        if (tif->tif_dir.td_stripoffset[strip - 1] >
 
5575
                            tif->tif_dir.td_stripoffset[strip]) {
 
5576
                                tif->tif_dir.td_stripbytecountsorted = 0;
 
5577
                                break;
 
5578
                        }
 
5579
                }
 
5580
        }
 
5581
 
 
5582
        return return_value;
 
5583
#else /* !defined(DEFER_STRILE_LOAD) */
 
5584
        (void) tif;
 
5585
        return 1;
 
5586
#endif 
 
5587
}
 
5588
 
 
5589
 
5434
5590
/* vim: set ts=8 sts=8 sw=8 noet: */
 
5591
/*
 
5592
 * Local Variables:
 
5593
 * mode: c
 
5594
 * c-basic-offset: 8
 
5595
 * fill-column: 78
 
5596
 * End:
 
5597
 */