← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/imagemagick/oneiric-updates

« back to all changes in this revision

Viewing changes to coders/meta.c

  • Committer: Bazaar Package Importer
  • Author(s): Colin Watson
  • Date: 2011-06-15 11:05:28 UTC
  • mfrom: (6.2.11 sid)
  • Revision ID: james.westby@ubuntu.com-20110615110528-08jgo07a4846xh8d
Tags: 8:6.6.0.4-3ubuntu1
https://launchpad.net/bugs/797595
* Resynchronise with Debian (LP: #797595).  Remaining changes:
  - Make ufraw-batch (universe) a suggestion instead of a recommendation.
  - Make debian/rules install target depend on check; they cannot reliably
    be run in parallel.
  - Don't set MAKEFLAGS in debian/rules; just pass it to the build.

Show diffs side-by-side

added added

removed removed

Lines of Context:
coders/meta.c
162
162
 
163
163
static int stringnicmp(const char *p,const char *q,size_t n)
164
164
{
165
 
  register ssize_t
 
165
  register long
166
166
    i,
167
167
    j;
168
168
 
288
288
#define IPTC_ID 1028
289
289
#define THUMBNAIL_ID 1033
290
290
 
291
 
static ssize_t parse8BIM(Image *ifile, Image *ofile)
 
291
static long parse8BIM(Image *ifile, Image *ofile)
292
292
{
293
293
  char
294
294
    brkused,
311
311
  int
312
312
    inputlen = BUFFER_SZ;
313
313
 
314
 
  ssize_t
 
314
  long
315
315
    savedolen = 0L,
316
316
    outputlen = 0L;
317
317
 
380
380
            int
381
381
              next;
382
382
 
383
 
            ssize_t
 
383
            long
384
384
              len;
385
385
 
386
386
            char
388
388
              quoted;
389
389
 
390
390
            next=0;
391
 
            len = (ssize_t) strlen(token);
 
391
            len = (long) strlen(token);
392
392
            while (Tokenizer(token_info,0,newstr,(size_t) inputlen,token,"","&",
393
393
              "",0,&brkused,&next,&quoted)==0)
394
394
            {
397
397
                  char
398
398
                    *s = &token[next-1];
399
399
 
400
 
                  len -= (ssize_t) convertHTMLcodes(s,(int) strlen(s));
 
400
                  len -= (long) convertHTMLcodes(s,(int) strlen(s));
401
401
                }
402
402
            }
403
403
 
414
414
                    MagickOffsetType
415
415
                      offset;
416
416
 
417
 
                    ssize_t diff = outputlen - savedolen;
 
417
                    long diff = outputlen - savedolen;
418
418
                    currentpos = TellBlob(ofile);
419
419
                    offset=SeekBlob(ofile,savedpos,SEEK_SET);
420
420
                    if (offset < 0)
421
421
                      return(-1);
422
 
                    (void) WriteBlobMSBLong(ofile,(unsigned int) diff);
 
422
                    (void) WriteBlobMSBLong(ofile,(unsigned long) diff);
423
423
                    offset=SeekBlob(ofile,currentpos,SEEK_SET);
424
424
                    if (offset < 0)
425
425
                      return(-1);
447
447
                  }
448
448
                if (recnum != IPTC_ID)
449
449
                  {
450
 
                    (void) WriteBlobMSBLong(ofile, (unsigned int) len);
 
450
                    (void) WriteBlobMSBLong(ofile, (unsigned long) len);
451
451
                    outputlen += 4;
452
452
 
453
453
                    next=0;
465
465
                  {
466
466
                    /* patch in a fake length for now and fix it later */
467
467
                    savedpos = TellBlob(ofile);
468
 
                    (void) WriteBlobMSBLong(ofile,0xFFFFFFFFU);
 
468
                    (void) WriteBlobMSBLong(ofile,0xFFFFFFFFUL);
469
469
                    outputlen += 4;
470
470
                    savedolen = outputlen;
471
471
                  }
500
500
      MagickOffsetType
501
501
        offset;
502
502
 
503
 
      ssize_t diff = outputlen - savedolen;
 
503
      long diff = outputlen - savedolen;
504
504
 
505
505
      currentpos = TellBlob(ofile);
506
506
      offset=SeekBlob(ofile,savedpos,SEEK_SET);
507
507
      if (offset < 0)
508
508
        return(-1);
509
 
      (void) WriteBlobMSBLong(ofile,(unsigned int) diff);
 
509
      (void) WriteBlobMSBLong(ofile,(unsigned long) diff);
510
510
      offset=SeekBlob(ofile,currentpos,SEEK_SET);
511
511
      if (offset < 0)
512
512
        return(-1);
564
564
  return((char *) p);
565
565
}
566
566
 
567
 
static ssize_t parse8BIMW(Image *ifile, Image *ofile)
 
567
static long parse8BIMW(Image *ifile, Image *ofile)
568
568
{
569
569
  char
570
570
    brkused,
587
587
  int
588
588
    inputlen = BUFFER_SZ;
589
589
 
590
 
  ssize_t
 
590
  long
591
591
    savedolen = 0L,
592
592
    outputlen = 0L;
593
593
 
656
656
            int
657
657
              next;
658
658
 
659
 
            ssize_t
 
659
            long
660
660
              len;
661
661
 
662
662
            char
664
664
              quoted;
665
665
 
666
666
            next=0;
667
 
            len = (ssize_t) strlen(token);
 
667
            len = (long) strlen(token);
668
668
            while (Tokenizer(token_info,0,newstr,(size_t) inputlen,token,"","&",
669
669
              "",0,&brkused,&next,&quoted)==0)
670
670
            {
673
673
                  char
674
674
                    *s = &token[next-1];
675
675
 
676
 
                  len -= (ssize_t) convertHTMLcodes(s,(int) strlen(s));
 
676
                  len -= (long) convertHTMLcodes(s,(int) strlen(s));
677
677
                }
678
678
            }
679
679
 
690
690
                    MagickOffsetType
691
691
                      offset;
692
692
 
693
 
                    ssize_t diff = outputlen - savedolen;
 
693
                    long diff = outputlen - savedolen;
694
694
                    currentpos = TellBlob(ofile);
695
695
                    offset=SeekBlob(ofile,savedpos,SEEK_SET);
696
696
                    if (offset < 0)
697
697
                      return(-1);
698
 
                    (void) WriteBlobMSBLong(ofile,(unsigned int) diff);
 
698
                    (void) WriteBlobMSBLong(ofile,(unsigned long) diff);
699
699
                    offset=SeekBlob(ofile,currentpos,SEEK_SET);
700
700
                    if (offset < 0)
701
701
                      return(-1);
723
723
                  }
