mirrors/opencv
1
0
Fork 0
Code Pull Requests Packages Releases Activity

vendor: OpenCV 5.0.0 snapshot at 40738fb16ceddb5fb3fea747585f7ce6abb0605b

Browse Source
This commit is contained in:
Gitea Mirror Bot
2026-08-22 00:10:33 +08:00
commit f7f077da11
6933 changed files with 2335208 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
3rdparty/libtiff/tif_packbits.c
Vendored
+330
View File
@@ -0,0 +1,330 @@
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
#include "tiffiop.h"
#ifdef PACKBITS_SUPPORT
/*
* TIFF Library.
*
* PackBits Compression Algorithm Support
*/
#include <stdio.h>
#ifndef PACKBITS_READ_ONLY
static int PackBitsPreEncode(TIFF *tif, uint16_t s)
{
(void)s;
tif->tif_data = (uint8_t *)_TIFFmallocExt(tif, sizeof(tmsize_t));
if (tif->tif_data == NULL)
return (0);
/*
* Calculate the scanline/tile-width size in bytes.
*/
if (isTiled(tif))
*(tmsize_t *)tif->tif_data = TIFFTileRowSize(tif);
else
*(tmsize_t *)tif->tif_data = TIFFScanlineSize(tif);
return (1);
}
static int PackBitsPostEncode(TIFF *tif)
{
if (tif->tif_data)
_TIFFfreeExt(tif, tif->tif_data);
return (1);
}
/*
* Encode a run of pixels.
*/
static int PackBitsEncode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
{
unsigned char *bp = (unsigned char *)buf;
uint8_t *op;
uint8_t *ep;
uint8_t *lastliteral;
long n, slop;
int b;
enum
{
BASE,
LITERAL,
RUN,
LITERAL_RUN
} state;
(void)s;
op = tif->tif_rawcp;
ep = tif->tif_rawdata + tif->tif_rawdatasize;
state = BASE;
lastliteral = NULL;
while (cc > 0)
{
/*
* Find the longest string of identical bytes.
*/
b = *bp++;
cc--;
n = 1;
for (; cc > 0 && b == *bp; cc--, bp++)
n++;
again:
if (op + 2 >= ep)
{ /* insure space for new data */
/*
* Be careful about writing the last
* literal. Must write up to that point
* and then copy the remainder to the
* front of the buffer.
*/
if (state == LITERAL || state == LITERAL_RUN)
{
slop = (long)(op - lastliteral);
tif->tif_rawcc += (tmsize_t)(lastliteral - tif->tif_rawcp);
if (!TIFFFlushData1(tif))
return (0);
op = tif->tif_rawcp;
while (slop-- > 0)
*op++ = *lastliteral++;
lastliteral = tif->tif_rawcp;
}
else
{
tif->tif_rawcc += (tmsize_t)(op - tif->tif_rawcp);
if (!TIFFFlushData1(tif))
return (0);
op = tif->tif_rawcp;
}
}
switch (state)
{
case BASE: /* initial state, set run/literal */
if (n > 1)
{
state = RUN;
if (n > 128)
{
*op++ = (uint8_t)-127;
*op++ = (uint8_t)b;
n -= 128;
goto again;
}
*op++ = (uint8_t)(-(n - 1));
*op++ = (uint8_t)b;
}
else
{
lastliteral = op;
*op++ = 0;
*op++ = (uint8_t)b;
state = LITERAL;
}
break;
case LITERAL: /* last object was literal string */
if (n > 1)
{
state = LITERAL_RUN;
if (n > 128)
{
*op++ = (uint8_t)-127;
*op++ = (uint8_t)b;
n -= 128;
goto again;
}
*op++ = (uint8_t)(-(n - 1)); /* encode run */
*op++ = (uint8_t)b;
}
else
{ /* extend literal */
if (++(*lastliteral) == 127)
state = BASE;
*op++ = (uint8_t)b;
}
break;
case RUN: /* last object was run */
if (n > 1)
{
if (n > 128)
{
*op++ = (uint8_t)-127;
*op++ = (uint8_t)b;
n -= 128;
goto again;
}
*op++ = (uint8_t)(-(n - 1));
*op++ = (uint8_t)b;
}
else
{
lastliteral = op;
*op++ = 0;
*op++ = (uint8_t)b;
state = LITERAL;
}
break;
case LITERAL_RUN: /* literal followed by a run */
/*
* Check to see if previous run should
* be converted to a literal, in which
* case we convert literal-run-literal
* to a single literal.
*/
if (n == 1 && op[-2] == (uint8_t)-1 && *lastliteral < 126)
{
state = (((*lastliteral) += 2) == 127 ? BASE : LITERAL);
op[-2] = op[-1]; /* replicate */
}
else
state = RUN;
goto again;
}
}
tif->tif_rawcc += (tmsize_t)(op - tif->tif_rawcp);
tif->tif_rawcp = op;
return (1);
}
/*
* Encode a rectangular chunk of pixels. We break it up
* into row-sized pieces to insure that encoded runs do
* not span rows. Otherwise, there can be problems with
* the decoder if data is read, for example, by scanlines
* when it was encoded by strips.
*/
static int PackBitsEncodeChunk(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
{
tmsize_t rowsize = *(tmsize_t *)tif->tif_data;
while (cc > 0)
{
tmsize_t chunk = rowsize;
if (cc < chunk)
chunk = cc;
if (PackBitsEncode(tif, bp, chunk, s) < 0)
return (-1);
bp += chunk;
cc -= chunk;
}
return (1);
}
#endif
static int PackBitsDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
{
static const char module[] = "PackBitsDecode";
int8_t *bp;
tmsize_t cc;
long n;
int b;
(void)s;
bp = (int8_t *)tif->tif_rawcp;
cc = tif->tif_rawcc;
while (cc > 0 && occ > 0)
{
n = (long)*bp++;
cc--;
if (n < 0)
{ /* replicate next byte -n+1 times */
if (n == -128) /* nop */
continue;
n = -n + 1;
if (occ < (tmsize_t)n)
{
TIFFWarningExtR(tif, module,
"Discarding %" TIFF_SSIZE_FORMAT
" bytes to avoid buffer overrun",
(tmsize_t)n - occ);
n = (long)occ;
}
if (cc == 0)
{
TIFFWarningExtR(
tif, module,
"Terminating PackBitsDecode due to lack of data.");
break;
}
occ -= n;
b = *bp++;
cc--;
while (n-- > 0)
*op++ = (uint8_t)b;
}
else
{ /* copy next n+1 bytes literally */
if (occ < (tmsize_t)(n + 1))
{
TIFFWarningExtR(tif, module,
"Discarding %" TIFF_SSIZE_FORMAT
" bytes to avoid buffer overrun",
(tmsize_t)n - occ + 1);
n = (long)occ - 1;
}
if (cc < (tmsize_t)(n + 1))
{
TIFFWarningExtR(
tif, module,
"Terminating PackBitsDecode due to lack of data.");
break;
}
_TIFFmemcpy(op, bp, ++n);
op += n;
occ -= n;
bp += n;
cc -= n;
}
}
tif->tif_rawcp = (uint8_t *)bp;
tif->tif_rawcc = cc;
if (occ > 0)
{
memset(op, 0, (size_t)occ);
TIFFErrorExtR(tif, module, "Not enough data for scanline %" PRIu32,
tif->tif_row);
return (0);
}
return (1);
}
int TIFFInitPackBits(TIFF *tif, int scheme)
{
(void)scheme;
tif->tif_decoderow = PackBitsDecode;
tif->tif_decodestrip = PackBitsDecode;
tif->tif_decodetile = PackBitsDecode;
#ifndef PACKBITS_READ_ONLY
tif->tif_preencode = PackBitsPreEncode;
tif->tif_postencode = PackBitsPostEncode;
tif->tif_encoderow = PackBitsEncode;
tif->tif_encodestrip = PackBitsEncodeChunk;
tif->tif_encodetile = PackBitsEncodeChunk;
#endif
return (1);
}
#endif /* PACKBITS_SUPPORT */