No changes, move wxStreamTempInputBuffer to a header file.

[wxWidgets.git] / src / tiff / libtiff / tif_compress.c

diff --git a/src/tiff/libtiff/tif_compress.c b/src/tiff/libtiff/tif_compress.c
index c6b0bec7a7d05c55ae4efb96f23cecfc9cd8c0c6..e92fcd5d39a400536a162ab07c9bc6289ec88c84 100644 (file)
--- a/src/tiff/libtiff/tif_compress.c
+++ b/src/tiff/libtiff/tif_compress.c
@@ -36,33 +36,34 @@ TIFFNoEncode(TIFF* tif, const char* method)
 {
        const TIFFCodec* c = TIFFFindCODEC(tif->tif_dir.td_compression);
 
 {
        const TIFFCodec* c = TIFFFindCODEC(tif->tif_dir.td_compression);
 

-       if (c) { 
-                       TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "%s %s encoding is not implemented",
-                          c->name, method);
-       } else { 
+       if (c) {

                TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
                TIFFErrorExt(tif->tif_clientdata, tif->tif_name,

-                         "Compression scheme %u %s encoding is not implemented",
-                   tif->tif_dir.td_compression, method);
+                            "%s %s encoding is not implemented",
+                            c->name, method);
+       } else {
+               TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
+                       "Compression scheme %u %s encoding is not implemented",
+                            tif->tif_dir.td_compression, method);

        }
        return (-1);
 }
 
 int
        }
        return (-1);
 }
 
 int

-_TIFFNoRowEncode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
+_TIFFNoRowEncode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s)

 {
        (void) pp; (void) cc; (void) s;
        return (TIFFNoEncode(tif, "scanline"));
 }
 
 int
 {
        (void) pp; (void) cc; (void) s;
        return (TIFFNoEncode(tif, "scanline"));
 }
 
 int

-_TIFFNoStripEncode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
+_TIFFNoStripEncode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s)

 {
        (void) pp; (void) cc; (void) s;
        return (TIFFNoEncode(tif, "strip"));
 }
 
 int
 {
        (void) pp; (void) cc; (void) s;
        return (TIFFNoEncode(tif, "strip"));
 }
 
 int

-_TIFFNoTileEncode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
+_TIFFNoTileEncode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s)

 {
        (void) pp; (void) cc; (void) s;
        return (TIFFNoEncode(tif, "tile"));
 {
        (void) pp; (void) cc; (void) s;
        return (TIFFNoEncode(tif, "tile"));


@@ -74,31 +75,39 @@ TIFFNoDecode(TIFF* tif, const char* method)
        const TIFFCodec* c = TIFFFindCODEC(tif->tif_dir.td_compression);
 
        if (c)
        const TIFFCodec* c = TIFFFindCODEC(tif->tif_dir.td_compression);
 
        if (c)

-               TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "%s %s decoding is not implemented",
-                   c->name, method);
+               TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
+                            "%s %s decoding is not implemented",
+                            c->name, method);

        else
                TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
        else
                TIFFErrorExt(tif->tif_clientdata, tif->tif_name,

-                   "Compression scheme %u %s decoding is not implemented",
-                   tif->tif_dir.td_compression, method);
+                            "Compression scheme %u %s decoding is not implemented",
+                            tif->tif_dir.td_compression, method);

        return (-1);
 }
 
 int
        return (-1);
 }
 
 int

-_TIFFNoRowDecode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
+_TIFFNoFixupTags(TIFF* tif)
+{
+       (void) tif;
+       return (1);
+}
+
+int
+_TIFFNoRowDecode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s)

 {
        (void) pp; (void) cc; (void) s;
        return (TIFFNoDecode(tif, "scanline"));
 }
 
 int
 {
        (void) pp; (void) cc; (void) s;
        return (TIFFNoDecode(tif, "scanline"));
 }
 
 int

-_TIFFNoStripDecode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
+_TIFFNoStripDecode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s)

 {
        (void) pp; (void) cc; (void) s;
        return (TIFFNoDecode(tif, "strip"));
 }
 
 int
 {
        (void) pp; (void) cc; (void) s;
        return (TIFFNoDecode(tif, "strip"));
 }
 
 int