724
724
                if (recnum != IPTC_ID)
725
725
                  {
726
 
                    (void) WriteBlobMSBLong(ofile,(unsigned int) len);
 
726
                    (void) WriteBlobMSBLong(ofile,(unsigned long) len);
727
727
                    outputlen += 4;
728
728
 
729
729
                    next=0;
741
741
                  {
742
742
                    /* patch in a fake length for now and fix it later */
743
743
                    savedpos = TellBlob(ofile);
744
 
                    (void) WriteBlobMSBLong(ofile,0xFFFFFFFFU);
 
744
                    (void) WriteBlobMSBLong(ofile,0xFFFFFFFFUL);
745
745
                    outputlen += 4;
746
746
                    savedolen = outputlen;
747
747
                  }
775
775
      MagickOffsetType
776
776
        offset;
777
777
 
778
 
      ssize_t diff = outputlen - savedolen;
 
778
      long diff = outputlen - savedolen;
779
779
 
780
780
      currentpos = TellBlob(ofile);
781
781
      offset=SeekBlob(ofile,savedpos,SEEK_SET);
782
782
      if (offset < 0)
783
783
        return(-1);
784
 
      (void) WriteBlobMSBLong(ofile,(unsigned int) diff);
 
784
      (void) WriteBlobMSBLong(ofile,(unsigned long) diff);
785
785
      offset=SeekBlob(ofile,currentpos,SEEK_SET);
786
786
      if (offset < 0)
787
787
        return(-1);
1222
1222
            (void) WriteBlobByte(buff,c);
1223
1223
          }
1224
1224
#else
1225
 
          ssize_t
 
1225
          long
1226
1226
            i;
1227
1227
 
1228
1228
          unsigned char
1240
1240
              while ((length=ReadBlob(image,MagickMaxBufferExtent,buffer)) != 0)
1241
1241
              {
1242
1242
                count=0;
1243
 
                for (i=0; i < (ssize_t) length; i+=count)
 
1243
                for (i=0; i < (long) length; i+=count)
1244
1244
                {
1245
1245
                  count=WriteBlob(buff,(size_t) (length-i),buffer+i);
1246
1246
                  if (count <= 0)
1247
1247
                    break;
1248
1248
                }
1249
 
                if (i < (ssize_t) length)
 
1249
                if (i < (long) length)
1250
1250
                  break;
1251
1251
              }
1252
1252
              buffer=(unsigned char *) RelinquishMagickMemory(buffer);
1394
1394
%
1395
1395
%  The format of the RegisterMETAImage method is:
1396
1396
%
1397
 
%      size_t RegisterMETAImage(void)
 
1397
%      unsigned long RegisterMETAImage(void)
1398
1398
%
1399
1399
*/
1400
 
ModuleExport size_t RegisterMETAImage(void)
 
1400
ModuleExport unsigned long RegisterMETAImage(void)
1401
1401
{
1402
1402
  MagickInfo
1403
1403
    *entry;
1593
1593
  int
1594
1594
    c;
1595
1595
 
1596
 
  register ssize_t
 
1596
  register long
1597
1597
    i;
1598
1598
 
1599
1599
  register unsigned char
1609
1609
  unsigned int
1610
1610
    marker;
1611
1611
 
1612
 
  size_t
 
1612
  unsigned long
1613
1613
    tag_length;
1614
1614
 
1615
1615
  p=(*info);
1637
1637
    extent-=c;
1638
1638
    if (extent < 4)
1639
1639
      break;
1640
 
    tag_length=(((size_t) *p) << 24) | (((size_t) *(p+1)) << 16) |
1641
 
      (((size_t) *(p+2)) << 8) | ((size_t) *(p+3));
 
1640
    tag_length=(((unsigned long) *p) << 24) | (((unsigned long) *(p+1)) << 16) |
 
1641
      (((unsigned long) *(p+2)) << 8) | ((unsigned long) *(p+3));
1642
1642
    p+=4;
1643
1643
    extent-=4;
1644
1644
    if (tag_length > extent)
1709
1709
      goto iptc_find;
1710
1710
    info_length++;
1711
1711
    /*
1712
 
      Decode the length of the block that follows - ssize_t or short format.
 
1712
      Decode the length of the block that follows - long or short format.
1713
1713
    */
1714
1714
    c=(*p++);
1715
1715
    length--;
1726
1726
            break;
1727
1727
          info_length++;
1728
1728
        }
1729
 
        tag_length=(((size_t) buffer[0]) << 24) |
1730
 
          (((size_t) buffer[1]) << 16) |
1731
 
          (((size_t) buffer[2]) << 8) | (((size_t) buffer[3])); 
 
1729
        tag_length=(((unsigned long) buffer[0]) << 24) |
 
1730
          (((unsigned long) buffer[1]) << 16) |
 
1731
          (((unsigned long) buffer[2]) << 8) | (((unsigned long) buffer[3])); 
1732
1732
      }
1733
1733
    else
1734
1734
      {
1735
 
        tag_length=(size_t) (c << 8);
 
1735
        tag_length=(unsigned long) (c << 8);
1736
1736
        c=(*p++);
1737
1737
        length--;
1738
1738
        if (length == 0)
1785
1785
      break;
1786
1786
    }
1787
1787
  }
1788
 
#if defined(MAGICKCORE_WINDOWS_SUPPORT)
 
1788
#if defined(__WINDOWS__)
1789
1789
  (void) WriteBlobString(ofile,"\"\r\n");
1790
1790
#else
1791
1791
#if defined(macintosh)
1878
1878
    *readable,
1879
1879
    *str;
1880
1880
 
1881
 
  ssize_t
 
1881
  long
1882
1882
    tagindx,
1883
1883
    taglen;
1884
1884
 
1923
1923
    else
1924
1924
      readable = (unsigned char *) "";
1925
1925
    /*
1926
 
      We decode the length of the block that follows - ssize_t or short fmt.
 
1926
      We decode the length of the block that follows - long or short fmt.
1927
1927
    */
1928
1928
    c=ReadBlobByte(ifile);
1929
1929
    if (c == EOF) return -1;
1973
1973
  return((int) tagsfound);
1974
1974
}
1975
1975
 
1976
 
static int readWordFromBuffer(char **s, ssize_t *len)
 
1976
static int readWordFromBuffer(char **s, long *len)
1977
1977
{
1978
1978
  unsigned char
1979
1979
    buffer[2];
1992
1992
         (((int) buffer[ 1 ]));
1993
1993
}
1994
1994
 
1995
 
static int formatIPTCfromBuffer(Image *ofile, char *s, ssize_t len)
 
1995
static int formatIPTCfromBuffer(Image *ofile, char *s, long len)
1996
1996
{
1997
1997
  char
1998
1998
    temp[MaxTextExtent];
2009
2009
    *readable,
2010
2010
    *str;
2011
2011
 
2012
 
  ssize_t
 
2012
  long
2013
2013
    tagindx,
2014
2014
    taglen;
2015
2015
 
2053
2053
    else
2054
2054
      readable=(unsigned char *) "";
2055
2055
    /*
2056
 
      We decode the length of the block that follows - ssize_t or short fmt.
 
2056
      We decode the length of the block that follows - long or short fmt.
2057
2057
    */
2058
2058
    c=(*s++);
2059
2059
    len--;
2196
2196
        printf("MemoryAllocationFailed");
2197
2197
        return 0;
2198
2198
      }
2199
 
    for (i=0; i < (ssize_t) count; i++)
 
2199
    for (i=0; i < (long) count; i++)
2200
2200
    {
2201
2201
      c=ReadBlobByte(ifile);
2202
2202
      if (c == EOF)
2221
2221
        if (ID == IPTC_ID)
2222
2222
          {
2223
2223
            formatString(ofile, "IPTC", 4);
2224
 
            formatIPTCfromBuffer(ofile, (char *)str, (ssize_t) count);
 
2224
            formatIPTCfromBuffer(ofile, (char *)str, (long) count);
2225
2225
          }
2226
2226
        else
2227
 
          formatString(ofile, (char *)str, (ssize_t) count);
 
2227
          formatString(ofile, (char *)str, (long) count);
2228
2228
      }
2229
2229
    str=(unsigned char *) RelinquishMagickMemory(str);
2230
2230
    PString=(unsigned char *) RelinquishMagickMemory(PString);