-_TIFFNoTileDecode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
+_TIFFNoTileDecode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s)

 {
        (void) pp; (void) cc; (void) s;
        return (TIFFNoDecode(tif, "tile"));
 {
        (void) pp; (void) cc; (void) s;
        return (TIFFNoDecode(tif, "tile"));


@@ -109,12 +118,12 @@ _TIFFNoSeek(TIFF* tif, uint32 off)
 {
        (void) off;
        TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
 {
        (void) off;
        TIFFErrorExt(tif->tif_clientdata, tif->tif_name,

-           "Compression algorithm does not support random access");
+                    "Compression algorithm does not support random access");

        return (0);
 }
 
 int
        return (0);
 }
 
 int

-_TIFFNoPreCode(TIFF* tif, tsample_t s)
+_TIFFNoPreCode(TIFF* tif, uint16 s)

 {
        (void) tif; (void) s;
        return (1);
 {
        (void) tif; (void) s;
        return (1);


@@ -126,25 +135,26 @@ static void _TIFFvoid(TIFF* tif) { (void) tif; }
 void
 _TIFFSetDefaultCompressionState(TIFF* tif)
 {
 void
 _TIFFSetDefaultCompressionState(TIFF* tif)
 {

+       tif->tif_fixuptags = _TIFFNoFixupTags; 

        tif->tif_decodestatus = TRUE;
        tif->tif_setupdecode = _TIFFtrue;
        tif->tif_predecode = _TIFFNoPreCode;
        tif->tif_decodestatus = TRUE;
        tif->tif_setupdecode = _TIFFtrue;
        tif->tif_predecode = _TIFFNoPreCode;

-       tif->tif_decoderow = _TIFFNoRowDecode;
+       tif->tif_decoderow = _TIFFNoRowDecode;  

        tif->tif_decodestrip = _TIFFNoStripDecode;
        tif->tif_decodestrip = _TIFFNoStripDecode;

-       tif->tif_decodetile = _TIFFNoTileDecode;
+       tif->tif_decodetile = _TIFFNoTileDecode;  

        tif->tif_encodestatus = TRUE;
        tif->tif_setupencode = _TIFFtrue;
        tif->tif_preencode = _TIFFNoPreCode;
        tif->tif_postencode = _TIFFtrue;
        tif->tif_encoderow = _TIFFNoRowEncode;
        tif->tif_encodestatus = TRUE;
        tif->tif_setupencode = _TIFFtrue;
        tif->tif_preencode = _TIFFNoPreCode;
        tif->tif_postencode = _TIFFtrue;
        tif->tif_encoderow = _TIFFNoRowEncode;

-       tif->tif_encodestrip = _TIFFNoStripEncode;
-       tif->tif_encodetile = _TIFFNoTileEncode;
+       tif->tif_encodestrip = _TIFFNoStripEncode;  
+       tif->tif_encodetile = _TIFFNoTileEncode;  

        tif->tif_close = _TIFFvoid;
        tif->tif_seek = _TIFFNoSeek;
        tif->tif_cleanup = _TIFFvoid;
        tif->tif_defstripsize = _TIFFDefaultStripSize;
        tif->tif_deftilesize = _TIFFDefaultTileSize;
        tif->tif_close = _TIFFvoid;
        tif->tif_seek = _TIFFNoSeek;
        tif->tif_cleanup = _TIFFvoid;
        tif->tif_defstripsize = _TIFFDefaultStripSize;
        tif->tif_deftilesize = _TIFFDefaultTileSize;

-       tif->tif_flags &= ~TIFF_NOBITREV;
+       tif->tif_flags &= ~(TIFF_NOBITREV|TIFF_NOREADRAW);

 }
 
 int
 }
 
 int


@@ -168,10 +178,10 @@ TIFFSetCompressionScheme(TIFF* tif, int scheme)
  * by this library.
  */
 typedef struct _codec {
  * by this library.
  */
 typedef struct _codec {

-       struct _codec*  next;
-       TIFFCodec*      info;
+       struct _codec* next;
+       TIFFCodec* info;

 } codec_t;
 } codec_t;

-static codec_t* registeredCODECS = NULL;
+static codec_t* registeredCODECS = NULL;

 
 const TIFFCodec*
 TIFFFindCODEC(uint16 scheme)
 
 const TIFFCodec*
 TIFFFindCODEC(uint16 scheme)


@@ -192,12 +202,12 @@ TIFFCodec*
 TIFFRegisterCODEC(uint16 scheme, const char* name, TIFFInitMethod init)
 {
        codec_t* cd = (codec_t*)
 TIFFRegisterCODEC(uint16 scheme, const char* name, TIFFInitMethod init)
 {
        codec_t* cd = (codec_t*)

-           _TIFFmalloc(sizeof (codec_t) + sizeof (TIFFCodec) + strlen(name)+1);
+           _TIFFmalloc((tmsize_t)(sizeof (codec_t) + sizeof (TIFFCodec) + strlen(name)+1));

 
        if (cd != NULL) {
 
        if (cd != NULL) {

-               cd->info = (TIFFCodec*) ((tidata_t) cd + sizeof (codec_t));
+               cd->info = (TIFFCodec*) ((uint8*) cd + sizeof (codec_t));

                cd->info->name = (char*)
                cd->info->name = (char*)

-                   ((tidata_t) cd->info + sizeof (TIFFCodec));
+                   ((uint8*) cd->info + sizeof (TIFFCodec));

                strcpy(cd->info->name, name);
                cd->info->scheme = scheme;
                cd->info->init = init;
                strcpy(cd->info->name, name);
                cd->info->scheme = scheme;
                cd->info->init = init;


@@ -242,13 +252,14 @@ TIFFUnRegisterCODEC(TIFFCodec* c)
 TIFFCodec*
 TIFFGetConfiguredCODECs()
 {
 TIFFCodec*
 TIFFGetConfiguredCODECs()
 {

-       int             i = 1;
-        codec_t                *cd;
-        const TIFFCodec        *c;
-       TIFFCodec       *codecs = NULL, *new_codecs;
+       int i = 1;
+       codec_t *cd;
+       const TIFFCodec* c;
+       TIFFCodec* codecs = NULL;
+       TIFFCodec* new_codecs;

 
 

-        for (cd = registeredCODECS; cd; cd = cd->next) {
-                new_codecs = (TIFFCodec *)
+       for (cd = registeredCODECS; cd; cd = cd->next) {
+               new_codecs = (TIFFCodec *)

                        _TIFFrealloc(codecs, i * sizeof(TIFFCodec));
                if (!new_codecs) {
                        _TIFFfree (codecs);
                        _TIFFrealloc(codecs, i * sizeof(TIFFCodec));
                if (!new_codecs) {
                        _TIFFfree (codecs);


@@ -258,16 +269,16 @@ TIFFGetConfiguredCODECs()
                _TIFFmemcpy(codecs + i - 1, cd, sizeof(TIFFCodec));
                i++;
        }
                _TIFFmemcpy(codecs + i - 1, cd, sizeof(TIFFCodec));
                i++;
        }

-        for (c = _TIFFBuiltinCODECS; c->name; c++) {
-                if (TIFFIsCODECConfigured(c->scheme)) {
-                        new_codecs = (TIFFCodec *)
+       for (c = _TIFFBuiltinCODECS; c->name; c++) {
+               if (TIFFIsCODECConfigured(c->scheme)) {
+                       new_codecs = (TIFFCodec *)

                                _TIFFrealloc(codecs, i * sizeof(TIFFCodec));
                        if (!new_codecs) {
                                _TIFFfree (codecs);
                                return NULL;
                        }
                        codecs = new_codecs;
                                _TIFFrealloc(codecs, i * sizeof(TIFFCodec));
                        if (!new_codecs) {
                                _TIFFfree (codecs);
                                return NULL;
                        }
                        codecs = new_codecs;

-                       _TIFFmemcpy(codecs + i - 1, (const tdata_t)c, sizeof(TIFFCodec));
+                       _TIFFmemcpy(codecs + i - 1, (const void*)c, sizeof(TIFFCodec));

                        i++;
                }
        }
                        i++;
                }
        }


@@ -280,7 +291,14 @@ TIFFGetConfiguredCODECs()
        codecs = new_codecs;
        _TIFFmemset(codecs + i - 1, 0, sizeof(TIFFCodec));
 
        codecs = new_codecs;
        _TIFFmemset(codecs + i - 1, 0, sizeof(TIFFCodec));
 

-        return codecs;
+       return codecs;

 }
 
 /* vim: set ts=8 sts=8 sw=8 noet: */
 }
 
 /* vim: set ts=8 sts=8 sw=8 noet: */

+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 8
+ * fill-column: 78
+ * End:
+ */