/shark/trunk/ports/png/makefile |
---|
0,0 → 1,23 |
# The Frame Buffer Device |
ifndef BASE |
BASE=../.. |
endif |
include $(BASE)/config/config.mk |
LIBRARY = png |
OBJS_PATH = $(BASE)/ports/png |
PNG = png.o pngerror.o pnggccrd.o pngget.o pngmem.o\ |
pngread.o pngpread.o pngrio.o pngrtran.o pngrutil.o\ |
pngset.o pngtest.o pngtrans.o pngvcrd.o pngwio.o\ |
pngwrite.o pngwtran.o pngwutil.o |
OBJS = $(PNG) |
C_OPT += -I../../../drivers/linuxc26/include -I./include -I. -I../zlib/include |
include $(BASE)/config/lib.mk |
/shark/trunk/ports/png/include/pngconf.h |
---|
0,0 → 1,1348 |
/* pngconf.h - machine configurable file for libpng |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
*/ |
/* Any machine specific code is near the front of this file, so if you |
* are configuring libpng for a machine, you may want to read the section |
* starting here down to where it starts to typedef png_color, png_text, |
* and png_info. |
*/ |
#ifndef PNGCONF_H |
#define PNGCONF_H |
/* This is the size of the compression buffer, and thus the size of |
* an IDAT chunk. Make this whatever size you feel is best for your |
* machine. One of these will be allocated per png_struct. When this |
* is full, it writes the data to the disk, and does some other |
* calculations. Making this an extremely small size will slow |
* the library down, but you may want to experiment to determine |
* where it becomes significant, if you are concerned with memory |
* usage. Note that zlib allocates at least 32Kb also. For readers, |
* this describes the size of the buffer available to read the data in. |
* Unless this gets smaller than the size of a row (compressed), |
* it should not make much difference how big this is. |
*/ |
#ifndef PNG_ZBUF_SIZE |
# define PNG_ZBUF_SIZE 8192 |
#endif |
/* Enable if you want a write-only libpng */ |
#ifndef PNG_NO_READ_SUPPORTED |
# define PNG_READ_SUPPORTED |
#endif |
/* Enable if you want a read-only libpng */ |
#ifndef PNG_NO_WRITE_SUPPORTED |
# define PNG_WRITE_SUPPORTED |
#endif |
/* Enabled by default in 1.2.0. You can disable this if you don't need to |
support PNGs that are embedded in MNG datastreams */ |
#if !defined(PNG_1_0_X) && !defined(PNG_NO_MNG_FEATURES) |
# ifndef PNG_MNG_FEATURES_SUPPORTED |
# define PNG_MNG_FEATURES_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_FLOATING_POINT_SUPPORTED |
# ifndef PNG_FLOATING_POINT_SUPPORTED |
# define PNG_FLOATING_POINT_SUPPORTED |
# endif |
#endif |
/* If you are running on a machine where you cannot allocate more |
* than 64K of memory at once, uncomment this. While libpng will not |
* normally need that much memory in a chunk (unless you load up a very |
* large file), zlib needs to know how big of a chunk it can use, and |
* libpng thus makes sure to check any memory allocation to verify it |
* will fit into memory. |
#define PNG_MAX_MALLOC_64K |
*/ |
#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K) |
# define PNG_MAX_MALLOC_64K |
#endif |
/* Special munging to support doing things the 'cygwin' way: |
* 'Normal' png-on-win32 defines/defaults: |
* PNG_BUILD_DLL -- building dll |
* PNG_USE_DLL -- building an application, linking to dll |
* (no define) -- building static library, or building an |
* application and linking to the static lib |
* 'Cygwin' defines/defaults: |
* PNG_BUILD_DLL -- (ignored) building the dll |
* (no define) -- (ignored) building an application, linking to the dll |
* PNG_STATIC -- (ignored) building the static lib, or building an |
* application that links to the static lib. |
* ALL_STATIC -- (ignored) building various static libs, or building an |
* application that links to the static libs. |
* Thus, |
* a cygwin user should define either PNG_BUILD_DLL or PNG_STATIC, and |
* this bit of #ifdefs will define the 'correct' config variables based on |
* that. If a cygwin user *wants* to define 'PNG_USE_DLL' that's okay, but |
* unnecessary. |
* |
* Also, the precedence order is: |
* ALL_STATIC (since we can't #undef something outside our namespace) |
* PNG_BUILD_DLL |
* PNG_STATIC |
* (nothing) == PNG_USE_DLL |
* |
* CYGWIN (2002-01-20): The preceding is now obsolete. With the advent |
* of auto-import in binutils, we no longer need to worry about |
* __declspec(dllexport) / __declspec(dllimport) and friends. Therefore, |
* we don't need to worry about PNG_STATIC or ALL_STATIC when it comes |
* to __declspec() stuff. However, we DO need to worry about |
* PNG_BUILD_DLL and PNG_STATIC because those change some defaults |
* such as CONSOLE_IO and whether GLOBAL_ARRAYS are allowed. |
*/ |
#if defined(__CYGWIN__) |
# if defined(ALL_STATIC) |
# if defined(PNG_BUILD_DLL) |
# undef PNG_BUILD_DLL |
# endif |
# if defined(PNG_USE_DLL) |
# undef PNG_USE_DLL |
# endif |
# if defined(PNG_DLL) |
# undef PNG_DLL |
# endif |
# if !defined(PNG_STATIC) |
# define PNG_STATIC |
# endif |
# else |
# if defined (PNG_BUILD_DLL) |
# if defined(PNG_STATIC) |
# undef PNG_STATIC |
# endif |
# if defined(PNG_USE_DLL) |
# undef PNG_USE_DLL |
# endif |
# if !defined(PNG_DLL) |
# define PNG_DLL |
# endif |
# else |
# if defined(PNG_STATIC) |
# if defined(PNG_USE_DLL) |
# undef PNG_USE_DLL |
# endif |
# if defined(PNG_DLL) |
# undef PNG_DLL |
# endif |
# else |
# if !defined(PNG_USE_DLL) |
# define PNG_USE_DLL |
# endif |
# if !defined(PNG_DLL) |
# define PNG_DLL |
# endif |
# endif |
# endif |
# endif |
#endif |
/* This protects us against compilers that run on a windowing system |
* and thus don't have or would rather us not use the stdio types: |
* stdin, stdout, and stderr. The only one currently used is stderr |
* in png_error() and png_warning(). #defining PNG_NO_CONSOLE_IO will |
* prevent these from being compiled and used. #defining PNG_NO_STDIO |
* will also prevent these, plus will prevent the entire set of stdio |
* macros and functions (FILE *, printf, etc.) from being compiled and used, |
* unless (PNG_DEBUG > 0) has been #defined. |
* |
* #define PNG_NO_CONSOLE_IO |
* #define PNG_NO_STDIO |
*/ |
#if defined(_WIN32_WCE) |
# include <windows.h> |
/* Console I/O functions are not supported on WindowsCE */ |
# define PNG_NO_CONSOLE_IO |
# ifdef PNG_DEBUG |
# undef PNG_DEBUG |
# endif |
#endif |
#ifdef PNG_BUILD_DLL |
# ifndef PNG_CONSOLE_IO_SUPPORTED |
# ifndef PNG_NO_CONSOLE_IO |
# define PNG_NO_CONSOLE_IO |
# endif |
# endif |
#endif |
# ifdef PNG_NO_STDIO |
# ifndef PNG_NO_CONSOLE_IO |
# define PNG_NO_CONSOLE_IO |
# endif |
# ifdef PNG_DEBUG |
# if (PNG_DEBUG > 0) |
# include <stdio.h> |
# endif |
# endif |
# else |
# if !defined(_WIN32_WCE) |
/* "stdio.h" functions are not supported on WindowsCE */ |
# include <stdio.h> |
# endif |
# endif |
/* This macro protects us against machines that don't have function |
* prototypes (ie K&R style headers). If your compiler does not handle |
* function prototypes, define this macro and use the included ansi2knr. |
* I've always been able to use _NO_PROTO as the indicator, but you may |
* need to drag the empty declaration out in front of here, or change the |
* ifdef to suit your own needs. |
*/ |
#ifndef PNGARG |
#ifdef OF /* zlib prototype munger */ |
# define PNGARG(arglist) OF(arglist) |
#else |
#ifdef _NO_PROTO |
# define PNGARG(arglist) () |
# ifndef PNG_TYPECAST_NULL |
# define PNG_TYPECAST_NULL |
# endif |
#else |
# define PNGARG(arglist) arglist |
#endif /* _NO_PROTO */ |
#endif /* OF */ |
#endif /* PNGARG */ |
/* Try to determine if we are compiling on a Mac. Note that testing for |
* just __MWERKS__ is not good enough, because the Codewarrior is now used |
* on non-Mac platforms. |
*/ |
#ifndef MACOS |
# if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \ |
defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC) |
# define MACOS |
# endif |
#endif |
/* enough people need this for various reasons to include it here */ |
#if !defined(MACOS) && !defined(RISCOS) && !defined(_WIN32_WCE) |
# include <sys/types.h> |
#endif |
#if !defined(PNG_SETJMP_NOT_SUPPORTED) && !defined(PNG_NO_SETJMP_SUPPORTED) |
//# define PNG_SETJMP_SUPPORTED |
#endif |
#ifdef PNG_SETJMP_SUPPORTED |
/* This is an attempt to force a single setjmp behaviour on Linux. If |
* the X config stuff didn't define _BSD_SOURCE we wouldn't need this. |
*/ |
# ifdef __linux__ |
# ifdef _BSD_SOURCE |
# define PNG_SAVE_BSD_SOURCE |
# undef _BSD_SOURCE |
# endif |
# ifdef _SETJMP_H |
__png.h__ already includes setjmp.h; |
__dont__ include it again.; |
# endif |
# endif /* __linux__ */ |
/* include setjmp.h for error handling */ |
//# include <setjmp.h> |
# ifdef __linux__ |
# ifdef PNG_SAVE_BSD_SOURCE |
# define _BSD_SOURCE |
# undef PNG_SAVE_BSD_SOURCE |
# endif |
# endif /* __linux__ */ |
#endif /* PNG_SETJMP_SUPPORTED */ |
#ifdef BSD |
# include <strings.h> |
#else |
# include <string.h> |
#endif |
/* Other defines for things like memory and the like can go here. */ |
#ifdef PNG_INTERNAL |
#include <stdlib.h> |
/* The functions exported by PNG_EXTERN are PNG_INTERNAL functions, which |
* aren't usually used outside the library (as far as I know), so it is |
* debatable if they should be exported at all. In the future, when it is |
* possible to have run-time registry of chunk-handling functions, some of |
* these will be made available again. |
#define PNG_EXTERN extern |
*/ |
#define PNG_EXTERN |
/* Other defines specific to compilers can go here. Try to keep |
* them inside an appropriate ifdef/endif pair for portability. |
*/ |
#if defined(PNG_FLOATING_POINT_SUPPORTED) |
# if defined(MACOS) |
/* We need to check that <math.h> hasn't already been included earlier |
* as it seems it doesn't agree with <fp.h>, yet we should really use |
* <fp.h> if possible. |
*/ |
# if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__) |
# include <fp.h> |
# endif |
# else |
# include <math.h> |
# endif |
# if defined(_AMIGA) && defined(__SASC) && defined(_M68881) |
/* Amiga SAS/C: We must include builtin FPU functions when compiling using |
* MATH=68881 |
*/ |
# include <m68881.h> |
# endif |
#endif |
/* Codewarrior on NT has linking problems without this. */ |
#if (defined(__MWERKS__) && defined(WIN32)) || defined(__STDC__) |
# define PNG_ALWAYS_EXTERN |
#endif |
/* For some reason, Borland C++ defines memcmp, etc. in mem.h, not |
* stdlib.h like it should (I think). Or perhaps this is a C++ |
* "feature"? |
*/ |
#ifdef __TURBOC__ |
# include <mem.h> |
# include "alloc.h" |
#endif |
#if defined(_MSC_VER) && (defined(WIN32) || defined(_Windows) || \ |
defined(_WINDOWS) || defined(_WIN32) || defined(__WIN32__)) |
# include <malloc.h> |
#endif |
/* This controls how fine the dithering gets. As this allocates |
* a largish chunk of memory (32K), those who are not as concerned |
* with dithering quality can decrease some or all of these. |
*/ |
#ifndef PNG_DITHER_RED_BITS |
# define PNG_DITHER_RED_BITS 5 |
#endif |
#ifndef PNG_DITHER_GREEN_BITS |
# define PNG_DITHER_GREEN_BITS 5 |
#endif |
#ifndef PNG_DITHER_BLUE_BITS |
# define PNG_DITHER_BLUE_BITS 5 |
#endif |
/* This controls how fine the gamma correction becomes when you |
* are only interested in 8 bits anyway. Increasing this value |
* results in more memory being used, and more pow() functions |
* being called to fill in the gamma tables. Don't set this value |
* less then 8, and even that may not work (I haven't tested it). |
*/ |
#ifndef PNG_MAX_GAMMA_8 |
# define PNG_MAX_GAMMA_8 11 |
#endif |
/* This controls how much a difference in gamma we can tolerate before |
* we actually start doing gamma conversion. |
*/ |
#ifndef PNG_GAMMA_THRESHOLD |
# define PNG_GAMMA_THRESHOLD 0.05 |
#endif |
#endif /* PNG_INTERNAL */ |
/* The following uses const char * instead of char * for error |
* and warning message functions, so some compilers won't complain. |
* If you do not want to use const, define PNG_NO_CONST here. |
*/ |
#ifndef PNG_NO_CONST |
# define PNG_CONST const |
#else |
# define PNG_CONST |
#endif |
/* The following defines give you the ability to remove code from the |
* library that you will not be using. I wish I could figure out how to |
* automate this, but I can't do that without making it seriously hard |
* on the users. So if you are not using an ability, change the #define |
* to and #undef, and that part of the library will not be compiled. If |
* your linker can't find a function, you may want to make sure the |
* ability is defined here. Some of these depend upon some others being |
* defined. I haven't figured out all the interactions here, so you may |
* have to experiment awhile to get everything to compile. If you are |
* creating or using a shared library, you probably shouldn't touch this, |
* as it will affect the size of the structures, and this will cause bad |
* things to happen if the library and/or application ever change. |
*/ |
/* Any features you will not be using can be undef'ed here */ |
/* GR-P, 0.96a: Set "*TRANSFORMS_SUPPORTED as default but allow user |
* to turn it off with "*TRANSFORMS_NOT_SUPPORTED" or *PNG_NO_*_TRANSFORMS |
* on the compile line, then pick and choose which ones to define without |
* having to edit this file. It is safe to use the *TRANSFORMS_NOT_SUPPORTED |
* if you only want to have a png-compliant reader/writer but don't need |
* any of the extra transformations. This saves about 80 kbytes in a |
* typical installation of the library. (PNG_NO_* form added in version |
* 1.0.1c, for consistency) |
*/ |
/* The size of the png_text structure changed in libpng-1.0.6 when |
* iTXt is supported. It is turned off by default, to support old apps |
* that malloc the png_text structure instead of calling png_set_text() |
* and letting libpng malloc it. It will be turned on by default in |
* libpng-1.3.0. |
*/ |
#ifndef PNG_iTXt_SUPPORTED |
# if !defined(PNG_READ_iTXt_SUPPORTED) && !defined(PNG_NO_READ_iTXt) |
# define PNG_NO_READ_iTXt |
# endif |
# if !defined(PNG_WRITE_iTXt_SUPPORTED) && !defined(PNG_NO_WRITE_iTXt) |
# define PNG_NO_WRITE_iTXt |
# endif |
#endif |
/* The following support, added after version 1.0.0, can be turned off here en |
* masse by defining PNG_LEGACY_SUPPORTED in case you need binary compatibility |
* with old applications that require the length of png_struct and png_info |
* to remain unchanged. |
*/ |
#ifdef PNG_LEGACY_SUPPORTED |
# define PNG_NO_FREE_ME |
# define PNG_NO_READ_UNKNOWN_CHUNKS |
# define PNG_NO_WRITE_UNKNOWN_CHUNKS |
# define PNG_NO_READ_USER_CHUNKS |
# define PNG_NO_READ_iCCP |
# define PNG_NO_WRITE_iCCP |
# define PNG_NO_READ_iTXt |
# define PNG_NO_WRITE_iTXt |
# define PNG_NO_READ_sCAL |
# define PNG_NO_WRITE_sCAL |
# define PNG_NO_READ_sPLT |
# define PNG_NO_WRITE_sPLT |
# define PNG_NO_INFO_IMAGE |
# define PNG_NO_READ_RGB_TO_GRAY |
# define PNG_NO_READ_USER_TRANSFORM |
# define PNG_NO_WRITE_USER_TRANSFORM |
# define PNG_NO_USER_MEM |
# define PNG_NO_READ_EMPTY_PLTE |
# define PNG_NO_MNG_FEATURES |
# define PNG_NO_FIXED_POINT_SUPPORTED |
#endif |
/* Ignore attempt to turn off both floating and fixed point support */ |
#if !defined(PNG_FLOATING_POINT_SUPPORTED) || \ |
!defined(PNG_NO_FIXED_POINT_SUPPORTED) |
# define PNG_FIXED_POINT_SUPPORTED |
#endif |
#ifndef PNG_NO_FREE_ME |
# define PNG_FREE_ME_SUPPORTED |
#endif |
#if defined(PNG_READ_SUPPORTED) |
#if !defined(PNG_READ_TRANSFORMS_NOT_SUPPORTED) && \ |
!defined(PNG_NO_READ_TRANSFORMS) |
# define PNG_READ_TRANSFORMS_SUPPORTED |
#endif |
#ifdef PNG_READ_TRANSFORMS_SUPPORTED |
# ifndef PNG_NO_READ_EXPAND |
# define PNG_READ_EXPAND_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_SHIFT |
# define PNG_READ_SHIFT_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_PACK |
# define PNG_READ_PACK_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_BGR |
# define PNG_READ_BGR_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_SWAP |
# define PNG_READ_SWAP_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_PACKSWAP |
# define PNG_READ_PACKSWAP_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_INVERT |
# define PNG_READ_INVERT_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_DITHER |
# define PNG_READ_DITHER_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_BACKGROUND |
# define PNG_READ_BACKGROUND_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_16_TO_8 |
# define PNG_READ_16_TO_8_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_FILLER |
# define PNG_READ_FILLER_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_GAMMA |
# define PNG_READ_GAMMA_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_GRAY_TO_RGB |
# define PNG_READ_GRAY_TO_RGB_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_SWAP_ALPHA |
# define PNG_READ_SWAP_ALPHA_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_INVERT_ALPHA |
# define PNG_READ_INVERT_ALPHA_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_STRIP_ALPHA |
# define PNG_READ_STRIP_ALPHA_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_USER_TRANSFORM |
# define PNG_READ_USER_TRANSFORM_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_RGB_TO_GRAY |
# define PNG_READ_RGB_TO_GRAY_SUPPORTED |
# endif |
#endif /* PNG_READ_TRANSFORMS_SUPPORTED */ |
#if !defined(PNG_NO_PROGRESSIVE_READ) && \ |
!defined(PNG_PROGRESSIVE_READ_NOT_SUPPORTED) /* if you don't do progressive */ |
# define PNG_PROGRESSIVE_READ_SUPPORTED /* reading. This is not talking */ |
#endif /* about interlacing capability! You'll */ |
/* still have interlacing unless you change the following line: */ |
#define PNG_READ_INTERLACING_SUPPORTED /* required for PNG-compliant decoders */ |
#ifndef PNG_NO_READ_COMPOSITE_NODIV |
# ifndef PNG_NO_READ_COMPOSITED_NODIV /* libpng-1.0.x misspelling */ |
# define PNG_READ_COMPOSITE_NODIV_SUPPORTED /* well tested on Intel, SGI */ |
# endif |
#endif |
/* Deprecated, will be removed from version 2.0.0. |
Use PNG_MNG_FEATURES_SUPPORTED instead. */ |
#ifndef PNG_NO_READ_EMPTY_PLTE |
# define PNG_READ_EMPTY_PLTE_SUPPORTED |
#endif |
#endif /* PNG_READ_SUPPORTED */ |
#if defined(PNG_WRITE_SUPPORTED) |
# if !defined(PNG_WRITE_TRANSFORMS_NOT_SUPPORTED) && \ |
!defined(PNG_NO_WRITE_TRANSFORMS) |
# define PNG_WRITE_TRANSFORMS_SUPPORTED |
#endif |
#ifdef PNG_WRITE_TRANSFORMS_SUPPORTED |
# ifndef PNG_NO_WRITE_SHIFT |
# define PNG_WRITE_SHIFT_SUPPORTED |
# endif |
# ifndef PNG_NO_WRITE_PACK |
# define PNG_WRITE_PACK_SUPPORTED |
# endif |
# ifndef PNG_NO_WRITE_BGR |
# define PNG_WRITE_BGR_SUPPORTED |
# endif |
# ifndef PNG_NO_WRITE_SWAP |
# define PNG_WRITE_SWAP_SUPPORTED |
# endif |
# ifndef PNG_NO_WRITE_PACKSWAP |
# define PNG_WRITE_PACKSWAP_SUPPORTED |
# endif |
# ifndef PNG_NO_WRITE_INVERT |
# define PNG_WRITE_INVERT_SUPPORTED |
# endif |
# ifndef PNG_NO_WRITE_FILLER |
# define PNG_WRITE_FILLER_SUPPORTED /* same as WRITE_STRIP_ALPHA */ |
# endif |
# ifndef PNG_NO_WRITE_SWAP_ALPHA |
# define PNG_WRITE_SWAP_ALPHA_SUPPORTED |
# endif |
# ifndef PNG_NO_WRITE_INVERT_ALPHA |
# define PNG_WRITE_INVERT_ALPHA_SUPPORTED |
# endif |
# ifndef PNG_NO_WRITE_USER_TRANSFORM |
# define PNG_WRITE_USER_TRANSFORM_SUPPORTED |
# endif |
#endif /* PNG_WRITE_TRANSFORMS_SUPPORTED */ |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ |
defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) |
# ifndef PNG_NO_USER_TRANSFORM_PTR |
# define PNG_USER_TRANSFORM_PTR_SUPPORTED |
# endif |
#endif |
#define PNG_WRITE_INTERLACING_SUPPORTED /* not required for PNG-compliant |
encoders, but can cause trouble |
if left undefined */ |
#if !defined(PNG_NO_WRITE_WEIGHTED_FILTER) && \ |
defined(PNG_FLOATING_POINT_SUPPORTED) |
# define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED |
#endif |
#ifndef PNG_1_0_X |
#ifndef PNG_NO_ERROR_NUMBERS |
#define PNG_ERROR_NUMBERS_SUPPORTED |
#endif |
#endif /* PNG_1_0_X */ |
#ifndef PNG_NO_WRITE_FLUSH |
# define PNG_WRITE_FLUSH_SUPPORTED |
#endif |
/* Deprecated, see PNG_MNG_FEATURES_SUPPORTED, above */ |
#ifndef PNG_NO_WRITE_EMPTY_PLTE |
# define PNG_WRITE_EMPTY_PLTE_SUPPORTED |
#endif |
#endif /* PNG_WRITE_SUPPORTED */ |
#ifndef PNG_NO_STDIO |
# define PNG_TIME_RFC1123_SUPPORTED |
#endif |
/* This adds extra functions in pngget.c for accessing data from the |
* info pointer (added in version 0.99) |
* png_get_image_width() |
* png_get_image_height() |
* png_get_bit_depth() |
* png_get_color_type() |
* png_get_compression_type() |
* png_get_filter_type() |
* png_get_interlace_type() |
* png_get_pixel_aspect_ratio() |
* png_get_pixels_per_meter() |
* png_get_x_offset_pixels() |
* png_get_y_offset_pixels() |
* png_get_x_offset_microns() |
* png_get_y_offset_microns() |
*/ |
#if !defined(PNG_NO_EASY_ACCESS) && !defined(PNG_EASY_ACCESS_SUPPORTED) |
# define PNG_EASY_ACCESS_SUPPORTED |
#endif |
/* PNG_ASSEMBLER_CODE was enabled by default in version 1.2.0 |
even when PNG_USE_PNGVCRD or PNG_USE_PNGGCCRD is not defined */ |
#if defined(PNG_READ_SUPPORTED) && !defined(PNG_NO_ASSEMBLER_CODE) |
# ifndef PNG_ASSEMBLER_CODE_SUPPORTED |
# define PNG_ASSEMBLER_CODE_SUPPORTED |
# endif |
# if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE) |
# define PNG_MMX_CODE_SUPPORTED |
# endif |
#endif |
/* If you are sure that you don't need thread safety and you are compiling |
with PNG_USE_PNGCCRD for an MMX application, you can define this for |
faster execution. See pnggccrd.c. |
#define PNG_THREAD_UNSAFE_OK |
*/ |
#if !defined(PNG_1_0_X) |
#if !defined(PNG_NO_USER_MEM) && !defined(PNG_USER_MEM_SUPPORTED) |
# define PNG_USER_MEM_SUPPORTED |
#endif |
#endif /* PNG_1_0_X */ |
/* These are currently experimental features, define them if you want */ |
/* very little testing */ |
/* |
#ifdef PNG_READ_SUPPORTED |
# ifndef PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED |
# define PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED |
# endif |
#endif |
*/ |
/* This is only for PowerPC big-endian and 680x0 systems */ |
/* some testing */ |
/* |
#ifdef PNG_READ_SUPPORTED |
# ifndef PNG_PNG_READ_BIG_ENDIAN_SUPPORTED |
# define PNG_READ_BIG_ENDIAN_SUPPORTED |
# endif |
#endif |
*/ |
/* Buggy compilers (e.g., gcc 2.7.2.2) need this */ |
/* |
#define PNG_NO_POINTER_INDEXING |
*/ |
/* These functions are turned off by default, as they will be phased out. */ |
/* |
#define PNG_USELESS_TESTS_SUPPORTED |
#define PNG_CORRECT_PALETTE_SUPPORTED |
*/ |
/* Any chunks you are not interested in, you can undef here. The |
* ones that allocate memory may be expecially important (hIST, |
* tEXt, zTXt, tRNS, pCAL). Others will just save time and make png_info |
* a bit smaller. |
*/ |
#if defined(PNG_READ_SUPPORTED) && \ |
!defined(PNG_READ_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \ |
!defined(PNG_NO_READ_ANCILLARY_CHUNKS) |
# define PNG_READ_ANCILLARY_CHUNKS_SUPPORTED |
#endif |
#if defined(PNG_WRITE_SUPPORTED) && \ |
!defined(PNG_WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \ |
!defined(PNG_NO_WRITE_ANCILLARY_CHUNKS) |
# define PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED |
#endif |
#ifdef PNG_READ_ANCILLARY_CHUNKS_SUPPORTED |
#ifdef PNG_NO_READ_TEXT |
# define PNG_NO_READ_iTXt |
# define PNG_NO_READ_tEXt |
# define PNG_NO_READ_zTXt |
#endif |
#ifndef PNG_NO_READ_bKGD |
# define PNG_READ_bKGD_SUPPORTED |
# define PNG_bKGD_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_cHRM |
# define PNG_READ_cHRM_SUPPORTED |
# define PNG_cHRM_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_gAMA |
# define PNG_READ_gAMA_SUPPORTED |
# define PNG_gAMA_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_hIST |
# define PNG_READ_hIST_SUPPORTED |
# define PNG_hIST_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_iCCP |
# define PNG_READ_iCCP_SUPPORTED |
# define PNG_iCCP_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_iTXt |
# ifndef PNG_READ_iTXt_SUPPORTED |
# define PNG_READ_iTXt_SUPPORTED |
# endif |
# ifndef PNG_iTXt_SUPPORTED |
# define PNG_iTXt_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_READ_oFFs |
# define PNG_READ_oFFs_SUPPORTED |
# define PNG_oFFs_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_pCAL |
# define PNG_READ_pCAL_SUPPORTED |
# define PNG_pCAL_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_sCAL |
# define PNG_READ_sCAL_SUPPORTED |
# define PNG_sCAL_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_pHYs |
# define PNG_READ_pHYs_SUPPORTED |
# define PNG_pHYs_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_sBIT |
# define PNG_READ_sBIT_SUPPORTED |
# define PNG_sBIT_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_sPLT |
# define PNG_READ_sPLT_SUPPORTED |
# define PNG_sPLT_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_sRGB |
# define PNG_READ_sRGB_SUPPORTED |
# define PNG_sRGB_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_tEXt |
# define PNG_READ_tEXt_SUPPORTED |
# define PNG_tEXt_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_tIME |
# define PNG_READ_tIME_SUPPORTED |
# define PNG_tIME_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_tRNS |
# define PNG_READ_tRNS_SUPPORTED |
# define PNG_tRNS_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_zTXt |
# define PNG_READ_zTXt_SUPPORTED |
# define PNG_zTXt_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_UNKNOWN_CHUNKS |
# define PNG_READ_UNKNOWN_CHUNKS_SUPPORTED |
# ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED |
# define PNG_UNKNOWN_CHUNKS_SUPPORTED |
# endif |
# ifndef PNG_NO_HANDLE_AS_UNKNOWN |
# define PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
# endif |
#endif |
#if !defined(PNG_NO_READ_USER_CHUNKS) && \ |
defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) |
# define PNG_READ_USER_CHUNKS_SUPPORTED |
# define PNG_USER_CHUNKS_SUPPORTED |
# ifdef PNG_NO_READ_UNKNOWN_CHUNKS |
# undef PNG_NO_READ_UNKNOWN_CHUNKS |
# endif |
# ifdef PNG_NO_HANDLE_AS_UNKNOWN |
# undef PNG_NO_HANDLE_AS_UNKNOWN |
# endif |
#endif |
#ifndef PNG_NO_READ_OPT_PLTE |
# define PNG_READ_OPT_PLTE_SUPPORTED /* only affects support of the */ |
#endif /* optional PLTE chunk in RGB and RGBA images */ |
#if defined(PNG_READ_iTXt_SUPPORTED) || defined(PNG_READ_tEXt_SUPPORTED) || \ |
defined(PNG_READ_zTXt_SUPPORTED) |
# define PNG_READ_TEXT_SUPPORTED |
# define PNG_TEXT_SUPPORTED |
#endif |
#endif /* PNG_READ_ANCILLARY_CHUNKS_SUPPORTED */ |
#ifdef PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED |
#ifdef PNG_NO_WRITE_TEXT |
# define PNG_NO_WRITE_iTXt |
# define PNG_NO_WRITE_tEXt |
# define PNG_NO_WRITE_zTXt |
#endif |
#ifndef PNG_NO_WRITE_bKGD |
# define PNG_WRITE_bKGD_SUPPORTED |
# ifndef PNG_bKGD_SUPPORTED |
# define PNG_bKGD_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_cHRM |
# define PNG_WRITE_cHRM_SUPPORTED |
# ifndef PNG_cHRM_SUPPORTED |
# define PNG_cHRM_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_gAMA |
# define PNG_WRITE_gAMA_SUPPORTED |
# ifndef PNG_gAMA_SUPPORTED |
# define PNG_gAMA_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_hIST |
# define PNG_WRITE_hIST_SUPPORTED |
# ifndef PNG_hIST_SUPPORTED |
# define PNG_hIST_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_iCCP |
# define PNG_WRITE_iCCP_SUPPORTED |
# ifndef PNG_iCCP_SUPPORTED |
# define PNG_iCCP_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_iTXt |
# ifndef PNG_WRITE_iTXt_SUPPORTED |
# define PNG_WRITE_iTXt_SUPPORTED |
# endif |
# ifndef PNG_iTXt_SUPPORTED |
# define PNG_iTXt_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_oFFs |
# define PNG_WRITE_oFFs_SUPPORTED |
# ifndef PNG_oFFs_SUPPORTED |
# define PNG_oFFs_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_pCAL |
# define PNG_WRITE_pCAL_SUPPORTED |
# ifndef PNG_pCAL_SUPPORTED |
# define PNG_pCAL_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_sCAL |
# define PNG_WRITE_sCAL_SUPPORTED |
# ifndef PNG_sCAL_SUPPORTED |
# define PNG_sCAL_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_pHYs |
# define PNG_WRITE_pHYs_SUPPORTED |
# ifndef PNG_pHYs_SUPPORTED |
# define PNG_pHYs_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_sBIT |
# define PNG_WRITE_sBIT_SUPPORTED |
# ifndef PNG_sBIT_SUPPORTED |
# define PNG_sBIT_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_sPLT |
# define PNG_WRITE_sPLT_SUPPORTED |
# ifndef PNG_sPLT_SUPPORTED |
# define PNG_sPLT_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_sRGB |
# define PNG_WRITE_sRGB_SUPPORTED |
# ifndef PNG_sRGB_SUPPORTED |
# define PNG_sRGB_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_tEXt |
# define PNG_WRITE_tEXt_SUPPORTED |
# ifndef PNG_tEXt_SUPPORTED |
# define PNG_tEXt_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_tIME |
//# define PNG_WRITE_tIME_SUPPORTED |
# ifndef PNG_tIME_SUPPORTED |
//# define PNG_tIME_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_tRNS |
# define PNG_WRITE_tRNS_SUPPORTED |
# ifndef PNG_tRNS_SUPPORTED |
# define PNG_tRNS_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_zTXt |
# define PNG_WRITE_zTXt_SUPPORTED |
# ifndef PNG_zTXt_SUPPORTED |
# define PNG_zTXt_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_UNKNOWN_CHUNKS |
# define PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED |
# ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED |
# define PNG_UNKNOWN_CHUNKS_SUPPORTED |
# endif |
# ifndef PNG_NO_HANDLE_AS_UNKNOWN |
# ifndef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
# define PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
# endif |
# endif |
#endif |
#if defined(PNG_WRITE_iTXt_SUPPORTED) || defined(PNG_WRITE_tEXt_SUPPORTED) || \ |
defined(PNG_WRITE_zTXt_SUPPORTED) |
# define PNG_WRITE_TEXT_SUPPORTED |
# ifndef PNG_TEXT_SUPPORTED |
# define PNG_TEXT_SUPPORTED |
# endif |
#endif |
#endif /* PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED */ |
/* Turn this off to disable png_read_png() and |
* png_write_png() and leave the row_pointers member |
* out of the info structure. |
*/ |
#ifndef PNG_NO_INFO_IMAGE |
# define PNG_INFO_IMAGE_SUPPORTED |
#endif |
/* need the time information for reading tIME chunks */ |
#if defined(PNG_tIME_SUPPORTED) |
# if !defined(_WIN32_WCE) |
/* "time.h" functions are not supported on WindowsCE */ |
# include <time.h> |
# endif |
#endif |
/* Some typedefs to get us started. These should be safe on most of the |
* common platforms. The typedefs should be at least as large as the |
* numbers suggest (a png_uint_32 must be at least 32 bits long), but they |
* don't have to be exactly that size. Some compilers dislike passing |
* unsigned shorts as function parameters, so you may be better off using |
* unsigned int for png_uint_16. Likewise, for 64-bit systems, you may |
* want to have unsigned int for png_uint_32 instead of unsigned long. |
*/ |
typedef unsigned long png_uint_32; |
typedef long png_int_32; |
typedef unsigned short png_uint_16; |
typedef short png_int_16; |
typedef unsigned char png_byte; |
/* This is usually size_t. It is typedef'ed just in case you need it to |
change (I'm not sure if you will or not, so I thought I'd be safe) */ |
typedef size_t png_size_t; |
/* The following is needed for medium model support. It cannot be in the |
* PNG_INTERNAL section. Needs modification for other compilers besides |
* MSC. Model independent support declares all arrays and pointers to be |
* large using the far keyword. The zlib version used must also support |
* model independent data. As of version zlib 1.0.4, the necessary changes |
* have been made in zlib. The USE_FAR_KEYWORD define triggers other |
* changes that are needed. (Tim Wegner) |
*/ |
/* Separate compiler dependencies (problem here is that zlib.h always |
defines FAR. (SJT) */ |
#ifdef __BORLANDC__ |
# if defined(__LARGE__) || defined(__HUGE__) || defined(__COMPACT__) |
# define LDATA 1 |
# else |
# define LDATA 0 |
# endif |
/* GRR: why is Cygwin in here? Cygwin is not Borland C... */ |
# if !defined(__WIN32__) && !defined(__FLAT__) && !defined(__CYGWIN__) |
# define PNG_MAX_MALLOC_64K |
# if (LDATA != 1) |
# ifndef FAR |
# define FAR __far |
# endif |
# define USE_FAR_KEYWORD |
# endif /* LDATA != 1 */ |
/* Possibly useful for moving data out of default segment. |
* Uncomment it if you want. Could also define FARDATA as |
* const if your compiler supports it. (SJT) |
# define FARDATA FAR |
*/ |
# endif /* __WIN32__, __FLAT__, __CYGWIN__ */ |
#endif /* __BORLANDC__ */ |
/* Suggest testing for specific compiler first before testing for |
* FAR. The Watcom compiler defines both __MEDIUM__ and M_I86MM, |
* making reliance oncertain keywords suspect. (SJT) |
*/ |
/* MSC Medium model */ |
#if defined(FAR) |
# if defined(M_I86MM) |
# define USE_FAR_KEYWORD |
# define FARDATA FAR |
# include <dos.h> |
# endif |
#endif |
/* SJT: default case */ |
#ifndef FAR |
# define FAR |
#endif |
/* At this point FAR is always defined */ |
#ifndef FARDATA |
# define FARDATA |
#endif |
/* Typedef for floating-point numbers that are converted |
to fixed-point with a multiple of 100,000, e.g., int_gamma */ |
typedef png_int_32 png_fixed_point; |
/* Add typedefs for pointers */ |
typedef void FAR * png_voidp; |
typedef png_byte FAR * png_bytep; |
typedef png_uint_32 FAR * png_uint_32p; |
typedef png_int_32 FAR * png_int_32p; |
typedef png_uint_16 FAR * png_uint_16p; |
typedef png_int_16 FAR * png_int_16p; |
typedef PNG_CONST char FAR * png_const_charp; |
typedef char FAR * png_charp; |
typedef png_fixed_point FAR * png_fixed_point_p; |
#ifndef PNG_NO_STDIO |
#if defined(_WIN32_WCE) |
typedef HANDLE png_FILE_p; |
#else |
typedef FILE * png_FILE_p; |
#endif |
#endif |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
typedef double FAR * png_doublep; |
#endif |
/* Pointers to pointers; i.e. arrays */ |
typedef png_byte FAR * FAR * png_bytepp; |
typedef png_uint_32 FAR * FAR * png_uint_32pp; |
typedef png_int_32 FAR * FAR * png_int_32pp; |
typedef png_uint_16 FAR * FAR * png_uint_16pp; |
typedef png_int_16 FAR * FAR * png_int_16pp; |
typedef PNG_CONST char FAR * FAR * png_const_charpp; |
typedef char FAR * FAR * png_charpp; |
typedef png_fixed_point FAR * FAR * png_fixed_point_pp; |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
typedef double FAR * FAR * png_doublepp; |
#endif |
/* Pointers to pointers to pointers; i.e., pointer to array */ |
typedef char FAR * FAR * FAR * png_charppp; |
/* libpng typedefs for types in zlib. If zlib changes |
* or another compression library is used, then change these. |
* Eliminates need to change all the source files. |
*/ |
typedef charf * png_zcharp; |
typedef charf * FAR * png_zcharpp; |
typedef z_stream FAR * png_zstreamp; |
/* |
* Define PNG_BUILD_DLL if the module being built is a Windows |
* LIBPNG DLL. |
* |
* Define PNG_USE_DLL if you want to *link* to the Windows LIBPNG DLL. |
* It is equivalent to Microsoft predefined macro _DLL that is |
* automatically defined when you compile using the share |
* version of the CRT (C Run-Time library) |
* |
* The cygwin mods make this behavior a little different: |
* Define PNG_BUILD_DLL if you are building a dll for use with cygwin |
* Define PNG_STATIC if you are building a static library for use with cygwin, |
* -or- if you are building an application that you want to link to the |
* static library. |
* PNG_USE_DLL is defined by default (no user action needed) unless one of |
* the other flags is defined. |
*/ |
#if !defined(PNG_DLL) && (defined(PNG_BUILD_DLL) || defined(PNG_USE_DLL)) |
# define PNG_DLL |
#endif |
/* If CYGWIN, then disallow GLOBAL ARRAYS unless building a static lib. |
* When building a static lib, default to no GLOBAL ARRAYS, but allow |
* command-line override |
*/ |
#if defined(__CYGWIN__) |
# if !defined(PNG_STATIC) |
# if defined(PNG_USE_GLOBAL_ARRAYS) |
# undef PNG_USE_GLOBAL_ARRAYS |
# endif |
# if !defined(PNG_USE_LOCAL_ARRAYS) |
# define PNG_USE_LOCAL_ARRAYS |
# endif |
# else |
# if defined(PNG_USE_LOCAL_ARRAYS) || defined(PNG_NO_GLOBAL_ARRAYS) |
# if defined(PNG_USE_GLOBAL_ARRAYS) |
# undef PNG_USE_GLOBAL_ARRAYS |
# endif |
# endif |
# endif |
# if !defined(PNG_USE_LOCAL_ARRAYS) && !defined(PNG_USE_GLOBAL_ARRAYS) |
# define PNG_USE_LOCAL_ARRAYS |
# endif |
#endif |
/* Do not use global arrays (helps with building DLL's) |
* They are no longer used in libpng itself, since version 1.0.5c, |
* but might be required for some pre-1.0.5c applications. |
*/ |
#if !defined(PNG_USE_LOCAL_ARRAYS) && !defined(PNG_USE_GLOBAL_ARRAYS) |
# if defined(PNG_NO_GLOBAL_ARRAYS) || (defined(__GNUC__) && defined(PNG_DLL)) |
# define PNG_USE_LOCAL_ARRAYS |
# else |
# define PNG_USE_GLOBAL_ARRAYS |
# endif |
#endif |
#if defined(__CYGWIN__) |
# undef PNGAPI |
# define PNGAPI __cdecl |
# undef PNG_IMPEXP |
# define PNG_IMPEXP |
#endif |
/* If you define PNGAPI, e.g., with compiler option "-DPNGAPI=__stdcall", |
* you may get warnings regarding the linkage of png_zalloc and png_zfree. |
* Don't ignore those warnings; you must also reset the default calling |
* convention in your compiler to match your PNGAPI, and you must build |
* zlib and your applications the same way you build libpng. |
*/ |
#ifndef PNGAPI |
#if defined(__MINGW32__) && !defined(PNG_MODULEDEF) |
# ifndef PNG_NO_MODULEDEF |
# define PNG_NO_MODULEDEF |
# endif |
#endif |
#if !defined(PNG_IMPEXP) && defined(PNG_BUILD_DLL) && !defined(PNG_NO_MODULEDEF) |
# define PNG_IMPEXP |
#endif |
#if defined(PNG_DLL) || defined(_DLL) || defined(__DLL__ ) || \ |
(( defined(_Windows) || defined(_WINDOWS) || \ |
defined(WIN32) || defined(_WIN32) || defined(__WIN32__) )) |
# if defined(__GNUC__) || (defined (_MSC_VER) && (_MSC_VER >= 800)) |
# define PNGAPI __cdecl |
# else |
# define PNGAPI _cdecl |
# endif |
# if !defined(PNG_IMPEXP) && (!defined(PNG_DLL) || \ |
0 /* WINCOMPILER_WITH_NO_SUPPORT_FOR_DECLIMPEXP */) |
# define PNG_IMPEXP |
# endif |
# if !defined(PNG_IMPEXP) |
# define PNG_EXPORT_TYPE1(type,symbol) PNG_IMPEXP type PNGAPI symbol |
# define PNG_EXPORT_TYPE2(type,symbol) type PNG_IMPEXP PNGAPI symbol |
/* Borland/Microsoft */ |
# if defined(_MSC_VER) || defined(__BORLANDC__) |
# if (_MSC_VER >= 800) || (__BORLANDC__ >= 0x500) |
# define PNG_EXPORT PNG_EXPORT_TYPE1 |
# else |
# define PNG_EXPORT PNG_EXPORT_TYPE2 |
# if defined(PNG_BUILD_DLL) |
# define PNG_IMPEXP __export |
# else |
# define PNG_IMPEXP /*__import */ /* doesn't exist AFAIK in |
VC++ */ |
# endif /* Exists in Borland C++ for |
C++ classes (== huge) */ |
# endif |
# endif |
# if !defined(PNG_IMPEXP) |
# if defined(PNG_BUILD_DLL) |
# define PNG_IMPEXP __declspec(dllexport) |
# else |
# define PNG_IMPEXP __declspec(dllimport) |
# endif |
# endif |
# endif /* PNG_IMPEXP */ |
#else /* !(DLL || non-cygwin WINDOWS) */ |
# if (defined(__IBMC__) || defined(IBMCPP__)) && defined(__OS2__) |
# define PNGAPI _System |
# define PNG_IMPEXP |
# else |
# if 0 /* ... other platforms, with other meanings */ |
# else |
# define PNGAPI |
# define PNG_IMPEXP |
# endif |
# endif |
#endif |
#endif |
#ifndef PNGAPI |
# define PNGAPI |
#endif |
#ifndef PNG_IMPEXP |
# define PNG_IMPEXP |
#endif |
#ifndef PNG_EXPORT |
# define PNG_EXPORT(type,symbol) PNG_IMPEXP type PNGAPI symbol |
#endif |
#ifdef PNG_USE_GLOBAL_ARRAYS |
# ifndef PNG_EXPORT_VAR |
# define PNG_EXPORT_VAR(type) extern PNG_IMPEXP type |
# endif |
#endif |
/* User may want to use these so they are not in PNG_INTERNAL. Any library |
* functions that are passed far data must be model independent. |
*/ |
#ifndef PNG_ABORT |
# define PNG_ABORT() abort() |
#endif |
#ifdef PNG_SETJMP_SUPPORTED |
# define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf) |
#else |
# define png_jmpbuf(png_ptr) \ |
(LIBPNG_WAS_COMPILED_WITH__PNG_SETJMP_NOT_SUPPORTED) |
#endif |
#if defined(USE_FAR_KEYWORD) /* memory model independent fns */ |
/* use this to make far-to-near assignments */ |
# define CHECK 1 |
# define NOCHECK 0 |
# define CVT_PTR(ptr) (png_far_to_near(png_ptr,ptr,CHECK)) |
# define CVT_PTR_NOCHECK(ptr) (png_far_to_near(png_ptr,ptr,NOCHECK)) |
# define png_strcpy _fstrcpy |
# define png_strlen _fstrlen |
# define png_memcmp _fmemcmp /* SJT: added */ |
# define png_memcpy _fmemcpy |
# define png_memset _fmemset |
#else /* use the usual functions */ |
# define CVT_PTR(ptr) (ptr) |
# define CVT_PTR_NOCHECK(ptr) (ptr) |
# define png_strcpy strcpy |
# define png_strlen strlen |
# define png_memcmp memcmp /* SJT: added */ |
# define png_memcpy memcpy |
# define png_memset memset |
#endif |
/* End of memory model independent support */ |
/* Just a little check that someone hasn't tried to define something |
* contradictory. |
*/ |
#if (PNG_ZBUF_SIZE > 65536) && defined(PNG_MAX_MALLOC_64K) |
# undef PNG_ZBUF_SIZE |
# define PNG_ZBUF_SIZE 65536 |
#endif |
#ifdef PNG_READ_SUPPORTED |
/* Prior to libpng-1.0.9, this block was in pngasmrd.h */ |
#if defined(PNG_INTERNAL) |
/* These are the default thresholds before the MMX code kicks in; if either |
* rowbytes or bitdepth is below the threshold, plain C code is used. These |
* can be overridden at runtime via the png_set_mmx_thresholds() call in |
* libpng 1.2.0 and later. The values below were chosen by Intel. |
*/ |
#ifndef PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT |
# define PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT 128 /* >= */ |
#endif |
#ifndef PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT |
# define PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT 9 /* >= */ |
#endif |
/* Set this in the makefile for VC++ on Pentium, not here. */ |
/* Platform must be Pentium. Makefile must assemble and load pngvcrd.c . |
* MMX will be detected at run time and used if present. |
*/ |
#ifdef PNG_USE_PNGVCRD |
# define PNG_HAVE_ASSEMBLER_COMBINE_ROW |
# define PNG_HAVE_ASSEMBLER_READ_INTERLACE |
# define PNG_HAVE_ASSEMBLER_READ_FILTER_ROW |
#endif |
/* Set this in the makefile for gcc/as on Pentium, not here. */ |
/* Platform must be Pentium. Makefile must assemble and load pnggccrd.c . |
* MMX will be detected at run time and used if present. |
*/ |
#ifdef PNG_USE_PNGGCCRD |
# define PNG_HAVE_ASSEMBLER_COMBINE_ROW |
# define PNG_HAVE_ASSEMBLER_READ_INTERLACE |
# define PNG_HAVE_ASSEMBLER_READ_FILTER_ROW |
#endif |
/* - see pnggccrd.c for info about what is currently enabled */ |
#endif /* PNG_INTERNAL */ |
#endif /* PNG_READ_SUPPORTED */ |
#endif /* PNGCONF_H */ |
/shark/trunk/ports/png/include/png.h |
---|
0,0 → 1,3283 |
/* png.h - header file for PNG reference library |
* |
* libpng version 1.2.5 - October 3, 2002 |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
* Authors and maintainers: |
* libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat |
* libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger |
* libpng versions 0.97, January 1998, through 1.2.5 - October 3, 2002: Glenn |
* See also "Contributing Authors", below. |
* |
* Note about libpng version numbers: |
* |
* Due to various miscommunications, unforeseen code incompatibilities |
* and occasional factors outside the authors' control, version numbering |
* on the library has not always been consistent and straightforward. |
* The following table summarizes matters since version 0.89c, which was |
* the first widely used release: |
* |
* source png.h png.h shared-lib |
* version string int version |
* ------- ------ ----- ---------- |
* 0.89c "1.0 beta 3" 0.89 89 1.0.89 |
* 0.90 "1.0 beta 4" 0.90 90 0.90 [should have been 2.0.90] |
* 0.95 "1.0 beta 5" 0.95 95 0.95 [should have been 2.0.95] |
* 0.96 "1.0 beta 6" 0.96 96 0.96 [should have been 2.0.96] |
* 0.97b "1.00.97 beta 7" 1.00.97 97 1.0.1 [should have been 2.0.97] |
* 0.97c 0.97 97 2.0.97 |
* 0.98 0.98 98 2.0.98 |
* 0.99 0.99 98 2.0.99 |
* 0.99a-m 0.99 99 2.0.99 |
* 1.00 1.00 100 2.1.0 [100 should be 10000] |
* 1.0.0 (from here on, the 100 2.1.0 [100 should be 10000] |
* 1.0.1 png.h string is 10001 2.1.0 |
* 1.0.1a-e identical to the 10002 from here on, the shared library |
* 1.0.2 source version) 10002 is 2.V where V is the source code |
* 1.0.2a-b 10003 version, except as noted. |
* 1.0.3 10003 |
* 1.0.3a-d 10004 |
* 1.0.4 10004 |
* 1.0.4a-f 10005 |
* 1.0.5 (+ 2 patches) 10005 |
* 1.0.5a-d 10006 |
* 1.0.5e-r 10100 (not source compatible) |
* 1.0.5s-v 10006 (not binary compatible) |
* 1.0.6 (+ 3 patches) 10006 (still binary incompatible) |
* 1.0.6d-f 10007 (still binary incompatible) |
* 1.0.6g 10007 |
* 1.0.6h 10007 10.6h (testing xy.z so-numbering) |
* 1.0.6i 10007 10.6i |
* 1.0.6j 10007 2.1.0.6j (incompatible with 1.0.0) |
* 1.0.7beta11-14 DLLNUM 10007 2.1.0.7beta11-14 (binary compatible) |
* 1.0.7beta15-18 1 10007 2.1.0.7beta15-18 (binary compatible) |
* 1.0.7rc1-2 1 10007 2.1.0.7rc1-2 (binary compatible) |
* 1.0.7 1 10007 (still compatible) |
* 1.0.8beta1-4 1 10008 2.1.0.8beta1-4 |
* 1.0.8rc1 1 10008 2.1.0.8rc1 |
* 1.0.8 1 10008 2.1.0.8 |
* 1.0.9beta1-6 1 10009 2.1.0.9beta1-6 |
* 1.0.9rc1 1 10009 2.1.0.9rc1 |
* 1.0.9beta7-10 1 10009 2.1.0.9beta7-10 |
* 1.0.9rc2 1 10009 2.1.0.9rc2 |
* 1.0.9 1 10009 2.1.0.9 |
* 1.0.10beta1 1 10010 2.1.0.10beta1 |
* 1.0.10rc1 1 10010 2.1.0.10rc1 |
* 1.0.10 1 10010 2.1.0.10 |
* 1.0.11beta1-3 1 10011 2.1.0.11beta1-3 |
* 1.0.11rc1 1 10011 2.1.0.11rc1 |
* 1.0.11 1 10011 2.1.0.11 |
* 1.0.12beta1-2 2 10012 2.1.0.12beta1-2 |
* 1.0.12rc1 2 10012 2.1.0.12rc1 |
* 1.0.12 2 10012 2.1.0.12 |
* 1.1.0a-f - 10100 2.1.1.0a-f (branch abandoned) |
* 1.2.0beta1-2 2 10200 2.1.2.0beta1-2 |
* 1.2.0beta3-5 3 10200 3.1.2.0beta3-5 |
* 1.2.0rc1 3 10200 3.1.2.0rc1 |
* 1.2.0 3 10200 3.1.2.0 |
* 1.2.1beta1-4 3 10201 3.1.2.1beta1-4 |
* 1.2.1rc1-2 3 10201 3.1.2.1rc1-2 |
* 1.2.1 3 10201 3.1.2.1 |
* 1.2.2beta1-6 12 10202 12.so.0.1.2.2beta1-6 |
* 1.0.13beta1 10 10013 10.so.0.1.0.13beta1 |
* 1.0.13rc1 10 10013 10.so.0.1.0.13rc1 |
* 1.2.2rc1 12 10202 12.so.0.1.2.2rc1 |
* 1.0.13 10 10013 10.so.0.1.0.13 |
* 1.2.2 12 10202 12.so.0.1.2.2 |
* 1.2.3rc1-6 12 10203 12.so.0.1.2.3rc1-6 |
* 1.2.3 12 10203 12.so.0.1.2.3 |
* 1.2.4beta1-3 13 10204 12.so.0.1.2.4beta1-3 |
* 1.0.14rc1 13 10014 10.so.0.1.0.14rc1 |
* 1.2.4rc1 13 10204 12.so.0.1.2.4rc1 |
* 1.0.14 10 10014 10.so.0.1.0.14 |
* 1.2.4 13 10204 12.so.0.1.2.4 |
* 1.2.5beta1-2 13 10205 12.so.0.1.2.5beta1-2 |
* 1.0.15rc1-3 10 10015 10.so.0.1.0.15rc1-3 |
* 1.2.5rc1-3 13 10205 12.so.0.1.2.5rc1-3 |
* 1.0.15 10 10015 10.so.0.1.0.15 |
* 1.2.5 13 10205 12.so.0.1.2.5 |
* |
* Henceforth the source version will match the shared-library major |
* and minor numbers; the shared-library major version number will be |
* used for changes in backward compatibility, as it is intended. The |
* PNG_LIBPNG_VER macro, which is not used within libpng but is available |
* for applications, is an unsigned integer of the form xyyzz corresponding |
* to the source version x.y.z (leading zeros in y and z). Beta versions |
* were given the previous public release number plus a letter, until |
* version 1.0.6j; from then on they were given the upcoming public |
* release number plus "betaNN" or "rcN". |
* |
* Binary incompatibility exists only when applications make direct access |
* to the info_ptr or png_ptr members through png.h, and the compiled |
* application is loaded with a different version of the library. |
* |
* DLLNUM will change each time there are forward or backward changes |
* in binary compatibility (e.g., when a new feature is added). |
* |
* See libpng.txt or libpng.3 for more information. The PNG specification |
* is available as RFC 2083 <ftp://ftp.uu.net/graphics/png/documents/> |
* and as a W3C Recommendation <http://www.w3.org/TR/REC.png.html> |
*/ |
/* |
* COPYRIGHT NOTICE, DISCLAIMER, and LICENSE: |
* |
* If you modify libpng you may insert additional notices immediately following |
* this sentence. |
* |
* libpng versions 1.0.7, July 1, 2000, through 1.2.5, October 3, 2002, are |
* Copyright (c) 2000-2002 Glenn Randers-Pehrson, and are |
* distributed according to the same disclaimer and license as libpng-1.0.6 |
* with the following individuals added to the list of Contributing Authors |
* |
* Simon-Pierre Cadieux |
* Eric S. Raymond |
* Gilles Vollant |
* |
* and with the following additions to the disclaimer: |
* |
* There is no warranty against interference with your enjoyment of the |
* library or against infringement. There is no warranty that our |
* efforts or the library will fulfill any of your particular purposes |
* or needs. This library is provided with all faults, and the entire |
* risk of satisfactory quality, performance, accuracy, and effort is with |
* the user. |
* |
* libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are |
* Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson |
* Distributed according to the same disclaimer and license as libpng-0.96, |
* with the following individuals added to the list of Contributing Authors: |
* |
* Tom Lane |
* Glenn Randers-Pehrson |
* Willem van Schaik |
* |
* libpng versions 0.89, June 1996, through 0.96, May 1997, are |
* Copyright (c) 1996, 1997 Andreas Dilger |
* Distributed according to the same disclaimer and license as libpng-0.88, |
* with the following individuals added to the list of Contributing Authors: |
* |
* John Bowler |
* Kevin Bracey |
* Sam Bushell |
* Magnus Holmgren |
* Greg Roelofs |
* Tom Tanner |
* |
* libpng versions 0.5, May 1995, through 0.88, January 1996, are |
* Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc. |
* |
* For the purposes of this copyright and license, "Contributing Authors" |
* is defined as the following set of individuals: |
* |
* Andreas Dilger |
* Dave Martindale |
* Guy Eric Schalnat |
* Paul Schmidt |
* Tim Wegner |
* |
* The PNG Reference Library is supplied "AS IS". The Contributing Authors |
* and Group 42, Inc. disclaim all warranties, expressed or implied, |
* including, without limitation, the warranties of merchantability and of |
* fitness for any purpose. The Contributing Authors and Group 42, Inc. |
* assume no liability for direct, indirect, incidental, special, exemplary, |
* or consequential damages, which may result from the use of the PNG |
* Reference Library, even if advised of the possibility of such damage. |
* |
* Permission is hereby granted to use, copy, modify, and distribute this |
* source code, or portions hereof, for any purpose, without fee, subject |
* to the following restrictions: |
* |
* 1. The origin of this source code must not be misrepresented. |
* |
* 2. Altered versions must be plainly marked as such and |
* must not be misrepresented as being the original source. |
* |
* 3. This Copyright notice may not be removed or altered from |
* any source or altered source distribution. |
* |
* The Contributing Authors and Group 42, Inc. specifically permit, without |
* fee, and encourage the use of this source code as a component to |
* supporting the PNG file format in commercial products. If you use this |
* source code in a product, acknowledgment is not required but would be |
* appreciated. |
*/ |
/* |
* A "png_get_copyright" function is available, for convenient use in "about" |
* boxes and the like: |
* |
* printf("%s",png_get_copyright(NULL)); |
* |
* Also, the PNG logo (in PNG format, of course) is supplied in the |
* files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31). |
*/ |
/* |
* Libpng is OSI Certified Open Source Software. OSI Certified is a |
* certification mark of the Open Source Initiative. |
*/ |
/* |
* The contributing authors would like to thank all those who helped |
* with testing, bug fixes, and patience. This wouldn't have been |
* possible without all of you. |
* |
* Thanks to Frank J. T. Wojcik for helping with the documentation. |
*/ |
/* |
* Y2K compliance in libpng: |
* ========================= |
* |
* October 3, 2002 |
* |
* Since the PNG Development group is an ad-hoc body, we can't make |
* an official declaration. |
* |
* This is your unofficial assurance that libpng from version 0.71 and |
* upward through 1.2.5 are Y2K compliant. It is my belief that earlier |
* versions were also Y2K compliant. |
* |
* Libpng only has three year fields. One is a 2-byte unsigned integer |
* that will hold years up to 65535. The other two hold the date in text |
* format, and will hold years up to 9999. |
* |
* The integer is |
* "png_uint_16 year" in png_time_struct. |
* |
* The strings are |
* "png_charp time_buffer" in png_struct and |
* "near_time_buffer", which is a local character string in png.c. |
* |
* There are seven time-related functions: |
* png.c: png_convert_to_rfc_1123() in png.c |
* (formerly png_convert_to_rfc_1152() in error) |
* png_convert_from_struct_tm() in pngwrite.c, called in pngwrite.c |
* png_convert_from_time_t() in pngwrite.c |
* png_get_tIME() in pngget.c |
* png_handle_tIME() in pngrutil.c, called in pngread.c |
* png_set_tIME() in pngset.c |
* png_write_tIME() in pngwutil.c, called in pngwrite.c |
* |
* All handle dates properly in a Y2K environment. The |
* png_convert_from_time_t() function calls gmtime() to convert from system |
* clock time, which returns (year - 1900), which we properly convert to |
* the full 4-digit year. There is a possibility that applications using |
* libpng are not passing 4-digit years into the png_convert_to_rfc_1123() |
* function, or that they are incorrectly passing only a 2-digit year |
* instead of "year - 1900" into the png_convert_from_struct_tm() function, |
* but this is not under our control. The libpng documentation has always |
* stated that it works with 4-digit years, and the APIs have been |
* documented as such. |
* |
* The tIME chunk itself is also Y2K compliant. It uses a 2-byte unsigned |
* integer to hold the year, and can hold years as large as 65535. |
* |
* zlib, upon which libpng depends, is also Y2K compliant. It contains |
* no date-related code. |
* |
* Glenn Randers-Pehrson |
* libpng maintainer |
* PNG Development Group |
*/ |
#ifndef PNG_H |
#define PNG_H |
/* This is not the place to learn how to use libpng. The file libpng.txt |
* describes how to use libpng, and the file example.c summarizes it |
* with some code on which to build. This file is useful for looking |
* at the actual function definitions and structure components. |
*/ |
/* Version information for png.h - this should match the version in png.c */ |
#define PNG_LIBPNG_VER_STRING "1.2.5" |
#define PNG_LIBPNG_VER_SONUM 0 |
#define PNG_LIBPNG_VER_DLLNUM %DLLNUM% |
/* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */ |
#define PNG_LIBPNG_VER_MAJOR 1 |
#define PNG_LIBPNG_VER_MINOR 2 |
#define PNG_LIBPNG_VER_RELEASE 5 |
/* This should match the numeric part of the final component of |
* PNG_LIBPNG_VER_STRING, omitting any leading zero: */ |
#define PNG_LIBPNG_VER_BUILD 0 |
#define PNG_LIBPNG_BUILD_ALPHA 1 |
#define PNG_LIBPNG_BUILD_BETA 2 |
#define PNG_LIBPNG_BUILD_RC 3 |
#define PNG_LIBPNG_BUILD_STABLE 4 |
#define PNG_LIBPNG_BUILD_TYPEMASK 7 |
#define PNG_LIBPNG_BUILD_PATCH 8 /* Can be OR'ed with STABLE only */ |
#define PNG_LIBPNG_BUILD_TYPE 4 |
/* Careful here. At one time, Guy wanted to use 082, but that would be octal. |
* We must not include leading zeros. |
* Versions 0.7 through 1.0.0 were in the range 0 to 100 here (only |
* version 1.0.0 was mis-numbered 100 instead of 10000). From |
* version 1.0.1 it's xxyyzz, where x=major, y=minor, z=release */ |
#define PNG_LIBPNG_VER 10205 /* 1.2.5 */ |
#ifndef PNG_VERSION_INFO_ONLY |
/* include the compression library's header */ |
#include "zlib.h" |
/* include all user configurable info, including optional assembler routines */ |
#include "pngconf.h" |
/* Inhibit C++ name-mangling for libpng functions but not for system calls. */ |
#ifdef __cplusplus |
extern "C" { |
#endif /* __cplusplus */ |
/* This file is arranged in several sections. The first section contains |
* structure and type definitions. The second section contains the external |
* library functions, while the third has the internal library functions, |
* which applications aren't expected to use directly. |
*/ |
#ifndef PNG_NO_TYPECAST_NULL |
#define int_p_NULL (int *)NULL |
#define png_bytep_NULL (png_bytep)NULL |
#define png_bytepp_NULL (png_bytepp)NULL |
#define png_doublep_NULL (png_doublep)NULL |
#define png_error_ptr_NULL (png_error_ptr)NULL |
#define png_flush_ptr_NULL (png_flush_ptr)NULL |
#define png_free_ptr_NULL (png_free_ptr)NULL |
#define png_infopp_NULL (png_infopp)NULL |
#define png_malloc_ptr_NULL (png_malloc_ptr)NULL |
#define png_read_status_ptr_NULL (png_read_status_ptr)NULL |
#define png_rw_ptr_NULL (png_rw_ptr)NULL |
#define png_structp_NULL (png_structp)NULL |
#define png_uint_16p_NULL (png_uint_16p)NULL |
#define png_voidp_NULL (png_voidp)NULL |
#define png_write_status_ptr_NULL (png_write_status_ptr)NULL |
#else |
#define int_p_NULL NULL |
#define png_bytep_NULL NULL |
#define png_bytepp_NULL NULL |
#define png_doublep_NULL NULL |
#define png_error_ptr_NULL NULL |
#define png_flush_ptr_NULL NULL |
#define png_free_ptr_NULL NULL |
#define png_infopp_NULL NULL |
#define png_malloc_ptr_NULL NULL |
#define png_read_status_ptr_NULL NULL |
#define png_rw_ptr_NULL NULL |
#define png_structp_NULL NULL |
#define png_uint_16p_NULL NULL |
#define png_voidp_NULL NULL |
#define png_write_status_ptr_NULL NULL |
#endif |
/* variables declared in png.c - only it needs to define PNG_NO_EXTERN */ |
#if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN) |
/* Version information for C files, stored in png.c. This had better match |
* the version above. |
*/ |
#ifdef PNG_USE_GLOBAL_ARRAYS |
PNG_EXPORT_VAR (const char) png_libpng_ver[18]; |
/* need room for 99.99.99beta99z */ |
#else |
#define png_libpng_ver png_get_header_ver(NULL) |
#endif |
#ifdef PNG_USE_GLOBAL_ARRAYS |
/* This was removed in version 1.0.5c */ |
/* Structures to facilitate easy interlacing. See png.c for more details */ |
PNG_EXPORT_VAR (const int FARDATA) png_pass_start[7]; |
PNG_EXPORT_VAR (const int FARDATA) png_pass_inc[7]; |
PNG_EXPORT_VAR (const int FARDATA) png_pass_ystart[7]; |
PNG_EXPORT_VAR (const int FARDATA) png_pass_yinc[7]; |
PNG_EXPORT_VAR (const int FARDATA) png_pass_mask[7]; |
PNG_EXPORT_VAR (const int FARDATA) png_pass_dsp_mask[7]; |
#ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW |
PNG_EXPORT_VAR (const int FARDATA) png_pass_width[7]; |
#endif |
/* This isn't currently used. If you need it, see png.c for more details. |
PNG_EXPORT_VAR (const int FARDATA) png_pass_height[7]; |
*/ |
#endif |
#endif /* PNG_NO_EXTERN */ |
/* Three color definitions. The order of the red, green, and blue, (and the |
* exact size) is not important, although the size of the fields need to |
* be png_byte or png_uint_16 (as defined below). |
*/ |
typedef struct png_color_struct |
{ |
png_byte red; |
png_byte green; |
png_byte blue; |
} png_color; |
typedef png_color FAR * png_colorp; |
typedef png_color FAR * FAR * png_colorpp; |
typedef struct png_color_16_struct |
{ |
png_byte index; /* used for palette files */ |
png_uint_16 red; /* for use in red green blue files */ |
png_uint_16 green; |
png_uint_16 blue; |
png_uint_16 gray; /* for use in grayscale files */ |
} png_color_16; |
typedef png_color_16 FAR * png_color_16p; |
typedef png_color_16 FAR * FAR * png_color_16pp; |
typedef struct png_color_8_struct |
{ |
png_byte red; /* for use in red green blue files */ |
png_byte green; |
png_byte blue; |
png_byte gray; /* for use in grayscale files */ |
png_byte alpha; /* for alpha channel files */ |
} png_color_8; |
typedef png_color_8 FAR * png_color_8p; |
typedef png_color_8 FAR * FAR * png_color_8pp; |
/* |
* The following two structures are used for the in-core representation |
* of sPLT chunks. |
*/ |
typedef struct png_sPLT_entry_struct |
{ |
png_uint_16 red; |
png_uint_16 green; |
png_uint_16 blue; |
png_uint_16 alpha; |
png_uint_16 frequency; |
} png_sPLT_entry; |
typedef png_sPLT_entry FAR * png_sPLT_entryp; |
typedef png_sPLT_entry FAR * FAR * png_sPLT_entrypp; |
/* When the depth of the sPLT palette is 8 bits, the color and alpha samples |
* occupy the LSB of their respective members, and the MSB of each member |
* is zero-filled. The frequency member always occupies the full 16 bits. |
*/ |
typedef struct png_sPLT_struct |
{ |
png_charp name; /* palette name */ |
png_byte depth; /* depth of palette samples */ |
png_sPLT_entryp entries; /* palette entries */ |
png_int_32 nentries; /* number of palette entries */ |
} png_sPLT_t; |
typedef png_sPLT_t FAR * png_sPLT_tp; |
typedef png_sPLT_t FAR * FAR * png_sPLT_tpp; |
#ifdef PNG_TEXT_SUPPORTED |
/* png_text holds the contents of a text/ztxt/itxt chunk in a PNG file, |
* and whether that contents is compressed or not. The "key" field |
* points to a regular zero-terminated C string. The "text", "lang", and |
* "lang_key" fields can be regular C strings, empty strings, or NULL pointers. |
* However, the * structure returned by png_get_text() will always contain |
* regular zero-terminated C strings (possibly empty), never NULL pointers, |
* so they can be safely used in printf() and other string-handling functions. |
*/ |
typedef struct png_text_struct |
{ |
int compression; /* compression value: |
-1: tEXt, none |
0: zTXt, deflate |
1: iTXt, none |
2: iTXt, deflate */ |
png_charp key; /* keyword, 1-79 character description of "text" */ |
png_charp text; /* comment, may be an empty string (ie "") |
or a NULL pointer */ |
png_size_t text_length; /* length of the text string */ |
#ifdef PNG_iTXt_SUPPORTED |
png_size_t itxt_length; /* length of the itxt string */ |
png_charp lang; /* language code, 0-79 characters |
or a NULL pointer */ |
png_charp lang_key; /* keyword translated UTF-8 string, 0 or more |
chars or a NULL pointer */ |
#endif |
} png_text; |
typedef png_text FAR * png_textp; |
typedef png_text FAR * FAR * png_textpp; |
#endif |
/* Supported compression types for text in PNG files (tEXt, and zTXt). |
* The values of the PNG_TEXT_COMPRESSION_ defines should NOT be changed. */ |
#define PNG_TEXT_COMPRESSION_NONE_WR -3 |
#define PNG_TEXT_COMPRESSION_zTXt_WR -2 |
#define PNG_TEXT_COMPRESSION_NONE -1 |
#define PNG_TEXT_COMPRESSION_zTXt 0 |
#define PNG_ITXT_COMPRESSION_NONE 1 |
#define PNG_ITXT_COMPRESSION_zTXt 2 |
#define PNG_TEXT_COMPRESSION_LAST 3 /* Not a valid value */ |
/* png_time is a way to hold the time in an machine independent way. |
* Two conversions are provided, both from time_t and struct tm. There |
* is no portable way to convert to either of these structures, as far |
* as I know. If you know of a portable way, send it to me. As a side |
* note - PNG has always been Year 2000 compliant! |
*/ |
typedef struct png_time_struct |
{ |
png_uint_16 year; /* full year, as in, 1995 */ |
png_byte month; /* month of year, 1 - 12 */ |
png_byte day; /* day of month, 1 - 31 */ |
png_byte hour; /* hour of day, 0 - 23 */ |
png_byte minute; /* minute of hour, 0 - 59 */ |
png_byte second; /* second of minute, 0 - 60 (for leap seconds) */ |
} png_time; |
typedef png_time FAR * png_timep; |
typedef png_time FAR * FAR * png_timepp; |
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) |
/* png_unknown_chunk is a structure to hold queued chunks for which there is |
* no specific support. The idea is that we can use this to queue |
* up private chunks for output even though the library doesn't actually |
* know about their semantics. |
*/ |
typedef struct png_unknown_chunk_t |
{ |
png_byte name[5]; |
png_byte *data; |
png_size_t size; |
/* libpng-using applications should NOT directly modify this byte. */ |
png_byte location; /* mode of operation at read time */ |
} |
png_unknown_chunk; |
typedef png_unknown_chunk FAR * png_unknown_chunkp; |
typedef png_unknown_chunk FAR * FAR * png_unknown_chunkpp; |
#endif |
/* png_info is a structure that holds the information in a PNG file so |
* that the application can find out the characteristics of the image. |
* If you are reading the file, this structure will tell you what is |
* in the PNG file. If you are writing the file, fill in the information |
* you want to put into the PNG file, then call png_write_info(). |
* The names chosen should be very close to the PNG specification, so |
* consult that document for information about the meaning of each field. |
* |
* With libpng < 0.95, it was only possible to directly set and read the |
* the values in the png_info_struct, which meant that the contents and |
* order of the values had to remain fixed. With libpng 0.95 and later, |
* however, there are now functions that abstract the contents of |
* png_info_struct from the application, so this makes it easier to use |
* libpng with dynamic libraries, and even makes it possible to use |
* libraries that don't have all of the libpng ancillary chunk-handing |
* functionality. |
* |
* In any case, the order of the parameters in png_info_struct should NOT |
* be changed for as long as possible to keep compatibility with applications |
* that use the old direct-access method with png_info_struct. |
* |
* The following members may have allocated storage attached that should be |
* cleaned up before the structure is discarded: palette, trans, text, |
* pcal_purpose, pcal_units, pcal_params, hist, iccp_name, iccp_profile, |
* splt_palettes, scal_unit, row_pointers, and unknowns. By default, these |
* are automatically freed when the info structure is deallocated, if they were |
* allocated internally by libpng. This behavior can be changed by means |
* of the png_data_freer() function. |
* |
* More allocation details: all the chunk-reading functions that |
* change these members go through the corresponding png_set_* |
* functions. A function to clear these members is available: see |
* png_free_data(). The png_set_* functions do not depend on being |
* able to point info structure members to any of the storage they are |
* passed (they make their own copies), EXCEPT that the png_set_text |
* functions use the same storage passed to them in the text_ptr or |
* itxt_ptr structure argument, and the png_set_rows and png_set_unknowns |
* functions do not make their own copies. |
*/ |
typedef struct png_info_struct |
{ |
/* the following are necessary for every PNG file */ |
png_uint_32 width; /* width of image in pixels (from IHDR) */ |
png_uint_32 height; /* height of image in pixels (from IHDR) */ |
png_uint_32 valid; /* valid chunk data (see PNG_INFO_ below) */ |
png_uint_32 rowbytes; /* bytes needed to hold an untransformed row */ |
png_colorp palette; /* array of color values (valid & PNG_INFO_PLTE) */ |
png_uint_16 num_palette; /* number of color entries in "palette" (PLTE) */ |
png_uint_16 num_trans; /* number of transparent palette color (tRNS) */ |
png_byte bit_depth; /* 1, 2, 4, 8, or 16 bits/channel (from IHDR) */ |
png_byte color_type; /* see PNG_COLOR_TYPE_ below (from IHDR) */ |
/* The following three should have been named *_method not *_type */ |
png_byte compression_type; /* must be PNG_COMPRESSION_TYPE_BASE (IHDR) */ |
png_byte filter_type; /* must be PNG_FILTER_TYPE_BASE (from IHDR) */ |
png_byte interlace_type; /* One of PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */ |
/* The following is informational only on read, and not used on writes. */ |
png_byte channels; /* number of data channels per pixel (1, 2, 3, 4) */ |
png_byte pixel_depth; /* number of bits per pixel */ |
png_byte spare_byte; /* to align the data, and for future use */ |
png_byte signature[8]; /* magic bytes read by libpng from start of file */ |
/* The rest of the data is optional. If you are reading, check the |
* valid field to see if the information in these are valid. If you |
* are writing, set the valid field to those chunks you want written, |
* and initialize the appropriate fields below. |
*/ |
#if defined(PNG_gAMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED) |
/* The gAMA chunk describes the gamma characteristics of the system |
* on which the image was created, normally in the range [1.0, 2.5]. |
* Data is valid if (valid & PNG_INFO_gAMA) is non-zero. |
*/ |
float gamma; /* gamma value of image, if (valid & PNG_INFO_gAMA) */ |
#endif |
#if defined(PNG_sRGB_SUPPORTED) |
/* GR-P, 0.96a */ |
/* Data valid if (valid & PNG_INFO_sRGB) non-zero. */ |
png_byte srgb_intent; /* sRGB rendering intent [0, 1, 2, or 3] */ |
#endif |
#if defined(PNG_TEXT_SUPPORTED) |
/* The tEXt, and zTXt chunks contain human-readable textual data in |
* uncompressed, compressed, and optionally compressed forms, respectively. |
* The data in "text" is an array of pointers to uncompressed, |
* null-terminated C strings. Each chunk has a keyword that describes the |
* textual data contained in that chunk. Keywords are not required to be |
* unique, and the text string may be empty. Any number of text chunks may |
* be in an image. |
*/ |
int num_text; /* number of comments read/to write */ |
int max_text; /* current size of text array */ |
png_textp text; /* array of comments read/to write */ |
#endif /* PNG_TEXT_SUPPORTED */ |
#if defined(PNG_tIME_SUPPORTED) |
/* The tIME chunk holds the last time the displayed image data was |
* modified. See the png_time struct for the contents of this struct. |
*/ |
png_time mod_time; |
#endif |
#if defined(PNG_sBIT_SUPPORTED) |
/* The sBIT chunk specifies the number of significant high-order bits |
* in the pixel data. Values are in the range [1, bit_depth], and are |
* only specified for the channels in the pixel data. The contents of |
* the low-order bits is not specified. Data is valid if |
* (valid & PNG_INFO_sBIT) is non-zero. |
*/ |
png_color_8 sig_bit; /* significant bits in color channels */ |
#endif |
#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_EXPAND_SUPPORTED) || \ |
defined(PNG_READ_BACKGROUND_SUPPORTED) |
/* The tRNS chunk supplies transparency data for paletted images and |
* other image types that don't need a full alpha channel. There are |
* "num_trans" transparency values for a paletted image, stored in the |
* same order as the palette colors, starting from index 0. Values |
* for the data are in the range [0, 255], ranging from fully transparent |
* to fully opaque, respectively. For non-paletted images, there is a |
* single color specified that should be treated as fully transparent. |
* Data is valid if (valid & PNG_INFO_tRNS) is non-zero. |
*/ |
png_bytep trans; /* transparent values for paletted image */ |
png_color_16 trans_values; /* transparent color for non-palette image */ |
#endif |
#if defined(PNG_bKGD_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
/* The bKGD chunk gives the suggested image background color if the |
* display program does not have its own background color and the image |
* is needs to composited onto a background before display. The colors |
* in "background" are normally in the same color space/depth as the |
* pixel data. Data is valid if (valid & PNG_INFO_bKGD) is non-zero. |
*/ |
png_color_16 background; |
#endif |
#if defined(PNG_oFFs_SUPPORTED) |
/* The oFFs chunk gives the offset in "offset_unit_type" units rightwards |
* and downwards from the top-left corner of the display, page, or other |
* application-specific co-ordinate space. See the PNG_OFFSET_ defines |
* below for the unit types. Valid if (valid & PNG_INFO_oFFs) non-zero. |
*/ |
png_int_32 x_offset; /* x offset on page */ |
png_int_32 y_offset; /* y offset on page */ |
png_byte offset_unit_type; /* offset units type */ |
#endif |
#if defined(PNG_pHYs_SUPPORTED) |
/* The pHYs chunk gives the physical pixel density of the image for |
* display or printing in "phys_unit_type" units (see PNG_RESOLUTION_ |
* defines below). Data is valid if (valid & PNG_INFO_pHYs) is non-zero. |
*/ |
png_uint_32 x_pixels_per_unit; /* horizontal pixel density */ |
png_uint_32 y_pixels_per_unit; /* vertical pixel density */ |
png_byte phys_unit_type; /* resolution type (see PNG_RESOLUTION_ below) */ |
#endif |
#if defined(PNG_hIST_SUPPORTED) |
/* The hIST chunk contains the relative frequency or importance of the |
* various palette entries, so that a viewer can intelligently select a |
* reduced-color palette, if required. Data is an array of "num_palette" |
* values in the range [0,65535]. Data valid if (valid & PNG_INFO_hIST) |
* is non-zero. |
*/ |
png_uint_16p hist; |
#endif |
#ifdef PNG_cHRM_SUPPORTED |
/* The cHRM chunk describes the CIE color characteristics of the monitor |
* on which the PNG was created. This data allows the viewer to do gamut |
* mapping of the input image to ensure that the viewer sees the same |
* colors in the image as the creator. Values are in the range |
* [0.0, 0.8]. Data valid if (valid & PNG_INFO_cHRM) non-zero. |
*/ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
float x_white; |
float y_white; |
float x_red; |
float y_red; |
float x_green; |
float y_green; |
float x_blue; |
float y_blue; |
#endif |
#endif |
#if defined(PNG_pCAL_SUPPORTED) |
/* The pCAL chunk describes a transformation between the stored pixel |
* values and original physical data values used to create the image. |
* The integer range [0, 2^bit_depth - 1] maps to the floating-point |
* range given by [pcal_X0, pcal_X1], and are further transformed by a |
* (possibly non-linear) transformation function given by "pcal_type" |
* and "pcal_params" into "pcal_units". Please see the PNG_EQUATION_ |
* defines below, and the PNG-Group's PNG extensions document for a |
* complete description of the transformations and how they should be |
* implemented, and for a description of the ASCII parameter strings. |
* Data values are valid if (valid & PNG_INFO_pCAL) non-zero. |
*/ |
png_charp pcal_purpose; /* pCAL chunk description string */ |
png_int_32 pcal_X0; /* minimum value */ |
png_int_32 pcal_X1; /* maximum value */ |
png_charp pcal_units; /* Latin-1 string giving physical units */ |
png_charpp pcal_params; /* ASCII strings containing parameter values */ |
png_byte pcal_type; /* equation type (see PNG_EQUATION_ below) */ |
png_byte pcal_nparams; /* number of parameters given in pcal_params */ |
#endif |
/* New members added in libpng-1.0.6 */ |
#ifdef PNG_FREE_ME_SUPPORTED |
png_uint_32 free_me; /* flags items libpng is responsible for freeing */ |
#endif |
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) |
/* storage for unknown chunks that the library doesn't recognize. */ |
png_unknown_chunkp unknown_chunks; |
png_size_t unknown_chunks_num; |
#endif |
#if defined(PNG_iCCP_SUPPORTED) |
/* iCCP chunk data. */ |
png_charp iccp_name; /* profile name */ |
png_charp iccp_profile; /* International Color Consortium profile data */ |
/* Note to maintainer: should be png_bytep */ |
png_uint_32 iccp_proflen; /* ICC profile data length */ |
png_byte iccp_compression; /* Always zero */ |
#endif |
#if defined(PNG_sPLT_SUPPORTED) |
/* data on sPLT chunks (there may be more than one). */ |
png_sPLT_tp splt_palettes; |
png_uint_32 splt_palettes_num; |
#endif |
#if defined(PNG_sCAL_SUPPORTED) |
/* The sCAL chunk describes the actual physical dimensions of the |
* subject matter of the graphic. The chunk contains a unit specification |
* a byte value, and two ASCII strings representing floating-point |
* values. The values are width and height corresponsing to one pixel |
* in the image. This external representation is converted to double |
* here. Data values are valid if (valid & PNG_INFO_sCAL) is non-zero. |
*/ |
png_byte scal_unit; /* unit of physical scale */ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
double scal_pixel_width; /* width of one pixel */ |
double scal_pixel_height; /* height of one pixel */ |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
png_charp scal_s_width; /* string containing height */ |
png_charp scal_s_height; /* string containing width */ |
#endif |
#endif |
#if defined(PNG_INFO_IMAGE_SUPPORTED) |
/* Memory has been allocated if (valid & PNG_ALLOCATED_INFO_ROWS) non-zero */ |
/* Data valid if (valid & PNG_INFO_IDAT) non-zero */ |
png_bytepp row_pointers; /* the image bits */ |
#endif |
#if defined(PNG_FIXED_POINT_SUPPORTED) && defined(PNG_gAMA_SUPPORTED) |
png_fixed_point int_gamma; /* gamma of image, if (valid & PNG_INFO_gAMA) */ |
#endif |
#if defined(PNG_cHRM_SUPPORTED) && defined(PNG_FIXED_POINT_SUPPORTED) |
png_fixed_point int_x_white; |
png_fixed_point int_y_white; |
png_fixed_point int_x_red; |
png_fixed_point int_y_red; |
png_fixed_point int_x_green; |
png_fixed_point int_y_green; |
png_fixed_point int_x_blue; |
png_fixed_point int_y_blue; |
#endif |
} png_info; |
typedef png_info FAR * png_infop; |
typedef png_info FAR * FAR * png_infopp; |
/* Maximum positive integer used in PNG is (2^31)-1 */ |
#define PNG_MAX_UINT ((png_uint_32)0x7fffffffL) |
/* These describe the color_type field in png_info. */ |
/* color type masks */ |
#define PNG_COLOR_MASK_PALETTE 1 |
#define PNG_COLOR_MASK_COLOR 2 |
#define PNG_COLOR_MASK_ALPHA 4 |
/* color types. Note that not all combinations are legal */ |
#define PNG_COLOR_TYPE_GRAY 0 |
#define PNG_COLOR_TYPE_PALETTE (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE) |
#define PNG_COLOR_TYPE_RGB (PNG_COLOR_MASK_COLOR) |
#define PNG_COLOR_TYPE_RGB_ALPHA (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA) |
#define PNG_COLOR_TYPE_GRAY_ALPHA (PNG_COLOR_MASK_ALPHA) |
/* aliases */ |
#define PNG_COLOR_TYPE_RGBA PNG_COLOR_TYPE_RGB_ALPHA |
#define PNG_COLOR_TYPE_GA PNG_COLOR_TYPE_GRAY_ALPHA |
/* This is for compression type. PNG 1.0-1.2 only define the single type. */ |
#define PNG_COMPRESSION_TYPE_BASE 0 /* Deflate method 8, 32K window */ |
#define PNG_COMPRESSION_TYPE_DEFAULT PNG_COMPRESSION_TYPE_BASE |
/* This is for filter type. PNG 1.0-1.2 only define the single type. */ |
#define PNG_FILTER_TYPE_BASE 0 /* Single row per-byte filtering */ |
#define PNG_INTRAPIXEL_DIFFERENCING 64 /* Used only in MNG datastreams */ |
#define PNG_FILTER_TYPE_DEFAULT PNG_FILTER_TYPE_BASE |
/* These are for the interlacing type. These values should NOT be changed. */ |
#define PNG_INTERLACE_NONE 0 /* Non-interlaced image */ |
#define PNG_INTERLACE_ADAM7 1 /* Adam7 interlacing */ |
#define PNG_INTERLACE_LAST 2 /* Not a valid value */ |
/* These are for the oFFs chunk. These values should NOT be changed. */ |
#define PNG_OFFSET_PIXEL 0 /* Offset in pixels */ |
#define PNG_OFFSET_MICROMETER 1 /* Offset in micrometers (1/10^6 meter) */ |
#define PNG_OFFSET_LAST 2 /* Not a valid value */ |
/* These are for the pCAL chunk. These values should NOT be changed. */ |
#define PNG_EQUATION_LINEAR 0 /* Linear transformation */ |
#define PNG_EQUATION_BASE_E 1 /* Exponential base e transform */ |
#define PNG_EQUATION_ARBITRARY 2 /* Arbitrary base exponential transform */ |
#define PNG_EQUATION_HYPERBOLIC 3 /* Hyperbolic sine transformation */ |
#define PNG_EQUATION_LAST 4 /* Not a valid value */ |
/* These are for the sCAL chunk. These values should NOT be changed. */ |
#define PNG_SCALE_UNKNOWN 0 /* unknown unit (image scale) */ |
#define PNG_SCALE_METER 1 /* meters per pixel */ |
#define PNG_SCALE_RADIAN 2 /* radians per pixel */ |
#define PNG_SCALE_LAST 3 /* Not a valid value */ |
/* These are for the pHYs chunk. These values should NOT be changed. */ |
#define PNG_RESOLUTION_UNKNOWN 0 /* pixels/unknown unit (aspect ratio) */ |
#define PNG_RESOLUTION_METER 1 /* pixels/meter */ |
#define PNG_RESOLUTION_LAST 2 /* Not a valid value */ |
/* These are for the sRGB chunk. These values should NOT be changed. */ |
#define PNG_sRGB_INTENT_PERCEPTUAL 0 |
#define PNG_sRGB_INTENT_RELATIVE 1 |
#define PNG_sRGB_INTENT_SATURATION 2 |
#define PNG_sRGB_INTENT_ABSOLUTE 3 |
#define PNG_sRGB_INTENT_LAST 4 /* Not a valid value */ |
/* This is for text chunks */ |
#define PNG_KEYWORD_MAX_LENGTH 79 |
/* Maximum number of entries in PLTE/sPLT/tRNS arrays */ |
#define PNG_MAX_PALETTE_LENGTH 256 |
/* These determine if an ancillary chunk's data has been successfully read |
* from the PNG header, or if the application has filled in the corresponding |
* data in the info_struct to be written into the output file. The values |
* of the PNG_INFO_<chunk> defines should NOT be changed. |
*/ |
#define PNG_INFO_gAMA 0x0001 |
#define PNG_INFO_sBIT 0x0002 |
#define PNG_INFO_cHRM 0x0004 |
#define PNG_INFO_PLTE 0x0008 |
#define PNG_INFO_tRNS 0x0010 |
#define PNG_INFO_bKGD 0x0020 |
#define PNG_INFO_hIST 0x0040 |
#define PNG_INFO_pHYs 0x0080 |
#define PNG_INFO_oFFs 0x0100 |
#define PNG_INFO_tIME 0x0200 |
#define PNG_INFO_pCAL 0x0400 |
#define PNG_INFO_sRGB 0x0800 /* GR-P, 0.96a */ |
#define PNG_INFO_iCCP 0x1000 /* ESR, 1.0.6 */ |
#define PNG_INFO_sPLT 0x2000 /* ESR, 1.0.6 */ |
#define PNG_INFO_sCAL 0x4000 /* ESR, 1.0.6 */ |
#define PNG_INFO_IDAT 0x8000L /* ESR, 1.0.6 */ |
/* This is used for the transformation routines, as some of them |
* change these values for the row. It also should enable using |
* the routines for other purposes. |
*/ |
typedef struct png_row_info_struct |
{ |
png_uint_32 width; /* width of row */ |
png_uint_32 rowbytes; /* number of bytes in row */ |
png_byte color_type; /* color type of row */ |
png_byte bit_depth; /* bit depth of row */ |
png_byte channels; /* number of channels (1, 2, 3, or 4) */ |
png_byte pixel_depth; /* bits per pixel (depth * channels) */ |
} png_row_info; |
typedef png_row_info FAR * png_row_infop; |
typedef png_row_info FAR * FAR * png_row_infopp; |
/* These are the function types for the I/O functions and for the functions |
* that allow the user to override the default I/O functions with his or her |
* own. The png_error_ptr type should match that of user-supplied warning |
* and error functions, while the png_rw_ptr type should match that of the |
* user read/write data functions. |
*/ |
typedef struct png_struct_def png_struct; |
typedef png_struct FAR * png_structp; |
typedef void (PNGAPI *png_error_ptr) PNGARG((png_structp, png_const_charp)); |
typedef void (PNGAPI *png_rw_ptr) PNGARG((png_structp, png_bytep, png_size_t)); |
typedef void (PNGAPI *png_flush_ptr) PNGARG((png_structp)); |
typedef void (PNGAPI *png_read_status_ptr) PNGARG((png_structp, png_uint_32, |
int)); |
typedef void (PNGAPI *png_write_status_ptr) PNGARG((png_structp, png_uint_32, |
int)); |
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
typedef void (PNGAPI *png_progressive_info_ptr) PNGARG((png_structp, png_infop)); |
typedef void (PNGAPI *png_progressive_end_ptr) PNGARG((png_structp, png_infop)); |
typedef void (PNGAPI *png_progressive_row_ptr) PNGARG((png_structp, png_bytep, |
png_uint_32, int)); |
#endif |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ |
defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ |
defined(PNG_LEGACY_SUPPORTED) |
typedef void (PNGAPI *png_user_transform_ptr) PNGARG((png_structp, |
png_row_infop, png_bytep)); |
#endif |
#if defined(PNG_USER_CHUNKS_SUPPORTED) |
typedef int (PNGAPI *png_user_chunk_ptr) PNGARG((png_structp, png_unknown_chunkp)); |
#endif |
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) |
typedef void (PNGAPI *png_unknown_chunk_ptr) PNGARG((png_structp)); |
#endif |
/* Transform masks for the high-level interface */ |
#define PNG_TRANSFORM_IDENTITY 0x0000 /* read and write */ |
#define PNG_TRANSFORM_STRIP_16 0x0001 /* read only */ |
#define PNG_TRANSFORM_STRIP_ALPHA 0x0002 /* read only */ |
#define PNG_TRANSFORM_PACKING 0x0004 /* read and write */ |
#define PNG_TRANSFORM_PACKSWAP 0x0008 /* read and write */ |
#define PNG_TRANSFORM_EXPAND 0x0010 /* read only */ |
#define PNG_TRANSFORM_INVERT_MONO 0x0020 /* read and write */ |
#define PNG_TRANSFORM_SHIFT 0x0040 /* read and write */ |
#define PNG_TRANSFORM_BGR 0x0080 /* read and write */ |
#define PNG_TRANSFORM_SWAP_ALPHA 0x0100 /* read and write */ |
#define PNG_TRANSFORM_SWAP_ENDIAN 0x0200 /* read and write */ |
#define PNG_TRANSFORM_INVERT_ALPHA 0x0400 /* read and write */ |
#define PNG_TRANSFORM_STRIP_FILLER 0x0800 /* WRITE only */ |
/* Flags for MNG supported features */ |
#define PNG_FLAG_MNG_EMPTY_PLTE 0x01 |
#define PNG_FLAG_MNG_FILTER_64 0x04 |
#define PNG_ALL_MNG_FEATURES 0x05 |
typedef png_voidp (*png_malloc_ptr) PNGARG((png_structp, png_size_t)); |
typedef void (*png_free_ptr) PNGARG((png_structp, png_voidp)); |
/* The structure that holds the information to read and write PNG files. |
* The only people who need to care about what is inside of this are the |
* people who will be modifying the library for their own special needs. |
* It should NOT be accessed directly by an application, except to store |
* the jmp_buf. |
*/ |
struct png_struct_def |
{ |
#ifdef PNG_SETJMP_SUPPORTED |
jmp_buf jmpbuf; /* used in png_error */ |
#endif |
png_error_ptr error_fn; /* function for printing errors and aborting */ |
png_error_ptr warning_fn; /* function for printing warnings */ |
png_voidp error_ptr; /* user supplied struct for error functions */ |
png_rw_ptr write_data_fn; /* function for writing output data */ |
png_rw_ptr read_data_fn; /* function for reading input data */ |
png_voidp io_ptr; /* ptr to application struct for I/O functions */ |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) |
png_user_transform_ptr read_user_transform_fn; /* user read transform */ |
#endif |
#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) |
png_user_transform_ptr write_user_transform_fn; /* user write transform */ |
#endif |
/* These were added in libpng-1.0.2 */ |
#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ |
defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) |
png_voidp user_transform_ptr; /* user supplied struct for user transform */ |
png_byte user_transform_depth; /* bit depth of user transformed pixels */ |
png_byte user_transform_channels; /* channels in user transformed pixels */ |
#endif |
#endif |
png_uint_32 mode; /* tells us where we are in the PNG file */ |
png_uint_32 flags; /* flags indicating various things to libpng */ |
png_uint_32 transformations; /* which transformations to perform */ |
z_stream zstream; /* pointer to decompression structure (below) */ |
png_bytep zbuf; /* buffer for zlib */ |
png_size_t zbuf_size; /* size of zbuf */ |
int zlib_level; /* holds zlib compression level */ |
int zlib_method; /* holds zlib compression method */ |
int zlib_window_bits; /* holds zlib compression window bits */ |
int zlib_mem_level; /* holds zlib compression memory level */ |
int zlib_strategy; /* holds zlib compression strategy */ |
png_uint_32 width; /* width of image in pixels */ |
png_uint_32 height; /* height of image in pixels */ |
png_uint_32 num_rows; /* number of rows in current pass */ |
png_uint_32 usr_width; /* width of row at start of write */ |
png_uint_32 rowbytes; /* size of row in bytes */ |
png_uint_32 irowbytes; /* size of current interlaced row in bytes */ |
png_uint_32 iwidth; /* width of current interlaced row in pixels */ |
png_uint_32 row_number; /* current row in interlace pass */ |
png_bytep prev_row; /* buffer to save previous (unfiltered) row */ |
png_bytep row_buf; /* buffer to save current (unfiltered) row */ |
png_bytep sub_row; /* buffer to save "sub" row when filtering */ |
png_bytep up_row; /* buffer to save "up" row when filtering */ |
png_bytep avg_row; /* buffer to save "avg" row when filtering */ |
png_bytep paeth_row; /* buffer to save "Paeth" row when filtering */ |
png_row_info row_info; /* used for transformation routines */ |
png_uint_32 idat_size; /* current IDAT size for read */ |
png_uint_32 crc; /* current chunk CRC value */ |
png_colorp palette; /* palette from the input file */ |
png_uint_16 num_palette; /* number of color entries in palette */ |
png_uint_16 num_trans; /* number of transparency values */ |
png_byte chunk_name[5]; /* null-terminated name of current chunk */ |
png_byte compression; /* file compression type (always 0) */ |
png_byte filter; /* file filter type (always 0) */ |
png_byte interlaced; /* PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */ |
png_byte pass; /* current interlace pass (0 - 6) */ |
png_byte do_filter; /* row filter flags (see PNG_FILTER_ below ) */ |
png_byte color_type; /* color type of file */ |
png_byte bit_depth; /* bit depth of file */ |
png_byte usr_bit_depth; /* bit depth of users row */ |
png_byte pixel_depth; /* number of bits per pixel */ |
png_byte channels; /* number of channels in file */ |
png_byte usr_channels; /* channels at start of write */ |
png_byte sig_bytes; /* magic bytes read/written from start of file */ |
#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) |
#ifdef PNG_LEGACY_SUPPORTED |
png_byte filler; /* filler byte for pixel expansion */ |
#else |
png_uint_16 filler; /* filler bytes for pixel expansion */ |
#endif |
#endif |
#if defined(PNG_bKGD_SUPPORTED) |
png_byte background_gamma_type; |
# ifdef PNG_FLOATING_POINT_SUPPORTED |
float background_gamma; |
# endif |
png_color_16 background; /* background color in screen gamma space */ |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
png_color_16 background_1; /* background normalized to gamma 1.0 */ |
#endif |
#endif /* PNG_bKGD_SUPPORTED */ |
#if defined(PNG_WRITE_FLUSH_SUPPORTED) |
png_flush_ptr output_flush_fn;/* Function for flushing output */ |
png_uint_32 flush_dist; /* how many rows apart to flush, 0 - no flush */ |
png_uint_32 flush_rows; /* number of rows written since last flush */ |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
int gamma_shift; /* number of "insignificant" bits 16-bit gamma */ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
float gamma; /* file gamma value */ |
float screen_gamma; /* screen gamma value (display_exponent) */ |
#endif |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
png_bytep gamma_table; /* gamma table for 8-bit depth files */ |
png_bytep gamma_from_1; /* converts from 1.0 to screen */ |
png_bytep gamma_to_1; /* converts from file to 1.0 */ |
png_uint_16pp gamma_16_table; /* gamma table for 16-bit depth files */ |
png_uint_16pp gamma_16_from_1; /* converts from 1.0 to screen */ |
png_uint_16pp gamma_16_to_1; /* converts from file to 1.0 */ |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_sBIT_SUPPORTED) |
png_color_8 sig_bit; /* significant bits in each available channel */ |
#endif |
#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) |
png_color_8 shift; /* shift for significant bit tranformation */ |
#endif |
#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) \ |
|| defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
png_bytep trans; /* transparency values for paletted files */ |
png_color_16 trans_values; /* transparency values for non-paletted files */ |
#endif |
png_read_status_ptr read_row_fn; /* called after each row is decoded */ |
png_write_status_ptr write_row_fn; /* called after each row is encoded */ |
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
png_progressive_info_ptr info_fn; /* called after header data fully read */ |
png_progressive_row_ptr row_fn; /* called after each prog. row is decoded */ |
png_progressive_end_ptr end_fn; /* called after image is complete */ |
png_bytep save_buffer_ptr; /* current location in save_buffer */ |
png_bytep save_buffer; /* buffer for previously read data */ |
png_bytep current_buffer_ptr; /* current location in current_buffer */ |
png_bytep current_buffer; /* buffer for recently used data */ |
png_uint_32 push_length; /* size of current input chunk */ |
png_uint_32 skip_length; /* bytes to skip in input data */ |
png_size_t save_buffer_size; /* amount of data now in save_buffer */ |
png_size_t save_buffer_max; /* total size of save_buffer */ |
png_size_t buffer_size; /* total amount of available input data */ |
png_size_t current_buffer_size; /* amount of data now in current_buffer */ |
int process_mode; /* what push library is currently doing */ |
int cur_palette; /* current push library palette index */ |
# if defined(PNG_TEXT_SUPPORTED) |
png_size_t current_text_size; /* current size of text input data */ |
png_size_t current_text_left; /* how much text left to read in input */ |
png_charp current_text; /* current text chunk buffer */ |
png_charp current_text_ptr; /* current location in current_text */ |
# endif /* PNG_PROGRESSIVE_READ_SUPPORTED && PNG_TEXT_SUPPORTED */ |
#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ |
#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__) |
/* for the Borland special 64K segment handler */ |
png_bytepp offset_table_ptr; |
png_bytep offset_table; |
png_uint_16 offset_table_number; |
png_uint_16 offset_table_count; |
png_uint_16 offset_table_count_free; |
#endif |
#if defined(PNG_READ_DITHER_SUPPORTED) |
png_bytep palette_lookup; /* lookup table for dithering */ |
png_bytep dither_index; /* index translation for palette files */ |
#endif |
#if defined(PNG_READ_DITHER_SUPPORTED) || defined(PNG_hIST_SUPPORTED) |
png_uint_16p hist; /* histogram */ |
#endif |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
png_byte heuristic_method; /* heuristic for row filter selection */ |
png_byte num_prev_filters; /* number of weights for previous rows */ |
png_bytep prev_filters; /* filter type(s) of previous row(s) */ |
png_uint_16p filter_weights; /* weight(s) for previous line(s) */ |
png_uint_16p inv_filter_weights; /* 1/weight(s) for previous line(s) */ |
png_uint_16p filter_costs; /* relative filter calculation cost */ |
png_uint_16p inv_filter_costs; /* 1/relative filter calculation cost */ |
#endif |
#if defined(PNG_TIME_RFC1123_SUPPORTED) |
png_charp time_buffer; /* String to hold RFC 1123 time text */ |
#endif |
/* New members added in libpng-1.0.6 */ |
#ifdef PNG_FREE_ME_SUPPORTED |
png_uint_32 free_me; /* flags items libpng is responsible for freeing */ |
#endif |
#if defined(PNG_USER_CHUNKS_SUPPORTED) |
png_voidp user_chunk_ptr; |
png_user_chunk_ptr read_user_chunk_fn; /* user read chunk handler */ |
#endif |
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) |
int num_chunk_list; |
png_bytep chunk_list; |
#endif |
/* New members added in libpng-1.0.3 */ |
#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) |
png_byte rgb_to_gray_status; |
/* These were changed from png_byte in libpng-1.0.6 */ |
png_uint_16 rgb_to_gray_red_coeff; |
png_uint_16 rgb_to_gray_green_coeff; |
png_uint_16 rgb_to_gray_blue_coeff; |
#endif |
/* New member added in libpng-1.0.4 (renamed in 1.0.9) */ |
#if defined(PNG_MNG_FEATURES_SUPPORTED) || \ |
defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \ |
defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED) |
/* changed from png_byte to png_uint_32 at version 1.2.0 */ |
#ifdef PNG_1_0_X |
png_byte mng_features_permitted; |
#else |
png_uint_32 mng_features_permitted; |
#endif /* PNG_1_0_X */ |
#endif |
/* New member added in libpng-1.0.7 */ |
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
png_fixed_point int_gamma; |
#endif |
/* New member added in libpng-1.0.9, ifdef'ed out in 1.0.12, enabled in 1.2.0 */ |
#if defined(PNG_MNG_FEATURES_SUPPORTED) |
png_byte filter_type; |
#endif |
#if defined(PNG_1_0_X) || (defined(PNG_DEBUG) && defined(PNG_USE_PNGGCCRD)) |
/* New member added in libpng-1.0.10, ifdef'ed out in 1.2.0 */ |
png_uint_32 row_buf_size; |
#endif |
/* New members added in libpng-1.2.0 */ |
#if !defined(PNG_1_0_X) && defined(PNG_ASSEMBLER_CODE_SUPPORTED) |
png_byte mmx_bitdepth_threshold; |
png_uint_32 mmx_rowbytes_threshold; |
png_uint_32 asm_flags; |
#endif |
/* New members added in libpng-1.0.2 but first enabled by default in 1.2.0 */ |
#ifdef PNG_USER_MEM_SUPPORTED |
png_voidp mem_ptr; /* user supplied struct for mem functions */ |
png_malloc_ptr malloc_fn; /* function for allocating memory */ |
png_free_ptr free_fn; /* function for freeing memory */ |
#endif |
/* New member added in libpng-1.0.13 and 1.2.0 */ |
png_bytep big_row_buf; /* buffer to save current (unfiltered) row */ |
#if defined(PNG_READ_DITHER_SUPPORTED) |
/* The following three members were added at version 1.0.14 and 1.2.4 */ |
png_bytep dither_sort; /* working sort array */ |
png_bytep index_to_palette; /* where the original index currently is */ |
/* in the palette */ |
png_bytep palette_to_index; /* which original index points to this */ |
/* palette color */ |
#endif |
}; |
/* This prevents a compiler error in png.c if png.c and png.h are both at |
version 1.2.5 |
*/ |
typedef png_structp version_1_2_5; |
typedef png_struct FAR * FAR * png_structpp; |
/* Here are the function definitions most commonly used. This is not |
* the place to find out how to use libpng. See libpng.txt for the |
* full explanation, see example.c for the summary. This just provides |
* a simple one line description of the use of each function. |
*/ |
/* Returns the version number of the library */ |
extern PNG_EXPORT(png_uint_32,png_access_version_number) PNGARG((void)); |
/* Tell lib we have already handled the first <num_bytes> magic bytes. |
* Handling more than 8 bytes from the beginning of the file is an error. |
*/ |
extern PNG_EXPORT(void,png_set_sig_bytes) PNGARG((png_structp png_ptr, |
int num_bytes)); |
/* Check sig[start] through sig[start + num_to_check - 1] to see if it's a |
* PNG file. Returns zero if the supplied bytes match the 8-byte PNG |
* signature, and non-zero otherwise. Having num_to_check == 0 or |
* start > 7 will always fail (ie return non-zero). |
*/ |
extern PNG_EXPORT(int,png_sig_cmp) PNGARG((png_bytep sig, png_size_t start, |
png_size_t num_to_check)); |
/* Simple signature checking function. This is the same as calling |
* png_check_sig(sig, n) := !png_sig_cmp(sig, 0, n). |
*/ |
extern PNG_EXPORT(int,png_check_sig) PNGARG((png_bytep sig, int num)); |
/* Allocate and initialize png_ptr struct for reading, and any other memory. */ |
extern PNG_EXPORT(png_structp,png_create_read_struct) |
PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, |
png_error_ptr error_fn, png_error_ptr warn_fn)); |
/* Allocate and initialize png_ptr struct for writing, and any other memory */ |
extern PNG_EXPORT(png_structp,png_create_write_struct) |
PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, |
png_error_ptr error_fn, png_error_ptr warn_fn)); |
extern PNG_EXPORT(png_uint_32,png_get_compression_buffer_size) |
PNGARG((png_structp png_ptr)); |
extern PNG_EXPORT(void,png_set_compression_buffer_size) |
PNGARG((png_structp png_ptr, png_uint_32 size)); |
/* Reset the compression stream */ |
extern PNG_EXPORT(int,png_reset_zstream) PNGARG((png_structp png_ptr)); |
/* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */ |
#ifdef PNG_USER_MEM_SUPPORTED |
extern PNG_EXPORT(png_structp,png_create_read_struct_2) |
PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, |
png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, |
png_malloc_ptr malloc_fn, png_free_ptr free_fn)); |
extern PNG_EXPORT(png_structp,png_create_write_struct_2) |
PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, |
png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, |
png_malloc_ptr malloc_fn, png_free_ptr free_fn)); |
#endif |
/* Write a PNG chunk - size, type, (optional) data, CRC. */ |
extern PNG_EXPORT(void,png_write_chunk) PNGARG((png_structp png_ptr, |
png_bytep chunk_name, png_bytep data, png_size_t length)); |
/* Write the start of a PNG chunk - length and chunk name. */ |
extern PNG_EXPORT(void,png_write_chunk_start) PNGARG((png_structp png_ptr, |
png_bytep chunk_name, png_uint_32 length)); |
/* Write the data of a PNG chunk started with png_write_chunk_start(). */ |
extern PNG_EXPORT(void,png_write_chunk_data) PNGARG((png_structp png_ptr, |
png_bytep data, png_size_t length)); |
/* Finish a chunk started with png_write_chunk_start() (includes CRC). */ |
extern PNG_EXPORT(void,png_write_chunk_end) PNGARG((png_structp png_ptr)); |
/* Allocate and initialize the info structure */ |
extern PNG_EXPORT(png_infop,png_create_info_struct) |
PNGARG((png_structp png_ptr)); |
/* Initialize the info structure (old interface - DEPRECATED) */ |
extern PNG_EXPORT(void,png_info_init) PNGARG((png_infop info_ptr)); |
#undef png_info_init |
#define png_info_init(info_ptr) png_info_init_3(&info_ptr, sizeof(png_info)); |
extern PNG_EXPORT(void,png_info_init_3) PNGARG((png_infopp info_ptr, |
png_size_t png_info_struct_size)); |
/* Writes all the PNG information before the image. */ |
extern PNG_EXPORT(void,png_write_info_before_PLTE) PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
extern PNG_EXPORT(void,png_write_info) PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
/* read the information before the actual image data. */ |
extern PNG_EXPORT(void,png_read_info) PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
#if defined(PNG_TIME_RFC1123_SUPPORTED) |
extern PNG_EXPORT(png_charp,png_convert_to_rfc1123) |
PNGARG((png_structp png_ptr, png_timep ptime)); |
#endif |
#if !defined(_WIN32_WCE) |
/* "time.h" functions are not supported on WindowsCE */ |
#if defined(PNG_WRITE_tIME_SUPPORTED) |
/* convert from a struct tm to png_time */ |
extern PNG_EXPORT(void,png_convert_from_struct_tm) PNGARG((png_timep ptime, |
struct tm FAR * ttime)); |
/* convert from time_t to png_time. Uses gmtime() */ |
extern PNG_EXPORT(void,png_convert_from_time_t) PNGARG((png_timep ptime, |
time_t ttime)); |
#endif /* PNG_WRITE_tIME_SUPPORTED */ |
#endif /* _WIN32_WCE */ |
#if defined(PNG_READ_EXPAND_SUPPORTED) |
/* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */ |
extern PNG_EXPORT(void,png_set_expand) PNGARG((png_structp png_ptr)); |
extern PNG_EXPORT(void,png_set_gray_1_2_4_to_8) PNGARG((png_structp png_ptr)); |
extern PNG_EXPORT(void,png_set_palette_to_rgb) PNGARG((png_structp png_ptr)); |
extern PNG_EXPORT(void,png_set_tRNS_to_alpha) PNGARG((png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) |
/* Use blue, green, red order for pixels. */ |
extern PNG_EXPORT(void,png_set_bgr) PNGARG((png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) |
/* Expand the grayscale to 24-bit RGB if necessary. */ |
extern PNG_EXPORT(void,png_set_gray_to_rgb) PNGARG((png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) |
/* Reduce RGB to grayscale. */ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
extern PNG_EXPORT(void,png_set_rgb_to_gray) PNGARG((png_structp png_ptr, |
int error_action, double red, double green )); |
#endif |
extern PNG_EXPORT(void,png_set_rgb_to_gray_fixed) PNGARG((png_structp png_ptr, |
int error_action, png_fixed_point red, png_fixed_point green )); |
extern PNG_EXPORT(png_byte,png_get_rgb_to_gray_status) PNGARG((png_structp |
png_ptr)); |
#endif |
extern PNG_EXPORT(void,png_build_grayscale_palette) PNGARG((int bit_depth, |
png_colorp palette)); |
#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED) |
extern PNG_EXPORT(void,png_set_strip_alpha) PNGARG((png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \ |
defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) |
extern PNG_EXPORT(void,png_set_swap_alpha) PNGARG((png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \ |
defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) |
extern PNG_EXPORT(void,png_set_invert_alpha) PNGARG((png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) |
/* Add a filler byte to 24-bit RGB images. */ |
extern PNG_EXPORT(void,png_set_filler) PNGARG((png_structp png_ptr, |
png_uint_32 filler, int flags)); |
/* The values of the PNG_FILLER_ defines should NOT be changed */ |
#define PNG_FILLER_BEFORE 0 |
#define PNG_FILLER_AFTER 1 |
#endif /* PNG_READ_FILLER_SUPPORTED || PNG_WRITE_FILLER_SUPPORTED */ |
#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) |
/* Swap bytes in 16-bit depth files. */ |
extern PNG_EXPORT(void,png_set_swap) PNGARG((png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED) |
/* Use 1 byte per pixel in 1, 2, or 4-bit depth files. */ |
extern PNG_EXPORT(void,png_set_packing) PNGARG((png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED) |
/* Swap packing order of pixels in bytes. */ |
extern PNG_EXPORT(void,png_set_packswap) PNGARG((png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) |
/* Converts files to legal bit depths. */ |
extern PNG_EXPORT(void,png_set_shift) PNGARG((png_structp png_ptr, |
png_color_8p true_bits)); |
#endif |
#if defined(PNG_READ_INTERLACING_SUPPORTED) || \ |
defined(PNG_WRITE_INTERLACING_SUPPORTED) |
/* Have the code handle the interlacing. Returns the number of passes. */ |
extern PNG_EXPORT(int,png_set_interlace_handling) PNGARG((png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) |
/* Invert monochrome files */ |
extern PNG_EXPORT(void,png_set_invert_mono) PNGARG((png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) |
/* Handle alpha and tRNS by replacing with a background color. */ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
extern PNG_EXPORT(void,png_set_background) PNGARG((png_structp png_ptr, |
png_color_16p background_color, int background_gamma_code, |
int need_expand, double background_gamma)); |
#endif |
#define PNG_BACKGROUND_GAMMA_UNKNOWN 0 |
#define PNG_BACKGROUND_GAMMA_SCREEN 1 |
#define PNG_BACKGROUND_GAMMA_FILE 2 |
#define PNG_BACKGROUND_GAMMA_UNIQUE 3 |
#endif |
#if defined(PNG_READ_16_TO_8_SUPPORTED) |
/* strip the second byte of information from a 16-bit depth file. */ |
extern PNG_EXPORT(void,png_set_strip_16) PNGARG((png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_DITHER_SUPPORTED) |
/* Turn on dithering, and reduce the palette to the number of colors available. */ |
extern PNG_EXPORT(void,png_set_dither) PNGARG((png_structp png_ptr, |
png_colorp palette, int num_palette, int maximum_colors, |
png_uint_16p histogram, int full_dither)); |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
/* Handle gamma correction. Screen_gamma=(display_exponent) */ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
extern PNG_EXPORT(void,png_set_gamma) PNGARG((png_structp png_ptr, |
double screen_gamma, double default_file_gamma)); |
#endif |
#endif |
#if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \ |
defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED) |
/* Permit or disallow empty PLTE (0: not permitted, 1: permitted) */ |
/* Deprecated and will be removed. Use png_permit_mng_features() instead. */ |
extern PNG_EXPORT(void,png_permit_empty_plte) PNGARG((png_structp png_ptr, |
int empty_plte_permitted)); |
#endif |
#if defined(PNG_WRITE_FLUSH_SUPPORTED) |
/* Set how many lines between output flushes - 0 for no flushing */ |
extern PNG_EXPORT(void,png_set_flush) PNGARG((png_structp png_ptr, int nrows)); |
/* Flush the current PNG output buffer */ |
extern PNG_EXPORT(void,png_write_flush) PNGARG((png_structp png_ptr)); |
#endif |
/* optional update palette with requested transformations */ |
extern PNG_EXPORT(void,png_start_read_image) PNGARG((png_structp png_ptr)); |
/* optional call to update the users info structure */ |
extern PNG_EXPORT(void,png_read_update_info) PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
/* read one or more rows of image data. */ |
extern PNG_EXPORT(void,png_read_rows) PNGARG((png_structp png_ptr, |
png_bytepp row, png_bytepp display_row, png_uint_32 num_rows)); |
/* read a row of data. */ |
extern PNG_EXPORT(void,png_read_row) PNGARG((png_structp png_ptr, |
png_bytep row, |
png_bytep display_row)); |
/* read the whole image into memory at once. */ |
extern PNG_EXPORT(void,png_read_image) PNGARG((png_structp png_ptr, |
png_bytepp image)); |
/* write a row of image data */ |
extern PNG_EXPORT(void,png_write_row) PNGARG((png_structp png_ptr, |
png_bytep row)); |
/* write a few rows of image data */ |
extern PNG_EXPORT(void,png_write_rows) PNGARG((png_structp png_ptr, |
png_bytepp row, png_uint_32 num_rows)); |
/* write the image data */ |
extern PNG_EXPORT(void,png_write_image) PNGARG((png_structp png_ptr, |
png_bytepp image)); |
/* writes the end of the PNG file. */ |
extern PNG_EXPORT(void,png_write_end) PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
/* read the end of the PNG file. */ |
extern PNG_EXPORT(void,png_read_end) PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
/* free any memory associated with the png_info_struct */ |
extern PNG_EXPORT(void,png_destroy_info_struct) PNGARG((png_structp png_ptr, |
png_infopp info_ptr_ptr)); |
/* free any memory associated with the png_struct and the png_info_structs */ |
extern PNG_EXPORT(void,png_destroy_read_struct) PNGARG((png_structpp |
png_ptr_ptr, png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr)); |
/* free all memory used by the read (old method - NOT DLL EXPORTED) */ |
extern void png_read_destroy PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_infop end_info_ptr)); |
/* free any memory associated with the png_struct and the png_info_structs */ |
extern PNG_EXPORT(void,png_destroy_write_struct) |
PNGARG((png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)); |
/* free any memory used in png_ptr struct (old method - NOT DLL EXPORTED) */ |
extern void png_write_destroy PNGARG((png_structp png_ptr)); |
/* set the libpng method of handling chunk CRC errors */ |
extern PNG_EXPORT(void,png_set_crc_action) PNGARG((png_structp png_ptr, |
int crit_action, int ancil_action)); |
/* Values for png_set_crc_action() to say how to handle CRC errors in |
* ancillary and critical chunks, and whether to use the data contained |
* therein. Note that it is impossible to "discard" data in a critical |
* chunk. For versions prior to 0.90, the action was always error/quit, |
* whereas in version 0.90 and later, the action for CRC errors in ancillary |
* chunks is warn/discard. These values should NOT be changed. |
* |
* value action:critical action:ancillary |
*/ |
#define PNG_CRC_DEFAULT 0 /* error/quit warn/discard data */ |
#define PNG_CRC_ERROR_QUIT 1 /* error/quit error/quit */ |
#define PNG_CRC_WARN_DISCARD 2 /* (INVALID) warn/discard data */ |
#define PNG_CRC_WARN_USE 3 /* warn/use data warn/use data */ |
#define PNG_CRC_QUIET_USE 4 /* quiet/use data quiet/use data */ |
#define PNG_CRC_NO_CHANGE 5 /* use current value use current value */ |
/* These functions give the user control over the scan-line filtering in |
* libpng and the compression methods used by zlib. These functions are |
* mainly useful for testing, as the defaults should work with most users. |
* Those users who are tight on memory or want faster performance at the |
* expense of compression can modify them. See the compression library |
* header file (zlib.h) for an explination of the compression functions. |
*/ |
/* set the filtering method(s) used by libpng. Currently, the only valid |
* value for "method" is 0. |
*/ |
extern PNG_EXPORT(void,png_set_filter) PNGARG((png_structp png_ptr, int method, |
int filters)); |
/* Flags for png_set_filter() to say which filters to use. The flags |
* are chosen so that they don't conflict with real filter types |
* below, in case they are supplied instead of the #defined constants. |
* These values should NOT be changed. |
*/ |
#define PNG_NO_FILTERS 0x00 |
#define PNG_FILTER_NONE 0x08 |
#define PNG_FILTER_SUB 0x10 |
#define PNG_FILTER_UP 0x20 |
#define PNG_FILTER_AVG 0x40 |
#define PNG_FILTER_PAETH 0x80 |
#define PNG_ALL_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP | \ |
PNG_FILTER_AVG | PNG_FILTER_PAETH) |
/* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now. |
* These defines should NOT be changed. |
*/ |
#define PNG_FILTER_VALUE_NONE 0 |
#define PNG_FILTER_VALUE_SUB 1 |
#define PNG_FILTER_VALUE_UP 2 |
#define PNG_FILTER_VALUE_AVG 3 |
#define PNG_FILTER_VALUE_PAETH 4 |
#define PNG_FILTER_VALUE_LAST 5 |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) /* EXPERIMENTAL */ |
/* The "heuristic_method" is given by one of the PNG_FILTER_HEURISTIC_ |
* defines, either the default (minimum-sum-of-absolute-differences), or |
* the experimental method (weighted-minimum-sum-of-absolute-differences). |
* |
* Weights are factors >= 1.0, indicating how important it is to keep the |
* filter type consistent between rows. Larger numbers mean the current |
* filter is that many times as likely to be the same as the "num_weights" |
* previous filters. This is cumulative for each previous row with a weight. |
* There needs to be "num_weights" values in "filter_weights", or it can be |
* NULL if the weights aren't being specified. Weights have no influence on |
* the selection of the first row filter. Well chosen weights can (in theory) |
* improve the compression for a given image. |
* |
* Costs are factors >= 1.0 indicating the relative decoding costs of a |
* filter type. Higher costs indicate more decoding expense, and are |
* therefore less likely to be selected over a filter with lower computational |
* costs. There needs to be a value in "filter_costs" for each valid filter |
* type (given by PNG_FILTER_VALUE_LAST), or it can be NULL if you aren't |
* setting the costs. Costs try to improve the speed of decompression without |
* unduly increasing the compressed image size. |
* |
* A negative weight or cost indicates the default value is to be used, and |
* values in the range [0.0, 1.0) indicate the value is to remain unchanged. |
* The default values for both weights and costs are currently 1.0, but may |
* change if good general weighting/cost heuristics can be found. If both |
* the weights and costs are set to 1.0, this degenerates the WEIGHTED method |
* to the UNWEIGHTED method, but with added encoding time/computation. |
*/ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
extern PNG_EXPORT(void,png_set_filter_heuristics) PNGARG((png_structp png_ptr, |
int heuristic_method, int num_weights, png_doublep filter_weights, |
png_doublep filter_costs)); |
#endif |
#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */ |
/* Heuristic used for row filter selection. These defines should NOT be |
* changed. |
*/ |
#define PNG_FILTER_HEURISTIC_DEFAULT 0 /* Currently "UNWEIGHTED" */ |
#define PNG_FILTER_HEURISTIC_UNWEIGHTED 1 /* Used by libpng < 0.95 */ |
#define PNG_FILTER_HEURISTIC_WEIGHTED 2 /* Experimental feature */ |
#define PNG_FILTER_HEURISTIC_LAST 3 /* Not a valid value */ |
/* Set the library compression level. Currently, valid values range from |
* 0 - 9, corresponding directly to the zlib compression levels 0 - 9 |
* (0 - no compression, 9 - "maximal" compression). Note that tests have |
* shown that zlib compression levels 3-6 usually perform as well as level 9 |
* for PNG images, and do considerably fewer caclulations. In the future, |
* these values may not correspond directly to the zlib compression levels. |
*/ |
extern PNG_EXPORT(void,png_set_compression_level) PNGARG((png_structp png_ptr, |
int level)); |
extern PNG_EXPORT(void,png_set_compression_mem_level) |
PNGARG((png_structp png_ptr, int mem_level)); |
extern PNG_EXPORT(void,png_set_compression_strategy) |
PNGARG((png_structp png_ptr, int strategy)); |
extern PNG_EXPORT(void,png_set_compression_window_bits) |
PNGARG((png_structp png_ptr, int window_bits)); |
extern PNG_EXPORT(void,png_set_compression_method) PNGARG((png_structp png_ptr, |
int method)); |
/* These next functions are called for input/output, memory, and error |
* handling. They are in the file pngrio.c, pngwio.c, and pngerror.c, |
* and call standard C I/O routines such as fread(), fwrite(), and |
* fprintf(). These functions can be made to use other I/O routines |
* at run time for those applications that need to handle I/O in a |
* different manner by calling png_set_???_fn(). See libpng.txt for |
* more information. |
*/ |
#if !defined(PNG_NO_STDIO) |
/* Initialize the input/output for the PNG file to the default functions. */ |
extern PNG_EXPORT(void,png_init_io) PNGARG((png_structp png_ptr, png_FILE_p fp)); |
#endif |
/* Replace the (error and abort), and warning functions with user |
* supplied functions. If no messages are to be printed you must still |
* write and use replacement functions. The replacement error_fn should |
* still do a longjmp to the last setjmp location if you are using this |
* method of error handling. If error_fn or warning_fn is NULL, the |
* default function will be used. |
*/ |
extern PNG_EXPORT(void,png_set_error_fn) PNGARG((png_structp png_ptr, |
png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn)); |
/* Return the user pointer associated with the error functions */ |
extern PNG_EXPORT(png_voidp,png_get_error_ptr) PNGARG((png_structp png_ptr)); |
/* Replace the default data output functions with a user supplied one(s). |
* If buffered output is not used, then output_flush_fn can be set to NULL. |
* If PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile time |
* output_flush_fn will be ignored (and thus can be NULL). |
*/ |
extern PNG_EXPORT(void,png_set_write_fn) PNGARG((png_structp png_ptr, |
png_voidp io_ptr, png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)); |
/* Replace the default data input function with a user supplied one. */ |
extern PNG_EXPORT(void,png_set_read_fn) PNGARG((png_structp png_ptr, |
png_voidp io_ptr, png_rw_ptr read_data_fn)); |
/* Return the user pointer associated with the I/O functions */ |
extern PNG_EXPORT(png_voidp,png_get_io_ptr) PNGARG((png_structp png_ptr)); |
extern PNG_EXPORT(void,png_set_read_status_fn) PNGARG((png_structp png_ptr, |
png_read_status_ptr read_row_fn)); |
extern PNG_EXPORT(void,png_set_write_status_fn) PNGARG((png_structp png_ptr, |
png_write_status_ptr write_row_fn)); |
#ifdef PNG_USER_MEM_SUPPORTED |
/* Replace the default memory allocation functions with user supplied one(s). */ |
extern PNG_EXPORT(void,png_set_mem_fn) PNGARG((png_structp png_ptr, |
png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn)); |
/* Return the user pointer associated with the memory functions */ |
extern PNG_EXPORT(png_voidp,png_get_mem_ptr) PNGARG((png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ |
defined(PNG_LEGACY_SUPPORTED) |
extern PNG_EXPORT(void,png_set_read_user_transform_fn) PNGARG((png_structp |
png_ptr, png_user_transform_ptr read_user_transform_fn)); |
#endif |
#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ |
defined(PNG_LEGACY_SUPPORTED) |
extern PNG_EXPORT(void,png_set_write_user_transform_fn) PNGARG((png_structp |
png_ptr, png_user_transform_ptr write_user_transform_fn)); |
#endif |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ |
defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ |
defined(PNG_LEGACY_SUPPORTED) |
extern PNG_EXPORT(void,png_set_user_transform_info) PNGARG((png_structp |
png_ptr, png_voidp user_transform_ptr, int user_transform_depth, |
int user_transform_channels)); |
/* Return the user pointer associated with the user transform functions */ |
extern PNG_EXPORT(png_voidp,png_get_user_transform_ptr) |
PNGARG((png_structp png_ptr)); |
#endif |
#ifdef PNG_USER_CHUNKS_SUPPORTED |
extern PNG_EXPORT(void,png_set_read_user_chunk_fn) PNGARG((png_structp png_ptr, |
png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn)); |
extern PNG_EXPORT(png_voidp,png_get_user_chunk_ptr) PNGARG((png_structp |
png_ptr)); |
#endif |
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
/* Sets the function callbacks for the push reader, and a pointer to a |
* user-defined structure available to the callback functions. |
*/ |
extern PNG_EXPORT(void,png_set_progressive_read_fn) PNGARG((png_structp png_ptr, |
png_voidp progressive_ptr, |
png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn, |
png_progressive_end_ptr end_fn)); |
/* returns the user pointer associated with the push read functions */ |
extern PNG_EXPORT(png_voidp,png_get_progressive_ptr) |
PNGARG((png_structp png_ptr)); |
/* function to be called when data becomes available */ |
extern PNG_EXPORT(void,png_process_data) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_bytep buffer, png_size_t buffer_size)); |
/* function that combines rows. Not very much different than the |
* png_combine_row() call. Is this even used????? |
*/ |
extern PNG_EXPORT(void,png_progressive_combine_row) PNGARG((png_structp png_ptr, |
png_bytep old_row, png_bytep new_row)); |
#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ |
extern PNG_EXPORT(png_voidp,png_malloc) PNGARG((png_structp png_ptr, |
png_uint_32 size)); |
#if defined(PNG_1_0_X) |
# define png_malloc_warn png_malloc |
#else |
/* Added at libpng version 1.2.4 */ |
extern PNG_EXPORT(png_voidp,png_malloc_warn) PNGARG((png_structp png_ptr, |
png_uint_32 size)); |
#endif |
/* frees a pointer allocated by png_malloc() */ |
extern PNG_EXPORT(void,png_free) PNGARG((png_structp png_ptr, png_voidp ptr)); |
#if defined(PNG_1_0_X) |
/* Function to allocate memory for zlib. */ |
extern PNG_EXPORT(voidpf,png_zalloc) PNGARG((voidpf png_ptr, uInt items, |
uInt size)); |
/* Function to free memory for zlib */ |
extern PNG_EXPORT(void,png_zfree) PNGARG((voidpf png_ptr, voidpf ptr)); |
#endif |
/* Free data that was allocated internally */ |
extern PNG_EXPORT(void,png_free_data) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_uint_32 free_me, int num)); |
#ifdef PNG_FREE_ME_SUPPORTED |
/* Reassign responsibility for freeing existing data, whether allocated |
* by libpng or by the application */ |
extern PNG_EXPORT(void,png_data_freer) PNGARG((png_structp png_ptr, |
png_infop info_ptr, int freer, png_uint_32 mask)); |
#endif |
/* assignments for png_data_freer */ |
#define PNG_DESTROY_WILL_FREE_DATA 1 |
#define PNG_SET_WILL_FREE_DATA 1 |
#define PNG_USER_WILL_FREE_DATA 2 |
/* Flags for png_ptr->free_me and info_ptr->free_me */ |
#define PNG_FREE_HIST 0x0008 |
#define PNG_FREE_ICCP 0x0010 |
#define PNG_FREE_SPLT 0x0020 |
#define PNG_FREE_ROWS 0x0040 |
#define PNG_FREE_PCAL 0x0080 |
#define PNG_FREE_SCAL 0x0100 |
#define PNG_FREE_UNKN 0x0200 |
#define PNG_FREE_LIST 0x0400 |
#define PNG_FREE_PLTE 0x1000 |
#define PNG_FREE_TRNS 0x2000 |
#define PNG_FREE_TEXT 0x4000 |
#define PNG_FREE_ALL 0x7fff |
#define PNG_FREE_MUL 0x4220 /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */ |
#ifdef PNG_USER_MEM_SUPPORTED |
extern PNG_EXPORT(png_voidp,png_malloc_default) PNGARG((png_structp png_ptr, |
png_uint_32 size)); |
extern PNG_EXPORT(void,png_free_default) PNGARG((png_structp png_ptr, |
png_voidp ptr)); |
#endif |
extern PNG_EXPORT(png_voidp,png_memcpy_check) PNGARG((png_structp png_ptr, |
png_voidp s1, png_voidp s2, png_uint_32 size)); |
extern PNG_EXPORT(png_voidp,png_memset_check) PNGARG((png_structp png_ptr, |
png_voidp s1, int value, png_uint_32 size)); |
#if defined(USE_FAR_KEYWORD) /* memory model conversion function */ |
extern void *png_far_to_near PNGARG((png_structp png_ptr,png_voidp ptr, |
int check)); |
#endif /* USE_FAR_KEYWORD */ |
/* Fatal error in PNG image of libpng - can't continue */ |
extern PNG_EXPORT(void,png_error) PNGARG((png_structp png_ptr, |
png_const_charp error_message)); |
/* The same, but the chunk name is prepended to the error string. */ |
extern PNG_EXPORT(void,png_chunk_error) PNGARG((png_structp png_ptr, |
png_const_charp error_message)); |
/* Non-fatal error in libpng. Can continue, but may have a problem. */ |
extern PNG_EXPORT(void,png_warning) PNGARG((png_structp png_ptr, |
png_const_charp warning_message)); |
/* Non-fatal error in libpng, chunk name is prepended to message. */ |
extern PNG_EXPORT(void,png_chunk_warning) PNGARG((png_structp png_ptr, |
png_const_charp warning_message)); |
/* The png_set_<chunk> functions are for storing values in the png_info_struct. |
* Similarly, the png_get_<chunk> calls are used to read values from the |
* png_info_struct, either storing the parameters in the passed variables, or |
* setting pointers into the png_info_struct where the data is stored. The |
* png_get_<chunk> functions return a non-zero value if the data was available |
* in info_ptr, or return zero and do not change any of the parameters if the |
* data was not available. |
* |
* These functions should be used instead of directly accessing png_info |
* to avoid problems with future changes in the size and internal layout of |
* png_info_struct. |
*/ |
/* Returns "flag" if chunk data is valid in info_ptr. */ |
extern PNG_EXPORT(png_uint_32,png_get_valid) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_uint_32 flag)); |
/* Returns number of bytes needed to hold a transformed row. */ |
extern PNG_EXPORT(png_uint_32,png_get_rowbytes) PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
#if defined(PNG_INFO_IMAGE_SUPPORTED) |
/* Returns row_pointers, which is an array of pointers to scanlines that was |
returned from png_read_png(). */ |
extern PNG_EXPORT(png_bytepp,png_get_rows) PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
/* Set row_pointers, which is an array of pointers to scanlines for use |
by png_write_png(). */ |
extern PNG_EXPORT(void,png_set_rows) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_bytepp row_pointers)); |
#endif |
/* Returns number of color channels in image. */ |
extern PNG_EXPORT(png_byte,png_get_channels) PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
#ifdef PNG_EASY_ACCESS_SUPPORTED |
/* Returns image width in pixels. */ |
extern PNG_EXPORT(png_uint_32, png_get_image_width) PNGARG((png_structp |
png_ptr, png_infop info_ptr)); |
/* Returns image height in pixels. */ |
extern PNG_EXPORT(png_uint_32, png_get_image_height) PNGARG((png_structp |
png_ptr, png_infop info_ptr)); |
/* Returns image bit_depth. */ |
extern PNG_EXPORT(png_byte, png_get_bit_depth) PNGARG((png_structp |
png_ptr, png_infop info_ptr)); |
/* Returns image color_type. */ |
extern PNG_EXPORT(png_byte, png_get_color_type) PNGARG((png_structp |
png_ptr, png_infop info_ptr)); |
/* Returns image filter_type. */ |
extern PNG_EXPORT(png_byte, png_get_filter_type) PNGARG((png_structp |
png_ptr, png_infop info_ptr)); |
/* Returns image interlace_type. */ |
extern PNG_EXPORT(png_byte, png_get_interlace_type) PNGARG((png_structp |
png_ptr, png_infop info_ptr)); |
/* Returns image compression_type. */ |
extern PNG_EXPORT(png_byte, png_get_compression_type) PNGARG((png_structp |
png_ptr, png_infop info_ptr)); |
/* Returns image resolution in pixels per meter, from pHYs chunk data. */ |
extern PNG_EXPORT(png_uint_32, png_get_pixels_per_meter) PNGARG((png_structp |
png_ptr, png_infop info_ptr)); |
extern PNG_EXPORT(png_uint_32, png_get_x_pixels_per_meter) PNGARG((png_structp |
png_ptr, png_infop info_ptr)); |
extern PNG_EXPORT(png_uint_32, png_get_y_pixels_per_meter) PNGARG((png_structp |
png_ptr, png_infop info_ptr)); |
/* Returns pixel aspect ratio, computed from pHYs chunk data. */ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
extern PNG_EXPORT(float, png_get_pixel_aspect_ratio) PNGARG((png_structp |
png_ptr, png_infop info_ptr)); |
#endif |
/* Returns image x, y offset in pixels or microns, from oFFs chunk data. */ |
extern PNG_EXPORT(png_int_32, png_get_x_offset_pixels) PNGARG((png_structp |
png_ptr, png_infop info_ptr)); |
extern PNG_EXPORT(png_int_32, png_get_y_offset_pixels) PNGARG((png_structp |
png_ptr, png_infop info_ptr)); |
extern PNG_EXPORT(png_int_32, png_get_x_offset_microns) PNGARG((png_structp |
png_ptr, png_infop info_ptr)); |
extern PNG_EXPORT(png_int_32, png_get_y_offset_microns) PNGARG((png_structp |
png_ptr, png_infop info_ptr)); |
#endif /* PNG_EASY_ACCESS_SUPPORTED */ |
/* Returns pointer to signature string read from PNG header */ |
extern PNG_EXPORT(png_bytep,png_get_signature) PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
#if defined(PNG_bKGD_SUPPORTED) |
extern PNG_EXPORT(png_uint_32,png_get_bKGD) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_color_16p *background)); |
#endif |
#if defined(PNG_bKGD_SUPPORTED) |
extern PNG_EXPORT(void,png_set_bKGD) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_color_16p background)); |
#endif |
#if defined(PNG_cHRM_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
extern PNG_EXPORT(png_uint_32,png_get_cHRM) PNGARG((png_structp png_ptr, |
png_infop info_ptr, double *white_x, double *white_y, double *red_x, |
double *red_y, double *green_x, double *green_y, double *blue_x, |
double *blue_y)); |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
extern PNG_EXPORT(png_uint_32,png_get_cHRM_fixed) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_fixed_point *int_white_x, png_fixed_point |
*int_white_y, png_fixed_point *int_red_x, png_fixed_point *int_red_y, |
png_fixed_point *int_green_x, png_fixed_point *int_green_y, png_fixed_point |
*int_blue_x, png_fixed_point *int_blue_y)); |
#endif |
#endif |
#if defined(PNG_cHRM_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
extern PNG_EXPORT(void,png_set_cHRM) PNGARG((png_structp png_ptr, |
png_infop info_ptr, double white_x, double white_y, double red_x, |
double red_y, double green_x, double green_y, double blue_x, double blue_y)); |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
extern PNG_EXPORT(void,png_set_cHRM_fixed) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_fixed_point int_white_x, png_fixed_point int_white_y, |
png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point |
int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, |
png_fixed_point int_blue_y)); |
#endif |
#endif |
#if defined(PNG_gAMA_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
extern PNG_EXPORT(png_uint_32,png_get_gAMA) PNGARG((png_structp png_ptr, |
png_infop info_ptr, double *file_gamma)); |
#endif |
extern PNG_EXPORT(png_uint_32,png_get_gAMA_fixed) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_fixed_point *int_file_gamma)); |
#endif |
#if defined(PNG_gAMA_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
extern PNG_EXPORT(void,png_set_gAMA) PNGARG((png_structp png_ptr, |
png_infop info_ptr, double file_gamma)); |
#endif |
extern PNG_EXPORT(void,png_set_gAMA_fixed) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_fixed_point int_file_gamma)); |
#endif |
#if defined(PNG_hIST_SUPPORTED) |
extern PNG_EXPORT(png_uint_32,png_get_hIST) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_uint_16p *hist)); |
#endif |
#if defined(PNG_hIST_SUPPORTED) |
extern PNG_EXPORT(void,png_set_hIST) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_uint_16p hist)); |
#endif |
extern PNG_EXPORT(png_uint_32,png_get_IHDR) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_uint_32 *width, png_uint_32 *height, |
int *bit_depth, int *color_type, int *interlace_method, |
int *compression_method, int *filter_method)); |
extern PNG_EXPORT(void,png_set_IHDR) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth, |
int color_type, int interlace_method, int compression_method, |
int filter_method)); |
#if defined(PNG_oFFs_SUPPORTED) |
extern PNG_EXPORT(png_uint_32,png_get_oFFs) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_int_32 *offset_x, png_int_32 *offset_y, |
int *unit_type)); |
#endif |
#if defined(PNG_oFFs_SUPPORTED) |
extern PNG_EXPORT(void,png_set_oFFs) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_int_32 offset_x, png_int_32 offset_y, |
int unit_type)); |
#endif |
#if defined(PNG_pCAL_SUPPORTED) |
extern PNG_EXPORT(png_uint_32,png_get_pCAL) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_charp *purpose, png_int_32 *X0, png_int_32 *X1, |
int *type, int *nparams, png_charp *units, png_charpp *params)); |
#endif |
#if defined(PNG_pCAL_SUPPORTED) |
extern PNG_EXPORT(void,png_set_pCAL) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_charp purpose, png_int_32 X0, png_int_32 X1, |
int type, int nparams, png_charp units, png_charpp params)); |
#endif |
#if defined(PNG_pHYs_SUPPORTED) |
extern PNG_EXPORT(png_uint_32,png_get_pHYs) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)); |
#endif |
#if defined(PNG_pHYs_SUPPORTED) |
extern PNG_EXPORT(void,png_set_pHYs) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type)); |
#endif |
extern PNG_EXPORT(png_uint_32,png_get_PLTE) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_colorp *palette, int *num_palette)); |
extern PNG_EXPORT(void,png_set_PLTE) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_colorp palette, int num_palette)); |
#if defined(PNG_sBIT_SUPPORTED) |
extern PNG_EXPORT(png_uint_32,png_get_sBIT) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_color_8p *sig_bit)); |
#endif |
#if defined(PNG_sBIT_SUPPORTED) |
extern PNG_EXPORT(void,png_set_sBIT) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_color_8p sig_bit)); |
#endif |
#if defined(PNG_sRGB_SUPPORTED) |
extern PNG_EXPORT(png_uint_32,png_get_sRGB) PNGARG((png_structp png_ptr, |
png_infop info_ptr, int *intent)); |
#endif |
#if defined(PNG_sRGB_SUPPORTED) |
extern PNG_EXPORT(void,png_set_sRGB) PNGARG((png_structp png_ptr, |
png_infop info_ptr, int intent)); |
extern PNG_EXPORT(void,png_set_sRGB_gAMA_and_cHRM) PNGARG((png_structp png_ptr, |
png_infop info_ptr, int intent)); |
#endif |
#if defined(PNG_iCCP_SUPPORTED) |
extern PNG_EXPORT(png_uint_32,png_get_iCCP) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_charpp name, int *compression_type, |
png_charpp profile, png_uint_32 *proflen)); |
/* Note to maintainer: profile should be png_bytepp */ |
#endif |
#if defined(PNG_iCCP_SUPPORTED) |
extern PNG_EXPORT(void,png_set_iCCP) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_charp name, int compression_type, |
png_charp profile, png_uint_32 proflen)); |
/* Note to maintainer: profile should be png_bytep */ |
#endif |
#if defined(PNG_sPLT_SUPPORTED) |
extern PNG_EXPORT(png_uint_32,png_get_sPLT) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_sPLT_tpp entries)); |
#endif |
#if defined(PNG_sPLT_SUPPORTED) |
extern PNG_EXPORT(void,png_set_sPLT) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_sPLT_tp entries, int nentries)); |
#endif |
#if defined(PNG_TEXT_SUPPORTED) |
/* png_get_text also returns the number of text chunks in *num_text */ |
extern PNG_EXPORT(png_uint_32,png_get_text) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_textp *text_ptr, int *num_text)); |
#endif |
/* |
* Note while png_set_text() will accept a structure whose text, |
* language, and translated keywords are NULL pointers, the structure |
* returned by png_get_text will always contain regular |
* zero-terminated C strings. They might be empty strings but |
* they will never be NULL pointers. |
*/ |
#if defined(PNG_TEXT_SUPPORTED) |
extern PNG_EXPORT(void,png_set_text) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_textp text_ptr, int num_text)); |
#endif |
#if defined(PNG_tIME_SUPPORTED) |
extern PNG_EXPORT(png_uint_32,png_get_tIME) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_timep *mod_time)); |
#endif |
#if defined(PNG_tIME_SUPPORTED) |
extern PNG_EXPORT(void,png_set_tIME) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_timep mod_time)); |
#endif |
#if defined(PNG_tRNS_SUPPORTED) |
extern PNG_EXPORT(png_uint_32,png_get_tRNS) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_bytep *trans, int *num_trans, |
png_color_16p *trans_values)); |
#endif |
#if defined(PNG_tRNS_SUPPORTED) |
extern PNG_EXPORT(void,png_set_tRNS) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_bytep trans, int num_trans, |
png_color_16p trans_values)); |
#endif |
#if defined(PNG_tRNS_SUPPORTED) |
#endif |
#if defined(PNG_sCAL_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
extern PNG_EXPORT(png_uint_32,png_get_sCAL) PNGARG((png_structp png_ptr, |
png_infop info_ptr, int *unit, double *width, double *height)); |
#else |
#ifdef PNG_FIXED_POINT_SUPPORTED |
extern PNG_EXPORT(png_uint_32,png_get_sCAL_s) PNGARG((png_structp png_ptr, |
png_infop info_ptr, int *unit, png_charpp swidth, png_charpp sheight)); |
#endif |
#endif |
#endif /* PNG_sCAL_SUPPORTED */ |
#if defined(PNG_sCAL_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
extern PNG_EXPORT(void,png_set_sCAL) PNGARG((png_structp png_ptr, |
png_infop info_ptr, int unit, double width, double height)); |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
extern PNG_EXPORT(void,png_set_sCAL_s) PNGARG((png_structp png_ptr, |
png_infop info_ptr, int unit, png_charp swidth, png_charp sheight)); |
#endif |
#endif /* PNG_sCAL_SUPPORTED || PNG_WRITE_sCAL_SUPPORTED */ |
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) |
/* provide a list of chunks and how they are to be handled, if the built-in |
handling or default unknown chunk handling is not desired. Any chunks not |
listed will be handled in the default manner. The IHDR and IEND chunks |
must not be listed. |
keep = 0: follow default behavour |
= 1: do not keep |
= 2: keep only if safe-to-copy |
= 3: keep even if unsafe-to-copy |
*/ |
extern PNG_EXPORT(void, png_set_keep_unknown_chunks) PNGARG((png_structp |
png_ptr, int keep, png_bytep chunk_list, int num_chunks)); |
extern PNG_EXPORT(void, png_set_unknown_chunks) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns)); |
extern PNG_EXPORT(void, png_set_unknown_chunk_location) |
PNGARG((png_structp png_ptr, png_infop info_ptr, int chunk, int location)); |
extern PNG_EXPORT(png_uint_32,png_get_unknown_chunks) PNGARG((png_structp |
png_ptr, png_infop info_ptr, png_unknown_chunkpp entries)); |
#endif |
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
PNG_EXPORT(int,png_handle_as_unknown) PNGARG((png_structp png_ptr, png_bytep |
chunk_name)); |
#endif |
/* Png_free_data() will turn off the "valid" flag for anything it frees. |
If you need to turn it off for a chunk that your application has freed, |
you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK); */ |
extern PNG_EXPORT(void, png_set_invalid) PNGARG((png_structp png_ptr, |
png_infop info_ptr, int mask)); |
#if defined(PNG_INFO_IMAGE_SUPPORTED) |
/* The "params" pointer is currently not used and is for future expansion. */ |
extern PNG_EXPORT(void, png_read_png) PNGARG((png_structp png_ptr, |
png_infop info_ptr, |
int transforms, |
png_voidp params)); |
extern PNG_EXPORT(void, png_write_png) PNGARG((png_structp png_ptr, |
png_infop info_ptr, |
int transforms, |
png_voidp params)); |
#endif |
/* Define PNG_DEBUG at compile time for debugging information. Higher |
* numbers for PNG_DEBUG mean more debugging information. This has |
* only been added since version 0.95 so it is not implemented throughout |
* libpng yet, but more support will be added as needed. |
*/ |
#ifdef PNG_DEBUG |
#if (PNG_DEBUG > 0) |
#if !defined(PNG_DEBUG_FILE) && defined(_MSC_VER) |
#include <crtdbg.h> |
#if (PNG_DEBUG > 1) |
#define png_debug(l,m) _RPT0(_CRT_WARN,m) |
#define png_debug1(l,m,p1) _RPT1(_CRT_WARN,m,p1) |
#define png_debug2(l,m,p1,p2) _RPT2(_CRT_WARN,m,p1,p2) |
#endif |
#else /* PNG_DEBUG_FILE || !_MSC_VER */ |
#ifndef PNG_DEBUG_FILE |
#define PNG_DEBUG_FILE stderr |
#endif /* PNG_DEBUG_FILE */ |
#if (PNG_DEBUG > 1) |
#define png_debug(l,m) \ |
{ \ |
int num_tabs=l; \ |
fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \ |
(num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":"")))); \ |
} |
#define png_debug1(l,m,p1) \ |
{ \ |
int num_tabs=l; \ |
fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \ |
(num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1); \ |
} |
#define png_debug2(l,m,p1,p2) \ |
{ \ |
int num_tabs=l; \ |
fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \ |
(num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1,p2); \ |
} |
#endif /* (PNG_DEBUG > 1) */ |
#endif /* _MSC_VER */ |
#endif /* (PNG_DEBUG > 0) */ |
#endif /* PNG_DEBUG */ |
#ifndef png_debug |
#define png_debug(l, m) |
#endif |
#ifndef png_debug1 |
#define png_debug1(l, m, p1) |
#endif |
#ifndef png_debug2 |
#define png_debug2(l, m, p1, p2) |
#endif |
extern PNG_EXPORT(png_bytep,png_sig_bytes) PNGARG((void)); |
extern PNG_EXPORT(png_charp,png_get_copyright) PNGARG((png_structp png_ptr)); |
extern PNG_EXPORT(png_charp,png_get_header_ver) PNGARG((png_structp png_ptr)); |
extern PNG_EXPORT(png_charp,png_get_header_version) PNGARG((png_structp png_ptr)); |
extern PNG_EXPORT(png_charp,png_get_libpng_ver) PNGARG((png_structp png_ptr)); |
#ifdef PNG_MNG_FEATURES_SUPPORTED |
extern PNG_EXPORT(png_uint_32,png_permit_mng_features) PNGARG((png_structp |
png_ptr, png_uint_32 mng_features_permitted)); |
#endif |
/* Added to version 1.2.0 */ |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) |
#define PNG_ASM_FLAG_MMX_SUPPORT_COMPILED 0x01 /* not user-settable */ |
#define PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU 0x02 /* not user-settable */ |
#define PNG_ASM_FLAG_MMX_READ_COMBINE_ROW 0x04 |
#define PNG_ASM_FLAG_MMX_READ_INTERLACE 0x08 |
#define PNG_ASM_FLAG_MMX_READ_FILTER_SUB 0x10 |
#define PNG_ASM_FLAG_MMX_READ_FILTER_UP 0x20 |
#define PNG_ASM_FLAG_MMX_READ_FILTER_AVG 0x40 |
#define PNG_ASM_FLAG_MMX_READ_FILTER_PAETH 0x80 |
#define PNG_ASM_FLAGS_INITIALIZED 0x80000000 /* not user-settable */ |
#define PNG_MMX_READ_FLAGS ( PNG_ASM_FLAG_MMX_READ_COMBINE_ROW \ |
| PNG_ASM_FLAG_MMX_READ_INTERLACE \ |
| PNG_ASM_FLAG_MMX_READ_FILTER_SUB \ |
| PNG_ASM_FLAG_MMX_READ_FILTER_UP \ |
| PNG_ASM_FLAG_MMX_READ_FILTER_AVG \ |
| PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ) |
#define PNG_MMX_WRITE_FLAGS ( 0 ) |
#define PNG_MMX_FLAGS ( PNG_ASM_FLAG_MMX_SUPPORT_COMPILED \ |
| PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU \ |
| PNG_MMX_READ_FLAGS \ |
| PNG_MMX_WRITE_FLAGS ) |
#define PNG_SELECT_READ 1 |
#define PNG_SELECT_WRITE 2 |
#if !defined(PNG_1_0_X) |
/* pngget.c */ |
extern PNG_EXPORT(png_uint_32,png_get_mmx_flagmask) |
PNGARG((int flag_select, int *compilerID)); |
/* pngget.c */ |
extern PNG_EXPORT(png_uint_32,png_get_asm_flagmask) |
PNGARG((int flag_select)); |
/* pngget.c */ |
extern PNG_EXPORT(png_uint_32,png_get_asm_flags) |
PNGARG((png_structp png_ptr)); |
/* pngget.c */ |
extern PNG_EXPORT(png_byte,png_get_mmx_bitdepth_threshold) |
PNGARG((png_structp png_ptr)); |
/* pngget.c */ |
extern PNG_EXPORT(png_uint_32,png_get_mmx_rowbytes_threshold) |
PNGARG((png_structp png_ptr)); |
/* pngset.c */ |
extern PNG_EXPORT(void,png_set_asm_flags) |
PNGARG((png_structp png_ptr, png_uint_32 asm_flags)); |
/* pngset.c */ |
extern PNG_EXPORT(void,png_set_mmx_thresholds) |
PNGARG((png_structp png_ptr, png_byte mmx_bitdepth_threshold, |
png_uint_32 mmx_rowbytes_threshold)); |
#endif /* PNG_1_0_X */ |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
#if !defined(PNG_1_0_X) |
/* png.c, pnggccrd.c, or pngvcrd.c */ |
extern PNG_EXPORT(int,png_mmx_support) PNGARG((void)); |
/* Strip the prepended error numbers ("#nnn ") from error and warning |
* messages before passing them to the error or warning handler. */ |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
extern PNG_EXPORT(void,png_set_strip_error_numbers) PNGARG((png_structp |
png_ptr, png_uint_32 strip_mode)); |
#endif |
#endif /* PNG_1_0_X */ |
/* Maintainer: Put new public prototypes here ^, in libpng.3, and project defs */ |
#define PNG_HEADER_VERSION_STRING \ |
" libpng version 1.2.5 - October 3, 2002 (header)\n" |
#ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED |
/* With these routines we avoid an integer divide, which will be slower on |
* most machines. However, it does take more operations than the corresponding |
* divide method, so it may be slower on a few RISC systems. There are two |
* shifts (by 8 or 16 bits) and an addition, versus a single integer divide. |
* |
* Note that the rounding factors are NOT supposed to be the same! 128 and |
* 32768 are correct for the NODIV code; 127 and 32767 are correct for the |
* standard method. |
* |
* [Optimized code by Greg Roelofs and Mark Adler...blame us for bugs. :-) ] |
*/ |
/* fg and bg should be in `gamma 1.0' space; alpha is the opacity */ |
# define png_composite(composite, fg, alpha, bg) \ |
{ png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) * (png_uint_16)(alpha) \ |
+ (png_uint_16)(bg)*(png_uint_16)(255 - \ |
(png_uint_16)(alpha)) + (png_uint_16)128); \ |
(composite) = (png_byte)((temp + (temp >> 8)) >> 8); } |
# define png_composite_16(composite, fg, alpha, bg) \ |
{ png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) * (png_uint_32)(alpha) \ |
+ (png_uint_32)(bg)*(png_uint_32)(65535L - \ |
(png_uint_32)(alpha)) + (png_uint_32)32768L); \ |
(composite) = (png_uint_16)((temp + (temp >> 16)) >> 16); } |
#else /* standard method using integer division */ |
# define png_composite(composite, fg, alpha, bg) \ |
(composite) = (png_byte)(((png_uint_16)(fg) * (png_uint_16)(alpha) + \ |
(png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \ |
(png_uint_16)127) / 255) |
# define png_composite_16(composite, fg, alpha, bg) \ |
(composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + \ |
(png_uint_32)(bg)*(png_uint_32)(65535L - (png_uint_32)(alpha)) + \ |
(png_uint_32)32767) / (png_uint_32)65535L) |
#endif /* PNG_READ_COMPOSITE_NODIV_SUPPORTED */ |
/* These next functions are used internally in the code. They generally |
* shouldn't be used unless you are writing code to add or replace some |
* functionality in libpng. More information about most functions can |
* be found in the files where the functions are located. |
*/ |
#if defined(PNG_INTERNAL) |
/* Various modes of operation. Note that after an init, mode is set to |
* zero automatically when the structure is created. |
*/ |
#define PNG_HAVE_IHDR 0x01 |
#define PNG_HAVE_PLTE 0x02 |
#define PNG_HAVE_IDAT 0x04 |
#define PNG_AFTER_IDAT 0x08 |
#define PNG_HAVE_IEND 0x10 |
#define PNG_HAVE_gAMA 0x20 |
#define PNG_HAVE_cHRM 0x40 |
#define PNG_HAVE_sRGB 0x80 |
#define PNG_HAVE_CHUNK_HEADER 0x100 |
#define PNG_WROTE_tIME 0x200 |
#define PNG_WROTE_INFO_BEFORE_PLTE 0x400 |
#define PNG_BACKGROUND_IS_GRAY 0x800 |
#define PNG_HAVE_PNG_SIGNATURE 0x1000 |
/* flags for the transformations the PNG library does on the image data */ |
#define PNG_BGR 0x0001 |
#define PNG_INTERLACE 0x0002 |
#define PNG_PACK 0x0004 |
#define PNG_SHIFT 0x0008 |
#define PNG_SWAP_BYTES 0x0010 |
#define PNG_INVERT_MONO 0x0020 |
#define PNG_DITHER 0x0040 |
#define PNG_BACKGROUND 0x0080 |
#define PNG_BACKGROUND_EXPAND 0x0100 |
/* 0x0200 unused */ |
#define PNG_16_TO_8 0x0400 |
#define PNG_RGBA 0x0800 |
#define PNG_EXPAND 0x1000 |
#define PNG_GAMMA 0x2000 |
#define PNG_GRAY_TO_RGB 0x4000 |
#define PNG_FILLER 0x8000L |
#define PNG_PACKSWAP 0x10000L |
#define PNG_SWAP_ALPHA 0x20000L |
#define PNG_STRIP_ALPHA 0x40000L |
#define PNG_INVERT_ALPHA 0x80000L |
#define PNG_USER_TRANSFORM 0x100000L |
#define PNG_RGB_TO_GRAY_ERR 0x200000L |
#define PNG_RGB_TO_GRAY_WARN 0x400000L |
#define PNG_RGB_TO_GRAY 0x600000L /* two bits, RGB_TO_GRAY_ERR|WARN */ |
/* flags for png_create_struct */ |
#define PNG_STRUCT_PNG 0x0001 |
#define PNG_STRUCT_INFO 0x0002 |
/* Scaling factor for filter heuristic weighting calculations */ |
#define PNG_WEIGHT_SHIFT 8 |
#define PNG_WEIGHT_FACTOR (1<<(PNG_WEIGHT_SHIFT)) |
#define PNG_COST_SHIFT 3 |
#define PNG_COST_FACTOR (1<<(PNG_COST_SHIFT)) |
/* flags for the png_ptr->flags rather than declaring a byte for each one */ |
#define PNG_FLAG_ZLIB_CUSTOM_STRATEGY 0x0001 |
#define PNG_FLAG_ZLIB_CUSTOM_LEVEL 0x0002 |
#define PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL 0x0004 |
#define PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS 0x0008 |
#define PNG_FLAG_ZLIB_CUSTOM_METHOD 0x0010 |
#define PNG_FLAG_ZLIB_FINISHED 0x0020 |
#define PNG_FLAG_ROW_INIT 0x0040 |
#define PNG_FLAG_FILLER_AFTER 0x0080 |
#define PNG_FLAG_CRC_ANCILLARY_USE 0x0100 |
#define PNG_FLAG_CRC_ANCILLARY_NOWARN 0x0200 |
#define PNG_FLAG_CRC_CRITICAL_USE 0x0400 |
#define PNG_FLAG_CRC_CRITICAL_IGNORE 0x0800 |
#define PNG_FLAG_FREE_PLTE 0x1000 |
#define PNG_FLAG_FREE_TRNS 0x2000 |
#define PNG_FLAG_FREE_HIST 0x4000 |
#define PNG_FLAG_KEEP_UNKNOWN_CHUNKS 0x8000L |
#define PNG_FLAG_KEEP_UNSAFE_CHUNKS 0x10000L |
#define PNG_FLAG_LIBRARY_MISMATCH 0x20000L |
#define PNG_FLAG_STRIP_ERROR_NUMBERS 0x40000L |
#define PNG_FLAG_STRIP_ERROR_TEXT 0x80000L |
#define PNG_FLAG_MALLOC_NULL_MEM_OK 0x100000L |
/* For use in png_set_keep_unknown, png_handle_as_unknown */ |
#define HANDLE_CHUNK_AS_DEFAULT 0 |
#define HANDLE_CHUNK_NEVER 1 |
#define HANDLE_CHUNK_IF_SAFE 2 |
#define HANDLE_CHUNK_ALWAYS 3 |
#define PNG_FLAG_CRC_ANCILLARY_MASK (PNG_FLAG_CRC_ANCILLARY_USE | \ |
PNG_FLAG_CRC_ANCILLARY_NOWARN) |
#define PNG_FLAG_CRC_CRITICAL_MASK (PNG_FLAG_CRC_CRITICAL_USE | \ |
PNG_FLAG_CRC_CRITICAL_IGNORE) |
#define PNG_FLAG_CRC_MASK (PNG_FLAG_CRC_ANCILLARY_MASK | \ |
PNG_FLAG_CRC_CRITICAL_MASK) |
/* save typing and make code easier to understand */ |
#define PNG_COLOR_DIST(c1, c2) (abs((int)((c1).red) - (int)((c2).red)) + \ |
abs((int)((c1).green) - (int)((c2).green)) + \ |
abs((int)((c1).blue) - (int)((c2).blue))) |
/* variables declared in png.c - only it needs to define PNG_NO_EXTERN */ |
#if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN) |
/* place to hold the signature string for a PNG file. */ |
#ifdef PNG_USE_GLOBAL_ARRAYS |
PNG_EXPORT_VAR (const png_byte FARDATA) png_sig[8]; |
#else |
#define png_sig png_sig_bytes(NULL) |
#endif |
#endif /* PNG_NO_EXTERN */ |
/* Constant strings for known chunk types. If you need to add a chunk, |
* define the name here, and add an invocation of the macro in png.c and |
* wherever it's needed. |
*/ |
#define PNG_IHDR const png_byte png_IHDR[5] = { 73, 72, 68, 82, '\0'} |
#define PNG_IDAT const png_byte png_IDAT[5] = { 73, 68, 65, 84, '\0'} |
#define PNG_IEND const png_byte png_IEND[5] = { 73, 69, 78, 68, '\0'} |
#define PNG_PLTE const png_byte png_PLTE[5] = { 80, 76, 84, 69, '\0'} |
#define PNG_bKGD const png_byte png_bKGD[5] = { 98, 75, 71, 68, '\0'} |
#define PNG_cHRM const png_byte png_cHRM[5] = { 99, 72, 82, 77, '\0'} |
#define PNG_gAMA const png_byte png_gAMA[5] = {103, 65, 77, 65, '\0'} |
#define PNG_hIST const png_byte png_hIST[5] = {104, 73, 83, 84, '\0'} |
#define PNG_iCCP const png_byte png_iCCP[5] = {105, 67, 67, 80, '\0'} |
#define PNG_iTXt const png_byte png_iTXt[5] = {105, 84, 88, 116, '\0'} |
#define PNG_oFFs const png_byte png_oFFs[5] = {111, 70, 70, 115, '\0'} |
#define PNG_pCAL const png_byte png_pCAL[5] = {112, 67, 65, 76, '\0'} |
#define PNG_sCAL const png_byte png_sCAL[5] = {115, 67, 65, 76, '\0'} |
#define PNG_pHYs const png_byte png_pHYs[5] = {112, 72, 89, 115, '\0'} |
#define PNG_sBIT const png_byte png_sBIT[5] = {115, 66, 73, 84, '\0'} |
#define PNG_sPLT const png_byte png_sPLT[5] = {115, 80, 76, 84, '\0'} |
#define PNG_sRGB const png_byte png_sRGB[5] = {115, 82, 71, 66, '\0'} |
#define PNG_tEXt const png_byte png_tEXt[5] = {116, 69, 88, 116, '\0'} |
#define PNG_tIME const png_byte png_tIME[5] = {116, 73, 77, 69, '\0'} |
#define PNG_tRNS const png_byte png_tRNS[5] = {116, 82, 78, 83, '\0'} |
#define PNG_zTXt const png_byte png_zTXt[5] = {122, 84, 88, 116, '\0'} |
#ifdef PNG_USE_GLOBAL_ARRAYS |
PNG_EXPORT_VAR (const png_byte FARDATA) png_IHDR[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_IDAT[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_IEND[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_PLTE[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_bKGD[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_cHRM[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_gAMA[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_hIST[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_iCCP[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_iTXt[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_oFFs[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_pCAL[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_sCAL[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_pHYs[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_sBIT[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_sPLT[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_sRGB[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_tEXt[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_tIME[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_tRNS[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_zTXt[5]; |
#endif /* PNG_USE_GLOBAL_ARRAYS */ |
/* Inline macros to do direct reads of bytes from the input buffer. These |
* require that you are using an architecture that uses PNG byte ordering |
* (MSB first) and supports unaligned data storage. I think that PowerPC |
* in big-endian mode and 680x0 are the only ones that will support this. |
* The x86 line of processors definitely do not. The png_get_int_32() |
* routine also assumes we are using two's complement format for negative |
* values, which is almost certainly true. |
*/ |
#if defined(PNG_READ_BIG_ENDIAN_SUPPORTED) |
# if defined(PNG_pCAL_SUPPORTED) || defined(PNG_oFFs_SUPPORTED) |
# define png_get_int_32(buf) ( *((png_int_32p) (buf))) |
# endif |
# define png_get_uint_32(buf) ( *((png_uint_32p) (buf))) |
# define png_get_uint_16(buf) ( *((png_uint_16p) (buf))) |
#else |
# if defined(PNG_pCAL_SUPPORTED) || defined(PNG_oFFs_SUPPORTED) |
PNG_EXTERN png_int_32 png_get_int_32 PNGARG((png_bytep buf)); |
# endif |
PNG_EXTERN png_uint_32 png_get_uint_32 PNGARG((png_bytep buf)); |
PNG_EXTERN png_uint_16 png_get_uint_16 PNGARG((png_bytep buf)); |
#endif /* !PNG_READ_BIG_ENDIAN_SUPPORTED */ |
/* Initialize png_ptr struct for reading, and allocate any other memory. |
* (old interface - DEPRECATED - use png_create_read_struct instead). |
*/ |
extern PNG_EXPORT(void,png_read_init) PNGARG((png_structp png_ptr)); |
#undef png_read_init |
#define png_read_init(png_ptr) png_read_init_3(&png_ptr, \ |
PNG_LIBPNG_VER_STRING, sizeof(png_struct)); |
extern PNG_EXPORT(void,png_read_init_3) PNGARG((png_structpp ptr_ptr, |
png_const_charp user_png_ver, png_size_t png_struct_size)); |
extern PNG_EXPORT(void,png_read_init_2) PNGARG((png_structp png_ptr, |
png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t |
png_info_size)); |
/* Initialize png_ptr struct for writing, and allocate any other memory. |
* (old interface - DEPRECATED - use png_create_write_struct instead). |
*/ |
extern PNG_EXPORT(void,png_write_init) PNGARG((png_structp png_ptr)); |
#undef png_write_init |
#define png_write_init(png_ptr) png_write_init_3(&png_ptr, \ |
PNG_LIBPNG_VER_STRING, sizeof(png_struct)); |
extern PNG_EXPORT(void,png_write_init_3) PNGARG((png_structpp ptr_ptr, |
png_const_charp user_png_ver, png_size_t png_struct_size)); |
extern PNG_EXPORT(void,png_write_init_2) PNGARG((png_structp png_ptr, |
png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t |
png_info_size)); |
/* Allocate memory for an internal libpng struct */ |
PNG_EXTERN png_voidp png_create_struct PNGARG((int type)); |
/* Free memory from internal libpng struct */ |
PNG_EXTERN void png_destroy_struct PNGARG((png_voidp struct_ptr)); |
PNG_EXTERN png_voidp png_create_struct_2 PNGARG((int type, png_malloc_ptr |
malloc_fn, png_voidp mem_ptr)); |
PNG_EXTERN void png_destroy_struct_2 PNGARG((png_voidp struct_ptr, |
png_free_ptr free_fn, png_voidp mem_ptr)); |
/* Free any memory that info_ptr points to and reset struct. */ |
PNG_EXTERN void png_info_destroy PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
#ifndef PNG_1_0_X |
/* Function to allocate memory for zlib. */ |
PNG_EXTERN voidpf png_zalloc PNGARG((voidpf png_ptr, uInt items, uInt size)); |
/* Function to free memory for zlib */ |
PNG_EXTERN void png_zfree PNGARG((voidpf png_ptr, voidpf ptr)); |
/* Next four functions are used internally as callbacks. PNGAPI is required |
* but not PNG_EXPORT. PNGAPI added at libpng version 1.2.3. */ |
PNG_EXTERN void PNGAPI png_default_read_data PNGARG((png_structp png_ptr, |
png_bytep data, png_size_t length)); |
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
PNG_EXTERN void PNGAPI png_push_fill_buffer PNGARG((png_structp png_ptr, |
png_bytep buffer, png_size_t length)); |
#endif |
PNG_EXTERN void PNGAPI png_default_write_data PNGARG((png_structp png_ptr, |
png_bytep data, png_size_t length)); |
#if defined(PNG_WRITE_FLUSH_SUPPORTED) |
#if !defined(PNG_NO_STDIO) |
PNG_EXTERN void PNGAPI png_default_flush PNGARG((png_structp png_ptr)); |
#endif |
#endif |
#else /* PNG_1_0_X */ |
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
PNG_EXTERN void png_push_fill_buffer PNGARG((png_structp png_ptr, |
png_bytep buffer, png_size_t length)); |
#endif |
#endif /* PNG_1_0_X */ |
/* Reset the CRC variable */ |
PNG_EXTERN void png_reset_crc PNGARG((png_structp png_ptr)); |
/* Write the "data" buffer to whatever output you are using. */ |
PNG_EXTERN void png_write_data PNGARG((png_structp png_ptr, png_bytep data, |
png_size_t length)); |
/* Read data from whatever input you are using into the "data" buffer */ |
PNG_EXTERN void png_read_data PNGARG((png_structp png_ptr, png_bytep data, |
png_size_t length)); |
/* Read bytes into buf, and update png_ptr->crc */ |
PNG_EXTERN void png_crc_read PNGARG((png_structp png_ptr, png_bytep buf, |
png_size_t length)); |
/* Decompress data in a chunk that uses compression */ |
#if defined(PNG_zTXt_SUPPORTED) || defined(PNG_iTXt_SUPPORTED) || \ |
defined(PNG_iCCP_SUPPORTED) || defined(PNG_sPLT_SUPPORTED) |
PNG_EXTERN png_charp png_decompress_chunk PNGARG((png_structp png_ptr, |
int comp_type, png_charp chunkdata, png_size_t chunklength, |
png_size_t prefix_length, png_size_t *data_length)); |
#endif |
/* Read "skip" bytes, read the file crc, and (optionally) verify png_ptr->crc */ |
PNG_EXTERN int png_crc_finish PNGARG((png_structp png_ptr, png_uint_32 skip)); |
/* Read the CRC from the file and compare it to the libpng calculated CRC */ |
PNG_EXTERN int png_crc_error PNGARG((png_structp png_ptr)); |
/* Calculate the CRC over a section of data. Note that we are only |
* passing a maximum of 64K on systems that have this as a memory limit, |
* since this is the maximum buffer size we can specify. |
*/ |
PNG_EXTERN void png_calculate_crc PNGARG((png_structp png_ptr, png_bytep ptr, |
png_size_t length)); |
#if defined(PNG_WRITE_FLUSH_SUPPORTED) |
PNG_EXTERN void png_flush PNGARG((png_structp png_ptr)); |
#endif |
/* Place a 32-bit number into a buffer in PNG byte order (big-endian). |
* The only currently known PNG chunks that use signed numbers are |
* the ancillary extension chunks, oFFs and pCAL. |
*/ |
PNG_EXTERN void png_save_uint_32 PNGARG((png_bytep buf, png_uint_32 i)); |
#if defined(PNG_WRITE_pCAL_SUPPORTED) || defined(PNG_WRITE_oFFs_SUPPORTED) |
PNG_EXTERN void png_save_int_32 PNGARG((png_bytep buf, png_int_32 i)); |
#endif |
/* Place a 16-bit number into a buffer in PNG byte order. |
* The parameter is declared unsigned int, not png_uint_16, |
* just to avoid potential problems on pre-ANSI C compilers. |
*/ |
PNG_EXTERN void png_save_uint_16 PNGARG((png_bytep buf, unsigned int i)); |
/* simple function to write the signature */ |
PNG_EXTERN void png_write_sig PNGARG((png_structp png_ptr)); |
/* write various chunks */ |
/* Write the IHDR chunk, and update the png_struct with the necessary |
* information. |
*/ |
PNG_EXTERN void png_write_IHDR PNGARG((png_structp png_ptr, png_uint_32 width, |
png_uint_32 height, |
int bit_depth, int color_type, int compression_method, int filter_method, |
int interlace_method)); |
PNG_EXTERN void png_write_PLTE PNGARG((png_structp png_ptr, png_colorp palette, |
png_uint_32 num_pal)); |
PNG_EXTERN void png_write_IDAT PNGARG((png_structp png_ptr, png_bytep data, |
png_size_t length)); |
PNG_EXTERN void png_write_IEND PNGARG((png_structp png_ptr)); |
#if defined(PNG_WRITE_gAMA_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
PNG_EXTERN void png_write_gAMA PNGARG((png_structp png_ptr, double file_gamma)); |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
PNG_EXTERN void png_write_gAMA_fixed PNGARG((png_structp png_ptr, png_fixed_point |
file_gamma)); |
#endif |
#endif |
#if defined(PNG_WRITE_sBIT_SUPPORTED) |
PNG_EXTERN void png_write_sBIT PNGARG((png_structp png_ptr, png_color_8p sbit, |
int color_type)); |
#endif |
#if defined(PNG_WRITE_cHRM_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
PNG_EXTERN void png_write_cHRM PNGARG((png_structp png_ptr, |
double white_x, double white_y, |
double red_x, double red_y, double green_x, double green_y, |
double blue_x, double blue_y)); |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
PNG_EXTERN void png_write_cHRM_fixed PNGARG((png_structp png_ptr, |
png_fixed_point int_white_x, png_fixed_point int_white_y, |
png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point |
int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, |
png_fixed_point int_blue_y)); |
#endif |
#endif |
#if defined(PNG_WRITE_sRGB_SUPPORTED) |
PNG_EXTERN void png_write_sRGB PNGARG((png_structp png_ptr, |
int intent)); |
#endif |
#if defined(PNG_WRITE_iCCP_SUPPORTED) |
PNG_EXTERN void png_write_iCCP PNGARG((png_structp png_ptr, |
png_charp name, int compression_type, |
png_charp profile, int proflen)); |
/* Note to maintainer: profile should be png_bytep */ |
#endif |
#if defined(PNG_WRITE_sPLT_SUPPORTED) |
PNG_EXTERN void png_write_sPLT PNGARG((png_structp png_ptr, |
png_sPLT_tp palette)); |
#endif |
#if defined(PNG_WRITE_tRNS_SUPPORTED) |
PNG_EXTERN void png_write_tRNS PNGARG((png_structp png_ptr, png_bytep trans, |
png_color_16p values, int number, int color_type)); |
#endif |
#if defined(PNG_WRITE_bKGD_SUPPORTED) |
PNG_EXTERN void png_write_bKGD PNGARG((png_structp png_ptr, |
png_color_16p values, int color_type)); |
#endif |
#if defined(PNG_WRITE_hIST_SUPPORTED) |
PNG_EXTERN void png_write_hIST PNGARG((png_structp png_ptr, png_uint_16p hist, |
int num_hist)); |
#endif |
#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \ |
defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED) |
PNG_EXTERN png_size_t png_check_keyword PNGARG((png_structp png_ptr, |
png_charp key, png_charpp new_key)); |
#endif |
#if defined(PNG_WRITE_tEXt_SUPPORTED) |
PNG_EXTERN void png_write_tEXt PNGARG((png_structp png_ptr, png_charp key, |
png_charp text, png_size_t text_len)); |
#endif |
#if defined(PNG_WRITE_zTXt_SUPPORTED) |
PNG_EXTERN void png_write_zTXt PNGARG((png_structp png_ptr, png_charp key, |
png_charp text, png_size_t text_len, int compression)); |
#endif |
#if defined(PNG_WRITE_iTXt_SUPPORTED) |
PNG_EXTERN void png_write_iTXt PNGARG((png_structp png_ptr, |
int compression, png_charp key, png_charp lang, png_charp lang_key, |
png_charp text)); |
#endif |
#if defined(PNG_TEXT_SUPPORTED) /* Added at version 1.0.14 and 1.2.4 */ |
PNG_EXTERN int png_set_text_2 PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_textp text_ptr, int num_text)); |
#endif |
#if defined(PNG_WRITE_oFFs_SUPPORTED) |
PNG_EXTERN void png_write_oFFs PNGARG((png_structp png_ptr, |
png_int_32 x_offset, png_int_32 y_offset, int unit_type)); |
#endif |
#if defined(PNG_WRITE_pCAL_SUPPORTED) |
PNG_EXTERN void png_write_pCAL PNGARG((png_structp png_ptr, png_charp purpose, |
png_int_32 X0, png_int_32 X1, int type, int nparams, |
png_charp units, png_charpp params)); |
#endif |
#if defined(PNG_WRITE_pHYs_SUPPORTED) |
PNG_EXTERN void png_write_pHYs PNGARG((png_structp png_ptr, |
png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit, |
int unit_type)); |
#endif |
#if defined(PNG_WRITE_tIME_SUPPORTED) |
PNG_EXTERN void png_write_tIME PNGARG((png_structp png_ptr, |
png_timep mod_time)); |
#endif |
#if defined(PNG_WRITE_sCAL_SUPPORTED) |
#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO) |
PNG_EXTERN void png_write_sCAL PNGARG((png_structp png_ptr, |
int unit, double width, double height)); |
#else |
#ifdef PNG_FIXED_POINT_SUPPORTED |
PNG_EXTERN void png_write_sCAL_s PNGARG((png_structp png_ptr, |
int unit, png_charp width, png_charp height)); |
#endif |
#endif |
#endif |
/* Called when finished processing a row of data */ |
PNG_EXTERN void png_write_finish_row PNGARG((png_structp png_ptr)); |
/* Internal use only. Called before first row of data */ |
PNG_EXTERN void png_write_start_row PNGARG((png_structp png_ptr)); |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
PNG_EXTERN void png_build_gamma_table PNGARG((png_structp png_ptr)); |
#endif |
/* combine a row of data, dealing with alpha, etc. if requested */ |
PNG_EXTERN void png_combine_row PNGARG((png_structp png_ptr, png_bytep row, |
int mask)); |
#if defined(PNG_READ_INTERLACING_SUPPORTED) |
/* expand an interlaced row */ |
/* OLD pre-1.0.9 interface: |
PNG_EXTERN void png_do_read_interlace PNGARG((png_row_infop row_info, |
png_bytep row, int pass, png_uint_32 transformations)); |
*/ |
PNG_EXTERN void png_do_read_interlace PNGARG((png_structp png_ptr)); |
#endif |
/* GRR TO DO (2.0 or whenever): simplify other internal calling interfaces */ |
#if defined(PNG_WRITE_INTERLACING_SUPPORTED) |
/* grab pixels out of a row for an interlaced pass */ |
PNG_EXTERN void png_do_write_interlace PNGARG((png_row_infop row_info, |
png_bytep row, int pass)); |
#endif |
/* unfilter a row */ |
PNG_EXTERN void png_read_filter_row PNGARG((png_structp png_ptr, |
png_row_infop row_info, png_bytep row, png_bytep prev_row, int filter)); |
/* Choose the best filter to use and filter the row data */ |
PNG_EXTERN void png_write_find_filter PNGARG((png_structp png_ptr, |
png_row_infop row_info)); |
/* Write out the filtered row. */ |
PNG_EXTERN void png_write_filtered_row PNGARG((png_structp png_ptr, |
png_bytep filtered_row)); |
/* finish a row while reading, dealing with interlacing passes, etc. */ |
PNG_EXTERN void png_read_finish_row PNGARG((png_structp png_ptr)); |
/* initialize the row buffers, etc. */ |
PNG_EXTERN void png_read_start_row PNGARG((png_structp png_ptr)); |
/* optional call to update the users info structure */ |
PNG_EXTERN void png_read_transform_info PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
/* these are the functions that do the transformations */ |
#if defined(PNG_READ_FILLER_SUPPORTED) |
PNG_EXTERN void png_do_read_filler PNGARG((png_row_infop row_info, |
png_bytep row, png_uint_32 filler, png_uint_32 flags)); |
#endif |
#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) |
PNG_EXTERN void png_do_read_swap_alpha PNGARG((png_row_infop row_info, |
png_bytep row)); |
#endif |
#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) |
PNG_EXTERN void png_do_write_swap_alpha PNGARG((png_row_infop row_info, |
png_bytep row)); |
#endif |
#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) |
PNG_EXTERN void png_do_read_invert_alpha PNGARG((png_row_infop row_info, |
png_bytep row)); |
#endif |
#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) |
PNG_EXTERN void png_do_write_invert_alpha PNGARG((png_row_infop row_info, |
png_bytep row)); |
#endif |
#if defined(PNG_WRITE_FILLER_SUPPORTED) || \ |
defined(PNG_READ_STRIP_ALPHA_SUPPORTED) |
PNG_EXTERN void png_do_strip_filler PNGARG((png_row_infop row_info, |
png_bytep row, png_uint_32 flags)); |
#endif |
#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) |
PNG_EXTERN void png_do_swap PNGARG((png_row_infop row_info, png_bytep row)); |
#endif |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED) |
PNG_EXTERN void png_do_packswap PNGARG((png_row_infop row_info, png_bytep row)); |
#endif |
#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) |
PNG_EXTERN int png_do_rgb_to_gray PNGARG((png_structp png_ptr, png_row_infop |
row_info, png_bytep row)); |
#endif |
#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) |
PNG_EXTERN void png_do_gray_to_rgb PNGARG((png_row_infop row_info, |
png_bytep row)); |
#endif |
#if defined(PNG_READ_PACK_SUPPORTED) |
PNG_EXTERN void png_do_unpack PNGARG((png_row_infop row_info, png_bytep row)); |
#endif |
#if defined(PNG_READ_SHIFT_SUPPORTED) |
PNG_EXTERN void png_do_unshift PNGARG((png_row_infop row_info, png_bytep row, |
png_color_8p sig_bits)); |
#endif |
#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) |
PNG_EXTERN void png_do_invert PNGARG((png_row_infop row_info, png_bytep row)); |
#endif |
#if defined(PNG_READ_16_TO_8_SUPPORTED) |
PNG_EXTERN void png_do_chop PNGARG((png_row_infop row_info, png_bytep row)); |
#endif |
#if defined(PNG_READ_DITHER_SUPPORTED) |
PNG_EXTERN void png_do_dither PNGARG((png_row_infop row_info, |
png_bytep row, png_bytep palette_lookup, png_bytep dither_lookup)); |
# if defined(PNG_CORRECT_PALETTE_SUPPORTED) |
PNG_EXTERN void png_correct_palette PNGARG((png_structp png_ptr, |
png_colorp palette, int num_palette)); |
# endif |
#endif |
#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) |
PNG_EXTERN void png_do_bgr PNGARG((png_row_infop row_info, png_bytep row)); |
#endif |
#if defined(PNG_WRITE_PACK_SUPPORTED) |
PNG_EXTERN void png_do_pack PNGARG((png_row_infop row_info, |
png_bytep row, png_uint_32 bit_depth)); |
#endif |
#if defined(PNG_WRITE_SHIFT_SUPPORTED) |
PNG_EXTERN void png_do_shift PNGARG((png_row_infop row_info, png_bytep row, |
png_color_8p bit_depth)); |
#endif |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row, |
png_color_16p trans_values, png_color_16p background, |
png_color_16p background_1, |
png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1, |
png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1, |
png_uint_16pp gamma_16_to_1, int gamma_shift)); |
#else |
PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row, |
png_color_16p trans_values, png_color_16p background)); |
#endif |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
PNG_EXTERN void png_do_gamma PNGARG((png_row_infop row_info, png_bytep row, |
png_bytep gamma_table, png_uint_16pp gamma_16_table, |
int gamma_shift)); |
#endif |
#if defined(PNG_READ_EXPAND_SUPPORTED) |
PNG_EXTERN void png_do_expand_palette PNGARG((png_row_infop row_info, |
png_bytep row, png_colorp palette, png_bytep trans, int num_trans)); |
PNG_EXTERN void png_do_expand PNGARG((png_row_infop row_info, |
png_bytep row, png_color_16p trans_value)); |
#endif |
/* The following decodes the appropriate chunks, and does error correction, |
* then calls the appropriate callback for the chunk if it is valid. |
*/ |
/* decode the IHDR chunk */ |
PNG_EXTERN void png_handle_IHDR PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
PNG_EXTERN void png_handle_PLTE PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
PNG_EXTERN void png_handle_IEND PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#if defined(PNG_READ_bKGD_SUPPORTED) |
PNG_EXTERN void png_handle_bKGD PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#if defined(PNG_READ_cHRM_SUPPORTED) |
PNG_EXTERN void png_handle_cHRM PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#if defined(PNG_READ_gAMA_SUPPORTED) |
PNG_EXTERN void png_handle_gAMA PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#if defined(PNG_READ_hIST_SUPPORTED) |
PNG_EXTERN void png_handle_hIST PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#if defined(PNG_READ_iCCP_SUPPORTED) |
extern void png_handle_iCCP PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif /* PNG_READ_iCCP_SUPPORTED */ |
#if defined(PNG_READ_iTXt_SUPPORTED) |
PNG_EXTERN void png_handle_iTXt PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#if defined(PNG_READ_oFFs_SUPPORTED) |
PNG_EXTERN void png_handle_oFFs PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#if defined(PNG_READ_pCAL_SUPPORTED) |
PNG_EXTERN void png_handle_pCAL PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#if defined(PNG_READ_pHYs_SUPPORTED) |
PNG_EXTERN void png_handle_pHYs PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#if defined(PNG_READ_sBIT_SUPPORTED) |
PNG_EXTERN void png_handle_sBIT PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#if defined(PNG_READ_sCAL_SUPPORTED) |
PNG_EXTERN void png_handle_sCAL PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#if defined(PNG_READ_sPLT_SUPPORTED) |
extern void png_handle_sPLT PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif /* PNG_READ_sPLT_SUPPORTED */ |
#if defined(PNG_READ_sRGB_SUPPORTED) |
PNG_EXTERN void png_handle_sRGB PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#if defined(PNG_READ_tEXt_SUPPORTED) |
PNG_EXTERN void png_handle_tEXt PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#if defined(PNG_READ_tIME_SUPPORTED) |
PNG_EXTERN void png_handle_tIME PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#if defined(PNG_READ_tRNS_SUPPORTED) |
PNG_EXTERN void png_handle_tRNS PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#if defined(PNG_READ_zTXt_SUPPORTED) |
PNG_EXTERN void png_handle_zTXt PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
PNG_EXTERN void png_handle_unknown PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_uint_32 length)); |
PNG_EXTERN void png_check_chunk_name PNGARG((png_structp png_ptr, |
png_bytep chunk_name)); |
/* handle the transformations for reading and writing */ |
PNG_EXTERN void png_do_read_transformations PNGARG((png_structp png_ptr)); |
PNG_EXTERN void png_do_write_transformations PNGARG((png_structp png_ptr)); |
PNG_EXTERN void png_init_read_transformations PNGARG((png_structp png_ptr)); |
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
PNG_EXTERN void png_push_read_chunk PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
PNG_EXTERN void png_push_read_sig PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
PNG_EXTERN void png_push_check_crc PNGARG((png_structp png_ptr)); |
PNG_EXTERN void png_push_crc_skip PNGARG((png_structp png_ptr, |
png_uint_32 length)); |
PNG_EXTERN void png_push_crc_finish PNGARG((png_structp png_ptr)); |
PNG_EXTERN void png_push_save_buffer PNGARG((png_structp png_ptr)); |
PNG_EXTERN void png_push_restore_buffer PNGARG((png_structp png_ptr, |
png_bytep buffer, png_size_t buffer_length)); |
PNG_EXTERN void png_push_read_IDAT PNGARG((png_structp png_ptr)); |
PNG_EXTERN void png_process_IDAT_data PNGARG((png_structp png_ptr, |
png_bytep buffer, png_size_t buffer_length)); |
PNG_EXTERN void png_push_process_row PNGARG((png_structp png_ptr)); |
PNG_EXTERN void png_push_handle_unknown PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_uint_32 length)); |
PNG_EXTERN void png_push_have_info PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
PNG_EXTERN void png_push_have_end PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
PNG_EXTERN void png_push_have_row PNGARG((png_structp png_ptr, png_bytep row)); |
PNG_EXTERN void png_push_read_end PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
PNG_EXTERN void png_process_some_data PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
PNG_EXTERN void png_read_push_finish_row PNGARG((png_structp png_ptr)); |
#if defined(PNG_READ_tEXt_SUPPORTED) |
PNG_EXTERN void png_push_handle_tEXt PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_uint_32 length)); |
PNG_EXTERN void png_push_read_tEXt PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
#endif |
#if defined(PNG_READ_zTXt_SUPPORTED) |
PNG_EXTERN void png_push_handle_zTXt PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_uint_32 length)); |
PNG_EXTERN void png_push_read_zTXt PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
#endif |
#if defined(PNG_READ_iTXt_SUPPORTED) |
PNG_EXTERN void png_push_handle_iTXt PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_uint_32 length)); |
PNG_EXTERN void png_push_read_iTXt PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
#endif |
#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ |
#ifdef PNG_MNG_FEATURES_SUPPORTED |
PNG_EXTERN void png_do_read_intrapixel PNGARG((png_row_infop row_info, |
png_bytep row)); |
PNG_EXTERN void png_do_write_intrapixel PNGARG((png_row_infop row_info, |
png_bytep row)); |
#endif |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) |
/* png.c */ /* PRIVATE */ |
PNG_EXTERN void png_init_mmx_flags PNGARG((png_structp png_ptr)); |
#endif |
/* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */ |
#endif /* PNG_INTERNAL */ |
#ifdef __cplusplus |
} |
#endif |
#endif /* PNG_VERSION_INFO_ONLY */ |
/* do not put anything past this line */ |
#endif /* PNG_H */ |
/shark/trunk/ports/png/pngerror.c |
---|
0,0 → 1,291 |
/* pngerror.c - stub functions for i/o and memory allocation |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
* This file provides a location for all error handling. Users who |
* need special error handling are expected to write replacement functions |
* and use png_set_error_fn() to use those functions. See the instructions |
* at each function. |
*/ |
#define PNG_INTERNAL |
#include "png.h" |
static void /* PRIVATE */ |
png_default_error PNGARG((png_structp png_ptr, |
png_const_charp error_message)); |
static void /* PRIVATE */ |
png_default_warning PNGARG((png_structp png_ptr, |
png_const_charp warning_message)); |
/* This function is called whenever there is a fatal error. This function |
* should not be changed. If there is a need to handle errors differently, |
* you should supply a replacement error function and use png_set_error_fn() |
* to replace the error function at run-time. |
*/ |
void PNGAPI |
png_error(png_structp png_ptr, png_const_charp error_message) |
{ |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
char msg[16]; |
if (png_ptr->flags&(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) |
{ |
int offset = 0; |
if (*error_message == '#') |
{ |
for (offset=1; offset<15; offset++) |
if (*(error_message+offset) == ' ') |
break; |
if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT) |
{ |
int i; |
for (i=0; i<offset-1; i++) |
msg[i]=error_message[i+1]; |
msg[i]='\0'; |
error_message=msg; |
} |
else |
error_message+=offset; |
} |
else |
{ |
if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT) |
{ |
msg[0]='0'; |
msg[1]='\0'; |
error_message=msg; |
} |
} |
} |
#endif |
if (png_ptr->error_fn != NULL) |
(*(png_ptr->error_fn))(png_ptr, error_message); |
/* if the following returns or doesn't exist, use the default function, |
which will not return */ |
png_default_error(png_ptr, error_message); |
} |
/* This function is called whenever there is a non-fatal error. This function |
* should not be changed. If there is a need to handle warnings differently, |
* you should supply a replacement warning function and use |
* png_set_error_fn() to replace the warning function at run-time. |
*/ |
void PNGAPI |
png_warning(png_structp png_ptr, png_const_charp warning_message) |
{ |
int offset = 0; |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
if (png_ptr->flags&(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) |
#endif |
{ |
if (*warning_message == '#') |
{ |
for (offset=1; offset<15; offset++) |
if (*(warning_message+offset) == ' ') |
break; |
} |
} |
if (png_ptr->warning_fn != NULL) |
(*(png_ptr->warning_fn))(png_ptr, |
(png_const_charp)(warning_message+offset)); |
else |
png_default_warning(png_ptr, (png_const_charp)(warning_message+offset)); |
} |
/* These utilities are used internally to build an error message that relates |
* to the current chunk. The chunk name comes from png_ptr->chunk_name, |
* this is used to prefix the message. The message is limited in length |
* to 63 bytes, the name characters are output as hex digits wrapped in [] |
* if the character is invalid. |
*/ |
#define isnonalpha(c) ((c) < 41 || (c) > 122 || ((c) > 90 && (c) < 97)) |
static PNG_CONST char png_digit[16] = { |
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', |
'F' }; |
static void /* PRIVATE */ |
png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp |
error_message) |
{ |
int iout = 0, iin = 0; |
while (iin < 4) |
{ |
int c = png_ptr->chunk_name[iin++]; |
if (isnonalpha(c)) |
{ |
buffer[iout++] = '['; |
buffer[iout++] = png_digit[(c & 0xf0) >> 4]; |
buffer[iout++] = png_digit[c & 0x0f]; |
buffer[iout++] = ']'; |
} |
else |
{ |
buffer[iout++] = (png_byte)c; |
} |
} |
if (error_message == NULL) |
buffer[iout] = 0; |
else |
{ |
buffer[iout++] = ':'; |
buffer[iout++] = ' '; |
png_memcpy(buffer+iout, error_message, 64); |
buffer[iout+63] = 0; |
} |
} |
void PNGAPI |
png_chunk_error(png_structp png_ptr, png_const_charp error_message) |
{ |
char msg[18+64]; |
png_format_buffer(png_ptr, msg, error_message); |
png_error(png_ptr, msg); |
} |
void PNGAPI |
png_chunk_warning(png_structp png_ptr, png_const_charp warning_message) |
{ |
char msg[18+64]; |
png_format_buffer(png_ptr, msg, warning_message); |
png_warning(png_ptr, msg); |
} |
/* This is the default error handling function. Note that replacements for |
* this function MUST NOT RETURN, or the program will likely crash. This |
* function is used by default, or if the program supplies NULL for the |
* error function pointer in png_set_error_fn(). |
*/ |
static void /* PRIVATE */ |
png_default_error(png_structp png_ptr, png_const_charp error_message) |
{ |
#ifndef PNG_NO_CONSOLE_IO |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
if (*error_message == '#') |
{ |
int offset; |
char error_number[16]; |
for (offset=0; offset<15; offset++) |
{ |
error_number[offset] = *(error_message+offset+1); |
if (*(error_message+offset) == ' ') |
break; |
} |
if((offset > 1) && (offset < 15)) |
{ |
error_number[offset-1]='\0'; |
cprintf("libpng error no. %s: %s\n", error_number, |
error_message+offset); |
} |
else |
cprintf("libpng error: %s, offset=%d\n", error_message,offset); |
} |
else |
#endif |
cprintf("libpng error: %s\n", error_message); |
#else |
if (error_message) |
/* make compiler happy */ ; |
#endif |
#ifdef PNG_SETJMP_SUPPORTED |
# ifdef USE_FAR_KEYWORD |
{ |
jmp_buf jmpbuf; |
png_memcpy(jmpbuf,png_ptr->jmpbuf,sizeof(jmp_buf)); |
longjmp(jmpbuf, 1); |
} |
# else |
longjmp(png_ptr->jmpbuf, 1); |
# endif |
#else |
if (png_ptr) |
/* make compiler happy */ ; |
PNG_ABORT(); |
#endif |
} |
/* This function is called when there is a warning, but the library thinks |
* it can continue anyway. Replacement functions don't have to do anything |
* here if you don't want them to. In the default configuration, png_ptr is |
* not used, but it is passed in case it may be useful. |
*/ |
static void /* PRIVATE */ |
png_default_warning(png_structp png_ptr, png_const_charp warning_message) |
{ |
#ifndef PNG_NO_CONSOLE_IO |
# ifdef PNG_ERROR_NUMBERS_SUPPORTED |
if (*warning_message == '#') |
{ |
int offset; |
char warning_number[16]; |
for (offset=0; offset<15; offset++) |
{ |
warning_number[offset]=*(warning_message+offset+1); |
if (*(warning_message+offset) == ' ') |
break; |
} |
if((offset > 1) && (offset < 15)) |
{ |
warning_number[offset-1]='\0'; |
cprintf("libpng warning no. %s: %s\n", warning_number, |
warning_message+offset); |
} |
else |
cprintf("libpng warning: %s\n", warning_message); |
} |
else |
# endif |
cprintf("libpng warning: %s\n", warning_message); |
#else |
if (warning_message) |
/* appease compiler */ ; |
#endif |
if (png_ptr) |
return; |
} |
/* This function is called when the application wants to use another method |
* of handling errors and warnings. Note that the error function MUST NOT |
* return to the calling routine or serious problems will occur. The return |
* method used in the default routine calls longjmp(png_ptr->jmpbuf, 1) |
*/ |
void PNGAPI |
png_set_error_fn(png_structp png_ptr, png_voidp error_ptr, |
png_error_ptr error_fn, png_error_ptr warning_fn) |
{ |
png_ptr->error_ptr = error_ptr; |
png_ptr->error_fn = error_fn; |
png_ptr->warning_fn = warning_fn; |
} |
/* This function returns a pointer to the error_ptr associated with the user |
* functions. The application should free any memory associated with this |
* pointer before png_write_destroy and png_read_destroy are called. |
*/ |
png_voidp PNGAPI |
png_get_error_ptr(png_structp png_ptr) |
{ |
return ((png_voidp)png_ptr->error_ptr); |
} |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
void PNGAPI |
png_set_strip_error_numbers(png_structp png_ptr, png_uint_32 strip_mode) |
{ |
if(png_ptr != NULL) |
{ |
png_ptr->flags &= |
((~(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode); |
} |
} |
#endif |
/shark/trunk/ports/png/pngwtran.c |
---|
0,0 → 1,563 |
/* pngwtran.c - transforms the data in a row for PNG writers |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
*/ |
#define PNG_INTERNAL |
#include "png.h" |
#ifdef PNG_WRITE_SUPPORTED |
/* Transform the data according to the user's wishes. The order of |
* transformations is significant. |
*/ |
void /* PRIVATE */ |
png_do_write_transformations(png_structp png_ptr) |
{ |
png_debug(1, "in png_do_write_transformations\n"); |
if (png_ptr == NULL) |
return; |
#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) |
if (png_ptr->transformations & PNG_USER_TRANSFORM) |
if(png_ptr->write_user_transform_fn != NULL) |
(*(png_ptr->write_user_transform_fn)) /* user write transform function */ |
(png_ptr, /* png_ptr */ |
&(png_ptr->row_info), /* row_info: */ |
/* png_uint_32 width; width of row */ |
/* png_uint_32 rowbytes; number of bytes in row */ |
/* png_byte color_type; color type of pixels */ |
/* png_byte bit_depth; bit depth of samples */ |
/* png_byte channels; number of channels (1-4) */ |
/* png_byte pixel_depth; bits per pixel (depth*channels) */ |
png_ptr->row_buf + 1); /* start of pixel data for row */ |
#endif |
#if defined(PNG_WRITE_FILLER_SUPPORTED) |
if (png_ptr->transformations & PNG_FILLER) |
png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1, |
png_ptr->flags); |
#endif |
#if defined(PNG_WRITE_PACKSWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_PACKSWAP) |
png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#if defined(PNG_WRITE_PACK_SUPPORTED) |
if (png_ptr->transformations & PNG_PACK) |
png_do_pack(&(png_ptr->row_info), png_ptr->row_buf + 1, |
(png_uint_32)png_ptr->bit_depth); |
#endif |
#if defined(PNG_WRITE_SWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_SWAP_BYTES) |
png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#if defined(PNG_WRITE_SHIFT_SUPPORTED) |
if (png_ptr->transformations & PNG_SHIFT) |
png_do_shift(&(png_ptr->row_info), png_ptr->row_buf + 1, |
&(png_ptr->shift)); |
#endif |
#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) |
if (png_ptr->transformations & PNG_INVERT_ALPHA) |
png_do_write_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) |
if (png_ptr->transformations & PNG_SWAP_ALPHA) |
png_do_write_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#if defined(PNG_WRITE_BGR_SUPPORTED) |
if (png_ptr->transformations & PNG_BGR) |
png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#if defined(PNG_WRITE_INVERT_SUPPORTED) |
if (png_ptr->transformations & PNG_INVERT_MONO) |
png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
} |
#if defined(PNG_WRITE_PACK_SUPPORTED) |
/* Pack pixels into bytes. Pass the true bit depth in bit_depth. The |
* row_info bit depth should be 8 (one pixel per byte). The channels |
* should be 1 (this only happens on grayscale and paletted images). |
*/ |
void /* PRIVATE */ |
png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth) |
{ |
png_debug(1, "in png_do_pack\n"); |
if (row_info->bit_depth == 8 && |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
row != NULL && row_info != NULL && |
#endif |
row_info->channels == 1) |
{ |
switch ((int)bit_depth) |
{ |
case 1: |
{ |
png_bytep sp, dp; |
int mask, v; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
sp = row; |
dp = row; |
mask = 0x80; |
v = 0; |
for (i = 0; i < row_width; i++) |
{ |
if (*sp != 0) |
v |= mask; |
sp++; |
if (mask > 1) |
mask >>= 1; |
else |
{ |
mask = 0x80; |
*dp = (png_byte)v; |
dp++; |
v = 0; |
} |
} |
if (mask != 0x80) |
*dp = (png_byte)v; |
break; |
} |
case 2: |
{ |
png_bytep sp, dp; |
int shift, v; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
sp = row; |
dp = row; |
shift = 6; |
v = 0; |
for (i = 0; i < row_width; i++) |
{ |
png_byte value; |
value = (png_byte)(*sp & 0x03); |
v |= (value << shift); |
if (shift == 0) |
{ |
shift = 6; |
*dp = (png_byte)v; |
dp++; |
v = 0; |
} |
else |
shift -= 2; |
sp++; |
} |
if (shift != 6) |
*dp = (png_byte)v; |
break; |
} |
case 4: |
{ |
png_bytep sp, dp; |
int shift, v; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
sp = row; |
dp = row; |
shift = 4; |
v = 0; |
for (i = 0; i < row_width; i++) |
{ |
png_byte value; |
value = (png_byte)(*sp & 0x0f); |
v |= (value << shift); |
if (shift == 0) |
{ |
shift = 4; |
*dp = (png_byte)v; |
dp++; |
v = 0; |
} |
else |
shift -= 4; |
sp++; |
} |
if (shift != 4) |
*dp = (png_byte)v; |
break; |
} |
} |
row_info->bit_depth = (png_byte)bit_depth; |
row_info->pixel_depth = (png_byte)(bit_depth * row_info->channels); |
row_info->rowbytes = |
((row_info->width * row_info->pixel_depth + 7) >> 3); |
} |
} |
#endif |
#if defined(PNG_WRITE_SHIFT_SUPPORTED) |
/* Shift pixel values to take advantage of whole range. Pass the |
* true number of bits in bit_depth. The row should be packed |
* according to row_info->bit_depth. Thus, if you had a row of |
* bit depth 4, but the pixels only had values from 0 to 7, you |
* would pass 3 as bit_depth, and this routine would translate the |
* data to 0 to 15. |
*/ |
void /* PRIVATE */ |
png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth) |
{ |
png_debug(1, "in png_do_shift\n"); |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
if (row != NULL && row_info != NULL && |
#else |
if ( |
#endif |
row_info->color_type != PNG_COLOR_TYPE_PALETTE) |
{ |
int shift_start[4], shift_dec[4]; |
int channels = 0; |
if (row_info->color_type & PNG_COLOR_MASK_COLOR) |
{ |
shift_start[channels] = row_info->bit_depth - bit_depth->red; |
shift_dec[channels] = bit_depth->red; |
channels++; |
shift_start[channels] = row_info->bit_depth - bit_depth->green; |
shift_dec[channels] = bit_depth->green; |
channels++; |
shift_start[channels] = row_info->bit_depth - bit_depth->blue; |
shift_dec[channels] = bit_depth->blue; |
channels++; |
} |
else |
{ |
shift_start[channels] = row_info->bit_depth - bit_depth->gray; |
shift_dec[channels] = bit_depth->gray; |
channels++; |
} |
if (row_info->color_type & PNG_COLOR_MASK_ALPHA) |
{ |
shift_start[channels] = row_info->bit_depth - bit_depth->alpha; |
shift_dec[channels] = bit_depth->alpha; |
channels++; |
} |
/* with low row depths, could only be grayscale, so one channel */ |
if (row_info->bit_depth < 8) |
{ |
png_bytep bp = row; |
png_uint_32 i; |
png_byte mask; |
png_uint_32 row_bytes = row_info->rowbytes; |
if (bit_depth->gray == 1 && row_info->bit_depth == 2) |
mask = 0x55; |
else if (row_info->bit_depth == 4 && bit_depth->gray == 3) |
mask = 0x11; |
else |
mask = 0xff; |
for (i = 0; i < row_bytes; i++, bp++) |
{ |
png_uint_16 v; |
int j; |
v = *bp; |
*bp = 0; |
for (j = shift_start[0]; j > -shift_dec[0]; j -= shift_dec[0]) |
{ |
if (j > 0) |
*bp |= (png_byte)((v << j) & 0xff); |
else |
*bp |= (png_byte)((v >> (-j)) & mask); |
} |
} |
} |
else if (row_info->bit_depth == 8) |
{ |
png_bytep bp = row; |
png_uint_32 i; |
png_uint_32 istop = channels * row_info->width; |
for (i = 0; i < istop; i++, bp++) |
{ |
png_uint_16 v; |
int j; |
int c = (int)(i%channels); |
v = *bp; |
*bp = 0; |
for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c]) |
{ |
if (j > 0) |
*bp |= (png_byte)((v << j) & 0xff); |
else |
*bp |= (png_byte)((v >> (-j)) & 0xff); |
} |
} |
} |
else |
{ |
png_bytep bp; |
png_uint_32 i; |
png_uint_32 istop = channels * row_info->width; |
for (bp = row, i = 0; i < istop; i++) |
{ |
int c = (int)(i%channels); |
png_uint_16 value, v; |
int j; |
v = (png_uint_16)(((png_uint_16)(*bp) << 8) + *(bp + 1)); |
value = 0; |
for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c]) |
{ |
if (j > 0) |
value |= (png_uint_16)((v << j) & (png_uint_16)0xffff); |
else |
value |= (png_uint_16)((v >> (-j)) & (png_uint_16)0xffff); |
} |
*bp++ = (png_byte)(value >> 8); |
*bp++ = (png_byte)(value & 0xff); |
} |
} |
} |
} |
#endif |
#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) |
void /* PRIVATE */ |
png_do_write_swap_alpha(png_row_infop row_info, png_bytep row) |
{ |
png_debug(1, "in png_do_write_swap_alpha\n"); |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
if (row != NULL && row_info != NULL) |
#endif |
{ |
if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
{ |
/* This converts from ARGB to RGBA */ |
if (row_info->bit_depth == 8) |
{ |
png_bytep sp, dp; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
for (i = 0, sp = dp = row; i < row_width; i++) |
{ |
png_byte save = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = save; |
} |
} |
/* This converts from AARRGGBB to RRGGBBAA */ |
else |
{ |
png_bytep sp, dp; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
for (i = 0, sp = dp = row; i < row_width; i++) |
{ |
png_byte save[2]; |
save[0] = *(sp++); |
save[1] = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = save[0]; |
*(dp++) = save[1]; |
} |
} |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) |
{ |
/* This converts from AG to GA */ |
if (row_info->bit_depth == 8) |
{ |
png_bytep sp, dp; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
for (i = 0, sp = dp = row; i < row_width; i++) |
{ |
png_byte save = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = save; |
} |
} |
/* This converts from AAGG to GGAA */ |
else |
{ |
png_bytep sp, dp; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
for (i = 0, sp = dp = row; i < row_width; i++) |
{ |
png_byte save[2]; |
save[0] = *(sp++); |
save[1] = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = save[0]; |
*(dp++) = save[1]; |
} |
} |
} |
} |
} |
#endif |
#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) |
void /* PRIVATE */ |
png_do_write_invert_alpha(png_row_infop row_info, png_bytep row) |
{ |
png_debug(1, "in png_do_write_invert_alpha\n"); |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
if (row != NULL && row_info != NULL) |
#endif |
{ |
if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
{ |
/* This inverts the alpha channel in RGBA */ |
if (row_info->bit_depth == 8) |
{ |
png_bytep sp, dp; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
for (i = 0, sp = dp = row; i < row_width; i++) |
{ |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = (png_byte)(255 - *(sp++)); |
} |
} |
/* This inverts the alpha channel in RRGGBBAA */ |
else |
{ |
png_bytep sp, dp; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
for (i = 0, sp = dp = row; i < row_width; i++) |
{ |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = (png_byte)(255 - *(sp++)); |
*(dp++) = (png_byte)(255 - *(sp++)); |
} |
} |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) |
{ |
/* This inverts the alpha channel in GA */ |
if (row_info->bit_depth == 8) |
{ |
png_bytep sp, dp; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
for (i = 0, sp = dp = row; i < row_width; i++) |
{ |
*(dp++) = *(sp++); |
*(dp++) = (png_byte)(255 - *(sp++)); |
} |
} |
/* This inverts the alpha channel in GGAA */ |
else |
{ |
png_bytep sp, dp; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
for (i = 0, sp = dp = row; i < row_width; i++) |
{ |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = (png_byte)(255 - *(sp++)); |
*(dp++) = (png_byte)(255 - *(sp++)); |
} |
} |
} |
} |
} |
#endif |
#if defined(PNG_MNG_FEATURES_SUPPORTED) |
/* undoes intrapixel differencing */ |
void /* PRIVATE */ |
png_do_write_intrapixel(png_row_infop row_info, png_bytep row) |
{ |
png_debug(1, "in png_do_write_intrapixel\n"); |
if ( |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
row != NULL && row_info != NULL && |
#endif |
(row_info->color_type & PNG_COLOR_MASK_COLOR)) |
{ |
int bytes_per_pixel; |
png_uint_32 row_width = row_info->width; |
if (row_info->bit_depth == 8) |
{ |
png_bytep rp; |
png_uint_32 i; |
if (row_info->color_type == PNG_COLOR_TYPE_RGB) |
bytes_per_pixel = 3; |
else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
bytes_per_pixel = 4; |
else |
return; |
for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel) |
{ |
*(rp) = (png_byte)((*rp - *(rp+1))&0xff); |
*(rp+2) = (png_byte)((*(rp+2) - *(rp+1))&0xff); |
} |
} |
else if (row_info->bit_depth == 16) |
{ |
png_bytep rp; |
png_uint_32 i; |
if (row_info->color_type == PNG_COLOR_TYPE_RGB) |
bytes_per_pixel = 6; |
else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
bytes_per_pixel = 8; |
else |
return; |
for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel) |
{ |
png_uint_32 s0=*(rp )<<8 | *(rp+1); |
png_uint_32 s1=*(rp+2)<<8 | *(rp+3); |
png_uint_32 s2=*(rp+4)<<8 | *(rp+5); |
png_uint_32 red=(s0-s1)&0xffff; |
png_uint_32 blue=(s2-s1)&0xffff; |
*(rp ) = (png_byte)((red>>8)&0xff); |
*(rp+1) = (png_byte)(red&0xff); |
*(rp+4) = (png_byte)((blue>>8)&0xff); |
*(rp+5) = (png_byte)(blue&0xff); |
} |
} |
} |
} |
#endif /* PNG_MNG_FEATURES_SUPPORTED */ |
#endif /* PNG_WRITE_SUPPORTED */ |
/shark/trunk/ports/png/pngvcrd.c |
---|
0,0 → 1,3845 |
/* pngvcrd.c - mixed C/assembler version of utilities to read a PNG file |
* |
* For Intel x86 CPU and Microsoft Visual C++ compiler |
* |
* libpng version 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* Copyright (c) 1998, Intel Corporation |
* |
* Contributed by Nirav Chhatrapati, Intel Corporation, 1998 |
* Interface to libpng contributed by Gilles Vollant, 1999 |
* |
* |
* In png_do_read_interlace() in libpng versions 1.0.3a through 1.0.4d, |
* a sign error in the post-MMX cleanup code for each pixel_depth resulted |
* in bad pixels at the beginning of some rows of some images, and also |
* (due to out-of-range memory reads and writes) caused heap corruption |
* when compiled with MSVC 6.0. The error was fixed in version 1.0.4e. |
* |
* [png_read_filter_row_mmx_avg() bpp == 2 bugfix, GRR 20000916] |
* |
* [runtime MMX configuration, GRR 20010102] |
* |
*/ |
#define PNG_INTERNAL |
#include "png.h" |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_USE_PNGVCRD) |
static int mmx_supported=2; |
int PNGAPI |
png_mmx_support(void) |
{ |
int mmx_supported_local = 0; |
_asm { |
push ebx //CPUID will trash these |
push ecx |
push edx |
pushfd //Save Eflag to stack |
pop eax //Get Eflag from stack into eax |
mov ecx, eax //Make another copy of Eflag in ecx |
xor eax, 0x200000 //Toggle ID bit in Eflag [i.e. bit(21)] |
push eax //Save modified Eflag back to stack |
popfd //Restored modified value back to Eflag reg |
pushfd //Save Eflag to stack |
pop eax //Get Eflag from stack |
push ecx // save original Eflag to stack |
popfd // restore original Eflag |
xor eax, ecx //Compare the new Eflag with the original Eflag |
jz NOT_SUPPORTED //If the same, CPUID instruction is not supported, |
//skip following instructions and jump to |
//NOT_SUPPORTED label |
xor eax, eax //Set eax to zero |
_asm _emit 0x0f //CPUID instruction (two bytes opcode) |
_asm _emit 0xa2 |
cmp eax, 1 //make sure eax return non-zero value |
jl NOT_SUPPORTED //If eax is zero, mmx not supported |
xor eax, eax //set eax to zero |
inc eax //Now increment eax to 1. This instruction is |
//faster than the instruction "mov eax, 1" |
_asm _emit 0x0f //CPUID instruction |
_asm _emit 0xa2 |
and edx, 0x00800000 //mask out all bits but mmx bit(24) |
cmp edx, 0 // 0 = mmx not supported |
jz NOT_SUPPORTED // non-zero = Yes, mmx IS supported |
mov mmx_supported_local, 1 //set return value to 1 |
NOT_SUPPORTED: |
mov eax, mmx_supported_local //move return value to eax |
pop edx //CPUID trashed these |
pop ecx |
pop ebx |
} |
//mmx_supported_local=0; // test code for force don't support MMX |
//printf("MMX : %u (1=MMX supported)\n",mmx_supported_local); |
mmx_supported = mmx_supported_local; |
return mmx_supported_local; |
} |
/* Combines the row recently read in with the previous row. |
This routine takes care of alpha and transparency if requested. |
This routine also handles the two methods of progressive display |
of interlaced images, depending on the mask value. |
The mask value describes which pixels are to be combined with |
the row. The pattern always repeats every 8 pixels, so just 8 |
bits are needed. A one indicates the pixel is to be combined; a |
zero indicates the pixel is to be skipped. This is in addition |
to any alpha or transparency value associated with the pixel. If |
you want all pixels to be combined, pass 0xff (255) in mask. */ |
/* Use this routine for x86 platform - uses faster MMX routine if machine |
supports MMX */ |
void /* PRIVATE */ |
png_combine_row(png_structp png_ptr, png_bytep row, int mask) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
#endif |
png_debug(1,"in png_combine_row_asm\n"); |
if (mmx_supported == 2) { |
/* this should have happened in png_init_mmx_flags() already */ |
png_warning(png_ptr, "asm_flags may not have been initialized"); |
png_mmx_support(); |
} |
if (mask == 0xff) |
{ |
png_memcpy(row, png_ptr->row_buf + 1, |
(png_size_t)((png_ptr->width * png_ptr->row_info.pixel_depth + 7) >> 3)); |
} |
/* GRR: add "else if (mask == 0)" case? |
* or does png_combine_row() not even get called in that case? */ |
else |
{ |
switch (png_ptr->row_info.pixel_depth) |
{ |
case 1: |
{ |
png_bytep sp; |
png_bytep dp; |
int s_inc, s_start, s_end; |
int m; |
int shift; |
png_uint_32 i; |
sp = png_ptr->row_buf + 1; |
dp = row; |
m = 0x80; |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_PACKSWAP) |
{ |
s_start = 0; |
s_end = 7; |
s_inc = 1; |
} |
else |
#endif |
{ |
s_start = 7; |
s_end = 0; |
s_inc = -1; |
} |
shift = s_start; |
for (i = 0; i < png_ptr->width; i++) |
{ |
if (m & mask) |
{ |
int value; |
value = (*sp >> shift) & 0x1; |
*dp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff); |
*dp |= (png_byte)(value << shift); |
} |
if (shift == s_end) |
{ |
shift = s_start; |
sp++; |
dp++; |
} |
else |
shift += s_inc; |
if (m == 1) |
m = 0x80; |
else |
m >>= 1; |
} |
break; |
} |
case 2: |
{ |
png_bytep sp; |
png_bytep dp; |
int s_start, s_end, s_inc; |
int m; |
int shift; |
png_uint_32 i; |
int value; |
sp = png_ptr->row_buf + 1; |
dp = row; |
m = 0x80; |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_PACKSWAP) |
{ |
s_start = 0; |
s_end = 6; |
s_inc = 2; |
} |
else |
#endif |
{ |
s_start = 6; |
s_end = 0; |
s_inc = -2; |
} |
shift = s_start; |
for (i = 0; i < png_ptr->width; i++) |
{ |
if (m & mask) |
{ |
value = (*sp >> shift) & 0x3; |
*dp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); |
*dp |= (png_byte)(value << shift); |
} |
if (shift == s_end) |
{ |
shift = s_start; |
sp++; |
dp++; |
} |
else |
shift += s_inc; |
if (m == 1) |
m = 0x80; |
else |
m >>= 1; |
} |
break; |
} |
case 4: |
{ |
png_bytep sp; |
png_bytep dp; |
int s_start, s_end, s_inc; |
int m; |
int shift; |
png_uint_32 i; |
int value; |
sp = png_ptr->row_buf + 1; |
dp = row; |
m = 0x80; |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_PACKSWAP) |
{ |
s_start = 0; |
s_end = 4; |
s_inc = 4; |
} |
else |
#endif |
{ |
s_start = 4; |
s_end = 0; |
s_inc = -4; |
} |
shift = s_start; |
for (i = 0; i < png_ptr->width; i++) |
{ |
if (m & mask) |
{ |
value = (*sp >> shift) & 0xf; |
*dp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); |
*dp |= (png_byte)(value << shift); |
} |
if (shift == s_end) |
{ |
shift = s_start; |
sp++; |
dp++; |
} |
else |
shift += s_inc; |
if (m == 1) |
m = 0x80; |
else |
m >>= 1; |
} |
break; |
} |
case 8: |
{ |
png_bytep srcptr; |
png_bytep dstptr; |
png_uint_32 len; |
int m; |
int diff, unmask; |
__int64 mask0=0x0102040810204080; |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) |
/* && mmx_supported */ ) |
{ |
srcptr = png_ptr->row_buf + 1; |
dstptr = row; |
m = 0x80; |
unmask = ~mask; |
len = png_ptr->width &~7; //reduce to multiple of 8 |
diff = png_ptr->width & 7; //amount lost |
_asm |
{ |
movd mm7, unmask //load bit pattern |
psubb mm6,mm6 //zero mm6 |
punpcklbw mm7,mm7 |
punpcklwd mm7,mm7 |
punpckldq mm7,mm7 //fill register with 8 masks |
movq mm0,mask0 |
pand mm0,mm7 //nonzero if keep byte |
pcmpeqb mm0,mm6 //zeros->1s, v versa |
mov ecx,len //load length of line (pixels) |
mov esi,srcptr //load source |
mov ebx,dstptr //load dest |
cmp ecx,0 //lcr |
je mainloop8end |
mainloop8: |
movq mm4,[esi] |
pand mm4,mm0 |
movq mm6,mm0 |
pandn mm6,[ebx] |
por mm4,mm6 |
movq [ebx],mm4 |
add esi,8 //inc by 8 bytes processed |
add ebx,8 |
sub ecx,8 //dec by 8 pixels processed |
ja mainloop8 |
mainloop8end: |
mov ecx,diff |
cmp ecx,0 |
jz end8 |
mov edx,mask |
sal edx,24 //make low byte the high byte |
secondloop8: |
sal edx,1 //move high bit to CF |
jnc skip8 //if CF = 0 |
mov al,[esi] |
mov [ebx],al |
skip8: |
inc esi |
inc ebx |
dec ecx |
jnz secondloop8 |
end8: |
emms |
} |
} |
else /* mmx not supported - use modified C routine */ |
{ |
register unsigned int incr1, initial_val, final_val; |
png_size_t pixel_bytes; |
png_uint_32 i; |
register int disp = png_pass_inc[png_ptr->pass]; |
int offset_table[7] = {0, 4, 0, 2, 0, 1, 0}; |
pixel_bytes = (png_ptr->row_info.pixel_depth >> 3); |
srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]* |
pixel_bytes; |
dstptr = row + offset_table[png_ptr->pass]*pixel_bytes; |
initial_val = offset_table[png_ptr->pass]*pixel_bytes; |
final_val = png_ptr->width*pixel_bytes; |
incr1 = (disp)*pixel_bytes; |
for (i = initial_val; i < final_val; i += incr1) |
{ |
png_memcpy(dstptr, srcptr, pixel_bytes); |
srcptr += incr1; |
dstptr += incr1; |
} |
} /* end of else */ |
break; |
} // end 8 bpp |
case 16: |
{ |
png_bytep srcptr; |
png_bytep dstptr; |
png_uint_32 len; |
int unmask, diff; |
__int64 mask1=0x0101020204040808, |
mask0=0x1010202040408080; |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) |
/* && mmx_supported */ ) |
{ |
srcptr = png_ptr->row_buf + 1; |
dstptr = row; |
unmask = ~mask; |
len = (png_ptr->width)&~7; |
diff = (png_ptr->width)&7; |
_asm |
{ |
movd mm7, unmask //load bit pattern |
psubb mm6,mm6 //zero mm6 |
punpcklbw mm7,mm7 |
punpcklwd mm7,mm7 |
punpckldq mm7,mm7 //fill register with 8 masks |
movq mm0,mask0 |
movq mm1,mask1 |
pand mm0,mm7 |
pand mm1,mm7 |
pcmpeqb mm0,mm6 |
pcmpeqb mm1,mm6 |
mov ecx,len //load length of line |
mov esi,srcptr //load source |
mov ebx,dstptr //load dest |
cmp ecx,0 //lcr |
jz mainloop16end |
mainloop16: |
movq mm4,[esi] |
pand mm4,mm0 |
movq mm6,mm0 |
movq mm7,[ebx] |
pandn mm6,mm7 |
por mm4,mm6 |
movq [ebx],mm4 |
movq mm5,[esi+8] |
pand mm5,mm1 |
movq mm7,mm1 |
movq mm6,[ebx+8] |
pandn mm7,mm6 |
por mm5,mm7 |
movq [ebx+8],mm5 |
add esi,16 //inc by 16 bytes processed |
add ebx,16 |
sub ecx,8 //dec by 8 pixels processed |
ja mainloop16 |
mainloop16end: |
mov ecx,diff |
cmp ecx,0 |
jz end16 |
mov edx,mask |
sal edx,24 //make low byte the high byte |
secondloop16: |
sal edx,1 //move high bit to CF |
jnc skip16 //if CF = 0 |
mov ax,[esi] |
mov [ebx],ax |
skip16: |
add esi,2 |
add ebx,2 |
dec ecx |
jnz secondloop16 |
end16: |
emms |
} |
} |
else /* mmx not supported - use modified C routine */ |
{ |
register unsigned int incr1, initial_val, final_val; |
png_size_t pixel_bytes; |
png_uint_32 i; |
register int disp = png_pass_inc[png_ptr->pass]; |
int offset_table[7] = {0, 4, 0, 2, 0, 1, 0}; |
pixel_bytes = (png_ptr->row_info.pixel_depth >> 3); |
srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]* |
pixel_bytes; |
dstptr = row + offset_table[png_ptr->pass]*pixel_bytes; |
initial_val = offset_table[png_ptr->pass]*pixel_bytes; |
final_val = png_ptr->width*pixel_bytes; |
incr1 = (disp)*pixel_bytes; |
for (i = initial_val; i < final_val; i += incr1) |
{ |
png_memcpy(dstptr, srcptr, pixel_bytes); |
srcptr += incr1; |
dstptr += incr1; |
} |
} /* end of else */ |
break; |
} // end 16 bpp |
case 24: |
{ |
png_bytep srcptr; |
png_bytep dstptr; |
png_uint_32 len; |
int unmask, diff; |
__int64 mask2=0x0101010202020404, //24bpp |
mask1=0x0408080810101020, |
mask0=0x2020404040808080; |
srcptr = png_ptr->row_buf + 1; |
dstptr = row; |
unmask = ~mask; |
len = (png_ptr->width)&~7; |
diff = (png_ptr->width)&7; |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) |
/* && mmx_supported */ ) |
{ |
_asm |
{ |
movd mm7, unmask //load bit pattern |
psubb mm6,mm6 //zero mm6 |
punpcklbw mm7,mm7 |
punpcklwd mm7,mm7 |
punpckldq mm7,mm7 //fill register with 8 masks |
movq mm0,mask0 |
movq mm1,mask1 |
movq mm2,mask2 |
pand mm0,mm7 |
pand mm1,mm7 |
pand mm2,mm7 |
pcmpeqb mm0,mm6 |
pcmpeqb mm1,mm6 |
pcmpeqb mm2,mm6 |
mov ecx,len //load length of line |
mov esi,srcptr //load source |
mov ebx,dstptr //load dest |
cmp ecx,0 |
jz mainloop24end |
mainloop24: |
movq mm4,[esi] |
pand mm4,mm0 |
movq mm6,mm0 |
movq mm7,[ebx] |
pandn mm6,mm7 |
por mm4,mm6 |
movq [ebx],mm4 |
movq mm5,[esi+8] |
pand mm5,mm1 |
movq mm7,mm1 |
movq mm6,[ebx+8] |
pandn mm7,mm6 |
por mm5,mm7 |
movq [ebx+8],mm5 |
movq mm6,[esi+16] |
pand mm6,mm2 |
movq mm4,mm2 |
movq mm7,[ebx+16] |
pandn mm4,mm7 |
por mm6,mm4 |
movq [ebx+16],mm6 |
add esi,24 //inc by 24 bytes processed |
add ebx,24 |
sub ecx,8 //dec by 8 pixels processed |
ja mainloop24 |
mainloop24end: |
mov ecx,diff |
cmp ecx,0 |
jz end24 |
mov edx,mask |
sal edx,24 //make low byte the high byte |
secondloop24: |
sal edx,1 //move high bit to CF |
jnc skip24 //if CF = 0 |
mov ax,[esi] |
mov [ebx],ax |
xor eax,eax |
mov al,[esi+2] |
mov [ebx+2],al |
skip24: |
add esi,3 |
add ebx,3 |
dec ecx |
jnz secondloop24 |
end24: |
emms |
} |
} |
else /* mmx not supported - use modified C routine */ |
{ |
register unsigned int incr1, initial_val, final_val; |
png_size_t pixel_bytes; |
png_uint_32 i; |
register int disp = png_pass_inc[png_ptr->pass]; |
int offset_table[7] = {0, 4, 0, 2, 0, 1, 0}; |
pixel_bytes = (png_ptr->row_info.pixel_depth >> 3); |
srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]* |
pixel_bytes; |
dstptr = row + offset_table[png_ptr->pass]*pixel_bytes; |
initial_val = offset_table[png_ptr->pass]*pixel_bytes; |
final_val = png_ptr->width*pixel_bytes; |
incr1 = (disp)*pixel_bytes; |
for (i = initial_val; i < final_val; i += incr1) |
{ |
png_memcpy(dstptr, srcptr, pixel_bytes); |
srcptr += incr1; |
dstptr += incr1; |
} |
} /* end of else */ |
break; |
} // end 24 bpp |
case 32: |
{ |
png_bytep srcptr; |
png_bytep dstptr; |
png_uint_32 len; |
int unmask, diff; |
__int64 mask3=0x0101010102020202, //32bpp |
mask2=0x0404040408080808, |
mask1=0x1010101020202020, |
mask0=0x4040404080808080; |
srcptr = png_ptr->row_buf + 1; |
dstptr = row; |
unmask = ~mask; |
len = (png_ptr->width)&~7; |
diff = (png_ptr->width)&7; |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) |
/* && mmx_supported */ ) |
{ |
_asm |
{ |
movd mm7, unmask //load bit pattern |
psubb mm6,mm6 //zero mm6 |
punpcklbw mm7,mm7 |
punpcklwd mm7,mm7 |
punpckldq mm7,mm7 //fill register with 8 masks |
movq mm0,mask0 |
movq mm1,mask1 |
movq mm2,mask2 |
movq mm3,mask3 |
pand mm0,mm7 |
pand mm1,mm7 |
pand mm2,mm7 |
pand mm3,mm7 |
pcmpeqb mm0,mm6 |
pcmpeqb mm1,mm6 |
pcmpeqb mm2,mm6 |
pcmpeqb mm3,mm6 |
mov ecx,len //load length of line |
mov esi,srcptr //load source |
mov ebx,dstptr //load dest |
cmp ecx,0 //lcr |
jz mainloop32end |
mainloop32: |
movq mm4,[esi] |
pand mm4,mm0 |
movq mm6,mm0 |
movq mm7,[ebx] |
pandn mm6,mm7 |
por mm4,mm6 |
movq [ebx],mm4 |
movq mm5,[esi+8] |
pand mm5,mm1 |
movq mm7,mm1 |
movq mm6,[ebx+8] |
pandn mm7,mm6 |
por mm5,mm7 |
movq [ebx+8],mm5 |
movq mm6,[esi+16] |
pand mm6,mm2 |
movq mm4,mm2 |
movq mm7,[ebx+16] |
pandn mm4,mm7 |
por mm6,mm4 |
movq [ebx+16],mm6 |
movq mm7,[esi+24] |
pand mm7,mm3 |
movq mm5,mm3 |
movq mm4,[ebx+24] |
pandn mm5,mm4 |
por mm7,mm5 |
movq [ebx+24],mm7 |
add esi,32 //inc by 32 bytes processed |
add ebx,32 |
sub ecx,8 //dec by 8 pixels processed |
ja mainloop32 |
mainloop32end: |
mov ecx,diff |
cmp ecx,0 |
jz end32 |
mov edx,mask |
sal edx,24 //make low byte the high byte |
secondloop32: |
sal edx,1 //move high bit to CF |
jnc skip32 //if CF = 0 |
mov eax,[esi] |
mov [ebx],eax |
skip32: |
add esi,4 |
add ebx,4 |
dec ecx |
jnz secondloop32 |
end32: |
emms |
} |
} |
else /* mmx _not supported - Use modified C routine */ |
{ |
register unsigned int incr1, initial_val, final_val; |
png_size_t pixel_bytes; |
png_uint_32 i; |
register int disp = png_pass_inc[png_ptr->pass]; |
int offset_table[7] = {0, 4, 0, 2, 0, 1, 0}; |
pixel_bytes = (png_ptr->row_info.pixel_depth >> 3); |
srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]* |
pixel_bytes; |
dstptr = row + offset_table[png_ptr->pass]*pixel_bytes; |
initial_val = offset_table[png_ptr->pass]*pixel_bytes; |
final_val = png_ptr->width*pixel_bytes; |
incr1 = (disp)*pixel_bytes; |
for (i = initial_val; i < final_val; i += incr1) |
{ |
png_memcpy(dstptr, srcptr, pixel_bytes); |
srcptr += incr1; |
dstptr += incr1; |
} |
} /* end of else */ |
break; |
} // end 32 bpp |
case 48: |
{ |
png_bytep srcptr; |
png_bytep dstptr; |
png_uint_32 len; |
int unmask, diff; |
__int64 mask5=0x0101010101010202, |
mask4=0x0202020204040404, |
mask3=0x0404080808080808, |
mask2=0x1010101010102020, |
mask1=0x2020202040404040, |
mask0=0x4040808080808080; |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) |
/* && mmx_supported */ ) |
{ |
srcptr = png_ptr->row_buf + 1; |
dstptr = row; |
unmask = ~mask; |
len = (png_ptr->width)&~7; |
diff = (png_ptr->width)&7; |
_asm |
{ |
movd mm7, unmask //load bit pattern |
psubb mm6,mm6 //zero mm6 |
punpcklbw mm7,mm7 |
punpcklwd mm7,mm7 |
punpckldq mm7,mm7 //fill register with 8 masks |
movq mm0,mask0 |
movq mm1,mask1 |
movq mm2,mask2 |
movq mm3,mask3 |
movq mm4,mask4 |
movq mm5,mask5 |
pand mm0,mm7 |
pand mm1,mm7 |
pand mm2,mm7 |
pand mm3,mm7 |
pand mm4,mm7 |
pand mm5,mm7 |
pcmpeqb mm0,mm6 |
pcmpeqb mm1,mm6 |
pcmpeqb mm2,mm6 |
pcmpeqb mm3,mm6 |
pcmpeqb mm4,mm6 |
pcmpeqb mm5,mm6 |
mov ecx,len //load length of line |
mov esi,srcptr //load source |
mov ebx,dstptr //load dest |
cmp ecx,0 |
jz mainloop48end |
mainloop48: |
movq mm7,[esi] |
pand mm7,mm0 |
movq mm6,mm0 |
pandn mm6,[ebx] |
por mm7,mm6 |
movq [ebx],mm7 |
movq mm6,[esi+8] |
pand mm6,mm1 |
movq mm7,mm1 |
pandn mm7,[ebx+8] |
por mm6,mm7 |
movq [ebx+8],mm6 |
movq mm6,[esi+16] |
pand mm6,mm2 |
movq mm7,mm2 |
pandn mm7,[ebx+16] |
por mm6,mm7 |
movq [ebx+16],mm6 |
movq mm7,[esi+24] |
pand mm7,mm3 |
movq mm6,mm3 |
pandn mm6,[ebx+24] |
por mm7,mm6 |
movq [ebx+24],mm7 |
movq mm6,[esi+32] |
pand mm6,mm4 |
movq mm7,mm4 |
pandn mm7,[ebx+32] |
por mm6,mm7 |
movq [ebx+32],mm6 |
movq mm7,[esi+40] |
pand mm7,mm5 |
movq mm6,mm5 |
pandn mm6,[ebx+40] |
por mm7,mm6 |
movq [ebx+40],mm7 |
add esi,48 //inc by 32 bytes processed |
add ebx,48 |
sub ecx,8 //dec by 8 pixels processed |
ja mainloop48 |
mainloop48end: |
mov ecx,diff |
cmp ecx,0 |
jz end48 |
mov edx,mask |
sal edx,24 //make low byte the high byte |
secondloop48: |
sal edx,1 //move high bit to CF |
jnc skip48 //if CF = 0 |
mov eax,[esi] |
mov [ebx],eax |
skip48: |
add esi,4 |
add ebx,4 |
dec ecx |
jnz secondloop48 |
end48: |
emms |
} |
} |
else /* mmx _not supported - Use modified C routine */ |
{ |
register unsigned int incr1, initial_val, final_val; |
png_size_t pixel_bytes; |
png_uint_32 i; |
register int disp = png_pass_inc[png_ptr->pass]; |
int offset_table[7] = {0, 4, 0, 2, 0, 1, 0}; |
pixel_bytes = (png_ptr->row_info.pixel_depth >> 3); |
srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]* |
pixel_bytes; |
dstptr = row + offset_table[png_ptr->pass]*pixel_bytes; |
initial_val = offset_table[png_ptr->pass]*pixel_bytes; |
final_val = png_ptr->width*pixel_bytes; |
incr1 = (disp)*pixel_bytes; |
for (i = initial_val; i < final_val; i += incr1) |
{ |
png_memcpy(dstptr, srcptr, pixel_bytes); |
srcptr += incr1; |
dstptr += incr1; |
} |
} /* end of else */ |
break; |
} // end 48 bpp |
default: |
{ |
png_bytep sptr; |
png_bytep dp; |
png_size_t pixel_bytes; |
int offset_table[7] = {0, 4, 0, 2, 0, 1, 0}; |
unsigned int i; |
register int disp = png_pass_inc[png_ptr->pass]; // get the offset |
register unsigned int incr1, initial_val, final_val; |
pixel_bytes = (png_ptr->row_info.pixel_depth >> 3); |
sptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]* |
pixel_bytes; |
dp = row + offset_table[png_ptr->pass]*pixel_bytes; |
initial_val = offset_table[png_ptr->pass]*pixel_bytes; |
final_val = png_ptr->width*pixel_bytes; |
incr1 = (disp)*pixel_bytes; |
for (i = initial_val; i < final_val; i += incr1) |
{ |
png_memcpy(dp, sptr, pixel_bytes); |
sptr += incr1; |
dp += incr1; |
} |
break; |
} |
} /* end switch (png_ptr->row_info.pixel_depth) */ |
} /* end if (non-trivial mask) */ |
} /* end png_combine_row() */ |
#if defined(PNG_READ_INTERLACING_SUPPORTED) |
void /* PRIVATE */ |
png_do_read_interlace(png_structp png_ptr) |
{ |
png_row_infop row_info = &(png_ptr->row_info); |
png_bytep row = png_ptr->row_buf + 1; |
int pass = png_ptr->pass; |
png_uint_32 transformations = png_ptr->transformations; |
#ifdef PNG_USE_LOCAL_ARRAYS |
const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
#endif |
png_debug(1,"in png_do_read_interlace\n"); |
if (mmx_supported == 2) { |
/* this should have happened in png_init_mmx_flags() already */ |
png_warning(png_ptr, "asm_flags may not have been initialized"); |
png_mmx_support(); |
} |
if (row != NULL && row_info != NULL) |
{ |
png_uint_32 final_width; |
final_width = row_info->width * png_pass_inc[pass]; |
switch (row_info->pixel_depth) |
{ |
case 1: |
{ |
png_bytep sp, dp; |
int sshift, dshift; |
int s_start, s_end, s_inc; |
png_byte v; |
png_uint_32 i; |
int j; |
sp = row + (png_size_t)((row_info->width - 1) >> 3); |
dp = row + (png_size_t)((final_width - 1) >> 3); |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (transformations & PNG_PACKSWAP) |
{ |
sshift = (int)((row_info->width + 7) & 7); |
dshift = (int)((final_width + 7) & 7); |
s_start = 7; |
s_end = 0; |
s_inc = -1; |
} |
else |
#endif |
{ |
sshift = 7 - (int)((row_info->width + 7) & 7); |
dshift = 7 - (int)((final_width + 7) & 7); |
s_start = 0; |
s_end = 7; |
s_inc = 1; |
} |
for (i = row_info->width; i; i--) |
{ |
v = (png_byte)((*sp >> sshift) & 0x1); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
*dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff); |
*dp |= (png_byte)(v << dshift); |
if (dshift == s_end) |
{ |
dshift = s_start; |
dp--; |
} |
else |
dshift += s_inc; |
} |
if (sshift == s_end) |
{ |
sshift = s_start; |
sp--; |
} |
else |
sshift += s_inc; |
} |
break; |
} |
case 2: |
{ |
png_bytep sp, dp; |
int sshift, dshift; |
int s_start, s_end, s_inc; |
png_uint_32 i; |
sp = row + (png_size_t)((row_info->width - 1) >> 2); |
dp = row + (png_size_t)((final_width - 1) >> 2); |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (transformations & PNG_PACKSWAP) |
{ |
sshift = (png_size_t)(((row_info->width + 3) & 3) << 1); |
dshift = (png_size_t)(((final_width + 3) & 3) << 1); |
s_start = 6; |
s_end = 0; |
s_inc = -2; |
} |
else |
#endif |
{ |
sshift = (png_size_t)((3 - ((row_info->width + 3) & 3)) << 1); |
dshift = (png_size_t)((3 - ((final_width + 3) & 3)) << 1); |
s_start = 0; |
s_end = 6; |
s_inc = 2; |
} |
for (i = row_info->width; i; i--) |
{ |
png_byte v; |
int j; |
v = (png_byte)((*sp >> sshift) & 0x3); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
*dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff); |
*dp |= (png_byte)(v << dshift); |
if (dshift == s_end) |
{ |
dshift = s_start; |
dp--; |
} |
else |
dshift += s_inc; |
} |
if (sshift == s_end) |
{ |
sshift = s_start; |
sp--; |
} |
else |
sshift += s_inc; |
} |
break; |
} |
case 4: |
{ |
png_bytep sp, dp; |
int sshift, dshift; |
int s_start, s_end, s_inc; |
png_uint_32 i; |
sp = row + (png_size_t)((row_info->width - 1) >> 1); |
dp = row + (png_size_t)((final_width - 1) >> 1); |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (transformations & PNG_PACKSWAP) |
{ |
sshift = (png_size_t)(((row_info->width + 1) & 1) << 2); |
dshift = (png_size_t)(((final_width + 1) & 1) << 2); |
s_start = 4; |
s_end = 0; |
s_inc = -4; |
} |
else |
#endif |
{ |
sshift = (png_size_t)((1 - ((row_info->width + 1) & 1)) << 2); |
dshift = (png_size_t)((1 - ((final_width + 1) & 1)) << 2); |
s_start = 0; |
s_end = 4; |
s_inc = 4; |
} |
for (i = row_info->width; i; i--) |
{ |
png_byte v; |
int j; |
v = (png_byte)((*sp >> sshift) & 0xf); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
*dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff); |
*dp |= (png_byte)(v << dshift); |
if (dshift == s_end) |
{ |
dshift = s_start; |
dp--; |
} |
else |
dshift += s_inc; |
} |
if (sshift == s_end) |
{ |
sshift = s_start; |
sp--; |
} |
else |
sshift += s_inc; |
} |
break; |
} |
default: // This is the place where the routine is modified |
{ |
__int64 const4 = 0x0000000000FFFFFF; |
// __int64 const5 = 0x000000FFFFFF0000; // unused... |
__int64 const6 = 0x00000000000000FF; |
png_bytep sptr, dp; |
png_uint_32 i; |
png_size_t pixel_bytes; |
int width = row_info->width; |
pixel_bytes = (row_info->pixel_depth >> 3); |
sptr = row + (width - 1) * pixel_bytes; |
dp = row + (final_width - 1) * pixel_bytes; |
// New code by Nirav Chhatrapati - Intel Corporation |
// sign fix by GRR |
// NOTE: there is NO MMX code for 48-bit and 64-bit images |
// use MMX routine if machine supports it |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_INTERLACE) |
/* && mmx_supported */ ) |
{ |
if (pixel_bytes == 3) |
{ |
if (((pass == 0) || (pass == 1)) && width) |
{ |
_asm |
{ |
mov esi, sptr |
mov edi, dp |
mov ecx, width |
sub edi, 21 // (png_pass_inc[pass] - 1)*pixel_bytes |
loop_pass0: |
movd mm0, [esi] ; X X X X X v2 v1 v0 |
pand mm0, const4 ; 0 0 0 0 0 v2 v1 v0 |
movq mm1, mm0 ; 0 0 0 0 0 v2 v1 v0 |
psllq mm0, 16 ; 0 0 0 v2 v1 v0 0 0 |
movq mm2, mm0 ; 0 0 0 v2 v1 v0 0 0 |
psllq mm0, 24 ; v2 v1 v0 0 0 0 0 0 |
psrlq mm1, 8 ; 0 0 0 0 0 0 v2 v1 |
por mm0, mm2 ; v2 v1 v0 v2 v1 v0 0 0 |
por mm0, mm1 ; v2 v1 v0 v2 v1 v0 v2 v1 |
movq mm3, mm0 ; v2 v1 v0 v2 v1 v0 v2 v1 |
psllq mm0, 16 ; v0 v2 v1 v0 v2 v1 0 0 |
movq mm4, mm3 ; v2 v1 v0 v2 v1 v0 v2 v1 |
punpckhdq mm3, mm0 ; v0 v2 v1 v0 v2 v1 v0 v2 |
movq [edi+16] , mm4 |
psrlq mm0, 32 ; 0 0 0 0 v0 v2 v1 v0 |
movq [edi+8] , mm3 |
punpckldq mm0, mm4 ; v1 v0 v2 v1 v0 v2 v1 v0 |
sub esi, 3 |
movq [edi], mm0 |
sub edi, 24 |
//sub esi, 3 |
dec ecx |
jnz loop_pass0 |
EMMS |
} |
} |
else if (((pass == 2) || (pass == 3)) && width) |
{ |
_asm |
{ |
mov esi, sptr |
mov edi, dp |
mov ecx, width |
sub edi, 9 // (png_pass_inc[pass] - 1)*pixel_bytes |
loop_pass2: |
movd mm0, [esi] ; X X X X X v2 v1 v0 |
pand mm0, const4 ; 0 0 0 0 0 v2 v1 v0 |
movq mm1, mm0 ; 0 0 0 0 0 v2 v1 v0 |
psllq mm0, 16 ; 0 0 0 v2 v1 v0 0 0 |
movq mm2, mm0 ; 0 0 0 v2 v1 v0 0 0 |
psllq mm0, 24 ; v2 v1 v0 0 0 0 0 0 |
psrlq mm1, 8 ; 0 0 0 0 0 0 v2 v1 |
por mm0, mm2 ; v2 v1 v0 v2 v1 v0 0 0 |
por mm0, mm1 ; v2 v1 v0 v2 v1 v0 v2 v1 |
movq [edi+4], mm0 ; move to memory |
psrlq mm0, 16 ; 0 0 v2 v1 v0 v2 v1 v0 |
movd [edi], mm0 ; move to memory |
sub esi, 3 |
sub edi, 12 |
dec ecx |
jnz loop_pass2 |
EMMS |
} |
} |
else if (width) /* && ((pass == 4) || (pass == 5)) */ |
{ |
int width_mmx = ((width >> 1) << 1) - 8; |
if (width_mmx < 0) |
width_mmx = 0; |
width -= width_mmx; // 8 or 9 pix, 24 or 27 bytes |
if (width_mmx) |
{ |
_asm |
{ |
mov esi, sptr |
mov edi, dp |
mov ecx, width_mmx |
sub esi, 3 |
sub edi, 9 |
loop_pass4: |
movq mm0, [esi] ; X X v2 v1 v0 v5 v4 v3 |
movq mm7, mm0 ; X X v2 v1 v0 v5 v4 v3 |
movq mm6, mm0 ; X X v2 v1 v0 v5 v4 v3 |
psllq mm0, 24 ; v1 v0 v5 v4 v3 0 0 0 |
pand mm7, const4 ; 0 0 0 0 0 v5 v4 v3 |
psrlq mm6, 24 ; 0 0 0 X X v2 v1 v0 |
por mm0, mm7 ; v1 v0 v5 v4 v3 v5 v4 v3 |
movq mm5, mm6 ; 0 0 0 X X v2 v1 v0 |
psllq mm6, 8 ; 0 0 X X v2 v1 v0 0 |
movq [edi], mm0 ; move quad to memory |
psrlq mm5, 16 ; 0 0 0 0 0 X X v2 |
pand mm5, const6 ; 0 0 0 0 0 0 0 v2 |
por mm6, mm5 ; 0 0 X X v2 v1 v0 v2 |
movd [edi+8], mm6 ; move double to memory |
sub esi, 6 |
sub edi, 12 |
sub ecx, 2 |
jnz loop_pass4 |
EMMS |
} |
} |
sptr -= width_mmx*3; |
dp -= width_mmx*6; |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, 3); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, 3); |
dp -= 3; |
} |
sptr -= 3; |
} |
} |
} /* end of pixel_bytes == 3 */ |
else if (pixel_bytes == 1) |
{ |
if (((pass == 0) || (pass == 1)) && width) |
{ |
int width_mmx = ((width >> 2) << 2); |
width -= width_mmx; |
if (width_mmx) |
{ |
_asm |
{ |
mov esi, sptr |
mov edi, dp |
mov ecx, width_mmx |
sub edi, 31 |
sub esi, 3 |
loop1_pass0: |
movd mm0, [esi] ; X X X X v0 v1 v2 v3 |
movq mm1, mm0 ; X X X X v0 v1 v2 v3 |
punpcklbw mm0, mm0 ; v0 v0 v1 v1 v2 v2 v3 v3 |
movq mm2, mm0 ; v0 v0 v1 v1 v2 v2 v3 v3 |
punpcklwd mm0, mm0 ; v2 v2 v2 v2 v3 v3 v3 v3 |
movq mm3, mm0 ; v2 v2 v2 v2 v3 v3 v3 v3 |
punpckldq mm0, mm0 ; v3 v3 v3 v3 v3 v3 v3 v3 |
punpckhdq mm3, mm3 ; v2 v2 v2 v2 v2 v2 v2 v2 |
movq [edi], mm0 ; move to memory v3 |
punpckhwd mm2, mm2 ; v0 v0 v0 v0 v1 v1 v1 v1 |
movq [edi+8], mm3 ; move to memory v2 |
movq mm4, mm2 ; v0 v0 v0 v0 v1 v1 v1 v1 |
punpckldq mm2, mm2 ; v1 v1 v1 v1 v1 v1 v1 v1 |
punpckhdq mm4, mm4 ; v0 v0 v0 v0 v0 v0 v0 v0 |
movq [edi+16], mm2 ; move to memory v1 |
movq [edi+24], mm4 ; move to memory v0 |
sub esi, 4 |
sub edi, 32 |
sub ecx, 4 |
jnz loop1_pass0 |
EMMS |
} |
} |
sptr -= width_mmx; |
dp -= width_mmx*8; |
for (i = width; i; i--) |
{ |
int j; |
/* I simplified this part in version 1.0.4e |
* here and in several other instances where |
* pixel_bytes == 1 -- GR-P |
* |
* Original code: |
* |
* png_byte v[8]; |
* png_memcpy(v, sptr, pixel_bytes); |
* for (j = 0; j < png_pass_inc[pass]; j++) |
* { |
* png_memcpy(dp, v, pixel_bytes); |
* dp -= pixel_bytes; |
* } |
* sptr -= pixel_bytes; |
* |
* Replacement code is in the next three lines: |
*/ |
for (j = 0; j < png_pass_inc[pass]; j++) |
*dp-- = *sptr; |
sptr--; |
} |
} |
else if (((pass == 2) || (pass == 3)) && width) |
{ |
int width_mmx = ((width >> 2) << 2); |
width -= width_mmx; |
if (width_mmx) |
{ |
_asm |
{ |
mov esi, sptr |
mov edi, dp |
mov ecx, width_mmx |
sub edi, 15 |
sub esi, 3 |
loop1_pass2: |
movd mm0, [esi] ; X X X X v0 v1 v2 v3 |
punpcklbw mm0, mm0 ; v0 v0 v1 v1 v2 v2 v3 v3 |
movq mm1, mm0 ; v0 v0 v1 v1 v2 v2 v3 v3 |
punpcklwd mm0, mm0 ; v2 v2 v2 v2 v3 v3 v3 v3 |
punpckhwd mm1, mm1 ; v0 v0 v0 v0 v1 v1 v1 v1 |
movq [edi], mm0 ; move to memory v2 and v3 |
sub esi, 4 |
movq [edi+8], mm1 ; move to memory v1 and v0 |
sub edi, 16 |
sub ecx, 4 |
jnz loop1_pass2 |
EMMS |
} |
} |
sptr -= width_mmx; |
dp -= width_mmx*4; |
for (i = width; i; i--) |
{ |
int j; |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
*dp-- = *sptr; |
} |
sptr --; |
} |
} |
else if (width) /* && ((pass == 4) || (pass == 5))) */ |
{ |
int width_mmx = ((width >> 3) << 3); |
width -= width_mmx; |
if (width_mmx) |
{ |
_asm |
{ |
mov esi, sptr |
mov edi, dp |
mov ecx, width_mmx |
sub edi, 15 |
sub esi, 7 |
loop1_pass4: |
movq mm0, [esi] ; v0 v1 v2 v3 v4 v5 v6 v7 |
movq mm1, mm0 ; v0 v1 v2 v3 v4 v5 v6 v7 |
punpcklbw mm0, mm0 ; v4 v4 v5 v5 v6 v6 v7 v7 |
//movq mm1, mm0 ; v0 v0 v1 v1 v2 v2 v3 v3 |
punpckhbw mm1, mm1 ;v0 v0 v1 v1 v2 v2 v3 v3 |
movq [edi+8], mm1 ; move to memory v0 v1 v2 and v3 |
sub esi, 8 |
movq [edi], mm0 ; move to memory v4 v5 v6 and v7 |
//sub esi, 4 |
sub edi, 16 |
sub ecx, 8 |
jnz loop1_pass4 |
EMMS |
} |
} |
sptr -= width_mmx; |
dp -= width_mmx*2; |
for (i = width; i; i--) |
{ |
int j; |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
*dp-- = *sptr; |
} |
sptr --; |
} |
} |
} /* end of pixel_bytes == 1 */ |
else if (pixel_bytes == 2) |
{ |
if (((pass == 0) || (pass == 1)) && width) |
{ |
int width_mmx = ((width >> 1) << 1); |
width -= width_mmx; |
if (width_mmx) |
{ |
_asm |
{ |
mov esi, sptr |
mov edi, dp |
mov ecx, width_mmx |
sub esi, 2 |
sub edi, 30 |
loop2_pass0: |
movd mm0, [esi] ; X X X X v1 v0 v3 v2 |
punpcklwd mm0, mm0 ; v1 v0 v1 v0 v3 v2 v3 v2 |
movq mm1, mm0 ; v1 v0 v1 v0 v3 v2 v3 v2 |
punpckldq mm0, mm0 ; v3 v2 v3 v2 v3 v2 v3 v2 |
punpckhdq mm1, mm1 ; v1 v0 v1 v0 v1 v0 v1 v0 |
movq [edi], mm0 |
movq [edi + 8], mm0 |
movq [edi + 16], mm1 |
movq [edi + 24], mm1 |
sub esi, 4 |
sub edi, 32 |
sub ecx, 2 |
jnz loop2_pass0 |
EMMS |
} |
} |
sptr -= (width_mmx*2 - 2); // sign fixed |
dp -= (width_mmx*16 - 2); // sign fixed |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
sptr -= 2; |
png_memcpy(v, sptr, 2); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
dp -= 2; |
png_memcpy(dp, v, 2); |
} |
} |
} |
else if (((pass == 2) || (pass == 3)) && width) |
{ |
int width_mmx = ((width >> 1) << 1) ; |
width -= width_mmx; |
if (width_mmx) |
{ |
_asm |
{ |
mov esi, sptr |
mov edi, dp |
mov ecx, width_mmx |
sub esi, 2 |
sub edi, 14 |
loop2_pass2: |
movd mm0, [esi] ; X X X X v1 v0 v3 v2 |
punpcklwd mm0, mm0 ; v1 v0 v1 v0 v3 v2 v3 v2 |
movq mm1, mm0 ; v1 v0 v1 v0 v3 v2 v3 v2 |
punpckldq mm0, mm0 ; v3 v2 v3 v2 v3 v2 v3 v2 |
punpckhdq mm1, mm1 ; v1 v0 v1 v0 v1 v0 v1 v0 |
movq [edi], mm0 |
sub esi, 4 |
movq [edi + 8], mm1 |
//sub esi, 4 |
sub edi, 16 |
sub ecx, 2 |
jnz loop2_pass2 |
EMMS |
} |
} |
sptr -= (width_mmx*2 - 2); // sign fixed |
dp -= (width_mmx*8 - 2); // sign fixed |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
sptr -= 2; |
png_memcpy(v, sptr, 2); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
dp -= 2; |
png_memcpy(dp, v, 2); |
} |
} |
} |
else if (width) // pass == 4 or 5 |
{ |
int width_mmx = ((width >> 1) << 1) ; |
width -= width_mmx; |
if (width_mmx) |
{ |
_asm |
{ |
mov esi, sptr |
mov edi, dp |
mov ecx, width_mmx |
sub esi, 2 |
sub edi, 6 |
loop2_pass4: |
movd mm0, [esi] ; X X X X v1 v0 v3 v2 |
punpcklwd mm0, mm0 ; v1 v0 v1 v0 v3 v2 v3 v2 |
sub esi, 4 |
movq [edi], mm0 |
sub edi, 8 |
sub ecx, 2 |
jnz loop2_pass4 |
EMMS |
} |
} |
sptr -= (width_mmx*2 - 2); // sign fixed |
dp -= (width_mmx*4 - 2); // sign fixed |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
sptr -= 2; |
png_memcpy(v, sptr, 2); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
dp -= 2; |
png_memcpy(dp, v, 2); |
} |
} |
} |
} /* end of pixel_bytes == 2 */ |
else if (pixel_bytes == 4) |
{ |
if (((pass == 0) || (pass == 1)) && width) |
{ |
int width_mmx = ((width >> 1) << 1) ; |
width -= width_mmx; |
if (width_mmx) |
{ |
_asm |
{ |
mov esi, sptr |
mov edi, dp |
mov ecx, width_mmx |
sub esi, 4 |
sub edi, 60 |
loop4_pass0: |
movq mm0, [esi] ; v3 v2 v1 v0 v7 v6 v5 v4 |
movq mm1, mm0 ; v3 v2 v1 v0 v7 v6 v5 v4 |
punpckldq mm0, mm0 ; v7 v6 v5 v4 v7 v6 v5 v4 |
punpckhdq mm1, mm1 ; v3 v2 v1 v0 v3 v2 v1 v0 |
movq [edi], mm0 |
movq [edi + 8], mm0 |
movq [edi + 16], mm0 |
movq [edi + 24], mm0 |
movq [edi+32], mm1 |
movq [edi + 40], mm1 |
movq [edi+ 48], mm1 |
sub esi, 8 |
movq [edi + 56], mm1 |
sub edi, 64 |
sub ecx, 2 |
jnz loop4_pass0 |
EMMS |
} |
} |
sptr -= (width_mmx*4 - 4); // sign fixed |
dp -= (width_mmx*32 - 4); // sign fixed |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
sptr -= 4; |
png_memcpy(v, sptr, 4); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
dp -= 4; |
png_memcpy(dp, v, 4); |
} |
} |
} |
else if (((pass == 2) || (pass == 3)) && width) |
{ |
int width_mmx = ((width >> 1) << 1) ; |
width -= width_mmx; |
if (width_mmx) |
{ |
_asm |
{ |
mov esi, sptr |
mov edi, dp |
mov ecx, width_mmx |
sub esi, 4 |
sub edi, 28 |
loop4_pass2: |
movq mm0, [esi] ; v3 v2 v1 v0 v7 v6 v5 v4 |
movq mm1, mm0 ; v3 v2 v1 v0 v7 v6 v5 v4 |
punpckldq mm0, mm0 ; v7 v6 v5 v4 v7 v6 v5 v4 |
punpckhdq mm1, mm1 ; v3 v2 v1 v0 v3 v2 v1 v0 |
movq [edi], mm0 |
movq [edi + 8], mm0 |
movq [edi+16], mm1 |
movq [edi + 24], mm1 |
sub esi, 8 |
sub edi, 32 |
sub ecx, 2 |
jnz loop4_pass2 |
EMMS |
} |
} |
sptr -= (width_mmx*4 - 4); // sign fixed |
dp -= (width_mmx*16 - 4); // sign fixed |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
sptr -= 4; |
png_memcpy(v, sptr, 4); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
dp -= 4; |
png_memcpy(dp, v, 4); |
} |
} |
} |
else if (width) // pass == 4 or 5 |
{ |
int width_mmx = ((width >> 1) << 1) ; |
width -= width_mmx; |
if (width_mmx) |
{ |
_asm |
{ |
mov esi, sptr |
mov edi, dp |
mov ecx, width_mmx |
sub esi, 4 |
sub edi, 12 |
loop4_pass4: |
movq mm0, [esi] ; v3 v2 v1 v0 v7 v6 v5 v4 |
movq mm1, mm0 ; v3 v2 v1 v0 v7 v6 v5 v4 |
punpckldq mm0, mm0 ; v7 v6 v5 v4 v7 v6 v5 v4 |
punpckhdq mm1, mm1 ; v3 v2 v1 v0 v3 v2 v1 v0 |
movq [edi], mm0 |
sub esi, 8 |
movq [edi + 8], mm1 |
sub edi, 16 |
sub ecx, 2 |
jnz loop4_pass4 |
EMMS |
} |
} |
sptr -= (width_mmx*4 - 4); // sign fixed |
dp -= (width_mmx*8 - 4); // sign fixed |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
sptr -= 4; |
png_memcpy(v, sptr, 4); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
dp -= 4; |
png_memcpy(dp, v, 4); |
} |
} |
} |
} /* end of pixel_bytes == 4 */ |
else if (pixel_bytes == 6) |
{ |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, 6); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, 6); |
dp -= 6; |
} |
sptr -= 6; |
} |
} /* end of pixel_bytes == 6 */ |
else |
{ |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, pixel_bytes); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, pixel_bytes); |
dp -= pixel_bytes; |
} |
sptr-= pixel_bytes; |
} |
} |
} /* end of mmx_supported */ |
else /* MMX not supported: use modified C code - takes advantage |
* of inlining of memcpy for a constant */ |
{ |
if (pixel_bytes == 1) |
{ |
for (i = width; i; i--) |
{ |
int j; |
for (j = 0; j < png_pass_inc[pass]; j++) |
*dp-- = *sptr; |
sptr--; |
} |
} |
else if (pixel_bytes == 3) |
{ |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, pixel_bytes); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, pixel_bytes); |
dp -= pixel_bytes; |
} |
sptr -= pixel_bytes; |
} |
} |
else if (pixel_bytes == 2) |
{ |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, pixel_bytes); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, pixel_bytes); |
dp -= pixel_bytes; |
} |
sptr -= pixel_bytes; |
} |
} |
else if (pixel_bytes == 4) |
{ |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, pixel_bytes); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, pixel_bytes); |
dp -= pixel_bytes; |
} |
sptr -= pixel_bytes; |
} |
} |
else if (pixel_bytes == 6) |
{ |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, pixel_bytes); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, pixel_bytes); |
dp -= pixel_bytes; |
} |
sptr -= pixel_bytes; |
} |
} |
else |
{ |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, pixel_bytes); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, pixel_bytes); |
dp -= pixel_bytes; |
} |
sptr -= pixel_bytes; |
} |
} |
} /* end of MMX not supported */ |
break; |
} |
} /* end switch (row_info->pixel_depth) */ |
row_info->width = final_width; |
row_info->rowbytes = ((final_width * |
(png_uint_32)row_info->pixel_depth + 7) >> 3); |
} |
} |
#endif /* PNG_READ_INTERLACING_SUPPORTED */ |
// These variables are utilized in the functions below. They are declared |
// globally here to ensure alignment on 8-byte boundaries. |
union uAll { |
__int64 use; |
double align; |
} LBCarryMask = {0x0101010101010101}, |
HBClearMask = {0x7f7f7f7f7f7f7f7f}, |
ActiveMask, ActiveMask2, ActiveMaskEnd, ShiftBpp, ShiftRem; |
// Optimized code for PNG Average filter decoder |
void /* PRIVATE */ |
png_read_filter_row_mmx_avg(png_row_infop row_info, png_bytep row |
, png_bytep prev_row) |
{ |
int bpp; |
png_uint_32 FullLength; |
png_uint_32 MMXLength; |
//png_uint_32 len; |
int diff; |
bpp = (row_info->pixel_depth + 7) >> 3; // Get # bytes per pixel |
FullLength = row_info->rowbytes; // # of bytes to filter |
_asm { |
// Init address pointers and offset |
mov edi, row // edi ==> Avg(x) |
xor ebx, ebx // ebx ==> x |
mov edx, edi |
mov esi, prev_row // esi ==> Prior(x) |
sub edx, bpp // edx ==> Raw(x-bpp) |
xor eax, eax |
// Compute the Raw value for the first bpp bytes |
// Raw(x) = Avg(x) + (Prior(x)/2) |
davgrlp: |
mov al, [esi + ebx] // Load al with Prior(x) |
inc ebx |
shr al, 1 // divide by 2 |
add al, [edi+ebx-1] // Add Avg(x); -1 to offset inc ebx |
cmp ebx, bpp |
mov [edi+ebx-1], al // Write back Raw(x); |
// mov does not affect flags; -1 to offset inc ebx |
jb davgrlp |
// get # of bytes to alignment |
mov diff, edi // take start of row |
add diff, ebx // add bpp |
add diff, 0xf // add 7 + 8 to incr past alignment boundary |
and diff, 0xfffffff8 // mask to alignment boundary |
sub diff, edi // subtract from start ==> value ebx at alignment |
jz davggo |
// fix alignment |
// Compute the Raw value for the bytes upto the alignment boundary |
// Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2) |
xor ecx, ecx |
davglp1: |
xor eax, eax |
mov cl, [esi + ebx] // load cl with Prior(x) |
mov al, [edx + ebx] // load al with Raw(x-bpp) |
add ax, cx |
inc ebx |
shr ax, 1 // divide by 2 |
add al, [edi+ebx-1] // Add Avg(x); -1 to offset inc ebx |
cmp ebx, diff // Check if at alignment boundary |
mov [edi+ebx-1], al // Write back Raw(x); |
// mov does not affect flags; -1 to offset inc ebx |
jb davglp1 // Repeat until at alignment boundary |
davggo: |
mov eax, FullLength |
mov ecx, eax |
sub eax, ebx // subtract alignment fix |
and eax, 0x00000007 // calc bytes over mult of 8 |
sub ecx, eax // drop over bytes from original length |
mov MMXLength, ecx |
} // end _asm block |
// Now do the math for the rest of the row |
switch ( bpp ) |
{ |
case 3: |
{ |
ActiveMask.use = 0x0000000000ffffff; |
ShiftBpp.use = 24; // == 3 * 8 |
ShiftRem.use = 40; // == 64 - 24 |
_asm { |
// Re-init address pointers and offset |
movq mm7, ActiveMask |
mov ebx, diff // ebx ==> x = offset to alignment boundary |
movq mm5, LBCarryMask |
mov edi, row // edi ==> Avg(x) |
movq mm4, HBClearMask |
mov esi, prev_row // esi ==> Prior(x) |
// PRIME the pump (load the first Raw(x-bpp) data set |
movq mm2, [edi + ebx - 8] // Load previous aligned 8 bytes |
// (we correct position in loop below) |
davg3lp: |
movq mm0, [edi + ebx] // Load mm0 with Avg(x) |
// Add (Prev_row/2) to Average |
movq mm3, mm5 |
psrlq mm2, ShiftRem // Correct position Raw(x-bpp) data |
movq mm1, [esi + ebx] // Load mm1 with Prior(x) |
movq mm6, mm7 |
pand mm3, mm1 // get lsb for each prev_row byte |
psrlq mm1, 1 // divide prev_row bytes by 2 |
pand mm1, mm4 // clear invalid bit 7 of each byte |
paddb mm0, mm1 // add (Prev_row/2) to Avg for each byte |
// Add 1st active group (Raw(x-bpp)/2) to Average with LBCarry |
movq mm1, mm3 // now use mm1 for getting LBCarrys |
pand mm1, mm2 // get LBCarrys for each byte where both |
// lsb's were == 1 (Only valid for active group) |
psrlq mm2, 1 // divide raw bytes by 2 |
pand mm2, mm4 // clear invalid bit 7 of each byte |
paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte |
pand mm2, mm6 // Leave only Active Group 1 bytes to add to Avg |
paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active |
// byte |
// Add 2nd active group (Raw(x-bpp)/2) to Average with LBCarry |
psllq mm6, ShiftBpp // shift the mm6 mask to cover bytes 3-5 |
movq mm2, mm0 // mov updated Raws to mm2 |
psllq mm2, ShiftBpp // shift data to position correctly |
movq mm1, mm3 // now use mm1 for getting LBCarrys |
pand mm1, mm2 // get LBCarrys for each byte where both |
// lsb's were == 1 (Only valid for active group) |
psrlq mm2, 1 // divide raw bytes by 2 |
pand mm2, mm4 // clear invalid bit 7 of each byte |
paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte |
pand mm2, mm6 // Leave only Active Group 2 bytes to add to Avg |
paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active |
// byte |
// Add 3rd active group (Raw(x-bpp)/2) to Average with LBCarry |
psllq mm6, ShiftBpp // shift the mm6 mask to cover the last two |
// bytes |
movq mm2, mm0 // mov updated Raws to mm2 |
psllq mm2, ShiftBpp // shift data to position correctly |
// Data only needs to be shifted once here to |
// get the correct x-bpp offset. |
movq mm1, mm3 // now use mm1 for getting LBCarrys |
pand mm1, mm2 // get LBCarrys for each byte where both |
// lsb's were == 1 (Only valid for active group) |
psrlq mm2, 1 // divide raw bytes by 2 |
pand mm2, mm4 // clear invalid bit 7 of each byte |
paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte |
pand mm2, mm6 // Leave only Active Group 2 bytes to add to Avg |
add ebx, 8 |
paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active |
// byte |
// Now ready to write back to memory |
movq [edi + ebx - 8], mm0 |
// Move updated Raw(x) to use as Raw(x-bpp) for next loop |
cmp ebx, MMXLength |
movq mm2, mm0 // mov updated Raw(x) to mm2 |
jb davg3lp |
} // end _asm block |
} |
break; |
case 6: |
case 4: |
case 7: |
case 5: |
{ |
ActiveMask.use = 0xffffffffffffffff; // use shift below to clear |
// appropriate inactive bytes |
ShiftBpp.use = bpp << 3; |
ShiftRem.use = 64 - ShiftBpp.use; |
_asm { |
movq mm4, HBClearMask |
// Re-init address pointers and offset |
mov ebx, diff // ebx ==> x = offset to alignment boundary |
// Load ActiveMask and clear all bytes except for 1st active group |
movq mm7, ActiveMask |
mov edi, row // edi ==> Avg(x) |
psrlq mm7, ShiftRem |
mov esi, prev_row // esi ==> Prior(x) |
movq mm6, mm7 |
movq mm5, LBCarryMask |
psllq mm6, ShiftBpp // Create mask for 2nd active group |
// PRIME the pump (load the first Raw(x-bpp) data set |
movq mm2, [edi + ebx - 8] // Load previous aligned 8 bytes |
// (we correct position in loop below) |
davg4lp: |
movq mm0, [edi + ebx] |
psrlq mm2, ShiftRem // shift data to position correctly |
movq mm1, [esi + ebx] |
// Add (Prev_row/2) to Average |
movq mm3, mm5 |
pand mm3, mm1 // get lsb for each prev_row byte |
psrlq mm1, 1 // divide prev_row bytes by 2 |
pand mm1, mm4 // clear invalid bit 7 of each byte |
paddb mm0, mm1 // add (Prev_row/2) to Avg for each byte |
// Add 1st active group (Raw(x-bpp)/2) to Average with LBCarry |
movq mm1, mm3 // now use mm1 for getting LBCarrys |
pand mm1, mm2 // get LBCarrys for each byte where both |
// lsb's were == 1 (Only valid for active group) |
psrlq mm2, 1 // divide raw bytes by 2 |
pand mm2, mm4 // clear invalid bit 7 of each byte |
paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte |
pand mm2, mm7 // Leave only Active Group 1 bytes to add to Avg |
paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active |
// byte |
// Add 2nd active group (Raw(x-bpp)/2) to Average with LBCarry |
movq mm2, mm0 // mov updated Raws to mm2 |
psllq mm2, ShiftBpp // shift data to position correctly |
add ebx, 8 |
movq mm1, mm3 // now use mm1 for getting LBCarrys |
pand mm1, mm2 // get LBCarrys for each byte where both |
// lsb's were == 1 (Only valid for active group) |
psrlq mm2, 1 // divide raw bytes by 2 |
pand mm2, mm4 // clear invalid bit 7 of each byte |
paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte |
pand mm2, mm6 // Leave only Active Group 2 bytes to add to Avg |
paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active |
// byte |
cmp ebx, MMXLength |
// Now ready to write back to memory |
movq [edi + ebx - 8], mm0 |
// Prep Raw(x-bpp) for next loop |
movq mm2, mm0 // mov updated Raws to mm2 |
jb davg4lp |
} // end _asm block |
} |
break; |
case 2: |
{ |
ActiveMask.use = 0x000000000000ffff; |
ShiftBpp.use = 16; // == 2 * 8 [BUGFIX] |
ShiftRem.use = 48; // == 64 - 16 [BUGFIX] |
_asm { |
// Load ActiveMask |
movq mm7, ActiveMask |
// Re-init address pointers and offset |
mov ebx, diff // ebx ==> x = offset to alignment boundary |
movq mm5, LBCarryMask |
mov edi, row // edi ==> Avg(x) |
movq mm4, HBClearMask |
mov esi, prev_row // esi ==> Prior(x) |
// PRIME the pump (load the first Raw(x-bpp) data set |
movq mm2, [edi + ebx - 8] // Load previous aligned 8 bytes |
// (we correct position in loop below) |
davg2lp: |
movq mm0, [edi + ebx] |
psrlq mm2, ShiftRem // shift data to position correctly [BUGFIX] |
movq mm1, [esi + ebx] |
// Add (Prev_row/2) to Average |
movq mm3, mm5 |
pand mm3, mm1 // get lsb for each prev_row byte |
psrlq mm1, 1 // divide prev_row bytes by 2 |
pand mm1, mm4 // clear invalid bit 7 of each byte |
movq mm6, mm7 |
paddb mm0, mm1 // add (Prev_row/2) to Avg for each byte |
// Add 1st active group (Raw(x-bpp)/2) to Average with LBCarry |
movq mm1, mm3 // now use mm1 for getting LBCarrys |
pand mm1, mm2 // get LBCarrys for each byte where both |
// lsb's were == 1 (Only valid for active group) |
psrlq mm2, 1 // divide raw bytes by 2 |
pand mm2, mm4 // clear invalid bit 7 of each byte |
paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte |
pand mm2, mm6 // Leave only Active Group 1 bytes to add to Avg |
paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active byte |
// Add 2nd active group (Raw(x-bpp)/2) to Average with LBCarry |
psllq mm6, ShiftBpp // shift the mm6 mask to cover bytes 2 & 3 |
movq mm2, mm0 // mov updated Raws to mm2 |
psllq mm2, ShiftBpp // shift data to position correctly |
movq mm1, mm3 // now use mm1 for getting LBCarrys |
pand mm1, mm2 // get LBCarrys for each byte where both |
// lsb's were == 1 (Only valid for active group) |
psrlq mm2, 1 // divide raw bytes by 2 |
pand mm2, mm4 // clear invalid bit 7 of each byte |
paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte |
pand mm2, mm6 // Leave only Active Group 2 bytes to add to Avg |
paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active byte |
// Add rdd active group (Raw(x-bpp)/2) to Average with LBCarry |
psllq mm6, ShiftBpp // shift the mm6 mask to cover bytes 4 & 5 |
movq mm2, mm0 // mov updated Raws to mm2 |
psllq mm2, ShiftBpp // shift data to position correctly |
// Data only needs to be shifted once here to |
// get the correct x-bpp offset. |
movq mm1, mm3 // now use mm1 for getting LBCarrys |
pand mm1, mm2 // get LBCarrys for each byte where both |
// lsb's were == 1 (Only valid for active group) |
psrlq mm2, 1 // divide raw bytes by 2 |
pand mm2, mm4 // clear invalid bit 7 of each byte |
paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte |
pand mm2, mm6 // Leave only Active Group 2 bytes to add to Avg |
paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active byte |
// Add 4th active group (Raw(x-bpp)/2) to Average with LBCarry |
psllq mm6, ShiftBpp // shift the mm6 mask to cover bytes 6 & 7 |
movq mm2, mm0 // mov updated Raws to mm2 |
psllq mm2, ShiftBpp // shift data to position correctly |
// Data only needs to be shifted once here to |
// get the correct x-bpp offset. |
add ebx, 8 |
movq mm1, mm3 // now use mm1 for getting LBCarrys |
pand mm1, mm2 // get LBCarrys for each byte where both |
// lsb's were == 1 (Only valid for active group) |
psrlq mm2, 1 // divide raw bytes by 2 |
pand mm2, mm4 // clear invalid bit 7 of each byte |
paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte |
pand mm2, mm6 // Leave only Active Group 2 bytes to add to Avg |
paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active byte |
cmp ebx, MMXLength |
// Now ready to write back to memory |
movq [edi + ebx - 8], mm0 |
// Prep Raw(x-bpp) for next loop |
movq mm2, mm0 // mov updated Raws to mm2 |
jb davg2lp |
} // end _asm block |
} |
break; |
case 1: // bpp == 1 |
{ |
_asm { |
// Re-init address pointers and offset |
mov ebx, diff // ebx ==> x = offset to alignment boundary |
mov edi, row // edi ==> Avg(x) |
cmp ebx, FullLength // Test if offset at end of array |
jnb davg1end |
// Do Paeth decode for remaining bytes |
mov esi, prev_row // esi ==> Prior(x) |
mov edx, edi |
xor ecx, ecx // zero ecx before using cl & cx in loop below |
sub edx, bpp // edx ==> Raw(x-bpp) |
davg1lp: |
// Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2) |
xor eax, eax |
mov cl, [esi + ebx] // load cl with Prior(x) |
mov al, [edx + ebx] // load al with Raw(x-bpp) |
add ax, cx |
inc ebx |
shr ax, 1 // divide by 2 |
add al, [edi+ebx-1] // Add Avg(x); -1 to offset inc ebx |
cmp ebx, FullLength // Check if at end of array |
mov [edi+ebx-1], al // Write back Raw(x); |
// mov does not affect flags; -1 to offset inc ebx |
jb davg1lp |
davg1end: |
} // end _asm block |
} |
return; |
case 8: // bpp == 8 |
{ |
_asm { |
// Re-init address pointers and offset |
mov ebx, diff // ebx ==> x = offset to alignment boundary |
movq mm5, LBCarryMask |
mov edi, row // edi ==> Avg(x) |
movq mm4, HBClearMask |
mov esi, prev_row // esi ==> Prior(x) |
// PRIME the pump (load the first Raw(x-bpp) data set |
movq mm2, [edi + ebx - 8] // Load previous aligned 8 bytes |
// (NO NEED to correct position in loop below) |
davg8lp: |
movq mm0, [edi + ebx] |
movq mm3, mm5 |
movq mm1, [esi + ebx] |
add ebx, 8 |
pand mm3, mm1 // get lsb for each prev_row byte |
psrlq mm1, 1 // divide prev_row bytes by 2 |
pand mm3, mm2 // get LBCarrys for each byte where both |
// lsb's were == 1 |
psrlq mm2, 1 // divide raw bytes by 2 |
pand mm1, mm4 // clear invalid bit 7 of each byte |
paddb mm0, mm3 // add LBCarrys to Avg for each byte |
pand mm2, mm4 // clear invalid bit 7 of each byte |
paddb mm0, mm1 // add (Prev_row/2) to Avg for each byte |
paddb mm0, mm2 // add (Raw/2) to Avg for each byte |
cmp ebx, MMXLength |
movq [edi + ebx - 8], mm0 |
movq mm2, mm0 // reuse as Raw(x-bpp) |
jb davg8lp |
} // end _asm block |
} |
break; |
default: // bpp greater than 8 |
{ |
_asm { |
movq mm5, LBCarryMask |
// Re-init address pointers and offset |
mov ebx, diff // ebx ==> x = offset to alignment boundary |
mov edi, row // edi ==> Avg(x) |
movq mm4, HBClearMask |
mov edx, edi |
mov esi, prev_row // esi ==> Prior(x) |
sub edx, bpp // edx ==> Raw(x-bpp) |
davgAlp: |
movq mm0, [edi + ebx] |
movq mm3, mm5 |
movq mm1, [esi + ebx] |
pand mm3, mm1 // get lsb for each prev_row byte |
movq mm2, [edx + ebx] |
psrlq mm1, 1 // divide prev_row bytes by 2 |
pand mm3, mm2 // get LBCarrys for each byte where both |
// lsb's were == 1 |
psrlq mm2, 1 // divide raw bytes by 2 |
pand mm1, mm4 // clear invalid bit 7 of each byte |
paddb mm0, mm3 // add LBCarrys to Avg for each byte |
pand mm2, mm4 // clear invalid bit 7 of each byte |
paddb mm0, mm1 // add (Prev_row/2) to Avg for each byte |
add ebx, 8 |
paddb mm0, mm2 // add (Raw/2) to Avg for each byte |
cmp ebx, MMXLength |
movq [edi + ebx - 8], mm0 |
jb davgAlp |
} // end _asm block |
} |
break; |
} // end switch ( bpp ) |
_asm { |
// MMX acceleration complete now do clean-up |
// Check if any remaining bytes left to decode |
mov ebx, MMXLength // ebx ==> x = offset bytes remaining after MMX |
mov edi, row // edi ==> Avg(x) |
cmp ebx, FullLength // Test if offset at end of array |
jnb davgend |
// Do Paeth decode for remaining bytes |
mov esi, prev_row // esi ==> Prior(x) |
mov edx, edi |
xor ecx, ecx // zero ecx before using cl & cx in loop below |
sub edx, bpp // edx ==> Raw(x-bpp) |
davglp2: |
// Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2) |
xor eax, eax |
mov cl, [esi + ebx] // load cl with Prior(x) |
mov al, [edx + ebx] // load al with Raw(x-bpp) |
add ax, cx |
inc ebx |
shr ax, 1 // divide by 2 |
add al, [edi+ebx-1] // Add Avg(x); -1 to offset inc ebx |
cmp ebx, FullLength // Check if at end of array |
mov [edi+ebx-1], al // Write back Raw(x); |
// mov does not affect flags; -1 to offset inc ebx |
jb davglp2 |
davgend: |
emms // End MMX instructions; prep for possible FP instrs. |
} // end _asm block |
} |
// Optimized code for PNG Paeth filter decoder |
void /* PRIVATE */ |
png_read_filter_row_mmx_paeth(png_row_infop row_info, png_bytep row, |
png_bytep prev_row) |
{ |
png_uint_32 FullLength; |
png_uint_32 MMXLength; |
//png_uint_32 len; |
int bpp; |
int diff; |
//int ptemp; |
int patemp, pbtemp, pctemp; |
bpp = (row_info->pixel_depth + 7) >> 3; // Get # bytes per pixel |
FullLength = row_info->rowbytes; // # of bytes to filter |
_asm |
{ |
xor ebx, ebx // ebx ==> x offset |
mov edi, row |
xor edx, edx // edx ==> x-bpp offset |
mov esi, prev_row |
xor eax, eax |
// Compute the Raw value for the first bpp bytes |
// Note: the formula works out to be always |
// Paeth(x) = Raw(x) + Prior(x) where x < bpp |
dpthrlp: |
mov al, [edi + ebx] |
add al, [esi + ebx] |
inc ebx |
cmp ebx, bpp |
mov [edi + ebx - 1], al |
jb dpthrlp |
// get # of bytes to alignment |
mov diff, edi // take start of row |
add diff, ebx // add bpp |
xor ecx, ecx |
add diff, 0xf // add 7 + 8 to incr past alignment boundary |
and diff, 0xfffffff8 // mask to alignment boundary |
sub diff, edi // subtract from start ==> value ebx at alignment |
jz dpthgo |
// fix alignment |
dpthlp1: |
xor eax, eax |
// pav = p - a = (a + b - c) - a = b - c |
mov al, [esi + ebx] // load Prior(x) into al |
mov cl, [esi + edx] // load Prior(x-bpp) into cl |
sub eax, ecx // subtract Prior(x-bpp) |
mov patemp, eax // Save pav for later use |
xor eax, eax |
// pbv = p - b = (a + b - c) - b = a - c |
mov al, [edi + edx] // load Raw(x-bpp) into al |
sub eax, ecx // subtract Prior(x-bpp) |
mov ecx, eax |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
add eax, patemp // pcv = pav + pbv |
// pc = abs(pcv) |
test eax, 0x80000000 |
jz dpthpca |
neg eax // reverse sign of neg values |
dpthpca: |
mov pctemp, eax // save pc for later use |
// pb = abs(pbv) |
test ecx, 0x80000000 |
jz dpthpba |
neg ecx // reverse sign of neg values |
dpthpba: |
mov pbtemp, ecx // save pb for later use |
// pa = abs(pav) |
mov eax, patemp |
test eax, 0x80000000 |
jz dpthpaa |
neg eax // reverse sign of neg values |
dpthpaa: |
mov patemp, eax // save pa for later use |
// test if pa <= pb |
cmp eax, ecx |
jna dpthabb |
// pa > pb; now test if pb <= pc |
cmp ecx, pctemp |
jna dpthbbc |
// pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp) |
mov cl, [esi + edx] // load Prior(x-bpp) into cl |
jmp dpthpaeth |
dpthbbc: |
// pb <= pc; Raw(x) = Paeth(x) + Prior(x) |
mov cl, [esi + ebx] // load Prior(x) into cl |
jmp dpthpaeth |
dpthabb: |
// pa <= pb; now test if pa <= pc |
cmp eax, pctemp |
jna dpthabc |
// pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp) |
mov cl, [esi + edx] // load Prior(x-bpp) into cl |
jmp dpthpaeth |
dpthabc: |
// pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp) |
mov cl, [edi + edx] // load Raw(x-bpp) into cl |
dpthpaeth: |
inc ebx |
inc edx |
// Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256 |
add [edi + ebx - 1], cl |
cmp ebx, diff |
jb dpthlp1 |
dpthgo: |
mov ecx, FullLength |
mov eax, ecx |
sub eax, ebx // subtract alignment fix |
and eax, 0x00000007 // calc bytes over mult of 8 |
sub ecx, eax // drop over bytes from original length |
mov MMXLength, ecx |
} // end _asm block |
// Now do the math for the rest of the row |
switch ( bpp ) |
{ |
case 3: |
{ |
ActiveMask.use = 0x0000000000ffffff; |
ActiveMaskEnd.use = 0xffff000000000000; |
ShiftBpp.use = 24; // == bpp(3) * 8 |
ShiftRem.use = 40; // == 64 - 24 |
_asm |
{ |
mov ebx, diff |
mov edi, row |
mov esi, prev_row |
pxor mm0, mm0 |
// PRIME the pump (load the first Raw(x-bpp) data set |
movq mm1, [edi+ebx-8] |
dpth3lp: |
psrlq mm1, ShiftRem // shift last 3 bytes to 1st 3 bytes |
movq mm2, [esi + ebx] // load b=Prior(x) |
punpcklbw mm1, mm0 // Unpack High bytes of a |
movq mm3, [esi+ebx-8] // Prep c=Prior(x-bpp) bytes |
punpcklbw mm2, mm0 // Unpack High bytes of b |
psrlq mm3, ShiftRem // shift last 3 bytes to 1st 3 bytes |
// pav = p - a = (a + b - c) - a = b - c |
movq mm4, mm2 |
punpcklbw mm3, mm0 // Unpack High bytes of c |
// pbv = p - b = (a + b - c) - b = a - c |
movq mm5, mm1 |
psubw mm4, mm3 |
pxor mm7, mm7 |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
movq mm6, mm4 |
psubw mm5, mm3 |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
pcmpgtw mm0, mm4 // Create mask pav bytes < 0 |
paddw mm6, mm5 |
pand mm0, mm4 // Only pav bytes < 0 in mm7 |
pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 |
psubw mm4, mm0 |
pand mm7, mm5 // Only pbv bytes < 0 in mm0 |
psubw mm4, mm0 |
psubw mm5, mm7 |
pxor mm0, mm0 |
pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 |
pand mm0, mm6 // Only pav bytes < 0 in mm7 |
psubw mm5, mm7 |
psubw mm6, mm0 |
// test pa <= pb |
movq mm7, mm4 |
psubw mm6, mm0 |
pcmpgtw mm7, mm5 // pa > pb? |
movq mm0, mm7 |
// use mm7 mask to merge pa & pb |
pand mm5, mm7 |
// use mm0 mask copy to merge a & b |
pand mm2, mm0 |
pandn mm7, mm4 |
pandn mm0, mm1 |
paddw mm7, mm5 |
paddw mm0, mm2 |
// test ((pa <= pb)? pa:pb) <= pc |
pcmpgtw mm7, mm6 // pab > pc? |
pxor mm1, mm1 |
pand mm3, mm7 |
pandn mm7, mm0 |
paddw mm7, mm3 |
pxor mm0, mm0 |
packuswb mm7, mm1 |
movq mm3, [esi + ebx] // load c=Prior(x-bpp) |
pand mm7, ActiveMask |
movq mm2, mm3 // load b=Prior(x) step 1 |
paddb mm7, [edi + ebx] // add Paeth predictor with Raw(x) |
punpcklbw mm3, mm0 // Unpack High bytes of c |
movq [edi + ebx], mm7 // write back updated value |
movq mm1, mm7 // Now mm1 will be used as Raw(x-bpp) |
// Now do Paeth for 2nd set of bytes (3-5) |
psrlq mm2, ShiftBpp // load b=Prior(x) step 2 |
punpcklbw mm1, mm0 // Unpack High bytes of a |
pxor mm7, mm7 |
punpcklbw mm2, mm0 // Unpack High bytes of b |
// pbv = p - b = (a + b - c) - b = a - c |
movq mm5, mm1 |
// pav = p - a = (a + b - c) - a = b - c |
movq mm4, mm2 |
psubw mm5, mm3 |
psubw mm4, mm3 |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = |
// pav + pbv = pbv + pav |
movq mm6, mm5 |
paddw mm6, mm4 |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
pcmpgtw mm0, mm5 // Create mask pbv bytes < 0 |
pcmpgtw mm7, mm4 // Create mask pav bytes < 0 |
pand mm0, mm5 // Only pbv bytes < 0 in mm0 |
pand mm7, mm4 // Only pav bytes < 0 in mm7 |
psubw mm5, mm0 |
psubw mm4, mm7 |
psubw mm5, mm0 |
psubw mm4, mm7 |
pxor mm0, mm0 |
pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 |
pand mm0, mm6 // Only pav bytes < 0 in mm7 |
psubw mm6, mm0 |
// test pa <= pb |
movq mm7, mm4 |
psubw mm6, mm0 |
pcmpgtw mm7, mm5 // pa > pb? |
movq mm0, mm7 |
// use mm7 mask to merge pa & pb |
pand mm5, mm7 |
// use mm0 mask copy to merge a & b |
pand mm2, mm0 |
pandn mm7, mm4 |
pandn mm0, mm1 |
paddw mm7, mm5 |
paddw mm0, mm2 |
// test ((pa <= pb)? pa:pb) <= pc |
pcmpgtw mm7, mm6 // pab > pc? |
movq mm2, [esi + ebx] // load b=Prior(x) |
pand mm3, mm7 |
pandn mm7, mm0 |
pxor mm1, mm1 |
paddw mm7, mm3 |
pxor mm0, mm0 |
packuswb mm7, mm1 |
movq mm3, mm2 // load c=Prior(x-bpp) step 1 |
pand mm7, ActiveMask |
punpckhbw mm2, mm0 // Unpack High bytes of b |
psllq mm7, ShiftBpp // Shift bytes to 2nd group of 3 bytes |
// pav = p - a = (a + b - c) - a = b - c |
movq mm4, mm2 |
paddb mm7, [edi + ebx] // add Paeth predictor with Raw(x) |
psllq mm3, ShiftBpp // load c=Prior(x-bpp) step 2 |
movq [edi + ebx], mm7 // write back updated value |
movq mm1, mm7 |
punpckhbw mm3, mm0 // Unpack High bytes of c |
psllq mm1, ShiftBpp // Shift bytes |
// Now mm1 will be used as Raw(x-bpp) |
// Now do Paeth for 3rd, and final, set of bytes (6-7) |
pxor mm7, mm7 |
punpckhbw mm1, mm0 // Unpack High bytes of a |
psubw mm4, mm3 |
// pbv = p - b = (a + b - c) - b = a - c |
movq mm5, mm1 |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
movq mm6, mm4 |
psubw mm5, mm3 |
pxor mm0, mm0 |
paddw mm6, mm5 |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
pcmpgtw mm0, mm4 // Create mask pav bytes < 0 |
pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 |
pand mm0, mm4 // Only pav bytes < 0 in mm7 |
pand mm7, mm5 // Only pbv bytes < 0 in mm0 |
psubw mm4, mm0 |
psubw mm5, mm7 |
psubw mm4, mm0 |
psubw mm5, mm7 |
pxor mm0, mm0 |
pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 |
pand mm0, mm6 // Only pav bytes < 0 in mm7 |
psubw mm6, mm0 |
// test pa <= pb |
movq mm7, mm4 |
psubw mm6, mm0 |
pcmpgtw mm7, mm5 // pa > pb? |
movq mm0, mm7 |
// use mm0 mask copy to merge a & b |
pand mm2, mm0 |
// use mm7 mask to merge pa & pb |
pand mm5, mm7 |
pandn mm0, mm1 |
pandn mm7, mm4 |
paddw mm0, mm2 |
paddw mm7, mm5 |
// test ((pa <= pb)? pa:pb) <= pc |
pcmpgtw mm7, mm6 // pab > pc? |
pand mm3, mm7 |
pandn mm7, mm0 |
paddw mm7, mm3 |
pxor mm1, mm1 |
packuswb mm1, mm7 |
// Step ebx to next set of 8 bytes and repeat loop til done |
add ebx, 8 |
pand mm1, ActiveMaskEnd |
paddb mm1, [edi + ebx - 8] // add Paeth predictor with Raw(x) |
cmp ebx, MMXLength |
pxor mm0, mm0 // pxor does not affect flags |
movq [edi + ebx - 8], mm1 // write back updated value |
// mm1 will be used as Raw(x-bpp) next loop |
// mm3 ready to be used as Prior(x-bpp) next loop |
jb dpth3lp |
} // end _asm block |
} |
break; |
case 6: |
case 7: |
case 5: |
{ |
ActiveMask.use = 0x00000000ffffffff; |
ActiveMask2.use = 0xffffffff00000000; |
ShiftBpp.use = bpp << 3; // == bpp * 8 |
ShiftRem.use = 64 - ShiftBpp.use; |
_asm |
{ |
mov ebx, diff |
mov edi, row |
mov esi, prev_row |
// PRIME the pump (load the first Raw(x-bpp) data set |
movq mm1, [edi+ebx-8] |
pxor mm0, mm0 |
dpth6lp: |
// Must shift to position Raw(x-bpp) data |
psrlq mm1, ShiftRem |
// Do first set of 4 bytes |
movq mm3, [esi+ebx-8] // read c=Prior(x-bpp) bytes |
punpcklbw mm1, mm0 // Unpack Low bytes of a |
movq mm2, [esi + ebx] // load b=Prior(x) |
punpcklbw mm2, mm0 // Unpack Low bytes of b |
// Must shift to position Prior(x-bpp) data |
psrlq mm3, ShiftRem |
// pav = p - a = (a + b - c) - a = b - c |
movq mm4, mm2 |
punpcklbw mm3, mm0 // Unpack Low bytes of c |
// pbv = p - b = (a + b - c) - b = a - c |
movq mm5, mm1 |
psubw mm4, mm3 |
pxor mm7, mm7 |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
movq mm6, mm4 |
psubw mm5, mm3 |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
pcmpgtw mm0, mm4 // Create mask pav bytes < 0 |
paddw mm6, mm5 |
pand mm0, mm4 // Only pav bytes < 0 in mm7 |
pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 |
psubw mm4, mm0 |
pand mm7, mm5 // Only pbv bytes < 0 in mm0 |
psubw mm4, mm0 |
psubw mm5, mm7 |
pxor mm0, mm0 |
pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 |
pand mm0, mm6 // Only pav bytes < 0 in mm7 |
psubw mm5, mm7 |
psubw mm6, mm0 |
// test pa <= pb |
movq mm7, mm4 |
psubw mm6, mm0 |
pcmpgtw mm7, mm5 // pa > pb? |
movq mm0, mm7 |
// use mm7 mask to merge pa & pb |
pand mm5, mm7 |
// use mm0 mask copy to merge a & b |
pand mm2, mm0 |
pandn mm7, mm4 |
pandn mm0, mm1 |
paddw mm7, mm5 |
paddw mm0, mm2 |
// test ((pa <= pb)? pa:pb) <= pc |
pcmpgtw mm7, mm6 // pab > pc? |
pxor mm1, mm1 |
pand mm3, mm7 |
pandn mm7, mm0 |
paddw mm7, mm3 |
pxor mm0, mm0 |
packuswb mm7, mm1 |
movq mm3, [esi + ebx - 8] // load c=Prior(x-bpp) |
pand mm7, ActiveMask |
psrlq mm3, ShiftRem |
movq mm2, [esi + ebx] // load b=Prior(x) step 1 |
paddb mm7, [edi + ebx] // add Paeth predictor with Raw(x) |
movq mm6, mm2 |
movq [edi + ebx], mm7 // write back updated value |
movq mm1, [edi+ebx-8] |
psllq mm6, ShiftBpp |
movq mm5, mm7 |
psrlq mm1, ShiftRem |
por mm3, mm6 |
psllq mm5, ShiftBpp |
punpckhbw mm3, mm0 // Unpack High bytes of c |
por mm1, mm5 |
// Do second set of 4 bytes |
punpckhbw mm2, mm0 // Unpack High bytes of b |
punpckhbw mm1, mm0 // Unpack High bytes of a |
// pav = p - a = (a + b - c) - a = b - c |
movq mm4, mm2 |
// pbv = p - b = (a + b - c) - b = a - c |
movq mm5, mm1 |
psubw mm4, mm3 |
pxor mm7, mm7 |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
movq mm6, mm4 |
psubw mm5, mm3 |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
pcmpgtw mm0, mm4 // Create mask pav bytes < 0 |
paddw mm6, mm5 |
pand mm0, mm4 // Only pav bytes < 0 in mm7 |
pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 |
psubw mm4, mm0 |
pand mm7, mm5 // Only pbv bytes < 0 in mm0 |
psubw mm4, mm0 |
psubw mm5, mm7 |
pxor mm0, mm0 |
pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 |
pand mm0, mm6 // Only pav bytes < 0 in mm7 |
psubw mm5, mm7 |
psubw mm6, mm0 |
// test pa <= pb |
movq mm7, mm4 |
psubw mm6, mm0 |
pcmpgtw mm7, mm5 // pa > pb? |
movq mm0, mm7 |
// use mm7 mask to merge pa & pb |
pand mm5, mm7 |
// use mm0 mask copy to merge a & b |
pand mm2, mm0 |
pandn mm7, mm4 |
pandn mm0, mm1 |
paddw mm7, mm5 |
paddw mm0, mm2 |
// test ((pa <= pb)? pa:pb) <= pc |
pcmpgtw mm7, mm6 // pab > pc? |
pxor mm1, mm1 |
pand mm3, mm7 |
pandn mm7, mm0 |
pxor mm1, mm1 |
paddw mm7, mm3 |
pxor mm0, mm0 |
// Step ex to next set of 8 bytes and repeat loop til done |
add ebx, 8 |
packuswb mm1, mm7 |
paddb mm1, [edi + ebx - 8] // add Paeth predictor with Raw(x) |
cmp ebx, MMXLength |
movq [edi + ebx - 8], mm1 // write back updated value |
// mm1 will be used as Raw(x-bpp) next loop |
jb dpth6lp |
} // end _asm block |
} |
break; |
case 4: |
{ |
ActiveMask.use = 0x00000000ffffffff; |
_asm { |
mov ebx, diff |
mov edi, row |
mov esi, prev_row |
pxor mm0, mm0 |
// PRIME the pump (load the first Raw(x-bpp) data set |
movq mm1, [edi+ebx-8] // Only time should need to read |
// a=Raw(x-bpp) bytes |
dpth4lp: |
// Do first set of 4 bytes |
movq mm3, [esi+ebx-8] // read c=Prior(x-bpp) bytes |
punpckhbw mm1, mm0 // Unpack Low bytes of a |
movq mm2, [esi + ebx] // load b=Prior(x) |
punpcklbw mm2, mm0 // Unpack High bytes of b |
// pav = p - a = (a + b - c) - a = b - c |
movq mm4, mm2 |
punpckhbw mm3, mm0 // Unpack High bytes of c |
// pbv = p - b = (a + b - c) - b = a - c |
movq mm5, mm1 |
psubw mm4, mm3 |
pxor mm7, mm7 |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
movq mm6, mm4 |
psubw mm5, mm3 |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
pcmpgtw mm0, mm4 // Create mask pav bytes < 0 |
paddw mm6, mm5 |
pand mm0, mm4 // Only pav bytes < 0 in mm7 |
pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 |
psubw mm4, mm0 |
pand mm7, mm5 // Only pbv bytes < 0 in mm0 |
psubw mm4, mm0 |
psubw mm5, mm7 |
pxor mm0, mm0 |
pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 |
pand mm0, mm6 // Only pav bytes < 0 in mm7 |
psubw mm5, mm7 |
psubw mm6, mm0 |
// test pa <= pb |
movq mm7, mm4 |
psubw mm6, mm0 |
pcmpgtw mm7, mm5 // pa > pb? |
movq mm0, mm7 |
// use mm7 mask to merge pa & pb |
pand mm5, mm7 |
// use mm0 mask copy to merge a & b |
pand mm2, mm0 |
pandn mm7, mm4 |
pandn mm0, mm1 |
paddw mm7, mm5 |
paddw mm0, mm2 |
// test ((pa <= pb)? pa:pb) <= pc |
pcmpgtw mm7, mm6 // pab > pc? |
pxor mm1, mm1 |
pand mm3, mm7 |
pandn mm7, mm0 |
paddw mm7, mm3 |
pxor mm0, mm0 |
packuswb mm7, mm1 |
movq mm3, [esi + ebx] // load c=Prior(x-bpp) |
pand mm7, ActiveMask |
movq mm2, mm3 // load b=Prior(x) step 1 |
paddb mm7, [edi + ebx] // add Paeth predictor with Raw(x) |
punpcklbw mm3, mm0 // Unpack High bytes of c |
movq [edi + ebx], mm7 // write back updated value |
movq mm1, mm7 // Now mm1 will be used as Raw(x-bpp) |
// Do second set of 4 bytes |
punpckhbw mm2, mm0 // Unpack Low bytes of b |
punpcklbw mm1, mm0 // Unpack Low bytes of a |
// pav = p - a = (a + b - c) - a = b - c |
movq mm4, mm2 |
// pbv = p - b = (a + b - c) - b = a - c |
movq mm5, mm1 |
psubw mm4, mm3 |
pxor mm7, mm7 |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
movq mm6, mm4 |
psubw mm5, mm3 |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
pcmpgtw mm0, mm4 // Create mask pav bytes < 0 |
paddw mm6, mm5 |
pand mm0, mm4 // Only pav bytes < 0 in mm7 |
pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 |
psubw mm4, mm0 |
pand mm7, mm5 // Only pbv bytes < 0 in mm0 |
psubw mm4, mm0 |
psubw mm5, mm7 |
pxor mm0, mm0 |
pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 |
pand mm0, mm6 // Only pav bytes < 0 in mm7 |
psubw mm5, mm7 |
psubw mm6, mm0 |
// test pa <= pb |
movq mm7, mm4 |
psubw mm6, mm0 |
pcmpgtw mm7, mm5 // pa > pb? |
movq mm0, mm7 |
// use mm7 mask to merge pa & pb |
pand mm5, mm7 |
// use mm0 mask copy to merge a & b |
pand mm2, mm0 |
pandn mm7, mm4 |
pandn mm0, mm1 |
paddw mm7, mm5 |
paddw mm0, mm2 |
// test ((pa <= pb)? pa:pb) <= pc |
pcmpgtw mm7, mm6 // pab > pc? |
pxor mm1, mm1 |
pand mm3, mm7 |
pandn mm7, mm0 |
pxor mm1, mm1 |
paddw mm7, mm3 |
pxor mm0, mm0 |
// Step ex to next set of 8 bytes and repeat loop til done |
add ebx, 8 |
packuswb mm1, mm7 |
paddb mm1, [edi + ebx - 8] // add Paeth predictor with Raw(x) |
cmp ebx, MMXLength |
movq [edi + ebx - 8], mm1 // write back updated value |
// mm1 will be used as Raw(x-bpp) next loop |
jb dpth4lp |
} // end _asm block |
} |
break; |
case 8: // bpp == 8 |
{ |
ActiveMask.use = 0x00000000ffffffff; |
_asm { |
mov ebx, diff |
mov edi, row |
mov esi, prev_row |
pxor mm0, mm0 |
// PRIME the pump (load the first Raw(x-bpp) data set |
movq mm1, [edi+ebx-8] // Only time should need to read |
// a=Raw(x-bpp) bytes |
dpth8lp: |
// Do first set of 4 bytes |
movq mm3, [esi+ebx-8] // read c=Prior(x-bpp) bytes |
punpcklbw mm1, mm0 // Unpack Low bytes of a |
movq mm2, [esi + ebx] // load b=Prior(x) |
punpcklbw mm2, mm0 // Unpack Low bytes of b |
// pav = p - a = (a + b - c) - a = b - c |
movq mm4, mm2 |
punpcklbw mm3, mm0 // Unpack Low bytes of c |
// pbv = p - b = (a + b - c) - b = a - c |
movq mm5, mm1 |
psubw mm4, mm3 |
pxor mm7, mm7 |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
movq mm6, mm4 |
psubw mm5, mm3 |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
pcmpgtw mm0, mm4 // Create mask pav bytes < 0 |
paddw mm6, mm5 |
pand mm0, mm4 // Only pav bytes < 0 in mm7 |
pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 |
psubw mm4, mm0 |
pand mm7, mm5 // Only pbv bytes < 0 in mm0 |
psubw mm4, mm0 |
psubw mm5, mm7 |
pxor mm0, mm0 |
pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 |
pand mm0, mm6 // Only pav bytes < 0 in mm7 |
psubw mm5, mm7 |
psubw mm6, mm0 |
// test pa <= pb |
movq mm7, mm4 |
psubw mm6, mm0 |
pcmpgtw mm7, mm5 // pa > pb? |
movq mm0, mm7 |
// use mm7 mask to merge pa & pb |
pand mm5, mm7 |
// use mm0 mask copy to merge a & b |
pand mm2, mm0 |
pandn mm7, mm4 |
pandn mm0, mm1 |
paddw mm7, mm5 |
paddw mm0, mm2 |
// test ((pa <= pb)? pa:pb) <= pc |
pcmpgtw mm7, mm6 // pab > pc? |
pxor mm1, mm1 |
pand mm3, mm7 |
pandn mm7, mm0 |
paddw mm7, mm3 |
pxor mm0, mm0 |
packuswb mm7, mm1 |
movq mm3, [esi+ebx-8] // read c=Prior(x-bpp) bytes |
pand mm7, ActiveMask |
movq mm2, [esi + ebx] // load b=Prior(x) |
paddb mm7, [edi + ebx] // add Paeth predictor with Raw(x) |
punpckhbw mm3, mm0 // Unpack High bytes of c |
movq [edi + ebx], mm7 // write back updated value |
movq mm1, [edi+ebx-8] // read a=Raw(x-bpp) bytes |
// Do second set of 4 bytes |
punpckhbw mm2, mm0 // Unpack High bytes of b |
punpckhbw mm1, mm0 // Unpack High bytes of a |
// pav = p - a = (a + b - c) - a = b - c |
movq mm4, mm2 |
// pbv = p - b = (a + b - c) - b = a - c |
movq mm5, mm1 |
psubw mm4, mm3 |
pxor mm7, mm7 |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
movq mm6, mm4 |
psubw mm5, mm3 |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
pcmpgtw mm0, mm4 // Create mask pav bytes < 0 |
paddw mm6, mm5 |
pand mm0, mm4 // Only pav bytes < 0 in mm7 |
pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 |
psubw mm4, mm0 |
pand mm7, mm5 // Only pbv bytes < 0 in mm0 |
psubw mm4, mm0 |
psubw mm5, mm7 |
pxor mm0, mm0 |
pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 |
pand mm0, mm6 // Only pav bytes < 0 in mm7 |
psubw mm5, mm7 |
psubw mm6, mm0 |
// test pa <= pb |
movq mm7, mm4 |
psubw mm6, mm0 |
pcmpgtw mm7, mm5 // pa > pb? |
movq mm0, mm7 |
// use mm7 mask to merge pa & pb |
pand mm5, mm7 |
// use mm0 mask copy to merge a & b |
pand mm2, mm0 |
pandn mm7, mm4 |
pandn mm0, mm1 |
paddw mm7, mm5 |
paddw mm0, mm2 |
// test ((pa <= pb)? pa:pb) <= pc |
pcmpgtw mm7, mm6 // pab > pc? |
pxor mm1, mm1 |
pand mm3, mm7 |
pandn mm7, mm0 |
pxor mm1, mm1 |
paddw mm7, mm3 |
pxor mm0, mm0 |
// Step ex to next set of 8 bytes and repeat loop til done |
add ebx, 8 |
packuswb mm1, mm7 |
paddb mm1, [edi + ebx - 8] // add Paeth predictor with Raw(x) |
cmp ebx, MMXLength |
movq [edi + ebx - 8], mm1 // write back updated value |
// mm1 will be used as Raw(x-bpp) next loop |
jb dpth8lp |
} // end _asm block |
} |
break; |
case 1: // bpp = 1 |
case 2: // bpp = 2 |
default: // bpp > 8 |
{ |
_asm { |
mov ebx, diff |
cmp ebx, FullLength |
jnb dpthdend |
mov edi, row |
mov esi, prev_row |
// Do Paeth decode for remaining bytes |
mov edx, ebx |
xor ecx, ecx // zero ecx before using cl & cx in loop below |
sub edx, bpp // Set edx = ebx - bpp |
dpthdlp: |
xor eax, eax |
// pav = p - a = (a + b - c) - a = b - c |
mov al, [esi + ebx] // load Prior(x) into al |
mov cl, [esi + edx] // load Prior(x-bpp) into cl |
sub eax, ecx // subtract Prior(x-bpp) |
mov patemp, eax // Save pav for later use |
xor eax, eax |
// pbv = p - b = (a + b - c) - b = a - c |
mov al, [edi + edx] // load Raw(x-bpp) into al |
sub eax, ecx // subtract Prior(x-bpp) |
mov ecx, eax |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
add eax, patemp // pcv = pav + pbv |
// pc = abs(pcv) |
test eax, 0x80000000 |
jz dpthdpca |
neg eax // reverse sign of neg values |
dpthdpca: |
mov pctemp, eax // save pc for later use |
// pb = abs(pbv) |
test ecx, 0x80000000 |
jz dpthdpba |
neg ecx // reverse sign of neg values |
dpthdpba: |
mov pbtemp, ecx // save pb for later use |
// pa = abs(pav) |
mov eax, patemp |
test eax, 0x80000000 |
jz dpthdpaa |
neg eax // reverse sign of neg values |
dpthdpaa: |
mov patemp, eax // save pa for later use |
// test if pa <= pb |
cmp eax, ecx |
jna dpthdabb |
// pa > pb; now test if pb <= pc |
cmp ecx, pctemp |
jna dpthdbbc |
// pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp) |
mov cl, [esi + edx] // load Prior(x-bpp) into cl |
jmp dpthdpaeth |
dpthdbbc: |
// pb <= pc; Raw(x) = Paeth(x) + Prior(x) |
mov cl, [esi + ebx] // load Prior(x) into cl |
jmp dpthdpaeth |
dpthdabb: |
// pa <= pb; now test if pa <= pc |
cmp eax, pctemp |
jna dpthdabc |
// pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp) |
mov cl, [esi + edx] // load Prior(x-bpp) into cl |
jmp dpthdpaeth |
dpthdabc: |
// pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp) |
mov cl, [edi + edx] // load Raw(x-bpp) into cl |
dpthdpaeth: |
inc ebx |
inc edx |
// Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256 |
add [edi + ebx - 1], cl |
cmp ebx, FullLength |
jb dpthdlp |
dpthdend: |
} // end _asm block |
} |
return; // No need to go further with this one |
} // end switch ( bpp ) |
_asm |
{ |
// MMX acceleration complete now do clean-up |
// Check if any remaining bytes left to decode |
mov ebx, MMXLength |
cmp ebx, FullLength |
jnb dpthend |
mov edi, row |
mov esi, prev_row |
// Do Paeth decode for remaining bytes |
mov edx, ebx |
xor ecx, ecx // zero ecx before using cl & cx in loop below |
sub edx, bpp // Set edx = ebx - bpp |
dpthlp2: |
xor eax, eax |
// pav = p - a = (a + b - c) - a = b - c |
mov al, [esi + ebx] // load Prior(x) into al |
mov cl, [esi + edx] // load Prior(x-bpp) into cl |
sub eax, ecx // subtract Prior(x-bpp) |
mov patemp, eax // Save pav for later use |
xor eax, eax |
// pbv = p - b = (a + b - c) - b = a - c |
mov al, [edi + edx] // load Raw(x-bpp) into al |
sub eax, ecx // subtract Prior(x-bpp) |
mov ecx, eax |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
add eax, patemp // pcv = pav + pbv |
// pc = abs(pcv) |
test eax, 0x80000000 |
jz dpthpca2 |
neg eax // reverse sign of neg values |
dpthpca2: |
mov pctemp, eax // save pc for later use |
// pb = abs(pbv) |
test ecx, 0x80000000 |
jz dpthpba2 |
neg ecx // reverse sign of neg values |
dpthpba2: |
mov pbtemp, ecx // save pb for later use |
// pa = abs(pav) |
mov eax, patemp |
test eax, 0x80000000 |
jz dpthpaa2 |
neg eax // reverse sign of neg values |
dpthpaa2: |
mov patemp, eax // save pa for later use |
// test if pa <= pb |
cmp eax, ecx |
jna dpthabb2 |
// pa > pb; now test if pb <= pc |
cmp ecx, pctemp |
jna dpthbbc2 |
// pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp) |
mov cl, [esi + edx] // load Prior(x-bpp) into cl |
jmp dpthpaeth2 |
dpthbbc2: |
// pb <= pc; Raw(x) = Paeth(x) + Prior(x) |
mov cl, [esi + ebx] // load Prior(x) into cl |
jmp dpthpaeth2 |
dpthabb2: |
// pa <= pb; now test if pa <= pc |
cmp eax, pctemp |
jna dpthabc2 |
// pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp) |
mov cl, [esi + edx] // load Prior(x-bpp) into cl |
jmp dpthpaeth2 |
dpthabc2: |
// pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp) |
mov cl, [edi + edx] // load Raw(x-bpp) into cl |
dpthpaeth2: |
inc ebx |
inc edx |
// Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256 |
add [edi + ebx - 1], cl |
cmp ebx, FullLength |
jb dpthlp2 |
dpthend: |
emms // End MMX instructions; prep for possible FP instrs. |
} // end _asm block |
} |
// Optimized code for PNG Sub filter decoder |
void /* PRIVATE */ |
png_read_filter_row_mmx_sub(png_row_infop row_info, png_bytep row) |
{ |
//int test; |
int bpp; |
png_uint_32 FullLength; |
png_uint_32 MMXLength; |
int diff; |
bpp = (row_info->pixel_depth + 7) >> 3; // Get # bytes per pixel |
FullLength = row_info->rowbytes - bpp; // # of bytes to filter |
_asm { |
mov edi, row |
mov esi, edi // lp = row |
add edi, bpp // rp = row + bpp |
xor eax, eax |
// get # of bytes to alignment |
mov diff, edi // take start of row |
add diff, 0xf // add 7 + 8 to incr past |
// alignment boundary |
xor ebx, ebx |
and diff, 0xfffffff8 // mask to alignment boundary |
sub diff, edi // subtract from start ==> value |
// ebx at alignment |
jz dsubgo |
// fix alignment |
dsublp1: |
mov al, [esi+ebx] |
add [edi+ebx], al |
inc ebx |
cmp ebx, diff |
jb dsublp1 |
dsubgo: |
mov ecx, FullLength |
mov edx, ecx |
sub edx, ebx // subtract alignment fix |
and edx, 0x00000007 // calc bytes over mult of 8 |
sub ecx, edx // drop over bytes from length |
mov MMXLength, ecx |
} // end _asm block |
// Now do the math for the rest of the row |
switch ( bpp ) |
{ |
case 3: |
{ |
ActiveMask.use = 0x0000ffffff000000; |
ShiftBpp.use = 24; // == 3 * 8 |
ShiftRem.use = 40; // == 64 - 24 |
_asm { |
mov edi, row |
movq mm7, ActiveMask // Load ActiveMask for 2nd active byte group |
mov esi, edi // lp = row |
add edi, bpp // rp = row + bpp |
movq mm6, mm7 |
mov ebx, diff |
psllq mm6, ShiftBpp // Move mask in mm6 to cover 3rd active |
// byte group |
// PRIME the pump (load the first Raw(x-bpp) data set |
movq mm1, [edi+ebx-8] |
dsub3lp: |
psrlq mm1, ShiftRem // Shift data for adding 1st bpp bytes |
// no need for mask; shift clears inactive bytes |
// Add 1st active group |
movq mm0, [edi+ebx] |
paddb mm0, mm1 |
// Add 2nd active group |
movq mm1, mm0 // mov updated Raws to mm1 |
psllq mm1, ShiftBpp // shift data to position correctly |
pand mm1, mm7 // mask to use only 2nd active group |
paddb mm0, mm1 |
// Add 3rd active group |
movq mm1, mm0 // mov updated Raws to mm1 |
psllq mm1, ShiftBpp // shift data to position correctly |
pand mm1, mm6 // mask to use only 3rd active group |
add ebx, 8 |
paddb mm0, mm1 |
cmp ebx, MMXLength |
movq [edi+ebx-8], mm0 // Write updated Raws back to array |
// Prep for doing 1st add at top of loop |
movq mm1, mm0 |
jb dsub3lp |
} // end _asm block |
} |
break; |
case 1: |
{ |
// Placed here just in case this is a duplicate of the |
// non-MMX code for the SUB filter in png_read_filter_row below |
// |
// png_bytep rp; |
// png_bytep lp; |
// png_uint_32 i; |
// bpp = (row_info->pixel_depth + 7) >> 3; |
// for (i = (png_uint_32)bpp, rp = row + bpp, lp = row; |
// i < row_info->rowbytes; i++, rp++, lp++) |
// { |
// *rp = (png_byte)(((int)(*rp) + (int)(*lp)) & 0xff); |
// } |
_asm { |
mov ebx, diff |
mov edi, row |
cmp ebx, FullLength |
jnb dsub1end |
mov esi, edi // lp = row |
xor eax, eax |
add edi, bpp // rp = row + bpp |
dsub1lp: |
mov al, [esi+ebx] |
add [edi+ebx], al |
inc ebx |
cmp ebx, FullLength |
jb dsub1lp |
dsub1end: |
} // end _asm block |
} |
return; |
case 6: |
case 7: |
case 4: |
case 5: |
{ |
ShiftBpp.use = bpp << 3; |
ShiftRem.use = 64 - ShiftBpp.use; |
_asm { |
mov edi, row |
mov ebx, diff |
mov esi, edi // lp = row |
add edi, bpp // rp = row + bpp |
// PRIME the pump (load the first Raw(x-bpp) data set |
movq mm1, [edi+ebx-8] |
dsub4lp: |
psrlq mm1, ShiftRem // Shift data for adding 1st bpp bytes |
// no need for mask; shift clears inactive bytes |
movq mm0, [edi+ebx] |
paddb mm0, mm1 |
// Add 2nd active group |
movq mm1, mm0 // mov updated Raws to mm1 |
psllq mm1, ShiftBpp // shift data to position correctly |
// there is no need for any mask |
// since shift clears inactive bits/bytes |
add ebx, 8 |
paddb mm0, mm1 |
cmp ebx, MMXLength |
movq [edi+ebx-8], mm0 |
movq mm1, mm0 // Prep for doing 1st add at top of loop |
jb dsub4lp |
} // end _asm block |
} |
break; |
case 2: |
{ |
ActiveMask.use = 0x00000000ffff0000; |
ShiftBpp.use = 16; // == 2 * 8 |
ShiftRem.use = 48; // == 64 - 16 |
_asm { |
movq mm7, ActiveMask // Load ActiveMask for 2nd active byte group |
mov ebx, diff |
movq mm6, mm7 |
mov edi, row |
psllq mm6, ShiftBpp // Move mask in mm6 to cover 3rd active |
// byte group |
mov esi, edi // lp = row |
movq mm5, mm6 |
add edi, bpp // rp = row + bpp |
psllq mm5, ShiftBpp // Move mask in mm5 to cover 4th active |
// byte group |
// PRIME the pump (load the first Raw(x-bpp) data set |
movq mm1, [edi+ebx-8] |
dsub2lp: |
// Add 1st active group |
psrlq mm1, ShiftRem // Shift data for adding 1st bpp bytes |
// no need for mask; shift clears inactive |
// bytes |
movq mm0, [edi+ebx] |
paddb mm0, mm1 |
// Add 2nd active group |
movq mm1, mm0 // mov updated Raws to mm1 |
psllq mm1, ShiftBpp // shift data to position correctly |
pand mm1, mm7 // mask to use only 2nd active group |
paddb mm0, mm1 |
// Add 3rd active group |
movq mm1, mm0 // mov updated Raws to mm1 |
psllq mm1, ShiftBpp // shift data to position correctly |
pand mm1, mm6 // mask to use only 3rd active group |
paddb mm0, mm1 |
// Add 4th active group |
movq mm1, mm0 // mov updated Raws to mm1 |
psllq mm1, ShiftBpp // shift data to position correctly |
pand mm1, mm5 // mask to use only 4th active group |
add ebx, 8 |
paddb mm0, mm1 |
cmp ebx, MMXLength |
movq [edi+ebx-8], mm0 // Write updated Raws back to array |
movq mm1, mm0 // Prep for doing 1st add at top of loop |
jb dsub2lp |
} // end _asm block |
} |
break; |
case 8: |
{ |
_asm { |
mov edi, row |
mov ebx, diff |
mov esi, edi // lp = row |
add edi, bpp // rp = row + bpp |
mov ecx, MMXLength |
movq mm7, [edi+ebx-8] // PRIME the pump (load the first |
// Raw(x-bpp) data set |
and ecx, 0x0000003f // calc bytes over mult of 64 |
dsub8lp: |
movq mm0, [edi+ebx] // Load Sub(x) for 1st 8 bytes |
paddb mm0, mm7 |
movq mm1, [edi+ebx+8] // Load Sub(x) for 2nd 8 bytes |
movq [edi+ebx], mm0 // Write Raw(x) for 1st 8 bytes |
// Now mm0 will be used as Raw(x-bpp) for |
// the 2nd group of 8 bytes. This will be |
// repeated for each group of 8 bytes with |
// the 8th group being used as the Raw(x-bpp) |
// for the 1st group of the next loop. |
paddb mm1, mm0 |
movq mm2, [edi+ebx+16] // Load Sub(x) for 3rd 8 bytes |
movq [edi+ebx+8], mm1 // Write Raw(x) for 2nd 8 bytes |
paddb mm2, mm1 |
movq mm3, [edi+ebx+24] // Load Sub(x) for 4th 8 bytes |
movq [edi+ebx+16], mm2 // Write Raw(x) for 3rd 8 bytes |
paddb mm3, mm2 |
movq mm4, [edi+ebx+32] // Load Sub(x) for 5th 8 bytes |
movq [edi+ebx+24], mm3 // Write Raw(x) for 4th 8 bytes |
paddb mm4, mm3 |
movq mm5, [edi+ebx+40] // Load Sub(x) for 6th 8 bytes |
movq [edi+ebx+32], mm4 // Write Raw(x) for 5th 8 bytes |
paddb mm5, mm4 |
movq mm6, [edi+ebx+48] // Load Sub(x) for 7th 8 bytes |
movq [edi+ebx+40], mm5 // Write Raw(x) for 6th 8 bytes |
paddb mm6, mm5 |
movq mm7, [edi+ebx+56] // Load Sub(x) for 8th 8 bytes |
movq [edi+ebx+48], mm6 // Write Raw(x) for 7th 8 bytes |
add ebx, 64 |
paddb mm7, mm6 |
cmp ebx, ecx |
movq [edi+ebx-8], mm7 // Write Raw(x) for 8th 8 bytes |
jb dsub8lp |
cmp ebx, MMXLength |
jnb dsub8lt8 |
dsub8lpA: |
movq mm0, [edi+ebx] |
add ebx, 8 |
paddb mm0, mm7 |
cmp ebx, MMXLength |
movq [edi+ebx-8], mm0 // use -8 to offset early add to ebx |
movq mm7, mm0 // Move calculated Raw(x) data to mm1 to |
// be the new Raw(x-bpp) for the next loop |
jb dsub8lpA |
dsub8lt8: |
} // end _asm block |
} |
break; |
default: // bpp greater than 8 bytes |
{ |
_asm { |
mov ebx, diff |
mov edi, row |
mov esi, edi // lp = row |
add edi, bpp // rp = row + bpp |
dsubAlp: |
movq mm0, [edi+ebx] |
movq mm1, [esi+ebx] |
add ebx, 8 |
paddb mm0, mm1 |
cmp ebx, MMXLength |
movq [edi+ebx-8], mm0 // mov does not affect flags; -8 to offset |
// add ebx |
jb dsubAlp |
} // end _asm block |
} |
break; |
} // end switch ( bpp ) |
_asm { |
mov ebx, MMXLength |
mov edi, row |
cmp ebx, FullLength |
jnb dsubend |
mov esi, edi // lp = row |
xor eax, eax |
add edi, bpp // rp = row + bpp |
dsublp2: |
mov al, [esi+ebx] |
add [edi+ebx], al |
inc ebx |
cmp ebx, FullLength |
jb dsublp2 |
dsubend: |
emms // End MMX instructions; prep for possible FP instrs. |
} // end _asm block |
} |
// Optimized code for PNG Up filter decoder |
void /* PRIVATE */ |
png_read_filter_row_mmx_up(png_row_infop row_info, png_bytep row, |
png_bytep prev_row) |
{ |
png_uint_32 len; |
len = row_info->rowbytes; // # of bytes to filter |
_asm { |
mov edi, row |
// get # of bytes to alignment |
mov ecx, edi |
xor ebx, ebx |
add ecx, 0x7 |
xor eax, eax |
and ecx, 0xfffffff8 |
mov esi, prev_row |
sub ecx, edi |
jz dupgo |
// fix alignment |
duplp1: |
mov al, [edi+ebx] |
add al, [esi+ebx] |
inc ebx |
cmp ebx, ecx |
mov [edi + ebx-1], al // mov does not affect flags; -1 to offset inc ebx |
jb duplp1 |
dupgo: |
mov ecx, len |
mov edx, ecx |
sub edx, ebx // subtract alignment fix |
and edx, 0x0000003f // calc bytes over mult of 64 |
sub ecx, edx // drop over bytes from length |
// Unrolled loop - use all MMX registers and interleave to reduce |
// number of branch instructions (loops) and reduce partial stalls |
duploop: |
movq mm1, [esi+ebx] |
movq mm0, [edi+ebx] |
movq mm3, [esi+ebx+8] |
paddb mm0, mm1 |
movq mm2, [edi+ebx+8] |
movq [edi+ebx], mm0 |
paddb mm2, mm3 |
movq mm5, [esi+ebx+16] |
movq [edi+ebx+8], mm2 |
movq mm4, [edi+ebx+16] |
movq mm7, [esi+ebx+24] |
paddb mm4, mm5 |
movq mm6, [edi+ebx+24] |
movq [edi+ebx+16], mm4 |
paddb mm6, mm7 |
movq mm1, [esi+ebx+32] |
movq [edi+ebx+24], mm6 |
movq mm0, [edi+ebx+32] |
movq mm3, [esi+ebx+40] |
paddb mm0, mm1 |
movq mm2, [edi+ebx+40] |
movq [edi+ebx+32], mm0 |
paddb mm2, mm3 |
movq mm5, [esi+ebx+48] |
movq [edi+ebx+40], mm2 |
movq mm4, [edi+ebx+48] |
movq mm7, [esi+ebx+56] |
paddb mm4, mm5 |
movq mm6, [edi+ebx+56] |
movq [edi+ebx+48], mm4 |
add ebx, 64 |
paddb mm6, mm7 |
cmp ebx, ecx |
movq [edi+ebx-8], mm6 // (+56)movq does not affect flags; |
// -8 to offset add ebx |
jb duploop |
cmp edx, 0 // Test for bytes over mult of 64 |
jz dupend |
// 2 lines added by lcreeve@netins.net |
// (mail 11 Jul 98 in png-implement list) |
cmp edx, 8 //test for less than 8 bytes |
jb duplt8 |
add ecx, edx |
and edx, 0x00000007 // calc bytes over mult of 8 |
sub ecx, edx // drop over bytes from length |
jz duplt8 |
// Loop using MMX registers mm0 & mm1 to update 8 bytes simultaneously |
duplpA: |
movq mm1, [esi+ebx] |
movq mm0, [edi+ebx] |
add ebx, 8 |
paddb mm0, mm1 |
cmp ebx, ecx |
movq [edi+ebx-8], mm0 // movq does not affect flags; -8 to offset add ebx |
jb duplpA |
cmp edx, 0 // Test for bytes over mult of 8 |
jz dupend |
duplt8: |
xor eax, eax |
add ecx, edx // move over byte count into counter |
// Loop using x86 registers to update remaining bytes |
duplp2: |
mov al, [edi + ebx] |
add al, [esi + ebx] |
inc ebx |
cmp ebx, ecx |
mov [edi + ebx-1], al // mov does not affect flags; -1 to offset inc ebx |
jb duplp2 |
dupend: |
// Conversion of filtered row completed |
emms // End MMX instructions; prep for possible FP instrs. |
} // end _asm block |
} |
// Optimized png_read_filter_row routines |
void /* PRIVATE */ |
png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep |
row, png_bytep prev_row, int filter) |
{ |
#ifdef PNG_DEBUG |
char filnm[10]; |
#endif |
if (mmx_supported == 2) { |
/* this should have happened in png_init_mmx_flags() already */ |
png_warning(png_ptr, "asm_flags may not have been initialized"); |
png_mmx_support(); |
} |
#ifdef PNG_DEBUG |
png_debug(1, "in png_read_filter_row\n"); |
switch (filter) |
{ |
case 0: sprintf(filnm, "none"); |
break; |
case 1: sprintf(filnm, "sub-%s", |
(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_SUB)? "MMX" : "x86"); |
break; |
case 2: sprintf(filnm, "up-%s", |
(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_UP)? "MMX" : "x86"); |
break; |
case 3: sprintf(filnm, "avg-%s", |
(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_AVG)? "MMX" : "x86"); |
break; |
case 4: sprintf(filnm, "Paeth-%s", |
(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH)? "MMX":"x86"); |
break; |
default: sprintf(filnm, "unknw"); |
break; |
} |
png_debug2(0,"row=%5d, %s, ", png_ptr->row_number, filnm); |
png_debug2(0, "pd=%2d, b=%d, ", (int)row_info->pixel_depth, |
(int)((row_info->pixel_depth + 7) >> 3)); |
png_debug1(0,"len=%8d, ", row_info->rowbytes); |
#endif /* PNG_DEBUG */ |
switch (filter) |
{ |
case PNG_FILTER_VALUE_NONE: |
break; |
case PNG_FILTER_VALUE_SUB: |
{ |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_SUB) && |
(row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && |
(row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) |
{ |
png_read_filter_row_mmx_sub(row_info, row); |
} |
else |
{ |
png_uint_32 i; |
png_uint_32 istop = row_info->rowbytes; |
png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; |
png_bytep rp = row + bpp; |
png_bytep lp = row; |
for (i = bpp; i < istop; i++) |
{ |
*rp = (png_byte)(((int)(*rp) + (int)(*lp++)) & 0xff); |
rp++; |
} |
} |
break; |
} |
case PNG_FILTER_VALUE_UP: |
{ |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_UP) && |
(row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && |
(row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) |
{ |
png_read_filter_row_mmx_up(row_info, row, prev_row); |
} |
else |
{ |
png_uint_32 i; |
png_uint_32 istop = row_info->rowbytes; |
png_bytep rp = row; |
png_bytep pp = prev_row; |
for (i = 0; i < istop; ++i) |
{ |
*rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); |
rp++; |
} |
} |
break; |
} |
case PNG_FILTER_VALUE_AVG: |
{ |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_AVG) && |
(row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && |
(row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) |
{ |
png_read_filter_row_mmx_avg(row_info, row, prev_row); |
} |
else |
{ |
png_uint_32 i; |
png_bytep rp = row; |
png_bytep pp = prev_row; |
png_bytep lp = row; |
png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; |
png_uint_32 istop = row_info->rowbytes - bpp; |
for (i = 0; i < bpp; i++) |
{ |
*rp = (png_byte)(((int)(*rp) + |
((int)(*pp++) >> 1)) & 0xff); |
rp++; |
} |
for (i = 0; i < istop; i++) |
{ |
*rp = (png_byte)(((int)(*rp) + |
((int)(*pp++ + *lp++) >> 1)) & 0xff); |
rp++; |
} |
} |
break; |
} |
case PNG_FILTER_VALUE_PAETH: |
{ |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH) && |
(row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && |
(row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) |
{ |
png_read_filter_row_mmx_paeth(row_info, row, prev_row); |
} |
else |
{ |
png_uint_32 i; |
png_bytep rp = row; |
png_bytep pp = prev_row; |
png_bytep lp = row; |
png_bytep cp = prev_row; |
png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; |
png_uint_32 istop=row_info->rowbytes - bpp; |
for (i = 0; i < bpp; i++) |
{ |
*rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); |
rp++; |
} |
for (i = 0; i < istop; i++) // use leftover rp,pp |
{ |
int a, b, c, pa, pb, pc, p; |
a = *lp++; |
b = *pp++; |
c = *cp++; |
p = b - c; |
pc = a - c; |
#ifdef PNG_USE_ABS |
pa = abs(p); |
pb = abs(pc); |
pc = abs(p + pc); |
#else |
pa = p < 0 ? -p : p; |
pb = pc < 0 ? -pc : pc; |
pc = (p + pc) < 0 ? -(p + pc) : p + pc; |
#endif |
/* |
if (pa <= pb && pa <= pc) |
p = a; |
else if (pb <= pc) |
p = b; |
else |
p = c; |
*/ |
p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c; |
*rp = (png_byte)(((int)(*rp) + p) & 0xff); |
rp++; |
} |
} |
break; |
} |
default: |
png_warning(png_ptr, "Ignoring bad row filter type"); |
*row=0; |
break; |
} |
} |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED && PNG_USE_PNGVCRD */ |
/shark/trunk/ports/png/pngread.c |
---|
0,0 → 1,1424 |
/* pngread.c - read a PNG file |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
* This file contains routines that an application calls directly to |
* read a PNG file or stream. |
*/ |
#define PNG_INTERNAL |
#include "png.h" |
/* Create a PNG structure for reading, and allocate any memory needed. */ |
png_structp PNGAPI |
png_create_read_struct(png_const_charp user_png_ver, png_voidp error_ptr, |
png_error_ptr error_fn, png_error_ptr warn_fn) |
{ |
#ifdef PNG_USER_MEM_SUPPORTED |
return (png_create_read_struct_2(user_png_ver, error_ptr, error_fn, |
warn_fn, png_voidp_NULL, png_malloc_ptr_NULL, png_free_ptr_NULL)); |
} |
/* Alternate create PNG structure for reading, and allocate any memory needed. */ |
png_structp PNGAPI |
png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr, |
png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, |
png_malloc_ptr malloc_fn, png_free_ptr free_fn) |
{ |
#endif /* PNG_USER_MEM_SUPPORTED */ |
png_structp png_ptr; |
#ifdef PNG_SETJMP_SUPPORTED |
#ifdef USE_FAR_KEYWORD |
jmp_buf jmpbuf; |
#endif |
#endif |
int i; |
png_debug(1, "in png_create_read_struct\n"); |
#ifdef PNG_USER_MEM_SUPPORTED |
png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG, |
(png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr); |
#else |
png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); |
#endif |
if (png_ptr == NULL) |
return (NULL); |
#if !defined(PNG_1_0_X) |
#ifdef PNG_ASSEMBLER_CODE_SUPPORTED |
png_init_mmx_flags(png_ptr); /* 1.2.0 addition */ |
#endif |
#endif /* PNG_1_0_X */ |
#ifdef PNG_SETJMP_SUPPORTED |
#ifdef USE_FAR_KEYWORD |
if (setjmp(jmpbuf)) |
#else |
if (setjmp(png_ptr->jmpbuf)) |
#endif |
{ |
png_free(png_ptr, png_ptr->zbuf); |
png_ptr->zbuf=NULL; |
#ifdef PNG_USER_MEM_SUPPORTED |
png_destroy_struct_2((png_voidp)png_ptr, |
(png_free_ptr)free_fn, (png_voidp)mem_ptr); |
#else |
png_destroy_struct((png_voidp)png_ptr); |
#endif |
return (NULL); |
} |
#ifdef USE_FAR_KEYWORD |
png_memcpy(png_ptr->jmpbuf,jmpbuf,sizeof(jmp_buf)); |
#endif |
#endif |
#ifdef PNG_USER_MEM_SUPPORTED |
png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn); |
#endif |
png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn); |
i=0; |
do |
{ |
if(user_png_ver[i] != png_libpng_ver[i]) |
png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; |
} while (png_libpng_ver[i++]); |
if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH) |
{ |
/* Libpng 0.90 and later are binary incompatible with libpng 0.89, so |
* we must recompile any applications that use any older library version. |
* For versions after libpng 1.0, we will be compatible, so we need |
* only check the first digit. |
*/ |
if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] || |
(user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) || |
(user_png_ver[0] == '0' && user_png_ver[2] < '9')) |
{ |
#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) |
char msg[80]; |
if (user_png_ver) |
{ |
sprintf(msg, "Application was compiled with png.h from libpng-%.20s", |
user_png_ver); |
png_warning(png_ptr, msg); |
} |
sprintf(msg, "Application is running with png.c from libpng-%.20s", |
png_libpng_ver); |
png_warning(png_ptr, msg); |
#endif |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
png_ptr->flags=0; |
#endif |
png_error(png_ptr, |
"Incompatible libpng version in application and library"); |
} |
} |
/* initialize zbuf - compression buffer */ |
png_ptr->zbuf_size = PNG_ZBUF_SIZE; |
png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)png_ptr->zbuf_size); |
png_ptr->zstream.zalloc = png_zalloc; |
png_ptr->zstream.zfree = png_zfree; |
png_ptr->zstream.opaque = (voidpf)png_ptr; |
switch (inflateInit(&png_ptr->zstream)) |
{ |
case Z_OK: /* Do nothing */ break; |
case Z_MEM_ERROR: |
case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory error"); break; |
case Z_VERSION_ERROR: png_error(png_ptr, "zlib version error"); break; |
default: png_error(png_ptr, "Unknown zlib error"); |
} |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL); |
#ifdef PNG_SETJMP_SUPPORTED |
/* Applications that neglect to set up their own setjmp() and then encounter |
a png_error() will longjmp here. Since the jmpbuf is then meaningless we |
abort instead of returning. */ |
#ifdef USE_FAR_KEYWORD |
if (setjmp(jmpbuf)) |
PNG_ABORT(); |
png_memcpy(png_ptr->jmpbuf,jmpbuf,sizeof(jmp_buf)); |
#else |
if (setjmp(png_ptr->jmpbuf)) |
PNG_ABORT(); |
#endif |
#endif |
return (png_ptr); |
} |
/* Initialize PNG structure for reading, and allocate any memory needed. |
This interface is deprecated in favour of the png_create_read_struct(), |
and it will eventually disappear. */ |
#undef png_read_init |
void PNGAPI |
png_read_init(png_structp png_ptr) |
{ |
/* We only come here via pre-1.0.7-compiled applications */ |
png_read_init_2(png_ptr, "1.0.6 or earlier", 0, 0); |
} |
void PNGAPI |
png_read_init_2(png_structp png_ptr, png_const_charp user_png_ver, |
png_size_t png_struct_size, png_size_t png_info_size) |
{ |
/* We only come here via pre-1.0.12-compiled applications */ |
#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) |
if(sizeof(png_struct) > png_struct_size || sizeof(png_info) > png_info_size) |
{ |
char msg[80]; |
png_ptr->warning_fn=NULL; |
if (user_png_ver) |
{ |
sprintf(msg, "Application was compiled with png.h from libpng-%.20s", |
user_png_ver); |
png_warning(png_ptr, msg); |
} |
sprintf(msg, "Application is running with png.c from libpng-%.20s", |
png_libpng_ver); |
png_warning(png_ptr, msg); |
} |
#endif |
if(sizeof(png_struct) > png_struct_size) |
{ |
png_ptr->error_fn=NULL; |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
png_ptr->flags=0; |
#endif |
png_error(png_ptr, |
"The png struct allocated by the application for reading is too small."); |
} |
if(sizeof(png_info) > png_info_size) |
{ |
png_ptr->error_fn=NULL; |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
png_ptr->flags=0; |
#endif |
png_error(png_ptr, |
"The info struct allocated by application for reading is too small."); |
} |
png_read_init_3(&png_ptr, user_png_ver, png_struct_size); |
} |
void PNGAPI |
png_read_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver, |
png_size_t png_struct_size) |
{ |
#ifdef PNG_SETJMP_SUPPORTED |
jmp_buf tmp_jmp; /* to save current jump buffer */ |
#endif |
int i=0; |
png_structp png_ptr=*ptr_ptr; |
do |
{ |
if(user_png_ver[i] != png_libpng_ver[i]) |
{ |
#ifdef PNG_LEGACY_SUPPORTED |
png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; |
#else |
png_ptr->warning_fn=NULL; |
png_warning(png_ptr, |
"Application uses deprecated png_read_init() and should be recompiled."); |
break; |
#endif |
} |
} while (png_libpng_ver[i++]); |
png_debug(1, "in png_read_init_3\n"); |
#ifdef PNG_SETJMP_SUPPORTED |
/* save jump buffer and error functions */ |
png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf)); |
#endif |
if(sizeof(png_struct) > png_struct_size) |
{ |
png_destroy_struct(png_ptr); |
*ptr_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); |
png_ptr = *ptr_ptr; |
} |
/* reset all variables to 0 */ |
png_memset(png_ptr, 0, sizeof (png_struct)); |
#ifdef PNG_SETJMP_SUPPORTED |
/* restore jump buffer */ |
png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf)); |
#endif |
/* initialize zbuf - compression buffer */ |
png_ptr->zbuf_size = PNG_ZBUF_SIZE; |
png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)png_ptr->zbuf_size); |
png_ptr->zstream.zalloc = png_zalloc; |
png_ptr->zstream.zfree = png_zfree; |
png_ptr->zstream.opaque = (voidpf)png_ptr; |
switch (inflateInit(&png_ptr->zstream)) |
{ |
case Z_OK: /* Do nothing */ break; |
case Z_MEM_ERROR: |
case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory"); break; |
case Z_VERSION_ERROR: png_error(png_ptr, "zlib version"); break; |
default: png_error(png_ptr, "Unknown zlib error"); |
} |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL); |
} |
/* Read the information before the actual image data. This has been |
* changed in v0.90 to allow reading a file that already has the magic |
* bytes read from the stream. You can tell libpng how many bytes have |
* been read from the beginning of the stream (up to the maximum of 8) |
* via png_set_sig_bytes(), and we will only check the remaining bytes |
* here. The application can then have access to the signature bytes we |
* read if it is determined that this isn't a valid PNG file. |
*/ |
void PNGAPI |
png_read_info(png_structp png_ptr, png_infop info_ptr) |
{ |
png_debug(1, "in png_read_info\n"); |
/* If we haven't checked all of the PNG signature bytes, do so now. */ |
if (png_ptr->sig_bytes < 8) |
{ |
png_size_t num_checked = png_ptr->sig_bytes, |
num_to_check = 8 - num_checked; |
png_read_data(png_ptr, &(info_ptr->signature[num_checked]), num_to_check); |
png_ptr->sig_bytes = 8; |
if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check)) |
{ |
if (num_checked < 4 && |
png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4)) |
png_error(png_ptr, "Not a PNG file"); |
else |
png_error(png_ptr, "PNG file corrupted by ASCII conversion"); |
} |
if (num_checked < 3) |
png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE; |
} |
for(;;) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_IHDR; |
PNG_IDAT; |
PNG_IEND; |
PNG_PLTE; |
#if defined(PNG_READ_bKGD_SUPPORTED) |
PNG_bKGD; |
#endif |
#if defined(PNG_READ_cHRM_SUPPORTED) |
PNG_cHRM; |
#endif |
#if defined(PNG_READ_gAMA_SUPPORTED) |
PNG_gAMA; |
#endif |
#if defined(PNG_READ_hIST_SUPPORTED) |
PNG_hIST; |
#endif |
#if defined(PNG_READ_iCCP_SUPPORTED) |
PNG_iCCP; |
#endif |
#if defined(PNG_READ_iTXt_SUPPORTED) |
PNG_iTXt; |
#endif |
#if defined(PNG_READ_oFFs_SUPPORTED) |
PNG_oFFs; |
#endif |
#if defined(PNG_READ_pCAL_SUPPORTED) |
PNG_pCAL; |
#endif |
#if defined(PNG_READ_pHYs_SUPPORTED) |
PNG_pHYs; |
#endif |
#if defined(PNG_READ_sBIT_SUPPORTED) |
PNG_sBIT; |
#endif |
#if defined(PNG_READ_sCAL_SUPPORTED) |
PNG_sCAL; |
#endif |
#if defined(PNG_READ_sPLT_SUPPORTED) |
PNG_sPLT; |
#endif |
#if defined(PNG_READ_sRGB_SUPPORTED) |
PNG_sRGB; |
#endif |
#if defined(PNG_READ_tEXt_SUPPORTED) |
PNG_tEXt; |
#endif |
#if defined(PNG_READ_tIME_SUPPORTED) |
PNG_tIME; |
#endif |
#if defined(PNG_READ_tRNS_SUPPORTED) |
PNG_tRNS; |
#endif |
#if defined(PNG_READ_zTXt_SUPPORTED) |
PNG_zTXt; |
#endif |
#endif /* PNG_GLOBAL_ARRAYS */ |
png_byte chunk_length[4]; |
png_uint_32 length; |
png_read_data(png_ptr, chunk_length, 4); |
length = png_get_uint_32(chunk_length); |
png_reset_crc(png_ptr); |
png_crc_read(png_ptr, png_ptr->chunk_name, 4); |
png_debug2(0, "Reading %s chunk, length=%lu.\n", png_ptr->chunk_name, |
length); |
if (length > PNG_MAX_UINT) |
png_error(png_ptr, "Invalid chunk length."); |
/* This should be a binary subdivision search or a hash for |
* matching the chunk name rather than a linear search. |
*/ |
if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4)) |
png_handle_IHDR(png_ptr, info_ptr, length); |
else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4)) |
png_handle_IEND(png_ptr, info_ptr, length); |
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name)) |
{ |
if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) |
png_ptr->mode |= PNG_HAVE_IDAT; |
png_handle_unknown(png_ptr, info_ptr, length); |
if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4)) |
png_ptr->mode |= PNG_HAVE_PLTE; |
else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) |
{ |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before IDAT"); |
else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && |
!(png_ptr->mode & PNG_HAVE_PLTE)) |
png_error(png_ptr, "Missing PLTE before IDAT"); |
break; |
} |
} |
#endif |
else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4)) |
png_handle_PLTE(png_ptr, info_ptr, length); |
else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) |
{ |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before IDAT"); |
else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && |
!(png_ptr->mode & PNG_HAVE_PLTE)) |
png_error(png_ptr, "Missing PLTE before IDAT"); |
png_ptr->idat_size = length; |
png_ptr->mode |= PNG_HAVE_IDAT; |
break; |
} |
#if defined(PNG_READ_bKGD_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4)) |
png_handle_bKGD(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_cHRM_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4)) |
png_handle_cHRM(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_gAMA_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4)) |
png_handle_gAMA(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_hIST_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4)) |
png_handle_hIST(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_oFFs_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4)) |
png_handle_oFFs(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_pCAL_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4)) |
png_handle_pCAL(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_sCAL_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4)) |
png_handle_sCAL(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_pHYs_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4)) |
png_handle_pHYs(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_sBIT_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4)) |
png_handle_sBIT(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_sRGB_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4)) |
png_handle_sRGB(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_iCCP_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4)) |
png_handle_iCCP(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_sPLT_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4)) |
png_handle_sPLT(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_tEXt_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4)) |
png_handle_tEXt(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_tIME_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4)) |
png_handle_tIME(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_tRNS_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4)) |
png_handle_tRNS(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_zTXt_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4)) |
png_handle_zTXt(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_iTXt_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4)) |
png_handle_iTXt(png_ptr, info_ptr, length); |
#endif |
else |
png_handle_unknown(png_ptr, info_ptr, length); |
} |
} |
/* optional call to update the users info_ptr structure */ |
void PNGAPI |
png_read_update_info(png_structp png_ptr, png_infop info_ptr) |
{ |
png_debug(1, "in png_read_update_info\n"); |
if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) |
png_read_start_row(png_ptr); |
else |
png_warning(png_ptr, |
"Ignoring extra png_read_update_info() call; row buffer not reallocated"); |
png_read_transform_info(png_ptr, info_ptr); |
} |
/* Initialize palette, background, etc, after transformations |
* are set, but before any reading takes place. This allows |
* the user to obtain a gamma-corrected palette, for example. |
* If the user doesn't call this, we will do it ourselves. |
*/ |
void PNGAPI |
png_start_read_image(png_structp png_ptr) |
{ |
png_debug(1, "in png_start_read_image\n"); |
if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) |
png_read_start_row(png_ptr); |
} |
void PNGAPI |
png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_IDAT; |
const int png_pass_dsp_mask[7] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff}; |
const int png_pass_mask[7] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff}; |
#endif |
int ret; |
png_debug2(1, "in png_read_row (row %lu, pass %d)\n", |
png_ptr->row_number, png_ptr->pass); |
if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) |
png_read_start_row(png_ptr); |
if (png_ptr->row_number == 0 && png_ptr->pass == 0) |
{ |
/* check for transforms that have been set but were defined out */ |
#if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED) |
if (png_ptr->transformations & PNG_INVERT_MONO) |
png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined."); |
#endif |
#if defined(PNG_WRITE_FILLER_SUPPORTED) && !defined(PNG_READ_FILLER_SUPPORTED) |
if (png_ptr->transformations & PNG_FILLER) |
png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined."); |
#endif |
#if defined(PNG_WRITE_PACKSWAP_SUPPORTED) && !defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_PACKSWAP) |
png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined."); |
#endif |
#if defined(PNG_WRITE_PACK_SUPPORTED) && !defined(PNG_READ_PACK_SUPPORTED) |
if (png_ptr->transformations & PNG_PACK) |
png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined."); |
#endif |
#if defined(PNG_WRITE_SHIFT_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED) |
if (png_ptr->transformations & PNG_SHIFT) |
png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined."); |
#endif |
#if defined(PNG_WRITE_BGR_SUPPORTED) && !defined(PNG_READ_BGR_SUPPORTED) |
if (png_ptr->transformations & PNG_BGR) |
png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined."); |
#endif |
#if defined(PNG_WRITE_SWAP_SUPPORTED) && !defined(PNG_READ_SWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_SWAP_BYTES) |
png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined."); |
#endif |
} |
#if defined(PNG_READ_INTERLACING_SUPPORTED) |
/* if interlaced and we do not need a new row, combine row and return */ |
if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE)) |
{ |
switch (png_ptr->pass) |
{ |
case 0: |
if (png_ptr->row_number & 0x07) |
{ |
if (dsp_row != NULL) |
png_combine_row(png_ptr, dsp_row, |
png_pass_dsp_mask[png_ptr->pass]); |
png_read_finish_row(png_ptr); |
return; |
} |
break; |
case 1: |
if ((png_ptr->row_number & 0x07) || png_ptr->width < 5) |
{ |
if (dsp_row != NULL) |
png_combine_row(png_ptr, dsp_row, |
png_pass_dsp_mask[png_ptr->pass]); |
png_read_finish_row(png_ptr); |
return; |
} |
break; |
case 2: |
if ((png_ptr->row_number & 0x07) != 4) |
{ |
if (dsp_row != NULL && (png_ptr->row_number & 4)) |
png_combine_row(png_ptr, dsp_row, |
png_pass_dsp_mask[png_ptr->pass]); |
png_read_finish_row(png_ptr); |
return; |
} |
break; |
case 3: |
if ((png_ptr->row_number & 3) || png_ptr->width < 3) |
{ |
if (dsp_row != NULL) |
png_combine_row(png_ptr, dsp_row, |
png_pass_dsp_mask[png_ptr->pass]); |
png_read_finish_row(png_ptr); |
return; |
} |
break; |
case 4: |
if ((png_ptr->row_number & 3) != 2) |
{ |
if (dsp_row != NULL && (png_ptr->row_number & 2)) |
png_combine_row(png_ptr, dsp_row, |
png_pass_dsp_mask[png_ptr->pass]); |
png_read_finish_row(png_ptr); |
return; |
} |
break; |
case 5: |
if ((png_ptr->row_number & 1) || png_ptr->width < 2) |
{ |
if (dsp_row != NULL) |
png_combine_row(png_ptr, dsp_row, |
png_pass_dsp_mask[png_ptr->pass]); |
png_read_finish_row(png_ptr); |
return; |
} |
break; |
case 6: |
if (!(png_ptr->row_number & 1)) |
{ |
png_read_finish_row(png_ptr); |
return; |
} |
break; |
} |
} |
#endif |
if (!(png_ptr->mode & PNG_HAVE_IDAT)) |
png_error(png_ptr, "Invalid attempt to read row data"); |
png_ptr->zstream.next_out = png_ptr->row_buf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes; |
do |
{ |
if (!(png_ptr->zstream.avail_in)) |
{ |
while (!png_ptr->idat_size) |
{ |
png_byte chunk_length[4]; |
png_crc_finish(png_ptr, 0); |
png_read_data(png_ptr, chunk_length, 4); |
png_ptr->idat_size = png_get_uint_32(chunk_length); |
if (png_ptr->idat_size > PNG_MAX_UINT) |
png_error(png_ptr, "Invalid chunk length."); |
png_reset_crc(png_ptr); |
png_crc_read(png_ptr, png_ptr->chunk_name, 4); |
if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) |
png_error(png_ptr, "Not enough image data"); |
} |
png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size; |
png_ptr->zstream.next_in = png_ptr->zbuf; |
if (png_ptr->zbuf_size > png_ptr->idat_size) |
png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size; |
png_crc_read(png_ptr, png_ptr->zbuf, |
(png_size_t)png_ptr->zstream.avail_in); |
png_ptr->idat_size -= png_ptr->zstream.avail_in; |
} |
ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); |
if (ret == Z_STREAM_END) |
{ |
if (png_ptr->zstream.avail_out || png_ptr->zstream.avail_in || |
png_ptr->idat_size) |
png_error(png_ptr, "Extra compressed data"); |
png_ptr->mode |= PNG_AFTER_IDAT; |
png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; |
break; |
} |
if (ret != Z_OK) |
png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg : |
"Decompression error"); |
} while (png_ptr->zstream.avail_out); |
png_ptr->row_info.color_type = png_ptr->color_type; |
png_ptr->row_info.width = png_ptr->iwidth; |
png_ptr->row_info.channels = png_ptr->channels; |
png_ptr->row_info.bit_depth = png_ptr->bit_depth; |
png_ptr->row_info.pixel_depth = png_ptr->pixel_depth; |
png_ptr->row_info.rowbytes = ((png_ptr->row_info.width * |
(png_uint_32)png_ptr->row_info.pixel_depth + 7) >> 3); |
if(png_ptr->row_buf[0]) |
png_read_filter_row(png_ptr, &(png_ptr->row_info), |
png_ptr->row_buf + 1, png_ptr->prev_row + 1, |
(int)(png_ptr->row_buf[0])); |
png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf, |
png_ptr->rowbytes + 1); |
#if defined(PNG_MNG_FEATURES_SUPPORTED) |
if((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && |
(png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING)) |
{ |
/* Intrapixel differencing */ |
png_do_read_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1); |
} |
#endif |
if (png_ptr->transformations) |
png_do_read_transformations(png_ptr); |
#if defined(PNG_READ_INTERLACING_SUPPORTED) |
/* blow up interlaced rows to full size */ |
if (png_ptr->interlaced && |
(png_ptr->transformations & PNG_INTERLACE)) |
{ |
if (png_ptr->pass < 6) |
/* old interface (pre-1.0.9): |
png_do_read_interlace(&(png_ptr->row_info), |
png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations); |
*/ |
png_do_read_interlace(png_ptr); |
if (dsp_row != NULL) |
png_combine_row(png_ptr, dsp_row, |
png_pass_dsp_mask[png_ptr->pass]); |
if (row != NULL) |
png_combine_row(png_ptr, row, |
png_pass_mask[png_ptr->pass]); |
} |
else |
#endif |
{ |
if (row != NULL) |
png_combine_row(png_ptr, row, 0xff); |
if (dsp_row != NULL) |
png_combine_row(png_ptr, dsp_row, 0xff); |
} |
png_read_finish_row(png_ptr); |
if (png_ptr->read_row_fn != NULL) |
(*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass); |
} |
/* Read one or more rows of image data. If the image is interlaced, |
* and png_set_interlace_handling() has been called, the rows need to |
* contain the contents of the rows from the previous pass. If the |
* image has alpha or transparency, and png_handle_alpha()[*] has been |
* called, the rows contents must be initialized to the contents of the |
* screen. |
* |
* "row" holds the actual image, and pixels are placed in it |
* as they arrive. If the image is displayed after each pass, it will |
* appear to "sparkle" in. "display_row" can be used to display a |
* "chunky" progressive image, with finer detail added as it becomes |
* available. If you do not want this "chunky" display, you may pass |
* NULL for display_row. If you do not want the sparkle display, and |
* you have not called png_handle_alpha(), you may pass NULL for rows. |
* If you have called png_handle_alpha(), and the image has either an |
* alpha channel or a transparency chunk, you must provide a buffer for |
* rows. In this case, you do not have to provide a display_row buffer |
* also, but you may. If the image is not interlaced, or if you have |
* not called png_set_interlace_handling(), the display_row buffer will |
* be ignored, so pass NULL to it. |
* |
* [*] png_handle_alpha() does not exist yet, as of libpng version 1.2.5 |
*/ |
void PNGAPI |
png_read_rows(png_structp png_ptr, png_bytepp row, |
png_bytepp display_row, png_uint_32 num_rows) |
{ |
png_uint_32 i; |
png_bytepp rp; |
png_bytepp dp; |
png_debug(1, "in png_read_rows\n"); |
rp = row; |
dp = display_row; |
if (rp != NULL && dp != NULL) |
for (i = 0; i < num_rows; i++) |
{ |
png_bytep rptr = *rp++; |
png_bytep dptr = *dp++; |
png_read_row(png_ptr, rptr, dptr); |
} |
else if(rp != NULL) |
for (i = 0; i < num_rows; i++) |
{ |
png_bytep rptr = *rp; |
png_read_row(png_ptr, rptr, png_bytep_NULL); |
rp++; |
} |
else if(dp != NULL) |
for (i = 0; i < num_rows; i++) |
{ |
png_bytep dptr = *dp; |
png_read_row(png_ptr, png_bytep_NULL, dptr); |
dp++; |
} |
} |
/* Read the entire image. If the image has an alpha channel or a tRNS |
* chunk, and you have called png_handle_alpha()[*], you will need to |
* initialize the image to the current image that PNG will be overlaying. |
* We set the num_rows again here, in case it was incorrectly set in |
* png_read_start_row() by a call to png_read_update_info() or |
* png_start_read_image() if png_set_interlace_handling() wasn't called |
* prior to either of these functions like it should have been. You can |
* only call this function once. If you desire to have an image for |
* each pass of a interlaced image, use png_read_rows() instead. |
* |
* [*] png_handle_alpha() does not exist yet, as of libpng version 1.2.5 |
*/ |
void PNGAPI |
png_read_image(png_structp png_ptr, png_bytepp image) |
{ |
png_uint_32 i,image_height; |
int pass, j; |
png_bytepp rp; |
png_debug(1, "in png_read_image\n"); |
#ifdef PNG_READ_INTERLACING_SUPPORTED |
pass = png_set_interlace_handling(png_ptr); |
#else |
if (png_ptr->interlaced) |
png_error(png_ptr, |
"Cannot read interlaced image -- interlace handler disabled."); |
pass = 1; |
#endif |
image_height=png_ptr->height; |
png_ptr->num_rows = image_height; /* Make sure this is set correctly */ |
for (j = 0; j < pass; j++) |
{ |
rp = image; |
for (i = 0; i < image_height; i++) |
{ |
png_read_row(png_ptr, *rp, png_bytep_NULL); |
rp++; |
} |
} |
} |
/* Read the end of the PNG file. Will not read past the end of the |
* file, will verify the end is accurate, and will read any comments |
* or time information at the end of the file, if info is not NULL. |
*/ |
void PNGAPI |
png_read_end(png_structp png_ptr, png_infop info_ptr) |
{ |
png_byte chunk_length[4]; |
png_uint_32 length; |
png_debug(1, "in png_read_end\n"); |
png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */ |
do |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_IHDR; |
PNG_IDAT; |
PNG_IEND; |
PNG_PLTE; |
#if defined(PNG_READ_bKGD_SUPPORTED) |
PNG_bKGD; |
#endif |
#if defined(PNG_READ_cHRM_SUPPORTED) |
PNG_cHRM; |
#endif |
#if defined(PNG_READ_gAMA_SUPPORTED) |
PNG_gAMA; |
#endif |
#if defined(PNG_READ_hIST_SUPPORTED) |
PNG_hIST; |
#endif |
#if defined(PNG_READ_iCCP_SUPPORTED) |
PNG_iCCP; |
#endif |
#if defined(PNG_READ_iTXt_SUPPORTED) |
PNG_iTXt; |
#endif |
#if defined(PNG_READ_oFFs_SUPPORTED) |
PNG_oFFs; |
#endif |
#if defined(PNG_READ_pCAL_SUPPORTED) |
PNG_pCAL; |
#endif |
#if defined(PNG_READ_pHYs_SUPPORTED) |
PNG_pHYs; |
#endif |
#if defined(PNG_READ_sBIT_SUPPORTED) |
PNG_sBIT; |
#endif |
#if defined(PNG_READ_sCAL_SUPPORTED) |
PNG_sCAL; |
#endif |
#if defined(PNG_READ_sPLT_SUPPORTED) |
PNG_sPLT; |
#endif |
#if defined(PNG_READ_sRGB_SUPPORTED) |
PNG_sRGB; |
#endif |
#if defined(PNG_READ_tEXt_SUPPORTED) |
PNG_tEXt; |
#endif |
#if defined(PNG_READ_tIME_SUPPORTED) |
PNG_tIME; |
#endif |
#if defined(PNG_READ_tRNS_SUPPORTED) |
PNG_tRNS; |
#endif |
#if defined(PNG_READ_zTXt_SUPPORTED) |
PNG_zTXt; |
#endif |
#endif /* PNG_GLOBAL_ARRAYS */ |
png_read_data(png_ptr, chunk_length, 4); |
length = png_get_uint_32(chunk_length); |
png_reset_crc(png_ptr); |
png_crc_read(png_ptr, png_ptr->chunk_name, 4); |
png_debug1(0, "Reading %s chunk.\n", png_ptr->chunk_name); |
if (length > PNG_MAX_UINT) |
png_error(png_ptr, "Invalid chunk length."); |
if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4)) |
png_handle_IHDR(png_ptr, info_ptr, length); |
else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4)) |
png_handle_IEND(png_ptr, info_ptr, length); |
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name)) |
{ |
if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) |
{ |
if (length > 0 || png_ptr->mode & PNG_AFTER_IDAT) |
png_error(png_ptr, "Too many IDAT's found"); |
} |
else |
png_ptr->mode |= PNG_AFTER_IDAT; |
png_handle_unknown(png_ptr, info_ptr, length); |
if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4)) |
png_ptr->mode |= PNG_HAVE_PLTE; |
} |
#endif |
else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) |
{ |
/* Zero length IDATs are legal after the last IDAT has been |
* read, but not after other chunks have been read. |
*/ |
if (length > 0 || png_ptr->mode & PNG_AFTER_IDAT) |
png_error(png_ptr, "Too many IDAT's found"); |
png_crc_finish(png_ptr, length); |
} |
else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4)) |
png_handle_PLTE(png_ptr, info_ptr, length); |
#if defined(PNG_READ_bKGD_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4)) |
png_handle_bKGD(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_cHRM_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4)) |
png_handle_cHRM(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_gAMA_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4)) |
png_handle_gAMA(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_hIST_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4)) |
png_handle_hIST(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_oFFs_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4)) |
png_handle_oFFs(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_pCAL_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4)) |
png_handle_pCAL(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_sCAL_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4)) |
png_handle_sCAL(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_pHYs_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4)) |
png_handle_pHYs(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_sBIT_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4)) |
png_handle_sBIT(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_sRGB_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4)) |
png_handle_sRGB(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_iCCP_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4)) |
png_handle_iCCP(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_sPLT_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4)) |
png_handle_sPLT(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_tEXt_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4)) |
png_handle_tEXt(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_tIME_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4)) |
png_handle_tIME(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_tRNS_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4)) |
png_handle_tRNS(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_zTXt_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4)) |
png_handle_zTXt(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_iTXt_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4)) |
png_handle_iTXt(png_ptr, info_ptr, length); |
#endif |
else |
png_handle_unknown(png_ptr, info_ptr, length); |
} while (!(png_ptr->mode & PNG_HAVE_IEND)); |
} |
/* free all memory used by the read */ |
void PNGAPI |
png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr, |
png_infopp end_info_ptr_ptr) |
{ |
png_structp png_ptr = NULL; |
png_infop info_ptr = NULL, end_info_ptr = NULL; |
#ifdef PNG_USER_MEM_SUPPORTED |
png_free_ptr free_fn = NULL; |
png_voidp mem_ptr = NULL; |
#endif |
png_debug(1, "in png_destroy_read_struct\n"); |
if (png_ptr_ptr != NULL) |
png_ptr = *png_ptr_ptr; |
if (info_ptr_ptr != NULL) |
info_ptr = *info_ptr_ptr; |
if (end_info_ptr_ptr != NULL) |
end_info_ptr = *end_info_ptr_ptr; |
#ifdef PNG_USER_MEM_SUPPORTED |
free_fn = png_ptr->free_fn; |
mem_ptr = png_ptr->mem_ptr; |
#endif |
png_read_destroy(png_ptr, info_ptr, end_info_ptr); |
if (info_ptr != NULL) |
{ |
#if defined(PNG_TEXT_SUPPORTED) |
png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, -1); |
#endif |
#ifdef PNG_USER_MEM_SUPPORTED |
png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn, |
(png_voidp)mem_ptr); |
#else |
png_destroy_struct((png_voidp)info_ptr); |
#endif |
*info_ptr_ptr = NULL; |
} |
if (end_info_ptr != NULL) |
{ |
#if defined(PNG_READ_TEXT_SUPPORTED) |
png_free_data(png_ptr, end_info_ptr, PNG_FREE_TEXT, -1); |
#endif |
#ifdef PNG_USER_MEM_SUPPORTED |
png_destroy_struct_2((png_voidp)end_info_ptr, (png_free_ptr)free_fn, |
(png_voidp)mem_ptr); |
#else |
png_destroy_struct((png_voidp)end_info_ptr); |
#endif |
*end_info_ptr_ptr = NULL; |
} |
if (png_ptr != NULL) |
{ |
#ifdef PNG_USER_MEM_SUPPORTED |
png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn, |
(png_voidp)mem_ptr); |
#else |
png_destroy_struct((png_voidp)png_ptr); |
#endif |
*png_ptr_ptr = NULL; |
} |
} |
/* free all memory used by the read (old method) */ |
void /* PRIVATE */ |
png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr) |
{ |
#ifdef PNG_SETJMP_SUPPORTED |
jmp_buf tmp_jmp; |
#endif |
png_error_ptr error_fn; |
png_error_ptr warning_fn; |
png_voidp error_ptr; |
#ifdef PNG_USER_MEM_SUPPORTED |
png_free_ptr free_fn; |
#endif |
png_debug(1, "in png_read_destroy\n"); |
if (info_ptr != NULL) |
png_info_destroy(png_ptr, info_ptr); |
if (end_info_ptr != NULL) |
png_info_destroy(png_ptr, end_info_ptr); |
png_free(png_ptr, png_ptr->zbuf); |
png_free(png_ptr, png_ptr->big_row_buf); |
png_free(png_ptr, png_ptr->prev_row); |
#if defined(PNG_READ_DITHER_SUPPORTED) |
png_free(png_ptr, png_ptr->palette_lookup); |
png_free(png_ptr, png_ptr->dither_index); |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
png_free(png_ptr, png_ptr->gamma_table); |
#endif |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) |
png_free(png_ptr, png_ptr->gamma_from_1); |
png_free(png_ptr, png_ptr->gamma_to_1); |
#endif |
#ifdef PNG_FREE_ME_SUPPORTED |
if (png_ptr->free_me & PNG_FREE_PLTE) |
png_zfree(png_ptr, png_ptr->palette); |
png_ptr->free_me &= ~PNG_FREE_PLTE; |
#else |
if (png_ptr->flags & PNG_FLAG_FREE_PLTE) |
png_zfree(png_ptr, png_ptr->palette); |
png_ptr->flags &= ~PNG_FLAG_FREE_PLTE; |
#endif |
#if defined(PNG_tRNS_SUPPORTED) || \ |
defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
#ifdef PNG_FREE_ME_SUPPORTED |
if (png_ptr->free_me & PNG_FREE_TRNS) |
png_free(png_ptr, png_ptr->trans); |
png_ptr->free_me &= ~PNG_FREE_TRNS; |
#else |
if (png_ptr->flags & PNG_FLAG_FREE_TRNS) |
png_free(png_ptr, png_ptr->trans); |
png_ptr->flags &= ~PNG_FLAG_FREE_TRNS; |
#endif |
#endif |
#if defined(PNG_READ_hIST_SUPPORTED) |
#ifdef PNG_FREE_ME_SUPPORTED |
if (png_ptr->free_me & PNG_FREE_HIST) |
png_free(png_ptr, png_ptr->hist); |
png_ptr->free_me &= ~PNG_FREE_HIST; |
#else |
if (png_ptr->flags & PNG_FLAG_FREE_HIST) |
png_free(png_ptr, png_ptr->hist); |
png_ptr->flags &= ~PNG_FLAG_FREE_HIST; |
#endif |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
if (png_ptr->gamma_16_table != NULL) |
{ |
int i; |
int istop = (1 << (8 - png_ptr->gamma_shift)); |
for (i = 0; i < istop; i++) |
{ |
png_free(png_ptr, png_ptr->gamma_16_table[i]); |
} |
png_free(png_ptr, png_ptr->gamma_16_table); |
} |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) |
if (png_ptr->gamma_16_from_1 != NULL) |
{ |
int i; |
int istop = (1 << (8 - png_ptr->gamma_shift)); |
for (i = 0; i < istop; i++) |
{ |
png_free(png_ptr, png_ptr->gamma_16_from_1[i]); |
} |
png_free(png_ptr, png_ptr->gamma_16_from_1); |
} |
if (png_ptr->gamma_16_to_1 != NULL) |
{ |
int i; |
int istop = (1 << (8 - png_ptr->gamma_shift)); |
for (i = 0; i < istop; i++) |
{ |
png_free(png_ptr, png_ptr->gamma_16_to_1[i]); |
} |
png_free(png_ptr, png_ptr->gamma_16_to_1); |
} |
#endif |
#endif |
#if defined(PNG_TIME_RFC1123_SUPPORTED) |
png_free(png_ptr, png_ptr->time_buffer); |
#endif |
inflateEnd(&png_ptr->zstream); |
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
png_free(png_ptr, png_ptr->save_buffer); |
#endif |
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
#ifdef PNG_TEXT_SUPPORTED |
png_free(png_ptr, png_ptr->current_text); |
#endif /* PNG_TEXT_SUPPORTED */ |
#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ |
/* Save the important info out of the png_struct, in case it is |
* being used again. |
*/ |
#ifdef PNG_SETJMP_SUPPORTED |
png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf)); |
#endif |
error_fn = png_ptr->error_fn; |
warning_fn = png_ptr->warning_fn; |
error_ptr = png_ptr->error_ptr; |
#ifdef PNG_USER_MEM_SUPPORTED |
free_fn = png_ptr->free_fn; |
#endif |
png_memset(png_ptr, 0, sizeof (png_struct)); |
png_ptr->error_fn = error_fn; |
png_ptr->warning_fn = warning_fn; |
png_ptr->error_ptr = error_ptr; |
#ifdef PNG_USER_MEM_SUPPORTED |
png_ptr->free_fn = free_fn; |
#endif |
#ifdef PNG_SETJMP_SUPPORTED |
png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf)); |
#endif |
} |
void PNGAPI |
png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn) |
{ |
png_ptr->read_row_fn = read_row_fn; |
} |
#if defined(PNG_INFO_IMAGE_SUPPORTED) |
void PNGAPI |
png_read_png(png_structp png_ptr, png_infop info_ptr, |
int transforms, |
voidp params) |
{ |
int row; |
#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) |
/* invert the alpha channel from opacity to transparency */ |
if (transforms & PNG_TRANSFORM_INVERT_ALPHA) |
png_set_invert_alpha(png_ptr); |
#endif |
/* The call to png_read_info() gives us all of the information from the |
* PNG file before the first IDAT (image data chunk). |
*/ |
png_read_info(png_ptr, info_ptr); |
/* -------------- image transformations start here ------------------- */ |
#if defined(PNG_READ_16_TO_8_SUPPORTED) |
/* tell libpng to strip 16 bit/color files down to 8 bits/color */ |
if (transforms & PNG_TRANSFORM_STRIP_16) |
png_set_strip_16(png_ptr); |
#endif |
#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED) |
/* Strip alpha bytes from the input data without combining with the |
* background (not recommended). |
*/ |
if (transforms & PNG_TRANSFORM_STRIP_ALPHA) |
png_set_strip_alpha(png_ptr); |
#endif |
#if defined(PNG_READ_PACK_SUPPORTED) && !defined(PNG_READ_EXPAND_SUPPORTED) |
/* Extract multiple pixels with bit depths of 1, 2, and 4 from a single |
* byte into separate bytes (useful for paletted and grayscale images). |
*/ |
if (transforms & PNG_TRANSFORM_PACKING) |
png_set_packing(png_ptr); |
#endif |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
/* Change the order of packed pixels to least significant bit first |
* (not useful if you are using png_set_packing). */ |
if (transforms & PNG_TRANSFORM_PACKSWAP) |
png_set_packswap(png_ptr); |
#endif |
#if defined(PNG_READ_EXPAND_SUPPORTED) |
/* Expand paletted colors into true RGB triplets |
* Expand grayscale images to full 8 bits from 1, 2, or 4 bits/pixel |
* Expand paletted or RGB images with transparency to full alpha |
* channels so the data will be available as RGBA quartets. |
*/ |
if (transforms & PNG_TRANSFORM_EXPAND) |
if ((png_ptr->bit_depth < 8) || |
(png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) || |
(png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))) |
png_set_expand(png_ptr); |
#endif |
/* We don't handle background color or gamma transformation or dithering. */ |
#if defined(PNG_READ_INVERT_SUPPORTED) |
/* invert monochrome files to have 0 as white and 1 as black */ |
if (transforms & PNG_TRANSFORM_INVERT_MONO) |
png_set_invert_mono(png_ptr); |
#endif |
#if defined(PNG_READ_SHIFT_SUPPORTED) |
/* If you want to shift the pixel values from the range [0,255] or |
* [0,65535] to the original [0,7] or [0,31], or whatever range the |
* colors were originally in: |
*/ |
if ((transforms & PNG_TRANSFORM_SHIFT) |
&& png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT)) |
{ |
png_color_8p sig_bit; |
png_get_sBIT(png_ptr, info_ptr, &sig_bit); |
png_set_shift(png_ptr, sig_bit); |
} |
#endif |
#if defined(PNG_READ_BGR_SUPPORTED) |
/* flip the RGB pixels to BGR (or RGBA to BGRA) */ |
if (transforms & PNG_TRANSFORM_BGR) |
png_set_bgr(png_ptr); |
#endif |
#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) |
/* swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR) */ |
if (transforms & PNG_TRANSFORM_SWAP_ALPHA) |
png_set_swap_alpha(png_ptr); |
#endif |
#if defined(PNG_READ_SWAP_SUPPORTED) |
/* swap bytes of 16 bit files to least significant byte first */ |
if (transforms & PNG_TRANSFORM_SWAP_ENDIAN) |
png_set_swap(png_ptr); |
#endif |
/* We don't handle adding filler bytes */ |
/* Optional call to gamma correct and add the background to the palette |
* and update info structure. REQUIRED if you are expecting libpng to |
* update the palette for you (i.e., you selected such a transform above). |
*/ |
png_read_update_info(png_ptr, info_ptr); |
/* -------------- image transformations end here ------------------- */ |
#ifdef PNG_FREE_ME_SUPPORTED |
png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0); |
#endif |
if(info_ptr->row_pointers == NULL) |
{ |
info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr, |
info_ptr->height * sizeof(png_bytep)); |
#ifdef PNG_FREE_ME_SUPPORTED |
info_ptr->free_me |= PNG_FREE_ROWS; |
#endif |
for (row = 0; row < (int)info_ptr->height; row++) |
{ |
info_ptr->row_pointers[row] = (png_bytep)png_malloc(png_ptr, |
png_get_rowbytes(png_ptr, info_ptr)); |
} |
} |
png_read_image(png_ptr, info_ptr->row_pointers); |
info_ptr->valid |= PNG_INFO_IDAT; |
/* read rest of file, and get additional chunks in info_ptr - REQUIRED */ |
png_read_end(png_ptr, info_ptr); |
if(transforms == 0 || params == NULL) |
/* quiet compiler warnings */ return; |
} |
#endif |
/shark/trunk/ports/png/pngmem.c |
---|
0,0 → 1,566 |
/* pngmem.c - stub functions for memory allocation |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
* This file provides a location for all memory allocation. Users who |
* need special memory handling are expected to supply replacement |
* functions for png_malloc() and png_free(), and to use |
* png_create_read_struct_2() and png_create_write_struct_2() to |
* identify the replacement functions. |
*/ |
#define PNG_INTERNAL |
#include "png.h" |
/* Borland DOS special memory handler */ |
#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__) |
/* if you change this, be sure to change the one in png.h also */ |
/* Allocate memory for a png_struct. The malloc and memset can be replaced |
by a single call to calloc() if this is thought to improve performance. */ |
png_voidp /* PRIVATE */ |
png_create_struct(int type) |
{ |
#ifdef PNG_USER_MEM_SUPPORTED |
return (png_create_struct_2(type, png_malloc_ptr_NULL, png_voidp_NULL)); |
} |
/* Alternate version of png_create_struct, for use with user-defined malloc. */ |
png_voidp /* PRIVATE */ |
png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr) |
{ |
#endif /* PNG_USER_MEM_SUPPORTED */ |
png_size_t size; |
png_voidp struct_ptr; |
if (type == PNG_STRUCT_INFO) |
size = sizeof(png_info); |
else if (type == PNG_STRUCT_PNG) |
size = sizeof(png_struct); |
else |
return (png_get_copyright()); |
#ifdef PNG_USER_MEM_SUPPORTED |
if(malloc_fn != NULL) |
{ |
png_struct dummy_struct; |
png_structp png_ptr = &dummy_struct; |
png_ptr->mem_ptr=mem_ptr; |
struct_ptr = (*(malloc_fn))(png_ptr, (png_uint_32)size); |
} |
else |
#endif /* PNG_USER_MEM_SUPPORTED */ |
struct_ptr = (png_voidp)farmalloc(size)); |
if (struct_ptr != NULL) |
png_memset(struct_ptr, 0, size); |
return (struct_ptr); |
} |
/* Free memory allocated by a png_create_struct() call */ |
void /* PRIVATE */ |
png_destroy_struct(png_voidp struct_ptr) |
{ |
#ifdef PNG_USER_MEM_SUPPORTED |
png_destroy_struct_2(struct_ptr, png_free_ptr_NULL, png_voidp_NULL); |
} |
/* Free memory allocated by a png_create_struct() call */ |
void /* PRIVATE */ |
png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn, |
png_voidp mem_ptr) |
{ |
#endif |
if (struct_ptr != NULL) |
{ |
#ifdef PNG_USER_MEM_SUPPORTED |
if(free_fn != NULL) |
{ |
png_struct dummy_struct; |
png_structp png_ptr = &dummy_struct; |
png_ptr->mem_ptr=mem_ptr; |
(*(free_fn))(png_ptr, struct_ptr); |
return; |
} |
#endif /* PNG_USER_MEM_SUPPORTED */ |
farfree (struct_ptr); |
} |
} |
/* Allocate memory. For reasonable files, size should never exceed |
* 64K. However, zlib may allocate more then 64K if you don't tell |
* it not to. See zconf.h and png.h for more information. zlib does |
* need to allocate exactly 64K, so whatever you call here must |
* have the ability to do that. |
* |
* Borland seems to have a problem in DOS mode for exactly 64K. |
* It gives you a segment with an offset of 8 (perhaps to store its |
* memory stuff). zlib doesn't like this at all, so we have to |
* detect and deal with it. This code should not be needed in |
* Windows or OS/2 modes, and only in 16 bit mode. This code has |
* been updated by Alexander Lehmann for version 0.89 to waste less |
* memory. |
* |
* Note that we can't use png_size_t for the "size" declaration, |
* since on some systems a png_size_t is a 16-bit quantity, and as a |
* result, we would be truncating potentially larger memory requests |
* (which should cause a fatal error) and introducing major problems. |
*/ |
png_voidp PNGAPI |
png_malloc(png_structp png_ptr, png_uint_32 size) |
{ |
png_voidp ret; |
if (png_ptr == NULL || size == 0) |
return (NULL); |
#ifdef PNG_USER_MEM_SUPPORTED |
if(png_ptr->malloc_fn != NULL) |
{ |
ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size)); |
if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, "Out of memory!"); |
return (ret); |
} |
else |
return png_malloc_default(png_ptr, size); |
} |
png_voidp PNGAPI |
png_malloc_default(png_structp png_ptr, png_uint_32 size) |
{ |
png_voidp ret; |
#endif /* PNG_USER_MEM_SUPPORTED */ |
#ifdef PNG_MAX_MALLOC_64K |
if (size > (png_uint_32)65536L) |
png_error(png_ptr, "Cannot Allocate > 64K"); |
#endif |
if (size == (png_uint_32)65536L) |
{ |
if (png_ptr->offset_table == NULL) |
{ |
/* try to see if we need to do any of this fancy stuff */ |
ret = farmalloc(size); |
if (ret == NULL || ((png_size_t)ret & 0xffff)) |
{ |
int num_blocks; |
png_uint_32 total_size; |
png_bytep table; |
int i; |
png_byte huge * hptr; |
if (ret != NULL) |
{ |
farfree(ret); |
ret = NULL; |
} |
if(png_ptr->zlib_window_bits > 14) |
num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14)); |
else |
num_blocks = 1; |
if (png_ptr->zlib_mem_level >= 7) |
num_blocks += (int)(1 << (png_ptr->zlib_mem_level - 7)); |
else |
num_blocks++; |
total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks+16; |
table = farmalloc(total_size); |
if (table == NULL) |
{ |
if (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, "Out Of Memory."); /* Note "O" and "M" */ |
else |
png_warning(png_ptr, "Out Of Memory."); |
return (NULL); |
} |
if ((png_size_t)table & 0xfff0) |
{ |
if (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, |
"Farmalloc didn't return normalized pointer"); |
else |
png_warning(png_ptr, |
"Farmalloc didn't return normalized pointer"); |
return (NULL); |
} |
png_ptr->offset_table = table; |
png_ptr->offset_table_ptr = farmalloc(num_blocks * |
sizeof (png_bytep)); |
if (png_ptr->offset_table_ptr == NULL) |
{ |
if (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, "Out Of memory."); /* Note "O" and "M" */ |
else |
png_warning(png_ptr, "Out Of memory."); |
return (NULL); |
} |
hptr = (png_byte huge *)table; |
if ((png_size_t)hptr & 0xf) |
{ |
hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L); |
hptr = hptr + 16L; /* "hptr += 16L" fails on Turbo C++ 3.0 */ |
} |
for (i = 0; i < num_blocks; i++) |
{ |
png_ptr->offset_table_ptr[i] = (png_bytep)hptr; |
hptr = hptr + (png_uint_32)65536L; /* "+=" fails on TC++3.0 */ |
} |
png_ptr->offset_table_number = num_blocks; |
png_ptr->offset_table_count = 0; |
png_ptr->offset_table_count_free = 0; |
} |
} |
if (png_ptr->offset_table_count >= png_ptr->offset_table_number) |
{ |
if (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, "Out of Memory."); /* Note "o" and "M" */ |
else |
png_warning(png_ptr, "Out of Memory."); |
return (NULL); |
} |
ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++]; |
} |
else |
ret = farmalloc(size); |
if (ret == NULL) |
{ |
if (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, "Out of memory."); /* Note "o" and "m" */ |
else |
png_warning(png_ptr, "Out of memory."); /* Note "o" and "m" */ |
} |
return (ret); |
} |
/* free a pointer allocated by png_malloc(). In the default |
configuration, png_ptr is not used, but is passed in case it |
is needed. If ptr is NULL, return without taking any action. */ |
void PNGAPI |
png_free(png_structp png_ptr, png_voidp ptr) |
{ |
if (png_ptr == NULL || ptr == NULL) |
return; |
#ifdef PNG_USER_MEM_SUPPORTED |
if (png_ptr->free_fn != NULL) |
{ |
(*(png_ptr->free_fn))(png_ptr, ptr); |
return; |
} |
else png_free_default(png_ptr, ptr); |
} |
void PNGAPI |
png_free_default(png_structp png_ptr, png_voidp ptr) |
{ |
#endif /* PNG_USER_MEM_SUPPORTED */ |
if (png_ptr->offset_table != NULL) |
{ |
int i; |
for (i = 0; i < png_ptr->offset_table_count; i++) |
{ |
if (ptr == png_ptr->offset_table_ptr[i]) |
{ |
ptr = NULL; |
png_ptr->offset_table_count_free++; |
break; |
} |
} |
if (png_ptr->offset_table_count_free == png_ptr->offset_table_count) |
{ |
farfree(png_ptr->offset_table); |
farfree(png_ptr->offset_table_ptr); |
png_ptr->offset_table = NULL; |
png_ptr->offset_table_ptr = NULL; |
} |
} |
if (ptr != NULL) |
{ |
farfree(ptr); |
} |
} |
#else /* Not the Borland DOS special memory handler */ |
/* Allocate memory for a png_struct or a png_info. The malloc and |
memset can be replaced by a single call to calloc() if this is thought |
to improve performance noticably. */ |
png_voidp /* PRIVATE */ |
png_create_struct(int type) |
{ |
#ifdef PNG_USER_MEM_SUPPORTED |
return (png_create_struct_2(type, png_malloc_ptr_NULL, png_voidp_NULL)); |
} |
/* Allocate memory for a png_struct or a png_info. The malloc and |
memset can be replaced by a single call to calloc() if this is thought |
to improve performance noticably. */ |
png_voidp /* PRIVATE */ |
png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr) |
{ |
#endif /* PNG_USER_MEM_SUPPORTED */ |
png_size_t size; |
png_voidp struct_ptr; |
if (type == PNG_STRUCT_INFO) |
size = sizeof(png_info); |
else if (type == PNG_STRUCT_PNG) |
size = sizeof(png_struct); |
else |
return (NULL); |
#ifdef PNG_USER_MEM_SUPPORTED |
if(malloc_fn != NULL) |
{ |
png_struct dummy_struct; |
png_structp png_ptr = &dummy_struct; |
png_ptr->mem_ptr=mem_ptr; |
struct_ptr = (*(malloc_fn))(png_ptr, size); |
if (struct_ptr != NULL) |
png_memset(struct_ptr, 0, size); |
return (struct_ptr); |
} |
#endif /* PNG_USER_MEM_SUPPORTED */ |
#if defined(__TURBOC__) && !defined(__FLAT__) |
if ((struct_ptr = (png_voidp)farmalloc(size)) != NULL) |
#else |
# if defined(_MSC_VER) && defined(MAXSEG_64K) |
if ((struct_ptr = (png_voidp)halloc(size,1)) != NULL) |
# else |
if ((struct_ptr = (png_voidp)malloc(size)) != NULL) |
# endif |
#endif |
{ |
png_memset(struct_ptr, 0, size); |
} |
return (struct_ptr); |
} |
/* Free memory allocated by a png_create_struct() call */ |
void /* PRIVATE */ |
png_destroy_struct(png_voidp struct_ptr) |
{ |
#ifdef PNG_USER_MEM_SUPPORTED |
png_destroy_struct_2(struct_ptr, png_free_ptr_NULL, png_voidp_NULL); |
} |
/* Free memory allocated by a png_create_struct() call */ |
void /* PRIVATE */ |
png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn, |
png_voidp mem_ptr) |
{ |
#endif /* PNG_USER_MEM_SUPPORTED */ |
if (struct_ptr != NULL) |
{ |
#ifdef PNG_USER_MEM_SUPPORTED |
if(free_fn != NULL) |
{ |
png_struct dummy_struct; |
png_structp png_ptr = &dummy_struct; |
png_ptr->mem_ptr=mem_ptr; |
(*(free_fn))(png_ptr, struct_ptr); |
return; |
} |
#endif /* PNG_USER_MEM_SUPPORTED */ |
#if defined(__TURBOC__) && !defined(__FLAT__) |
farfree(struct_ptr); |
#else |
# if defined(_MSC_VER) && defined(MAXSEG_64K) |
hfree(struct_ptr); |
# else |
free(struct_ptr); |
# endif |
#endif |
} |
} |
/* Allocate memory. For reasonable files, size should never exceed |
64K. However, zlib may allocate more then 64K if you don't tell |
it not to. See zconf.h and png.h for more information. zlib does |
need to allocate exactly 64K, so whatever you call here must |
have the ability to do that. */ |
png_voidp PNGAPI |
png_malloc(png_structp png_ptr, png_uint_32 size) |
{ |
png_voidp ret; |
if (png_ptr == NULL || size == 0) |
return (NULL); |
#ifdef PNG_USER_MEM_SUPPORTED |
if(png_ptr->malloc_fn != NULL) |
{ |
ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size)); |
if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, "Out of Memory!"); |
return (ret); |
} |
else |
return (png_malloc_default(png_ptr, size)); |
} |
png_voidp PNGAPI |
png_malloc_default(png_structp png_ptr, png_uint_32 size) |
{ |
png_voidp ret; |
#endif /* PNG_USER_MEM_SUPPORTED */ |
#ifdef PNG_MAX_MALLOC_64K |
if (size > (png_uint_32)65536L) |
{ |
if(png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, "Cannot Allocate > 64K"); |
else |
return NULL; |
} |
#endif |
#if defined(__TURBOC__) && !defined(__FLAT__) |
ret = farmalloc(size); |
#else |
# if defined(_MSC_VER) && defined(MAXSEG_64K) |
ret = halloc(size, 1); |
# else |
ret = malloc((size_t)size); |
# endif |
#endif |
if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, "Out of Memory"); |
return (ret); |
} |
/* Free a pointer allocated by png_malloc(). If ptr is NULL, return |
without taking any action. */ |
void PNGAPI |
png_free(png_structp png_ptr, png_voidp ptr) |
{ |
if (png_ptr == NULL || ptr == NULL) |
return; |
#ifdef PNG_USER_MEM_SUPPORTED |
if (png_ptr->free_fn != NULL) |
{ |
(*(png_ptr->free_fn))(png_ptr, ptr); |
return; |
} |
else png_free_default(png_ptr, ptr); |
} |
void PNGAPI |
png_free_default(png_structp png_ptr, png_voidp ptr) |
{ |
if (png_ptr == NULL || ptr == NULL) |
return; |
#endif /* PNG_USER_MEM_SUPPORTED */ |
#if defined(__TURBOC__) && !defined(__FLAT__) |
farfree(ptr); |
#else |
# if defined(_MSC_VER) && defined(MAXSEG_64K) |
hfree(ptr); |
# else |
free(ptr); |
# endif |
#endif |
} |
#endif /* Not Borland DOS special memory handler */ |
#if defined(PNG_1_0_X) |
# define png_malloc_warn png_malloc |
#else |
/* This function was added at libpng version 1.2.3. The png_malloc_warn() |
* function will issue a png_warning and return NULL instead of issuing a |
* png_error, if it fails to allocate the requested memory. |
*/ |
png_voidp PNGAPI |
png_malloc_warn(png_structp png_ptr, png_uint_32 size) |
{ |
png_voidp ptr; |
png_uint_32 save_flags=png_ptr->flags; |
png_ptr->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK; |
ptr = (png_voidp)png_malloc((png_structp)png_ptr, size); |
png_ptr->flags=save_flags; |
return(ptr); |
} |
#endif |
png_voidp PNGAPI |
png_memcpy_check (png_structp png_ptr, png_voidp s1, png_voidp s2, |
png_uint_32 length) |
{ |
png_size_t size; |
size = (png_size_t)length; |
if ((png_uint_32)size != length) |
png_error(png_ptr,"Overflow in png_memcpy_check."); |
return(png_memcpy (s1, s2, size)); |
} |
png_voidp PNGAPI |
png_memset_check (png_structp png_ptr, png_voidp s1, int value, |
png_uint_32 length) |
{ |
png_size_t size; |
size = (png_size_t)length; |
if ((png_uint_32)size != length) |
png_error(png_ptr,"Overflow in png_memset_check."); |
return (png_memset (s1, value, size)); |
} |
#ifdef PNG_USER_MEM_SUPPORTED |
/* This function is called when the application wants to use another method |
* of allocating and freeing memory. |
*/ |
void PNGAPI |
png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr |
malloc_fn, png_free_ptr free_fn) |
{ |
png_ptr->mem_ptr = mem_ptr; |
png_ptr->malloc_fn = malloc_fn; |
png_ptr->free_fn = free_fn; |
} |
/* This function returns a pointer to the mem_ptr associated with the user |
* functions. The application should free any memory associated with this |
* pointer before png_write_destroy and png_read_destroy are called. |
*/ |
png_voidp PNGAPI |
png_get_mem_ptr(png_structp png_ptr) |
{ |
return ((png_voidp)png_ptr->mem_ptr); |
} |
#endif /* PNG_USER_MEM_SUPPORTED */ |
/shark/trunk/ports/png/pngget.c |
---|
0,0 → 1,927 |
/* pngget.c - retrieval of values from info struct |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
*/ |
#define PNG_INTERNAL |
#include "png.h" |
png_uint_32 PNGAPI |
png_get_valid(png_structp png_ptr, png_infop info_ptr, png_uint_32 flag) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
return(info_ptr->valid & flag); |
else |
return(0); |
} |
png_uint_32 PNGAPI |
png_get_rowbytes(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
return(info_ptr->rowbytes); |
else |
return(0); |
} |
#if defined(PNG_INFO_IMAGE_SUPPORTED) |
png_bytepp PNGAPI |
png_get_rows(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
return(info_ptr->row_pointers); |
else |
return(0); |
} |
#endif |
#ifdef PNG_EASY_ACCESS_SUPPORTED |
/* easy access to info, added in libpng-0.99 */ |
png_uint_32 PNGAPI |
png_get_image_width(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
{ |
return info_ptr->width; |
} |
return (0); |
} |
png_uint_32 PNGAPI |
png_get_image_height(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
{ |
return info_ptr->height; |
} |
return (0); |
} |
png_byte PNGAPI |
png_get_bit_depth(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
{ |
return info_ptr->bit_depth; |
} |
return (0); |
} |
png_byte PNGAPI |
png_get_color_type(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
{ |
return info_ptr->color_type; |
} |
return (0); |
} |
png_byte PNGAPI |
png_get_filter_type(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
{ |
return info_ptr->filter_type; |
} |
return (0); |
} |
png_byte PNGAPI |
png_get_interlace_type(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
{ |
return info_ptr->interlace_type; |
} |
return (0); |
} |
png_byte PNGAPI |
png_get_compression_type(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
{ |
return info_ptr->compression_type; |
} |
return (0); |
} |
png_uint_32 PNGAPI |
png_get_x_pixels_per_meter(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
#if defined(PNG_pHYs_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_pHYs) |
{ |
png_debug1(1, "in %s retrieval function\n", "png_get_x_pixels_per_meter"); |
if(info_ptr->phys_unit_type != PNG_RESOLUTION_METER) |
return (0); |
else return (info_ptr->x_pixels_per_unit); |
} |
#else |
return (0); |
#endif |
return (0); |
} |
png_uint_32 PNGAPI |
png_get_y_pixels_per_meter(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
#if defined(PNG_pHYs_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_pHYs) |
{ |
png_debug1(1, "in %s retrieval function\n", "png_get_y_pixels_per_meter"); |
if(info_ptr->phys_unit_type != PNG_RESOLUTION_METER) |
return (0); |
else return (info_ptr->y_pixels_per_unit); |
} |
#else |
return (0); |
#endif |
return (0); |
} |
png_uint_32 PNGAPI |
png_get_pixels_per_meter(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
#if defined(PNG_pHYs_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_pHYs) |
{ |
png_debug1(1, "in %s retrieval function\n", "png_get_pixels_per_meter"); |
if(info_ptr->phys_unit_type != PNG_RESOLUTION_METER || |
info_ptr->x_pixels_per_unit != info_ptr->y_pixels_per_unit) |
return (0); |
else return (info_ptr->x_pixels_per_unit); |
} |
#else |
return (0); |
#endif |
return (0); |
} |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
float PNGAPI |
png_get_pixel_aspect_ratio(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
#if defined(PNG_pHYs_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_pHYs) |
{ |
png_debug1(1, "in %s retrieval function\n", "png_get_aspect_ratio"); |
if (info_ptr->x_pixels_per_unit == 0) |
return ((float)0.0); |
else |
return ((float)((float)info_ptr->y_pixels_per_unit |
/(float)info_ptr->x_pixels_per_unit)); |
} |
#else |
return (0.0); |
#endif |
return ((float)0.0); |
} |
#endif |
png_int_32 PNGAPI |
png_get_x_offset_microns(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
#if defined(PNG_oFFs_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_oFFs) |
{ |
png_debug1(1, "in %s retrieval function\n", "png_get_x_offset_microns"); |
if(info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER) |
return (0); |
else return (info_ptr->x_offset); |
} |
#else |
return (0); |
#endif |
return (0); |
} |
png_int_32 PNGAPI |
png_get_y_offset_microns(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
#if defined(PNG_oFFs_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_oFFs) |
{ |
png_debug1(1, "in %s retrieval function\n", "png_get_y_offset_microns"); |
if(info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER) |
return (0); |
else return (info_ptr->y_offset); |
} |
#else |
return (0); |
#endif |
return (0); |
} |
png_int_32 PNGAPI |
png_get_x_offset_pixels(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
#if defined(PNG_oFFs_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_oFFs) |
{ |
png_debug1(1, "in %s retrieval function\n", "png_get_x_offset_microns"); |
if(info_ptr->offset_unit_type != PNG_OFFSET_PIXEL) |
return (0); |
else return (info_ptr->x_offset); |
} |
#else |
return (0); |
#endif |
return (0); |
} |
png_int_32 PNGAPI |
png_get_y_offset_pixels(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
#if defined(PNG_oFFs_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_oFFs) |
{ |
png_debug1(1, "in %s retrieval function\n", "png_get_y_offset_microns"); |
if(info_ptr->offset_unit_type != PNG_OFFSET_PIXEL) |
return (0); |
else return (info_ptr->y_offset); |
} |
#else |
return (0); |
#endif |
return (0); |
} |
#if defined(PNG_INCH_CONVERSIONS) && defined(PNG_FLOATING_POINT_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_pixels_per_inch(png_structp png_ptr, png_infop info_ptr) |
{ |
return ((png_uint_32)((float)png_get_pixels_per_meter(png_ptr, info_ptr) |
*.0254 +.5)); |
} |
png_uint_32 PNGAPI |
png_get_x_pixels_per_inch(png_structp png_ptr, png_infop info_ptr) |
{ |
return ((png_uint_32)((float)png_get_x_pixels_per_meter(png_ptr, info_ptr) |
*.0254 +.5)); |
} |
png_uint_32 PNGAPI |
png_get_y_pixels_per_inch(png_structp png_ptr, png_infop info_ptr) |
{ |
return ((png_uint_32)((float)png_get_y_pixels_per_meter(png_ptr, info_ptr) |
*.0254 +.5)); |
} |
float PNGAPI |
png_get_x_offset_inches(png_structp png_ptr, png_infop info_ptr) |
{ |
return ((float)png_get_x_offset_microns(png_ptr, info_ptr) |
*.00003937); |
} |
float PNGAPI |
png_get_y_offset_inches(png_structp png_ptr, png_infop info_ptr) |
{ |
return ((float)png_get_y_offset_microns(png_ptr, info_ptr) |
*.00003937); |
} |
#if defined(PNG_pHYs_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_pHYs_dpi(png_structp png_ptr, png_infop info_ptr, |
png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type) |
{ |
png_uint_32 retval = 0; |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)) |
{ |
png_debug1(1, "in %s retrieval function\n", "pHYs"); |
if (res_x != NULL) |
{ |
*res_x = info_ptr->x_pixels_per_unit; |
retval |= PNG_INFO_pHYs; |
} |
if (res_y != NULL) |
{ |
*res_y = info_ptr->y_pixels_per_unit; |
retval |= PNG_INFO_pHYs; |
} |
if (unit_type != NULL) |
{ |
*unit_type = (int)info_ptr->phys_unit_type; |
retval |= PNG_INFO_pHYs; |
if(*unit_type == 1) |
{ |
if (res_x != NULL) *res_x = (png_uint_32)(*res_x * .0254 + .50); |
if (res_y != NULL) *res_y = (png_uint_32)(*res_y * .0254 + .50); |
} |
} |
} |
return (retval); |
} |
#endif /* PNG_pHYs_SUPPORTED */ |
#endif /* PNG_INCH_CONVERSIONS && PNG_FLOATING_POINT_SUPPORTED */ |
/* png_get_channels really belongs in here, too, but it's been around longer */ |
#endif /* PNG_EASY_ACCESS_SUPPORTED */ |
png_byte PNGAPI |
png_get_channels(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
return(info_ptr->channels); |
else |
return (0); |
} |
png_bytep PNGAPI |
png_get_signature(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
return(info_ptr->signature); |
else |
return (NULL); |
} |
#if defined(PNG_bKGD_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_bKGD(png_structp png_ptr, png_infop info_ptr, |
png_color_16p *background) |
{ |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD) |
&& background != NULL) |
{ |
png_debug1(1, "in %s retrieval function\n", "bKGD"); |
*background = &(info_ptr->background); |
return (PNG_INFO_bKGD); |
} |
return (0); |
} |
#endif |
#if defined(PNG_cHRM_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
png_uint_32 PNGAPI |
png_get_cHRM(png_structp png_ptr, png_infop info_ptr, |
double *white_x, double *white_y, double *red_x, double *red_y, |
double *green_x, double *green_y, double *blue_x, double *blue_y) |
{ |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM)) |
{ |
png_debug1(1, "in %s retrieval function\n", "cHRM"); |
if (white_x != NULL) |
*white_x = (double)info_ptr->x_white; |
if (white_y != NULL) |
*white_y = (double)info_ptr->y_white; |
if (red_x != NULL) |
*red_x = (double)info_ptr->x_red; |
if (red_y != NULL) |
*red_y = (double)info_ptr->y_red; |
if (green_x != NULL) |
*green_x = (double)info_ptr->x_green; |
if (green_y != NULL) |
*green_y = (double)info_ptr->y_green; |
if (blue_x != NULL) |
*blue_x = (double)info_ptr->x_blue; |
if (blue_y != NULL) |
*blue_y = (double)info_ptr->y_blue; |
return (PNG_INFO_cHRM); |
} |
return (0); |
} |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
png_uint_32 PNGAPI |
png_get_cHRM_fixed(png_structp png_ptr, png_infop info_ptr, |
png_fixed_point *white_x, png_fixed_point *white_y, png_fixed_point *red_x, |
png_fixed_point *red_y, png_fixed_point *green_x, png_fixed_point *green_y, |
png_fixed_point *blue_x, png_fixed_point *blue_y) |
{ |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM)) |
{ |
png_debug1(1, "in %s retrieval function\n", "cHRM"); |
if (white_x != NULL) |
*white_x = info_ptr->int_x_white; |
if (white_y != NULL) |
*white_y = info_ptr->int_y_white; |
if (red_x != NULL) |
*red_x = info_ptr->int_x_red; |
if (red_y != NULL) |
*red_y = info_ptr->int_y_red; |
if (green_x != NULL) |
*green_x = info_ptr->int_x_green; |
if (green_y != NULL) |
*green_y = info_ptr->int_y_green; |
if (blue_x != NULL) |
*blue_x = info_ptr->int_x_blue; |
if (blue_y != NULL) |
*blue_y = info_ptr->int_y_blue; |
return (PNG_INFO_cHRM); |
} |
return (0); |
} |
#endif |
#endif |
#if defined(PNG_gAMA_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
png_uint_32 PNGAPI |
png_get_gAMA(png_structp png_ptr, png_infop info_ptr, double *file_gamma) |
{ |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA) |
&& file_gamma != NULL) |
{ |
png_debug1(1, "in %s retrieval function\n", "gAMA"); |
*file_gamma = (double)info_ptr->gamma; |
return (PNG_INFO_gAMA); |
} |
return (0); |
} |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
png_uint_32 PNGAPI |
png_get_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, |
png_fixed_point *int_file_gamma) |
{ |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA) |
&& int_file_gamma != NULL) |
{ |
png_debug1(1, "in %s retrieval function\n", "gAMA"); |
*int_file_gamma = info_ptr->int_gamma; |
return (PNG_INFO_gAMA); |
} |
return (0); |
} |
#endif |
#endif |
#if defined(PNG_sRGB_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_sRGB(png_structp png_ptr, png_infop info_ptr, int *file_srgb_intent) |
{ |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB) |
&& file_srgb_intent != NULL) |
{ |
png_debug1(1, "in %s retrieval function\n", "sRGB"); |
*file_srgb_intent = (int)info_ptr->srgb_intent; |
return (PNG_INFO_sRGB); |
} |
return (0); |
} |
#endif |
#if defined(PNG_iCCP_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_iCCP(png_structp png_ptr, png_infop info_ptr, |
png_charpp name, int *compression_type, |
png_charpp profile, png_uint_32 *proflen) |
{ |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP) |
&& name != NULL && profile != NULL && proflen != NULL) |
{ |
png_debug1(1, "in %s retrieval function\n", "iCCP"); |
*name = info_ptr->iccp_name; |
*profile = info_ptr->iccp_profile; |
/* compression_type is a dummy so the API won't have to change |
if we introduce multiple compression types later. */ |
*proflen = (int)info_ptr->iccp_proflen; |
*compression_type = (int)info_ptr->iccp_compression; |
return (PNG_INFO_iCCP); |
} |
return (0); |
} |
#endif |
#if defined(PNG_sPLT_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_sPLT(png_structp png_ptr, png_infop info_ptr, |
png_sPLT_tpp spalettes) |
{ |
if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL) |
*spalettes = info_ptr->splt_palettes; |
return ((png_uint_32)info_ptr->splt_palettes_num); |
} |
#endif |
#if defined(PNG_hIST_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p *hist) |
{ |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST) |
&& hist != NULL) |
{ |
png_debug1(1, "in %s retrieval function\n", "hIST"); |
*hist = info_ptr->hist; |
return (PNG_INFO_hIST); |
} |
return (0); |
} |
#endif |
png_uint_32 PNGAPI |
png_get_IHDR(png_structp png_ptr, png_infop info_ptr, |
png_uint_32 *width, png_uint_32 *height, int *bit_depth, |
int *color_type, int *interlace_type, int *compression_type, |
int *filter_type) |
{ |
if (png_ptr != NULL && info_ptr != NULL && width != NULL && height != NULL && |
bit_depth != NULL && color_type != NULL) |
{ |
int pixel_depth, channels; |
png_uint_32 rowbytes_per_pixel; |
png_debug1(1, "in %s retrieval function\n", "IHDR"); |
*width = info_ptr->width; |
*height = info_ptr->height; |
*bit_depth = info_ptr->bit_depth; |
if (info_ptr->bit_depth < 1 || info_ptr->bit_depth > 16) |
png_error(png_ptr, "Invalid bit depth"); |
*color_type = info_ptr->color_type; |
if (info_ptr->color_type > 6) |
png_error(png_ptr, "Invalid color type"); |
if (compression_type != NULL) |
*compression_type = info_ptr->compression_type; |
if (filter_type != NULL) |
*filter_type = info_ptr->filter_type; |
if (interlace_type != NULL) |
*interlace_type = info_ptr->interlace_type; |
/* check for potential overflow of rowbytes */ |
if (*color_type == PNG_COLOR_TYPE_PALETTE) |
channels = 1; |
else if (*color_type & PNG_COLOR_MASK_COLOR) |
channels = 3; |
else |
channels = 1; |
if (*color_type & PNG_COLOR_MASK_ALPHA) |
channels++; |
pixel_depth = *bit_depth * channels; |
rowbytes_per_pixel = (pixel_depth + 7) >> 3; |
if (width == 0 || *width > PNG_MAX_UINT) |
png_error(png_ptr, "Invalid image width"); |
if (height == 0 || *height > PNG_MAX_UINT) |
png_error(png_ptr, "Invalid image height"); |
if (*width > PNG_MAX_UINT/rowbytes_per_pixel - 64) |
{ |
png_error(png_ptr, |
"Width too large for libpng to process image data."); |
} |
return (1); |
} |
return (0); |
} |
#if defined(PNG_oFFs_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_oFFs(png_structp png_ptr, png_infop info_ptr, |
png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type) |
{ |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs) |
&& offset_x != NULL && offset_y != NULL && unit_type != NULL) |
{ |
png_debug1(1, "in %s retrieval function\n", "oFFs"); |
*offset_x = info_ptr->x_offset; |
*offset_y = info_ptr->y_offset; |
*unit_type = (int)info_ptr->offset_unit_type; |
return (PNG_INFO_oFFs); |
} |
return (0); |
} |
#endif |
#if defined(PNG_pCAL_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_pCAL(png_structp png_ptr, png_infop info_ptr, |
png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams, |
png_charp *units, png_charpp *params) |
{ |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL) |
&& purpose != NULL && X0 != NULL && X1 != NULL && type != NULL && |
nparams != NULL && units != NULL && params != NULL) |
{ |
png_debug1(1, "in %s retrieval function\n", "pCAL"); |
*purpose = info_ptr->pcal_purpose; |
*X0 = info_ptr->pcal_X0; |
*X1 = info_ptr->pcal_X1; |
*type = (int)info_ptr->pcal_type; |
*nparams = (int)info_ptr->pcal_nparams; |
*units = info_ptr->pcal_units; |
*params = info_ptr->pcal_params; |
return (PNG_INFO_pCAL); |
} |
return (0); |
} |
#endif |
#if defined(PNG_sCAL_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
png_uint_32 PNGAPI |
png_get_sCAL(png_structp png_ptr, png_infop info_ptr, |
int *unit, double *width, double *height) |
{ |
if (png_ptr != NULL && info_ptr != NULL && |
(info_ptr->valid & PNG_INFO_sCAL)) |
{ |
*unit = info_ptr->scal_unit; |
*width = info_ptr->scal_pixel_width; |
*height = info_ptr->scal_pixel_height; |
return (PNG_INFO_sCAL); |
} |
return(0); |
} |
#else |
#ifdef PNG_FIXED_POINT_SUPPORTED |
png_uint_32 PNGAPI |
png_get_sCAL_s(png_structp png_ptr, png_infop info_ptr, |
int *unit, png_charpp width, png_charpp height) |
{ |
if (png_ptr != NULL && info_ptr != NULL && |
(info_ptr->valid & PNG_INFO_sCAL)) |
{ |
*unit = info_ptr->scal_unit; |
*width = info_ptr->scal_s_width; |
*height = info_ptr->scal_s_height; |
return (PNG_INFO_sCAL); |
} |
return(0); |
} |
#endif |
#endif |
#endif |
#if defined(PNG_pHYs_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_pHYs(png_structp png_ptr, png_infop info_ptr, |
png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type) |
{ |
png_uint_32 retval = 0; |
if (png_ptr != NULL && info_ptr != NULL && |
(info_ptr->valid & PNG_INFO_pHYs)) |
{ |
png_debug1(1, "in %s retrieval function\n", "pHYs"); |
if (res_x != NULL) |
{ |
*res_x = info_ptr->x_pixels_per_unit; |
retval |= PNG_INFO_pHYs; |
} |
if (res_y != NULL) |
{ |
*res_y = info_ptr->y_pixels_per_unit; |
retval |= PNG_INFO_pHYs; |
} |
if (unit_type != NULL) |
{ |
*unit_type = (int)info_ptr->phys_unit_type; |
retval |= PNG_INFO_pHYs; |
} |
} |
return (retval); |
} |
#endif |
png_uint_32 PNGAPI |
png_get_PLTE(png_structp png_ptr, png_infop info_ptr, png_colorp *palette, |
int *num_palette) |
{ |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_PLTE) |
&& palette != NULL) |
{ |
png_debug1(1, "in %s retrieval function\n", "PLTE"); |
*palette = info_ptr->palette; |
*num_palette = info_ptr->num_palette; |
png_debug1(3, "num_palette = %d\n", *num_palette); |
return (PNG_INFO_PLTE); |
} |
return (0); |
} |
#if defined(PNG_sBIT_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_sBIT(png_structp png_ptr, png_infop info_ptr, png_color_8p *sig_bit) |
{ |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT) |
&& sig_bit != NULL) |
{ |
png_debug1(1, "in %s retrieval function\n", "sBIT"); |
*sig_bit = &(info_ptr->sig_bit); |
return (PNG_INFO_sBIT); |
} |
return (0); |
} |
#endif |
#if defined(PNG_TEXT_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr, |
int *num_text) |
{ |
if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0) |
{ |
png_debug1(1, "in %s retrieval function\n", |
(png_ptr->chunk_name[0] == '\0' ? "text" |
: (png_const_charp)png_ptr->chunk_name)); |
if (text_ptr != NULL) |
*text_ptr = info_ptr->text; |
if (num_text != NULL) |
*num_text = info_ptr->num_text; |
return ((png_uint_32)info_ptr->num_text); |
} |
if (num_text != NULL) |
*num_text = 0; |
return(0); |
} |
#endif |
#if defined(PNG_tIME_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_tIME(png_structp png_ptr, png_infop info_ptr, png_timep *mod_time) |
{ |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME) |
&& mod_time != NULL) |
{ |
png_debug1(1, "in %s retrieval function\n", "tIME"); |
*mod_time = &(info_ptr->mod_time); |
return (PNG_INFO_tIME); |
} |
return (0); |
} |
#endif |
#if defined(PNG_tRNS_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_tRNS(png_structp png_ptr, png_infop info_ptr, |
png_bytep *trans, int *num_trans, png_color_16p *trans_values) |
{ |
png_uint_32 retval = 0; |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS)) |
{ |
png_debug1(1, "in %s retrieval function\n", "tRNS"); |
if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
if (trans != NULL) |
{ |
*trans = info_ptr->trans; |
retval |= PNG_INFO_tRNS; |
} |
if (trans_values != NULL) |
*trans_values = &(info_ptr->trans_values); |
} |
else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */ |
{ |
if (trans_values != NULL) |
{ |
*trans_values = &(info_ptr->trans_values); |
retval |= PNG_INFO_tRNS; |
} |
if(trans != NULL) |
*trans = NULL; |
} |
if(num_trans != NULL) |
{ |
*num_trans = info_ptr->num_trans; |
retval |= PNG_INFO_tRNS; |
} |
} |
return (retval); |
} |
#endif |
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_unknown_chunks(png_structp png_ptr, png_infop info_ptr, |
png_unknown_chunkpp unknowns) |
{ |
if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL) |
*unknowns = info_ptr->unknown_chunks; |
return ((png_uint_32)info_ptr->unknown_chunks_num); |
} |
#endif |
#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) |
png_byte PNGAPI |
png_get_rgb_to_gray_status (png_structp png_ptr) |
{ |
return (png_byte)(png_ptr? png_ptr->rgb_to_gray_status : 0); |
} |
#endif |
#if defined(PNG_USER_CHUNKS_SUPPORTED) |
png_voidp PNGAPI |
png_get_user_chunk_ptr(png_structp png_ptr) |
{ |
return (png_ptr? png_ptr->user_chunk_ptr : NULL); |
} |
#endif |
png_uint_32 PNGAPI |
png_get_compression_buffer_size(png_structp png_ptr) |
{ |
return (png_uint_32)(png_ptr? png_ptr->zbuf_size : 0L); |
} |
#ifndef PNG_1_0_X |
#ifdef PNG_ASSEMBLER_CODE_SUPPORTED |
/* this function was added to libpng 1.2.0 and should exist by default */ |
png_uint_32 PNGAPI |
png_get_asm_flags (png_structp png_ptr) |
{ |
return (png_uint_32)(png_ptr? png_ptr->asm_flags : 0L); |
} |
/* this function was added to libpng 1.2.0 and should exist by default */ |
png_uint_32 PNGAPI |
png_get_asm_flagmask (int flag_select) |
{ |
png_uint_32 settable_asm_flags = 0; |
if (flag_select & PNG_SELECT_READ) |
settable_asm_flags |= |
PNG_ASM_FLAG_MMX_READ_COMBINE_ROW | |
PNG_ASM_FLAG_MMX_READ_INTERLACE | |
PNG_ASM_FLAG_MMX_READ_FILTER_SUB | |
PNG_ASM_FLAG_MMX_READ_FILTER_UP | |
PNG_ASM_FLAG_MMX_READ_FILTER_AVG | |
PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ; |
/* no non-MMX flags yet */ |
#if 0 |
/* GRR: no write-flags yet, either, but someday... */ |
if (flag_select & PNG_SELECT_WRITE) |
settable_asm_flags |= |
PNG_ASM_FLAG_MMX_WRITE_ [whatever] ; |
#endif /* 0 */ |
return settable_asm_flags; /* _theoretically_ settable capabilities only */ |
} |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) |
/* GRR: could add this: && defined(PNG_MMX_CODE_SUPPORTED) */ |
/* this function was added to libpng 1.2.0 */ |
png_uint_32 PNGAPI |
png_get_mmx_flagmask (int flag_select, int *compilerID) |
{ |
png_uint_32 settable_mmx_flags = 0; |
if (flag_select & PNG_SELECT_READ) |
settable_mmx_flags |= |
PNG_ASM_FLAG_MMX_READ_COMBINE_ROW | |
PNG_ASM_FLAG_MMX_READ_INTERLACE | |
PNG_ASM_FLAG_MMX_READ_FILTER_SUB | |
PNG_ASM_FLAG_MMX_READ_FILTER_UP | |
PNG_ASM_FLAG_MMX_READ_FILTER_AVG | |
PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ; |
#if 0 |
/* GRR: no MMX write support yet, but someday... */ |
if (flag_select & PNG_SELECT_WRITE) |
settable_mmx_flags |= |
PNG_ASM_FLAG_MMX_WRITE_ [whatever] ; |
#endif /* 0 */ |
if (compilerID != NULL) { |
#ifdef PNG_USE_PNGVCRD |
*compilerID = 1; /* MSVC */ |
#else |
#ifdef PNG_USE_PNGGCCRD |
*compilerID = 2; /* gcc/gas */ |
#else |
*compilerID = -1; /* unknown (i.e., no asm/MMX code compiled) */ |
#endif |
#endif |
} |
return settable_mmx_flags; /* _theoretically_ settable capabilities only */ |
} |
/* this function was added to libpng 1.2.0 */ |
png_byte PNGAPI |
png_get_mmx_bitdepth_threshold (png_structp png_ptr) |
{ |
return (png_byte)(png_ptr? png_ptr->mmx_bitdepth_threshold : 0); |
} |
/* this function was added to libpng 1.2.0 */ |
png_uint_32 PNGAPI |
png_get_mmx_rowbytes_threshold (png_structp png_ptr) |
{ |
return (png_uint_32)(png_ptr? png_ptr->mmx_rowbytes_threshold : 0L); |
} |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
#endif /* PNG_1_0_X */ |
/shark/trunk/ports/png/png.c |
---|
0,0 → 1,805 |
/* png.c - location for general purpose libpng functions |
* |
* libpng version 1.2.5 - October 3, 2002 |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
*/ |
#define PNG_INTERNAL |
#define PNG_NO_EXTERN |
#include "png.h" |
/* Generate a compiler error if there is an old png.h in the search path. */ |
typedef version_1_2_5 Your_png_h_is_not_version_1_2_5; |
/* Version information for C files. This had better match the version |
* string defined in png.h. */ |
#ifdef PNG_USE_GLOBAL_ARRAYS |
/* png_libpng_ver was changed to a function in version 1.0.5c */ |
const char png_libpng_ver[18] = "1.2.5"; |
/* png_sig was changed to a function in version 1.0.5c */ |
/* Place to hold the signature string for a PNG file. */ |
const png_byte FARDATA png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10}; |
/* Invoke global declarations for constant strings for known chunk types */ |
PNG_IHDR; |
PNG_IDAT; |
PNG_IEND; |
PNG_PLTE; |
PNG_bKGD; |
PNG_cHRM; |
PNG_gAMA; |
PNG_hIST; |
PNG_iCCP; |
PNG_iTXt; |
PNG_oFFs; |
PNG_pCAL; |
PNG_sCAL; |
PNG_pHYs; |
PNG_sBIT; |
PNG_sPLT; |
PNG_sRGB; |
PNG_tEXt; |
PNG_tIME; |
PNG_tRNS; |
PNG_zTXt; |
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
/* start of interlace block */ |
const int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; |
/* offset to next interlace block */ |
const int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; |
/* start of interlace block in the y direction */ |
const int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1}; |
/* offset to next interlace block in the y direction */ |
const int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2}; |
/* width of interlace block (used in assembler routines only) */ |
#ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW |
const int FARDATA png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; |
#endif |
/* Height of interlace block. This is not currently used - if you need |
* it, uncomment it here and in png.h |
const int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1}; |
*/ |
/* Mask to determine which pixels are valid in a pass */ |
const int FARDATA png_pass_mask[] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff}; |
/* Mask to determine which pixels to overwrite while displaying */ |
const int FARDATA png_pass_dsp_mask[] |
= {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff}; |
#endif |
/* Tells libpng that we have already handled the first "num_bytes" bytes |
* of the PNG file signature. If the PNG data is embedded into another |
* stream we can set num_bytes = 8 so that libpng will not attempt to read |
* or write any of the magic bytes before it starts on the IHDR. |
*/ |
void PNGAPI |
png_set_sig_bytes(png_structp png_ptr, int num_bytes) |
{ |
png_debug(1, "in png_set_sig_bytes\n"); |
if (num_bytes > 8) |
png_error(png_ptr, "Too many bytes for PNG signature."); |
png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes); |
} |
/* Checks whether the supplied bytes match the PNG signature. We allow |
* checking less than the full 8-byte signature so that those apps that |
* already read the first few bytes of a file to determine the file type |
* can simply check the remaining bytes for extra assurance. Returns |
* an integer less than, equal to, or greater than zero if sig is found, |
* respectively, to be less than, to match, or be greater than the correct |
* PNG signature (this is the same behaviour as strcmp, memcmp, etc). |
*/ |
int PNGAPI |
png_sig_cmp(png_bytep sig, png_size_t start, png_size_t num_to_check) |
{ |
png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10}; |
if (num_to_check > 8) |
num_to_check = 8; |
else if (num_to_check < 1) |
return (0); |
if (start > 7) |
return (0); |
if (start + num_to_check > 8) |
num_to_check = 8 - start; |
return ((int)(png_memcmp(&sig[start], &png_signature[start], num_to_check))); |
} |
/* (Obsolete) function to check signature bytes. It does not allow one |
* to check a partial signature. This function might be removed in the |
* future - use png_sig_cmp(). Returns true (nonzero) if the file is a PNG. |
*/ |
int PNGAPI |
png_check_sig(png_bytep sig, int num) |
{ |
return ((int)!png_sig_cmp(sig, (png_size_t)0, (png_size_t)num)); |
} |
/* Function to allocate memory for zlib and clear it to 0. */ |
#ifdef PNG_1_0_X |
voidpf PNGAPI |
#else |
voidpf /* private */ |
#endif |
png_zalloc(voidpf png_ptr, uInt items, uInt size) |
{ |
png_uint_32 num_bytes = (png_uint_32)items * size; |
png_voidp ptr; |
png_structp p=png_ptr; |
png_uint_32 save_flags=p->flags; |
p->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK; |
ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes); |
p->flags=save_flags; |
#ifndef PNG_NO_ZALLOC_ZERO |
if (ptr == NULL) |
return ((voidpf)ptr); |
if (num_bytes > (png_uint_32)0x8000L) |
{ |
png_memset(ptr, 0, (png_size_t)0x8000L); |
png_memset((png_bytep)ptr + (png_size_t)0x8000L, 0, |
(png_size_t)(num_bytes - (png_uint_32)0x8000L)); |
} |
else |
{ |
png_memset(ptr, 0, (png_size_t)num_bytes); |
} |
#endif |
return ((voidpf)ptr); |
} |
/* function to free memory for zlib */ |
#ifdef PNG_1_0_X |
void PNGAPI |
#else |
void /* private */ |
#endif |
png_zfree(voidpf png_ptr, voidpf ptr) |
{ |
png_free((png_structp)png_ptr, (png_voidp)ptr); |
} |
/* Reset the CRC variable to 32 bits of 1's. Care must be taken |
* in case CRC is > 32 bits to leave the top bits 0. |
*/ |
void /* PRIVATE */ |
png_reset_crc(png_structp png_ptr) |
{ |
png_ptr->crc = crc32(0, Z_NULL, 0); |
} |
/* Calculate the CRC over a section of data. We can only pass as |
* much data to this routine as the largest single buffer size. We |
* also check that this data will actually be used before going to the |
* trouble of calculating it. |
*/ |
void /* PRIVATE */ |
png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length) |
{ |
int need_crc = 1; |
if (png_ptr->chunk_name[0] & 0x20) /* ancillary */ |
{ |
if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) == |
(PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN)) |
need_crc = 0; |
} |
else /* critical */ |
{ |
if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE) |
need_crc = 0; |
} |
if (need_crc) |
png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length); |
} |
/* Allocate the memory for an info_struct for the application. We don't |
* really need the png_ptr, but it could potentially be useful in the |
* future. This should be used in favour of malloc(sizeof(png_info)) |
* and png_info_init() so that applications that want to use a shared |
* libpng don't have to be recompiled if png_info changes size. |
*/ |
png_infop PNGAPI |
png_create_info_struct(png_structp png_ptr) |
{ |
png_infop info_ptr; |
png_debug(1, "in png_create_info_struct\n"); |
if(png_ptr == NULL) return (NULL); |
#ifdef PNG_USER_MEM_SUPPORTED |
info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO, |
png_ptr->malloc_fn, png_ptr->mem_ptr); |
#else |
info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO); |
#endif |
if (info_ptr != NULL) |
png_info_init_3(&info_ptr, sizeof(png_info)); |
return (info_ptr); |
} |
/* This function frees the memory associated with a single info struct. |
* Normally, one would use either png_destroy_read_struct() or |
* png_destroy_write_struct() to free an info struct, but this may be |
* useful for some applications. |
*/ |
void PNGAPI |
png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr) |
{ |
png_infop info_ptr = NULL; |
png_debug(1, "in png_destroy_info_struct\n"); |
if (info_ptr_ptr != NULL) |
info_ptr = *info_ptr_ptr; |
if (info_ptr != NULL) |
{ |
png_info_destroy(png_ptr, info_ptr); |
#ifdef PNG_USER_MEM_SUPPORTED |
png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn, |
png_ptr->mem_ptr); |
#else |
png_destroy_struct((png_voidp)info_ptr); |
#endif |
*info_ptr_ptr = NULL; |
} |
} |
/* Initialize the info structure. This is now an internal function (0.89) |
* and applications using it are urged to use png_create_info_struct() |
* instead. |
*/ |
#undef png_info_init |
void PNGAPI |
png_info_init(png_infop info_ptr) |
{ |
/* We only come here via pre-1.0.12-compiled applications */ |
png_info_init_3(&info_ptr, 0); |
} |
void PNGAPI |
png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size) |
{ |
png_infop info_ptr = *ptr_ptr; |
png_debug(1, "in png_info_init_3\n"); |
if(sizeof(png_info) > png_info_struct_size) |
{ |
png_destroy_struct(info_ptr); |
info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO); |
*ptr_ptr = info_ptr; |
} |
/* set everything to 0 */ |
png_memset(info_ptr, 0, sizeof (png_info)); |
} |
#ifdef PNG_FREE_ME_SUPPORTED |
void PNGAPI |
png_data_freer(png_structp png_ptr, png_infop info_ptr, |
int freer, png_uint_32 mask) |
{ |
png_debug(1, "in png_data_freer\n"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
if(freer == PNG_DESTROY_WILL_FREE_DATA) |
info_ptr->free_me |= mask; |
else if(freer == PNG_USER_WILL_FREE_DATA) |
info_ptr->free_me &= ~mask; |
else |
png_warning(png_ptr, |
"Unknown freer parameter in png_data_freer."); |
} |
#endif |
void PNGAPI |
png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask, |
int num) |
{ |
png_debug(1, "in png_free_data\n"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
#if defined(PNG_TEXT_SUPPORTED) |
/* free text item num or (if num == -1) all text items */ |
#ifdef PNG_FREE_ME_SUPPORTED |
if ((mask & PNG_FREE_TEXT) & info_ptr->free_me) |
#else |
if (mask & PNG_FREE_TEXT) |
#endif |
{ |
if (num != -1) |
{ |
if (info_ptr->text && info_ptr->text[num].key) |
{ |
png_free(png_ptr, info_ptr->text[num].key); |
info_ptr->text[num].key = NULL; |
} |
} |
else |
{ |
int i; |
for (i = 0; i < info_ptr->num_text; i++) |
png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i); |
png_free(png_ptr, info_ptr->text); |
info_ptr->text = NULL; |
info_ptr->num_text=0; |
} |
} |
#endif |
#if defined(PNG_tRNS_SUPPORTED) |
/* free any tRNS entry */ |
#ifdef PNG_FREE_ME_SUPPORTED |
if ((mask & PNG_FREE_TRNS) & info_ptr->free_me) |
#else |
if ((mask & PNG_FREE_TRNS) && (png_ptr->flags & PNG_FLAG_FREE_TRNS)) |
#endif |
{ |
png_free(png_ptr, info_ptr->trans); |
info_ptr->valid &= ~PNG_INFO_tRNS; |
#ifndef PNG_FREE_ME_SUPPORTED |
png_ptr->flags &= ~PNG_FLAG_FREE_TRNS; |
#endif |
info_ptr->trans = NULL; |
} |
#endif |
#if defined(PNG_sCAL_SUPPORTED) |
/* free any sCAL entry */ |
#ifdef PNG_FREE_ME_SUPPORTED |
if ((mask & PNG_FREE_SCAL) & info_ptr->free_me) |
#else |
if (mask & PNG_FREE_SCAL) |
#endif |
{ |
#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED) |
png_free(png_ptr, info_ptr->scal_s_width); |
png_free(png_ptr, info_ptr->scal_s_height); |
info_ptr->scal_s_width = NULL; |
info_ptr->scal_s_height = NULL; |
#endif |
info_ptr->valid &= ~PNG_INFO_sCAL; |
} |
#endif |
#if defined(PNG_pCAL_SUPPORTED) |
/* free any pCAL entry */ |
#ifdef PNG_FREE_ME_SUPPORTED |
if ((mask & PNG_FREE_PCAL) & info_ptr->free_me) |
#else |
if (mask & PNG_FREE_PCAL) |
#endif |
{ |
png_free(png_ptr, info_ptr->pcal_purpose); |
png_free(png_ptr, info_ptr->pcal_units); |
info_ptr->pcal_purpose = NULL; |
info_ptr->pcal_units = NULL; |
if (info_ptr->pcal_params != NULL) |
{ |
int i; |
for (i = 0; i < (int)info_ptr->pcal_nparams; i++) |
{ |
png_free(png_ptr, info_ptr->pcal_params[i]); |
info_ptr->pcal_params[i]=NULL; |
} |
png_free(png_ptr, info_ptr->pcal_params); |
info_ptr->pcal_params = NULL; |
} |
info_ptr->valid &= ~PNG_INFO_pCAL; |
} |
#endif |
#if defined(PNG_iCCP_SUPPORTED) |
/* free any iCCP entry */ |
#ifdef PNG_FREE_ME_SUPPORTED |
if ((mask & PNG_FREE_ICCP) & info_ptr->free_me) |
#else |
if (mask & PNG_FREE_ICCP) |
#endif |
{ |
png_free(png_ptr, info_ptr->iccp_name); |
png_free(png_ptr, info_ptr->iccp_profile); |
info_ptr->iccp_name = NULL; |
info_ptr->iccp_profile = NULL; |
info_ptr->valid &= ~PNG_INFO_iCCP; |
} |
#endif |
#if defined(PNG_sPLT_SUPPORTED) |
/* free a given sPLT entry, or (if num == -1) all sPLT entries */ |
#ifdef PNG_FREE_ME_SUPPORTED |
if ((mask & PNG_FREE_SPLT) & info_ptr->free_me) |
#else |
if (mask & PNG_FREE_SPLT) |
#endif |
{ |
if (num != -1) |
{ |
if(info_ptr->splt_palettes) |
{ |
png_free(png_ptr, info_ptr->splt_palettes[num].name); |
png_free(png_ptr, info_ptr->splt_palettes[num].entries); |
info_ptr->splt_palettes[num].name = NULL; |
info_ptr->splt_palettes[num].entries = NULL; |
} |
} |
else |
{ |
if(info_ptr->splt_palettes_num) |
{ |
int i; |
for (i = 0; i < (int)info_ptr->splt_palettes_num; i++) |
png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i); |
png_free(png_ptr, info_ptr->splt_palettes); |
info_ptr->splt_palettes = NULL; |
info_ptr->splt_palettes_num = 0; |
} |
info_ptr->valid &= ~PNG_INFO_sPLT; |
} |
} |
#endif |
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) |
#ifdef PNG_FREE_ME_SUPPORTED |
if ((mask & PNG_FREE_UNKN) & info_ptr->free_me) |
#else |
if (mask & PNG_FREE_UNKN) |
#endif |
{ |
if (num != -1) |
{ |
if(info_ptr->unknown_chunks) |
{ |
png_free(png_ptr, info_ptr->unknown_chunks[num].data); |
info_ptr->unknown_chunks[num].data = NULL; |
} |
} |
else |
{ |
int i; |
if(info_ptr->unknown_chunks_num) |
{ |
for (i = 0; i < (int)info_ptr->unknown_chunks_num; i++) |
png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i); |
png_free(png_ptr, info_ptr->unknown_chunks); |
info_ptr->unknown_chunks = NULL; |
info_ptr->unknown_chunks_num = 0; |
} |
} |
} |
#endif |
#if defined(PNG_hIST_SUPPORTED) |
/* free any hIST entry */ |
#ifdef PNG_FREE_ME_SUPPORTED |
if ((mask & PNG_FREE_HIST) & info_ptr->free_me) |
#else |
if ((mask & PNG_FREE_HIST) && (png_ptr->flags & PNG_FLAG_FREE_HIST)) |
#endif |
{ |
png_free(png_ptr, info_ptr->hist); |
info_ptr->hist = NULL; |
info_ptr->valid &= ~PNG_INFO_hIST; |
#ifndef PNG_FREE_ME_SUPPORTED |
png_ptr->flags &= ~PNG_FLAG_FREE_HIST; |
#endif |
} |
#endif |
/* free any PLTE entry that was internally allocated */ |
#ifdef PNG_FREE_ME_SUPPORTED |
if ((mask & PNG_FREE_PLTE) & info_ptr->free_me) |
#else |
if ((mask & PNG_FREE_PLTE) && (png_ptr->flags & PNG_FLAG_FREE_PLTE)) |
#endif |
{ |
png_zfree(png_ptr, info_ptr->palette); |
info_ptr->palette = NULL; |
info_ptr->valid &= ~PNG_INFO_PLTE; |
#ifndef PNG_FREE_ME_SUPPORTED |
png_ptr->flags &= ~PNG_FLAG_FREE_PLTE; |
#endif |
info_ptr->num_palette = 0; |
} |
#if defined(PNG_INFO_IMAGE_SUPPORTED) |
/* free any image bits attached to the info structure */ |
#ifdef PNG_FREE_ME_SUPPORTED |
if ((mask & PNG_FREE_ROWS) & info_ptr->free_me) |
#else |
if (mask & PNG_FREE_ROWS) |
#endif |
{ |
if(info_ptr->row_pointers) |
{ |
int row; |
for (row = 0; row < (int)info_ptr->height; row++) |
{ |
png_free(png_ptr, info_ptr->row_pointers[row]); |
info_ptr->row_pointers[row]=NULL; |
} |
png_free(png_ptr, info_ptr->row_pointers); |
info_ptr->row_pointers=NULL; |
} |
info_ptr->valid &= ~PNG_INFO_IDAT; |
} |
#endif |
#ifdef PNG_FREE_ME_SUPPORTED |
if(num == -1) |
info_ptr->free_me &= ~mask; |
else |
info_ptr->free_me &= ~(mask & ~PNG_FREE_MUL); |
#endif |
} |
/* This is an internal routine to free any memory that the info struct is |
* pointing to before re-using it or freeing the struct itself. Recall |
* that png_free() checks for NULL pointers for us. |
*/ |
void /* PRIVATE */ |
png_info_destroy(png_structp png_ptr, png_infop info_ptr) |
{ |
png_debug(1, "in png_info_destroy\n"); |
png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1); |
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) |
if (png_ptr->num_chunk_list) |
{ |
png_free(png_ptr, png_ptr->chunk_list); |
png_ptr->chunk_list=NULL; |
png_ptr->num_chunk_list=0; |
} |
#endif |
png_info_init_3(&info_ptr, sizeof(png_info)); |
} |
/* This function returns a pointer to the io_ptr associated with the user |
* functions. The application should free any memory associated with this |
* pointer before png_write_destroy() or png_read_destroy() are called. |
*/ |
png_voidp PNGAPI |
png_get_io_ptr(png_structp png_ptr) |
{ |
return (png_ptr->io_ptr); |
} |
#if !defined(PNG_NO_STDIO) |
/* Initialize the default input/output functions for the PNG file. If you |
* use your own read or write routines, you can call either png_set_read_fn() |
* or png_set_write_fn() instead of png_init_io(). If you have defined |
* PNG_NO_STDIO, you must use a function of your own because "FILE *" isn't |
* necessarily available. |
*/ |
void PNGAPI |
png_init_io(png_structp png_ptr, png_FILE_p fp) |
{ |
png_debug(1, "in png_init_io\n"); |
png_ptr->io_ptr = (png_voidp)fp; |
} |
#endif |
#if defined(PNG_TIME_RFC1123_SUPPORTED) |
/* Convert the supplied time into an RFC 1123 string suitable for use in |
* a "Creation Time" or other text-based time string. |
*/ |
png_charp PNGAPI |
png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime) |
{ |
static PNG_CONST char short_months[12][4] = |
{"Jan", "Feb", "Mar", "Apr", "May", "Jun", |
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; |
if (png_ptr->time_buffer == NULL) |
{ |
png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29* |
sizeof(char))); |
} |
#if defined(_WIN32_WCE) |
{ |
wchar_t time_buf[29]; |
wsprintf(time_buf, TEXT("%d %S %d %02d:%02d:%02d +0000"), |
ptime->day % 32, short_months[(ptime->month - 1) % 12], |
ptime->year, ptime->hour % 24, ptime->minute % 60, |
ptime->second % 61); |
WideCharToMultiByte(CP_ACP, 0, time_buf, -1, png_ptr->time_buffer, 29, |
NULL, NULL); |
} |
#else |
#ifdef USE_FAR_KEYWORD |
{ |
char near_time_buf[29]; |
sprintf(near_time_buf, "%d %s %d %02d:%02d:%02d +0000", |
ptime->day % 32, short_months[(ptime->month - 1) % 12], |
ptime->year, ptime->hour % 24, ptime->minute % 60, |
ptime->second % 61); |
png_memcpy(png_ptr->time_buffer, near_time_buf, |
29*sizeof(char)); |
} |
#else |
sprintf(png_ptr->time_buffer, "%d %s %d %02d:%02d:%02d +0000", |
ptime->day % 32, short_months[(ptime->month - 1) % 12], |
ptime->year, ptime->hour % 24, ptime->minute % 60, |
ptime->second % 61); |
#endif |
#endif /* _WIN32_WCE */ |
return ((png_charp)png_ptr->time_buffer); |
} |
#endif /* PNG_TIME_RFC1123_SUPPORTED */ |
#if 0 |
/* Signature string for a PNG file. */ |
png_bytep PNGAPI |
png_sig_bytes(void) |
{ |
return ((png_bytep)"\211\120\116\107\015\012\032\012"); |
} |
#endif |
png_charp PNGAPI |
png_get_copyright(png_structp png_ptr) |
{ |
if (png_ptr != NULL || png_ptr == NULL) /* silence compiler warning */ |
return ((png_charp) "\n libpng version 1.2.5 - October 3, 2002\n\ |
Copyright (c) 1998-2002 Glenn Randers-Pehrson\n\ |
Copyright (c) 1996-1997 Andreas Dilger\n\ |
Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.\n"); |
return ((png_charp) ""); |
} |
/* The following return the library version as a short string in the |
* format 1.0.0 through 99.99.99zz. To get the version of *.h files used |
* with your application, print out PNG_LIBPNG_VER_STRING, which is defined |
* in png.h. |
*/ |
png_charp PNGAPI |
png_get_libpng_ver(png_structp png_ptr) |
{ |
/* Version of *.c files used when building libpng */ |
if(png_ptr != NULL) /* silence compiler warning about unused png_ptr */ |
return((png_charp) "1.2.5"); |
return((png_charp) "1.2.5"); |
} |
png_charp PNGAPI |
png_get_header_ver(png_structp png_ptr) |
{ |
/* Version of *.h files used when building libpng */ |
if(png_ptr != NULL) /* silence compiler warning about unused png_ptr */ |
return((png_charp) PNG_LIBPNG_VER_STRING); |
return((png_charp) PNG_LIBPNG_VER_STRING); |
} |
png_charp PNGAPI |
png_get_header_version(png_structp png_ptr) |
{ |
/* Returns longer string containing both version and date */ |
if(png_ptr != NULL) /* silence compiler warning about unused png_ptr */ |
return((png_charp) PNG_HEADER_VERSION_STRING); |
return((png_charp) PNG_HEADER_VERSION_STRING); |
} |
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
int PNGAPI |
png_handle_as_unknown(png_structp png_ptr, png_bytep chunk_name) |
{ |
/* check chunk_name and return "keep" value if it's on the list, else 0 */ |
int i; |
png_bytep p; |
if((png_ptr == NULL && chunk_name == NULL) || png_ptr->num_chunk_list<=0) |
return 0; |
p=png_ptr->chunk_list+png_ptr->num_chunk_list*5-5; |
for (i = png_ptr->num_chunk_list; i; i--, p-=5) |
if (!png_memcmp(chunk_name, p, 4)) |
return ((int)*(p+4)); |
return 0; |
} |
#endif |
/* This function, added to libpng-1.0.6g, is untested. */ |
int PNGAPI |
png_reset_zstream(png_structp png_ptr) |
{ |
return (inflateReset(&png_ptr->zstream)); |
} |
/* This function was added to libpng-1.0.7 */ |
png_uint_32 PNGAPI |
png_access_version_number(void) |
{ |
/* Version of *.c files used when building libpng */ |
return((png_uint_32) 10205L); |
} |
#if !defined(PNG_1_0_X) |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) |
/* GRR: could add this: && defined(PNG_MMX_CODE_SUPPORTED) */ |
/* this INTERNAL function was added to libpng 1.2.0 */ |
void /* PRIVATE */ |
png_init_mmx_flags (png_structp png_ptr) |
{ |
png_ptr->mmx_rowbytes_threshold = 0; |
png_ptr->mmx_bitdepth_threshold = 0; |
# if (defined(PNG_USE_PNGVCRD) || defined(PNG_USE_PNGGCCRD)) |
png_ptr->asm_flags |= PNG_ASM_FLAG_MMX_SUPPORT_COMPILED; |
if (png_mmx_support() > 0) { |
png_ptr->asm_flags |= PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU |
# ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW |
| PNG_ASM_FLAG_MMX_READ_COMBINE_ROW |
# endif |
# ifdef PNG_HAVE_ASSEMBLER_READ_INTERLACE |
| PNG_ASM_FLAG_MMX_READ_INTERLACE |
# endif |
# ifndef PNG_HAVE_ASSEMBLER_READ_FILTER_ROW |
; |
# else |
| PNG_ASM_FLAG_MMX_READ_FILTER_SUB |
| PNG_ASM_FLAG_MMX_READ_FILTER_UP |
| PNG_ASM_FLAG_MMX_READ_FILTER_AVG |
| PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ; |
png_ptr->mmx_rowbytes_threshold = PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT; |
png_ptr->mmx_bitdepth_threshold = PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT; |
# endif |
} else { |
png_ptr->asm_flags &= ~( PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU |
| PNG_MMX_READ_FLAGS |
| PNG_MMX_WRITE_FLAGS ); |
} |
# else /* !((PNGVCRD || PNGGCCRD) && PNG_ASSEMBLER_CODE_SUPPORTED)) */ |
/* clear all MMX flags; no support is compiled in */ |
png_ptr->asm_flags &= ~( PNG_MMX_FLAGS ); |
# endif /* ?(PNGVCRD || PNGGCCRD) */ |
} |
#endif /* !(PNG_ASSEMBLER_CODE_SUPPORTED) */ |
/* this function was added to libpng 1.2.0 */ |
#if !defined(PNG_USE_PNGGCCRD) && \ |
!(defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_USE_PNGVCRD)) |
int PNGAPI |
png_mmx_support(void) |
{ |
return -1; |
} |
#endif |
#endif /* PNG_1_0_X */ |
/shark/trunk/ports/png/pnggccrd.c |
---|
0,0 → 1,5397 |
/* pnggccrd.c - mixed C/assembler version of utilities to read a PNG file |
* |
* For Intel x86 CPU (Pentium-MMX or later) and GNU C compiler. |
* |
* See http://www.intel.com/drg/pentiumII/appnotes/916/916.htm |
* and http://www.intel.com/drg/pentiumII/appnotes/923/923.htm |
* for Intel's performance analysis of the MMX vs. non-MMX code. |
* |
* libpng version 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* Copyright (c) 1998, Intel Corporation |
* |
* Based on MSVC code contributed by Nirav Chhatrapati, Intel Corp., 1998. |
* Interface to libpng contributed by Gilles Vollant, 1999. |
* GNU C port by Greg Roelofs, 1999-2001. |
* |
* Lines 2350-4300 converted in place with intel2gas 1.3.1: |
* |
* intel2gas -mdI pnggccrd.c.partially-msvc -o pnggccrd.c |
* |
* and then cleaned up by hand. See http://hermes.terminal.at/intel2gas/ . |
* |
* NOTE: A sufficiently recent version of GNU as (or as.exe under DOS/Windows) |
* is required to assemble the newer MMX instructions such as movq. |
* For djgpp, see |
* |
* ftp://ftp.simtel.net/pub/simtelnet/gnu/djgpp/v2gnu/bnu281b.zip |
* |
* (or a later version in the same directory). For Linux, check your |
* distribution's web site(s) or try these links: |
* |
* http://rufus.w3.org/linux/RPM/binutils.html |
* http://www.debian.org/Packages/stable/devel/binutils.html |
* ftp://ftp.slackware.com/pub/linux/slackware/slackware/slakware/d1/ |
* binutils.tgz |
* |
* For other platforms, see the main GNU site: |
* |
* ftp://ftp.gnu.org/pub/gnu/binutils/ |
* |
* Version 2.5.2l.15 is definitely too old... |
*/ |
/* |
* TEMPORARY PORTING NOTES AND CHANGELOG (mostly by Greg Roelofs) |
* ===================================== |
* |
* 19991006: |
* - fixed sign error in post-MMX cleanup code (16- & 32-bit cases) |
* |
* 19991007: |
* - additional optimizations (possible or definite): |
* x [DONE] write MMX code for 64-bit case (pixel_bytes == 8) [not tested] |
* - write MMX code for 48-bit case (pixel_bytes == 6) |
* - figure out what's up with 24-bit case (pixel_bytes == 3): |
* why subtract 8 from width_mmx in the pass 4/5 case? |
* (only width_mmx case) (near line 1606) |
* x [DONE] replace pixel_bytes within each block with the true |
* constant value (or are compilers smart enough to do that?) |
* - rewrite all MMX interlacing code so it's aligned with |
* the *beginning* of the row buffer, not the end. This |
* would not only allow one to eliminate half of the memory |
* writes for odd passes (that is, pass == odd), it may also |
* eliminate some unaligned-data-access exceptions (assuming |
* there's a penalty for not aligning 64-bit accesses on |
* 64-bit boundaries). The only catch is that the "leftover" |
* pixel(s) at the end of the row would have to be saved, |
* but there are enough unused MMX registers in every case, |
* so this is not a problem. A further benefit is that the |
* post-MMX cleanup code (C code) in at least some of the |
* cases could be done within the assembler block. |
* x [DONE] the "v3 v2 v1 v0 v7 v6 v5 v4" comments are confusing, |
* inconsistent, and don't match the MMX Programmer's Reference |
* Manual conventions anyway. They should be changed to |
* "b7 b6 b5 b4 b3 b2 b1 b0," where b0 indicates the byte that |
* was lowest in memory (e.g., corresponding to a left pixel) |
* and b7 is the byte that was highest (e.g., a right pixel). |
* |
* 19991016: |
* - Brennan's Guide notwithstanding, gcc under Linux does *not* |
* want globals prefixed by underscores when referencing them-- |
* i.e., if the variable is const4, then refer to it as const4, |
* not _const4. This seems to be a djgpp-specific requirement. |
* Also, such variables apparently *must* be declared outside |
* of functions; neither static nor automatic variables work if |
* defined within the scope of a single function, but both |
* static and truly global (multi-module) variables work fine. |
* |
* 19991023: |
* - fixed png_combine_row() non-MMX replication bug (odd passes only?) |
* - switched from string-concatenation-with-macros to cleaner method of |
* renaming global variables for djgpp--i.e., always use prefixes in |
* inlined assembler code (== strings) and conditionally rename the |
* variables, not the other way around. Hence _const4, _mask8_0, etc. |
* |
* 19991024: |
* - fixed mmxsupport()/png_do_read_interlace() first-row bug |
* This one was severely weird: even though mmxsupport() doesn't touch |
* ebx (where "row" pointer was stored), it nevertheless managed to zero |
* the register (even in static/non-fPIC code--see below), which in turn |
* caused png_do_read_interlace() to return prematurely on the first row of |
* interlaced images (i.e., without expanding the interlaced pixels). |
* Inspection of the generated assembly code didn't turn up any clues, |
* although it did point at a minor optimization (i.e., get rid of |
* mmx_supported_local variable and just use eax). Possibly the CPUID |
* instruction is more destructive than it looks? (Not yet checked.) |
* - "info gcc" was next to useless, so compared fPIC and non-fPIC assembly |
* listings... Apparently register spillage has to do with ebx, since |
* it's used to index the global offset table. Commenting it out of the |
* input-reg lists in png_combine_row() eliminated compiler barfage, so |
* ifdef'd with __PIC__ macro: if defined, use a global for unmask |
* |
* 19991107: |
* - verified CPUID clobberage: 12-char string constant ("GenuineIntel", |
* "AuthenticAMD", etc.) placed in ebx:ecx:edx. Still need to polish. |
* |
* 19991120: |
* - made "diff" variable (now "_dif") global to simplify conversion of |
* filtering routines (running out of regs, sigh). "diff" is still used |
* in interlacing routines, however. |
* - fixed up both versions of mmxsupport() (ORIG_THAT_USED_TO_CLOBBER_EBX |
* macro determines which is used); original not yet tested. |
* |
* 20000213: |
* - when compiling with gcc, be sure to use -fomit-frame-pointer |
* |
* 20000319: |
* - fixed a register-name typo in png_do_read_interlace(), default (MMX) case, |
* pass == 4 or 5, that caused visible corruption of interlaced images |
* |
* 20000623: |
* - Various problems were reported with gcc 2.95.2 in the Cygwin environment, |
* many of the form "forbidden register 0 (ax) was spilled for class AREG." |
* This is explained at http://gcc.gnu.org/fom_serv/cache/23.html, and |
* Chuck Wilson supplied a patch involving dummy output registers. See |
* http://sourceforge.net/bugs/?func=detailbug&bug_id=108741&group_id=5624 |
* for the original (anonymous) SourceForge bug report. |
* |
* 20000706: |
* - Chuck Wilson passed along these remaining gcc 2.95.2 errors: |
* pnggccrd.c: In function `png_combine_row': |
* pnggccrd.c:525: more than 10 operands in `asm' |
* pnggccrd.c:669: more than 10 operands in `asm' |
* pnggccrd.c:828: more than 10 operands in `asm' |
* pnggccrd.c:994: more than 10 operands in `asm' |
* pnggccrd.c:1177: more than 10 operands in `asm' |
* They are all the same problem and can be worked around by using the |
* global _unmask variable unconditionally, not just in the -fPIC case. |
* Reportedly earlier versions of gcc also have the problem with more than |
* 10 operands; they just don't report it. Much strangeness ensues, etc. |
* |
* 20000729: |
* - enabled png_read_filter_row_mmx_up() (shortest remaining unconverted |
* MMX routine); began converting png_read_filter_row_mmx_sub() |
* - to finish remaining sections: |
* - clean up indentation and comments |
* - preload local variables |
* - add output and input regs (order of former determines numerical |
* mapping of latter) |
* - avoid all usage of ebx (including bx, bh, bl) register [20000823] |
* - remove "$" from addressing of Shift and Mask variables [20000823] |
* |
* 20000731: |
* - global union vars causing segfaults in png_read_filter_row_mmx_sub()? |
* |
* 20000822: |
* - ARGH, stupid png_read_filter_row_mmx_sub() segfault only happens with |
* shared-library (-fPIC) version! Code works just fine as part of static |
* library. Damn damn damn damn damn, should have tested that sooner. |
* ebx is getting clobbered again (explicitly this time); need to save it |
* on stack or rewrite asm code to avoid using it altogether. Blargh! |
* |
* 20000823: |
* - first section was trickiest; all remaining sections have ebx -> edx now. |
* (-fPIC works again.) Also added missing underscores to various Shift* |
* and *Mask* globals and got rid of leading "$" signs. |
* |
* 20000826: |
* - added visual separators to help navigate microscopic printed copies |
* (http://pobox.com/~newt/code/gpr-latest.zip, mode 10); started working |
* on png_read_filter_row_mmx_avg() |
* |
* 20000828: |
* - finished png_read_filter_row_mmx_avg(): only Paeth left! (930 lines...) |
* What the hell, did png_read_filter_row_mmx_paeth(), too. Comments not |
* cleaned up/shortened in either routine, but functionality is complete |
* and seems to be working fine. |
* |
* 20000829: |
* - ahhh, figured out last(?) bit of gcc/gas asm-fu: if register is listed |
* as an input reg (with dummy output variables, etc.), then it *cannot* |
* also appear in the clobber list or gcc 2.95.2 will barf. The solution |
* is simple enough... |
* |
* 20000914: |
* - bug in png_read_filter_row_mmx_avg(): 16-bit grayscale not handled |
* correctly (but 48-bit RGB just fine) |
* |
* 20000916: |
* - fixed bug in png_read_filter_row_mmx_avg(), bpp == 2 case; three errors: |
* - "_ShiftBpp.use = 24;" should have been "_ShiftBpp.use = 16;" |
* - "_ShiftRem.use = 40;" should have been "_ShiftRem.use = 48;" |
* - "psllq _ShiftRem, %%mm2" should have been "psrlq _ShiftRem, %%mm2" |
* |
* 20010101: |
* - added new png_init_mmx_flags() function (here only because it needs to |
* call mmxsupport(), which should probably become global png_mmxsupport()); |
* modified other MMX routines to run conditionally (png_ptr->asm_flags) |
* |
* 20010103: |
* - renamed mmxsupport() to png_mmx_support(), with auto-set of mmx_supported, |
* and made it public; moved png_init_mmx_flags() to png.c as internal func |
* |
* 20010104: |
* - removed dependency on png_read_filter_row_c() (C code already duplicated |
* within MMX version of png_read_filter_row()) so no longer necessary to |
* compile it into pngrutil.o |
* |
* 20010310: |
* - fixed buffer-overrun bug in png_combine_row() C code (non-MMX) |
* |
* 20020304: |
* - eliminated incorrect use of width_mmx in pixel_bytes == 8 case |
* |
* STILL TO DO: |
* - test png_do_read_interlace() 64-bit case (pixel_bytes == 8) |
* - write MMX code for 48-bit case (pixel_bytes == 6) |
* - figure out what's up with 24-bit case (pixel_bytes == 3): |
* why subtract 8 from width_mmx in the pass 4/5 case? |
* (only width_mmx case) (near line 1606) |
* - rewrite all MMX interlacing code so it's aligned with beginning |
* of the row buffer, not the end (see 19991007 for details) |
* x pick one version of mmxsupport() and get rid of the other |
* - add error messages to any remaining bogus default cases |
* - enable pixel_depth == 8 cases in png_read_filter_row()? (test speed) |
* x add support for runtime enable/disable/query of various MMX routines |
*/ |
#define PNG_INTERNAL |
#include "png.h" |
#if defined(PNG_USE_PNGGCCRD) |
int PNGAPI png_mmx_support(void); |
#ifdef PNG_USE_LOCAL_ARRAYS |
static const int FARDATA png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; |
static const int FARDATA png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
static const int FARDATA png_pass_width[7] = {8, 4, 4, 2, 2, 1, 1}; |
#endif |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) |
/* djgpp, Win32, and Cygwin add their own underscores to global variables, |
* so define them without: */ |
#if defined(__DJGPP__) || defined(WIN32) || defined(__CYGWIN__) |
# define _mmx_supported mmx_supported |
# define _const4 const4 |
# define _const6 const6 |
# define _mask8_0 mask8_0 |
# define _mask16_1 mask16_1 |
# define _mask16_0 mask16_0 |
# define _mask24_2 mask24_2 |
# define _mask24_1 mask24_1 |
# define _mask24_0 mask24_0 |
# define _mask32_3 mask32_3 |
# define _mask32_2 mask32_2 |
# define _mask32_1 mask32_1 |
# define _mask32_0 mask32_0 |
# define _mask48_5 mask48_5 |
# define _mask48_4 mask48_4 |
# define _mask48_3 mask48_3 |
# define _mask48_2 mask48_2 |
# define _mask48_1 mask48_1 |
# define _mask48_0 mask48_0 |
# define _LBCarryMask LBCarryMask |
# define _HBClearMask HBClearMask |
# define _ActiveMask ActiveMask |
# define _ActiveMask2 ActiveMask2 |
# define _ActiveMaskEnd ActiveMaskEnd |
# define _ShiftBpp ShiftBpp |
# define _ShiftRem ShiftRem |
#ifdef PNG_THREAD_UNSAFE_OK |
# define _unmask unmask |
# define _FullLength FullLength |
# define _MMXLength MMXLength |
# define _dif dif |
# define _patemp patemp |
# define _pbtemp pbtemp |
# define _pctemp pctemp |
#endif |
#endif |
/* These constants are used in the inlined MMX assembly code. |
Ignore gcc's "At top level: defined but not used" warnings. */ |
/* GRR 20000706: originally _unmask was needed only when compiling with -fPIC, |
* since that case uses the %ebx register for indexing the Global Offset Table |
* and there were no other registers available. But gcc 2.95 and later emit |
* "more than 10 operands in `asm'" errors when %ebx is used to preload unmask |
* in the non-PIC case, so we'll just use the global unconditionally now. |
*/ |
#ifdef PNG_THREAD_UNSAFE_OK |
static int _unmask; |
#endif |
static unsigned long long _mask8_0 = 0x0102040810204080LL; |
static unsigned long long _mask16_1 = 0x0101020204040808LL; |
static unsigned long long _mask16_0 = 0x1010202040408080LL; |
static unsigned long long _mask24_2 = 0x0101010202020404LL; |
static unsigned long long _mask24_1 = 0x0408080810101020LL; |
static unsigned long long _mask24_0 = 0x2020404040808080LL; |
static unsigned long long _mask32_3 = 0x0101010102020202LL; |
static unsigned long long _mask32_2 = 0x0404040408080808LL; |
static unsigned long long _mask32_1 = 0x1010101020202020LL; |
static unsigned long long _mask32_0 = 0x4040404080808080LL; |
static unsigned long long _mask48_5 = 0x0101010101010202LL; |
static unsigned long long _mask48_4 = 0x0202020204040404LL; |
static unsigned long long _mask48_3 = 0x0404080808080808LL; |
static unsigned long long _mask48_2 = 0x1010101010102020LL; |
static unsigned long long _mask48_1 = 0x2020202040404040LL; |
static unsigned long long _mask48_0 = 0x4040808080808080LL; |
static unsigned long long _const4 = 0x0000000000FFFFFFLL; |
//static unsigned long long _const5 = 0x000000FFFFFF0000LL; // NOT USED |
static unsigned long long _const6 = 0x00000000000000FFLL; |
// These are used in the row-filter routines and should/would be local |
// variables if not for gcc addressing limitations. |
// WARNING: Their presence probably defeats the thread safety of libpng. |
#ifdef PNG_THREAD_UNSAFE_OK |
static png_uint_32 _FullLength; |
static png_uint_32 _MMXLength; |
static int _dif; |
static int _patemp; // temp variables for Paeth routine |
static int _pbtemp; |
static int _pctemp; |
#endif |
void /* PRIVATE */ |
png_squelch_warnings(void) |
{ |
#ifdef PNG_THREAD_UNSAFE_OK |
_dif = _dif; |
_patemp = _patemp; |
_pbtemp = _pbtemp; |
_pctemp = _pctemp; |
_MMXLength = _MMXLength; |
#endif |
_const4 = _const4; |
_const6 = _const6; |
_mask8_0 = _mask8_0; |
_mask16_1 = _mask16_1; |
_mask16_0 = _mask16_0; |
_mask24_2 = _mask24_2; |
_mask24_1 = _mask24_1; |
_mask24_0 = _mask24_0; |
_mask32_3 = _mask32_3; |
_mask32_2 = _mask32_2; |
_mask32_1 = _mask32_1; |
_mask32_0 = _mask32_0; |
_mask48_5 = _mask48_5; |
_mask48_4 = _mask48_4; |
_mask48_3 = _mask48_3; |
_mask48_2 = _mask48_2; |
_mask48_1 = _mask48_1; |
_mask48_0 = _mask48_0; |
} |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
static int _mmx_supported = 2; |
/*===========================================================================*/ |
/* */ |
/* P N G _ C O M B I N E _ R O W */ |
/* */ |
/*===========================================================================*/ |
#if defined(PNG_HAVE_ASSEMBLER_COMBINE_ROW) |
#define BPP2 2 |
#define BPP3 3 /* bytes per pixel (a.k.a. pixel_bytes) */ |
#define BPP4 4 |
#define BPP6 6 /* (defined only to help avoid cut-and-paste errors) */ |
#define BPP8 8 |
/* Combines the row recently read in with the previous row. |
This routine takes care of alpha and transparency if requested. |
This routine also handles the two methods of progressive display |
of interlaced images, depending on the mask value. |
The mask value describes which pixels are to be combined with |
the row. The pattern always repeats every 8 pixels, so just 8 |
bits are needed. A one indicates the pixel is to be combined; a |
zero indicates the pixel is to be skipped. This is in addition |
to any alpha or transparency value associated with the pixel. |
If you want all pixels to be combined, pass 0xff (255) in mask. */ |
/* Use this routine for the x86 platform - it uses a faster MMX routine |
if the machine supports MMX. */ |
void /* PRIVATE */ |
png_combine_row(png_structp png_ptr, png_bytep row, int mask) |
{ |
png_debug(1, "in png_combine_row (pnggccrd.c)\n"); |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) |
if (_mmx_supported == 2) { |
/* this should have happened in png_init_mmx_flags() already */ |
png_warning(png_ptr, "asm_flags may not have been initialized"); |
png_mmx_support(); |
} |
#endif |
if (mask == 0xff) |
{ |
png_debug(2,"mask == 0xff: doing single png_memcpy()\n"); |
png_memcpy(row, png_ptr->row_buf + 1, |
(png_size_t)((png_ptr->width * png_ptr->row_info.pixel_depth + 7) >> 3)); |
} |
else /* (png_combine_row() is never called with mask == 0) */ |
{ |
switch (png_ptr->row_info.pixel_depth) |
{ |
case 1: /* png_ptr->row_info.pixel_depth */ |
{ |
png_bytep sp; |
png_bytep dp; |
int s_inc, s_start, s_end; |
int m; |
int shift; |
png_uint_32 i; |
sp = png_ptr->row_buf + 1; |
dp = row; |
m = 0x80; |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_PACKSWAP) |
{ |
s_start = 0; |
s_end = 7; |
s_inc = 1; |
} |
else |
#endif |
{ |
s_start = 7; |
s_end = 0; |
s_inc = -1; |
} |
shift = s_start; |
for (i = 0; i < png_ptr->width; i++) |
{ |
if (m & mask) |
{ |
int value; |
value = (*sp >> shift) & 0x1; |
*dp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff); |
*dp |= (png_byte)(value << shift); |
} |
if (shift == s_end) |
{ |
shift = s_start; |
sp++; |
dp++; |
} |
else |
shift += s_inc; |
if (m == 1) |
m = 0x80; |
else |
m >>= 1; |
} |
break; |
} |
case 2: /* png_ptr->row_info.pixel_depth */ |
{ |
png_bytep sp; |
png_bytep dp; |
int s_start, s_end, s_inc; |
int m; |
int shift; |
png_uint_32 i; |
int value; |
sp = png_ptr->row_buf + 1; |
dp = row; |
m = 0x80; |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_PACKSWAP) |
{ |
s_start = 0; |
s_end = 6; |
s_inc = 2; |
} |
else |
#endif |
{ |
s_start = 6; |
s_end = 0; |
s_inc = -2; |
} |
shift = s_start; |
for (i = 0; i < png_ptr->width; i++) |
{ |
if (m & mask) |
{ |
value = (*sp >> shift) & 0x3; |
*dp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); |
*dp |= (png_byte)(value << shift); |
} |
if (shift == s_end) |
{ |
shift = s_start; |
sp++; |
dp++; |
} |
else |
shift += s_inc; |
if (m == 1) |
m = 0x80; |
else |
m >>= 1; |
} |
break; |
} |
case 4: /* png_ptr->row_info.pixel_depth */ |
{ |
png_bytep sp; |
png_bytep dp; |
int s_start, s_end, s_inc; |
int m; |
int shift; |
png_uint_32 i; |
int value; |
sp = png_ptr->row_buf + 1; |
dp = row; |
m = 0x80; |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_PACKSWAP) |
{ |
s_start = 0; |
s_end = 4; |
s_inc = 4; |
} |
else |
#endif |
{ |
s_start = 4; |
s_end = 0; |
s_inc = -4; |
} |
shift = s_start; |
for (i = 0; i < png_ptr->width; i++) |
{ |
if (m & mask) |
{ |
value = (*sp >> shift) & 0xf; |
*dp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); |
*dp |= (png_byte)(value << shift); |
} |
if (shift == s_end) |
{ |
shift = s_start; |
sp++; |
dp++; |
} |
else |
shift += s_inc; |
if (m == 1) |
m = 0x80; |
else |
m >>= 1; |
} |
break; |
} |
case 8: /* png_ptr->row_info.pixel_depth */ |
{ |
png_bytep srcptr; |
png_bytep dstptr; |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) |
#if !defined(PNG_1_0_X) |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) |
/* && _mmx_supported */ ) |
#else |
if (_mmx_supported) |
#endif |
{ |
png_uint_32 len; |
int diff; |
int dummy_value_a; // fix 'forbidden register spilled' error |
int dummy_value_d; |
int dummy_value_c; |
int dummy_value_S; |
int dummy_value_D; |
_unmask = ~mask; // global variable for -fPIC version |
srcptr = png_ptr->row_buf + 1; |
dstptr = row; |
len = png_ptr->width &~7; // reduce to multiple of 8 |
diff = (int) (png_ptr->width & 7); // amount lost |
__asm__ __volatile__ ( |
"movd _unmask, %%mm7 \n\t" // load bit pattern |
"psubb %%mm6, %%mm6 \n\t" // zero mm6 |
"punpcklbw %%mm7, %%mm7 \n\t" |
"punpcklwd %%mm7, %%mm7 \n\t" |
"punpckldq %%mm7, %%mm7 \n\t" // fill reg with 8 masks |
"movq _mask8_0, %%mm0 \n\t" |
"pand %%mm7, %%mm0 \n\t" // nonzero if keep byte |
"pcmpeqb %%mm6, %%mm0 \n\t" // zeros->1s, v versa |
// preload "movl len, %%ecx \n\t" // load length of line |
// preload "movl srcptr, %%esi \n\t" // load source |
// preload "movl dstptr, %%edi \n\t" // load dest |
"cmpl $0, %%ecx \n\t" // len == 0 ? |
"je mainloop8end \n\t" |
"mainloop8: \n\t" |
"movq (%%esi), %%mm4 \n\t" // *srcptr |
"pand %%mm0, %%mm4 \n\t" |
"movq %%mm0, %%mm6 \n\t" |
"pandn (%%edi), %%mm6 \n\t" // *dstptr |
"por %%mm6, %%mm4 \n\t" |
"movq %%mm4, (%%edi) \n\t" |
"addl $8, %%esi \n\t" // inc by 8 bytes processed |
"addl $8, %%edi \n\t" |
"subl $8, %%ecx \n\t" // dec by 8 pixels processed |
"ja mainloop8 \n\t" |
"mainloop8end: \n\t" |
// preload "movl diff, %%ecx \n\t" // (diff is in eax) |
"movl %%eax, %%ecx \n\t" |
"cmpl $0, %%ecx \n\t" |
"jz end8 \n\t" |
// preload "movl mask, %%edx \n\t" |
"sall $24, %%edx \n\t" // make low byte, high byte |
"secondloop8: \n\t" |
"sall %%edx \n\t" // move high bit to CF |
"jnc skip8 \n\t" // if CF = 0 |
"movb (%%esi), %%al \n\t" |
"movb %%al, (%%edi) \n\t" |
"skip8: \n\t" |
"incl %%esi \n\t" |
"incl %%edi \n\t" |
"decl %%ecx \n\t" |
"jnz secondloop8 \n\t" |
"end8: \n\t" |
"EMMS \n\t" // DONE |
: "=a" (dummy_value_a), // output regs (dummy) |
"=d" (dummy_value_d), |
"=c" (dummy_value_c), |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "3" (srcptr), // esi // input regs |
"4" (dstptr), // edi |
"0" (diff), // eax |
// was (unmask) "b" RESERVED // ebx // Global Offset Table idx |
"2" (len), // ecx |
"1" (mask) // edx |
#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm4", "%mm6", "%mm7" // clobber list |
#endif |
); |
} |
else /* mmx _not supported - Use modified C routine */ |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
{ |
register png_uint_32 i; |
png_uint_32 initial_val = png_pass_start[png_ptr->pass]; |
/* png.c: png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */ |
register int stride = png_pass_inc[png_ptr->pass]; |
/* png.c: png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */ |
register int rep_bytes = png_pass_width[png_ptr->pass]; |
/* png.c: png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */ |
png_uint_32 len = png_ptr->width &~7; /* reduce to mult. of 8 */ |
int diff = (int) (png_ptr->width & 7); /* amount lost */ |
register png_uint_32 final_val = len; /* GRR bugfix */ |
srcptr = png_ptr->row_buf + 1 + initial_val; |
dstptr = row + initial_val; |
for (i = initial_val; i < final_val; i += stride) |
{ |
png_memcpy(dstptr, srcptr, rep_bytes); |
srcptr += stride; |
dstptr += stride; |
} |
if (diff) /* number of leftover pixels: 3 for pngtest */ |
{ |
final_val+=diff /* *BPP1 */ ; |
for (; i < final_val; i += stride) |
{ |
if (rep_bytes > (int)(final_val-i)) |
rep_bytes = (int)(final_val-i); |
png_memcpy(dstptr, srcptr, rep_bytes); |
srcptr += stride; |
dstptr += stride; |
} |
} |
} /* end of else (_mmx_supported) */ |
break; |
} /* end 8 bpp */ |
case 16: /* png_ptr->row_info.pixel_depth */ |
{ |
png_bytep srcptr; |
png_bytep dstptr; |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) |
#if !defined(PNG_1_0_X) |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) |
/* && _mmx_supported */ ) |
#else |
if (_mmx_supported) |
#endif |
{ |
png_uint_32 len; |
int diff; |
int dummy_value_a; // fix 'forbidden register spilled' error |
int dummy_value_d; |
int dummy_value_c; |
int dummy_value_S; |
int dummy_value_D; |
_unmask = ~mask; // global variable for -fPIC version |
srcptr = png_ptr->row_buf + 1; |
dstptr = row; |
len = png_ptr->width &~7; // reduce to multiple of 8 |
diff = (int) (png_ptr->width & 7); // amount lost // |
__asm__ __volatile__ ( |
"movd _unmask, %%mm7 \n\t" // load bit pattern |
"psubb %%mm6, %%mm6 \n\t" // zero mm6 |
"punpcklbw %%mm7, %%mm7 \n\t" |
"punpcklwd %%mm7, %%mm7 \n\t" |
"punpckldq %%mm7, %%mm7 \n\t" // fill reg with 8 masks |
"movq _mask16_0, %%mm0 \n\t" |
"movq _mask16_1, %%mm1 \n\t" |
"pand %%mm7, %%mm0 \n\t" |
"pand %%mm7, %%mm1 \n\t" |
"pcmpeqb %%mm6, %%mm0 \n\t" |
"pcmpeqb %%mm6, %%mm1 \n\t" |
// preload "movl len, %%ecx \n\t" // load length of line |
// preload "movl srcptr, %%esi \n\t" // load source |
// preload "movl dstptr, %%edi \n\t" // load dest |
"cmpl $0, %%ecx \n\t" |
"jz mainloop16end \n\t" |
"mainloop16: \n\t" |
"movq (%%esi), %%mm4 \n\t" |
"pand %%mm0, %%mm4 \n\t" |
"movq %%mm0, %%mm6 \n\t" |
"movq (%%edi), %%mm7 \n\t" |
"pandn %%mm7, %%mm6 \n\t" |
"por %%mm6, %%mm4 \n\t" |
"movq %%mm4, (%%edi) \n\t" |
"movq 8(%%esi), %%mm5 \n\t" |
"pand %%mm1, %%mm5 \n\t" |
"movq %%mm1, %%mm7 \n\t" |
"movq 8(%%edi), %%mm6 \n\t" |
"pandn %%mm6, %%mm7 \n\t" |
"por %%mm7, %%mm5 \n\t" |
"movq %%mm5, 8(%%edi) \n\t" |
"addl $16, %%esi \n\t" // inc by 16 bytes processed |
"addl $16, %%edi \n\t" |
"subl $8, %%ecx \n\t" // dec by 8 pixels processed |
"ja mainloop16 \n\t" |
"mainloop16end: \n\t" |
// preload "movl diff, %%ecx \n\t" // (diff is in eax) |
"movl %%eax, %%ecx \n\t" |
"cmpl $0, %%ecx \n\t" |
"jz end16 \n\t" |
// preload "movl mask, %%edx \n\t" |
"sall $24, %%edx \n\t" // make low byte, high byte |
"secondloop16: \n\t" |
"sall %%edx \n\t" // move high bit to CF |
"jnc skip16 \n\t" // if CF = 0 |
"movw (%%esi), %%ax \n\t" |
"movw %%ax, (%%edi) \n\t" |
"skip16: \n\t" |
"addl $2, %%esi \n\t" |
"addl $2, %%edi \n\t" |
"decl %%ecx \n\t" |
"jnz secondloop16 \n\t" |
"end16: \n\t" |
"EMMS \n\t" // DONE |
: "=a" (dummy_value_a), // output regs (dummy) |
"=c" (dummy_value_c), |
"=d" (dummy_value_d), |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "0" (diff), // eax // input regs |
// was (unmask) " " RESERVED // ebx // Global Offset Table idx |
"1" (len), // ecx |
"2" (mask), // edx |
"3" (srcptr), // esi |
"4" (dstptr) // edi |
#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm1", "%mm4" // clobber list |
, "%mm5", "%mm6", "%mm7" |
#endif |
); |
} |
else /* mmx _not supported - Use modified C routine */ |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
{ |
register png_uint_32 i; |
png_uint_32 initial_val = BPP2 * png_pass_start[png_ptr->pass]; |
/* png.c: png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */ |
register int stride = BPP2 * png_pass_inc[png_ptr->pass]; |
/* png.c: png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */ |
register int rep_bytes = BPP2 * png_pass_width[png_ptr->pass]; |
/* png.c: png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */ |
png_uint_32 len = png_ptr->width &~7; /* reduce to mult. of 8 */ |
int diff = (int) (png_ptr->width & 7); /* amount lost */ |
register png_uint_32 final_val = BPP2 * len; /* GRR bugfix */ |
srcptr = png_ptr->row_buf + 1 + initial_val; |
dstptr = row + initial_val; |
for (i = initial_val; i < final_val; i += stride) |
{ |
png_memcpy(dstptr, srcptr, rep_bytes); |
srcptr += stride; |
dstptr += stride; |
} |
if (diff) /* number of leftover pixels: 3 for pngtest */ |
{ |
final_val+=diff*BPP2; |
for (; i < final_val; i += stride) |
{ |
if (rep_bytes > (int)(final_val-i)) |
rep_bytes = (int)(final_val-i); |
png_memcpy(dstptr, srcptr, rep_bytes); |
srcptr += stride; |
dstptr += stride; |
} |
} |
} /* end of else (_mmx_supported) */ |
break; |
} /* end 16 bpp */ |
case 24: /* png_ptr->row_info.pixel_depth */ |
{ |
png_bytep srcptr; |
png_bytep dstptr; |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) |
#if !defined(PNG_1_0_X) |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) |
/* && _mmx_supported */ ) |
#else |
if (_mmx_supported) |
#endif |
{ |
png_uint_32 len; |
int diff; |
int dummy_value_a; // fix 'forbidden register spilled' error |
int dummy_value_d; |
int dummy_value_c; |
int dummy_value_S; |
int dummy_value_D; |
_unmask = ~mask; // global variable for -fPIC version |
srcptr = png_ptr->row_buf + 1; |
dstptr = row; |
len = png_ptr->width &~7; // reduce to multiple of 8 |
diff = (int) (png_ptr->width & 7); // amount lost // |
__asm__ __volatile__ ( |
"movd _unmask, %%mm7 \n\t" // load bit pattern |
"psubb %%mm6, %%mm6 \n\t" // zero mm6 |
"punpcklbw %%mm7, %%mm7 \n\t" |
"punpcklwd %%mm7, %%mm7 \n\t" |
"punpckldq %%mm7, %%mm7 \n\t" // fill reg with 8 masks |
"movq _mask24_0, %%mm0 \n\t" |
"movq _mask24_1, %%mm1 \n\t" |
"movq _mask24_2, %%mm2 \n\t" |
"pand %%mm7, %%mm0 \n\t" |
"pand %%mm7, %%mm1 \n\t" |
"pand %%mm7, %%mm2 \n\t" |
"pcmpeqb %%mm6, %%mm0 \n\t" |
"pcmpeqb %%mm6, %%mm1 \n\t" |
"pcmpeqb %%mm6, %%mm2 \n\t" |
// preload "movl len, %%ecx \n\t" // load length of line |
// preload "movl srcptr, %%esi \n\t" // load source |
// preload "movl dstptr, %%edi \n\t" // load dest |
"cmpl $0, %%ecx \n\t" |
"jz mainloop24end \n\t" |
"mainloop24: \n\t" |
"movq (%%esi), %%mm4 \n\t" |
"pand %%mm0, %%mm4 \n\t" |
"movq %%mm0, %%mm6 \n\t" |
"movq (%%edi), %%mm7 \n\t" |
"pandn %%mm7, %%mm6 \n\t" |
"por %%mm6, %%mm4 \n\t" |
"movq %%mm4, (%%edi) \n\t" |
"movq 8(%%esi), %%mm5 \n\t" |
"pand %%mm1, %%mm5 \n\t" |
"movq %%mm1, %%mm7 \n\t" |
"movq 8(%%edi), %%mm6 \n\t" |
"pandn %%mm6, %%mm7 \n\t" |
"por %%mm7, %%mm5 \n\t" |
"movq %%mm5, 8(%%edi) \n\t" |
"movq 16(%%esi), %%mm6 \n\t" |
"pand %%mm2, %%mm6 \n\t" |
"movq %%mm2, %%mm4 \n\t" |
"movq 16(%%edi), %%mm7 \n\t" |
"pandn %%mm7, %%mm4 \n\t" |
"por %%mm4, %%mm6 \n\t" |
"movq %%mm6, 16(%%edi) \n\t" |
"addl $24, %%esi \n\t" // inc by 24 bytes processed |
"addl $24, %%edi \n\t" |
"subl $8, %%ecx \n\t" // dec by 8 pixels processed |
"ja mainloop24 \n\t" |
"mainloop24end: \n\t" |
// preload "movl diff, %%ecx \n\t" // (diff is in eax) |
"movl %%eax, %%ecx \n\t" |
"cmpl $0, %%ecx \n\t" |
"jz end24 \n\t" |
// preload "movl mask, %%edx \n\t" |
"sall $24, %%edx \n\t" // make low byte, high byte |
"secondloop24: \n\t" |
"sall %%edx \n\t" // move high bit to CF |
"jnc skip24 \n\t" // if CF = 0 |
"movw (%%esi), %%ax \n\t" |
"movw %%ax, (%%edi) \n\t" |
"xorl %%eax, %%eax \n\t" |
"movb 2(%%esi), %%al \n\t" |
"movb %%al, 2(%%edi) \n\t" |
"skip24: \n\t" |
"addl $3, %%esi \n\t" |
"addl $3, %%edi \n\t" |
"decl %%ecx \n\t" |
"jnz secondloop24 \n\t" |
"end24: \n\t" |
"EMMS \n\t" // DONE |
: "=a" (dummy_value_a), // output regs (dummy) |
"=d" (dummy_value_d), |
"=c" (dummy_value_c), |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "3" (srcptr), // esi // input regs |
"4" (dstptr), // edi |
"0" (diff), // eax |
// was (unmask) "b" RESERVED // ebx // Global Offset Table idx |
"2" (len), // ecx |
"1" (mask) // edx |
#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm1", "%mm2" // clobber list |
, "%mm4", "%mm5", "%mm6", "%mm7" |
#endif |
); |
} |
else /* mmx _not supported - Use modified C routine */ |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
{ |
register png_uint_32 i; |
png_uint_32 initial_val = BPP3 * png_pass_start[png_ptr->pass]; |
/* png.c: png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */ |
register int stride = BPP3 * png_pass_inc[png_ptr->pass]; |
/* png.c: png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */ |
register int rep_bytes = BPP3 * png_pass_width[png_ptr->pass]; |
/* png.c: png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */ |
png_uint_32 len = png_ptr->width &~7; /* reduce to mult. of 8 */ |
int diff = (int) (png_ptr->width & 7); /* amount lost */ |
register png_uint_32 final_val = BPP3 * len; /* GRR bugfix */ |
srcptr = png_ptr->row_buf + 1 + initial_val; |
dstptr = row + initial_val; |
for (i = initial_val; i < final_val; i += stride) |
{ |
png_memcpy(dstptr, srcptr, rep_bytes); |
srcptr += stride; |
dstptr += stride; |
} |
if (diff) /* number of leftover pixels: 3 for pngtest */ |
{ |
final_val+=diff*BPP3; |
for (; i < final_val; i += stride) |
{ |
if (rep_bytes > (int)(final_val-i)) |
rep_bytes = (int)(final_val-i); |
png_memcpy(dstptr, srcptr, rep_bytes); |
srcptr += stride; |
dstptr += stride; |
} |
} |
} /* end of else (_mmx_supported) */ |
break; |
} /* end 24 bpp */ |
case 32: /* png_ptr->row_info.pixel_depth */ |
{ |
png_bytep srcptr; |
png_bytep dstptr; |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) |
#if !defined(PNG_1_0_X) |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) |
/* && _mmx_supported */ ) |
#else |
if (_mmx_supported) |
#endif |
{ |
png_uint_32 len; |
int diff; |
int dummy_value_a; // fix 'forbidden register spilled' error |
int dummy_value_d; |
int dummy_value_c; |
int dummy_value_S; |
int dummy_value_D; |
_unmask = ~mask; // global variable for -fPIC version |
srcptr = png_ptr->row_buf + 1; |
dstptr = row; |
len = png_ptr->width &~7; // reduce to multiple of 8 |
diff = (int) (png_ptr->width & 7); // amount lost // |
__asm__ __volatile__ ( |
"movd _unmask, %%mm7 \n\t" // load bit pattern |
"psubb %%mm6, %%mm6 \n\t" // zero mm6 |
"punpcklbw %%mm7, %%mm7 \n\t" |
"punpcklwd %%mm7, %%mm7 \n\t" |
"punpckldq %%mm7, %%mm7 \n\t" // fill reg with 8 masks |
"movq _mask32_0, %%mm0 \n\t" |
"movq _mask32_1, %%mm1 \n\t" |
"movq _mask32_2, %%mm2 \n\t" |
"movq _mask32_3, %%mm3 \n\t" |
"pand %%mm7, %%mm0 \n\t" |
"pand %%mm7, %%mm1 \n\t" |
"pand %%mm7, %%mm2 \n\t" |
"pand %%mm7, %%mm3 \n\t" |
"pcmpeqb %%mm6, %%mm0 \n\t" |
"pcmpeqb %%mm6, %%mm1 \n\t" |
"pcmpeqb %%mm6, %%mm2 \n\t" |
"pcmpeqb %%mm6, %%mm3 \n\t" |
// preload "movl len, %%ecx \n\t" // load length of line |
// preload "movl srcptr, %%esi \n\t" // load source |
// preload "movl dstptr, %%edi \n\t" // load dest |
"cmpl $0, %%ecx \n\t" // lcr |
"jz mainloop32end \n\t" |
"mainloop32: \n\t" |
"movq (%%esi), %%mm4 \n\t" |
"pand %%mm0, %%mm4 \n\t" |
"movq %%mm0, %%mm6 \n\t" |
"movq (%%edi), %%mm7 \n\t" |
"pandn %%mm7, %%mm6 \n\t" |
"por %%mm6, %%mm4 \n\t" |
"movq %%mm4, (%%edi) \n\t" |
"movq 8(%%esi), %%mm5 \n\t" |
"pand %%mm1, %%mm5 \n\t" |
"movq %%mm1, %%mm7 \n\t" |
"movq 8(%%edi), %%mm6 \n\t" |
"pandn %%mm6, %%mm7 \n\t" |
"por %%mm7, %%mm5 \n\t" |
"movq %%mm5, 8(%%edi) \n\t" |
"movq 16(%%esi), %%mm6 \n\t" |
"pand %%mm2, %%mm6 \n\t" |
"movq %%mm2, %%mm4 \n\t" |
"movq 16(%%edi), %%mm7 \n\t" |
"pandn %%mm7, %%mm4 \n\t" |
"por %%mm4, %%mm6 \n\t" |
"movq %%mm6, 16(%%edi) \n\t" |
"movq 24(%%esi), %%mm7 \n\t" |
"pand %%mm3, %%mm7 \n\t" |
"movq %%mm3, %%mm5 \n\t" |
"movq 24(%%edi), %%mm4 \n\t" |
"pandn %%mm4, %%mm5 \n\t" |
"por %%mm5, %%mm7 \n\t" |
"movq %%mm7, 24(%%edi) \n\t" |
"addl $32, %%esi \n\t" // inc by 32 bytes processed |
"addl $32, %%edi \n\t" |
"subl $8, %%ecx \n\t" // dec by 8 pixels processed |
"ja mainloop32 \n\t" |
"mainloop32end: \n\t" |
// preload "movl diff, %%ecx \n\t" // (diff is in eax) |
"movl %%eax, %%ecx \n\t" |
"cmpl $0, %%ecx \n\t" |
"jz end32 \n\t" |
// preload "movl mask, %%edx \n\t" |
"sall $24, %%edx \n\t" // low byte => high byte |
"secondloop32: \n\t" |
"sall %%edx \n\t" // move high bit to CF |
"jnc skip32 \n\t" // if CF = 0 |
"movl (%%esi), %%eax \n\t" |
"movl %%eax, (%%edi) \n\t" |
"skip32: \n\t" |
"addl $4, %%esi \n\t" |
"addl $4, %%edi \n\t" |
"decl %%ecx \n\t" |
"jnz secondloop32 \n\t" |
"end32: \n\t" |
"EMMS \n\t" // DONE |
: "=a" (dummy_value_a), // output regs (dummy) |
"=d" (dummy_value_d), |
"=c" (dummy_value_c), |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "3" (srcptr), // esi // input regs |
"4" (dstptr), // edi |
"0" (diff), // eax |
// was (unmask) "b" RESERVED // ebx // Global Offset Table idx |
"2" (len), // ecx |
"1" (mask) // edx |
#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm1", "%mm2", "%mm3" // clobber list |
, "%mm4", "%mm5", "%mm6", "%mm7" |
#endif |
); |
} |
else /* mmx _not supported - Use modified C routine */ |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
{ |
register png_uint_32 i; |
png_uint_32 initial_val = BPP4 * png_pass_start[png_ptr->pass]; |
/* png.c: png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */ |
register int stride = BPP4 * png_pass_inc[png_ptr->pass]; |
/* png.c: png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */ |
register int rep_bytes = BPP4 * png_pass_width[png_ptr->pass]; |
/* png.c: png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */ |
png_uint_32 len = png_ptr->width &~7; /* reduce to mult. of 8 */ |
int diff = (int) (png_ptr->width & 7); /* amount lost */ |
register png_uint_32 final_val = BPP4 * len; /* GRR bugfix */ |
srcptr = png_ptr->row_buf + 1 + initial_val; |
dstptr = row + initial_val; |
for (i = initial_val; i < final_val; i += stride) |
{ |
png_memcpy(dstptr, srcptr, rep_bytes); |
srcptr += stride; |
dstptr += stride; |
} |
if (diff) /* number of leftover pixels: 3 for pngtest */ |
{ |
final_val+=diff*BPP4; |
for (; i < final_val; i += stride) |
{ |
if (rep_bytes > (int)(final_val-i)) |
rep_bytes = (int)(final_val-i); |
png_memcpy(dstptr, srcptr, rep_bytes); |
srcptr += stride; |
dstptr += stride; |
} |
} |
} /* end of else (_mmx_supported) */ |
break; |
} /* end 32 bpp */ |
case 48: /* png_ptr->row_info.pixel_depth */ |
{ |
png_bytep srcptr; |
png_bytep dstptr; |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) |
#if !defined(PNG_1_0_X) |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) |
/* && _mmx_supported */ ) |
#else |
if (_mmx_supported) |
#endif |
{ |
png_uint_32 len; |
int diff; |
int dummy_value_a; // fix 'forbidden register spilled' error |
int dummy_value_d; |
int dummy_value_c; |
int dummy_value_S; |
int dummy_value_D; |
_unmask = ~mask; // global variable for -fPIC version |
srcptr = png_ptr->row_buf + 1; |
dstptr = row; |
len = png_ptr->width &~7; // reduce to multiple of 8 |
diff = (int) (png_ptr->width & 7); // amount lost // |
__asm__ __volatile__ ( |
"movd _unmask, %%mm7 \n\t" // load bit pattern |
"psubb %%mm6, %%mm6 \n\t" // zero mm6 |
"punpcklbw %%mm7, %%mm7 \n\t" |
"punpcklwd %%mm7, %%mm7 \n\t" |
"punpckldq %%mm7, %%mm7 \n\t" // fill reg with 8 masks |
"movq _mask48_0, %%mm0 \n\t" |
"movq _mask48_1, %%mm1 \n\t" |
"movq _mask48_2, %%mm2 \n\t" |
"movq _mask48_3, %%mm3 \n\t" |
"movq _mask48_4, %%mm4 \n\t" |
"movq _mask48_5, %%mm5 \n\t" |
"pand %%mm7, %%mm0 \n\t" |
"pand %%mm7, %%mm1 \n\t" |
"pand %%mm7, %%mm2 \n\t" |
"pand %%mm7, %%mm3 \n\t" |
"pand %%mm7, %%mm4 \n\t" |
"pand %%mm7, %%mm5 \n\t" |
"pcmpeqb %%mm6, %%mm0 \n\t" |
"pcmpeqb %%mm6, %%mm1 \n\t" |
"pcmpeqb %%mm6, %%mm2 \n\t" |
"pcmpeqb %%mm6, %%mm3 \n\t" |
"pcmpeqb %%mm6, %%mm4 \n\t" |
"pcmpeqb %%mm6, %%mm5 \n\t" |
// preload "movl len, %%ecx \n\t" // load length of line |
// preload "movl srcptr, %%esi \n\t" // load source |
// preload "movl dstptr, %%edi \n\t" // load dest |
"cmpl $0, %%ecx \n\t" |
"jz mainloop48end \n\t" |
"mainloop48: \n\t" |
"movq (%%esi), %%mm7 \n\t" |
"pand %%mm0, %%mm7 \n\t" |
"movq %%mm0, %%mm6 \n\t" |
"pandn (%%edi), %%mm6 \n\t" |
"por %%mm6, %%mm7 \n\t" |
"movq %%mm7, (%%edi) \n\t" |
"movq 8(%%esi), %%mm6 \n\t" |
"pand %%mm1, %%mm6 \n\t" |
"movq %%mm1, %%mm7 \n\t" |
"pandn 8(%%edi), %%mm7 \n\t" |
"por %%mm7, %%mm6 \n\t" |
"movq %%mm6, 8(%%edi) \n\t" |
"movq 16(%%esi), %%mm6 \n\t" |
"pand %%mm2, %%mm6 \n\t" |
"movq %%mm2, %%mm7 \n\t" |
"pandn 16(%%edi), %%mm7 \n\t" |
"por %%mm7, %%mm6 \n\t" |
"movq %%mm6, 16(%%edi) \n\t" |
"movq 24(%%esi), %%mm7 \n\t" |
"pand %%mm3, %%mm7 \n\t" |
"movq %%mm3, %%mm6 \n\t" |
"pandn 24(%%edi), %%mm6 \n\t" |
"por %%mm6, %%mm7 \n\t" |
"movq %%mm7, 24(%%edi) \n\t" |
"movq 32(%%esi), %%mm6 \n\t" |
"pand %%mm4, %%mm6 \n\t" |
"movq %%mm4, %%mm7 \n\t" |
"pandn 32(%%edi), %%mm7 \n\t" |
"por %%mm7, %%mm6 \n\t" |
"movq %%mm6, 32(%%edi) \n\t" |
"movq 40(%%esi), %%mm7 \n\t" |
"pand %%mm5, %%mm7 \n\t" |
"movq %%mm5, %%mm6 \n\t" |
"pandn 40(%%edi), %%mm6 \n\t" |
"por %%mm6, %%mm7 \n\t" |
"movq %%mm7, 40(%%edi) \n\t" |
"addl $48, %%esi \n\t" // inc by 48 bytes processed |
"addl $48, %%edi \n\t" |
"subl $8, %%ecx \n\t" // dec by 8 pixels processed |
"ja mainloop48 \n\t" |
"mainloop48end: \n\t" |
// preload "movl diff, %%ecx \n\t" // (diff is in eax) |
"movl %%eax, %%ecx \n\t" |
"cmpl $0, %%ecx \n\t" |
"jz end48 \n\t" |
// preload "movl mask, %%edx \n\t" |
"sall $24, %%edx \n\t" // make low byte, high byte |
"secondloop48: \n\t" |
"sall %%edx \n\t" // move high bit to CF |
"jnc skip48 \n\t" // if CF = 0 |
"movl (%%esi), %%eax \n\t" |
"movl %%eax, (%%edi) \n\t" |
"skip48: \n\t" |
"addl $4, %%esi \n\t" |
"addl $4, %%edi \n\t" |
"decl %%ecx \n\t" |
"jnz secondloop48 \n\t" |
"end48: \n\t" |
"EMMS \n\t" // DONE |
: "=a" (dummy_value_a), // output regs (dummy) |
"=d" (dummy_value_d), |
"=c" (dummy_value_c), |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "3" (srcptr), // esi // input regs |
"4" (dstptr), // edi |
"0" (diff), // eax |
// was (unmask) "b" RESERVED // ebx // Global Offset Table idx |
"2" (len), // ecx |
"1" (mask) // edx |
#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm1", "%mm2", "%mm3" // clobber list |
, "%mm4", "%mm5", "%mm6", "%mm7" |
#endif |
); |
} |
else /* mmx _not supported - Use modified C routine */ |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
{ |
register png_uint_32 i; |
png_uint_32 initial_val = BPP6 * png_pass_start[png_ptr->pass]; |
/* png.c: png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */ |
register int stride = BPP6 * png_pass_inc[png_ptr->pass]; |
/* png.c: png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */ |
register int rep_bytes = BPP6 * png_pass_width[png_ptr->pass]; |
/* png.c: png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */ |
png_uint_32 len = png_ptr->width &~7; /* reduce to mult. of 8 */ |
int diff = (int) (png_ptr->width & 7); /* amount lost */ |
register png_uint_32 final_val = BPP6 * len; /* GRR bugfix */ |
srcptr = png_ptr->row_buf + 1 + initial_val; |
dstptr = row + initial_val; |
for (i = initial_val; i < final_val; i += stride) |
{ |
png_memcpy(dstptr, srcptr, rep_bytes); |
srcptr += stride; |
dstptr += stride; |
} |
if (diff) /* number of leftover pixels: 3 for pngtest */ |
{ |
final_val+=diff*BPP6; |
for (; i < final_val; i += stride) |
{ |
if (rep_bytes > (int)(final_val-i)) |
rep_bytes = (int)(final_val-i); |
png_memcpy(dstptr, srcptr, rep_bytes); |
srcptr += stride; |
dstptr += stride; |
} |
} |
} /* end of else (_mmx_supported) */ |
break; |
} /* end 48 bpp */ |
case 64: /* png_ptr->row_info.pixel_depth */ |
{ |
png_bytep srcptr; |
png_bytep dstptr; |
register png_uint_32 i; |
png_uint_32 initial_val = BPP8 * png_pass_start[png_ptr->pass]; |
/* png.c: png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */ |
register int stride = BPP8 * png_pass_inc[png_ptr->pass]; |
/* png.c: png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */ |
register int rep_bytes = BPP8 * png_pass_width[png_ptr->pass]; |
/* png.c: png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */ |
png_uint_32 len = png_ptr->width &~7; /* reduce to mult. of 8 */ |
int diff = (int) (png_ptr->width & 7); /* amount lost */ |
register png_uint_32 final_val = BPP8 * len; /* GRR bugfix */ |
srcptr = png_ptr->row_buf + 1 + initial_val; |
dstptr = row + initial_val; |
for (i = initial_val; i < final_val; i += stride) |
{ |
png_memcpy(dstptr, srcptr, rep_bytes); |
srcptr += stride; |
dstptr += stride; |
} |
if (diff) /* number of leftover pixels: 3 for pngtest */ |
{ |
final_val+=diff*BPP8; |
for (; i < final_val; i += stride) |
{ |
if (rep_bytes > (int)(final_val-i)) |
rep_bytes = (int)(final_val-i); |
png_memcpy(dstptr, srcptr, rep_bytes); |
srcptr += stride; |
dstptr += stride; |
} |
} |
break; |
} /* end 64 bpp */ |
default: /* png_ptr->row_info.pixel_depth != 1,2,4,8,16,24,32,48,64 */ |
{ |
/* this should never happen */ |
png_warning(png_ptr, "Invalid row_info.pixel_depth in pnggccrd"); |
break; |
} |
} /* end switch (png_ptr->row_info.pixel_depth) */ |
} /* end if (non-trivial mask) */ |
} /* end png_combine_row() */ |
#endif /* PNG_HAVE_ASSEMBLER_COMBINE_ROW */ |
/*===========================================================================*/ |
/* */ |
/* P N G _ D O _ R E A D _ I N T E R L A C E */ |
/* */ |
/*===========================================================================*/ |
#if defined(PNG_READ_INTERLACING_SUPPORTED) |
#if defined(PNG_HAVE_ASSEMBLER_READ_INTERLACE) |
/* png_do_read_interlace() is called after any 16-bit to 8-bit conversion |
* has taken place. [GRR: what other steps come before and/or after?] |
*/ |
void /* PRIVATE */ |
png_do_read_interlace(png_structp png_ptr) |
{ |
png_row_infop row_info = &(png_ptr->row_info); |
png_bytep row = png_ptr->row_buf + 1; |
int pass = png_ptr->pass; |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
png_uint_32 transformations = png_ptr->transformations; |
#endif |
png_debug(1, "in png_do_read_interlace (pnggccrd.c)\n"); |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) |
if (_mmx_supported == 2) { |
#if !defined(PNG_1_0_X) |
/* this should have happened in png_init_mmx_flags() already */ |
png_warning(png_ptr, "asm_flags may not have been initialized"); |
#endif |
png_mmx_support(); |
} |
#endif |
if (row != NULL && row_info != NULL) |
{ |
png_uint_32 final_width; |
final_width = row_info->width * png_pass_inc[pass]; |
switch (row_info->pixel_depth) |
{ |
case 1: |
{ |
png_bytep sp, dp; |
int sshift, dshift; |
int s_start, s_end, s_inc; |
png_byte v; |
png_uint_32 i; |
int j; |
sp = row + (png_size_t)((row_info->width - 1) >> 3); |
dp = row + (png_size_t)((final_width - 1) >> 3); |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (transformations & PNG_PACKSWAP) |
{ |
sshift = (int)((row_info->width + 7) & 7); |
dshift = (int)((final_width + 7) & 7); |
s_start = 7; |
s_end = 0; |
s_inc = -1; |
} |
else |
#endif |
{ |
sshift = 7 - (int)((row_info->width + 7) & 7); |
dshift = 7 - (int)((final_width + 7) & 7); |
s_start = 0; |
s_end = 7; |
s_inc = 1; |
} |
for (i = row_info->width; i; i--) |
{ |
v = (png_byte)((*sp >> sshift) & 0x1); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
*dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff); |
*dp |= (png_byte)(v << dshift); |
if (dshift == s_end) |
{ |
dshift = s_start; |
dp--; |
} |
else |
dshift += s_inc; |
} |
if (sshift == s_end) |
{ |
sshift = s_start; |
sp--; |
} |
else |
sshift += s_inc; |
} |
break; |
} |
case 2: |
{ |
png_bytep sp, dp; |
int sshift, dshift; |
int s_start, s_end, s_inc; |
png_uint_32 i; |
sp = row + (png_size_t)((row_info->width - 1) >> 2); |
dp = row + (png_size_t)((final_width - 1) >> 2); |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (transformations & PNG_PACKSWAP) |
{ |
sshift = (png_size_t)(((row_info->width + 3) & 3) << 1); |
dshift = (png_size_t)(((final_width + 3) & 3) << 1); |
s_start = 6; |
s_end = 0; |
s_inc = -2; |
} |
else |
#endif |
{ |
sshift = (png_size_t)((3 - ((row_info->width + 3) & 3)) << 1); |
dshift = (png_size_t)((3 - ((final_width + 3) & 3)) << 1); |
s_start = 0; |
s_end = 6; |
s_inc = 2; |
} |
for (i = row_info->width; i; i--) |
{ |
png_byte v; |
int j; |
v = (png_byte)((*sp >> sshift) & 0x3); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
*dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff); |
*dp |= (png_byte)(v << dshift); |
if (dshift == s_end) |
{ |
dshift = s_start; |
dp--; |
} |
else |
dshift += s_inc; |
} |
if (sshift == s_end) |
{ |
sshift = s_start; |
sp--; |
} |
else |
sshift += s_inc; |
} |
break; |
} |
case 4: |
{ |
png_bytep sp, dp; |
int sshift, dshift; |
int s_start, s_end, s_inc; |
png_uint_32 i; |
sp = row + (png_size_t)((row_info->width - 1) >> 1); |
dp = row + (png_size_t)((final_width - 1) >> 1); |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (transformations & PNG_PACKSWAP) |
{ |
sshift = (png_size_t)(((row_info->width + 1) & 1) << 2); |
dshift = (png_size_t)(((final_width + 1) & 1) << 2); |
s_start = 4; |
s_end = 0; |
s_inc = -4; |
} |
else |
#endif |
{ |
sshift = (png_size_t)((1 - ((row_info->width + 1) & 1)) << 2); |
dshift = (png_size_t)((1 - ((final_width + 1) & 1)) << 2); |
s_start = 0; |
s_end = 4; |
s_inc = 4; |
} |
for (i = row_info->width; i; i--) |
{ |
png_byte v; |
int j; |
v = (png_byte)((*sp >> sshift) & 0xf); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
*dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff); |
*dp |= (png_byte)(v << dshift); |
if (dshift == s_end) |
{ |
dshift = s_start; |
dp--; |
} |
else |
dshift += s_inc; |
} |
if (sshift == s_end) |
{ |
sshift = s_start; |
sp--; |
} |
else |
sshift += s_inc; |
} |
break; |
} |
/*====================================================================*/ |
default: /* 8-bit or larger (this is where the routine is modified) */ |
{ |
#if 0 |
// static unsigned long long _const4 = 0x0000000000FFFFFFLL; no good |
// static unsigned long long const4 = 0x0000000000FFFFFFLL; no good |
// unsigned long long _const4 = 0x0000000000FFFFFFLL; no good |
// unsigned long long const4 = 0x0000000000FFFFFFLL; no good |
#endif |
png_bytep sptr, dp; |
png_uint_32 i; |
png_size_t pixel_bytes; |
int width = (int)row_info->width; |
pixel_bytes = (row_info->pixel_depth >> 3); |
/* point sptr at the last pixel in the pre-expanded row: */ |
sptr = row + (width - 1) * pixel_bytes; |
/* point dp at the last pixel position in the expanded row: */ |
dp = row + (final_width - 1) * pixel_bytes; |
/* New code by Nirav Chhatrapati - Intel Corporation */ |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) |
#if !defined(PNG_1_0_X) |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_INTERLACE) |
/* && _mmx_supported */ ) |
#else |
if (_mmx_supported) |
#endif |
{ |
//-------------------------------------------------------------- |
if (pixel_bytes == 3) |
{ |
if (((pass == 0) || (pass == 1)) && width) |
{ |
int dummy_value_c; // fix 'forbidden register spilled' |
int dummy_value_S; |
int dummy_value_D; |
__asm__ __volatile__ ( |
"subl $21, %%edi \n\t" |
// (png_pass_inc[pass] - 1)*pixel_bytes |
".loop3_pass0: \n\t" |
"movd (%%esi), %%mm0 \n\t" // x x x x x 2 1 0 |
"pand _const4, %%mm0 \n\t" // z z z z z 2 1 0 |
"movq %%mm0, %%mm1 \n\t" // z z z z z 2 1 0 |
"psllq $16, %%mm0 \n\t" // z z z 2 1 0 z z |
"movq %%mm0, %%mm2 \n\t" // z z z 2 1 0 z z |
"psllq $24, %%mm0 \n\t" // 2 1 0 z z z z z |
"psrlq $8, %%mm1 \n\t" // z z z z z z 2 1 |
"por %%mm2, %%mm0 \n\t" // 2 1 0 2 1 0 z z |
"por %%mm1, %%mm0 \n\t" // 2 1 0 2 1 0 2 1 |
"movq %%mm0, %%mm3 \n\t" // 2 1 0 2 1 0 2 1 |
"psllq $16, %%mm0 \n\t" // 0 2 1 0 2 1 z z |
"movq %%mm3, %%mm4 \n\t" // 2 1 0 2 1 0 2 1 |
"punpckhdq %%mm0, %%mm3 \n\t" // 0 2 1 0 2 1 0 2 |
"movq %%mm4, 16(%%edi) \n\t" |
"psrlq $32, %%mm0 \n\t" // z z z z 0 2 1 0 |
"movq %%mm3, 8(%%edi) \n\t" |
"punpckldq %%mm4, %%mm0 \n\t" // 1 0 2 1 0 2 1 0 |
"subl $3, %%esi \n\t" |
"movq %%mm0, (%%edi) \n\t" |
"subl $24, %%edi \n\t" |
"decl %%ecx \n\t" |
"jnz .loop3_pass0 \n\t" |
"EMMS \n\t" // DONE |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "1" (sptr), // esi // input regs |
"2" (dp), // edi |
"0" (width) // ecx |
// doesn't work "i" (0x0000000000FFFFFFLL) // %1 (a.k.a. _const4) |
#if 0 /* %mm0, ..., %mm4 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm1", "%mm2" // clobber list |
, "%mm3", "%mm4" |
#endif |
); |
} |
else if (((pass == 2) || (pass == 3)) && width) |
{ |
int dummy_value_c; // fix 'forbidden register spilled' |
int dummy_value_S; |
int dummy_value_D; |
__asm__ __volatile__ ( |
"subl $9, %%edi \n\t" |
// (png_pass_inc[pass] - 1)*pixel_bytes |
".loop3_pass2: \n\t" |
"movd (%%esi), %%mm0 \n\t" // x x x x x 2 1 0 |
"pand _const4, %%mm0 \n\t" // z z z z z 2 1 0 |
"movq %%mm0, %%mm1 \n\t" // z z z z z 2 1 0 |
"psllq $16, %%mm0 \n\t" // z z z 2 1 0 z z |
"movq %%mm0, %%mm2 \n\t" // z z z 2 1 0 z z |
"psllq $24, %%mm0 \n\t" // 2 1 0 z z z z z |
"psrlq $8, %%mm1 \n\t" // z z z z z z 2 1 |
"por %%mm2, %%mm0 \n\t" // 2 1 0 2 1 0 z z |
"por %%mm1, %%mm0 \n\t" // 2 1 0 2 1 0 2 1 |
"movq %%mm0, 4(%%edi) \n\t" |
"psrlq $16, %%mm0 \n\t" // z z 2 1 0 2 1 0 |
"subl $3, %%esi \n\t" |
"movd %%mm0, (%%edi) \n\t" |
"subl $12, %%edi \n\t" |
"decl %%ecx \n\t" |
"jnz .loop3_pass2 \n\t" |
"EMMS \n\t" // DONE |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "1" (sptr), // esi // input regs |
"2" (dp), // edi |
"0" (width) // ecx |
#if 0 /* %mm0, ..., %mm2 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm1", "%mm2" // clobber list |
#endif |
); |
} |
else if (width) /* && ((pass == 4) || (pass == 5)) */ |
{ |
int width_mmx = ((width >> 1) << 1) - 8; // GRR: huh? |
if (width_mmx < 0) |
width_mmx = 0; |
width -= width_mmx; // 8 or 9 pix, 24 or 27 bytes |
if (width_mmx) |
{ |
// png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; |
// sptr points at last pixel in pre-expanded row |
// dp points at last pixel position in expanded row |
int dummy_value_c; // fix 'forbidden register spilled' |
int dummy_value_S; |
int dummy_value_D; |
__asm__ __volatile__ ( |
"subl $3, %%esi \n\t" |
"subl $9, %%edi \n\t" |
// (png_pass_inc[pass] + 1)*pixel_bytes |
".loop3_pass4: \n\t" |
"movq (%%esi), %%mm0 \n\t" // x x 5 4 3 2 1 0 |
"movq %%mm0, %%mm1 \n\t" // x x 5 4 3 2 1 0 |
"movq %%mm0, %%mm2 \n\t" // x x 5 4 3 2 1 0 |
"psllq $24, %%mm0 \n\t" // 4 3 2 1 0 z z z |
"pand _const4, %%mm1 \n\t" // z z z z z 2 1 0 |
"psrlq $24, %%mm2 \n\t" // z z z x x 5 4 3 |
"por %%mm1, %%mm0 \n\t" // 4 3 2 1 0 2 1 0 |
"movq %%mm2, %%mm3 \n\t" // z z z x x 5 4 3 |
"psllq $8, %%mm2 \n\t" // z z x x 5 4 3 z |
"movq %%mm0, (%%edi) \n\t" |
"psrlq $16, %%mm3 \n\t" // z z z z z x x 5 |
"pand _const6, %%mm3 \n\t" // z z z z z z z 5 |
"por %%mm3, %%mm2 \n\t" // z z x x 5 4 3 5 |
"subl $6, %%esi \n\t" |
"movd %%mm2, 8(%%edi) \n\t" |
"subl $12, %%edi \n\t" |
"subl $2, %%ecx \n\t" |
"jnz .loop3_pass4 \n\t" |
"EMMS \n\t" // DONE |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "1" (sptr), // esi // input regs |
"2" (dp), // edi |
"0" (width_mmx) // ecx |
#if 0 /* %mm0, ..., %mm3 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm1" // clobber list |
, "%mm2", "%mm3" |
#endif |
); |
} |
sptr -= width_mmx*3; |
dp -= width_mmx*6; |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, 3); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, 3); |
dp -= 3; |
} |
sptr -= 3; |
} |
} |
} /* end of pixel_bytes == 3 */ |
//-------------------------------------------------------------- |
else if (pixel_bytes == 1) |
{ |
if (((pass == 0) || (pass == 1)) && width) |
{ |
int width_mmx = ((width >> 2) << 2); |
width -= width_mmx; // 0-3 pixels => 0-3 bytes |
if (width_mmx) |
{ |
int dummy_value_c; // fix 'forbidden register spilled' |
int dummy_value_S; |
int dummy_value_D; |
__asm__ __volatile__ ( |
"subl $3, %%esi \n\t" |
"subl $31, %%edi \n\t" |
".loop1_pass0: \n\t" |
"movd (%%esi), %%mm0 \n\t" // x x x x 3 2 1 0 |
"movq %%mm0, %%mm1 \n\t" // x x x x 3 2 1 0 |
"punpcklbw %%mm0, %%mm0 \n\t" // 3 3 2 2 1 1 0 0 |
"movq %%mm0, %%mm2 \n\t" // 3 3 2 2 1 1 0 0 |
"punpcklwd %%mm0, %%mm0 \n\t" // 1 1 1 1 0 0 0 0 |
"movq %%mm0, %%mm3 \n\t" // 1 1 1 1 0 0 0 0 |
"punpckldq %%mm0, %%mm0 \n\t" // 0 0 0 0 0 0 0 0 |
"punpckhdq %%mm3, %%mm3 \n\t" // 1 1 1 1 1 1 1 1 |
"movq %%mm0, (%%edi) \n\t" |
"punpckhwd %%mm2, %%mm2 \n\t" // 3 3 3 3 2 2 2 2 |
"movq %%mm3, 8(%%edi) \n\t" |
"movq %%mm2, %%mm4 \n\t" // 3 3 3 3 2 2 2 2 |
"punpckldq %%mm2, %%mm2 \n\t" // 2 2 2 2 2 2 2 2 |
"punpckhdq %%mm4, %%mm4 \n\t" // 3 3 3 3 3 3 3 3 |
"movq %%mm2, 16(%%edi) \n\t" |
"subl $4, %%esi \n\t" |
"movq %%mm4, 24(%%edi) \n\t" |
"subl $32, %%edi \n\t" |
"subl $4, %%ecx \n\t" |
"jnz .loop1_pass0 \n\t" |
"EMMS \n\t" // DONE |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "1" (sptr), // esi // input regs |
"2" (dp), // edi |
"0" (width_mmx) // ecx |
#if 0 /* %mm0, ..., %mm4 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm1", "%mm2" // clobber list |
, "%mm3", "%mm4" |
#endif |
); |
} |
sptr -= width_mmx; |
dp -= width_mmx*8; |
for (i = width; i; i--) |
{ |
int j; |
/* I simplified this part in version 1.0.4e |
* here and in several other instances where |
* pixel_bytes == 1 -- GR-P |
* |
* Original code: |
* |
* png_byte v[8]; |
* png_memcpy(v, sptr, pixel_bytes); |
* for (j = 0; j < png_pass_inc[pass]; j++) |
* { |
* png_memcpy(dp, v, pixel_bytes); |
* dp -= pixel_bytes; |
* } |
* sptr -= pixel_bytes; |
* |
* Replacement code is in the next three lines: |
*/ |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
*dp-- = *sptr; |
} |
--sptr; |
} |
} |
else if (((pass == 2) || (pass == 3)) && width) |
{ |
int width_mmx = ((width >> 2) << 2); |
width -= width_mmx; // 0-3 pixels => 0-3 bytes |
if (width_mmx) |
{ |
int dummy_value_c; // fix 'forbidden register spilled' |
int dummy_value_S; |
int dummy_value_D; |
__asm__ __volatile__ ( |
"subl $3, %%esi \n\t" |
"subl $15, %%edi \n\t" |
".loop1_pass2: \n\t" |
"movd (%%esi), %%mm0 \n\t" // x x x x 3 2 1 0 |
"punpcklbw %%mm0, %%mm0 \n\t" // 3 3 2 2 1 1 0 0 |
"movq %%mm0, %%mm1 \n\t" // 3 3 2 2 1 1 0 0 |
"punpcklwd %%mm0, %%mm0 \n\t" // 1 1 1 1 0 0 0 0 |
"punpckhwd %%mm1, %%mm1 \n\t" // 3 3 3 3 2 2 2 2 |
"movq %%mm0, (%%edi) \n\t" |
"subl $4, %%esi \n\t" |
"movq %%mm1, 8(%%edi) \n\t" |
"subl $16, %%edi \n\t" |
"subl $4, %%ecx \n\t" |
"jnz .loop1_pass2 \n\t" |
"EMMS \n\t" // DONE |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "1" (sptr), // esi // input regs |
"2" (dp), // edi |
"0" (width_mmx) // ecx |
#if 0 /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm1" // clobber list |
#endif |
); |
} |
sptr -= width_mmx; |
dp -= width_mmx*4; |
for (i = width; i; i--) |
{ |
int j; |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
*dp-- = *sptr; |
} |
--sptr; |
} |
} |
else if (width) /* && ((pass == 4) || (pass == 5)) */ |
{ |
int width_mmx = ((width >> 3) << 3); |
width -= width_mmx; // 0-3 pixels => 0-3 bytes |
if (width_mmx) |
{ |
int dummy_value_c; // fix 'forbidden register spilled' |
int dummy_value_S; |
int dummy_value_D; |
__asm__ __volatile__ ( |
"subl $7, %%esi \n\t" |
"subl $15, %%edi \n\t" |
".loop1_pass4: \n\t" |
"movq (%%esi), %%mm0 \n\t" // 7 6 5 4 3 2 1 0 |
"movq %%mm0, %%mm1 \n\t" // 7 6 5 4 3 2 1 0 |
"punpcklbw %%mm0, %%mm0 \n\t" // 3 3 2 2 1 1 0 0 |
"punpckhbw %%mm1, %%mm1 \n\t" // 7 7 6 6 5 5 4 4 |
"movq %%mm1, 8(%%edi) \n\t" |
"subl $8, %%esi \n\t" |
"movq %%mm0, (%%edi) \n\t" |
"subl $16, %%edi \n\t" |
"subl $8, %%ecx \n\t" |
"jnz .loop1_pass4 \n\t" |
"EMMS \n\t" // DONE |
: "=c" (dummy_value_c), // output regs (none) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "1" (sptr), // esi // input regs |
"2" (dp), // edi |
"0" (width_mmx) // ecx |
#if 0 /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm1" // clobber list |
#endif |
); |
} |
sptr -= width_mmx; |
dp -= width_mmx*2; |
for (i = width; i; i--) |
{ |
int j; |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
*dp-- = *sptr; |
} |
--sptr; |
} |
} |
} /* end of pixel_bytes == 1 */ |
//-------------------------------------------------------------- |
else if (pixel_bytes == 2) |
{ |
if (((pass == 0) || (pass == 1)) && width) |
{ |
int width_mmx = ((width >> 1) << 1); |
width -= width_mmx; // 0,1 pixels => 0,2 bytes |
if (width_mmx) |
{ |
int dummy_value_c; // fix 'forbidden register spilled' |
int dummy_value_S; |
int dummy_value_D; |
__asm__ __volatile__ ( |
"subl $2, %%esi \n\t" |
"subl $30, %%edi \n\t" |
".loop2_pass0: \n\t" |
"movd (%%esi), %%mm0 \n\t" // x x x x 3 2 1 0 |
"punpcklwd %%mm0, %%mm0 \n\t" // 3 2 3 2 1 0 1 0 |
"movq %%mm0, %%mm1 \n\t" // 3 2 3 2 1 0 1 0 |
"punpckldq %%mm0, %%mm0 \n\t" // 1 0 1 0 1 0 1 0 |
"punpckhdq %%mm1, %%mm1 \n\t" // 3 2 3 2 3 2 3 2 |
"movq %%mm0, (%%edi) \n\t" |
"movq %%mm0, 8(%%edi) \n\t" |
"movq %%mm1, 16(%%edi) \n\t" |
"subl $4, %%esi \n\t" |
"movq %%mm1, 24(%%edi) \n\t" |
"subl $32, %%edi \n\t" |
"subl $2, %%ecx \n\t" |
"jnz .loop2_pass0 \n\t" |
"EMMS \n\t" // DONE |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "1" (sptr), // esi // input regs |
"2" (dp), // edi |
"0" (width_mmx) // ecx |
#if 0 /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm1" // clobber list |
#endif |
); |
} |
sptr -= (width_mmx*2 - 2); // sign fixed |
dp -= (width_mmx*16 - 2); // sign fixed |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
sptr -= 2; |
png_memcpy(v, sptr, 2); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
dp -= 2; |
png_memcpy(dp, v, 2); |
} |
} |
} |
else if (((pass == 2) || (pass == 3)) && width) |
{ |
int width_mmx = ((width >> 1) << 1) ; |
width -= width_mmx; // 0,1 pixels => 0,2 bytes |
if (width_mmx) |
{ |
int dummy_value_c; // fix 'forbidden register spilled' |
int dummy_value_S; |
int dummy_value_D; |
__asm__ __volatile__ ( |
"subl $2, %%esi \n\t" |
"subl $14, %%edi \n\t" |
".loop2_pass2: \n\t" |
"movd (%%esi), %%mm0 \n\t" // x x x x 3 2 1 0 |
"punpcklwd %%mm0, %%mm0 \n\t" // 3 2 3 2 1 0 1 0 |
"movq %%mm0, %%mm1 \n\t" // 3 2 3 2 1 0 1 0 |
"punpckldq %%mm0, %%mm0 \n\t" // 1 0 1 0 1 0 1 0 |
"punpckhdq %%mm1, %%mm1 \n\t" // 3 2 3 2 3 2 3 2 |
"movq %%mm0, (%%edi) \n\t" |
"subl $4, %%esi \n\t" |
"movq %%mm1, 8(%%edi) \n\t" |
"subl $16, %%edi \n\t" |
"subl $2, %%ecx \n\t" |
"jnz .loop2_pass2 \n\t" |
"EMMS \n\t" // DONE |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "1" (sptr), // esi // input regs |
"2" (dp), // edi |
"0" (width_mmx) // ecx |
#if 0 /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm1" // clobber list |
#endif |
); |
} |
sptr -= (width_mmx*2 - 2); // sign fixed |
dp -= (width_mmx*8 - 2); // sign fixed |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
sptr -= 2; |
png_memcpy(v, sptr, 2); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
dp -= 2; |
png_memcpy(dp, v, 2); |
} |
} |
} |
else if (width) // pass == 4 or 5 |
{ |
int width_mmx = ((width >> 1) << 1) ; |
width -= width_mmx; // 0,1 pixels => 0,2 bytes |
if (width_mmx) |
{ |
int dummy_value_c; // fix 'forbidden register spilled' |
int dummy_value_S; |
int dummy_value_D; |
__asm__ __volatile__ ( |
"subl $2, %%esi \n\t" |
"subl $6, %%edi \n\t" |
".loop2_pass4: \n\t" |
"movd (%%esi), %%mm0 \n\t" // x x x x 3 2 1 0 |
"punpcklwd %%mm0, %%mm0 \n\t" // 3 2 3 2 1 0 1 0 |
"subl $4, %%esi \n\t" |
"movq %%mm0, (%%edi) \n\t" |
"subl $8, %%edi \n\t" |
"subl $2, %%ecx \n\t" |
"jnz .loop2_pass4 \n\t" |
"EMMS \n\t" // DONE |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "1" (sptr), // esi // input regs |
"2" (dp), // edi |
"0" (width_mmx) // ecx |
#if 0 /* %mm0 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0" // clobber list |
#endif |
); |
} |
sptr -= (width_mmx*2 - 2); // sign fixed |
dp -= (width_mmx*4 - 2); // sign fixed |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
sptr -= 2; |
png_memcpy(v, sptr, 2); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
dp -= 2; |
png_memcpy(dp, v, 2); |
} |
} |
} |
} /* end of pixel_bytes == 2 */ |
//-------------------------------------------------------------- |
else if (pixel_bytes == 4) |
{ |
if (((pass == 0) || (pass == 1)) && width) |
{ |
int width_mmx = ((width >> 1) << 1); |
width -= width_mmx; // 0,1 pixels => 0,4 bytes |
if (width_mmx) |
{ |
int dummy_value_c; // fix 'forbidden register spilled' |
int dummy_value_S; |
int dummy_value_D; |
__asm__ __volatile__ ( |
"subl $4, %%esi \n\t" |
"subl $60, %%edi \n\t" |
".loop4_pass0: \n\t" |
"movq (%%esi), %%mm0 \n\t" // 7 6 5 4 3 2 1 0 |
"movq %%mm0, %%mm1 \n\t" // 7 6 5 4 3 2 1 0 |
"punpckldq %%mm0, %%mm0 \n\t" // 3 2 1 0 3 2 1 0 |
"punpckhdq %%mm1, %%mm1 \n\t" // 7 6 5 4 7 6 5 4 |
"movq %%mm0, (%%edi) \n\t" |
"movq %%mm0, 8(%%edi) \n\t" |
"movq %%mm0, 16(%%edi) \n\t" |
"movq %%mm0, 24(%%edi) \n\t" |
"movq %%mm1, 32(%%edi) \n\t" |
"movq %%mm1, 40(%%edi) \n\t" |
"movq %%mm1, 48(%%edi) \n\t" |
"subl $8, %%esi \n\t" |
"movq %%mm1, 56(%%edi) \n\t" |
"subl $64, %%edi \n\t" |
"subl $2, %%ecx \n\t" |
"jnz .loop4_pass0 \n\t" |
"EMMS \n\t" // DONE |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "1" (sptr), // esi // input regs |
"2" (dp), // edi |
"0" (width_mmx) // ecx |
#if 0 /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm1" // clobber list |
#endif |
); |
} |
sptr -= (width_mmx*4 - 4); // sign fixed |
dp -= (width_mmx*32 - 4); // sign fixed |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
sptr -= 4; |
png_memcpy(v, sptr, 4); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
dp -= 4; |
png_memcpy(dp, v, 4); |
} |
} |
} |
else if (((pass == 2) || (pass == 3)) && width) |
{ |
int width_mmx = ((width >> 1) << 1); |
width -= width_mmx; // 0,1 pixels => 0,4 bytes |
if (width_mmx) |
{ |
int dummy_value_c; // fix 'forbidden register spilled' |
int dummy_value_S; |
int dummy_value_D; |
__asm__ __volatile__ ( |
"subl $4, %%esi \n\t" |
"subl $28, %%edi \n\t" |
".loop4_pass2: \n\t" |
"movq (%%esi), %%mm0 \n\t" // 7 6 5 4 3 2 1 0 |
"movq %%mm0, %%mm1 \n\t" // 7 6 5 4 3 2 1 0 |
"punpckldq %%mm0, %%mm0 \n\t" // 3 2 1 0 3 2 1 0 |
"punpckhdq %%mm1, %%mm1 \n\t" // 7 6 5 4 7 6 5 4 |
"movq %%mm0, (%%edi) \n\t" |
"movq %%mm0, 8(%%edi) \n\t" |
"movq %%mm1, 16(%%edi) \n\t" |
"movq %%mm1, 24(%%edi) \n\t" |
"subl $8, %%esi \n\t" |
"subl $32, %%edi \n\t" |
"subl $2, %%ecx \n\t" |
"jnz .loop4_pass2 \n\t" |
"EMMS \n\t" // DONE |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "1" (sptr), // esi // input regs |
"2" (dp), // edi |
"0" (width_mmx) // ecx |
#if 0 /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm1" // clobber list |
#endif |
); |
} |
sptr -= (width_mmx*4 - 4); // sign fixed |
dp -= (width_mmx*16 - 4); // sign fixed |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
sptr -= 4; |
png_memcpy(v, sptr, 4); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
dp -= 4; |
png_memcpy(dp, v, 4); |
} |
} |
} |
else if (width) // pass == 4 or 5 |
{ |
int width_mmx = ((width >> 1) << 1) ; |
width -= width_mmx; // 0,1 pixels => 0,4 bytes |
if (width_mmx) |
{ |
int dummy_value_c; // fix 'forbidden register spilled' |
int dummy_value_S; |
int dummy_value_D; |
__asm__ __volatile__ ( |
"subl $4, %%esi \n\t" |
"subl $12, %%edi \n\t" |
".loop4_pass4: \n\t" |
"movq (%%esi), %%mm0 \n\t" // 7 6 5 4 3 2 1 0 |
"movq %%mm0, %%mm1 \n\t" // 7 6 5 4 3 2 1 0 |
"punpckldq %%mm0, %%mm0 \n\t" // 3 2 1 0 3 2 1 0 |
"punpckhdq %%mm1, %%mm1 \n\t" // 7 6 5 4 7 6 5 4 |
"movq %%mm0, (%%edi) \n\t" |
"subl $8, %%esi \n\t" |
"movq %%mm1, 8(%%edi) \n\t" |
"subl $16, %%edi \n\t" |
"subl $2, %%ecx \n\t" |
"jnz .loop4_pass4 \n\t" |
"EMMS \n\t" // DONE |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "1" (sptr), // esi // input regs |
"2" (dp), // edi |
"0" (width_mmx) // ecx |
#if 0 /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm1" // clobber list |
#endif |
); |
} |
sptr -= (width_mmx*4 - 4); // sign fixed |
dp -= (width_mmx*8 - 4); // sign fixed |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
sptr -= 4; |
png_memcpy(v, sptr, 4); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
dp -= 4; |
png_memcpy(dp, v, 4); |
} |
} |
} |
} /* end of pixel_bytes == 4 */ |
//-------------------------------------------------------------- |
else if (pixel_bytes == 8) |
{ |
// GRR TEST: should work, but needs testing (special 64-bit version of rpng2?) |
// GRR NOTE: no need to combine passes here! |
if (((pass == 0) || (pass == 1)) && width) |
{ |
int dummy_value_c; // fix 'forbidden register spilled' |
int dummy_value_S; |
int dummy_value_D; |
// source is 8-byte RRGGBBAA |
// dest is 64-byte RRGGBBAA RRGGBBAA RRGGBBAA RRGGBBAA ... |
__asm__ __volatile__ ( |
"subl $56, %%edi \n\t" // start of last block |
".loop8_pass0: \n\t" |
"movq (%%esi), %%mm0 \n\t" // 7 6 5 4 3 2 1 0 |
"movq %%mm0, (%%edi) \n\t" |
"movq %%mm0, 8(%%edi) \n\t" |
"movq %%mm0, 16(%%edi) \n\t" |
"movq %%mm0, 24(%%edi) \n\t" |
"movq %%mm0, 32(%%edi) \n\t" |
"movq %%mm0, 40(%%edi) \n\t" |
"movq %%mm0, 48(%%edi) \n\t" |
"subl $8, %%esi \n\t" |
"movq %%mm0, 56(%%edi) \n\t" |
"subl $64, %%edi \n\t" |
"decl %%ecx \n\t" |
"jnz .loop8_pass0 \n\t" |
"EMMS \n\t" // DONE |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "1" (sptr), // esi // input regs |
"2" (dp), // edi |
"0" (width) // ecx |
#if 0 /* %mm0 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0" // clobber list |
#endif |
); |
} |
else if (((pass == 2) || (pass == 3)) && width) |
{ |
// source is 8-byte RRGGBBAA |
// dest is 32-byte RRGGBBAA RRGGBBAA RRGGBBAA RRGGBBAA |
// (recall that expansion is _in place_: sptr and dp |
// both point at locations within same row buffer) |
{ |
int dummy_value_c; // fix 'forbidden register spilled' |
int dummy_value_S; |
int dummy_value_D; |
__asm__ __volatile__ ( |
"subl $24, %%edi \n\t" // start of last block |
".loop8_pass2: \n\t" |
"movq (%%esi), %%mm0 \n\t" // 7 6 5 4 3 2 1 0 |
"movq %%mm0, (%%edi) \n\t" |
"movq %%mm0, 8(%%edi) \n\t" |
"movq %%mm0, 16(%%edi) \n\t" |
"subl $8, %%esi \n\t" |
"movq %%mm0, 24(%%edi) \n\t" |
"subl $32, %%edi \n\t" |
"decl %%ecx \n\t" |
"jnz .loop8_pass2 \n\t" |
"EMMS \n\t" // DONE |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "1" (sptr), // esi // input regs |
"2" (dp), // edi |
"0" (width) // ecx |
#if 0 /* %mm0 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0" // clobber list |
#endif |
); |
} |
} |
else if (width) // pass == 4 or 5 |
{ |
// source is 8-byte RRGGBBAA |
// dest is 16-byte RRGGBBAA RRGGBBAA |
{ |
int dummy_value_c; // fix 'forbidden register spilled' |
int dummy_value_S; |
int dummy_value_D; |
__asm__ __volatile__ ( |
"subl $8, %%edi \n\t" // start of last block |
".loop8_pass4: \n\t" |
"movq (%%esi), %%mm0 \n\t" // 7 6 5 4 3 2 1 0 |
"movq %%mm0, (%%edi) \n\t" |
"subl $8, %%esi \n\t" |
"movq %%mm0, 8(%%edi) \n\t" |
"subl $16, %%edi \n\t" |
"decl %%ecx \n\t" |
"jnz .loop8_pass4 \n\t" |
"EMMS \n\t" // DONE |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "1" (sptr), // esi // input regs |
"2" (dp), // edi |
"0" (width) // ecx |
#if 0 /* %mm0 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0" // clobber list |
#endif |
); |
} |
} |
} /* end of pixel_bytes == 8 */ |
//-------------------------------------------------------------- |
else if (pixel_bytes == 6) |
{ |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, 6); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, 6); |
dp -= 6; |
} |
sptr -= 6; |
} |
} /* end of pixel_bytes == 6 */ |
//-------------------------------------------------------------- |
else |
{ |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, pixel_bytes); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, pixel_bytes); |
dp -= pixel_bytes; |
} |
sptr-= pixel_bytes; |
} |
} |
} // end of _mmx_supported ======================================== |
else /* MMX not supported: use modified C code - takes advantage |
* of inlining of png_memcpy for a constant */ |
/* GRR 19991007: does it? or should pixel_bytes in each |
* block be replaced with immediate value (e.g., 1)? */ |
/* GRR 19991017: replaced with constants in each case */ |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
{ |
if (pixel_bytes == 1) |
{ |
for (i = width; i; i--) |
{ |
int j; |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
*dp-- = *sptr; |
} |
--sptr; |
} |
} |
else if (pixel_bytes == 3) |
{ |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, 3); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, 3); |
dp -= 3; |
} |
sptr -= 3; |
} |
} |
else if (pixel_bytes == 2) |
{ |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, 2); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, 2); |
dp -= 2; |
} |
sptr -= 2; |
} |
} |
else if (pixel_bytes == 4) |
{ |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, 4); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
#ifdef PNG_DEBUG |
if (dp < row || dp+3 > row+png_ptr->row_buf_size) |
{ |
printf("dp out of bounds: row=%d, dp=%d, rp=%d\n", |
row, dp, row+png_ptr->row_buf_size); |
printf("row_buf=%d\n",png_ptr->row_buf_size); |
} |
#endif |
png_memcpy(dp, v, 4); |
dp -= 4; |
} |
sptr -= 4; |
} |
} |
else if (pixel_bytes == 6) |
{ |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, 6); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, 6); |
dp -= 6; |
} |
sptr -= 6; |
} |
} |
else if (pixel_bytes == 8) |
{ |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, 8); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, 8); |
dp -= 8; |
} |
sptr -= 8; |
} |
} |
else /* GRR: should never be reached */ |
{ |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, pixel_bytes); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, pixel_bytes); |
dp -= pixel_bytes; |
} |
sptr -= pixel_bytes; |
} |
} |
} /* end if (MMX not supported) */ |
break; |
} |
} /* end switch (row_info->pixel_depth) */ |
row_info->width = final_width; |
row_info->rowbytes = ((final_width * |
(png_uint_32)row_info->pixel_depth + 7) >> 3); |
} |
} /* end png_do_read_interlace() */ |
#endif /* PNG_HAVE_ASSEMBLER_READ_INTERLACE */ |
#endif /* PNG_READ_INTERLACING_SUPPORTED */ |
#if defined(PNG_HAVE_ASSEMBLER_READ_FILTER_ROW) |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) |
// These variables are utilized in the functions below. They are declared |
// globally here to ensure alignment on 8-byte boundaries. |
union uAll { |
long long use; |
double align; |
} _LBCarryMask = {0x0101010101010101LL}, |
_HBClearMask = {0x7f7f7f7f7f7f7f7fLL}, |
_ActiveMask, _ActiveMask2, _ActiveMaskEnd, _ShiftBpp, _ShiftRem; |
#ifdef PNG_THREAD_UNSAFE_OK |
//===========================================================================// |
// // |
// P N G _ R E A D _ F I L T E R _ R O W _ M M X _ A V G // |
// // |
//===========================================================================// |
// Optimized code for PNG Average filter decoder |
static void /* PRIVATE */ |
png_read_filter_row_mmx_avg(png_row_infop row_info, png_bytep row, |
png_bytep prev_row) |
{ |
int bpp; |
int dummy_value_c; // fix 'forbidden register 2 (cx) was spilled' error |
int dummy_value_S; |
int dummy_value_D; |
bpp = (row_info->pixel_depth + 7) >> 3; // get # bytes per pixel |
_FullLength = row_info->rowbytes; // # of bytes to filter |
__asm__ __volatile__ ( |
// initialize address pointers and offset |
#ifdef __PIC__ |
"pushl %%ebx \n\t" // save index to Global Offset Table |
#endif |
//pre "movl row, %%edi \n\t" // edi: Avg(x) |
"xorl %%ebx, %%ebx \n\t" // ebx: x |
"movl %%edi, %%edx \n\t" |
//pre "movl prev_row, %%esi \n\t" // esi: Prior(x) |
//pre "subl bpp, %%edx \n\t" // (bpp is preloaded into ecx) |
"subl %%ecx, %%edx \n\t" // edx: Raw(x-bpp) |
"xorl %%eax,%%eax \n\t" |
// Compute the Raw value for the first bpp bytes |
// Raw(x) = Avg(x) + (Prior(x)/2) |
"avg_rlp: \n\t" |
"movb (%%esi,%%ebx,),%%al \n\t" // load al with Prior(x) |
"incl %%ebx \n\t" |
"shrb %%al \n\t" // divide by 2 |
"addb -1(%%edi,%%ebx,),%%al \n\t" // add Avg(x); -1 to offset inc ebx |
//pre "cmpl bpp, %%ebx \n\t" // (bpp is preloaded into ecx) |
"cmpl %%ecx, %%ebx \n\t" |
"movb %%al,-1(%%edi,%%ebx,) \n\t" // write Raw(x); -1 to offset inc ebx |
"jb avg_rlp \n\t" // mov does not affect flags |
// get # of bytes to alignment |
"movl %%edi, _dif \n\t" // take start of row |
"addl %%ebx, _dif \n\t" // add bpp |
"addl $0xf, _dif \n\t" // add 7+8 to incr past alignment bdry |
"andl $0xfffffff8, _dif \n\t" // mask to alignment boundary |
"subl %%edi, _dif \n\t" // subtract from start => value ebx at |
"jz avg_go \n\t" // alignment |
// fix alignment |
// Compute the Raw value for the bytes up to the alignment boundary |
// Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2) |
"xorl %%ecx, %%ecx \n\t" |
"avg_lp1: \n\t" |
"xorl %%eax, %%eax \n\t" |
"movb (%%esi,%%ebx,), %%cl \n\t" // load cl with Prior(x) |
"movb (%%edx,%%ebx,), %%al \n\t" // load al with Raw(x-bpp) |
"addw %%cx, %%ax \n\t" |
"incl %%ebx \n\t" |
"shrw %%ax \n\t" // divide by 2 |
"addb -1(%%edi,%%ebx,), %%al \n\t" // add Avg(x); -1 to offset inc ebx |
"cmpl _dif, %%ebx \n\t" // check if at alignment boundary |
"movb %%al, -1(%%edi,%%ebx,) \n\t" // write Raw(x); -1 to offset inc ebx |
"jb avg_lp1 \n\t" // repeat until at alignment boundary |
"avg_go: \n\t" |
"movl _FullLength, %%eax \n\t" |
"movl %%eax, %%ecx \n\t" |
"subl %%ebx, %%eax \n\t" // subtract alignment fix |
"andl $0x00000007, %%eax \n\t" // calc bytes over mult of 8 |
"subl %%eax, %%ecx \n\t" // drop over bytes from original length |
"movl %%ecx, _MMXLength \n\t" |
#ifdef __PIC__ |
"popl %%ebx \n\t" // restore index to Global Offset Table |
#endif |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "0" (bpp), // ecx // input regs |
"1" (prev_row), // esi |
"2" (row) // edi |
: "%eax", "%edx" // clobber list |
#ifndef __PIC__ |
, "%ebx" |
#endif |
// GRR: INCLUDE "memory" as clobbered? (_dif, _MMXLength) |
// (seems to work fine without...) |
); |
// now do the math for the rest of the row |
switch (bpp) |
{ |
case 3: |
{ |
_ActiveMask.use = 0x0000000000ffffffLL; |
_ShiftBpp.use = 24; // == 3 * 8 |
_ShiftRem.use = 40; // == 64 - 24 |
__asm__ __volatile__ ( |
// re-init address pointers and offset |
"movq _ActiveMask, %%mm7 \n\t" |
"movl _dif, %%ecx \n\t" // ecx: x = offset to |
"movq _LBCarryMask, %%mm5 \n\t" // alignment boundary |
// preload "movl row, %%edi \n\t" // edi: Avg(x) |
"movq _HBClearMask, %%mm4 \n\t" |
// preload "movl prev_row, %%esi \n\t" // esi: Prior(x) |
// prime the pump: load the first Raw(x-bpp) data set |
"movq -8(%%edi,%%ecx,), %%mm2 \n\t" // load previous aligned 8 bytes |
// (correct pos. in loop below) |
"avg_3lp: \n\t" |
"movq (%%edi,%%ecx,), %%mm0 \n\t" // load mm0 with Avg(x) |
"movq %%mm5, %%mm3 \n\t" |
"psrlq _ShiftRem, %%mm2 \n\t" // correct position Raw(x-bpp) |
// data |
"movq (%%esi,%%ecx,), %%mm1 \n\t" // load mm1 with Prior(x) |
"movq %%mm7, %%mm6 \n\t" |
"pand %%mm1, %%mm3 \n\t" // get lsb for each prev_row byte |
"psrlq $1, %%mm1 \n\t" // divide prev_row bytes by 2 |
"pand %%mm4, %%mm1 \n\t" // clear invalid bit 7 of each |
// byte |
"paddb %%mm1, %%mm0 \n\t" // add (Prev_row/2) to Avg for |
// each byte |
// add 1st active group (Raw(x-bpp)/2) to average with LBCarry |
"movq %%mm3, %%mm1 \n\t" // now use mm1 for getting |
// LBCarrys |
"pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte |
// where both |
// lsb's were == 1 (only valid for active group) |
"psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 |
"pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each |
// byte |
"paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) |
// for each byte |
"pand %%mm6, %%mm2 \n\t" // leave only Active Group 1 |
// bytes to add to Avg |
"paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to |
// Avg for each Active |
// byte |
// add 2nd active group (Raw(x-bpp)/2) to average with _LBCarry |
"psllq _ShiftBpp, %%mm6 \n\t" // shift the mm6 mask to cover |
// bytes 3-5 |
"movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 |
"psllq _ShiftBpp, %%mm2 \n\t" // shift data to pos. correctly |
"movq %%mm3, %%mm1 \n\t" // now use mm1 for getting |
// LBCarrys |
"pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte |
// where both |
// lsb's were == 1 (only valid for active group) |
"psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 |
"pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each |
// byte |
"paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) |
// for each byte |
"pand %%mm6, %%mm2 \n\t" // leave only Active Group 2 |
// bytes to add to Avg |
"paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to |
// Avg for each Active |
// byte |
// add 3rd active group (Raw(x-bpp)/2) to average with _LBCarry |
"psllq _ShiftBpp, %%mm6 \n\t" // shift mm6 mask to cover last |
// two |
// bytes |
"movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 |
"psllq _ShiftBpp, %%mm2 \n\t" // shift data to pos. correctly |
// Data only needs to be shifted once here to |
// get the correct x-bpp offset. |
"movq %%mm3, %%mm1 \n\t" // now use mm1 for getting |
// LBCarrys |
"pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte |
// where both |
// lsb's were == 1 (only valid for active group) |
"psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 |
"pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each |
// byte |
"paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) |
// for each byte |
"pand %%mm6, %%mm2 \n\t" // leave only Active Group 2 |
// bytes to add to Avg |
"addl $8, %%ecx \n\t" |
"paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to |
// Avg for each Active |
// byte |
// now ready to write back to memory |
"movq %%mm0, -8(%%edi,%%ecx,) \n\t" |
// move updated Raw(x) to use as Raw(x-bpp) for next loop |
"cmpl _MMXLength, %%ecx \n\t" |
"movq %%mm0, %%mm2 \n\t" // mov updated Raw(x) to mm2 |
"jb avg_3lp \n\t" |
: "=S" (dummy_value_S), // output regs (dummy) |
"=D" (dummy_value_D) |
: "0" (prev_row), // esi // input regs |
"1" (row) // edi |
: "%ecx" // clobber list |
#if 0 /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
, "%mm0", "%mm1", "%mm2", "%mm3" |
, "%mm4", "%mm5", "%mm6", "%mm7" |
#endif |
); |
} |
break; // end 3 bpp |
case 6: |
case 4: |
//case 7: // who wrote this? PNG doesn't support 5 or 7 bytes/pixel |
//case 5: // GRR BOGUS |
{ |
_ActiveMask.use = 0xffffffffffffffffLL; // use shift below to clear |
// appropriate inactive bytes |
_ShiftBpp.use = bpp << 3; |
_ShiftRem.use = 64 - _ShiftBpp.use; |
__asm__ __volatile__ ( |
"movq _HBClearMask, %%mm4 \n\t" |
// re-init address pointers and offset |
"movl _dif, %%ecx \n\t" // ecx: x = offset to |
// alignment boundary |
// load _ActiveMask and clear all bytes except for 1st active group |
"movq _ActiveMask, %%mm7 \n\t" |
// preload "movl row, %%edi \n\t" // edi: Avg(x) |
"psrlq _ShiftRem, %%mm7 \n\t" |
// preload "movl prev_row, %%esi \n\t" // esi: Prior(x) |
"movq %%mm7, %%mm6 \n\t" |
"movq _LBCarryMask, %%mm5 \n\t" |
"psllq _ShiftBpp, %%mm6 \n\t" // create mask for 2nd active |
// group |
// prime the pump: load the first Raw(x-bpp) data set |
"movq -8(%%edi,%%ecx,), %%mm2 \n\t" // load previous aligned 8 bytes |
// (we correct pos. in loop below) |
"avg_4lp: \n\t" |
"movq (%%edi,%%ecx,), %%mm0 \n\t" |
"psrlq _ShiftRem, %%mm2 \n\t" // shift data to pos. correctly |
"movq (%%esi,%%ecx,), %%mm1 \n\t" |
// add (Prev_row/2) to average |
"movq %%mm5, %%mm3 \n\t" |
"pand %%mm1, %%mm3 \n\t" // get lsb for each prev_row byte |
"psrlq $1, %%mm1 \n\t" // divide prev_row bytes by 2 |
"pand %%mm4, %%mm1 \n\t" // clear invalid bit 7 of each |
// byte |
"paddb %%mm1, %%mm0 \n\t" // add (Prev_row/2) to Avg for |
// each byte |
// add 1st active group (Raw(x-bpp)/2) to average with _LBCarry |
"movq %%mm3, %%mm1 \n\t" // now use mm1 for getting |
// LBCarrys |
"pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte |
// where both |
// lsb's were == 1 (only valid for active group) |
"psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 |
"pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each |
// byte |
"paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) |
// for each byte |
"pand %%mm7, %%mm2 \n\t" // leave only Active Group 1 |
// bytes to add to Avg |
"paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to Avg |
// for each Active |
// byte |
// add 2nd active group (Raw(x-bpp)/2) to average with _LBCarry |
"movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 |
"psllq _ShiftBpp, %%mm2 \n\t" // shift data to pos. correctly |
"addl $8, %%ecx \n\t" |
"movq %%mm3, %%mm1 \n\t" // now use mm1 for getting |
// LBCarrys |
"pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte |
// where both |
// lsb's were == 1 (only valid for active group) |
"psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 |
"pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each |
// byte |
"paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) |
// for each byte |
"pand %%mm6, %%mm2 \n\t" // leave only Active Group 2 |
// bytes to add to Avg |
"paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to |
// Avg for each Active |
// byte |
"cmpl _MMXLength, %%ecx \n\t" |
// now ready to write back to memory |
"movq %%mm0, -8(%%edi,%%ecx,) \n\t" |
// prep Raw(x-bpp) for next loop |
"movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 |
"jb avg_4lp \n\t" |
: "=S" (dummy_value_S), // output regs (dummy) |
"=D" (dummy_value_D) |
: "0" (prev_row), // esi // input regs |
"1" (row) // edi |
: "%ecx" // clobber list |
#if 0 /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
, "%mm0", "%mm1", "%mm2", "%mm3" |
, "%mm4", "%mm5", "%mm6", "%mm7" |
#endif |
); |
} |
break; // end 4,6 bpp |
case 2: |
{ |
_ActiveMask.use = 0x000000000000ffffLL; |
_ShiftBpp.use = 16; // == 2 * 8 |
_ShiftRem.use = 48; // == 64 - 16 |
__asm__ __volatile__ ( |
// load _ActiveMask |
"movq _ActiveMask, %%mm7 \n\t" |
// re-init address pointers and offset |
"movl _dif, %%ecx \n\t" // ecx: x = offset to alignment |
// boundary |
"movq _LBCarryMask, %%mm5 \n\t" |
// preload "movl row, %%edi \n\t" // edi: Avg(x) |
"movq _HBClearMask, %%mm4 \n\t" |
// preload "movl prev_row, %%esi \n\t" // esi: Prior(x) |
// prime the pump: load the first Raw(x-bpp) data set |
"movq -8(%%edi,%%ecx,), %%mm2 \n\t" // load previous aligned 8 bytes |
// (we correct pos. in loop below) |
"avg_2lp: \n\t" |
"movq (%%edi,%%ecx,), %%mm0 \n\t" |
"psrlq _ShiftRem, %%mm2 \n\t" // shift data to pos. correctly |
"movq (%%esi,%%ecx,), %%mm1 \n\t" // (GRR BUGFIX: was psllq) |
// add (Prev_row/2) to average |
"movq %%mm5, %%mm3 \n\t" |
"pand %%mm1, %%mm3 \n\t" // get lsb for each prev_row byte |
"psrlq $1, %%mm1 \n\t" // divide prev_row bytes by 2 |
"pand %%mm4, %%mm1 \n\t" // clear invalid bit 7 of each |
// byte |
"movq %%mm7, %%mm6 \n\t" |
"paddb %%mm1, %%mm0 \n\t" // add (Prev_row/2) to Avg for |
// each byte |
// add 1st active group (Raw(x-bpp)/2) to average with _LBCarry |
"movq %%mm3, %%mm1 \n\t" // now use mm1 for getting |
// LBCarrys |
"pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte |
// where both |
// lsb's were == 1 (only valid |
// for active group) |
"psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 |
"pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each |
// byte |
"paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) |
// for each byte |
"pand %%mm6, %%mm2 \n\t" // leave only Active Group 1 |
// bytes to add to Avg |
"paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to Avg |
// for each Active byte |
// add 2nd active group (Raw(x-bpp)/2) to average with _LBCarry |
"psllq _ShiftBpp, %%mm6 \n\t" // shift the mm6 mask to cover |
// bytes 2 & 3 |
"movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 |
"psllq _ShiftBpp, %%mm2 \n\t" // shift data to pos. correctly |
"movq %%mm3, %%mm1 \n\t" // now use mm1 for getting |
// LBCarrys |
"pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte |
// where both |
// lsb's were == 1 (only valid |
// for active group) |
"psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 |
"pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each |
// byte |
"paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) |
// for each byte |
"pand %%mm6, %%mm2 \n\t" // leave only Active Group 2 |
// bytes to add to Avg |
"paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to |
// Avg for each Active byte |
// add 3rd active group (Raw(x-bpp)/2) to average with _LBCarry |
"psllq _ShiftBpp, %%mm6 \n\t" // shift the mm6 mask to cover |
// bytes 4 & 5 |
"movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 |
"psllq _ShiftBpp, %%mm2 \n\t" // shift data to pos. correctly |
"movq %%mm3, %%mm1 \n\t" // now use mm1 for getting |
// LBCarrys |
"pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte |
// where both lsb's were == 1 |
// (only valid for active group) |
"psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 |
"pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each |
// byte |
"paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) |
// for each byte |
"pand %%mm6, %%mm2 \n\t" // leave only Active Group 2 |
// bytes to add to Avg |
"paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to |
// Avg for each Active byte |
// add 4th active group (Raw(x-bpp)/2) to average with _LBCarry |
"psllq _ShiftBpp, %%mm6 \n\t" // shift the mm6 mask to cover |
// bytes 6 & 7 |
"movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 |
"psllq _ShiftBpp, %%mm2 \n\t" // shift data to pos. correctly |
"addl $8, %%ecx \n\t" |
"movq %%mm3, %%mm1 \n\t" // now use mm1 for getting |
// LBCarrys |
"pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte |
// where both |
// lsb's were == 1 (only valid |
// for active group) |
"psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 |
"pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each |
// byte |
"paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) |
// for each byte |
"pand %%mm6, %%mm2 \n\t" // leave only Active Group 2 |
// bytes to add to Avg |
"paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to |
// Avg for each Active byte |
"cmpl _MMXLength, %%ecx \n\t" |
// now ready to write back to memory |
"movq %%mm0, -8(%%edi,%%ecx,) \n\t" |
// prep Raw(x-bpp) for next loop |
"movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 |
"jb avg_2lp \n\t" |
: "=S" (dummy_value_S), // output regs (dummy) |
"=D" (dummy_value_D) |
: "0" (prev_row), // esi // input regs |
"1" (row) // edi |
: "%ecx" // clobber list |
#if 0 /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
, "%mm0", "%mm1", "%mm2", "%mm3" |
, "%mm4", "%mm5", "%mm6", "%mm7" |
#endif |
); |
} |
break; // end 2 bpp |
case 1: |
{ |
__asm__ __volatile__ ( |
// re-init address pointers and offset |
#ifdef __PIC__ |
"pushl %%ebx \n\t" // save Global Offset Table index |
#endif |
"movl _dif, %%ebx \n\t" // ebx: x = offset to alignment |
// boundary |
// preload "movl row, %%edi \n\t" // edi: Avg(x) |
"cmpl _FullLength, %%ebx \n\t" // test if offset at end of array |
"jnb avg_1end \n\t" |
// do Paeth decode for remaining bytes |
// preload "movl prev_row, %%esi \n\t" // esi: Prior(x) |
"movl %%edi, %%edx \n\t" |
// preload "subl bpp, %%edx \n\t" // (bpp is preloaded into ecx) |
"subl %%ecx, %%edx \n\t" // edx: Raw(x-bpp) |
"xorl %%ecx, %%ecx \n\t" // zero ecx before using cl & cx |
// in loop below |
"avg_1lp: \n\t" |
// Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2) |
"xorl %%eax, %%eax \n\t" |
"movb (%%esi,%%ebx,), %%cl \n\t" // load cl with Prior(x) |
"movb (%%edx,%%ebx,), %%al \n\t" // load al with Raw(x-bpp) |
"addw %%cx, %%ax \n\t" |
"incl %%ebx \n\t" |
"shrw %%ax \n\t" // divide by 2 |
"addb -1(%%edi,%%ebx,), %%al \n\t" // add Avg(x); -1 to offset |
// inc ebx |
"cmpl _FullLength, %%ebx \n\t" // check if at end of array |
"movb %%al, -1(%%edi,%%ebx,) \n\t" // write back Raw(x); |
// mov does not affect flags; -1 to offset inc ebx |
"jb avg_1lp \n\t" |
"avg_1end: \n\t" |
#ifdef __PIC__ |
"popl %%ebx \n\t" // Global Offset Table index |
#endif |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "0" (bpp), // ecx // input regs |
"1" (prev_row), // esi |
"2" (row) // edi |
: "%eax", "%edx" // clobber list |
#ifndef __PIC__ |
, "%ebx" |
#endif |
); |
} |
return; // end 1 bpp |
case 8: |
{ |
__asm__ __volatile__ ( |
// re-init address pointers and offset |
"movl _dif, %%ecx \n\t" // ecx: x == offset to alignment |
"movq _LBCarryMask, %%mm5 \n\t" // boundary |
// preload "movl row, %%edi \n\t" // edi: Avg(x) |
"movq _HBClearMask, %%mm4 \n\t" |
// preload "movl prev_row, %%esi \n\t" // esi: Prior(x) |
// prime the pump: load the first Raw(x-bpp) data set |
"movq -8(%%edi,%%ecx,), %%mm2 \n\t" // load previous aligned 8 bytes |
// (NO NEED to correct pos. in loop below) |
"avg_8lp: \n\t" |
"movq (%%edi,%%ecx,), %%mm0 \n\t" |
"movq %%mm5, %%mm3 \n\t" |
"movq (%%esi,%%ecx,), %%mm1 \n\t" |
"addl $8, %%ecx \n\t" |
"pand %%mm1, %%mm3 \n\t" // get lsb for each prev_row byte |
"psrlq $1, %%mm1 \n\t" // divide prev_row bytes by 2 |
"pand %%mm2, %%mm3 \n\t" // get LBCarrys for each byte |
// where both lsb's were == 1 |
"psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 |
"pand %%mm4, %%mm1 \n\t" // clear invalid bit 7, each byte |
"paddb %%mm3, %%mm0 \n\t" // add LBCarrys to Avg, each byte |
"pand %%mm4, %%mm2 \n\t" // clear invalid bit 7, each byte |
"paddb %%mm1, %%mm0 \n\t" // add (Prev_row/2) to Avg, each |
"paddb %%mm2, %%mm0 \n\t" // add (Raw/2) to Avg for each |
"cmpl _MMXLength, %%ecx \n\t" |
"movq %%mm0, -8(%%edi,%%ecx,) \n\t" |
"movq %%mm0, %%mm2 \n\t" // reuse as Raw(x-bpp) |
"jb avg_8lp \n\t" |
: "=S" (dummy_value_S), // output regs (dummy) |
"=D" (dummy_value_D) |
: "0" (prev_row), // esi // input regs |
"1" (row) // edi |
: "%ecx" // clobber list |
#if 0 /* %mm0, ..., %mm5 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
, "%mm0", "%mm1", "%mm2" |
, "%mm3", "%mm4", "%mm5" |
#endif |
); |
} |
break; // end 8 bpp |
default: // bpp greater than 8 (!= 1,2,3,4,[5],6,[7],8) |
{ |
#ifdef PNG_DEBUG |
// GRR: PRINT ERROR HERE: SHOULD NEVER BE REACHED |
png_debug(1, |
"Internal logic error in pnggccrd (png_read_filter_row_mmx_avg())\n"); |
#endif |
#if 0 |
__asm__ __volatile__ ( |
"movq _LBCarryMask, %%mm5 \n\t" |
// re-init address pointers and offset |
"movl _dif, %%ebx \n\t" // ebx: x = offset to |
// alignment boundary |
"movl row, %%edi \n\t" // edi: Avg(x) |
"movq _HBClearMask, %%mm4 \n\t" |
"movl %%edi, %%edx \n\t" |
"movl prev_row, %%esi \n\t" // esi: Prior(x) |
"subl bpp, %%edx \n\t" // edx: Raw(x-bpp) |
"avg_Alp: \n\t" |
"movq (%%edi,%%ebx,), %%mm0 \n\t" |
"movq %%mm5, %%mm3 \n\t" |
"movq (%%esi,%%ebx,), %%mm1 \n\t" |
"pand %%mm1, %%mm3 \n\t" // get lsb for each prev_row byte |
"movq (%%edx,%%ebx,), %%mm2 \n\t" |
"psrlq $1, %%mm1 \n\t" // divide prev_row bytes by 2 |
"pand %%mm2, %%mm3 \n\t" // get LBCarrys for each byte |
// where both lsb's were == 1 |
"psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 |
"pand %%mm4, %%mm1 \n\t" // clear invalid bit 7 of each |
// byte |
"paddb %%mm3, %%mm0 \n\t" // add LBCarrys to Avg for each |
// byte |
"pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each |
// byte |
"paddb %%mm1, %%mm0 \n\t" // add (Prev_row/2) to Avg for |
// each byte |
"addl $8, %%ebx \n\t" |
"paddb %%mm2, %%mm0 \n\t" // add (Raw/2) to Avg for each |
// byte |
"cmpl _MMXLength, %%ebx \n\t" |
"movq %%mm0, -8(%%edi,%%ebx,) \n\t" |
"jb avg_Alp \n\t" |
: // FIXASM: output regs/vars go here, e.g.: "=m" (memory_var) |
: // FIXASM: input regs, e.g.: "c" (count), "S" (src), "D" (dest) |
: "%ebx", "%edx", "%edi", "%esi" // CHECKASM: clobber list |
); |
#endif /* 0 - NEVER REACHED */ |
} |
break; |
} // end switch (bpp) |
__asm__ __volatile__ ( |
// MMX acceleration complete; now do clean-up |
// check if any remaining bytes left to decode |
#ifdef __PIC__ |
"pushl %%ebx \n\t" // save index to Global Offset Table |
#endif |
"movl _MMXLength, %%ebx \n\t" // ebx: x == offset bytes after MMX |
//pre "movl row, %%edi \n\t" // edi: Avg(x) |
"cmpl _FullLength, %%ebx \n\t" // test if offset at end of array |
"jnb avg_end \n\t" |
// do Avg decode for remaining bytes |
//pre "movl prev_row, %%esi \n\t" // esi: Prior(x) |
"movl %%edi, %%edx \n\t" |
//pre "subl bpp, %%edx \n\t" // (bpp is preloaded into ecx) |
"subl %%ecx, %%edx \n\t" // edx: Raw(x-bpp) |
"xorl %%ecx, %%ecx \n\t" // zero ecx before using cl & cx below |
"avg_lp2: \n\t" |
// Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2) |
"xorl %%eax, %%eax \n\t" |
"movb (%%esi,%%ebx,), %%cl \n\t" // load cl with Prior(x) |
"movb (%%edx,%%ebx,), %%al \n\t" // load al with Raw(x-bpp) |
"addw %%cx, %%ax \n\t" |
"incl %%ebx \n\t" |
"shrw %%ax \n\t" // divide by 2 |
"addb -1(%%edi,%%ebx,), %%al \n\t" // add Avg(x); -1 to offset inc ebx |
"cmpl _FullLength, %%ebx \n\t" // check if at end of array |
"movb %%al, -1(%%edi,%%ebx,) \n\t" // write back Raw(x) [mov does not |
"jb avg_lp2 \n\t" // affect flags; -1 to offset inc ebx] |
"avg_end: \n\t" |
"EMMS \n\t" // end MMX; prep for poss. FP instrs. |
#ifdef __PIC__ |
"popl %%ebx \n\t" // restore index to Global Offset Table |
#endif |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "0" (bpp), // ecx // input regs |
"1" (prev_row), // esi |
"2" (row) // edi |
: "%eax", "%edx" // clobber list |
#ifndef __PIC__ |
, "%ebx" |
#endif |
); |
} /* end png_read_filter_row_mmx_avg() */ |
#endif |
#ifdef PNG_THREAD_UNSAFE_OK |
//===========================================================================// |
// // |
// P N G _ R E A D _ F I L T E R _ R O W _ M M X _ P A E T H // |
// // |
//===========================================================================// |
// Optimized code for PNG Paeth filter decoder |
static void /* PRIVATE */ |
png_read_filter_row_mmx_paeth(png_row_infop row_info, png_bytep row, |
png_bytep prev_row) |
{ |
int bpp; |
int dummy_value_c; // fix 'forbidden register 2 (cx) was spilled' error |
int dummy_value_S; |
int dummy_value_D; |
bpp = (row_info->pixel_depth + 7) >> 3; // Get # bytes per pixel |
_FullLength = row_info->rowbytes; // # of bytes to filter |
__asm__ __volatile__ ( |
#ifdef __PIC__ |
"pushl %%ebx \n\t" // save index to Global Offset Table |
#endif |
"xorl %%ebx, %%ebx \n\t" // ebx: x offset |
//pre "movl row, %%edi \n\t" |
"xorl %%edx, %%edx \n\t" // edx: x-bpp offset |
//pre "movl prev_row, %%esi \n\t" |
"xorl %%eax, %%eax \n\t" |
// Compute the Raw value for the first bpp bytes |
// Note: the formula works out to be always |
// Paeth(x) = Raw(x) + Prior(x) where x < bpp |
"paeth_rlp: \n\t" |
"movb (%%edi,%%ebx,), %%al \n\t" |
"addb (%%esi,%%ebx,), %%al \n\t" |
"incl %%ebx \n\t" |
//pre "cmpl bpp, %%ebx \n\t" (bpp is preloaded into ecx) |
"cmpl %%ecx, %%ebx \n\t" |
"movb %%al, -1(%%edi,%%ebx,) \n\t" |
"jb paeth_rlp \n\t" |
// get # of bytes to alignment |
"movl %%edi, _dif \n\t" // take start of row |
"addl %%ebx, _dif \n\t" // add bpp |
"xorl %%ecx, %%ecx \n\t" |
"addl $0xf, _dif \n\t" // add 7 + 8 to incr past alignment |
// boundary |
"andl $0xfffffff8, _dif \n\t" // mask to alignment boundary |
"subl %%edi, _dif \n\t" // subtract from start ==> value ebx |
// at alignment |
"jz paeth_go \n\t" |
// fix alignment |
"paeth_lp1: \n\t" |
"xorl %%eax, %%eax \n\t" |
// pav = p - a = (a + b - c) - a = b - c |
"movb (%%esi,%%ebx,), %%al \n\t" // load Prior(x) into al |
"movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl |
"subl %%ecx, %%eax \n\t" // subtract Prior(x-bpp) |
"movl %%eax, _patemp \n\t" // Save pav for later use |
"xorl %%eax, %%eax \n\t" |
// pbv = p - b = (a + b - c) - b = a - c |
"movb (%%edi,%%edx,), %%al \n\t" // load Raw(x-bpp) into al |
"subl %%ecx, %%eax \n\t" // subtract Prior(x-bpp) |
"movl %%eax, %%ecx \n\t" |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
"addl _patemp, %%eax \n\t" // pcv = pav + pbv |
// pc = abs(pcv) |
"testl $0x80000000, %%eax \n\t" |
"jz paeth_pca \n\t" |
"negl %%eax \n\t" // reverse sign of neg values |
"paeth_pca: \n\t" |
"movl %%eax, _pctemp \n\t" // save pc for later use |
// pb = abs(pbv) |
"testl $0x80000000, %%ecx \n\t" |
"jz paeth_pba \n\t" |
"negl %%ecx \n\t" // reverse sign of neg values |
"paeth_pba: \n\t" |
"movl %%ecx, _pbtemp \n\t" // save pb for later use |
// pa = abs(pav) |
"movl _patemp, %%eax \n\t" |
"testl $0x80000000, %%eax \n\t" |
"jz paeth_paa \n\t" |
"negl %%eax \n\t" // reverse sign of neg values |
"paeth_paa: \n\t" |
"movl %%eax, _patemp \n\t" // save pa for later use |
// test if pa <= pb |
"cmpl %%ecx, %%eax \n\t" |
"jna paeth_abb \n\t" |
// pa > pb; now test if pb <= pc |
"cmpl _pctemp, %%ecx \n\t" |
"jna paeth_bbc \n\t" |
// pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp) |
"movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl |
"jmp paeth_paeth \n\t" |
"paeth_bbc: \n\t" |
// pb <= pc; Raw(x) = Paeth(x) + Prior(x) |
"movb (%%esi,%%ebx,), %%cl \n\t" // load Prior(x) into cl |
"jmp paeth_paeth \n\t" |
"paeth_abb: \n\t" |
// pa <= pb; now test if pa <= pc |
"cmpl _pctemp, %%eax \n\t" |
"jna paeth_abc \n\t" |
// pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp) |
"movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl |
"jmp paeth_paeth \n\t" |
"paeth_abc: \n\t" |
// pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp) |
"movb (%%edi,%%edx,), %%cl \n\t" // load Raw(x-bpp) into cl |
"paeth_paeth: \n\t" |
"incl %%ebx \n\t" |
"incl %%edx \n\t" |
// Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256 |
"addb %%cl, -1(%%edi,%%ebx,) \n\t" |
"cmpl _dif, %%ebx \n\t" |
"jb paeth_lp1 \n\t" |
"paeth_go: \n\t" |
"movl _FullLength, %%ecx \n\t" |
"movl %%ecx, %%eax \n\t" |
"subl %%ebx, %%eax \n\t" // subtract alignment fix |
"andl $0x00000007, %%eax \n\t" // calc bytes over mult of 8 |
"subl %%eax, %%ecx \n\t" // drop over bytes from original length |
"movl %%ecx, _MMXLength \n\t" |
#ifdef __PIC__ |
"popl %%ebx \n\t" // restore index to Global Offset Table |
#endif |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "0" (bpp), // ecx // input regs |
"1" (prev_row), // esi |
"2" (row) // edi |
: "%eax", "%edx" // clobber list |
#ifndef __PIC__ |
, "%ebx" |
#endif |
); |
// now do the math for the rest of the row |
switch (bpp) |
{ |
case 3: |
{ |
_ActiveMask.use = 0x0000000000ffffffLL; |
_ActiveMaskEnd.use = 0xffff000000000000LL; |
_ShiftBpp.use = 24; // == bpp(3) * 8 |
_ShiftRem.use = 40; // == 64 - 24 |
__asm__ __volatile__ ( |
"movl _dif, %%ecx \n\t" |
// preload "movl row, %%edi \n\t" |
// preload "movl prev_row, %%esi \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
// prime the pump: load the first Raw(x-bpp) data set |
"movq -8(%%edi,%%ecx,), %%mm1 \n\t" |
"paeth_3lp: \n\t" |
"psrlq _ShiftRem, %%mm1 \n\t" // shift last 3 bytes to 1st |
// 3 bytes |
"movq (%%esi,%%ecx,), %%mm2 \n\t" // load b=Prior(x) |
"punpcklbw %%mm0, %%mm1 \n\t" // unpack High bytes of a |
"movq -8(%%esi,%%ecx,), %%mm3 \n\t" // prep c=Prior(x-bpp) bytes |
"punpcklbw %%mm0, %%mm2 \n\t" // unpack High bytes of b |
"psrlq _ShiftRem, %%mm3 \n\t" // shift last 3 bytes to 1st |
// 3 bytes |
// pav = p - a = (a + b - c) - a = b - c |
"movq %%mm2, %%mm4 \n\t" |
"punpcklbw %%mm0, %%mm3 \n\t" // unpack High bytes of c |
// pbv = p - b = (a + b - c) - b = a - c |
"movq %%mm1, %%mm5 \n\t" |
"psubw %%mm3, %%mm4 \n\t" |
"pxor %%mm7, %%mm7 \n\t" |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
"movq %%mm4, %%mm6 \n\t" |
"psubw %%mm3, %%mm5 \n\t" |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
"pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 |
"paddw %%mm5, %%mm6 \n\t" |
"pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 |
"psubw %%mm0, %%mm4 \n\t" |
"pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 |
"psubw %%mm0, %%mm4 \n\t" |
"psubw %%mm7, %%mm5 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 |
"pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"psubw %%mm7, %%mm5 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
// test pa <= pb |
"movq %%mm4, %%mm7 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
"pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? |
"movq %%mm7, %%mm0 \n\t" |
// use mm7 mask to merge pa & pb |
"pand %%mm7, %%mm5 \n\t" |
// use mm0 mask copy to merge a & b |
"pand %%mm0, %%mm2 \n\t" |
"pandn %%mm4, %%mm7 \n\t" |
"pandn %%mm1, %%mm0 \n\t" |
"paddw %%mm5, %%mm7 \n\t" |
"paddw %%mm2, %%mm0 \n\t" |
// test ((pa <= pb)? pa:pb) <= pc |
"pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? |
"pxor %%mm1, %%mm1 \n\t" |
"pand %%mm7, %%mm3 \n\t" |
"pandn %%mm0, %%mm7 \n\t" |
"paddw %%mm3, %%mm7 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"packuswb %%mm1, %%mm7 \n\t" |
"movq (%%esi,%%ecx,), %%mm3 \n\t" // load c=Prior(x-bpp) |
"pand _ActiveMask, %%mm7 \n\t" |
"movq %%mm3, %%mm2 \n\t" // load b=Prior(x) step 1 |
"paddb (%%edi,%%ecx,), %%mm7 \n\t" // add Paeth predictor with Raw(x) |
"punpcklbw %%mm0, %%mm3 \n\t" // unpack High bytes of c |
"movq %%mm7, (%%edi,%%ecx,) \n\t" // write back updated value |
"movq %%mm7, %%mm1 \n\t" // now mm1 will be used as |
// Raw(x-bpp) |
// now do Paeth for 2nd set of bytes (3-5) |
"psrlq _ShiftBpp, %%mm2 \n\t" // load b=Prior(x) step 2 |
"punpcklbw %%mm0, %%mm1 \n\t" // unpack High bytes of a |
"pxor %%mm7, %%mm7 \n\t" |
"punpcklbw %%mm0, %%mm2 \n\t" // unpack High bytes of b |
// pbv = p - b = (a + b - c) - b = a - c |
"movq %%mm1, %%mm5 \n\t" |
// pav = p - a = (a + b - c) - a = b - c |
"movq %%mm2, %%mm4 \n\t" |
"psubw %%mm3, %%mm5 \n\t" |
"psubw %%mm3, %%mm4 \n\t" |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = |
// pav + pbv = pbv + pav |
"movq %%mm5, %%mm6 \n\t" |
"paddw %%mm4, %%mm6 \n\t" |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
"pcmpgtw %%mm5, %%mm0 \n\t" // create mask pbv bytes < 0 |
"pcmpgtw %%mm4, %%mm7 \n\t" // create mask pav bytes < 0 |
"pand %%mm5, %%mm0 \n\t" // only pbv bytes < 0 in mm0 |
"pand %%mm4, %%mm7 \n\t" // only pav bytes < 0 in mm7 |
"psubw %%mm0, %%mm5 \n\t" |
"psubw %%mm7, %%mm4 \n\t" |
"psubw %%mm0, %%mm5 \n\t" |
"psubw %%mm7, %%mm4 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 |
"pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"psubw %%mm0, %%mm6 \n\t" |
// test pa <= pb |
"movq %%mm4, %%mm7 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
"pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? |
"movq %%mm7, %%mm0 \n\t" |
// use mm7 mask to merge pa & pb |
"pand %%mm7, %%mm5 \n\t" |
// use mm0 mask copy to merge a & b |
"pand %%mm0, %%mm2 \n\t" |
"pandn %%mm4, %%mm7 \n\t" |
"pandn %%mm1, %%mm0 \n\t" |
"paddw %%mm5, %%mm7 \n\t" |
"paddw %%mm2, %%mm0 \n\t" |
// test ((pa <= pb)? pa:pb) <= pc |
"pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? |
"movq (%%esi,%%ecx,), %%mm2 \n\t" // load b=Prior(x) |
"pand %%mm7, %%mm3 \n\t" |
"pandn %%mm0, %%mm7 \n\t" |
"pxor %%mm1, %%mm1 \n\t" |
"paddw %%mm3, %%mm7 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"packuswb %%mm1, %%mm7 \n\t" |
"movq %%mm2, %%mm3 \n\t" // load c=Prior(x-bpp) step 1 |
"pand _ActiveMask, %%mm7 \n\t" |
"punpckhbw %%mm0, %%mm2 \n\t" // unpack High bytes of b |
"psllq _ShiftBpp, %%mm7 \n\t" // shift bytes to 2nd group of |
// 3 bytes |
// pav = p - a = (a + b - c) - a = b - c |
"movq %%mm2, %%mm4 \n\t" |
"paddb (%%edi,%%ecx,), %%mm7 \n\t" // add Paeth predictor with Raw(x) |
"psllq _ShiftBpp, %%mm3 \n\t" // load c=Prior(x-bpp) step 2 |
"movq %%mm7, (%%edi,%%ecx,) \n\t" // write back updated value |
"movq %%mm7, %%mm1 \n\t" |
"punpckhbw %%mm0, %%mm3 \n\t" // unpack High bytes of c |
"psllq _ShiftBpp, %%mm1 \n\t" // shift bytes |
// now mm1 will be used as Raw(x-bpp) |
// now do Paeth for 3rd, and final, set of bytes (6-7) |
"pxor %%mm7, %%mm7 \n\t" |
"punpckhbw %%mm0, %%mm1 \n\t" // unpack High bytes of a |
"psubw %%mm3, %%mm4 \n\t" |
// pbv = p - b = (a + b - c) - b = a - c |
"movq %%mm1, %%mm5 \n\t" |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
"movq %%mm4, %%mm6 \n\t" |
"psubw %%mm3, %%mm5 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"paddw %%mm5, %%mm6 \n\t" |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
"pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 |
"pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 |
"pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 |
"psubw %%mm0, %%mm4 \n\t" |
"psubw %%mm7, %%mm5 \n\t" |
"psubw %%mm0, %%mm4 \n\t" |
"psubw %%mm7, %%mm5 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 |
"pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"psubw %%mm0, %%mm6 \n\t" |
// test pa <= pb |
"movq %%mm4, %%mm7 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
"pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? |
"movq %%mm7, %%mm0 \n\t" |
// use mm0 mask copy to merge a & b |
"pand %%mm0, %%mm2 \n\t" |
// use mm7 mask to merge pa & pb |
"pand %%mm7, %%mm5 \n\t" |
"pandn %%mm1, %%mm0 \n\t" |
"pandn %%mm4, %%mm7 \n\t" |
"paddw %%mm2, %%mm0 \n\t" |
"paddw %%mm5, %%mm7 \n\t" |
// test ((pa <= pb)? pa:pb) <= pc |
"pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? |
"pand %%mm7, %%mm3 \n\t" |
"pandn %%mm0, %%mm7 \n\t" |
"paddw %%mm3, %%mm7 \n\t" |
"pxor %%mm1, %%mm1 \n\t" |
"packuswb %%mm7, %%mm1 \n\t" |
// step ecx to next set of 8 bytes and repeat loop til done |
"addl $8, %%ecx \n\t" |
"pand _ActiveMaskEnd, %%mm1 \n\t" |
"paddb -8(%%edi,%%ecx,), %%mm1 \n\t" // add Paeth predictor with |
// Raw(x) |
"cmpl _MMXLength, %%ecx \n\t" |
"pxor %%mm0, %%mm0 \n\t" // pxor does not affect flags |
"movq %%mm1, -8(%%edi,%%ecx,) \n\t" // write back updated value |
// mm1 will be used as Raw(x-bpp) next loop |
// mm3 ready to be used as Prior(x-bpp) next loop |
"jb paeth_3lp \n\t" |
: "=S" (dummy_value_S), // output regs (dummy) |
"=D" (dummy_value_D) |
: "0" (prev_row), // esi // input regs |
"1" (row) // edi |
: "%ecx" // clobber list |
#if 0 /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
, "%mm0", "%mm1", "%mm2", "%mm3" |
, "%mm4", "%mm5", "%mm6", "%mm7" |
#endif |
); |
} |
break; // end 3 bpp |
case 6: |
//case 7: // GRR BOGUS |
//case 5: // GRR BOGUS |
{ |
_ActiveMask.use = 0x00000000ffffffffLL; |
_ActiveMask2.use = 0xffffffff00000000LL; |
_ShiftBpp.use = bpp << 3; // == bpp * 8 |
_ShiftRem.use = 64 - _ShiftBpp.use; |
__asm__ __volatile__ ( |
"movl _dif, %%ecx \n\t" |
// preload "movl row, %%edi \n\t" |
// preload "movl prev_row, %%esi \n\t" |
// prime the pump: load the first Raw(x-bpp) data set |
"movq -8(%%edi,%%ecx,), %%mm1 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"paeth_6lp: \n\t" |
// must shift to position Raw(x-bpp) data |
"psrlq _ShiftRem, %%mm1 \n\t" |
// do first set of 4 bytes |
"movq -8(%%esi,%%ecx,), %%mm3 \n\t" // read c=Prior(x-bpp) bytes |
"punpcklbw %%mm0, %%mm1 \n\t" // unpack Low bytes of a |
"movq (%%esi,%%ecx,), %%mm2 \n\t" // load b=Prior(x) |
"punpcklbw %%mm0, %%mm2 \n\t" // unpack Low bytes of b |
// must shift to position Prior(x-bpp) data |
"psrlq _ShiftRem, %%mm3 \n\t" |
// pav = p - a = (a + b - c) - a = b - c |
"movq %%mm2, %%mm4 \n\t" |
"punpcklbw %%mm0, %%mm3 \n\t" // unpack Low bytes of c |
// pbv = p - b = (a + b - c) - b = a - c |
"movq %%mm1, %%mm5 \n\t" |
"psubw %%mm3, %%mm4 \n\t" |
"pxor %%mm7, %%mm7 \n\t" |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
"movq %%mm4, %%mm6 \n\t" |
"psubw %%mm3, %%mm5 \n\t" |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
"pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 |
"paddw %%mm5, %%mm6 \n\t" |
"pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 |
"psubw %%mm0, %%mm4 \n\t" |
"pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 |
"psubw %%mm0, %%mm4 \n\t" |
"psubw %%mm7, %%mm5 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 |
"pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"psubw %%mm7, %%mm5 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
// test pa <= pb |
"movq %%mm4, %%mm7 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
"pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? |
"movq %%mm7, %%mm0 \n\t" |
// use mm7 mask to merge pa & pb |
"pand %%mm7, %%mm5 \n\t" |
// use mm0 mask copy to merge a & b |
"pand %%mm0, %%mm2 \n\t" |
"pandn %%mm4, %%mm7 \n\t" |
"pandn %%mm1, %%mm0 \n\t" |
"paddw %%mm5, %%mm7 \n\t" |
"paddw %%mm2, %%mm0 \n\t" |
// test ((pa <= pb)? pa:pb) <= pc |
"pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? |
"pxor %%mm1, %%mm1 \n\t" |
"pand %%mm7, %%mm3 \n\t" |
"pandn %%mm0, %%mm7 \n\t" |
"paddw %%mm3, %%mm7 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"packuswb %%mm1, %%mm7 \n\t" |
"movq -8(%%esi,%%ecx,), %%mm3 \n\t" // load c=Prior(x-bpp) |
"pand _ActiveMask, %%mm7 \n\t" |
"psrlq _ShiftRem, %%mm3 \n\t" |
"movq (%%esi,%%ecx,), %%mm2 \n\t" // load b=Prior(x) step 1 |
"paddb (%%edi,%%ecx,), %%mm7 \n\t" // add Paeth predictor and Raw(x) |
"movq %%mm2, %%mm6 \n\t" |
"movq %%mm7, (%%edi,%%ecx,) \n\t" // write back updated value |
"movq -8(%%edi,%%ecx,), %%mm1 \n\t" |
"psllq _ShiftBpp, %%mm6 \n\t" |
"movq %%mm7, %%mm5 \n\t" |
"psrlq _ShiftRem, %%mm1 \n\t" |
"por %%mm6, %%mm3 \n\t" |
"psllq _ShiftBpp, %%mm5 \n\t" |
"punpckhbw %%mm0, %%mm3 \n\t" // unpack High bytes of c |
"por %%mm5, %%mm1 \n\t" |
// do second set of 4 bytes |
"punpckhbw %%mm0, %%mm2 \n\t" // unpack High bytes of b |
"punpckhbw %%mm0, %%mm1 \n\t" // unpack High bytes of a |
// pav = p - a = (a + b - c) - a = b - c |
"movq %%mm2, %%mm4 \n\t" |
// pbv = p - b = (a + b - c) - b = a - c |
"movq %%mm1, %%mm5 \n\t" |
"psubw %%mm3, %%mm4 \n\t" |
"pxor %%mm7, %%mm7 \n\t" |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
"movq %%mm4, %%mm6 \n\t" |
"psubw %%mm3, %%mm5 \n\t" |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
"pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 |
"paddw %%mm5, %%mm6 \n\t" |
"pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 |
"psubw %%mm0, %%mm4 \n\t" |
"pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 |
"psubw %%mm0, %%mm4 \n\t" |
"psubw %%mm7, %%mm5 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 |
"pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"psubw %%mm7, %%mm5 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
// test pa <= pb |
"movq %%mm4, %%mm7 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
"pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? |
"movq %%mm7, %%mm0 \n\t" |
// use mm7 mask to merge pa & pb |
"pand %%mm7, %%mm5 \n\t" |
// use mm0 mask copy to merge a & b |
"pand %%mm0, %%mm2 \n\t" |
"pandn %%mm4, %%mm7 \n\t" |
"pandn %%mm1, %%mm0 \n\t" |
"paddw %%mm5, %%mm7 \n\t" |
"paddw %%mm2, %%mm0 \n\t" |
// test ((pa <= pb)? pa:pb) <= pc |
"pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? |
"pxor %%mm1, %%mm1 \n\t" |
"pand %%mm7, %%mm3 \n\t" |
"pandn %%mm0, %%mm7 \n\t" |
"pxor %%mm1, %%mm1 \n\t" |
"paddw %%mm3, %%mm7 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
// step ecx to next set of 8 bytes and repeat loop til done |
"addl $8, %%ecx \n\t" |
"packuswb %%mm7, %%mm1 \n\t" |
"paddb -8(%%edi,%%ecx,), %%mm1 \n\t" // add Paeth predictor with Raw(x) |
"cmpl _MMXLength, %%ecx \n\t" |
"movq %%mm1, -8(%%edi,%%ecx,) \n\t" // write back updated value |
// mm1 will be used as Raw(x-bpp) next loop |
"jb paeth_6lp \n\t" |
: "=S" (dummy_value_S), // output regs (dummy) |
"=D" (dummy_value_D) |
: "0" (prev_row), // esi // input regs |
"1" (row) // edi |
: "%ecx" // clobber list |
#if 0 /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
, "%mm0", "%mm1", "%mm2", "%mm3" |
, "%mm4", "%mm5", "%mm6", "%mm7" |
#endif |
); |
} |
break; // end 6 bpp |
case 4: |
{ |
_ActiveMask.use = 0x00000000ffffffffLL; |
__asm__ __volatile__ ( |
"movl _dif, %%ecx \n\t" |
// preload "movl row, %%edi \n\t" |
// preload "movl prev_row, %%esi \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
// prime the pump: load the first Raw(x-bpp) data set |
"movq -8(%%edi,%%ecx,), %%mm1 \n\t" // only time should need to read |
// a=Raw(x-bpp) bytes |
"paeth_4lp: \n\t" |
// do first set of 4 bytes |
"movq -8(%%esi,%%ecx,), %%mm3 \n\t" // read c=Prior(x-bpp) bytes |
"punpckhbw %%mm0, %%mm1 \n\t" // unpack Low bytes of a |
"movq (%%esi,%%ecx,), %%mm2 \n\t" // load b=Prior(x) |
"punpcklbw %%mm0, %%mm2 \n\t" // unpack High bytes of b |
// pav = p - a = (a + b - c) - a = b - c |
"movq %%mm2, %%mm4 \n\t" |
"punpckhbw %%mm0, %%mm3 \n\t" // unpack High bytes of c |
// pbv = p - b = (a + b - c) - b = a - c |
"movq %%mm1, %%mm5 \n\t" |
"psubw %%mm3, %%mm4 \n\t" |
"pxor %%mm7, %%mm7 \n\t" |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
"movq %%mm4, %%mm6 \n\t" |
"psubw %%mm3, %%mm5 \n\t" |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
"pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 |
"paddw %%mm5, %%mm6 \n\t" |
"pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 |
"psubw %%mm0, %%mm4 \n\t" |
"pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 |
"psubw %%mm0, %%mm4 \n\t" |
"psubw %%mm7, %%mm5 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 |
"pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"psubw %%mm7, %%mm5 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
// test pa <= pb |
"movq %%mm4, %%mm7 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
"pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? |
"movq %%mm7, %%mm0 \n\t" |
// use mm7 mask to merge pa & pb |
"pand %%mm7, %%mm5 \n\t" |
// use mm0 mask copy to merge a & b |
"pand %%mm0, %%mm2 \n\t" |
"pandn %%mm4, %%mm7 \n\t" |
"pandn %%mm1, %%mm0 \n\t" |
"paddw %%mm5, %%mm7 \n\t" |
"paddw %%mm2, %%mm0 \n\t" |
// test ((pa <= pb)? pa:pb) <= pc |
"pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? |
"pxor %%mm1, %%mm1 \n\t" |
"pand %%mm7, %%mm3 \n\t" |
"pandn %%mm0, %%mm7 \n\t" |
"paddw %%mm3, %%mm7 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"packuswb %%mm1, %%mm7 \n\t" |
"movq (%%esi,%%ecx,), %%mm3 \n\t" // load c=Prior(x-bpp) |
"pand _ActiveMask, %%mm7 \n\t" |
"movq %%mm3, %%mm2 \n\t" // load b=Prior(x) step 1 |
"paddb (%%edi,%%ecx,), %%mm7 \n\t" // add Paeth predictor with Raw(x) |
"punpcklbw %%mm0, %%mm3 \n\t" // unpack High bytes of c |
"movq %%mm7, (%%edi,%%ecx,) \n\t" // write back updated value |
"movq %%mm7, %%mm1 \n\t" // now mm1 will be used as Raw(x-bpp) |
// do second set of 4 bytes |
"punpckhbw %%mm0, %%mm2 \n\t" // unpack Low bytes of b |
"punpcklbw %%mm0, %%mm1 \n\t" // unpack Low bytes of a |
// pav = p - a = (a + b - c) - a = b - c |
"movq %%mm2, %%mm4 \n\t" |
// pbv = p - b = (a + b - c) - b = a - c |
"movq %%mm1, %%mm5 \n\t" |
"psubw %%mm3, %%mm4 \n\t" |
"pxor %%mm7, %%mm7 \n\t" |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
"movq %%mm4, %%mm6 \n\t" |
"psubw %%mm3, %%mm5 \n\t" |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
"pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 |
"paddw %%mm5, %%mm6 \n\t" |
"pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 |
"psubw %%mm0, %%mm4 \n\t" |
"pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 |
"psubw %%mm0, %%mm4 \n\t" |
"psubw %%mm7, %%mm5 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 |
"pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"psubw %%mm7, %%mm5 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
// test pa <= pb |
"movq %%mm4, %%mm7 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
"pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? |
"movq %%mm7, %%mm0 \n\t" |
// use mm7 mask to merge pa & pb |
"pand %%mm7, %%mm5 \n\t" |
// use mm0 mask copy to merge a & b |
"pand %%mm0, %%mm2 \n\t" |
"pandn %%mm4, %%mm7 \n\t" |
"pandn %%mm1, %%mm0 \n\t" |
"paddw %%mm5, %%mm7 \n\t" |
"paddw %%mm2, %%mm0 \n\t" |
// test ((pa <= pb)? pa:pb) <= pc |
"pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? |
"pxor %%mm1, %%mm1 \n\t" |
"pand %%mm7, %%mm3 \n\t" |
"pandn %%mm0, %%mm7 \n\t" |
"pxor %%mm1, %%mm1 \n\t" |
"paddw %%mm3, %%mm7 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
// step ecx to next set of 8 bytes and repeat loop til done |
"addl $8, %%ecx \n\t" |
"packuswb %%mm7, %%mm1 \n\t" |
"paddb -8(%%edi,%%ecx,), %%mm1 \n\t" // add predictor with Raw(x) |
"cmpl _MMXLength, %%ecx \n\t" |
"movq %%mm1, -8(%%edi,%%ecx,) \n\t" // write back updated value |
// mm1 will be used as Raw(x-bpp) next loop |
"jb paeth_4lp \n\t" |
: "=S" (dummy_value_S), // output regs (dummy) |
"=D" (dummy_value_D) |
: "0" (prev_row), // esi // input regs |
"1" (row) // edi |
: "%ecx" // clobber list |
#if 0 /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
, "%mm0", "%mm1", "%mm2", "%mm3" |
, "%mm4", "%mm5", "%mm6", "%mm7" |
#endif |
); |
} |
break; // end 4 bpp |
case 8: // bpp == 8 |
{ |
_ActiveMask.use = 0x00000000ffffffffLL; |
__asm__ __volatile__ ( |
"movl _dif, %%ecx \n\t" |
// preload "movl row, %%edi \n\t" |
// preload "movl prev_row, %%esi \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
// prime the pump: load the first Raw(x-bpp) data set |
"movq -8(%%edi,%%ecx,), %%mm1 \n\t" // only time should need to read |
// a=Raw(x-bpp) bytes |
"paeth_8lp: \n\t" |
// do first set of 4 bytes |
"movq -8(%%esi,%%ecx,), %%mm3 \n\t" // read c=Prior(x-bpp) bytes |
"punpcklbw %%mm0, %%mm1 \n\t" // unpack Low bytes of a |
"movq (%%esi,%%ecx,), %%mm2 \n\t" // load b=Prior(x) |
"punpcklbw %%mm0, %%mm2 \n\t" // unpack Low bytes of b |
// pav = p - a = (a + b - c) - a = b - c |
"movq %%mm2, %%mm4 \n\t" |
"punpcklbw %%mm0, %%mm3 \n\t" // unpack Low bytes of c |
// pbv = p - b = (a + b - c) - b = a - c |
"movq %%mm1, %%mm5 \n\t" |
"psubw %%mm3, %%mm4 \n\t" |
"pxor %%mm7, %%mm7 \n\t" |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
"movq %%mm4, %%mm6 \n\t" |
"psubw %%mm3, %%mm5 \n\t" |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
"pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 |
"paddw %%mm5, %%mm6 \n\t" |
"pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 |
"psubw %%mm0, %%mm4 \n\t" |
"pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 |
"psubw %%mm0, %%mm4 \n\t" |
"psubw %%mm7, %%mm5 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 |
"pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"psubw %%mm7, %%mm5 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
// test pa <= pb |
"movq %%mm4, %%mm7 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
"pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? |
"movq %%mm7, %%mm0 \n\t" |
// use mm7 mask to merge pa & pb |
"pand %%mm7, %%mm5 \n\t" |
// use mm0 mask copy to merge a & b |
"pand %%mm0, %%mm2 \n\t" |
"pandn %%mm4, %%mm7 \n\t" |
"pandn %%mm1, %%mm0 \n\t" |
"paddw %%mm5, %%mm7 \n\t" |
"paddw %%mm2, %%mm0 \n\t" |
// test ((pa <= pb)? pa:pb) <= pc |
"pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? |
"pxor %%mm1, %%mm1 \n\t" |
"pand %%mm7, %%mm3 \n\t" |
"pandn %%mm0, %%mm7 \n\t" |
"paddw %%mm3, %%mm7 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"packuswb %%mm1, %%mm7 \n\t" |
"movq -8(%%esi,%%ecx,), %%mm3 \n\t" // read c=Prior(x-bpp) bytes |
"pand _ActiveMask, %%mm7 \n\t" |
"movq (%%esi,%%ecx,), %%mm2 \n\t" // load b=Prior(x) |
"paddb (%%edi,%%ecx,), %%mm7 \n\t" // add Paeth predictor with Raw(x) |
"punpckhbw %%mm0, %%mm3 \n\t" // unpack High bytes of c |
"movq %%mm7, (%%edi,%%ecx,) \n\t" // write back updated value |
"movq -8(%%edi,%%ecx,), %%mm1 \n\t" // read a=Raw(x-bpp) bytes |
// do second set of 4 bytes |
"punpckhbw %%mm0, %%mm2 \n\t" // unpack High bytes of b |
"punpckhbw %%mm0, %%mm1 \n\t" // unpack High bytes of a |
// pav = p - a = (a + b - c) - a = b - c |
"movq %%mm2, %%mm4 \n\t" |
// pbv = p - b = (a + b - c) - b = a - c |
"movq %%mm1, %%mm5 \n\t" |
"psubw %%mm3, %%mm4 \n\t" |
"pxor %%mm7, %%mm7 \n\t" |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
"movq %%mm4, %%mm6 \n\t" |
"psubw %%mm3, %%mm5 \n\t" |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
"pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 |
"paddw %%mm5, %%mm6 \n\t" |
"pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 |
"psubw %%mm0, %%mm4 \n\t" |
"pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 |
"psubw %%mm0, %%mm4 \n\t" |
"psubw %%mm7, %%mm5 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 |
"pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"psubw %%mm7, %%mm5 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
// test pa <= pb |
"movq %%mm4, %%mm7 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
"pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? |
"movq %%mm7, %%mm0 \n\t" |
// use mm7 mask to merge pa & pb |
"pand %%mm7, %%mm5 \n\t" |
// use mm0 mask copy to merge a & b |
"pand %%mm0, %%mm2 \n\t" |
"pandn %%mm4, %%mm7 \n\t" |
"pandn %%mm1, %%mm0 \n\t" |
"paddw %%mm5, %%mm7 \n\t" |
"paddw %%mm2, %%mm0 \n\t" |
// test ((pa <= pb)? pa:pb) <= pc |
"pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? |
"pxor %%mm1, %%mm1 \n\t" |
"pand %%mm7, %%mm3 \n\t" |
"pandn %%mm0, %%mm7 \n\t" |
"pxor %%mm1, %%mm1 \n\t" |
"paddw %%mm3, %%mm7 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
// step ecx to next set of 8 bytes and repeat loop til done |
"addl $8, %%ecx \n\t" |
"packuswb %%mm7, %%mm1 \n\t" |
"paddb -8(%%edi,%%ecx,), %%mm1 \n\t" // add Paeth predictor with Raw(x) |
"cmpl _MMXLength, %%ecx \n\t" |
"movq %%mm1, -8(%%edi,%%ecx,) \n\t" // write back updated value |
// mm1 will be used as Raw(x-bpp) next loop |
"jb paeth_8lp \n\t" |
: "=S" (dummy_value_S), // output regs (dummy) |
"=D" (dummy_value_D) |
: "0" (prev_row), // esi // input regs |
"1" (row) // edi |
: "%ecx" // clobber list |
#if 0 /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
, "%mm0", "%mm1", "%mm2", "%mm3" |
, "%mm4", "%mm5", "%mm6", "%mm7" |
#endif |
); |
} |
break; // end 8 bpp |
case 1: // bpp = 1 |
case 2: // bpp = 2 |
default: // bpp > 8 |
{ |
__asm__ __volatile__ ( |
#ifdef __PIC__ |
"pushl %%ebx \n\t" // save Global Offset Table index |
#endif |
"movl _dif, %%ebx \n\t" |
"cmpl _FullLength, %%ebx \n\t" |
"jnb paeth_dend \n\t" |
// preload "movl row, %%edi \n\t" |
// preload "movl prev_row, %%esi \n\t" |
// do Paeth decode for remaining bytes |
"movl %%ebx, %%edx \n\t" |
// preload "subl bpp, %%edx \n\t" // (bpp is preloaded into ecx) |
"subl %%ecx, %%edx \n\t" // edx = ebx - bpp |
"xorl %%ecx, %%ecx \n\t" // zero ecx before using cl & cx |
"paeth_dlp: \n\t" |
"xorl %%eax, %%eax \n\t" |
// pav = p - a = (a + b - c) - a = b - c |
"movb (%%esi,%%ebx,), %%al \n\t" // load Prior(x) into al |
"movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl |
"subl %%ecx, %%eax \n\t" // subtract Prior(x-bpp) |
"movl %%eax, _patemp \n\t" // Save pav for later use |
"xorl %%eax, %%eax \n\t" |
// pbv = p - b = (a + b - c) - b = a - c |
"movb (%%edi,%%edx,), %%al \n\t" // load Raw(x-bpp) into al |
"subl %%ecx, %%eax \n\t" // subtract Prior(x-bpp) |
"movl %%eax, %%ecx \n\t" |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
"addl _patemp, %%eax \n\t" // pcv = pav + pbv |
// pc = abs(pcv) |
"testl $0x80000000, %%eax \n\t" |
"jz paeth_dpca \n\t" |
"negl %%eax \n\t" // reverse sign of neg values |
"paeth_dpca: \n\t" |
"movl %%eax, _pctemp \n\t" // save pc for later use |
// pb = abs(pbv) |
"testl $0x80000000, %%ecx \n\t" |
"jz paeth_dpba \n\t" |
"negl %%ecx \n\t" // reverse sign of neg values |
"paeth_dpba: \n\t" |
"movl %%ecx, _pbtemp \n\t" // save pb for later use |
// pa = abs(pav) |
"movl _patemp, %%eax \n\t" |
"testl $0x80000000, %%eax \n\t" |
"jz paeth_dpaa \n\t" |
"negl %%eax \n\t" // reverse sign of neg values |
"paeth_dpaa: \n\t" |
"movl %%eax, _patemp \n\t" // save pa for later use |
// test if pa <= pb |
"cmpl %%ecx, %%eax \n\t" |
"jna paeth_dabb \n\t" |
// pa > pb; now test if pb <= pc |
"cmpl _pctemp, %%ecx \n\t" |
"jna paeth_dbbc \n\t" |
// pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp) |
"movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl |
"jmp paeth_dpaeth \n\t" |
"paeth_dbbc: \n\t" |
// pb <= pc; Raw(x) = Paeth(x) + Prior(x) |
"movb (%%esi,%%ebx,), %%cl \n\t" // load Prior(x) into cl |
"jmp paeth_dpaeth \n\t" |
"paeth_dabb: \n\t" |
// pa <= pb; now test if pa <= pc |
"cmpl _pctemp, %%eax \n\t" |
"jna paeth_dabc \n\t" |
// pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp) |
"movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl |
"jmp paeth_dpaeth \n\t" |
"paeth_dabc: \n\t" |
// pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp) |
"movb (%%edi,%%edx,), %%cl \n\t" // load Raw(x-bpp) into cl |
"paeth_dpaeth: \n\t" |
"incl %%ebx \n\t" |
"incl %%edx \n\t" |
// Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256 |
"addb %%cl, -1(%%edi,%%ebx,) \n\t" |
"cmpl _FullLength, %%ebx \n\t" |
"jb paeth_dlp \n\t" |
"paeth_dend: \n\t" |
#ifdef __PIC__ |
"popl %%ebx \n\t" // index to Global Offset Table |
#endif |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "0" (bpp), // ecx // input regs |
"1" (prev_row), // esi |
"2" (row) // edi |
: "%eax", "%edx" // clobber list |
#ifndef __PIC__ |
, "%ebx" |
#endif |
); |
} |
return; // No need to go further with this one |
} // end switch (bpp) |
__asm__ __volatile__ ( |
// MMX acceleration complete; now do clean-up |
// check if any remaining bytes left to decode |
#ifdef __PIC__ |
"pushl %%ebx \n\t" // save index to Global Offset Table |
#endif |
"movl _MMXLength, %%ebx \n\t" |
"cmpl _FullLength, %%ebx \n\t" |
"jnb paeth_end \n\t" |
//pre "movl row, %%edi \n\t" |
//pre "movl prev_row, %%esi \n\t" |
// do Paeth decode for remaining bytes |
"movl %%ebx, %%edx \n\t" |
//pre "subl bpp, %%edx \n\t" // (bpp is preloaded into ecx) |
"subl %%ecx, %%edx \n\t" // edx = ebx - bpp |
"xorl %%ecx, %%ecx \n\t" // zero ecx before using cl & cx below |
"paeth_lp2: \n\t" |
"xorl %%eax, %%eax \n\t" |
// pav = p - a = (a + b - c) - a = b - c |
"movb (%%esi,%%ebx,), %%al \n\t" // load Prior(x) into al |
"movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl |
"subl %%ecx, %%eax \n\t" // subtract Prior(x-bpp) |
"movl %%eax, _patemp \n\t" // Save pav for later use |
"xorl %%eax, %%eax \n\t" |
// pbv = p - b = (a + b - c) - b = a - c |
"movb (%%edi,%%edx,), %%al \n\t" // load Raw(x-bpp) into al |
"subl %%ecx, %%eax \n\t" // subtract Prior(x-bpp) |
"movl %%eax, %%ecx \n\t" |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
"addl _patemp, %%eax \n\t" // pcv = pav + pbv |
// pc = abs(pcv) |
"testl $0x80000000, %%eax \n\t" |
"jz paeth_pca2 \n\t" |
"negl %%eax \n\t" // reverse sign of neg values |
"paeth_pca2: \n\t" |
"movl %%eax, _pctemp \n\t" // save pc for later use |
// pb = abs(pbv) |
"testl $0x80000000, %%ecx \n\t" |
"jz paeth_pba2 \n\t" |
"negl %%ecx \n\t" // reverse sign of neg values |
"paeth_pba2: \n\t" |
"movl %%ecx, _pbtemp \n\t" // save pb for later use |
// pa = abs(pav) |
"movl _patemp, %%eax \n\t" |
"testl $0x80000000, %%eax \n\t" |
"jz paeth_paa2 \n\t" |
"negl %%eax \n\t" // reverse sign of neg values |
"paeth_paa2: \n\t" |
"movl %%eax, _patemp \n\t" // save pa for later use |
// test if pa <= pb |
"cmpl %%ecx, %%eax \n\t" |
"jna paeth_abb2 \n\t" |
// pa > pb; now test if pb <= pc |
"cmpl _pctemp, %%ecx \n\t" |
"jna paeth_bbc2 \n\t" |
// pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp) |
"movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl |
"jmp paeth_paeth2 \n\t" |
"paeth_bbc2: \n\t" |
// pb <= pc; Raw(x) = Paeth(x) + Prior(x) |
"movb (%%esi,%%ebx,), %%cl \n\t" // load Prior(x) into cl |
"jmp paeth_paeth2 \n\t" |
"paeth_abb2: \n\t" |
// pa <= pb; now test if pa <= pc |
"cmpl _pctemp, %%eax \n\t" |
"jna paeth_abc2 \n\t" |
// pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp) |
"movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl |
"jmp paeth_paeth2 \n\t" |
"paeth_abc2: \n\t" |
// pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp) |
"movb (%%edi,%%edx,), %%cl \n\t" // load Raw(x-bpp) into cl |
"paeth_paeth2: \n\t" |
"incl %%ebx \n\t" |
"incl %%edx \n\t" |
// Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256 |
"addb %%cl, -1(%%edi,%%ebx,) \n\t" |
"cmpl _FullLength, %%ebx \n\t" |
"jb paeth_lp2 \n\t" |
"paeth_end: \n\t" |
"EMMS \n\t" // end MMX; prep for poss. FP instrs. |
#ifdef __PIC__ |
"popl %%ebx \n\t" // restore index to Global Offset Table |
#endif |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "0" (bpp), // ecx // input regs |
"1" (prev_row), // esi |
"2" (row) // edi |
: "%eax", "%edx" // clobber list (no input regs!) |
#ifndef __PIC__ |
, "%ebx" |
#endif |
); |
} /* end png_read_filter_row_mmx_paeth() */ |
#endif |
#ifdef PNG_THREAD_UNSAFE_OK |
//===========================================================================// |
// // |
// P N G _ R E A D _ F I L T E R _ R O W _ M M X _ S U B // |
// // |
//===========================================================================// |
// Optimized code for PNG Sub filter decoder |
static void /* PRIVATE */ |
png_read_filter_row_mmx_sub(png_row_infop row_info, png_bytep row) |
{ |
int bpp; |
int dummy_value_a; |
int dummy_value_D; |
bpp = (row_info->pixel_depth + 7) >> 3; // calc number of bytes per pixel |
_FullLength = row_info->rowbytes - bpp; // number of bytes to filter |
__asm__ __volatile__ ( |
//pre "movl row, %%edi \n\t" |
"movl %%edi, %%esi \n\t" // lp = row |
//pre "movl bpp, %%eax \n\t" |
"addl %%eax, %%edi \n\t" // rp = row + bpp |
//irr "xorl %%eax, %%eax \n\t" |
// get # of bytes to alignment |
"movl %%edi, _dif \n\t" // take start of row |
"addl $0xf, _dif \n\t" // add 7 + 8 to incr past |
// alignment boundary |
"xorl %%ecx, %%ecx \n\t" |
"andl $0xfffffff8, _dif \n\t" // mask to alignment boundary |
"subl %%edi, _dif \n\t" // subtract from start ==> value |
"jz sub_go \n\t" // ecx at alignment |
"sub_lp1: \n\t" // fix alignment |
"movb (%%esi,%%ecx,), %%al \n\t" |
"addb %%al, (%%edi,%%ecx,) \n\t" |
"incl %%ecx \n\t" |
"cmpl _dif, %%ecx \n\t" |
"jb sub_lp1 \n\t" |
"sub_go: \n\t" |
"movl _FullLength, %%eax \n\t" |
"movl %%eax, %%edx \n\t" |
"subl %%ecx, %%edx \n\t" // subtract alignment fix |
"andl $0x00000007, %%edx \n\t" // calc bytes over mult of 8 |
"subl %%edx, %%eax \n\t" // drop over bytes from length |
"movl %%eax, _MMXLength \n\t" |
: "=a" (dummy_value_a), // 0 // output regs (dummy) |
"=D" (dummy_value_D) // 1 |
: "0" (bpp), // eax // input regs |
"1" (row) // edi |
: "%ebx", "%ecx", "%edx" // clobber list |
, "%esi" |
#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ |
, "%mm0", "%mm1", "%mm2", "%mm3" |
, "%mm4", "%mm5", "%mm6", "%mm7" |
#endif |
); |
// now do the math for the rest of the row |
switch (bpp) |
{ |
case 3: |
{ |
_ActiveMask.use = 0x0000ffffff000000LL; |
_ShiftBpp.use = 24; // == 3 * 8 |
_ShiftRem.use = 40; // == 64 - 24 |
__asm__ __volatile__ ( |
// preload "movl row, %%edi \n\t" |
"movq _ActiveMask, %%mm7 \n\t" // load _ActiveMask for 2nd |
// active byte group |
"movl %%edi, %%esi \n\t" // lp = row |
// preload "movl bpp, %%eax \n\t" |
"addl %%eax, %%edi \n\t" // rp = row + bpp |
"movq %%mm7, %%mm6 \n\t" |
"movl _dif, %%edx \n\t" |
"psllq _ShiftBpp, %%mm6 \n\t" // move mask in mm6 to cover |
// 3rd active byte group |
// prime the pump: load the first Raw(x-bpp) data set |
"movq -8(%%edi,%%edx,), %%mm1 \n\t" |
"sub_3lp: \n\t" // shift data for adding first |
"psrlq _ShiftRem, %%mm1 \n\t" // bpp bytes (no need for mask; |
// shift clears inactive bytes) |
// add 1st active group |
"movq (%%edi,%%edx,), %%mm0 \n\t" |
"paddb %%mm1, %%mm0 \n\t" |
// add 2nd active group |
"movq %%mm0, %%mm1 \n\t" // mov updated Raws to mm1 |
"psllq _ShiftBpp, %%mm1 \n\t" // shift data to pos. correctly |
"pand %%mm7, %%mm1 \n\t" // mask to use 2nd active group |
"paddb %%mm1, %%mm0 \n\t" |
// add 3rd active group |
"movq %%mm0, %%mm1 \n\t" // mov updated Raws to mm1 |
"psllq _ShiftBpp, %%mm1 \n\t" // shift data to pos. correctly |
"pand %%mm6, %%mm1 \n\t" // mask to use 3rd active group |
"addl $8, %%edx \n\t" |
"paddb %%mm1, %%mm0 \n\t" |
"cmpl _MMXLength, %%edx \n\t" |
"movq %%mm0, -8(%%edi,%%edx,) \n\t" // write updated Raws to array |
"movq %%mm0, %%mm1 \n\t" // prep 1st add at top of loop |
"jb sub_3lp \n\t" |
: "=a" (dummy_value_a), // 0 // output regs (dummy) |
"=D" (dummy_value_D) // 1 |
: "0" (bpp), // eax // input regs |
"1" (row) // edi |
: "%edx", "%esi" // clobber list |
#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ |
, "%mm0", "%mm1", "%mm6", "%mm7" |
#endif |
); |
} |
break; |
case 1: |
{ |
__asm__ __volatile__ ( |
"movl _dif, %%edx \n\t" |
// preload "movl row, %%edi \n\t" |
"cmpl _FullLength, %%edx \n\t" |
"jnb sub_1end \n\t" |
"movl %%edi, %%esi \n\t" // lp = row |
"xorl %%eax, %%eax \n\t" |
// preload "movl bpp, %%eax \n\t" |
"addl %%eax, %%edi \n\t" // rp = row + bpp |
"sub_1lp: \n\t" |
"movb (%%esi,%%edx,), %%al \n\t" |
"addb %%al, (%%edi,%%edx,) \n\t" |
"incl %%edx \n\t" |
"cmpl _FullLength, %%edx \n\t" |
"jb sub_1lp \n\t" |
"sub_1end: \n\t" |
: "=a" (dummy_value_a), // 0 // output regs (dummy) |
"=D" (dummy_value_D) // 1 |
: "0" (bpp), // eax // input regs |
"1" (row) // edi |
: "%edx", "%esi" // clobber list |
); |
} |
return; |
case 6: |
case 4: |
//case 7: // GRR BOGUS |
//case 5: // GRR BOGUS |
{ |
_ShiftBpp.use = bpp << 3; |
_ShiftRem.use = 64 - _ShiftBpp.use; |
__asm__ __volatile__ ( |
// preload "movl row, %%edi \n\t" |
"movl _dif, %%edx \n\t" |
"movl %%edi, %%esi \n\t" // lp = row |
// preload "movl bpp, %%eax \n\t" |
"addl %%eax, %%edi \n\t" // rp = row + bpp |
// prime the pump: load the first Raw(x-bpp) data set |
"movq -8(%%edi,%%edx,), %%mm1 \n\t" |
"sub_4lp: \n\t" // shift data for adding first |
"psrlq _ShiftRem, %%mm1 \n\t" // bpp bytes (no need for mask; |
// shift clears inactive bytes) |
"movq (%%edi,%%edx,), %%mm0 \n\t" |
"paddb %%mm1, %%mm0 \n\t" |
// add 2nd active group |
"movq %%mm0, %%mm1 \n\t" // mov updated Raws to mm1 |
"psllq _ShiftBpp, %%mm1 \n\t" // shift data to pos. correctly |
"addl $8, %%edx \n\t" |
"paddb %%mm1, %%mm0 \n\t" |
"cmpl _MMXLength, %%edx \n\t" |
"movq %%mm0, -8(%%edi,%%edx,) \n\t" |
"movq %%mm0, %%mm1 \n\t" // prep 1st add at top of loop |
"jb sub_4lp \n\t" |
: "=a" (dummy_value_a), // 0 // output regs (dummy) |
"=D" (dummy_value_D) // 1 |
: "0" (bpp), // eax // input regs |
"1" (row) // edi |
: "%edx", "%esi" // clobber list |
#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ |
, "%mm0", "%mm1" |
#endif |
); |
} |
break; |
case 2: |
{ |
_ActiveMask.use = 0x00000000ffff0000LL; |
_ShiftBpp.use = 16; // == 2 * 8 |
_ShiftRem.use = 48; // == 64 - 16 |
__asm__ __volatile__ ( |
"movq _ActiveMask, %%mm7 \n\t" // load _ActiveMask for 2nd |
// active byte group |
"movl _dif, %%edx \n\t" |
"movq %%mm7, %%mm6 \n\t" |
// preload "movl row, %%edi \n\t" |
"psllq _ShiftBpp, %%mm6 \n\t" // move mask in mm6 to cover |
// 3rd active byte group |
"movl %%edi, %%esi \n\t" // lp = row |
"movq %%mm6, %%mm5 \n\t" |
// preload "movl bpp, %%eax \n\t" |
"addl %%eax, %%edi \n\t" // rp = row + bpp |
"psllq _ShiftBpp, %%mm5 \n\t" // move mask in mm5 to cover |
// 4th active byte group |
// prime the pump: load the first Raw(x-bpp) data set |
"movq -8(%%edi,%%edx,), %%mm1 \n\t" |
"sub_2lp: \n\t" // shift data for adding first |
"psrlq _ShiftRem, %%mm1 \n\t" // bpp bytes (no need for mask; |
// shift clears inactive bytes) |
// add 1st active group |
"movq (%%edi,%%edx,), %%mm0 \n\t" |
"paddb %%mm1, %%mm0 \n\t" |
// add 2nd active group |
"movq %%mm0, %%mm1 \n\t" // mov updated Raws to mm1 |
"psllq _ShiftBpp, %%mm1 \n\t" // shift data to pos. correctly |
"pand %%mm7, %%mm1 \n\t" // mask to use 2nd active group |
"paddb %%mm1, %%mm0 \n\t" |
// add 3rd active group |
"movq %%mm0, %%mm1 \n\t" // mov updated Raws to mm1 |
"psllq _ShiftBpp, %%mm1 \n\t" // shift data to pos. correctly |
"pand %%mm6, %%mm1 \n\t" // mask to use 3rd active group |
"paddb %%mm1, %%mm0 \n\t" |
// add 4th active group |
"movq %%mm0, %%mm1 \n\t" // mov updated Raws to mm1 |
"psllq _ShiftBpp, %%mm1 \n\t" // shift data to pos. correctly |
"pand %%mm5, %%mm1 \n\t" // mask to use 4th active group |
"addl $8, %%edx \n\t" |
"paddb %%mm1, %%mm0 \n\t" |
"cmpl _MMXLength, %%edx \n\t" |
"movq %%mm0, -8(%%edi,%%edx,) \n\t" // write updated Raws to array |
"movq %%mm0, %%mm1 \n\t" // prep 1st add at top of loop |
"jb sub_2lp \n\t" |
: "=a" (dummy_value_a), // 0 // output regs (dummy) |
"=D" (dummy_value_D) // 1 |
: "0" (bpp), // eax // input regs |
"1" (row) // edi |
: "%edx", "%esi" // clobber list |
#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ |
, "%mm0", "%mm1", "%mm5", "%mm6", "%mm7" |
#endif |
); |
} |
break; |
case 8: |
{ |
__asm__ __volatile__ ( |
// preload "movl row, %%edi \n\t" |
"movl _dif, %%edx \n\t" |
"movl %%edi, %%esi \n\t" // lp = row |
// preload "movl bpp, %%eax \n\t" |
"addl %%eax, %%edi \n\t" // rp = row + bpp |
"movl _MMXLength, %%ecx \n\t" |
// prime the pump: load the first Raw(x-bpp) data set |
"movq -8(%%edi,%%edx,), %%mm7 \n\t" |
"andl $0x0000003f, %%ecx \n\t" // calc bytes over mult of 64 |
"sub_8lp: \n\t" |
"movq (%%edi,%%edx,), %%mm0 \n\t" // load Sub(x) for 1st 8 bytes |
"paddb %%mm7, %%mm0 \n\t" |
"movq 8(%%edi,%%edx,), %%mm1 \n\t" // load Sub(x) for 2nd 8 bytes |
"movq %%mm0, (%%edi,%%edx,) \n\t" // write Raw(x) for 1st 8 bytes |
// Now mm0 will be used as Raw(x-bpp) for the 2nd group of 8 bytes. |
// This will be repeated for each group of 8 bytes with the 8th |
// group being used as the Raw(x-bpp) for the 1st group of the |
// next loop. |
"paddb %%mm0, %%mm1 \n\t" |
"movq 16(%%edi,%%edx,), %%mm2 \n\t" // load Sub(x) for 3rd 8 bytes |
"movq %%mm1, 8(%%edi,%%edx,) \n\t" // write Raw(x) for 2nd 8 bytes |
"paddb %%mm1, %%mm2 \n\t" |
"movq 24(%%edi,%%edx,), %%mm3 \n\t" // load Sub(x) for 4th 8 bytes |
"movq %%mm2, 16(%%edi,%%edx,) \n\t" // write Raw(x) for 3rd 8 bytes |
"paddb %%mm2, %%mm3 \n\t" |
"movq 32(%%edi,%%edx,), %%mm4 \n\t" // load Sub(x) for 5th 8 bytes |
"movq %%mm3, 24(%%edi,%%edx,) \n\t" // write Raw(x) for 4th 8 bytes |
"paddb %%mm3, %%mm4 \n\t" |
"movq 40(%%edi,%%edx,), %%mm5 \n\t" // load Sub(x) for 6th 8 bytes |
"movq %%mm4, 32(%%edi,%%edx,) \n\t" // write Raw(x) for 5th 8 bytes |
"paddb %%mm4, %%mm5 \n\t" |
"movq 48(%%edi,%%edx,), %%mm6 \n\t" // load Sub(x) for 7th 8 bytes |
"movq %%mm5, 40(%%edi,%%edx,) \n\t" // write Raw(x) for 6th 8 bytes |
"paddb %%mm5, %%mm6 \n\t" |
"movq 56(%%edi,%%edx,), %%mm7 \n\t" // load Sub(x) for 8th 8 bytes |
"movq %%mm6, 48(%%edi,%%edx,) \n\t" // write Raw(x) for 7th 8 bytes |
"addl $64, %%edx \n\t" |
"paddb %%mm6, %%mm7 \n\t" |
"cmpl %%ecx, %%edx \n\t" |
"movq %%mm7, -8(%%edi,%%edx,) \n\t" // write Raw(x) for 8th 8 bytes |
"jb sub_8lp \n\t" |
"cmpl _MMXLength, %%edx \n\t" |
"jnb sub_8lt8 \n\t" |
"sub_8lpA: \n\t" |
"movq (%%edi,%%edx,), %%mm0 \n\t" |
"addl $8, %%edx \n\t" |
"paddb %%mm7, %%mm0 \n\t" |
"cmpl _MMXLength, %%edx \n\t" |
"movq %%mm0, -8(%%edi,%%edx,) \n\t" // -8 to offset early addl edx |
"movq %%mm0, %%mm7 \n\t" // move calculated Raw(x) data |
// to mm1 to be new Raw(x-bpp) |
// for next loop |
"jb sub_8lpA \n\t" |
"sub_8lt8: \n\t" |
: "=a" (dummy_value_a), // 0 // output regs (dummy) |
"=D" (dummy_value_D) // 1 |
: "0" (bpp), // eax // input regs |
"1" (row) // edi |
: "%ecx", "%edx", "%esi" // clobber list |
#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ |
, "%mm0", "%mm1", "%mm2", "%mm3", "%mm4", "%mm5", "%mm6", "%mm7" |
#endif |
); |
} |
break; |
default: // bpp greater than 8 bytes GRR BOGUS |
{ |
__asm__ __volatile__ ( |
"movl _dif, %%edx \n\t" |
// preload "movl row, %%edi \n\t" |
"movl %%edi, %%esi \n\t" // lp = row |
// preload "movl bpp, %%eax \n\t" |
"addl %%eax, %%edi \n\t" // rp = row + bpp |
"sub_Alp: \n\t" |
"movq (%%edi,%%edx,), %%mm0 \n\t" |
"movq (%%esi,%%edx,), %%mm1 \n\t" |
"addl $8, %%edx \n\t" |
"paddb %%mm1, %%mm0 \n\t" |
"cmpl _MMXLength, %%edx \n\t" |
"movq %%mm0, -8(%%edi,%%edx,) \n\t" // mov does not affect flags; |
// -8 to offset addl edx |
"jb sub_Alp \n\t" |
: "=a" (dummy_value_a), // 0 // output regs (dummy) |
"=D" (dummy_value_D) // 1 |
: "0" (bpp), // eax // input regs |
"1" (row) // edi |
: "%edx", "%esi" // clobber list |
#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ |
, "%mm0", "%mm1" |
#endif |
); |
} |
break; |
} // end switch (bpp) |
__asm__ __volatile__ ( |
"movl _MMXLength, %%edx \n\t" |
//pre "movl row, %%edi \n\t" |
"cmpl _FullLength, %%edx \n\t" |
"jnb sub_end \n\t" |
"movl %%edi, %%esi \n\t" // lp = row |
//pre "movl bpp, %%eax \n\t" |
"addl %%eax, %%edi \n\t" // rp = row + bpp |
"xorl %%eax, %%eax \n\t" |
"sub_lp2: \n\t" |
"movb (%%esi,%%edx,), %%al \n\t" |
"addb %%al, (%%edi,%%edx,) \n\t" |
"incl %%edx \n\t" |
"cmpl _FullLength, %%edx \n\t" |
"jb sub_lp2 \n\t" |
"sub_end: \n\t" |
"EMMS \n\t" // end MMX instructions |
: "=a" (dummy_value_a), // 0 // output regs (dummy) |
"=D" (dummy_value_D) // 1 |
: "0" (bpp), // eax // input regs |
"1" (row) // edi |
: "%edx", "%esi" // clobber list |
); |
} // end of png_read_filter_row_mmx_sub() |
#endif |
//===========================================================================// |
// // |
// P N G _ R E A D _ F I L T E R _ R O W _ M M X _ U P // |
// // |
//===========================================================================// |
// Optimized code for PNG Up filter decoder |
static void /* PRIVATE */ |
png_read_filter_row_mmx_up(png_row_infop row_info, png_bytep row, |
png_bytep prev_row) |
{ |
png_uint_32 len; |
int dummy_value_d; // fix 'forbidden register 3 (dx) was spilled' error |
int dummy_value_S; |
int dummy_value_D; |
len = row_info->rowbytes; // number of bytes to filter |
__asm__ __volatile__ ( |
//pre "movl row, %%edi \n\t" |
// get # of bytes to alignment |
#ifdef __PIC__ |
"pushl %%ebx \n\t" |
#endif |
"movl %%edi, %%ecx \n\t" |
"xorl %%ebx, %%ebx \n\t" |
"addl $0x7, %%ecx \n\t" |
"xorl %%eax, %%eax \n\t" |
"andl $0xfffffff8, %%ecx \n\t" |
//pre "movl prev_row, %%esi \n\t" |
"subl %%edi, %%ecx \n\t" |
"jz up_go \n\t" |
"up_lp1: \n\t" // fix alignment |
"movb (%%edi,%%ebx,), %%al \n\t" |
"addb (%%esi,%%ebx,), %%al \n\t" |
"incl %%ebx \n\t" |
"cmpl %%ecx, %%ebx \n\t" |
"movb %%al, -1(%%edi,%%ebx,) \n\t" // mov does not affect flags; -1 to |
"jb up_lp1 \n\t" // offset incl ebx |
"up_go: \n\t" |
//pre "movl len, %%edx \n\t" |
"movl %%edx, %%ecx \n\t" |
"subl %%ebx, %%edx \n\t" // subtract alignment fix |
"andl $0x0000003f, %%edx \n\t" // calc bytes over mult of 64 |
"subl %%edx, %%ecx \n\t" // drop over bytes from length |
// unrolled loop - use all MMX registers and interleave to reduce |
// number of branch instructions (loops) and reduce partial stalls |
"up_loop: \n\t" |
"movq (%%esi,%%ebx,), %%mm1 \n\t" |
"movq (%%edi,%%ebx,), %%mm0 \n\t" |
"movq 8(%%esi,%%ebx,), %%mm3 \n\t" |
"paddb %%mm1, %%mm0 \n\t" |
"movq 8(%%edi,%%ebx,), %%mm2 \n\t" |
"movq %%mm0, (%%edi,%%ebx,) \n\t" |
"paddb %%mm3, %%mm2 \n\t" |
"movq 16(%%esi,%%ebx,), %%mm5 \n\t" |
"movq %%mm2, 8(%%edi,%%ebx,) \n\t" |
"movq 16(%%edi,%%ebx,), %%mm4 \n\t" |
"movq 24(%%esi,%%ebx,), %%mm7 \n\t" |
"paddb %%mm5, %%mm4 \n\t" |
"movq 24(%%edi,%%ebx,), %%mm6 \n\t" |
"movq %%mm4, 16(%%edi,%%ebx,) \n\t" |
"paddb %%mm7, %%mm6 \n\t" |
"movq 32(%%esi,%%ebx,), %%mm1 \n\t" |
"movq %%mm6, 24(%%edi,%%ebx,) \n\t" |
"movq 32(%%edi,%%ebx,), %%mm0 \n\t" |
"movq 40(%%esi,%%ebx,), %%mm3 \n\t" |
"paddb %%mm1, %%mm0 \n\t" |
"movq 40(%%edi,%%ebx,), %%mm2 \n\t" |
"movq %%mm0, 32(%%edi,%%ebx,) \n\t" |
"paddb %%mm3, %%mm2 \n\t" |
"movq 48(%%esi,%%ebx,), %%mm5 \n\t" |
"movq %%mm2, 40(%%edi,%%ebx,) \n\t" |
"movq 48(%%edi,%%ebx,), %%mm4 \n\t" |
"movq 56(%%esi,%%ebx,), %%mm7 \n\t" |
"paddb %%mm5, %%mm4 \n\t" |
"movq 56(%%edi,%%ebx,), %%mm6 \n\t" |
"movq %%mm4, 48(%%edi,%%ebx,) \n\t" |
"addl $64, %%ebx \n\t" |
"paddb %%mm7, %%mm6 \n\t" |
"cmpl %%ecx, %%ebx \n\t" |
"movq %%mm6, -8(%%edi,%%ebx,) \n\t" // (+56)movq does not affect flags; |
"jb up_loop \n\t" // -8 to offset addl ebx |
"cmpl $0, %%edx \n\t" // test for bytes over mult of 64 |
"jz up_end \n\t" |
"cmpl $8, %%edx \n\t" // test for less than 8 bytes |
"jb up_lt8 \n\t" // [added by lcreeve@netins.net] |
"addl %%edx, %%ecx \n\t" |
"andl $0x00000007, %%edx \n\t" // calc bytes over mult of 8 |
"subl %%edx, %%ecx \n\t" // drop over bytes from length |
"jz up_lt8 \n\t" |
"up_lpA: \n\t" // use MMX regs to update 8 bytes sim. |
"movq (%%esi,%%ebx,), %%mm1 \n\t" |
"movq (%%edi,%%ebx,), %%mm0 \n\t" |
"addl $8, %%ebx \n\t" |
"paddb %%mm1, %%mm0 \n\t" |
"cmpl %%ecx, %%ebx \n\t" |
"movq %%mm0, -8(%%edi,%%ebx,) \n\t" // movq does not affect flags; -8 to |
"jb up_lpA \n\t" // offset add ebx |
"cmpl $0, %%edx \n\t" // test for bytes over mult of 8 |
"jz up_end \n\t" |
"up_lt8: \n\t" |
"xorl %%eax, %%eax \n\t" |
"addl %%edx, %%ecx \n\t" // move over byte count into counter |
"up_lp2: \n\t" // use x86 regs for remaining bytes |
"movb (%%edi,%%ebx,), %%al \n\t" |
"addb (%%esi,%%ebx,), %%al \n\t" |
"incl %%ebx \n\t" |
"cmpl %%ecx, %%ebx \n\t" |
"movb %%al, -1(%%edi,%%ebx,) \n\t" // mov does not affect flags; -1 to |
"jb up_lp2 \n\t" // offset inc ebx |
"up_end: \n\t" |
"EMMS \n\t" // conversion of filtered row complete |
#ifdef __PIC__ |
"popl %%ebx \n\t" |
#endif |
: "=d" (dummy_value_d), // 0 // output regs (dummy) |
"=S" (dummy_value_S), // 1 |
"=D" (dummy_value_D) // 2 |
: "0" (len), // edx // input regs |
"1" (prev_row), // esi |
"2" (row) // edi |
: "%eax", "%ebx", "%ecx" // clobber list (no input regs!) |
#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ |
, "%mm0", "%mm1", "%mm2", "%mm3" |
, "%mm4", "%mm5", "%mm6", "%mm7" |
#endif |
); |
} // end of png_read_filter_row_mmx_up() |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
/*===========================================================================*/ |
/* */ |
/* P N G _ R E A D _ F I L T E R _ R O W */ |
/* */ |
/*===========================================================================*/ |
/* Optimized png_read_filter_row routines */ |
void /* PRIVATE */ |
png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep |
row, png_bytep prev_row, int filter) |
{ |
#ifdef PNG_DEBUG |
char filnm[10]; |
#endif |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) |
/* GRR: these are superseded by png_ptr->asm_flags: */ |
#define UseMMX_sub 1 // GRR: converted 20000730 |
#define UseMMX_up 1 // GRR: converted 20000729 |
#define UseMMX_avg 1 // GRR: converted 20000828 (+ 16-bit bugfix 20000916) |
#define UseMMX_paeth 1 // GRR: converted 20000828 |
if (_mmx_supported == 2) { |
/* this should have happened in png_init_mmx_flags() already */ |
#if !defined(PNG_1_0_X) |
png_warning(png_ptr, "asm_flags may not have been initialized"); |
#endif |
png_mmx_support(); |
} |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
#ifdef PNG_DEBUG |
png_debug(1, "in png_read_filter_row (pnggccrd.c)\n"); |
switch (filter) |
{ |
case 0: sprintf(filnm, "none"); |
break; |
case 1: sprintf(filnm, "sub-%s", |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) |
#if !defined(PNG_1_0_X) |
(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_SUB)? "MMX" : |
#endif |
#endif |
"x86"); |
break; |
case 2: sprintf(filnm, "up-%s", |
#ifdef PNG_ASSEMBLER_CODE_SUPPORTED |
#if !defined(PNG_1_0_X) |
(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_UP)? "MMX" : |
#endif |
#endif |
"x86"); |
break; |
case 3: sprintf(filnm, "avg-%s", |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) |
#if !defined(PNG_1_0_X) |
(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_AVG)? "MMX" : |
#endif |
#endif |
"x86"); |
break; |
case 4: sprintf(filnm, "Paeth-%s", |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) |
#if !defined(PNG_1_0_X) |
(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH)? "MMX": |
#endif |
#endif |
"x86"); |
break; |
default: sprintf(filnm, "unknw"); |
break; |
} |
png_debug2(0, "row_number=%5ld, %5s, ", png_ptr->row_number, filnm); |
png_debug1(0, "row=0x%08lx, ", (unsigned long)row); |
png_debug2(0, "pixdepth=%2d, bytes=%d, ", (int)row_info->pixel_depth, |
(int)((row_info->pixel_depth + 7) >> 3)); |
png_debug1(0,"rowbytes=%8ld\n", row_info->rowbytes); |
#endif /* PNG_DEBUG */ |
switch (filter) |
{ |
case PNG_FILTER_VALUE_NONE: |
break; |
case PNG_FILTER_VALUE_SUB: |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) |
#if !defined(PNG_1_0_X) |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_SUB) && |
(row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && |
(row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) |
#else |
if (_mmx_supported) |
#endif |
{ |
png_read_filter_row_mmx_sub(row_info, row); |
} |
else |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
{ |
png_uint_32 i; |
png_uint_32 istop = row_info->rowbytes; |
png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; |
png_bytep rp = row + bpp; |
png_bytep lp = row; |
for (i = bpp; i < istop; i++) |
{ |
*rp = (png_byte)(((int)(*rp) + (int)(*lp++)) & 0xff); |
rp++; |
} |
} /* end !UseMMX_sub */ |
break; |
case PNG_FILTER_VALUE_UP: |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) |
#if !defined(PNG_1_0_X) |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_UP) && |
(row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && |
(row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) |
#else |
if (_mmx_supported) |
#endif |
{ |
png_read_filter_row_mmx_up(row_info, row, prev_row); |
} |
else |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
{ |
png_uint_32 i; |
png_uint_32 istop = row_info->rowbytes; |
png_bytep rp = row; |
png_bytep pp = prev_row; |
for (i = 0; i < istop; ++i) |
{ |
*rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); |
rp++; |
} |
} /* end !UseMMX_up */ |
break; |
case PNG_FILTER_VALUE_AVG: |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) |
#if !defined(PNG_1_0_X) |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_AVG) && |
(row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && |
(row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) |
#else |
if (_mmx_supported) |
#endif |
{ |
png_read_filter_row_mmx_avg(row_info, row, prev_row); |
} |
else |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
{ |
png_uint_32 i; |
png_bytep rp = row; |
png_bytep pp = prev_row; |
png_bytep lp = row; |
png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; |
png_uint_32 istop = row_info->rowbytes - bpp; |
for (i = 0; i < bpp; i++) |
{ |
*rp = (png_byte)(((int)(*rp) + |
((int)(*pp++) >> 1)) & 0xff); |
rp++; |
} |
for (i = 0; i < istop; i++) |
{ |
*rp = (png_byte)(((int)(*rp) + |
((int)(*pp++ + *lp++) >> 1)) & 0xff); |
rp++; |
} |
} /* end !UseMMX_avg */ |
break; |
case PNG_FILTER_VALUE_PAETH: |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) |
#if !defined(PNG_1_0_X) |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH) && |
(row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && |
(row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) |
#else |
if (_mmx_supported) |
#endif |
{ |
png_read_filter_row_mmx_paeth(row_info, row, prev_row); |
} |
else |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
{ |
png_uint_32 i; |
png_bytep rp = row; |
png_bytep pp = prev_row; |
png_bytep lp = row; |
png_bytep cp = prev_row; |
png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; |
png_uint_32 istop = row_info->rowbytes - bpp; |
for (i = 0; i < bpp; i++) |
{ |
*rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); |
rp++; |
} |
for (i = 0; i < istop; i++) /* use leftover rp,pp */ |
{ |
int a, b, c, pa, pb, pc, p; |
a = *lp++; |
b = *pp++; |
c = *cp++; |
p = b - c; |
pc = a - c; |
#ifdef PNG_USE_ABS |
pa = abs(p); |
pb = abs(pc); |
pc = abs(p + pc); |
#else |
pa = p < 0 ? -p : p; |
pb = pc < 0 ? -pc : pc; |
pc = (p + pc) < 0 ? -(p + pc) : p + pc; |
#endif |
/* |
if (pa <= pb && pa <= pc) |
p = a; |
else if (pb <= pc) |
p = b; |
else |
p = c; |
*/ |
p = (pa <= pb && pa <= pc) ? a : (pb <= pc) ? b : c; |
*rp = (png_byte)(((int)(*rp) + p) & 0xff); |
rp++; |
} |
} /* end !UseMMX_paeth */ |
break; |
default: |
png_warning(png_ptr, "Ignoring bad row-filter type"); |
*row=0; |
break; |
} |
} |
#endif /* PNG_HAVE_ASSEMBLER_READ_FILTER_ROW */ |
/*===========================================================================*/ |
/* */ |
/* P N G _ M M X _ S U P P O R T */ |
/* */ |
/*===========================================================================*/ |
/* GRR NOTES: (1) the following code assumes 386 or better (pushfl/popfl) |
* (2) all instructions compile with gcc 2.7.2.3 and later |
* (3) the function is moved down here to prevent gcc from |
* inlining it in multiple places and then barfing be- |
* cause the ".NOT_SUPPORTED" label is multiply defined |
* [is there a way to signal that a *single* function should |
* not be inlined? is there a way to modify the label for |
* each inlined instance, e.g., by appending _1, _2, etc.? |
* maybe if don't use leading "." in label name? (nope...sigh)] |
*/ |
int PNGAPI |
png_mmx_support(void) |
{ |
#if defined(PNG_MMX_CODE_SUPPORTED) |
__asm__ __volatile__ ( |
"pushl %%ebx \n\t" // ebx gets clobbered by CPUID instruction |
"pushl %%ecx \n\t" // so does ecx... |
"pushl %%edx \n\t" // ...and edx (but ecx & edx safe on Linux) |
// ".byte 0x66 \n\t" // convert 16-bit pushf to 32-bit pushfd |
// "pushf \n\t" // 16-bit pushf |
"pushfl \n\t" // save Eflag to stack |
"popl %%eax \n\t" // get Eflag from stack into eax |
"movl %%eax, %%ecx \n\t" // make another copy of Eflag in ecx |
"xorl $0x200000, %%eax \n\t" // toggle ID bit in Eflag (i.e., bit 21) |
"pushl %%eax \n\t" // save modified Eflag back to stack |
// ".byte 0x66 \n\t" // convert 16-bit popf to 32-bit popfd |
// "popf \n\t" // 16-bit popf |
"popfl \n\t" // restore modified value to Eflag reg |
"pushfl \n\t" // save Eflag to stack |
"popl %%eax \n\t" // get Eflag from stack |
"pushl %%ecx \n\t" // save original Eflag to stack |
"popfl \n\t" // restore original Eflag |
"xorl %%ecx, %%eax \n\t" // compare new Eflag with original Eflag |
"jz 0f \n\t" // if same, CPUID instr. is not supported |
"xorl %%eax, %%eax \n\t" // set eax to zero |
// ".byte 0x0f, 0xa2 \n\t" // CPUID instruction (two-byte opcode) |
"cpuid \n\t" // get the CPU identification info |
"cmpl $1, %%eax \n\t" // make sure eax return non-zero value |
"jl 0f \n\t" // if eax is zero, MMX is not supported |
"xorl %%eax, %%eax \n\t" // set eax to zero and... |
"incl %%eax \n\t" // ...increment eax to 1. This pair is |
// faster than the instruction "mov eax, 1" |
"cpuid \n\t" // get the CPU identification info again |
"andl $0x800000, %%edx \n\t" // mask out all bits but MMX bit (23) |
"cmpl $0, %%edx \n\t" // 0 = MMX not supported |
"jz 0f \n\t" // non-zero = yes, MMX IS supported |
"movl $1, %%eax \n\t" // set return value to 1 |
"jmp 1f \n\t" // DONE: have MMX support |
"0: \n\t" // .NOT_SUPPORTED: target label for jump instructions |
"movl $0, %%eax \n\t" // set return value to 0 |
"1: \n\t" // .RETURN: target label for jump instructions |
"movl %%eax, _mmx_supported \n\t" // save in global static variable, too |
"popl %%edx \n\t" // restore edx |
"popl %%ecx \n\t" // restore ecx |
"popl %%ebx \n\t" // restore ebx |
// "ret \n\t" // DONE: no MMX support |
// (fall through to standard C "ret") |
: // output list (none) |
: // any variables used on input (none) |
: "%eax" // clobber list |
// , "%ebx", "%ecx", "%edx" // GRR: we handle these manually |
// , "memory" // if write to a variable gcc thought was in a reg |
// , "cc" // "condition codes" (flag bits) |
); |
#else |
_mmx_supported = 0; |
#endif /* PNG_MMX_CODE_SUPPORTED */ |
return _mmx_supported; |
} |
#endif /* PNG_USE_PNGGCCRD */ |
/shark/trunk/ports/png/example.c |
---|
0,0 → 1,804 |
#if 0 /* in case someone actually tries to compile this */ |
/* example.c - an example of using libpng */ |
/* This is an example of how to use libpng to read and write PNG files. |
* The file libpng.txt is much more verbose then this. If you have not |
* read it, do so first. This was designed to be a starting point of an |
* implementation. This is not officially part of libpng, is hereby placed |
* in the public domain, and therefore does not require a copyright notice. |
* |
* This file does not currently compile, because it is missing certain |
* parts, like allocating memory to hold an image. You will have to |
* supply these parts to get it to compile. For an example of a minimal |
* working PNG reader/writer, see pngtest.c, included in this distribution; |
* see also the programs in the contrib directory. |
*/ |
#include "png.h" |
/* The png_jmpbuf() macro, used in error handling, became available in |
* libpng version 1.0.6. If you want to be able to run your code with older |
* versions of libpng, you must define the macro yourself (but only if it |
* is not already defined by libpng!). |
*/ |
#ifndef png_jmpbuf |
# define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf) |
#endif |
/* Check to see if a file is a PNG file using png_sig_cmp(). png_sig_cmp() |
* returns zero if the image is a PNG and nonzero if it isn't a PNG. |
* |
* The function check_if_png() shown here, but not used, returns nonzero (true) |
* if the file can be opened and is a PNG, 0 (false) otherwise. |
* |
* If this call is successful, and you are going to keep the file open, |
* you should call png_set_sig_bytes(png_ptr, PNG_BYTES_TO_CHECK); once |
* you have created the png_ptr, so that libpng knows your application |
* has read that many bytes from the start of the file. Make sure you |
* don't call png_set_sig_bytes() with more than 8 bytes read or give it |
* an incorrect number of bytes read, or you will either have read too |
* many bytes (your fault), or you are telling libpng to read the wrong |
* number of magic bytes (also your fault). |
* |
* Many applications already read the first 2 or 4 bytes from the start |
* of the image to determine the file type, so it would be easiest just |
* to pass the bytes to png_sig_cmp() or even skip that if you know |
* you have a PNG file, and call png_set_sig_bytes(). |
*/ |
#define PNG_BYTES_TO_CHECK 4 |
int check_if_png(char *file_name, FILE **fp) |
{ |
char buf[PNG_BYTES_TO_CHECK]; |
/* Open the prospective PNG file. */ |
if ((*fp = fopen(file_name, "rb")) == NULL) |
return 0; |
/* Read in some of the signature bytes */ |
if (fread(buf, 1, PNG_BYTES_TO_CHECK, *fp) != PNG_BYTES_TO_CHECK) |
return 0; |
/* Compare the first PNG_BYTES_TO_CHECK bytes of the signature. |
Return nonzero (true) if they match */ |
return(!png_sig_cmp(buf, (png_size_t)0, PNG_BYTES_TO_CHECK)); |
} |
/* Read a PNG file. You may want to return an error code if the read |
* fails (depending upon the failure). There are two "prototypes" given |
* here - one where we are given the filename, and we need to open the |
* file, and the other where we are given an open file (possibly with |
* some or all of the magic bytes read - see comments above). |
*/ |
#ifdef open_file /* prototype 1 */ |
void read_png(char *file_name) /* We need to open the file */ |
{ |
png_structp png_ptr; |
png_infop info_ptr; |
unsigned int sig_read = 0; |
png_uint_32 width, height; |
int bit_depth, color_type, interlace_type; |
FILE *fp; |
if ((fp = fopen(file_name, "rb")) == NULL) |
return (ERROR); |
#else no_open_file /* prototype 2 */ |
void read_png(FILE *fp, unsigned int sig_read) /* file is already open */ |
{ |
png_structp png_ptr; |
png_infop info_ptr; |
png_uint_32 width, height; |
int bit_depth, color_type, interlace_type; |
#endif no_open_file /* only use one prototype! */ |
/* Create and initialize the png_struct with the desired error handler |
* functions. If you want to use the default stderr and longjump method, |
* you can supply NULL for the last three parameters. We also supply the |
* the compiler header file version, so that we know if the application |
* was compiled with a compatible version of the library. REQUIRED |
*/ |
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, |
png_voidp user_error_ptr, user_error_fn, user_warning_fn); |
if (png_ptr == NULL) |
{ |
fclose(fp); |
return (ERROR); |
} |
/* Allocate/initialize the memory for image information. REQUIRED. */ |
info_ptr = png_create_info_struct(png_ptr); |
if (info_ptr == NULL) |
{ |
fclose(fp); |
png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL); |
return (ERROR); |
} |
/* Set error handling if you are using the setjmp/longjmp method (this is |
* the normal method of doing things with libpng). REQUIRED unless you |
* set up your own error handlers in the png_create_read_struct() earlier. |
*/ |
if (setjmp(png_jmpbuf(png_ptr))) |
{ |
/* Free all of the memory associated with the png_ptr and info_ptr */ |
png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL); |
fclose(fp); |
/* If we get here, we had a problem reading the file */ |
return (ERROR); |
} |
/* One of the following I/O initialization methods is REQUIRED */ |
#ifdef streams /* PNG file I/O method 1 */ |
/* Set up the input control if you are using standard C streams */ |
png_init_io(png_ptr, fp); |
#else no_streams /* PNG file I/O method 2 */ |
/* If you are using replacement read functions, instead of calling |
* png_init_io() here you would call: |
*/ |
png_set_read_fn(png_ptr, (void *)user_io_ptr, user_read_fn); |
/* where user_io_ptr is a structure you want available to the callbacks */ |
#endif no_streams /* Use only one I/O method! */ |
/* If we have already read some of the signature */ |
png_set_sig_bytes(png_ptr, sig_read); |
#ifdef hilevel |
/* |
* If you have enough memory to read in the entire image at once, |
* and you need to specify only transforms that can be controlled |
* with one of the PNG_TRANSFORM_* bits (this presently excludes |
* dithering, filling, setting background, and doing gamma |
* adjustment), then you can read the entire image (including |
* pixels) into the info structure with this call: |
*/ |
png_read_png(png_ptr, info_ptr, png_transforms, png_voidp_NULL); |
#else |
/* OK, you're doing it the hard way, with the lower-level functions */ |
/* The call to png_read_info() gives us all of the information from the |
* PNG file before the first IDAT (image data chunk). REQUIRED |
*/ |
png_read_info(png_ptr, info_ptr); |
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, |
&interlace_type, int_p_NULL, int_p_NULL); |
/* Set up the data transformations you want. Note that these are all |
* optional. Only call them if you want/need them. Many of the |
* transformations only work on specific types of images, and many |
* are mutually exclusive. |
*/ |
/* tell libpng to strip 16 bit/color files down to 8 bits/color */ |
png_set_strip_16(png_ptr); |
/* Strip alpha bytes from the input data without combining with the |
* background (not recommended). |
*/ |
png_set_strip_alpha(png_ptr); |
/* Extract multiple pixels with bit depths of 1, 2, and 4 from a single |
* byte into separate bytes (useful for paletted and grayscale images). |
*/ |
png_set_packing(png_ptr); |
/* Change the order of packed pixels to least significant bit first |
* (not useful if you are using png_set_packing). */ |
png_set_packswap(png_ptr); |
/* Expand paletted colors into true RGB triplets */ |
if (color_type == PNG_COLOR_TYPE_PALETTE) |
png_set_palette_rgb(png_ptr); |
/* Expand grayscale images to the full 8 bits from 1, 2, or 4 bits/pixel */ |
if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) |
png_set_gray_1_2_4_to_8(png_ptr); |
/* Expand paletted or RGB images with transparency to full alpha channels |
* so the data will be available as RGBA quartets. |
*/ |
if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) |
png_set_tRNS_to_alpha(png_ptr); |
/* Set the background color to draw transparent and alpha images over. |
* It is possible to set the red, green, and blue components directly |
* for paletted images instead of supplying a palette index. Note that |
* even if the PNG file supplies a background, you are not required to |
* use it - you should use the (solid) application background if it has one. |
*/ |
png_color_16 my_background, *image_background; |
if (png_get_bKGD(png_ptr, info_ptr, &image_background)) |
png_set_background(png_ptr, image_background, |
PNG_BACKGROUND_GAMMA_FILE, 1, 1.0); |
else |
png_set_background(png_ptr, &my_background, |
PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0); |
/* Some suggestions as to how to get a screen gamma value */ |
/* Note that screen gamma is the display_exponent, which includes |
* the CRT_exponent and any correction for viewing conditions */ |
if (/* We have a user-defined screen gamma value */) |
{ |
screen_gamma = user-defined screen_gamma; |
} |
/* This is one way that applications share the same screen gamma value */ |
else if ((gamma_str = getenv("SCREEN_GAMMA")) != NULL) |
{ |
screen_gamma = atof(gamma_str); |
} |
/* If we don't have another value */ |
else |
{ |
screen_gamma = 2.2; /* A good guess for a PC monitors in a dimly |
lit room */ |
screen_gamma = 1.7 or 1.0; /* A good guess for Mac systems */ |
} |
/* Tell libpng to handle the gamma conversion for you. The final call |
* is a good guess for PC generated images, but it should be configurable |
* by the user at run time by the user. It is strongly suggested that |
* your application support gamma correction. |
*/ |
int intent; |
if (png_get_sRGB(png_ptr, info_ptr, &intent)) |
png_set_gamma(png_ptr, screen_gamma, 0.45455); |
else |
{ |
double image_gamma; |
if (png_get_gAMA(png_ptr, info_ptr, &image_gamma)) |
png_set_gamma(png_ptr, screen_gamma, image_gamma); |
else |
png_set_gamma(png_ptr, screen_gamma, 0.45455); |
} |
/* Dither RGB files down to 8 bit palette or reduce palettes |
* to the number of colors available on your screen. |
*/ |
if (color_type & PNG_COLOR_MASK_COLOR) |
{ |
int num_palette; |
png_colorp palette; |
/* This reduces the image to the application supplied palette */ |
if (/* we have our own palette */) |
{ |
/* An array of colors to which the image should be dithered */ |
png_color std_color_cube[MAX_SCREEN_COLORS]; |
png_set_dither(png_ptr, std_color_cube, MAX_SCREEN_COLORS, |
MAX_SCREEN_COLORS, png_uint_16p_NULL, 0); |
} |
/* This reduces the image to the palette supplied in the file */ |
else if (png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette)) |
{ |
png_uint_16p histogram = NULL; |
png_get_hIST(png_ptr, info_ptr, &histogram); |
png_set_dither(png_ptr, palette, num_palette, |
max_screen_colors, histogram, 0); |
} |
} |
/* invert monochrome files to have 0 as white and 1 as black */ |
png_set_invert_mono(png_ptr); |
/* If you want to shift the pixel values from the range [0,255] or |
* [0,65535] to the original [0,7] or [0,31], or whatever range the |
* colors were originally in: |
*/ |
if (png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT)) |
{ |
png_color_8p sig_bit; |
png_get_sBIT(png_ptr, info_ptr, &sig_bit); |
png_set_shift(png_ptr, sig_bit); |
} |
/* flip the RGB pixels to BGR (or RGBA to BGRA) */ |
if (color_type & PNG_COLOR_MASK_COLOR) |
png_set_bgr(png_ptr); |
/* swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR) */ |
png_set_swap_alpha(png_ptr); |
/* swap bytes of 16 bit files to least significant byte first */ |
png_set_swap(png_ptr); |
/* Add filler (or alpha) byte (before/after each RGB triplet) */ |
png_set_filler(png_ptr, 0xff, PNG_FILLER_AFTER); |
/* Turn on interlace handling. REQUIRED if you are not using |
* png_read_image(). To see how to handle interlacing passes, |
* see the png_read_row() method below: |
*/ |
number_passes = png_set_interlace_handling(png_ptr); |
/* Optional call to gamma correct and add the background to the palette |
* and update info structure. REQUIRED if you are expecting libpng to |
* update the palette for you (ie you selected such a transform above). |
*/ |
png_read_update_info(png_ptr, info_ptr); |
/* Allocate the memory to hold the image using the fields of info_ptr. */ |
/* The easiest way to read the image: */ |
png_bytep row_pointers[height]; |
for (row = 0; row < height; row++) |
{ |
row_pointers[row] = png_malloc(png_ptr, png_get_rowbytes(png_ptr, |
info_ptr)); |
} |
/* Now it's time to read the image. One of these methods is REQUIRED */ |
#ifdef entire /* Read the entire image in one go */ |
png_read_image(png_ptr, row_pointers); |
#else no_entire /* Read the image one or more scanlines at a time */ |
/* The other way to read images - deal with interlacing: */ |
for (pass = 0; pass < number_passes; pass++) |
{ |
#ifdef single /* Read the image a single row at a time */ |
for (y = 0; y < height; y++) |
{ |
png_read_rows(png_ptr, &row_pointers[y], png_bytepp_NULL, 1); |
} |
#else no_single /* Read the image several rows at a time */ |
for (y = 0; y < height; y += number_of_rows) |
{ |
#ifdef sparkle /* Read the image using the "sparkle" effect. */ |
png_read_rows(png_ptr, &row_pointers[y], png_bytepp_NULL, |
number_of_rows); |
#else no_sparkle /* Read the image using the "rectangle" effect */ |
png_read_rows(png_ptr, png_bytepp_NULL, &row_pointers[y], |
number_of_rows); |
#endif no_sparkle /* use only one of these two methods */ |
} |
/* if you want to display the image after every pass, do |
so here */ |
#endif no_single /* use only one of these two methods */ |
} |
#endif no_entire /* use only one of these two methods */ |
/* read rest of file, and get additional chunks in info_ptr - REQUIRED */ |
png_read_end(png_ptr, info_ptr); |
#endif hilevel |
/* At this point you have read the entire image */ |
/* clean up after the read, and free any memory allocated - REQUIRED */ |
png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL); |
/* close the file */ |
fclose(fp); |
/* that's it */ |
return (OK); |
} |
/* progressively read a file */ |
int |
initialize_png_reader(png_structp *png_ptr, png_infop *info_ptr) |
{ |
/* Create and initialize the png_struct with the desired error handler |
* functions. If you want to use the default stderr and longjump method, |
* you can supply NULL for the last three parameters. We also check that |
* the library version is compatible in case we are using dynamically |
* linked libraries. |
*/ |
*png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, |
png_voidp user_error_ptr, user_error_fn, user_warning_fn); |
if (*png_ptr == NULL) |
{ |
*info_ptr = NULL; |
return (ERROR); |
} |
*info_ptr = png_create_info_struct(png_ptr); |
if (*info_ptr == NULL) |
{ |
png_destroy_read_struct(png_ptr, info_ptr, png_infopp_NULL); |
return (ERROR); |
} |
if (setjmp(png_jmpbuf((*png_ptr)))) |
{ |
png_destroy_read_struct(png_ptr, info_ptr, png_infopp_NULL); |
return (ERROR); |
} |
/* This one's new. You will need to provide all three |
* function callbacks, even if you aren't using them all. |
* If you aren't using all functions, you can specify NULL |
* parameters. Even when all three functions are NULL, |
* you need to call png_set_progressive_read_fn(). |
* These functions shouldn't be dependent on global or |
* static variables if you are decoding several images |
* simultaneously. You should store stream specific data |
* in a separate struct, given as the second parameter, |
* and retrieve the pointer from inside the callbacks using |
* the function png_get_progressive_ptr(png_ptr). |
*/ |
png_set_progressive_read_fn(*png_ptr, (void *)stream_data, |
info_callback, row_callback, end_callback); |
return (OK); |
} |
int |
process_data(png_structp *png_ptr, png_infop *info_ptr, |
png_bytep buffer, png_uint_32 length) |
{ |
if (setjmp(png_jmpbuf((*png_ptr)))) |
{ |
/* Free the png_ptr and info_ptr memory on error */ |
png_destroy_read_struct(png_ptr, info_ptr, png_infopp_NULL); |
return (ERROR); |
} |
/* This one's new also. Simply give it chunks of data as |
* they arrive from the data stream (in order, of course). |
* On Segmented machines, don't give it any more than 64K. |
* The library seems to run fine with sizes of 4K, although |
* you can give it much less if necessary (I assume you can |
* give it chunks of 1 byte, but I haven't tried with less |
* than 256 bytes yet). When this function returns, you may |
* want to display any rows that were generated in the row |
* callback, if you aren't already displaying them there. |
*/ |
png_process_data(*png_ptr, *info_ptr, buffer, length); |
return (OK); |
} |
info_callback(png_structp png_ptr, png_infop info) |
{ |
/* do any setup here, including setting any of the transformations |
* mentioned in the Reading PNG files section. For now, you _must_ |
* call either png_start_read_image() or png_read_update_info() |
* after all the transformations are set (even if you don't set |
* any). You may start getting rows before png_process_data() |
* returns, so this is your last chance to prepare for that. |
*/ |
} |
row_callback(png_structp png_ptr, png_bytep new_row, |
png_uint_32 row_num, int pass) |
{ |
/* |
* This function is called for every row in the image. If the |
* image is interlaced, and you turned on the interlace handler, |
* this function will be called for every row in every pass. |
* |
* In this function you will receive a pointer to new row data from |
* libpng called new_row that is to replace a corresponding row (of |
* the same data format) in a buffer allocated by your application. |
* |
* The new row data pointer new_row may be NULL, indicating there is |
* no new data to be replaced (in cases of interlace loading). |
* |
* If new_row is not NULL then you need to call |
* png_progressive_combine_row() to replace the corresponding row as |
* shown below: |
*/ |
/* Check if row_num is in bounds. */ |
if((row_num >= 0) && (row_num < height)) |
{ |
/* Get pointer to corresponding row in our |
* PNG read buffer. |
*/ |
png_bytep old_row = ((png_bytep *)our_data)[row_num]; |
/* If both rows are allocated then copy the new row |
* data to the corresponding row data. |
*/ |
if((old_row != NULL) && (new_row != NULL)) |
png_progressive_combine_row(png_ptr, old_row, new_row); |
} |
/* |
* The rows and passes are called in order, so you don't really |
* need the row_num and pass, but I'm supplying them because it |
* may make your life easier. |
* |
* For the non-NULL rows of interlaced images, you must call |
* png_progressive_combine_row() passing in the new row and the |
* old row, as demonstrated above. You can call this function for |
* NULL rows (it will just return) and for non-interlaced images |
* (it just does the png_memcpy for you) if it will make the code |
* easier. Thus, you can just do this for all cases: |
*/ |
png_progressive_combine_row(png_ptr, old_row, new_row); |
/* where old_row is what was displayed for previous rows. Note |
* that the first pass (pass == 0 really) will completely cover |
* the old row, so the rows do not have to be initialized. After |
* the first pass (and only for interlaced images), you will have |
* to pass the current row as new_row, and the function will combine |
* the old row and the new row. |
*/ |
} |
end_callback(png_structp png_ptr, png_infop info) |
{ |
/* this function is called when the whole image has been read, |
* including any chunks after the image (up to and including |
* the IEND). You will usually have the same info chunk as you |
* had in the header, although some data may have been added |
* to the comments and time fields. |
* |
* Most people won't do much here, perhaps setting a flag that |
* marks the image as finished. |
*/ |
} |
/* write a png file */ |
void write_png(char *file_name /* , ... other image information ... */) |
{ |
FILE *fp; |
png_structp png_ptr; |
png_infop info_ptr; |
png_colorp palette; |
/* open the file */ |
fp = fopen(file_name, "wb"); |
if (fp == NULL) |
return (ERROR); |
/* Create and initialize the png_struct with the desired error handler |
* functions. If you want to use the default stderr and longjump method, |
* you can supply NULL for the last three parameters. We also check that |
* the library version is compatible with the one used at compile time, |
* in case we are using dynamically linked libraries. REQUIRED. |
*/ |
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, |
png_voidp user_error_ptr, user_error_fn, user_warning_fn); |
if (png_ptr == NULL) |
{ |
fclose(fp); |
return (ERROR); |
} |
/* Allocate/initialize the image information data. REQUIRED */ |
info_ptr = png_create_info_struct(png_ptr); |
if (info_ptr == NULL) |
{ |
fclose(fp); |
png_destroy_write_struct(&png_ptr, png_infopp_NULL); |
return (ERROR); |
} |
/* Set error handling. REQUIRED if you aren't supplying your own |
* error handling functions in the png_create_write_struct() call. |
*/ |
if (setjmp(png_jmpbuf(png_ptr))) |
{ |
/* If we get here, we had a problem reading the file */ |
fclose(fp); |
png_destroy_write_struct(&png_ptr, &info_ptr); |
return (ERROR); |
} |
/* One of the following I/O initialization functions is REQUIRED */ |
#ifdef streams /* I/O initialization method 1 */ |
/* set up the output control if you are using standard C streams */ |
png_init_io(png_ptr, fp); |
#else no_streams /* I/O initialization method 2 */ |
/* If you are using replacement read functions, instead of calling |
* png_init_io() here you would call */ |
png_set_write_fn(png_ptr, (void *)user_io_ptr, user_write_fn, |
user_IO_flush_function); |
/* where user_io_ptr is a structure you want available to the callbacks */ |
#endif no_streams /* only use one initialization method */ |
#ifdef hilevel |
/* This is the easy way. Use it if you already have all the |
* image info living info in the structure. You could "|" many |
* PNG_TRANSFORM flags into the png_transforms integer here. |
*/ |
png_write_png(png_ptr, info_ptr, png_transforms, png_voidp_NULL); |
#else |
/* This is the hard way */ |
/* Set the image information here. Width and height are up to 2^31, |
* bit_depth is one of 1, 2, 4, 8, or 16, but valid values also depend on |
* the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY, |
* PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB, |
* or PNG_COLOR_TYPE_RGB_ALPHA. interlace is either PNG_INTERLACE_NONE or |
* PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST |
* currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE. REQUIRED |
*/ |
png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, PNG_COLOR_TYPE_???, |
PNG_INTERLACE_????, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); |
/* set the palette if there is one. REQUIRED for indexed-color images */ |
palette = (png_colorp)png_malloc(png_ptr, PNG_MAX_PALETTE_LENGTH |
* sizeof (png_color)); |
/* ... set palette colors ... */ |
png_set_PLTE(png_ptr, info_ptr, palette, PNG_MAX_PALETTE_LENGTH); |
/* You must not free palette here, because png_set_PLTE only makes a link to |
the palette that you malloced. Wait until you are about to destroy |
the png structure. */ |
/* optional significant bit chunk */ |
/* if we are dealing with a grayscale image then */ |
sig_bit.gray = true_bit_depth; |
/* otherwise, if we are dealing with a color image then */ |
sig_bit.red = true_red_bit_depth; |
sig_bit.green = true_green_bit_depth; |
sig_bit.blue = true_blue_bit_depth; |
/* if the image has an alpha channel then */ |
sig_bit.alpha = true_alpha_bit_depth; |
png_set_sBIT(png_ptr, info_ptr, sig_bit); |
/* Optional gamma chunk is strongly suggested if you have any guess |
* as to the correct gamma of the image. |
*/ |
png_set_gAMA(png_ptr, info_ptr, gamma); |
/* Optionally write comments into the image */ |
text_ptr[0].key = "Title"; |
text_ptr[0].text = "Mona Lisa"; |
text_ptr[0].compression = PNG_TEXT_COMPRESSION_NONE; |
text_ptr[1].key = "Author"; |
text_ptr[1].text = "Leonardo DaVinci"; |
text_ptr[1].compression = PNG_TEXT_COMPRESSION_NONE; |
text_ptr[2].key = "Description"; |
text_ptr[2].text = "<long text>"; |
text_ptr[2].compression = PNG_TEXT_COMPRESSION_zTXt; |
#ifdef PNG_iTXt_SUPPORTED |
text_ptr[0].lang = NULL; |
text_ptr[1].lang = NULL; |
text_ptr[2].lang = NULL; |
#endif |
png_set_text(png_ptr, info_ptr, text_ptr, 3); |
/* other optional chunks like cHRM, bKGD, tRNS, tIME, oFFs, pHYs, */ |
/* note that if sRGB is present the gAMA and cHRM chunks must be ignored |
* on read and must be written in accordance with the sRGB profile */ |
/* Write the file header information. REQUIRED */ |
png_write_info(png_ptr, info_ptr); |
/* If you want, you can write the info in two steps, in case you need to |
* write your private chunk ahead of PLTE: |
* |
* png_write_info_before_PLTE(write_ptr, write_info_ptr); |
* write_my_chunk(); |
* png_write_info(png_ptr, info_ptr); |
* |
* However, given the level of known- and unknown-chunk support in 1.1.0 |
* and up, this should no longer be necessary. |
*/ |
/* Once we write out the header, the compression type on the text |
* chunks gets changed to PNG_TEXT_COMPRESSION_NONE_WR or |
* PNG_TEXT_COMPRESSION_zTXt_WR, so it doesn't get written out again |
* at the end. |
*/ |
/* set up the transformations you want. Note that these are |
* all optional. Only call them if you want them. |
*/ |
/* invert monochrome pixels */ |
png_set_invert_mono(png_ptr); |
/* Shift the pixels up to a legal bit depth and fill in |
* as appropriate to correctly scale the image. |
*/ |
png_set_shift(png_ptr, &sig_bit); |
/* pack pixels into bytes */ |
png_set_packing(png_ptr); |
/* swap location of alpha bytes from ARGB to RGBA */ |
png_set_swap_alpha(png_ptr); |
/* Get rid of filler (OR ALPHA) bytes, pack XRGB/RGBX/ARGB/RGBA into |
* RGB (4 channels -> 3 channels). The second parameter is not used. |
*/ |
png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE); |
/* flip BGR pixels to RGB */ |
png_set_bgr(png_ptr); |
/* swap bytes of 16-bit files to most significant byte first */ |
png_set_swap(png_ptr); |
/* swap bits of 1, 2, 4 bit packed pixel formats */ |
png_set_packswap(png_ptr); |
/* turn on interlace handling if you are not using png_write_image() */ |
if (interlacing) |
number_passes = png_set_interlace_handling(png_ptr); |
else |
number_passes = 1; |
/* The easiest way to write the image (you may have a different memory |
* layout, however, so choose what fits your needs best). You need to |
* use the first method if you aren't handling interlacing yourself. |
*/ |
png_uint_32 k, height, width; |
png_byte image[height][width*bytes_per_pixel]; |
png_bytep row_pointers[height]; |
for (k = 0; k < height; k++) |
row_pointers[k] = image + k*width*bytes_per_pixel; |
/* One of the following output methods is REQUIRED */ |
#ifdef entire /* write out the entire image data in one call */ |
png_write_image(png_ptr, row_pointers); |
/* the other way to write the image - deal with interlacing */ |
#else no_entire /* write out the image data by one or more scanlines */ |
/* The number of passes is either 1 for non-interlaced images, |
* or 7 for interlaced images. |
*/ |
for (pass = 0; pass < number_passes; pass++) |
{ |
/* Write a few rows at a time. */ |
png_write_rows(png_ptr, &row_pointers[first_row], number_of_rows); |
/* If you are only writing one row at a time, this works */ |
for (y = 0; y < height; y++) |
{ |
png_write_rows(png_ptr, &row_pointers[y], 1); |
} |
} |
#endif no_entire /* use only one output method */ |
/* You can write optional chunks like tEXt, zTXt, and tIME at the end |
* as well. Shouldn't be necessary in 1.1.0 and up as all the public |
* chunks are supported and you can use png_set_unknown_chunks() to |
* register unknown chunks into the info structure to be written out. |
*/ |
/* It is REQUIRED to call this to finish writing the rest of the file */ |
png_write_end(png_ptr, info_ptr); |
#endif hilevel |
/* If you png_malloced a palette, free it here (don't free info_ptr->palette, |
as recommended in versions 1.0.5m and earlier of this example; if |
libpng mallocs info_ptr->palette, libpng will free it). If you |
allocated it with malloc() instead of png_malloc(), use free() instead |
of png_free(). */ |
png_free(png_ptr, palette); |
palette=NULL; |
/* Similarly, if you png_malloced any data that you passed in with |
png_set_something(), such as a hist or trans array, free it here, |
when you can be sure that libpng is through with it. */ |
png_free(png_ptr, trans); |
trans=NULL; |
/* clean up after the write, and free any memory allocated */ |
png_destroy_write_struct(&png_ptr, &info_ptr); |
/* close the file */ |
fclose(fp); |
/* that's it */ |
return (OK); |
} |
#endif /* if 0 */ |
/shark/trunk/ports/png/pngtrans.c |
---|
0,0 → 1,640 |
/* pngtrans.c - transforms the data in a row (used by both readers and writers) |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
*/ |
#define PNG_INTERNAL |
#include "png.h" |
#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) |
/* turn on BGR-to-RGB mapping */ |
void PNGAPI |
png_set_bgr(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_bgr\n"); |
png_ptr->transformations |= PNG_BGR; |
} |
#endif |
#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) |
/* turn on 16 bit byte swapping */ |
void PNGAPI |
png_set_swap(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_swap\n"); |
if (png_ptr->bit_depth == 16) |
png_ptr->transformations |= PNG_SWAP_BYTES; |
} |
#endif |
#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED) |
/* turn on pixel packing */ |
void PNGAPI |
png_set_packing(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_packing\n"); |
if (png_ptr->bit_depth < 8) |
{ |
png_ptr->transformations |= PNG_PACK; |
png_ptr->usr_bit_depth = 8; |
} |
} |
#endif |
#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED) |
/* turn on packed pixel swapping */ |
void PNGAPI |
png_set_packswap(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_packswap\n"); |
if (png_ptr->bit_depth < 8) |
png_ptr->transformations |= PNG_PACKSWAP; |
} |
#endif |
#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) |
void PNGAPI |
png_set_shift(png_structp png_ptr, png_color_8p true_bits) |
{ |
png_debug(1, "in png_set_shift\n"); |
png_ptr->transformations |= PNG_SHIFT; |
png_ptr->shift = *true_bits; |
} |
#endif |
#if defined(PNG_READ_INTERLACING_SUPPORTED) || \ |
defined(PNG_WRITE_INTERLACING_SUPPORTED) |
int PNGAPI |
png_set_interlace_handling(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_interlace handling\n"); |
if (png_ptr->interlaced) |
{ |
png_ptr->transformations |= PNG_INTERLACE; |
return (7); |
} |
return (1); |
} |
#endif |
#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) |
/* Add a filler byte on read, or remove a filler or alpha byte on write. |
* The filler type has changed in v0.95 to allow future 2-byte fillers |
* for 48-bit input data, as well as to avoid problems with some compilers |
* that don't like bytes as parameters. |
*/ |
void PNGAPI |
png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc) |
{ |
png_debug(1, "in png_set_filler\n"); |
png_ptr->transformations |= PNG_FILLER; |
png_ptr->filler = (png_byte)filler; |
if (filler_loc == PNG_FILLER_AFTER) |
png_ptr->flags |= PNG_FLAG_FILLER_AFTER; |
else |
png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER; |
/* This should probably go in the "do_filler" routine. |
* I attempted to do that in libpng-1.0.1a but that caused problems |
* so I restored it in libpng-1.0.2a |
*/ |
if (png_ptr->color_type == PNG_COLOR_TYPE_RGB) |
{ |
png_ptr->usr_channels = 4; |
} |
/* Also I added this in libpng-1.0.2a (what happens when we expand |
* a less-than-8-bit grayscale to GA? */ |
if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY && png_ptr->bit_depth >= 8) |
{ |
png_ptr->usr_channels = 2; |
} |
} |
#endif |
#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \ |
defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) |
void PNGAPI |
png_set_swap_alpha(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_swap_alpha\n"); |
png_ptr->transformations |= PNG_SWAP_ALPHA; |
} |
#endif |
#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \ |
defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) |
void PNGAPI |
png_set_invert_alpha(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_invert_alpha\n"); |
png_ptr->transformations |= PNG_INVERT_ALPHA; |
} |
#endif |
#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) |
void PNGAPI |
png_set_invert_mono(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_invert_mono\n"); |
png_ptr->transformations |= PNG_INVERT_MONO; |
} |
/* invert monochrome grayscale data */ |
void /* PRIVATE */ |
png_do_invert(png_row_infop row_info, png_bytep row) |
{ |
png_debug(1, "in png_do_invert\n"); |
/* This test removed from libpng version 1.0.13 and 1.2.0: |
* if (row_info->bit_depth == 1 && |
*/ |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
if (row == NULL || row_info == NULL) |
return; |
#endif |
if (row_info->color_type == PNG_COLOR_TYPE_GRAY) |
{ |
png_bytep rp = row; |
png_uint_32 i; |
png_uint_32 istop = row_info->rowbytes; |
for (i = 0; i < istop; i++) |
{ |
*rp = (png_byte)(~(*rp)); |
rp++; |
} |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA && |
row_info->bit_depth == 8) |
{ |
png_bytep rp = row; |
png_uint_32 i; |
png_uint_32 istop = row_info->rowbytes; |
for (i = 0; i < istop; i+=2) |
{ |
*rp = (png_byte)(~(*rp)); |
rp+=2; |
} |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA && |
row_info->bit_depth == 16) |
{ |
png_bytep rp = row; |
png_uint_32 i; |
png_uint_32 istop = row_info->rowbytes; |
for (i = 0; i < istop; i+=4) |
{ |
*rp = (png_byte)(~(*rp)); |
*(rp+1) = (png_byte)(~(*(rp+1))); |
rp+=4; |
} |
} |
} |
#endif |
#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) |
/* swaps byte order on 16 bit depth images */ |
void /* PRIVATE */ |
png_do_swap(png_row_infop row_info, png_bytep row) |
{ |
png_debug(1, "in png_do_swap\n"); |
if ( |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
row != NULL && row_info != NULL && |
#endif |
row_info->bit_depth == 16) |
{ |
png_bytep rp = row; |
png_uint_32 i; |
png_uint_32 istop= row_info->width * row_info->channels; |
for (i = 0; i < istop; i++, rp += 2) |
{ |
png_byte t = *rp; |
*rp = *(rp + 1); |
*(rp + 1) = t; |
} |
} |
} |
#endif |
#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED) |
static png_byte onebppswaptable[256] = { |
0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, |
0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0, |
0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8, |
0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8, |
0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4, |
0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4, |
0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC, |
0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC, |
0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2, |
0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2, |
0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA, |
0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA, |
0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6, |
0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6, |
0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE, |
0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE, |
0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1, |
0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1, |
0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9, |
0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9, |
0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5, |
0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5, |
0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED, |
0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD, |
0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3, |
0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3, |
0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB, |
0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB, |
0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7, |
0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7, |
0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF, |
0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF |
}; |
static png_byte twobppswaptable[256] = { |
0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0, |
0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0, |
0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4, |
0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4, |
0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8, |
0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8, |
0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC, |
0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC, |
0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1, |
0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1, |
0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5, |
0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5, |
0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9, |
0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9, |
0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD, |
0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD, |
0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2, |
0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2, |
0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6, |
0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6, |
0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA, |
0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA, |
0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE, |
0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE, |
0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3, |
0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3, |
0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7, |
0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7, |
0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB, |
0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB, |
0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF, |
0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF |
}; |
static png_byte fourbppswaptable[256] = { |
0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, |
0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0, |
0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71, |
0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1, |
0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72, |
0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2, |
0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73, |
0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3, |
0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74, |
0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4, |
0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75, |
0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5, |
0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76, |
0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6, |
0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77, |
0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7, |
0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78, |
0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8, |
0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79, |
0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9, |
0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A, |
0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA, |
0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B, |
0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB, |
0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C, |
0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC, |
0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D, |
0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD, |
0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E, |
0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE, |
0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F, |
0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF |
}; |
/* swaps pixel packing order within bytes */ |
void /* PRIVATE */ |
png_do_packswap(png_row_infop row_info, png_bytep row) |
{ |
png_debug(1, "in png_do_packswap\n"); |
if ( |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
row != NULL && row_info != NULL && |
#endif |
row_info->bit_depth < 8) |
{ |
png_bytep rp, end, table; |
end = row + row_info->rowbytes; |
if (row_info->bit_depth == 1) |
table = onebppswaptable; |
else if (row_info->bit_depth == 2) |
table = twobppswaptable; |
else if (row_info->bit_depth == 4) |
table = fourbppswaptable; |
else |
return; |
for (rp = row; rp < end; rp++) |
*rp = table[*rp]; |
} |
} |
#endif /* PNG_READ_PACKSWAP_SUPPORTED or PNG_WRITE_PACKSWAP_SUPPORTED */ |
#if defined(PNG_WRITE_FILLER_SUPPORTED) || \ |
defined(PNG_READ_STRIP_ALPHA_SUPPORTED) |
/* remove filler or alpha byte(s) */ |
void /* PRIVATE */ |
png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags) |
{ |
png_debug(1, "in png_do_strip_filler\n"); |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
if (row != NULL && row_info != NULL) |
#endif |
{ |
/* |
if (row_info->color_type == PNG_COLOR_TYPE_RGB || |
row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
*/ |
png_bytep sp=row; |
png_bytep dp=row; |
png_uint_32 row_width=row_info->width; |
png_uint_32 i; |
if (row_info->channels == 4) |
{ |
if (row_info->bit_depth == 8) |
{ |
/* This converts from RGBX or RGBA to RGB */ |
if (flags & PNG_FLAG_FILLER_AFTER) |
{ |
dp+=3; sp+=4; |
for (i = 1; i < row_width; i++) |
{ |
*dp++ = *sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
sp++; |
} |
} |
/* This converts from XRGB or ARGB to RGB */ |
else |
{ |
for (i = 0; i < row_width; i++) |
{ |
sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
} |
} |
row_info->pixel_depth = 24; |
row_info->rowbytes = row_width * 3; |
} |
else /* if (row_info->bit_depth == 16) */ |
{ |
if (flags & PNG_FLAG_FILLER_AFTER) |
{ |
/* This converts from RRGGBBXX or RRGGBBAA to RRGGBB */ |
sp += 8; dp += 6; |
for (i = 1; i < row_width; i++) |
{ |
/* This could be (although png_memcpy is probably slower): |
png_memcpy(dp, sp, 6); |
sp += 8; |
dp += 6; |
*/ |
*dp++ = *sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
sp += 2; |
} |
} |
else |
{ |
/* This converts from XXRRGGBB or AARRGGBB to RRGGBB */ |
for (i = 0; i < row_width; i++) |
{ |
/* This could be (although png_memcpy is probably slower): |
png_memcpy(dp, sp, 6); |
sp += 8; |
dp += 6; |
*/ |
sp+=2; |
*dp++ = *sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
} |
} |
row_info->pixel_depth = 48; |
row_info->rowbytes = row_width * 6; |
} |
row_info->channels = 3; |
row_info->color_type &= ~PNG_COLOR_MASK_ALPHA; |
} |
/* |
else if (row_info->color_type == PNG_COLOR_TYPE_GRAY || |
row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) |
*/ |
else if (row_info->channels == 2) |
{ |
if (row_info->bit_depth == 8) |
{ |
/* This converts from GX or GA to G */ |
if (flags & PNG_FLAG_FILLER_AFTER) |
{ |
for (i = 0; i < row_width; i++) |
{ |
*dp++ = *sp++; |
sp++; |
} |
} |
/* This converts from XG or AG to G */ |
else |
{ |
for (i = 0; i < row_width; i++) |
{ |
sp++; |
*dp++ = *sp++; |
} |
} |
row_info->pixel_depth = 8; |
row_info->rowbytes = row_width; |
} |
else /* if (row_info->bit_depth == 16) */ |
{ |
if (flags & PNG_FLAG_FILLER_AFTER) |
{ |
/* This converts from GGXX or GGAA to GG */ |
sp += 4; dp += 2; |
for (i = 1; i < row_width; i++) |
{ |
*dp++ = *sp++; |
*dp++ = *sp++; |
sp += 2; |
} |
} |
else |
{ |
/* This converts from XXGG or AAGG to GG */ |
for (i = 0; i < row_width; i++) |
{ |
sp += 2; |
*dp++ = *sp++; |
*dp++ = *sp++; |
} |
} |
row_info->pixel_depth = 16; |
row_info->rowbytes = row_width * 2; |
} |
row_info->channels = 1; |
row_info->color_type &= ~PNG_COLOR_MASK_ALPHA; |
} |
} |
} |
#endif |
#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) |
/* swaps red and blue bytes within a pixel */ |
void /* PRIVATE */ |
png_do_bgr(png_row_infop row_info, png_bytep row) |
{ |
png_debug(1, "in png_do_bgr\n"); |
if ( |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
row != NULL && row_info != NULL && |
#endif |
(row_info->color_type & PNG_COLOR_MASK_COLOR)) |
{ |
png_uint_32 row_width = row_info->width; |
if (row_info->bit_depth == 8) |
{ |
if (row_info->color_type == PNG_COLOR_TYPE_RGB) |
{ |
png_bytep rp; |
png_uint_32 i; |
for (i = 0, rp = row; i < row_width; i++, rp += 3) |
{ |
png_byte save = *rp; |
*rp = *(rp + 2); |
*(rp + 2) = save; |
} |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
{ |
png_bytep rp; |
png_uint_32 i; |
for (i = 0, rp = row; i < row_width; i++, rp += 4) |
{ |
png_byte save = *rp; |
*rp = *(rp + 2); |
*(rp + 2) = save; |
} |
} |
} |
else if (row_info->bit_depth == 16) |
{ |
if (row_info->color_type == PNG_COLOR_TYPE_RGB) |
{ |
png_bytep rp; |
png_uint_32 i; |
for (i = 0, rp = row; i < row_width; i++, rp += 6) |
{ |
png_byte save = *rp; |
*rp = *(rp + 4); |
*(rp + 4) = save; |
save = *(rp + 1); |
*(rp + 1) = *(rp + 5); |
*(rp + 5) = save; |
} |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
{ |
png_bytep rp; |
png_uint_32 i; |
for (i = 0, rp = row; i < row_width; i++, rp += 8) |
{ |
png_byte save = *rp; |
*rp = *(rp + 4); |
*(rp + 4) = save; |
save = *(rp + 1); |
*(rp + 1) = *(rp + 5); |
*(rp + 5) = save; |
} |
} |
} |
} |
} |
#endif /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */ |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ |
defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ |
defined(PNG_LEGACY_SUPPORTED) |
void PNGAPI |
png_set_user_transform_info(png_structp png_ptr, png_voidp |
user_transform_ptr, int user_transform_depth, int user_transform_channels) |
{ |
png_debug(1, "in png_set_user_transform_info\n"); |
#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) |
png_ptr->user_transform_ptr = user_transform_ptr; |
png_ptr->user_transform_depth = (png_byte)user_transform_depth; |
png_ptr->user_transform_channels = (png_byte)user_transform_channels; |
#else |
if(user_transform_ptr || user_transform_depth || user_transform_channels) |
png_warning(png_ptr, |
"This version of libpng does not support user transform info"); |
#endif |
} |
#endif |
/* This function returns a pointer to the user_transform_ptr associated with |
* the user transform functions. The application should free any memory |
* associated with this pointer before png_write_destroy and png_read_destroy |
* are called. |
*/ |
png_voidp PNGAPI |
png_get_user_transform_ptr(png_structp png_ptr) |
{ |
#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) |
return ((png_voidp)png_ptr->user_transform_ptr); |
#else |
if(png_ptr) |
return (NULL); |
return (NULL); |
#endif |
} |
/shark/trunk/ports/png/pngrio.c |
---|
0,0 → 1,161 |
/* pngrio.c - functions for data input |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
* This file provides a location for all input. Users who need |
* special handling are expected to write a function that has the same |
* arguments as this and performs a similar function, but that possibly |
* has a different input method. Note that you shouldn't change this |
* function, but rather write a replacement function and then make |
* libpng use it at run time with png_set_read_fn(...). |
*/ |
#define PNG_INTERNAL |
#include "png.h" |
/* Read the data from whatever input you are using. The default routine |
reads from a file pointer. Note that this routine sometimes gets called |
with very small lengths, so you should implement some kind of simple |
buffering if you are using unbuffered reads. This should never be asked |
to read more then 64K on a 16 bit machine. */ |
void /* PRIVATE */ |
png_read_data(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
png_debug1(4,"reading %d bytes\n", (int)length); |
if (png_ptr->read_data_fn != NULL) |
(*(png_ptr->read_data_fn))(png_ptr, data, length); |
else |
png_error(png_ptr, "Call to NULL read function"); |
} |
#if !defined(PNG_NO_STDIO) |
/* This is the function that does the actual reading of data. If you are |
not reading from a standard C stream, you should create a replacement |
read_data function and use it at run time with png_set_read_fn(), rather |
than changing the library. */ |
#ifndef USE_FAR_KEYWORD |
void PNGAPI |
png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
png_size_t check; |
/* fread() returns 0 on error, so it is OK to store this in a png_size_t |
* instead of an int, which is what fread() actually returns. |
*/ |
#if defined(_WIN32_WCE) |
if ( !ReadFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) ) |
check = 0; |
#else |
check = (png_size_t)fread(data, (png_size_t)1, length, |
(png_FILE_p)png_ptr->io_ptr); |
#endif |
if (check != length) |
png_error(png_ptr, "Read Error"); |
} |
#else |
/* this is the model-independent version. Since the standard I/O library |
can't handle far buffers in the medium and small models, we have to copy |
the data. |
*/ |
#define NEAR_BUF_SIZE 1024 |
#define MIN(a,b) (a <= b ? a : b) |
static void /* PRIVATE */ |
png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
int check; |
png_byte *n_data; |
png_FILE_p io_ptr; |
/* Check if data really is near. If so, use usual code. */ |
n_data = (png_byte *)CVT_PTR_NOCHECK(data); |
io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr); |
if ((png_bytep)n_data == data) |
{ |
#if defined(_WIN32_WCE) |
if ( !ReadFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) ) |
check = 0; |
#else |
check = fread(n_data, 1, length, io_ptr); |
#endif |
} |
else |
{ |
png_byte buf[NEAR_BUF_SIZE]; |
png_size_t read, remaining, err; |
check = 0; |
remaining = length; |
do |
{ |
read = MIN(NEAR_BUF_SIZE, remaining); |
#if defined(_WIN32_WCE) |
if ( !ReadFile((HANDLE)(io_ptr), buf, read, &err, NULL) ) |
err = 0; |
#else |
err = fread(buf, (png_size_t)1, read, io_ptr); |
#endif |
png_memcpy(data, buf, read); /* copy far buffer to near buffer */ |
if(err != read) |
break; |
else |
check += err; |
data += read; |
remaining -= read; |
} |
while (remaining != 0); |
} |
if ((png_uint_32)check != (png_uint_32)length) |
png_error(png_ptr, "read Error"); |
} |
#endif |
#endif |
/* This function allows the application to supply a new input function |
for libpng if standard C streams aren't being used. |
This function takes as its arguments: |
png_ptr - pointer to a png input data structure |
io_ptr - pointer to user supplied structure containing info about |
the input functions. May be NULL. |
read_data_fn - pointer to a new input function that takes as its |
arguments a pointer to a png_struct, a pointer to |
a location where input data can be stored, and a 32-bit |
unsigned int that is the number of bytes to be read. |
To exit and output any fatal error messages the new write |
function should call png_error(png_ptr, "Error msg"). */ |
void PNGAPI |
png_set_read_fn(png_structp png_ptr, png_voidp io_ptr, |
png_rw_ptr read_data_fn) |
{ |
png_ptr->io_ptr = io_ptr; |
#if !defined(PNG_NO_STDIO) |
if (read_data_fn != NULL) |
png_ptr->read_data_fn = read_data_fn; |
else |
png_ptr->read_data_fn = png_default_read_data; |
#else |
png_ptr->read_data_fn = read_data_fn; |
#endif |
/* It is an error to write to a read device */ |
if (png_ptr->write_data_fn != NULL) |
{ |
png_ptr->write_data_fn = NULL; |
png_warning(png_ptr, |
"It's an error to set both read_data_fn and write_data_fn in the "); |
png_warning(png_ptr, |
"same structure. Resetting write_data_fn to NULL."); |
} |
#if defined(PNG_WRITE_FLUSH_SUPPORTED) |
png_ptr->output_flush_fn = NULL; |
#endif |
} |
/shark/trunk/ports/png/pngwrite.c |
---|
0,0 → 1,1450 |
/* pngwrite.c - general routines to write a PNG file |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
*/ |
/* get internal access to png.h */ |
#define PNG_INTERNAL |
#include "png.h" |
#ifdef PNG_WRITE_SUPPORTED |
/* Writes all the PNG information. This is the suggested way to use the |
* library. If you have a new chunk to add, make a function to write it, |
* and put it in the correct location here. If you want the chunk written |
* after the image data, put it in png_write_end(). I strongly encourage |
* you to supply a PNG_INFO_ flag, and check info_ptr->valid before writing |
* the chunk, as that will keep the code from breaking if you want to just |
* write a plain PNG file. If you have long comments, I suggest writing |
* them in png_write_end(), and compressing them. |
*/ |
void PNGAPI |
png_write_info_before_PLTE(png_structp png_ptr, png_infop info_ptr) |
{ |
png_debug(1, "in png_write_info_before_PLTE\n"); |
if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE)) |
{ |
png_write_sig(png_ptr); /* write PNG signature */ |
#if defined(PNG_MNG_FEATURES_SUPPORTED) |
if((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)&&(png_ptr->mng_features_permitted)) |
{ |
png_warning(png_ptr,"MNG features are not allowed in a PNG datastream\n"); |
png_ptr->mng_features_permitted=0; |
} |
#endif |
/* write IHDR information. */ |
png_write_IHDR(png_ptr, info_ptr->width, info_ptr->height, |
info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type, |
info_ptr->filter_type, |
#if defined(PNG_WRITE_INTERLACING_SUPPORTED) |
info_ptr->interlace_type); |
#else |
0); |
#endif |
/* the rest of these check to see if the valid field has the appropriate |
flag set, and if it does, writes the chunk. */ |
#if defined(PNG_WRITE_gAMA_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_gAMA) |
{ |
# ifdef PNG_FLOATING_POINT_SUPPORTED |
png_write_gAMA(png_ptr, info_ptr->gamma); |
#else |
#ifdef PNG_FIXED_POINT_SUPPORTED |
png_write_gAMA_fixed(png_ptr, info_ptr->int_gamma); |
# endif |
#endif |
} |
#endif |
#if defined(PNG_WRITE_sRGB_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_sRGB) |
png_write_sRGB(png_ptr, (int)info_ptr->srgb_intent); |
#endif |
#if defined(PNG_WRITE_iCCP_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_iCCP) |
png_write_iCCP(png_ptr, info_ptr->iccp_name, PNG_COMPRESSION_TYPE_BASE, |
info_ptr->iccp_profile, (int)info_ptr->iccp_proflen); |
#endif |
#if defined(PNG_WRITE_sBIT_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_sBIT) |
png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type); |
#endif |
#if defined(PNG_WRITE_cHRM_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_cHRM) |
{ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
png_write_cHRM(png_ptr, |
info_ptr->x_white, info_ptr->y_white, |
info_ptr->x_red, info_ptr->y_red, |
info_ptr->x_green, info_ptr->y_green, |
info_ptr->x_blue, info_ptr->y_blue); |
#else |
# ifdef PNG_FIXED_POINT_SUPPORTED |
png_write_cHRM_fixed(png_ptr, |
info_ptr->int_x_white, info_ptr->int_y_white, |
info_ptr->int_x_red, info_ptr->int_y_red, |
info_ptr->int_x_green, info_ptr->int_y_green, |
info_ptr->int_x_blue, info_ptr->int_y_blue); |
# endif |
#endif |
} |
#endif |
#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) |
if (info_ptr->unknown_chunks_num) |
{ |
png_unknown_chunk *up; |
png_debug(5, "writing extra chunks\n"); |
for (up = info_ptr->unknown_chunks; |
up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num; |
up++) |
{ |
int keep=png_handle_as_unknown(png_ptr, up->name); |
if (keep != HANDLE_CHUNK_NEVER && |
up->location && (!(up->location & PNG_HAVE_PLTE)) && |
((up->name[3] & 0x20) || keep == HANDLE_CHUNK_ALWAYS || |
(png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS))) |
{ |
png_write_chunk(png_ptr, up->name, up->data, up->size); |
} |
} |
} |
#endif |
png_ptr->mode |= PNG_WROTE_INFO_BEFORE_PLTE; |
} |
} |
void PNGAPI |
png_write_info(png_structp png_ptr, png_infop info_ptr) |
{ |
#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED) |
int i; |
#endif |
png_debug(1, "in png_write_info\n"); |
png_write_info_before_PLTE(png_ptr, info_ptr); |
if (info_ptr->valid & PNG_INFO_PLTE) |
png_write_PLTE(png_ptr, info_ptr->palette, |
(png_uint_32)info_ptr->num_palette); |
else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
png_error(png_ptr, "Valid palette required for paletted images\n"); |
#if defined(PNG_WRITE_tRNS_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_tRNS) |
{ |
#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) |
/* invert the alpha channel (in tRNS) */ |
if ((png_ptr->transformations & PNG_INVERT_ALPHA) && |
info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
int j; |
for (j=0; j<(int)info_ptr->num_trans; j++) |
info_ptr->trans[j] = (png_byte)(255 - info_ptr->trans[j]); |
} |
#endif |
png_write_tRNS(png_ptr, info_ptr->trans, &(info_ptr->trans_values), |
info_ptr->num_trans, info_ptr->color_type); |
} |
#endif |
#if defined(PNG_WRITE_bKGD_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_bKGD) |
png_write_bKGD(png_ptr, &(info_ptr->background), info_ptr->color_type); |
#endif |
#if defined(PNG_WRITE_hIST_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_hIST) |
png_write_hIST(png_ptr, info_ptr->hist, info_ptr->num_palette); |
#endif |
#if defined(PNG_WRITE_oFFs_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_oFFs) |
png_write_oFFs(png_ptr, info_ptr->x_offset, info_ptr->y_offset, |
info_ptr->offset_unit_type); |
#endif |
#if defined(PNG_WRITE_pCAL_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_pCAL) |
png_write_pCAL(png_ptr, info_ptr->pcal_purpose, info_ptr->pcal_X0, |
info_ptr->pcal_X1, info_ptr->pcal_type, info_ptr->pcal_nparams, |
info_ptr->pcal_units, info_ptr->pcal_params); |
#endif |
#if defined(PNG_WRITE_sCAL_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_sCAL) |
#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO) |
png_write_sCAL(png_ptr, (int)info_ptr->scal_unit, |
info_ptr->scal_pixel_width, info_ptr->scal_pixel_height); |
#else |
#ifdef PNG_FIXED_POINT_SUPPORTED |
png_write_sCAL_s(png_ptr, (int)info_ptr->scal_unit, |
info_ptr->scal_s_width, info_ptr->scal_s_height); |
#else |
png_warning(png_ptr, |
"png_write_sCAL not supported; sCAL chunk not written.\n"); |
#endif |
#endif |
#endif |
#if defined(PNG_WRITE_pHYs_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_pHYs) |
png_write_pHYs(png_ptr, info_ptr->x_pixels_per_unit, |
info_ptr->y_pixels_per_unit, info_ptr->phys_unit_type); |
#endif |
#if defined(PNG_WRITE_tIME_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_tIME) |
{ |
png_write_tIME(png_ptr, &(info_ptr->mod_time)); |
png_ptr->mode |= PNG_WROTE_tIME; |
} |
#endif |
#if defined(PNG_WRITE_sPLT_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_sPLT) |
for (i = 0; i < (int)info_ptr->splt_palettes_num; i++) |
png_write_sPLT(png_ptr, info_ptr->splt_palettes + i); |
#endif |
#if defined(PNG_WRITE_TEXT_SUPPORTED) |
/* Check to see if we need to write text chunks */ |
for (i = 0; i < info_ptr->num_text; i++) |
{ |
png_debug2(2, "Writing header text chunk %d, type %d\n", i, |
info_ptr->text[i].compression); |
/* an internationalized chunk? */ |
if (info_ptr->text[i].compression > 0) |
{ |
#if defined(PNG_WRITE_iTXt_SUPPORTED) |
/* write international chunk */ |
png_write_iTXt(png_ptr, |
info_ptr->text[i].compression, |
info_ptr->text[i].key, |
info_ptr->text[i].lang, |
info_ptr->text[i].lang_key, |
info_ptr->text[i].text); |
#else |
png_warning(png_ptr, "Unable to write international text\n"); |
#endif |
/* Mark this chunk as written */ |
info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR; |
} |
/* If we want a compressed text chunk */ |
else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_zTXt) |
{ |
#if defined(PNG_WRITE_zTXt_SUPPORTED) |
/* write compressed chunk */ |
png_write_zTXt(png_ptr, info_ptr->text[i].key, |
info_ptr->text[i].text, 0, |
info_ptr->text[i].compression); |
#else |
png_warning(png_ptr, "Unable to write compressed text\n"); |
#endif |
/* Mark this chunk as written */ |
info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR; |
} |
else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE) |
{ |
#if defined(PNG_WRITE_tEXt_SUPPORTED) |
/* write uncompressed chunk */ |
png_write_tEXt(png_ptr, info_ptr->text[i].key, |
info_ptr->text[i].text, |
0); |
#else |
png_warning(png_ptr, "Unable to write uncompressed text\n"); |
#endif |
/* Mark this chunk as written */ |
info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR; |
} |
} |
#endif |
#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) |
if (info_ptr->unknown_chunks_num) |
{ |
png_unknown_chunk *up; |
png_debug(5, "writing extra chunks\n"); |
for (up = info_ptr->unknown_chunks; |
up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num; |
up++) |
{ |
int keep=png_handle_as_unknown(png_ptr, up->name); |
if (keep != HANDLE_CHUNK_NEVER && |
up->location && (up->location & PNG_HAVE_PLTE) && |
!(up->location & PNG_HAVE_IDAT) && |
((up->name[3] & 0x20) || keep == HANDLE_CHUNK_ALWAYS || |
(png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS))) |
{ |
png_write_chunk(png_ptr, up->name, up->data, up->size); |
} |
} |
} |
#endif |
} |
/* Writes the end of the PNG file. If you don't want to write comments or |
* time information, you can pass NULL for info. If you already wrote these |
* in png_write_info(), do not write them again here. If you have long |
* comments, I suggest writing them here, and compressing them. |
*/ |
void PNGAPI |
png_write_end(png_structp png_ptr, png_infop info_ptr) |
{ |
png_debug(1, "in png_write_end\n"); |
if (!(png_ptr->mode & PNG_HAVE_IDAT)) |
png_error(png_ptr, "No IDATs written into file"); |
/* see if user wants us to write information chunks */ |
if (info_ptr != NULL) |
{ |
#if defined(PNG_WRITE_TEXT_SUPPORTED) |
int i; /* local index variable */ |
#endif |
#if defined(PNG_WRITE_tIME_SUPPORTED) |
/* check to see if user has supplied a time chunk */ |
if ((info_ptr->valid & PNG_INFO_tIME) && |
!(png_ptr->mode & PNG_WROTE_tIME)) |
png_write_tIME(png_ptr, &(info_ptr->mod_time)); |
#endif |
#if defined(PNG_WRITE_TEXT_SUPPORTED) |
/* loop through comment chunks */ |
for (i = 0; i < info_ptr->num_text; i++) |
{ |
png_debug2(2, "Writing trailer text chunk %d, type %d\n", i, |
info_ptr->text[i].compression); |
/* an internationalized chunk? */ |
if (info_ptr->text[i].compression > 0) |
{ |
#if defined(PNG_WRITE_iTXt_SUPPORTED) |
/* write international chunk */ |
png_write_iTXt(png_ptr, |
info_ptr->text[i].compression, |
info_ptr->text[i].key, |
info_ptr->text[i].lang, |
info_ptr->text[i].lang_key, |
info_ptr->text[i].text); |
#else |
png_warning(png_ptr, "Unable to write international text\n"); |
#endif |
/* Mark this chunk as written */ |
info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR; |
} |
else if (info_ptr->text[i].compression >= PNG_TEXT_COMPRESSION_zTXt) |
{ |
#if defined(PNG_WRITE_zTXt_SUPPORTED) |
/* write compressed chunk */ |
png_write_zTXt(png_ptr, info_ptr->text[i].key, |
info_ptr->text[i].text, 0, |
info_ptr->text[i].compression); |
#else |
png_warning(png_ptr, "Unable to write compressed text\n"); |
#endif |
/* Mark this chunk as written */ |
info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR; |
} |
else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE) |
{ |
#if defined(PNG_WRITE_tEXt_SUPPORTED) |
/* write uncompressed chunk */ |
png_write_tEXt(png_ptr, info_ptr->text[i].key, |
info_ptr->text[i].text, 0); |
#else |
png_warning(png_ptr, "Unable to write uncompressed text\n"); |
#endif |
/* Mark this chunk as written */ |
info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR; |
} |
} |
#endif |
#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) |
if (info_ptr->unknown_chunks_num) |
{ |
png_unknown_chunk *up; |
png_debug(5, "writing extra chunks\n"); |
for (up = info_ptr->unknown_chunks; |
up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num; |
up++) |
{ |
int keep=png_handle_as_unknown(png_ptr, up->name); |
if (keep != HANDLE_CHUNK_NEVER && |
up->location && (up->location & PNG_AFTER_IDAT) && |
((up->name[3] & 0x20) || keep == HANDLE_CHUNK_ALWAYS || |
(png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS))) |
{ |
png_write_chunk(png_ptr, up->name, up->data, up->size); |
} |
} |
} |
#endif |
} |
png_ptr->mode |= PNG_AFTER_IDAT; |
/* write end of PNG file */ |
png_write_IEND(png_ptr); |
#if 0 |
/* This flush, added in libpng-1.0.8, causes some applications to crash |
because they do not set png_ptr->output_flush_fn */ |
png_flush(png_ptr); |
#endif |
} |
#if defined(PNG_WRITE_tIME_SUPPORTED) |
#if !defined(_WIN32_WCE) |
/* "time.h" functions are not supported on WindowsCE */ |
void PNGAPI |
png_convert_from_struct_tm(png_timep ptime, struct tm FAR * ttime) |
{ |
png_debug(1, "in png_convert_from_struct_tm\n"); |
ptime->year = (png_uint_16)(1900 + ttime->tm_year); |
ptime->month = (png_byte)(ttime->tm_mon + 1); |
ptime->day = (png_byte)ttime->tm_mday; |
ptime->hour = (png_byte)ttime->tm_hour; |
ptime->minute = (png_byte)ttime->tm_min; |
ptime->second = (png_byte)ttime->tm_sec; |
} |
void PNGAPI |
png_convert_from_time_t(png_timep ptime, time_t ttime) |
{ |
struct tm *tbuf; |
png_debug(1, "in png_convert_from_time_t\n"); |
tbuf = gmtime(&ttime); |
png_convert_from_struct_tm(ptime, tbuf); |
} |
#endif |
#endif |
/* Initialize png_ptr structure, and allocate any memory needed */ |
png_structp PNGAPI |
png_create_write_struct(png_const_charp user_png_ver, png_voidp error_ptr, |
png_error_ptr error_fn, png_error_ptr warn_fn) |
{ |
#ifdef PNG_USER_MEM_SUPPORTED |
return (png_create_write_struct_2(user_png_ver, error_ptr, error_fn, |
warn_fn, png_voidp_NULL, png_malloc_ptr_NULL, png_free_ptr_NULL)); |
} |
/* Alternate initialize png_ptr structure, and allocate any memory needed */ |
png_structp PNGAPI |
png_create_write_struct_2(png_const_charp user_png_ver, png_voidp error_ptr, |
png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, |
png_malloc_ptr malloc_fn, png_free_ptr free_fn) |
{ |
#endif /* PNG_USER_MEM_SUPPORTED */ |
png_structp png_ptr; |
#ifdef PNG_SETJMP_SUPPORTED |
#ifdef USE_FAR_KEYWORD |
jmp_buf jmpbuf; |
#endif |
#endif |
int i; |
png_debug(1, "in png_create_write_struct\n"); |
#ifdef PNG_USER_MEM_SUPPORTED |
png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG, |
(png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr); |
#else |
png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); |
#endif /* PNG_USER_MEM_SUPPORTED */ |
if (png_ptr == NULL) |
return (NULL); |
#if !defined(PNG_1_0_X) |
#ifdef PNG_ASSEMBLER_CODE_SUPPORTED |
png_init_mmx_flags(png_ptr); /* 1.2.0 addition */ |
#endif |
#endif /* PNG_1_0_X */ |
#ifdef PNG_SETJMP_SUPPORTED |
#ifdef USE_FAR_KEYWORD |
if (setjmp(jmpbuf)) |
#else |
if (setjmp(png_ptr->jmpbuf)) |
#endif |
{ |
png_free(png_ptr, png_ptr->zbuf); |
png_ptr->zbuf=NULL; |
png_destroy_struct(png_ptr); |
return (NULL); |
} |
#ifdef USE_FAR_KEYWORD |
png_memcpy(png_ptr->jmpbuf,jmpbuf,sizeof(jmp_buf)); |
#endif |
#endif |
#ifdef PNG_USER_MEM_SUPPORTED |
png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn); |
#endif /* PNG_USER_MEM_SUPPORTED */ |
png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn); |
i=0; |
do |
{ |
if(user_png_ver[i] != png_libpng_ver[i]) |
png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; |
} while (png_libpng_ver[i++]); |
if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH) |
{ |
/* Libpng 0.90 and later are binary incompatible with libpng 0.89, so |
* we must recompile any applications that use any older library version. |
* For versions after libpng 1.0, we will be compatible, so we need |
* only check the first digit. |
*/ |
if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] || |
(user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) || |
(user_png_ver[0] == '0' && user_png_ver[2] < '9')) |
{ |
#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) |
char msg[80]; |
if (user_png_ver) |
{ |
sprintf(msg, "Application was compiled with png.h from libpng-%.20s", |
user_png_ver); |
png_warning(png_ptr, msg); |
} |
sprintf(msg, "Application is running with png.c from libpng-%.20s", |
png_libpng_ver); |
png_warning(png_ptr, msg); |
#endif |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
png_ptr->flags=0; |
#endif |
png_error(png_ptr, |
"Incompatible libpng version in application and library"); |
} |
} |
/* initialize zbuf - compression buffer */ |
png_ptr->zbuf_size = PNG_ZBUF_SIZE; |
png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)png_ptr->zbuf_size); |
png_set_write_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL, |
png_flush_ptr_NULL); |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT, |
1, png_doublep_NULL, png_doublep_NULL); |
#endif |
#ifdef PNG_SETJMP_SUPPORTED |
/* Applications that neglect to set up their own setjmp() and then encounter |
a png_error() will longjmp here. Since the jmpbuf is then meaningless we |
abort instead of returning. */ |
#ifdef USE_FAR_KEYWORD |
if (setjmp(jmpbuf)) |
PNG_ABORT(); |
png_memcpy(png_ptr->jmpbuf,jmpbuf,sizeof(jmp_buf)); |
#else |
if (setjmp(png_ptr->jmpbuf)) |
PNG_ABORT(); |
#endif |
#endif |
return (png_ptr); |
} |
/* Initialize png_ptr structure, and allocate any memory needed */ |
#undef png_write_init |
void PNGAPI |
png_write_init(png_structp png_ptr) |
{ |
/* We only come here via pre-1.0.7-compiled applications */ |
png_write_init_2(png_ptr, "1.0.6 or earlier", 0, 0); |
} |
void PNGAPI |
png_write_init_2(png_structp png_ptr, png_const_charp user_png_ver, |
png_size_t png_struct_size, png_size_t png_info_size) |
{ |
/* We only come here via pre-1.0.12-compiled applications */ |
#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) |
if(sizeof(png_struct) > png_struct_size || sizeof(png_info) > png_info_size) |
{ |
char msg[80]; |
png_ptr->warning_fn=NULL; |
if (user_png_ver) |
{ |
sprintf(msg, "Application was compiled with png.h from libpng-%.20s", |
user_png_ver); |
png_warning(png_ptr, msg); |
} |
sprintf(msg, "Application is running with png.c from libpng-%.20s", |
png_libpng_ver); |
png_warning(png_ptr, msg); |
} |
#endif |
if(sizeof(png_struct) > png_struct_size) |
{ |
png_ptr->error_fn=NULL; |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
png_ptr->flags=0; |
#endif |
png_error(png_ptr, |
"The png struct allocated by the application for writing is too small."); |
} |
if(sizeof(png_info) > png_info_size) |
{ |
png_ptr->error_fn=NULL; |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
png_ptr->flags=0; |
#endif |
png_error(png_ptr, |
"The info struct allocated by the application for writing is too small."); |
} |
png_write_init_3(&png_ptr, user_png_ver, png_struct_size); |
} |
void PNGAPI |
png_write_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver, |
png_size_t png_struct_size) |
{ |
png_structp png_ptr=*ptr_ptr; |
#ifdef PNG_SETJMP_SUPPORTED |
jmp_buf tmp_jmp; /* to save current jump buffer */ |
#endif |
int i = 0; |
do |
{ |
if (user_png_ver[i] != png_libpng_ver[i]) |
{ |
#ifdef PNG_LEGACY_SUPPORTED |
png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; |
#else |
png_ptr->warning_fn=NULL; |
png_warning(png_ptr, |
"Application uses deprecated png_write_init() and should be recompiled."); |
break; |
#endif |
} |
} while (png_libpng_ver[i++]); |
png_debug(1, "in png_write_init_3\n"); |
#ifdef PNG_SETJMP_SUPPORTED |
/* save jump buffer and error functions */ |
png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf)); |
#endif |
if (sizeof(png_struct) > png_struct_size) |
{ |
png_destroy_struct(png_ptr); |
png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); |
*ptr_ptr = png_ptr; |
} |
/* reset all variables to 0 */ |
png_memset(png_ptr, 0, sizeof (png_struct)); |
#if !defined(PNG_1_0_X) |
#ifdef PNG_ASSEMBLER_CODE_SUPPORTED |
png_init_mmx_flags(png_ptr); /* 1.2.0 addition */ |
#endif |
#endif /* PNG_1_0_X */ |
#ifdef PNG_SETJMP_SUPPORTED |
/* restore jump buffer */ |
png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf)); |
#endif |
png_set_write_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL, |
png_flush_ptr_NULL); |
/* initialize zbuf - compression buffer */ |
png_ptr->zbuf_size = PNG_ZBUF_SIZE; |
png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)png_ptr->zbuf_size); |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT, |
1, png_doublep_NULL, png_doublep_NULL); |
#endif |
} |
/* Write a few rows of image data. If the image is interlaced, |
* either you will have to write the 7 sub images, or, if you |
* have called png_set_interlace_handling(), you will have to |
* "write" the image seven times. |
*/ |
void PNGAPI |
png_write_rows(png_structp png_ptr, png_bytepp row, |
png_uint_32 num_rows) |
{ |
png_uint_32 i; /* row counter */ |
png_bytepp rp; /* row pointer */ |
png_debug(1, "in png_write_rows\n"); |
/* loop through the rows */ |
for (i = 0, rp = row; i < num_rows; i++, rp++) |
{ |
png_write_row(png_ptr, *rp); |
} |
} |
/* Write the image. You only need to call this function once, even |
* if you are writing an interlaced image. |
*/ |
void PNGAPI |
png_write_image(png_structp png_ptr, png_bytepp image) |
{ |
png_uint_32 i; /* row index */ |
int pass, num_pass; /* pass variables */ |
png_bytepp rp; /* points to current row */ |
png_debug(1, "in png_write_image\n"); |
#if defined(PNG_WRITE_INTERLACING_SUPPORTED) |
/* intialize interlace handling. If image is not interlaced, |
this will set pass to 1 */ |
num_pass = png_set_interlace_handling(png_ptr); |
#else |
num_pass = 1; |
#endif |
/* loop through passes */ |
for (pass = 0; pass < num_pass; pass++) |
{ |
/* loop through image */ |
for (i = 0, rp = image; i < png_ptr->height; i++, rp++) |
{ |
png_write_row(png_ptr, *rp); |
} |
} |
} |
/* called by user to write a row of image data */ |
void PNGAPI |
png_write_row(png_structp png_ptr, png_bytep row) |
{ |
png_debug2(1, "in png_write_row (row %ld, pass %d)\n", |
png_ptr->row_number, png_ptr->pass); |
/* initialize transformations and other stuff if first time */ |
if (png_ptr->row_number == 0 && png_ptr->pass == 0) |
{ |
/* make sure we wrote the header info */ |
if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE)) |
png_error(png_ptr, |
"png_write_info was never called before png_write_row."); |
/* check for transforms that have been set but were defined out */ |
#if !defined(PNG_WRITE_INVERT_SUPPORTED) && defined(PNG_READ_INVERT_SUPPORTED) |
if (png_ptr->transformations & PNG_INVERT_MONO) |
png_warning(png_ptr, "PNG_WRITE_INVERT_SUPPORTED is not defined."); |
#endif |
#if !defined(PNG_WRITE_FILLER_SUPPORTED) && defined(PNG_READ_FILLER_SUPPORTED) |
if (png_ptr->transformations & PNG_FILLER) |
png_warning(png_ptr, "PNG_WRITE_FILLER_SUPPORTED is not defined."); |
#endif |
#if !defined(PNG_WRITE_PACKSWAP_SUPPORTED) && defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_PACKSWAP) |
png_warning(png_ptr, "PNG_WRITE_PACKSWAP_SUPPORTED is not defined."); |
#endif |
#if !defined(PNG_WRITE_PACK_SUPPORTED) && defined(PNG_READ_PACK_SUPPORTED) |
if (png_ptr->transformations & PNG_PACK) |
png_warning(png_ptr, "PNG_WRITE_PACK_SUPPORTED is not defined."); |
#endif |
#if !defined(PNG_WRITE_SHIFT_SUPPORTED) && defined(PNG_READ_SHIFT_SUPPORTED) |
if (png_ptr->transformations & PNG_SHIFT) |
png_warning(png_ptr, "PNG_WRITE_SHIFT_SUPPORTED is not defined."); |
#endif |
#if !defined(PNG_WRITE_BGR_SUPPORTED) && defined(PNG_READ_BGR_SUPPORTED) |
if (png_ptr->transformations & PNG_BGR) |
png_warning(png_ptr, "PNG_WRITE_BGR_SUPPORTED is not defined."); |
#endif |
#if !defined(PNG_WRITE_SWAP_SUPPORTED) && defined(PNG_READ_SWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_SWAP_BYTES) |
png_warning(png_ptr, "PNG_WRITE_SWAP_SUPPORTED is not defined."); |
#endif |
png_write_start_row(png_ptr); |
} |
#if defined(PNG_WRITE_INTERLACING_SUPPORTED) |
/* if interlaced and not interested in row, return */ |
if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE)) |
{ |
switch (png_ptr->pass) |
{ |
case 0: |
if (png_ptr->row_number & 0x07) |
{ |
png_write_finish_row(png_ptr); |
return; |
} |
break; |
case 1: |
if ((png_ptr->row_number & 0x07) || png_ptr->width < 5) |
{ |
png_write_finish_row(png_ptr); |
return; |
} |
break; |
case 2: |
if ((png_ptr->row_number & 0x07) != 4) |
{ |
png_write_finish_row(png_ptr); |
return; |
} |
break; |
case 3: |
if ((png_ptr->row_number & 0x03) || png_ptr->width < 3) |
{ |
png_write_finish_row(png_ptr); |
return; |
} |
break; |
case 4: |
if ((png_ptr->row_number & 0x03) != 2) |
{ |
png_write_finish_row(png_ptr); |
return; |
} |
break; |
case 5: |
if ((png_ptr->row_number & 0x01) || png_ptr->width < 2) |
{ |
png_write_finish_row(png_ptr); |
return; |
} |
break; |
case 6: |
if (!(png_ptr->row_number & 0x01)) |
{ |
png_write_finish_row(png_ptr); |
return; |
} |
break; |
} |
} |
#endif |
/* set up row info for transformations */ |
png_ptr->row_info.color_type = png_ptr->color_type; |
png_ptr->row_info.width = png_ptr->usr_width; |
png_ptr->row_info.channels = png_ptr->usr_channels; |
png_ptr->row_info.bit_depth = png_ptr->usr_bit_depth; |
png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth * |
png_ptr->row_info.channels); |
png_ptr->row_info.rowbytes = ((png_ptr->row_info.width * |
(png_uint_32)png_ptr->row_info.pixel_depth + 7) >> 3); |
png_debug1(3, "row_info->color_type = %d\n", png_ptr->row_info.color_type); |
png_debug1(3, "row_info->width = %lu\n", png_ptr->row_info.width); |
png_debug1(3, "row_info->channels = %d\n", png_ptr->row_info.channels); |
png_debug1(3, "row_info->bit_depth = %d\n", png_ptr->row_info.bit_depth); |
png_debug1(3, "row_info->pixel_depth = %d\n", png_ptr->row_info.pixel_depth); |
png_debug1(3, "row_info->rowbytes = %lu\n", png_ptr->row_info.rowbytes); |
/* Copy user's row into buffer, leaving room for filter byte. */ |
png_memcpy_check(png_ptr, png_ptr->row_buf + 1, row, |
png_ptr->row_info.rowbytes); |
#if defined(PNG_WRITE_INTERLACING_SUPPORTED) |
/* handle interlacing */ |
if (png_ptr->interlaced && png_ptr->pass < 6 && |
(png_ptr->transformations & PNG_INTERLACE)) |
{ |
png_do_write_interlace(&(png_ptr->row_info), |
png_ptr->row_buf + 1, png_ptr->pass); |
/* this should always get caught above, but still ... */ |
if (!(png_ptr->row_info.width)) |
{ |
png_write_finish_row(png_ptr); |
return; |
} |
} |
#endif |
/* handle other transformations */ |
if (png_ptr->transformations) |
png_do_write_transformations(png_ptr); |
#if defined(PNG_MNG_FEATURES_SUPPORTED) |
/* Write filter_method 64 (intrapixel differencing) only if |
* 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and |
* 2. Libpng did not write a PNG signature (this filter_method is only |
* used in PNG datastreams that are embedded in MNG datastreams) and |
* 3. The application called png_permit_mng_features with a mask that |
* included PNG_FLAG_MNG_FILTER_64 and |
* 4. The filter_method is 64 and |
* 5. The color_type is RGB or RGBA |
*/ |
if((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && |
(png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING)) |
{ |
/* Intrapixel differencing */ |
png_do_write_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1); |
} |
#endif |
/* Find a filter if necessary, filter the row and write it out. */ |
png_write_find_filter(png_ptr, &(png_ptr->row_info)); |
if (png_ptr->write_row_fn != NULL) |
(*(png_ptr->write_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass); |
} |
#if defined(PNG_WRITE_FLUSH_SUPPORTED) |
/* Set the automatic flush interval or 0 to turn flushing off */ |
void PNGAPI |
png_set_flush(png_structp png_ptr, int nrows) |
{ |
png_debug(1, "in png_set_flush\n"); |
png_ptr->flush_dist = (nrows < 0 ? 0 : nrows); |
} |
/* flush the current output buffers now */ |
void PNGAPI |
png_write_flush(png_structp png_ptr) |
{ |
int wrote_IDAT; |
png_debug(1, "in png_write_flush\n"); |
/* We have already written out all of the data */ |
if (png_ptr->row_number >= png_ptr->num_rows) |
return; |
do |
{ |
int ret; |
/* compress the data */ |
ret = deflate(&png_ptr->zstream, Z_SYNC_FLUSH); |
wrote_IDAT = 0; |
/* check for compression errors */ |
if (ret != Z_OK) |
{ |
if (png_ptr->zstream.msg != NULL) |
png_error(png_ptr, png_ptr->zstream.msg); |
else |
png_error(png_ptr, "zlib error"); |
} |
if (!(png_ptr->zstream.avail_out)) |
{ |
/* write the IDAT and reset the zlib output buffer */ |
png_write_IDAT(png_ptr, png_ptr->zbuf, |
png_ptr->zbuf_size); |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
wrote_IDAT = 1; |
} |
} while(wrote_IDAT == 1); |
/* If there is any data left to be output, write it into a new IDAT */ |
if (png_ptr->zbuf_size != png_ptr->zstream.avail_out) |
{ |
/* write the IDAT and reset the zlib output buffer */ |
png_write_IDAT(png_ptr, png_ptr->zbuf, |
png_ptr->zbuf_size - png_ptr->zstream.avail_out); |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
} |
png_ptr->flush_rows = 0; |
png_flush(png_ptr); |
} |
#endif /* PNG_WRITE_FLUSH_SUPPORTED */ |
/* free all memory used by the write */ |
void PNGAPI |
png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr) |
{ |
png_structp png_ptr = NULL; |
png_infop info_ptr = NULL; |
#ifdef PNG_USER_MEM_SUPPORTED |
png_free_ptr free_fn = NULL; |
png_voidp mem_ptr = NULL; |
#endif |
png_debug(1, "in png_destroy_write_struct\n"); |
if (png_ptr_ptr != NULL) |
{ |
png_ptr = *png_ptr_ptr; |
#ifdef PNG_USER_MEM_SUPPORTED |
free_fn = png_ptr->free_fn; |
mem_ptr = png_ptr->mem_ptr; |
#endif |
} |
if (info_ptr_ptr != NULL) |
info_ptr = *info_ptr_ptr; |
if (info_ptr != NULL) |
{ |
png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1); |
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) |
if (png_ptr->num_chunk_list) |
{ |
png_free(png_ptr, png_ptr->chunk_list); |
png_ptr->chunk_list=NULL; |
png_ptr->num_chunk_list=0; |
} |
#endif |
#ifdef PNG_USER_MEM_SUPPORTED |
png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn, |
(png_voidp)mem_ptr); |
#else |
png_destroy_struct((png_voidp)info_ptr); |
#endif |
*info_ptr_ptr = NULL; |
} |
if (png_ptr != NULL) |
{ |
png_write_destroy(png_ptr); |
#ifdef PNG_USER_MEM_SUPPORTED |
png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn, |
(png_voidp)mem_ptr); |
#else |
png_destroy_struct((png_voidp)png_ptr); |
#endif |
*png_ptr_ptr = NULL; |
} |
} |
/* Free any memory used in png_ptr struct (old method) */ |
void /* PRIVATE */ |
png_write_destroy(png_structp png_ptr) |
{ |
#ifdef PNG_SETJMP_SUPPORTED |
jmp_buf tmp_jmp; /* save jump buffer */ |
#endif |
png_error_ptr error_fn; |
png_error_ptr warning_fn; |
png_voidp error_ptr; |
#ifdef PNG_USER_MEM_SUPPORTED |
png_free_ptr free_fn; |
#endif |
png_debug(1, "in png_write_destroy\n"); |
/* free any memory zlib uses */ |
deflateEnd(&png_ptr->zstream); |
/* free our memory. png_free checks NULL for us. */ |
png_free(png_ptr, png_ptr->zbuf); |
png_free(png_ptr, png_ptr->row_buf); |
png_free(png_ptr, png_ptr->prev_row); |
png_free(png_ptr, png_ptr->sub_row); |
png_free(png_ptr, png_ptr->up_row); |
png_free(png_ptr, png_ptr->avg_row); |
png_free(png_ptr, png_ptr->paeth_row); |
#if defined(PNG_TIME_RFC1123_SUPPORTED) |
png_free(png_ptr, png_ptr->time_buffer); |
#endif |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
png_free(png_ptr, png_ptr->prev_filters); |
png_free(png_ptr, png_ptr->filter_weights); |
png_free(png_ptr, png_ptr->inv_filter_weights); |
png_free(png_ptr, png_ptr->filter_costs); |
png_free(png_ptr, png_ptr->inv_filter_costs); |
#endif |
#ifdef PNG_SETJMP_SUPPORTED |
/* reset structure */ |
png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf)); |
#endif |
error_fn = png_ptr->error_fn; |
warning_fn = png_ptr->warning_fn; |
error_ptr = png_ptr->error_ptr; |
#ifdef PNG_USER_MEM_SUPPORTED |
free_fn = png_ptr->free_fn; |
#endif |
png_memset(png_ptr, 0, sizeof (png_struct)); |
png_ptr->error_fn = error_fn; |
png_ptr->warning_fn = warning_fn; |
png_ptr->error_ptr = error_ptr; |
#ifdef PNG_USER_MEM_SUPPORTED |
png_ptr->free_fn = free_fn; |
#endif |
#ifdef PNG_SETJMP_SUPPORTED |
png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf)); |
#endif |
} |
/* Allow the application to select one or more row filters to use. */ |
void PNGAPI |
png_set_filter(png_structp png_ptr, int method, int filters) |
{ |
png_debug(1, "in png_set_filter\n"); |
#if defined(PNG_MNG_FEATURES_SUPPORTED) |
if((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && |
(method == PNG_INTRAPIXEL_DIFFERENCING)) |
method = PNG_FILTER_TYPE_BASE; |
#endif |
if (method == PNG_FILTER_TYPE_BASE) |
{ |
switch (filters & (PNG_ALL_FILTERS | 0x07)) |
{ |
case 5: |
case 6: |
case 7: png_warning(png_ptr, "Unknown row filter for method 0"); |
case PNG_FILTER_VALUE_NONE: png_ptr->do_filter=PNG_FILTER_NONE; break; |
case PNG_FILTER_VALUE_SUB: png_ptr->do_filter=PNG_FILTER_SUB; break; |
case PNG_FILTER_VALUE_UP: png_ptr->do_filter=PNG_FILTER_UP; break; |
case PNG_FILTER_VALUE_AVG: png_ptr->do_filter=PNG_FILTER_AVG; break; |
case PNG_FILTER_VALUE_PAETH: png_ptr->do_filter=PNG_FILTER_PAETH;break; |
default: png_ptr->do_filter = (png_byte)filters; break; |
} |
/* If we have allocated the row_buf, this means we have already started |
* with the image and we should have allocated all of the filter buffers |
* that have been selected. If prev_row isn't already allocated, then |
* it is too late to start using the filters that need it, since we |
* will be missing the data in the previous row. If an application |
* wants to start and stop using particular filters during compression, |
* it should start out with all of the filters, and then add and |
* remove them after the start of compression. |
*/ |
if (png_ptr->row_buf != NULL) |
{ |
if ((png_ptr->do_filter & PNG_FILTER_SUB) && png_ptr->sub_row == NULL) |
{ |
png_ptr->sub_row = (png_bytep)png_malloc(png_ptr, |
(png_ptr->rowbytes + 1)); |
png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB; |
} |
if ((png_ptr->do_filter & PNG_FILTER_UP) && png_ptr->up_row == NULL) |
{ |
if (png_ptr->prev_row == NULL) |
{ |
png_warning(png_ptr, "Can't add Up filter after starting"); |
png_ptr->do_filter &= ~PNG_FILTER_UP; |
} |
else |
{ |
png_ptr->up_row = (png_bytep)png_malloc(png_ptr, |
(png_ptr->rowbytes + 1)); |
png_ptr->up_row[0] = PNG_FILTER_VALUE_UP; |
} |
} |
if ((png_ptr->do_filter & PNG_FILTER_AVG) && png_ptr->avg_row == NULL) |
{ |
if (png_ptr->prev_row == NULL) |
{ |
png_warning(png_ptr, "Can't add Average filter after starting"); |
png_ptr->do_filter &= ~PNG_FILTER_AVG; |
} |
else |
{ |
png_ptr->avg_row = (png_bytep)png_malloc(png_ptr, |
(png_ptr->rowbytes + 1)); |
png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG; |
} |
} |
if ((png_ptr->do_filter & PNG_FILTER_PAETH) && |
png_ptr->paeth_row == NULL) |
{ |
if (png_ptr->prev_row == NULL) |
{ |
png_warning(png_ptr, "Can't add Paeth filter after starting"); |
png_ptr->do_filter &= (png_byte)(~PNG_FILTER_PAETH); |
} |
else |
{ |
png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr, |
(png_ptr->rowbytes + 1)); |
png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH; |
} |
} |
if (png_ptr->do_filter == PNG_NO_FILTERS) |
png_ptr->do_filter = PNG_FILTER_NONE; |
} |
} |
else |
png_error(png_ptr, "Unknown custom filter method"); |
} |
/* This allows us to influence the way in which libpng chooses the "best" |
* filter for the current scanline. While the "minimum-sum-of-absolute- |
* differences metric is relatively fast and effective, there is some |
* question as to whether it can be improved upon by trying to keep the |
* filtered data going to zlib more consistent, hopefully resulting in |
* better compression. |
*/ |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) /* GRR 970116 */ |
void PNGAPI |
png_set_filter_heuristics(png_structp png_ptr, int heuristic_method, |
int num_weights, png_doublep filter_weights, |
png_doublep filter_costs) |
{ |
int i; |
png_debug(1, "in png_set_filter_heuristics\n"); |
if (heuristic_method >= PNG_FILTER_HEURISTIC_LAST) |
{ |
png_warning(png_ptr, "Unknown filter heuristic method"); |
return; |
} |
if (heuristic_method == PNG_FILTER_HEURISTIC_DEFAULT) |
{ |
heuristic_method = PNG_FILTER_HEURISTIC_UNWEIGHTED; |
} |
if (num_weights < 0 || filter_weights == NULL || |
heuristic_method == PNG_FILTER_HEURISTIC_UNWEIGHTED) |
{ |
num_weights = 0; |
} |
png_ptr->num_prev_filters = (png_byte)num_weights; |
png_ptr->heuristic_method = (png_byte)heuristic_method; |
if (num_weights > 0) |
{ |
if (png_ptr->prev_filters == NULL) |
{ |
png_ptr->prev_filters = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)(sizeof(png_byte) * num_weights)); |
/* To make sure that the weighting starts out fairly */ |
for (i = 0; i < num_weights; i++) |
{ |
png_ptr->prev_filters[i] = 255; |
} |
} |
if (png_ptr->filter_weights == NULL) |
{ |
png_ptr->filter_weights = (png_uint_16p)png_malloc(png_ptr, |
(png_uint_32)(sizeof(png_uint_16) * num_weights)); |
png_ptr->inv_filter_weights = (png_uint_16p)png_malloc(png_ptr, |
(png_uint_32)(sizeof(png_uint_16) * num_weights)); |
for (i = 0; i < num_weights; i++) |
{ |
png_ptr->inv_filter_weights[i] = |
png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR; |
} |
} |
for (i = 0; i < num_weights; i++) |
{ |
if (filter_weights[i] < 0.0) |
{ |
png_ptr->inv_filter_weights[i] = |
png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR; |
} |
else |
{ |
png_ptr->inv_filter_weights[i] = |
(png_uint_16)((double)PNG_WEIGHT_FACTOR*filter_weights[i]+0.5); |
png_ptr->filter_weights[i] = |
(png_uint_16)((double)PNG_WEIGHT_FACTOR/filter_weights[i]+0.5); |
} |
} |
} |
/* If, in the future, there are other filter methods, this would |
* need to be based on png_ptr->filter. |
*/ |
if (png_ptr->filter_costs == NULL) |
{ |
png_ptr->filter_costs = (png_uint_16p)png_malloc(png_ptr, |
(png_uint_32)(sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST)); |
png_ptr->inv_filter_costs = (png_uint_16p)png_malloc(png_ptr, |
(png_uint_32)(sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST)); |
for (i = 0; i < PNG_FILTER_VALUE_LAST; i++) |
{ |
png_ptr->inv_filter_costs[i] = |
png_ptr->filter_costs[i] = PNG_COST_FACTOR; |
} |
} |
/* Here is where we set the relative costs of the different filters. We |
* should take the desired compression level into account when setting |
* the costs, so that Paeth, for instance, has a high relative cost at low |
* compression levels, while it has a lower relative cost at higher |
* compression settings. The filter types are in order of increasing |
* relative cost, so it would be possible to do this with an algorithm. |
*/ |
for (i = 0; i < PNG_FILTER_VALUE_LAST; i++) |
{ |
if (filter_costs == NULL || filter_costs[i] < 0.0) |
{ |
png_ptr->inv_filter_costs[i] = |
png_ptr->filter_costs[i] = PNG_COST_FACTOR; |
} |
else if (filter_costs[i] >= 1.0) |
{ |
png_ptr->inv_filter_costs[i] = |
(png_uint_16)((double)PNG_COST_FACTOR / filter_costs[i] + 0.5); |
png_ptr->filter_costs[i] = |
(png_uint_16)((double)PNG_COST_FACTOR * filter_costs[i] + 0.5); |
} |
} |
} |
#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */ |
void PNGAPI |
png_set_compression_level(png_structp png_ptr, int level) |
{ |
png_debug(1, "in png_set_compression_level\n"); |
png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_LEVEL; |
png_ptr->zlib_level = level; |
} |
void PNGAPI |
png_set_compression_mem_level(png_structp png_ptr, int mem_level) |
{ |
png_debug(1, "in png_set_compression_mem_level\n"); |
png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL; |
png_ptr->zlib_mem_level = mem_level; |
} |
void PNGAPI |
png_set_compression_strategy(png_structp png_ptr, int strategy) |
{ |
png_debug(1, "in png_set_compression_strategy\n"); |
png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_STRATEGY; |
png_ptr->zlib_strategy = strategy; |
} |
void PNGAPI |
png_set_compression_window_bits(png_structp png_ptr, int window_bits) |
{ |
if (window_bits > 15) |
png_warning(png_ptr, "Only compression windows <= 32k supported by PNG"); |
else if (window_bits < 8) |
png_warning(png_ptr, "Only compression windows >= 256 supported by PNG"); |
#ifndef WBITS_8_OK |
/* avoid libpng bug with 256-byte windows */ |
if (window_bits == 8) |
{ |
png_warning(png_ptr, "Compression window is being reset to 512"); |
window_bits=9; |
} |
#endif |
png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS; |
png_ptr->zlib_window_bits = window_bits; |
} |
void PNGAPI |
png_set_compression_method(png_structp png_ptr, int method) |
{ |
png_debug(1, "in png_set_compression_method\n"); |
if (method != 8) |
png_warning(png_ptr, "Only compression method 8 is supported by PNG"); |
png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_METHOD; |
png_ptr->zlib_method = method; |
} |
void PNGAPI |
png_set_write_status_fn(png_structp png_ptr, png_write_status_ptr write_row_fn) |
{ |
png_ptr->write_row_fn = write_row_fn; |
} |
#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) |
void PNGAPI |
png_set_write_user_transform_fn(png_structp png_ptr, png_user_transform_ptr |
write_user_transform_fn) |
{ |
png_debug(1, "in png_set_write_user_transform_fn\n"); |
png_ptr->transformations |= PNG_USER_TRANSFORM; |
png_ptr->write_user_transform_fn = write_user_transform_fn; |
} |
#endif |
#if defined(PNG_INFO_IMAGE_SUPPORTED) |
void PNGAPI |
png_write_png(png_structp png_ptr, png_infop info_ptr, |
int transforms, voidp params) |
{ |
#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) |
/* invert the alpha channel from opacity to transparency */ |
if (transforms & PNG_TRANSFORM_INVERT_ALPHA) |
png_set_invert_alpha(png_ptr); |
#endif |
/* Write the file header information. */ |
png_write_info(png_ptr, info_ptr); |
/* ------ these transformations don't touch the info structure ------- */ |
#if defined(PNG_WRITE_INVERT_SUPPORTED) |
/* invert monochrome pixels */ |
if (transforms & PNG_TRANSFORM_INVERT_MONO) |
png_set_invert_mono(png_ptr); |
#endif |
#if defined(PNG_WRITE_SHIFT_SUPPORTED) |
/* Shift the pixels up to a legal bit depth and fill in |
* as appropriate to correctly scale the image. |
*/ |
if ((transforms & PNG_TRANSFORM_SHIFT) |
&& (info_ptr->valid & PNG_INFO_sBIT)) |
png_set_shift(png_ptr, &info_ptr->sig_bit); |
#endif |
#if defined(PNG_WRITE_PACK_SUPPORTED) |
/* pack pixels into bytes */ |
if (transforms & PNG_TRANSFORM_PACKING) |
png_set_packing(png_ptr); |
#endif |
#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) |
/* swap location of alpha bytes from ARGB to RGBA */ |
if (transforms & PNG_TRANSFORM_SWAP_ALPHA) |
png_set_swap_alpha(png_ptr); |
#endif |
#if defined(PNG_WRITE_FILLER_SUPPORTED) |
/* Get rid of filler (OR ALPHA) bytes, pack XRGB/RGBX/ARGB/RGBA into |
* RGB (4 channels -> 3 channels). The second parameter is not used. |
*/ |
if (transforms & PNG_TRANSFORM_STRIP_FILLER) |
png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE); |
#endif |
#if defined(PNG_WRITE_BGR_SUPPORTED) |
/* flip BGR pixels to RGB */ |
if (transforms & PNG_TRANSFORM_BGR) |
png_set_bgr(png_ptr); |
#endif |
#if defined(PNG_WRITE_SWAP_SUPPORTED) |
/* swap bytes of 16-bit files to most significant byte first */ |
if (transforms & PNG_TRANSFORM_SWAP_ENDIAN) |
png_set_swap(png_ptr); |
#endif |
#if defined(PNG_WRITE_PACKSWAP_SUPPORTED) |
/* swap bits of 1, 2, 4 bit packed pixel formats */ |
if (transforms & PNG_TRANSFORM_PACKSWAP) |
png_set_packswap(png_ptr); |
#endif |
/* ----------------------- end of transformations ------------------- */ |
/* write the bits */ |
if (info_ptr->valid & PNG_INFO_IDAT) |
png_write_image(png_ptr, info_ptr->row_pointers); |
/* It is REQUIRED to call this to finish writing the rest of the file */ |
png_write_end(png_ptr, info_ptr); |
if(transforms == 0 || params == NULL) |
/* quiet compiler warnings */ return; |
} |
#endif |
#endif /* PNG_WRITE_SUPPORTED */ |
/shark/trunk/ports/png/pngpread.c |
---|
0,0 → 1,1543 |
/* pngpread.c - read a png file in push mode |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
*/ |
#define PNG_INTERNAL |
#include "png.h" |
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
/* push model modes */ |
#define PNG_READ_SIG_MODE 0 |
#define PNG_READ_CHUNK_MODE 1 |
#define PNG_READ_IDAT_MODE 2 |
#define PNG_SKIP_MODE 3 |
#define PNG_READ_tEXt_MODE 4 |
#define PNG_READ_zTXt_MODE 5 |
#define PNG_READ_DONE_MODE 6 |
#define PNG_READ_iTXt_MODE 7 |
#define PNG_ERROR_MODE 8 |
void PNGAPI |
png_process_data(png_structp png_ptr, png_infop info_ptr, |
png_bytep buffer, png_size_t buffer_size) |
{ |
png_push_restore_buffer(png_ptr, buffer, buffer_size); |
while (png_ptr->buffer_size) |
{ |
png_process_some_data(png_ptr, info_ptr); |
} |
} |
/* What we do with the incoming data depends on what we were previously |
* doing before we ran out of data... |
*/ |
void /* PRIVATE */ |
png_process_some_data(png_structp png_ptr, png_infop info_ptr) |
{ |
switch (png_ptr->process_mode) |
{ |
case PNG_READ_SIG_MODE: |
{ |
png_push_read_sig(png_ptr, info_ptr); |
break; |
} |
case PNG_READ_CHUNK_MODE: |
{ |
png_push_read_chunk(png_ptr, info_ptr); |
break; |
} |
case PNG_READ_IDAT_MODE: |
{ |
png_push_read_IDAT(png_ptr); |
break; |
} |
#if defined(PNG_READ_tEXt_SUPPORTED) |
case PNG_READ_tEXt_MODE: |
{ |
png_push_read_tEXt(png_ptr, info_ptr); |
break; |
} |
#endif |
#if defined(PNG_READ_zTXt_SUPPORTED) |
case PNG_READ_zTXt_MODE: |
{ |
png_push_read_zTXt(png_ptr, info_ptr); |
break; |
} |
#endif |
#if defined(PNG_READ_iTXt_SUPPORTED) |
case PNG_READ_iTXt_MODE: |
{ |
png_push_read_iTXt(png_ptr, info_ptr); |
break; |
} |
#endif |
case PNG_SKIP_MODE: |
{ |
png_push_crc_finish(png_ptr); |
break; |
} |
default: |
{ |
png_ptr->buffer_size = 0; |
break; |
} |
} |
} |
/* Read any remaining signature bytes from the stream and compare them with |
* the correct PNG signature. It is possible that this routine is called |
* with bytes already read from the signature, either because they have been |
* checked by the calling application, or because of multiple calls to this |
* routine. |
*/ |
void /* PRIVATE */ |
png_push_read_sig(png_structp png_ptr, png_infop info_ptr) |
{ |
png_size_t num_checked = png_ptr->sig_bytes, |
num_to_check = 8 - num_checked; |
if (png_ptr->buffer_size < num_to_check) |
{ |
num_to_check = png_ptr->buffer_size; |
} |
png_push_fill_buffer(png_ptr, &(info_ptr->signature[num_checked]), |
num_to_check); |
png_ptr->sig_bytes = (png_byte)(png_ptr->sig_bytes+num_to_check); |
if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check)) |
{ |
if (num_checked < 4 && |
png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4)) |
png_error(png_ptr, "Not a PNG file"); |
else |
png_error(png_ptr, "PNG file corrupted by ASCII conversion"); |
} |
else |
{ |
if (png_ptr->sig_bytes >= 8) |
{ |
png_ptr->process_mode = PNG_READ_CHUNK_MODE; |
} |
} |
} |
void /* PRIVATE */ |
png_push_read_chunk(png_structp png_ptr, png_infop info_ptr) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_IHDR; |
PNG_IDAT; |
PNG_IEND; |
PNG_PLTE; |
#if defined(PNG_READ_bKGD_SUPPORTED) |
PNG_bKGD; |
#endif |
#if defined(PNG_READ_cHRM_SUPPORTED) |
PNG_cHRM; |
#endif |
#if defined(PNG_READ_gAMA_SUPPORTED) |
PNG_gAMA; |
#endif |
#if defined(PNG_READ_hIST_SUPPORTED) |
PNG_hIST; |
#endif |
#if defined(PNG_READ_iCCP_SUPPORTED) |
PNG_iCCP; |
#endif |
#if defined(PNG_READ_iTXt_SUPPORTED) |
PNG_iTXt; |
#endif |
#if defined(PNG_READ_oFFs_SUPPORTED) |
PNG_oFFs; |
#endif |
#if defined(PNG_READ_pCAL_SUPPORTED) |
PNG_pCAL; |
#endif |
#if defined(PNG_READ_pHYs_SUPPORTED) |
PNG_pHYs; |
#endif |
#if defined(PNG_READ_sBIT_SUPPORTED) |
PNG_sBIT; |
#endif |
#if defined(PNG_READ_sCAL_SUPPORTED) |
PNG_sCAL; |
#endif |
#if defined(PNG_READ_sRGB_SUPPORTED) |
PNG_sRGB; |
#endif |
#if defined(PNG_READ_sPLT_SUPPORTED) |
PNG_sPLT; |
#endif |
#if defined(PNG_READ_tEXt_SUPPORTED) |
PNG_tEXt; |
#endif |
#if defined(PNG_READ_tIME_SUPPORTED) |
PNG_tIME; |
#endif |
#if defined(PNG_READ_tRNS_SUPPORTED) |
PNG_tRNS; |
#endif |
#if defined(PNG_READ_zTXt_SUPPORTED) |
PNG_zTXt; |
#endif |
#endif /* PNG_USE_LOCAL_ARRAYS */ |
/* First we make sure we have enough data for the 4 byte chunk name |
* and the 4 byte chunk length before proceeding with decoding the |
* chunk data. To fully decode each of these chunks, we also make |
* sure we have enough data in the buffer for the 4 byte CRC at the |
* end of every chunk (except IDAT, which is handled separately). |
*/ |
if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER)) |
{ |
png_byte chunk_length[4]; |
if (png_ptr->buffer_size < 8) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_push_fill_buffer(png_ptr, chunk_length, 4); |
png_ptr->push_length = png_get_uint_32(chunk_length); |
png_reset_crc(png_ptr); |
png_crc_read(png_ptr, png_ptr->chunk_name, 4); |
png_ptr->mode |= PNG_HAVE_CHUNK_HEADER; |
} |
if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_IHDR(png_ptr, info_ptr, png_ptr->push_length); |
} |
else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_PLTE(png_ptr, info_ptr, png_ptr->push_length); |
} |
else if (!png_memcmp(png_ptr->chunk_name, (png_bytep)png_IDAT, 4)) |
{ |
/* If we reach an IDAT chunk, this means we have read all of the |
* header chunks, and we can start reading the image (or if this |
* is called after the image has been read - we have an error). |
*/ |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before IDAT"); |
else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && |
!(png_ptr->mode & PNG_HAVE_PLTE)) |
png_error(png_ptr, "Missing PLTE before IDAT"); |
if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
if (png_ptr->push_length == 0) |
return; |
if (png_ptr->mode & PNG_AFTER_IDAT) |
png_error(png_ptr, "Too many IDAT's found"); |
} |
png_ptr->idat_size = png_ptr->push_length; |
png_ptr->mode |= PNG_HAVE_IDAT; |
png_ptr->process_mode = PNG_READ_IDAT_MODE; |
png_push_have_info(png_ptr, info_ptr); |
png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes; |
png_ptr->zstream.next_out = png_ptr->row_buf; |
return; |
} |
else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_IEND(png_ptr, info_ptr, png_ptr->push_length); |
png_ptr->process_mode = PNG_READ_DONE_MODE; |
png_push_have_end(png_ptr, info_ptr); |
} |
#if defined(PNG_READ_gAMA_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_gAMA(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_sBIT_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_sBIT(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_cHRM_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_sRGB_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_iCCP_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_iCCP(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_sPLT_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_sPLT(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_tRNS_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_tRNS(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_bKGD_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_bKGD(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_hIST_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_hIST(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_pHYs_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_pHYs(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_oFFs_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_oFFs(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_pCAL_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_pCAL(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_sCAL_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_sCAL(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_tIME_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_tIME(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_tEXt_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_push_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_zTXt_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_push_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_iTXt_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_push_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
else |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_push_handle_unknown(png_ptr, info_ptr, png_ptr->push_length); |
} |
png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER; |
} |
void /* PRIVATE */ |
png_push_crc_skip(png_structp png_ptr, png_uint_32 skip) |
{ |
png_ptr->process_mode = PNG_SKIP_MODE; |
png_ptr->skip_length = skip; |
} |
void /* PRIVATE */ |
png_push_crc_finish(png_structp png_ptr) |
{ |
if (png_ptr->skip_length && png_ptr->save_buffer_size) |
{ |
png_size_t save_size; |
if (png_ptr->skip_length < (png_uint_32)png_ptr->save_buffer_size) |
save_size = (png_size_t)png_ptr->skip_length; |
else |
save_size = png_ptr->save_buffer_size; |
png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size); |
png_ptr->skip_length -= save_size; |
png_ptr->buffer_size -= save_size; |
png_ptr->save_buffer_size -= save_size; |
png_ptr->save_buffer_ptr += save_size; |
} |
if (png_ptr->skip_length && png_ptr->current_buffer_size) |
{ |
png_size_t save_size; |
if (png_ptr->skip_length < (png_uint_32)png_ptr->current_buffer_size) |
save_size = (png_size_t)png_ptr->skip_length; |
else |
save_size = png_ptr->current_buffer_size; |
png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size); |
png_ptr->skip_length -= save_size; |
png_ptr->buffer_size -= save_size; |
png_ptr->current_buffer_size -= save_size; |
png_ptr->current_buffer_ptr += save_size; |
} |
if (!png_ptr->skip_length) |
{ |
if (png_ptr->buffer_size < 4) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_crc_finish(png_ptr, 0); |
png_ptr->process_mode = PNG_READ_CHUNK_MODE; |
} |
} |
void PNGAPI |
png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length) |
{ |
png_bytep ptr; |
ptr = buffer; |
if (png_ptr->save_buffer_size) |
{ |
png_size_t save_size; |
if (length < png_ptr->save_buffer_size) |
save_size = length; |
else |
save_size = png_ptr->save_buffer_size; |
png_memcpy(ptr, png_ptr->save_buffer_ptr, save_size); |
length -= save_size; |
ptr += save_size; |
png_ptr->buffer_size -= save_size; |
png_ptr->save_buffer_size -= save_size; |
png_ptr->save_buffer_ptr += save_size; |
} |
if (length && png_ptr->current_buffer_size) |
{ |
png_size_t save_size; |
if (length < png_ptr->current_buffer_size) |
save_size = length; |
else |
save_size = png_ptr->current_buffer_size; |
png_memcpy(ptr, png_ptr->current_buffer_ptr, save_size); |
png_ptr->buffer_size -= save_size; |
png_ptr->current_buffer_size -= save_size; |
png_ptr->current_buffer_ptr += save_size; |
} |
} |
void /* PRIVATE */ |
png_push_save_buffer(png_structp png_ptr) |
{ |
if (png_ptr->save_buffer_size) |
{ |
if (png_ptr->save_buffer_ptr != png_ptr->save_buffer) |
{ |
png_size_t i,istop; |
png_bytep sp; |
png_bytep dp; |
istop = png_ptr->save_buffer_size; |
for (i = 0, sp = png_ptr->save_buffer_ptr, dp = png_ptr->save_buffer; |
i < istop; i++, sp++, dp++) |
{ |
*dp = *sp; |
} |
} |
} |
if (png_ptr->save_buffer_size + png_ptr->current_buffer_size > |
png_ptr->save_buffer_max) |
{ |
png_size_t new_max; |
png_bytep old_buffer; |
new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256; |
old_buffer = png_ptr->save_buffer; |
png_ptr->save_buffer = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)new_max); |
png_memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size); |
png_free(png_ptr, old_buffer); |
png_ptr->save_buffer_max = new_max; |
} |
if (png_ptr->current_buffer_size) |
{ |
png_memcpy(png_ptr->save_buffer + png_ptr->save_buffer_size, |
png_ptr->current_buffer_ptr, png_ptr->current_buffer_size); |
png_ptr->save_buffer_size += png_ptr->current_buffer_size; |
png_ptr->current_buffer_size = 0; |
} |
png_ptr->save_buffer_ptr = png_ptr->save_buffer; |
png_ptr->buffer_size = 0; |
} |
void /* PRIVATE */ |
png_push_restore_buffer(png_structp png_ptr, png_bytep buffer, |
png_size_t buffer_length) |
{ |
png_ptr->current_buffer = buffer; |
png_ptr->current_buffer_size = buffer_length; |
png_ptr->buffer_size = buffer_length + png_ptr->save_buffer_size; |
png_ptr->current_buffer_ptr = png_ptr->current_buffer; |
} |
void /* PRIVATE */ |
png_push_read_IDAT(png_structp png_ptr) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_IDAT; |
#endif |
if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER)) |
{ |
png_byte chunk_length[4]; |
if (png_ptr->buffer_size < 8) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_push_fill_buffer(png_ptr, chunk_length, 4); |
png_ptr->push_length = png_get_uint_32(chunk_length); |
png_reset_crc(png_ptr); |
png_crc_read(png_ptr, png_ptr->chunk_name, 4); |
png_ptr->mode |= PNG_HAVE_CHUNK_HEADER; |
if (png_memcmp(png_ptr->chunk_name, (png_bytep)png_IDAT, 4)) |
{ |
png_ptr->process_mode = PNG_READ_CHUNK_MODE; |
if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED)) |
png_error(png_ptr, "Not enough compressed data"); |
return; |
} |
png_ptr->idat_size = png_ptr->push_length; |
} |
if (png_ptr->idat_size && png_ptr->save_buffer_size) |
{ |
png_size_t save_size; |
if (png_ptr->idat_size < (png_uint_32)png_ptr->save_buffer_size) |
{ |
save_size = (png_size_t)png_ptr->idat_size; |
/* check for overflow */ |
if((png_uint_32)save_size != png_ptr->idat_size) |
png_error(png_ptr, "save_size overflowed in pngpread"); |
} |
else |
save_size = png_ptr->save_buffer_size; |
png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size); |
if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED)) |
png_process_IDAT_data(png_ptr, png_ptr->save_buffer_ptr, save_size); |
png_ptr->idat_size -= save_size; |
png_ptr->buffer_size -= save_size; |
png_ptr->save_buffer_size -= save_size; |
png_ptr->save_buffer_ptr += save_size; |
} |
if (png_ptr->idat_size && png_ptr->current_buffer_size) |
{ |
png_size_t save_size; |
if (png_ptr->idat_size < (png_uint_32)png_ptr->current_buffer_size) |
{ |
save_size = (png_size_t)png_ptr->idat_size; |
/* check for overflow */ |
if((png_uint_32)save_size != png_ptr->idat_size) |
png_error(png_ptr, "save_size overflowed in pngpread"); |
} |
else |
save_size = png_ptr->current_buffer_size; |
png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size); |
if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED)) |
png_process_IDAT_data(png_ptr, png_ptr->current_buffer_ptr, save_size); |
png_ptr->idat_size -= save_size; |
png_ptr->buffer_size -= save_size; |
png_ptr->current_buffer_size -= save_size; |
png_ptr->current_buffer_ptr += save_size; |
} |
if (!png_ptr->idat_size) |
{ |
if (png_ptr->buffer_size < 4) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_crc_finish(png_ptr, 0); |
png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER; |
png_ptr->mode |= PNG_AFTER_IDAT; |
} |
} |
void /* PRIVATE */ |
png_process_IDAT_data(png_structp png_ptr, png_bytep buffer, |
png_size_t buffer_length) |
{ |
int ret; |
if ((png_ptr->flags & PNG_FLAG_ZLIB_FINISHED) && buffer_length) |
png_error(png_ptr, "Extra compression data"); |
png_ptr->zstream.next_in = buffer; |
png_ptr->zstream.avail_in = (uInt)buffer_length; |
for(;;) |
{ |
ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); |
if (ret != Z_OK) |
{ |
if (ret == Z_STREAM_END) |
{ |
if (png_ptr->zstream.avail_in) |
png_error(png_ptr, "Extra compressed data"); |
if (!(png_ptr->zstream.avail_out)) |
{ |
png_push_process_row(png_ptr); |
} |
png_ptr->mode |= PNG_AFTER_IDAT; |
png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; |
break; |
} |
else if (ret == Z_BUF_ERROR) |
break; |
else |
png_error(png_ptr, "Decompression Error"); |
} |
if (!(png_ptr->zstream.avail_out)) |
{ |
if (( |
#if defined(PNG_READ_INTERLACING_SUPPORTED) |
png_ptr->interlaced && png_ptr->pass > 6) || |
(!png_ptr->interlaced && |
#endif |
png_ptr->row_number == png_ptr->num_rows-1)) |
{ |
if (png_ptr->zstream.avail_in) |
png_warning(png_ptr, "Too much data in IDAT chunks"); |
png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; |
break; |
} |
png_push_process_row(png_ptr); |
png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes; |
png_ptr->zstream.next_out = png_ptr->row_buf; |
} |
else |
break; |
} |
} |
void /* PRIVATE */ |
png_push_process_row(png_structp png_ptr) |
{ |
png_ptr->row_info.color_type = png_ptr->color_type; |
png_ptr->row_info.width = png_ptr->iwidth; |
png_ptr->row_info.channels = png_ptr->channels; |
png_ptr->row_info.bit_depth = png_ptr->bit_depth; |
png_ptr->row_info.pixel_depth = png_ptr->pixel_depth; |
png_ptr->row_info.rowbytes = ((png_ptr->row_info.width * |
(png_uint_32)png_ptr->row_info.pixel_depth + 7) >> 3); |
png_read_filter_row(png_ptr, &(png_ptr->row_info), |
png_ptr->row_buf + 1, png_ptr->prev_row + 1, |
(int)(png_ptr->row_buf[0])); |
png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf, |
png_ptr->rowbytes + 1); |
if (png_ptr->transformations) |
png_do_read_transformations(png_ptr); |
#if defined(PNG_READ_INTERLACING_SUPPORTED) |
/* blow up interlaced rows to full size */ |
if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE)) |
{ |
if (png_ptr->pass < 6) |
/* old interface (pre-1.0.9): |
png_do_read_interlace(&(png_ptr->row_info), |
png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations); |
*/ |
png_do_read_interlace(png_ptr); |
switch (png_ptr->pass) |
{ |
case 0: |
{ |
int i; |
for (i = 0; i < 8 && png_ptr->pass == 0; i++) |
{ |
png_push_have_row(png_ptr, png_ptr->row_buf + 1); |
png_read_push_finish_row(png_ptr); /* updates png_ptr->pass */ |
} |
if (png_ptr->pass == 2) /* pass 1 might be empty */ |
{ |
for (i = 0; i < 4 && png_ptr->pass == 2; i++) |
{ |
png_push_have_row(png_ptr, png_bytep_NULL); |
png_read_push_finish_row(png_ptr); |
} |
} |
if (png_ptr->pass == 4 && png_ptr->height <= 4) |
{ |
for (i = 0; i < 2 && png_ptr->pass == 4; i++) |
{ |
png_push_have_row(png_ptr, png_bytep_NULL); |
png_read_push_finish_row(png_ptr); |
} |
} |
if (png_ptr->pass == 6 && png_ptr->height <= 4) |
{ |
png_push_have_row(png_ptr, png_bytep_NULL); |
png_read_push_finish_row(png_ptr); |
} |
break; |
} |
case 1: |
{ |
int i; |
for (i = 0; i < 8 && png_ptr->pass == 1; i++) |
{ |
png_push_have_row(png_ptr, png_ptr->row_buf + 1); |
png_read_push_finish_row(png_ptr); |
} |
if (png_ptr->pass == 2) /* skip top 4 generated rows */ |
{ |
for (i = 0; i < 4 && png_ptr->pass == 2; i++) |
{ |
png_push_have_row(png_ptr, png_bytep_NULL); |
png_read_push_finish_row(png_ptr); |
} |
} |
break; |
} |
case 2: |
{ |
int i; |
for (i = 0; i < 4 && png_ptr->pass == 2; i++) |
{ |
png_push_have_row(png_ptr, png_ptr->row_buf + 1); |
png_read_push_finish_row(png_ptr); |
} |
for (i = 0; i < 4 && png_ptr->pass == 2; i++) |
{ |
png_push_have_row(png_ptr, png_bytep_NULL); |
png_read_push_finish_row(png_ptr); |
} |
if (png_ptr->pass == 4) /* pass 3 might be empty */ |
{ |
for (i = 0; i < 2 && png_ptr->pass == 4; i++) |
{ |
png_push_have_row(png_ptr, png_bytep_NULL); |
png_read_push_finish_row(png_ptr); |
} |
} |
break; |
} |
case 3: |
{ |
int i; |
for (i = 0; i < 4 && png_ptr->pass == 3; i++) |
{ |
png_push_have_row(png_ptr, png_ptr->row_buf + 1); |
png_read_push_finish_row(png_ptr); |
} |
if (png_ptr->pass == 4) /* skip top two generated rows */ |
{ |
for (i = 0; i < 2 && png_ptr->pass == 4; i++) |
{ |
png_push_have_row(png_ptr, png_bytep_NULL); |
png_read_push_finish_row(png_ptr); |
} |
} |
break; |
} |
case 4: |
{ |
int i; |
for (i = 0; i < 2 && png_ptr->pass == 4; i++) |
{ |
png_push_have_row(png_ptr, png_ptr->row_buf + 1); |
png_read_push_finish_row(png_ptr); |
} |
for (i = 0; i < 2 && png_ptr->pass == 4; i++) |
{ |
png_push_have_row(png_ptr, png_bytep_NULL); |
png_read_push_finish_row(png_ptr); |
} |
if (png_ptr->pass == 6) /* pass 5 might be empty */ |
{ |
png_push_have_row(png_ptr, png_bytep_NULL); |
png_read_push_finish_row(png_ptr); |
} |
break; |
} |
case 5: |
{ |
int i; |
for (i = 0; i < 2 && png_ptr->pass == 5; i++) |
{ |
png_push_have_row(png_ptr, png_ptr->row_buf + 1); |
png_read_push_finish_row(png_ptr); |
} |
if (png_ptr->pass == 6) /* skip top generated row */ |
{ |
png_push_have_row(png_ptr, png_bytep_NULL); |
png_read_push_finish_row(png_ptr); |
} |
break; |
} |
case 6: |
{ |
png_push_have_row(png_ptr, png_ptr->row_buf + 1); |
png_read_push_finish_row(png_ptr); |
if (png_ptr->pass != 6) |
break; |
png_push_have_row(png_ptr, png_bytep_NULL); |
png_read_push_finish_row(png_ptr); |
} |
} |
} |
else |
#endif |
{ |
png_push_have_row(png_ptr, png_ptr->row_buf + 1); |
png_read_push_finish_row(png_ptr); |
} |
} |
void /* PRIVATE */ |
png_read_push_finish_row(png_structp png_ptr) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
/* start of interlace block */ |
const int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; |
/* offset to next interlace block */ |
const int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; |
/* start of interlace block in the y direction */ |
const int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1}; |
/* offset to next interlace block in the y direction */ |
const int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2}; |
/* Width of interlace block. This is not currently used - if you need |
* it, uncomment it here and in png.h |
const int FARDATA png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; |
*/ |
/* Height of interlace block. This is not currently used - if you need |
* it, uncomment it here and in png.h |
const int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1}; |
*/ |
#endif |
png_ptr->row_number++; |
if (png_ptr->row_number < png_ptr->num_rows) |
return; |
if (png_ptr->interlaced) |
{ |
png_ptr->row_number = 0; |
png_memset_check(png_ptr, png_ptr->prev_row, 0, |
png_ptr->rowbytes + 1); |
do |
{ |
png_ptr->pass++; |
if ((png_ptr->pass == 1 && png_ptr->width < 5) || |
(png_ptr->pass == 3 && png_ptr->width < 3) || |
(png_ptr->pass == 5 && png_ptr->width < 2)) |
png_ptr->pass++; |
if (png_ptr->pass > 7) |
png_ptr->pass--; |
if (png_ptr->pass >= 7) |
break; |
png_ptr->iwidth = (png_ptr->width + |
png_pass_inc[png_ptr->pass] - 1 - |
png_pass_start[png_ptr->pass]) / |
png_pass_inc[png_ptr->pass]; |
png_ptr->irowbytes = ((png_ptr->iwidth * |
png_ptr->pixel_depth + 7) >> 3) + 1; |
if (png_ptr->transformations & PNG_INTERLACE) |
break; |
png_ptr->num_rows = (png_ptr->height + |
png_pass_yinc[png_ptr->pass] - 1 - |
png_pass_ystart[png_ptr->pass]) / |
png_pass_yinc[png_ptr->pass]; |
} while (png_ptr->iwidth == 0 || png_ptr->num_rows == 0); |
} |
} |
#if defined(PNG_READ_tEXt_SUPPORTED) |
void /* PRIVATE */ |
png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 |
length) |
{ |
if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND)) |
{ |
png_error(png_ptr, "Out of place tEXt"); |
/* to quiet some compiler warnings */ |
if(info_ptr == NULL) return; |
} |
#ifdef PNG_MAX_MALLOC_64K |
png_ptr->skip_length = 0; /* This may not be necessary */ |
if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */ |
{ |
png_warning(png_ptr, "tEXt chunk too large to fit in memory"); |
png_ptr->skip_length = length - (png_uint_32)65535L; |
length = (png_uint_32)65535L; |
} |
#endif |
png_ptr->current_text = (png_charp)png_malloc(png_ptr, |
(png_uint_32)(length+1)); |
png_ptr->current_text[length] = '\0'; |
png_ptr->current_text_ptr = png_ptr->current_text; |
png_ptr->current_text_size = (png_size_t)length; |
png_ptr->current_text_left = (png_size_t)length; |
png_ptr->process_mode = PNG_READ_tEXt_MODE; |
} |
void /* PRIVATE */ |
png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr->buffer_size && png_ptr->current_text_left) |
{ |
png_size_t text_size; |
if (png_ptr->buffer_size < png_ptr->current_text_left) |
text_size = png_ptr->buffer_size; |
else |
text_size = png_ptr->current_text_left; |
png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size); |
png_ptr->current_text_left -= text_size; |
png_ptr->current_text_ptr += text_size; |
} |
if (!(png_ptr->current_text_left)) |
{ |
png_textp text_ptr; |
png_charp text; |
png_charp key; |
int ret; |
if (png_ptr->buffer_size < 4) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_push_crc_finish(png_ptr); |
#if defined(PNG_MAX_MALLOC_64K) |
if (png_ptr->skip_length) |
return; |
#endif |
key = png_ptr->current_text; |
for (text = key; *text; text++) |
/* empty loop */ ; |
if (text != key + png_ptr->current_text_size) |
text++; |
text_ptr = (png_textp)png_malloc(png_ptr, (png_uint_32)sizeof(png_text)); |
text_ptr->compression = PNG_TEXT_COMPRESSION_NONE; |
text_ptr->key = key; |
#ifdef PNG_iTXt_SUPPORTED |
text_ptr->lang = NULL; |
text_ptr->lang_key = NULL; |
#endif |
text_ptr->text = text; |
ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1); |
png_free(png_ptr, key); |
png_free(png_ptr, text_ptr); |
png_ptr->current_text = NULL; |
if (ret) |
png_warning(png_ptr, "Insufficient memory to store text chunk."); |
} |
} |
#endif |
#if defined(PNG_READ_zTXt_SUPPORTED) |
void /* PRIVATE */ |
png_push_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 |
length) |
{ |
if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND)) |
{ |
png_error(png_ptr, "Out of place zTXt"); |
/* to quiet some compiler warnings */ |
if(info_ptr == NULL) return; |
} |
#ifdef PNG_MAX_MALLOC_64K |
/* We can't handle zTXt chunks > 64K, since we don't have enough space |
* to be able to store the uncompressed data. Actually, the threshold |
* is probably around 32K, but it isn't as definite as 64K is. |
*/ |
if (length > (png_uint_32)65535L) |
{ |
png_warning(png_ptr, "zTXt chunk too large to fit in memory"); |
png_push_crc_skip(png_ptr, length); |
return; |
} |
#endif |
png_ptr->current_text = (png_charp)png_malloc(png_ptr, |
(png_uint_32)(length+1)); |
png_ptr->current_text[length] = '\0'; |
png_ptr->current_text_ptr = png_ptr->current_text; |
png_ptr->current_text_size = (png_size_t)length; |
png_ptr->current_text_left = (png_size_t)length; |
png_ptr->process_mode = PNG_READ_zTXt_MODE; |
} |
void /* PRIVATE */ |
png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr->buffer_size && png_ptr->current_text_left) |
{ |
png_size_t text_size; |
if (png_ptr->buffer_size < (png_uint_32)png_ptr->current_text_left) |
text_size = png_ptr->buffer_size; |
else |
text_size = png_ptr->current_text_left; |
png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size); |
png_ptr->current_text_left -= text_size; |
png_ptr->current_text_ptr += text_size; |
} |
if (!(png_ptr->current_text_left)) |
{ |
png_textp text_ptr; |
png_charp text; |
png_charp key; |
int ret; |
png_size_t text_size, key_size; |
if (png_ptr->buffer_size < 4) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_push_crc_finish(png_ptr); |
key = png_ptr->current_text; |
for (text = key; *text; text++) |
/* empty loop */ ; |
/* zTXt can't have zero text */ |
if (text == key + png_ptr->current_text_size) |
{ |
png_ptr->current_text = NULL; |
png_free(png_ptr, key); |
return; |
} |
text++; |
if (*text != PNG_TEXT_COMPRESSION_zTXt) /* check compression byte */ |
{ |
png_ptr->current_text = NULL; |
png_free(png_ptr, key); |
return; |
} |
text++; |
png_ptr->zstream.next_in = (png_bytep )text; |
png_ptr->zstream.avail_in = (uInt)(png_ptr->current_text_size - |
(text - key)); |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
key_size = text - key; |
text_size = 0; |
text = NULL; |
ret = Z_STREAM_END; |
while (png_ptr->zstream.avail_in) |
{ |
ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); |
if (ret != Z_OK && ret != Z_STREAM_END) |
{ |
inflateReset(&png_ptr->zstream); |
png_ptr->zstream.avail_in = 0; |
png_ptr->current_text = NULL; |
png_free(png_ptr, key); |
png_free(png_ptr, text); |
return; |
} |
if (!(png_ptr->zstream.avail_out) || ret == Z_STREAM_END) |
{ |
if (text == NULL) |
{ |
text = (png_charp)png_malloc(png_ptr, |
(png_uint_32)(png_ptr->zbuf_size - png_ptr->zstream.avail_out |
+ key_size + 1)); |
png_memcpy(text + key_size, png_ptr->zbuf, |
png_ptr->zbuf_size - png_ptr->zstream.avail_out); |
png_memcpy(text, key, key_size); |
text_size = key_size + png_ptr->zbuf_size - |
png_ptr->zstream.avail_out; |
*(text + text_size) = '\0'; |
} |
else |
{ |
png_charp tmp; |
tmp = text; |
text = (png_charp)png_malloc(png_ptr, text_size + |
(png_uint_32)(png_ptr->zbuf_size - png_ptr->zstream.avail_out |
+ 1)); |
png_memcpy(text, tmp, text_size); |
png_free(png_ptr, tmp); |
png_memcpy(text + text_size, png_ptr->zbuf, |
png_ptr->zbuf_size - png_ptr->zstream.avail_out); |
text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out; |
*(text + text_size) = '\0'; |
} |
if (ret != Z_STREAM_END) |
{ |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
} |
} |
else |
{ |
break; |
} |
if (ret == Z_STREAM_END) |
break; |
} |
inflateReset(&png_ptr->zstream); |
png_ptr->zstream.avail_in = 0; |
if (ret != Z_STREAM_END) |
{ |
png_ptr->current_text = NULL; |
png_free(png_ptr, key); |
png_free(png_ptr, text); |
return; |
} |
png_ptr->current_text = NULL; |
png_free(png_ptr, key); |
key = text; |
text += key_size; |
text_ptr = (png_textp)png_malloc(png_ptr, (png_uint_32)sizeof(png_text)); |
text_ptr->compression = PNG_TEXT_COMPRESSION_zTXt; |
text_ptr->key = key; |
#ifdef PNG_iTXt_SUPPORTED |
text_ptr->lang = NULL; |
text_ptr->lang_key = NULL; |
#endif |
text_ptr->text = text; |
ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1); |
png_free(png_ptr, key); |
png_free(png_ptr, text_ptr); |
if (ret) |
png_warning(png_ptr, "Insufficient memory to store text chunk."); |
} |
} |
#endif |
#if defined(PNG_READ_iTXt_SUPPORTED) |
void /* PRIVATE */ |
png_push_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 |
length) |
{ |
if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND)) |
{ |
png_error(png_ptr, "Out of place iTXt"); |
/* to quiet some compiler warnings */ |
if(info_ptr == NULL) return; |
} |
#ifdef PNG_MAX_MALLOC_64K |
png_ptr->skip_length = 0; /* This may not be necessary */ |
if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */ |
{ |
png_warning(png_ptr, "iTXt chunk too large to fit in memory"); |
png_ptr->skip_length = length - (png_uint_32)65535L; |
length = (png_uint_32)65535L; |
} |
#endif |
png_ptr->current_text = (png_charp)png_malloc(png_ptr, |
(png_uint_32)(length+1)); |
png_ptr->current_text[length] = '\0'; |
png_ptr->current_text_ptr = png_ptr->current_text; |
png_ptr->current_text_size = (png_size_t)length; |
png_ptr->current_text_left = (png_size_t)length; |
png_ptr->process_mode = PNG_READ_iTXt_MODE; |
} |
void /* PRIVATE */ |
png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr->buffer_size && png_ptr->current_text_left) |
{ |
png_size_t text_size; |
if (png_ptr->buffer_size < png_ptr->current_text_left) |
text_size = png_ptr->buffer_size; |
else |
text_size = png_ptr->current_text_left; |
png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size); |
png_ptr->current_text_left -= text_size; |
png_ptr->current_text_ptr += text_size; |
} |
if (!(png_ptr->current_text_left)) |
{ |
png_textp text_ptr; |
png_charp key; |
int comp_flag; |
png_charp lang; |
png_charp lang_key; |
png_charp text; |
int ret; |
if (png_ptr->buffer_size < 4) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_push_crc_finish(png_ptr); |
#if defined(PNG_MAX_MALLOC_64K) |
if (png_ptr->skip_length) |
return; |
#endif |
key = png_ptr->current_text; |
for (lang = key; *lang; lang++) |
/* empty loop */ ; |
if (lang != key + png_ptr->current_text_size) |
lang++; |
comp_flag = *lang++; |
lang++; /* skip comp_type, always zero */ |
for (lang_key = lang; *lang_key; lang_key++) |
/* empty loop */ ; |
lang_key++; /* skip NUL separator */ |
for (text = lang_key; *text; text++) |
/* empty loop */ ; |
if (text != key + png_ptr->current_text_size) |
text++; |
text_ptr = (png_textp)png_malloc(png_ptr, (png_uint_32)sizeof(png_text)); |
text_ptr->compression = comp_flag + 2; |
text_ptr->key = key; |
text_ptr->lang = lang; |
text_ptr->lang_key = lang_key; |
text_ptr->text = text; |
text_ptr->text_length = 0; |
text_ptr->itxt_length = png_strlen(text); |
ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1); |
png_ptr->current_text = NULL; |
png_free(png_ptr, text_ptr); |
if (ret) |
png_warning(png_ptr, "Insufficient memory to store iTXt chunk."); |
} |
} |
#endif |
/* This function is called when we haven't found a handler for this |
* chunk. If there isn't a problem with the chunk itself (ie a bad chunk |
* name or a critical chunk), the chunk is (currently) silently ignored. |
*/ |
void /* PRIVATE */ |
png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 |
length) |
{ |
png_uint_32 skip=0; |
png_check_chunk_name(png_ptr, png_ptr->chunk_name); |
if (!(png_ptr->chunk_name[0] & 0x20)) |
{ |
#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) |
if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) != |
HANDLE_CHUNK_ALWAYS |
#if defined(PNG_READ_USER_CHUNKS_SUPPORTED) |
&& png_ptr->read_user_chunk_fn == NULL |
#endif |
) |
#endif |
png_chunk_error(png_ptr, "unknown critical chunk"); |
/* to quiet compiler warnings about unused info_ptr */ |
if (info_ptr == NULL) |
return; |
} |
#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) |
if (png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS) |
{ |
png_unknown_chunk chunk; |
#ifdef PNG_MAX_MALLOC_64K |
if (length > (png_uint_32)65535L) |
{ |
png_warning(png_ptr, "unknown chunk too large to fit in memory"); |
skip = length - (png_uint_32)65535L; |
length = (png_uint_32)65535L; |
} |
#endif |
png_strcpy((png_charp)chunk.name, (png_charp)png_ptr->chunk_name); |
chunk.data = (png_bytep)png_malloc(png_ptr, length); |
png_crc_read(png_ptr, chunk.data, length); |
chunk.size = length; |
#if defined(PNG_READ_USER_CHUNKS_SUPPORTED) |
if(png_ptr->read_user_chunk_fn != NULL) |
{ |
/* callback to user unknown chunk handler */ |
if ((*(png_ptr->read_user_chunk_fn)) (png_ptr, &chunk) <= 0) |
{ |
if (!(png_ptr->chunk_name[0] & 0x20)) |
if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) != |
HANDLE_CHUNK_ALWAYS) |
png_chunk_error(png_ptr, "unknown critical chunk"); |
} |
png_set_unknown_chunks(png_ptr, info_ptr, &chunk, 1); |
} |
else |
#endif |
png_set_unknown_chunks(png_ptr, info_ptr, &chunk, 1); |
png_free(png_ptr, chunk.data); |
} |
else |
#endif |
skip=length; |
png_push_crc_skip(png_ptr, skip); |
} |
void /* PRIVATE */ |
png_push_have_info(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr->info_fn != NULL) |
(*(png_ptr->info_fn))(png_ptr, info_ptr); |
} |
void /* PRIVATE */ |
png_push_have_end(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr->end_fn != NULL) |
(*(png_ptr->end_fn))(png_ptr, info_ptr); |
} |
void /* PRIVATE */ |
png_push_have_row(png_structp png_ptr, png_bytep row) |
{ |
if (png_ptr->row_fn != NULL) |
(*(png_ptr->row_fn))(png_ptr, row, png_ptr->row_number, |
(int)png_ptr->pass); |
} |
void PNGAPI |
png_progressive_combine_row (png_structp png_ptr, |
png_bytep old_row, png_bytep new_row) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
const int FARDATA png_pass_dsp_mask[7] = |
{0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff}; |
#endif |
if (new_row != NULL) /* new_row must == png_ptr->row_buf here. */ |
png_combine_row(png_ptr, old_row, png_pass_dsp_mask[png_ptr->pass]); |
} |
void PNGAPI |
png_set_progressive_read_fn(png_structp png_ptr, png_voidp progressive_ptr, |
png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn, |
png_progressive_end_ptr end_fn) |
{ |
png_ptr->info_fn = info_fn; |
png_ptr->row_fn = row_fn; |
png_ptr->end_fn = end_fn; |
png_set_read_fn(png_ptr, progressive_ptr, png_push_fill_buffer); |
} |
png_voidp PNGAPI |
png_get_progressive_ptr(png_structp png_ptr) |
{ |
return png_ptr->io_ptr; |
} |
#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ |
/shark/trunk/ports/png/pngset.c |
---|
0,0 → 1,1160 |
/* pngset.c - storage of image information into info struct |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
* The functions here are used during reads to store data from the file |
* into the info struct, and during writes to store application data |
* into the info struct for writing into the file. This abstracts the |
* info struct and allows us to change the structure in the future. |
*/ |
#define PNG_INTERNAL |
#include "png.h" |
#if defined(PNG_bKGD_SUPPORTED) |
void PNGAPI |
png_set_bKGD(png_structp png_ptr, png_infop info_ptr, png_color_16p background) |
{ |
png_debug1(1, "in %s storage function\n", "bKGD"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
png_memcpy(&(info_ptr->background), background, sizeof(png_color_16)); |
info_ptr->valid |= PNG_INFO_bKGD; |
} |
#endif |
#if defined(PNG_cHRM_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
void PNGAPI |
png_set_cHRM(png_structp png_ptr, png_infop info_ptr, |
double white_x, double white_y, double red_x, double red_y, |
double green_x, double green_y, double blue_x, double blue_y) |
{ |
png_debug1(1, "in %s storage function\n", "cHRM"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
if (white_x < 0.0 || white_y < 0.0 || |
red_x < 0.0 || red_y < 0.0 || |
green_x < 0.0 || green_y < 0.0 || |
blue_x < 0.0 || blue_y < 0.0) |
{ |
png_warning(png_ptr, |
"Ignoring attempt to set negative chromaticity value"); |
return; |
} |
if (white_x > 21474.83 || white_y > 21474.83 || |
red_x > 21474.83 || red_y > 21474.83 || |
green_x > 21474.83 || green_y > 21474.83 || |
blue_x > 21474.83 || blue_y > 21474.83) |
{ |
png_warning(png_ptr, |
"Ignoring attempt to set chromaticity value exceeding 21474.83"); |
return; |
} |
info_ptr->x_white = (float)white_x; |
info_ptr->y_white = (float)white_y; |
info_ptr->x_red = (float)red_x; |
info_ptr->y_red = (float)red_y; |
info_ptr->x_green = (float)green_x; |
info_ptr->y_green = (float)green_y; |
info_ptr->x_blue = (float)blue_x; |
info_ptr->y_blue = (float)blue_y; |
#ifdef PNG_FIXED_POINT_SUPPORTED |
info_ptr->int_x_white = (png_fixed_point)(white_x*100000.+0.5); |
info_ptr->int_y_white = (png_fixed_point)(white_y*100000.+0.5); |
info_ptr->int_x_red = (png_fixed_point)( red_x*100000.+0.5); |
info_ptr->int_y_red = (png_fixed_point)( red_y*100000.+0.5); |
info_ptr->int_x_green = (png_fixed_point)(green_x*100000.+0.5); |
info_ptr->int_y_green = (png_fixed_point)(green_y*100000.+0.5); |
info_ptr->int_x_blue = (png_fixed_point)( blue_x*100000.+0.5); |
info_ptr->int_y_blue = (png_fixed_point)( blue_y*100000.+0.5); |
#endif |
info_ptr->valid |= PNG_INFO_cHRM; |
} |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
void PNGAPI |
png_set_cHRM_fixed(png_structp png_ptr, png_infop info_ptr, |
png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x, |
png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y, |
png_fixed_point blue_x, png_fixed_point blue_y) |
{ |
png_debug1(1, "in %s storage function\n", "cHRM"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
if (white_x < 0 || white_y < 0 || |
red_x < 0 || red_y < 0 || |
green_x < 0 || green_y < 0 || |
blue_x < 0 || blue_y < 0) |
{ |
png_warning(png_ptr, |
"Ignoring attempt to set negative chromaticity value"); |
return; |
} |
if (white_x > (double) PNG_MAX_UINT || white_y > (double) PNG_MAX_UINT || |
red_x > (double) PNG_MAX_UINT || red_y > (double) PNG_MAX_UINT || |
green_x > (double) PNG_MAX_UINT || green_y > (double) PNG_MAX_UINT || |
blue_x > (double) PNG_MAX_UINT || blue_y > (double) PNG_MAX_UINT) |
{ |
png_warning(png_ptr, |
"Ignoring attempt to set chromaticity value exceeding 21474.83"); |
return; |
} |
info_ptr->int_x_white = white_x; |
info_ptr->int_y_white = white_y; |
info_ptr->int_x_red = red_x; |
info_ptr->int_y_red = red_y; |
info_ptr->int_x_green = green_x; |
info_ptr->int_y_green = green_y; |
info_ptr->int_x_blue = blue_x; |
info_ptr->int_y_blue = blue_y; |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
info_ptr->x_white = (float)(white_x/100000.); |
info_ptr->y_white = (float)(white_y/100000.); |
info_ptr->x_red = (float)( red_x/100000.); |
info_ptr->y_red = (float)( red_y/100000.); |
info_ptr->x_green = (float)(green_x/100000.); |
info_ptr->y_green = (float)(green_y/100000.); |
info_ptr->x_blue = (float)( blue_x/100000.); |
info_ptr->y_blue = (float)( blue_y/100000.); |
#endif |
info_ptr->valid |= PNG_INFO_cHRM; |
} |
#endif |
#endif |
#if defined(PNG_gAMA_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
void PNGAPI |
png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma) |
{ |
double gamma; |
png_debug1(1, "in %s storage function\n", "gAMA"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
/* Check for overflow */ |
if (file_gamma > 21474.83) |
{ |
png_warning(png_ptr, "Limiting gamma to 21474.83"); |
gamma=21474.83; |
} |
else |
gamma=file_gamma; |
info_ptr->gamma = (float)gamma; |
#ifdef PNG_FIXED_POINT_SUPPORTED |
info_ptr->int_gamma = (int)(gamma*100000.+.5); |
#endif |
info_ptr->valid |= PNG_INFO_gAMA; |
if(gamma == 0.0) |
png_warning(png_ptr, "Setting gamma=0"); |
} |
#endif |
void PNGAPI |
png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point |
int_gamma) |
{ |
png_fixed_point gamma; |
png_debug1(1, "in %s storage function\n", "gAMA"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
if (int_gamma > (png_fixed_point) PNG_MAX_UINT) |
{ |
png_warning(png_ptr, "Limiting gamma to 21474.83"); |
gamma=PNG_MAX_UINT; |
} |
else |
{ |
if (int_gamma < 0) |
{ |
png_warning(png_ptr, "Setting negative gamma to zero"); |
gamma=0; |
} |
else |
gamma=int_gamma; |
} |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
info_ptr->gamma = (float)(gamma/100000.); |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
info_ptr->int_gamma = gamma; |
#endif |
info_ptr->valid |= PNG_INFO_gAMA; |
if(gamma == 0) |
png_warning(png_ptr, "Setting gamma=0"); |
} |
#endif |
#if defined(PNG_hIST_SUPPORTED) |
void PNGAPI |
png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p hist) |
{ |
int i; |
png_debug1(1, "in %s storage function\n", "hIST"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
if (info_ptr->num_palette == 0) |
{ |
png_warning(png_ptr, |
"Palette size 0, hIST allocation skipped."); |
return; |
} |
#ifdef PNG_FREE_ME_SUPPORTED |
png_free_data(png_ptr, info_ptr, PNG_FREE_HIST, 0); |
#endif |
/* Changed from info->num_palette to 256 in version 1.2.1 */ |
png_ptr->hist = (png_uint_16p)png_malloc_warn(png_ptr, |
(png_uint_32)(256 * sizeof (png_uint_16))); |
if (png_ptr->hist == NULL) |
{ |
png_warning(png_ptr, "Insufficient memory for hIST chunk data."); |
return; |
} |
for (i = 0; i < info_ptr->num_palette; i++) |
png_ptr->hist[i] = hist[i]; |
info_ptr->hist = png_ptr->hist; |
info_ptr->valid |= PNG_INFO_hIST; |
#ifdef PNG_FREE_ME_SUPPORTED |
info_ptr->free_me |= PNG_FREE_HIST; |
#else |
png_ptr->flags |= PNG_FLAG_FREE_HIST; |
#endif |
} |
#endif |
void PNGAPI |
png_set_IHDR(png_structp png_ptr, png_infop info_ptr, |
png_uint_32 width, png_uint_32 height, int bit_depth, |
int color_type, int interlace_type, int compression_type, |
int filter_type) |
{ |
int rowbytes_per_pixel; |
png_debug1(1, "in %s storage function\n", "IHDR"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
/* check for width and height valid values */ |
if (width == 0 || height == 0) |
png_error(png_ptr, "Image width or height is zero in IHDR"); |
if (width > PNG_MAX_UINT || height > PNG_MAX_UINT) |
png_error(png_ptr, "Invalid image size in IHDR"); |
/* check other values */ |
if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 && |
bit_depth != 8 && bit_depth != 16) |
png_error(png_ptr, "Invalid bit depth in IHDR"); |
if (color_type < 0 || color_type == 1 || |
color_type == 5 || color_type > 6) |
png_error(png_ptr, "Invalid color type in IHDR"); |
if (((color_type == PNG_COLOR_TYPE_PALETTE) && bit_depth > 8) || |
((color_type == PNG_COLOR_TYPE_RGB || |
color_type == PNG_COLOR_TYPE_GRAY_ALPHA || |
color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8)) |
png_error(png_ptr, "Invalid color type/bit depth combination in IHDR"); |
if (interlace_type >= PNG_INTERLACE_LAST) |
png_error(png_ptr, "Unknown interlace method in IHDR"); |
if (compression_type != PNG_COMPRESSION_TYPE_BASE) |
png_error(png_ptr, "Unknown compression method in IHDR"); |
#if defined(PNG_MNG_FEATURES_SUPPORTED) |
/* Accept filter_method 64 (intrapixel differencing) only if |
* 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and |
* 2. Libpng did not read a PNG signature (this filter_method is only |
* used in PNG datastreams that are embedded in MNG datastreams) and |
* 3. The application called png_permit_mng_features with a mask that |
* included PNG_FLAG_MNG_FILTER_64 and |
* 4. The filter_method is 64 and |
* 5. The color_type is RGB or RGBA |
*/ |
if((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)&&png_ptr->mng_features_permitted) |
png_warning(png_ptr,"MNG features are not allowed in a PNG datastream\n"); |
if(filter_type != PNG_FILTER_TYPE_BASE) |
{ |
if(!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && |
(filter_type == PNG_INTRAPIXEL_DIFFERENCING) && |
((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) && |
(color_type == PNG_COLOR_TYPE_RGB || |
color_type == PNG_COLOR_TYPE_RGB_ALPHA))) |
png_error(png_ptr, "Unknown filter method in IHDR"); |
if(png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) |
png_warning(png_ptr, "Invalid filter method in IHDR"); |
} |
#else |
if(filter_type != PNG_FILTER_TYPE_BASE) |
png_error(png_ptr, "Unknown filter method in IHDR"); |
#endif |
info_ptr->width = width; |
info_ptr->height = height; |
info_ptr->bit_depth = (png_byte)bit_depth; |
info_ptr->color_type =(png_byte) color_type; |
info_ptr->compression_type = (png_byte)compression_type; |
info_ptr->filter_type = (png_byte)filter_type; |
info_ptr->interlace_type = (png_byte)interlace_type; |
if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
info_ptr->channels = 1; |
else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR) |
info_ptr->channels = 3; |
else |
info_ptr->channels = 1; |
if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA) |
info_ptr->channels++; |
info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth); |
/* check for overflow */ |
rowbytes_per_pixel = (info_ptr->pixel_depth + 7) >> 3; |
if ( width > PNG_MAX_UINT/rowbytes_per_pixel - 64) |
{ |
png_warning(png_ptr, |
"Width too large to process image data; rowbytes will overflow."); |
info_ptr->rowbytes = (png_size_t)0; |
} |
else |
info_ptr->rowbytes = (info_ptr->width * info_ptr->pixel_depth + 7) >> 3; |
} |
#if defined(PNG_oFFs_SUPPORTED) |
void PNGAPI |
png_set_oFFs(png_structp png_ptr, png_infop info_ptr, |
png_int_32 offset_x, png_int_32 offset_y, int unit_type) |
{ |
png_debug1(1, "in %s storage function\n", "oFFs"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
info_ptr->x_offset = offset_x; |
info_ptr->y_offset = offset_y; |
info_ptr->offset_unit_type = (png_byte)unit_type; |
info_ptr->valid |= PNG_INFO_oFFs; |
} |
#endif |
#if defined(PNG_pCAL_SUPPORTED) |
void PNGAPI |
png_set_pCAL(png_structp png_ptr, png_infop info_ptr, |
png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams, |
png_charp units, png_charpp params) |
{ |
png_uint_32 length; |
int i; |
png_debug1(1, "in %s storage function\n", "pCAL"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
length = png_strlen(purpose) + 1; |
png_debug1(3, "allocating purpose for info (%lu bytes)\n", length); |
info_ptr->pcal_purpose = (png_charp)png_malloc_warn(png_ptr, length); |
if (info_ptr->pcal_purpose == NULL) |
{ |
png_warning(png_ptr, "Insufficient memory for pCAL purpose."); |
return; |
} |
png_memcpy(info_ptr->pcal_purpose, purpose, (png_size_t)length); |
png_debug(3, "storing X0, X1, type, and nparams in info\n"); |
info_ptr->pcal_X0 = X0; |
info_ptr->pcal_X1 = X1; |
info_ptr->pcal_type = (png_byte)type; |
info_ptr->pcal_nparams = (png_byte)nparams; |
length = png_strlen(units) + 1; |
png_debug1(3, "allocating units for info (%lu bytes)\n", length); |
info_ptr->pcal_units = (png_charp)png_malloc_warn(png_ptr, length); |
if (info_ptr->pcal_units == NULL) |
{ |
png_warning(png_ptr, "Insufficient memory for pCAL units."); |
return; |
} |
png_memcpy(info_ptr->pcal_units, units, (png_size_t)length); |
info_ptr->pcal_params = (png_charpp)png_malloc_warn(png_ptr, |
(png_uint_32)((nparams + 1) * sizeof(png_charp))); |
if (info_ptr->pcal_params == NULL) |
{ |
png_warning(png_ptr, "Insufficient memory for pCAL params."); |
return; |
} |
info_ptr->pcal_params[nparams] = NULL; |
for (i = 0; i < nparams; i++) |
{ |
length = png_strlen(params[i]) + 1; |
png_debug2(3, "allocating parameter %d for info (%lu bytes)\n", i, length); |
info_ptr->pcal_params[i] = (png_charp)png_malloc_warn(png_ptr, length); |
if (info_ptr->pcal_params[i] == NULL) |
{ |
png_warning(png_ptr, "Insufficient memory for pCAL parameter."); |
return; |
} |
png_memcpy(info_ptr->pcal_params[i], params[i], (png_size_t)length); |
} |
info_ptr->valid |= PNG_INFO_pCAL; |
#ifdef PNG_FREE_ME_SUPPORTED |
info_ptr->free_me |= PNG_FREE_PCAL; |
#endif |
} |
#endif |
#if defined(PNG_READ_sCAL_SUPPORTED) || defined(PNG_WRITE_sCAL_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
void PNGAPI |
png_set_sCAL(png_structp png_ptr, png_infop info_ptr, |
int unit, double width, double height) |
{ |
png_debug1(1, "in %s storage function\n", "sCAL"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
info_ptr->scal_unit = (png_byte)unit; |
info_ptr->scal_pixel_width = width; |
info_ptr->scal_pixel_height = height; |
info_ptr->valid |= PNG_INFO_sCAL; |
} |
#else |
#ifdef PNG_FIXED_POINT_SUPPORTED |
void PNGAPI |
png_set_sCAL_s(png_structp png_ptr, png_infop info_ptr, |
int unit, png_charp swidth, png_charp sheight) |
{ |
png_uint_32 length; |
png_debug1(1, "in %s storage function\n", "sCAL"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
info_ptr->scal_unit = (png_byte)unit; |
length = png_strlen(swidth) + 1; |
png_debug1(3, "allocating unit for info (%d bytes)\n", length); |
info_ptr->scal_s_width = (png_charp)png_malloc(png_ptr, length); |
png_memcpy(info_ptr->scal_s_width, swidth, (png_size_t)length); |
length = png_strlen(sheight) + 1; |
png_debug1(3, "allocating unit for info (%d bytes)\n", length); |
info_ptr->scal_s_height = (png_charp)png_malloc(png_ptr, length); |
png_memcpy(info_ptr->scal_s_height, sheight, (png_size_t)length); |
info_ptr->valid |= PNG_INFO_sCAL; |
#ifdef PNG_FREE_ME_SUPPORTED |
info_ptr->free_me |= PNG_FREE_SCAL; |
#endif |
} |
#endif |
#endif |
#endif |
#if defined(PNG_pHYs_SUPPORTED) |
void PNGAPI |
png_set_pHYs(png_structp png_ptr, png_infop info_ptr, |
png_uint_32 res_x, png_uint_32 res_y, int unit_type) |
{ |
png_debug1(1, "in %s storage function\n", "pHYs"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
info_ptr->x_pixels_per_unit = res_x; |
info_ptr->y_pixels_per_unit = res_y; |
info_ptr->phys_unit_type = (png_byte)unit_type; |
info_ptr->valid |= PNG_INFO_pHYs; |
} |
#endif |
void PNGAPI |
png_set_PLTE(png_structp png_ptr, png_infop info_ptr, |
png_colorp palette, int num_palette) |
{ |
png_debug1(1, "in %s storage function\n", "PLTE"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
/* |
* It may not actually be necessary to set png_ptr->palette here; |
* we do it for backward compatibility with the way the png_handle_tRNS |
* function used to do the allocation. |
*/ |
#ifdef PNG_FREE_ME_SUPPORTED |
png_free_data(png_ptr, info_ptr, PNG_FREE_PLTE, 0); |
#endif |
/* Changed in libpng-1.2.1 to allocate 256 instead of num_palette entries, |
in case of an invalid PNG file that has too-large sample values. */ |
png_ptr->palette = (png_colorp)png_zalloc(png_ptr, (uInt)256, |
sizeof (png_color)); |
if (png_ptr->palette == NULL) |
png_error(png_ptr, "Unable to malloc palette"); |
png_memcpy(png_ptr->palette, palette, num_palette * sizeof (png_color)); |
info_ptr->palette = png_ptr->palette; |
info_ptr->num_palette = png_ptr->num_palette = (png_uint_16)num_palette; |
#ifdef PNG_FREE_ME_SUPPORTED |
info_ptr->free_me |= PNG_FREE_PLTE; |
#else |
png_ptr->flags |= PNG_FLAG_FREE_PLTE; |
#endif |
info_ptr->valid |= PNG_INFO_PLTE; |
} |
#if defined(PNG_sBIT_SUPPORTED) |
void PNGAPI |
png_set_sBIT(png_structp png_ptr, png_infop info_ptr, |
png_color_8p sig_bit) |
{ |
png_debug1(1, "in %s storage function\n", "sBIT"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
png_memcpy(&(info_ptr->sig_bit), sig_bit, sizeof (png_color_8)); |
info_ptr->valid |= PNG_INFO_sBIT; |
} |
#endif |
#if defined(PNG_sRGB_SUPPORTED) |
void PNGAPI |
png_set_sRGB(png_structp png_ptr, png_infop info_ptr, int intent) |
{ |
png_debug1(1, "in %s storage function\n", "sRGB"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
info_ptr->srgb_intent = (png_byte)intent; |
info_ptr->valid |= PNG_INFO_sRGB; |
} |
void PNGAPI |
png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr, |
int intent) |
{ |
#if defined(PNG_gAMA_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
float file_gamma; |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
png_fixed_point int_file_gamma; |
#endif |
#endif |
#if defined(PNG_cHRM_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y; |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
png_fixed_point int_white_x, int_white_y, int_red_x, int_red_y, int_green_x, |
int_green_y, int_blue_x, int_blue_y; |
#endif |
#endif |
png_debug1(1, "in %s storage function\n", "sRGB_gAMA_and_cHRM"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
png_set_sRGB(png_ptr, info_ptr, intent); |
#if defined(PNG_gAMA_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
file_gamma = (float).45455; |
png_set_gAMA(png_ptr, info_ptr, file_gamma); |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
int_file_gamma = 45455L; |
png_set_gAMA_fixed(png_ptr, info_ptr, int_file_gamma); |
#endif |
#endif |
#if defined(PNG_cHRM_SUPPORTED) |
#ifdef PNG_FIXED_POINT_SUPPORTED |
int_white_x = 31270L; |
int_white_y = 32900L; |
int_red_x = 64000L; |
int_red_y = 33000L; |
int_green_x = 30000L; |
int_green_y = 60000L; |
int_blue_x = 15000L; |
int_blue_y = 6000L; |
png_set_cHRM_fixed(png_ptr, info_ptr, |
int_white_x, int_white_y, int_red_x, int_red_y, int_green_x, int_green_y, |
int_blue_x, int_blue_y); |
#endif |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
white_x = (float).3127; |
white_y = (float).3290; |
red_x = (float).64; |
red_y = (float).33; |
green_x = (float).30; |
green_y = (float).60; |
blue_x = (float).15; |
blue_y = (float).06; |
png_set_cHRM(png_ptr, info_ptr, |
white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y); |
#endif |
#endif |
} |
#endif |
#if defined(PNG_iCCP_SUPPORTED) |
void PNGAPI |
png_set_iCCP(png_structp png_ptr, png_infop info_ptr, |
png_charp name, int compression_type, |
png_charp profile, png_uint_32 proflen) |
{ |
png_charp new_iccp_name; |
png_charp new_iccp_profile; |
png_debug1(1, "in %s storage function\n", "iCCP"); |
if (png_ptr == NULL || info_ptr == NULL || name == NULL || profile == NULL) |
return; |
new_iccp_name = (png_charp)png_malloc(png_ptr, png_strlen(name)+1); |
png_strcpy(new_iccp_name, name); |
new_iccp_profile = (png_charp)png_malloc(png_ptr, proflen); |
png_memcpy(new_iccp_profile, profile, (png_size_t)proflen); |
png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, 0); |
info_ptr->iccp_proflen = proflen; |
info_ptr->iccp_name = new_iccp_name; |
info_ptr->iccp_profile = new_iccp_profile; |
/* Compression is always zero but is here so the API and info structure |
* does not have to change if we introduce multiple compression types */ |
info_ptr->iccp_compression = (png_byte)compression_type; |
#ifdef PNG_FREE_ME_SUPPORTED |
info_ptr->free_me |= PNG_FREE_ICCP; |
#endif |
info_ptr->valid |= PNG_INFO_iCCP; |
} |
#endif |
#if defined(PNG_TEXT_SUPPORTED) |
void PNGAPI |
png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr, |
int num_text) |
{ |
int ret; |
ret=png_set_text_2(png_ptr, info_ptr, text_ptr, num_text); |
if (ret) |
png_error(png_ptr, "Insufficient memory to store text"); |
} |
int /* PRIVATE */ |
png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr, |
int num_text) |
{ |
int i; |
png_debug1(1, "in %s storage function\n", (png_ptr->chunk_name[0] == '\0' ? |
"text" : (png_const_charp)png_ptr->chunk_name)); |
if (png_ptr == NULL || info_ptr == NULL || num_text == 0) |
return(0); |
/* Make sure we have enough space in the "text" array in info_struct |
* to hold all of the incoming text_ptr objects. |
*/ |
if (info_ptr->num_text + num_text > info_ptr->max_text) |
{ |
if (info_ptr->text != NULL) |
{ |
png_textp old_text; |
int old_max; |
old_max = info_ptr->max_text; |
info_ptr->max_text = info_ptr->num_text + num_text + 8; |
old_text = info_ptr->text; |
info_ptr->text = (png_textp)png_malloc_warn(png_ptr, |
(png_uint_32)(info_ptr->max_text * sizeof (png_text))); |
if (info_ptr->text == NULL) |
{ |
png_free(png_ptr, old_text); |
return(1); |
} |
png_memcpy(info_ptr->text, old_text, (png_size_t)(old_max * |
sizeof(png_text))); |
png_free(png_ptr, old_text); |
} |
else |
{ |
info_ptr->max_text = num_text + 8; |
info_ptr->num_text = 0; |
info_ptr->text = (png_textp)png_malloc_warn(png_ptr, |
(png_uint_32)(info_ptr->max_text * sizeof (png_text))); |
if (info_ptr->text == NULL) |
return(1); |
#ifdef PNG_FREE_ME_SUPPORTED |
info_ptr->free_me |= PNG_FREE_TEXT; |
#endif |
} |
png_debug1(3, "allocated %d entries for info_ptr->text\n", |
info_ptr->max_text); |
} |
for (i = 0; i < num_text; i++) |
{ |
png_size_t text_length,key_len; |
png_size_t lang_len,lang_key_len; |
png_textp textp = &(info_ptr->text[info_ptr->num_text]); |
if (text_ptr[i].key == NULL) |
continue; |
key_len = png_strlen(text_ptr[i].key); |
if(text_ptr[i].compression <= 0) |
{ |
lang_len = 0; |
lang_key_len = 0; |
} |
else |
#ifdef PNG_iTXt_SUPPORTED |
{ |
/* set iTXt data */ |
if (text_ptr[i].lang != NULL) |
lang_len = png_strlen(text_ptr[i].lang); |
else |
lang_len = 0; |
if (text_ptr[i].lang_key != NULL) |
lang_key_len = png_strlen(text_ptr[i].lang_key); |
else |
lang_key_len = 0; |
} |
#else |
{ |
png_warning(png_ptr, "iTXt chunk not supported."); |
continue; |
} |
#endif |
if (text_ptr[i].text == NULL || text_ptr[i].text[0] == '\0') |
{ |
text_length = 0; |
#ifdef PNG_iTXt_SUPPORTED |
if(text_ptr[i].compression > 0) |
textp->compression = PNG_ITXT_COMPRESSION_NONE; |
else |
#endif |
textp->compression = PNG_TEXT_COMPRESSION_NONE; |
} |
else |
{ |
text_length = png_strlen(text_ptr[i].text); |
textp->compression = text_ptr[i].compression; |
} |
textp->key = (png_charp)png_malloc_warn(png_ptr, |
(png_uint_32)(key_len + text_length + lang_len + lang_key_len + 4)); |
if (textp->key == NULL) |
return(1); |
png_debug2(2, "Allocated %lu bytes at %x in png_set_text\n", |
(png_uint_32)(key_len + lang_len + lang_key_len + text_length + 4), |
(int)textp->key); |
png_memcpy(textp->key, text_ptr[i].key, |
(png_size_t)(key_len)); |
*(textp->key+key_len) = '\0'; |
#ifdef PNG_iTXt_SUPPORTED |
if (text_ptr[i].compression > 0) |
{ |
textp->lang=textp->key + key_len + 1; |
png_memcpy(textp->lang, text_ptr[i].lang, lang_len); |
*(textp->lang+lang_len) = '\0'; |
textp->lang_key=textp->lang + lang_len + 1; |
png_memcpy(textp->lang_key, text_ptr[i].lang_key, lang_key_len); |
*(textp->lang_key+lang_key_len) = '\0'; |
textp->text=textp->lang_key + lang_key_len + 1; |
} |
else |
#endif |
{ |
#ifdef PNG_iTXt_SUPPORTED |
textp->lang=NULL; |
textp->lang_key=NULL; |
#endif |
textp->text=textp->key + key_len + 1; |
} |
if(text_length) |
png_memcpy(textp->text, text_ptr[i].text, |
(png_size_t)(text_length)); |
*(textp->text+text_length) = '\0'; |
#ifdef PNG_iTXt_SUPPORTED |
if(textp->compression > 0) |
{ |
textp->text_length = 0; |
textp->itxt_length = text_length; |
} |
else |
#endif |
{ |
textp->text_length = text_length; |
#ifdef PNG_iTXt_SUPPORTED |
textp->itxt_length = 0; |
#endif |
} |
info_ptr->text[info_ptr->num_text]= *textp; |
info_ptr->num_text++; |
png_debug1(3, "transferred text chunk %d\n", info_ptr->num_text); |
} |
return(0); |
} |
#endif |
#if defined(PNG_tIME_SUPPORTED) |
void PNGAPI |
png_set_tIME(png_structp png_ptr, png_infop info_ptr, png_timep mod_time) |
{ |
png_debug1(1, "in %s storage function\n", "tIME"); |
if (png_ptr == NULL || info_ptr == NULL || |
(png_ptr->mode & PNG_WROTE_tIME)) |
return; |
png_memcpy(&(info_ptr->mod_time), mod_time, sizeof (png_time)); |
info_ptr->valid |= PNG_INFO_tIME; |
} |
#endif |
#if defined(PNG_tRNS_SUPPORTED) |
void PNGAPI |
png_set_tRNS(png_structp png_ptr, png_infop info_ptr, |
png_bytep trans, int num_trans, png_color_16p trans_values) |
{ |
png_debug1(1, "in %s storage function\n", "tRNS"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
if (trans != NULL) |
{ |
/* |
* It may not actually be necessary to set png_ptr->trans here; |
* we do it for backward compatibility with the way the png_handle_tRNS |
* function used to do the allocation. |
*/ |
#ifdef PNG_FREE_ME_SUPPORTED |
png_free_data(png_ptr, info_ptr, PNG_FREE_TRNS, 0); |
#endif |
/* Changed from num_trans to 256 in version 1.2.1 */ |
png_ptr->trans = info_ptr->trans = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)256); |
png_memcpy(info_ptr->trans, trans, (png_size_t)num_trans); |
#ifdef PNG_FREE_ME_SUPPORTED |
info_ptr->free_me |= PNG_FREE_TRNS; |
#else |
png_ptr->flags |= PNG_FLAG_FREE_TRNS; |
#endif |
} |
if (trans_values != NULL) |
{ |
png_memcpy(&(info_ptr->trans_values), trans_values, |
sizeof(png_color_16)); |
if (num_trans == 0) |
num_trans = 1; |
} |
info_ptr->num_trans = (png_uint_16)num_trans; |
info_ptr->valid |= PNG_INFO_tRNS; |
} |
#endif |
#if defined(PNG_sPLT_SUPPORTED) |
void PNGAPI |
png_set_sPLT(png_structp png_ptr, |
png_infop info_ptr, png_sPLT_tp entries, int nentries) |
{ |
png_sPLT_tp np; |
int i; |
np = (png_sPLT_tp)png_malloc_warn(png_ptr, |
(info_ptr->splt_palettes_num + nentries) * sizeof(png_sPLT_t)); |
if (np == NULL) |
{ |
png_warning(png_ptr, "No memory for sPLT palettes."); |
return; |
} |
png_memcpy(np, info_ptr->splt_palettes, |
info_ptr->splt_palettes_num * sizeof(png_sPLT_t)); |
png_free(png_ptr, info_ptr->splt_palettes); |
info_ptr->splt_palettes=NULL; |
for (i = 0; i < nentries; i++) |
{ |
png_sPLT_tp to = np + info_ptr->splt_palettes_num + i; |
png_sPLT_tp from = entries + i; |
to->name = (png_charp)png_malloc(png_ptr, |
png_strlen(from->name) + 1); |
png_strcpy(to->name, from->name); |
to->entries = (png_sPLT_entryp)png_malloc(png_ptr, |
from->nentries * sizeof(png_sPLT_t)); |
png_memcpy(to->entries, from->entries, |
from->nentries * sizeof(png_sPLT_t)); |
to->nentries = from->nentries; |
to->depth = from->depth; |
} |
info_ptr->splt_palettes = np; |
info_ptr->splt_palettes_num += nentries; |
info_ptr->valid |= PNG_INFO_sPLT; |
#ifdef PNG_FREE_ME_SUPPORTED |
info_ptr->free_me |= PNG_FREE_SPLT; |
#endif |
} |
#endif /* PNG_sPLT_SUPPORTED */ |
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) |
void PNGAPI |
png_set_unknown_chunks(png_structp png_ptr, |
png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns) |
{ |
png_unknown_chunkp np; |
int i; |
if (png_ptr == NULL || info_ptr == NULL || num_unknowns == 0) |
return; |
np = (png_unknown_chunkp)png_malloc_warn(png_ptr, |
(info_ptr->unknown_chunks_num + num_unknowns) * |
sizeof(png_unknown_chunk)); |
if (np == NULL) |
{ |
png_warning(png_ptr, "Out of memory while processing unknown chunk."); |
return; |
} |
png_memcpy(np, info_ptr->unknown_chunks, |
info_ptr->unknown_chunks_num * sizeof(png_unknown_chunk)); |
png_free(png_ptr, info_ptr->unknown_chunks); |
info_ptr->unknown_chunks=NULL; |
for (i = 0; i < num_unknowns; i++) |
{ |
png_unknown_chunkp to = np + info_ptr->unknown_chunks_num + i; |
png_unknown_chunkp from = unknowns + i; |
png_strcpy((png_charp)to->name, (png_charp)from->name); |
to->data = (png_bytep)png_malloc(png_ptr, from->size); |
if (to->data == NULL) |
png_warning(png_ptr, "Out of memory while processing unknown chunk."); |
else |
{ |
png_memcpy(to->data, from->data, from->size); |
to->size = from->size; |
/* note our location in the read or write sequence */ |
to->location = (png_byte)(png_ptr->mode & 0xff); |
} |
} |
info_ptr->unknown_chunks = np; |
info_ptr->unknown_chunks_num += num_unknowns; |
#ifdef PNG_FREE_ME_SUPPORTED |
info_ptr->free_me |= PNG_FREE_UNKN; |
#endif |
} |
void PNGAPI |
png_set_unknown_chunk_location(png_structp png_ptr, png_infop info_ptr, |
int chunk, int location) |
{ |
if(png_ptr != NULL && info_ptr != NULL && chunk >= 0 && chunk < |
(int)info_ptr->unknown_chunks_num) |
info_ptr->unknown_chunks[chunk].location = (png_byte)location; |
} |
#endif |
#if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \ |
defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED) |
void PNGAPI |
png_permit_empty_plte (png_structp png_ptr, int empty_plte_permitted) |
{ |
/* This function is deprecated in favor of png_permit_mng_features() |
and will be removed from libpng-2.0.0 */ |
png_debug(1, "in png_permit_empty_plte, DEPRECATED.\n"); |
if (png_ptr == NULL) |
return; |
png_ptr->mng_features_permitted = (png_byte) |
((png_ptr->mng_features_permitted & (~(PNG_FLAG_MNG_EMPTY_PLTE))) | |
((empty_plte_permitted & PNG_FLAG_MNG_EMPTY_PLTE))); |
} |
#endif |
#if defined(PNG_MNG_FEATURES_SUPPORTED) |
png_uint_32 PNGAPI |
png_permit_mng_features (png_structp png_ptr, png_uint_32 mng_features) |
{ |
png_debug(1, "in png_permit_mng_features\n"); |
if (png_ptr == NULL) |
return (png_uint_32)0; |
png_ptr->mng_features_permitted = |
(png_byte)(mng_features & PNG_ALL_MNG_FEATURES); |
return (png_uint_32)png_ptr->mng_features_permitted; |
} |
#endif |
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) |
void PNGAPI |
png_set_keep_unknown_chunks(png_structp png_ptr, int keep, png_bytep |
chunk_list, int num_chunks) |
{ |
png_bytep new_list, p; |
int i, old_num_chunks; |
if (num_chunks == 0) |
{ |
if(keep == HANDLE_CHUNK_ALWAYS || keep == HANDLE_CHUNK_IF_SAFE) |
png_ptr->flags |= PNG_FLAG_KEEP_UNKNOWN_CHUNKS; |
else |
png_ptr->flags &= ~PNG_FLAG_KEEP_UNKNOWN_CHUNKS; |
if(keep == HANDLE_CHUNK_ALWAYS) |
png_ptr->flags |= PNG_FLAG_KEEP_UNSAFE_CHUNKS; |
else |
png_ptr->flags &= ~PNG_FLAG_KEEP_UNSAFE_CHUNKS; |
return; |
} |
if (chunk_list == NULL) |
return; |
old_num_chunks=png_ptr->num_chunk_list; |
new_list=(png_bytep)png_malloc(png_ptr, |
(png_uint_32)(5*(num_chunks+old_num_chunks))); |
if(png_ptr->chunk_list != NULL) |
{ |
png_memcpy(new_list, png_ptr->chunk_list, |
(png_size_t)(5*old_num_chunks)); |
png_free(png_ptr, png_ptr->chunk_list); |
png_ptr->chunk_list=NULL; |
} |
png_memcpy(new_list+5*old_num_chunks, chunk_list, |
(png_size_t)(5*num_chunks)); |
for (p=new_list+5*old_num_chunks+4, i=0; i<num_chunks; i++, p+=5) |
*p=(png_byte)keep; |
png_ptr->num_chunk_list=old_num_chunks+num_chunks; |
png_ptr->chunk_list=new_list; |
#ifdef PNG_FREE_ME_SUPPORTED |
png_ptr->free_me |= PNG_FREE_LIST; |
#endif |
} |
#endif |
#if defined(PNG_READ_USER_CHUNKS_SUPPORTED) |
void PNGAPI |
png_set_read_user_chunk_fn(png_structp png_ptr, png_voidp user_chunk_ptr, |
png_user_chunk_ptr read_user_chunk_fn) |
{ |
png_debug(1, "in png_set_read_user_chunk_fn\n"); |
png_ptr->read_user_chunk_fn = read_user_chunk_fn; |
png_ptr->user_chunk_ptr = user_chunk_ptr; |
} |
#endif |
#if defined(PNG_INFO_IMAGE_SUPPORTED) |
void PNGAPI |
png_set_rows(png_structp png_ptr, png_infop info_ptr, png_bytepp row_pointers) |
{ |
png_debug1(1, "in %s storage function\n", "rows"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
if(info_ptr->row_pointers && (info_ptr->row_pointers != row_pointers)) |
png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0); |
info_ptr->row_pointers = row_pointers; |
if(row_pointers) |
info_ptr->valid |= PNG_INFO_IDAT; |
} |
#endif |
void PNGAPI |
png_set_compression_buffer_size(png_structp png_ptr, png_uint_32 size) |
{ |
if(png_ptr->zbuf) |
png_free(png_ptr, png_ptr->zbuf); |
png_ptr->zbuf_size = (png_size_t)size; |
png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, size); |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
} |
void PNGAPI |
png_set_invalid(png_structp png_ptr, png_infop info_ptr, int mask) |
{ |
if (png_ptr && info_ptr) |
info_ptr->valid &= ~(mask); |
} |
#ifndef PNG_1_0_X |
#ifdef PNG_ASSEMBLER_CODE_SUPPORTED |
/* this function was added to libpng 1.2.0 and should always exist by default */ |
void PNGAPI |
png_set_asm_flags (png_structp png_ptr, png_uint_32 asm_flags) |
{ |
png_uint_32 settable_asm_flags; |
png_uint_32 settable_mmx_flags; |
settable_mmx_flags = |
#ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW |
PNG_ASM_FLAG_MMX_READ_COMBINE_ROW | |
#endif |
#ifdef PNG_HAVE_ASSEMBLER_READ_INTERLACE |
PNG_ASM_FLAG_MMX_READ_INTERLACE | |
#endif |
#ifdef PNG_HAVE_ASSEMBLER_READ_FILTER_ROW |
PNG_ASM_FLAG_MMX_READ_FILTER_SUB | |
PNG_ASM_FLAG_MMX_READ_FILTER_UP | |
PNG_ASM_FLAG_MMX_READ_FILTER_AVG | |
PNG_ASM_FLAG_MMX_READ_FILTER_PAETH | |
#endif |
0; |
/* could be some non-MMX ones in the future, but not currently: */ |
settable_asm_flags = settable_mmx_flags; |
if (!(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_SUPPORT_COMPILED) || |
!(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU)) |
{ |
/* clear all MMX flags if MMX isn't supported */ |
settable_asm_flags &= ~settable_mmx_flags; |
png_ptr->asm_flags &= ~settable_mmx_flags; |
} |
/* we're replacing the settable bits with those passed in by the user, |
* so first zero them out of the master copy, then logical-OR in the |
* allowed subset that was requested */ |
png_ptr->asm_flags &= ~settable_asm_flags; /* zero them */ |
png_ptr->asm_flags |= (asm_flags & settable_asm_flags); /* set them */ |
} |
#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */ |
#ifdef PNG_ASSEMBLER_CODE_SUPPORTED |
/* this function was added to libpng 1.2.0 */ |
void PNGAPI |
png_set_mmx_thresholds (png_structp png_ptr, |
png_byte mmx_bitdepth_threshold, |
png_uint_32 mmx_rowbytes_threshold) |
{ |
png_ptr->mmx_bitdepth_threshold = mmx_bitdepth_threshold; |
png_ptr->mmx_rowbytes_threshold = mmx_rowbytes_threshold; |
} |
#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */ |
#endif /* ?PNG_1_0_X */ |
/shark/trunk/ports/png/pngwio.c |
---|
0,0 → 1,228 |
/* pngwio.c - functions for data output |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
* This file provides a location for all output. Users who need |
* special handling are expected to write functions that have the same |
* arguments as these and perform similar functions, but that possibly |
* use different output methods. Note that you shouldn't change these |
* functions, but rather write replacement functions and then change |
* them at run time with png_set_write_fn(...). |
*/ |
#define PNG_INTERNAL |
#include "png.h" |
#ifdef PNG_WRITE_SUPPORTED |
/* Write the data to whatever output you are using. The default routine |
writes to a file pointer. Note that this routine sometimes gets called |
with very small lengths, so you should implement some kind of simple |
buffering if you are using unbuffered writes. This should never be asked |
to write more than 64K on a 16 bit machine. */ |
void /* PRIVATE */ |
png_write_data(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
if (png_ptr->write_data_fn != NULL ) |
(*(png_ptr->write_data_fn))(png_ptr, data, length); |
else |
png_error(png_ptr, "Call to NULL write function"); |
} |
#if !defined(PNG_NO_STDIO) |
/* This is the function that does the actual writing of data. If you are |
not writing to a standard C stream, you should create a replacement |
write_data function and use it at run time with png_set_write_fn(), rather |
than changing the library. */ |
#ifndef USE_FAR_KEYWORD |
void PNGAPI |
png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
png_uint_32 check; |
#if defined(_WIN32_WCE) |
if ( !WriteFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) ) |
check = 0; |
#else |
check = fwrite(data, 1, length, (png_FILE_p)(png_ptr->io_ptr)); |
#endif |
if (check != length) |
png_error(png_ptr, "Write Error"); |
} |
#else |
/* this is the model-independent version. Since the standard I/O library |
can't handle far buffers in the medium and small models, we have to copy |
the data. |
*/ |
#define NEAR_BUF_SIZE 1024 |
#define MIN(a,b) (a <= b ? a : b) |
void PNGAPI |
png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
png_uint_32 check; |
png_byte *near_data; /* Needs to be "png_byte *" instead of "png_bytep" */ |
png_FILE_p io_ptr; |
/* Check if data really is near. If so, use usual code. */ |
near_data = (png_byte *)CVT_PTR_NOCHECK(data); |
io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr); |
if ((png_bytep)near_data == data) |
{ |
#if defined(_WIN32_WCE) |
if ( !WriteFile(io_ptr, near_data, length, &check, NULL) ) |
check = 0; |
#else |
check = fwrite(near_data, 1, length, io_ptr); |
#endif |
} |
else |
{ |
png_byte buf[NEAR_BUF_SIZE]; |
png_size_t written, remaining, err; |
check = 0; |
remaining = length; |
do |
{ |
written = MIN(NEAR_BUF_SIZE, remaining); |
png_memcpy(buf, data, written); /* copy far buffer to near buffer */ |
#if defined(_WIN32_WCE) |
if ( !WriteFile(io_ptr, buf, written, &err, NULL) ) |
err = 0; |
#else |
err = fwrite(buf, 1, written, io_ptr); |
#endif |
if (err != written) |
break; |
else |
check += err; |
data += written; |
remaining -= written; |
} |
while (remaining != 0); |
} |
if (check != length) |
png_error(png_ptr, "Write Error"); |
} |
#endif |
#endif |
/* This function is called to output any data pending writing (normally |
to disk). After png_flush is called, there should be no data pending |
writing in any buffers. */ |
#if defined(PNG_WRITE_FLUSH_SUPPORTED) |
void /* PRIVATE */ |
png_flush(png_structp png_ptr) |
{ |
if (png_ptr->output_flush_fn != NULL) |
(*(png_ptr->output_flush_fn))(png_ptr); |
} |
#if !defined(PNG_NO_STDIO) |
void PNGAPI |
png_default_flush(png_structp png_ptr) |
{ |
#if !defined(_WIN32_WCE) |
png_FILE_p io_ptr; |
io_ptr = (png_FILE_p)CVT_PTR((png_ptr->io_ptr)); |
if (io_ptr != NULL) |
fflush(io_ptr); |
#endif |
} |
#endif |
#endif |
/* This function allows the application to supply new output functions for |
libpng if standard C streams aren't being used. |
This function takes as its arguments: |
png_ptr - pointer to a png output data structure |
io_ptr - pointer to user supplied structure containing info about |
the output functions. May be NULL. |
write_data_fn - pointer to a new output function that takes as its |
arguments a pointer to a png_struct, a pointer to |
data to be written, and a 32-bit unsigned int that is |
the number of bytes to be written. The new write |
function should call png_error(png_ptr, "Error msg") |
to exit and output any fatal error messages. |
flush_data_fn - pointer to a new flush function that takes as its |
arguments a pointer to a png_struct. After a call to |
the flush function, there should be no data in any buffers |
or pending transmission. If the output method doesn't do |
any buffering of ouput, a function prototype must still be |
supplied although it doesn't have to do anything. If |
PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile |
time, output_flush_fn will be ignored, although it must be |
supplied for compatibility. */ |
void PNGAPI |
png_set_write_fn(png_structp png_ptr, png_voidp io_ptr, |
png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn) |
{ |
png_ptr->io_ptr = io_ptr; |
#if !defined(PNG_NO_STDIO) |
if (write_data_fn != NULL) |
png_ptr->write_data_fn = write_data_fn; |
else |
png_ptr->write_data_fn = png_default_write_data; |
#else |
png_ptr->write_data_fn = write_data_fn; |
#endif |
#if defined(PNG_WRITE_FLUSH_SUPPORTED) |
#if !defined(PNG_NO_STDIO) |
if (output_flush_fn != NULL) |
png_ptr->output_flush_fn = output_flush_fn; |
else |
png_ptr->output_flush_fn = png_default_flush; |
#else |
png_ptr->output_flush_fn = output_flush_fn; |
#endif |
#endif /* PNG_WRITE_FLUSH_SUPPORTED */ |
/* It is an error to read while writing a png file */ |
if (png_ptr->read_data_fn != NULL) |
{ |
png_ptr->read_data_fn = NULL; |
png_warning(png_ptr, |
"Attempted to set both read_data_fn and write_data_fn in"); |
png_warning(png_ptr, |
"the same structure. Resetting read_data_fn to NULL."); |
} |
} |
#if defined(USE_FAR_KEYWORD) |
#if defined(_MSC_VER) |
void *png_far_to_near(png_structp png_ptr,png_voidp ptr, int check) |
{ |
void *near_ptr; |
void FAR *far_ptr; |
FP_OFF(near_ptr) = FP_OFF(ptr); |
far_ptr = (void FAR *)near_ptr; |
if(check != 0) |
if(FP_SEG(ptr) != FP_SEG(far_ptr)) |
png_error(png_ptr,"segment lost in conversion"); |
return(near_ptr); |
} |
# else |
void *png_far_to_near(png_structp png_ptr,png_voidp ptr, int check) |
{ |
void *near_ptr; |
void FAR *far_ptr; |
near_ptr = (void FAR *)ptr; |
far_ptr = (void FAR *)near_ptr; |
if(check != 0) |
if(far_ptr != ptr) |
png_error(png_ptr,"segment lost in conversion"); |
return(near_ptr); |
} |
# endif |
# endif |
#endif /* PNG_WRITE_SUPPORTED */ |
/shark/trunk/ports/png/pngrutil.c |
---|
0,0 → 1,3101 |
/* pngrutil.c - utilities to read a PNG file |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
* This file contains routines that are only called from within |
* libpng itself during the course of reading an image. |
*/ |
#define PNG_INTERNAL |
#include "png.h" |
#if defined(_WIN32_WCE) |
/* strtod() function is not supported on WindowsCE */ |
# ifdef PNG_FLOATING_POINT_SUPPORTED |
__inline double strtod(const char *nptr, char **endptr) |
{ |
double result = 0; |
int len; |
wchar_t *str, *end; |
len = MultiByteToWideChar(CP_ACP, 0, nptr, -1, NULL, 0); |
str = (wchar_t *)malloc(len * sizeof(wchar_t)); |
if ( NULL != str ) |
{ |
MultiByteToWideChar(CP_ACP, 0, nptr, -1, str, len); |
result = wcstod(str, &end); |
len = WideCharToMultiByte(CP_ACP, 0, end, -1, NULL, 0, NULL, NULL); |
*endptr = (char *)nptr + (png_strlen(nptr) - len + 1); |
free(str); |
} |
return result; |
} |
# endif |
#endif |
#ifndef PNG_READ_BIG_ENDIAN_SUPPORTED |
/* Grab an unsigned 32-bit integer from a buffer in big-endian format. */ |
png_uint_32 /* PRIVATE */ |
png_get_uint_32(png_bytep buf) |
{ |
png_uint_32 i = ((png_uint_32)(*buf) << 24) + |
((png_uint_32)(*(buf + 1)) << 16) + |
((png_uint_32)(*(buf + 2)) << 8) + |
(png_uint_32)(*(buf + 3)); |
return (i); |
} |
#if defined(PNG_READ_pCAL_SUPPORTED) || defined(PNG_READ_oFFs_SUPPORTED) |
/* Grab a signed 32-bit integer from a buffer in big-endian format. The |
* data is stored in the PNG file in two's complement format, and it is |
* assumed that the machine format for signed integers is the same. */ |
png_int_32 /* PRIVATE */ |
png_get_int_32(png_bytep buf) |
{ |
png_int_32 i = ((png_int_32)(*buf) << 24) + |
((png_int_32)(*(buf + 1)) << 16) + |
((png_int_32)(*(buf + 2)) << 8) + |
(png_int_32)(*(buf + 3)); |
return (i); |
} |
#endif /* PNG_READ_pCAL_SUPPORTED */ |
/* Grab an unsigned 16-bit integer from a buffer in big-endian format. */ |
png_uint_16 /* PRIVATE */ |
png_get_uint_16(png_bytep buf) |
{ |
png_uint_16 i = (png_uint_16)(((png_uint_16)(*buf) << 8) + |
(png_uint_16)(*(buf + 1))); |
return (i); |
} |
#endif /* PNG_READ_BIG_ENDIAN_SUPPORTED */ |
/* Read data, and (optionally) run it through the CRC. */ |
void /* PRIVATE */ |
png_crc_read(png_structp png_ptr, png_bytep buf, png_size_t length) |
{ |
png_read_data(png_ptr, buf, length); |
png_calculate_crc(png_ptr, buf, length); |
} |
/* Optionally skip data and then check the CRC. Depending on whether we |
are reading a ancillary or critical chunk, and how the program has set |
things up, we may calculate the CRC on the data and print a message. |
Returns '1' if there was a CRC error, '0' otherwise. */ |
int /* PRIVATE */ |
png_crc_finish(png_structp png_ptr, png_uint_32 skip) |
{ |
png_size_t i; |
png_size_t istop = png_ptr->zbuf_size; |
for (i = (png_size_t)skip; i > istop; i -= istop) |
{ |
png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size); |
} |
if (i) |
{ |
png_crc_read(png_ptr, png_ptr->zbuf, i); |
} |
if (png_crc_error(png_ptr)) |
{ |
if (((png_ptr->chunk_name[0] & 0x20) && /* Ancillary */ |
!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)) || |
(!(png_ptr->chunk_name[0] & 0x20) && /* Critical */ |
(png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE))) |
{ |
png_chunk_warning(png_ptr, "CRC error"); |
} |
else |
{ |
png_chunk_error(png_ptr, "CRC error"); |
} |
return (1); |
} |
return (0); |
} |
/* Compare the CRC stored in the PNG file with that calculated by libpng from |
the data it has read thus far. */ |
int /* PRIVATE */ |
png_crc_error(png_structp png_ptr) |
{ |
png_byte crc_bytes[4]; |
png_uint_32 crc; |
int need_crc = 1; |
if (png_ptr->chunk_name[0] & 0x20) /* ancillary */ |
{ |
if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) == |
(PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN)) |
need_crc = 0; |
} |
else /* critical */ |
{ |
if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE) |
need_crc = 0; |
} |
png_read_data(png_ptr, crc_bytes, 4); |
if (need_crc) |
{ |
crc = png_get_uint_32(crc_bytes); |
return ((int)(crc != png_ptr->crc)); |
} |
else |
return (0); |
} |
#if defined(PNG_READ_zTXt_SUPPORTED) || defined(PNG_READ_iTXt_SUPPORTED) || \ |
defined(PNG_READ_iCCP_SUPPORTED) |
/* |
* Decompress trailing data in a chunk. The assumption is that chunkdata |
* points at an allocated area holding the contents of a chunk with a |
* trailing compressed part. What we get back is an allocated area |
* holding the original prefix part and an uncompressed version of the |
* trailing part (the malloc area passed in is freed). |
*/ |
png_charp /* PRIVATE */ |
png_decompress_chunk(png_structp png_ptr, int comp_type, |
png_charp chunkdata, png_size_t chunklength, |
png_size_t prefix_size, png_size_t *newlength) |
{ |
static char msg[] = "Error decoding compressed text"; |
png_charp text = NULL; |
png_size_t text_size; |
if (comp_type == PNG_COMPRESSION_TYPE_BASE) |
{ |
int ret = Z_OK; |
png_ptr->zstream.next_in = (png_bytep)(chunkdata + prefix_size); |
png_ptr->zstream.avail_in = (uInt)(chunklength - prefix_size); |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
text_size = 0; |
text = NULL; |
while (png_ptr->zstream.avail_in) |
{ |
ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); |
if (ret != Z_OK && ret != Z_STREAM_END) |
{ |
if (png_ptr->zstream.msg != NULL) |
png_warning(png_ptr, png_ptr->zstream.msg); |
else |
png_warning(png_ptr, msg); |
inflateReset(&png_ptr->zstream); |
png_ptr->zstream.avail_in = 0; |
if (text == NULL) |
{ |
text_size = prefix_size + sizeof(msg) + 1; |
text = (png_charp)png_malloc_warn(png_ptr, text_size); |
if (text == NULL) |
{ |
png_free(png_ptr,chunkdata); |
png_error(png_ptr,"Not enough memory to decompress chunk"); |
} |
png_memcpy(text, chunkdata, prefix_size); |
} |
text[text_size - 1] = 0x00; |
/* Copy what we can of the error message into the text chunk */ |
text_size = (png_size_t)(chunklength - (text - chunkdata) - 1); |
text_size = sizeof(msg) > text_size ? text_size : sizeof(msg); |
png_memcpy(text + prefix_size, msg, text_size + 1); |
break; |
} |
if (!png_ptr->zstream.avail_out || ret == Z_STREAM_END) |
{ |
if (text == NULL) |
{ |
text_size = prefix_size + |
png_ptr->zbuf_size - png_ptr->zstream.avail_out; |
text = (png_charp)png_malloc_warn(png_ptr, text_size + 1); |
if (text == NULL) |
{ |
png_free(png_ptr,chunkdata); |
png_error(png_ptr,"Not enough memory to decompress chunk."); |
} |
png_memcpy(text + prefix_size, png_ptr->zbuf, |
text_size - prefix_size); |
png_memcpy(text, chunkdata, prefix_size); |
*(text + text_size) = 0x00; |
} |
else |
{ |
png_charp tmp; |
tmp = text; |
text = (png_charp)png_malloc_warn(png_ptr, |
(png_uint_32)(text_size + |
png_ptr->zbuf_size - png_ptr->zstream.avail_out + 1)); |
if (text == NULL) |
{ |
png_free(png_ptr, tmp); |
png_free(png_ptr, chunkdata); |
png_error(png_ptr,"Not enough memory to decompress chunk.."); |
} |
png_memcpy(text, tmp, text_size); |
png_free(png_ptr, tmp); |
png_memcpy(text + text_size, png_ptr->zbuf, |
(png_ptr->zbuf_size - png_ptr->zstream.avail_out)); |
text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out; |
*(text + text_size) = 0x00; |
} |
if (ret == Z_STREAM_END) |
break; |
else |
{ |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
} |
} |
} |
if (ret != Z_STREAM_END) |
{ |
#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) |
char umsg[50]; |
if (ret == Z_BUF_ERROR) |
sprintf(umsg,"Buffer error in compressed datastream in %s chunk", |
png_ptr->chunk_name); |
else if (ret == Z_DATA_ERROR) |
sprintf(umsg,"Data error in compressed datastream in %s chunk", |
png_ptr->chunk_name); |
else |
sprintf(umsg,"Incomplete compressed datastream in %s chunk", |
png_ptr->chunk_name); |
png_warning(png_ptr, umsg); |
#else |
png_warning(png_ptr, |
"Incomplete compressed datastream in chunk other than IDAT"); |
#endif |
text_size=prefix_size; |
if (text == NULL) |
{ |
text = (png_charp)png_malloc_warn(png_ptr, text_size+1); |
if (text == NULL) |
{ |
png_free(png_ptr, chunkdata); |
png_error(png_ptr,"Not enough memory for text."); |
} |
png_memcpy(text, chunkdata, prefix_size); |
} |
*(text + text_size) = 0x00; |
} |
inflateReset(&png_ptr->zstream); |
png_ptr->zstream.avail_in = 0; |
png_free(png_ptr, chunkdata); |
chunkdata = text; |
*newlength=text_size; |
} |
else /* if (comp_type != PNG_COMPRESSION_TYPE_BASE) */ |
{ |
#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) |
char umsg[50]; |
sprintf(umsg, "Unknown zTXt compression type %d", comp_type); |
png_warning(png_ptr, umsg); |
#else |
png_warning(png_ptr, "Unknown zTXt compression type"); |
#endif |
*(chunkdata + prefix_size) = 0x00; |
*newlength=prefix_size; |
} |
return chunkdata; |
} |
#endif |
/* read and check the IDHR chunk */ |
void /* PRIVATE */ |
png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_byte buf[13]; |
png_uint_32 width, height; |
int bit_depth, color_type, compression_type, filter_type; |
int interlace_type; |
png_debug(1, "in png_handle_IHDR\n"); |
if (png_ptr->mode & PNG_HAVE_IHDR) |
png_error(png_ptr, "Out of place IHDR"); |
/* check the length */ |
if (length != 13) |
png_error(png_ptr, "Invalid IHDR chunk"); |
png_ptr->mode |= PNG_HAVE_IHDR; |
png_crc_read(png_ptr, buf, 13); |
png_crc_finish(png_ptr, 0); |
width = png_get_uint_32(buf); |
height = png_get_uint_32(buf + 4); |
bit_depth = buf[8]; |
color_type = buf[9]; |
compression_type = buf[10]; |
filter_type = buf[11]; |
interlace_type = buf[12]; |
/* set internal variables */ |
png_ptr->width = width; |
png_ptr->height = height; |
png_ptr->bit_depth = (png_byte)bit_depth; |
png_ptr->interlaced = (png_byte)interlace_type; |
png_ptr->color_type = (png_byte)color_type; |
#if defined(PNG_MNG_FEATURES_SUPPORTED) |
png_ptr->filter_type = (png_byte)filter_type; |
#endif |
/* find number of channels */ |
switch (png_ptr->color_type) |
{ |
case PNG_COLOR_TYPE_GRAY: |
case PNG_COLOR_TYPE_PALETTE: |
png_ptr->channels = 1; |
break; |
case PNG_COLOR_TYPE_RGB: |
png_ptr->channels = 3; |
break; |
case PNG_COLOR_TYPE_GRAY_ALPHA: |
png_ptr->channels = 2; |
break; |
case PNG_COLOR_TYPE_RGB_ALPHA: |
png_ptr->channels = 4; |
break; |
} |
/* set up other useful info */ |
png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth * |
png_ptr->channels); |
png_ptr->rowbytes = ((png_ptr->width * |
(png_uint_32)png_ptr->pixel_depth + 7) >> 3); |
png_debug1(3,"bit_depth = %d\n", png_ptr->bit_depth); |
png_debug1(3,"channels = %d\n", png_ptr->channels); |
png_debug1(3,"rowbytes = %lu\n", png_ptr->rowbytes); |
png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, |
color_type, interlace_type, compression_type, filter_type); |
} |
/* read and check the palette */ |
void /* PRIVATE */ |
png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_color palette[PNG_MAX_PALETTE_LENGTH]; |
int num, i; |
#ifndef PNG_NO_POINTER_INDEXING |
png_colorp pal_ptr; |
#endif |
png_debug(1, "in png_handle_PLTE\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before PLTE"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid PLTE after IDAT"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (png_ptr->mode & PNG_HAVE_PLTE) |
png_error(png_ptr, "Duplicate PLTE chunk"); |
png_ptr->mode |= PNG_HAVE_PLTE; |
if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR)) |
{ |
png_warning(png_ptr, |
"Ignoring PLTE chunk in grayscale PNG"); |
png_crc_finish(png_ptr, length); |
return; |
} |
#if !defined(PNG_READ_OPT_PLTE_SUPPORTED) |
if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE) |
{ |
png_crc_finish(png_ptr, length); |
return; |
} |
#endif |
if (length > 3*PNG_MAX_PALETTE_LENGTH || length % 3) |
{ |
if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE) |
{ |
png_warning(png_ptr, "Invalid palette chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else |
{ |
png_error(png_ptr, "Invalid palette chunk"); |
} |
} |
num = (int)length / 3; |
#ifndef PNG_NO_POINTER_INDEXING |
for (i = 0, pal_ptr = palette; i < num; i++, pal_ptr++) |
{ |
png_byte buf[3]; |
png_crc_read(png_ptr, buf, 3); |
pal_ptr->red = buf[0]; |
pal_ptr->green = buf[1]; |
pal_ptr->blue = buf[2]; |
} |
#else |
for (i = 0; i < num; i++) |
{ |
png_byte buf[3]; |
png_crc_read(png_ptr, buf, 3); |
/* don't depend upon png_color being any order */ |
palette[i].red = buf[0]; |
palette[i].green = buf[1]; |
palette[i].blue = buf[2]; |
} |
#endif |
/* If we actually NEED the PLTE chunk (ie for a paletted image), we do |
whatever the normal CRC configuration tells us. However, if we |
have an RGB image, the PLTE can be considered ancillary, so |
we will act as though it is. */ |
#if !defined(PNG_READ_OPT_PLTE_SUPPORTED) |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
#endif |
{ |
png_crc_finish(png_ptr, 0); |
} |
#if !defined(PNG_READ_OPT_PLTE_SUPPORTED) |
else if (png_crc_error(png_ptr)) /* Only if we have a CRC error */ |
{ |
/* If we don't want to use the data from an ancillary chunk, |
we have two options: an error abort, or a warning and we |
ignore the data in this chunk (which should be OK, since |
it's considered ancillary for a RGB or RGBA image). */ |
if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_USE)) |
{ |
if (png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN) |
{ |
png_chunk_error(png_ptr, "CRC error"); |
} |
else |
{ |
png_chunk_warning(png_ptr, "CRC error"); |
return; |
} |
} |
/* Otherwise, we (optionally) emit a warning and use the chunk. */ |
else if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)) |
{ |
png_chunk_warning(png_ptr, "CRC error"); |
} |
} |
#endif |
png_set_PLTE(png_ptr, info_ptr, palette, num); |
#if defined(PNG_READ_tRNS_SUPPORTED) |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS)) |
{ |
if (png_ptr->num_trans > (png_uint_16)num) |
{ |
png_warning(png_ptr, "Truncating incorrect tRNS chunk length"); |
png_ptr->num_trans = (png_uint_16)num; |
} |
if (info_ptr->num_trans > (png_uint_16)num) |
{ |
png_warning(png_ptr, "Truncating incorrect info tRNS chunk length"); |
info_ptr->num_trans = (png_uint_16)num; |
} |
} |
} |
#endif |
} |
void /* PRIVATE */ |
png_handle_IEND(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_debug(1, "in png_handle_IEND\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR) || !(png_ptr->mode & PNG_HAVE_IDAT)) |
{ |
png_error(png_ptr, "No image in file"); |
info_ptr = info_ptr; /* quiet compiler warnings about unused info_ptr */ |
} |
png_ptr->mode |= (PNG_AFTER_IDAT | PNG_HAVE_IEND); |
if (length != 0) |
{ |
png_warning(png_ptr, "Incorrect IEND chunk length"); |
} |
png_crc_finish(png_ptr, length); |
} |
#if defined(PNG_READ_gAMA_SUPPORTED) |
void /* PRIVATE */ |
png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_fixed_point igamma; |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
float file_gamma; |
#endif |
png_byte buf[4]; |
png_debug(1, "in png_handle_gAMA\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before gAMA"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid gAMA after IDAT"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (png_ptr->mode & PNG_HAVE_PLTE) |
/* Should be an error, but we can cope with it */ |
png_warning(png_ptr, "Out of place gAMA chunk"); |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA) |
#if defined(PNG_READ_sRGB_SUPPORTED) |
&& !(info_ptr->valid & PNG_INFO_sRGB) |
#endif |
) |
{ |
png_warning(png_ptr, "Duplicate gAMA chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
if (length != 4) |
{ |
png_warning(png_ptr, "Incorrect gAMA chunk length"); |
png_crc_finish(png_ptr, length); |
return; |
} |
png_crc_read(png_ptr, buf, 4); |
if (png_crc_finish(png_ptr, 0)) |
return; |
igamma = (png_fixed_point)png_get_uint_32(buf); |
/* check for zero gamma */ |
if (igamma == 0) |
{ |
png_warning(png_ptr, |
"Ignoring gAMA chunk with gamma=0"); |
return; |
} |
#if defined(PNG_READ_sRGB_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_sRGB) |
if(igamma < 45000L || igamma > 46000L) |
{ |
png_warning(png_ptr, |
"Ignoring incorrect gAMA value when sRGB is also present"); |
#ifndef PNG_NO_CONSOLE_IO |
cprintf("gamma = (%d/100000)\n", (int)igamma); |
#endif |
return; |
} |
#endif /* PNG_READ_sRGB_SUPPORTED */ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
file_gamma = (float)igamma / (float)100000.0; |
# ifdef PNG_READ_GAMMA_SUPPORTED |
png_ptr->gamma = file_gamma; |
# endif |
png_set_gAMA(png_ptr, info_ptr, file_gamma); |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
png_set_gAMA_fixed(png_ptr, info_ptr, igamma); |
#endif |
} |
#endif |
#if defined(PNG_READ_sBIT_SUPPORTED) |
void /* PRIVATE */ |
png_handle_sBIT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_size_t truelen; |
png_byte buf[4]; |
png_debug(1, "in png_handle_sBIT\n"); |
buf[0] = buf[1] = buf[2] = buf[3] = 0; |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before sBIT"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid sBIT after IDAT"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (png_ptr->mode & PNG_HAVE_PLTE) |
{ |
/* Should be an error, but we can cope with it */ |
png_warning(png_ptr, "Out of place sBIT chunk"); |
} |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT)) |
{ |
png_warning(png_ptr, "Duplicate sBIT chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
truelen = 3; |
else |
truelen = (png_size_t)png_ptr->channels; |
if (length != truelen) |
{ |
png_warning(png_ptr, "Incorrect sBIT chunk length"); |
png_crc_finish(png_ptr, length); |
return; |
} |
png_crc_read(png_ptr, buf, truelen); |
if (png_crc_finish(png_ptr, 0)) |
return; |
if (png_ptr->color_type & PNG_COLOR_MASK_COLOR) |
{ |
png_ptr->sig_bit.red = buf[0]; |
png_ptr->sig_bit.green = buf[1]; |
png_ptr->sig_bit.blue = buf[2]; |
png_ptr->sig_bit.alpha = buf[3]; |
} |
else |
{ |
png_ptr->sig_bit.gray = buf[0]; |
png_ptr->sig_bit.red = buf[0]; |
png_ptr->sig_bit.green = buf[0]; |
png_ptr->sig_bit.blue = buf[0]; |
png_ptr->sig_bit.alpha = buf[1]; |
} |
png_set_sBIT(png_ptr, info_ptr, &(png_ptr->sig_bit)); |
} |
#endif |
#if defined(PNG_READ_cHRM_SUPPORTED) |
void /* PRIVATE */ |
png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_byte buf[4]; |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y; |
#endif |
png_fixed_point int_x_white, int_y_white, int_x_red, int_y_red, int_x_green, |
int_y_green, int_x_blue, int_y_blue; |
png_uint_32 uint_x, uint_y; |
png_debug(1, "in png_handle_cHRM\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before cHRM"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid cHRM after IDAT"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (png_ptr->mode & PNG_HAVE_PLTE) |
/* Should be an error, but we can cope with it */ |
png_warning(png_ptr, "Missing PLTE before cHRM"); |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM) |
#if defined(PNG_READ_sRGB_SUPPORTED) |
&& !(info_ptr->valid & PNG_INFO_sRGB) |
#endif |
) |
{ |
png_warning(png_ptr, "Duplicate cHRM chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
if (length != 32) |
{ |
png_warning(png_ptr, "Incorrect cHRM chunk length"); |
png_crc_finish(png_ptr, length); |
return; |
} |
png_crc_read(png_ptr, buf, 4); |
uint_x = png_get_uint_32(buf); |
png_crc_read(png_ptr, buf, 4); |
uint_y = png_get_uint_32(buf); |
if (uint_x > 80000L || uint_y > 80000L || |
uint_x + uint_y > 100000L) |
{ |
png_warning(png_ptr, "Invalid cHRM white point"); |
png_crc_finish(png_ptr, 24); |
return; |
} |
int_x_white = (png_fixed_point)uint_x; |
int_y_white = (png_fixed_point)uint_y; |
png_crc_read(png_ptr, buf, 4); |
uint_x = png_get_uint_32(buf); |
png_crc_read(png_ptr, buf, 4); |
uint_y = png_get_uint_32(buf); |
if (uint_x > 80000L || uint_y > 80000L || |
uint_x + uint_y > 100000L) |
{ |
png_warning(png_ptr, "Invalid cHRM red point"); |
png_crc_finish(png_ptr, 16); |
return; |
} |
int_x_red = (png_fixed_point)uint_x; |
int_y_red = (png_fixed_point)uint_y; |
png_crc_read(png_ptr, buf, 4); |
uint_x = png_get_uint_32(buf); |
png_crc_read(png_ptr, buf, 4); |
uint_y = png_get_uint_32(buf); |
if (uint_x > 80000L || uint_y > 80000L || |
uint_x + uint_y > 100000L) |
{ |
png_warning(png_ptr, "Invalid cHRM green point"); |
png_crc_finish(png_ptr, 8); |
return; |
} |
int_x_green = (png_fixed_point)uint_x; |
int_y_green = (png_fixed_point)uint_y; |
png_crc_read(png_ptr, buf, 4); |
uint_x = png_get_uint_32(buf); |
png_crc_read(png_ptr, buf, 4); |
uint_y = png_get_uint_32(buf); |
if (uint_x > 80000L || uint_y > 80000L || |
uint_x + uint_y > 100000L) |
{ |
png_warning(png_ptr, "Invalid cHRM blue point"); |
png_crc_finish(png_ptr, 0); |
return; |
} |
int_x_blue = (png_fixed_point)uint_x; |
int_y_blue = (png_fixed_point)uint_y; |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
white_x = (float)int_x_white / (float)100000.0; |
white_y = (float)int_y_white / (float)100000.0; |
red_x = (float)int_x_red / (float)100000.0; |
red_y = (float)int_y_red / (float)100000.0; |
green_x = (float)int_x_green / (float)100000.0; |
green_y = (float)int_y_green / (float)100000.0; |
blue_x = (float)int_x_blue / (float)100000.0; |
blue_y = (float)int_y_blue / (float)100000.0; |
#endif |
#if defined(PNG_READ_sRGB_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_sRGB) |
{ |
if (abs(int_x_white - 31270L) > 1000 || |
abs(int_y_white - 32900L) > 1000 || |
abs(int_x_red - 64000L) > 1000 || |
abs(int_y_red - 33000L) > 1000 || |
abs(int_x_green - 30000L) > 1000 || |
abs(int_y_green - 60000L) > 1000 || |
abs(int_x_blue - 15000L) > 1000 || |
abs(int_y_blue - 6000L) > 1000) |
{ |
png_warning(png_ptr, |
"Ignoring incorrect cHRM value when sRGB is also present"); |
#ifndef PNG_NO_CONSOLE_IO |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
cprintf("wx=%f, wy=%f, rx=%f, ry=%f\n", |
white_x, white_y, red_x, red_y); |
cprintf("gx=%f, gy=%f, bx=%f, by=%f\n", |
green_x, green_y, blue_x, blue_y); |
#else |
cprintf("wx=%ld, wy=%ld, rx=%ld, ry=%ld\n", |
int_x_white, int_y_white, int_x_red, int_y_red); |
cprintf("gx=%ld, gy=%ld, bx=%ld, by=%ld\n", |
int_x_green, int_y_green, int_x_blue, int_y_blue); |
#endif |
#endif /* PNG_NO_CONSOLE_IO */ |
} |
png_crc_finish(png_ptr, 0); |
return; |
} |
#endif /* PNG_READ_sRGB_SUPPORTED */ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
png_set_cHRM(png_ptr, info_ptr, |
white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y); |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
png_set_cHRM_fixed(png_ptr, info_ptr, |
int_x_white, int_y_white, int_x_red, int_y_red, int_x_green, |
int_y_green, int_x_blue, int_y_blue); |
#endif |
if (png_crc_finish(png_ptr, 0)) |
return; |
} |
#endif |
#if defined(PNG_READ_sRGB_SUPPORTED) |
void /* PRIVATE */ |
png_handle_sRGB(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
int intent; |
png_byte buf[1]; |
png_debug(1, "in png_handle_sRGB\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before sRGB"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid sRGB after IDAT"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (png_ptr->mode & PNG_HAVE_PLTE) |
/* Should be an error, but we can cope with it */ |
png_warning(png_ptr, "Out of place sRGB chunk"); |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)) |
{ |
png_warning(png_ptr, "Duplicate sRGB chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
if (length != 1) |
{ |
png_warning(png_ptr, "Incorrect sRGB chunk length"); |
png_crc_finish(png_ptr, length); |
return; |
} |
png_crc_read(png_ptr, buf, 1); |
if (png_crc_finish(png_ptr, 0)) |
return; |
intent = buf[0]; |
/* check for bad intent */ |
if (intent >= PNG_sRGB_INTENT_LAST) |
{ |
png_warning(png_ptr, "Unknown sRGB intent"); |
return; |
} |
#if defined(PNG_READ_gAMA_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED) |
if ((info_ptr->valid & PNG_INFO_gAMA)) |
{ |
int igamma; |
#ifdef PNG_FIXED_POINT_SUPPORTED |
igamma=(int)info_ptr->int_gamma; |
#else |
# ifdef PNG_FLOATING_POINT_SUPPORTED |
igamma=(int)(info_ptr->gamma * 100000.); |
# endif |
#endif |
if(igamma < 45000L || igamma > 46000L) |
{ |
png_warning(png_ptr, |
"Ignoring incorrect gAMA value when sRGB is also present"); |
#ifndef PNG_NO_CONSOLE_IO |
# ifdef PNG_FIXED_POINT_SUPPORTED |
cprintf("incorrect gamma=(%d/100000)\n",(int)png_ptr->int_gamma); |
# else |
# ifdef PNG_FLOATING_POINT_SUPPORTED |
cprintf("incorrect gamma=%f\n",png_ptr->gamma); |
# endif |
# endif |
#endif |
} |
} |
#endif /* PNG_READ_gAMA_SUPPORTED */ |
#ifdef PNG_READ_cHRM_SUPPORTED |
#ifdef PNG_FIXED_POINT_SUPPORTED |
if (info_ptr->valid & PNG_INFO_cHRM) |
if (abs(info_ptr->int_x_white - 31270L) > 1000 || |
abs(info_ptr->int_y_white - 32900L) > 1000 || |
abs(info_ptr->int_x_red - 64000L) > 1000 || |
abs(info_ptr->int_y_red - 33000L) > 1000 || |
abs(info_ptr->int_x_green - 30000L) > 1000 || |
abs(info_ptr->int_y_green - 60000L) > 1000 || |
abs(info_ptr->int_x_blue - 15000L) > 1000 || |
abs(info_ptr->int_y_blue - 6000L) > 1000) |
{ |
png_warning(png_ptr, |
"Ignoring incorrect cHRM value when sRGB is also present"); |
} |
#endif /* PNG_FIXED_POINT_SUPPORTED */ |
#endif /* PNG_READ_cHRM_SUPPORTED */ |
png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, intent); |
} |
#endif /* PNG_READ_sRGB_SUPPORTED */ |
#if defined(PNG_READ_iCCP_SUPPORTED) |
void /* PRIVATE */ |
png_handle_iCCP(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
/* Note: this does not properly handle chunks that are > 64K under DOS */ |
{ |
png_charp chunkdata; |
png_byte compression_type; |
png_bytep pC; |
png_charp profile; |
png_uint_32 skip = 0; |
png_uint_32 profile_size = 0; |
png_uint_32 profile_length = 0; |
png_size_t slength, prefix_length, data_length; |
png_debug(1, "in png_handle_iCCP\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before iCCP"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid iCCP after IDAT"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (png_ptr->mode & PNG_HAVE_PLTE) |
/* Should be an error, but we can cope with it */ |
png_warning(png_ptr, "Out of place iCCP chunk"); |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP)) |
{ |
png_warning(png_ptr, "Duplicate iCCP chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
#ifdef PNG_MAX_MALLOC_64K |
if (length > (png_uint_32)65535L) |
{ |
png_warning(png_ptr, "iCCP chunk too large to fit in memory"); |
skip = length - (png_uint_32)65535L; |
length = (png_uint_32)65535L; |
} |
#endif |
chunkdata = (png_charp)png_malloc(png_ptr, length + 1); |
slength = (png_size_t)length; |
png_crc_read(png_ptr, (png_bytep)chunkdata, slength); |
if (png_crc_finish(png_ptr, skip)) |
{ |
png_free(png_ptr, chunkdata); |
return; |
} |
chunkdata[slength] = 0x00; |
for (profile = chunkdata; *profile; profile++) |
/* empty loop to find end of name */ ; |
++profile; |
/* there should be at least one zero (the compression type byte) |
following the separator, and we should be on it */ |
if ( profile >= chunkdata + slength) |
{ |
png_free(png_ptr, chunkdata); |
png_warning(png_ptr, "Malformed iCCP chunk"); |
return; |
} |
/* compression_type should always be zero */ |
compression_type = *profile++; |
if (compression_type) |
{ |
png_warning(png_ptr, "Ignoring nonzero compression type in iCCP chunk"); |
compression_type=0x00; /* Reset it to zero (libpng-1.0.6 through 1.0.8 |
wrote nonzero) */ |
} |
prefix_length = profile - chunkdata; |
chunkdata = png_decompress_chunk(png_ptr, compression_type, chunkdata, |
slength, prefix_length, &data_length); |
profile_length = data_length - prefix_length; |
if ( prefix_length > data_length || profile_length < 4) |
{ |
png_free(png_ptr, chunkdata); |
png_warning(png_ptr, "Profile size field missing from iCCP chunk"); |
return; |
} |
/* Check the profile_size recorded in the first 32 bits of the ICC profile */ |
pC = (png_bytep)(chunkdata+prefix_length); |
profile_size = ((*(pC ))<<24) | |
((*(pC+1))<<16) | |
((*(pC+2))<< 8) | |
((*(pC+3)) ); |
if(profile_size < profile_length) |
profile_length = profile_size; |
if(profile_size > profile_length) |
{ |
png_free(png_ptr, chunkdata); |
png_warning(png_ptr, "Ignoring truncated iCCP profile.\n"); |
return; |
} |
png_set_iCCP(png_ptr, info_ptr, chunkdata, compression_type, |
chunkdata + prefix_length, profile_length); |
png_free(png_ptr, chunkdata); |
} |
#endif /* PNG_READ_iCCP_SUPPORTED */ |
#if defined(PNG_READ_sPLT_SUPPORTED) |
void /* PRIVATE */ |
png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
/* Note: this does not properly handle chunks that are > 64K under DOS */ |
{ |
png_bytep chunkdata; |
png_bytep entry_start; |
png_sPLT_t new_palette; |
#ifdef PNG_NO_POINTER_INDEXING |
png_sPLT_entryp pp; |
#endif |
int data_length, entry_size, i; |
png_uint_32 skip = 0; |
png_size_t slength; |
png_debug(1, "in png_handle_sPLT\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before sPLT"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid sPLT after IDAT"); |
png_crc_finish(png_ptr, length); |
return; |
} |
#ifdef PNG_MAX_MALLOC_64K |
if (length > (png_uint_32)65535L) |
{ |
png_warning(png_ptr, "sPLT chunk too large to fit in memory"); |
skip = length - (png_uint_32)65535L; |
length = (png_uint_32)65535L; |
} |
#endif |
chunkdata = (png_bytep)png_malloc(png_ptr, length + 1); |
slength = (png_size_t)length; |
png_crc_read(png_ptr, (png_bytep)chunkdata, slength); |
if (png_crc_finish(png_ptr, skip)) |
{ |
png_free(png_ptr, chunkdata); |
return; |
} |
chunkdata[slength] = 0x00; |
for (entry_start = chunkdata; *entry_start; entry_start++) |
/* empty loop to find end of name */ ; |
++entry_start; |
/* a sample depth should follow the separator, and we should be on it */ |
if (entry_start > chunkdata + slength) |
{ |
png_free(png_ptr, chunkdata); |
png_warning(png_ptr, "malformed sPLT chunk"); |
return; |
} |
new_palette.depth = *entry_start++; |
entry_size = (new_palette.depth == 8 ? 6 : 10); |
data_length = (slength - (entry_start - chunkdata)); |
/* integrity-check the data length */ |
if (data_length % entry_size) |
{ |
png_free(png_ptr, chunkdata); |
png_warning(png_ptr, "sPLT chunk has bad length"); |
return; |
} |
new_palette.nentries = data_length / entry_size; |
new_palette.entries = (png_sPLT_entryp)png_malloc( |
png_ptr, new_palette.nentries * sizeof(png_sPLT_entry)); |
#ifndef PNG_NO_POINTER_INDEXING |
for (i = 0; i < new_palette.nentries; i++) |
{ |
png_sPLT_entryp pp = new_palette.entries + i; |
if (new_palette.depth == 8) |
{ |
pp->red = *entry_start++; |
pp->green = *entry_start++; |
pp->blue = *entry_start++; |
pp->alpha = *entry_start++; |
} |
else |
{ |
pp->red = png_get_uint_16(entry_start); entry_start += 2; |
pp->green = png_get_uint_16(entry_start); entry_start += 2; |
pp->blue = png_get_uint_16(entry_start); entry_start += 2; |
pp->alpha = png_get_uint_16(entry_start); entry_start += 2; |
} |
pp->frequency = png_get_uint_16(entry_start); entry_start += 2; |
} |
#else |
pp = new_palette.entries; |
for (i = 0; i < new_palette.nentries; i++) |
{ |
if (new_palette.depth == 8) |
{ |
pp[i].red = *entry_start++; |
pp[i].green = *entry_start++; |
pp[i].blue = *entry_start++; |
pp[i].alpha = *entry_start++; |
} |
else |
{ |
pp[i].red = png_get_uint_16(entry_start); entry_start += 2; |
pp[i].green = png_get_uint_16(entry_start); entry_start += 2; |
pp[i].blue = png_get_uint_16(entry_start); entry_start += 2; |
pp[i].alpha = png_get_uint_16(entry_start); entry_start += 2; |
} |
pp->frequency = png_get_uint_16(entry_start); entry_start += 2; |
} |
#endif |
/* discard all chunk data except the name and stash that */ |
new_palette.name = (png_charp)chunkdata; |
png_set_sPLT(png_ptr, info_ptr, &new_palette, 1); |
png_free(png_ptr, chunkdata); |
png_free(png_ptr, new_palette.entries); |
} |
#endif /* PNG_READ_sPLT_SUPPORTED */ |
#if defined(PNG_READ_tRNS_SUPPORTED) |
void /* PRIVATE */ |
png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_byte readbuf[PNG_MAX_PALETTE_LENGTH]; |
png_debug(1, "in png_handle_tRNS\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before tRNS"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid tRNS after IDAT"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS)) |
{ |
png_warning(png_ptr, "Duplicate tRNS chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
if (!(png_ptr->mode & PNG_HAVE_PLTE)) |
{ |
/* Should be an error, but we can cope with it */ |
png_warning(png_ptr, "Missing PLTE before tRNS"); |
} |
else if (length > (png_uint_32)png_ptr->num_palette) |
{ |
png_warning(png_ptr, "Incorrect tRNS chunk length"); |
png_crc_finish(png_ptr, length); |
return; |
} |
if (length == 0) |
{ |
png_warning(png_ptr, "Zero length tRNS chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
png_crc_read(png_ptr, readbuf, (png_size_t)length); |
png_ptr->num_trans = (png_uint_16)length; |
} |
else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB) |
{ |
png_byte buf[6]; |
if (length != 6) |
{ |
png_warning(png_ptr, "Incorrect tRNS chunk length"); |
png_crc_finish(png_ptr, length); |
return; |
} |
png_crc_read(png_ptr, buf, (png_size_t)length); |
png_ptr->num_trans = 1; |
png_ptr->trans_values.red = png_get_uint_16(buf); |
png_ptr->trans_values.green = png_get_uint_16(buf + 2); |
png_ptr->trans_values.blue = png_get_uint_16(buf + 4); |
} |
else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY) |
{ |
png_byte buf[6]; |
if (length != 2) |
{ |
png_warning(png_ptr, "Incorrect tRNS chunk length"); |
png_crc_finish(png_ptr, length); |
return; |
} |
png_crc_read(png_ptr, buf, 2); |
png_ptr->num_trans = 1; |
png_ptr->trans_values.gray = png_get_uint_16(buf); |
} |
else |
{ |
png_warning(png_ptr, "tRNS chunk not allowed with alpha channel"); |
png_crc_finish(png_ptr, length); |
return; |
} |
if (png_crc_finish(png_ptr, 0)) |
return; |
png_set_tRNS(png_ptr, info_ptr, readbuf, png_ptr->num_trans, |
&(png_ptr->trans_values)); |
} |
#endif |
#if defined(PNG_READ_bKGD_SUPPORTED) |
void /* PRIVATE */ |
png_handle_bKGD(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_size_t truelen; |
png_byte buf[6]; |
png_debug(1, "in png_handle_bKGD\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before bKGD"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid bKGD after IDAT"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && |
!(png_ptr->mode & PNG_HAVE_PLTE)) |
{ |
png_warning(png_ptr, "Missing PLTE before bKGD"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD)) |
{ |
png_warning(png_ptr, "Duplicate bKGD chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
truelen = 1; |
else if (png_ptr->color_type & PNG_COLOR_MASK_COLOR) |
truelen = 6; |
else |
truelen = 2; |
if (length != truelen) |
{ |
png_warning(png_ptr, "Incorrect bKGD chunk length"); |
png_crc_finish(png_ptr, length); |
return; |
} |
png_crc_read(png_ptr, buf, truelen); |
if (png_crc_finish(png_ptr, 0)) |
return; |
/* We convert the index value into RGB components so that we can allow |
* arbitrary RGB values for background when we have transparency, and |
* so it is easy to determine the RGB values of the background color |
* from the info_ptr struct. */ |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
png_ptr->background.index = buf[0]; |
if(info_ptr->num_palette) |
{ |
if(buf[0] > info_ptr->num_palette) |
{ |
png_warning(png_ptr, "Incorrect bKGD chunk index value"); |
return; |
} |
png_ptr->background.red = |
(png_uint_16)png_ptr->palette[buf[0]].red; |
png_ptr->background.green = |
(png_uint_16)png_ptr->palette[buf[0]].green; |
png_ptr->background.blue = |
(png_uint_16)png_ptr->palette[buf[0]].blue; |
} |
} |
else if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) /* GRAY */ |
{ |
png_ptr->background.red = |
png_ptr->background.green = |
png_ptr->background.blue = |
png_ptr->background.gray = png_get_uint_16(buf); |
} |
else |
{ |
png_ptr->background.red = png_get_uint_16(buf); |
png_ptr->background.green = png_get_uint_16(buf + 2); |
png_ptr->background.blue = png_get_uint_16(buf + 4); |
} |
png_set_bKGD(png_ptr, info_ptr, &(png_ptr->background)); |
} |
#endif |
#if defined(PNG_READ_hIST_SUPPORTED) |
void /* PRIVATE */ |
png_handle_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
int num, i; |
png_uint_16 readbuf[PNG_MAX_PALETTE_LENGTH]; |
png_debug(1, "in png_handle_hIST\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before hIST"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid hIST after IDAT"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (!(png_ptr->mode & PNG_HAVE_PLTE)) |
{ |
png_warning(png_ptr, "Missing PLTE before hIST"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST)) |
{ |
png_warning(png_ptr, "Duplicate hIST chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
num = (int)length / 2 ; |
if (num != png_ptr->num_palette) |
{ |
png_warning(png_ptr, "Incorrect hIST chunk length"); |
png_crc_finish(png_ptr, length); |
return; |
} |
for (i = 0; i < num; i++) |
{ |
png_byte buf[2]; |
png_crc_read(png_ptr, buf, 2); |
readbuf[i] = png_get_uint_16(buf); |
} |
if (png_crc_finish(png_ptr, 0)) |
return; |
png_set_hIST(png_ptr, info_ptr, readbuf); |
} |
#endif |
#if defined(PNG_READ_pHYs_SUPPORTED) |
void /* PRIVATE */ |
png_handle_pHYs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_byte buf[9]; |
png_uint_32 res_x, res_y; |
int unit_type; |
png_debug(1, "in png_handle_pHYs\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before pHYs"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid pHYs after IDAT"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)) |
{ |
png_warning(png_ptr, "Duplicate pHYs chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
if (length != 9) |
{ |
png_warning(png_ptr, "Incorrect pHYs chunk length"); |
png_crc_finish(png_ptr, length); |
return; |
} |
png_crc_read(png_ptr, buf, 9); |
if (png_crc_finish(png_ptr, 0)) |
return; |
res_x = png_get_uint_32(buf); |
res_y = png_get_uint_32(buf + 4); |
unit_type = buf[8]; |
png_set_pHYs(png_ptr, info_ptr, res_x, res_y, unit_type); |
} |
#endif |
#if defined(PNG_READ_oFFs_SUPPORTED) |
void /* PRIVATE */ |
png_handle_oFFs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_byte buf[9]; |
png_int_32 offset_x, offset_y; |
int unit_type; |
png_debug(1, "in png_handle_oFFs\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before oFFs"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid oFFs after IDAT"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)) |
{ |
png_warning(png_ptr, "Duplicate oFFs chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
if (length != 9) |
{ |
png_warning(png_ptr, "Incorrect oFFs chunk length"); |
png_crc_finish(png_ptr, length); |
return; |
} |
png_crc_read(png_ptr, buf, 9); |
if (png_crc_finish(png_ptr, 0)) |
return; |
offset_x = png_get_int_32(buf); |
offset_y = png_get_int_32(buf + 4); |
unit_type = buf[8]; |
png_set_oFFs(png_ptr, info_ptr, offset_x, offset_y, unit_type); |
} |
#endif |
#if defined(PNG_READ_pCAL_SUPPORTED) |
/* read the pCAL chunk (described in the PNG Extensions document) */ |
void /* PRIVATE */ |
png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_charp purpose; |
png_int_32 X0, X1; |
png_byte type, nparams; |
png_charp buf, units, endptr; |
png_charpp params; |
png_size_t slength; |
int i; |
png_debug(1, "in png_handle_pCAL\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before pCAL"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid pCAL after IDAT"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL)) |
{ |
png_warning(png_ptr, "Duplicate pCAL chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
png_debug1(2, "Allocating and reading pCAL chunk data (%lu bytes)\n", |
length + 1); |
purpose = (png_charp)png_malloc_warn(png_ptr, length + 1); |
if (purpose == NULL) |
{ |
png_warning(png_ptr, "No memory for pCAL purpose."); |
return; |
} |
slength = (png_size_t)length; |
png_crc_read(png_ptr, (png_bytep)purpose, slength); |
if (png_crc_finish(png_ptr, 0)) |
{ |
png_free(png_ptr, purpose); |
return; |
} |
purpose[slength] = 0x00; /* null terminate the last string */ |
png_debug(3, "Finding end of pCAL purpose string\n"); |
for (buf = purpose; *buf; buf++) |
/* empty loop */ ; |
endptr = purpose + slength; |
/* We need to have at least 12 bytes after the purpose string |
in order to get the parameter information. */ |
if (endptr <= buf + 12) |
{ |
png_warning(png_ptr, "Invalid pCAL data"); |
png_free(png_ptr, purpose); |
return; |
} |
png_debug(3, "Reading pCAL X0, X1, type, nparams, and units\n"); |
X0 = png_get_int_32((png_bytep)buf+1); |
X1 = png_get_int_32((png_bytep)buf+5); |
type = buf[9]; |
nparams = buf[10]; |
units = buf + 11; |
png_debug(3, "Checking pCAL equation type and number of parameters\n"); |
/* Check that we have the right number of parameters for known |
equation types. */ |
if ((type == PNG_EQUATION_LINEAR && nparams != 2) || |
(type == PNG_EQUATION_BASE_E && nparams != 3) || |
(type == PNG_EQUATION_ARBITRARY && nparams != 3) || |
(type == PNG_EQUATION_HYPERBOLIC && nparams != 4)) |
{ |
png_warning(png_ptr, "Invalid pCAL parameters for equation type"); |
png_free(png_ptr, purpose); |
return; |
} |
else if (type >= PNG_EQUATION_LAST) |
{ |
png_warning(png_ptr, "Unrecognized equation type for pCAL chunk"); |
} |
for (buf = units; *buf; buf++) |
/* Empty loop to move past the units string. */ ; |
png_debug(3, "Allocating pCAL parameters array\n"); |
params = (png_charpp)png_malloc_warn(png_ptr, (png_uint_32)(nparams |
*sizeof(png_charp))) ; |
if (params == NULL) |
{ |
png_free(png_ptr, purpose); |
png_warning(png_ptr, "No memory for pCAL params."); |
return; |
} |
/* Get pointers to the start of each parameter string. */ |
for (i = 0; i < (int)nparams; i++) |
{ |
buf++; /* Skip the null string terminator from previous parameter. */ |
png_debug1(3, "Reading pCAL parameter %d\n", i); |
for (params[i] = buf; *buf != 0x00 && buf <= endptr; buf++) |
/* Empty loop to move past each parameter string */ ; |
/* Make sure we haven't run out of data yet */ |
if (buf > endptr) |
{ |
png_warning(png_ptr, "Invalid pCAL data"); |
png_free(png_ptr, purpose); |
png_free(png_ptr, params); |
return; |
} |
} |
png_set_pCAL(png_ptr, info_ptr, purpose, X0, X1, type, nparams, |
units, params); |
png_free(png_ptr, purpose); |
png_free(png_ptr, params); |
} |
#endif |
#if defined(PNG_READ_sCAL_SUPPORTED) |
/* read the sCAL chunk */ |
void /* PRIVATE */ |
png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_charp buffer, ep; |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
double width, height; |
png_charp vp; |
#else |
#ifdef PNG_FIXED_POINT_SUPPORTED |
png_charp swidth, sheight; |
#endif |
#endif |
png_size_t slength; |
png_debug(1, "in png_handle_sCAL\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before sCAL"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid sCAL after IDAT"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sCAL)) |
{ |
png_warning(png_ptr, "Duplicate sCAL chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
png_debug1(2, "Allocating and reading sCAL chunk data (%lu bytes)\n", |
length + 1); |
buffer = (png_charp)png_malloc_warn(png_ptr, length + 1); |
if (buffer == NULL) |
{ |
png_warning(png_ptr, "Out of memory while processing sCAL chunk"); |
return; |
} |
slength = (png_size_t)length; |
png_crc_read(png_ptr, (png_bytep)buffer, slength); |
if (png_crc_finish(png_ptr, 0)) |
{ |
png_free(png_ptr, buffer); |
return; |
} |
buffer[slength] = 0x00; /* null terminate the last string */ |
ep = buffer + 1; /* skip unit byte */ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
width = strtod(ep, &vp); |
if (*vp) |
{ |
png_warning(png_ptr, "malformed width string in sCAL chunk"); |
return; |
} |
#else |
#ifdef PNG_FIXED_POINT_SUPPORTED |
swidth = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1); |
if (swidth == NULL) |
{ |
png_warning(png_ptr, "Out of memory while processing sCAL chunk width"); |
return; |
} |
png_memcpy(swidth, ep, (png_size_t)png_strlen(ep)); |
#endif |
#endif |
for (ep = buffer; *ep; ep++) |
/* empty loop */ ; |
ep++; |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
height = strtod(ep, &vp); |
if (*vp) |
{ |
png_warning(png_ptr, "malformed height string in sCAL chunk"); |
return; |
} |
#else |
#ifdef PNG_FIXED_POINT_SUPPORTED |
sheight = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1); |
if (swidth == NULL) |
{ |
png_warning(png_ptr, "Out of memory while processing sCAL chunk height"); |
return; |
} |
png_memcpy(sheight, ep, (png_size_t)png_strlen(ep)); |
#endif |
#endif |
if (buffer + slength < ep |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
|| width <= 0. || height <= 0. |
#endif |
) |
{ |
png_warning(png_ptr, "Invalid sCAL data"); |
png_free(png_ptr, buffer); |
#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED) |
png_free(png_ptr, swidth); |
png_free(png_ptr, sheight); |
#endif |
return; |
} |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
png_set_sCAL(png_ptr, info_ptr, buffer[0], width, height); |
#else |
#ifdef PNG_FIXED_POINT_SUPPORTED |
png_set_sCAL_s(png_ptr, info_ptr, buffer[0], swidth, sheight); |
#endif |
#endif |
png_free(png_ptr, buffer); |
#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED) |
png_free(png_ptr, swidth); |
png_free(png_ptr, sheight); |
#endif |
} |
#endif |
#if defined(PNG_READ_tIME_SUPPORTED) |
void /* PRIVATE */ |
png_handle_tIME(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_byte buf[7]; |
png_time mod_time; |
png_debug(1, "in png_handle_tIME\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Out of place tIME chunk"); |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME)) |
{ |
png_warning(png_ptr, "Duplicate tIME chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
if (png_ptr->mode & PNG_HAVE_IDAT) |
png_ptr->mode |= PNG_AFTER_IDAT; |
if (length != 7) |
{ |
png_warning(png_ptr, "Incorrect tIME chunk length"); |
png_crc_finish(png_ptr, length); |
return; |
} |
png_crc_read(png_ptr, buf, 7); |
if (png_crc_finish(png_ptr, 0)) |
return; |
mod_time.second = buf[6]; |
mod_time.minute = buf[5]; |
mod_time.hour = buf[4]; |
mod_time.day = buf[3]; |
mod_time.month = buf[2]; |
mod_time.year = png_get_uint_16(buf); |
png_set_tIME(png_ptr, info_ptr, &mod_time); |
} |
#endif |
#if defined(PNG_READ_tEXt_SUPPORTED) |
/* Note: this does not properly handle chunks that are > 64K under DOS */ |
void /* PRIVATE */ |
png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_textp text_ptr; |
png_charp key; |
png_charp text; |
png_uint_32 skip = 0; |
png_size_t slength; |
int ret; |
png_debug(1, "in png_handle_tEXt\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before tEXt"); |
if (png_ptr->mode & PNG_HAVE_IDAT) |
png_ptr->mode |= PNG_AFTER_IDAT; |
#ifdef PNG_MAX_MALLOC_64K |
if (length > (png_uint_32)65535L) |
{ |
png_warning(png_ptr, "tEXt chunk too large to fit in memory"); |
skip = length - (png_uint_32)65535L; |
length = (png_uint_32)65535L; |
} |
#endif |
key = (png_charp)png_malloc_warn(png_ptr, length + 1); |
if (key == NULL) |
{ |
png_warning(png_ptr, "No memory to process text chunk."); |
return; |
} |
slength = (png_size_t)length; |
png_crc_read(png_ptr, (png_bytep)key, slength); |
if (png_crc_finish(png_ptr, skip)) |
{ |
png_free(png_ptr, key); |
return; |
} |
key[slength] = 0x00; |
for (text = key; *text; text++) |
/* empty loop to find end of key */ ; |
if (text != key + slength) |
text++; |
text_ptr = (png_textp)png_malloc_warn(png_ptr, (png_uint_32)sizeof(png_text)); |
if (text_ptr == NULL) |
{ |
png_warning(png_ptr, "Not enough memory to process text chunk."); |
png_free(png_ptr, key); |
return; |
} |
text_ptr->compression = PNG_TEXT_COMPRESSION_NONE; |
text_ptr->key = key; |
#ifdef PNG_iTXt_SUPPORTED |
text_ptr->lang = NULL; |
text_ptr->lang_key = NULL; |
text_ptr->itxt_length = 0; |
#endif |
text_ptr->text = text; |
text_ptr->text_length = png_strlen(text); |
ret=png_set_text_2(png_ptr, info_ptr, text_ptr, 1); |
png_free(png_ptr, key); |
png_free(png_ptr, text_ptr); |
if (ret) |
png_warning(png_ptr, "Insufficient memory to process text chunk."); |
} |
#endif |
#if defined(PNG_READ_zTXt_SUPPORTED) |
/* note: this does not correctly handle chunks that are > 64K under DOS */ |
void /* PRIVATE */ |
png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_textp text_ptr; |
png_charp chunkdata; |
png_charp text; |
int comp_type; |
int ret; |
png_size_t slength, prefix_len, data_len; |
png_debug(1, "in png_handle_zTXt\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before zTXt"); |
if (png_ptr->mode & PNG_HAVE_IDAT) |
png_ptr->mode |= PNG_AFTER_IDAT; |
#ifdef PNG_MAX_MALLOC_64K |
/* We will no doubt have problems with chunks even half this size, but |
there is no hard and fast rule to tell us where to stop. */ |
if (length > (png_uint_32)65535L) |
{ |
png_warning(png_ptr,"zTXt chunk too large to fit in memory"); |
png_crc_finish(png_ptr, length); |
return; |
} |
#endif |
chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1); |
if (chunkdata == NULL) |
{ |
png_warning(png_ptr,"Out of memory processing zTXt chunk."); |
return; |
} |
slength = (png_size_t)length; |
png_crc_read(png_ptr, (png_bytep)chunkdata, slength); |
if (png_crc_finish(png_ptr, 0)) |
{ |
png_free(png_ptr, chunkdata); |
return; |
} |
chunkdata[slength] = 0x00; |
for (text = chunkdata; *text; text++) |
/* empty loop */ ; |
/* zTXt must have some text after the chunkdataword */ |
if (text == chunkdata + slength) |
{ |
comp_type = PNG_TEXT_COMPRESSION_NONE; |
png_warning(png_ptr, "Zero length zTXt chunk"); |
} |
else |
{ |
comp_type = *(++text); |
if (comp_type != PNG_TEXT_COMPRESSION_zTXt) |
{ |
png_warning(png_ptr, "Unknown compression type in zTXt chunk"); |
comp_type = PNG_TEXT_COMPRESSION_zTXt; |
} |
text++; /* skip the compression_method byte */ |
} |
prefix_len = text - chunkdata; |
chunkdata = (png_charp)png_decompress_chunk(png_ptr, comp_type, chunkdata, |
(png_size_t)length, prefix_len, &data_len); |
text_ptr = (png_textp)png_malloc_warn(png_ptr, (png_uint_32)sizeof(png_text)); |
if (text_ptr == NULL) |
{ |
png_warning(png_ptr,"Not enough memory to process zTXt chunk."); |
png_free(png_ptr, chunkdata); |
return; |
} |
text_ptr->compression = comp_type; |
text_ptr->key = chunkdata; |
#ifdef PNG_iTXt_SUPPORTED |
text_ptr->lang = NULL; |
text_ptr->lang_key = NULL; |
text_ptr->itxt_length = 0; |
#endif |
text_ptr->text = chunkdata + prefix_len; |
text_ptr->text_length = data_len; |
ret=png_set_text_2(png_ptr, info_ptr, text_ptr, 1); |
png_free(png_ptr, text_ptr); |
png_free(png_ptr, chunkdata); |
if (ret) |
png_error(png_ptr, "Insufficient memory to store zTXt chunk."); |
} |
#endif |
#if defined(PNG_READ_iTXt_SUPPORTED) |
/* note: this does not correctly handle chunks that are > 64K under DOS */ |
void /* PRIVATE */ |
png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_textp text_ptr; |
png_charp chunkdata; |
png_charp key, lang, text, lang_key; |
int comp_flag; |
int comp_type = 0; |
int ret; |
png_size_t slength, prefix_len, data_len; |
png_debug(1, "in png_handle_iTXt\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before iTXt"); |
if (png_ptr->mode & PNG_HAVE_IDAT) |
png_ptr->mode |= PNG_AFTER_IDAT; |
#ifdef PNG_MAX_MALLOC_64K |
/* We will no doubt have problems with chunks even half this size, but |
there is no hard and fast rule to tell us where to stop. */ |
if (length > (png_uint_32)65535L) |
{ |
png_warning(png_ptr,"iTXt chunk too large to fit in memory"); |
png_crc_finish(png_ptr, length); |
return; |
} |
#endif |
chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1); |
if (chunkdata == NULL) |
{ |
png_warning(png_ptr, "No memory to process iTXt chunk."); |
return; |
} |
slength = (png_size_t)length; |
png_crc_read(png_ptr, (png_bytep)chunkdata, slength); |
if (png_crc_finish(png_ptr, 0)) |
{ |
png_free(png_ptr, chunkdata); |
return; |
} |
chunkdata[slength] = 0x00; |
for (lang = chunkdata; *lang; lang++) |
/* empty loop */ ; |
lang++; /* skip NUL separator */ |
/* iTXt must have a language tag (possibly empty), two compression bytes, |
translated keyword (possibly empty), and possibly some text after the |
keyword */ |
if (lang >= chunkdata + slength) |
{ |
comp_flag = PNG_TEXT_COMPRESSION_NONE; |
png_warning(png_ptr, "Zero length iTXt chunk"); |
} |
else |
{ |
comp_flag = *lang++; |
comp_type = *lang++; |
} |
for (lang_key = lang; *lang_key; lang_key++) |
/* empty loop */ ; |
lang_key++; /* skip NUL separator */ |
for (text = lang_key; *text; text++) |
/* empty loop */ ; |
text++; /* skip NUL separator */ |
prefix_len = text - chunkdata; |
key=chunkdata; |
if (comp_flag) |
chunkdata = png_decompress_chunk(png_ptr, comp_type, chunkdata, |
(size_t)length, prefix_len, &data_len); |
else |
data_len=png_strlen(chunkdata + prefix_len); |
text_ptr = (png_textp)png_malloc_warn(png_ptr, (png_uint_32)sizeof(png_text)); |
if (text_ptr == NULL) |
{ |
png_warning(png_ptr,"Not enough memory to process iTXt chunk."); |
png_free(png_ptr, chunkdata); |
return; |
} |
text_ptr->compression = (int)comp_flag + 1; |
text_ptr->lang_key = chunkdata+(lang_key-key); |
text_ptr->lang = chunkdata+(lang-key); |
text_ptr->itxt_length = data_len; |
text_ptr->text_length = 0; |
text_ptr->key = chunkdata; |
text_ptr->text = chunkdata + prefix_len; |
ret=png_set_text_2(png_ptr, info_ptr, text_ptr, 1); |
png_free(png_ptr, text_ptr); |
png_free(png_ptr, chunkdata); |
if (ret) |
png_error(png_ptr, "Insufficient memory to store iTXt chunk."); |
} |
#endif |
/* This function is called when we haven't found a handler for a |
chunk. If there isn't a problem with the chunk itself (ie bad |
chunk name, CRC, or a critical chunk), the chunk is silently ignored |
-- unless the PNG_FLAG_UNKNOWN_CHUNKS_SUPPORTED flag is on in which |
case it will be saved away to be written out later. */ |
void /* PRIVATE */ |
png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_uint_32 skip = 0; |
png_debug(1, "in png_handle_unknown\n"); |
if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_IDAT; |
#endif |
if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) /* not an IDAT */ |
png_ptr->mode |= PNG_AFTER_IDAT; |
} |
png_check_chunk_name(png_ptr, png_ptr->chunk_name); |
if (!(png_ptr->chunk_name[0] & 0x20)) |
{ |
#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) |
if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) != |
HANDLE_CHUNK_ALWAYS |
#if defined(PNG_READ_USER_CHUNKS_SUPPORTED) |
&& png_ptr->read_user_chunk_fn == NULL |
#endif |
) |
#endif |
png_chunk_error(png_ptr, "unknown critical chunk"); |
} |
#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) |
if (png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS) |
{ |
png_unknown_chunk chunk; |
#ifdef PNG_MAX_MALLOC_64K |
if (length > (png_uint_32)65535L) |
{ |
png_warning(png_ptr, "unknown chunk too large to fit in memory"); |
skip = length - (png_uint_32)65535L; |
length = (png_uint_32)65535L; |
} |
#endif |
png_strcpy((png_charp)chunk.name, (png_charp)png_ptr->chunk_name); |
chunk.data = (png_bytep)png_malloc(png_ptr, length); |
chunk.size = (png_size_t)length; |
png_crc_read(png_ptr, (png_bytep)chunk.data, length); |
#if defined(PNG_READ_USER_CHUNKS_SUPPORTED) |
if(png_ptr->read_user_chunk_fn != NULL) |
{ |
/* callback to user unknown chunk handler */ |
if ((*(png_ptr->read_user_chunk_fn)) (png_ptr, &chunk) <= 0) |
{ |
if (!(png_ptr->chunk_name[0] & 0x20)) |
if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) != |
HANDLE_CHUNK_ALWAYS) |
{ |
png_free(png_ptr, chunk.data); |
png_chunk_error(png_ptr, "unknown critical chunk"); |
} |
png_set_unknown_chunks(png_ptr, info_ptr, &chunk, 1); |
} |
} |
else |
#endif |
png_set_unknown_chunks(png_ptr, info_ptr, &chunk, 1); |
png_free(png_ptr, chunk.data); |
} |
else |
#endif |
skip = length; |
png_crc_finish(png_ptr, skip); |
#if !defined(PNG_READ_USER_CHUNKS_SUPPORTED) |
info_ptr = info_ptr; /* quiet compiler warnings about unused info_ptr */ |
#endif |
} |
/* This function is called to verify that a chunk name is valid. |
This function can't have the "critical chunk check" incorporated |
into it, since in the future we will need to be able to call user |
functions to handle unknown critical chunks after we check that |
the chunk name itself is valid. */ |
#define isnonalpha(c) ((c) < 41 || (c) > 122 || ((c) > 90 && (c) < 97)) |
void /* PRIVATE */ |
png_check_chunk_name(png_structp png_ptr, png_bytep chunk_name) |
{ |
png_debug(1, "in png_check_chunk_name\n"); |
if (isnonalpha(chunk_name[0]) || isnonalpha(chunk_name[1]) || |
isnonalpha(chunk_name[2]) || isnonalpha(chunk_name[3])) |
{ |
png_chunk_error(png_ptr, "invalid chunk type"); |
} |
} |
/* Combines the row recently read in with the existing pixels in the |
row. This routine takes care of alpha and transparency if requested. |
This routine also handles the two methods of progressive display |
of interlaced images, depending on the mask value. |
The mask value describes which pixels are to be combined with |
the row. The pattern always repeats every 8 pixels, so just 8 |
bits are needed. A one indicates the pixel is to be combined, |
a zero indicates the pixel is to be skipped. This is in addition |
to any alpha or transparency value associated with the pixel. If |
you want all pixels to be combined, pass 0xff (255) in mask. */ |
#ifndef PNG_HAVE_ASSEMBLER_COMBINE_ROW |
void /* PRIVATE */ |
png_combine_row(png_structp png_ptr, png_bytep row, int mask) |
{ |
png_debug(1,"in png_combine_row\n"); |
if (mask == 0xff) |
{ |
png_memcpy(row, png_ptr->row_buf + 1, |
(png_size_t)((png_ptr->width * |
png_ptr->row_info.pixel_depth + 7) >> 3)); |
} |
else |
{ |
switch (png_ptr->row_info.pixel_depth) |
{ |
case 1: |
{ |
png_bytep sp = png_ptr->row_buf + 1; |
png_bytep dp = row; |
int s_inc, s_start, s_end; |
int m = 0x80; |
int shift; |
png_uint_32 i; |
png_uint_32 row_width = png_ptr->width; |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_PACKSWAP) |
{ |
s_start = 0; |
s_end = 7; |
s_inc = 1; |
} |
else |
#endif |
{ |
s_start = 7; |
s_end = 0; |
s_inc = -1; |
} |
shift = s_start; |
for (i = 0; i < row_width; i++) |
{ |
if (m & mask) |
{ |
int value; |
value = (*sp >> shift) & 0x01; |
*dp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff); |
*dp |= (png_byte)(value << shift); |
} |
if (shift == s_end) |
{ |
shift = s_start; |
sp++; |
dp++; |
} |
else |
shift += s_inc; |
if (m == 1) |
m = 0x80; |
else |
m >>= 1; |
} |
break; |
} |
case 2: |
{ |
png_bytep sp = png_ptr->row_buf + 1; |
png_bytep dp = row; |
int s_start, s_end, s_inc; |
int m = 0x80; |
int shift; |
png_uint_32 i; |
png_uint_32 row_width = png_ptr->width; |
int value; |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_PACKSWAP) |
{ |
s_start = 0; |
s_end = 6; |
s_inc = 2; |
} |
else |
#endif |
{ |
s_start = 6; |
s_end = 0; |
s_inc = -2; |
} |
shift = s_start; |
for (i = 0; i < row_width; i++) |
{ |
if (m & mask) |
{ |
value = (*sp >> shift) & 0x03; |
*dp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); |
*dp |= (png_byte)(value << shift); |
} |
if (shift == s_end) |
{ |
shift = s_start; |
sp++; |
dp++; |
} |
else |
shift += s_inc; |
if (m == 1) |
m = 0x80; |
else |
m >>= 1; |
} |
break; |
} |
case 4: |
{ |
png_bytep sp = png_ptr->row_buf + 1; |
png_bytep dp = row; |
int s_start, s_end, s_inc; |
int m = 0x80; |
int shift; |
png_uint_32 i; |
png_uint_32 row_width = png_ptr->width; |
int value; |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_PACKSWAP) |
{ |
s_start = 0; |
s_end = 4; |
s_inc = 4; |
} |
else |
#endif |
{ |
s_start = 4; |
s_end = 0; |
s_inc = -4; |
} |
shift = s_start; |
for (i = 0; i < row_width; i++) |
{ |
if (m & mask) |
{ |
value = (*sp >> shift) & 0xf; |
*dp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); |
*dp |= (png_byte)(value << shift); |
} |
if (shift == s_end) |
{ |
shift = s_start; |
sp++; |
dp++; |
} |
else |
shift += s_inc; |
if (m == 1) |
m = 0x80; |
else |
m >>= 1; |
} |
break; |
} |
default: |
{ |
png_bytep sp = png_ptr->row_buf + 1; |
png_bytep dp = row; |
png_size_t pixel_bytes = (png_ptr->row_info.pixel_depth >> 3); |
png_uint_32 i; |
png_uint_32 row_width = png_ptr->width; |
png_byte m = 0x80; |
for (i = 0; i < row_width; i++) |
{ |
if (m & mask) |
{ |
png_memcpy(dp, sp, pixel_bytes); |
} |
sp += pixel_bytes; |
dp += pixel_bytes; |
if (m == 1) |
m = 0x80; |
else |
m >>= 1; |
} |
break; |
} |
} |
} |
} |
#endif /* !PNG_HAVE_ASSEMBLER_COMBINE_ROW */ |
#ifdef PNG_READ_INTERLACING_SUPPORTED |
#ifndef PNG_HAVE_ASSEMBLER_READ_INTERLACE /* else in pngvcrd.c, pnggccrd.c */ |
/* OLD pre-1.0.9 interface: |
void png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass, |
png_uint_32 transformations) |
*/ |
void /* PRIVATE */ |
png_do_read_interlace(png_structp png_ptr) |
{ |
png_row_infop row_info = &(png_ptr->row_info); |
png_bytep row = png_ptr->row_buf + 1; |
int pass = png_ptr->pass; |
png_uint_32 transformations = png_ptr->transformations; |
#ifdef PNG_USE_LOCAL_ARRAYS |
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
/* offset to next interlace block */ |
const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
#endif |
png_debug(1,"in png_do_read_interlace (stock C version)\n"); |
if (row != NULL && row_info != NULL) |
{ |
png_uint_32 final_width; |
final_width = row_info->width * png_pass_inc[pass]; |
switch (row_info->pixel_depth) |
{ |
case 1: |
{ |
png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 3); |
png_bytep dp = row + (png_size_t)((final_width - 1) >> 3); |
int sshift, dshift; |
int s_start, s_end, s_inc; |
int jstop = png_pass_inc[pass]; |
png_byte v; |
png_uint_32 i; |
int j; |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (transformations & PNG_PACKSWAP) |
{ |
sshift = (int)((row_info->width + 7) & 0x07); |
dshift = (int)((final_width + 7) & 0x07); |
s_start = 7; |
s_end = 0; |
s_inc = -1; |
} |
else |
#endif |
{ |
sshift = 7 - (int)((row_info->width + 7) & 0x07); |
dshift = 7 - (int)((final_width + 7) & 0x07); |
s_start = 0; |
s_end = 7; |
s_inc = 1; |
} |
for (i = 0; i < row_info->width; i++) |
{ |
v = (png_byte)((*sp >> sshift) & 0x01); |
for (j = 0; j < jstop; j++) |
{ |
*dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff); |
*dp |= (png_byte)(v << dshift); |
if (dshift == s_end) |
{ |
dshift = s_start; |
dp--; |
} |
else |
dshift += s_inc; |
} |
if (sshift == s_end) |
{ |
sshift = s_start; |
sp--; |
} |
else |
sshift += s_inc; |
} |
break; |
} |
case 2: |
{ |
png_bytep sp = row + (png_uint_32)((row_info->width - 1) >> 2); |
png_bytep dp = row + (png_uint_32)((final_width - 1) >> 2); |
int sshift, dshift; |
int s_start, s_end, s_inc; |
int jstop = png_pass_inc[pass]; |
png_uint_32 i; |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (transformations & PNG_PACKSWAP) |
{ |
sshift = (int)(((row_info->width + 3) & 0x03) << 1); |
dshift = (int)(((final_width + 3) & 0x03) << 1); |
s_start = 6; |
s_end = 0; |
s_inc = -2; |
} |
else |
#endif |
{ |
sshift = (int)((3 - ((row_info->width + 3) & 0x03)) << 1); |
dshift = (int)((3 - ((final_width + 3) & 0x03)) << 1); |
s_start = 0; |
s_end = 6; |
s_inc = 2; |
} |
for (i = 0; i < row_info->width; i++) |
{ |
png_byte v; |
int j; |
v = (png_byte)((*sp >> sshift) & 0x03); |
for (j = 0; j < jstop; j++) |
{ |
*dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff); |
*dp |= (png_byte)(v << dshift); |
if (dshift == s_end) |
{ |
dshift = s_start; |
dp--; |
} |
else |
dshift += s_inc; |
} |
if (sshift == s_end) |
{ |
sshift = s_start; |
sp--; |
} |
else |
sshift += s_inc; |
} |
break; |
} |
case 4: |
{ |
png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 1); |
png_bytep dp = row + (png_size_t)((final_width - 1) >> 1); |
int sshift, dshift; |
int s_start, s_end, s_inc; |
png_uint_32 i; |
int jstop = png_pass_inc[pass]; |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (transformations & PNG_PACKSWAP) |
{ |
sshift = (int)(((row_info->width + 1) & 0x01) << 2); |
dshift = (int)(((final_width + 1) & 0x01) << 2); |
s_start = 4; |
s_end = 0; |
s_inc = -4; |
} |
else |
#endif |
{ |
sshift = (int)((1 - ((row_info->width + 1) & 0x01)) << 2); |
dshift = (int)((1 - ((final_width + 1) & 0x01)) << 2); |
s_start = 0; |
s_end = 4; |
s_inc = 4; |
} |
for (i = 0; i < row_info->width; i++) |
{ |
png_byte v = (png_byte)((*sp >> sshift) & 0xf); |
int j; |
for (j = 0; j < jstop; j++) |
{ |
*dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff); |
*dp |= (png_byte)(v << dshift); |
if (dshift == s_end) |
{ |
dshift = s_start; |
dp--; |
} |
else |
dshift += s_inc; |
} |
if (sshift == s_end) |
{ |
sshift = s_start; |
sp--; |
} |
else |
sshift += s_inc; |
} |
break; |
} |
default: |
{ |
png_size_t pixel_bytes = (row_info->pixel_depth >> 3); |
png_bytep sp = row + (png_size_t)(row_info->width - 1) * pixel_bytes; |
png_bytep dp = row + (png_size_t)(final_width - 1) * pixel_bytes; |
int jstop = png_pass_inc[pass]; |
png_uint_32 i; |
for (i = 0; i < row_info->width; i++) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sp, pixel_bytes); |
for (j = 0; j < jstop; j++) |
{ |
png_memcpy(dp, v, pixel_bytes); |
dp -= pixel_bytes; |
} |
sp -= pixel_bytes; |
} |
break; |
} |
} |
row_info->width = final_width; |
row_info->rowbytes = ((final_width * |
(png_uint_32)row_info->pixel_depth + 7) >> 3); |
} |
#if !defined(PNG_READ_PACKSWAP_SUPPORTED) |
transformations = transformations; /* silence compiler warning */ |
#endif |
} |
#endif /* !PNG_HAVE_ASSEMBLER_READ_INTERLACE */ |
#endif /* PNG_READ_INTERLACING_SUPPORTED */ |
#ifndef PNG_HAVE_ASSEMBLER_READ_FILTER_ROW |
void /* PRIVATE */ |
png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row, |
png_bytep prev_row, int filter) |
{ |
png_debug(1, "in png_read_filter_row\n"); |
png_debug2(2,"row = %lu, filter = %d\n", png_ptr->row_number, filter); |
switch (filter) |
{ |
case PNG_FILTER_VALUE_NONE: |
break; |
case PNG_FILTER_VALUE_SUB: |
{ |
png_uint_32 i; |
png_uint_32 istop = row_info->rowbytes; |
png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; |
png_bytep rp = row + bpp; |
png_bytep lp = row; |
for (i = bpp; i < istop; i++) |
{ |
*rp = (png_byte)(((int)(*rp) + (int)(*lp++)) & 0xff); |
rp++; |
} |
break; |
} |
case PNG_FILTER_VALUE_UP: |
{ |
png_uint_32 i; |
png_uint_32 istop = row_info->rowbytes; |
png_bytep rp = row; |
png_bytep pp = prev_row; |
for (i = 0; i < istop; i++) |
{ |
*rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); |
rp++; |
} |
break; |
} |
case PNG_FILTER_VALUE_AVG: |
{ |
png_uint_32 i; |
png_bytep rp = row; |
png_bytep pp = prev_row; |
png_bytep lp = row; |
png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; |
png_uint_32 istop = row_info->rowbytes - bpp; |
for (i = 0; i < bpp; i++) |
{ |
*rp = (png_byte)(((int)(*rp) + |
((int)(*pp++) / 2 )) & 0xff); |
rp++; |
} |
for (i = 0; i < istop; i++) |
{ |
*rp = (png_byte)(((int)(*rp) + |
(int)(*pp++ + *lp++) / 2 ) & 0xff); |
rp++; |
} |
break; |
} |
case PNG_FILTER_VALUE_PAETH: |
{ |
png_uint_32 i; |
png_bytep rp = row; |
png_bytep pp = prev_row; |
png_bytep lp = row; |
png_bytep cp = prev_row; |
png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; |
png_uint_32 istop=row_info->rowbytes - bpp; |
for (i = 0; i < bpp; i++) |
{ |
*rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); |
rp++; |
} |
for (i = 0; i < istop; i++) /* use leftover rp,pp */ |
{ |
int a, b, c, pa, pb, pc, p; |
a = *lp++; |
b = *pp++; |
c = *cp++; |
p = b - c; |
pc = a - c; |
#ifdef PNG_USE_ABS |
pa = abs(p); |
pb = abs(pc); |
pc = abs(p + pc); |
#else |
pa = p < 0 ? -p : p; |
pb = pc < 0 ? -pc : pc; |
pc = (p + pc) < 0 ? -(p + pc) : p + pc; |
#endif |
/* |
if (pa <= pb && pa <= pc) |
p = a; |
else if (pb <= pc) |
p = b; |
else |
p = c; |
*/ |
p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c; |
*rp = (png_byte)(((int)(*rp) + p) & 0xff); |
rp++; |
} |
break; |
} |
default: |
png_warning(png_ptr, "Ignoring bad adaptive filter type"); |
*row=0; |
break; |
} |
} |
#endif /* !PNG_HAVE_ASSEMBLER_READ_FILTER_ROW */ |
void /* PRIVATE */ |
png_read_finish_row(png_structp png_ptr) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
/* start of interlace block */ |
const int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; |
/* offset to next interlace block */ |
const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
/* start of interlace block in the y direction */ |
const int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; |
/* offset to next interlace block in the y direction */ |
const int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; |
#endif |
png_debug(1, "in png_read_finish_row\n"); |
png_ptr->row_number++; |
if (png_ptr->row_number < png_ptr->num_rows) |
return; |
if (png_ptr->interlaced) |
{ |
png_ptr->row_number = 0; |
png_memset_check(png_ptr, png_ptr->prev_row, 0, png_ptr->rowbytes + 1); |
do |
{ |
png_ptr->pass++; |
if (png_ptr->pass >= 7) |
break; |
png_ptr->iwidth = (png_ptr->width + |
png_pass_inc[png_ptr->pass] - 1 - |
png_pass_start[png_ptr->pass]) / |
png_pass_inc[png_ptr->pass]; |
png_ptr->irowbytes = ((png_ptr->iwidth * |
(png_uint_32)png_ptr->pixel_depth + 7) >> 3) +1; |
if (!(png_ptr->transformations & PNG_INTERLACE)) |
{ |
png_ptr->num_rows = (png_ptr->height + |
png_pass_yinc[png_ptr->pass] - 1 - |
png_pass_ystart[png_ptr->pass]) / |
png_pass_yinc[png_ptr->pass]; |
if (!(png_ptr->num_rows)) |
continue; |
} |
else /* if (png_ptr->transformations & PNG_INTERLACE) */ |
break; |
} while (png_ptr->iwidth == 0); |
if (png_ptr->pass < 7) |
return; |
} |
if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED)) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_IDAT; |
#endif |
char extra; |
int ret; |
png_ptr->zstream.next_out = (Byte *)&extra; |
png_ptr->zstream.avail_out = (uInt)1; |
for(;;) |
{ |
if (!(png_ptr->zstream.avail_in)) |
{ |
while (!png_ptr->idat_size) |
{ |
png_byte chunk_length[4]; |
png_crc_finish(png_ptr, 0); |
png_read_data(png_ptr, chunk_length, 4); |
png_ptr->idat_size = png_get_uint_32(chunk_length); |
png_reset_crc(png_ptr); |
png_crc_read(png_ptr, png_ptr->chunk_name, 4); |
if (png_memcmp(png_ptr->chunk_name, (png_bytep)png_IDAT, 4)) |
png_error(png_ptr, "Not enough image data"); |
} |
png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size; |
png_ptr->zstream.next_in = png_ptr->zbuf; |
if (png_ptr->zbuf_size > png_ptr->idat_size) |
png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size; |
png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zstream.avail_in); |
png_ptr->idat_size -= png_ptr->zstream.avail_in; |
} |
ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); |
if (ret == Z_STREAM_END) |
{ |
if (!(png_ptr->zstream.avail_out) || png_ptr->zstream.avail_in || |
png_ptr->idat_size) |
png_warning(png_ptr, "Extra compressed data"); |
png_ptr->mode |= PNG_AFTER_IDAT; |
png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; |
break; |
} |
if (ret != Z_OK) |
png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg : |
"Decompression Error"); |
if (!(png_ptr->zstream.avail_out)) |
{ |
png_warning(png_ptr, "Extra compressed data."); |
png_ptr->mode |= PNG_AFTER_IDAT; |
png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; |
break; |
} |
} |
png_ptr->zstream.avail_out = 0; |
} |
if (png_ptr->idat_size || png_ptr->zstream.avail_in) |
png_warning(png_ptr, "Extra compression data"); |
inflateReset(&png_ptr->zstream); |
png_ptr->mode |= PNG_AFTER_IDAT; |
} |
void /* PRIVATE */ |
png_read_start_row(png_structp png_ptr) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
/* start of interlace block */ |
const int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; |
/* offset to next interlace block */ |
const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
/* start of interlace block in the y direction */ |
const int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; |
/* offset to next interlace block in the y direction */ |
const int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; |
#endif |
int max_pixel_depth; |
png_uint_32 row_bytes; |
png_debug(1, "in png_read_start_row\n"); |
png_ptr->zstream.avail_in = 0; |
png_init_read_transformations(png_ptr); |
if (png_ptr->interlaced) |
{ |
if (!(png_ptr->transformations & PNG_INTERLACE)) |
png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 - |
png_pass_ystart[0]) / png_pass_yinc[0]; |
else |
png_ptr->num_rows = png_ptr->height; |
png_ptr->iwidth = (png_ptr->width + |
png_pass_inc[png_ptr->pass] - 1 - |
png_pass_start[png_ptr->pass]) / |
png_pass_inc[png_ptr->pass]; |
row_bytes = ((png_ptr->iwidth * |
(png_uint_32)png_ptr->pixel_depth + 7) >> 3) +1; |
png_ptr->irowbytes = (png_size_t)row_bytes; |
if((png_uint_32)png_ptr->irowbytes != row_bytes) |
png_error(png_ptr, "Rowbytes overflow in png_read_start_row"); |
} |
else |
{ |
png_ptr->num_rows = png_ptr->height; |
png_ptr->iwidth = png_ptr->width; |
png_ptr->irowbytes = png_ptr->rowbytes + 1; |
} |
max_pixel_depth = png_ptr->pixel_depth; |
#if defined(PNG_READ_PACK_SUPPORTED) |
if ((png_ptr->transformations & PNG_PACK) && png_ptr->bit_depth < 8) |
max_pixel_depth = 8; |
#endif |
#if defined(PNG_READ_EXPAND_SUPPORTED) |
if (png_ptr->transformations & PNG_EXPAND) |
{ |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
if (png_ptr->num_trans) |
max_pixel_depth = 32; |
else |
max_pixel_depth = 24; |
} |
else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY) |
{ |
if (max_pixel_depth < 8) |
max_pixel_depth = 8; |
if (png_ptr->num_trans) |
max_pixel_depth *= 2; |
} |
else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB) |
{ |
if (png_ptr->num_trans) |
{ |
max_pixel_depth *= 4; |
max_pixel_depth /= 3; |
} |
} |
} |
#endif |
#if defined(PNG_READ_FILLER_SUPPORTED) |
if (png_ptr->transformations & (PNG_FILLER)) |
{ |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
max_pixel_depth = 32; |
else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY) |
{ |
if (max_pixel_depth <= 8) |
max_pixel_depth = 16; |
else |
max_pixel_depth = 32; |
} |
else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB) |
{ |
if (max_pixel_depth <= 32) |
max_pixel_depth = 32; |
else |
max_pixel_depth = 64; |
} |
} |
#endif |
#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) |
if (png_ptr->transformations & PNG_GRAY_TO_RGB) |
{ |
if ( |
#if defined(PNG_READ_EXPAND_SUPPORTED) |
(png_ptr->num_trans && (png_ptr->transformations & PNG_EXPAND)) || |
#endif |
#if defined(PNG_READ_FILLER_SUPPORTED) |
(png_ptr->transformations & (PNG_FILLER)) || |
#endif |
png_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) |
{ |
if (max_pixel_depth <= 16) |
max_pixel_depth = 32; |
else |
max_pixel_depth = 64; |
} |
else |
{ |
if (max_pixel_depth <= 8) |
{ |
if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
max_pixel_depth = 32; |
else |
max_pixel_depth = 24; |
} |
else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
max_pixel_depth = 64; |
else |
max_pixel_depth = 48; |
} |
} |
#endif |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) && \ |
defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) |
if(png_ptr->transformations & PNG_USER_TRANSFORM) |
{ |
int user_pixel_depth=png_ptr->user_transform_depth* |
png_ptr->user_transform_channels; |
if(user_pixel_depth > max_pixel_depth) |
max_pixel_depth=user_pixel_depth; |
} |
#endif |
/* align the width on the next larger 8 pixels. Mainly used |
for interlacing */ |
row_bytes = ((png_ptr->width + 7) & ~((png_uint_32)7)); |
/* calculate the maximum bytes needed, adding a byte and a pixel |
for safety's sake */ |
row_bytes = ((row_bytes * (png_uint_32)max_pixel_depth + 7) >> 3) + |
1 + ((max_pixel_depth + 7) >> 3); |
#ifdef PNG_MAX_MALLOC_64K |
if (row_bytes > (png_uint_32)65536L) |
png_error(png_ptr, "This image requires a row greater than 64KB"); |
#endif |
png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr, row_bytes+64); |
png_ptr->row_buf = png_ptr->big_row_buf+32; |
#if defined(PNG_DEBUG) && defined(PNG_USE_PNGGCCRD) |
png_ptr->row_buf_size = row_bytes; |
#endif |
#ifdef PNG_MAX_MALLOC_64K |
if ((png_uint_32)png_ptr->rowbytes + 1 > (png_uint_32)65536L) |
png_error(png_ptr, "This image requires a row greater than 64KB"); |
#endif |
png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)( |
png_ptr->rowbytes + 1)); |
png_memset_check(png_ptr, png_ptr->prev_row, 0, png_ptr->rowbytes + 1); |
png_debug1(3, "width = %lu,\n", png_ptr->width); |
png_debug1(3, "height = %lu,\n", png_ptr->height); |
png_debug1(3, "iwidth = %lu,\n", png_ptr->iwidth); |
png_debug1(3, "num_rows = %lu\n", png_ptr->num_rows); |
png_debug1(3, "rowbytes = %lu,\n", png_ptr->rowbytes); |
png_debug1(3, "irowbytes = %lu,\n", png_ptr->irowbytes); |
png_ptr->flags |= PNG_FLAG_ROW_INIT; |
} |
/shark/trunk/ports/png/pngwutil.c |
---|
0,0 → 1,2675 |
/* pngwutil.c - utilities to write a PNG file |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
*/ |
#define PNG_INTERNAL |
#include "png.h" |
#ifdef PNG_WRITE_SUPPORTED |
/* Place a 32-bit number into a buffer in PNG byte order. We work |
* with unsigned numbers for convenience, although one supported |
* ancillary chunk uses signed (two's complement) numbers. |
*/ |
void /* PRIVATE */ |
png_save_uint_32(png_bytep buf, png_uint_32 i) |
{ |
buf[0] = (png_byte)((i >> 24) & 0xff); |
buf[1] = (png_byte)((i >> 16) & 0xff); |
buf[2] = (png_byte)((i >> 8) & 0xff); |
buf[3] = (png_byte)(i & 0xff); |
} |
#if defined(PNG_WRITE_pCAL_SUPPORTED) || defined(PNG_WRITE_oFFs_SUPPORTED) |
/* The png_save_int_32 function assumes integers are stored in two's |
* complement format. If this isn't the case, then this routine needs to |
* be modified to write data in two's complement format. |
*/ |
void /* PRIVATE */ |
png_save_int_32(png_bytep buf, png_int_32 i) |
{ |
buf[0] = (png_byte)((i >> 24) & 0xff); |
buf[1] = (png_byte)((i >> 16) & 0xff); |
buf[2] = (png_byte)((i >> 8) & 0xff); |
buf[3] = (png_byte)(i & 0xff); |
} |
#endif |
/* Place a 16-bit number into a buffer in PNG byte order. |
* The parameter is declared unsigned int, not png_uint_16, |
* just to avoid potential problems on pre-ANSI C compilers. |
*/ |
void /* PRIVATE */ |
png_save_uint_16(png_bytep buf, unsigned int i) |
{ |
buf[0] = (png_byte)((i >> 8) & 0xff); |
buf[1] = (png_byte)(i & 0xff); |
} |
/* Write a PNG chunk all at once. The type is an array of ASCII characters |
* representing the chunk name. The array must be at least 4 bytes in |
* length, and does not need to be null terminated. To be safe, pass the |
* pre-defined chunk names here, and if you need a new one, define it |
* where the others are defined. The length is the length of the data. |
* All the data must be present. If that is not possible, use the |
* png_write_chunk_start(), png_write_chunk_data(), and png_write_chunk_end() |
* functions instead. |
*/ |
void PNGAPI |
png_write_chunk(png_structp png_ptr, png_bytep chunk_name, |
png_bytep data, png_size_t length) |
{ |
png_write_chunk_start(png_ptr, chunk_name, (png_uint_32)length); |
png_write_chunk_data(png_ptr, data, length); |
png_write_chunk_end(png_ptr); |
} |
/* Write the start of a PNG chunk. The type is the chunk type. |
* The total_length is the sum of the lengths of all the data you will be |
* passing in png_write_chunk_data(). |
*/ |
void PNGAPI |
png_write_chunk_start(png_structp png_ptr, png_bytep chunk_name, |
png_uint_32 length) |
{ |
png_byte buf[4]; |
png_debug2(0, "Writing %s chunk (%lu bytes)\n", chunk_name, length); |
/* write the length */ |
png_save_uint_32(buf, length); |
png_write_data(png_ptr, buf, (png_size_t)4); |
/* write the chunk name */ |
png_write_data(png_ptr, chunk_name, (png_size_t)4); |
/* reset the crc and run it over the chunk name */ |
png_reset_crc(png_ptr); |
png_calculate_crc(png_ptr, chunk_name, (png_size_t)4); |
} |
/* Write the data of a PNG chunk started with png_write_chunk_start(). |
* Note that multiple calls to this function are allowed, and that the |
* sum of the lengths from these calls *must* add up to the total_length |
* given to png_write_chunk_start(). |
*/ |
void PNGAPI |
png_write_chunk_data(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
/* write the data, and run the CRC over it */ |
if (data != NULL && length > 0) |
{ |
png_calculate_crc(png_ptr, data, length); |
png_write_data(png_ptr, data, length); |
} |
} |
/* Finish a chunk started with png_write_chunk_start(). */ |
void PNGAPI |
png_write_chunk_end(png_structp png_ptr) |
{ |
png_byte buf[4]; |
/* write the crc */ |
png_save_uint_32(buf, png_ptr->crc); |
png_write_data(png_ptr, buf, (png_size_t)4); |
} |
/* Simple function to write the signature. If we have already written |
* the magic bytes of the signature, or more likely, the PNG stream is |
* being embedded into another stream and doesn't need its own signature, |
* we should call png_set_sig_bytes() to tell libpng how many of the |
* bytes have already been written. |
*/ |
void /* PRIVATE */ |
png_write_sig(png_structp png_ptr) |
{ |
png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10}; |
/* write the rest of the 8 byte signature */ |
png_write_data(png_ptr, &png_signature[png_ptr->sig_bytes], |
(png_size_t)8 - png_ptr->sig_bytes); |
if(png_ptr->sig_bytes < 3) |
png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE; |
} |
#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_iCCP_SUPPORTED) |
/* |
* This pair of functions encapsulates the operation of (a) compressing a |
* text string, and (b) issuing it later as a series of chunk data writes. |
* The compression_state structure is shared context for these functions |
* set up by the caller in order to make the whole mess thread-safe. |
*/ |
typedef struct |
{ |
char *input; /* the uncompressed input data */ |
int input_len; /* its length */ |
int num_output_ptr; /* number of output pointers used */ |
int max_output_ptr; /* size of output_ptr */ |
png_charpp output_ptr; /* array of pointers to output */ |
} compression_state; |
/* compress given text into storage in the png_ptr structure */ |
static int /* PRIVATE */ |
png_text_compress(png_structp png_ptr, |
png_charp text, png_size_t text_len, int compression, |
compression_state *comp) |
{ |
int ret; |
comp->num_output_ptr = comp->max_output_ptr = 0; |
comp->output_ptr = NULL; |
comp->input = NULL; |
/* we may just want to pass the text right through */ |
if (compression == PNG_TEXT_COMPRESSION_NONE) |
{ |
comp->input = text; |
comp->input_len = text_len; |
return((int)text_len); |
} |
if (compression >= PNG_TEXT_COMPRESSION_LAST) |
{ |
#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) |
char msg[50]; |
sprintf(msg, "Unknown compression type %d", compression); |
png_warning(png_ptr, msg); |
#else |
png_warning(png_ptr, "Unknown compression type"); |
#endif |
} |
/* We can't write the chunk until we find out how much data we have, |
* which means we need to run the compressor first and save the |
* output. This shouldn't be a problem, as the vast majority of |
* comments should be reasonable, but we will set up an array of |
* malloc'd pointers to be sure. |
* |
* If we knew the application was well behaved, we could simplify this |
* greatly by assuming we can always malloc an output buffer large |
* enough to hold the compressed text ((1001 * text_len / 1000) + 12) |
* and malloc this directly. The only time this would be a bad idea is |
* if we can't malloc more than 64K and we have 64K of random input |
* data, or if the input string is incredibly large (although this |
* wouldn't cause a failure, just a slowdown due to swapping). |
*/ |
/* set up the compression buffers */ |
png_ptr->zstream.avail_in = (uInt)text_len; |
png_ptr->zstream.next_in = (Bytef *)text; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
png_ptr->zstream.next_out = (Bytef *)png_ptr->zbuf; |
/* this is the same compression loop as in png_write_row() */ |
do |
{ |
/* compress the data */ |
ret = deflate(&png_ptr->zstream, Z_NO_FLUSH); |
if (ret != Z_OK) |
{ |
/* error */ |
if (png_ptr->zstream.msg != NULL) |
png_error(png_ptr, png_ptr->zstream.msg); |
else |
png_error(png_ptr, "zlib error"); |
} |
/* check to see if we need more room */ |
if (!png_ptr->zstream.avail_out && png_ptr->zstream.avail_in) |
{ |
/* make sure the output array has room */ |
if (comp->num_output_ptr >= comp->max_output_ptr) |
{ |
int old_max; |
old_max = comp->max_output_ptr; |
comp->max_output_ptr = comp->num_output_ptr + 4; |
if (comp->output_ptr != NULL) |
{ |
png_charpp old_ptr; |
old_ptr = comp->output_ptr; |
comp->output_ptr = (png_charpp)png_malloc(png_ptr, |
(png_uint_32)(comp->max_output_ptr * sizeof (png_charpp))); |
png_memcpy(comp->output_ptr, old_ptr, old_max |
* sizeof (png_charp)); |
png_free(png_ptr, old_ptr); |
} |
else |
comp->output_ptr = (png_charpp)png_malloc(png_ptr, |
(png_uint_32)(comp->max_output_ptr * sizeof (png_charp))); |
} |
/* save the data */ |
comp->output_ptr[comp->num_output_ptr] = (png_charp)png_malloc(png_ptr, |
(png_uint_32)png_ptr->zbuf_size); |
png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf, |
png_ptr->zbuf_size); |
comp->num_output_ptr++; |
/* and reset the buffer */ |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
png_ptr->zstream.next_out = png_ptr->zbuf; |
} |
/* continue until we don't have any more to compress */ |
} while (png_ptr->zstream.avail_in); |
/* finish the compression */ |
do |
{ |
/* tell zlib we are finished */ |
ret = deflate(&png_ptr->zstream, Z_FINISH); |
if (ret == Z_OK) |
{ |
/* check to see if we need more room */ |
if (!(png_ptr->zstream.avail_out)) |
{ |
/* check to make sure our output array has room */ |
if (comp->num_output_ptr >= comp->max_output_ptr) |
{ |
int old_max; |
old_max = comp->max_output_ptr; |
comp->max_output_ptr = comp->num_output_ptr + 4; |
if (comp->output_ptr != NULL) |
{ |
png_charpp old_ptr; |
old_ptr = comp->output_ptr; |
/* This could be optimized to realloc() */ |
comp->output_ptr = (png_charpp)png_malloc(png_ptr, |
(png_uint_32)(comp->max_output_ptr * sizeof (png_charpp))); |
png_memcpy(comp->output_ptr, old_ptr, |
old_max * sizeof (png_charp)); |
png_free(png_ptr, old_ptr); |
} |
else |
comp->output_ptr = (png_charpp)png_malloc(png_ptr, |
(png_uint_32)(comp->max_output_ptr * sizeof (png_charp))); |
} |
/* save off the data */ |
comp->output_ptr[comp->num_output_ptr] = |
(png_charp)png_malloc(png_ptr, (png_uint_32)png_ptr->zbuf_size); |
png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf, |
png_ptr->zbuf_size); |
comp->num_output_ptr++; |
/* and reset the buffer pointers */ |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
png_ptr->zstream.next_out = png_ptr->zbuf; |
} |
} |
else if (ret != Z_STREAM_END) |
{ |
/* we got an error */ |
if (png_ptr->zstream.msg != NULL) |
png_error(png_ptr, png_ptr->zstream.msg); |
else |
png_error(png_ptr, "zlib error"); |
} |
} while (ret != Z_STREAM_END); |
/* text length is number of buffers plus last buffer */ |
text_len = png_ptr->zbuf_size * comp->num_output_ptr; |
if (png_ptr->zstream.avail_out < png_ptr->zbuf_size) |
text_len += png_ptr->zbuf_size - (png_size_t)png_ptr->zstream.avail_out; |
return((int)text_len); |
} |
/* ship the compressed text out via chunk writes */ |
static void /* PRIVATE */ |
png_write_compressed_data_out(png_structp png_ptr, compression_state *comp) |
{ |
int i; |
/* handle the no-compression case */ |
if (comp->input) |
{ |
png_write_chunk_data(png_ptr, (png_bytep)comp->input, |
(png_size_t)comp->input_len); |
return; |
} |
/* write saved output buffers, if any */ |
for (i = 0; i < comp->num_output_ptr; i++) |
{ |
png_write_chunk_data(png_ptr,(png_bytep)comp->output_ptr[i], |
png_ptr->zbuf_size); |
png_free(png_ptr, comp->output_ptr[i]); |
comp->output_ptr[i]=NULL; |
} |
if (comp->max_output_ptr != 0) |
png_free(png_ptr, comp->output_ptr); |
comp->output_ptr=NULL; |
/* write anything left in zbuf */ |
if (png_ptr->zstream.avail_out < (png_uint_32)png_ptr->zbuf_size) |
png_write_chunk_data(png_ptr, png_ptr->zbuf, |
png_ptr->zbuf_size - png_ptr->zstream.avail_out); |
/* reset zlib for another zTXt/iTXt or the image data */ |
deflateReset(&png_ptr->zstream); |
} |
#endif |
/* Write the IHDR chunk, and update the png_struct with the necessary |
* information. Note that the rest of this code depends upon this |
* information being correct. |
*/ |
void /* PRIVATE */ |
png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height, |
int bit_depth, int color_type, int compression_type, int filter_type, |
int interlace_type) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_IHDR; |
#endif |
png_byte buf[13]; /* buffer to store the IHDR info */ |
png_debug(1, "in png_write_IHDR\n"); |
/* Check that we have valid input data from the application info */ |
switch (color_type) |
{ |
case PNG_COLOR_TYPE_GRAY: |
switch (bit_depth) |
{ |
case 1: |
case 2: |
case 4: |
case 8: |
case 16: png_ptr->channels = 1; break; |
default: png_error(png_ptr,"Invalid bit depth for grayscale image"); |
} |
break; |
case PNG_COLOR_TYPE_RGB: |
if (bit_depth != 8 && bit_depth != 16) |
png_error(png_ptr, "Invalid bit depth for RGB image"); |
png_ptr->channels = 3; |
break; |
case PNG_COLOR_TYPE_PALETTE: |
switch (bit_depth) |
{ |
case 1: |
case 2: |
case 4: |
case 8: png_ptr->channels = 1; break; |
default: png_error(png_ptr, "Invalid bit depth for paletted image"); |
} |
break; |
case PNG_COLOR_TYPE_GRAY_ALPHA: |
if (bit_depth != 8 && bit_depth != 16) |
png_error(png_ptr, "Invalid bit depth for grayscale+alpha image"); |
png_ptr->channels = 2; |
break; |
case PNG_COLOR_TYPE_RGB_ALPHA: |
if (bit_depth != 8 && bit_depth != 16) |
png_error(png_ptr, "Invalid bit depth for RGBA image"); |
png_ptr->channels = 4; |
break; |
default: |
png_error(png_ptr, "Invalid image color type specified"); |
} |
if (compression_type != PNG_COMPRESSION_TYPE_BASE) |
{ |
png_warning(png_ptr, "Invalid compression type specified"); |
compression_type = PNG_COMPRESSION_TYPE_BASE; |
} |
/* Write filter_method 64 (intrapixel differencing) only if |
* 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and |
* 2. Libpng did not write a PNG signature (this filter_method is only |
* used in PNG datastreams that are embedded in MNG datastreams) and |
* 3. The application called png_permit_mng_features with a mask that |
* included PNG_FLAG_MNG_FILTER_64 and |
* 4. The filter_method is 64 and |
* 5. The color_type is RGB or RGBA |
*/ |
if ( |
#if defined(PNG_MNG_FEATURES_SUPPORTED) |
!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && |
((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) && |
(color_type == PNG_COLOR_TYPE_RGB || |
color_type == PNG_COLOR_TYPE_RGB_ALPHA) && |
(filter_type == PNG_INTRAPIXEL_DIFFERENCING)) && |
#endif |
filter_type != PNG_FILTER_TYPE_BASE) |
{ |
png_warning(png_ptr, "Invalid filter type specified"); |
filter_type = PNG_FILTER_TYPE_BASE; |
} |
#ifdef PNG_WRITE_INTERLACING_SUPPORTED |
if (interlace_type != PNG_INTERLACE_NONE && |
interlace_type != PNG_INTERLACE_ADAM7) |
{ |
png_warning(png_ptr, "Invalid interlace type specified"); |
interlace_type = PNG_INTERLACE_ADAM7; |
} |
#else |
interlace_type=PNG_INTERLACE_NONE; |
#endif |
/* save off the relevent information */ |
png_ptr->bit_depth = (png_byte)bit_depth; |
png_ptr->color_type = (png_byte)color_type; |
png_ptr->interlaced = (png_byte)interlace_type; |
#if defined(PNG_MNG_FEATURES_SUPPORTED) |
png_ptr->filter_type = (png_byte)filter_type; |
#endif |
png_ptr->width = width; |
png_ptr->height = height; |
png_ptr->pixel_depth = (png_byte)(bit_depth * png_ptr->channels); |
png_ptr->rowbytes = ((width * (png_size_t)png_ptr->pixel_depth + 7) >> 3); |
/* set the usr info, so any transformations can modify it */ |
png_ptr->usr_width = png_ptr->width; |
png_ptr->usr_bit_depth = png_ptr->bit_depth; |
png_ptr->usr_channels = png_ptr->channels; |
/* pack the header information into the buffer */ |
png_save_uint_32(buf, width); |
png_save_uint_32(buf + 4, height); |
buf[8] = (png_byte)bit_depth; |
buf[9] = (png_byte)color_type; |
buf[10] = (png_byte)compression_type; |
buf[11] = (png_byte)filter_type; |
buf[12] = (png_byte)interlace_type; |
/* write the chunk */ |
png_write_chunk(png_ptr, (png_bytep)png_IHDR, buf, (png_size_t)13); |
/* initialize zlib with PNG info */ |
png_ptr->zstream.zalloc = png_zalloc; |
png_ptr->zstream.zfree = png_zfree; |
png_ptr->zstream.opaque = (voidpf)png_ptr; |
if (!(png_ptr->do_filter)) |
{ |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE || |
png_ptr->bit_depth < 8) |
png_ptr->do_filter = PNG_FILTER_NONE; |
else |
png_ptr->do_filter = PNG_ALL_FILTERS; |
} |
if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY)) |
{ |
if (png_ptr->do_filter != PNG_FILTER_NONE) |
png_ptr->zlib_strategy = Z_FILTERED; |
else |
png_ptr->zlib_strategy = Z_DEFAULT_STRATEGY; |
} |
if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_LEVEL)) |
png_ptr->zlib_level = Z_DEFAULT_COMPRESSION; |
if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL)) |
png_ptr->zlib_mem_level = 8; |
if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS)) |
png_ptr->zlib_window_bits = 15; |
if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_METHOD)) |
png_ptr->zlib_method = 8; |
deflateInit2(&png_ptr->zstream, png_ptr->zlib_level, |
png_ptr->zlib_method, png_ptr->zlib_window_bits, |
png_ptr->zlib_mem_level, png_ptr->zlib_strategy); |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
png_ptr->mode = PNG_HAVE_IHDR; |
} |
/* write the palette. We are careful not to trust png_color to be in the |
* correct order for PNG, so people can redefine it to any convenient |
* structure. |
*/ |
void /* PRIVATE */ |
png_write_PLTE(png_structp png_ptr, png_colorp palette, png_uint_32 num_pal) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_PLTE; |
#endif |
png_uint_32 i; |
png_colorp pal_ptr; |
png_byte buf[3]; |
png_debug(1, "in png_write_PLTE\n"); |
if (( |
#if defined(PNG_MNG_FEATURES_SUPPORTED) |
!(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) && |
#endif |
num_pal == 0) || num_pal > 256) |
{ |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
png_error(png_ptr, "Invalid number of colors in palette"); |
} |
else |
{ |
png_warning(png_ptr, "Invalid number of colors in palette"); |
return; |
} |
} |
if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR)) |
{ |
png_warning(png_ptr, |
"Ignoring request to write a PLTE chunk in grayscale PNG"); |
return; |
} |
png_ptr->num_palette = (png_uint_16)num_pal; |
png_debug1(3, "num_palette = %d\n", png_ptr->num_palette); |
png_write_chunk_start(png_ptr, (png_bytep)png_PLTE, num_pal * 3); |
#ifndef PNG_NO_POINTER_INDEXING |
for (i = 0, pal_ptr = palette; i < num_pal; i++, pal_ptr++) |
{ |
buf[0] = pal_ptr->red; |
buf[1] = pal_ptr->green; |
buf[2] = pal_ptr->blue; |
png_write_chunk_data(png_ptr, buf, (png_size_t)3); |
} |
#else |
/* This is a little slower but some buggy compilers need to do this instead */ |
pal_ptr=palette; |
for (i = 0; i < num_pal; i++) |
{ |
buf[0] = pal_ptr[i].red; |
buf[1] = pal_ptr[i].green; |
buf[2] = pal_ptr[i].blue; |
png_write_chunk_data(png_ptr, buf, (png_size_t)3); |
} |
#endif |
png_write_chunk_end(png_ptr); |
png_ptr->mode |= PNG_HAVE_PLTE; |
} |
/* write an IDAT chunk */ |
void /* PRIVATE */ |
png_write_IDAT(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_IDAT; |
#endif |
png_debug(1, "in png_write_IDAT\n"); |
png_write_chunk(png_ptr, (png_bytep)png_IDAT, data, length); |
png_ptr->mode |= PNG_HAVE_IDAT; |
} |
/* write an IEND chunk */ |
void /* PRIVATE */ |
png_write_IEND(png_structp png_ptr) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_IEND; |
#endif |
png_debug(1, "in png_write_IEND\n"); |
png_write_chunk(png_ptr, (png_bytep)png_IEND, png_bytep_NULL, |
(png_size_t)0); |
png_ptr->mode |= PNG_HAVE_IEND; |
} |
#if defined(PNG_WRITE_gAMA_SUPPORTED) |
/* write a gAMA chunk */ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
void /* PRIVATE */ |
png_write_gAMA(png_structp png_ptr, double file_gamma) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_gAMA; |
#endif |
png_uint_32 igamma; |
png_byte buf[4]; |
png_debug(1, "in png_write_gAMA\n"); |
/* file_gamma is saved in 1/100,000ths */ |
igamma = (png_uint_32)(file_gamma * 100000.0 + 0.5); |
png_save_uint_32(buf, igamma); |
png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4); |
} |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
void /* PRIVATE */ |
png_write_gAMA_fixed(png_structp png_ptr, png_fixed_point file_gamma) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_gAMA; |
#endif |
png_byte buf[4]; |
png_debug(1, "in png_write_gAMA\n"); |
/* file_gamma is saved in 1/100,000ths */ |
png_save_uint_32(buf, (png_uint_32)file_gamma); |
png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4); |
} |
#endif |
#endif |
#if defined(PNG_WRITE_sRGB_SUPPORTED) |
/* write a sRGB chunk */ |
void /* PRIVATE */ |
png_write_sRGB(png_structp png_ptr, int srgb_intent) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_sRGB; |
#endif |
png_byte buf[1]; |
png_debug(1, "in png_write_sRGB\n"); |
if(srgb_intent >= PNG_sRGB_INTENT_LAST) |
png_warning(png_ptr, |
"Invalid sRGB rendering intent specified"); |
buf[0]=(png_byte)srgb_intent; |
png_write_chunk(png_ptr, (png_bytep)png_sRGB, buf, (png_size_t)1); |
} |
#endif |
#if defined(PNG_WRITE_iCCP_SUPPORTED) |
/* write an iCCP chunk */ |
void /* PRIVATE */ |
png_write_iCCP(png_structp png_ptr, png_charp name, int compression_type, |
png_charp profile, int profile_len) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_iCCP; |
#endif |
png_size_t name_len; |
png_charp new_name; |
compression_state comp; |
png_debug(1, "in png_write_iCCP\n"); |
if (name == NULL || (name_len = png_check_keyword(png_ptr, name, |
&new_name)) == 0) |
{ |
png_warning(png_ptr, "Empty keyword in iCCP chunk"); |
return; |
} |
if (compression_type != PNG_COMPRESSION_TYPE_BASE) |
png_warning(png_ptr, "Unknown compression type in iCCP chunk"); |
if (profile == NULL) |
profile_len = 0; |
if (profile_len) |
profile_len = png_text_compress(png_ptr, profile, (png_size_t)profile_len, |
PNG_COMPRESSION_TYPE_BASE, &comp); |
/* make sure we include the NULL after the name and the compression type */ |
png_write_chunk_start(png_ptr, (png_bytep)png_iCCP, |
(png_uint_32)name_len+profile_len+2); |
new_name[name_len+1]=0x00; |
png_write_chunk_data(png_ptr, (png_bytep)new_name, name_len + 2); |
if (profile_len) |
png_write_compressed_data_out(png_ptr, &comp); |
png_write_chunk_end(png_ptr); |
png_free(png_ptr, new_name); |
} |
#endif |
#if defined(PNG_WRITE_sPLT_SUPPORTED) |
/* write a sPLT chunk */ |
void /* PRIVATE */ |
png_write_sPLT(png_structp png_ptr, png_sPLT_tp spalette) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_sPLT; |
#endif |
png_size_t name_len; |
png_charp new_name; |
png_byte entrybuf[10]; |
int entry_size = (spalette->depth == 8 ? 6 : 10); |
int palette_size = entry_size * spalette->nentries; |
png_sPLT_entryp ep; |
#ifdef PNG_NO_POINTER_INDEXING |
int i; |
#endif |
png_debug(1, "in png_write_sPLT\n"); |
if (spalette->name == NULL || (name_len = png_check_keyword(png_ptr, |
spalette->name, &new_name))==0) |
{ |
png_warning(png_ptr, "Empty keyword in sPLT chunk"); |
return; |
} |
/* make sure we include the NULL after the name */ |
png_write_chunk_start(png_ptr, (png_bytep)png_sPLT, |
(png_uint_32)(name_len + 2 + palette_size)); |
png_write_chunk_data(png_ptr, (png_bytep)new_name, name_len + 1); |
png_write_chunk_data(png_ptr, (png_bytep)&spalette->depth, 1); |
/* loop through each palette entry, writing appropriately */ |
#ifndef PNG_NO_POINTER_INDEXING |
for (ep = spalette->entries; ep<spalette->entries+spalette->nentries; ep++) |
{ |
if (spalette->depth == 8) |
{ |
entrybuf[0] = (png_byte)ep->red; |
entrybuf[1] = (png_byte)ep->green; |
entrybuf[2] = (png_byte)ep->blue; |
entrybuf[3] = (png_byte)ep->alpha; |
png_save_uint_16(entrybuf + 4, ep->frequency); |
} |
else |
{ |
png_save_uint_16(entrybuf + 0, ep->red); |
png_save_uint_16(entrybuf + 2, ep->green); |
png_save_uint_16(entrybuf + 4, ep->blue); |
png_save_uint_16(entrybuf + 6, ep->alpha); |
png_save_uint_16(entrybuf + 8, ep->frequency); |
} |
png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size); |
} |
#else |
ep=spalette->entries; |
for (i=0; i>spalette->nentries; i++) |
{ |
if (spalette->depth == 8) |
{ |
entrybuf[0] = (png_byte)ep[i].red; |
entrybuf[1] = (png_byte)ep[i].green; |
entrybuf[2] = (png_byte)ep[i].blue; |
entrybuf[3] = (png_byte)ep[i].alpha; |
png_save_uint_16(entrybuf + 4, ep[i].frequency); |
} |
else |
{ |
png_save_uint_16(entrybuf + 0, ep[i].red); |
png_save_uint_16(entrybuf + 2, ep[i].green); |
png_save_uint_16(entrybuf + 4, ep[i].blue); |
png_save_uint_16(entrybuf + 6, ep[i].alpha); |
png_save_uint_16(entrybuf + 8, ep[i].frequency); |
} |
png_write_chunk_data(png_ptr, entrybuf, entry_size); |
} |
#endif |
png_write_chunk_end(png_ptr); |
png_free(png_ptr, new_name); |
} |
#endif |
#if defined(PNG_WRITE_sBIT_SUPPORTED) |
/* write the sBIT chunk */ |
void /* PRIVATE */ |
png_write_sBIT(png_structp png_ptr, png_color_8p sbit, int color_type) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_sBIT; |
#endif |
png_byte buf[4]; |
png_size_t size; |
png_debug(1, "in png_write_sBIT\n"); |
/* make sure we don't depend upon the order of PNG_COLOR_8 */ |
if (color_type & PNG_COLOR_MASK_COLOR) |
{ |
png_byte maxbits; |
maxbits = (png_byte)(color_type==PNG_COLOR_TYPE_PALETTE ? 8 : |
png_ptr->usr_bit_depth); |
if (sbit->red == 0 || sbit->red > maxbits || |
sbit->green == 0 || sbit->green > maxbits || |
sbit->blue == 0 || sbit->blue > maxbits) |
{ |
png_warning(png_ptr, "Invalid sBIT depth specified"); |
return; |
} |
buf[0] = sbit->red; |
buf[1] = sbit->green; |
buf[2] = sbit->blue; |
size = 3; |
} |
else |
{ |
if (sbit->gray == 0 || sbit->gray > png_ptr->usr_bit_depth) |
{ |
png_warning(png_ptr, "Invalid sBIT depth specified"); |
return; |
} |
buf[0] = sbit->gray; |
size = 1; |
} |
if (color_type & PNG_COLOR_MASK_ALPHA) |
{ |
if (sbit->alpha == 0 || sbit->alpha > png_ptr->usr_bit_depth) |
{ |
png_warning(png_ptr, "Invalid sBIT depth specified"); |
return; |
} |
buf[size++] = sbit->alpha; |
} |
png_write_chunk(png_ptr, (png_bytep)png_sBIT, buf, size); |
} |
#endif |
#if defined(PNG_WRITE_cHRM_SUPPORTED) |
/* write the cHRM chunk */ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
void /* PRIVATE */ |
png_write_cHRM(png_structp png_ptr, double white_x, double white_y, |
double red_x, double red_y, double green_x, double green_y, |
double blue_x, double blue_y) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_cHRM; |
#endif |
png_byte buf[32]; |
png_uint_32 itemp; |
png_debug(1, "in png_write_cHRM\n"); |
/* each value is saved in 1/100,000ths */ |
if (white_x < 0 || white_x > 0.8 || white_y < 0 || white_y > 0.8 || |
white_x + white_y > 1.0) |
{ |
png_warning(png_ptr, "Invalid cHRM white point specified"); |
#if !defined(PNG_NO_CONSOLE_IO) |
cprintf("white_x=%f, white_y=%f\n",white_x, white_y); |
#endif |
return; |
} |
itemp = (png_uint_32)(white_x * 100000.0 + 0.5); |
png_save_uint_32(buf, itemp); |
itemp = (png_uint_32)(white_y * 100000.0 + 0.5); |
png_save_uint_32(buf + 4, itemp); |
if (red_x < 0 || red_x > 0.8 || red_y < 0 || red_y > 0.8 || |
red_x + red_y > 1.0) |
{ |
png_warning(png_ptr, "Invalid cHRM red point specified"); |
return; |
} |
itemp = (png_uint_32)(red_x * 100000.0 + 0.5); |
png_save_uint_32(buf + 8, itemp); |
itemp = (png_uint_32)(red_y * 100000.0 + 0.5); |
png_save_uint_32(buf + 12, itemp); |
if (green_x < 0 || green_x > 0.8 || green_y < 0 || green_y > 0.8 || |
green_x + green_y > 1.0) |
{ |
png_warning(png_ptr, "Invalid cHRM green point specified"); |
return; |
} |
itemp = (png_uint_32)(green_x * 100000.0 + 0.5); |
png_save_uint_32(buf + 16, itemp); |
itemp = (png_uint_32)(green_y * 100000.0 + 0.5); |
png_save_uint_32(buf + 20, itemp); |
if (blue_x < 0 || blue_x > 0.8 || blue_y < 0 || blue_y > 0.8 || |
blue_x + blue_y > 1.0) |
{ |
png_warning(png_ptr, "Invalid cHRM blue point specified"); |
return; |
} |
itemp = (png_uint_32)(blue_x * 100000.0 + 0.5); |
png_save_uint_32(buf + 24, itemp); |
itemp = (png_uint_32)(blue_y * 100000.0 + 0.5); |
png_save_uint_32(buf + 28, itemp); |
png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32); |
} |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
void /* PRIVATE */ |
png_write_cHRM_fixed(png_structp png_ptr, png_fixed_point white_x, |
png_fixed_point white_y, png_fixed_point red_x, png_fixed_point red_y, |
png_fixed_point green_x, png_fixed_point green_y, png_fixed_point blue_x, |
png_fixed_point blue_y) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_cHRM; |
#endif |
png_byte buf[32]; |
png_debug(1, "in png_write_cHRM\n"); |
/* each value is saved in 1/100,000ths */ |
if (white_x > 80000L || white_y > 80000L || white_x + white_y > 100000L) |
{ |
png_warning(png_ptr, "Invalid fixed cHRM white point specified"); |
#if !defined(PNG_NO_CONSOLE_IO) |
cprintf("white_x=%ld, white_y=%ld\n",white_x, white_y); |
#endif |
return; |
} |
png_save_uint_32(buf, (png_uint_32)white_x); |
png_save_uint_32(buf + 4, (png_uint_32)white_y); |
if (red_x > 80000L || red_y > 80000L || red_x + red_y > 100000L) |
{ |
png_warning(png_ptr, "Invalid cHRM fixed red point specified"); |
return; |
} |
png_save_uint_32(buf + 8, (png_uint_32)red_x); |
png_save_uint_32(buf + 12, (png_uint_32)red_y); |
if (green_x > 80000L || green_y > 80000L || green_x + green_y > 100000L) |
{ |
png_warning(png_ptr, "Invalid fixed cHRM green point specified"); |
return; |
} |
png_save_uint_32(buf + 16, (png_uint_32)green_x); |
png_save_uint_32(buf + 20, (png_uint_32)green_y); |
if (blue_x > 80000L || blue_y > 80000L || blue_x + blue_y > 100000L) |
{ |
png_warning(png_ptr, "Invalid fixed cHRM blue point specified"); |
return; |
} |
png_save_uint_32(buf + 24, (png_uint_32)blue_x); |
png_save_uint_32(buf + 28, (png_uint_32)blue_y); |
png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32); |
} |
#endif |
#endif |
#if defined(PNG_WRITE_tRNS_SUPPORTED) |
/* write the tRNS chunk */ |
void /* PRIVATE */ |
png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran, |
int num_trans, int color_type) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_tRNS; |
#endif |
png_byte buf[6]; |
png_debug(1, "in png_write_tRNS\n"); |
if (color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
if (num_trans <= 0 || num_trans > (int)png_ptr->num_palette) |
{ |
png_warning(png_ptr,"Invalid number of transparent colors specified"); |
return; |
} |
/* write the chunk out as it is */ |
png_write_chunk(png_ptr, (png_bytep)png_tRNS, trans, (png_size_t)num_trans); |
} |
else if (color_type == PNG_COLOR_TYPE_GRAY) |
{ |
/* one 16 bit value */ |
if(tran->gray >= (1 << png_ptr->bit_depth)) |
{ |
png_warning(png_ptr, |
"Ignoring attempt to write tRNS chunk out-of-range for bit_depth"); |
return; |
} |
png_save_uint_16(buf, tran->gray); |
png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)2); |
} |
else if (color_type == PNG_COLOR_TYPE_RGB) |
{ |
/* three 16 bit values */ |
png_save_uint_16(buf, tran->red); |
png_save_uint_16(buf + 2, tran->green); |
png_save_uint_16(buf + 4, tran->blue); |
if(png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4])) |
{ |
png_warning(png_ptr, |
"Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8"); |
return; |
} |
png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)6); |
} |
else |
{ |
png_warning(png_ptr, "Can't write tRNS with an alpha channel"); |
} |
} |
#endif |
#if defined(PNG_WRITE_bKGD_SUPPORTED) |
/* write the background chunk */ |
void /* PRIVATE */ |
png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_bKGD; |
#endif |
png_byte buf[6]; |
png_debug(1, "in png_write_bKGD\n"); |
if (color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
if ( |
#if defined(PNG_MNG_FEATURES_SUPPORTED) |
(png_ptr->num_palette || |
(!(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE))) && |
#endif |
back->index > png_ptr->num_palette) |
{ |
png_warning(png_ptr, "Invalid background palette index"); |
return; |
} |
buf[0] = back->index; |
png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)1); |
} |
else if (color_type & PNG_COLOR_MASK_COLOR) |
{ |
png_save_uint_16(buf, back->red); |
png_save_uint_16(buf + 2, back->green); |
png_save_uint_16(buf + 4, back->blue); |
if(png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4])) |
{ |
png_warning(png_ptr, |
"Ignoring attempt to write 16-bit bKGD chunk when bit_depth is 8"); |
return; |
} |
png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)6); |
} |
else |
{ |
if(back->gray >= (1 << png_ptr->bit_depth)) |
{ |
png_warning(png_ptr, |
"Ignoring attempt to write bKGD chunk out-of-range for bit_depth"); |
return; |
} |
png_save_uint_16(buf, back->gray); |
png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)2); |
} |
} |
#endif |
#if defined(PNG_WRITE_hIST_SUPPORTED) |
/* write the histogram */ |
void /* PRIVATE */ |
png_write_hIST(png_structp png_ptr, png_uint_16p hist, int num_hist) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_hIST; |
#endif |
int i; |
png_byte buf[3]; |
png_debug(1, "in png_write_hIST\n"); |
if (num_hist > (int)png_ptr->num_palette) |
{ |
png_debug2(3, "num_hist = %d, num_palette = %d\n", num_hist, |
png_ptr->num_palette); |
png_warning(png_ptr, "Invalid number of histogram entries specified"); |
return; |
} |
png_write_chunk_start(png_ptr, (png_bytep)png_hIST, (png_uint_32)(num_hist * 2)); |
for (i = 0; i < num_hist; i++) |
{ |
png_save_uint_16(buf, hist[i]); |
png_write_chunk_data(png_ptr, buf, (png_size_t)2); |
} |
png_write_chunk_end(png_ptr); |
} |
#endif |
#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \ |
defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED) |
/* Check that the tEXt or zTXt keyword is valid per PNG 1.0 specification, |
* and if invalid, correct the keyword rather than discarding the entire |
* chunk. The PNG 1.0 specification requires keywords 1-79 characters in |
* length, forbids leading or trailing whitespace, multiple internal spaces, |
* and the non-break space (0x80) from ISO 8859-1. Returns keyword length. |
* |
* The new_key is allocated to hold the corrected keyword and must be freed |
* by the calling routine. This avoids problems with trying to write to |
* static keywords without having to have duplicate copies of the strings. |
*/ |
png_size_t /* PRIVATE */ |
png_check_keyword(png_structp png_ptr, png_charp key, png_charpp new_key) |
{ |
png_size_t key_len; |
png_charp kp, dp; |
int kflag; |
int kwarn=0; |
png_debug(1, "in png_check_keyword\n"); |
*new_key = NULL; |
if (key == NULL || (key_len = png_strlen(key)) == 0) |
{ |
png_warning(png_ptr, "zero length keyword"); |
return ((png_size_t)0); |
} |
png_debug1(2, "Keyword to be checked is '%s'\n", key); |
*new_key = (png_charp)png_malloc(png_ptr, (png_uint_32)(key_len + 2)); |
/* Replace non-printing characters with a blank and print a warning */ |
for (kp = key, dp = *new_key; *kp != '\0'; kp++, dp++) |
{ |
if (*kp < 0x20 || (*kp > 0x7E && (png_byte)*kp < 0xA1)) |
{ |
#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) |
char msg[40]; |
sprintf(msg, "invalid keyword character 0x%02X", *kp); |
png_warning(png_ptr, msg); |
#else |
png_warning(png_ptr, "invalid character in keyword"); |
#endif |
*dp = ' '; |
} |
else |
{ |
*dp = *kp; |
} |
} |
*dp = '\0'; |
/* Remove any trailing white space. */ |
kp = *new_key + key_len - 1; |
if (*kp == ' ') |
{ |
png_warning(png_ptr, "trailing spaces removed from keyword"); |
while (*kp == ' ') |
{ |
*(kp--) = '\0'; |
key_len--; |
} |
} |
/* Remove any leading white space. */ |
kp = *new_key; |
if (*kp == ' ') |
{ |
png_warning(png_ptr, "leading spaces removed from keyword"); |
while (*kp == ' ') |
{ |
kp++; |
key_len--; |
} |
} |
png_debug1(2, "Checking for multiple internal spaces in '%s'\n", kp); |
/* Remove multiple internal spaces. */ |
for (kflag = 0, dp = *new_key; *kp != '\0'; kp++) |
{ |
if (*kp == ' ' && kflag == 0) |
{ |
*(dp++) = *kp; |
kflag = 1; |
} |
else if (*kp == ' ') |
{ |
key_len--; |
kwarn=1; |
} |
else |
{ |
*(dp++) = *kp; |
kflag = 0; |
} |
} |
*dp = '\0'; |
if(kwarn) |
png_warning(png_ptr, "extra interior spaces removed from keyword"); |
if (key_len == 0) |
{ |
png_free(png_ptr, *new_key); |
*new_key=NULL; |
png_warning(png_ptr, "Zero length keyword"); |
} |
if (key_len > 79) |
{ |
png_warning(png_ptr, "keyword length must be 1 - 79 characters"); |
new_key[79] = '\0'; |
key_len = 79; |
} |
return (key_len); |
} |
#endif |
#if defined(PNG_WRITE_tEXt_SUPPORTED) |
/* write a tEXt chunk */ |
void /* PRIVATE */ |
png_write_tEXt(png_structp png_ptr, png_charp key, png_charp text, |
png_size_t text_len) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_tEXt; |
#endif |
png_size_t key_len; |
png_charp new_key; |
png_debug(1, "in png_write_tEXt\n"); |
if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0) |
{ |
png_warning(png_ptr, "Empty keyword in tEXt chunk"); |
return; |
} |
if (text == NULL || *text == '\0') |
text_len = 0; |
else |
text_len = png_strlen(text); |
/* make sure we include the 0 after the key */ |
png_write_chunk_start(png_ptr, (png_bytep)png_tEXt, (png_uint_32)key_len+text_len+1); |
/* |
* We leave it to the application to meet PNG-1.0 requirements on the |
* contents of the text. PNG-1.0 through PNG-1.2 discourage the use of |
* any non-Latin-1 characters except for NEWLINE. ISO PNG will forbid them. |
* The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG. |
*/ |
png_write_chunk_data(png_ptr, (png_bytep)new_key, key_len + 1); |
if (text_len) |
png_write_chunk_data(png_ptr, (png_bytep)text, text_len); |
png_write_chunk_end(png_ptr); |
png_free(png_ptr, new_key); |
} |
#endif |
#if defined(PNG_WRITE_zTXt_SUPPORTED) |
/* write a compressed text chunk */ |
void /* PRIVATE */ |
png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text, |
png_size_t text_len, int compression) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_zTXt; |
#endif |
png_size_t key_len; |
char buf[1]; |
png_charp new_key; |
compression_state comp; |
png_debug(1, "in png_write_zTXt\n"); |
if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0) |
{ |
png_warning(png_ptr, "Empty keyword in zTXt chunk"); |
return; |
} |
if (text == NULL || *text == '\0' || compression==PNG_TEXT_COMPRESSION_NONE) |
{ |
png_write_tEXt(png_ptr, new_key, text, (png_size_t)0); |
png_free(png_ptr, new_key); |
return; |
} |
text_len = png_strlen(text); |
png_free(png_ptr, new_key); |
/* compute the compressed data; do it now for the length */ |
text_len = png_text_compress(png_ptr, text, text_len, compression, |
&comp); |
/* write start of chunk */ |
png_write_chunk_start(png_ptr, (png_bytep)png_zTXt, (png_uint_32) |
(key_len+text_len+2)); |
/* write key */ |
png_write_chunk_data(png_ptr, (png_bytep)key, key_len + 1); |
buf[0] = (png_byte)compression; |
/* write compression */ |
png_write_chunk_data(png_ptr, (png_bytep)buf, (png_size_t)1); |
/* write the compressed data */ |
png_write_compressed_data_out(png_ptr, &comp); |
/* close the chunk */ |
png_write_chunk_end(png_ptr); |
} |
#endif |
#if defined(PNG_WRITE_iTXt_SUPPORTED) |
/* write an iTXt chunk */ |
void /* PRIVATE */ |
png_write_iTXt(png_structp png_ptr, int compression, png_charp key, |
png_charp lang, png_charp lang_key, png_charp text) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_iTXt; |
#endif |
png_size_t lang_len, key_len, lang_key_len, text_len; |
png_charp new_lang, new_key; |
png_byte cbuf[2]; |
compression_state comp; |
png_debug(1, "in png_write_iTXt\n"); |
if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0) |
{ |
png_warning(png_ptr, "Empty keyword in iTXt chunk"); |
return; |
} |
if (lang == NULL || (lang_len = png_check_keyword(png_ptr, lang, &new_lang))==0) |
{ |
png_warning(png_ptr, "Empty language field in iTXt chunk"); |
new_lang = NULL; |
lang_len = 0; |
} |
if (lang_key == NULL) |
lang_key_len = 0; |
else |
lang_key_len = png_strlen(lang_key); |
if (text == NULL) |
text_len = 0; |
else |
text_len = png_strlen(text); |
/* compute the compressed data; do it now for the length */ |
text_len = png_text_compress(png_ptr, text, text_len, compression-2, |
&comp); |
/* make sure we include the compression flag, the compression byte, |
* and the NULs after the key, lang, and lang_key parts */ |
png_write_chunk_start(png_ptr, (png_bytep)png_iTXt, |
(png_uint_32)( |
5 /* comp byte, comp flag, terminators for key, lang and lang_key */ |
+ key_len |
+ lang_len |
+ lang_key_len |
+ text_len)); |
/* |
* We leave it to the application to meet PNG-1.0 requirements on the |
* contents of the text. PNG-1.0 through PNG-1.2 discourage the use of |
* any non-Latin-1 characters except for NEWLINE. ISO PNG will forbid them. |
* The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG. |
*/ |
png_write_chunk_data(png_ptr, (png_bytep)new_key, key_len + 1); |
/* set the compression flag */ |
if (compression == PNG_ITXT_COMPRESSION_NONE || \ |
compression == PNG_TEXT_COMPRESSION_NONE) |
cbuf[0] = 0; |
else /* compression == PNG_ITXT_COMPRESSION_zTXt */ |
cbuf[0] = 1; |
/* set the compression method */ |
cbuf[1] = 0; |
png_write_chunk_data(png_ptr, cbuf, 2); |
cbuf[0] = 0; |
png_write_chunk_data(png_ptr, (new_lang ? (png_bytep)new_lang : cbuf), lang_len + 1); |
png_write_chunk_data(png_ptr, (lang_key ? (png_bytep)lang_key : cbuf), lang_key_len + 1); |
png_write_compressed_data_out(png_ptr, &comp); |
png_write_chunk_end(png_ptr); |
png_free(png_ptr, new_key); |
if (new_lang) |
png_free(png_ptr, new_lang); |
} |
#endif |
#if defined(PNG_WRITE_oFFs_SUPPORTED) |
/* write the oFFs chunk */ |
void /* PRIVATE */ |
png_write_oFFs(png_structp png_ptr, png_int_32 x_offset, png_int_32 y_offset, |
int unit_type) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_oFFs; |
#endif |
png_byte buf[9]; |
png_debug(1, "in png_write_oFFs\n"); |
if (unit_type >= PNG_OFFSET_LAST) |
png_warning(png_ptr, "Unrecognized unit type for oFFs chunk"); |
png_save_int_32(buf, x_offset); |
png_save_int_32(buf + 4, y_offset); |
buf[8] = (png_byte)unit_type; |
png_write_chunk(png_ptr, (png_bytep)png_oFFs, buf, (png_size_t)9); |
} |
#endif |
#if defined(PNG_WRITE_pCAL_SUPPORTED) |
/* write the pCAL chunk (described in the PNG extensions document) */ |
void /* PRIVATE */ |
png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0, |
png_int_32 X1, int type, int nparams, png_charp units, png_charpp params) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_pCAL; |
#endif |
png_size_t purpose_len, units_len, total_len; |
png_uint_32p params_len; |
png_byte buf[10]; |
png_charp new_purpose; |
int i; |
png_debug1(1, "in png_write_pCAL (%d parameters)\n", nparams); |
if (type >= PNG_EQUATION_LAST) |
png_warning(png_ptr, "Unrecognized equation type for pCAL chunk"); |
purpose_len = png_check_keyword(png_ptr, purpose, &new_purpose) + 1; |
png_debug1(3, "pCAL purpose length = %d\n", (int)purpose_len); |
units_len = png_strlen(units) + (nparams == 0 ? 0 : 1); |
png_debug1(3, "pCAL units length = %d\n", (int)units_len); |
total_len = purpose_len + units_len + 10; |
params_len = (png_uint_32p)png_malloc(png_ptr, (png_uint_32)(nparams |
*sizeof(png_uint_32))); |
/* Find the length of each parameter, making sure we don't count the |
null terminator for the last parameter. */ |
for (i = 0; i < nparams; i++) |
{ |
params_len[i] = png_strlen(params[i]) + (i == nparams - 1 ? 0 : 1); |
png_debug2(3, "pCAL parameter %d length = %lu\n", i, params_len[i]); |
total_len += (png_size_t)params_len[i]; |
} |
png_debug1(3, "pCAL total length = %d\n", (int)total_len); |
png_write_chunk_start(png_ptr, (png_bytep)png_pCAL, (png_uint_32)total_len); |
png_write_chunk_data(png_ptr, (png_bytep)new_purpose, purpose_len); |
png_save_int_32(buf, X0); |
png_save_int_32(buf + 4, X1); |
buf[8] = (png_byte)type; |
buf[9] = (png_byte)nparams; |
png_write_chunk_data(png_ptr, buf, (png_size_t)10); |
png_write_chunk_data(png_ptr, (png_bytep)units, (png_size_t)units_len); |
png_free(png_ptr, new_purpose); |
for (i = 0; i < nparams; i++) |
{ |
png_write_chunk_data(png_ptr, (png_bytep)params[i], |
(png_size_t)params_len[i]); |
} |
png_free(png_ptr, params_len); |
png_write_chunk_end(png_ptr); |
} |
#endif |
#if defined(PNG_WRITE_sCAL_SUPPORTED) |
/* write the sCAL chunk */ |
#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO) |
void /* PRIVATE */ |
png_write_sCAL(png_structp png_ptr, int unit, double width,double height) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_sCAL; |
#endif |
png_size_t total_len; |
char wbuf[32], hbuf[32]; |
png_debug(1, "in png_write_sCAL\n"); |
#if defined(_WIN32_WCE) |
/* sprintf() function is not supported on WindowsCE */ |
{ |
wchar_t wc_buf[32]; |
swprintf(wc_buf, TEXT("%12.12e"), width); |
WideCharToMultiByte(CP_ACP, 0, wc_buf, -1, wbuf, 32, NULL, NULL); |
swprintf(wc_buf, TEXT("%12.12e"), height); |
WideCharToMultiByte(CP_ACP, 0, wc_buf, -1, hbuf, 32, NULL, NULL); |
} |
#else |
sprintf(wbuf, "%12.12e", width); |
sprintf(hbuf, "%12.12e", height); |
#endif |
total_len = 1 + png_strlen(wbuf)+1 + png_strlen(hbuf); |
png_debug1(3, "sCAL total length = %d\n", (int)total_len); |
png_write_chunk_start(png_ptr, (png_bytep)png_sCAL, (png_uint_32)total_len); |
png_write_chunk_data(png_ptr, (png_bytep)&unit, 1); |
png_write_chunk_data(png_ptr, (png_bytep)wbuf, png_strlen(wbuf)+1); |
png_write_chunk_data(png_ptr, (png_bytep)hbuf, png_strlen(hbuf)); |
png_write_chunk_end(png_ptr); |
} |
#else |
#ifdef PNG_FIXED_POINT_SUPPORTED |
void /* PRIVATE */ |
png_write_sCAL_s(png_structp png_ptr, int unit, png_charp width, |
png_charp height) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_sCAL; |
#endif |
png_size_t total_len; |
char wbuf[32], hbuf[32]; |
png_debug(1, "in png_write_sCAL_s\n"); |
png_strcpy(wbuf,(const char *)width); |
png_strcpy(hbuf,(const char *)height); |
total_len = 1 + png_strlen(wbuf)+1 + png_strlen(hbuf); |
png_debug1(3, "sCAL total length = %d\n", total_len); |
png_write_chunk_start(png_ptr, (png_bytep)png_sCAL, (png_uint_32)total_len); |
png_write_chunk_data(png_ptr, (png_bytep)&unit, 1); |
png_write_chunk_data(png_ptr, (png_bytep)wbuf, png_strlen(wbuf)+1); |
png_write_chunk_data(png_ptr, (png_bytep)hbuf, png_strlen(hbuf)); |
png_write_chunk_end(png_ptr); |
} |
#endif |
#endif |
#endif |
#if defined(PNG_WRITE_pHYs_SUPPORTED) |
/* write the pHYs chunk */ |
void /* PRIVATE */ |
png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit, |
png_uint_32 y_pixels_per_unit, |
int unit_type) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_pHYs; |
#endif |
png_byte buf[9]; |
png_debug(1, "in png_write_pHYs\n"); |
if (unit_type >= PNG_RESOLUTION_LAST) |
png_warning(png_ptr, "Unrecognized unit type for pHYs chunk"); |
png_save_uint_32(buf, x_pixels_per_unit); |
png_save_uint_32(buf + 4, y_pixels_per_unit); |
buf[8] = (png_byte)unit_type; |
png_write_chunk(png_ptr, (png_bytep)png_pHYs, buf, (png_size_t)9); |
} |
#endif |
#if defined(PNG_WRITE_tIME_SUPPORTED) |
/* Write the tIME chunk. Use either png_convert_from_struct_tm() |
* or png_convert_from_time_t(), or fill in the structure yourself. |
*/ |
void /* PRIVATE */ |
png_write_tIME(png_structp png_ptr, png_timep mod_time) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_tIME; |
#endif |
png_byte buf[7]; |
png_debug(1, "in png_write_tIME\n"); |
if (mod_time->month > 12 || mod_time->month < 1 || |
mod_time->day > 31 || mod_time->day < 1 || |
mod_time->hour > 23 || mod_time->second > 60) |
{ |
png_warning(png_ptr, "Invalid time specified for tIME chunk"); |
return; |
} |
png_save_uint_16(buf, mod_time->year); |
buf[2] = mod_time->month; |
buf[3] = mod_time->day; |
buf[4] = mod_time->hour; |
buf[5] = mod_time->minute; |
buf[6] = mod_time->second; |
png_write_chunk(png_ptr, (png_bytep)png_tIME, buf, (png_size_t)7); |
} |
#endif |
/* initializes the row writing capability of libpng */ |
void /* PRIVATE */ |
png_write_start_row(png_structp png_ptr) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
/* start of interlace block */ |
int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; |
/* offset to next interlace block */ |
int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
/* start of interlace block in the y direction */ |
int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; |
/* offset to next interlace block in the y direction */ |
int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; |
#endif |
png_size_t buf_size; |
png_debug(1, "in png_write_start_row\n"); |
buf_size = (png_size_t)(((png_ptr->width * png_ptr->usr_channels * |
png_ptr->usr_bit_depth + 7) >> 3) + 1); |
/* set up row buffer */ |
png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, (png_uint_32)buf_size); |
png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE; |
/* set up filtering buffer, if using this filter */ |
if (png_ptr->do_filter & PNG_FILTER_SUB) |
{ |
png_ptr->sub_row = (png_bytep)png_malloc(png_ptr, |
(png_ptr->rowbytes + 1)); |
png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB; |
} |
/* We only need to keep the previous row if we are using one of these. */ |
if (png_ptr->do_filter & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH)) |
{ |
/* set up previous row buffer */ |
png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)buf_size); |
png_memset(png_ptr->prev_row, 0, buf_size); |
if (png_ptr->do_filter & PNG_FILTER_UP) |
{ |
png_ptr->up_row = (png_bytep )png_malloc(png_ptr, |
(png_ptr->rowbytes + 1)); |
png_ptr->up_row[0] = PNG_FILTER_VALUE_UP; |
} |
if (png_ptr->do_filter & PNG_FILTER_AVG) |
{ |
png_ptr->avg_row = (png_bytep)png_malloc(png_ptr, |
(png_ptr->rowbytes + 1)); |
png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG; |
} |
if (png_ptr->do_filter & PNG_FILTER_PAETH) |
{ |
png_ptr->paeth_row = (png_bytep )png_malloc(png_ptr, |
(png_ptr->rowbytes + 1)); |
png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH; |
} |
} |
#ifdef PNG_WRITE_INTERLACING_SUPPORTED |
/* if interlaced, we need to set up width and height of pass */ |
if (png_ptr->interlaced) |
{ |
if (!(png_ptr->transformations & PNG_INTERLACE)) |
{ |
png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 - |
png_pass_ystart[0]) / png_pass_yinc[0]; |
png_ptr->usr_width = (png_ptr->width + png_pass_inc[0] - 1 - |
png_pass_start[0]) / png_pass_inc[0]; |
} |
else |
{ |
png_ptr->num_rows = png_ptr->height; |
png_ptr->usr_width = png_ptr->width; |
} |
} |
else |
#endif |
{ |
png_ptr->num_rows = png_ptr->height; |
png_ptr->usr_width = png_ptr->width; |
} |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
png_ptr->zstream.next_out = png_ptr->zbuf; |
} |
/* Internal use only. Called when finished processing a row of data. */ |
void /* PRIVATE */ |
png_write_finish_row(png_structp png_ptr) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
/* start of interlace block */ |
int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; |
/* offset to next interlace block */ |
int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
/* start of interlace block in the y direction */ |
int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; |
/* offset to next interlace block in the y direction */ |
int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; |
#endif |
int ret; |
png_debug(1, "in png_write_finish_row\n"); |
/* next row */ |
png_ptr->row_number++; |
/* see if we are done */ |
if (png_ptr->row_number < png_ptr->num_rows) |
return; |
#ifdef PNG_WRITE_INTERLACING_SUPPORTED |
/* if interlaced, go to next pass */ |
if (png_ptr->interlaced) |
{ |
png_ptr->row_number = 0; |
if (png_ptr->transformations & PNG_INTERLACE) |
{ |
png_ptr->pass++; |
} |
else |
{ |
/* loop until we find a non-zero width or height pass */ |
do |
{ |
png_ptr->pass++; |
if (png_ptr->pass >= 7) |
break; |
png_ptr->usr_width = (png_ptr->width + |
png_pass_inc[png_ptr->pass] - 1 - |
png_pass_start[png_ptr->pass]) / |
png_pass_inc[png_ptr->pass]; |
png_ptr->num_rows = (png_ptr->height + |
png_pass_yinc[png_ptr->pass] - 1 - |
png_pass_ystart[png_ptr->pass]) / |
png_pass_yinc[png_ptr->pass]; |
if (png_ptr->transformations & PNG_INTERLACE) |
break; |
} while (png_ptr->usr_width == 0 || png_ptr->num_rows == 0); |
} |
/* reset the row above the image for the next pass */ |
if (png_ptr->pass < 7) |
{ |
if (png_ptr->prev_row != NULL) |
png_memset(png_ptr->prev_row, 0, |
(png_size_t) (((png_uint_32)png_ptr->usr_channels * |
(png_uint_32)png_ptr->usr_bit_depth * |
png_ptr->width + 7) >> 3) + 1); |
return; |
} |
} |
#endif |
/* if we get here, we've just written the last row, so we need |
to flush the compressor */ |
do |
{ |
/* tell the compressor we are done */ |
ret = deflate(&png_ptr->zstream, Z_FINISH); |
/* check for an error */ |
if (ret == Z_OK) |
{ |
/* check to see if we need more room */ |
if (!(png_ptr->zstream.avail_out)) |
{ |
png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size); |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
} |
} |
else if (ret != Z_STREAM_END) |
{ |
if (png_ptr->zstream.msg != NULL) |
png_error(png_ptr, png_ptr->zstream.msg); |
else |
png_error(png_ptr, "zlib error"); |
} |
} while (ret != Z_STREAM_END); |
/* write any extra space */ |
if (png_ptr->zstream.avail_out < png_ptr->zbuf_size) |
{ |
png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size - |
png_ptr->zstream.avail_out); |
} |
deflateReset(&png_ptr->zstream); |
} |
#if defined(PNG_WRITE_INTERLACING_SUPPORTED) |
/* Pick out the correct pixels for the interlace pass. |
* The basic idea here is to go through the row with a source |
* pointer and a destination pointer (sp and dp), and copy the |
* correct pixels for the pass. As the row gets compacted, |
* sp will always be >= dp, so we should never overwrite anything. |
* See the default: case for the easiest code to understand. |
*/ |
void /* PRIVATE */ |
png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
/* start of interlace block */ |
int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; |
/* offset to next interlace block */ |
int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
#endif |
png_debug(1, "in png_do_write_interlace\n"); |
/* we don't have to do anything on the last pass (6) */ |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
if (row != NULL && row_info != NULL && pass < 6) |
#else |
if (pass < 6) |
#endif |
{ |
/* each pixel depth is handled separately */ |
switch (row_info->pixel_depth) |
{ |
case 1: |
{ |
png_bytep sp; |
png_bytep dp; |
int shift; |
int d; |
int value; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
dp = row; |
d = 0; |
shift = 7; |
for (i = png_pass_start[pass]; i < row_width; |
i += png_pass_inc[pass]) |
{ |
sp = row + (png_size_t)(i >> 3); |
value = (int)(*sp >> (7 - (int)(i & 0x07))) & 0x01; |
d |= (value << shift); |
if (shift == 0) |
{ |
shift = 7; |
*dp++ = (png_byte)d; |
d = 0; |
} |
else |
shift--; |
} |
if (shift != 7) |
*dp = (png_byte)d; |
break; |
} |
case 2: |
{ |
png_bytep sp; |
png_bytep dp; |
int shift; |
int d; |
int value; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
dp = row; |
shift = 6; |
d = 0; |
for (i = png_pass_start[pass]; i < row_width; |
i += png_pass_inc[pass]) |
{ |
sp = row + (png_size_t)(i >> 2); |
value = (*sp >> ((3 - (int)(i & 0x03)) << 1)) & 0x03; |
d |= (value << shift); |
if (shift == 0) |
{ |
shift = 6; |
*dp++ = (png_byte)d; |
d = 0; |
} |
else |
shift -= 2; |
} |
if (shift != 6) |
*dp = (png_byte)d; |
break; |
} |
case 4: |
{ |
png_bytep sp; |
png_bytep dp; |
int shift; |
int d; |
int value; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
dp = row; |
shift = 4; |
d = 0; |
for (i = png_pass_start[pass]; i < row_width; |
i += png_pass_inc[pass]) |
{ |
sp = row + (png_size_t)(i >> 1); |
value = (*sp >> ((1 - (int)(i & 0x01)) << 2)) & 0x0f; |
d |= (value << shift); |
if (shift == 0) |
{ |
shift = 4; |
*dp++ = (png_byte)d; |
d = 0; |
} |
else |
shift -= 4; |
} |
if (shift != 4) |
*dp = (png_byte)d; |
break; |
} |
default: |
{ |
png_bytep sp; |
png_bytep dp; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
png_size_t pixel_bytes; |
/* start at the beginning */ |
dp = row; |
/* find out how many bytes each pixel takes up */ |
pixel_bytes = (row_info->pixel_depth >> 3); |
/* loop through the row, only looking at the pixels that |
matter */ |
for (i = png_pass_start[pass]; i < row_width; |
i += png_pass_inc[pass]) |
{ |
/* find out where the original pixel is */ |
sp = row + (png_size_t)i * pixel_bytes; |
/* move the pixel */ |
if (dp != sp) |
png_memcpy(dp, sp, pixel_bytes); |
/* next pixel */ |
dp += pixel_bytes; |
} |
break; |
} |
} |
/* set new row width */ |
row_info->width = (row_info->width + |
png_pass_inc[pass] - 1 - |
png_pass_start[pass]) / |
png_pass_inc[pass]; |
row_info->rowbytes = ((row_info->width * |
row_info->pixel_depth + 7) >> 3); |
} |
} |
#endif |
/* This filters the row, chooses which filter to use, if it has not already |
* been specified by the application, and then writes the row out with the |
* chosen filter. |
*/ |
#define PNG_MAXSUM (~((png_uint_32)0) >> 1) |
#define PNG_HISHIFT 10 |
#define PNG_LOMASK ((png_uint_32)0xffffL) |
#define PNG_HIMASK ((png_uint_32)(~PNG_LOMASK >> PNG_HISHIFT)) |
void /* PRIVATE */ |
png_write_find_filter(png_structp png_ptr, png_row_infop row_info) |
{ |
png_bytep prev_row, best_row, row_buf; |
png_uint_32 mins, bpp; |
png_byte filter_to_do = png_ptr->do_filter; |
png_uint_32 row_bytes = row_info->rowbytes; |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
int num_p_filters = (int)png_ptr->num_prev_filters; |
#endif |
png_debug(1, "in png_write_find_filter\n"); |
/* find out how many bytes offset each pixel is */ |
bpp = (row_info->pixel_depth + 7) / 8; |
prev_row = png_ptr->prev_row; |
best_row = row_buf = png_ptr->row_buf; |
mins = PNG_MAXSUM; |
/* The prediction method we use is to find which method provides the |
* smallest value when summing the absolute values of the distances |
* from zero, using anything >= 128 as negative numbers. This is known |
* as the "minimum sum of absolute differences" heuristic. Other |
* heuristics are the "weighted minimum sum of absolute differences" |
* (experimental and can in theory improve compression), and the "zlib |
* predictive" method (not implemented yet), which does test compressions |
* of lines using different filter methods, and then chooses the |
* (series of) filter(s) that give minimum compressed data size (VERY |
* computationally expensive). |
* |
* GRR 980525: consider also |
* (1) minimum sum of absolute differences from running average (i.e., |
* keep running sum of non-absolute differences & count of bytes) |
* [track dispersion, too? restart average if dispersion too large?] |
* (1b) minimum sum of absolute differences from sliding average, probably |
* with window size <= deflate window (usually 32K) |
* (2) minimum sum of squared differences from zero or running average |
* (i.e., ~ root-mean-square approach) |
*/ |
/* We don't need to test the 'no filter' case if this is the only filter |
* that has been chosen, as it doesn't actually do anything to the data. |
*/ |
if ((filter_to_do & PNG_FILTER_NONE) && |
filter_to_do != PNG_FILTER_NONE) |
{ |
png_bytep rp; |
png_uint_32 sum = 0; |
png_uint_32 i; |
int v; |
for (i = 0, rp = row_buf + 1; i < row_bytes; i++, rp++) |
{ |
v = *rp; |
sum += (v < 128) ? v : 256 - v; |
} |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) |
{ |
png_uint_32 sumhi, sumlo; |
int j; |
sumlo = sum & PNG_LOMASK; |
sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; /* Gives us some footroom */ |
/* Reduce the sum if we match any of the previous rows */ |
for (j = 0; j < num_p_filters; j++) |
{ |
if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE) |
{ |
sumlo = (sumlo * png_ptr->filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
sumhi = (sumhi * png_ptr->filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
} |
} |
/* Factor in the cost of this filter (this is here for completeness, |
* but it makes no sense to have a "cost" for the NONE filter, as |
* it has the minimum possible computational cost - none). |
*/ |
sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >> |
PNG_COST_SHIFT; |
sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >> |
PNG_COST_SHIFT; |
if (sumhi > PNG_HIMASK) |
sum = PNG_MAXSUM; |
else |
sum = (sumhi << PNG_HISHIFT) + sumlo; |
} |
#endif |
mins = sum; |
} |
/* sub filter */ |
if (filter_to_do == PNG_FILTER_SUB) |
/* it's the only filter so no testing is needed */ |
{ |
png_bytep rp, lp, dp; |
png_uint_32 i; |
for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp; |
i++, rp++, dp++) |
{ |
*dp = *rp; |
} |
for (lp = row_buf + 1; i < row_bytes; |
i++, rp++, lp++, dp++) |
{ |
*dp = (png_byte)(((int)*rp - (int)*lp) & 0xff); |
} |
best_row = png_ptr->sub_row; |
} |
else if (filter_to_do & PNG_FILTER_SUB) |
{ |
png_bytep rp, dp, lp; |
png_uint_32 sum = 0, lmins = mins; |
png_uint_32 i; |
int v; |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
/* We temporarily increase the "minimum sum" by the factor we |
* would reduce the sum of this filter, so that we can do the |
* early exit comparison without scaling the sum each time. |
*/ |
if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) |
{ |
int j; |
png_uint_32 lmhi, lmlo; |
lmlo = lmins & PNG_LOMASK; |
lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK; |
for (j = 0; j < num_p_filters; j++) |
{ |
if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB) |
{ |
lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
} |
} |
lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >> |
PNG_COST_SHIFT; |
lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >> |
PNG_COST_SHIFT; |
if (lmhi > PNG_HIMASK) |
lmins = PNG_MAXSUM; |
else |
lmins = (lmhi << PNG_HISHIFT) + lmlo; |
} |
#endif |
for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp; |
i++, rp++, dp++) |
{ |
v = *dp = *rp; |
sum += (v < 128) ? v : 256 - v; |
} |
for (lp = row_buf + 1; i < row_info->rowbytes; |
i++, rp++, lp++, dp++) |
{ |
v = *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff); |
sum += (v < 128) ? v : 256 - v; |
if (sum > lmins) /* We are already worse, don't continue. */ |
break; |
} |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) |
{ |
int j; |
png_uint_32 sumhi, sumlo; |
sumlo = sum & PNG_LOMASK; |
sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; |
for (j = 0; j < num_p_filters; j++) |
{ |
if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB) |
{ |
sumlo = (sumlo * png_ptr->inv_filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
sumhi = (sumhi * png_ptr->inv_filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
} |
} |
sumlo = (sumlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >> |
PNG_COST_SHIFT; |
sumhi = (sumhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >> |
PNG_COST_SHIFT; |
if (sumhi > PNG_HIMASK) |
sum = PNG_MAXSUM; |
else |
sum = (sumhi << PNG_HISHIFT) + sumlo; |
} |
#endif |
if (sum < mins) |
{ |
mins = sum; |
best_row = png_ptr->sub_row; |
} |
} |
/* up filter */ |
if (filter_to_do == PNG_FILTER_UP) |
{ |
png_bytep rp, dp, pp; |
png_uint_32 i; |
for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1, |
pp = prev_row + 1; i < row_bytes; |
i++, rp++, pp++, dp++) |
{ |
*dp = (png_byte)(((int)*rp - (int)*pp) & 0xff); |
} |
best_row = png_ptr->up_row; |
} |
else if (filter_to_do & PNG_FILTER_UP) |
{ |
png_bytep rp, dp, pp; |
png_uint_32 sum = 0, lmins = mins; |
png_uint_32 i; |
int v; |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) |
{ |
int j; |
png_uint_32 lmhi, lmlo; |
lmlo = lmins & PNG_LOMASK; |
lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK; |
for (j = 0; j < num_p_filters; j++) |
{ |
if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP) |
{ |
lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
} |
} |
lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >> |
PNG_COST_SHIFT; |
lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >> |
PNG_COST_SHIFT; |
if (lmhi > PNG_HIMASK) |
lmins = PNG_MAXSUM; |
else |
lmins = (lmhi << PNG_HISHIFT) + lmlo; |
} |
#endif |
for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1, |
pp = prev_row + 1; i < row_bytes; i++) |
{ |
v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff); |
sum += (v < 128) ? v : 256 - v; |
if (sum > lmins) /* We are already worse, don't continue. */ |
break; |
} |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) |
{ |
int j; |
png_uint_32 sumhi, sumlo; |
sumlo = sum & PNG_LOMASK; |
sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; |
for (j = 0; j < num_p_filters; j++) |
{ |
if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP) |
{ |
sumlo = (sumlo * png_ptr->filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
sumhi = (sumhi * png_ptr->filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
} |
} |
sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >> |
PNG_COST_SHIFT; |
sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >> |
PNG_COST_SHIFT; |
if (sumhi > PNG_HIMASK) |
sum = PNG_MAXSUM; |
else |
sum = (sumhi << PNG_HISHIFT) + sumlo; |
} |
#endif |
if (sum < mins) |
{ |
mins = sum; |
best_row = png_ptr->up_row; |
} |
} |
/* avg filter */ |
if (filter_to_do == PNG_FILTER_AVG) |
{ |
png_bytep rp, dp, pp, lp; |
png_uint_32 i; |
for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1, |
pp = prev_row + 1; i < bpp; i++) |
{ |
*dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff); |
} |
for (lp = row_buf + 1; i < row_bytes; i++) |
{ |
*dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) |
& 0xff); |
} |
best_row = png_ptr->avg_row; |
} |
else if (filter_to_do & PNG_FILTER_AVG) |
{ |
png_bytep rp, dp, pp, lp; |
png_uint_32 sum = 0, lmins = mins; |
png_uint_32 i; |
int v; |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) |
{ |
int j; |
png_uint_32 lmhi, lmlo; |
lmlo = lmins & PNG_LOMASK; |
lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK; |
for (j = 0; j < num_p_filters; j++) |
{ |
if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_AVG) |
{ |
lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
} |
} |
lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >> |
PNG_COST_SHIFT; |
lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >> |
PNG_COST_SHIFT; |
if (lmhi > PNG_HIMASK) |
lmins = PNG_MAXSUM; |
else |
lmins = (lmhi << PNG_HISHIFT) + lmlo; |
} |
#endif |
for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1, |
pp = prev_row + 1; i < bpp; i++) |
{ |
v = *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff); |
sum += (v < 128) ? v : 256 - v; |
} |
for (lp = row_buf + 1; i < row_bytes; i++) |
{ |
v = *dp++ = |
(png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) & 0xff); |
sum += (v < 128) ? v : 256 - v; |
if (sum > lmins) /* We are already worse, don't continue. */ |
break; |
} |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) |
{ |
int j; |
png_uint_32 sumhi, sumlo; |
sumlo = sum & PNG_LOMASK; |
sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; |
for (j = 0; j < num_p_filters; j++) |
{ |
if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE) |
{ |
sumlo = (sumlo * png_ptr->filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
sumhi = (sumhi * png_ptr->filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
} |
} |
sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >> |
PNG_COST_SHIFT; |
sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >> |
PNG_COST_SHIFT; |
if (sumhi > PNG_HIMASK) |
sum = PNG_MAXSUM; |
else |
sum = (sumhi << PNG_HISHIFT) + sumlo; |
} |
#endif |
if (sum < mins) |
{ |
mins = sum; |
best_row = png_ptr->avg_row; |
} |
} |
/* Paeth filter */ |
if (filter_to_do == PNG_FILTER_PAETH) |
{ |
png_bytep rp, dp, pp, cp, lp; |
png_uint_32 i; |
for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1, |
pp = prev_row + 1; i < bpp; i++) |
{ |
*dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff); |
} |
for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++) |
{ |
int a, b, c, pa, pb, pc, p; |
b = *pp++; |
c = *cp++; |
a = *lp++; |
p = b - c; |
pc = a - c; |
#ifdef PNG_USE_ABS |
pa = abs(p); |
pb = abs(pc); |
pc = abs(p + pc); |
#else |
pa = p < 0 ? -p : p; |
pb = pc < 0 ? -pc : pc; |
pc = (p + pc) < 0 ? -(p + pc) : p + pc; |
#endif |
p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c; |
*dp++ = (png_byte)(((int)*rp++ - p) & 0xff); |
} |
best_row = png_ptr->paeth_row; |
} |
else if (filter_to_do & PNG_FILTER_PAETH) |
{ |
png_bytep rp, dp, pp, cp, lp; |
png_uint_32 sum = 0, lmins = mins; |
png_uint_32 i; |
int v; |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) |
{ |
int j; |
png_uint_32 lmhi, lmlo; |
lmlo = lmins & PNG_LOMASK; |
lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK; |
for (j = 0; j < num_p_filters; j++) |
{ |
if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH) |
{ |
lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
} |
} |
lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >> |
PNG_COST_SHIFT; |
lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >> |
PNG_COST_SHIFT; |
if (lmhi > PNG_HIMASK) |
lmins = PNG_MAXSUM; |
else |
lmins = (lmhi << PNG_HISHIFT) + lmlo; |
} |
#endif |
for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1, |
pp = prev_row + 1; i < bpp; i++) |
{ |
v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff); |
sum += (v < 128) ? v : 256 - v; |
} |
for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++) |
{ |
int a, b, c, pa, pb, pc, p; |
b = *pp++; |
c = *cp++; |
a = *lp++; |
#ifndef PNG_SLOW_PAETH |
p = b - c; |
pc = a - c; |
#ifdef PNG_USE_ABS |
pa = abs(p); |
pb = abs(pc); |
pc = abs(p + pc); |
#else |
pa = p < 0 ? -p : p; |
pb = pc < 0 ? -pc : pc; |
pc = (p + pc) < 0 ? -(p + pc) : p + pc; |
#endif |
p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c; |
#else /* PNG_SLOW_PAETH */ |
p = a + b - c; |
pa = abs(p - a); |
pb = abs(p - b); |
pc = abs(p - c); |
if (pa <= pb && pa <= pc) |
p = a; |
else if (pb <= pc) |
p = b; |
else |
p = c; |
#endif /* PNG_SLOW_PAETH */ |
v = *dp++ = (png_byte)(((int)*rp++ - p) & 0xff); |
sum += (v < 128) ? v : 256 - v; |
if (sum > lmins) /* We are already worse, don't continue. */ |
break; |
} |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) |
{ |
int j; |
png_uint_32 sumhi, sumlo; |
sumlo = sum & PNG_LOMASK; |
sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; |
for (j = 0; j < num_p_filters; j++) |
{ |
if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH) |
{ |
sumlo = (sumlo * png_ptr->filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
sumhi = (sumhi * png_ptr->filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
} |
} |
sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >> |
PNG_COST_SHIFT; |
sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >> |
PNG_COST_SHIFT; |
if (sumhi > PNG_HIMASK) |
sum = PNG_MAXSUM; |
else |
sum = (sumhi << PNG_HISHIFT) + sumlo; |
} |
#endif |
if (sum < mins) |
{ |
best_row = png_ptr->paeth_row; |
} |
} |
/* Do the actual writing of the filtered row data from the chosen filter. */ |
png_write_filtered_row(png_ptr, best_row); |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
/* Save the type of filter we picked this time for future calculations */ |
if (png_ptr->num_prev_filters > 0) |
{ |
int j; |
for (j = 1; j < num_p_filters; j++) |
{ |
png_ptr->prev_filters[j] = png_ptr->prev_filters[j - 1]; |
} |
png_ptr->prev_filters[j] = best_row[0]; |
} |
#endif |
} |
/* Do the actual writing of a previously filtered row. */ |
void /* PRIVATE */ |
png_write_filtered_row(png_structp png_ptr, png_bytep filtered_row) |
{ |
png_debug(1, "in png_write_filtered_row\n"); |
png_debug1(2, "filter = %d\n", filtered_row[0]); |
/* set up the zlib input buffer */ |
png_ptr->zstream.next_in = filtered_row; |
png_ptr->zstream.avail_in = (uInt)png_ptr->row_info.rowbytes + 1; |
/* repeat until we have compressed all the data */ |
do |
{ |
int ret; /* return of zlib */ |
/* compress the data */ |
ret = deflate(&png_ptr->zstream, Z_NO_FLUSH); |
/* check for compression errors */ |
if (ret != Z_OK) |
{ |
if (png_ptr->zstream.msg != NULL) |
png_error(png_ptr, png_ptr->zstream.msg); |
else |
png_error(png_ptr, "zlib error"); |
} |
/* see if it is time to write another IDAT */ |
if (!(png_ptr->zstream.avail_out)) |
{ |
/* write the IDAT and reset the zlib output buffer */ |
png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size); |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
} |
/* repeat until all data has been compressed */ |
} while (png_ptr->zstream.avail_in); |
/* swap the current and previous rows */ |
if (png_ptr->prev_row != NULL) |
{ |
png_bytep tptr; |
tptr = png_ptr->prev_row; |
png_ptr->prev_row = png_ptr->row_buf; |
png_ptr->row_buf = tptr; |
} |
/* finish row - updates counters and flushes zlib if last row */ |
png_write_finish_row(png_ptr); |
#if defined(PNG_WRITE_FLUSH_SUPPORTED) |
png_ptr->flush_rows++; |
if (png_ptr->flush_dist > 0 && |
png_ptr->flush_rows >= png_ptr->flush_dist) |
{ |
png_write_flush(png_ptr); |
} |
#endif |
} |
#endif /* PNG_WRITE_SUPPORTED */ |
/shark/trunk/ports/png/readme |
---|
0,0 → 1,15 |
Project: S.Ha.R.K. |
PNG Lib and Zlib porting |
Coordinators: |
Giorgio Buttazzo <giorgio@sssup.it> |
Paolo Gai <pj@gandalf.sssup.it> |
Authors: |
Giacomo Guidi <giacomo@gandalf.sssup.it> |
Shark lib to open png graphic files |
/shark/trunk/ports/png/pngasmrd.h |
---|
0,0 → 1,11 |
/* pngasmrd.h - assembler version of utilities to read a PNG file |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 2002 Glenn Randers-Pehrson |
* |
*/ |
/* This file is obsolete in libpng-1.0.9 and later; its contents now appear |
* at the end of pngconf.h. |
*/ |
/shark/trunk/ports/png/pngtest.c |
---|
0,0 → 1,1531 |
/* pngtest.c - a simple test program to test libpng |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
* This program reads in a PNG image, writes it out again, and then |
* compares the two files. If the files are identical, this shows that |
* the basic chunk handling, filtering, and (de)compression code is working |
* properly. It does not currently test all of the transforms, although |
* it probably should. |
* |
* The program will report "FAIL" in certain legitimate cases: |
* 1) when the compression level or filter selection method is changed. |
* 2) when the maximum IDAT size (PNG_ZBUF_SIZE in pngconf.h) is not 8192. |
* 3) unknown unsafe-to-copy ancillary chunks or unknown critical chunks |
* exist in the input file. |
* 4) others not listed here... |
* In these cases, it is best to check with another tool such as "pngcheck" |
* to see what the differences between the two files are. |
* |
* If a filename is given on the command-line, then this file is used |
* for the input, rather than the default "pngtest.png". This allows |
* testing a wide variety of files easily. You can also test a number |
* of files at once by typing "pngtest -m file1.png file2.png ..." |
*/ |
#if defined(_WIN32_WCE) |
# if _WIN32_WCE < 211 |
__error__ (f|w)printf functions are not supported on old WindowsCE.; |
# endif |
# include <windows.h> |
# include <stdlib.h> |
# define READFILE(file, data, length, check) \ |
if (ReadFile(file, data, length, &check,NULL)) check = 0 |
# define WRITEFILE(file, data, length, check)) \ |
if (WriteFile(file, data, length, &check, NULL)) check = 0 |
# define FCLOSE(file) CloseHandle(file) |
#else |
# include <stdio.h> |
# include <stdlib.h> |
# include <assert.h> |
# define READFILE(file, data, length, check) \ |
check=(png_size_t)fread(data,(png_size_t)1,length,file) |
# define WRITEFILE(file, data, length, check) \ |
check=(png_size_t)fwrite(data,(png_size_t)1, length, file) |
# define FCLOSE(file) fclose(file) |
#endif |
#if defined(PNG_NO_STDIO) |
# if defined(_WIN32_WCE) |
typedef HANDLE png_FILE_p; |
# else |
typedef FILE * png_FILE_p; |
# endif |
#endif |
/* Makes pngtest verbose so we can find problems (needs to be before png.h) */ |
#ifndef PNG_DEBUG |
# define PNG_DEBUG 0 |
#endif |
#if !PNG_DEBUG |
# define SINGLE_ROWBUF_ALLOC /* makes buffer overruns easier to nail */ |
#endif |
/* Turn on CPU timing |
#define PNGTEST_TIMING |
*/ |
#ifdef PNG_NO_FLOATING_POINT_SUPPORTED |
#undef PNGTEST_TIMING |
#endif |
#ifdef PNGTEST_TIMING |
static float t_start, t_stop, t_decode, t_encode, t_misc; |
#include <time.h> |
#endif |
#include "png.h" |
/* Define png_jmpbuf() in case we are using a pre-1.0.6 version of libpng */ |
#ifndef png_jmpbuf |
# define png_jmpbuf(png_ptr) png_ptr->jmpbuf |
#endif |
#ifdef PNGTEST_TIMING |
static float t_start, t_stop, t_decode, t_encode, t_misc; |
#if !defined(PNG_tIME_SUPPORTED) |
#include <time.h> |
#endif |
#endif |
#if defined(PNG_TIME_RFC1123_SUPPORTED) |
static int tIME_chunk_present=0; |
static char tIME_string[30] = "no tIME chunk present in file"; |
#endif |
static int verbose = 0; |
int test_one_file PNGARG((PNG_CONST char *inname, PNG_CONST char *outname)); |
#ifdef __TURBOC__ |
#include <mem.h> |
#endif |
/* defined so I can write to a file on gui/windowing platforms */ |
/* #define STDERR stderr */ |
#define STDERR stdout /* for DOS */ |
/* example of using row callbacks to make a simple progress meter */ |
static int status_pass=1; |
static int status_dots_requested=0; |
static int status_dots=1; |
void |
#ifdef PNG_1_0_X |
PNGAPI |
#endif |
read_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass); |
void |
#ifdef PNG_1_0_X |
PNGAPI |
#endif |
read_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass) |
{ |
if(png_ptr == NULL || row_number > PNG_MAX_UINT) return; |
if(status_pass != pass) |
{ |
cprintf("\n Pass %d: ",pass); |
status_pass = pass; |
status_dots = 31; |
} |
status_dots--; |
if(status_dots == 0) |
{ |
cprintf("\n "); |
status_dots=30; |
} |
cprintf("r"); |
} |
void |
#ifdef PNG_1_0_X |
PNGAPI |
#endif |
write_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass); |
void |
#ifdef PNG_1_0_X |
PNGAPI |
#endif |
write_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass) |
{ |
if(png_ptr == NULL || row_number > PNG_MAX_UINT || pass > 7) return; |
cprintf("w"); |
} |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) |
/* Example of using user transform callback (we don't transform anything, |
but merely examine the row filters. We set this to 256 rather than |
5 in case illegal filter values are present.) */ |
static png_uint_32 filters_used[256]; |
void |
#ifdef PNG_1_0_X |
PNGAPI |
#endif |
count_filters(png_structp png_ptr, png_row_infop row_info, png_bytep data); |
void |
#ifdef PNG_1_0_X |
PNGAPI |
#endif |
count_filters(png_structp png_ptr, png_row_infop row_info, png_bytep data) |
{ |
if(png_ptr != NULL && row_info != NULL) |
++filters_used[*(data-1)]; |
} |
#endif |
#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) |
/* example of using user transform callback (we don't transform anything, |
but merely count the zero samples) */ |
static png_uint_32 zero_samples; |
void |
#ifdef PNG_1_0_X |
PNGAPI |
#endif |
count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data); |
void |
#ifdef PNG_1_0_X |
PNGAPI |
#endif |
count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data) |
{ |
png_bytep dp = data; |
if(png_ptr == NULL)return; |
/* contents of row_info: |
* png_uint_32 width width of row |
* png_uint_32 rowbytes number of bytes in row |
* png_byte color_type color type of pixels |
* png_byte bit_depth bit depth of samples |
* png_byte channels number of channels (1-4) |
* png_byte pixel_depth bits per pixel (depth*channels) |
*/ |
/* counts the number of zero samples (or zero pixels if color_type is 3 */ |
if(row_info->color_type == 0 || row_info->color_type == 3) |
{ |
int pos=0; |
png_uint_32 n, nstop; |
for (n=0, nstop=row_info->width; n<nstop; n++) |
{ |
if(row_info->bit_depth == 1) |
{ |
if(((*dp << pos++ ) & 0x80) == 0) zero_samples++; |
if(pos == 8) |
{ |
pos = 0; |
dp++; |
} |
} |
if(row_info->bit_depth == 2) |
{ |
if(((*dp << (pos+=2)) & 0xc0) == 0) zero_samples++; |
if(pos == 8) |
{ |
pos = 0; |
dp++; |
} |
} |
if(row_info->bit_depth == 4) |
{ |
if(((*dp << (pos+=4)) & 0xf0) == 0) zero_samples++; |
if(pos == 8) |
{ |
pos = 0; |
dp++; |
} |
} |
if(row_info->bit_depth == 8) |
if(*dp++ == 0) zero_samples++; |
if(row_info->bit_depth == 16) |
{ |
if((*dp | *(dp+1)) == 0) zero_samples++; |
dp+=2; |
} |
} |
} |
else /* other color types */ |
{ |
png_uint_32 n, nstop; |
int channel; |
int color_channels = row_info->channels; |
if(row_info->color_type > 3)color_channels--; |
for (n=0, nstop=row_info->width; n<nstop; n++) |
{ |
for (channel = 0; channel < color_channels; channel++) |
{ |
if(row_info->bit_depth == 8) |
if(*dp++ == 0) zero_samples++; |
if(row_info->bit_depth == 16) |
{ |
if((*dp | *(dp+1)) == 0) zero_samples++; |
dp+=2; |
} |
} |
if(row_info->color_type > 3) |
{ |
dp++; |
if(row_info->bit_depth == 16)dp++; |
} |
} |
} |
} |
#endif /* PNG_WRITE_USER_TRANSFORM_SUPPORTED */ |
static int wrote_question = 0; |
#if defined(PNG_NO_STDIO) |
/* START of code to validate stdio-free compilation */ |
/* These copies of the default read/write functions come from pngrio.c and */ |
/* pngwio.c. They allow "don't include stdio" testing of the library. */ |
/* This is the function that does the actual reading of data. If you are |
not reading from a standard C stream, you should create a replacement |
read_data function and use it at run time with png_set_read_fn(), rather |
than changing the library. */ |
#ifndef USE_FAR_KEYWORD |
static void |
pngtest_read_data(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
png_size_t check; |
/* fread() returns 0 on error, so it is OK to store this in a png_size_t |
* instead of an int, which is what fread() actually returns. |
*/ |
READFILE((png_FILE_p)png_ptr->io_ptr, data, length, check); |
if (check != length) |
{ |
png_error(png_ptr, "Read Error!"); |
} |
} |
#else |
/* this is the model-independent version. Since the standard I/O library |
can't handle far buffers in the medium and small models, we have to copy |
the data. |
*/ |
#define NEAR_BUF_SIZE 1024 |
#define MIN(a,b) (a <= b ? a : b) |
static void |
pngtest_read_data(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
int check; |
png_byte *n_data; |
png_FILE_p io_ptr; |
/* Check if data really is near. If so, use usual code. */ |
n_data = (png_byte *)CVT_PTR_NOCHECK(data); |
io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr); |
if ((png_bytep)n_data == data) |
{ |
READFILE(io_ptr, n_data, length, check); |
} |
else |
{ |
png_byte buf[NEAR_BUF_SIZE]; |
png_size_t read, remaining, err; |
check = 0; |
remaining = length; |
do |
{ |
read = MIN(NEAR_BUF_SIZE, remaining); |
READFILE(io_ptr, buf, 1, err); |
png_memcpy(data, buf, read); /* copy far buffer to near buffer */ |
if(err != read) |
break; |
else |
check += err; |
data += read; |
remaining -= read; |
} |
while (remaining != 0); |
} |
if (check != length) |
{ |
png_error(png_ptr, "read Error"); |
} |
} |
#endif /* USE_FAR_KEYWORD */ |
#if defined(PNG_WRITE_FLUSH_SUPPORTED) |
static void |
pngtest_flush(png_structp png_ptr) |
{ |
#if !defined(_WIN32_WCE) |
png_FILE_p io_ptr; |
io_ptr = (png_FILE_p)CVT_PTR((png_ptr->io_ptr)); |
if (io_ptr != NULL) |
fflush(io_ptr); |
#endif |
} |
#endif |
/* This is the function that does the actual writing of data. If you are |
not writing to a standard C stream, you should create a replacement |
write_data function and use it at run time with png_set_write_fn(), rather |
than changing the library. */ |
#ifndef USE_FAR_KEYWORD |
static void |
pngtest_write_data(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
png_uint_32 check; |
WRITEFILE((png_FILE_p)png_ptr->io_ptr, data, length, check); |
if (check != length) |
{ |
png_error(png_ptr, "Write Error"); |
} |
} |
#else |
/* this is the model-independent version. Since the standard I/O library |
can't handle far buffers in the medium and small models, we have to copy |
the data. |
*/ |
#define NEAR_BUF_SIZE 1024 |
#define MIN(a,b) (a <= b ? a : b) |
static void |
pngtest_write_data(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
png_uint_32 check; |
png_byte *near_data; /* Needs to be "png_byte *" instead of "png_bytep" */ |
png_FILE_p io_ptr; |
/* Check if data really is near. If so, use usual code. */ |
near_data = (png_byte *)CVT_PTR_NOCHECK(data); |
io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr); |
if ((png_bytep)near_data == data) |
{ |
WRITEFILE(io_ptr, near_data, length, check); |
} |
else |
{ |
png_byte buf[NEAR_BUF_SIZE]; |
png_size_t written, remaining, err; |
check = 0; |
remaining = length; |
do |
{ |
written = MIN(NEAR_BUF_SIZE, remaining); |
png_memcpy(buf, data, written); /* copy far buffer to near buffer */ |
WRITEFILE(io_ptr, buf, written, err); |
if (err != written) |
break; |
else |
check += err; |
data += written; |
remaining -= written; |
} |
while (remaining != 0); |
} |
if (check != length) |
{ |
png_error(png_ptr, "Write Error"); |
} |
} |
#endif /* USE_FAR_KEYWORD */ |
/* This function is called when there is a warning, but the library thinks |
* it can continue anyway. Replacement functions don't have to do anything |
* here if you don't want to. In the default configuration, png_ptr is |
* not used, but it is passed in case it may be useful. |
*/ |
static void |
pngtest_warning(png_structp png_ptr, png_const_charp message) |
{ |
PNG_CONST char *name = "UNKNOWN (ERROR!)"; |
if (png_ptr != NULL && png_ptr->error_ptr != NULL) |
name = png_ptr->error_ptr; |
cprintf("%s: libpng warning: %s\n", name, message); |
} |
/* This is the default error handling function. Note that replacements for |
* this function MUST NOT RETURN, or the program will likely crash. This |
* function is used by default, or if the program supplies NULL for the |
* error function pointer in png_set_error_fn(). |
*/ |
static void |
pngtest_error(png_structp png_ptr, png_const_charp message) |
{ |
pngtest_warning(png_ptr, message); |
/* We can return because png_error calls the default handler, which is |
* actually OK in this case. */ |
} |
#endif /* PNG_NO_STDIO */ |
/* END of code to validate stdio-free compilation */ |
/* START of code to validate memory allocation and deallocation */ |
#ifdef PNG_USER_MEM_SUPPORTED |
/* Allocate memory. For reasonable files, size should never exceed |
64K. However, zlib may allocate more then 64K if you don't tell |
it not to. See zconf.h and png.h for more information. zlib does |
need to allocate exactly 64K, so whatever you call here must |
have the ability to do that. |
This piece of code can be compiled to validate max 64K allocations |
by setting MAXSEG_64K in zlib zconf.h *or* PNG_MAX_MALLOC_64K. */ |
typedef struct memory_information |
{ |
png_uint_32 size; |
png_voidp pointer; |
struct memory_information FAR *next; |
} memory_information; |
typedef memory_information FAR *memory_infop; |
static memory_infop pinformation = NULL; |
static int current_allocation = 0; |
static int maximum_allocation = 0; |
static int total_allocation = 0; |
static int num_allocations = 0; |
png_voidp png_debug_malloc PNGARG((png_structp png_ptr, png_uint_32 size)); |
void png_debug_free PNGARG((png_structp png_ptr, png_voidp ptr)); |
png_voidp |
png_debug_malloc(png_structp png_ptr, png_uint_32 size) |
{ |
/* png_malloc has already tested for NULL; png_create_struct calls |
png_debug_malloc directly, with png_ptr == NULL which is OK */ |
if (size == 0) |
return (NULL); |
/* This calls the library allocator twice, once to get the requested |
buffer and once to get a new free list entry. */ |
{ |
memory_infop pinfo = (memory_infop)png_malloc_default(png_ptr, |
(png_uint_32)sizeof *pinfo); |
pinfo->size = size; |
current_allocation += size; |
total_allocation += size; |
num_allocations ++; |
if (current_allocation > maximum_allocation) |
maximum_allocation = current_allocation; |
pinfo->pointer = (png_voidp)png_malloc_default(png_ptr, size); |
pinfo->next = pinformation; |
pinformation = pinfo; |
/* Make sure the caller isn't assuming zeroed memory. */ |
png_memset(pinfo->pointer, 0xdd, pinfo->size); |
#if PNG_DEBUG |
if(verbose) |
printf("png_malloc %lu bytes at %x\n",size,pinfo->pointer); |
#endif |
assert(pinfo->size != 12345678); |
return (png_voidp)(pinfo->pointer); |
} |
} |
/* Free a pointer. It is removed from the list at the same time. */ |
void |
png_debug_free(png_structp png_ptr, png_voidp ptr) |
{ |
if (png_ptr == NULL) |
cprintf("NULL pointer to png_debug_free.\n"); |
if (ptr == 0) |
{ |
#if 0 /* This happens all the time. */ |
cprintf("WARNING: freeing NULL pointer\n"); |
#endif |
return; |
} |
/* Unlink the element from the list. */ |
{ |
memory_infop FAR *ppinfo = &pinformation; |
for (;;) |
{ |
memory_infop pinfo = *ppinfo; |
if (pinfo->pointer == ptr) |
{ |
*ppinfo = pinfo->next; |
current_allocation -= pinfo->size; |
if (current_allocation < 0) |
cprintf("Duplicate free of memory\n"); |
/* We must free the list element too, but first kill |
the memory that is to be freed. */ |
png_memset(ptr, 0x55, pinfo->size); |
png_free_default(png_ptr, pinfo); |
pinfo=NULL; |
break; |
} |
if (pinfo->next == NULL) |
{ |
cprintf("Pointer %x not found\n", (unsigned int)ptr); |
break; |
} |
ppinfo = &pinfo->next; |
} |
} |
/* Finally free the data. */ |
#if PNG_DEBUG |
if(verbose) |
cprintf("Freeing %x\n",ptr); |
#endif |
png_free_default(png_ptr, ptr); |
ptr=NULL; |
} |
#endif /* PNG_USER_MEM_SUPPORTED */ |
/* END of code to test memory allocation/deallocation */ |
/* Test one file */ |
int |
test_one_file(PNG_CONST char *inname, PNG_CONST char *outname) |
{ |
static png_FILE_p fpin; |
static png_FILE_p fpout; /* "static" prevents setjmp corruption */ |
png_structp read_ptr; |
png_infop read_info_ptr, end_info_ptr; |
#ifdef PNG_WRITE_SUPPORTED |
png_structp write_ptr; |
png_infop write_info_ptr; |
png_infop write_end_info_ptr; |
#else |
png_structp write_ptr = NULL; |
png_infop write_info_ptr = NULL; |
png_infop write_end_info_ptr = NULL; |
#endif |
png_bytep row_buf; |
png_uint_32 y; |
png_uint_32 width, height; |
int num_pass, pass; |
int bit_depth, color_type; |
#ifdef PNG_SETJMP_SUPPORTED |
#ifdef USE_FAR_KEYWORD |
jmp_buf jmpbuf; |
#endif |
#endif |
#if defined(_WIN32_WCE) |
TCHAR path[MAX_PATH]; |
#endif |
char inbuf[256], outbuf[256]; |
row_buf = NULL; |
#if defined(_WIN32_WCE) |
MultiByteToWideChar(CP_ACP, 0, inname, -1, path, MAX_PATH); |
if ((fpin = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE) |
#else |
if ((fpin = fopen(inname, "rb")) == NULL) |
#endif |
{ |
cprintf("Could not find input file %s\n", inname); |
return (1); |
} |
#if defined(_WIN32_WCE) |
MultiByteToWideChar(CP_ACP, 0, outname, -1, path, MAX_PATH); |
if ((fpout = CreateFile(path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL)) == INVALID_HANDLE_VALUE) |
#else |
if ((fpout = fopen(outname, "wb")) == NULL) |
#endif |
{ |
cprintf("Could not open output file %s\n", outname); |
FCLOSE(fpin); |
return (1); |
} |
png_debug(0, "Allocating read and write structures\n"); |
#ifdef PNG_USER_MEM_SUPPORTED |
read_ptr = png_create_read_struct_2(PNG_LIBPNG_VER_STRING, png_voidp_NULL, |
png_error_ptr_NULL, png_error_ptr_NULL, png_voidp_NULL, |
(png_malloc_ptr)png_debug_malloc, (png_free_ptr)png_debug_free); |
#else |
read_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, png_voidp_NULL, |
png_error_ptr_NULL, png_error_ptr_NULL); |
#endif |
#if defined(PNG_NO_STDIO) |
png_set_error_fn(read_ptr, (png_voidp)inname, pngtest_error, |
pngtest_warning); |
#endif |
#ifdef PNG_WRITE_SUPPORTED |
#ifdef PNG_USER_MEM_SUPPORTED |
write_ptr = png_create_write_struct_2(PNG_LIBPNG_VER_STRING, png_voidp_NULL, |
png_error_ptr_NULL, png_error_ptr_NULL, png_voidp_NULL, |
(png_malloc_ptr)png_debug_malloc, (png_free_ptr)png_debug_free); |
#else |
write_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, png_voidp_NULL, |
png_error_ptr_NULL, png_error_ptr_NULL); |
#endif |
#if defined(PNG_NO_STDIO) |
png_set_error_fn(write_ptr, (png_voidp)inname, pngtest_error, |
pngtest_warning); |
#endif |
#endif |
png_debug(0, "Allocating read_info, write_info and end_info structures\n"); |
read_info_ptr = png_create_info_struct(read_ptr); |
end_info_ptr = png_create_info_struct(read_ptr); |
#ifdef PNG_WRITE_SUPPORTED |
write_info_ptr = png_create_info_struct(write_ptr); |
write_end_info_ptr = png_create_info_struct(write_ptr); |
#endif |
#ifdef PNG_SETJMP_SUPPORTED |
png_debug(0, "Setting jmpbuf for read struct\n"); |
#ifdef USE_FAR_KEYWORD |
if (setjmp(jmpbuf)) |
#else |
if (setjmp(png_jmpbuf(read_ptr))) |
#endif |
{ |
cprintf("%s -> %s: libpng read error\n", inname, outname); |
if (row_buf) |
png_free(read_ptr, row_buf); |
png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr); |
#ifdef PNG_WRITE_SUPPORTED |
png_destroy_info_struct(write_ptr, &write_end_info_ptr); |
png_destroy_write_struct(&write_ptr, &write_info_ptr); |
#endif |
FCLOSE(fpin); |
FCLOSE(fpout); |
return (1); |
} |
#ifdef USE_FAR_KEYWORD |
png_memcpy(png_jmpbuf(read_ptr),jmpbuf,sizeof(jmp_buf)); |
#endif |
#ifdef PNG_WRITE_SUPPORTED |
png_debug(0, "Setting jmpbuf for write struct\n"); |
#ifdef USE_FAR_KEYWORD |
if (setjmp(jmpbuf)) |
#else |
if (setjmp(png_jmpbuf(write_ptr))) |
#endif |
{ |
cprintf("%s -> %s: libpng write error\n", inname, outname); |
png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr); |
png_destroy_info_struct(write_ptr, &write_end_info_ptr); |
#ifdef PNG_WRITE_SUPPORTED |
png_destroy_write_struct(&write_ptr, &write_info_ptr); |
#endif |
FCLOSE(fpin); |
FCLOSE(fpout); |
return (1); |
} |
#ifdef USE_FAR_KEYWORD |
png_memcpy(png_jmpbuf(write_ptr),jmpbuf,sizeof(jmp_buf)); |
#endif |
#endif |
#endif |
png_debug(0, "Initializing input and output streams\n"); |
#if !defined(PNG_NO_STDIO) |
png_init_io(read_ptr, fpin); |
# ifdef PNG_WRITE_SUPPORTED |
png_init_io(write_ptr, fpout); |
# endif |
#else |
png_set_read_fn(read_ptr, (png_voidp)fpin, pngtest_read_data); |
# ifdef PNG_WRITE_SUPPORTED |
png_set_write_fn(write_ptr, (png_voidp)fpout, pngtest_write_data, |
# if defined(PNG_WRITE_FLUSH_SUPPORTED) |
pngtest_flush); |
# else |
NULL); |
# endif |
# endif |
#endif |
if(status_dots_requested == 1) |
{ |
#ifdef PNG_WRITE_SUPPORTED |
png_set_write_status_fn(write_ptr, write_row_callback); |
#endif |
png_set_read_status_fn(read_ptr, read_row_callback); |
} |
else |
{ |
#ifdef PNG_WRITE_SUPPORTED |
png_set_write_status_fn(write_ptr, png_write_status_ptr_NULL); |
#endif |
png_set_read_status_fn(read_ptr, png_read_status_ptr_NULL); |
} |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) |
{ |
int i; |
for(i=0; i<256; i++) |
filters_used[i]=0; |
png_set_read_user_transform_fn(read_ptr, count_filters); |
} |
#endif |
#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) |
zero_samples=0; |
png_set_write_user_transform_fn(write_ptr, count_zero_samples); |
#endif |
#define HANDLE_CHUNK_IF_SAFE 2 |
#define HANDLE_CHUNK_ALWAYS 3 |
#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) |
png_set_keep_unknown_chunks(read_ptr, HANDLE_CHUNK_ALWAYS, |
png_bytep_NULL, 0); |
#endif |
#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) |
png_set_keep_unknown_chunks(write_ptr, HANDLE_CHUNK_IF_SAFE, |
png_bytep_NULL, 0); |
#endif |
png_debug(0, "Reading info struct\n"); |
png_read_info(read_ptr, read_info_ptr); |
png_debug(0, "Transferring info struct\n"); |
{ |
int interlace_type, compression_type, filter_type; |
if (png_get_IHDR(read_ptr, read_info_ptr, &width, &height, &bit_depth, |
&color_type, &interlace_type, &compression_type, &filter_type)) |
{ |
png_set_IHDR(write_ptr, write_info_ptr, width, height, bit_depth, |
#if defined(PNG_WRITE_INTERLACING_SUPPORTED) |
color_type, interlace_type, compression_type, filter_type); |
#else |
color_type, PNG_INTERLACE_NONE, compression_type, filter_type); |
#endif |
} |
} |
#if defined(PNG_FIXED_POINT_SUPPORTED) |
#if defined(PNG_cHRM_SUPPORTED) |
{ |
png_fixed_point white_x, white_y, red_x, red_y, green_x, green_y, blue_x, |
blue_y; |
if (png_get_cHRM_fixed(read_ptr, read_info_ptr, &white_x, &white_y, &red_x, |
&red_y, &green_x, &green_y, &blue_x, &blue_y)) |
{ |
png_set_cHRM_fixed(write_ptr, write_info_ptr, white_x, white_y, red_x, |
red_y, green_x, green_y, blue_x, blue_y); |
} |
} |
#endif |
#if defined(PNG_gAMA_SUPPORTED) |
{ |
png_fixed_point gamma; |
if (png_get_gAMA_fixed(read_ptr, read_info_ptr, &gamma)) |
{ |
png_set_gAMA_fixed(write_ptr, write_info_ptr, gamma); |
} |
} |
#endif |
#else /* Use floating point versions */ |
#if defined(PNG_FLOATING_POINT_SUPPORTED) |
#if defined(PNG_cHRM_SUPPORTED) |
{ |
double white_x, white_y, red_x, red_y, green_x, green_y, blue_x, |
blue_y; |
if (png_get_cHRM(read_ptr, read_info_ptr, &white_x, &white_y, &red_x, |
&red_y, &green_x, &green_y, &blue_x, &blue_y)) |
{ |
png_set_cHRM(write_ptr, write_info_ptr, white_x, white_y, red_x, |
red_y, green_x, green_y, blue_x, blue_y); |
} |
} |
#endif |
#if defined(PNG_gAMA_SUPPORTED) |
{ |
double gamma; |
if (png_get_gAMA(read_ptr, read_info_ptr, &gamma)) |
{ |
png_set_gAMA(write_ptr, write_info_ptr, gamma); |
} |
} |
#endif |
#endif /* floating point */ |
#endif /* fixed point */ |
#if defined(PNG_iCCP_SUPPORTED) |
{ |
png_charp name; |
png_charp profile; |
png_uint_32 proflen; |
int compression_type; |
if (png_get_iCCP(read_ptr, read_info_ptr, &name, &compression_type, |
&profile, &proflen)) |
{ |
png_set_iCCP(write_ptr, write_info_ptr, name, compression_type, |
profile, proflen); |
} |
} |
#endif |
#if defined(PNG_sRGB_SUPPORTED) |
{ |
int intent; |
if (png_get_sRGB(read_ptr, read_info_ptr, &intent)) |
{ |
png_set_sRGB(write_ptr, write_info_ptr, intent); |
} |
} |
#endif |
{ |
png_colorp palette; |
int num_palette; |
if (png_get_PLTE(read_ptr, read_info_ptr, &palette, &num_palette)) |
{ |
png_set_PLTE(write_ptr, write_info_ptr, palette, num_palette); |
} |
} |
#if defined(PNG_bKGD_SUPPORTED) |
{ |
png_color_16p background; |
if (png_get_bKGD(read_ptr, read_info_ptr, &background)) |
{ |
png_set_bKGD(write_ptr, write_info_ptr, background); |
} |
} |
#endif |
#if defined(PNG_hIST_SUPPORTED) |
{ |
png_uint_16p hist; |
if (png_get_hIST(read_ptr, read_info_ptr, &hist)) |
{ |
png_set_hIST(write_ptr, write_info_ptr, hist); |
} |
} |
#endif |
#if defined(PNG_oFFs_SUPPORTED) |
{ |
png_int_32 offset_x, offset_y; |
int unit_type; |
if (png_get_oFFs(read_ptr, read_info_ptr,&offset_x,&offset_y,&unit_type)) |
{ |
png_set_oFFs(write_ptr, write_info_ptr, offset_x, offset_y, unit_type); |
} |
} |
#endif |
#if defined(PNG_pCAL_SUPPORTED) |
{ |
png_charp purpose, units; |
png_charpp params; |
png_int_32 X0, X1; |
int type, nparams; |
if (png_get_pCAL(read_ptr, read_info_ptr, &purpose, &X0, &X1, &type, |
&nparams, &units, ¶ms)) |
{ |
png_set_pCAL(write_ptr, write_info_ptr, purpose, X0, X1, type, |
nparams, units, params); |
} |
} |
#endif |
#if defined(PNG_pHYs_SUPPORTED) |
{ |
png_uint_32 res_x, res_y; |
int unit_type; |
if (png_get_pHYs(read_ptr, read_info_ptr, &res_x, &res_y, &unit_type)) |
{ |
png_set_pHYs(write_ptr, write_info_ptr, res_x, res_y, unit_type); |
} |
} |
#endif |
#if defined(PNG_sBIT_SUPPORTED) |
{ |
png_color_8p sig_bit; |
if (png_get_sBIT(read_ptr, read_info_ptr, &sig_bit)) |
{ |
png_set_sBIT(write_ptr, write_info_ptr, sig_bit); |
} |
} |
#endif |
#if defined(PNG_sCAL_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
{ |
int unit; |
double scal_width, scal_height; |
if (png_get_sCAL(read_ptr, read_info_ptr, &unit, &scal_width, |
&scal_height)) |
{ |
png_set_sCAL(write_ptr, write_info_ptr, unit, scal_width, scal_height); |
} |
} |
#else |
#ifdef PNG_FIXED_POINT_SUPPORTED |
{ |
int unit; |
png_charp scal_width, scal_height; |
if (png_get_sCAL_s(read_ptr, read_info_ptr, &unit, &scal_width, |
&scal_height)) |
{ |
png_set_sCAL_s(write_ptr, write_info_ptr, unit, scal_width, scal_height); |
} |
} |
#endif |
#endif |
#endif |
#if defined(PNG_TEXT_SUPPORTED) |
{ |
png_textp text_ptr; |
int num_text; |
if (png_get_text(read_ptr, read_info_ptr, &text_ptr, &num_text) > 0) |
{ |
png_debug1(0, "Handling %d iTXt/tEXt/zTXt chunks\n", num_text); |
png_set_text(write_ptr, write_info_ptr, text_ptr, num_text); |
} |
} |
#endif |
#if defined(PNG_tIME_SUPPORTED) |
{ |
png_timep mod_time; |
if (png_get_tIME(read_ptr, read_info_ptr, &mod_time)) |
{ |
png_set_tIME(write_ptr, write_info_ptr, mod_time); |
#if defined(PNG_TIME_RFC1123_SUPPORTED) |
/* we have to use png_strcpy instead of "=" because the string |
pointed to by png_convert_to_rfc1123() gets free'ed before |
we use it */ |
png_strcpy(tIME_string,png_convert_to_rfc1123(read_ptr, mod_time)); |
tIME_chunk_present++; |
#endif /* PNG_TIME_RFC1123_SUPPORTED */ |
} |
} |
#endif |
#if defined(PNG_tRNS_SUPPORTED) |
{ |
png_bytep trans; |
int num_trans; |
png_color_16p trans_values; |
if (png_get_tRNS(read_ptr, read_info_ptr, &trans, &num_trans, |
&trans_values)) |
{ |
png_set_tRNS(write_ptr, write_info_ptr, trans, num_trans, |
trans_values); |
} |
} |
#endif |
#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) |
{ |
png_unknown_chunkp unknowns; |
int num_unknowns = (int)png_get_unknown_chunks(read_ptr, read_info_ptr, |
&unknowns); |
if (num_unknowns) |
{ |
png_size_t i; |
png_set_unknown_chunks(write_ptr, write_info_ptr, unknowns, |
num_unknowns); |
/* copy the locations from the read_info_ptr. The automatically |
generated locations in write_info_ptr are wrong because we |
haven't written anything yet */ |
for (i = 0; i < (png_size_t)num_unknowns; i++) |
png_set_unknown_chunk_location(write_ptr, write_info_ptr, i, |
unknowns[i].location); |
} |
} |
#endif |
#ifdef PNG_WRITE_SUPPORTED |
png_debug(0, "\nWriting info struct\n"); |
/* If we wanted, we could write info in two steps: |
png_write_info_before_PLTE(write_ptr, write_info_ptr); |
*/ |
png_write_info(write_ptr, write_info_ptr); |
#endif |
#ifdef SINGLE_ROWBUF_ALLOC |
png_debug(0, "\nAllocating row buffer..."); |
row_buf = (png_bytep)png_malloc(read_ptr, |
png_get_rowbytes(read_ptr, read_info_ptr)); |
png_debug1(0, "0x%08lx\n\n", (unsigned long)row_buf); |
#endif /* SINGLE_ROWBUF_ALLOC */ |
png_debug(0, "Writing row data\n"); |
#if defined(PNG_READ_INTERLACING_SUPPORTED) || \ |
defined(PNG_WRITE_INTERLACING_SUPPORTED) |
num_pass = png_set_interlace_handling(read_ptr); |
# ifdef PNG_WRITE_SUPPORTED |
png_set_interlace_handling(write_ptr); |
# endif |
#else |
num_pass=1; |
#endif |
#ifdef PNGTEST_TIMING |
t_stop = (float)clock(); |
t_misc += (t_stop - t_start); |
t_start = t_stop; |
#endif |
for (pass = 0; pass < num_pass; pass++) |
{ |
png_debug1(0, "Writing row data for pass %d\n",pass); |
for (y = 0; y < height; y++) |
{ |
#ifndef SINGLE_ROWBUF_ALLOC |
png_debug2(0, "\nAllocating row buffer (pass %d, y = %ld)...", pass,y); |
row_buf = (png_bytep)png_malloc(read_ptr, |
png_get_rowbytes(read_ptr, read_info_ptr)); |
png_debug2(0, "0x%08lx (%ld bytes)\n", (unsigned long)row_buf, |
png_get_rowbytes(read_ptr, read_info_ptr)); |
#endif /* !SINGLE_ROWBUF_ALLOC */ |
png_read_rows(read_ptr, (png_bytepp)&row_buf, png_bytepp_NULL, 1); |
#ifdef PNG_WRITE_SUPPORTED |
#ifdef PNGTEST_TIMING |
t_stop = (float)clock(); |
t_decode += (t_stop - t_start); |
t_start = t_stop; |
#endif |
png_write_rows(write_ptr, (png_bytepp)&row_buf, 1); |
#ifdef PNGTEST_TIMING |
t_stop = (float)clock(); |
t_encode += (t_stop - t_start); |
t_start = t_stop; |
#endif |
#endif /* PNG_WRITE_SUPPORTED */ |
#ifndef SINGLE_ROWBUF_ALLOC |
png_debug2(0, "Freeing row buffer (pass %d, y = %ld)\n\n", pass, y); |
png_free(read_ptr, row_buf); |
#endif /* !SINGLE_ROWBUF_ALLOC */ |
} |
} |
#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) |
png_free_data(read_ptr, read_info_ptr, PNG_FREE_UNKN, -1); |
#endif |
#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) |
png_free_data(write_ptr, write_info_ptr, PNG_FREE_UNKN, -1); |
#endif |
png_debug(0, "Reading and writing end_info data\n"); |
png_read_end(read_ptr, end_info_ptr); |
#if defined(PNG_TEXT_SUPPORTED) |
{ |
png_textp text_ptr; |
int num_text; |
if (png_get_text(read_ptr, end_info_ptr, &text_ptr, &num_text) > 0) |
{ |
png_debug1(0, "Handling %d iTXt/tEXt/zTXt chunks\n", num_text); |
png_set_text(write_ptr, write_end_info_ptr, text_ptr, num_text); |
} |
} |
#endif |
#if defined(PNG_tIME_SUPPORTED) |
{ |
png_timep mod_time; |
if (png_get_tIME(read_ptr, end_info_ptr, &mod_time)) |
{ |
png_set_tIME(write_ptr, write_end_info_ptr, mod_time); |
#if defined(PNG_TIME_RFC1123_SUPPORTED) |
/* we have to use png_strcpy instead of "=" because the string |
pointed to by png_convert_to_rfc1123() gets free'ed before |
we use it */ |
png_strcpy(tIME_string,png_convert_to_rfc1123(read_ptr, mod_time)); |
tIME_chunk_present++; |
#endif /* PNG_TIME_RFC1123_SUPPORTED */ |
} |
} |
#endif |
#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) |
{ |
png_unknown_chunkp unknowns; |
int num_unknowns; |
num_unknowns = (int)png_get_unknown_chunks(read_ptr, end_info_ptr, |
&unknowns); |
if (num_unknowns) |
{ |
png_size_t i; |
png_set_unknown_chunks(write_ptr, write_end_info_ptr, unknowns, |
num_unknowns); |
/* copy the locations from the read_info_ptr. The automatically |
generated locations in write_end_info_ptr are wrong because we |
haven't written the end_info yet */ |
for (i = 0; i < (png_size_t)num_unknowns; i++) |
png_set_unknown_chunk_location(write_ptr, write_end_info_ptr, i, |
unknowns[i].location); |
} |
} |
#endif |
#ifdef PNG_WRITE_SUPPORTED |
png_write_end(write_ptr, write_end_info_ptr); |
#endif |
#ifdef PNG_EASY_ACCESS_SUPPORTED |
if(verbose) |
{ |
png_uint_32 iwidth, iheight; |
iwidth = png_get_image_width(write_ptr, write_info_ptr); |
iheight = png_get_image_height(write_ptr, write_info_ptr); |
cprintf("Image width = %lu, height = %lu\n", |
iwidth, iheight); |
} |
#endif |
png_debug(0, "Destroying data structs\n"); |
#ifdef SINGLE_ROWBUF_ALLOC |
png_debug(1, "destroying row_buf for read_ptr\n"); |
png_free(read_ptr, row_buf); |
row_buf=NULL; |
#endif /* SINGLE_ROWBUF_ALLOC */ |
png_debug(1, "destroying read_ptr, read_info_ptr, end_info_ptr\n"); |
png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr); |
#ifdef PNG_WRITE_SUPPORTED |
png_debug(1, "destroying write_end_info_ptr\n"); |
png_destroy_info_struct(write_ptr, &write_end_info_ptr); |
png_debug(1, "destroying write_ptr, write_info_ptr\n"); |
png_destroy_write_struct(&write_ptr, &write_info_ptr); |
#endif |
png_debug(0, "Destruction complete.\n"); |
FCLOSE(fpin); |
FCLOSE(fpout); |
png_debug(0, "Opening files for comparison\n"); |
#if defined(_WIN32_WCE) |
MultiByteToWideChar(CP_ACP, 0, inname, -1, path, MAX_PATH); |
if ((fpin = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE) |
#else |
if ((fpin = fopen(inname, "rb")) == NULL) |
#endif |
{ |
cprintf("Could not find file %s\n", inname); |
return (1); |
} |
#if defined(_WIN32_WCE) |
MultiByteToWideChar(CP_ACP, 0, outname, -1, path, MAX_PATH); |
if ((fpout = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE) |
#else |
if ((fpout = fopen(outname, "rb")) == NULL) |
#endif |
{ |
cprintf("Could not find file %s\n", outname); |
FCLOSE(fpin); |
return (1); |
} |
for(;;) |
{ |
png_size_t num_in, num_out; |
READFILE(fpin, inbuf, 1, num_in); |
READFILE(fpout, outbuf, 1, num_out); |
if (num_in != num_out) |
{ |
cprintf("\nFiles %s and %s are of a different size\n", |
inname, outname); |
if(wrote_question == 0) |
{ |
cprintf(" Was %s written with the same maximum IDAT chunk size (%d bytes),", |
inname,PNG_ZBUF_SIZE); |
cprintf("\n filtering heuristic (libpng default), compression"); |
cprintf(" level (zlib default),\n and zlib version (%s)?\n\n", |
ZLIB_VERSION); |
wrote_question=1; |
} |
FCLOSE(fpin); |
FCLOSE(fpout); |
return (0); |
} |
if (!num_in) |
break; |
if (png_memcmp(inbuf, outbuf, num_in)) |
{ |
cprintf("\nFiles %s and %s are different\n", inname, outname); |
if(wrote_question == 0) |
{ |
cprintf(" Was %s written with the same maximum IDAT chunk size (%d bytes),", |
inname,PNG_ZBUF_SIZE); |
cprintf("\n filtering heuristic (libpng default), compression"); |
cprintf(" level (zlib default),\n and zlib version (%s)?\n\n", |
ZLIB_VERSION); |
wrote_question=1; |
} |
FCLOSE(fpin); |
FCLOSE(fpout); |
return (0); |
} |
} |
FCLOSE(fpin); |
FCLOSE(fpout); |
return (0); |
} |
/* input and output filenames */ |
#ifdef RISCOS |
static PNG_CONST char *inname = "pngtest/png"; |
static PNG_CONST char *outname = "pngout/png"; |
#else |
static PNG_CONST char *inname = "pngtest.png"; |
static PNG_CONST char *outname = "pngout.png"; |
#endif |
int |
main(int argc, char *argv[]) |
{ |
int multiple = 0; |
int ierror = 0; |
cprintf("Testing libpng version %s\n", PNG_LIBPNG_VER_STRING); |
cprintf(" with zlib version %s\n", ZLIB_VERSION); |
cprintf("%s",png_get_copyright(NULL)); |
/* Show the version of libpng used in building the library */ |
cprintf(" library (%lu):%s", png_access_version_number(), |
png_get_header_version(NULL)); |
/* Show the version of libpng used in building the application */ |
cprintf(" pngtest (%lu):%s", (unsigned long)PNG_LIBPNG_VER, |
PNG_HEADER_VERSION_STRING); |
cprintf(" sizeof(png_struct)=%ld, sizeof(png_info)=%ld\n", |
(long)sizeof(png_struct), (long)sizeof(png_info)); |
/* Do some consistency checking on the memory allocation settings, I'm |
not sure this matters, but it is nice to know, the first of these |
tests should be impossible because of the way the macros are set |
in pngconf.h */ |
#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K) |
cprintf(" NOTE: Zlib compiled for max 64k, libpng not\n"); |
#endif |
/* I think the following can happen. */ |
#if !defined(MAXSEG_64K) && defined(PNG_MAX_MALLOC_64K) |
cprintf(" NOTE: libpng compiled for max 64k, zlib not\n"); |
#endif |
if (strcmp(png_libpng_ver, PNG_LIBPNG_VER_STRING)) |
{ |
cprintf("Warning: versions are different between png.h and png.c\n"); |
cprintf(" png.h version: %s\n", PNG_LIBPNG_VER_STRING); |
cprintf(" png.c version: %s\n\n", png_libpng_ver); |
++ierror; |
} |
if (argc > 1) |
{ |
if (strcmp(argv[1], "-m") == 0) |
{ |
multiple = 1; |
status_dots_requested = 0; |
} |
else if (strcmp(argv[1], "-mv") == 0 || |
strcmp(argv[1], "-vm") == 0 ) |
{ |
multiple = 1; |
verbose = 1; |
status_dots_requested = 1; |
} |
else if (strcmp(argv[1], "-v") == 0) |
{ |
verbose = 1; |
status_dots_requested = 1; |
inname = argv[2]; |
} |
else |
{ |
inname = argv[1]; |
status_dots_requested = 0; |
} |
} |
if (!multiple && argc == 3+verbose) |
outname = argv[2+verbose]; |
if ((!multiple && argc > 3+verbose) || (multiple && argc < 2)) |
{ |
cprintf("usage: %s [infile.png] [outfile.png]\n\t%s -m {infile.png}\n", |
argv[0], argv[0]); |
cprintf(" reads/writes one PNG file (without -m) or multiple files (-m)\n"); |
cprintf(" with -m %s is used as a temporary file\n", outname); |
exit(1); |
} |
if (multiple) |
{ |
int i; |
#ifdef PNG_USER_MEM_SUPPORTED |
int allocation_now = current_allocation; |
#endif |
for (i=2; i<argc; ++i) |
{ |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) |
int k; |
#endif |
int kerror; |
cprintf("Testing %s:",argv[i]); |
kerror = test_one_file(argv[i], outname); |
if (kerror == 0) |
{ |
#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) |
cprintf("\n PASS (%lu zero samples)\n",zero_samples); |
#else |
cprintf(" PASS\n"); |
#endif |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) |
for (k=0; k<256; k++) |
if(filters_used[k]) |
cprintf(" Filter %d was used %lu times\n", |
k,filters_used[k]); |
#endif |
#if defined(PNG_TIME_RFC1123_SUPPORTED) |
if(tIME_chunk_present != 0) |
cprintf(" tIME = %s\n",tIME_string); |
tIME_chunk_present = 0; |
#endif /* PNG_TIME_RFC1123_SUPPORTED */ |
} |
else |
{ |
cprintf(" FAIL\n"); |
ierror += kerror; |
} |
#ifdef PNG_USER_MEM_SUPPORTED |
if (allocation_now != current_allocation) |
cprintf("MEMORY ERROR: %d bytes lost\n", |
current_allocation-allocation_now); |
if (current_allocation != 0) |
{ |
memory_infop pinfo = pinformation; |
cprintf("MEMORY ERROR: %d bytes still allocated\n", |
current_allocation); |
while (pinfo != NULL) |
{ |
cprintf(" %lu bytes at %x\n", pinfo->size, |
(unsigned int) pinfo->pointer); |
pinfo = pinfo->next; |
} |
} |
#endif |
} |
#ifdef PNG_USER_MEM_SUPPORTED |
cprintf(" Current memory allocation: %10d bytes\n", |
current_allocation); |
cprintf(" Maximum memory allocation: %10d bytes\n", |
maximum_allocation); |
cprintf(" Total memory allocation: %10d bytes\n", |
total_allocation); |
cprintf(" Number of allocations: %10d\n", |
num_allocations); |
#endif |
} |
else |
{ |
int i; |
for (i=0; i<3; ++i) |
{ |
int kerror; |
#ifdef PNG_USER_MEM_SUPPORTED |
int allocation_now = current_allocation; |
#endif |
if (i == 1) status_dots_requested = 1; |
else if(verbose == 0)status_dots_requested = 0; |
if (i == 0 || verbose == 1 || ierror != 0) |
cprintf("Testing %s:",inname); |
kerror = test_one_file(inname, outname); |
if(kerror == 0) |
{ |
if(verbose == 1 || i == 2) |
{ |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) |
int k; |
#endif |
#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) |
cprintf("\n PASS (%lu zero samples)\n",zero_samples); |
#else |
cprintf(" PASS\n"); |
#endif |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) |
for (k=0; k<256; k++) |
if(filters_used[k]) |
cprintf(" Filter %d was used %lu times\n", |
k,filters_used[k]); |
#endif |
#if defined(PNG_TIME_RFC1123_SUPPORTED) |
if(tIME_chunk_present != 0) |
cprintf(" tIME = %s\n",tIME_string); |
#endif /* PNG_TIME_RFC1123_SUPPORTED */ |
} |
} |
else |
{ |
if(verbose == 0 && i != 2) |
cprintf("Testing %s:",inname); |
cprintf(" FAIL\n"); |
ierror += kerror; |
} |
#ifdef PNG_USER_MEM_SUPPORTED |
if (allocation_now != current_allocation) |
cprintf("MEMORY ERROR: %d bytes lost\n", |
current_allocation-allocation_now); |
if (current_allocation != 0) |
{ |
memory_infop pinfo = pinformation; |
cprintf("MEMORY ERROR: %d bytes still allocated\n", |
current_allocation); |
while (pinfo != NULL) |
{ |
cprintf(" %lu bytes at %x\n", |
pinfo->size, (unsigned int)pinfo->pointer); |
pinfo = pinfo->next; |
} |
} |
#endif |
} |
#ifdef PNG_USER_MEM_SUPPORTED |
cprintf(" Current memory allocation: %10d bytes\n", |
current_allocation); |
cprintf(" Maximum memory allocation: %10d bytes\n", |
maximum_allocation); |
cprintf(" Total memory allocation: %10d bytes\n", |
total_allocation); |
cprintf(" Number of allocations: %10d\n", |
num_allocations); |
#endif |
} |
#ifdef PNGTEST_TIMING |
t_stop = (float)clock(); |
t_misc += (t_stop - t_start); |
t_start = t_stop; |
cprintf(" CPU time used = %.3f seconds", |
(t_misc+t_decode+t_encode)/(float)CLOCKS_PER_SEC); |
cprintf(" (decoding %.3f,\n", |
t_decode/(float)CLOCKS_PER_SEC); |
cprintf(" encoding %.3f ,", |
t_encode/(float)CLOCKS_PER_SEC); |
cprintf(" other %.3f seconds)\n\n", |
t_misc/(float)CLOCKS_PER_SEC); |
#endif |
if (ierror == 0) |
cprintf("libpng passes test\n"); |
else |
cprintf("libpng FAILS test\n"); |
return (int)(ierror != 0); |
} |
/* Generate a compiler error if there is an old png.h in the search path. */ |
typedef version_1_2_5 your_png_h_is_not_version_1_2_5; |
/shark/trunk/ports/png/pngrtran.c |
---|
0,0 → 1,4175 |
/* pngrtran.c - transforms the data in a row for PNG readers |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
* This file contains functions optionally called by an application |
* in order to tell libpng how to handle data when reading a PNG. |
* Transformations that are used in both reading and writing are |
* in pngtrans.c. |
*/ |
#define PNG_INTERNAL |
#include "png.h" |
/* Set the action on getting a CRC error for an ancillary or critical chunk. */ |
void PNGAPI |
png_set_crc_action(png_structp png_ptr, int crit_action, int ancil_action) |
{ |
png_debug(1, "in png_set_crc_action\n"); |
/* Tell libpng how we react to CRC errors in critical chunks */ |
switch (crit_action) |
{ |
case PNG_CRC_NO_CHANGE: /* leave setting as is */ |
break; |
case PNG_CRC_WARN_USE: /* warn/use data */ |
png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK; |
png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE; |
break; |
case PNG_CRC_QUIET_USE: /* quiet/use data */ |
png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK; |
png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE | |
PNG_FLAG_CRC_CRITICAL_IGNORE; |
break; |
case PNG_CRC_WARN_DISCARD: /* not a valid action for critical data */ |
png_warning(png_ptr, "Can't discard critical data on CRC error."); |
case PNG_CRC_ERROR_QUIT: /* error/quit */ |
case PNG_CRC_DEFAULT: |
default: |
png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK; |
break; |
} |
switch (ancil_action) |
{ |
case PNG_CRC_NO_CHANGE: /* leave setting as is */ |
break; |
case PNG_CRC_WARN_USE: /* warn/use data */ |
png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK; |
png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE; |
break; |
case PNG_CRC_QUIET_USE: /* quiet/use data */ |
png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK; |
png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE | |
PNG_FLAG_CRC_ANCILLARY_NOWARN; |
break; |
case PNG_CRC_ERROR_QUIT: /* error/quit */ |
png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK; |
png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_NOWARN; |
break; |
case PNG_CRC_WARN_DISCARD: /* warn/discard data */ |
case PNG_CRC_DEFAULT: |
default: |
png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK; |
break; |
} |
} |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \ |
defined(PNG_FLOATING_POINT_SUPPORTED) |
/* handle alpha and tRNS via a background color */ |
void PNGAPI |
png_set_background(png_structp png_ptr, |
png_color_16p background_color, int background_gamma_code, |
int need_expand, double background_gamma) |
{ |
png_debug(1, "in png_set_background\n"); |
if (background_gamma_code == PNG_BACKGROUND_GAMMA_UNKNOWN) |
{ |
png_warning(png_ptr, "Application must supply a known background gamma"); |
return; |
} |
png_ptr->transformations |= PNG_BACKGROUND; |
png_memcpy(&(png_ptr->background), background_color, sizeof(png_color_16)); |
png_ptr->background_gamma = (float)background_gamma; |
png_ptr->background_gamma_type = (png_byte)(background_gamma_code); |
png_ptr->transformations |= (need_expand ? PNG_BACKGROUND_EXPAND : 0); |
/* Note: if need_expand is set and color_type is either RGB or RGB_ALPHA |
* (in which case need_expand is superfluous anyway), the background color |
* might actually be gray yet not be flagged as such. This is not a problem |
* for the current code, which uses PNG_BACKGROUND_IS_GRAY only to |
* decide when to do the png_do_gray_to_rgb() transformation. |
*/ |
if ((need_expand && !(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) || |
(!need_expand && background_color->red == background_color->green && |
background_color->red == background_color->blue)) |
png_ptr->mode |= PNG_BACKGROUND_IS_GRAY; |
} |
#endif |
#if defined(PNG_READ_16_TO_8_SUPPORTED) |
/* strip 16 bit depth files to 8 bit depth */ |
void PNGAPI |
png_set_strip_16(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_strip_16\n"); |
png_ptr->transformations |= PNG_16_TO_8; |
} |
#endif |
#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED) |
void PNGAPI |
png_set_strip_alpha(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_strip_alpha\n"); |
png_ptr->transformations |= PNG_STRIP_ALPHA; |
} |
#endif |
#if defined(PNG_READ_DITHER_SUPPORTED) |
/* Dither file to 8 bit. Supply a palette, the current number |
* of elements in the palette, the maximum number of elements |
* allowed, and a histogram if possible. If the current number |
* of colors is greater then the maximum number, the palette will be |
* modified to fit in the maximum number. "full_dither" indicates |
* whether we need a dithering cube set up for RGB images, or if we |
* simply are reducing the number of colors in a paletted image. |
*/ |
typedef struct png_dsort_struct |
{ |
struct png_dsort_struct FAR * next; |
png_byte left; |
png_byte right; |
} png_dsort; |
typedef png_dsort FAR * png_dsortp; |
typedef png_dsort FAR * FAR * png_dsortpp; |
void PNGAPI |
png_set_dither(png_structp png_ptr, png_colorp palette, |
int num_palette, int maximum_colors, png_uint_16p histogram, |
int full_dither) |
{ |
png_debug(1, "in png_set_dither\n"); |
png_ptr->transformations |= PNG_DITHER; |
if (!full_dither) |
{ |
int i; |
png_ptr->dither_index = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)(num_palette * sizeof (png_byte))); |
for (i = 0; i < num_palette; i++) |
png_ptr->dither_index[i] = (png_byte)i; |
} |
if (num_palette > maximum_colors) |
{ |
if (histogram != NULL) |
{ |
/* This is easy enough, just throw out the least used colors. |
Perhaps not the best solution, but good enough. */ |
int i; |
/* initialize an array to sort colors */ |
png_ptr->dither_sort = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)(num_palette * sizeof (png_byte))); |
/* initialize the dither_sort array */ |
for (i = 0; i < num_palette; i++) |
png_ptr->dither_sort[i] = (png_byte)i; |
/* Find the least used palette entries by starting a |
bubble sort, and running it until we have sorted |
out enough colors. Note that we don't care about |
sorting all the colors, just finding which are |
least used. */ |
for (i = num_palette - 1; i >= maximum_colors; i--) |
{ |
int done; /* to stop early if the list is pre-sorted */ |
int j; |
done = 1; |
for (j = 0; j < i; j++) |
{ |
if (histogram[png_ptr->dither_sort[j]] |
< histogram[png_ptr->dither_sort[j + 1]]) |
{ |
png_byte t; |
t = png_ptr->dither_sort[j]; |
png_ptr->dither_sort[j] = png_ptr->dither_sort[j + 1]; |
png_ptr->dither_sort[j + 1] = t; |
done = 0; |
} |
} |
if (done) |
break; |
} |
/* swap the palette around, and set up a table, if necessary */ |
if (full_dither) |
{ |
int j = num_palette; |
/* put all the useful colors within the max, but don't |
move the others */ |
for (i = 0; i < maximum_colors; i++) |
{ |
if ((int)png_ptr->dither_sort[i] >= maximum_colors) |
{ |
do |
j--; |
while ((int)png_ptr->dither_sort[j] >= maximum_colors); |
palette[i] = palette[j]; |
} |
} |
} |
else |
{ |
int j = num_palette; |
/* move all the used colors inside the max limit, and |
develop a translation table */ |
for (i = 0; i < maximum_colors; i++) |
{ |
/* only move the colors we need to */ |
if ((int)png_ptr->dither_sort[i] >= maximum_colors) |
{ |
png_color tmp_color; |
do |
j--; |
while ((int)png_ptr->dither_sort[j] >= maximum_colors); |
tmp_color = palette[j]; |
palette[j] = palette[i]; |
palette[i] = tmp_color; |
/* indicate where the color went */ |
png_ptr->dither_index[j] = (png_byte)i; |
png_ptr->dither_index[i] = (png_byte)j; |
} |
} |
/* find closest color for those colors we are not using */ |
for (i = 0; i < num_palette; i++) |
{ |
if ((int)png_ptr->dither_index[i] >= maximum_colors) |
{ |
int min_d, k, min_k, d_index; |
/* find the closest color to one we threw out */ |
d_index = png_ptr->dither_index[i]; |
min_d = PNG_COLOR_DIST(palette[d_index], palette[0]); |
for (k = 1, min_k = 0; k < maximum_colors; k++) |
{ |
int d; |
d = PNG_COLOR_DIST(palette[d_index], palette[k]); |
if (d < min_d) |
{ |
min_d = d; |
min_k = k; |
} |
} |
/* point to closest color */ |
png_ptr->dither_index[i] = (png_byte)min_k; |
} |
} |
} |
png_free(png_ptr, png_ptr->dither_sort); |
png_ptr->dither_sort=NULL; |
} |
else |
{ |
/* This is much harder to do simply (and quickly). Perhaps |
we need to go through a median cut routine, but those |
don't always behave themselves with only a few colors |
as input. So we will just find the closest two colors, |
and throw out one of them (chosen somewhat randomly). |
[We don't understand this at all, so if someone wants to |
work on improving it, be our guest - AED, GRP] |
*/ |
int i; |
int max_d; |
int num_new_palette; |
png_dsortp t; |
png_dsortpp hash; |
t=NULL; |
/* initialize palette index arrays */ |
png_ptr->index_to_palette = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)(num_palette * sizeof (png_byte))); |
png_ptr->palette_to_index = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)(num_palette * sizeof (png_byte))); |
/* initialize the sort array */ |
for (i = 0; i < num_palette; i++) |
{ |
png_ptr->index_to_palette[i] = (png_byte)i; |
png_ptr->palette_to_index[i] = (png_byte)i; |
} |
hash = (png_dsortpp)png_malloc(png_ptr, (png_uint_32)(769 * |
sizeof (png_dsortp))); |
for (i = 0; i < 769; i++) |
hash[i] = NULL; |
/* png_memset(hash, 0, 769 * sizeof (png_dsortp)); */ |
num_new_palette = num_palette; |
/* initial wild guess at how far apart the farthest pixel |
pair we will be eliminating will be. Larger |
numbers mean more areas will be allocated, Smaller |
numbers run the risk of not saving enough data, and |
having to do this all over again. |
I have not done extensive checking on this number. |
*/ |
max_d = 96; |
while (num_new_palette > maximum_colors) |
{ |
for (i = 0; i < num_new_palette - 1; i++) |
{ |
int j; |
for (j = i + 1; j < num_new_palette; j++) |
{ |
int d; |
d = PNG_COLOR_DIST(palette[i], palette[j]); |
if (d <= max_d) |
{ |
t = (png_dsortp)png_malloc_warn(png_ptr, |
(png_uint_32)(sizeof(png_dsort))); |
if (t == NULL) |
break; |
t->next = hash[d]; |
t->left = (png_byte)i; |
t->right = (png_byte)j; |
hash[d] = t; |
} |
} |
if (t == NULL) |
break; |
} |
if (t != NULL) |
for (i = 0; i <= max_d; i++) |
{ |
if (hash[i] != NULL) |
{ |
png_dsortp p; |
for (p = hash[i]; p; p = p->next) |
{ |
if ((int)png_ptr->index_to_palette[p->left] |
< num_new_palette && |
(int)png_ptr->index_to_palette[p->right] |
< num_new_palette) |
{ |
int j, next_j; |
if (num_new_palette & 0x01) |
{ |
j = p->left; |
next_j = p->right; |
} |
else |
{ |
j = p->right; |
next_j = p->left; |
} |
num_new_palette--; |
palette[png_ptr->index_to_palette[j]] |
= palette[num_new_palette]; |
if (!full_dither) |
{ |
int k; |
for (k = 0; k < num_palette; k++) |
{ |
if (png_ptr->dither_index[k] == |
png_ptr->index_to_palette[j]) |
png_ptr->dither_index[k] = |
png_ptr->index_to_palette[next_j]; |
if ((int)png_ptr->dither_index[k] == |
num_new_palette) |
png_ptr->dither_index[k] = |
png_ptr->index_to_palette[j]; |
} |
} |
png_ptr->index_to_palette[png_ptr->palette_to_index |
[num_new_palette]] = png_ptr->index_to_palette[j]; |
png_ptr->palette_to_index[png_ptr->index_to_palette[j]] |
= png_ptr->palette_to_index[num_new_palette]; |
png_ptr->index_to_palette[j] = (png_byte)num_new_palette; |
png_ptr->palette_to_index[num_new_palette] = (png_byte)j; |
} |
if (num_new_palette <= maximum_colors) |
break; |
} |
if (num_new_palette <= maximum_colors) |
break; |
} |
} |
for (i = 0; i < 769; i++) |
{ |
if (hash[i] != NULL) |
{ |
png_dsortp p = hash[i]; |
while (p) |
{ |
t = p->next; |
png_free(png_ptr, p); |
p = t; |
} |
} |
hash[i] = 0; |
} |
max_d += 96; |
} |
png_free(png_ptr, hash); |
png_free(png_ptr, png_ptr->palette_to_index); |
png_free(png_ptr, png_ptr->index_to_palette); |
png_ptr->palette_to_index=NULL; |
png_ptr->index_to_palette=NULL; |
} |
num_palette = maximum_colors; |
} |
if (png_ptr->palette == NULL) |
{ |
png_ptr->palette = palette; |
} |
png_ptr->num_palette = (png_uint_16)num_palette; |
if (full_dither) |
{ |
int i; |
png_bytep distance; |
int total_bits = PNG_DITHER_RED_BITS + PNG_DITHER_GREEN_BITS + |
PNG_DITHER_BLUE_BITS; |
int num_red = (1 << PNG_DITHER_RED_BITS); |
int num_green = (1 << PNG_DITHER_GREEN_BITS); |
int num_blue = (1 << PNG_DITHER_BLUE_BITS); |
png_size_t num_entries = ((png_size_t)1 << total_bits); |
png_ptr->palette_lookup = (png_bytep )png_malloc(png_ptr, |
(png_uint_32)(num_entries * sizeof (png_byte))); |
png_memset(png_ptr->palette_lookup, 0, num_entries * sizeof (png_byte)); |
distance = (png_bytep)png_malloc(png_ptr, (png_uint_32)(num_entries * |
sizeof(png_byte))); |
png_memset(distance, 0xff, num_entries * sizeof(png_byte)); |
for (i = 0; i < num_palette; i++) |
{ |
int ir, ig, ib; |
int r = (palette[i].red >> (8 - PNG_DITHER_RED_BITS)); |
int g = (palette[i].green >> (8 - PNG_DITHER_GREEN_BITS)); |
int b = (palette[i].blue >> (8 - PNG_DITHER_BLUE_BITS)); |
for (ir = 0; ir < num_red; ir++) |
{ |
int dr = abs(ir - r); |
int index_r = (ir << (PNG_DITHER_BLUE_BITS + PNG_DITHER_GREEN_BITS)); |
for (ig = 0; ig < num_green; ig++) |
{ |
int dg = abs(ig - g); |
int dt = dr + dg; |
int dm = ((dr > dg) ? dr : dg); |
int index_g = index_r | (ig << PNG_DITHER_BLUE_BITS); |
for (ib = 0; ib < num_blue; ib++) |
{ |
int d_index = index_g | ib; |
int db = abs(ib - b); |
int dmax = ((dm > db) ? dm : db); |
int d = dmax + dt + db; |
if (d < (int)distance[d_index]) |
{ |
distance[d_index] = (png_byte)d; |
png_ptr->palette_lookup[d_index] = (png_byte)i; |
} |
} |
} |
} |
} |
png_free(png_ptr, distance); |
} |
} |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED) |
/* Transform the image from the file_gamma to the screen_gamma. We |
* only do transformations on images where the file_gamma and screen_gamma |
* are not close reciprocals, otherwise it slows things down slightly, and |
* also needlessly introduces small errors. |
* |
* We will turn off gamma transformation later if no semitransparent entries |
* are present in the tRNS array for palette images. We can't do it here |
* because we don't necessarily have the tRNS chunk yet. |
*/ |
void PNGAPI |
png_set_gamma(png_structp png_ptr, double scrn_gamma, double file_gamma) |
{ |
png_debug(1, "in png_set_gamma\n"); |
if ((fabs(scrn_gamma * file_gamma - 1.0) > PNG_GAMMA_THRESHOLD) || |
(png_ptr->color_type & PNG_COLOR_MASK_ALPHA) || |
(png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)) |
png_ptr->transformations |= PNG_GAMMA; |
png_ptr->gamma = (float)file_gamma; |
png_ptr->screen_gamma = (float)scrn_gamma; |
} |
#endif |
#if defined(PNG_READ_EXPAND_SUPPORTED) |
/* Expand paletted images to RGB, expand grayscale images of |
* less than 8-bit depth to 8-bit depth, and expand tRNS chunks |
* to alpha channels. |
*/ |
void PNGAPI |
png_set_expand(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_expand\n"); |
png_ptr->transformations |= PNG_EXPAND; |
} |
/* GRR 19990627: the following three functions currently are identical |
* to png_set_expand(). However, it is entirely reasonable that someone |
* might wish to expand an indexed image to RGB but *not* expand a single, |
* fully transparent palette entry to a full alpha channel--perhaps instead |
* convert tRNS to the grayscale/RGB format (16-bit RGB value), or replace |
* the transparent color with a particular RGB value, or drop tRNS entirely. |
* IOW, a future version of the library may make the transformations flag |
* a bit more fine-grained, with separate bits for each of these three |
* functions. |
* |
* More to the point, these functions make it obvious what libpng will be |
* doing, whereas "expand" can (and does) mean any number of things. |
*/ |
/* Expand paletted images to RGB. */ |
void PNGAPI |
png_set_palette_to_rgb(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_expand\n"); |
png_ptr->transformations |= PNG_EXPAND; |
} |
/* Expand grayscale images of less than 8-bit depth to 8 bits. */ |
void PNGAPI |
png_set_gray_1_2_4_to_8(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_expand\n"); |
png_ptr->transformations |= PNG_EXPAND; |
} |
/* Expand tRNS chunks to alpha channels. */ |
void PNGAPI |
png_set_tRNS_to_alpha(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_expand\n"); |
png_ptr->transformations |= PNG_EXPAND; |
} |
#endif /* defined(PNG_READ_EXPAND_SUPPORTED) */ |
#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) |
void PNGAPI |
png_set_gray_to_rgb(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_gray_to_rgb\n"); |
png_ptr->transformations |= PNG_GRAY_TO_RGB; |
} |
#endif |
#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) |
#if defined(PNG_FLOATING_POINT_SUPPORTED) |
/* Convert a RGB image to a grayscale of the same width. This allows us, |
* for example, to convert a 24 bpp RGB image into an 8 bpp grayscale image. |
*/ |
void PNGAPI |
png_set_rgb_to_gray(png_structp png_ptr, int error_action, double red, |
double green) |
{ |
int red_fixed = (int)((float)red*100000.0 + 0.5); |
int green_fixed = (int)((float)green*100000.0 + 0.5); |
png_set_rgb_to_gray_fixed(png_ptr, error_action, red_fixed, green_fixed); |
} |
#endif |
void PNGAPI |
png_set_rgb_to_gray_fixed(png_structp png_ptr, int error_action, |
png_fixed_point red, png_fixed_point green) |
{ |
png_debug(1, "in png_set_rgb_to_gray\n"); |
switch(error_action) |
{ |
case 1: png_ptr->transformations |= PNG_RGB_TO_GRAY; |
break; |
case 2: png_ptr->transformations |= PNG_RGB_TO_GRAY_WARN; |
break; |
case 3: png_ptr->transformations |= PNG_RGB_TO_GRAY_ERR; |
} |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
#if defined(PNG_READ_EXPAND_SUPPORTED) |
png_ptr->transformations |= PNG_EXPAND; |
#else |
{ |
png_warning(png_ptr, "Cannot do RGB_TO_GRAY without EXPAND_SUPPORTED."); |
png_ptr->transformations &= ~PNG_RGB_TO_GRAY; |
} |
#endif |
{ |
png_uint_16 red_int, green_int; |
if(red < 0 || green < 0) |
{ |
red_int = 6968; /* .212671 * 32768 + .5 */ |
green_int = 23434; /* .715160 * 32768 + .5 */ |
} |
else if(red + green < 100000L) |
{ |
red_int = (png_uint_16)(((png_uint_32)red*32768L)/100000L); |
green_int = (png_uint_16)(((png_uint_32)green*32768L)/100000L); |
} |
else |
{ |
png_warning(png_ptr, "ignoring out of range rgb_to_gray coefficients"); |
red_int = 6968; |
green_int = 23434; |
} |
png_ptr->rgb_to_gray_red_coeff = red_int; |
png_ptr->rgb_to_gray_green_coeff = green_int; |
png_ptr->rgb_to_gray_blue_coeff = (png_uint_16)(32768-red_int-green_int); |
} |
} |
#endif |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ |
defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ |
defined(PNG_LEGACY_SUPPORTED) |
void PNGAPI |
png_set_read_user_transform_fn(png_structp png_ptr, png_user_transform_ptr |
read_user_transform_fn) |
{ |
png_debug(1, "in png_set_read_user_transform_fn\n"); |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) |
png_ptr->transformations |= PNG_USER_TRANSFORM; |
png_ptr->read_user_transform_fn = read_user_transform_fn; |
#endif |
#ifdef PNG_LEGACY_SUPPORTED |
if(read_user_transform_fn) |
png_warning(png_ptr, |
"This version of libpng does not support user transforms"); |
#endif |
} |
#endif |
/* Initialize everything needed for the read. This includes modifying |
* the palette. |
*/ |
void /* PRIVATE */ |
png_init_read_transformations(png_structp png_ptr) |
{ |
png_debug(1, "in png_init_read_transformations\n"); |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
if(png_ptr != NULL) |
#endif |
{ |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) || defined(PNG_READ_SHIFT_SUPPORTED) \ |
|| defined(PNG_READ_GAMMA_SUPPORTED) |
int color_type = png_ptr->color_type; |
#endif |
#if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED) |
if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) && |
(png_ptr->transformations & PNG_EXPAND)) |
{ |
if (!(color_type & PNG_COLOR_MASK_COLOR)) /* i.e., GRAY or GRAY_ALPHA */ |
{ |
/* expand background chunk. */ |
switch (png_ptr->bit_depth) |
{ |
case 1: |
png_ptr->background.gray *= (png_uint_16)0xff; |
png_ptr->background.red = png_ptr->background.green |
= png_ptr->background.blue = png_ptr->background.gray; |
break; |
case 2: |
png_ptr->background.gray *= (png_uint_16)0x55; |
png_ptr->background.red = png_ptr->background.green |
= png_ptr->background.blue = png_ptr->background.gray; |
break; |
case 4: |
png_ptr->background.gray *= (png_uint_16)0x11; |
png_ptr->background.red = png_ptr->background.green |
= png_ptr->background.blue = png_ptr->background.gray; |
break; |
case 8: |
case 16: |
png_ptr->background.red = png_ptr->background.green |
= png_ptr->background.blue = png_ptr->background.gray; |
break; |
} |
} |
else if (color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
png_ptr->background.red = |
png_ptr->palette[png_ptr->background.index].red; |
png_ptr->background.green = |
png_ptr->palette[png_ptr->background.index].green; |
png_ptr->background.blue = |
png_ptr->palette[png_ptr->background.index].blue; |
#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) |
if (png_ptr->transformations & PNG_INVERT_ALPHA) |
{ |
#if defined(PNG_READ_EXPAND_SUPPORTED) |
if (!(png_ptr->transformations & PNG_EXPAND)) |
#endif |
{ |
/* invert the alpha channel (in tRNS) unless the pixels are |
going to be expanded, in which case leave it for later */ |
int i,istop; |
istop=(int)png_ptr->num_trans; |
for (i=0; i<istop; i++) |
png_ptr->trans[i] = (png_byte)(255 - png_ptr->trans[i]); |
} |
} |
#endif |
} |
} |
#endif |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED) |
png_ptr->background_1 = png_ptr->background; |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED) |
if ((color_type == PNG_COLOR_TYPE_PALETTE && png_ptr->num_trans != 0) |
&& (fabs(png_ptr->screen_gamma * png_ptr->gamma - 1.0) |
< PNG_GAMMA_THRESHOLD)) |
{ |
int i,k; |
k=0; |
for (i=0; i<png_ptr->num_trans; i++) |
{ |
if (png_ptr->trans[i] != 0 && png_ptr->trans[i] != 0xff) |
k=1; /* partial transparency is present */ |
} |
if (k == 0) |
png_ptr->transformations &= (~PNG_GAMMA); |
} |
if (png_ptr->transformations & (PNG_GAMMA | PNG_RGB_TO_GRAY)) |
{ |
png_build_gamma_table(png_ptr); |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) |
if (png_ptr->transformations & PNG_BACKGROUND) |
{ |
if (color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
/* could skip if no transparency and |
*/ |
png_color back, back_1; |
png_colorp palette = png_ptr->palette; |
int num_palette = png_ptr->num_palette; |
int i; |
if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE) |
{ |
back.red = png_ptr->gamma_table[png_ptr->background.red]; |
back.green = png_ptr->gamma_table[png_ptr->background.green]; |
back.blue = png_ptr->gamma_table[png_ptr->background.blue]; |
back_1.red = png_ptr->gamma_to_1[png_ptr->background.red]; |
back_1.green = png_ptr->gamma_to_1[png_ptr->background.green]; |
back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue]; |
} |
else |
{ |
double g, gs; |
switch (png_ptr->background_gamma_type) |
{ |
case PNG_BACKGROUND_GAMMA_SCREEN: |
g = (png_ptr->screen_gamma); |
gs = 1.0; |
break; |
case PNG_BACKGROUND_GAMMA_FILE: |
g = 1.0 / (png_ptr->gamma); |
gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma); |
break; |
case PNG_BACKGROUND_GAMMA_UNIQUE: |
g = 1.0 / (png_ptr->background_gamma); |
gs = 1.0 / (png_ptr->background_gamma * |
png_ptr->screen_gamma); |
break; |
default: |
g = 1.0; /* back_1 */ |
gs = 1.0; /* back */ |
} |
if ( fabs(gs - 1.0) < PNG_GAMMA_THRESHOLD) |
{ |
back.red = (png_byte)png_ptr->background.red; |
back.green = (png_byte)png_ptr->background.green; |
back.blue = (png_byte)png_ptr->background.blue; |
} |
else |
{ |
back.red = (png_byte)(pow( |
(double)png_ptr->background.red/255, gs) * 255.0 + .5); |
back.green = (png_byte)(pow( |
(double)png_ptr->background.green/255, gs) * 255.0 + .5); |
back.blue = (png_byte)(pow( |
(double)png_ptr->background.blue/255, gs) * 255.0 + .5); |
} |
back_1.red = (png_byte)(pow( |
(double)png_ptr->background.red/255, g) * 255.0 + .5); |
back_1.green = (png_byte)(pow( |
(double)png_ptr->background.green/255, g) * 255.0 + .5); |
back_1.blue = (png_byte)(pow( |
(double)png_ptr->background.blue/255, g) * 255.0 + .5); |
} |
for (i = 0; i < num_palette; i++) |
{ |
if (i < (int)png_ptr->num_trans && png_ptr->trans[i] != 0xff) |
{ |
if (png_ptr->trans[i] == 0) |
{ |
palette[i] = back; |
} |
else /* if (png_ptr->trans[i] != 0xff) */ |
{ |
png_byte v, w; |
v = png_ptr->gamma_to_1[palette[i].red]; |
png_composite(w, v, png_ptr->trans[i], back_1.red); |
palette[i].red = png_ptr->gamma_from_1[w]; |
v = png_ptr->gamma_to_1[palette[i].green]; |
png_composite(w, v, png_ptr->trans[i], back_1.green); |
palette[i].green = png_ptr->gamma_from_1[w]; |
v = png_ptr->gamma_to_1[palette[i].blue]; |
png_composite(w, v, png_ptr->trans[i], back_1.blue); |
palette[i].blue = png_ptr->gamma_from_1[w]; |
} |
} |
else |
{ |
palette[i].red = png_ptr->gamma_table[palette[i].red]; |
palette[i].green = png_ptr->gamma_table[palette[i].green]; |
palette[i].blue = png_ptr->gamma_table[palette[i].blue]; |
} |
} |
} |
/* if (png_ptr->background_gamma_type!=PNG_BACKGROUND_GAMMA_UNKNOWN) */ |
else |
/* color_type != PNG_COLOR_TYPE_PALETTE */ |
{ |
double m = (double)(((png_uint_32)1 << png_ptr->bit_depth) - 1); |
double g = 1.0; |
double gs = 1.0; |
switch (png_ptr->background_gamma_type) |
{ |
case PNG_BACKGROUND_GAMMA_SCREEN: |
g = (png_ptr->screen_gamma); |
gs = 1.0; |
break; |
case PNG_BACKGROUND_GAMMA_FILE: |
g = 1.0 / (png_ptr->gamma); |
gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma); |
break; |
case PNG_BACKGROUND_GAMMA_UNIQUE: |
g = 1.0 / (png_ptr->background_gamma); |
gs = 1.0 / (png_ptr->background_gamma * |
png_ptr->screen_gamma); |
break; |
} |
png_ptr->background_1.gray = (png_uint_16)(pow( |
(double)png_ptr->background.gray / m, g) * m + .5); |
png_ptr->background.gray = (png_uint_16)(pow( |
(double)png_ptr->background.gray / m, gs) * m + .5); |
if ((png_ptr->background.red != png_ptr->background.green) || |
(png_ptr->background.red != png_ptr->background.blue) || |
(png_ptr->background.red != png_ptr->background.gray)) |
{ |
/* RGB or RGBA with color background */ |
png_ptr->background_1.red = (png_uint_16)(pow( |
(double)png_ptr->background.red / m, g) * m + .5); |
png_ptr->background_1.green = (png_uint_16)(pow( |
(double)png_ptr->background.green / m, g) * m + .5); |
png_ptr->background_1.blue = (png_uint_16)(pow( |
(double)png_ptr->background.blue / m, g) * m + .5); |
png_ptr->background.red = (png_uint_16)(pow( |
(double)png_ptr->background.red / m, gs) * m + .5); |
png_ptr->background.green = (png_uint_16)(pow( |
(double)png_ptr->background.green / m, gs) * m + .5); |
png_ptr->background.blue = (png_uint_16)(pow( |
(double)png_ptr->background.blue / m, gs) * m + .5); |
} |
else |
{ |
/* GRAY, GRAY ALPHA, RGB, or RGBA with gray background */ |
png_ptr->background_1.red = png_ptr->background_1.green |
= png_ptr->background_1.blue = png_ptr->background_1.gray; |
png_ptr->background.red = png_ptr->background.green |
= png_ptr->background.blue = png_ptr->background.gray; |
} |
} |
} |
else |
/* transformation does not include PNG_BACKGROUND */ |
#endif /* PNG_READ_BACKGROUND_SUPPORTED */ |
if (color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
png_colorp palette = png_ptr->palette; |
int num_palette = png_ptr->num_palette; |
int i; |
for (i = 0; i < num_palette; i++) |
{ |
palette[i].red = png_ptr->gamma_table[palette[i].red]; |
palette[i].green = png_ptr->gamma_table[palette[i].green]; |
palette[i].blue = png_ptr->gamma_table[palette[i].blue]; |
} |
} |
} |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) |
else |
#endif |
#endif /* PNG_READ_GAMMA_SUPPORTED && PNG_FLOATING_POINT_SUPPORTED */ |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) |
/* No GAMMA transformation */ |
if ((png_ptr->transformations & PNG_BACKGROUND) && |
(color_type == PNG_COLOR_TYPE_PALETTE)) |
{ |
int i; |
int istop = (int)png_ptr->num_trans; |
png_color back; |
png_colorp palette = png_ptr->palette; |
back.red = (png_byte)png_ptr->background.red; |
back.green = (png_byte)png_ptr->background.green; |
back.blue = (png_byte)png_ptr->background.blue; |
for (i = 0; i < istop; i++) |
{ |
if (png_ptr->trans[i] == 0) |
{ |
palette[i] = back; |
} |
else if (png_ptr->trans[i] != 0xff) |
{ |
/* The png_composite() macro is defined in png.h */ |
png_composite(palette[i].red, palette[i].red, |
png_ptr->trans[i], back.red); |
png_composite(palette[i].green, palette[i].green, |
png_ptr->trans[i], back.green); |
png_composite(palette[i].blue, palette[i].blue, |
png_ptr->trans[i], back.blue); |
} |
} |
} |
#endif /* PNG_READ_BACKGROUND_SUPPORTED */ |
#if defined(PNG_READ_SHIFT_SUPPORTED) |
if ((png_ptr->transformations & PNG_SHIFT) && |
(color_type == PNG_COLOR_TYPE_PALETTE)) |
{ |
png_uint_16 i; |
png_uint_16 istop = png_ptr->num_palette; |
int sr = 8 - png_ptr->sig_bit.red; |
int sg = 8 - png_ptr->sig_bit.green; |
int sb = 8 - png_ptr->sig_bit.blue; |
if (sr < 0 || sr > 8) |
sr = 0; |
if (sg < 0 || sg > 8) |
sg = 0; |
if (sb < 0 || sb > 8) |
sb = 0; |
for (i = 0; i < istop; i++) |
{ |
png_ptr->palette[i].red >>= sr; |
png_ptr->palette[i].green >>= sg; |
png_ptr->palette[i].blue >>= sb; |
} |
} |
#endif /* PNG_READ_SHIFT_SUPPORTED */ |
} |
#if !defined(PNG_READ_GAMMA_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED) \ |
&& !defined(PNG_READ_BACKGROUND_SUPPORTED) |
if(png_ptr) |
return; |
#endif |
} |
/* Modify the info structure to reflect the transformations. The |
* info should be updated so a PNG file could be written with it, |
* assuming the transformations result in valid PNG data. |
*/ |
void /* PRIVATE */ |
png_read_transform_info(png_structp png_ptr, png_infop info_ptr) |
{ |
png_debug(1, "in png_read_transform_info\n"); |
#if defined(PNG_READ_EXPAND_SUPPORTED) |
if (png_ptr->transformations & PNG_EXPAND) |
{ |
if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
if (png_ptr->num_trans) |
info_ptr->color_type = PNG_COLOR_TYPE_RGB_ALPHA; |
else |
info_ptr->color_type = PNG_COLOR_TYPE_RGB; |
info_ptr->bit_depth = 8; |
info_ptr->num_trans = 0; |
} |
else |
{ |
if (png_ptr->num_trans) |
info_ptr->color_type |= PNG_COLOR_MASK_ALPHA; |
if (info_ptr->bit_depth < 8) |
info_ptr->bit_depth = 8; |
info_ptr->num_trans = 0; |
} |
} |
#endif |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) |
if (png_ptr->transformations & PNG_BACKGROUND) |
{ |
info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA; |
info_ptr->num_trans = 0; |
info_ptr->background = png_ptr->background; |
} |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
if (png_ptr->transformations & PNG_GAMMA) |
{ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
info_ptr->gamma = png_ptr->gamma; |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
info_ptr->int_gamma = png_ptr->int_gamma; |
#endif |
} |
#endif |
#if defined(PNG_READ_16_TO_8_SUPPORTED) |
if ((png_ptr->transformations & PNG_16_TO_8) && (info_ptr->bit_depth == 16)) |
info_ptr->bit_depth = 8; |
#endif |
#if defined(PNG_READ_DITHER_SUPPORTED) |
if (png_ptr->transformations & PNG_DITHER) |
{ |
if (((info_ptr->color_type == PNG_COLOR_TYPE_RGB) || |
(info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)) && |
png_ptr->palette_lookup && info_ptr->bit_depth == 8) |
{ |
info_ptr->color_type = PNG_COLOR_TYPE_PALETTE; |
} |
} |
#endif |
#if defined(PNG_READ_PACK_SUPPORTED) |
if ((png_ptr->transformations & PNG_PACK) && (info_ptr->bit_depth < 8)) |
info_ptr->bit_depth = 8; |
#endif |
#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) |
if (png_ptr->transformations & PNG_GRAY_TO_RGB) |
info_ptr->color_type |= PNG_COLOR_MASK_COLOR; |
#endif |
#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) |
if (png_ptr->transformations & PNG_RGB_TO_GRAY) |
info_ptr->color_type &= ~PNG_COLOR_MASK_COLOR; |
#endif |
if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
info_ptr->channels = 1; |
else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR) |
info_ptr->channels = 3; |
else |
info_ptr->channels = 1; |
#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED) |
if (png_ptr->transformations & PNG_STRIP_ALPHA) |
info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA; |
#endif |
if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA) |
info_ptr->channels++; |
#if defined(PNG_READ_FILLER_SUPPORTED) |
/* STRIP_ALPHA and FILLER allowed: MASK_ALPHA bit stripped above */ |
if ((png_ptr->transformations & PNG_FILLER) && |
((info_ptr->color_type == PNG_COLOR_TYPE_RGB) || |
(info_ptr->color_type == PNG_COLOR_TYPE_GRAY))) |
{ |
info_ptr->channels++; |
#if 0 /* if adding a true alpha channel not just filler */ |
info_ptr->color_type |= PNG_COLOR_MASK_ALPHA; |
#endif |
} |
#endif |
#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) && \ |
defined(PNG_READ_USER_TRANSFORM_SUPPORTED) |
if(png_ptr->transformations & PNG_USER_TRANSFORM) |
{ |
if(info_ptr->bit_depth < png_ptr->user_transform_depth) |
info_ptr->bit_depth = png_ptr->user_transform_depth; |
if(info_ptr->channels < png_ptr->user_transform_channels) |
info_ptr->channels = png_ptr->user_transform_channels; |
} |
#endif |
info_ptr->pixel_depth = (png_byte)(info_ptr->channels * |
info_ptr->bit_depth); |
info_ptr->rowbytes = ((info_ptr->width * info_ptr->pixel_depth + 7) >> 3); |
#if !defined(PNG_READ_EXPAND_SUPPORTED) |
if(png_ptr) |
return; |
#endif |
} |
/* Transform the row. The order of transformations is significant, |
* and is very touchy. If you add a transformation, take care to |
* decide how it fits in with the other transformations here. |
*/ |
void /* PRIVATE */ |
png_do_read_transformations(png_structp png_ptr) |
{ |
png_debug(1, "in png_do_read_transformations\n"); |
#if !defined(PNG_USELESS_TESTS_SUPPORTED) |
if (png_ptr->row_buf == NULL) |
{ |
#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) |
char msg[50]; |
sprintf(msg, "NULL row buffer for row %ld, pass %d", png_ptr->row_number, |
png_ptr->pass); |
png_error(png_ptr, msg); |
#else |
png_error(png_ptr, "NULL row buffer"); |
#endif |
} |
#endif |
#if defined(PNG_READ_EXPAND_SUPPORTED) |
if (png_ptr->transformations & PNG_EXPAND) |
{ |
if (png_ptr->row_info.color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
png_do_expand_palette(&(png_ptr->row_info), png_ptr->row_buf + 1, |
png_ptr->palette, png_ptr->trans, png_ptr->num_trans); |
} |
else |
{ |
if (png_ptr->num_trans) |
png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1, |
&(png_ptr->trans_values)); |
else |
png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1, |
NULL); |
} |
} |
#endif |
#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED) |
if (png_ptr->transformations & PNG_STRIP_ALPHA) |
png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1, |
PNG_FLAG_FILLER_AFTER); |
#endif |
#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) |
if (png_ptr->transformations & PNG_RGB_TO_GRAY) |
{ |
int rgb_error = |
png_do_rgb_to_gray(png_ptr, &(png_ptr->row_info), png_ptr->row_buf + 1); |
if(rgb_error) |
{ |
png_ptr->rgb_to_gray_status=1; |
if(png_ptr->transformations == PNG_RGB_TO_GRAY_WARN) |
png_warning(png_ptr, "png_do_rgb_to_gray found nongray pixel"); |
if(png_ptr->transformations == PNG_RGB_TO_GRAY_ERR) |
png_error(png_ptr, "png_do_rgb_to_gray found nongray pixel"); |
} |
} |
#endif |
/* |
From Andreas Dilger e-mail to png-implement, 26 March 1998: |
In most cases, the "simple transparency" should be done prior to doing |
gray-to-RGB, or you will have to test 3x as many bytes to check if a |
pixel is transparent. You would also need to make sure that the |
transparency information is upgraded to RGB. |
To summarize, the current flow is: |
- Gray + simple transparency -> compare 1 or 2 gray bytes and composite |
with background "in place" if transparent, |
convert to RGB if necessary |
- Gray + alpha -> composite with gray background and remove alpha bytes, |
convert to RGB if necessary |
To support RGB backgrounds for gray images we need: |
- Gray + simple transparency -> convert to RGB + simple transparency, compare |
3 or 6 bytes and composite with background |
"in place" if transparent (3x compare/pixel |
compared to doing composite with gray bkgrnd) |
- Gray + alpha -> convert to RGB + alpha, composite with background and |
remove alpha bytes (3x float operations/pixel |
compared with composite on gray background) |
Greg's change will do this. The reason it wasn't done before is for |
performance, as this increases the per-pixel operations. If we would check |
in advance if the background was gray or RGB, and position the gray-to-RGB |
transform appropriately, then it would save a lot of work/time. |
*/ |
#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) |
/* if gray -> RGB, do so now only if background is non-gray; else do later |
* for performance reasons */ |
if ((png_ptr->transformations & PNG_GRAY_TO_RGB) && |
!(png_ptr->mode & PNG_BACKGROUND_IS_GRAY)) |
png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) |
if ((png_ptr->transformations & PNG_BACKGROUND) && |
((png_ptr->num_trans != 0 ) || |
(png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) |
png_do_background(&(png_ptr->row_info), png_ptr->row_buf + 1, |
&(png_ptr->trans_values), &(png_ptr->background) |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
, &(png_ptr->background_1), |
png_ptr->gamma_table, png_ptr->gamma_from_1, |
png_ptr->gamma_to_1, png_ptr->gamma_16_table, |
png_ptr->gamma_16_from_1, png_ptr->gamma_16_to_1, |
png_ptr->gamma_shift |
#endif |
); |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
if ((png_ptr->transformations & PNG_GAMMA) && |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) |
!((png_ptr->transformations & PNG_BACKGROUND) && |
((png_ptr->num_trans != 0) || |
(png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) && |
#endif |
(png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)) |
png_do_gamma(&(png_ptr->row_info), png_ptr->row_buf + 1, |
png_ptr->gamma_table, png_ptr->gamma_16_table, |
png_ptr->gamma_shift); |
#endif |
#if defined(PNG_READ_16_TO_8_SUPPORTED) |
if (png_ptr->transformations & PNG_16_TO_8) |
png_do_chop(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#if defined(PNG_READ_DITHER_SUPPORTED) |
if (png_ptr->transformations & PNG_DITHER) |
{ |
png_do_dither((png_row_infop)&(png_ptr->row_info), png_ptr->row_buf + 1, |
png_ptr->palette_lookup, png_ptr->dither_index); |
if(png_ptr->row_info.rowbytes == (png_uint_32)0) |
png_error(png_ptr, "png_do_dither returned rowbytes=0"); |
} |
#endif |
#if defined(PNG_READ_INVERT_SUPPORTED) |
if (png_ptr->transformations & PNG_INVERT_MONO) |
png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#if defined(PNG_READ_SHIFT_SUPPORTED) |
if (png_ptr->transformations & PNG_SHIFT) |
png_do_unshift(&(png_ptr->row_info), png_ptr->row_buf + 1, |
&(png_ptr->shift)); |
#endif |
#if defined(PNG_READ_PACK_SUPPORTED) |
if (png_ptr->transformations & PNG_PACK) |
png_do_unpack(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#if defined(PNG_READ_BGR_SUPPORTED) |
if (png_ptr->transformations & PNG_BGR) |
png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_PACKSWAP) |
png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) |
/* if gray -> RGB, do so now only if we did not do so above */ |
if ((png_ptr->transformations & PNG_GRAY_TO_RGB) && |
(png_ptr->mode & PNG_BACKGROUND_IS_GRAY)) |
png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#if defined(PNG_READ_FILLER_SUPPORTED) |
if (png_ptr->transformations & PNG_FILLER) |
png_do_read_filler(&(png_ptr->row_info), png_ptr->row_buf + 1, |
(png_uint_32)png_ptr->filler, png_ptr->flags); |
#endif |
#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) |
if (png_ptr->transformations & PNG_INVERT_ALPHA) |
png_do_read_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) |
if (png_ptr->transformations & PNG_SWAP_ALPHA) |
png_do_read_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#if defined(PNG_READ_SWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_SWAP_BYTES) |
png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) |
if (png_ptr->transformations & PNG_USER_TRANSFORM) |
{ |
if(png_ptr->read_user_transform_fn != NULL) |
(*(png_ptr->read_user_transform_fn)) /* user read transform function */ |
(png_ptr, /* png_ptr */ |
&(png_ptr->row_info), /* row_info: */ |
/* png_uint_32 width; width of row */ |
/* png_uint_32 rowbytes; number of bytes in row */ |
/* png_byte color_type; color type of pixels */ |
/* png_byte bit_depth; bit depth of samples */ |
/* png_byte channels; number of channels (1-4) */ |
/* png_byte pixel_depth; bits per pixel (depth*channels) */ |
png_ptr->row_buf + 1); /* start of pixel data for row */ |
#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) |
if(png_ptr->user_transform_depth) |
png_ptr->row_info.bit_depth = png_ptr->user_transform_depth; |
if(png_ptr->user_transform_channels) |
png_ptr->row_info.channels = png_ptr->user_transform_channels; |
#endif |
png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth * |
png_ptr->row_info.channels); |
png_ptr->row_info.rowbytes = (png_ptr->row_info.width * |
png_ptr->row_info.pixel_depth+7)>>3; |
} |
#endif |
} |
#if defined(PNG_READ_PACK_SUPPORTED) |
/* Unpack pixels of 1, 2, or 4 bits per pixel into 1 byte per pixel, |
* without changing the actual values. Thus, if you had a row with |
* a bit depth of 1, you would end up with bytes that only contained |
* the numbers 0 or 1. If you would rather they contain 0 and 255, use |
* png_do_shift() after this. |
*/ |
void /* PRIVATE */ |
png_do_unpack(png_row_infop row_info, png_bytep row) |
{ |
png_debug(1, "in png_do_unpack\n"); |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
if (row != NULL && row_info != NULL && row_info->bit_depth < 8) |
#else |
if (row_info->bit_depth < 8) |
#endif |
{ |
png_uint_32 i; |
png_uint_32 row_width=row_info->width; |
switch (row_info->bit_depth) |
{ |
case 1: |
{ |
png_bytep sp = row + (png_size_t)((row_width - 1) >> 3); |
png_bytep dp = row + (png_size_t)row_width - 1; |
png_uint_32 shift = 7 - (int)((row_width + 7) & 0x07); |
for (i = 0; i < row_width; i++) |
{ |
*dp = (png_byte)((*sp >> shift) & 0x01); |
if (shift == 7) |
{ |
shift = 0; |
sp--; |
} |
else |
shift++; |
dp--; |
} |
break; |
} |
case 2: |
{ |
png_bytep sp = row + (png_size_t)((row_width - 1) >> 2); |
png_bytep dp = row + (png_size_t)row_width - 1; |
png_uint_32 shift = (int)((3 - ((row_width + 3) & 0x03)) << 1); |
for (i = 0; i < row_width; i++) |
{ |
*dp = (png_byte)((*sp >> shift) & 0x03); |
if (shift == 6) |
{ |
shift = 0; |
sp--; |
} |
else |
shift += 2; |
dp--; |
} |
break; |
} |
case 4: |
{ |
png_bytep sp = row + (png_size_t)((row_width - 1) >> 1); |
png_bytep dp = row + (png_size_t)row_width - 1; |
png_uint_32 shift = (int)((1 - ((row_width + 1) & 0x01)) << 2); |
for (i = 0; i < row_width; i++) |
{ |
*dp = (png_byte)((*sp >> shift) & 0x0f); |
if (shift == 4) |
{ |
shift = 0; |
sp--; |
} |
else |
shift = 4; |
dp--; |
} |
break; |
} |
} |
row_info->bit_depth = 8; |
row_info->pixel_depth = (png_byte)(8 * row_info->channels); |
row_info->rowbytes = row_width * row_info->channels; |
} |
} |
#endif |
#if defined(PNG_READ_SHIFT_SUPPORTED) |
/* Reverse the effects of png_do_shift. This routine merely shifts the |
* pixels back to their significant bits values. Thus, if you have |
* a row of bit depth 8, but only 5 are significant, this will shift |
* the values back to 0 through 31. |
*/ |
void /* PRIVATE */ |
png_do_unshift(png_row_infop row_info, png_bytep row, png_color_8p sig_bits) |
{ |
png_debug(1, "in png_do_unshift\n"); |
if ( |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
row != NULL && row_info != NULL && sig_bits != NULL && |
#endif |
row_info->color_type != PNG_COLOR_TYPE_PALETTE) |
{ |
int shift[4]; |
int channels = 0; |
int c; |
png_uint_16 value = 0; |
png_uint_32 row_width = row_info->width; |
if (row_info->color_type & PNG_COLOR_MASK_COLOR) |
{ |
shift[channels++] = row_info->bit_depth - sig_bits->red; |
shift[channels++] = row_info->bit_depth - sig_bits->green; |
shift[channels++] = row_info->bit_depth - sig_bits->blue; |
} |
else |
{ |
shift[channels++] = row_info->bit_depth - sig_bits->gray; |
} |
if (row_info->color_type & PNG_COLOR_MASK_ALPHA) |
{ |
shift[channels++] = row_info->bit_depth - sig_bits->alpha; |
} |
for (c = 0; c < channels; c++) |
{ |
if (shift[c] <= 0) |
shift[c] = 0; |
else |
value = 1; |
} |
if (!value) |
return; |
switch (row_info->bit_depth) |
{ |
case 2: |
{ |
png_bytep bp; |
png_uint_32 i; |
png_uint_32 istop = row_info->rowbytes; |
for (bp = row, i = 0; i < istop; i++) |
{ |
*bp >>= 1; |
*bp++ &= 0x55; |
} |
break; |
} |
case 4: |
{ |
png_bytep bp = row; |
png_uint_32 i; |
png_uint_32 istop = row_info->rowbytes; |
png_byte mask = (png_byte)((((int)0xf0 >> shift[0]) & (int)0xf0) | |
(png_byte)((int)0xf >> shift[0])); |
for (i = 0; i < istop; i++) |
{ |
*bp >>= shift[0]; |
*bp++ &= mask; |
} |
break; |
} |
case 8: |
{ |
png_bytep bp = row; |
png_uint_32 i; |
png_uint_32 istop = row_width * channels; |
for (i = 0; i < istop; i++) |
{ |
*bp++ >>= shift[i%channels]; |
} |
break; |
} |
case 16: |
{ |
png_bytep bp = row; |
png_uint_32 i; |
png_uint_32 istop = channels * row_width; |
for (i = 0; i < istop; i++) |
{ |
value = (png_uint_16)((*bp << 8) + *(bp + 1)); |
value >>= shift[i%channels]; |
*bp++ = (png_byte)(value >> 8); |
*bp++ = (png_byte)(value & 0xff); |
} |
break; |
} |
} |
} |
} |
#endif |
#if defined(PNG_READ_16_TO_8_SUPPORTED) |
/* chop rows of bit depth 16 down to 8 */ |
void /* PRIVATE */ |
png_do_chop(png_row_infop row_info, png_bytep row) |
{ |
png_debug(1, "in png_do_chop\n"); |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
if (row != NULL && row_info != NULL && row_info->bit_depth == 16) |
#else |
if (row_info->bit_depth == 16) |
#endif |
{ |
png_bytep sp = row; |
png_bytep dp = row; |
png_uint_32 i; |
png_uint_32 istop = row_info->width * row_info->channels; |
for (i = 0; i<istop; i++, sp += 2, dp++) |
{ |
#if defined(PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED) |
/* This does a more accurate scaling of the 16-bit color |
* value, rather than a simple low-byte truncation. |
* |
* What the ideal calculation should be: |
* *dp = (((((png_uint_32)(*sp) << 8) | |
* (png_uint_32)(*(sp + 1))) * 255 + 127) / (png_uint_32)65535L; |
* |
* GRR: no, I think this is what it really should be: |
* *dp = (((((png_uint_32)(*sp) << 8) | |
* (png_uint_32)(*(sp + 1))) + 128L) / (png_uint_32)257L; |
* |
* GRR: here's the exact calculation with shifts: |
* temp = (((png_uint_32)(*sp) << 8) | (png_uint_32)(*(sp + 1))) + 128L; |
* *dp = (temp - (temp >> 8)) >> 8; |
* |
* Approximate calculation with shift/add instead of multiply/divide: |
* *dp = ((((png_uint_32)(*sp) << 8) | |
* (png_uint_32)((int)(*(sp + 1)) - *sp)) + 128) >> 8; |
* |
* What we actually do to avoid extra shifting and conversion: |
*/ |
*dp = *sp + ((((int)(*(sp + 1)) - *sp) > 128) ? 1 : 0); |
#else |
/* Simply discard the low order byte */ |
*dp = *sp; |
#endif |
} |
row_info->bit_depth = 8; |
row_info->pixel_depth = (png_byte)(8 * row_info->channels); |
row_info->rowbytes = row_info->width * row_info->channels; |
} |
} |
#endif |
#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) |
void /* PRIVATE */ |
png_do_read_swap_alpha(png_row_infop row_info, png_bytep row) |
{ |
png_debug(1, "in png_do_read_swap_alpha\n"); |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
if (row != NULL && row_info != NULL) |
#endif |
{ |
png_uint_32 row_width = row_info->width; |
if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
{ |
/* This converts from RGBA to ARGB */ |
if (row_info->bit_depth == 8) |
{ |
png_bytep sp = row + row_info->rowbytes; |
png_bytep dp = sp; |
png_byte save; |
png_uint_32 i; |
for (i = 0; i < row_width; i++) |
{ |
save = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = save; |
} |
} |
/* This converts from RRGGBBAA to AARRGGBB */ |
else |
{ |
png_bytep sp = row + row_info->rowbytes; |
png_bytep dp = sp; |
png_byte save[2]; |
png_uint_32 i; |
for (i = 0; i < row_width; i++) |
{ |
save[0] = *(--sp); |
save[1] = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = save[0]; |
*(--dp) = save[1]; |
} |
} |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) |
{ |
/* This converts from GA to AG */ |
if (row_info->bit_depth == 8) |
{ |
png_bytep sp = row + row_info->rowbytes; |
png_bytep dp = sp; |
png_byte save; |
png_uint_32 i; |
for (i = 0; i < row_width; i++) |
{ |
save = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = save; |
} |
} |
/* This converts from GGAA to AAGG */ |
else |
{ |
png_bytep sp = row + row_info->rowbytes; |
png_bytep dp = sp; |
png_byte save[2]; |
png_uint_32 i; |
for (i = 0; i < row_width; i++) |
{ |
save[0] = *(--sp); |
save[1] = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = save[0]; |
*(--dp) = save[1]; |
} |
} |
} |
} |
} |
#endif |
#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) |
void /* PRIVATE */ |
png_do_read_invert_alpha(png_row_infop row_info, png_bytep row) |
{ |
png_debug(1, "in png_do_read_invert_alpha\n"); |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
if (row != NULL && row_info != NULL) |
#endif |
{ |
png_uint_32 row_width = row_info->width; |
if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
{ |
/* This inverts the alpha channel in RGBA */ |
if (row_info->bit_depth == 8) |
{ |
png_bytep sp = row + row_info->rowbytes; |
png_bytep dp = sp; |
png_uint_32 i; |
for (i = 0; i < row_width; i++) |
{ |
*(--dp) = (png_byte)(255 - *(--sp)); |
/* This does nothing: |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
We can replace it with: |
*/ |
sp-=3; |
dp=sp; |
} |
} |
/* This inverts the alpha channel in RRGGBBAA */ |
else |
{ |
png_bytep sp = row + row_info->rowbytes; |
png_bytep dp = sp; |
png_uint_32 i; |
for (i = 0; i < row_width; i++) |
{ |
*(--dp) = (png_byte)(255 - *(--sp)); |
*(--dp) = (png_byte)(255 - *(--sp)); |
/* This does nothing: |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
We can replace it with: |
*/ |
sp-=6; |
dp=sp; |
} |
} |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) |
{ |
/* This inverts the alpha channel in GA */ |
if (row_info->bit_depth == 8) |
{ |
png_bytep sp = row + row_info->rowbytes; |
png_bytep dp = sp; |
png_uint_32 i; |
for (i = 0; i < row_width; i++) |
{ |
*(--dp) = (png_byte)(255 - *(--sp)); |
*(--dp) = *(--sp); |
} |
} |
/* This inverts the alpha channel in GGAA */ |
else |
{ |
png_bytep sp = row + row_info->rowbytes; |
png_bytep dp = sp; |
png_uint_32 i; |
for (i = 0; i < row_width; i++) |
{ |
*(--dp) = (png_byte)(255 - *(--sp)); |
*(--dp) = (png_byte)(255 - *(--sp)); |
/* |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*/ |
sp-=2; |
dp=sp; |
} |
} |
} |
} |
} |
#endif |
#if defined(PNG_READ_FILLER_SUPPORTED) |
/* Add filler channel if we have RGB color */ |
void /* PRIVATE */ |
png_do_read_filler(png_row_infop row_info, png_bytep row, |
png_uint_32 filler, png_uint_32 flags) |
{ |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
png_byte hi_filler = (png_byte)((filler>>8) & 0xff); |
png_byte lo_filler = (png_byte)(filler & 0xff); |
png_debug(1, "in png_do_read_filler\n"); |
if ( |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
row != NULL && row_info != NULL && |
#endif |
row_info->color_type == PNG_COLOR_TYPE_GRAY) |
{ |
if(row_info->bit_depth == 8) |
{ |
/* This changes the data from G to GX */ |
if (flags & PNG_FLAG_FILLER_AFTER) |
{ |
png_bytep sp = row + (png_size_t)row_width; |
png_bytep dp = sp + (png_size_t)row_width; |
for (i = 1; i < row_width; i++) |
{ |
*(--dp) = lo_filler; |
*(--dp) = *(--sp); |
} |
*(--dp) = lo_filler; |
row_info->channels = 2; |
row_info->pixel_depth = 16; |
row_info->rowbytes = row_width * 2; |
} |
/* This changes the data from G to XG */ |
else |
{ |
png_bytep sp = row + (png_size_t)row_width; |
png_bytep dp = sp + (png_size_t)row_width; |
for (i = 0; i < row_width; i++) |
{ |
*(--dp) = *(--sp); |
*(--dp) = lo_filler; |
} |
row_info->channels = 2; |
row_info->pixel_depth = 16; |
row_info->rowbytes = row_width * 2; |
} |
} |
else if(row_info->bit_depth == 16) |
{ |
/* This changes the data from GG to GGXX */ |
if (flags & PNG_FLAG_FILLER_AFTER) |
{ |
png_bytep sp = row + (png_size_t)row_width; |
png_bytep dp = sp + (png_size_t)row_width; |
for (i = 1; i < row_width; i++) |
{ |
*(--dp) = hi_filler; |
*(--dp) = lo_filler; |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
} |
*(--dp) = hi_filler; |
*(--dp) = lo_filler; |
row_info->channels = 2; |
row_info->pixel_depth = 32; |
row_info->rowbytes = row_width * 4; |
} |
/* This changes the data from GG to XXGG */ |
else |
{ |
png_bytep sp = row + (png_size_t)row_width; |
png_bytep dp = sp + (png_size_t)row_width; |
for (i = 0; i < row_width; i++) |
{ |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = hi_filler; |
*(--dp) = lo_filler; |
} |
row_info->channels = 2; |
row_info->pixel_depth = 32; |
row_info->rowbytes = row_width * 4; |
} |
} |
} /* COLOR_TYPE == GRAY */ |
else if (row_info->color_type == PNG_COLOR_TYPE_RGB) |
{ |
if(row_info->bit_depth == 8) |
{ |
/* This changes the data from RGB to RGBX */ |
if (flags & PNG_FLAG_FILLER_AFTER) |
{ |
png_bytep sp = row + (png_size_t)row_width * 3; |
png_bytep dp = sp + (png_size_t)row_width; |
for (i = 1; i < row_width; i++) |
{ |
*(--dp) = lo_filler; |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
} |
*(--dp) = lo_filler; |
row_info->channels = 4; |
row_info->pixel_depth = 32; |
row_info->rowbytes = row_width * 4; |
} |
/* This changes the data from RGB to XRGB */ |
else |
{ |
png_bytep sp = row + (png_size_t)row_width * 3; |
png_bytep dp = sp + (png_size_t)row_width; |
for (i = 0; i < row_width; i++) |
{ |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = lo_filler; |
} |
row_info->channels = 4; |
row_info->pixel_depth = 32; |
row_info->rowbytes = row_width * 4; |
} |
} |
else if(row_info->bit_depth == 16) |
{ |
/* This changes the data from RRGGBB to RRGGBBXX */ |
if (flags & PNG_FLAG_FILLER_AFTER) |
{ |
png_bytep sp = row + (png_size_t)row_width * 3; |
png_bytep dp = sp + (png_size_t)row_width; |
for (i = 1; i < row_width; i++) |
{ |
*(--dp) = hi_filler; |
*(--dp) = lo_filler; |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
} |
*(--dp) = hi_filler; |
*(--dp) = lo_filler; |
row_info->channels = 4; |
row_info->pixel_depth = 64; |
row_info->rowbytes = row_width * 8; |
} |
/* This changes the data from RRGGBB to XXRRGGBB */ |
else |
{ |
png_bytep sp = row + (png_size_t)row_width * 3; |
png_bytep dp = sp + (png_size_t)row_width; |
for (i = 0; i < row_width; i++) |
{ |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = hi_filler; |
*(--dp) = lo_filler; |
} |
row_info->channels = 4; |
row_info->pixel_depth = 64; |
row_info->rowbytes = row_width * 8; |
} |
} |
} /* COLOR_TYPE == RGB */ |
} |
#endif |
#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) |
/* expand grayscale files to RGB, with or without alpha */ |
void /* PRIVATE */ |
png_do_gray_to_rgb(png_row_infop row_info, png_bytep row) |
{ |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
png_debug(1, "in png_do_gray_to_rgb\n"); |
if (row_info->bit_depth >= 8 && |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
row != NULL && row_info != NULL && |
#endif |
!(row_info->color_type & PNG_COLOR_MASK_COLOR)) |
{ |
if (row_info->color_type == PNG_COLOR_TYPE_GRAY) |
{ |
if (row_info->bit_depth == 8) |
{ |
png_bytep sp = row + (png_size_t)row_width - 1; |
png_bytep dp = sp + (png_size_t)row_width * 2; |
for (i = 0; i < row_width; i++) |
{ |
*(dp--) = *sp; |
*(dp--) = *sp; |
*(dp--) = *(sp--); |
} |
} |
else |
{ |
png_bytep sp = row + (png_size_t)row_width * 2 - 1; |
png_bytep dp = sp + (png_size_t)row_width * 4; |
for (i = 0; i < row_width; i++) |
{ |
*(dp--) = *sp; |
*(dp--) = *(sp - 1); |
*(dp--) = *sp; |
*(dp--) = *(sp - 1); |
*(dp--) = *(sp--); |
*(dp--) = *(sp--); |
} |
} |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) |
{ |
if (row_info->bit_depth == 8) |
{ |
png_bytep sp = row + (png_size_t)row_width * 2 - 1; |
png_bytep dp = sp + (png_size_t)row_width * 2; |
for (i = 0; i < row_width; i++) |
{ |
*(dp--) = *(sp--); |
*(dp--) = *sp; |
*(dp--) = *sp; |
*(dp--) = *(sp--); |
} |
} |
else |
{ |
png_bytep sp = row + (png_size_t)row_width * 4 - 1; |
png_bytep dp = sp + (png_size_t)row_width * 4; |
for (i = 0; i < row_width; i++) |
{ |
*(dp--) = *(sp--); |
*(dp--) = *(sp--); |
*(dp--) = *sp; |
*(dp--) = *(sp - 1); |
*(dp--) = *sp; |
*(dp--) = *(sp - 1); |
*(dp--) = *(sp--); |
*(dp--) = *(sp--); |
} |
} |
} |
row_info->channels += (png_byte)2; |
row_info->color_type |= PNG_COLOR_MASK_COLOR; |
row_info->pixel_depth = (png_byte)(row_info->channels * |
row_info->bit_depth); |
row_info->rowbytes = ((row_width * |
row_info->pixel_depth + 7) >> 3); |
} |
} |
#endif |
#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) |
/* reduce RGB files to grayscale, with or without alpha |
* using the equation given in Poynton's ColorFAQ at |
* <http://www.inforamp.net/~poynton/> |
* Copyright (c) 1998-01-04 Charles Poynton poynton@inforamp.net |
* |
* Y = 0.212671 * R + 0.715160 * G + 0.072169 * B |
* |
* We approximate this with |
* |
* Y = 0.21268 * R + 0.7151 * G + 0.07217 * B |
* |
* which can be expressed with integers as |
* |
* Y = (6969 * R + 23434 * G + 2365 * B)/32768 |
* |
* The calculation is to be done in a linear colorspace. |
* |
* Other integer coefficents can be used via png_set_rgb_to_gray(). |
*/ |
int /* PRIVATE */ |
png_do_rgb_to_gray(png_structp png_ptr, png_row_infop row_info, png_bytep row) |
{ |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
int rgb_error = 0; |
png_debug(1, "in png_do_rgb_to_gray\n"); |
if ( |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
row != NULL && row_info != NULL && |
#endif |
(row_info->color_type & PNG_COLOR_MASK_COLOR)) |
{ |
png_uint_32 rc = png_ptr->rgb_to_gray_red_coeff; |
png_uint_32 gc = png_ptr->rgb_to_gray_green_coeff; |
png_uint_32 bc = png_ptr->rgb_to_gray_blue_coeff; |
if (row_info->color_type == PNG_COLOR_TYPE_RGB) |
{ |
if (row_info->bit_depth == 8) |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL) |
{ |
png_bytep sp = row; |
png_bytep dp = row; |
for (i = 0; i < row_width; i++) |
{ |
png_byte red = png_ptr->gamma_to_1[*(sp++)]; |
png_byte green = png_ptr->gamma_to_1[*(sp++)]; |
png_byte blue = png_ptr->gamma_to_1[*(sp++)]; |
if(red != green || red != blue) |
{ |
rgb_error |= 1; |
*(dp++) = png_ptr->gamma_from_1[ |
(rc*red+gc*green+bc*blue)>>15]; |
} |
else |
*(dp++) = *(sp-1); |
} |
} |
else |
#endif |
{ |
png_bytep sp = row; |
png_bytep dp = row; |
for (i = 0; i < row_width; i++) |
{ |
png_byte red = *(sp++); |
png_byte green = *(sp++); |
png_byte blue = *(sp++); |
if(red != green || red != blue) |
{ |
rgb_error |= 1; |
*(dp++) = (png_byte)((rc*red+gc*green+bc*blue)>>15); |
} |
else |
*(dp++) = *(sp-1); |
} |
} |
} |
else /* RGB bit_depth == 16 */ |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
if (png_ptr->gamma_16_to_1 != NULL && |
png_ptr->gamma_16_from_1 != NULL) |
{ |
png_bytep sp = row; |
png_bytep dp = row; |
for (i = 0; i < row_width; i++) |
{ |
png_uint_16 red, green, blue, w; |
red = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; |
green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; |
blue = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; |
if(red == green && red == blue) |
w = red; |
else |
{ |
png_uint_16 red_1 = png_ptr->gamma_16_to_1[(red&0xff) >> |
png_ptr->gamma_shift][red>>8]; |
png_uint_16 green_1 = png_ptr->gamma_16_to_1[(green&0xff) >> |
png_ptr->gamma_shift][green>>8]; |
png_uint_16 blue_1 = png_ptr->gamma_16_to_1[(blue&0xff) >> |
png_ptr->gamma_shift][blue>>8]; |
png_uint_16 gray16 = (png_uint_16)((rc*red_1 + gc*green_1 |
+ bc*blue_1)>>15); |
w = png_ptr->gamma_16_from_1[(gray16&0xff) >> |
png_ptr->gamma_shift][gray16 >> 8]; |
rgb_error |= 1; |
} |
*(dp++) = (png_byte)((w>>8) & 0xff); |
*(dp++) = (png_byte)(w & 0xff); |
} |
} |
else |
#endif |
{ |
png_bytep sp = row; |
png_bytep dp = row; |
for (i = 0; i < row_width; i++) |
{ |
png_uint_16 red, green, blue, gray16; |
red = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; |
green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; |
blue = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; |
if(red != green || red != blue) |
rgb_error |= 1; |
gray16 = (png_uint_16)((rc*red + gc*green + bc*blue)>>15); |
*(dp++) = (png_byte)((gray16>>8) & 0xff); |
*(dp++) = (png_byte)(gray16 & 0xff); |
} |
} |
} |
} |
if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
{ |
if (row_info->bit_depth == 8) |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL) |
{ |
png_bytep sp = row; |
png_bytep dp = row; |
for (i = 0; i < row_width; i++) |
{ |
png_byte red = png_ptr->gamma_to_1[*(sp++)]; |
png_byte green = png_ptr->gamma_to_1[*(sp++)]; |
png_byte blue = png_ptr->gamma_to_1[*(sp++)]; |
if(red != green || red != blue) |
rgb_error |= 1; |
*(dp++) = png_ptr->gamma_from_1 |
[(rc*red + gc*green + bc*blue)>>15]; |
*(dp++) = *(sp++); /* alpha */ |
} |
} |
else |
#endif |
{ |
png_bytep sp = row; |
png_bytep dp = row; |
for (i = 0; i < row_width; i++) |
{ |
png_byte red = *(sp++); |
png_byte green = *(sp++); |
png_byte blue = *(sp++); |
if(red != green || red != blue) |
rgb_error |= 1; |
*(dp++) = (png_byte)((gc*red + gc*green + bc*blue)>>8); |
*(dp++) = *(sp++); /* alpha */ |
} |
} |
} |
else /* RGBA bit_depth == 16 */ |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
if (png_ptr->gamma_16_to_1 != NULL && |
png_ptr->gamma_16_from_1 != NULL) |
{ |
png_bytep sp = row; |
png_bytep dp = row; |
for (i = 0; i < row_width; i++) |
{ |
png_uint_16 red, green, blue, w; |
red = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; |
green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; |
blue = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; |
if(red == green && red == blue) |
w = red; |
else |
{ |
png_uint_16 red_1 = png_ptr->gamma_16_to_1[(red&0xff) >> |
png_ptr->gamma_shift][red>>8]; |
png_uint_16 green_1 = png_ptr->gamma_16_to_1[(green&0xff) >> |
png_ptr->gamma_shift][green>>8]; |
png_uint_16 blue_1 = png_ptr->gamma_16_to_1[(blue&0xff) >> |
png_ptr->gamma_shift][blue>>8]; |
png_uint_16 gray16 = (png_uint_16)((rc * red_1 |
+ gc * green_1 + bc * blue_1)>>15); |
w = png_ptr->gamma_16_from_1[(gray16&0xff) >> |
png_ptr->gamma_shift][gray16 >> 8]; |
rgb_error |= 1; |
} |
*(dp++) = (png_byte)((w>>8) & 0xff); |
*(dp++) = (png_byte)(w & 0xff); |
*(dp++) = *(sp++); /* alpha */ |
*(dp++) = *(sp++); |
} |
} |
else |
#endif |
{ |
png_bytep sp = row; |
png_bytep dp = row; |
for (i = 0; i < row_width; i++) |
{ |
png_uint_16 red, green, blue, gray16; |
red = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2; |
green = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2; |
blue = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2; |
if(red != green || red != blue) |
rgb_error |= 1; |
gray16 = (png_uint_16)((rc*red + gc*green + bc*blue)>>15); |
*(dp++) = (png_byte)((gray16>>8) & 0xff); |
*(dp++) = (png_byte)(gray16 & 0xff); |
*(dp++) = *(sp++); /* alpha */ |
*(dp++) = *(sp++); |
} |
} |
} |
} |
row_info->channels -= (png_byte)2; |
row_info->color_type &= ~PNG_COLOR_MASK_COLOR; |
row_info->pixel_depth = (png_byte)(row_info->channels * |
row_info->bit_depth); |
row_info->rowbytes = ((row_width * |
row_info->pixel_depth + 7) >> 3); |
} |
return rgb_error; |
} |
#endif |
/* Build a grayscale palette. Palette is assumed to be 1 << bit_depth |
* large of png_color. This lets grayscale images be treated as |
* paletted. Most useful for gamma correction and simplification |
* of code. |
*/ |
void PNGAPI |
png_build_grayscale_palette(int bit_depth, png_colorp palette) |
{ |
int num_palette; |
int color_inc; |
int i; |
int v; |
png_debug(1, "in png_do_build_grayscale_palette\n"); |
if (palette == NULL) |
return; |
switch (bit_depth) |
{ |
case 1: |
num_palette = 2; |
color_inc = 0xff; |
break; |
case 2: |
num_palette = 4; |
color_inc = 0x55; |
break; |
case 4: |
num_palette = 16; |
color_inc = 0x11; |
break; |
case 8: |
num_palette = 256; |
color_inc = 1; |
break; |
default: |
num_palette = 0; |
color_inc = 0; |
break; |
} |
for (i = 0, v = 0; i < num_palette; i++, v += color_inc) |
{ |
palette[i].red = (png_byte)v; |
palette[i].green = (png_byte)v; |
palette[i].blue = (png_byte)v; |
} |
} |
/* This function is currently unused. Do we really need it? */ |
#if defined(PNG_READ_DITHER_SUPPORTED) && defined(PNG_CORRECT_PALETTE_SUPPORTED) |
void /* PRIVATE */ |
png_correct_palette(png_structp png_ptr, png_colorp palette, |
int num_palette) |
{ |
png_debug(1, "in png_correct_palette\n"); |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \ |
defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED) |
if (png_ptr->transformations & (PNG_GAMMA | PNG_BACKGROUND)) |
{ |
png_color back, back_1; |
if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE) |
{ |
back.red = png_ptr->gamma_table[png_ptr->background.red]; |
back.green = png_ptr->gamma_table[png_ptr->background.green]; |
back.blue = png_ptr->gamma_table[png_ptr->background.blue]; |
back_1.red = png_ptr->gamma_to_1[png_ptr->background.red]; |
back_1.green = png_ptr->gamma_to_1[png_ptr->background.green]; |
back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue]; |
} |
else |
{ |
double g; |
g = 1.0 / (png_ptr->background_gamma * png_ptr->screen_gamma); |
if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_SCREEN || |
fabs(g - 1.0) < PNG_GAMMA_THRESHOLD) |
{ |
back.red = png_ptr->background.red; |
back.green = png_ptr->background.green; |
back.blue = png_ptr->background.blue; |
} |
else |
{ |
back.red = |
(png_byte)(pow((double)png_ptr->background.red/255, g) * |
255.0 + 0.5); |
back.green = |
(png_byte)(pow((double)png_ptr->background.green/255, g) * |
255.0 + 0.5); |
back.blue = |
(png_byte)(pow((double)png_ptr->background.blue/255, g) * |
255.0 + 0.5); |
} |
g = 1.0 / png_ptr->background_gamma; |
back_1.red = |
(png_byte)(pow((double)png_ptr->background.red/255, g) * |
255.0 + 0.5); |
back_1.green = |
(png_byte)(pow((double)png_ptr->background.green/255, g) * |
255.0 + 0.5); |
back_1.blue = |
(png_byte)(pow((double)png_ptr->background.blue/255, g) * |
255.0 + 0.5); |
} |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
png_uint_32 i; |
for (i = 0; i < (png_uint_32)num_palette; i++) |
{ |
if (i < png_ptr->num_trans && png_ptr->trans[i] == 0) |
{ |
palette[i] = back; |
} |
else if (i < png_ptr->num_trans && png_ptr->trans[i] != 0xff) |
{ |
png_byte v, w; |
v = png_ptr->gamma_to_1[png_ptr->palette[i].red]; |
png_composite(w, v, png_ptr->trans[i], back_1.red); |
palette[i].red = png_ptr->gamma_from_1[w]; |
v = png_ptr->gamma_to_1[png_ptr->palette[i].green]; |
png_composite(w, v, png_ptr->trans[i], back_1.green); |
palette[i].green = png_ptr->gamma_from_1[w]; |
v = png_ptr->gamma_to_1[png_ptr->palette[i].blue]; |
png_composite(w, v, png_ptr->trans[i], back_1.blue); |
palette[i].blue = png_ptr->gamma_from_1[w]; |
} |
else |
{ |
palette[i].red = png_ptr->gamma_table[palette[i].red]; |
palette[i].green = png_ptr->gamma_table[palette[i].green]; |
palette[i].blue = png_ptr->gamma_table[palette[i].blue]; |
} |
} |
} |
else |
{ |
int i; |
for (i = 0; i < num_palette; i++) |
{ |
if (palette[i].red == (png_byte)png_ptr->trans_values.gray) |
{ |
palette[i] = back; |
} |
else |
{ |
palette[i].red = png_ptr->gamma_table[palette[i].red]; |
palette[i].green = png_ptr->gamma_table[palette[i].green]; |
palette[i].blue = png_ptr->gamma_table[palette[i].blue]; |
} |
} |
} |
} |
else |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
if (png_ptr->transformations & PNG_GAMMA) |
{ |
int i; |
for (i = 0; i < num_palette; i++) |
{ |
palette[i].red = png_ptr->gamma_table[palette[i].red]; |
palette[i].green = png_ptr->gamma_table[palette[i].green]; |
palette[i].blue = png_ptr->gamma_table[palette[i].blue]; |
} |
} |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) |
else |
#endif |
#endif |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) |
if (png_ptr->transformations & PNG_BACKGROUND) |
{ |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
png_color back; |
back.red = (png_byte)png_ptr->background.red; |
back.green = (png_byte)png_ptr->background.green; |
back.blue = (png_byte)png_ptr->background.blue; |
for (i = 0; i < (int)png_ptr->num_trans; i++) |
{ |
if (png_ptr->trans[i] == 0) |
{ |
palette[i].red = back.red; |
palette[i].green = back.green; |
palette[i].blue = back.blue; |
} |
else if (png_ptr->trans[i] != 0xff) |
{ |
png_composite(palette[i].red, png_ptr->palette[i].red, |
png_ptr->trans[i], back.red); |
png_composite(palette[i].green, png_ptr->palette[i].green, |
png_ptr->trans[i], back.green); |
png_composite(palette[i].blue, png_ptr->palette[i].blue, |
png_ptr->trans[i], back.blue); |
} |
} |
} |
else /* assume grayscale palette (what else could it be?) */ |
{ |
int i; |
for (i = 0; i < num_palette; i++) |
{ |
if (i == (png_byte)png_ptr->trans_values.gray) |
{ |
palette[i].red = (png_byte)png_ptr->background.red; |
palette[i].green = (png_byte)png_ptr->background.green; |
palette[i].blue = (png_byte)png_ptr->background.blue; |
} |
} |
} |
} |
#endif |
} |
#endif |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) |
/* Replace any alpha or transparency with the supplied background color. |
* "background" is already in the screen gamma, while "background_1" is |
* at a gamma of 1.0. Paletted files have already been taken care of. |
*/ |
void /* PRIVATE */ |
png_do_background(png_row_infop row_info, png_bytep row, |
png_color_16p trans_values, png_color_16p background |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
, png_color_16p background_1, |
png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1, |
png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1, |
png_uint_16pp gamma_16_to_1, int gamma_shift |
#endif |
) |
{ |
png_bytep sp, dp; |
png_uint_32 i; |
png_uint_32 row_width=row_info->width; |
int shift; |
png_debug(1, "in png_do_background\n"); |
if (background != NULL && |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
row != NULL && row_info != NULL && |
#endif |
(!(row_info->color_type & PNG_COLOR_MASK_ALPHA) || |
(row_info->color_type != PNG_COLOR_TYPE_PALETTE && trans_values))) |
{ |
switch (row_info->color_type) |
{ |
case PNG_COLOR_TYPE_GRAY: |
{ |
switch (row_info->bit_depth) |
{ |
case 1: |
{ |
sp = row; |
shift = 7; |
for (i = 0; i < row_width; i++) |
{ |
if ((png_uint_16)((*sp >> shift) & 0x01) |
== trans_values->gray) |
{ |
*sp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff); |
*sp |= (png_byte)(background->gray << shift); |
} |
if (!shift) |
{ |
shift = 7; |
sp++; |
} |
else |
shift--; |
} |
break; |
} |
case 2: |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
if (gamma_table != NULL) |
{ |
sp = row; |
shift = 6; |
for (i = 0; i < row_width; i++) |
{ |
if ((png_uint_16)((*sp >> shift) & 0x03) |
== trans_values->gray) |
{ |
*sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); |
*sp |= (png_byte)(background->gray << shift); |
} |
else |
{ |
png_byte p = (png_byte)((*sp >> shift) & 0x03); |
png_byte g = (png_byte)((gamma_table [p | (p << 2) | |
(p << 4) | (p << 6)] >> 6) & 0x03); |
*sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); |
*sp |= (png_byte)(g << shift); |
} |
if (!shift) |
{ |
shift = 6; |
sp++; |
} |
else |
shift -= 2; |
} |
} |
else |
#endif |
{ |
sp = row; |
shift = 6; |
for (i = 0; i < row_width; i++) |
{ |
if ((png_uint_16)((*sp >> shift) & 0x03) |
== trans_values->gray) |
{ |
*sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); |
*sp |= (png_byte)(background->gray << shift); |
} |
if (!shift) |
{ |
shift = 6; |
sp++; |
} |
else |
shift -= 2; |
} |
} |
break; |
} |
case 4: |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
if (gamma_table != NULL) |
{ |
sp = row; |
shift = 4; |
for (i = 0; i < row_width; i++) |
{ |
if ((png_uint_16)((*sp >> shift) & 0x0f) |
== trans_values->gray) |
{ |
*sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); |
*sp |= (png_byte)(background->gray << shift); |
} |
else |
{ |
png_byte p = (png_byte)((*sp >> shift) & 0x0f); |
png_byte g = (png_byte)((gamma_table[p | |
(p << 4)] >> 4) & 0x0f); |
*sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); |
*sp |= (png_byte)(g << shift); |
} |
if (!shift) |
{ |
shift = 4; |
sp++; |
} |
else |
shift -= 4; |
} |
} |
else |
#endif |
{ |
sp = row; |
shift = 4; |
for (i = 0; i < row_width; i++) |
{ |
if ((png_uint_16)((*sp >> shift) & 0x0f) |
== trans_values->gray) |
{ |
*sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); |
*sp |= (png_byte)(background->gray << shift); |
} |
if (!shift) |
{ |
shift = 4; |
sp++; |
} |
else |
shift -= 4; |
} |
} |
break; |
} |
case 8: |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
if (gamma_table != NULL) |
{ |
sp = row; |
for (i = 0; i < row_width; i++, sp++) |
{ |
if (*sp == trans_values->gray) |
{ |
*sp = (png_byte)background->gray; |
} |
else |
{ |
*sp = gamma_table[*sp]; |
} |
} |
} |
else |
#endif |
{ |
sp = row; |
for (i = 0; i < row_width; i++, sp++) |
{ |
if (*sp == trans_values->gray) |
{ |
*sp = (png_byte)background->gray; |
} |
} |
} |
break; |
} |
case 16: |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
if (gamma_16 != NULL) |
{ |
sp = row; |
for (i = 0; i < row_width; i++, sp += 2) |
{ |
png_uint_16 v; |
v = (png_uint_16)(((*sp) << 8) + *(sp + 1)); |
if (v == trans_values->gray) |
{ |
/* background is already in screen gamma */ |
*sp = (png_byte)((background->gray >> 8) & 0xff); |
*(sp + 1) = (png_byte)(background->gray & 0xff); |
} |
else |
{ |
v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; |
*sp = (png_byte)((v >> 8) & 0xff); |
*(sp + 1) = (png_byte)(v & 0xff); |
} |
} |
} |
else |
#endif |
{ |
sp = row; |
for (i = 0; i < row_width; i++, sp += 2) |
{ |
png_uint_16 v; |
v = (png_uint_16)(((*sp) << 8) + *(sp + 1)); |
if (v == trans_values->gray) |
{ |
*sp = (png_byte)((background->gray >> 8) & 0xff); |
*(sp + 1) = (png_byte)(background->gray & 0xff); |
} |
} |
} |
break; |
} |
} |
break; |
} |
case PNG_COLOR_TYPE_RGB: |
{ |
if (row_info->bit_depth == 8) |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
if (gamma_table != NULL) |
{ |
sp = row; |
for (i = 0; i < row_width; i++, sp += 3) |
{ |
if (*sp == trans_values->red && |
*(sp + 1) == trans_values->green && |
*(sp + 2) == trans_values->blue) |
{ |
*sp = (png_byte)background->red; |
*(sp + 1) = (png_byte)background->green; |
*(sp + 2) = (png_byte)background->blue; |
} |
else |
{ |
*sp = gamma_table[*sp]; |
*(sp + 1) = gamma_table[*(sp + 1)]; |
*(sp + 2) = gamma_table[*(sp + 2)]; |
} |
} |
} |
else |
#endif |
{ |
sp = row; |
for (i = 0; i < row_width; i++, sp += 3) |
{ |
if (*sp == trans_values->red && |
*(sp + 1) == trans_values->green && |
*(sp + 2) == trans_values->blue) |
{ |
*sp = (png_byte)background->red; |
*(sp + 1) = (png_byte)background->green; |
*(sp + 2) = (png_byte)background->blue; |
} |
} |
} |
} |
else /* if (row_info->bit_depth == 16) */ |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
if (gamma_16 != NULL) |
{ |
sp = row; |
for (i = 0; i < row_width; i++, sp += 6) |
{ |
png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1)); |
png_uint_16 g = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3)); |
png_uint_16 b = (png_uint_16)(((*(sp+4)) << 8) + *(sp+5)); |
if (r == trans_values->red && g == trans_values->green && |
b == trans_values->blue) |
{ |
/* background is already in screen gamma */ |
*sp = (png_byte)((background->red >> 8) & 0xff); |
*(sp + 1) = (png_byte)(background->red & 0xff); |
*(sp + 2) = (png_byte)((background->green >> 8) & 0xff); |
*(sp + 3) = (png_byte)(background->green & 0xff); |
*(sp + 4) = (png_byte)((background->blue >> 8) & 0xff); |
*(sp + 5) = (png_byte)(background->blue & 0xff); |
} |
else |
{ |
png_uint_16 v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; |
*sp = (png_byte)((v >> 8) & 0xff); |
*(sp + 1) = (png_byte)(v & 0xff); |
v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)]; |
*(sp + 2) = (png_byte)((v >> 8) & 0xff); |
*(sp + 3) = (png_byte)(v & 0xff); |
v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)]; |
*(sp + 4) = (png_byte)((v >> 8) & 0xff); |
*(sp + 5) = (png_byte)(v & 0xff); |
} |
} |
} |
else |
#endif |
{ |
sp = row; |
for (i = 0; i < row_width; i++, sp += 6) |
{ |
png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp+1)); |
png_uint_16 g = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3)); |
png_uint_16 b = (png_uint_16)(((*(sp+4)) << 8) + *(sp+5)); |
if (r == trans_values->red && g == trans_values->green && |
b == trans_values->blue) |
{ |
*sp = (png_byte)((background->red >> 8) & 0xff); |
*(sp + 1) = (png_byte)(background->red & 0xff); |
*(sp + 2) = (png_byte)((background->green >> 8) & 0xff); |
*(sp + 3) = (png_byte)(background->green & 0xff); |
*(sp + 4) = (png_byte)((background->blue >> 8) & 0xff); |
*(sp + 5) = (png_byte)(background->blue & 0xff); |
} |
} |
} |
} |
break; |
} |
case PNG_COLOR_TYPE_GRAY_ALPHA: |
{ |
if (row_info->bit_depth == 8) |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
if (gamma_to_1 != NULL && gamma_from_1 != NULL && |
gamma_table != NULL) |
{ |
sp = row; |
dp = row; |
for (i = 0; i < row_width; i++, sp += 2, dp++) |
{ |
png_uint_16 a = *(sp + 1); |
if (a == 0xff) |
{ |
*dp = gamma_table[*sp]; |
} |
else if (a == 0) |
{ |
/* background is already in screen gamma */ |
*dp = (png_byte)background->gray; |
} |
else |
{ |
png_byte v, w; |
v = gamma_to_1[*sp]; |
png_composite(w, v, a, background_1->gray); |
*dp = gamma_from_1[w]; |
} |
} |
} |
else |
#endif |
{ |
sp = row; |
dp = row; |
for (i = 0; i < row_width; i++, sp += 2, dp++) |
{ |
png_byte a = *(sp + 1); |
if (a == 0xff) |
{ |
*dp = *sp; |
} |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
else if (a == 0) |
{ |
*dp = (png_byte)background->gray; |
} |
else |
{ |
png_composite(*dp, *sp, a, background_1->gray); |
} |
#else |
*dp = (png_byte)background->gray; |
#endif |
} |
} |
} |
else /* if (png_ptr->bit_depth == 16) */ |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
if (gamma_16 != NULL && gamma_16_from_1 != NULL && |
gamma_16_to_1 != NULL) |
{ |
sp = row; |
dp = row; |
for (i = 0; i < row_width; i++, sp += 4, dp += 2) |
{ |
png_uint_16 a = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3)); |
if (a == (png_uint_16)0xffff) |
{ |
png_uint_16 v; |
v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; |
*dp = (png_byte)((v >> 8) & 0xff); |
*(dp + 1) = (png_byte)(v & 0xff); |
} |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
else if (a == 0) |
#else |
else |
#endif |
{ |
/* background is already in screen gamma */ |
*dp = (png_byte)((background->gray >> 8) & 0xff); |
*(dp + 1) = (png_byte)(background->gray & 0xff); |
} |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
else |
{ |
png_uint_16 g, v, w; |
g = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp]; |
png_composite_16(v, g, a, background_1->gray); |
w = gamma_16_from_1[(v&0xff) >> gamma_shift][v >> 8]; |
*dp = (png_byte)((w >> 8) & 0xff); |
*(dp + 1) = (png_byte)(w & 0xff); |
} |
#endif |
} |
} |
else |
#endif |
{ |
sp = row; |
dp = row; |
for (i = 0; i < row_width; i++, sp += 4, dp += 2) |
{ |
png_uint_16 a = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3)); |
if (a == (png_uint_16)0xffff) |
{ |
png_memcpy(dp, sp, 2); |
} |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
else if (a == 0) |
#else |
else |
#endif |
{ |
*dp = (png_byte)((background->gray >> 8) & 0xff); |
*(dp + 1) = (png_byte)(background->gray & 0xff); |
} |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
else |
{ |
png_uint_16 g, v; |
g = (png_uint_16)(((*sp) << 8) + *(sp + 1)); |
png_composite_16(v, g, a, background_1->gray); |
*dp = (png_byte)((v >> 8) & 0xff); |
*(dp + 1) = (png_byte)(v & 0xff); |
} |
#endif |
} |
} |
} |
break; |
} |
case PNG_COLOR_TYPE_RGB_ALPHA: |
{ |
if (row_info->bit_depth == 8) |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
if (gamma_to_1 != NULL && gamma_from_1 != NULL && |
gamma_table != NULL) |
{ |
sp = row; |
dp = row; |
for (i = 0; i < row_width; i++, sp += 4, dp += 3) |
{ |
png_byte a = *(sp + 3); |
if (a == 0xff) |
{ |
*dp = gamma_table[*sp]; |
*(dp + 1) = gamma_table[*(sp + 1)]; |
*(dp + 2) = gamma_table[*(sp + 2)]; |
} |
else if (a == 0) |
{ |
/* background is already in screen gamma */ |
*dp = (png_byte)background->red; |
*(dp + 1) = (png_byte)background->green; |
*(dp + 2) = (png_byte)background->blue; |
} |
else |
{ |
png_byte v, w; |
v = gamma_to_1[*sp]; |
png_composite(w, v, a, background_1->red); |
*dp = gamma_from_1[w]; |
v = gamma_to_1[*(sp + 1)]; |
png_composite(w, v, a, background_1->green); |
*(dp + 1) = gamma_from_1[w]; |
v = gamma_to_1[*(sp + 2)]; |
png_composite(w, v, a, background_1->blue); |
*(dp + 2) = gamma_from_1[w]; |
} |
} |
} |
else |
#endif |
{ |
sp = row; |
dp = row; |
for (i = 0; i < row_width; i++, sp += 4, dp += 3) |
{ |
png_byte a = *(sp + 3); |
if (a == 0xff) |
{ |
*dp = *sp; |
*(dp + 1) = *(sp + 1); |
*(dp + 2) = *(sp + 2); |
} |
else if (a == 0) |
{ |
*dp = (png_byte)background->red; |
*(dp + 1) = (png_byte)background->green; |
*(dp + 2) = (png_byte)background->blue; |
} |
else |
{ |
png_composite(*dp, *sp, a, background->red); |
png_composite(*(dp + 1), *(sp + 1), a, |
background->green); |
png_composite(*(dp + 2), *(sp + 2), a, |
background->blue); |
} |
} |
} |
} |
else /* if (row_info->bit_depth == 16) */ |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
if (gamma_16 != NULL && gamma_16_from_1 != NULL && |
gamma_16_to_1 != NULL) |
{ |
sp = row; |
dp = row; |
for (i = 0; i < row_width; i++, sp += 8, dp += 6) |
{ |
png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6)) |
<< 8) + (png_uint_16)(*(sp + 7))); |
if (a == (png_uint_16)0xffff) |
{ |
png_uint_16 v; |
v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; |
*dp = (png_byte)((v >> 8) & 0xff); |
*(dp + 1) = (png_byte)(v & 0xff); |
v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)]; |
*(dp + 2) = (png_byte)((v >> 8) & 0xff); |
*(dp + 3) = (png_byte)(v & 0xff); |
v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)]; |
*(dp + 4) = (png_byte)((v >> 8) & 0xff); |
*(dp + 5) = (png_byte)(v & 0xff); |
} |
else if (a == 0) |
{ |
/* background is already in screen gamma */ |
*dp = (png_byte)((background->red >> 8) & 0xff); |
*(dp + 1) = (png_byte)(background->red & 0xff); |
*(dp + 2) = (png_byte)((background->green >> 8) & 0xff); |
*(dp + 3) = (png_byte)(background->green & 0xff); |
*(dp + 4) = (png_byte)((background->blue >> 8) & 0xff); |
*(dp + 5) = (png_byte)(background->blue & 0xff); |
} |
else |
{ |
png_uint_16 v, w, x; |
v = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp]; |
png_composite_16(w, v, a, background_1->red); |
x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8]; |
*dp = (png_byte)((x >> 8) & 0xff); |
*(dp + 1) = (png_byte)(x & 0xff); |
v = gamma_16_to_1[*(sp + 3) >> gamma_shift][*(sp + 2)]; |
png_composite_16(w, v, a, background_1->green); |
x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8]; |
*(dp + 2) = (png_byte)((x >> 8) & 0xff); |
*(dp + 3) = (png_byte)(x & 0xff); |
v = gamma_16_to_1[*(sp + 5) >> gamma_shift][*(sp + 4)]; |
png_composite_16(w, v, a, background_1->blue); |
x = gamma_16_from_1[(w & 0xff) >> gamma_shift][w >> 8]; |
*(dp + 4) = (png_byte)((x >> 8) & 0xff); |
*(dp + 5) = (png_byte)(x & 0xff); |
} |
} |
} |
else |
#endif |
{ |
sp = row; |
dp = row; |
for (i = 0; i < row_width; i++, sp += 8, dp += 6) |
{ |
png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6)) |
<< 8) + (png_uint_16)(*(sp + 7))); |
if (a == (png_uint_16)0xffff) |
{ |
png_memcpy(dp, sp, 6); |
} |
else if (a == 0) |
{ |
*dp = (png_byte)((background->red >> 8) & 0xff); |
*(dp + 1) = (png_byte)(background->red & 0xff); |
*(dp + 2) = (png_byte)((background->green >> 8) & 0xff); |
*(dp + 3) = (png_byte)(background->green & 0xff); |
*(dp + 4) = (png_byte)((background->blue >> 8) & 0xff); |
*(dp + 5) = (png_byte)(background->blue & 0xff); |
} |
else |
{ |
png_uint_16 v; |
png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1)); |
png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8) |
+ *(sp + 3)); |
png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8) |
+ *(sp + 5)); |
png_composite_16(v, r, a, background->red); |
*dp = (png_byte)((v >> 8) & 0xff); |
*(dp + 1) = (png_byte)(v & 0xff); |
png_composite_16(v, g, a, background->green); |
*(dp + 2) = (png_byte)((v >> 8) & 0xff); |
*(dp + 3) = (png_byte)(v & 0xff); |
png_composite_16(v, b, a, background->blue); |
*(dp + 4) = (png_byte)((v >> 8) & 0xff); |
*(dp + 5) = (png_byte)(v & 0xff); |
} |
} |
} |
} |
break; |
} |
} |
if (row_info->color_type & PNG_COLOR_MASK_ALPHA) |
{ |
row_info->color_type &= ~PNG_COLOR_MASK_ALPHA; |
row_info->channels--; |
row_info->pixel_depth = (png_byte)(row_info->channels * |
row_info->bit_depth); |
row_info->rowbytes = ((row_width * |
row_info->pixel_depth + 7) >> 3); |
} |
} |
} |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
/* Gamma correct the image, avoiding the alpha channel. Make sure |
* you do this after you deal with the transparency issue on grayscale |
* or RGB images. If your bit depth is 8, use gamma_table, if it |
* is 16, use gamma_16_table and gamma_shift. Build these with |
* build_gamma_table(). |
*/ |
void /* PRIVATE */ |
png_do_gamma(png_row_infop row_info, png_bytep row, |
png_bytep gamma_table, png_uint_16pp gamma_16_table, |
int gamma_shift) |
{ |
png_bytep sp; |
png_uint_32 i; |
png_uint_32 row_width=row_info->width; |
png_debug(1, "in png_do_gamma\n"); |
if ( |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
row != NULL && row_info != NULL && |
#endif |
((row_info->bit_depth <= 8 && gamma_table != NULL) || |
(row_info->bit_depth == 16 && gamma_16_table != NULL))) |
{ |
switch (row_info->color_type) |
{ |
case PNG_COLOR_TYPE_RGB: |
{ |
if (row_info->bit_depth == 8) |
{ |
sp = row; |
for (i = 0; i < row_width; i++) |
{ |
*sp = gamma_table[*sp]; |
sp++; |
*sp = gamma_table[*sp]; |
sp++; |
*sp = gamma_table[*sp]; |
sp++; |
} |
} |
else /* if (row_info->bit_depth == 16) */ |
{ |
sp = row; |
for (i = 0; i < row_width; i++) |
{ |
png_uint_16 v; |
v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; |
*sp = (png_byte)((v >> 8) & 0xff); |
*(sp + 1) = (png_byte)(v & 0xff); |
sp += 2; |
v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; |
*sp = (png_byte)((v >> 8) & 0xff); |
*(sp + 1) = (png_byte)(v & 0xff); |
sp += 2; |
v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; |
*sp = (png_byte)((v >> 8) & 0xff); |
*(sp + 1) = (png_byte)(v & 0xff); |
sp += 2; |
} |
} |
break; |
} |
case PNG_COLOR_TYPE_RGB_ALPHA: |
{ |
if (row_info->bit_depth == 8) |
{ |
sp = row; |
for (i = 0; i < row_width; i++) |
{ |
*sp = gamma_table[*sp]; |
sp++; |
*sp = gamma_table[*sp]; |
sp++; |
*sp = gamma_table[*sp]; |
sp++; |
sp++; |
} |
} |
else /* if (row_info->bit_depth == 16) */ |
{ |
sp = row; |
for (i = 0; i < row_width; i++) |
{ |
png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; |
*sp = (png_byte)((v >> 8) & 0xff); |
*(sp + 1) = (png_byte)(v & 0xff); |
sp += 2; |
v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; |
*sp = (png_byte)((v >> 8) & 0xff); |
*(sp + 1) = (png_byte)(v & 0xff); |
sp += 2; |
v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; |
*sp = (png_byte)((v >> 8) & 0xff); |
*(sp + 1) = (png_byte)(v & 0xff); |
sp += 4; |
} |
} |
break; |
} |
case PNG_COLOR_TYPE_GRAY_ALPHA: |
{ |
if (row_info->bit_depth == 8) |
{ |
sp = row; |
for (i = 0; i < row_width; i++) |
{ |
*sp = gamma_table[*sp]; |
sp += 2; |
} |
} |
else /* if (row_info->bit_depth == 16) */ |
{ |
sp = row; |
for (i = 0; i < row_width; i++) |
{ |
png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; |
*sp = (png_byte)((v >> 8) & 0xff); |
*(sp + 1) = (png_byte)(v & 0xff); |
sp += 4; |
} |
} |
break; |
} |
case PNG_COLOR_TYPE_GRAY: |
{ |
if (row_info->bit_depth == 2) |
{ |
sp = row; |
for (i = 0; i < row_width; i += 4) |
{ |
int a = *sp & 0xc0; |
int b = *sp & 0x30; |
int c = *sp & 0x0c; |
int d = *sp & 0x03; |
*sp = (png_byte)( |
((((int)gamma_table[a|(a>>2)|(a>>4)|(a>>6)]) ) & 0xc0)| |
((((int)gamma_table[(b<<2)|b|(b>>2)|(b>>4)])>>2) & 0x30)| |
((((int)gamma_table[(c<<4)|(c<<2)|c|(c>>2)])>>4) & 0x0c)| |
((((int)gamma_table[(d<<6)|(d<<4)|(d<<2)|d])>>6) )); |
sp++; |
} |
} |
if (row_info->bit_depth == 4) |
{ |
sp = row; |
for (i = 0; i < row_width; i += 2) |
{ |
int msb = *sp & 0xf0; |
int lsb = *sp & 0x0f; |
*sp = (png_byte)((((int)gamma_table[msb | (msb >> 4)]) & 0xf0) |
| (((int)gamma_table[(lsb << 4) | lsb]) >> 4)); |
sp++; |
} |
} |
else if (row_info->bit_depth == 8) |
{ |
sp = row; |
for (i = 0; i < row_width; i++) |
{ |
*sp = gamma_table[*sp]; |
sp++; |
} |
} |
else if (row_info->bit_depth == 16) |
{ |
sp = row; |
for (i = 0; i < row_width; i++) |
{ |
png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; |
*sp = (png_byte)((v >> 8) & 0xff); |
*(sp + 1) = (png_byte)(v & 0xff); |
sp += 2; |
} |
} |
break; |
} |
} |
} |
} |
#endif |
#if defined(PNG_READ_EXPAND_SUPPORTED) |
/* Expands a palette row to an RGB or RGBA row depending |
* upon whether you supply trans and num_trans. |
*/ |
void /* PRIVATE */ |
png_do_expand_palette(png_row_infop row_info, png_bytep row, |
png_colorp palette, png_bytep trans, int num_trans) |
{ |
int shift, value; |
png_bytep sp, dp; |
png_uint_32 i; |
png_uint_32 row_width=row_info->width; |
png_debug(1, "in png_do_expand_palette\n"); |
if ( |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
row != NULL && row_info != NULL && |
#endif |
row_info->color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
if (row_info->bit_depth < 8) |
{ |
switch (row_info->bit_depth) |
{ |
case 1: |
{ |
sp = row + (png_size_t)((row_width - 1) >> 3); |
dp = row + (png_size_t)row_width - 1; |
shift = 7 - (int)((row_width + 7) & 0x07); |
for (i = 0; i < row_width; i++) |
{ |
if ((*sp >> shift) & 0x01) |
*dp = 1; |
else |
*dp = 0; |
if (shift == 7) |
{ |
shift = 0; |
sp--; |
} |
else |
shift++; |
dp--; |
} |
break; |
} |
case 2: |
{ |
sp = row + (png_size_t)((row_width - 1) >> 2); |
dp = row + (png_size_t)row_width - 1; |
shift = (int)((3 - ((row_width + 3) & 0x03)) << 1); |
for (i = 0; i < row_width; i++) |
{ |
value = (*sp >> shift) & 0x03; |
*dp = (png_byte)value; |
if (shift == 6) |
{ |
shift = 0; |
sp--; |
} |
else |
shift += 2; |
dp--; |
} |
break; |
} |
case 4: |
{ |
sp = row + (png_size_t)((row_width - 1) >> 1); |
dp = row + (png_size_t)row_width - 1; |
shift = (int)((row_width & 0x01) << 2); |
for (i = 0; i < row_width; i++) |
{ |
value = (*sp >> shift) & 0x0f; |
*dp = (png_byte)value; |
if (shift == 4) |
{ |
shift = 0; |
sp--; |
} |
else |
shift += 4; |
dp--; |
} |
break; |
} |
} |
row_info->bit_depth = 8; |
row_info->pixel_depth = 8; |
row_info->rowbytes = row_width; |
} |
switch (row_info->bit_depth) |
{ |
case 8: |
{ |
if (trans != NULL) |
{ |
sp = row + (png_size_t)row_width - 1; |
dp = row + (png_size_t)(row_width << 2) - 1; |
for (i = 0; i < row_width; i++) |
{ |
if ((int)(*sp) >= num_trans) |
*dp-- = 0xff; |
else |
*dp-- = trans[*sp]; |
*dp-- = palette[*sp].blue; |
*dp-- = palette[*sp].green; |
*dp-- = palette[*sp].red; |
sp--; |
} |
row_info->bit_depth = 8; |
row_info->pixel_depth = 32; |
row_info->rowbytes = row_width * 4; |
row_info->color_type = 6; |
row_info->channels = 4; |
} |
else |
{ |
sp = row + (png_size_t)row_width - 1; |
dp = row + (png_size_t)(row_width * 3) - 1; |
for (i = 0; i < row_width; i++) |
{ |
*dp-- = palette[*sp].blue; |
*dp-- = palette[*sp].green; |
*dp-- = palette[*sp].red; |
sp--; |
} |
row_info->bit_depth = 8; |
row_info->pixel_depth = 24; |
row_info->rowbytes = row_width * 3; |
row_info->color_type = 2; |
row_info->channels = 3; |
} |
break; |
} |
} |
} |
} |
/* If the bit depth < 8, it is expanded to 8. Also, if the |
* transparency value is supplied, an alpha channel is built. |
*/ |
void /* PRIVATE */ |
png_do_expand(png_row_infop row_info, png_bytep row, |
png_color_16p trans_value) |
{ |
int shift, value; |
png_bytep sp, dp; |
png_uint_32 i; |
png_uint_32 row_width=row_info->width; |
png_debug(1, "in png_do_expand\n"); |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
if (row != NULL && row_info != NULL) |
#endif |
{ |
if (row_info->color_type == PNG_COLOR_TYPE_GRAY) |
{ |
png_uint_16 gray = (png_uint_16)(trans_value ? trans_value->gray : 0); |
if (row_info->bit_depth < 8) |
{ |
switch (row_info->bit_depth) |
{ |
case 1: |
{ |
gray = (png_uint_16)(gray*0xff); |
sp = row + (png_size_t)((row_width - 1) >> 3); |
dp = row + (png_size_t)row_width - 1; |
shift = 7 - (int)((row_width + 7) & 0x07); |
for (i = 0; i < row_width; i++) |
{ |
if ((*sp >> shift) & 0x01) |
*dp = 0xff; |
else |
*dp = 0; |
if (shift == 7) |
{ |
shift = 0; |
sp--; |
} |
else |
shift++; |
dp--; |
} |
break; |
} |
case 2: |
{ |
gray = (png_uint_16)(gray*0x55); |
sp = row + (png_size_t)((row_width - 1) >> 2); |
dp = row + (png_size_t)row_width - 1; |
shift = (int)((3 - ((row_width + 3) & 0x03)) << 1); |
for (i = 0; i < row_width; i++) |
{ |
value = (*sp >> shift) & 0x03; |
*dp = (png_byte)(value | (value << 2) | (value << 4) | |
(value << 6)); |
if (shift == 6) |
{ |
shift = 0; |
sp--; |
} |
else |
shift += 2; |
dp--; |
} |
break; |
} |
case 4: |
{ |
gray = (png_uint_16)(gray*0x11); |
sp = row + (png_size_t)((row_width - 1) >> 1); |
dp = row + (png_size_t)row_width - 1; |
shift = (int)((1 - ((row_width + 1) & 0x01)) << 2); |
for (i = 0; i < row_width; i++) |
{ |
value = (*sp >> shift) & 0x0f; |
*dp = (png_byte)(value | (value << 4)); |
if (shift == 4) |
{ |
shift = 0; |
sp--; |
} |
else |
shift = 4; |
dp--; |
} |
break; |
} |
} |
row_info->bit_depth = 8; |
row_info->pixel_depth = 8; |
row_info->rowbytes = row_width; |
} |
if (trans_value != NULL) |
{ |
if (row_info->bit_depth == 8) |
{ |
sp = row + (png_size_t)row_width - 1; |
dp = row + (png_size_t)(row_width << 1) - 1; |
for (i = 0; i < row_width; i++) |
{ |
if (*sp == gray) |
*dp-- = 0; |
else |
*dp-- = 0xff; |
*dp-- = *sp--; |
} |
} |
else if (row_info->bit_depth == 16) |
{ |
sp = row + row_info->rowbytes - 1; |
dp = row + (row_info->rowbytes << 1) - 1; |
for (i = 0; i < row_width; i++) |
{ |
if (((png_uint_16)*(sp) | |
((png_uint_16)*(sp - 1) << 8)) == gray) |
{ |
*dp-- = 0; |
*dp-- = 0; |
} |
else |
{ |
*dp-- = 0xff; |
*dp-- = 0xff; |
} |
*dp-- = *sp--; |
*dp-- = *sp--; |
} |
} |
row_info->color_type = PNG_COLOR_TYPE_GRAY_ALPHA; |
row_info->channels = 2; |
row_info->pixel_depth = (png_byte)(row_info->bit_depth << 1); |
row_info->rowbytes = |
((row_width * row_info->pixel_depth) >> 3); |
} |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_RGB && trans_value) |
{ |
if (row_info->bit_depth == 8) |
{ |
sp = row + (png_size_t)row_info->rowbytes - 1; |
dp = row + (png_size_t)(row_width << 2) - 1; |
for (i = 0; i < row_width; i++) |
{ |
if (*(sp - 2) == trans_value->red && |
*(sp - 1) == trans_value->green && |
*(sp - 0) == trans_value->blue) |
*dp-- = 0; |
else |
*dp-- = 0xff; |
*dp-- = *sp--; |
*dp-- = *sp--; |
*dp-- = *sp--; |
} |
} |
else if (row_info->bit_depth == 16) |
{ |
sp = row + row_info->rowbytes - 1; |
dp = row + (png_size_t)(row_width << 3) - 1; |
for (i = 0; i < row_width; i++) |
{ |
if ((((png_uint_16)*(sp - 4) | |
((png_uint_16)*(sp - 5) << 8)) == trans_value->red) && |
(((png_uint_16)*(sp - 2) | |
((png_uint_16)*(sp - 3) << 8)) == trans_value->green) && |
(((png_uint_16)*(sp - 0) | |
((png_uint_16)*(sp - 1) << 8)) == trans_value->blue)) |
{ |
*dp-- = 0; |
*dp-- = 0; |
} |
else |
{ |
*dp-- = 0xff; |
*dp-- = 0xff; |
} |
*dp-- = *sp--; |
*dp-- = *sp--; |
*dp-- = *sp--; |
*dp-- = *sp--; |
*dp-- = *sp--; |
*dp-- = *sp--; |
} |
} |
row_info->color_type = PNG_COLOR_TYPE_RGB_ALPHA; |
row_info->channels = 4; |
row_info->pixel_depth = (png_byte)(row_info->bit_depth << 2); |
row_info->rowbytes = |
((row_width * row_info->pixel_depth) >> 3); |
} |
} |
} |
#endif |
#if defined(PNG_READ_DITHER_SUPPORTED) |
void /* PRIVATE */ |
png_do_dither(png_row_infop row_info, png_bytep row, |
png_bytep palette_lookup, png_bytep dither_lookup) |
{ |
png_bytep sp, dp; |
png_uint_32 i; |
png_uint_32 row_width=row_info->width; |
png_debug(1, "in png_do_dither\n"); |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
if (row != NULL && row_info != NULL) |
#endif |
{ |
if (row_info->color_type == PNG_COLOR_TYPE_RGB && |
palette_lookup && row_info->bit_depth == 8) |
{ |
int r, g, b, p; |
sp = row; |
dp = row; |
for (i = 0; i < row_width; i++) |
{ |
r = *sp++; |
g = *sp++; |
b = *sp++; |
/* this looks real messy, but the compiler will reduce |
it down to a reasonable formula. For example, with |
5 bits per color, we get: |
p = (((r >> 3) & 0x1f) << 10) | |
(((g >> 3) & 0x1f) << 5) | |
((b >> 3) & 0x1f); |
*/ |
p = (((r >> (8 - PNG_DITHER_RED_BITS)) & |
((1 << PNG_DITHER_RED_BITS) - 1)) << |
(PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) | |
(((g >> (8 - PNG_DITHER_GREEN_BITS)) & |
((1 << PNG_DITHER_GREEN_BITS) - 1)) << |
(PNG_DITHER_BLUE_BITS)) | |
((b >> (8 - PNG_DITHER_BLUE_BITS)) & |
((1 << PNG_DITHER_BLUE_BITS) - 1)); |
*dp++ = palette_lookup[p]; |
} |
row_info->color_type = PNG_COLOR_TYPE_PALETTE; |
row_info->channels = 1; |
row_info->pixel_depth = row_info->bit_depth; |
row_info->rowbytes = |
((row_width * row_info->pixel_depth + 7) >> 3); |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA && |
palette_lookup != NULL && row_info->bit_depth == 8) |
{ |
int r, g, b, p; |
sp = row; |
dp = row; |
for (i = 0; i < row_width; i++) |
{ |
r = *sp++; |
g = *sp++; |
b = *sp++; |
sp++; |
p = (((r >> (8 - PNG_DITHER_RED_BITS)) & |
((1 << PNG_DITHER_RED_BITS) - 1)) << |
(PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) | |
(((g >> (8 - PNG_DITHER_GREEN_BITS)) & |
((1 << PNG_DITHER_GREEN_BITS) - 1)) << |
(PNG_DITHER_BLUE_BITS)) | |
((b >> (8 - PNG_DITHER_BLUE_BITS)) & |
((1 << PNG_DITHER_BLUE_BITS) - 1)); |
*dp++ = palette_lookup[p]; |
} |
row_info->color_type = PNG_COLOR_TYPE_PALETTE; |
row_info->channels = 1; |
row_info->pixel_depth = row_info->bit_depth; |
row_info->rowbytes = |
((row_width * row_info->pixel_depth + 7) >> 3); |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_PALETTE && |
dither_lookup && row_info->bit_depth == 8) |
{ |
sp = row; |
for (i = 0; i < row_width; i++, sp++) |
{ |
*sp = dither_lookup[*sp]; |
} |
} |
} |
} |
#endif |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
static int png_gamma_shift[] = |
{0x10, 0x21, 0x42, 0x84, 0x110, 0x248, 0x550, 0xff0}; |
/* We build the 8- or 16-bit gamma tables here. Note that for 16-bit |
* tables, we don't make a full table if we are reducing to 8-bit in |
* the future. Note also how the gamma_16 tables are segmented so that |
* we don't need to allocate > 64K chunks for a full 16-bit table. |
*/ |
void /* PRIVATE */ |
png_build_gamma_table(png_structp png_ptr) |
{ |
png_debug(1, "in png_build_gamma_table\n"); |
if(png_ptr->gamma != 0.0) |
{ |
if (png_ptr->bit_depth <= 8) |
{ |
int i; |
double g; |
if (png_ptr->screen_gamma > .000001) |
g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma); |
else |
g = 1.0; |
png_ptr->gamma_table = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)256); |
for (i = 0; i < 256; i++) |
{ |
png_ptr->gamma_table[i] = (png_byte)(pow((double)i / 255.0, |
g) * 255.0 + .5); |
} |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \ |
defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) |
if (png_ptr->transformations & ((PNG_BACKGROUND) | PNG_RGB_TO_GRAY)) |
{ |
g = 1.0 / (png_ptr->gamma); |
png_ptr->gamma_to_1 = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)256); |
for (i = 0; i < 256; i++) |
{ |
png_ptr->gamma_to_1[i] = (png_byte)(pow((double)i / 255.0, |
g) * 255.0 + .5); |
} |
png_ptr->gamma_from_1 = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)256); |
if(png_ptr->screen_gamma > 0.000001) |
g = 1.0 / png_ptr->screen_gamma; |
else |
g = png_ptr->gamma; /* probably doing rgb_to_gray */ |
for (i = 0; i < 256; i++) |
{ |
png_ptr->gamma_from_1[i] = (png_byte)(pow((double)i / 255.0, |
g) * 255.0 + .5); |
} |
} |
#endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */ |
} |
else |
{ |
double g; |
int i, j, shift, num; |
int sig_bit; |
png_uint_32 ig; |
if (png_ptr->color_type & PNG_COLOR_MASK_COLOR) |
{ |
sig_bit = (int)png_ptr->sig_bit.red; |
if ((int)png_ptr->sig_bit.green > sig_bit) |
sig_bit = png_ptr->sig_bit.green; |
if ((int)png_ptr->sig_bit.blue > sig_bit) |
sig_bit = png_ptr->sig_bit.blue; |
} |
else |
{ |
sig_bit = (int)png_ptr->sig_bit.gray; |
} |
if (sig_bit > 0) |
shift = 16 - sig_bit; |
else |
shift = 0; |
if (png_ptr->transformations & PNG_16_TO_8) |
{ |
if (shift < (16 - PNG_MAX_GAMMA_8)) |
shift = (16 - PNG_MAX_GAMMA_8); |
} |
if (shift > 8) |
shift = 8; |
if (shift < 0) |
shift = 0; |
png_ptr->gamma_shift = (png_byte)shift; |
num = (1 << (8 - shift)); |
if (png_ptr->screen_gamma > .000001) |
g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma); |
else |
g = 1.0; |
png_ptr->gamma_16_table = (png_uint_16pp)png_malloc(png_ptr, |
(png_uint_32)(num * sizeof (png_uint_16p))); |
if (png_ptr->transformations & (PNG_16_TO_8 | PNG_BACKGROUND)) |
{ |
double fin, fout; |
png_uint_32 last, max; |
for (i = 0; i < num; i++) |
{ |
png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr, |
(png_uint_32)(256 * sizeof (png_uint_16))); |
} |
g = 1.0 / g; |
last = 0; |
for (i = 0; i < 256; i++) |
{ |
fout = ((double)i + 0.5) / 256.0; |
fin = pow(fout, g); |
max = (png_uint_32)(fin * (double)((png_uint_32)num << 8)); |
while (last <= max) |
{ |
png_ptr->gamma_16_table[(int)(last & (0xff >> shift))] |
[(int)(last >> (8 - shift))] = (png_uint_16)( |
(png_uint_16)i | ((png_uint_16)i << 8)); |
last++; |
} |
} |
while (last < ((png_uint_32)num << 8)) |
{ |
png_ptr->gamma_16_table[(int)(last & (0xff >> shift))] |
[(int)(last >> (8 - shift))] = (png_uint_16)65535L; |
last++; |
} |
} |
else |
{ |
for (i = 0; i < num; i++) |
{ |
png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr, |
(png_uint_32)(256 * sizeof (png_uint_16))); |
ig = (((png_uint_32)i * (png_uint_32)png_gamma_shift[shift]) >> 4); |
for (j = 0; j < 256; j++) |
{ |
png_ptr->gamma_16_table[i][j] = |
(png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) / |
65535.0, g) * 65535.0 + .5); |
} |
} |
} |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \ |
defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) |
if (png_ptr->transformations & (PNG_BACKGROUND | PNG_RGB_TO_GRAY)) |
{ |
g = 1.0 / (png_ptr->gamma); |
png_ptr->gamma_16_to_1 = (png_uint_16pp)png_malloc(png_ptr, |
(png_uint_32)(num * sizeof (png_uint_16p ))); |
for (i = 0; i < num; i++) |
{ |
png_ptr->gamma_16_to_1[i] = (png_uint_16p)png_malloc(png_ptr, |
(png_uint_32)(256 * sizeof (png_uint_16))); |
ig = (((png_uint_32)i * |
(png_uint_32)png_gamma_shift[shift]) >> 4); |
for (j = 0; j < 256; j++) |
{ |
png_ptr->gamma_16_to_1[i][j] = |
(png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) / |
65535.0, g) * 65535.0 + .5); |
} |
} |
if(png_ptr->screen_gamma > 0.000001) |
g = 1.0 / png_ptr->screen_gamma; |
else |
g = png_ptr->gamma; /* probably doing rgb_to_gray */ |
png_ptr->gamma_16_from_1 = (png_uint_16pp)png_malloc(png_ptr, |
(png_uint_32)(num * sizeof (png_uint_16p))); |
for (i = 0; i < num; i++) |
{ |
png_ptr->gamma_16_from_1[i] = (png_uint_16p)png_malloc(png_ptr, |
(png_uint_32)(256 * sizeof (png_uint_16))); |
ig = (((png_uint_32)i * |
(png_uint_32)png_gamma_shift[shift]) >> 4); |
for (j = 0; j < 256; j++) |
{ |
png_ptr->gamma_16_from_1[i][j] = |
(png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) / |
65535.0, g) * 65535.0 + .5); |
} |
} |
} |
#endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */ |
} |
} |
} |
#endif |
/* To do: install integer version of png_build_gamma_table here */ |
#endif |
#if defined(PNG_MNG_FEATURES_SUPPORTED) |
/* undoes intrapixel differencing */ |
void /* PRIVATE */ |
png_do_read_intrapixel(png_row_infop row_info, png_bytep row) |
{ |
png_debug(1, "in png_do_read_intrapixel\n"); |
if ( |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
row != NULL && row_info != NULL && |
#endif |
(row_info->color_type & PNG_COLOR_MASK_COLOR)) |
{ |
int bytes_per_pixel; |
png_uint_32 row_width = row_info->width; |
if (row_info->bit_depth == 8) |
{ |
png_bytep rp; |
png_uint_32 i; |
if (row_info->color_type == PNG_COLOR_TYPE_RGB) |
bytes_per_pixel = 3; |
else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
bytes_per_pixel = 4; |
else |
return; |
for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel) |
{ |
*(rp) = (png_byte)((256 + *rp + *(rp+1))&0xff); |
*(rp+2) = (png_byte)((256 + *(rp+2) + *(rp+1))&0xff); |
} |
} |
else if (row_info->bit_depth == 16) |
{ |
png_bytep rp; |
png_uint_32 i; |
if (row_info->color_type == PNG_COLOR_TYPE_RGB) |
bytes_per_pixel = 6; |
else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
bytes_per_pixel = 8; |
else |
return; |
for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel) |
{ |
png_uint_32 s0=*(rp )<<8 | *(rp+1); |
png_uint_32 s1=*(rp+2)<<8 | *(rp+3); |
png_uint_32 s2=*(rp+4)<<8 | *(rp+5); |
png_uint_32 red=(65536+s0+s1)&0xffff; |
png_uint_32 blue=(65536+s2+s1)&0xffff; |
*(rp ) = (png_byte)((red>>8)&0xff); |
*(rp+1) = (png_byte)(red&0xff); |
*(rp+4) = (png_byte)((blue>>8)&0xff); |
*(rp+5) = (png_byte)(blue&0xff); |
} |
} |
} |
} |
#endif /* PNG_MNG_FEATURES_SUPPORTED */ |
/shark/trunk/ports/mpg123/makefile |
---|
0,0 → 1,33 |
# |
# The mpeg library |
# |
# (see sources for copyrights) |
ifndef BASE |
BASE=../.. |
endif |
include $(BASE)/config/config.mk |
LIBRARY = mp3 |
OBJS_PATH = $(BASE)/ports/mpg123 |
OBJS= decode.o dct64.o common.o decode_2to1.o decode_4to1.o \ |
tabinit.o layer1.o layer2.o layer3.o |
#mpg123.o httpget.o xfermem.o |
#buffer.o getlopt.o |
#OBJS= $(patsubst %.c,%.o,$(SRCS)) |
#C_WARN += -Wno-unused -Wno-uninitialized -Wno-implicit-function-declaration \ |
# -Wno-switch -Wno-return-type |
#C_DEF += -DNOCONTROLS |
C_INC += -I. |
include $(BASE)/config/lib.mk |
/shark/trunk/ports/mpg123/mpg123.h |
---|
0,0 → 1,228 |
/* |
* mpg123 defines |
* used source: musicout.h from mpegaudio package |
*/ |
#include <stdio.h> |
#include <stdlib.h> |
#include <string.h> |
#include <signal.h> |
#include <math.h> |
#include <unistd.h> |
#ifdef OS2 |
#include <float.h> |
#endif |
#define MPG123_REMOTE |
#define SHUFFLESUPPORT |
#ifdef HPUX |
#define random rand |
#define srandom srand |
#endif |
#define FRONTEND_SAJBER 1 |
#define FRONTEND_TK3PLAY 2 |
#ifdef SGI |
#include <audio.h> |
#endif |
#include "xfermem.h" |
#ifdef SUNOS |
#define memmove(dst,src,size) bcopy(src,dst,size) |
#endif |
#ifdef REAL_IS_FLOAT |
# define real float |
#elif defined(REAL_IS_LONG_DOUBLE) |
# define real long double |
#else |
# define real double |
#endif |
#ifdef __GNUC__ |
#define INLINE inline |
#else |
#define INLINE |
#endif |
#if defined(LINUX) || defined(__FreeBSD__) |
#define VOXWARE |
#endif |
#include "audio.h" |
/* AUDIOBUFSIZE = n*64 with n=1,2,3 ... */ |
#define AUDIOBUFSIZE 16384 |
#define FALSE 0 |
#define TRUE 1 |
#define MAX_NAME_SIZE 81 |
#define SBLIMIT 32 |
#define SCALE_BLOCK 12 |
#define SSLIMIT 18 |
#define MPG_MD_STEREO 0 |
#define MPG_MD_JOINT_STEREO 1 |
#define MPG_MD_DUAL_CHANNEL 2 |
#define MPG_MD_MONO 3 |
#define MAXOUTBURST 32768 |
struct al_table |
{ |
short bits; |
short d; |
}; |
struct frame { |
struct al_table *alloc; |
int (*synth)(real *,int,unsigned char *); |
int (*synth_mono)(real *,unsigned char *); |
int stereo; |
int jsbound; |
int single; |
int II_sblimit; |
int lsf; |
int mpeg25; |
int down_sample; |
int header_change; |
int block_size; |
int lay; |
int (*do_layer)(struct frame *fr,int,struct audio_info_struct *); |
int error_protection; |
int bitrate_index; |
int sampling_frequency; |
int padding; |
int extension; |
int mode; |
int mode_ext; |
int copyright; |
int original; |
int emphasis; |
}; |
extern int outmode; |
extern int tryresync; |
extern int quiet; |
extern int halfspeed; |
extern int usebuffer; |
extern int buffer_fd[2]; |
extern txfermem *buffermem; |
extern char *prgName, *prgVersion; |
#ifndef OS2 |
extern void buffer_loop(struct audio_info_struct *ai, sigset_t *oldsigset); |
#endif |
/* ------ Declarations from "httpget.c" ------ */ |
extern char *proxyurl; |
extern unsigned long proxyip; |
extern FILE *http_open (char *url); |
/* ------ Declarations from "common.c" ------ */ |
extern void audio_flush(int, struct audio_info_struct *); |
extern void (*catchsignal(int signum, void(*handler)()))(); |
extern void print_header(struct frame *); |
extern void print_header_compact(struct frame *); |
extern char *strndup(const char *src, int num); |
extern int split_dir_file(const char *path, char **dname, char **fname); |
extern unsigned int get1bit(void); |
extern unsigned int getbits(int); |
extern unsigned int getbits_fast(int); |
extern void set_pointer(long); |
extern unsigned char *pcm_sample; |
extern int pcm_point; |
extern int audiobufsize; |
#ifdef VARMODESUPPORT |
extern int varmode; |
extern int playlimit; |
#endif |
struct III_sideinfo |
{ |
unsigned main_data_begin; |
unsigned private_bits; |
struct { |
struct gr_info_s { |
int scfsi; |
unsigned part2_3_length; |
unsigned big_values; |
unsigned scalefac_compress; |
unsigned block_type; |
unsigned mixed_block_flag; |
unsigned table_select[3]; |
unsigned subblock_gain[3]; |
unsigned maxband[3]; |
unsigned maxbandl; |
unsigned maxb; |
unsigned region1start; |
unsigned region2start; |
unsigned preflag; |
unsigned scalefac_scale; |
unsigned count1table_select; |
real *full_gain[3]; |
real *pow2gain; |
} gr[2]; |
} ch[2]; |
}; |
extern void open_stream(char *,int fd); |
extern void close_stream(void); |
extern long tell_stream(void); |
extern void read_frame_init (void); |
extern int read_frame(struct frame *fr); |
extern int back_frame(struct frame *fr,int num); |
extern void play_frame(int init,struct frame *fr); |
extern int do_layer3(struct frame *fr,int,struct audio_info_struct *); |
extern int do_layer2(struct frame *fr,int,struct audio_info_struct *); |
extern int do_layer1(struct frame *fr,int,struct audio_info_struct *); |
extern int synth_1to1 (real *,int,unsigned char *); |
extern int synth_1to1_8bit (real *,int,unsigned char *); |
extern int synth_2to1 (real *,int,unsigned char *); |
extern int synth_2to1_8bit (real *,int,unsigned char *); |
extern int synth_4to1 (real *,int,unsigned char *); |
extern int synth_4to1_8bit (real *,int,unsigned char *); |
extern int synth_1to1_mono (real *,unsigned char *); |
extern int synth_1to1_8bit_mono (real *,unsigned char *); |
extern int synth_2to1_mono (real *,unsigned char *); |
extern int synth_2to1_8bit_mono (real *,unsigned char *); |
extern int synth_4to1_mono (real *,unsigned char *); |
extern int synth_4to1_8bit_mono (real *,unsigned char *); |
extern void rewindNbits(int bits); |
extern int hsstell(void); |
extern void set_pointer(long); |
extern void huffman_decoder(int ,int *); |
extern void huffman_count1(int,int *); |
extern void init_layer3(int); |
extern void init_layer2(void); |
extern void make_decode_tables(long scale); |
extern void make_conv16to8_table(int); |
extern void dct64(real *,real *,real *); |
extern void control_sajber(struct frame *fr); |
extern void control_tk3play(struct frame *fr); |
extern unsigned char *conv16to8; |
extern long freqs[7]; |
extern real muls[27][64]; |
extern real decwin[512+32]; |
extern real *pnts[5]; |
/shark/trunk/ports/mpg123/layer2.c |
---|
0,0 → 1,265 |
/* |
* Mpeg Layer-2 audio decoder |
* -------------------------- |
* copyright (c) 1995 by Michael Hipp, All rights reserved. See also 'README' |
* |
*/ |
#include "mpg123.h" |
static int grp_3tab[32 * 3] = { 0, }; /* used: 27 */ |
static int grp_5tab[128 * 3] = { 0, }; /* used: 125 */ |
static int grp_9tab[1024 * 3] = { 0, }; /* used: 729 */ |
real muls[27][64]; /* also used by layer 1 */ |
void init_layer2(void) |
{ |
static double mulmul[27] = { |
0.0 , -2.0/3.0 , 2.0/3.0 , |
2.0/7.0 , 2.0/15.0 , 2.0/31.0, 2.0/63.0 , 2.0/127.0 , 2.0/255.0 , |
2.0/511.0 , 2.0/1023.0 , 2.0/2047.0 , 2.0/4095.0 , 2.0/8191.0 , |
2.0/16383.0 , 2.0/32767.0 , 2.0/65535.0 , |
-4.0/5.0 , -2.0/5.0 , 2.0/5.0, 4.0/5.0 , |
-8.0/9.0 , -4.0/9.0 , -2.0/9.0 , 2.0/9.0 , 4.0/9.0 , 8.0/9.0 }; |
static int base[3][9] = { |
{ 1 , 0, 2 , } , |
{ 17, 18, 0 , 19, 20 , } , |
{ 21, 1, 22, 23, 0, 24, 25, 2, 26 } }; |
int i,j,k,l,len; |
real *table; |
static int tablen[3] = { 3 , 5 , 9 }; |
static int *itable,*tables[3] = { grp_3tab , grp_5tab , grp_9tab }; |
for(i=0;i<3;i++) |
{ |
itable = tables[i]; |
len = tablen[i]; |
for(j=0;j<len;j++) |
for(k=0;k<len;k++) |
for(l=0;l<len;l++) |
{ |
*itable++ = base[i][l]; |
*itable++ = base[i][k]; |
*itable++ = base[i][j]; |
} |
} |
for(k=0;k<27;k++) |
{ |
double m=mulmul[k]; |
table = muls[k]; |
for(j=3,i=0;i<63;i++,j--) |
*table++ = m * pow(2.0,(double) j / 3.0); |
*table++ = 0.0; |
} |
} |
void II_step_one(unsigned int *bit_alloc,int *scale,struct frame *fr) |
{ |
int stereo = fr->stereo-1; |
int sblimit = fr->II_sblimit; |
int jsbound = fr->jsbound; |
int sblimit2 = fr->II_sblimit<<stereo; |
struct al_table *alloc1 = fr->alloc; |
int i; |
static unsigned int scfsi_buf[64]; |
unsigned int *scfsi,*bita; |
int sc,step; |
bita = bit_alloc; |
if(stereo) |
{ |
for (i=jsbound;i;i--,alloc1+=(1<<step)) |
{ |
*bita++ = (char) getbits(step=alloc1->bits); |
*bita++ = (char) getbits(step); |
} |
for (i=sblimit-jsbound;i;i--,alloc1+=(1<<step)) |
{ |
bita[0] = (char) getbits(step=alloc1->bits); |
bita[1] = bita[0]; |
bita+=2; |
} |
bita = bit_alloc; |
scfsi=scfsi_buf; |
for (i=sblimit2;i;i--) |
if (*bita++) |
*scfsi++ = (char) getbits_fast(2); |
} |
else /* mono */ |
{ |
for (i=sblimit;i;i--,alloc1+=(1<<step)) |
*bita++ = (char) getbits(step=alloc1->bits); |
bita = bit_alloc; |
scfsi=scfsi_buf; |
for (i=sblimit;i;i--) |
if (*bita++) |
*scfsi++ = (char) getbits_fast(2); |
} |
bita = bit_alloc; |
scfsi=scfsi_buf; |
for (i=sblimit2;i;i--) |
if (*bita++) |
switch (*scfsi++) |
{ |
case 0: |
*scale++ = getbits_fast(6); |
*scale++ = getbits_fast(6); |
*scale++ = getbits_fast(6); |
break; |
case 1 : |
*scale++ = sc = getbits_fast(6); |
*scale++ = sc; |
*scale++ = getbits_fast(6); |
break; |
case 2: |
*scale++ = sc = getbits_fast(6); |
*scale++ = sc; |
*scale++ = sc; |
break; |
default: /* case 3 */ |
*scale++ = getbits_fast(6); |
*scale++ = sc = getbits_fast(6); |
*scale++ = sc; |
break; |
} |
} |
void II_step_two(unsigned int *bit_alloc,real fraction[2][4][SBLIMIT],int *scale,struct frame *fr,int x1) |
{ |
int i,j,k,ba; |
int stereo = fr->stereo; |
int sblimit = fr->II_sblimit; |
int jsbound = fr->jsbound; |
struct al_table *alloc2,*alloc1 = fr->alloc; |
unsigned int *bita=bit_alloc; |
int d1,step; |
for (i=0;i<jsbound;i++,alloc1+=(1<<step)) |
{ |
step = alloc1->bits; |
for (j=0;j<stereo;j++) |
{ |
if ( (ba=*bita++) ) |
{ |
k=(alloc2 = alloc1+ba)->bits; |
if( (d1=alloc2->d) < 0) |
{ |
real cm=muls[k][scale[x1]]; |
fraction[j][0][i] = ((real) ((int)getbits(k) + d1)) * cm; |
fraction[j][1][i] = ((real) ((int)getbits(k) + d1)) * cm; |
fraction[j][2][i] = ((real) ((int)getbits(k) + d1)) * cm; |
} |
else |
{ |
static int *table[] = { 0,0,0,grp_3tab,0,grp_5tab,0,0,0,grp_9tab }; |
unsigned int idx,*tab,m=scale[x1]; |
idx = (unsigned int) getbits(k); |
tab = (unsigned int *) (table[d1] + idx + idx + idx); |
fraction[j][0][i] = muls[*tab++][m]; |
fraction[j][1][i] = muls[*tab++][m]; |
fraction[j][2][i] = muls[*tab][m]; |
} |
scale+=3; |
} |
else |
fraction[j][0][i] = fraction[j][1][i] = fraction[j][2][i] = 0.0; |
} |
} |
for (i=jsbound;i<sblimit;i++,alloc1+=(1<<step)) |
{ |
step = alloc1->bits; |
bita++; /* channel 1 and channel 2 bitalloc are the same */ |
if ( (ba=*bita++) ) |
{ |
k=(alloc2 = alloc1+ba)->bits; |
if( (d1=alloc2->d) < 0) |
{ |
real cm; |
cm=muls[k][scale[x1+3]]; |
fraction[1][0][i] = (fraction[0][0][i] = (real) ((int)getbits(k) + d1) ) * cm; |
fraction[1][1][i] = (fraction[0][1][i] = (real) ((int)getbits(k) + d1) ) * cm; |
fraction[1][2][i] = (fraction[0][2][i] = (real) ((int)getbits(k) + d1) ) * cm; |
cm=muls[k][scale[x1]]; |
fraction[0][0][i] *= cm; fraction[0][1][i] *= cm; fraction[0][2][i] *= cm; |
} |
else |
{ |
static int *table[] = { 0,0,0,grp_3tab,0,grp_5tab,0,0,0,grp_9tab }; |
unsigned int idx,*tab,m1,m2; |
m1 = scale[x1]; m2 = scale[x1+3]; |
idx = (unsigned int) getbits(k); |
tab = (unsigned int *) (table[d1] + idx + idx + idx); |
fraction[0][0][i] = muls[*tab][m1]; fraction[1][0][i] = muls[*tab++][m2]; |
fraction[0][1][i] = muls[*tab][m1]; fraction[1][1][i] = muls[*tab++][m2]; |
fraction[0][2][i] = muls[*tab][m1]; fraction[1][2][i] = muls[*tab][m2]; |
} |
scale+=6; |
} |
else { |
fraction[0][0][i] = fraction[0][1][i] = fraction[0][2][i] = |
fraction[1][0][i] = fraction[1][1][i] = fraction[1][2][i] = 0.0; |
} |
/* |
should we use individual scalefac for channel 2 or |
is the current way the right one , where we just copy channel 1 to |
channel 2 ?? |
The current 'strange' thing is, that we throw away the scalefac |
values for the second channel ...!! |
-> changed .. now we use the scalefac values of channel one !! |
*/ |
} |
if(sblimit > (SBLIMIT>>fr->down_sample) ) |
sblimit = SBLIMIT>>fr->down_sample; |
for(i=sblimit;i<SBLIMIT;i++) |
for (j=0;j<stereo;j++) |
fraction[j][0][i] = fraction[j][1][i] = fraction[j][2][i] = 0.0; |
} |
int do_layer2(struct frame *fr,int outmode,struct audio_info_struct *ai) |
{ |
int clip=0; |
int i,j; |
int stereo = fr->stereo; |
real fraction[2][4][SBLIMIT]; /* pick_table clears unused subbands */ |
unsigned int bit_alloc[64]; |
int scale[192]; |
int single = fr->single; |
if(stereo == 1 || single == 3) |
single = 0; |
II_step_one(bit_alloc, scale, fr); |
for (i=0;i<SCALE_BLOCK;i++) |
{ |
II_step_two(bit_alloc,fraction,scale,fr,i>>2); |
for (j=0;j<3;j++) |
{ |
if(single >= 0) |
{ |
clip += (fr->synth_mono) (fraction[single][j],pcm_sample+pcm_point); |
} |
else { |
clip += (fr->synth) (fraction[0][j],0,pcm_sample+pcm_point); |
clip += (fr->synth) (fraction[1][j],1,pcm_sample+pcm_point); |
} |
pcm_point += fr->block_size; |
if(pcm_point == audiobufsize) |
audio_flush(outmode,ai); |
} |
} |
return clip; |
} |
/shark/trunk/ports/mpg123/layer3.c |
---|
0,0 → 1,2112 |
/* |
* Mpeg Layer-3 audio decoder |
* -------------------------- |
* copyright (c) 1995,1996,1997 by Michael Hipp. |
* All rights reserved. See also 'README' |
* |
* - I'm currently working on that .. needs a few more optimizations, |
* though the code is now fast enough to run in realtime on a 100Mhz 486 |
* - a few personal notes are in german .. |
* |
* used source: |
* mpeg1_iis package |
*/ |
#include "mpg123.h" |
#include "huffman.h" |
#if 0 |
#include "get1bit.h" |
#endif |
static real ispow[8207]; |
static real aa_ca[8],aa_cs[8]; |
static real COS1[12][6]; |
static real win[4][36]; |
static real win1[4][36]; |
static real gainpow2[256+118+4]; |
static real COS9[9]; |
static real COS6_1,COS6_2; |
static real tfcos36[9]; |
static real tfcos12[3]; |
#ifdef NEW_DCT9 |
static real cos9[3],cos18[3]; |
#endif |
struct bandInfoStruct { |
int longIdx[23]; |
int longDiff[22]; |
int shortIdx[14]; |
int shortDiff[13]; |
}; |
int longLimit[7][23]; |
int shortLimit[7][14]; |
struct bandInfoStruct bandInfo[7] = { |
/* MPEG 1.0 */ |
{ {0,4,8,12,16,20,24,30,36,44,52,62,74, 90,110,134,162,196,238,288,342,418,576}, |
{4,4,4,4,4,4,6,6,8, 8,10,12,16,20,24,28,34,42,50,54, 76,158}, |
{0,4*3,8*3,12*3,16*3,22*3,30*3,40*3,52*3,66*3, 84*3,106*3,136*3,192*3}, |
{4,4,4,4,6,8,10,12,14,18,22,30,56} } , |
{ {0,4,8,12,16,20,24,30,36,42,50,60,72, 88,106,128,156,190,230,276,330,384,576}, |
{4,4,4,4,4,4,6,6,6, 8,10,12,16,18,22,28,34,40,46,54, 54,192}, |
{0,4*3,8*3,12*3,16*3,22*3,28*3,38*3,50*3,64*3, 80*3,100*3,126*3,192*3}, |
{4,4,4,4,6,6,10,12,14,16,20,26,66} } , |
{ {0,4,8,12,16,20,24,30,36,44,54,66,82,102,126,156,194,240,296,364,448,550,576} , |
{4,4,4,4,4,4,6,6,8,10,12,16,20,24,30,38,46,56,68,84,102, 26} , |
{0,4*3,8*3,12*3,16*3,22*3,30*3,42*3,58*3,78*3,104*3,138*3,180*3,192*3} , |
{4,4,4,4,6,8,12,16,20,26,34,42,12} } , |
/* MPEG 2.0 */ |
{ {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576}, |
{6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54 } , |
{0,4*3,8*3,12*3,18*3,24*3,32*3,42*3,56*3,74*3,100*3,132*3,174*3,192*3} , |
{4,4,4,6,6,8,10,14,18,26,32,42,18 } } , |
{ {0,6,12,18,24,30,36,44,54,66,80,96,114,136,162,194,232,278,330,394,464,540,576}, |
{6,6,6,6,6,6,8,10,12,14,16,18,22,26,32,38,46,52,64,70,76,36 } , |
{0,4*3,8*3,12*3,18*3,26*3,36*3,48*3,62*3,80*3,104*3,136*3,180*3,192*3} , |
{4,4,4,6,8,10,12,14,18,24,32,44,12 } } , |
{ {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576}, |
{6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54 }, |
{0,4*3,8*3,12*3,18*3,26*3,36*3,48*3,62*3,80*3,104*3,134*3,174*3,192*3}, |
{4,4,4,6,8,10,12,14,18,24,30,40,18 } } , |
/* MPEG 2.5, wrong! table (it's just a copy of MPEG 2.0/44.1kHz) */ |
{ {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576}, |
{6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54 } , |
{0,4*3,8*3,12*3,18*3,24*3,32*3,42*3,56*3,74*3,100*3,132*3,174*3,192*3} , |
{4,4,4,6,6,8,10,14,18,26,32,42,18 } } , |
}; |
static int mapbuf0[7][152]; |
static int mapbuf1[7][156]; |
static int mapbuf2[7][44]; |
static int *map[7][3]; |
static int *mapend[7][3]; |
static unsigned int n_slen2[512]; /* MPEG 2.0 slen for 'normal' mode */ |
static unsigned int i_slen2[256]; /* MPEG 2.0 slen for intensity stereo */ |
static real tan1_1[16],tan2_1[16],tan1_2[16],tan2_2[16]; |
static real pow1_1[2][16],pow2_1[2][16],pow1_2[2][16],pow2_2[2][16]; |
/* |
* init tables for layer-3 |
*/ |
void init_layer3(int down_samp) |
{ |
int i,j,k,l; |
for(i=-256;i<118+4;i++) |
gainpow2[i+256] = pow((double)2.0,-0.25 * (double) (i+210) ); |
for(i=0;i<8207;i++) |
ispow[i] = pow((double)i,(double)4.0/3.0); |
for (i=0;i<8;i++) |
{ |
static double Ci[8]={-0.6,-0.535,-0.33,-0.185,-0.095,-0.041,-0.0142,-0.0037}; |
double sq=sqrt(1.0+Ci[i]*Ci[i]); |
aa_cs[i] = 1.0/sq; |
aa_ca[i] = Ci[i]/sq; |
} |
for(i=0;i<18;i++) |
{ |
win[0][i] = win[1][i] = 0.5 * sin( M_PI / 72.0 * (double) (2*(i+0) +1) ) / cos ( M_PI * (double) (2*(i+0) +19) / 72.0 ); |
win[0][i+18] = win[3][i+18] = 0.5 * sin( M_PI / 72.0 * (double) (2*(i+18)+1) ) / cos ( M_PI * (double) (2*(i+18)+19) / 72.0 ); |
} |
for(i=0;i<6;i++) |
{ |
win[1][i+18] = 0.5 / cos ( M_PI * (double) (2*(i+18)+19) / 72.0 ); |
win[3][i+12] = 0.5 / cos ( M_PI * (double) (2*(i+12)+19) / 72.0 ); |
win[1][i+24] = 0.5 * sin( M_PI / 24.0 * (double) (2*i+13) ) / cos ( M_PI * (double) (2*(i+24)+19) / 72.0 ); |
win[1][i+30] = win[3][i] = 0.0; |
win[3][i+6 ] = 0.5 * sin( M_PI / 24.0 * (double) (2*i+1) ) / cos ( M_PI * (double) (2*(i+6 )+19) / 72.0 ); |
} |
for(i=0;i<9;i++) |
COS9[i] = cos( M_PI / 18.0 * (double) i); |
for(i=0;i<9;i++) |
tfcos36[i] = 0.5 / cos ( M_PI * (double) (i*2+1) / 36.0 ); |
for(i=0;i<3;i++) |
tfcos12[i] = 0.5 / cos ( M_PI * (double) (i*2+1) / 12.0 ); |
COS6_1 = cos( M_PI / 6.0 * (double) 1); |
COS6_2 = cos( M_PI / 6.0 * (double) 2); |
#ifdef NEW_DCT9 |
cos9[0] = cos(1.0*M_PI/9.0); |
cos9[1] = cos(5.0*M_PI/9.0); |
cos9[2] = cos(7.0*M_PI/9.0); |
cos18[0] = cos(1.0*M_PI/18.0); |
cos18[1] = cos(11.0*M_PI/18.0); |
cos18[2] = cos(13.0*M_PI/18.0); |
#endif |
for(i=0;i<12;i++) |
{ |
win[2][i] = 0.5 * sin( M_PI / 24.0 * (double) (2*i+1) ) / cos ( M_PI * (double) (2*i+7) / 24.0 ); |
for(j=0;j<6;j++) |
COS1[i][j] = cos( M_PI / 24.0 * (double) ((2*i+7)*(2*j+1)) ); |
} |
for(j=0;j<4;j++) { |
static int len[4] = { 36,36,12,36 }; |
for(i=0;i<len[j];i+=2) |
win1[j][i] = + win[j][i]; |
for(i=1;i<len[j];i+=2) |
win1[j][i] = - win[j][i]; |
} |
for(i=0;i<16;i++) |
{ |
double t = tan( (double) i * M_PI / 12.0 ); |
tan1_1[i] = t / (1.0+t); |
tan2_1[i] = 1.0 / (1.0 + t); |
tan1_2[i] = M_SQRT2 * t / (1.0+t); |
tan2_2[i] = M_SQRT2 / (1.0 + t); |
for(j=0;j<2;j++) { |
double base = pow(2.0,-0.25*(j+1.0)); |
double p1=1.0,p2=1.0; |
if(i > 0) { |
if( i & 1 ) |
p1 = pow(base,(i+1.0)*0.5); |
else |
p2 = pow(base,i*0.5); |
} |
pow1_1[j][i] = p1; |
pow2_1[j][i] = p2; |
pow1_2[j][i] = M_SQRT2 * p1; |
pow2_2[j][i] = M_SQRT2 * p2; |
} |
} |
for(j=0;j<7;j++) |
{ |
struct bandInfoStruct *bi = &bandInfo[j]; |
int *mp; |
int cb,lwin; |
int *bdf; |
mp = map[j][0] = mapbuf0[j]; |
bdf = bi->longDiff; |
for(i=0,cb = 0; cb < 8 ; cb++,i+=*bdf++) { |
*mp++ = (*bdf) >> 1; |
*mp++ = i; |
*mp++ = 3; |
*mp++ = cb; |
} |
bdf = bi->shortDiff+3; |
for(cb=3;cb<13;cb++) { |
int l = (*bdf++) >> 1; |
for(lwin=0;lwin<3;lwin++) { |
*mp++ = l; |
*mp++ = i + lwin; |
*mp++ = lwin; |
*mp++ = cb; |
} |
i += 6*l; |
} |
mapend[j][0] = mp; |
mp = map[j][1] = mapbuf1[j]; |
bdf = bi->shortDiff+0; |
for(i=0,cb=0;cb<13;cb++) { |
int l = (*bdf++) >> 1; |
for(lwin=0;lwin<3;lwin++) { |
*mp++ = l; |
*mp++ = i + lwin; |
*mp++ = lwin; |
*mp++ = cb; |
} |
i += 6*l; |
} |
mapend[j][1] = mp; |
mp = map[j][2] = mapbuf2[j]; |
bdf = bi->longDiff; |
for(cb = 0; cb < 22 ; cb++) { |
*mp++ = (*bdf++) >> 1; |
*mp++ = cb; |
} |
mapend[j][2] = mp; |
} |
for(j=0;j<7;j++) { |
for(i=0;i<23;i++) { |
longLimit[j][i] = (bandInfo[j].longIdx[i] - 1 + 8) / 18 + 1; |
if(longLimit[j][i] > (SBLIMIT >> down_samp) ) |
longLimit[j][i] = SBLIMIT >> down_samp; |
} |
for(i=0;i<14;i++) { |
shortLimit[j][i] = (bandInfo[j].shortIdx[i] - 1) / 18 + 1; |
if(shortLimit[j][i] > (SBLIMIT >> down_samp) ) |
shortLimit[j][i] = SBLIMIT >> down_samp; |
} |
} |
for(i=0;i<5;i++) { |
for(j=0;j<6;j++) { |
for(k=0;k<6;k++) { |
int n = k + j * 6 + i * 36; |
i_slen2[n] = i|(j<<3)|(k<<6)|(3<<12); |
} |
} |
} |
for(i=0;i<4;i++) { |
for(j=0;j<4;j++) { |
for(k=0;k<4;k++) { |
int n = k + j * 4 + i * 16; |
i_slen2[n+180] = i|(j<<3)|(k<<6)|(4<<12); |
} |
} |
} |
for(i=0;i<4;i++) { |
for(j=0;j<3;j++) { |
int n = j + i * 3; |
i_slen2[n+244] = i|(j<<3) | (5<<12); |
n_slen2[n+500] = i|(j<<3) | (2<<12) | (1<<15); |
} |
} |
for(i=0;i<5;i++) { |
for(j=0;j<5;j++) { |
for(k=0;k<4;k++) { |
for(l=0;l<4;l++) { |
int n = l + k * 4 + j * 16 + i * 80; |
n_slen2[n] = i|(j<<3)|(k<<6)|(l<<9)|(0<<12); |
} |
} |
} |
} |
for(i=0;i<5;i++) { |
for(j=0;j<5;j++) { |
for(k=0;k<4;k++) { |
int n = k + j * 4 + i * 20; |
n_slen2[n+400] = i|(j<<3)|(k<<6)|(1<<12); |
} |
} |
} |
} |
/* |
* read additional side information |
*/ |
static void III_get_side_info_1(struct III_sideinfo *si,int stereo, |
int ms_stereo,long sfreq,int single) |
{ |
int ch, gr; |
int powdiff = (single == 3) ? 4 : 0; |
si->main_data_begin = getbits(9); |
if (stereo == 1) |
si->private_bits = getbits_fast(5); |
else |
si->private_bits = getbits_fast(3); |
for (ch=0; ch<stereo; ch++) { |
si->ch[ch].gr[0].scfsi = -1; |
si->ch[ch].gr[1].scfsi = getbits_fast(4); |
} |
for (gr=0; gr<2; gr++) |
{ |
for (ch=0; ch<stereo; ch++) |
{ |
register struct gr_info_s *gr_info = &(si->ch[ch].gr[gr]); |
gr_info->part2_3_length = getbits(12); |
gr_info->big_values = getbits_fast(9); |
gr_info->pow2gain = gainpow2+256 - getbits_fast(8) + powdiff; |
if(ms_stereo) |
gr_info->pow2gain += 2; |
gr_info->scalefac_compress = getbits_fast(4); |
/* window-switching flag == 1 for block_Type != 0 .. and block-type == 0 -> win-sw-flag = 0 */ |
if(get1bit()) |
{ |
int i; |
gr_info->block_type = getbits_fast(2); |
gr_info->mixed_block_flag = get1bit(); |
gr_info->table_select[0] = getbits_fast(5); |
gr_info->table_select[1] = getbits_fast(5); |
/* |
* table_select[2] not needed, because there is no region2, |
* but to satisfy some verifications tools we set it either. |
*/ |
gr_info->table_select[2] = 0; |
for(i=0;i<3;i++) |
gr_info->full_gain[i] = gr_info->pow2gain + (getbits_fast(3)<<3); |
if(gr_info->block_type == 0) { |
fprintf(stderr,"Blocktype == 0 and window-switching == 1 not allowed.\n"); |
exit(1); |
} |
/* region_count/start parameters are implicit in this case. */ |
gr_info->region1start = 36>>1; |
gr_info->region2start = 576>>1; |
} |
else |
{ |
int i,r0c,r1c; |
for (i=0; i<3; i++) |
gr_info->table_select[i] = getbits_fast(5); |
r0c = getbits_fast(4); |
r1c = getbits_fast(3); |
gr_info->region1start = bandInfo[sfreq].longIdx[r0c+1] >> 1 ; |
gr_info->region2start = bandInfo[sfreq].longIdx[r0c+1+r1c+1] >> 1; |
gr_info->block_type = 0; |
gr_info->mixed_block_flag = 0; |
} |
gr_info->preflag = get1bit(); |
gr_info->scalefac_scale = get1bit(); |
gr_info->count1table_select = get1bit(); |
} |
} |
} |
/* |
* Side Info for MPEG 2.0 / LSF |
*/ |
static void III_get_side_info_2(struct III_sideinfo *si,int stereo, |
int ms_stereo,long sfreq,int single) |
{ |
int ch; |
int powdiff = (single == 3) ? 4 : 0; |
si->main_data_begin = getbits(8); |
if (stereo == 1) |
si->private_bits = get1bit(); |
else |
si->private_bits = getbits_fast(2); |
for (ch=0; ch<stereo; ch++) |
{ |
register struct gr_info_s *gr_info = &(si->ch[ch].gr[0]); |
gr_info->part2_3_length = getbits(12); |
gr_info->big_values = getbits_fast(9); |
gr_info->pow2gain = gainpow2+256 - getbits_fast(8) + powdiff; |
if(ms_stereo) |
gr_info->pow2gain += 2; |
gr_info->scalefac_compress = getbits(9); |
/* window-switching flag == 1 for block_Type != 0 .. and block-type == 0 -> win-sw-flag = 0 */ |
if(get1bit()) |
{ |
int i; |
gr_info->block_type = getbits_fast(2); |
gr_info->mixed_block_flag = get1bit(); |
gr_info->table_select[0] = getbits_fast(5); |
gr_info->table_select[1] = getbits_fast(5); |
/* |
* table_select[2] not needed, because there is no region2, |
* but to satisfy some verifications tools we set it either. |
*/ |
gr_info->table_select[2] = 0; |
for(i=0;i<3;i++) |
gr_info->full_gain[i] = gr_info->pow2gain + (getbits_fast(3)<<3); |
if(gr_info->block_type == 0) { |
fprintf(stderr,"Blocktype == 0 and window-switching == 1 not allowed.\n"); |
exit(1); |
} |
/* region_count/start parameters are implicit in this case. */ |
/* check this again! */ |
if(gr_info->block_type == 2) |
gr_info->region1start = 36>>1; |
else { |
gr_info->region1start = 54>>1; |
} |
gr_info->region2start = 576>>1; |
} |
else |
{ |
int i,r0c,r1c; |
for (i=0; i<3; i++) |
gr_info->table_select[i] = getbits_fast(5); |
r0c = getbits_fast(4); |
r1c = getbits_fast(3); |
gr_info->region1start = bandInfo[sfreq].longIdx[r0c+1] >> 1 ; |
gr_info->region2start = bandInfo[sfreq].longIdx[r0c+1+r1c+1] >> 1; |
gr_info->block_type = 0; |
gr_info->mixed_block_flag = 0; |
} |
gr_info->scalefac_scale = get1bit(); |
gr_info->count1table_select = get1bit(); |
} |
} |
/* |
* read scalefactors |
*/ |
static int III_get_scale_factors_1(int *scf,struct gr_info_s *gr_info) |
{ |
static unsigned char slen[2][16] = { |
{0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4}, |
{0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3} |
}; |
int numbits; |
int num0 = slen[0][gr_info->scalefac_compress]; |
int num1 = slen[1][gr_info->scalefac_compress]; |
if (gr_info->block_type == 2) |
{ |
int i=18; |
numbits = (num0 + num1) * 18; |
if (gr_info->mixed_block_flag) { |
for (i=8;i;i--) |
*scf++ = getbits_fast(num0); |
i = 9; |
numbits -= num0; /* num0 * 17 + num1 * 18 */ |
} |
for (;i;i--) |
*scf++ = getbits_fast(num0); |
for (i = 18; i; i--) |
*scf++ = getbits_fast(num1); |
*scf++ = 0; *scf++ = 0; *scf++ = 0; /* short[13][0..2] = 0 */ |
} |
else |
{ |
int i; |
int scfsi = gr_info->scfsi; |
if(scfsi < 0) { /* scfsi < 0 => granule == 0 */ |
for(i=11;i;i--) |
*scf++ = getbits_fast(num0); |
for(i=10;i;i--) |
*scf++ = getbits_fast(num1); |
numbits = (num0 + num1) * 10 + num0; |
} |
else { |
numbits = 0; |
if(!(scfsi & 0x8)) { |
for (i=6;i;i--) |
*scf++ = getbits_fast(num0); |
numbits += num0 * 6; |
} |
else { |
*scf++ = 0; *scf++ = 0; *scf++ = 0; /* set to ZERO necessary? */ |
*scf++ = 0; *scf++ = 0; *scf++ = 0; |
} |
if(!(scfsi & 0x4)) { |
for (i=5;i;i--) |
*scf++ = getbits_fast(num0); |
numbits += num0 * 5; |
} |
else { |
*scf++ = 0; *scf++ = 0; *scf++ = 0; /* set to ZERO necessary? */ |
*scf++ = 0; *scf++ = 0; |
} |
if(!(scfsi & 0x2)) { |
for(i=5;i;i--) |
*scf++ = getbits_fast(num1); |
numbits += num1 * 5; |
} |
else { |
*scf++ = 0; *scf++ = 0; *scf++ = 0; /* set to ZERO necessary? */ |
*scf++ = 0; *scf++ = 0; |
} |
if(!(scfsi & 0x1)) { |
for (i=5;i;i--) |
*scf++ = getbits_fast(num1); |
numbits += num1 * 5; |
} |
else { |
*scf++ = 0; *scf++ = 0; *scf++ = 0; /* set to ZERO necessary? */ |
*scf++ = 0; *scf++ = 0; |
} |
} |
*scf++ = 0; /* no l[21] in original sources */ |
} |
return numbits; |
} |
static int III_get_scale_factors_2(int *scf,struct gr_info_s *gr_info,int i_stereo) |
{ |
unsigned char *pnt; |
int i,j; |
unsigned int slen; |
int n = 0; |
int numbits = 0; |
static unsigned char stab[3][6][4] = { |
{ { 6, 5, 5,5 } , { 6, 5, 7,3 } , { 11,10,0,0} , |
{ 7, 7, 7,0 } , { 6, 6, 6,3 } , { 8, 8,5,0} } , |
{ { 9, 9, 9,9 } , { 9, 9,12,6 } , { 18,18,0,0} , |
{12,12,12,0 } , {12, 9, 9,6 } , { 15,12,9,0} } , |
{ { 6, 9, 9,9 } , { 6, 9,12,6 } , { 15,18,0,0} , |
{ 6,15,12,0 } , { 6,12, 9,6 } , { 6,18,9,0} } }; |
if(i_stereo) /* i_stereo AND second channel -> do_layer3() checks this */ |
slen = i_slen2[gr_info->scalefac_compress>>1]; |
else |
slen = n_slen2[gr_info->scalefac_compress]; |
gr_info->preflag = (slen>>15) & 0x1; |
n = 0; |
if( gr_info->block_type == 2 ) { |
n++; |
if(gr_info->mixed_block_flag) |
n++; |
} |
pnt = stab[n][(slen>>12)&0x7]; |
for(i=0;i<4;i++) { |
int num = slen & 0x7; |
slen >>= 3; |
if(num) { |
for(j=0;j<pnt[i];j++) |
*scf++ = getbits(num); |
numbits += pnt[i] * num; |
} |
else { |
for(j=0;j<pnt[i];j++) |
*scf++ = 0; |
} |
} |
n = (n << 1) + 1; |
for(i=0;i<n;i++) |
*scf++ = 0; |
return numbits; |
} |
static int pretab1[22] = {0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2,2,3,3,3,2,0}; |
static int pretab2[22] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; |
/* |
* don't forget to apply the same changes to III_dequantize_sample_ms() !!! |
*/ |
static int III_dequantize_sample(real xr[SBLIMIT][SSLIMIT],int *scf, |
struct gr_info_s *gr_info,int sfreq,int part2bits) |
{ |
int shift = 1 + gr_info->scalefac_scale; |
real *xrpnt = (real *) xr; |
int l[3],l3; |
int part2remain = gr_info->part2_3_length - part2bits; |
int *me; |
{ |
int bv = gr_info->big_values; |
int region1 = gr_info->region1start; |
int region2 = gr_info->region2start; |
l3 = ((576>>1)-bv)>>1; |
/* |
* we may lose the 'odd' bit here !! |
* check this later again |
*/ |
if(bv <= region1) { |
l[0] = bv; l[1] = 0; l[2] = 0; |
} |
else { |
l[0] = region1; |
if(bv <= region2) { |
l[1] = bv - l[0]; l[2] = 0; |
} |
else { |
l[1] = region2 - l[0]; l[2] = bv - region2; |
} |
} |
} |
if(gr_info->block_type == 2) { |
int i,max[4]; |
int step=0,lwin=0,cb=0; |
register real v = 0.0; |
register int *m,mc; |
if(gr_info->mixed_block_flag) { |
max[3] = -1; |
max[0] = max[1] = max[2] = 2; |
m = map[sfreq][0]; |
me = mapend[sfreq][0]; |
} |
else { |
max[0] = max[1] = max[2] = max[3] = -1; |
/* max[3] not really needed in this case */ |
m = map[sfreq][1]; |
me = mapend[sfreq][1]; |
} |
mc = 0; |
for(i=0;i<2;i++) { |
int lp = l[i]; |
struct newhuff *h = ht+gr_info->table_select[i]; |
for(;lp;lp--,mc--) { |
register int x,y; |
if( (!mc) ) { |
mc = *m++; |
xrpnt = ((real *) xr) + (*m++); |
lwin = *m++; |
cb = *m++; |
if(lwin == 3) { |
v = gr_info->pow2gain[(*scf++) << shift]; |
step = 1; |
} |
else { |
v = gr_info->full_gain[lwin][(*scf++) << shift]; |
step = 3; |
} |
} |
{ |
register short *val = h->table; |
while((y=*val++)<0) { |
if (get1bit()) |
val -= y; |
part2remain--; |
} |
x = y >> 4; |
y &= 0xf; |
} |
if(x == 15) { |
max[lwin] = cb; |
part2remain -= h->linbits+1; |
x += getbits(h->linbits); |
if(get1bit()) |
*xrpnt = -ispow[x] * v; |
else |
*xrpnt = ispow[x] * v; |
} |
else if(x) { |
max[lwin] = cb; |
if(get1bit()) |
*xrpnt = -ispow[x] * v; |
else |
*xrpnt = ispow[x] * v; |
part2remain--; |
} |
else |
*xrpnt = 0.0; |
xrpnt += step; |
if(y == 15) { |
max[lwin] = cb; |
part2remain -= h->linbits+1; |
y += getbits(h->linbits); |
if(get1bit()) |
*xrpnt = -ispow[y] * v; |
else |
*xrpnt = ispow[y] * v; |
} |
else if(y) { |
max[lwin] = cb; |
if(get1bit()) |
*xrpnt = -ispow[y] * v; |
else |
*xrpnt = ispow[y] * v; |
part2remain--; |
} |
else |
*xrpnt = 0.0; |
xrpnt += step; |
} |
} |
for(;l3 && (part2remain > 0);l3--) { |
struct newhuff *h = htc+gr_info->count1table_select; |
register short *val = h->table,a; |
while((a=*val++)<0) { |
part2remain--; |
if(part2remain < 0) { |
part2remain++; |
a = 0; |
break; |
} |
if (get1bit()) |
val -= a; |
} |
for(i=0;i<4;i++) { |
if(!(i & 1)) { |
if(!mc) { |
mc = *m++; |
xrpnt = ((real *) xr) + (*m++); |
lwin = *m++; |
cb = *m++; |
if(lwin == 3) { |
v = gr_info->pow2gain[(*scf++) << shift]; |
step = 1; |
} |
else { |
v = gr_info->full_gain[lwin][(*scf++) << shift]; |
step = 3; |
} |
} |
mc--; |
} |
if( (a & (0x8>>i)) ) { |
max[lwin] = cb; |
part2remain--; |
if(part2remain < 0) { |
part2remain++; |
break; |
} |
if(get1bit()) |
*xrpnt = -v; |
else |
*xrpnt = v; |
} |
else |
*xrpnt = 0.0; |
xrpnt += step; |
} |
} |
while( m < me ) { |
if(!mc) { |
mc = *m++; |
xrpnt = ((real *) xr) + *m++; |
if( (*m++) == 3) |
step = 1; |
else |
step = 3; |
m++; /* cb */ |
} |
mc--; |
*xrpnt = 0.0; |
xrpnt += step; |
*xrpnt = 0.0; |
xrpnt += step; |
} |
gr_info->maxband[0] = max[0]+1; |
gr_info->maxband[1] = max[1]+1; |
gr_info->maxband[2] = max[2]+1; |
gr_info->maxbandl = max[3]+1; |
{ |
int rmax = max[0] > max[1] ? max[0] : max[1]; |
rmax = (rmax > max[2] ? rmax : max[2]) + 1; |
gr_info->maxb = rmax ? shortLimit[sfreq][rmax] : longLimit[sfreq][max[3]+1]; |
} |
} |
else { |
int *pretab = gr_info->preflag ? pretab1 : pretab2; |
int i,max = -1; |
int cb = 0; |
register int *m = map[sfreq][2]; |
register real v = 0.0; |
register int mc = 0; |
me = mapend[sfreq][2]; |
for(i=0;i<3;i++) { |
int lp = l[i]; |
struct newhuff *h = ht+gr_info->table_select[i]; |
for(;lp;lp--,mc--) { |
int x,y; |
if(!mc) { |
mc = *m++; |
v = gr_info->pow2gain[((*scf++) + (*pretab++)) << shift]; |
cb = *m++; |
} |
{ |
register short *val = h->table; |
while((y=*val++)<0) { |
if (get1bit()) |
val -= y; |
part2remain--; |
} |
x = y >> 4; |
y &= 0xf; |
} |
if (x == 15) { |
max = cb; |
part2remain -= h->linbits+1; |
x += getbits(h->linbits); |
if(get1bit()) |
*xrpnt++ = -ispow[x] * v; |
else |
*xrpnt++ = ispow[x] * v; |
} |
else if(x) { |
max = cb; |
if(get1bit()) |
*xrpnt++ = -ispow[x] * v; |
else |
*xrpnt++ = ispow[x] * v; |
part2remain--; |
} |
else |
*xrpnt++ = 0.0; |
if (y == 15) { |
max = cb; |
part2remain -= h->linbits+1; |
y += getbits(h->linbits); |
if(get1bit()) |
*xrpnt++ = -ispow[y] * v; |
else |
*xrpnt++ = ispow[y] * v; |
} |
else if(y) { |
max = cb; |
if(get1bit()) |
*xrpnt++ = -ispow[y] * v; |
else |
*xrpnt++ = ispow[y] * v; |
part2remain--; |
} |
else |
*xrpnt++ = 0.0; |
} |
} |
for(;l3 && (part2remain > 0);l3--) { |
struct newhuff *h = htc+gr_info->count1table_select; |
register short *val = h->table,a; |
while((a=*val++)<0) { |
part2remain--; |
if(part2remain < 0) { |
part2remain++; |
a = 0; |
break; |
} |
if (get1bit()) |
val -= a; |
} |
for(i=0;i<4;i++) { |
if(!(i & 1)) { |
if(!mc) { |
mc = *m++; |
cb = *m++; |
v = gr_info->pow2gain[((*scf++) + (*pretab++)) << shift]; |
} |
mc--; |
} |
if ( (a & (0x8>>i)) ) { |
max = cb; |
part2remain--; |
if(part2remain < 0) { |
part2remain++; |
break; |
} |
if(get1bit()) |
*xrpnt++ = -v; |
else |
*xrpnt++ = v; |
} |
else |
*xrpnt++ = 0.0; |
} |
} |
for(i=(&xr[SBLIMIT][SSLIMIT]-xrpnt)>>1;i;i--) { |
*xrpnt++ = 0.0; |
*xrpnt++ = 0.0; |
} |
gr_info->maxbandl = max+1; |
gr_info->maxb = longLimit[sfreq][gr_info->maxbandl]; |
} |
while( part2remain > 16 ) { |
getbits(16); /* Dismiss stuffing Bits */ |
part2remain -= 16; |
} |
if(part2remain > 0) |
getbits(part2remain); |
else if(part2remain < 0) { |
fprintf(stderr,"mpg123: Can't rewind stream by %d bits!\n",-part2remain); |
return 1; /* -> error */ |
} |
return 0; |
} |
static int III_dequantize_sample_ms(real xr[2][SBLIMIT][SSLIMIT],int *scf, |
struct gr_info_s *gr_info,int sfreq,int part2bits) |
{ |
int shift = 1 + gr_info->scalefac_scale; |
real *xrpnt = (real *) xr[1]; |
real *xr0pnt = (real *) xr[0]; |
int l[3],l3; |
int part2remain = gr_info->part2_3_length - part2bits; |
int *me; |
{ |
int bv = gr_info->big_values; |
int region1 = gr_info->region1start; |
int region2 = gr_info->region2start; |
l3 = ((576>>1)-bv)>>1; |
/* |
* we may lose the 'odd' bit here !! |
* check this later gain |
*/ |
if(bv <= region1) { |
l[0] = bv; l[1] = 0; l[2] = 0; |
} |
else { |
l[0] = region1; |
if(bv <= region2) { |
l[1] = bv - l[0]; l[2] = 0; |
} |
else { |
l[1] = region2 - l[0]; l[2] = bv - region2; |
} |
} |
} |
if(gr_info->block_type == 2) { |
int i,max[4]; |
int step=0,lwin=0,cb=0; |
register real v = 0.0; |
register int *m,mc = 0; |
if(gr_info->mixed_block_flag) { |
max[3] = -1; |
max[0] = max[1] = max[2] = 2; |
m = map[sfreq][0]; |
me = mapend[sfreq][0]; |
} |
else { |
max[0] = max[1] = max[2] = max[3] = -1; |
/* max[3] not really needed in this case */ |
m = map[sfreq][1]; |
me = mapend[sfreq][1]; |
} |
for(i=0;i<2;i++) { |
int lp = l[i]; |
struct newhuff *h = ht+gr_info->table_select[i]; |
for(;lp;lp--,mc--) { |
int x,y; |
if(!mc) { |
mc = *m++; |
xrpnt = ((real *) xr[1]) + *m; |
xr0pnt = ((real *) xr[0]) + *m++; |
lwin = *m++; |
cb = *m++; |
if(lwin == 3) { |
v = gr_info->pow2gain[(*scf++) << shift]; |
step = 1; |
} |
else { |
v = gr_info->full_gain[lwin][(*scf++) << shift]; |
step = 3; |
} |
} |
{ |
register short *val = h->table; |
while((y=*val++)<0) { |
if (get1bit()) |
val -= y; |
part2remain--; |
} |
x = y >> 4; |
y &= 0xf; |
} |
if(x == 15) { |
max[lwin] = cb; |
part2remain -= h->linbits+1; |
x += getbits(h->linbits); |
if(get1bit()) { |
real a = ispow[x] * v; |
*xrpnt = *xr0pnt + a; |
*xr0pnt -= a; |
} |
else { |
real a = ispow[x] * v; |
*xrpnt = *xr0pnt - a; |
*xr0pnt += a; |
} |
} |
else if(x) { |
max[lwin] = cb; |
if(get1bit()) { |
real a = ispow[x] * v; |
*xrpnt = *xr0pnt + a; |
*xr0pnt -= a; |
} |
else { |
real a = ispow[x] * v; |
*xrpnt = *xr0pnt - a; |
*xr0pnt += a; |
} |
part2remain--; |
} |
else |
*xrpnt = *xr0pnt; |
xrpnt += step; |
xr0pnt += step; |
if(y == 15) { |
max[lwin] = cb; |
part2remain -= h->linbits+1; |
y += getbits(h->linbits); |
if(get1bit()) { |
real a = ispow[y] * v; |
*xrpnt = *xr0pnt + a; |
*xr0pnt -= a; |
} |
else { |
real a = ispow[y] * v; |
*xrpnt = *xr0pnt - a; |
*xr0pnt += a; |
} |
} |
else if(y) { |
max[lwin] = cb; |
if(get1bit()) { |
real a = ispow[y] * v; |
*xrpnt = *xr0pnt + a; |
*xr0pnt -= a; |
} |
else { |
real a = ispow[y] * v; |
*xrpnt = *xr0pnt - a; |
*xr0pnt += a; |
} |
part2remain--; |
} |
else |
*xrpnt = *xr0pnt; |
xrpnt += step; |
xr0pnt += step; |
} |
} |
for(;l3 && (part2remain > 0);l3--) { |
struct newhuff *h = htc+gr_info->count1table_select; |
register short *val = h->table,a; |
while((a=*val++)<0) { |
part2remain--; |
if(part2remain < 0) { |
part2remain++; |
a = 0; |
break; |
} |
if (get1bit()) |
val -= a; |
} |
for(i=0;i<4;i++) { |
if(!(i & 1)) { |
if(!mc) { |
mc = *m++; |
xrpnt = ((real *) xr[1]) + *m; |
xr0pnt = ((real *) xr[0]) + *m++; |
lwin = *m++; |
cb = *m++; |
if(lwin == 3) { |
v = gr_info->pow2gain[(*scf++) << shift]; |
step = 1; |
} |
else { |
v = gr_info->full_gain[lwin][(*scf++) << shift]; |
step = 3; |
} |
} |
mc--; |
} |
if( (a & (0x8>>i)) ) { |
max[lwin] = cb; |
part2remain--; |
if(part2remain < 0) { |
part2remain++; |
break; |
} |
if(get1bit()) { |
*xrpnt = *xr0pnt + v; |
*xr0pnt -= v; |
} |
else { |
*xrpnt = *xr0pnt - v; |
*xr0pnt += v; |
} |
} |
else |
*xrpnt = *xr0pnt; |
xrpnt += step; |
xr0pnt += step; |
} |
} |
while( m < me ) { |
if(!mc) { |
mc = *m++; |
xrpnt = ((real *) xr) + *m; |
xr0pnt = ((real *) xr) + *m++; |
if(*m++ == 3) |
step = 1; |
else |
step = 3; |
m++; /* cb */ |
} |
mc--; |
*xrpnt = *xr0pnt; |
xrpnt += step; |
xr0pnt += step; |
*xrpnt = *xr0pnt; |
xrpnt += step; |
xr0pnt += step; |
} |
gr_info->maxband[0] = max[0]+1; |
gr_info->maxband[1] = max[1]+1; |
gr_info->maxband[2] = max[2]+1; |
gr_info->maxbandl = max[3]+1; |
{ |
int rmax = max[0] > max[1] ? max[0] : max[1]; |
rmax = (rmax > max[2] ? rmax : max[2]) + 1; |
gr_info->maxb = rmax ? shortLimit[sfreq][rmax] : longLimit[sfreq][max[3]+1]; |
} |
} |
else { |
int *pretab = gr_info->preflag ? pretab1 : pretab2; |
int i,max = -1; |
int cb = 0; |
register int mc=0,*m = map[sfreq][2]; |
register real v = 0.0; |
me = mapend[sfreq][2]; |
for(i=0;i<3;i++) { |
int lp = l[i]; |
struct newhuff *h = ht+gr_info->table_select[i]; |
for(;lp;lp--,mc--) { |
int x,y; |
if(!mc) { |
mc = *m++; |
cb = *m++; |
v = gr_info->pow2gain[((*scf++) + (*pretab++)) << shift]; |
} |
{ |
register short *val = h->table; |
while((y=*val++)<0) { |
if (get1bit()) |
val -= y; |
part2remain--; |
} |
x = y >> 4; |
y &= 0xf; |
} |
if (x == 15) { |
max = cb; |
part2remain -= h->linbits+1; |
x += getbits(h->linbits); |
if(get1bit()) { |
real a = ispow[x] * v; |
*xrpnt++ = *xr0pnt + a; |
*xr0pnt++ -= a; |
} |
else { |
real a = ispow[x] * v; |
*xrpnt++ = *xr0pnt - a; |
*xr0pnt++ += a; |
} |
} |
else if(x) { |
max = cb; |
if(get1bit()) { |
real a = ispow[x] * v; |
*xrpnt++ = *xr0pnt + a; |
*xr0pnt++ -= a; |
} |
else { |
real a = ispow[x] * v; |
*xrpnt++ = *xr0pnt - a; |
*xr0pnt++ += a; |
} |
part2remain--; |
} |
else |
*xrpnt++ = *xr0pnt++; |
if (y == 15) { |
max = cb; |
part2remain -= h->linbits+1; |
y += getbits(h->linbits); |
if(get1bit()) { |
real a = ispow[y] * v; |
*xrpnt++ = *xr0pnt + a; |
*xr0pnt++ -= a; |
} |
else { |
real a = ispow[y] * v; |
*xrpnt++ = *xr0pnt - a; |
*xr0pnt++ += a; |
} |
} |
else if(y) { |
max = cb; |
if(get1bit()) { |
real a = ispow[y] * v; |
*xrpnt++ = *xr0pnt + a; |
*xr0pnt++ -= a; |
} |
else { |
real a = ispow[y] * v; |
*xrpnt++ = *xr0pnt - a; |
*xr0pnt++ += a; |
} |
part2remain--; |
} |
else |
*xrpnt++ = *xr0pnt++; |
} |
} |
for(;l3 && (part2remain > 0);l3--) { |
struct newhuff *h = htc+gr_info->count1table_select; |
register short *val = h->table,a; |
while((a=*val++)<0) { |
part2remain--; |
if(part2remain < 0) { |
part2remain++; |
a = 0; |
break; |
} |
if (get1bit()) |
val -= a; |
} |
for(i=0;i<4;i++) { |
if(!(i & 1)) { |
if(!mc) { |
mc = *m++; |
cb = *m++; |
v = gr_info->pow2gain[((*scf++) + (*pretab++)) << shift]; |
} |
mc--; |
} |
if ( (a & (0x8>>i)) ) { |
max = cb; |
part2remain--; |
if(part2remain <= 0) { |
part2remain++; |
break; |
} |
if(get1bit()) { |
*xrpnt++ = *xr0pnt + v; |
*xr0pnt++ -= v; |
} |
else { |
*xrpnt++ = *xr0pnt - v; |
*xr0pnt++ += v; |
} |
} |
else |
*xrpnt++ = *xr0pnt++; |
} |
} |
for(i=(&xr[1][SBLIMIT][SSLIMIT]-xrpnt)>>1;i;i--) { |
*xrpnt++ = *xr0pnt++; |
*xrpnt++ = *xr0pnt++; |
} |
gr_info->maxbandl = max+1; |
gr_info->maxb = longLimit[sfreq][gr_info->maxbandl]; |
} |
while ( part2remain > 16 ) { |
getbits(16); /* Dismiss stuffing Bits */ |
part2remain -= 16; |
} |
if(part2remain > 0 ) |
getbits(part2remain); |
else if(part2remain < 0) { |
fprintf(stderr,"mpg123_ms: Can't rewind stream by %d bits!\n",-part2remain); |
return 1; /* -> error */ |
} |
return 0; |
} |
/* |
* III_stereo: calculate real channel values for Joint-I-Stereo-mode |
*/ |
static void III_i_stereo(real xr_buf[2][SBLIMIT][SSLIMIT],int *scalefac, |
struct gr_info_s *gr_info,int sfreq,int ms_stereo,int lsf) |
{ |
real (*xr)[SBLIMIT*SSLIMIT] = (real (*)[SBLIMIT*SSLIMIT] ) xr_buf; |
struct bandInfoStruct *bi = &bandInfo[sfreq]; |
real *tab1,*tab2; |
if(lsf) { |
int p = gr_info->scalefac_compress & 0x1; |
if(ms_stereo) { |
tab1 = pow1_2[p]; tab2 = pow2_2[p]; |
} |
else { |
tab1 = pow1_1[p]; tab2 = pow2_1[p]; |
} |
} |
else { |
if(ms_stereo) { |
tab1 = tan1_2; tab2 = tan2_2; |
} |
else { |
tab1 = tan1_1; tab2 = tan2_1; |
} |
} |
if (gr_info->block_type == 2) |
{ |
int lwin,do_l = 0; |
if( gr_info->mixed_block_flag ) |
do_l = 1; |
for (lwin=0;lwin<3;lwin++) /* process each window */ |
{ |
/* get first band with zero values */ |
int is_p,sb,idx,sfb = gr_info->maxband[lwin]; /* sfb is minimal 3 for mixed mode */ |
if(sfb > 3) |
do_l = 0; |
for(;sfb<12;sfb++) |
{ |
is_p = scalefac[sfb*3+lwin-gr_info->mixed_block_flag]; /* scale: 0-15 */ |
if(is_p != 7) { |
real t1,t2; |
sb = bi->shortDiff[sfb]; |
idx = bi->shortIdx[sfb] + lwin; |
t1 = tab1[is_p]; t2 = tab2[is_p]; |
for (; sb > 0; sb--,idx+=3) |
{ |
real v = xr[0][idx]; |
xr[0][idx] = v * t1; |
xr[1][idx] = v * t2; |
} |
} |
} |
#if 1 |
/* in the original: copy 10 to 11 , here: copy 11 to 12 |
maybe still wrong??? (copy 12 to 13?) */ |
is_p = scalefac[11*3+lwin-gr_info->mixed_block_flag]; /* scale: 0-15 */ |
sb = bi->shortDiff[12]; |
idx = bi->shortIdx[12] + lwin; |
#else |
is_p = scalefac[10*3+lwin-gr_info->mixed_block_flag]; /* scale: 0-15 */ |
sb = bi->shortDiff[11]; |
idx = bi->shortIdx[11] + lwin; |
#endif |
if(is_p != 7) |
{ |
real t1,t2; |
t1 = tab1[is_p]; t2 = tab2[is_p]; |
for ( ; sb > 0; sb--,idx+=3 ) |
{ |
real v = xr[0][idx]; |
xr[0][idx] = v * t1; |
xr[1][idx] = v * t2; |
} |
} |
} /* end for(lwin; .. ; . ) */ |
if (do_l) |
{ |
/* also check l-part, if ALL bands in the three windows are 'empty' |
* and mode = mixed_mode |
*/ |
int sfb = gr_info->maxbandl; |
int idx = bi->longIdx[sfb]; |
for ( ; sfb<8; sfb++ ) |
{ |
int sb = bi->longDiff[sfb]; |
int is_p = scalefac[sfb]; /* scale: 0-15 */ |
if(is_p != 7) { |
real t1,t2; |
t1 = tab1[is_p]; t2 = tab2[is_p]; |
for ( ; sb > 0; sb--,idx++) |
{ |
real v = xr[0][idx]; |
xr[0][idx] = v * t1; |
xr[1][idx] = v * t2; |
} |
} |
else |
idx += sb; |
} |
} |
} |
else /* ((gr_info->block_type != 2)) */ |
{ |
int sfb = gr_info->maxbandl; |
int is_p,idx = bi->longIdx[sfb]; |
for ( ; sfb<21; sfb++) |
{ |
int sb = bi->longDiff[sfb]; |
is_p = scalefac[sfb]; /* scale: 0-15 */ |
if(is_p != 7) { |
real t1,t2; |
t1 = tab1[is_p]; t2 = tab2[is_p]; |
for ( ; sb > 0; sb--,idx++) |
{ |
real v = xr[0][idx]; |
xr[0][idx] = v * t1; |
xr[1][idx] = v * t2; |
} |
} |
else |
idx += sb; |
} |
is_p = scalefac[20]; /* copy l-band 20 to l-band 21 */ |
if(is_p != 7) |
{ |
int sb; |
real t1 = tab1[is_p],t2 = tab2[is_p]; |
for ( sb = bi->longDiff[21]; sb > 0; sb--,idx++ ) |
{ |
real v = xr[0][idx]; |
xr[0][idx] = v * t1; |
xr[1][idx] = v * t2; |
} |
} |
} /* ... */ |
} |
static void III_antialias(real xr[SBLIMIT][SSLIMIT],struct gr_info_s *gr_info) |
{ |
int sblim; |
if(gr_info->block_type == 2) |
{ |
if(!gr_info->mixed_block_flag) |
return; |
sblim = 1; |
} |
else { |
sblim = gr_info->maxb-1; |
} |
/* 31 alias-reduction operations between each pair of sub-bands */ |
/* with 8 butterflies between each pair */ |
{ |
int sb; |
real *xr1=(real *) xr[1]; |
for(sb=sblim;sb;sb--,xr1+=10) |
{ |
int ss; |
real *cs=aa_cs,*ca=aa_ca; |
real *xr2 = xr1; |
for(ss=7;ss>=0;ss--) |
{ /* upper and lower butterfly inputs */ |
register real bu = *--xr2,bd = *xr1; |
*xr2 = (bu * (*cs) ) - (bd * (*ca) ); |
*xr1++ = (bd * (*cs++) ) + (bu * (*ca++) ); |
} |
} |
} |
} |
/* |
// This is an optimized DCT from Jeff Tsay's maplay 1.2+ package. |
// Saved one multiplication by doing the 'twiddle factor' stuff |
// together with the window mul. (MH) |
// |
// This uses Byeong Gi Lee's Fast Cosine Transform algorithm, but the |
// 9 point IDCT needs to be reduced further. Unfortunately, I don't |
// know how to do that, because 9 is not an even number. - Jeff. |
// |
////////////////////////////////////////////////////////////////// |
// |
// 9 Point Inverse Discrete Cosine Transform |
// |
// This piece of code is Copyright 1997 Mikko Tommila and is freely usable |
// by anybody. The algorithm itself is of course in the public domain. |
// |
// Again derived heuristically from the 9-point WFTA. |
// |
// The algorithm is optimized (?) for speed, not for small rounding errors or |
// good readability. |
// |
// 36 additions, 11 multiplications |
// |
// Again this is very likely sub-optimal. |
// |
// The code is optimized to use a minimum number of temporary variables, |
// so it should compile quite well even on 8-register Intel x86 processors. |
// This makes the code quite obfuscated and very difficult to understand. |
// |
// References: |
// [1] S. Winograd: "On Computing the Discrete Fourier Transform", |
// Mathematics of Computation, Volume 32, Number 141, January 1978, |
// Pages 175-199 |
*/ |
/*------------------------------------------------------------------*/ |
/* */ |
/* Function: Calculation of the inverse MDCT */ |
/* */ |
/*------------------------------------------------------------------*/ |
static void dct36(real *inbuf,real *o1,real *o2,real *wintab,real *tsbuf) |
{ |
#ifdef NEW_DCT9 |
real tmp[18]; |
#endif |
{ |
register real *in = inbuf; |
in[17]+=in[16]; in[16]+=in[15]; in[15]+=in[14]; |
in[14]+=in[13]; in[13]+=in[12]; in[12]+=in[11]; |
in[11]+=in[10]; in[10]+=in[9]; in[9] +=in[8]; |
in[8] +=in[7]; in[7] +=in[6]; in[6] +=in[5]; |
in[5] +=in[4]; in[4] +=in[3]; in[3] +=in[2]; |
in[2] +=in[1]; in[1] +=in[0]; |
in[17]+=in[15]; in[15]+=in[13]; in[13]+=in[11]; in[11]+=in[9]; |
in[9] +=in[7]; in[7] +=in[5]; in[5] +=in[3]; in[3] +=in[1]; |
#ifdef NEW_DCT9 |
{ |
real t0, t1, t2, t3, t4, t5, t6, t7; |
t1 = COS6_2 * in[12]; |
t2 = COS6_2 * (in[8] + in[16] - in[4]); |
t3 = in[0] + t1; |
t4 = in[0] - t1 - t1; |
t5 = t4 - t2; |
t0 = cos9[0] * (in[4] + in[8]); |
t1 = cos9[1] * (in[8] - in[16]); |
tmp[4] = t4 + t2 + t2; |
t2 = cos9[2] * (in[4] + in[16]); |
t6 = t3 - t0 - t2; |
t0 += t3 + t1; |
t3 += t2 - t1; |
t2 = cos18[0] * (in[2] + in[10]); |
t4 = cos18[1] * (in[10] - in[14]); |
t7 = COS6_1 * in[6]; |
t1 = t2 + t4 + t7; |
tmp[0] = t0 + t1; |
tmp[8] = t0 - t1; |
t1 = cos18[2] * (in[2] + in[14]); |
t2 += t1 - t7; |
tmp[3] = t3 + t2; |
t0 = COS6_1 * (in[10] + in[14] - in[2]); |
tmp[5] = t3 - t2; |
t4 -= t1 + t7; |
tmp[1] = t5 - t0; |
tmp[7] = t5 + t0; |
tmp[2] = t6 + t4; |
tmp[6] = t6 - t4; |
} |
{ |
real t0, t1, t2, t3, t4, t5, t6, t7; |
t1 = COS6_2 * in[13]; |
t2 = COS6_2 * (in[9] + in[17] - in[5]); |
t3 = in[1] + t1; |
t4 = in[1] - t1 - t1; |
t5 = t4 - t2; |
t0 = cos9[0] * (in[5] + in[9]); |
t1 = cos9[1] * (in[9] - in[17]); |
tmp[13] = (t4 + t2 + t2) * tfcos36[17-13]; |
t2 = cos9[2] * (in[5] + in[17]); |
t6 = t3 - t0 - t2; |
t0 += t3 + t1; |
t3 += t2 - t1; |
t2 = cos18[0] * (in[3] + in[11]); |
t4 = cos18[1] * (in[11] - in[15]); |
t7 = COS6_1 * in[7]; |
t1 = t2 + t4 + t7; |
tmp[17] = (t0 + t1) * tfcos36[17-17]; |
tmp[9] = (t0 - t1) * tfcos36[17-9]; |
t1 = cos18[2] * (in[3] + in[15]); |
t2 += t1 - t7; |
tmp[14] = (t3 + t2) * tfcos36[17-14]; |
t0 = COS6_1 * (in[11] + in[15] - in[3]); |
tmp[12] = (t3 - t2) * tfcos36[17-12]; |
t4 -= t1 + t7; |
tmp[16] = (t5 - t0) * tfcos36[17-16]; |
tmp[10] = (t5 + t0) * tfcos36[17-10]; |
tmp[15] = (t6 + t4) * tfcos36[17-15]; |
tmp[11] = (t6 - t4) * tfcos36[17-11]; |
} |
#define MACRO(v) { \ |
real tmpval; \ |
real sum0 = tmp[(v)]; \ |
real sum1 = tmp[17-(v)]; \ |
out2[9+(v)] = (tmpval = sum0 + sum1) * w[27+(v)]; \ |
out2[8-(v)] = tmpval * w[26-(v)]; \ |
sum0 -= sum1; \ |
ts[SBLIMIT*(8-(v))] = out1[8-(v)] + sum0 * w[8-(v)]; \ |
ts[SBLIMIT*(9+(v))] = out1[9+(v)] + sum0 * w[9+(v)]; } |
{ |
register real *out2 = o2; |
register real *w = wintab; |
register real *out1 = o1; |
register real *ts = tsbuf; |
MACRO(0); |
MACRO(1); |
MACRO(2); |
MACRO(3); |
MACRO(4); |
MACRO(5); |
MACRO(6); |
MACRO(7); |
MACRO(8); |
} |
#else |
{ |
#define MACRO0(v) { \ |
real tmp; \ |
out2[9+(v)] = (tmp = sum0 + sum1) * w[27+(v)]; \ |
out2[8-(v)] = tmp * w[26-(v)]; } \ |
sum0 -= sum1; \ |
ts[SBLIMIT*(8-(v))] = out1[8-(v)] + sum0 * w[8-(v)]; \ |
ts[SBLIMIT*(9+(v))] = out1[9+(v)] + sum0 * w[9+(v)]; |
#define MACRO1(v) { \ |
real sum0,sum1; \ |
sum0 = tmp1a + tmp2a; \ |
sum1 = (tmp1b + tmp2b) * tfcos36[(v)]; \ |
MACRO0(v); } |
#define MACRO2(v) { \ |
real sum0,sum1; \ |
sum0 = tmp2a - tmp1a; \ |
sum1 = (tmp2b - tmp1b) * tfcos36[(v)]; \ |
MACRO0(v); } |
register const real *c = COS9; |
register real *out2 = o2; |
register real *w = wintab; |
register real *out1 = o1; |
register real *ts = tsbuf; |
real ta33,ta66,tb33,tb66; |
ta33 = in[2*3+0] * c[3]; |
ta66 = in[2*6+0] * c[6]; |
tb33 = in[2*3+1] * c[3]; |
tb66 = in[2*6+1] * c[6]; |
{ |
real tmp1a,tmp2a,tmp1b,tmp2b; |
tmp1a = in[2*1+0] * c[1] + ta33 + in[2*5+0] * c[5] + in[2*7+0] * c[7]; |
tmp1b = in[2*1+1] * c[1] + tb33 + in[2*5+1] * c[5] + in[2*7+1] * c[7]; |
tmp2a = in[2*0+0] + in[2*2+0] * c[2] + in[2*4+0] * c[4] + ta66 + in[2*8+0] * c[8]; |
tmp2b = in[2*0+1] + in[2*2+1] * c[2] + in[2*4+1] * c[4] + tb66 + in[2*8+1] * c[8]; |
MACRO1(0); |
MACRO2(8); |
} |
{ |
real tmp1a,tmp2a,tmp1b,tmp2b; |
tmp1a = ( in[2*1+0] - in[2*5+0] - in[2*7+0] ) * c[3]; |
tmp1b = ( in[2*1+1] - in[2*5+1] - in[2*7+1] ) * c[3]; |
tmp2a = ( in[2*2+0] - in[2*4+0] - in[2*8+0] ) * c[6] - in[2*6+0] + in[2*0+0]; |
tmp2b = ( in[2*2+1] - in[2*4+1] - in[2*8+1] ) * c[6] - in[2*6+1] + in[2*0+1]; |
MACRO1(1); |
MACRO2(7); |
} |
{ |
real tmp1a,tmp2a,tmp1b,tmp2b; |
tmp1a = in[2*1+0] * c[5] - ta33 - in[2*5+0] * c[7] + in[2*7+0] * c[1]; |
tmp1b = in[2*1+1] * c[5] - tb33 - in[2*5+1] * c[7] + in[2*7+1] * c[1]; |
tmp2a = in[2*0+0] - in[2*2+0] * c[8] - in[2*4+0] * c[2] + ta66 + in[2*8+0] * c[4]; |
tmp2b = in[2*0+1] - in[2*2+1] * c[8] - in[2*4+1] * c[2] + tb66 + in[2*8+1] * c[4]; |
MACRO1(2); |
MACRO2(6); |
} |
{ |
real tmp1a,tmp2a,tmp1b,tmp2b; |
tmp1a = in[2*1+0] * c[7] - ta33 + in[2*5+0] * c[1] - in[2*7+0] * c[5]; |
tmp1b = in[2*1+1] * c[7] - tb33 + in[2*5+1] * c[1] - in[2*7+1] * c[5]; |
tmp2a = in[2*0+0] - in[2*2+0] * c[4] + in[2*4+0] * c[8] + ta66 - in[2*8+0] * c[2]; |
tmp2b = in[2*0+1] - in[2*2+1] * c[4] + in[2*4+1] * c[8] + tb66 - in[2*8+1] * c[2]; |
MACRO1(3); |
MACRO2(5); |
} |
{ |
real sum0,sum1; |
sum0 = in[2*0+0] - in[2*2+0] + in[2*4+0] - in[2*6+0] + in[2*8+0]; |
sum1 = (in[2*0+1] - in[2*2+1] + in[2*4+1] - in[2*6+1] + in[2*8+1] ) * tfcos36[4]; |
MACRO0(4); |
} |
} |
#endif |
} |
} |
/* |
* new DCT12 |
*/ |
static void dct12(real *in,real *rawout1,real *rawout2,register real *wi,register real *ts) |
{ |
#define DCT12_PART1 \ |
in5 = in[5*3]; \ |
in5 += (in4 = in[4*3]); \ |
in4 += (in3 = in[3*3]); \ |
in3 += (in2 = in[2*3]); \ |
in2 += (in1 = in[1*3]); \ |
in1 += (in0 = in[0*3]); \ |
\ |
in5 += in3; in3 += in1; \ |
\ |
in2 *= COS6_1; \ |
in3 *= COS6_1; \ |
#define DCT12_PART2 \ |
in0 += in4 * COS6_2; \ |
\ |
in4 = in0 + in2; \ |
in0 -= in2; \ |
\ |
in1 += in5 * COS6_2; \ |
\ |
in5 = (in1 + in3) * tfcos12[0]; \ |
in1 = (in1 - in3) * tfcos12[2]; \ |
\ |
in3 = in4 + in5; \ |
in4 -= in5; \ |
\ |
in2 = in0 + in1; \ |
in0 -= in1; |
{ |
real in0,in1,in2,in3,in4,in5; |
register real *out1 = rawout1; |
ts[SBLIMIT*0] = out1[0]; ts[SBLIMIT*1] = out1[1]; ts[SBLIMIT*2] = out1[2]; |
ts[SBLIMIT*3] = out1[3]; ts[SBLIMIT*4] = out1[4]; ts[SBLIMIT*5] = out1[5]; |
DCT12_PART1 |
{ |
real tmp0,tmp1 = (in0 - in4); |
{ |
real tmp2 = (in1 - in5) * tfcos12[1]; |
tmp0 = tmp1 + tmp2; |
tmp1 -= tmp2; |
} |
ts[(17-1)*SBLIMIT] = out1[17-1] + tmp0 * wi[11-1]; |
ts[(12+1)*SBLIMIT] = out1[12+1] + tmp0 * wi[6+1]; |
ts[(6 +1)*SBLIMIT] = out1[6 +1] + tmp1 * wi[1]; |
ts[(11-1)*SBLIMIT] = out1[11-1] + tmp1 * wi[5-1]; |
} |
DCT12_PART2 |
ts[(17-0)*SBLIMIT] = out1[17-0] + in2 * wi[11-0]; |
ts[(12+0)*SBLIMIT] = out1[12+0] + in2 * wi[6+0]; |
ts[(12+2)*SBLIMIT] = out1[12+2] + in3 * wi[6+2]; |
ts[(17-2)*SBLIMIT] = out1[17-2] + in3 * wi[11-2]; |
ts[(6+0)*SBLIMIT] = out1[6+0] + in0 * wi[0]; |
ts[(11-0)*SBLIMIT] = out1[11-0] + in0 * wi[5-0]; |
ts[(6+2)*SBLIMIT] = out1[6+2] + in4 * wi[2]; |
ts[(11-2)*SBLIMIT] = out1[11-2] + in4 * wi[5-2]; |
} |
in++; |
{ |
real in0,in1,in2,in3,in4,in5; |
register real *out2 = rawout2; |
DCT12_PART1 |
{ |
real tmp0,tmp1 = (in0 - in4); |
{ |
real tmp2 = (in1 - in5) * tfcos12[1]; |
tmp0 = tmp1 + tmp2; |
tmp1 -= tmp2; |
} |
out2[5-1] = tmp0 * wi[11-1]; |
out2[0+1] = tmp0 * wi[6+1]; |
ts[(12+1)*SBLIMIT] += tmp1 * wi[1]; |
ts[(17-1)*SBLIMIT] += tmp1 * wi[5-1]; |
} |
DCT12_PART2 |
out2[5-0] = in2 * wi[11-0]; |
out2[0+0] = in2 * wi[6+0]; |
out2[0+2] = in3 * wi[6+2]; |
out2[5-2] = in3 * wi[11-2]; |
ts[(12+0)*SBLIMIT] += in0 * wi[0]; |
ts[(17-0)*SBLIMIT] += in0 * wi[5-0]; |
ts[(12+2)*SBLIMIT] += in4 * wi[2]; |
ts[(17-2)*SBLIMIT] += in4 * wi[5-2]; |
} |
in++; |
{ |
real in0,in1,in2,in3,in4,in5; |
register real *out2 = rawout2; |
out2[12]=out2[13]=out2[14]=out2[15]=out2[16]=out2[17]=0.0; |
DCT12_PART1 |
{ |
real tmp0,tmp1 = (in0 - in4); |
{ |
real tmp2 = (in1 - in5) * tfcos12[1]; |
tmp0 = tmp1 + tmp2; |
tmp1 -= tmp2; |
} |
out2[11-1] = tmp0 * wi[11-1]; |
out2[6 +1] = tmp0 * wi[6+1]; |
out2[0+1] += tmp1 * wi[1]; |
out2[5-1] += tmp1 * wi[5-1]; |
} |
DCT12_PART2 |
out2[11-0] = in2 * wi[11-0]; |
out2[6 +0] = in2 * wi[6+0]; |
out2[6 +2] = in3 * wi[6+2]; |
out2[11-2] = in3 * wi[11-2]; |
out2[0+0] += in0 * wi[0]; |
out2[5-0] += in0 * wi[5-0]; |
out2[0+2] += in4 * wi[2]; |
out2[5-2] += in4 * wi[5-2]; |
} |
} |
/* |
* III_hybrid |
*/ |
static void III_hybrid(real fsIn[SBLIMIT][SSLIMIT],real tsOut[SSLIMIT][SBLIMIT], |
int ch,struct gr_info_s *gr_info) |
{ |
real *tspnt = (real *) tsOut; |
static real block[2][2][SBLIMIT*SSLIMIT] = { { { 0, } } }; |
static int blc[2]={0,0}; |
real *rawout1,*rawout2; |
int bt; |
int sb = 0; |
{ |
int b = blc[ch]; |
rawout1=block[b][ch]; |
b=-b+1; |
rawout2=block[b][ch]; |
blc[ch] = b; |
} |
if(gr_info->mixed_block_flag) { |
sb = 2; |
dct36(fsIn[0],rawout1,rawout2,win[0],tspnt); |
dct36(fsIn[1],rawout1+18,rawout2+18,win1[0],tspnt+1); |
rawout1 += 36; rawout2 += 36; tspnt += 2; |
} |
bt = gr_info->block_type; |
if(bt == 2) { |
for (; sb<gr_info->maxb; sb+=2,tspnt+=2,rawout1+=36,rawout2+=36) { |
dct12(fsIn[sb],rawout1,rawout2,win[2],tspnt); |
dct12(fsIn[sb+1],rawout1+18,rawout2+18,win1[2],tspnt+1); |
} |
} |
else { |
for (; sb<gr_info->maxb; sb+=2,tspnt+=2,rawout1+=36,rawout2+=36) { |
dct36(fsIn[sb],rawout1,rawout2,win[bt],tspnt); |
dct36(fsIn[sb+1],rawout1+18,rawout2+18,win1[bt],tspnt+1); |
} |
} |
for(;sb<SBLIMIT;sb++,tspnt++) { |
int i; |
for(i=0;i<SSLIMIT;i++) { |
tspnt[i*SBLIMIT] = *rawout1++; |
*rawout2++ = 0.0; |
} |
} |
} |
/* |
* main layer3 handler |
*/ |
int do_layer3(struct frame *fr,int outmode,struct audio_info_struct *ai) |
{ |
int gr, ch, ss,clip=0; |
int scalefacs[39]; /* max 39 for short[13][3] mode, mixed: 38, long: 22 */ |
struct III_sideinfo sideinfo; |
int stereo = fr->stereo; |
int single = fr->single; |
int ms_stereo,i_stereo; |
int sfreq = fr->sampling_frequency; |
int stereo1,granules; |
if(stereo == 1) { |
stereo1 = 1; |
single = 0; |
} |
else if(single >= 0) |
stereo1 = 1; |
else |
stereo1 = 2; |
ms_stereo = (fr->mode == MPG_MD_JOINT_STEREO) && (fr->mode_ext & 0x2); |
i_stereo = (fr->mode == MPG_MD_JOINT_STEREO) && (fr->mode_ext & 0x1); |
if(fr->lsf) { |
granules = 1; |
III_get_side_info_2(&sideinfo,stereo,ms_stereo,sfreq,single); |
} |
else { |
granules = 2; |
III_get_side_info_1(&sideinfo,stereo,ms_stereo,sfreq,single); |
} |
set_pointer(sideinfo.main_data_begin); |
for (gr=0;gr<granules;gr++) |
{ |
static real hybridIn[2][SBLIMIT][SSLIMIT]; |
static real hybridOut[2][SSLIMIT][SBLIMIT]; |
{ |
struct gr_info_s *gr_info = &(sideinfo.ch[0].gr[gr]); |
long part2bits; |
if(fr->lsf) |
part2bits = III_get_scale_factors_2(scalefacs,gr_info,0); |
else |
part2bits = III_get_scale_factors_1(scalefacs,gr_info); |
if(III_dequantize_sample(hybridIn[0], scalefacs,gr_info,sfreq,part2bits)) |
return clip; |
} |
if(stereo == 2) { |
struct gr_info_s *gr_info = &(sideinfo.ch[1].gr[gr]); |
long part2bits; |
if(fr->lsf) |
part2bits = III_get_scale_factors_2(scalefacs,gr_info,i_stereo); |
else |
part2bits = III_get_scale_factors_1(scalefacs,gr_info); |
if(ms_stereo) { |
if(III_dequantize_sample_ms(hybridIn,scalefacs,gr_info,sfreq,part2bits)) |
return clip; |
} |
else { |
if(III_dequantize_sample(hybridIn[1],scalefacs,gr_info,sfreq,part2bits)) |
return clip; |
} |
if(i_stereo) |
III_i_stereo(hybridIn,scalefacs,gr_info,sfreq,ms_stereo,fr->lsf); |
if(ms_stereo || i_stereo || (single == 3) ) { |
if(gr_info->maxb > sideinfo.ch[0].gr[gr].maxb) |
sideinfo.ch[0].gr[gr].maxb = gr_info->maxb; |
else |
gr_info->maxb = sideinfo.ch[0].gr[gr].maxb; |
} |
switch(single) { |
case 3: |
{ |
register int i; |
register real *in0 = (real *) hybridIn[0],*in1 = (real *) hybridIn[1]; |
for(i=0;i<SSLIMIT*gr_info->maxb;i++,in0++) |
*in0 = (*in0 + *in1++); /* *0.5 done by pow-scale */ |
} |
break; |
case 1: |
{ |
register int i; |
register real *in0 = (real *) hybridIn[0],*in1 = (real *) hybridIn[1]; |
for(i=0;i<SSLIMIT*gr_info->maxb;i++) |
*in0++ = *in1++; |
} |
break; |
} |
} |
for(ch=0;ch<stereo1;ch++) { |
struct gr_info_s *gr_info = &(sideinfo.ch[ch].gr[gr]); |
III_antialias(hybridIn[ch],gr_info); |
III_hybrid(hybridIn[ch], hybridOut[ch], ch,gr_info); |
} |
for(ss=0;ss<SSLIMIT;ss++) { |
if(single >= 0) { |
clip += (fr->synth_mono)(hybridOut[0][ss],pcm_sample+pcm_point); |
} |
else { |
clip += (fr->synth)(hybridOut[0][ss],0,pcm_sample+pcm_point); |
clip += (fr->synth)(hybridOut[1][ss],1,pcm_sample+pcm_point); |
} |
pcm_point += fr->block_size; |
#ifdef VARMODESUPPORT |
if (playlimit < 128) { |
pcm_point -= playlimit >> 1; |
playlimit = 0; |
} |
else |
playlimit -= 128; |
#endif |
if(pcm_point >= audiobufsize) |
audio_flush(outmode,ai); |
} |
} |
return clip; |
} |
/shark/trunk/ports/mpg123/dct64_i3.c |
---|
0,0 → 1,315 |
/* |
* Discrete Cosine Tansform (DCT) for subband synthesis |
* optimized for machines with no auto-increment. |
* The performance is highly compiler dependend. Maybe |
* the dct64.c version for 'normal' processor may be faster |
* even for Intel processors. |
*/ |
#include "mpg123.h" |
static void dct64_1(real *out0,real *out1,real *b1,real *b2,real *samples) |
{ |
{ |
register real *costab = pnts[0]; |
b1[0x00] = samples[0x00] + samples[0x1F]; |
b1[0x1F] = (samples[0x00] - samples[0x1F]) * costab[0x0]; |
b1[0x01] = samples[0x01] + samples[0x1E]; |
b1[0x1E] = (samples[0x01] - samples[0x1E]) * costab[0x1]; |
b1[0x02] = samples[0x02] + samples[0x1D]; |
b1[0x1D] = (samples[0x02] - samples[0x1D]) * costab[0x2]; |
b1[0x03] = samples[0x03] + samples[0x1C]; |
b1[0x1C] = (samples[0x03] - samples[0x1C]) * costab[0x3]; |
b1[0x04] = samples[0x04] + samples[0x1B]; |
b1[0x1B] = (samples[0x04] - samples[0x1B]) * costab[0x4]; |
b1[0x05] = samples[0x05] + samples[0x1A]; |
b1[0x1A] = (samples[0x05] - samples[0x1A]) * costab[0x5]; |
b1[0x06] = samples[0x06] + samples[0x19]; |
b1[0x19] = (samples[0x06] - samples[0x19]) * costab[0x6]; |
b1[0x07] = samples[0x07] + samples[0x18]; |
b1[0x18] = (samples[0x07] - samples[0x18]) * costab[0x7]; |
b1[0x08] = samples[0x08] + samples[0x17]; |
b1[0x17] = (samples[0x08] - samples[0x17]) * costab[0x8]; |
b1[0x09] = samples[0x09] + samples[0x16]; |
b1[0x16] = (samples[0x09] - samples[0x16]) * costab[0x9]; |
b1[0x0A] = samples[0x0A] + samples[0x15]; |
b1[0x15] = (samples[0x0A] - samples[0x15]) * costab[0xA]; |
b1[0x0B] = samples[0x0B] + samples[0x14]; |
b1[0x14] = (samples[0x0B] - samples[0x14]) * costab[0xB]; |
b1[0x0C] = samples[0x0C] + samples[0x13]; |
b1[0x13] = (samples[0x0C] - samples[0x13]) * costab[0xC]; |
b1[0x0D] = samples[0x0D] + samples[0x12]; |
b1[0x12] = (samples[0x0D] - samples[0x12]) * costab[0xD]; |
b1[0x0E] = samples[0x0E] + samples[0x11]; |
b1[0x11] = (samples[0x0E] - samples[0x11]) * costab[0xE]; |
b1[0x0F] = samples[0x0F] + samples[0x10]; |
b1[0x10] = (samples[0x0F] - samples[0x10]) * costab[0xF]; |
} |
{ |
register real *costab = pnts[1]; |
b2[0x00] = b1[0x00] + b1[0x0F]; |
b2[0x0F] = (b1[0x00] - b1[0x0F]) * costab[0]; |
b2[0x01] = b1[0x01] + b1[0x0E]; |
b2[0x0E] = (b1[0x01] - b1[0x0E]) * costab[1]; |
b2[0x02] = b1[0x02] + b1[0x0D]; |
b2[0x0D] = (b1[0x02] - b1[0x0D]) * costab[2]; |
b2[0x03] = b1[0x03] + b1[0x0C]; |
b2[0x0C] = (b1[0x03] - b1[0x0C]) * costab[3]; |
b2[0x04] = b1[0x04] + b1[0x0B]; |
b2[0x0B] = (b1[0x04] - b1[0x0B]) * costab[4]; |
b2[0x05] = b1[0x05] + b1[0x0A]; |
b2[0x0A] = (b1[0x05] - b1[0x0A]) * costab[5]; |
b2[0x06] = b1[0x06] + b1[0x09]; |
b2[0x09] = (b1[0x06] - b1[0x09]) * costab[6]; |
b2[0x07] = b1[0x07] + b1[0x08]; |
b2[0x08] = (b1[0x07] - b1[0x08]) * costab[7]; |
b2[0x10] = b1[0x10] + b1[0x1F]; |
b2[0x1F] = (b1[0x1F] - b1[0x10]) * costab[0]; |
b2[0x11] = b1[0x11] + b1[0x1E]; |
b2[0x1E] = (b1[0x1E] - b1[0x11]) * costab[1]; |
b2[0x12] = b1[0x12] + b1[0x1D]; |
b2[0x1D] = (b1[0x1D] - b1[0x12]) * costab[2]; |
b2[0x13] = b1[0x13] + b1[0x1C]; |
b2[0x1C] = (b1[0x1C] - b1[0x13]) * costab[3]; |
b2[0x14] = b1[0x14] + b1[0x1B]; |
b2[0x1B] = (b1[0x1B] - b1[0x14]) * costab[4]; |
b2[0x15] = b1[0x15] + b1[0x1A]; |
b2[0x1A] = (b1[0x1A] - b1[0x15]) * costab[5]; |
b2[0x16] = b1[0x16] + b1[0x19]; |
b2[0x19] = (b1[0x19] - b1[0x16]) * costab[6]; |
b2[0x17] = b1[0x17] + b1[0x18]; |
b2[0x18] = (b1[0x18] - b1[0x17]) * costab[7]; |
} |
{ |
register real *costab = pnts[2]; |
b1[0x00] = b2[0x00] + b2[0x07]; |
b1[0x07] = (b2[0x00] - b2[0x07]) * costab[0]; |
b1[0x01] = b2[0x01] + b2[0x06]; |
b1[0x06] = (b2[0x01] - b2[0x06]) * costab[1]; |
b1[0x02] = b2[0x02] + b2[0x05]; |
b1[0x05] = (b2[0x02] - b2[0x05]) * costab[2]; |
b1[0x03] = b2[0x03] + b2[0x04]; |
b1[0x04] = (b2[0x03] - b2[0x04]) * costab[3]; |
b1[0x08] = b2[0x08] + b2[0x0F]; |
b1[0x0F] = (b2[0x0F] - b2[0x08]) * costab[0]; |
b1[0x09] = b2[0x09] + b2[0x0E]; |
b1[0x0E] = (b2[0x0E] - b2[0x09]) * costab[1]; |
b1[0x0A] = b2[0x0A] + b2[0x0D]; |
b1[0x0D] = (b2[0x0D] - b2[0x0A]) * costab[2]; |
b1[0x0B] = b2[0x0B] + b2[0x0C]; |
b1[0x0C] = (b2[0x0C] - b2[0x0B]) * costab[3]; |
b1[0x10] = b2[0x10] + b2[0x17]; |
b1[0x17] = (b2[0x10] - b2[0x17]) * costab[0]; |
b1[0x11] = b2[0x11] + b2[0x16]; |
b1[0x16] = (b2[0x11] - b2[0x16]) * costab[1]; |
b1[0x12] = b2[0x12] + b2[0x15]; |
b1[0x15] = (b2[0x12] - b2[0x15]) * costab[2]; |
b1[0x13] = b2[0x13] + b2[0x14]; |
b1[0x14] = (b2[0x13] - b2[0x14]) * costab[3]; |
b1[0x18] = b2[0x18] + b2[0x1F]; |
b1[0x1F] = (b2[0x1F] - b2[0x18]) * costab[0]; |
b1[0x19] = b2[0x19] + b2[0x1E]; |
b1[0x1E] = (b2[0x1E] - b2[0x19]) * costab[1]; |
b1[0x1A] = b2[0x1A] + b2[0x1D]; |
b1[0x1D] = (b2[0x1D] - b2[0x1A]) * costab[2]; |
b1[0x1B] = b2[0x1B] + b2[0x1C]; |
b1[0x1C] = (b2[0x1C] - b2[0x1B]) * costab[3]; |
} |
{ |
register real const cos0 = pnts[3][0]; |
register real const cos1 = pnts[3][1]; |
b2[0x00] = b1[0x00] + b1[0x03]; |
b2[0x03] = (b1[0x00] - b1[0x03]) * cos0; |
b2[0x01] = b1[0x01] + b1[0x02]; |
b2[0x02] = (b1[0x01] - b1[0x02]) * cos1; |
b2[0x04] = b1[0x04] + b1[0x07]; |
b2[0x07] = (b1[0x07] - b1[0x04]) * cos0; |
b2[0x05] = b1[0x05] + b1[0x06]; |
b2[0x06] = (b1[0x06] - b1[0x05]) * cos1; |
b2[0x08] = b1[0x08] + b1[0x0B]; |
b2[0x0B] = (b1[0x08] - b1[0x0B]) * cos0; |
b2[0x09] = b1[0x09] + b1[0x0A]; |
b2[0x0A] = (b1[0x09] - b1[0x0A]) * cos1; |
b2[0x0C] = b1[0x0C] + b1[0x0F]; |
b2[0x0F] = (b1[0x0F] - b1[0x0C]) * cos0; |
b2[0x0D] = b1[0x0D] + b1[0x0E]; |
b2[0x0E] = (b1[0x0E] - b1[0x0D]) * cos1; |
b2[0x10] = b1[0x10] + b1[0x13]; |
b2[0x13] = (b1[0x10] - b1[0x13]) * cos0; |
b2[0x11] = b1[0x11] + b1[0x12]; |
b2[0x12] = (b1[0x11] - b1[0x12]) * cos1; |
b2[0x14] = b1[0x14] + b1[0x17]; |
b2[0x17] = (b1[0x17] - b1[0x14]) * cos0; |
b2[0x15] = b1[0x15] + b1[0x16]; |
b2[0x16] = (b1[0x16] - b1[0x15]) * cos1; |
b2[0x18] = b1[0x18] + b1[0x1B]; |
b2[0x1B] = (b1[0x18] - b1[0x1B]) * cos0; |
b2[0x19] = b1[0x19] + b1[0x1A]; |
b2[0x1A] = (b1[0x19] - b1[0x1A]) * cos1; |
b2[0x1C] = b1[0x1C] + b1[0x1F]; |
b2[0x1F] = (b1[0x1F] - b1[0x1C]) * cos0; |
b2[0x1D] = b1[0x1D] + b1[0x1E]; |
b2[0x1E] = (b1[0x1E] - b1[0x1D]) * cos1; |
} |
{ |
register real const cos0 = pnts[4][0]; |
b1[0x00] = b2[0x00] + b2[0x01]; |
b1[0x01] = (b2[0x00] - b2[0x01]) * cos0; |
b1[0x02] = b2[0x02] + b2[0x03]; |
b1[0x03] = (b2[0x03] - b2[0x02]) * cos0; |
b1[0x02] += b1[0x03]; |
b1[0x04] = b2[0x04] + b2[0x05]; |
b1[0x05] = (b2[0x04] - b2[0x05]) * cos0; |
b1[0x06] = b2[0x06] + b2[0x07]; |
b1[0x07] = (b2[0x07] - b2[0x06]) * cos0; |
b1[0x06] += b1[0x07]; |
b1[0x04] += b1[0x06]; |
b1[0x06] += b1[0x05]; |
b1[0x05] += b1[0x07]; |
b1[0x08] = b2[0x08] + b2[0x09]; |
b1[0x09] = (b2[0x08] - b2[0x09]) * cos0; |
b1[0x0A] = b2[0x0A] + b2[0x0B]; |
b1[0x0B] = (b2[0x0B] - b2[0x0A]) * cos0; |
b1[0x0A] += b1[0x0B]; |
b1[0x0C] = b2[0x0C] + b2[0x0D]; |
b1[0x0D] = (b2[0x0C] - b2[0x0D]) * cos0; |
b1[0x0E] = b2[0x0E] + b2[0x0F]; |
b1[0x0F] = (b2[0x0F] - b2[0x0E]) * cos0; |
b1[0x0E] += b1[0x0F]; |
b1[0x0C] += b1[0x0E]; |
b1[0x0E] += b1[0x0D]; |
b1[0x0D] += b1[0x0F]; |
b1[0x10] = b2[0x10] + b2[0x11]; |
b1[0x11] = (b2[0x10] - b2[0x11]) * cos0; |
b1[0x12] = b2[0x12] + b2[0x13]; |
b1[0x13] = (b2[0x13] - b2[0x12]) * cos0; |
b1[0x12] += b1[0x13]; |
b1[0x14] = b2[0x14] + b2[0x15]; |
b1[0x15] = (b2[0x14] - b2[0x15]) * cos0; |
b1[0x16] = b2[0x16] + b2[0x17]; |
b1[0x17] = (b2[0x17] - b2[0x16]) * cos0; |
b1[0x16] += b1[0x17]; |
b1[0x14] += b1[0x16]; |
b1[0x16] += b1[0x15]; |
b1[0x15] += b1[0x17]; |
b1[0x18] = b2[0x18] + b2[0x19]; |
b1[0x19] = (b2[0x18] - b2[0x19]) * cos0; |
b1[0x1A] = b2[0x1A] + b2[0x1B]; |
b1[0x1B] = (b2[0x1B] - b2[0x1A]) * cos0; |
b1[0x1A] += b1[0x1B]; |
b1[0x1C] = b2[0x1C] + b2[0x1D]; |
b1[0x1D] = (b2[0x1C] - b2[0x1D]) * cos0; |
b1[0x1E] = b2[0x1E] + b2[0x1F]; |
b1[0x1F] = (b2[0x1F] - b2[0x1E]) * cos0; |
b1[0x1E] += b1[0x1F]; |
b1[0x1C] += b1[0x1E]; |
b1[0x1E] += b1[0x1D]; |
b1[0x1D] += b1[0x1F]; |
} |
out0[0x10*16] = b1[0x00]; |
out0[0x10*12] = b1[0x04]; |
out0[0x10* 8] = b1[0x02]; |
out0[0x10* 4] = b1[0x06]; |
out0[0x10* 0] = b1[0x01]; |
out1[0x10* 0] = b1[0x01]; |
out1[0x10* 4] = b1[0x05]; |
out1[0x10* 8] = b1[0x03]; |
out1[0x10*12] = b1[0x07]; |
b1[0x08] += b1[0x0C]; |
out0[0x10*14] = b1[0x08]; |
b1[0x0C] += b1[0x0a]; |
out0[0x10*10] = b1[0x0C]; |
b1[0x0A] += b1[0x0E]; |
out0[0x10* 6] = b1[0x0A]; |
b1[0x0E] += b1[0x09]; |
out0[0x10* 2] = b1[0x0E]; |
b1[0x09] += b1[0x0D]; |
out1[0x10* 2] = b1[0x09]; |
b1[0x0D] += b1[0x0B]; |
out1[0x10* 6] = b1[0x0D]; |
b1[0x0B] += b1[0x0F]; |
out1[0x10*10] = b1[0x0B]; |
out1[0x10*14] = b1[0x0F]; |
b1[0x18] += b1[0x1C]; |
out0[0x10*15] = b1[0x10] + b1[0x18]; |
out0[0x10*13] = b1[0x18] + b1[0x14]; |
b1[0x1C] += b1[0x1a]; |
out0[0x10*11] = b1[0x14] + b1[0x1C]; |
out0[0x10* 9] = b1[0x1C] + b1[0x12]; |
b1[0x1A] += b1[0x1E]; |
out0[0x10* 7] = b1[0x12] + b1[0x1A]; |
out0[0x10* 5] = b1[0x1A] + b1[0x16]; |
b1[0x1E] += b1[0x19]; |
out0[0x10* 3] = b1[0x16] + b1[0x1E]; |
out0[0x10* 1] = b1[0x1E] + b1[0x11]; |
b1[0x19] += b1[0x1D]; |
out1[0x10* 1] = b1[0x11] + b1[0x19]; |
out1[0x10* 3] = b1[0x19] + b1[0x15]; |
b1[0x1D] += b1[0x1B]; |
out1[0x10* 5] = b1[0x15] + b1[0x1D]; |
out1[0x10* 7] = b1[0x1D] + b1[0x13]; |
b1[0x1B] += b1[0x1F]; |
out1[0x10* 9] = b1[0x13] + b1[0x1B]; |
out1[0x10*11] = b1[0x1B] + b1[0x17]; |
out1[0x10*13] = b1[0x17] + b1[0x1F]; |
out1[0x10*15] = b1[0x1F]; |
} |
/* |
* the call via dct64 is a trick to force GCC to use |
* (new) registers for the b1,b2 pointer to the bufs[xx] field |
*/ |
void dct64(real *a,real *b,real *c) |
{ |
real bufs[0x40]; |
dct64_1(a,b,bufs,bufs+0x20,c); |
} |
/shark/trunk/ports/mpg123/getbits_.s |
---|
0,0 → 1,73 |
.globl _wordpointer |
.type _wordpointer,@object |
.size _wordpointer,4 |
.globl _bitindex |
.type _bitindex,@object |
.size _bitindex,4 |
.globl _getbits |
.type _getbits,@function |
_getbits: |
cmpl $0,4(%esp) |
jne .L1 |
xorl %eax,%eax |
ret |
.L1: |
movl _wordpointer,%ecx |
movzbl (%ecx),%eax |
shll $16,%eax |
movb 1(%ecx),%ah |
movb 2(%ecx),%al |
movl _bitindex,%ecx |
shll $8,%eax |
shll %cl,%eax |
movl 4(%esp),%ecx |
addl %ecx,_bitindex |
negl %ecx |
addl $32,%ecx |
shrl %cl,%eax |
movl _bitindex,%ecx |
sarl $3,%ecx |
addl %ecx,_wordpointer |
andl $7,_bitindex |
ret |
.globl _getbits_fast |
.type _getbits_fast,@function |
_getbits_fast: |
movl _wordpointer,%ecx |
movzbl 1(%ecx),%eax |
movb (%ecx),%ah |
movl _bitindex,%ecx |
shlw %cl,%ax |
movl 4(%esp),%ecx |
addl %ecx,_bitindex |
negl %ecx |
addl $16,%ecx |
shrl %cl,%eax |
movl _bitindex,%ecx |
sarl $3,%ecx |
addl %ecx,_wordpointer |
andl $7,_bitindex |
ret |
.globl _get1bit |
.type _get1bit,@function |
_get1bit: |
movl _wordpointer,%ecx |
movzbl (%ecx),%eax |
movl _bitindex,%ecx |
incl %ecx |
rolb %cl,%al |
andb $1,%al |
movl %ecx,_bitindex |
andl $7,_bitindex |
sarl $3,%ecx |
addl %ecx,_wordpointer |
ret |
/shark/trunk/ports/mpg123/control.c |
---|
0,0 → 1,220 |
/* |
* Control interface to front ends. |
* written/copyrights 1997 by Michael Hipp |
*/ |
#include <stdio.h> |
#include <sys/time.h> |
#include <sys/types.h> |
#include <unistd.h> |
#include <linux/socket.h> |
/* <sys/socket.h> */ |
#include "jukebox/controldata.h" |
#include "mpg123.h" |
#define MODE_STOPPED 0 |
#define MODE_PLAYING 1 |
#define MODE_PAUSED 2 |
extern FILE *filept; |
extern int tabsel_123[2][3][16]; |
int sajber_sendmsg(int type,int data) |
{ |
TControlMsg msg; |
msg.type = type; |
msg.data = data; |
return write(1,&msg,sizeof(TControlMsg)); |
} |
void control_sajber(struct frame *fr) |
{ |
struct timeval timeout; |
fd_set readfds; |
int n; |
int mode = MODE_STOPPED; |
TControlMsg smsg,rmsg; |
struct msghdr msghdr; |
struct m_cmsghdr cmsghdr; |
struct iovec iovec[1]; |
char buf[2]; |
int init = 0; |
int framecnt = 0; |
while(1) { |
timeout.tv_sec = 0; |
timeout.tv_usec = 0; |
FD_ZERO(&readfds); |
FD_SET(0,&readfds); |
if(mode == MODE_PLAYING) { |
n = select(32,&readfds,NULL,NULL,&timeout); |
if(n == 0) { |
if(!read_frame(fr)) { |
mode = MODE_STOPPED; |
close_stream(); |
sajber_sendmsg(MSG_NEXT,0); |
continue; |
} |
play_frame(init,fr); |
if(init) { |
AudioInfo sai; |
sai.bitrate = tabsel_123[fr->lsf][fr->lay-1][fr->bitrate_index] * 1000; |
sai.frequency = freqs[fr->sampling_frequency]; |
sai.stereo = fr->stereo; |
sai.type = fr->lay; |
sai.sample = 16; |
sajber_sendmsg(MSG_INFO,TRUE); |
write(1,&sai,sizeof(AudioInfo)); |
init = 0; |
} |
framecnt++; |
if(!(framecnt & 0xf)) { |
sajber_sendmsg(MSG_FRAMES,framecnt); |
sajber_sendmsg(MSG_POSITION,tell_stream()); |
} |
} |
} |
else { |
while(1) { |
n = select(32,&readfds,NULL,NULL,NULL); |
if(n > 0) |
break; |
} |
} |
if(n < 0) { |
exit(1); |
} |
if(n > 0) { |
int len; |
len = read(0,&rmsg,sizeof(TControlMsg)); |
if(len != sizeof(TControlMsg)) { |
fprintf(stderr,"Error reading control message!\n"); |
exit(1); |
} |
#if 0 |
fprintf(stderr,"%d.%d\n",rmsg.type,rmsg.data); |
#endif |
switch(rmsg.type) { |
case MSG_CTRL: |
switch(rmsg.data) { |
case FORWARD_STEP: |
if(mode != MODE_STOPPED) { |
int i; |
for(i=0;i<16;i++) { |
read_frame(fr); |
if(framecnt && fr->lay == 3) |
set_pointer(512); |
framecnt++; |
} |
} |
sajber_sendmsg(MSG_RESPONSE,FORWARD_STEP); |
break; |
case FORWARD_BEGIN: |
sajber_sendmsg(MSG_RESPONSE,FORWARD_BEGIN); |
break; |
case FORWARD_END: |
sajber_sendmsg(MSG_RESPONSE,FORWARD_END); |
break; |
case REWIND_BEGIN: |
sajber_sendmsg(MSG_RESPONSE,REWIND_BEGIN); |
break; |
case REWIND_STEP: |
if(back_frame(fr,16) == 0) |
framecnt -= 16; |
else |
framecnt = 0; |
sajber_sendmsg(MSG_RESPONSE,REWIND_STEP); |
break; |
case REWIND_END: |
sajber_sendmsg(MSG_RESPONSE,REWIND_END); |
break; |
case PLAY_STOP: |
mode = MODE_STOPPED; |
close_stream(); |
break; |
case PLAY_PAUSE: |
mode = MODE_PAUSED; |
break; |
} |
break; |
case MSG_BUFFER: |
break; |
case MSG_SONG: |
if(mode == MODE_PLAYING) { |
close_stream(); |
mode = MODE_STOPPED; |
} |
iovec[0].iov_base = buf; |
iovec[0].iov_len = 2; |
/* |
* this control message 'delivers' a given file |
* descriptor to another process .. |
* the sent descriptor can then be accesed by the |
* child process. |
*/ |
cmsghdr.cmsg_len = sizeof(cmsghdr); |
cmsghdr.cmsg_level = SOL_SOCKET; |
cmsghdr.cmsg_type = SCM_RIGHTS; |
msghdr.msg_name = NULL; |
msghdr.msg_namelen = 0; |
msghdr.msg_iov = iovec; |
msghdr.msg_iovlen = 1; |
msghdr.msg_control = &cmsghdr; |
msghdr.msg_controllen = sizeof(cmsghdr); |
if(recvmsg(0,&msghdr,0) < 0) { |
perror("recvmsg"); |
exit(1); |
} |
open_stream(NULL,cmsghdr.fd); |
mode = MODE_PLAYING; |
init = 1; |
framecnt = 0; |
read_frame_init(); |
break; |
case MSG_QUIT: |
exit(0); |
break; |
case MSG_QUERY: |
smsg.type = MSG_RESPONSE; |
smsg.data = FALSE; |
switch(rmsg.data) { |
case QUERY_PLAYING: |
if(mode == MODE_PLAYING) |
smsg.data = TRUE; |
break; |
case QUERY_PAUSED: |
if(mode == MODE_PAUSED) |
smsg.data = TRUE; |
break; |
} |
write(1,&smsg,sizeof(TControlMsg)); |
break; |
case MSG_BUFAHEAD: |
break; |
case MSG_SEEK: |
break; |
case MSG_PRIORITY: |
break; |
case MSG_RELEASE: |
break; |
} |
} |
} |
} |
void control_tk3play(struct frame *fr) |
{ |
} |
/shark/trunk/ports/mpg123/decode.c |
---|
0,0 → 1,168 |
/* |
* Mpeg Layer-1,2,3 audio decoder |
* ------------------------------ |
* copyright (c) 1995,1996,1997 by Michael Hipp, All rights reserved. |
* See also 'README' |
* |
*/ |
#include <stdlib.h> |
#include <math.h> |
#include <string.h> |
#include "mpg123.h" |
#define WRITE_SAMPLE(samples,sum,clip) \ |
if( (sum) > 32767.0) { *(samples) = 0x7fff; (clip)++; } \ |
else if( (sum) < -32768.0) { *(samples) = -0x8000; (clip)++; } \ |
else { *(samples) = sum; } |
int synth_1to1_8bit(real *bandPtr,int channel,unsigned char *samples) |
{ |
short samples_tmp[64]; |
short *tmp1 = samples_tmp + channel; |
int i,ret; |
samples += channel; |
ret = synth_1to1(bandPtr,channel,(unsigned char *) samples_tmp); |
for(i=0;i<32;i++) { |
*samples = conv16to8[*tmp1>>4]; |
samples += 2; |
tmp1 += 2; |
} |
return ret; |
} |
int synth_1to1_8bit_mono(real *bandPtr,unsigned char *samples) |
{ |
short samples_tmp[64]; |
short *tmp1 = samples_tmp; |
int i,ret; |
ret = synth_1to1(bandPtr,0,(unsigned char *) samples_tmp); |
for(i=0;i<32;i++) { |
*samples++ = conv16to8[*tmp1>>4]; |
*samples++ = conv16to8[*tmp1>>4]; |
tmp1 += 2; |
} |
return ret; |
} |
int synth_1to1_mono(real *bandPtr,unsigned char *samples) |
{ |
int i,ret = synth_1to1(bandPtr,0,samples); |
for(i=0;i<32;i++) { |
((short *)samples)[1] = ((short *)samples)[0]; |
samples+=4; |
} |
return ret; |
} |
int synth_1to1(real *bandPtr,int channel,unsigned char *out) |
{ |
static real buffs[2][2][0x110]; |
static int bo = 1; |
short *samples = (short *) out; |
real *b0,(*buf)[0x110]; |
int clip = 0; |
int bo1; |
static const int step = 2; |
if(!channel) { |
bo--; |
bo &= 0xf; |
buf = buffs[0]; |
} |
else { |
samples++; |
buf = buffs[1]; |
} |
if(bo & 0x1) { |
b0 = buf[0]; |
bo1 = bo; |
dct64(buf[1]+((bo+1)&0xf),buf[0]+bo,bandPtr); |
} |
else { |
b0 = buf[1]; |
bo1 = bo+1; |
dct64(buf[0]+bo,buf[1]+bo+1,bandPtr); |
} |
{ |
register int j; |
real *window = decwin + 16 - bo1; |
for (j=16;j;j--,window+=0x10,samples+=step) |
{ |
real sum; |
sum = *window++ * *b0++; |
sum -= *window++ * *b0++; |
sum += *window++ * *b0++; |
sum -= *window++ * *b0++; |
sum += *window++ * *b0++; |
sum -= *window++ * *b0++; |
sum += *window++ * *b0++; |
sum -= *window++ * *b0++; |
sum += *window++ * *b0++; |
sum -= *window++ * *b0++; |
sum += *window++ * *b0++; |
sum -= *window++ * *b0++; |
sum += *window++ * *b0++; |
sum -= *window++ * *b0++; |
sum += *window++ * *b0++; |
sum -= *window++ * *b0++; |
WRITE_SAMPLE(samples,sum,clip); |
} |
{ |
real sum; |
sum = window[0x0] * b0[0x0]; |
sum += window[0x2] * b0[0x2]; |
sum += window[0x4] * b0[0x4]; |
sum += window[0x6] * b0[0x6]; |
sum += window[0x8] * b0[0x8]; |
sum += window[0xA] * b0[0xA]; |
sum += window[0xC] * b0[0xC]; |
sum += window[0xE] * b0[0xE]; |
WRITE_SAMPLE(samples,sum,clip); |
b0-=0x10,window-=0x20,samples+=step; |
} |
window += bo1<<1; |
for (j=15;j;j--,b0-=0x20,window-=0x10,samples+=step) |
{ |
real sum; |
sum = -*(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
WRITE_SAMPLE(samples,sum,clip); |
} |
} |
return clip; |
} |
/shark/trunk/ports/mpg123/dct64.c |
---|
0,0 → 1,168 |
/* |
* Discrete Cosine Tansform (DCT) for subband synthesis |
* |
* -funroll-loops (for gcc) will remove the loops for better performance |
* using loops in the source-code enhances readabillity |
*/ |
/* |
* TODO: write an optimized version for the down-sampling modes |
* (in these modes the bands 16-31 (2:1) or 8-31 (4:1) are zero |
*/ |
#include "mpg123.h" |
void dct64(real *out0,real *out1,real *samples) |
{ |
real bufs[64]; |
{ |
register int i,j; |
register real *b1,*b2,*bs,*costab; |
b1 = samples; |
bs = bufs; |
costab = pnts[0]+16; |
b2 = b1 + 32; |
for(i=15;i>=0;i--) |
*bs++ = (*b1++ + *--b2); |
for(i=15;i>=0;i--) |
*bs++ = (*--b2 - *b1++) * *--costab; |
b1 = bufs; |
costab = pnts[1]+8; |
b2 = b1 + 16; |
{ |
for(i=7;i>=0;i--) |
*bs++ = (*b1++ + *--b2); |
for(i=7;i>=0;i--) |
*bs++ = (*--b2 - *b1++) * *--costab; |
b2 += 32; |
costab += 8; |
for(i=7;i>=0;i--) |
*bs++ = (*b1++ + *--b2); |
for(i=7;i>=0;i--) |
*bs++ = (*b1++ - *--b2) * *--costab; |
b2 += 32; |
} |
bs = bufs; |
costab = pnts[2]; |
b2 = b1 + 8; |
for(j=2;j;j--) |
{ |
for(i=3;i>=0;i--) |
*bs++ = (*b1++ + *--b2); |
for(i=3;i>=0;i--) |
*bs++ = (*--b2 - *b1++) * costab[i]; |
b2 += 16; |
for(i=3;i>=0;i--) |
*bs++ = (*b1++ + *--b2); |
for(i=3;i>=0;i--) |
*bs++ = (*b1++ - *--b2) * costab[i]; |
b2 += 16; |
} |
b1 = bufs; |
costab = pnts[3]; |
b2 = b1 + 4; |
for(j=4;j;j--) |
{ |
*bs++ = (*b1++ + *--b2); |
*bs++ = (*b1++ + *--b2); |
*bs++ = (*--b2 - *b1++) * costab[1]; |
*bs++ = (*--b2 - *b1++) * costab[0]; |
b2 += 8; |
*bs++ = (*b1++ + *--b2); |
*bs++ = (*b1++ + *--b2); |
*bs++ = (*b1++ - *--b2) * costab[1]; |
*bs++ = (*b1++ - *--b2) * costab[0]; |
b2 += 8; |
} |
bs = bufs; |
costab = pnts[4]; |
for(j=8;j;j--) |
{ |
real v0,v1; |
v0=*b1++; v1 = *b1++; |
*bs++ = (v0 + v1); |
*bs++ = (v0 - v1) * (*costab); |
v0=*b1++; v1 = *b1++; |
*bs++ = (v0 + v1); |
*bs++ = (v1 - v0) * (*costab); |
} |
} |
{ |
register real *b1; |
register int i; |
for(b1=bufs,i=8;i;i--,b1+=4) |
b1[2] += b1[3]; |
for(b1=bufs,i=4;i;i--,b1+=8) |
{ |
b1[4] += b1[6]; |
b1[6] += b1[5]; |
b1[5] += b1[7]; |
} |
for(b1=bufs,i=2;i;i--,b1+=16) |
{ |
b1[8] += b1[12]; |
b1[12] += b1[10]; |
b1[10] += b1[14]; |
b1[14] += b1[9]; |
b1[9] += b1[13]; |
b1[13] += b1[11]; |
b1[11] += b1[15]; |
} |
} |
out0[0x10*16] = bufs[0]; |
out0[0x10*15] = bufs[16+0] + bufs[16+8]; |
out0[0x10*14] = bufs[8]; |
out0[0x10*13] = bufs[16+8] + bufs[16+4]; |
out0[0x10*12] = bufs[4]; |
out0[0x10*11] = bufs[16+4] + bufs[16+12]; |
out0[0x10*10] = bufs[12]; |
out0[0x10* 9] = bufs[16+12] + bufs[16+2]; |
out0[0x10* 8] = bufs[2]; |
out0[0x10* 7] = bufs[16+2] + bufs[16+10]; |
out0[0x10* 6] = bufs[10]; |
out0[0x10* 5] = bufs[16+10] + bufs[16+6]; |
out0[0x10* 4] = bufs[6]; |
out0[0x10* 3] = bufs[16+6] + bufs[16+14]; |
out0[0x10* 2] = bufs[14]; |
out0[0x10* 1] = bufs[16+14] + bufs[16+1]; |
out0[0x10* 0] = bufs[1]; |
out1[0x10* 0] = bufs[1]; |
out1[0x10* 1] = bufs[16+1] + bufs[16+9]; |
out1[0x10* 2] = bufs[9]; |
out1[0x10* 3] = bufs[16+9] + bufs[16+5]; |
out1[0x10* 4] = bufs[5]; |
out1[0x10* 5] = bufs[16+5] + bufs[16+13]; |
out1[0x10* 6] = bufs[13]; |
out1[0x10* 7] = bufs[16+13] + bufs[16+3]; |
out1[0x10* 8] = bufs[3]; |
out1[0x10* 9] = bufs[16+3] + bufs[16+11]; |
out1[0x10*10] = bufs[11]; |
out1[0x10*11] = bufs[16+11] + bufs[16+7]; |
out1[0x10*12] = bufs[7]; |
out1[0x10*13] = bufs[16+7] + bufs[16+15]; |
out1[0x10*14] = bufs[15]; |
out1[0x10*15] = bufs[16+15]; |
} |
/shark/trunk/ports/mpg123/decode_2to1.c |
---|
0,0 → 1,176 |
/* |
* Mpeg Layer-1,2,3 audio decoder |
* ------------------------------ |
* copyright (c) 1995 by Michael Hipp, All rights reserved. See also 'README' |
* version for slower machines .. decodes only every second sample |
* sounds like 24000,22050 or 16000 kHz .. (depending on original sample freq.) |
* |
*/ |
#include <stdlib.h> |
#include <math.h> |
#include <string.h> |
#include "mpg123.h" |
#define WRITE_SAMPLE(samples,sum,clip) \ |
if( (sum) > 32767.0) { *(samples) = 0x7fff; (clip)++; } \ |
else if( (sum) < -32768.0) { *(samples) = -0x8000; (clip)++; } \ |
else { *(samples) = sum; } |
int synth_2to1_8bit(real *bandPtr,int channel,unsigned char *samples) |
{ |
short samples_tmp[32]; |
short *tmp1 = samples_tmp + channel; |
int i,ret; |
samples += channel; |
ret = synth_2to1(bandPtr,channel,(unsigned char *) samples_tmp); |
for(i=0;i<16;i++) { |
*samples = conv16to8[*tmp1>>4]; |
samples += 2; |
tmp1 += 2; |
} |
return ret; |
} |
int synth_2to1_8bit_mono(real *bandPtr,unsigned char *samples) |
{ |
short samples_tmp[32]; |
short *tmp1 = samples_tmp; |
int i,ret; |
ret = synth_2to1(bandPtr,0,(unsigned char *) samples_tmp); |
for(i=0;i<16;i++) { |
*samples++ = conv16to8[*tmp1>>4]; |
*samples++ = conv16to8[*tmp1>>4]; |
tmp1 += 2; |
} |
return ret; |
} |
int synth_2to1_mono(real *bandPtr,unsigned char *samples) |
{ |
int i,ret = synth_2to1(bandPtr,0,samples); |
for(i=0;i<16;i++) { |
((short *)samples)[1] = ((short *)samples)[0]; |
samples+=4; |
} |
return ret; |
} |
int synth_2to1(real *bandPtr,int channel,unsigned char *out) |
{ |
static real buffs[2][2][0x110]; |
static const int step = 2; |
static int bo = 1; |
short *samples = (short *) out; |
real *b0,(*buf)[0x110]; |
int clip = 0; |
int bo1; |
if(!channel) { |
bo--; |
bo &= 0xf; |
buf = buffs[0]; |
} |
else { |
samples++; |
buf = buffs[1]; |
} |
if(bo & 0x1) { |
b0 = buf[0]; |
bo1 = bo; |
dct64(buf[1]+((bo+1)&0xf),buf[0]+bo,bandPtr); |
} |
else { |
b0 = buf[1]; |
bo1 = bo+1; |
dct64(buf[0]+bo,buf[1]+bo+1,bandPtr); |
} |
{ |
register int j; |
real *window = decwin + 16 - bo1; |
for (j=8;j;j--,b0+=0x10,window+=0x30) |
{ |
real sum; |
sum = *window++ * *b0++; |
sum -= *window++ * *b0++; |
sum += *window++ * *b0++; |
sum -= *window++ * *b0++; |
sum += *window++ * *b0++; |
sum -= *window++ * *b0++; |
sum += *window++ * *b0++; |
sum -= *window++ * *b0++; |
sum += *window++ * *b0++; |
sum -= *window++ * *b0++; |
sum += *window++ * *b0++; |
sum -= *window++ * *b0++; |
sum += *window++ * *b0++; |
sum -= *window++ * *b0++; |
sum += *window++ * *b0++; |
sum -= *window++ * *b0++; |
WRITE_SAMPLE(samples,sum,clip); samples += step; |
#if 0 |
WRITE_SAMPLE(samples,sum,clip); samples += step; |
#endif |
} |
{ |
real sum; |
sum = window[0x0] * b0[0x0]; |
sum += window[0x2] * b0[0x2]; |
sum += window[0x4] * b0[0x4]; |
sum += window[0x6] * b0[0x6]; |
sum += window[0x8] * b0[0x8]; |
sum += window[0xA] * b0[0xA]; |
sum += window[0xC] * b0[0xC]; |
sum += window[0xE] * b0[0xE]; |
WRITE_SAMPLE(samples,sum,clip); samples += step; |
#if 0 |
WRITE_SAMPLE(samples,sum,clip); samples += step; |
#endif |
b0-=0x20,window-=0x40; |
} |
window += bo1<<1; |
for (j=7;j;j--,b0-=0x30,window-=0x30) |
{ |
real sum; |
sum = -*(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
WRITE_SAMPLE(samples,sum,clip); samples += step; |
#if 0 |
WRITE_SAMPLE(samples,sum,clip); samples += step; |
#endif |
} |
} |
return clip; |
} |
/shark/trunk/ports/mpg123/decode_4to1.c |
---|
0,0 → 1,183 |
/* |
* Mpeg Layer-1,2,3 audio decoder |
* ------------------------------ |
* copyright (c) 1995,1996,1997 by Michael Hipp, All rights reserved. |
* See also 'README' |
* version for slower machines .. decodes only every fourth sample |
* dunno why it sounds THIS annoying (maybe we should adapt the window?) |
* absolutely not optimized for this operation |
*/ |
#include <stdlib.h> |
#include <math.h> |
#include <string.h> |
#include "mpg123.h" |
#define WRITE_SAMPLE(samples,sum,clip) \ |
if( (sum) > 32767.0) { *(samples) = 0x7fff; (clip)++; } \ |
else if( (sum) < -32768.0) { *(samples) = -0x8000; (clip)++; } \ |
else { *(samples) = sum; } |
int synth_4to1_8bit(real *bandPtr,int channel,unsigned char *samples) |
{ |
short samples_tmp[16]; |
short *tmp1 = samples_tmp + channel; |
int i,ret; |
samples += channel; |
ret = synth_4to1(bandPtr,channel,(unsigned char *) samples_tmp); |
for(i=0;i<8;i++) { |
*samples = conv16to8[*tmp1>>4]; |
samples += 2; |
tmp1 += 2; |
} |
return ret; |
} |
int synth_4to1_8bit_mono(real *bandPtr,unsigned char *samples) |
{ |
short samples_tmp[16]; |
short *tmp1 = samples_tmp; |
int i,ret; |
ret = synth_4to1(bandPtr,0,(unsigned char *) samples_tmp); |
for(i=0;i<8;i++) { |
*samples++ = conv16to8[*tmp1>>4]; |
*samples++ = conv16to8[*tmp1>>4]; |
tmp1 += 2; |
} |
return ret; |
} |
int synth_4to1_mono(real *bandPtr,unsigned char *samples) |
{ |
int i,ret = synth_4to1(bandPtr,0,samples); |
for(i=0;i<8;i++) { |
((short *)samples)[1] = ((short *)samples)[0]; |
samples+=4; |
} |
return ret; |
} |
int synth_4to1(real *bandPtr,int channel,unsigned char *out) |
{ |
static real buffs[2][2][0x110]; |
static const int step = 2; |
static int bo = 1; |
short *samples = (short *) out; |
real *b0,(*buf)[0x110]; |
int clip = 0; |
int bo1; |
if(!channel) { |
bo--; |
bo &= 0xf; |
buf = buffs[0]; |
} |
else { |
samples++; |
buf = buffs[1]; |
} |
if(bo & 0x1) { |
b0 = buf[0]; |
bo1 = bo; |
dct64(buf[1]+((bo+1)&0xf),buf[0]+bo,bandPtr); |
} |
else { |
b0 = buf[1]; |
bo1 = bo+1; |
dct64(buf[0]+bo,buf[1]+bo+1,bandPtr); |
} |
{ |
register int j; |
real *window = decwin + 16 - bo1; |
for (j=4;j;j--,b0+=0x30,window+=0x70) |
{ |
real sum; |
sum = *window++ * *b0++; |
sum -= *window++ * *b0++; |
sum += *window++ * *b0++; |
sum -= *window++ * *b0++; |
sum += *window++ * *b0++; |
sum -= *window++ * *b0++; |
sum += *window++ * *b0++; |
sum -= *window++ * *b0++; |
sum += *window++ * *b0++; |
sum -= *window++ * *b0++; |
sum += *window++ * *b0++; |
sum -= *window++ * *b0++; |
sum += *window++ * *b0++; |
sum -= *window++ * *b0++; |
sum += *window++ * *b0++; |
sum -= *window++ * *b0++; |
WRITE_SAMPLE(samples,sum,clip); samples += step; |
#if 0 |
WRITE_SAMPLE(samples,sum,clip); samples += step; |
WRITE_SAMPLE(samples,sum,clip); samples += step; |
WRITE_SAMPLE(samples,sum,clip); samples += step; |
#endif |
} |
{ |
real sum; |
sum = window[0x0] * b0[0x0]; |
sum += window[0x2] * b0[0x2]; |
sum += window[0x4] * b0[0x4]; |
sum += window[0x6] * b0[0x6]; |
sum += window[0x8] * b0[0x8]; |
sum += window[0xA] * b0[0xA]; |
sum += window[0xC] * b0[0xC]; |
sum += window[0xE] * b0[0xE]; |
WRITE_SAMPLE(samples,sum,clip); samples += step; |
#if 0 |
WRITE_SAMPLE(samples,sum,clip); samples += step; |
WRITE_SAMPLE(samples,sum,clip); samples += step; |
WRITE_SAMPLE(samples,sum,clip); samples += step; |
#endif |
b0-=0x40,window-=0x80; |
} |
window += bo1<<1; |
for (j=3;j;j--,b0-=0x50,window-=0x70) |
{ |
real sum; |
sum = -*(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
sum -= *(--window) * *b0++; |
WRITE_SAMPLE(samples,sum,clip); samples += step; |
#if 0 |
WRITE_SAMPLE(samples,sum,clip); samples += step; |
WRITE_SAMPLE(samples,sum,clip); samples += step; |
WRITE_SAMPLE(samples,sum,clip); samples += step; |
#endif |
} |
} |
return clip; |
} |
/shark/trunk/ports/mpg123/tabinit.c |
---|
0,0 → 1,106 |
#include "mpg123.h" |
real decwin[512+32]; |
static real cos64[16],cos32[8],cos16[4],cos8[2],cos4[1]; |
real *pnts[] = { cos64,cos32,cos16,cos8,cos4 }; |
static unsigned char conv16to8_buf[4096]; |
unsigned char *conv16to8 = conv16to8_buf + 2048; |
static long intwinbase[] = { |
0, -1, -1, -1, -1, -1, -1, -2, -2, -2, |
-2, -3, -3, -4, -4, -5, -5, -6, -7, -7, |
-8, -9, -10, -11, -13, -14, -16, -17, -19, -21, |
-24, -26, -29, -31, -35, -38, -41, -45, -49, -53, |
-58, -63, -68, -73, -79, -85, -91, -97, -104, -111, |
-117, -125, -132, -139, -147, -154, -161, -169, -176, -183, |
-190, -196, -202, -208, -213, -218, -222, -225, -227, -228, |
-228, -227, -224, -221, -215, -208, -200, -189, -177, -163, |
-146, -127, -106, -83, -57, -29, 2, 36, 72, 111, |
153, 197, 244, 294, 347, 401, 459, 519, 581, 645, |
711, 779, 848, 919, 991, 1064, 1137, 1210, 1283, 1356, |
1428, 1498, 1567, 1634, 1698, 1759, 1817, 1870, 1919, 1962, |
2001, 2032, 2057, 2075, 2085, 2087, 2080, 2063, 2037, 2000, |
1952, 1893, 1822, 1739, 1644, 1535, 1414, 1280, 1131, 970, |
794, 605, 402, 185, -45, -288, -545, -814, -1095, -1388, |
-1692, -2006, -2330, -2663, -3004, -3351, -3705, -4063, -4425, -4788, |
-5153, -5517, -5879, -6237, -6589, -6935, -7271, -7597, -7910, -8209, |
-8491, -8755, -8998, -9219, -9416, -9585, -9727, -9838, -9916, -9959, |
-9966, -9935, -9863, -9750, -9592, -9389, -9139, -8840, -8492, -8092, |
-7640, -7134, -6574, -5959, -5288, -4561, -3776, -2935, -2037, -1082, |
-70, 998, 2122, 3300, 4533, 5818, 7154, 8540, 9975, 11455, |
12980, 14548, 16155, 17799, 19478, 21189, 22929, 24694, 26482, 28289, |
30112, 31947, 33791, 35640, 37489, 39336, 41176, 43006, 44821, 46617, |
48390, 50137, 51853, 53534, 55178, 56778, 58333, 59838, 61289, 62684, |
64019, 65290, 66494, 67629, 68692, 69679, 70590, 71420, 72169, 72835, |
73415, 73908, 74313, 74630, 74856, 74992, 75038 }; |
void make_decode_tables(long scaleval) |
{ |
int i,j,k,kr,divv; |
real *table,*costab; |
for(i=0;i<5;i++) |
{ |
kr=0x10>>i; divv=0x40>>i; |
costab = pnts[i]; |
for(k=0;k<kr;k++) |
costab[k] = 1.0 / (2.0 * cos(M_PI * ((double) k * 2.0 + 1.0) / (double) divv)); |
} |
table = decwin; |
scaleval = -scaleval; |
for(i=0,j=0;i<256;i++,j++,table+=32) |
{ |
if(table < decwin+512+16) |
table[16] = table[0] = (double) intwinbase[j] / 65536.0 * (double) scaleval; |
if(i % 32 == 31) |
table -= 1023; |
if(i % 64 == 63) |
scaleval = - scaleval; |
} |
for( /* i=256 */ ;i<512;i++,j--,table+=32) |
{ |
if(table < decwin+512+16) |
table[16] = table[0] = (double) intwinbase[j] / 65536.0 * (double) scaleval; |
if(i % 32 == 31) |
table -= 1023; |
if(i % 64 == 63) |
scaleval = - scaleval; |
} |
} |
void make_conv16to8_table(int mode) |
{ |
int i; |
unsigned char c; |
if(mode == AUDIO_FORMAT_ULAW_8) { |
double m=127.0 / log(256.0); |
for(i=-2048;i<2048;i++) { |
/* dunno whether this is a valid transformation rule ?!?!? */ |
if(i < 0) |
c = 127 - (int) (log( 1.0 - 255.0 * (double) i*16.0 / 32767.0 ) * m); |
else |
c = 255 - (int) (log( 1.0 + 255.0 * (double) i*16.0 / 32767.0 ) * m); |
conv16to8[i] = c; |
} |
} |
else if(mode == AUDIO_FORMAT_SIGNED_8) { |
for(i=-2048;i<2048;i++) { |
conv16to8[i] = i>>4; |
} |
} |
else if(mode == AUDIO_FORMAT_UNSIGNED_8) { |
for(i=-2048;i<2048;i++) { |
conv16to8[i] = (i>>4)+128; |
} |
} |
else { |
for(i=-2048;i<2048;i++) { |
conv16to8[i] = 0; |
} |
} |
} |
/shark/trunk/ports/mpg123/audio.c |
---|
0,0 → 1,797 |
/* |
* simple audio Lib .. |
* copyrights (c) 1994,1995,1996 by Michael Hipp |
* SGI audio support copyrights (c) 1995 by Thomas Woerner |
* copy policy: GPL V2.0 |
*/ |
#include <sys/types.h> |
#include <stdio.h> |
#include <unistd.h> |
#include <fcntl.h> |
#ifdef SOLARIS |
#include <stropts.h> |
#include <sys/conf.h> |
#endif |
#include "mpg123.h" |
extern int outburst; |
void audio_info_struct_init(struct audio_info_struct *ai) |
{ |
#ifdef AUDIO_USES_FD |
ai->fn = -1; |
#endif |
#ifdef SGI |
#if 0 |
ALconfig config; |
ALport port; |
#endif |
#endif |
ai->rate = -1; |
ai->gain = -1; |
ai->output = -1; |
ai->device = NULL; |
ai->channels = -1; |
ai->format = -1; |
} |
#ifdef OS2 |
#include <stdlib.h> |
#include <os2.h> |
#define INCL_OS2MM |
#include <os2me.h> |
#define BUFNUM 20 |
#define BUFSIZE 16384 |
#endif |
#ifdef VOXWARE |
#include <sys/ioctl.h> |
#ifdef LINUX |
#include <linux/soundcard.h> |
#else |
#include <machine/soundcard.h> |
#endif |
int audio_open(struct audio_info_struct *ai) |
{ |
if(!ai) |
return -1; |
if(!ai->device) |
ai->device = "/dev/dsp"; |
ai->fn = open(ai->device,O_WRONLY); |
if(ai->fn < 0) |
{ |
fprintf(stderr,"Can't open %s!\n",ai->device); |
exit(1); |
} |
ioctl(ai->fn, SNDCTL_DSP_GETBLKSIZE, &outburst); |
if(outburst > MAXOUTBURST) |
outburst = MAXOUTBURST; |
if(audio_reset_parameters(ai) < 0) { |
close(ai->fn); |
return -1; |
} |
if(ai->gain >= 0) { |
int e,mask; |
e = ioctl(ai->fn , SOUND_MIXER_READ_DEVMASK ,&mask); |
if(e < 0) { |
fprintf(stderr,"audio/gain: Can't get audio device features list.\n"); |
} |
else if(mask & SOUND_MASK_PCM) { |
int gain = (ai->gain<<8)|(ai->gain); |
e = ioctl(ai->fn, SOUND_MIXER_WRITE_PCM , &gain); |
} |
else if(!(mask & SOUND_MASK_VOLUME)) { |
fprintf(stderr,"audio/gain: setable Volume/PCM-Level not supported by your audio device: %#04x\n",mask); |
} |
else { |
int gain = (ai->gain<<8)|(ai->gain); |
e = ioctl(ai->fn, SOUND_MIXER_WRITE_VOLUME , &gain); |
} |
} |
return ai->fn; |
} |
int audio_reset_parameters(struct audio_info_struct *ai) |
{ |
int ret; |
ret = ioctl(ai->fn,SNDCTL_DSP_RESET,NULL); |
if(ret >= 0) |
ret = audio_set_format(ai); |
if(ret >= 0) |
ret = audio_set_channels(ai); |
if(ret >= 0) |
ret = audio_set_rate(ai); |
return ret; |
} |
int audio_rate_best_match(struct audio_info_struct *ai) |
{ |
int ret,dsp_rate; |
if(!ai || ai->fn < 0 || ai->rate < 0) |
return -1; |
dsp_rate = ai->rate; |
ret = ioctl(ai->fn, SNDCTL_DSP_SPEED,&dsp_rate); |
if(ret < 0) |
return ret; |
ai->rate = dsp_rate; |
return 0; |
} |
int audio_set_rate(struct audio_info_struct *ai) |
{ |
int dsp_rate; |
if(ai->rate >= 0) { |
dsp_rate = ai->rate; |
return ioctl(ai->fn, SNDCTL_DSP_SPEED,&dsp_rate); |
} |
return 0; |
} |
int audio_set_channels(struct audio_info_struct *ai) |
{ |
int chan = ai->channels - 1; |
if(ai->channels < 0) |
return 0; |
return ioctl(ai->fn, SNDCTL_DSP_STEREO, &chan); |
} |
int audio_set_format(struct audio_info_struct *ai) |
{ |
int sample_size,fmts; |
if(ai->format == -1) |
return 0; |
switch(ai->format) { |
case AUDIO_FORMAT_SIGNED_16: |
default: |
fmts = AFMT_S16_LE; |
sample_size = 16; |
break; |
case AUDIO_FORMAT_UNSIGNED_8: |
fmts = AFMT_U8; |
sample_size = 8; |
break; |
case AUDIO_FORMAT_SIGNED_8: |
fmts = AFMT_S8; |
sample_size = 8; |
break; |
case AUDIO_FORMAT_ULAW_8: |
fmts = AFMT_MU_LAW; |
sample_size = 8; |
break; |
} |
if(ioctl(ai->fn, SNDCTL_DSP_SAMPLESIZE,&sample_size) < 0) |
return -1; |
return ioctl(ai->fn, SNDCTL_DSP_SETFMT, &fmts); |
} |
int audio_get_formats(struct audio_info_struct *ai) |
{ |
int ret = 0; |
int fmts; |
if(ioctl(ai->fn,SNDCTL_DSP_GETFMTS,&fmts) < 0) |
return -1; |
if(fmts & AFMT_MU_LAW) |
ret |= AUDIO_FORMAT_ULAW_8; |
if(fmts & AFMT_S16_LE) |
ret |= AUDIO_FORMAT_SIGNED_16; |
if(fmts & AFMT_U8) |
ret |= AUDIO_FORMAT_UNSIGNED_8; |
if(fmts & AFMT_S8) |
ret |= AUDIO_FORMAT_SIGNED_8; |
return ret; |
} |
int audio_play_samples(struct audio_info_struct *ai,unsigned char *buf,int len) |
{ |
return write(ai->fn,buf,len); |
} |
int audio_close(struct audio_info_struct *ai) |
{ |
close (ai->fn); |
return 0; |
} |
#elif defined(SOLARIS) || defined(SUNOS) |
#include <sys/filio.h> |
#ifdef SUNOS |
#include <sun/audioio.h> |
#else |
#include <sys/audioio.h> |
#endif |
int audio_open(struct audio_info_struct *ai) |
{ |
audio_info_t ainfo; |
ai->fn = open("/dev/audio",O_WRONLY); |
if(ai->fn < 0) |
return ai->fn; |
#ifdef SUNOS |
{ |
int type; |
if(ioctl(ai->fn, AUDIO_GETDEV, &type) == -1) |
return -1; |
if(type == AUDIO_DEV_UNKNOWN || type == AUDIO_DEV_AMD) |
return -1; |
} |
#else |
#if 0 |
{ |
struct audio_device ad; |
if(ioctl(ai->fn, AUDIO_GETDEV, &ad) == -1) |
return -1; |
fprintf(stderr,"%s\n",ad.name); |
if(strstr(ad.name,"CS4231")) |
fprintf(stderr,"Warning: Your machine can't play full 44.1Khz stereo.\n"); |
if(!strstr(ad.name,"dbri") && !strstr(ad.name,"CS4231")) |
fprintf(stderr,"Warning: Unknown sound system %s. But we try it.\n",ad.name); |
} |
#endif |
#endif |
if(audio_reset_parameters(ai) < 0) { |
return -1; |
} |
if(ioctl(ai->fn, AUDIO_GETINFO, &ainfo) == -1) |
return -1; |
switch(ai->output) |
{ |
case AUDIO_OUT_INTERNAL_SPEAKER: |
ainfo.play.port = AUDIO_SPEAKER; |
break; |
case AUDIO_OUT_HEADPHONES: |
ainfo.play.port = AUDIO_HEADPHONE; |
break; |
case AUDIO_OUT_LINE_OUT: |
ainfo.play.port = AUDIO_LINE_OUT; |
break; |
} |
if(ai->gain != -1) |
ainfo.play.gain = ai->gain; |
if(ioctl(ai->fn, AUDIO_SETINFO, &ainfo) == -1) |
return -1; |
return ai->fn; |
} |
int audio_reset_parameters(struct audio_info_struct *ai) |
{ |
int ret; |
ret = audio_set_format(ai); |
if(ret >= 0) |
ret = audio_set_channels(ai); |
if(ret >= 0) |
ret = audio_set_rate(ai); |
return ret; |
} |
int audio_rate_best_match(struct audio_info_struct *ai) |
{ |
return 0; |
} |
int audio_set_rate(struct audio_info_struct *ai) |
{ |
audio_info_t ainfo; |
if(ai->rate != -1) |
{ |
if(ioctl(ai->fn, AUDIO_GETINFO, &ainfo) == -1) |
return -1; |
ainfo.play.sample_rate = ai->rate; |
if(ioctl(ai->fn, AUDIO_SETINFO, &ainfo) == -1) |
return -1; |
return 0; |
} |
return -1; |
} |
int audio_set_channels(struct audio_info_struct *ai) |
{ |
audio_info_t ainfo; |
if(ioctl(ai->fn, AUDIO_GETINFO, &ainfo) == -1) |
return -1; |
ainfo.play.channels = ai->channels; |
if(ioctl(ai->fn, AUDIO_SETINFO, &ainfo) == -1) |
return -1; |
return 0; |
} |
int audio_set_format(struct audio_info_struct *ai) |
{ |
audio_info_t ainfo; |
if(ioctl(ai->fn, AUDIO_GETINFO, &ainfo) == -1) |
return -1; |
switch(ai->format) { |
case -1: |
case AUDIO_FORMAT_SIGNED_16: |
default: |
ainfo.play.encoding = AUDIO_ENCODING_LINEAR; |
ainfo.play.precision = 16; |
break; |
case AUDIO_FORMAT_UNSIGNED_8: |
#ifndef SUNOS |
ainfo.play.encoding = AUDIO_ENCODING_LINEAR8; |
ainfo.play.precision = 8; |
break; |
#endif |
case AUDIO_FORMAT_SIGNED_8: |
fprintf(stderr,"Linear signed 8 bit not supported!\n"); |
return -1; |
case AUDIO_FORMAT_ULAW_8: |
ainfo.play.encoding = AUDIO_ENCODING_ULAW; |
ainfo.play.precision = 8; |
break; |
case AUDIO_FORMAT_ALAW_8: |
ainfo.play.encoding = AUDIO_ENCODING_ALAW; |
ainfo.play.precision = 8; |
break; |
} |
if(ioctl(ai->fn, AUDIO_SETINFO, &ainfo) == -1) |
return -1; |
return 0; |
} |
int audio_get_formats(struct audio_info_struct *ai) |
{ |
return AUDIO_FORMAT_SIGNED_16|AUDIO_FORMAT_ULAW_8; |
} |
int audio_play_samples(struct audio_info_struct *ai,unsigned char *buf,int len) |
{ |
return write(ai->fn,buf,len); |
} |
int audio_close(struct audio_info_struct *ai) |
{ |
close (ai->fn); |
return 0; |
} |
#ifdef SOLARIS |
void audio_queueflush (struct audio_info_struct *ai) |
{ |
ioctl (ai->fn, I_FLUSH, FLUSHRW); |
} |
#endif |
#elif defined(HPUX) |
#include <sys/audio.h> |
int audio_open(struct audio_info_struct *ai) |
{ |
struct audio_describe ades; |
struct audio_gain again; |
int i,audio; |
ai->fn = open("/dev/audio",O_RDWR); |
if(ai->fn < 0) |
return -1; |
ioctl(ai->fn,AUDIO_DESCRIBE,&ades); |
if(ai->gain != -1) |
{ |
if(ai->gain > ades.max_transmit_gain) |
{ |
fprintf(stderr,"your gainvalue was to high -> set to maximum.\n"); |
ai->gain = ades.max_transmit_gain; |
} |
if(ai->gain < ades.min_transmit_gain) |
{ |
fprintf(stderr,"your gainvalue was to low -> set to minimum.\n"); |
ai->gain = ades.min_transmit_gain; |
} |
again.channel_mask = AUDIO_CHANNEL_0 | AUDIO_CHANNEL_1; |
ioctl(ai->fn,AUDIO_GET_GAINS,&again); |
again.cgain[0].transmit_gain = ai->gain; |
again.cgain[1].transmit_gain = ai->gain; |
again.channel_mask = AUDIO_CHANNEL_0 | AUDIO_CHANNEL_1; |
ioctl(ai->fn,AUDIO_SET_GAINS,&again); |
} |
if(ai->output != -1) |
{ |
if(ai->output == AUDIO_OUT_INTERNAL_SPEAKER) |
ioctl(ai->fn,AUDIO_SET_OUTPUT,AUDIO_OUT_SPEAKER); |
else if(ai->output == AUDIO_OUT_HEADPHONES) |
ioctl(ai->fn,AUDIO_SET_OUTPUT,AUDIO_OUT_HEADPHONE); |
else if(ai->output == AUDIO_OUT_LINE_OUT) |
ioctl(ai->fn,AUDIO_SET_OUTPUT,AUDIO_OUT_LINE); |
} |
if(ai->rate == -1) |
ai->rate = 44100; |
for(i=0;i<ades.nrates;i++) |
{ |
if(ai->rate == ades.sample_rate[i]) |
break; |
} |
if(i == ades.nrates) |
{ |
fprintf(stderr,"Can't set sample-rate to %ld.\n",ai->rate); |
i = 0; |
} |
if(audio_reset_parameters(ai) < 0) |
return -1; |
return ai->fn; |
} |
int audio_reset_parameters(struct audio_info_struct *ai) |
{ |
int ret; |
ret = audio_set_format(ai); |
if(ret >= 0) |
ret = audio_set_channels(ai); |
if(ret >= 0) |
ret = audio_set_rate(ai); |
return ret; |
} |
int audio_rate_best_match(struct audio_info_struct *ai) |
{ |
return 0; |
} |
int audio_set_rate(struct audio_info_struct *ai) |
{ |
if(ai->rate >= 0) |
return ioctl(ai->fn,AUDIO_SET_SAMPLE_RATE,ai->rate); |
return 0; |
} |
int audio_set_channels(struct audio_info_struct *ai) |
{ |
return ioctl(ai->fn,AUDIO_SET_CHANNELS,ai->channels); |
} |
int audio_set_format(struct audio_info_struct *ai) |
{ |
int fmt; |
switch(ai->format) { |
case -1: |
case AUDIO_FORMAT_SIGNED_16: |
default: |
fmt = AUDIO_FORMAT_LINEAR16BIT; |
break; |
case AUDIO_FORMAT_UNSIGNED_8: |
fprintf(stderr,"unsigned 8 bit linear not supported\n"); |
return -1; |
case AUDIO_FORMAT_SIGNED_8: |
fprintf(stderr,"signed 8 bit linear not supported\n"); |
return -1; |
case AUDIO_FORMAT_ALAW_8: |
fmt = AUDIO_FORMAT_ALAW; |
break; |
case AUDIO_FORMAT_ULAW_8: |
fmt = AUDIO_FORMAT_ULAW; |
break; |
} |
return ioctl(ai->fn,AUDIO_SET_DATA_FORMAT,fmt); |
} |
int audio_get_formats(struct audio_info_struct *ai) |
{ |
return AUDIO_FORMAT_SIGNED_16; |
} |
int audio_play_samples(struct audio_info_struct *ai,unsigned char *buf,int len) |
{ |
return write(ai->fn,buf,len); |
} |
int audio_close(struct audio_info_struct *ai) |
{ |
close (ai->fn); |
return 0; |
} |
#elif defined(SGI) |
int audio_open(struct audio_info_struct *ai) |
{ |
ai->config = ALnewconfig(); |
if(ai->channels == 2) |
ALsetchannels(ai->config, AL_STEREO); |
else |
ALsetchannels(ai->config, AL_MONO); |
ALsetwidth(ai->config, AL_SAMPLE_16); |
ALsetqueuesize(ai->config, 131069); |
ai->port = ALopenport("mpg132", "w", ai->config); |
if(ai->port == NULL){ |
fprintf(stderr, "Unable to open audio channel."); |
exit(-1); |
} |
audio_reset_parameters(ai); |
return 1; |
} |
int audio_reset_parameters(struct audio_info_struct *ai) |
{ |
int ret; |
ret = audio_set_format(ai); |
if(ret >= 0) |
ret = audio_set_channels(ai); |
if(ret >= 0) |
ret = audio_set_rate(ai); |
/* todo: Set new parameters here */ |
return ret; |
} |
int audio_rate_best_match(struct audio_info_struct *ai) |
{ |
return 0; |
} |
int audio_set_rate(struct audio_info_struct *ai) |
{ |
long params[2] = {AL_OUTPUT_RATE, 44100}; |
params[1] = ai->rate; |
ALsetparams(AL_DEFAULT_DEVICE, params, 2); |
return 0; |
} |
int audio_set_channels(struct audio_info_struct *ai) |
{ |
if(ai->channels == 2) |
ALsetchannels(ai->config, AL_STEREO); |
else |
ALsetchannels(ai->config, AL_MONO); |
return 0; |
} |
int audio_set_format(struct audio_info_struct *ai) |
{ |
return 0; |
} |
int audio_get_formats(struct audio_info_struct *ai) |
{ |
return AUDIO_FORMAT_SIGNED_16; |
} |
int audio_play_samples(struct audio_info_struct *ai,unsigned char *buf,int len) |
{ |
if(ai->format == AUDIO_FORMAT_SIGNED_8) |
ALwritesamps(ai->port, buf, len); |
else |
ALwritesamps(ai->port, buf, len>>1); |
return len; |
} |
int audio_close(struct audio_info_struct *ai) |
{ |
while(ALgetfilled(ai->port) > 0) |
sginap(1); |
ALcloseport(ai->port); |
ALfreeconfig(ai->config); |
return 0; |
} |
#elif defined(OS2) |
typedef struct { |
ULONG operation; |
ULONG operand1; |
ULONG operand2; |
ULONG operand3; |
} ple; |
MCI_WAVE_SET_PARMS msp; |
MCI_PLAY_PARMS mpp; |
int id, pos=0; |
ple pl[BUFNUM+2]; |
int audio_open(struct audio_info_struct *ai) |
{ |
char *buf[BUFNUM]; |
int i; |
ULONG rc; |
MCI_OPEN_PARMS mop; |
pl[0].operation = (ULONG)NOP_OPERATION; |
pl[0].operand1 = 0; |
pl[0].operand2 = 0; |
pl[0].operand3 = 0; |
for(i = 0; i < BUFNUM; i++) { |
buf[i] = (char*)malloc(BUFSIZE); |
memset(buf[i], 0, BUFSIZE); |
pl[i+1].operation = (ULONG)DATA_OPERATION; |
pl[i+1].operand1 = (ULONG)buf[i]; |
pl[i+1].operand2 = BUFSIZE/2; |
pl[i+1].operand3 = 0; |
} |
pl[BUFNUM+1].operation = (ULONG)BRANCH_OPERATION; |
pl[BUFNUM+1].operand1 = 0; |
pl[BUFNUM+1].operand2 = 1; |
pl[BUFNUM+1].operand3 = 0; |
mop.pszDeviceType = (PSZ)MCI_DEVTYPE_WAVEFORM_AUDIO_NAME; |
mop.pszElementName = (PSZ)&pl; |
rc = mciSendCommand(0, MCI_OPEN, MCI_WAIT |
| MCI_OPEN_PLAYLIST, (PVOID)&mop, 0); |
if (rc) { |
puts("open audio device failed!"); |
exit(1); |
} |
id = mop.usDeviceID; |
msp.usBitsPerSample = 16; |
rc = mciSendCommand(id, MCI_SET, MCI_WAIT | MCI_WAVE_SET_BITSPERSAMPLE, (PVOID)&msp, 0); |
return 0; |
} |
int audio_reset_parameters(struct audio_info_struct *ai) |
{ |
static int audio_initialized = FALSE, i; |
if (audio_initialized) { |
while (pl[pos].operand3 < pl[pos].operand2) _sleep2(125); |
for(i = 1; i <= BUFNUM; i++) { |
memset((char*)pl[i].operand1, 0, BUFSIZE); |
pl[i].operand2 = BUFSIZE; |
pl[i].operand3 = 0; |
} |
_sleep2(2000); |
mciSendCommand(id, MCI_STOP, MCI_WAIT, (PVOID)&mpp, 0); |
for(i = 1; i <= BUFNUM; i++) { |
memset((char*)pl[i].operand1, 0, BUFSIZE); |
pl[i].operand2 = BUFSIZE/2; |
pl[i].operand3 = 0; |
} |
pos = 0; |
} |
msp.ulSamplesPerSec = ai->rate; |
msp.usChannels = ai->channels; |
mciSendCommand(id, MCI_SET, MCI_WAIT |
| MCI_WAVE_SET_SAMPLESPERSEC |
| MCI_WAVE_SET_CHANNELS, (PVOID)&msp, 0); |
mciSendCommand(id, MCI_PLAY, 0, (PVOID)&mpp, 0); |
if(!audio_initialized) audio_initialized = TRUE; |
return 0; |
} |
int audio_rate_best_match(struct audio_info_struct *ai) |
{ |
return 0; |
} |
int audio_set_rate(struct audio_info_struct *ai) |
{ |
return 0; |
} |
int audio_play_samples(struct audio_info_struct *ai,unsigned char *buf,int len) |
{ |
pos = pos + 1; |
if (pos > BUFNUM) pos = 1; |
while (pl[pos].operand3 < pl[pos].operand2) _sleep2(125); |
memcpy((char*)pl[pos].operand1, buf, len); |
pl[pos].operand2 = len; |
pl[pos].operand3 = 0; |
return len; |
} |
int audio_close(struct audio_info_struct *ai) |
{ |
ULONG rc; |
pl[pos].operation = (ULONG)EXIT_OPERATION; |
pl[pos].operand2 = 0; |
pl[pos].operand3 = 0; |
pos = pos - 1; |
if(pos == 0) pos = BUFNUM; |
while (pl[pos].operand3 < pl[pos].operand2) _sleep2(250); |
_sleep2(2000); |
rc = mciSendCommand(id, MCI_CLOSE, MCI_WAIT, (PVOID)NULL, 0); |
return 0; |
} |
#else |
int audio_open(struct audio_info_struct *ai) |
{ |
fprintf(stderr,"No audio device support compiled into this binary (use -s).\n"); |
return -1; |
} |
int audio_reset_parameters(struct audio_info_struct *ai) |
{ |
return 0; |
} |
int audio_rate_best_match(struct audio_info_struct *ai) |
{ |
return 0; |
} |
int audio_set_rate(struct audio_info_struct *ai) |
{ |
return 0; |
} |
int audio_set_channels(struct audio_info_struct *ai) |
{ |
return 0; |
} |
int audio_set_format(struct audio_info_struct *ai) |
{ |
return 0; |
} |
int audio_get_formats(struct audio_info_struct *ai) |
{ |
return AUDIO_FORMAT_SIGNED_16; |
} |
int audio_play_samples(struct audio_info_struct *ai,unsigned char *buf,int len) |
{ |
return len; |
} |
int audio_close(struct audio_info_struct *ai) |
{ |
return 0; |
} |
#endif |
/shark/trunk/ports/mpg123/xfermem.c |
---|
0,0 → 1,242 |
/* |
* xfermem.c |
* |
* Oliver Fromme <oliver.fromme@heim3.tu-clausthal.de> |
* Sun Apr 6 02:26:26 MET DST 1997 |
* |
* See xfermem.h for documentation/description. |
*/ |
#include <stdio.h> |
#include <stdlib.h> |
#include <string.h> |
#include <unistd.h> |
#include <errno.h> |
#include <sys/types.h> |
#include <sys/time.h> |
#include <sys/uio.h> |
#include <sys/mman.h> |
#include <sys/socket.h> |
#include <fcntl.h> |
#include "xfermem.h" |
#include "mpg123.h" |
#ifndef USE_MMAP |
#include <sys/ipc.h> |
#include <sys/shm.h> |
#endif |
extern int errno; |
#if defined (USE_MMAP) && defined(MAP_ANONYMOUS) && !defined(MAP_ANON) |
#define MAP_ANON MAP_ANONYMOUS |
#endif |
void xfermem_init (txfermem **xf, int bufsize, int msize) |
{ |
int regsize = bufsize + msize + sizeof(txfermem); |
#ifdef USE_MMAP |
# ifdef MAP_ANON |
if ((*xf = (txfermem *) mmap(0, regsize, PROT_READ | PROT_WRITE, |
MAP_ANON | MAP_SHARED, -1, 0)) == (txfermem *) -1) { |
perror ("mmap()"); |
exit (1); |
} |
# else |
int devzero; |
if ((devzero = open("/dev/zero", O_RDWR, 0)) == -1) { |
perror ("open(/dev/zero)"); |
exit (1); |
} |
if ((*xf = (txfermem *) mmap(0, regsize, PROT_READ | PROT_WRITE, |
MAP_SHARED, devzero, 0)) == (txfermem *) -1) { |
perror ("mmap()"); |
exit (1); |
} |
close (devzero); |
# endif |
#else |
struct shmid_ds shmemds; |
int shmemid; |
if ((shmemid = shmget(IPC_PRIVATE, regsize, IPC_CREAT | 0600)) == -1) { |
perror ("shmget()"); |
exit (1); |
} |
if ((*xf = (txfermem *) shmat(shmemid, 0, 0)) == (txfermem *) -1) { |
perror ("shmat()"); |
shmctl (shmemid, IPC_RMID, &shmemds); |
exit (1); |
} |
if (shmctl(shmemid, IPC_RMID, &shmemds) == -1) { |
perror ("shmctl()"); |
xfermem_done (*xf); |
exit (1); |
} |
#endif |
if (socketpair(AF_UNIX, SOCK_STREAM, 0, (*xf)->fd) < 0) { |
perror ("socketpair()"); |
xfermem_done (*xf); |
exit (1); |
} |
(*xf)->freeindex = (*xf)->readindex = 0; |
(*xf)->wakeme[0] = (*xf)->wakeme[1] = FALSE; |
(*xf)->data = ((byte *) *xf) + sizeof(txfermem) + msize; |
(*xf)->metadata = ((byte *) *xf) + sizeof(txfermem); |
(*xf)->size = bufsize; |
(*xf)->metasize = msize; |
} |
void xfermem_done (txfermem *xf) |
{ |
#ifdef USE_MMAP |
munmap ((caddr_t) xf, xf->size + xf->metasize + sizeof(txfermem)); |
#else |
if (shmdt((void *) xf) == -1) { |
perror ("shmdt()"); |
exit (1); |
} |
#endif |
} |
void xfermem_init_writer (txfermem *xf) |
{ |
close (xf->fd[XF_READER]); |
} |
void xfermem_init_reader (txfermem *xf) |
{ |
close (xf->fd[XF_WRITER]); |
} |
int xfermem_get_freespace (txfermem *xf) |
{ |
int freeindex, readindex; |
if ((freeindex = xf->freeindex) < 0 |
|| (readindex = xf->readindex) < 0) |
return (0); |
if (readindex > freeindex) |
return ((readindex - freeindex) - 1); |
else |
return ((xf->size - (freeindex - readindex)) - 1); |
} |
int xfermem_get_usedspace (txfermem *xf) |
{ |
int freeindex, readindex; |
if ((freeindex = xf->freeindex) < 0 |
|| (readindex = xf->readindex) < 0) |
return (0); |
if (freeindex >= readindex) |
return (freeindex - readindex); |
else |
return (xf->size - (readindex - freeindex)); |
} |
int xfermem_write (txfermem *xf, byte *data, int count) |
{ |
int nbytes; |
if ((nbytes = xfermem_get_freespace(xf))> count) |
nbytes = count; |
if (nbytes) { |
if (xf->freeindex + nbytes > xf->size) { |
int first = xf->size - xf->freeindex; |
memcpy (xf->data + xf->freeindex, data, first); |
memcpy (xf->data, data + first, nbytes - first); |
} |
else |
memcpy (xf->data + xf->freeindex, data, nbytes); |
xf->freeindex = (xf->freeindex + nbytes) % xf->size; |
} |
return (nbytes); |
} |
int xfermem_read (txfermem *xf, byte *data, int count) |
{ |
int nbytes; |
if ((nbytes = xfermem_get_usedspace(xf))> count) |
nbytes = count; |
if (nbytes) { |
if (xf->readindex + nbytes > xf->size) { |
int first = xf->size - xf->readindex; |
memcpy (data, xf->data + xf->readindex, first); |
memcpy (data + first, xf->data, nbytes - first); |
} |
else |
memcpy (data, xf->data + xf->readindex, nbytes); |
xf->readindex = (xf->readindex + nbytes) % xf->size; |
} |
return (nbytes); |
} |
int xfermem_getcmd (int fd, int block) |
{ |
fd_set selfds; |
struct timeval selto = {0, 0}; |
byte cmd; |
for (;;) { |
FD_ZERO (&selfds); |
FD_SET (fd, &selfds); |
switch (select(FD_SETSIZE, &selfds, NULL, NULL, block ? NULL : &selto)) { |
case 0: |
if (!block) |
return (0); |
continue; |
case -1: |
if (errno == EINTR) |
continue; |
return (-2); |
case 1: |
if (FD_ISSET(fd, &selfds)) |
switch (read(fd, &cmd, 1)) { |
case 0: /* EOF */ |
return (-1); |
case -1: |
if (errno == EINTR) |
continue; |
return (-3); |
case 1: |
return (cmd); |
default: /* ?!? */ |
return (-4); |
} |
else /* ?!? */ |
return (-5); |
default: /* ?!? */ |
return (-6); |
} |
} |
} |
int xfermem_putcmd (int fd, byte cmd) |
{ |
for (;;) |
switch (write(fd, &cmd, 1)) { |
case 1: |
return (1); |
case -1: |
if (errno != EINTR) |
return (-1); |
} |
} |
int xfermem_block (int readwrite, txfermem *xf) |
{ |
int myfd = xf->fd[readwrite]; |
int result; |
xf->wakeme[readwrite] = TRUE; |
if (xf->wakeme[1 - readwrite]) |
xfermem_putcmd (myfd, XF_CMD_WAKEUP); |
result = xfermem_getcmd(myfd, TRUE); |
xf->wakeme[readwrite] = FALSE; |
return ((result <= 0) ? -1 : result); |
} |
/* EOF */ |
/shark/trunk/ports/mpg123/get1bit.h |
---|
0,0 → 1,28 |
#ifdef I386_ASSEM |
static inline int get1bit(void) { |
extern int bitindex; |
extern unsigned char *wordpointer; |
int ret; |
asm("\n\t" |
"movl %1,%%ecx\n\t" |
"movzbl (%%ecx),%%eax\n\t" |
"movl %2,%%ecx\n\t" |
"incl %%ecx\n\t" |
"rolb %%cl,%%al\n\t" |
"andb $1,%%al\n\t" |
"movl %%ecx,%2\n\t" |
"andl $7,%2\n\t" |
"sarl $3,%%ecx\n\t" |
"addl %%ecx,%1\n" |
: "=a" (ret) |
: "m" (wordpointer) , "m" (bitindex) |
: "eax" , "ecx" , "memory" ); |
return ret; |
} |
#endif |
/shark/trunk/ports/mpg123/audio.h |
---|
0,0 → 1,48 |
/* |
* Audio 'LIB' defines |
*/ |
enum { AUDIO_OUT_HEADPHONES,AUDIO_OUT_INTERNAL_SPEAKER,AUDIO_OUT_LINE_OUT }; |
enum { DECODE_TEST, DECODE_AUDIO, DECODE_STDOUT, DECODE_BUFFER }; |
#define AUDIO_FORMAT_SIGNED_16 0x1 |
#define AUDIO_FORMAT_UNSIGNED_8 0x2 |
#define AUDIO_FORMAT_SIGNED_8 0x4 |
#define AUDIO_FORMAT_ULAW_8 0x8 |
#define AUDIO_FORMAT_ALAW_8 0x10 |
#if defined(HPUX) || defined(SUNOS) || defined(SOLARIS) || defined(VOXWARE) |
#define AUDIO_USES_FD |
#endif |
struct audio_info_struct |
{ |
#ifdef AUDIO_USES_FD |
int fn; /* filenumber */ |
#endif |
#ifdef SGI |
ALconfig config; |
ALport port; |
#endif |
long rate; |
int gain; |
int output; |
char *device; |
int channels; |
int format; |
}; |
extern int audio_play_samples(struct audio_info_struct *,unsigned char *,int); |
extern int audio_open(struct audio_info_struct *); |
extern int audio_reset_parameters(struct audio_info_struct *); |
extern int audio_rate_best_match(struct audio_info_struct *ai); |
extern int audio_set_rate(struct audio_info_struct *); |
extern int audio_set_format(struct audio_info_struct *); |
extern int audio_get_formats(struct audio_info_struct *); |
extern int audio_set_channels(struct audio_info_struct *); |
extern int audio_write_sample(struct audio_info_struct *,short *,int); |
extern int audio_close(struct audio_info_struct *); |
extern void audio_info_struct_init(struct audio_info_struct *); |
#ifdef SOLARIS |
extern void audio_queueflush(struct audio_info_struct *ai); |
#endif |
/shark/trunk/ports/mpg123/xfermem.h |
---|
0,0 → 1,60 |
/* |
* xfermem.h |
* |
* Oliver Fromme <oliver.fromme@heim3.tu-clausthal.de> |
* Sat Mar 29 04:41:34 MET 1997 |
* |
* This is a stand-alone module which implements a unidirectional, |
* fast pipe using mmap(). Its primary use is to transfer large |
* amounts of data from a parent process to its child process, |
* with a buffer in between which decouples blocking conditions |
* on both sides. Control information is transferred between the |
* processes through a socketpair. See xftest.c for an example on |
* how to use this module. |
*/ |
#ifndef TRUE |
#define FALSE 0 |
#define TRUE 1 |
#endif |
typedef unsigned char byte; |
typedef struct { |
int freeindex; /* [W] next free index */ |
int readindex; /* [R] next index to read */ |
int fd[2]; |
int wakeme[2]; |
byte *data; |
byte *metadata; |
int size; |
int metasize; |
} txfermem; |
/* |
* [W] -- May be written to by the writing process only! |
* [R] -- May be written to by the reading process only! |
* All other entries are initialized once. |
*/ |
void xfermem_init (txfermem **xf, int bufsize, int msize); |
void xfermem_init_writer (txfermem *xf); |
void xfermem_init_reader (txfermem *xf); |
int xfermem_write (txfermem *xf, byte *data, int count); |
int xfermem_read (txfermem *xf, byte *data, int count); |
int xfermem_get_freespace (txfermem *xf); |
int xfermem_get_usedspace (txfermem *xf); |
#define XF_CMD_WAKEUP 0x02 |
#define XF_CMD_TERMINATE 0x03 |
#define XF_WRITER 0 |
#define XF_READER 1 |
int xfermem_getcmd (int fd, int block); |
int xfermem_putcmd (int fd, byte cmd); |
int xfermem_block (int fd, txfermem *xf); |
void xfermem_done (txfermem *xf); |
#define xfermem_done_writer xfermem_init_reader |
#define xfermem_done_reader xfermem_init_writer |
/* EOF */ |
/shark/trunk/ports/mpg123/mpg123.c |
---|
0,0 → 1,698 |
/* |
* Mpeg Layer audio decoder (see version.h for version number) |
* ------------------------ |
* copyright (c) 1995,1996,1997 by Michael Hipp, All rights reserved. |
* See also 'README' ! |
* |
*/ |
#include <stdlib.h> |
#include <sys/types.h> |
#include <sys/wait.h> |
#include <sys/time.h> |
#include <sys/resource.h> |
/* #define SET_PRIO */ |
#include "mpg123.h" |
#include "getlopt.h" |
#include "version.h" |
static void usage(char *dummy); |
static void print_title(void); |
static long rates[3][3] = { |
{ 32000,44100,48000 } , |
{ 16000,22050,24000 } , |
{ 8000,11025,12000 } |
}; |
int supported_rates = 0; |
int outmode = DECODE_AUDIO; |
char *listname = NULL; |
long outscale = 32768; |
int checkrange = FALSE; |
int tryresync = TRUE; |
int quiet = FALSE; |
int verbose = 0; |
int doublespeed= 0; |
int halfspeed = 0; |
int shuffle = 0; |
int change_always = 1; |
int force_8bit = 0; |
int force_frequency = -1; |
long numframes = -1; |
long startFrame= 0; |
int usebuffer = 0; |
int frontend_type = 0; |
int remote = 0; |
int buffer_fd[2]; |
int buffer_pid; |
static void catch_child(void) |
{ |
while (waitpid(-1, NULL, WNOHANG) > 0); |
} |
static int intflag = FALSE; |
static int remflag = FALSE; |
static void catch_interrupt(void) |
{ |
intflag = TRUE; |
} |
static char remote_buffer[1024]; |
static struct frame fr; |
static struct audio_info_struct ai; |
txfermem *buffermem; |
#define FRAMEBUFUNIT (18 * 64 * 4) |
void print_rheader(struct frame *fr); |
static void catch_remote(void) |
{ |
remflag = TRUE; |
intflag = TRUE; |
if(usebuffer) |
kill(buffer_pid,SIGINT); |
} |
char *handle_remote(void) |
{ |
switch(frontend_type) { |
case FRONTEND_SAJBER: |
#ifdef FRONTEND |
control_sajber(&fr); |
#endif |
break; |
case FRONTEND_TK3PLAY: |
#ifdef FRONTEND |
control_tk3play(&fr); |
#endif |
break; |
default: |
fgets(remote_buffer,1024,stdin); |
remote_buffer[strlen(remote_buffer)-1]=0; |
switch(remote_buffer[0]) { |
case 'P': |
return remote_buffer+1; |
} |
if(usebuffer) |
kill(buffer_pid,SIGINT); |
break; |
} |
return NULL; |
} |
void init_output(void) |
{ |
static int init_done = FALSE; |
if (init_done) |
return; |
init_done = TRUE; |
#ifndef OS2 |
if (usebuffer) { |
unsigned int bufferbytes; |
sigset_t newsigset, oldsigset; |
if (usebuffer < 32) |
usebuffer = 32; /* minimum is 32 Kbytes! */ |
bufferbytes = (usebuffer * 1024); |
bufferbytes -= bufferbytes % FRAMEBUFUNIT; |
xfermem_init (&buffermem, bufferbytes, sizeof(ai.rate)); |
pcm_sample = (unsigned char *) buffermem->data; |
pcm_point = 0; |
sigemptyset (&newsigset); |
sigaddset (&newsigset, SIGUSR1); |
sigprocmask (SIG_BLOCK, &newsigset, &oldsigset); |
catchsignal (SIGCHLD, catch_child); |
switch ((buffer_pid = fork())) { |
case -1: /* error */ |
perror("fork()"); |
exit(1); |
case 0: /* child */ |
xfermem_init_reader (buffermem); |
buffer_loop (&ai, &oldsigset); |
xfermem_done_reader (buffermem); |
xfermem_done (buffermem); |
_exit(0); |
default: /* parent */ |
xfermem_init_writer (buffermem); |
outmode = DECODE_BUFFER; |
} |
} |
else { |
#endif |
if (!(pcm_sample = (unsigned char *) malloc(audiobufsize * 2))) { |
perror ("malloc()"); |
exit (1); |
#ifndef OS2 |
} |
#endif |
} |
if(outmode==DECODE_AUDIO) { |
if(audio_open(&ai) < 0) { |
perror("audio"); |
exit(1); |
} |
/* audio_set_rate (&ai); should already be done in audio_open() [OF] */ |
} |
} |
char *get_next_file (int argc, char *argv[]) |
{ |
static FILE *listfile = NULL; |
static char line[1024]; |
#ifdef SHUFFLESUPPORT |
static int ord[2048]; |
int temp, randomized,pos; |
static char initialized=0; |
time_t t; |
#endif |
if (remote) |
return handle_remote(); |
if (listname || listfile) { |
if (!listfile) { |
if (!*listname || !strcmp(listname, "-")) { |
listfile = stdin; |
listname = NULL; |
} |
else if (!strncmp(listname, "http://", 7)) |
listfile = http_open(listname); |
else if (!(listfile = fopen(listname, "rb"))) { |
perror (listname); |
exit (1); |
} |
if (verbose) |
fprintf (stderr, "Using playlist from %s ...\n", |
listname ? listname : "standard input"); |
} |
do { |
if (fgets(line, 1023, listfile)) { |
line[strcspn(line, "\t\n\r")] = '\0'; |
if (line[0]=='\0' || line[0]=='#') |
continue; |
return (line); |
} |
else { |
if (*listname) |
fclose (listfile); |
listname = NULL; |
listfile = NULL; |
} |
} while (listfile); |
} |
#ifdef SHUFFLESUPPORT |
if(!initialized){ |
for(pos=0;pos<=argc; pos++) ord[pos]=pos; |
initialized=1; |
} |
if(shuffle){ |
fprintf(stderr, "\nShuffle play - %u file(s) in loop.\n", argc-loptind); |
srandom(time(&t)); |
for(pos=loptind;pos<argc;pos++){ |
randomized=(random()%(argc-pos))+pos; |
temp=ord[pos]; |
ord[pos]=ord[randomized]; |
ord[randomized]=temp; |
} |
shuffle=0; |
} |
if (loptind < argc) |
return (argv[ord[loptind++]]); |
return (NULL); |
#else |
if (loptind < argc) |
return (argv[loptind++]); |
return (NULL); |
#endif |
} |
void set_synth (char *arg) |
{ |
if (*arg == '2') { |
fr.down_sample = 1; |
} |
else { |
fr.down_sample = 2; |
} |
} |
#ifdef VARMODESUPPORT |
void set_varmode (char *arg) |
{ |
audiobufsize = ((audiobufsize >> 1) + 63) & 0xffffc0; |
} |
#endif |
void set_output (char *arg) |
{ |
switch (*arg) { |
case 'h': ai.output = AUDIO_OUT_HEADPHONES; break; |
case 's': ai.output = AUDIO_OUT_INTERNAL_SPEAKER; break; |
case 'l': ai.output = AUDIO_OUT_LINE_OUT; break; |
default: |
fprintf (stderr, "%s: Unknown argument \"%s\" to option \"%s\".\n", |
prgName, arg, loptarg); |
exit (1); |
} |
} |
void set_verbose (char *arg) |
{ |
verbose++; |
} |
topt opts[] = { |
{'k', "skip", GLO_ARG | GLO_NUM, 0, &startFrame, 0}, |
{'a', "audiodevice", GLO_ARG | GLO_CHAR, 0, &ai.device, 0}, |
{'2', "2to1", 0, set_synth, 0, 0}, |
{'4', "4to1", 0, set_synth, 0, 0}, |
{'t', "test", 0, 0, &outmode, DECODE_TEST}, |
{'s', "stdout", 0, 0, &outmode, DECODE_STDOUT}, |
{'c', "check", 0, 0, &checkrange, TRUE}, |
{'v', "verbose", 0, set_verbose, 0, 0}, |
{'q', "quiet", 0, 0, &quiet, TRUE}, |
{'y', "resync", 0, 0, &tryresync, FALSE}, |
{'0', "single0", 0, 0, &fr.single, 0}, |
{0, "left", 0, 0, &fr.single, 0}, |
{'1', "single1", 0, 0, &fr.single, 1}, |
{0, "right", 0, 0, &fr.single, 1}, |
{'m', "singlemix", 0, 0, &fr.single, 3}, |
{0, "mix", 0, 0, &fr.single, 3}, |
{'g', "gain", GLO_ARG | GLO_NUM, 0, &ai.gain, 0}, |
{'r', "rate", GLO_ARG | GLO_NUM, 0, &force_frequency, 0}, |
{0, "8bit", 0, 0, &force_8bit, 1}, |
{0, "headphones", 0, 0, &ai.output, AUDIO_OUT_HEADPHONES}, |
{0, "speaker", 0, 0, &ai.output, AUDIO_OUT_INTERNAL_SPEAKER}, |
{0, "lineout", 0, 0, &ai.output, AUDIO_OUT_LINE_OUT}, |
{'o', "output", GLO_ARG | GLO_CHAR, set_output, 0, 0}, |
{'f', "scale", GLO_ARG | GLO_NUM, 0, &outscale, 0}, |
{'n', "frames", GLO_ARG | GLO_NUM, 0, &numframes, 0}, |
#ifdef VARMODESUPPORT |
{'v', "var", 0, set_varmode, &varmode, TRUE}, |
#endif |
{'b', "buffer", GLO_ARG | GLO_NUM, 0, &usebuffer, 0}, |
{'R', "remote", 0, 0, &remote, TRUE}, |
{'d', "doublespeed", GLO_ARG | GLO_NUM, 0, &doublespeed,0}, |
{'h', "halfspeed", GLO_ARG | GLO_NUM, 0, &halfspeed, 0}, |
{'p', "proxy", GLO_ARG | GLO_CHAR, 0, &proxyurl, 0}, |
{'@', "list", GLO_ARG | GLO_CHAR, 0, &listname, 0}, |
#ifdef SHUFFLESUPPORT |
/* 'z' comes from the the german word 'zufall' (eng: random) */ |
{'z', "shuffle", 0, 0, &shuffle, 1}, |
#endif |
{'?', "help", 0, usage, 0, 0}, |
{0, 0, 0, 0, 0, 0} |
}; |
/* |
* Change the playback sample rate. |
*/ |
static void reset_audio_samplerate(void) |
{ |
if (usebuffer) { |
/* wait until the buffer is empty, |
* then tell the buffer process to |
* change the sample rate. [OF] |
*/ |
while (xfermem_get_usedspace(buffermem) > 0) |
if (xfermem_block(XF_WRITER, buffermem) == XF_CMD_TERMINATE) { |
intflag = TRUE; |
break; |
} |
buffermem->freeindex = -1; |
buffermem->readindex = 0; /* I know what I'm doing! ;-) */ |
buffermem->freeindex = 0; |
if (intflag) |
return; |
memcpy (buffermem->metadata, &ai.rate, sizeof(ai.rate)); |
kill (buffer_pid, SIGUSR1); |
} |
else if (outmode == DECODE_AUDIO) { |
/* audio_reset_parameters(&ai); */ |
/* close and re-open in order to flush |
* the device's internal buffer before |
* changing the sample rate. [OF] |
*/ |
audio_close (&ai); |
if (audio_open(&ai) < 0) { |
perror("audio"); |
exit(1); |
} |
} |
} |
/* |
* play a frame read read_frame(); |
* (re)initialize audio if necessary. |
*/ |
void play_frame(int init,struct frame *fr) |
{ |
int clip; |
if((fr->header_change && change_always) || init) { |
int reset_audio = 0; |
if(remote) |
print_rheader(fr); |
if (!quiet && init) |
if (verbose) |
print_header(fr); |
else |
print_header_compact(fr); |
if(force_frequency < 0) { |
if(ai.rate != freqs[fr->sampling_frequency]>>(fr->down_sample)) { |
ai.rate = freqs[fr->sampling_frequency]>>(fr->down_sample); |
reset_audio = 1; |
} |
} |
else if(ai.rate != force_frequency) { |
ai.rate = force_frequency; |
reset_audio = 1; |
} |
init_output(); |
if(reset_audio) { |
reset_audio_samplerate(); |
if (intflag) |
return; |
} |
} |
if (fr->error_protection) { |
getbits(16); /* crc */ |
} |
clip = (fr->do_layer)(fr,outmode,&ai); |
#ifndef OS2 |
if (usebuffer) { |
if (!intflag) { |
buffermem->freeindex = |
(buffermem->freeindex + pcm_point) % buffermem->size; |
if (buffermem->wakeme[XF_READER]) |
xfermem_putcmd(buffermem->fd[XF_WRITER], XF_CMD_WAKEUP); |
} |
pcm_sample = (unsigned char *) (buffermem->data + buffermem->freeindex); |
pcm_point = 0; |
while (xfermem_get_freespace(buffermem) < (FRAMEBUFUNIT << 1)) |
if (xfermem_block(XF_WRITER, buffermem) == XF_CMD_TERMINATE) { |
intflag = TRUE; |
break; |
} |
if (intflag) |
return; |
} |
#endif |
if(clip > 0 && checkrange) |
fprintf(stderr,"%d samples clipped\n", clip); |
} |
int main(int argc, char *argv[]) |
{ |
int result; |
unsigned long frameNum = 0; |
char *fname; |
struct timeval start_time, now; |
unsigned long secdiff; |
int init; |
#ifdef OS2 |
_wildcard(&argc,&argv); |
#endif |
#ifdef SET_PRIO |
int mypid = getpid(); |
setpriority(PRIO_PROCESS,mypid,-20); |
#endif |
if(!strcmp("sajberplay",argv[0])) |
frontend_type = FRONTEND_SAJBER; |
if(!strcmp("mpg123m",argv[0])) |
frontend_type = FRONTEND_TK3PLAY; |
fr.single = -1; /* both channels */ |
fr.synth = synth_1to1; |
fr.down_sample = 0; |
ai.format = AUDIO_FORMAT_SIGNED_16; |
ai.gain = ai.rate = ai.output = -1; |
ai.device = NULL; |
ai.channels = 2; |
(prgName = strrchr(argv[0], '/')) ? prgName++ : (prgName = argv[0]); |
while ((result = getlopt(argc, argv, opts))) |
switch (result) { |
case GLO_UNKNOWN: |
fprintf (stderr, "%s: Unknown option \"%s\".\n", prgName, loptarg); |
exit (1); |
case GLO_NOARG: |
fprintf (stderr, "%s: Missing argument for option \"%s\".\n", |
prgName, loptarg); |
exit (1); |
} |
if (loptind >= argc && !listname && !frontend_type) |
usage(NULL); |
if (remote){ |
verbose = 0; |
quiet = 1; |
catchsignal(SIGUSR1, catch_remote); |
fprintf(stderr,"@R MPG123\n"); |
} |
if (!quiet) |
print_title(); |
{ |
int fmts; |
int i,j; |
struct audio_info_struct ai; |
audio_info_struct_init(&ai); |
if (outmode == DECODE_AUDIO) { |
audio_open(&ai); |
fmts = audio_get_formats(&ai); |
} |
else |
fmts = AUDIO_FORMAT_SIGNED_16; |
supported_rates = 0; |
for(i=0;i<3;i++) { |
for(j=0;j<3;j++) { |
ai.rate = rates[i][j]; |
if (outmode == DECODE_AUDIO) |
audio_rate_best_match(&ai); |
/* allow about 2% difference */ |
if( ((rates[i][j]*98) < (ai.rate*100)) && |
((rates[i][j]*102) > (ai.rate*100)) ) |
supported_rates |= 1<<(i*3+j); |
} |
} |
if (outmode == DECODE_AUDIO) |
audio_close(&ai); |
if(!force_8bit && !(fmts & AUDIO_FORMAT_SIGNED_16)) |
force_8bit = 1; |
if(force_8bit && !(fmts & AUDIO_FORMAT_ULAW_8)) { |
fprintf(stderr,"No supported audio format found!\n"); |
exit(1); |
} |
} |
if(force_8bit) { |
#if 0 |
ai.format = AUDIO_FORMAT_UNSIGNED_8; |
ai.format = AUDIO_FORMAT_SIGNED_8; |
#endif |
ai.format = AUDIO_FORMAT_ULAW_8; |
make_conv16to8_table(ai.format); |
switch(fr.down_sample) { |
case 0: |
fr.synth = synth_1to1_8bit; |
fr.synth_mono = synth_1to1_8bit_mono; |
fr.block_size = 64; |
break; |
case 1: |
fr.synth = synth_2to1_8bit; |
fr.synth_mono = synth_2to1_8bit_mono; |
fr.block_size = 32; |
break; |
case 2: |
fr.synth = synth_4to1_8bit; |
fr.synth_mono = synth_4to1_8bit_mono; |
fr.block_size = 16; |
break; |
} |
} |
else { |
switch(fr.down_sample) { |
case 0: |
fr.synth = synth_1to1; |
fr.synth_mono = synth_1to1_mono; |
fr.block_size = 128; |
break; |
case 1: |
fr.synth = synth_2to1; |
fr.synth_mono = synth_2to1_mono; |
fr.block_size = 64; |
break; |
case 2: |
fr.synth = synth_4to1; |
fr.synth_mono = synth_4to1_mono; |
fr.block_size = 32; |
break; |
} |
} |
make_decode_tables(outscale); |
init_layer2(); /* inits also shared tables with layer1 */ |
init_layer3(fr.down_sample); |
catchsignal (SIGINT, catch_interrupt); |
if(frontend_type) { |
handle_remote(); |
exit(0); |
} |
while ((fname = get_next_file(argc, argv))) { |
char *dirname, *filename; |
if(!*fname || !strcmp(fname, "-")) |
fname = NULL; |
open_stream(fname,-1); |
if (!quiet) { |
if (split_dir_file(fname ? fname : "standard input", |
&dirname, &filename)) |
fprintf(stderr, "\nDirectory: %s", dirname); |
fprintf(stderr, "\nPlaying MPEG stream from %s ...\n", filename); |
} |
gettimeofday (&start_time, NULL); |
read_frame_init(); |
init = 1; |
for(frameNum=0;read_frame(&fr) && numframes && !intflag;frameNum++) { |
if(frameNum < startFrame || (doublespeed && (frameNum % doublespeed))) { |
if(fr.lay == 3) |
set_pointer(512); |
continue; |
} |
numframes--; |
play_frame(init,&fr); |
init = 0; |
if(verbose) { |
if (verbose > 1 || !(frameNum & 0xf)) |
fprintf(stderr, "\r{%4lu} ",frameNum); |
#ifndef OS2 |
if (verbose > 1 && usebuffer) |
fprintf (stderr, "%7d ", xfermem_get_usedspace(buffermem)); |
#endif |
} |
} |
close_stream(); |
if (!quiet) { |
/* This formula seems to work at least for |
* MPEG 1.0/2.0 layer 3 streams. |
*/ |
int sfd = freqs[fr.sampling_frequency] * (fr.lsf + 1); |
int secs = (frameNum * (fr.lay==1 ? 384 : 1152) + sfd / 2) / sfd; |
fprintf(stderr,"[%d:%02d] Decoding of %s finished.\n", secs / 60, |
secs % 60, filename); |
} |
if(remote) |
fprintf(stderr,"@R MPG123\n"); |
if (remflag) { |
intflag = FALSE; |
remflag = FALSE; |
} |
if (intflag) { |
gettimeofday (&now, NULL); |
secdiff = (now.tv_sec - start_time.tv_sec) * 1000; |
if (now.tv_usec >= start_time.tv_usec) |
secdiff += (now.tv_usec - start_time.tv_usec) / 1000; |
else |
secdiff -= (start_time.tv_usec - now.tv_usec) / 1000; |
if (secdiff < 1000) |
break; |
intflag = FALSE; |
} |
} |
#ifndef OS2 |
if (usebuffer) { |
xfermem_done_writer (buffermem); |
waitpid (buffer_pid, NULL, 0); |
xfermem_done (buffermem); |
} |
else { |
#endif |
audio_flush(outmode, &ai); |
free (pcm_sample); |
#ifndef OS2 |
} |
#endif |
if(outmode==DECODE_AUDIO) |
audio_close(&ai); |
exit( 0 ); |
} |
static void print_title(void) |
{ |
fprintf(stderr,"High Performance MPEG 1.0/2.0 Audio Player for Layer 1, 2 and 3.\n"); |
fprintf(stderr,"Version %s (%s). Written and copyrights by Michael Hipp.\n", prgVersion, prgDate); |
fprintf(stderr,"Uses code from various people. See 'README' for more!\n"); |
fprintf(stderr,"THIS SOFTWARE COMES WITH ABSOLUTELY NO WARRANTY! USE AT YOUR OWN RISK!\n"); |
} |
static void usage(char *dummy) /* print syntax & exit */ |
{ |
print_title(); |
fprintf(stderr,"\nusage: %s [option(s)] [file(s) | URL(s) | -]\n", prgName); |
fprintf(stderr,"supported options [defaults in brackets]:\n"); |
fprintf(stderr," -v increase verbosity level -q quiet (don't print title)\n"); |
fprintf(stderr," -t testmode (no output) -s write to stdout\n"); |
fprintf(stderr," -k n skip first n frames [0] -n n decode only n frames [all]\n"); |
fprintf(stderr," -c check range violations -y DISABLE resync on errors\n"); |
fprintf(stderr," -b n output buffer: n Kbytes [0] -f n change scalefactor [32768]\n"); |
fprintf(stderr," -r n override samplerate [auto] -g n set audio hardware output gain\n"); |
fprintf(stderr," -os output to built-in speaker -oh output to headphones\n"); |
fprintf(stderr," -ol output to line-out connector -a d set audio device\n"); |
fprintf(stderr," -2 downsample 1:2 (22 kHz) -4 downsample 1:4 (11 kHz)\n"); |
fprintf(stderr," -d n play every n'th frame only -h n play every frame n times\n"); |
fprintf(stderr," -0 decode channel 0 (left) only -1 decode channel 1 (right) only\n"); |
fprintf(stderr," -m mix both channels (mono) -p p use HTTP proxy p [$HTTP_PROXY]\n"); |
fprintf(stderr," -@ f read filenames/URLs from f -z shuffle play (with wildcards)\n"); |
fprintf(stderr,"See the manpage %s(1) for more information.\n", prgName); |
exit(1); |
} |
/shark/trunk/ports/mpg123/buffer.c |
---|
0,0 → 1,98 |
/* |
* buffer.c |
* |
* Oliver Fromme <oliver.fromme@heim3.tu-clausthal.de> |
* Mon Apr 14 03:53:18 MET DST 1997 |
*/ |
#include "mpg123.h" |
int outburst = MAXOUTBURST; |
static int intflag = FALSE; |
static int usr1flag = FALSE; |
static void catch_interrupt (void) |
{ |
intflag = TRUE; |
} |
static void catch_usr1 (void) |
{ |
usr1flag = TRUE; |
} |
#ifndef OS2 |
void buffer_loop(struct audio_info_struct *ai, sigset_t *oldsigset) |
{ |
int bytes; |
int my_fd = buffermem->fd[XF_READER]; |
txfermem *xf = buffermem; |
int done = FALSE; |
catchsignal (SIGINT, catch_interrupt); |
catchsignal (SIGUSR1, catch_usr1); |
sigprocmask (SIG_SETMASK, oldsigset, NULL); |
if (outmode == DECODE_AUDIO) { |
if (audio_open(ai) < 0) { |
perror("audio"); |
exit(1); |
} |
/* audio_set_rate (ai); already done by audio_open() */ |
} |
for (;;) { |
if (intflag) { |
intflag = FALSE; |
#ifdef SOLARIS |
if (outmode == DECODE_AUDIO) |
audio_queueflush (ai); |
#endif |
xf->readindex = xf->freeindex; |
} |
if (usr1flag) { |
usr1flag = FALSE; |
/* close and re-open in order to flush |
* the device's internal buffer before |
* changing the sample rate. [OF] |
*/ |
if (outmode == DECODE_AUDIO) { |
audio_close (ai); |
memcpy (&ai->rate, xf->metadata, sizeof(ai->rate)); |
if (audio_open(ai) < 0) { |
perror("audio"); |
exit(1); |
} |
} |
} |
if (!(bytes = xfermem_get_usedspace(xf))) { |
if (done) |
break; |
if (xfermem_block(XF_READER, xf) != XF_CMD_WAKEUP) |
done = TRUE; |
continue; |
} |
if (bytes > xf->size - xf->readindex) |
bytes = xf->size - xf->readindex; |
if (bytes > outburst) |
bytes = outburst; |
if (outmode == DECODE_STDOUT) |
bytes = write(1, xf->data + xf->readindex, bytes); |
else if (outmode == DECODE_AUDIO) |
bytes = audio_play_samples(ai, |
(unsigned char *) (xf->data + xf->readindex), bytes); |
xf->readindex = (xf->readindex + bytes) % xf->size; |
if (xf->wakeme[XF_WRITER]) |
xfermem_putcmd(my_fd, XF_CMD_WAKEUP); |
} |
if (outmode == DECODE_AUDIO) |
audio_close (ai); |
} |
#endif |
/* EOF */ |
/shark/trunk/ports/mpg123/readme |
---|
0,0 → 1,134 |
********************************************************************** |
* MPEG 1.0/2.0 _AUDIO_ PLAYER, V0.59k * |
* * |
* (full?) MPEG 1.0/2.0, Layer 1,2 and 3 support * |
* Layer-3 realtime only with a 'fast' machine * |
* Since April 97, 128kbit j-stereo should work on a 486DX4-100. * |
* With 2:1 down-sampling or using the downmix-mode even a 486DX2-66 * |
* should play such a stream in realtime! * |
* * |
* I still claim to have the fastest MPEG Audio Player for UNIX ;) * |
********************************************************************** |
Please read first the important information in the COPYING file. |
written/modfied by: |
Michael Hipp (email: Michael.Hipp@student.uni-tuebingen.de) |
Oliver Fromme <oliver.fromme@heim3.tu-clausthal.de> |
(several enhancements, man pages, Makefile, FreeBSD port, License, etc.) |
Uses code (or at least ideas) from: |
MPEG Software Simulation Group (Base package) |
Tobias Bading (subband synthesis) |
Jeff Tsay and Mikko Tommila (DCT36) |
Philipp Knirsch (DCT36/manual unroll) |
Thomas Woerner (SGI Audio) |
Damien Clermonte (HP-UX audio fixes) |
Niclas Lindstrom (OS2 port) |
and more .... |
current original distribution site is: |
http://www.sfs.nphil.uni-tuebingen.de/~hipp/mpg123.html |
here's Oliver Fromme's mpg123 page: |
http://www.heim3.tu-clausthal.de/~olli/mpg123/ |
(includes information about the mpg123 mailing list) |
and you can get the latest release from here: |
ftp.tu-clausthal.de:/pub/unix/audio/mpg123 |
http://ftp.tu-clausthal.de/pub/unix/audio/mpg123 |
------------------------------------------------------------------------ |
V0.59k plays a layer3,112Kbit/s,J-Stereo stream on my AMD 5x86/133Mhz |
with about 66% CPU load. (on the console, NO X11) |
If your machine isn't fast enough you may try the downsampling |
feature (--2to1 and --4to1 options) |
Playing in '--singlemix' (stero reduced to mono) also saves some |
CPU cycles, though the whole code is optimized for 'full' stereo playing. |
'Benchmarks': (+/- 2%) |
---------------------- |
(AMD 486/133MHZ,ASUS SP3G,256KB cache,DIRTY-TAG installed,(BusLogic SCSI)) |
(Layer3, 112Kbit/s, Joint-Stereo stream (partially MS stereo, no I-stereo)) |
(Compiled with: -DI386_ASSEM -DREAL_IS_FLOAT -DLINUX -Wall -O2 -m486 |
-fomit-frame-pointer -funroll-all-loops -finline-functions -ffast-math) |
full quality: (stero) 66% (-> should work on 486DX4-100) |
(singlemix) 38% (-> should work on 486DX2-66) |
2:1 downsampling: (stereo) 48% |
(singlemix) 30% (-> should work on 486DX-50) |
--------------------------------------------------------------------- |
Description: |
This isn't a new player. It's a near fully rewritten version based on the |
mpegaudio (FHG-version) package. The DCT algorithm in the |
synthesis filter is a rewritten version of the DCT first seen in the maplay |
package, which was written by Tobias Bading (bading@cs.tu-berlin.de). The |
rewrite was neccassary, because the GPL may not allow this copyright mix. |
The mpegaudio package was written by various people from the MPEG/audio |
software simulation group. The maplay is under GPL .. You can find the |
original source code and the mpegaudio package on: ftp.tnt.uni-hannover.de. |
You will find code from the mpegaudio package in: |
layer3.c |
common.c |
mpg123.h |
I also often used the same variable names in the rewritten parts. |
In the current layer3.c I'm using a DCT36 from Jeff Tsay's |
(ctsay@pasteur.eecs.berkeley.edu) maplay 1.2+ package. His code is |
under GPL .. I also tried the enhancement from Mikko Tommila. His |
code is also in layer3.c (but it's disabled at the moment, because |
it was slightly slower than the unrolled 9 point DCT (at least on |
_my_ system)). Theoretically it should be faster. You may try it on |
your system. |
The output is always 'two channel interleaved'. If the input is a |
a mono-stream or single-channel is enabled, the player duplicates |
the channel. Currently, only (very simple) audiosupport for |
Linux,HP7xx,SGI,SunOS/Solaris and FreeBSD systems. |
I have tested the program with a lot of teststreams, but it's very |
likely, that there are still a few bugs. |
have fun, |
Mike |
---------------------------------------------------------------------------- |
Just for info: |
I'm also working (but not at the moment) on a DSP port for this package. |
A first testversion of the layer-2 part is finished and seems |
to work in realtime with my 20MHZ ADSP-2115 |
---------------------------------------------------------------------------- |
Copyrights (c) 1995,1996,1997 of all changes/modifications and |
of the new code by Michael Hipp. All rights reserved. |
Copyrights (c) 1997 of several enhancements by Oliver Fromme. |
See the packages 'maplay 1.2(+)' and 'mpegaudio' for their copy-policies. |
Copyrights (c) 1997 of the OS2 specific parts by Niclas Lindstrom |
known bugs: |
layer 3 i-stereo not heavily tested |
btw: I'm looking for i-stereo teststreams .. maybe you could send me a few |
Layer 1 not heavily tested |
no CRC checking .. |
no 'free format streams' |
no clean audio interface |
MPEG 2.0, Layer1 and Layer2 not tested (and probably will not work) |
MPEG 2.0, Layer3 not heavily tested .. may has bugs. |
****************************************************************************** |
* |
* This is software with ABSOLUTELY NO WARRANTY. |
* Use it at your OWN RISK. It's possible to damage e.g. hardware or your hearing |
* due to a bug or for other reasons. |
* |
* I do not warrant that the program is free of infringement of any third-party |
* patents. |
* |
****************************************************************************** |
/shark/trunk/ports/mpg123/getlopt.c |
---|
0,0 → 1,121 |
/* |
* getlopt.c |
* |
* Oliver Fromme <oliver.fromme@heim3.tu-clausthal.de> |
* Tue Apr 8 07:15:13 MET DST 1997 |
*/ |
#include "getlopt.h" |
int loptind = 1; /* index in argv[] */ |
int loptchr = 0; /* index in argv[loptind] */ |
char *loptarg; /* points to argument if present, else to option */ |
#if defined(ultrix) || defined(ULTRIX) |
char *strdup (char *src) |
{ |
char *dest; |
if (!(dest = (char *) malloc(strlen(src)+1))) |
return (NULL); |
return (strcpy(dest, src)); |
} |
#endif |
topt *findopt (int islong, char *opt, topt *opts) |
{ |
if (!opts) |
return (0); |
while (opts->lname) { |
if (islong) { |
if (!strcmp(opts->lname, opt)) |
return (opts); |
} |
else |
if (opts->sname == *opt) |
return (opts); |
opts++; |
} |
return (0); |
} |
int performoption (int argc, char *argv[], topt *opt) |
{ |
int result = GLO_CONTINUE; |
if (!(opt->flags & 1)) /* doesn't take argument */ |
if (opt->var) |
if (opt->flags & 2) /* var is *char */ |
*((char *) opt->var) = (char) opt->value; |
else |
*((int *) opt->var) = opt->value; |
else |
result = opt->value ? opt->value : opt->sname; |
else { /* requires argument */ |
if (loptind >= argc) |
return (GLO_NOARG); |
loptarg = argv[loptind++]+loptchr; |
loptchr = 0; |
if (opt->var) |
if (opt->flags & 2) /* var is *char */ |
*((char **) opt->var) = strdup(loptarg); |
else |
*((int *) opt->var) = atoi(loptarg); |
else |
result = opt->value ? opt->value : opt->sname; |
} |
if (opt->func) |
opt->func(loptarg); |
return (result); |
} |
int getsingleopt (int argc, char *argv[], topt *opts) |
{ |
char *thisopt; |
topt *opt; |
static char shortopt[2] = {0, 0}; |
if (loptind >= argc) |
return (GLO_END); |
thisopt = argv[loptind]; |
if (!loptchr) { /* start new option string */ |
if (thisopt[0] != '-' || !thisopt[1]) /* no more options */ |
return (GLO_END); |
if (thisopt[1] == '-') /* "--" */ |
if (thisopt[2]) { /* long option */ |
loptarg = thisopt+2; |
loptind++; |
if (!(opt = findopt(1, thisopt+2, opts))) |
return (GLO_UNKNOWN); |
else |
return (performoption(argc, argv, opt)); |
} |
else { /* "--" == end of options */ |
loptind++; |
return (GLO_END); |
} |
else /* start short option(s) */ |
loptchr = 1; |
} |
shortopt[0] = thisopt[loptchr]; |
loptarg = shortopt; |
opt = findopt(0, thisopt+(loptchr++), opts); |
if (!thisopt[loptchr]) { |
loptind++; |
loptchr = 0; |
} |
if (!opt) |
return (GLO_UNKNOWN); |
else |
return (performoption(argc, argv, opt)); |
} |
int getlopt (int argc, char *argv[], topt *opts) |
{ |
int result; |
while ((result = getsingleopt(argc, argv, opts)) == GLO_CONTINUE); |
return (result); |
} |
/* EOF */ |
/shark/trunk/ports/mpg123/tables.h |
---|
0,0 → 1,154 |
/* |
* Layer 2 Alloc tables .. |
* most other tables are calculated on program start (which is (of course) |
* not ISO-conform) .. |
* Layer-3 huffman table is in huffman.h |
*/ |
struct al_table alloc_0[] = { |
{4,0},{5,3},{3,-3},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},{10,-511}, |
{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},{16,-32767}, |
{4,0},{5,3},{3,-3},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},{10,-511}, |
{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},{16,-32767}, |
{4,0},{5,3},{3,-3},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},{10,-511}, |
{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},{16,-32767}, |
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, |
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, |
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, |
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, |
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, |
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, |
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, |
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, |
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, |
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, |
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, |
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, |
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, |
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, |
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, |
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, |
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, |
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, |
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, |
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, |
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, |
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, |
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, |
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, |
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, |
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, |
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, |
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, |
{2,0},{5,3},{7,5},{16,-32767}, |
{2,0},{5,3},{7,5},{16,-32767}, |
{2,0},{5,3},{7,5},{16,-32767}, |
{2,0},{5,3},{7,5},{16,-32767} }; |
struct al_table alloc_1[] = { |
{4,0},{5,3},{3,-3},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},{10,-511}, |
{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},{16,-32767}, |
{4,0},{5,3},{3,-3},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},{10,-511}, |
{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},{16,-32767}, |
{4,0},{5,3},{3,-3},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255},{10,-511}, |
{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383},{16,-32767}, |
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, |
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, |
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, |
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, |
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, |
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, |
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, |
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, |
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, |
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, |
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, |
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, |
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, |
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, |
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, |
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{16,-32767}, |
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, |
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, |
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, |
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, |
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, |
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, |
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, |
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, |
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, |
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, |
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, |
{3,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{16,-32767}, |
{2,0},{5,3},{7,5},{16,-32767}, |
{2,0},{5,3},{7,5},{16,-32767}, |
{2,0},{5,3},{7,5},{16,-32767}, |
{2,0},{5,3},{7,5},{16,-32767}, |
{2,0},{5,3},{7,5},{16,-32767}, |
{2,0},{5,3},{7,5},{16,-32767}, |
{2,0},{5,3},{7,5},{16,-32767} }; |
struct al_table alloc_2[] = { |
{4,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255}, |
{10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383}, |
{4,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255}, |
{10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383}, |
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, |
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, |
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, |
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, |
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, |
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63} }; |
struct al_table alloc_3[] = { |
{4,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255}, |
{10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383}, |
{4,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127},{9,-255}, |
{10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191},{15,-16383}, |
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, |
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, |
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, |
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, |
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, |
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, |
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, |
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, |
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, |
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63} }; |
struct al_table alloc_4[] = { |
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, |
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191}, |
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, |
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191}, |
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, |
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191}, |
{4,0},{5,3},{7,5},{3,-3},{10,9},{4,-7},{5,-15},{6,-31},{7,-63},{8,-127}, |
{9,-255},{10,-511},{11,-1023},{12,-2047},{13,-4095},{14,-8191}, |
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, |
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, |
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, |
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, |
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, |
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, |
{3,0},{5,3},{7,5},{10,9},{4,-7},{5,-15},{6,-31},{7,-63}, |
{2,0},{5,3},{7,5},{10,9}, |
{2,0},{5,3},{7,5},{10,9}, |
{2,0},{5,3},{7,5},{10,9}, |
{2,0},{5,3},{7,5},{10,9}, |
{2,0},{5,3},{7,5},{10,9}, |
{2,0},{5,3},{7,5},{10,9}, |
{2,0},{5,3},{7,5},{10,9}, |
{2,0},{5,3},{7,5},{10,9}, |
{2,0},{5,3},{7,5},{10,9}, |
{2,0},{5,3},{7,5},{10,9}, |
{2,0},{5,3},{7,5},{10,9}, |
{2,0},{5,3},{7,5},{10,9}, |
{2,0},{5,3},{7,5},{10,9}, |
{2,0},{5,3},{7,5},{10,9}, |
{2,0},{5,3},{7,5},{10,9}, |
{2,0},{5,3},{7,5},{10,9}, |
{2,0},{5,3},{7,5},{10,9}, |
{2,0},{5,3},{7,5},{10,9}, |
{2,0},{5,3},{7,5},{10,9} }; |
/shark/trunk/ports/mpg123/httpget.c |
---|
0,0 → 1,209 |
/* |
* httpget.c |
* |
* Oliver Fromme <oliver.fromme@heim3.tu-clausthal.de> |
* Wed Apr 9 20:57:47 MET DST 1997 |
*/ |
#include <stdlib.h> |
#include <stdio.h> |
#include <string.h> |
#include <netdb.h> |
#include <sys/param.h> |
#include <sys/types.h> |
#include <sys/socket.h> |
#include <netinet/in.h> |
#include <arpa/inet.h> |
#include <sys/errno.h> |
extern int errno; |
#include "mpg123.h" |
#ifndef INADDR_NONE |
#define INADDR_NONE 0xffffffff |
#endif |
void writestring (int fd, char *string) |
{ |
int result, bytes = strlen(string); |
while (bytes) { |
if ((result = write(fd, string, bytes)) < 0 && errno != EINTR) { |
perror ("write"); |
exit (1); |
} |
else if (result == 0) { |
fprintf (stderr, "write: %s\n", |
"socket closed unexpectedly"); |
exit (1); |
} |
string += result; |
bytes -= result; |
} |
} |
void readstring (char *string, int maxlen, FILE *f) |
{ |
char *result; |
do { |
result = fgets(string, maxlen, f); |
} while (!result && errno == EINTR); |
if (!result) { |
fprintf (stderr, "Error reading from socket or unexpected EOF.\n"); |
exit (1); |
} |
} |
char *url2hostport (char *url, char **hname, unsigned long *hip, unsigned int *port) |
{ |
char *cptr; |
struct hostent *myhostent; |
struct in_addr myaddr; |
int isip = 1; |
if (!(strncmp(url, "http://", 7))) |
url += 7; |
cptr = url; |
while (*cptr && *cptr != ':' && *cptr != '/') { |
if ((*cptr < '0' || *cptr > '9') && *cptr != '.') |
isip = 0; |
cptr++; |
} |
if (!(*hname = strndup(url, cptr - url))) { |
*hname = NULL; |
return (NULL); |
} |
if (!isip) { |
if (!(myhostent = gethostbyname(*hname))) |
return (NULL); |
memcpy (&myaddr, myhostent->h_addr, sizeof(myaddr)); |
*hip = myaddr.s_addr; |
} |
else |
if ((*hip = inet_addr(*hname)) == INADDR_NONE) |
return (NULL); |
if (!*cptr || *cptr == '/') { |
*port = 80; |
return (cptr); |
} |
*port = atoi(++cptr); |
while (*cptr && *cptr != '/') |
cptr++; |
return (cptr); |
} |
char *proxyurl = NULL; |
unsigned long proxyip = 0; |
unsigned int proxyport; |
#define ACCEPT_HEAD "Accept: audio/mpeg, audio/x-mpegurl, */*\r\n" |
FILE *http_open (char *url) |
{ |
char *purl, *host, *request, *sptr; |
int linelength; |
unsigned long myip; |
unsigned int myport; |
int sock; |
int relocate, numrelocs = 0; |
struct sockaddr_in server; |
FILE *myfile; |
if (!proxyip) { |
if (!proxyurl) |
if (!(proxyurl = getenv("MP3_HTTP_PROXY"))) |
if (!(proxyurl = getenv("http_proxy"))) |
proxyurl = getenv("HTTP_PROXY"); |
if (proxyurl && proxyurl[0] && strcmp(proxyurl, "none")) { |
if (!(url2hostport(proxyurl, &host, &proxyip, &proxyport))) { |
fprintf (stderr, "Unknown proxy host \"%s\".\n", |
host ? host : ""); |
exit (1); |
} |
if (host) |
free (host); |
} |
else |
proxyip = INADDR_NONE; |
} |
if ((linelength = strlen(url)+200) < 1024) |
linelength = 1024; |
if (!(request = malloc(linelength)) || !(purl = malloc(1024))) { |
fprintf (stderr, "malloc() failed, out of memory.\n"); |
exit (1); |
} |
strncpy (purl, url, 1023); |
purl[1023] = '\0'; |
do { |
strcpy (request, "GET "); |
if (proxyip != INADDR_NONE) { |
if (strncmp(url, "http://", 7)) |
strcat (request, "http://"); |
strcat (request, purl); |
myport = proxyport; |
myip = proxyip; |
} |
else { |
if (!(sptr = url2hostport(purl, &host, &myip, &myport))) { |
fprintf (stderr, "Unknown host \"%s\".\n", |
host ? host : ""); |
exit (1); |
} |
if (host) |
free (host); |
strcat (request, sptr); |
} |
sprintf (request + strlen(request), |
" HTTP/1.0\r\nUser-Agent: %s/%s\r\n", |
prgName, prgVersion); |
strcat (request, ACCEPT_HEAD); |
strcat (request, "\r\n"); |
server.sin_family = AF_INET; |
server.sin_port = htons(myport); |
server.sin_addr.s_addr = myip; |
if ((sock = socket(PF_INET, SOCK_STREAM, 6)) < 0) { |
perror ("socket"); |
exit (1); |
} |
if (connect(sock, (struct sockaddr *)&server, sizeof(server))) { |
perror ("connect"); |
exit (1); |
} |
writestring (sock, request); |
if (!(myfile = fdopen(sock, "rb"))) { |
perror ("fdopen"); |
exit (1); |
}; |
relocate = FALSE; |
purl[0] = '\0'; |
readstring (request, linelength-1, myfile); |
if ((sptr = strchr(request, ' '))) { |
switch (sptr[1]) { |
case '3': |
relocate = TRUE; |
case '2': |
break; |
default: |
fprintf (stderr, "HTTP request failed: %s", |
sptr+1); /* '\n' is included */ |
exit (1); |
} |
} |
do { |
readstring (request, linelength-1, myfile); |
if (!strncmp(request, "Location:", 9)) |
strncpy (purl, request+10, 1023); |
} while (request[0] != '\r' && request[0] != '\n'); |
} while (relocate && purl[0] && numrelocs++ < 5); |
if (relocate) { |
fprintf (stderr, "Too many HTTP relocations.\n"); |
exit (1); |
} |
free (purl); |
free (request); |
return (myfile); |
} |
/* EOF */ |
/shark/trunk/ports/mpg123/getbits.s |
---|
0,0 → 1,68 |
.globl getbits |
.type getbits,@function |
getbits: |
cmpl $0,4(%esp) |
jne .L1 |
xorl %eax,%eax |
ret |
.L1: |
movl wordpointer,%ecx |
movzbl (%ecx),%eax |
shll $16,%eax |
movb 1(%ecx),%ah |
movb 2(%ecx),%al |
movl bitindex,%ecx |
shll $8,%eax |
shll %cl,%eax |
movl 4(%esp),%ecx |
addl %ecx,bitindex |
negl %ecx |
addl $32,%ecx |
shrl %cl,%eax |
movl bitindex,%ecx |
sarl $3,%ecx |
addl %ecx,wordpointer |
andl $7,bitindex |
ret |
.globl getbits_fast |
.type getbits_fast,@function |
getbits_fast: |
movl wordpointer,%ecx |
movzbl 1(%ecx),%eax |
movb (%ecx),%ah |
movl bitindex,%ecx |
shlw %cl,%ax |
movl 4(%esp),%ecx |
addl %ecx,bitindex |
negl %ecx |
addl $16,%ecx |
shrl %cl,%eax |
movl bitindex,%ecx |
sarl $3,%ecx |
addl %ecx,wordpointer |
andl $7,bitindex |
ret |
.globl get1bit |
.type get1bit,@function |
get1bit: |
movl wordpointer,%ecx |
movzbl (%ecx),%eax |
movl bitindex,%ecx |
incl %ecx |
rolb %cl,%al |
andb $1,%al |
movl %ecx,bitindex |
andl $7,bitindex |
sarl $3,%ecx |
addl %ecx,wordpointer |
ret |
/shark/trunk/ports/mpg123/getlopt.h |
---|
0,0 → 1,65 |
/* |
* getlopt.h |
* |
* Oliver Fromme <oliver.fromme@heim3.tu-clausthal.de> |
* Tue Apr 8 07:13:39 MET DST 1997 |
*/ |
#include <stdlib.h> |
#include <string.h> |
extern int loptind; /* index in argv[] */ |
extern int loptchr; /* index in argv[loptind] */ |
extern char *loptarg; /* points to argument if present, else to option */ |
typedef struct { |
char sname; /* short option name, can be 0 */ |
char *lname; /* long option name, can be 0 */ |
int flags; /* see below */ |
void (*func)(char *); /* called if != 0 (after setting of var) */ |
void *var; /* type is *int, *char or **char, see below */ |
int value; |
} topt; |
#define GLO_ARG 1 |
#define GLO_CHAR 2 |
#define GLO_NUM 0 |
/* flags: |
* bit 0 = 0 - no argument |
* if var != NULL |
* *var := value or (char)value [see bit 1] |
* else |
* loptarg = &option |
* return ((value != 0) ? value : sname) |
* bit 0 = 1 - argument required |
* if var != NULL |
* *var := atoi(arg) or strdup(arg) [see bit 1] |
* else |
* loptarg = &arg |
* return ((value != 0) ? value : sname) |
* |
* bit 1 = 0 - var is a pointer to an int |
* bit 1 = 1 - var is a pointer to a char (or string), |
* and value is interpreted as char |
* |
* Note: The options definition is terminated by a topt |
* containing only zeroes. |
*/ |
#define GLO_END 0 |
#define GLO_UNKNOWN -1 |
#define GLO_NOARG -2 |
#define GLO_CONTINUE -3 |
int getlopt (int argc, char *argv[], topt *opts); |
/* return values: |
* GLO_END (0) end of options |
* GLO_UNKNOWN (-1) unknown option *loptarg |
* GLO_NOARG (-2) missing argument |
* GLO_CONTINUE (-3) (reserved for internal use) |
* else - return value according to flags (see above) |
*/ |
/* EOF */ |
/shark/trunk/ports/mpg123/todo |
---|
0,0 → 1,20 |
Layer-1 support not heavily tested .. |
I-stereo in Level-3 seems to work now, but I have to optimize it. |
general optimizations in Level-3 code. |
add CRC check. |
no 'free format stream' support. |
in layer2.c: |
step_two: fraction as pointer .. |
process first channel 0 than channel 1 |
copy channel 0 to channel 1 for: i >= jsbound |
- better frame reader .. especially for layer 3 |
- MPEG system stream decoder |
- check again layer1 !! |
- Write a special (optimized) 'single channel' decode. |
- optimized dct64 for down sampling modes |
- native audio support for AIX and DEC |
/shark/trunk/ports/mpg123/makefile.ori |
---|
0,0 → 1,219 |
### |
### mpg123 Makefile |
### |
# Where to install binary and manpage on "make install": |
PREFIX=/usr/local |
BINDIR=$(PREFIX)/bin |
MANDIR=$(PREFIX)/man |
SECTION=1 |
################################################### |
###### ###### |
###### End of user-configurable settings ###### |
###### ###### |
################################################### |
nothing-specified: |
@echo "" |
@echo "You must specify the system which you want to compile for:" |
@echo "" |
@echo "make linux Linux" |
@echo "make freebsd FreeBSD" |
@echo "make solaris Solaris 2.x (tested: 2.5 and 2.5.1) using SparcWorks cc" |
@echo "make solaris-gcc Solaris 2.x using GNU cc (somewhat slower)" |
@echo "make sunos SunOS 4.x (tested: 4.1.4)" |
@echo "make hpux HP/UX 9/10, /7xx" |
@echo "make sgi SGI running IRIX" |
@echo "make dec DEC Unix (tested: 3.2 and 4.0), OSF/1" |
@echo "make ultrix DEC Ultrix (tested: 4.4)" |
@echo "make aix IBM AIX (tested: 4.2)" |
@echo "make os2 IBM OS/2" |
@echo "make generic try this one if your system isn't listed above" |
@echo "" |
@echo "Please read the file INSTALL for additional information." |
@echo "" |
linux-devel: |
$(MAKE) OBJECTS='decode_i386.o dct64_i386.o' \ |
CC=gcc LDFLAGS= \ |
CFLAGS='-DREAL_IS_FLOAT -DLINUX -Wall -g -m486 \ |
-funroll-all-loops \ |
-finline-functions -ffast-math' \ |
mpg123 |
linux-profile: |
$(MAKE) OBJECTS='decode_i386.o dct64_i386.o' \ |
CC=gcc LDFLAGS='-pg' \ |
CFLAGS='-DREAL_IS_FLOAT -DLINUX -Wall -pg -m486 \ |
-funroll-all-loops \ |
-finline-functions -ffast-math' \ |
mpg123 |
linux: |
$(MAKE) CC=gcc LDFLAGS= \ |
OBJECTS='decode_i386.o dct64_i386.o getbits.o' \ |
CFLAGS='-DI386_ASSEM -DREAL_IS_FLOAT -DLINUX -Wall -O2 -m486 \ |
-fomit-frame-pointer -funroll-all-loops \ |
-finline-functions -ffast-math' \ |
mpg123 |
linux-sajber: |
$(MAKE) CC=gcc LDFLAGS= \ |
OBJECTS='decode_i386.o dct64_i386.o getbits.o control.o' \ |
CFLAGS='-DFRONTEND -DI386_ASSEM -DREAL_IS_FLOAT -DLINUX -Wall -O2 -m486\ |
-fomit-frame-pointer -funroll-all-loops \ |
-finline-functions -ffast-math' \ |
sajberplay |
#### the following defines are for experimental use ... |
# |
#CFLAGS='-pg -DI386_ASSEM -DREAL_IS_FLOAT -DLINUX -Wall -O2 -m486 -funroll-all-loops -finline-functions -ffast-math' mpg123 |
#CFLAGS='-DI386_ASSEM -O2 -DREAL_IS_FLOAT -DLINUX -Wall -g' |
#CFLAGS='-DI386_ASSEM -DREAL_IS_FLOAT -DLINUX -Wall -O2 -m486 -fomit-frame-pointer -funroll-all-loops -finline-functions -ffast-math -malign-loops=2 -malign-jumps=2 -malign-functions=2' |
freebsd: |
$(MAKE) CC=cc LDFLAGS= \ |
OBJECTS='decode_i386.o dct64_i386.o getbits_.o' \ |
CFLAGS='-Wall -ansi -pedantic -O4 -m486 -fomit-frame-pointer \ |
-funroll-all-loops -ffast-math -DROT_I386 \ |
-DI386_ASSEM -DREAL_IS_FLOAT -DUSE_MMAP' \ |
mpg123 |
solaris: |
$(MAKE) CC=cc LDFLAGS='-lsocket -lnsl' OBJECTS='decode.o dct64.o' \ |
CFLAGS='-fast -native -xO5 -DSOLARIS -DREAL_IS_FLOAT \ |
-DUSE_MMAP' \ |
mpg123 |
solaris-gcc: |
$(MAKE) CC=gcc LDFLAGS='-lsocket -lnsl' OBJECTS='decode.o dct64.o' \ |
CFLAGS='-O2 -Wall -DSOLARIS -DREAL_IS_FLOAT -DUSE_MMAP \ |
-funroll-all-loops -finline-functions' \ |
mpg123 |
sunos: |
$(MAKE) CC=gcc LDFLAGS= OBJECTS='decode.o dct64.o' \ |
CFLAGS='-O2 -DSUNOS -DREAL_IS_FLOAT -DUSE_MMAP \ |
-funroll-loops' \ |
mpg123 |
hpux: |
$(MAKE) CC=cc LDFLAGS= OBJECTS='decode.o dct64.o' \ |
CFLAGS='-DREAL_IS_FLOAT -Aa +O3 -D_HPUX_SOURCE -DHPUX' \ |
mpg123 |
sgi: |
$(MAKE) CC=cc LDFLAGS= OBJECTS='decode.o dct64.o' AUDIO_LIB=-laudio \ |
CFLAGS='-O2 -DSGI -DREAL_IS_FLOAT -DUSE_MMAP' \ |
mpg123 |
dec: |
$(MAKE) CC=cc LDFLAGS= OBJECTS='decode.o dct64.o' \ |
CFLAGS='-std1 -warnprotos -O4 -DUSE_MMAP' \ |
mpg123 |
ultrix: |
$(MAKE) CC=cc LDFLAGS= OBJECTS='decode.o dct64.o' \ |
CFLAGS='-std1 -O2 -DULTRIX' \ |
mpg123 |
aix: |
$(MAKE) LDFLAGS= OBJECTS='decode.o dct64.o' \ |
CFLAGS='-O -DAIX -DUSE_MMAP' \ |
mpg123 |
os2: |
$(MAKE) CC=gcc LDFLAGS= \ |
OBJECTS='decode_i386.o dct64_i386.o' \ |
CFLAGS='-DREAL_IS_FLOAT -DOS2 -Wall -O2 -m486 \ |
-fomit-frame-pointer -funroll-all-loops \ |
-finline-functions -ffast-math' \ |
LIBS='-los2me -lsocket' \ |
mpg123.exe |
generic: |
$(MAKE) LDFLAGS= OBJECTS='decode.o dct64.o' \ |
CFLAGS='-O' \ |
mpg123 |
sajberplay: mpg123.o common.o $(OBJECTS) decode_2to1.o decode_4to1.o \ |
tabinit.o audio.o layer1.o layer2.o layer3.o buffer.o \ |
getlopt.o httpget.o xfermem.o Makefile |
$(CC) $(CFLAGS) $(LDFLAGS) mpg123.o tabinit.o common.o layer1.o \ |
layer2.o layer3.o audio.o buffer.o decode_2to1.o \ |
decode_4to1.o getlopt.o httpget.o xfermem.o $(OBJECTS) \ |
-o sajberplay -lm $(AUDIO_LIB) |
mpg123: mpg123.o common.o $(OBJECTS) decode_2to1.o decode_4to1.o \ |
tabinit.o audio.o layer1.o layer2.o layer3.o buffer.o \ |
getlopt.o httpget.o xfermem.o Makefile |
$(CC) $(CFLAGS) $(LDFLAGS) mpg123.o tabinit.o common.o layer1.o \ |
layer2.o layer3.o audio.o buffer.o decode_2to1.o \ |
decode_4to1.o getlopt.o httpget.o xfermem.o $(OBJECTS) \ |
-o mpg123 -lm $(AUDIO_LIB) |
mpg123.exe: mpg123.o common.o $(OBJECTS) decode_2to1.o decode_4to1.o \ |
tabinit.o audio.o layer1.o layer2.o layer3.o buffer.o \ |
getlopt.o httpget.o Makefile |
$(CC) $(CFLAGS) $(LDFLAGS) mpg123.o tabinit.o common.o layer1.o \ |
layer2.o layer3.o audio.o buffer.o decode_2to1.o \ |
decode_4to1.o getlopt.o httpget.o $(OBJECTS) \ |
-o mpg123.exe -lm $(LIBS) |
tst: |
gcc $(CFLAGS) -S decode.c |
layer1.o: mpg123.h |
layer2.o: mpg123.h |
layer3.o: mpg123.h huffman.h get1bit.h |
decode.o: mpg123.h |
decode_int.o: mpg123.h |
decode_2to1.o: mpg123.h |
decode_4to1.o: mpg123.h |
decode_i386.o: mpg123.h |
common.o: mpg123.h tables.h |
mpg123.o: mpg123.h getlopt.h xfermem.h version.h |
mpg123.h: audio.h |
audio.o: mpg123.h |
buffer.o: mpg123.h xfermem.h |
getbits.o: mpg123.h |
getbits_.o: mpg123.h |
tabinit.o: mpg123.h |
getlopt.o: getlopt.h |
httpget.o: mpg123.h |
dct64.o: mpg123.h |
dct64_i386.o: mpg123.h |
xfermem.o: xfermem.h |
clean: |
rm -f *.o *core *~ mpg123 gmon.out sajberplay |
prepared-for-install: |
@if [ ! -x mpg123 ]; then \ |
echo '###' ; \ |
echo '### Before doing "make install", you have to compile the software.' ; \ |
echo '### Type "make" for more information.' ; \ |
echo '###' ; \ |
exit 1 ; \ |
fi |
install: prepared-for-install |
strip mpg123 |
if [ -x /usr/ccs/bin/mcs ]; then /usr/ccs/bin/mcs -d mpg123; fi |
cp -f mpg123 $(BINDIR) |
chmod 755 $(BINDIR)/mpg123 |
cp -f mpg123.1 $(MANDIR)/man$(SECTION) |
chmod 644 $(MANDIR)/man$(SECTION)/mpg123.1 |
if [ -r $(MANDIR)/windex ]; then catman -w -M $(MANDIR) $(SECTION); fi |
dist: clean |
DISTNAME="`basename \`pwd\``" ; \ |
sed '/prgDate/s_".*"_"'`date +%Y/%m/%d`'"_' version.h > version.new; \ |
mv -f version.new version.h; \ |
cd .. ; \ |
rm -f "$$DISTNAME".tar.gz "$$DISTNAME".tar ; \ |
tar cvf "$$DISTNAME".tar "$$DISTNAME" ; \ |
gzip -9 "$$DISTNAME".tar |
/shark/trunk/ports/mpg123/install |
---|
0,0 → 1,38 |
(1) Read the README file. |
(also read the JUKEBOX file if you wanna compile a player |
for the sajber jukebox) |
(2) Type "make" to see a list of supported hardware platforms |
and operating systems, then type the make command that |
best fits your system. |
(3) If compilation was successful, type "make install" to |
install the binary and the manual page in /usr/local. |
Have fun! |
Some additional remarks: |
- There is currently no direct audio hardware support for the |
"dec", "aix" and "generic" targets. That means that you |
have to use the "-s" commandline option to write the decoded |
audio data to stdout. |
- On Solaris, use Sun's SparcWorks compiler ("make solaris") |
if at all possible. It generates faster code than gcc, so |
use gcc only if there's no other way. |
- The macro "htons" causes a compiler warning in httpget.c |
(at least on FreeBSD 2.1.x). This can be safely ignored. |
- For Solaris 2.4: append the options "-L/usr/ucblib -lucb" |
at the end of the link command line. Do this ONLY for |
Solaris 2.4, NOT for Solaris 2.5 or newer versions. |
- The HP-UX port might be broken. I was able to compile it |
on an HP-UX 9 account, but there were some problems with |
libraries on HP-UX 10. I'm not an HP expert, but perhaps |
someone else can fix it. |
*** |
/shark/trunk/ports/mpg123/copying |
---|
0,0 → 1,30 |
Copyright (c) 1995-97 by Michael Hipp, all rights reserved. |
Parts of the software are contributed by other people, please |
refer to the README file for details. |
DISTRIBUTION: |
This software may be distributed freely, provided that it is |
distributed in its entirety, without modifications, and with |
the original copyright notice and license included. It may |
not be sold for profit or as "hidden" part of another software, |
but it may be included with collections of other free software, |
such as CD-ROM images of FTP servers and similar, provided that |
this software is not a significant part of that collection. |
Precompiled binaries of this software may be distributed in the |
same way, provided that this copyright notice and license is |
included without modification. |
USAGE: |
This software may be used freely, provided that the original |
author is always credited. If you intend to use this software |
as a significant part of business (for-profit) activities, you |
have to contact the author first. Also, any usage that is not |
covered by this license requires the explicit permission of |
the author. |
DISCLAIMER: |
This software is provided as-is. The author can not be held |
liable for any damage that might arise from the use of this |
software. Use it at your own risk. |
/shark/trunk/ports/mpg123/mpg123.1 |
---|
0,0 → 1,363 |
.\" @(#)mpg123.1 0.01 21-Apr-1997 OF; from mpg123 archive |
.TH mpg123 1 "21 Apr 1997" |
.SH NAME |
mpg123 \- play audio MPEG 1.0/2.0 file (layers 1, 2 and 3) |
.SH SYNOPSIS |
.B mpg123 |
[ |
.B \-tscvqy01m24 |
] |
[ |
.BI \-b " size" |
] |
[ |
.BI \-k " num" |
] |
[ |
.BI \-n " num" |
] |
[ |
.BI \-f " factor" |
] |
[ |
.BI \-r " rate" |
] |
[ |
.BI \-g " gain" |
] |
[ |
.BI \-a " dev" |
] |
[ |
.BR "\-o s" " | " "\-o h" " | " "\-o l" |
] |
[ |
.BI \-d " n" |
] |
[ |
.BI \-h " n" |
] |
[ |
.BI \-p " proxy" |
] |
[ |
.BI \-@ " file" |
] |
.IR file " ... | " URL " ... | " |
.B \- |
.SH DESCRIPTION |
.B mpg123 |
reads one or more |
.IR file\^ s |
(or standard input if ``\-'' is specified) or |
.IR URL\^ s |
and plays them on the audio device (default) or |
outputs them to stdout. |
.IR file\^ / URL |
is assumed to be an MPEG-1/2 audio bit stream. |
.SH OPTIONS |
.B mpg123 |
options may be either the traditional POSIX one letter options, |
or the GNU style long options. POSIX style options start with a |
single ``\-'', while GNU long options start with ``\-\^\-''. |
.TP |
.BR \-t ", " \-\^\-test |
Test mode. The audio stream is decoded, but no output occurs. |
.TP |
.BR \-s ", " \-\^\-stdout |
The decoded audio samples are written to standard output, |
instead of playing them through the audio device. This |
option must be used if your audio hardware is not supported |
by |
.BR mpg123 . |
The output format is raw (headerless) linear PCM audio data, |
16 bit, stereo, host byte order. |
.TP |
.BR \-c ", " \-\^\-check |
Check for filter range violations, and report them for each frame |
if any occur. |
.TP |
.BR \-v ", " \-\^\-verbose |
Increase the verbosity level. For example, displays the frame |
numbers during decoding. |
.TP |
.BR \-q ", " \-\^\-quiet |
Quiet. Suppress diagnostic messages. |
.TP |
.BR \-y ", " \-\^\-resync |
Try to resync and continue decoding if an error occurs in |
the input file. Also try to recover from certain broken |
headers. Useful if you have a broken MPEG file, on which |
.B mpg123 |
normally gives up saying `Illegal header'. Be careful: |
Broken locations in MPEG files might cause sharp, loud pops or |
clicks, which might damage your speakers if played too loud. |
.TP |
.BR \-0 ", " \-\^\-single0 "; " \-1 ", " \-\^\-single1 |
Decode only channel 0 (left) or channel 1 (right), |
respectively. These options are available for |
stereo MPEG streams only. |
.TP |
.BR \-m ", " \-\^\-singlemix |
Mix both channels. This option is available for |
stereo MPEG layer-3 streams only. It takes less |
CPU time than full stereo decoding. |
.TP |
.BR \-2 ", " \-\^\-2to1 "; " \-4 ", " \-\^\-4to1 |
Performs a downsampling of ratio 2:1 (22 kHz) or 4:1 (11 kHz) |
on the output stream, respectively. Saves some CPU cycles, but |
at least the 4:1 ratio sounds ugly. |
.TP |
\fB\-b \fIsize\fR, \fB\-\^\-buffer \fIsize |
Use an audio output buffer of |
.I size |
Kbytes. This is useful to bypass short periods of heavy |
system activity, which would normally cause the audio output |
to be interrupted. |
You should specify a buffer size of at least 1024 |
(i.e. 1 Mb, which equals about 6 seconds of audio data) or more; |
less than about 300 does not make much sense. The default is 0, |
which turns buffering off. |
.TP |
\fB\-k \fInum\fR, \fB\-\^\-skip \fInum |
Skip first |
.I num |
frames. By default the decoding starts at the first frame. |
.TP |
\fB\-n \fInum\fR, \fB\-\^\-frames \fInum |
Decode only |
.I num |
frames. By default the complete stream is decoded. |
.TP |
\fB\-f \fIfactor\fR, \fB\-\^\-scale \fIfactor |
Change scale factor (default: 32768). |
.TP |
\fB\-r \fIrate\fR, \fB\-\^\-rate \fIrate |
Set sample rate (default: automatic). You don't want to |
change this. |
.TP |
\fB\-g \fIgain\fR, \fB\-\^\-gain \fIgain |
Set audio hardware output gain (default: don't change). |
.TP |
\fB\-a \fIdev\fR, \fB\-\^\-audiodevice \fIdev |
Specify the audio device to use. The default is |
system-dependent (usually /dev/audio or /dev/dsp). |
Use this option if you have multiple audio devices and |
the default is not what you want. |
.TP |
.BR "\-o s" ", " \-\^\-speaker |
Direct audio output to the speaker. |
.TP |
.BR "\-o h" ", " \-\^\-headphones |
Direct audio output to the headphone connector. |
.TP |
.BR "\-o l" ", " \-\^\-lineout |
Direct audio output to the line-out connector. |
.TP |
\fB\-d \fIn\fR, \fB\-\^\-doublespeed \fIn |
Only play every |
.IR n 'th |
frame. This will cause the MPEG stream |
to be played |
.I n |
times faster, which can be used for special |
effects. Can also be combined with the |
.B \-\^\-halfspeed |
option to play 3 out of 4 frames etc. Don't expect great |
sound quality when using this option. |
.TP |
\fB\-h \fIn\fR, \fB\-\^\-halfspeed \fIn |
Play each frame |
.I n |
times. This will cause the MPEG stream |
to be played at |
.RI 1 / n 'th |
speed (n times slower), which can be |
used for special effects. Can also be combined with the |
.B \-\^\-doublespeed |
option to double every third frame or things like that. |
Don't expect great sound quality when using this option. |
.TP |
\fB\-p \fIURL \fR| \fBnone\fR, \fB\-\^\-proxy \fIURL \fR| \fBnone |
The specified |
.I proxy |
will be used for HTTP requests. It |
should be specified as full URL (``http://host.domain:port/''), |
but the ``http://'' prefix, the port number and the trailing |
slash are optional (the default port is 80). Specifying |
.B none |
means not to use any proxy, and to retrieve files directly |
from the respective servers. See also the |
``HTTP SUPPORT'' section. |
.TP |
\fB\-@ \fIfile\fR, \fB\-\^\-list \fIfile |
Read filenames and/or URLs of MPEG audio streams from the specified |
.I file |
in addition to the ones specified on the command line (if any). |
Note that |
.I file |
can be either an ordinary file, a dash ``\-'' to indicate that |
a list of filenames/URLs is to be read from the standard input, |
or an URL pointing to a an appropriate list file. Note: only |
one |
.B \-@ |
option can be used (if more than one is specified, only the |
last one will be recognized). |
.SH OPERANDS |
The following operands are supported: |
.TP 8 |
.IR file (s) |
The path name(s) of one or more input files. They must be |
valid MPEG-1/2 audio layer-1, -2 or -3 bit streams. |
If a dash ``\-'' is specified, MPEG data will |
be read from the standard input. Furthermore, any name |
starting with ``http://'' is recognized as |
.I URL |
(see next section). |
.SH HTTP SUPPORT |
In addition to reading MPEG audio streams from ordinary |
files and from the standard input, |
.B mpg123 |
supports retrieval of MPEG audio files via the HTTP protocol, |
which is used in the World Wide Web (WWW). Such files are |
specified using a so-called URL (universal resource |
location), which starts with ``http://''. When a file with |
that prefix is encountered, |
.B mpg123 |
attempts to open an HTTP connection to the server in order to |
retrieve that file to decode and play it. |
.P |
It is often useful to retrieve files through a WWW cache or |
so-called proxy. To accomplish this, |
.B mpg123 |
examines the environment for variables named |
.BR MP3_HTTP_PROXY ", " http_proxy " and " HTTP_PROXY , |
in this order. The value of the first one that is set will |
be used as proxy specification. To override this, you can |
use the |
.B \-p |
command line option (see the ``OPTIONS'' section). Specifying |
.B "\-p none" |
will enforce contacting the server directly without using |
any proxy, even if one of the above environment variables |
is set. |
.P |
Note that, in order to play MPEG audio files from a WWW |
server, it is necessary that the connection to that server |
is fast enough. For example, a 128 kbit/s MPEG file |
requires the network connection to be at least 128 kbit/s |
(16 kbyte/s) plus protocol overhead. If you suffer from |
short network outages, you should try the |
.B \-b |
option (buffer) to bypass such outages. If your network |
connection is generally not fast enough to retrieve MPEG |
audio files in realtime, you can first download the files |
to your local harddisk (e.g. using |
.BR lynx (1)) |
and then play them from there. |
.SH INTERRUPT |
You can abort |
.B mpg123 |
at any time by pressing Ctrl-C. If you are playing multiple |
files, this will stop the current file and begin playing the |
next one. If you want to abort playing immediately instead |
of skipping to the next file, press Ctrl-C twice in short |
succession (within about one second). |
.P |
Note that the result of pressing Ctrl-C might not be audible |
immediately, due to audio data buffering in the audio device. |
This delay is system dependent, but it is usually not more |
than one or two seconds. |
.SH "SEE ALSO" |
.BR lynx (1), |
.BR sox (1), |
.BR intro (1) |
.SH NOTES |
MPEG audio decoding requires a good deal of CPU performance, |
especially layer-3. To decode it in realtime, you should |
have at least a Pentium, Alpha, SuperSparc or equivalent |
processor. You can also use the |
.B -singlemix |
option to decode mono only, which reduces the CPU load |
somewhat for layer-3 streams. See also the |
.BR \-2 " and " \-4 |
options. |
.P |
If everything else fails, use the |
.B \-s |
option to decode to standard output, direct it into a file |
and then use an appropriate utility to play that file. |
You might have to use a tool such as |
.BR sox (1) |
to convert the output to an audio format suitable for |
your audio player. |
.P |
Also note that |
.B mpg123 |
always generates 16 bit stereo data (if one of the |
.BR \-single * |
options is used, two identical stereo channels are |
generated). If your hardware requires some other |
format, for example 8 bit mono, you also have |
to use a converter such as |
.BR sox (1). |
.P |
If your system is generally fast enough to decode in |
realtime, but there are sometimes periods of heavy |
system load (such as cronjobs, users logging in remotely, |
starting of ``big'' programs etc.) causing the |
audio output to be interrupted, then you should use |
the |
.B \-b |
option to use a buffer of at least 1000 Kbytes. |
.SH BUGS |
.TP |
Known bugs and limitations: |
.br |
MPEG-2, Layer 1 and 2 not tested. May not work. (Layer 3 should work.) |
.br |
Free format streams are not supported. |
.br |
Layer-1 support is not heavily tested. |
.br |
No CRC error checking is performed. |
.br |
There is currently no support for audio hardware on |
DEC Digital Unix, Ultrix and IBM AIX, therefore the |
.B \-s |
option has to be used on those platforms. |
.SH AUTHORS |
.TP |
Main author: |
.br |
Michael Hipp <Michael.Hipp@student.uni-tuebingen.de> |
.TP |
Uses code (or at least ideas) from: |
.br |
MPEG Software Simulation Group (Base package) |
.br |
Philipp Knirsch <phil@mpik-tueb.mpg.de> (DCT36/manual unroll) |
.br |
Tobias Bading <bading@cs.tu-berlin.de> (subband synthesis) |
.br |
Jeff Tsay <ctsay@pasteur.eecs.berkeley.edu> (DCT36) |
.br |
Thomas Woerner (SGI Audio) |
.br |
Damien Clermonte <clermond@esiee.fr> (HP-UX audio fixes) |
.br |
Oliver Fromme <oliver.fromme@heim3.tu-clausthal.de> |
.P |
Internet references: |
.br |
http://www.sfs.nphil.uni-tuebingen.de/~hipp/mpg123.html |
.br |
http://www.heim3.tu-clausthal.de/~olli/mpg123/ |
.br |
(includes information about the mpg123 mailing list) |
.P |
The latest version is also available from here: |
.br |
ftp.tu-clausthal.de:/pub/unix/audio/mpg123 |
.br |
http://ftp.tu-clausthal.de/pub/unix/audio/mpg123 |
/shark/trunk/ports/mpg123/changes |
---|
0,0 → 1,247 |
0.59k: (OF) |
------ |
- fixed "Accept" header in httpget.c |
- fixed buffer overflow (causing core dumps) in httpget.c |
- fixed display of song length |
- fixed -b (buffer) problem on SGI / IRIX -- it definitely works now |
- fixed problem when files with different sample rates where played, |
it now works with -b (buffer), too |
- fixed order of local variables in decode.c to work around a |
compiler bug in ultrix |
- fixed Makefile for ultrix |
- reverted to old getbits.s (the new one could cause coredumps) |
- more compact MPEG header display in non-verbose mode |
- small fixes in buffer code and elsewhere |
0.59j: (MH) |
------ |
- added sajber jukebox control interface (it's currently a big hack) |
(see 'JUKEBOX' file for more) |
- added simple rewind facility .. (only used by sajber interface at the moment) |
0.59i: (MH) |
----------- |
- added front-end (remote) patch from "Brian J. Swetland" <swetland@uiuc.edu> |
- added OS2 patches from Niclas Lindstrom <nil@wineasy.se> |
- fixed 'rewind bug' |
- added patches from Leo Broukhis <leo@zycad.com> |
- added shuffle patch from Tillmann Steinbrecher <tst@darmstadt.netsurf.de> |
- added i386-getbits from M.Stekelenburg <m.stekelenburg@student.utwente.nl> |
- added fallback to 8bit if no 16bit samples support (currently linux only) |
- added (slightly changed) outburst patch |
from Antti Andreimann <anttix@cyberix.edu.ee> |
- added 'http accept' patch from Hur TaeSung <saturn@arari.snu.ac.kr> |
- fixed buffer mode bug |
0.59h: (MH) |
------ |
- added '--8bit' option to force 'ULAW 8 BIT' playing |
- pcm buffer type changed to 'unsigned char *' |
- plays 2:1 and 4:1 with the real frequency (ie 11025/22050 instead |
of 44100) |
- program (re)sets (changed) frequency for every frame |
- buffer mode is broken |
0.59g: (MH) |
------ |
- added support for MPEG 2.5 (it's a HACK!) .. mpg123 understands and plays |
2.5 but it does it wrong. (you will hear this!) |
- Fixed wrong values in BandInfo struct for 32kHz mode |
- Some performance improvements and minor changes and bug-fixes. |
- Tried the new imdct from the maplay1.2+ (version 1.81) package. (but |
it was slightly slower on my system, currently disabled) |
0.59f: (OF) |
------ |
- HP-UX audio fix (provided by Damien Clermonte) |
- Buffering (-b option) hopefully fixed. Please test! |
0.59e: |
------ |
- added Audio MPEG 2.0 support (but near untested) (MH) |
0.59d: (MH) |
------ |
- minor modifications to dct64_i386.c |
- removed duplicated dependency 'dct64.o' in Makefile |
0.59c: (OF) |
------ |
Another complete rework of the buffer system (-b option) |
(normally uses mmap(), but it can also use SYSV-ShMem because |
mmap() is broken on linux). |
0.59: (MH) |
----- |
extracted dct64() from decode*.c files. |
some changes to dct64() and decode*.c to allow auto-increment/decrement |
removed bit-counter in getbit-functions. Layer3 part2 now counts it itself. |
0.58: (OF) |
----- |
Bugfix: not closing the audio device caused a few samples to be lost. |
Bugfix: audio_set_rate() was not called (!?!). |
Additional command line options "--doublespeed" and "--halfspeed" |
(couldn't find better names). See the manpage. |
Complete redesign of command line options. See the manpage. |
Changed the buffer algorithm (-b). I'm not sure whether it's better |
or worse now. |
Supports multiple files on the command line. Pressing Ctrl-C will |
skip to the next MPEG file, pressing it twice within one second |
will abort mpg123 completely. See the "INTERRUPT" section in the |
manpage. |
Support for http URLs. See also the -p option in the manpage. |
Support for list files. See also the -@ option in the manpage. |
0.57: (MH) |
----- |
Put the downsampling code together with the full |
quality decode into one binary. (new options -2to1,-4to1) |
Optimizations in the dct12. |
Removed the 'int' version. |
0.56: (OF) |
----- |
Additional command line option "-rs" to try to resync on |
"broken" MPEG streams (now called "--resync" or "-y"). |
Additional command line option "-b" to use audio output buffering. |
See the manpage for additional information. |
Changed a few variable names and some other minor fixes, so the |
source compiles more cleanly (without warnings) on most |
platforms (for example, the FreeBSD port compiles without |
warnings using "-Wall -ansi -pedantic"). |
Makefile changes: moved "solaris" to "solaris-gcc", new target |
"solaris" (using Sun's SparcWorks cc, faster tha gcc!), new |
targets "aix" and "generic". |
0.55: |
----- |
removed some obsolete code from layer3.c (MH) |
changed scalefac stoing in layer3 (MH) |
decode_4to1.c added again. Renamed decode_lp.c to decode_2to1.c (MH) |
(both not optimized .. still expterimental) |
Minor cleanups and optimizations in layer3. (MH) |
Removed some (probable) minor bugs. (MH) |
Changed 2**(...) scaling (and omitted a few muls) (MH) |
Changed Makefile (OF) |
Changed dequantize to reorder with a mapping table |
(you can disable this by undefining MAP in layer3.c) (MH) |
removed the 'dummy' scale step for mixed mode (MH) |
Changed copy policy (MH) |
Modified dequant-reorder-mapping (MH) |
0.54: (MH) |
----- |
Minor changes in the documents .. |
huffman.c: x->len,y->len removed .. always '15' for the important cases |
audio.c: some additions to the SOLARIS audio code |
0.53b: (OF) |
------ |
Makefile: |
Renamed SPARC10 to SUNOS (which is more appropriate). |
Tested with SunOS 4.1.4 on a SPARCstation SLC, 20 MHz |
(322% CPU, so no realtime decoding). |
Added SOLARIS. Tested with Solaris 2.5.1 on an Ultra 1, |
167 MHz (14% CPU), a SPARCstation 5, 110 MHz (47% CPU), |
and a SPARCstation 10, 33 MHz (68% CPU). |
Added FreeBSD. Tested with 2.1.7 on a Pentium-90 (38% CPU) |
and 2.2 on a Pentium-166 (20% CPU). |
Added Digital Unix. Tested with DU 3.2 on a DEC 3000/500 |
(Alpha AXP 150 MHz, 33% CPU). Does not support DEC's |
audio interface ("AudioFile"), decodes to stdout only. |
Improved "clean" target to remove core files and editor |
backup files. |
Added "install" target. |
Added "dist" target to create a .tar.gz file of the source |
directory. |
In the distributed Makefile, all system sections are |
commented out. When you type "make" without uncommenting |
one of the sections, an appropriate error message will |
be displayed. |
audio.c |
Fixed problem when opening /dev/audio on Solaris: |
I had to remove O_NDELAY, because writing to /dev/audio |
didn't block until the requested number of samples |
could be written, but instead it wrote only as much |
samples as it was able too. Sounded funny. Removing |
O_NDELAY fixed the problem. I don't think that it |
hurts SunOS either, so I didn't make another #ifdef. |
common.c |
Fixed bug by adding function finish_output(): |
The decoder writes the audio samples into a buffer, and |
each time the buffer is full, it is written to the |
audio device (or to stdout). But when the decoding is |
done, there are some samples left in the buffer which |
aren't written yet -- they were just discarded. |
This additional function fixes the problem by writing |
the remaining samples from the buffer. It is called |
immediately after the main frame loop in mpg123.c. |
decode*.c |
Fixed compiler warning on symbol "div": |
Some compilers issue warnings because the symbol div is |
already used for something else (see "man div"), so I |
changed it to "divv". |
layer*.c |
Functions do_layer*: |
Moved the declaration for audio_play_samples into |
mpg123.h. Makes the code cleaner. |
I moved the variables pcm_samples and pcm_point to |
common.c, so they are shared between all modules. This |
was necessary because the finish_output() function |
(see common.c above) needs to access them. |
Renamed loop variables "i" and "j" to "k" in order to |
fix compiler warnings for duplicate/hidden symbols |
(similar to "div" in decode*.c, see above). |
Changed the preprocessor symbol AUDIOBUFSIZE into a |
global variable "audiobufsize". This makes it possible |
to change it by a command line option. |
layer1.c |
Fixed error in function I_step_one, second parameter: |
unsigned int scale_index[2][] --> ...[2][SBLIMIT] |
This caused an error with the DU compiler (which is ok, |
because [2][] is incorrect according to ANSI). I don't |
know whether [2][SBLIMIT] actually works correctly (I |
have no layer-1 streams to test it), but at least it |
compiles without error, and it appears to be correct |
(looking at the rest of the source). Heaven knows why |
gcc doesn't issue an error, and what it actually makes |
from it. |
mpg123.1 |
A simple manual page. Type "nroff -man mpg123.1 | more" |
to view it, or install it in /usr/local/man/man1 (this is |
done automatically by "make install"). |
mpg123.c |
New boolean variable "quiet": |
If this variable is set to TRUE (command line option |
-q), no messages are printed. |
*** |
/shark/trunk/ports/mpg123/common.c |
---|
0,0 → 1,673 |
#include <ctype.h> |
#include <stdlib.h> |
#include "mpg123.h" |
#include "tables.h" |
/* max = 1728 */ |
#define MAXFRAMESIZE 1792 |
#define SKIP_JUNK 1 |
int tabsel_123[2][3][16] = { |
{ {0,32,64,96,128,160,192,224,256,288,320,352,384,416,448,}, |
{0,32,48,56, 64, 80, 96,112,128,160,192,224,256,320,384,}, |
{0,32,40,48, 56, 64, 80, 96,112,128,160,192,224,256,320,} }, |
{ {0,32,48,56,64,80,96,112,128,144,160,176,192,224,256,}, |
{0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,}, |
{0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,} } |
}; |
long freqs[7] = { 44100, 48000, 32000, 22050, 24000, 16000 , 11025 }; |
#ifdef I386_ASSEM |
int bitindex; |
unsigned char *wordpointer; |
#else |
static int bitindex; |
static unsigned char *wordpointer; |
#endif |
static int fsize=0,fsizeold=0,ssize; |
static unsigned char bsspace[2][MAXFRAMESIZE+512]; /* MAXFRAMESIZE */ |
static unsigned char *bsbuf=bsspace[1],*bsbufold; |
static int bsnum=0; |
struct ibuf { |
struct ibuf *next; |
struct ibuf *prev; |
unsigned char *buf; |
unsigned char *pnt; |
int len; |
/* skip,time stamp */ |
}; |
struct ibuf ibufs[2]; |
struct ibuf *cibuf; |
int ibufnum=0; |
unsigned char *pcm_sample; |
int pcm_point = 0; |
int audiobufsize = AUDIOBUFSIZE; |
#ifdef VARMODESUPPORT |
/* |
* This is a dirty hack! It might burn your PC and kill your cat! |
* When in "varmode", specially formatted layer-3 mpeg files are |
* expected as input -- it will NOT work with standard mpeg files. |
* The reason for this: |
* Varmode mpeg files enable my own GUI player to perform fast |
* forward and backward functions, and to jump to an arbitrary |
* timestamp position within the file. This would be possible |
* with standard mpeg files, too, but it would be a lot harder to |
* implement. |
* A filter for converting standard mpeg to varmode mpeg is |
* available on request, but it's really not useful on its own. |
* |
* Oliver Fromme <oliver.fromme@heim3.tu-clausthal.de> |
* Mon Mar 24 00:04:24 MET 1997 |
*/ |
int varmode = FALSE; |
int playlimit; |
#endif |
static FILE *filept; |
static int filept_opened; |
static void get_II_stuff(struct frame *fr) |
{ |
static int translate[3][2][16] = |
{ { { 0,2,2,2,2,2,2,0,0,0,1,1,1,1,1,0 } , |
{ 0,2,2,0,0,0,1,1,1,1,1,1,1,1,1,0 } } , |
{ { 0,2,2,2,2,2,2,0,0,0,0,0,0,0,0,0 } , |
{ 0,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0 } } , |
{ { 0,3,3,3,3,3,3,0,0,0,1,1,1,1,1,0 } , |
{ 0,3,3,0,0,0,1,1,1,1,1,1,1,1,1,0 } } }; |
int table,sblim; |
static struct al_table *tables[5] = |
{ alloc_0, alloc_1, alloc_2, alloc_3 , alloc_4 }; |
static int sblims[5] = { 27 , 30 , 8, 12 , 30 }; |
if(fr->lsf) |
table = 4; |
else |
table = translate[fr->sampling_frequency][2-fr->stereo][fr->bitrate_index]; |
sblim = sblims[table]; |
fr->alloc = tables[table]; |
fr->II_sblimit = sblim; |
} |
void audio_flush(int outmode, struct audio_info_struct *ai) |
{ |
if (pcm_point) { |
switch (outmode) { |
case DECODE_STDOUT: |
write (1, pcm_sample, pcm_point); |
break; |
case DECODE_AUDIO: |
audio_play_samples (ai, pcm_sample, pcm_point); |
break; |
case DECODE_BUFFER: |
write (buffer_fd[1], pcm_sample, pcm_point); |
break; |
} |
pcm_point = 0; |
} |
} |
void (*catchsignal(int signum, void(*handler)()))() |
{ |
struct sigaction new_sa; |
struct sigaction old_sa; |
new_sa.sa_handler = handler; |
sigemptyset(&new_sa.sa_mask); |
new_sa.sa_flags = 0; |
if (sigaction(signum, &new_sa, &old_sa) == -1) |
return ((void (*)()) -1); |
return (old_sa.sa_handler); |
} |
static unsigned long oldhead = 0; |
static unsigned long firsthead=0; |
void read_frame_init (void) |
{ |
oldhead = 0; |
firsthead = 0; |
} |
#define HDRCMPMASK 0xfffffd00 |
#if 0 |
#define HDRCMPMASK 0xfffffdft |
#endif |
/* |
* HACK,HACK,HACK |
* step back <num> frames |
*/ |
int back_frame(struct frame *fr,int num) |
{ |
long bytes; |
unsigned char buf[4]; |
unsigned long newhead; |
if(!firsthead) |
return 0; |
bytes = (fsize+8)*(num+2); |
if(fseek(filept,-bytes,SEEK_CUR) < 0) |
return -1; |
if(fread(buf,1,4,filept) != 4) |
return -1; |
newhead = (buf[0]<<24) + (buf[1]<<16) + (buf[2]<<8) + buf[3]; |
while( (newhead & HDRCMPMASK) != (firsthead & HDRCMPMASK) ) { |
if(fread(buf,1,1,filept) != 1) |
return -1; |
newhead <<= 8; |
newhead |= buf[0]; |
newhead &= 0xffffffff; |
} |
if( fseek(filept,-4,SEEK_CUR) < 0) |
return -1; |
read_frame(fr); |
read_frame(fr); |
if(fr->lay == 3) { |
set_pointer(512); |
} |
return 0; |
} |
int read_frame(struct frame *fr) |
{ |
static unsigned long newhead; |
static unsigned char ssave[34]; |
unsigned char hbuf[8]; |
static int framesize; |
static int halfphase = 0; |
int l; |
int try = 0; |
if (halfspeed) |
if (halfphase--) { |
bitindex = 0; |
wordpointer = (unsigned char *) bsbuf; |
if (fr->lay == 3) |
memcpy (bsbuf, ssave, ssize); |
return 1; |
} |
else |
halfphase = halfspeed - 1; |
#ifdef VARMODESUPPORT |
if (varmode) { |
if(fread(hbuf,1,8,filept) != 8) |
return 0; |
} |
else |
#endif |
read_again: |
if(fread(hbuf,1,4,filept) != 4) |
return 0; |
newhead = ((unsigned long) hbuf[0] << 24) | ((unsigned long) hbuf[1] << 16) | |
((unsigned long) hbuf[2] << 8) | (unsigned long) hbuf[3]; |
if(oldhead != newhead || !oldhead) |
{ |
fr->header_change = 1; |
#if 0 |
fprintf(stderr,"Major headerchange %08lx->%08lx.\n",oldhead,newhead); |
#endif |
init_resync: |
if( (newhead & 0xffe00000) != 0xffe00000) { |
#ifdef SKIP_JUNK |
if(!firsthead) { |
int i; |
/* I even saw RIFF headers at the beginning of MPEG streams ;( */ |
if(newhead == ('R'<<24)+('I'<<16)+('F'<<8)+'F') { |
char buf[40]; |
fprintf(stderr,"Skipped RIFF header\n"); |
fread(buf,1,68,filept); |
goto read_again; |
} |
/* give up after 1024 bytes */ |
for(i=0;i<1024;i++) { |
memmove (&hbuf[0], &hbuf[1], 3); |
if(fread(hbuf+3,1,1,filept) != 1) |
return 0; |
newhead <<= 8; |
newhead |= hbuf[3]; |
newhead &= 0xffffffff; |
goto init_resync; |
} |
fprintf(stderr,"Giving up searching valid MPEG header\n"); |
return 0; |
} |
#endif |
if (!quiet) |
fprintf(stderr,"Illegal Audio-MPEG-Header 0x%08lx at offset 0x%lx.\n", |
newhead,ftell(filept)-4); |
if (tryresync) { |
/* Read more bytes until we find something that looks |
reasonably like a valid header. This is not a |
perfect strategy, but it should get us back on the |
track within a short time (and hopefully without |
too much distortion in the audio output). */ |
do { |
try++; |
memmove (&hbuf[0], &hbuf[1], 7); |
#ifdef VARMODESUPPORT |
if (fread(&hbuf[varmode?7:3],1,1,filept) != 1) |
#else |
if (fread(&hbuf[3],1,1,filept) != 1) |
#endif |
return 0; |
/* This is faster than combining newhead from scratch */ |
newhead = ((newhead << 8) | hbuf[3]) & 0xffffffff; |
if (!oldhead) |
goto init_resync; /* "considered harmful", eh? */ |
} while ((newhead & HDRCMPMASK) != (oldhead & HDRCMPMASK) |
&& (newhead & HDRCMPMASK) != (firsthead & HDRCMPMASK)); |
if (!quiet) |
fprintf (stderr, "Skipped %d bytes in input.\n", try); |
} |
else |
return (0); |
} |
if (!firsthead) |
firsthead = newhead; |
if( newhead & (1<<20) ) { |
fr->lsf = (newhead & (1<<19)) ? 0x0 : 0x1; |
fr->mpeg25 = 0; |
} |
else { |
fr->lsf = 1; |
fr->mpeg25 = 1; |
} |
if (!tryresync || !oldhead) { |
/* If "tryresync" is true, assume that certain |
parameters do not change within the stream! */ |
fr->lay = 4-((newhead>>17)&3); |
fr->bitrate_index = ((newhead>>12)&0xf); |
if( ((newhead>>10)&0x3) == 0x3) { |
fprintf(stderr,"Stream error\n"); |
exit(1); |
} |
if(fr->mpeg25) |
fr->sampling_frequency = 6; |
else |
fr->sampling_frequency = ((newhead>>10)&0x3) + (fr->lsf*3); |
fr->error_protection = ((newhead>>16)&0x1)^0x1; |
} |
fr->padding = ((newhead>>9)&0x1); |
fr->extension = ((newhead>>8)&0x1); |
fr->mode = ((newhead>>6)&0x3); |
fr->mode_ext = ((newhead>>4)&0x3); |
fr->copyright = ((newhead>>3)&0x1); |
fr->original = ((newhead>>2)&0x1); |
fr->emphasis = newhead & 0x3; |
fr->stereo = (fr->mode == MPG_MD_MONO) ? 1 : 2; |
oldhead = newhead; |
if(!fr->bitrate_index) |
{ |
fprintf(stderr,"Free format not supported.\n"); |
return (0); |
} |
switch(fr->lay) |
{ |
case 1: |
fr->do_layer = do_layer1; |
#ifdef VARMODESUPPORT |
if (varmode) { |
fprintf(stderr,"Sorry, layer-1 not supported in varmode.\n"); |
return (0); |
} |
#endif |
fr->jsbound = (fr->mode == MPG_MD_JOINT_STEREO) ? |
(fr->mode_ext<<2)+4 : 32; |
framesize = (long) tabsel_123[fr->lsf][0][fr->bitrate_index] * 12000; |
framesize /= freqs[fr->sampling_frequency]; |
framesize = ((framesize+fr->padding)<<2)-4; |
break; |
case 2: |
fr->do_layer = do_layer2; |
#ifdef VARMODESUPPORT |
if (varmode) { |
fprintf(stderr,"Sorry, layer-2 not supported in varmode.\n"); |
return (0); |
} |
#endif |
get_II_stuff(fr); |
fr->jsbound = (fr->mode == MPG_MD_JOINT_STEREO) ? |
(fr->mode_ext<<2)+4 : fr->II_sblimit; |
framesize = (long) tabsel_123[fr->lsf][1][fr->bitrate_index] * 144000; |
framesize /= freqs[fr->sampling_frequency]; |
framesize += fr->padding - 4; |
break; |
case 3: |
fr->do_layer = do_layer3; |
if(fr->lsf) |
ssize = (fr->stereo == 1) ? 9 : 17; |
else |
ssize = (fr->stereo == 1) ? 17 : 32; |
if(fr->error_protection) |
ssize += 2; |
#ifdef VARMODESUPPORT |
if (varmode) |
playlimit = ((unsigned int) hbuf[6] << 8) | (unsigned int) hbuf[7]; |
framesize = ssize + |
(((unsigned int) hbuf[4] << 8) | (unsigned int) hbuf[5]); |
else { |
#endif |
framesize = (long) tabsel_123[fr->lsf][2][fr->bitrate_index] * 144000; |
framesize /= freqs[fr->sampling_frequency]<<(fr->lsf); |
framesize = framesize + fr->padding - 4; |
#ifdef VARMODESUPPORT |
} |
#endif |
break; |
default: |
fprintf(stderr,"Sorry, unknown layer type.\n"); |
return (0); |
} |
} |
else |
fr->header_change = 0; |
fsizeold=fsize; /* for Layer3 */ |
bsbufold = bsbuf; |
bsbuf = bsspace[bsnum]+512; |
bsnum = (bsnum + 1) & 1; |
fsize = framesize; |
if( (l=fread(bsbuf,1,fsize,filept)) != fsize) |
{ |
if(l <= 0) |
return 0; |
memset(bsbuf+l,0,fsize-l); |
} |
if (halfspeed && fr->lay == 3) |
memcpy (ssave, bsbuf, ssize); |
bitindex = 0; |
wordpointer = (unsigned char *) bsbuf; |
return 1; |
} |
#ifdef MPG123_REMOTE |
void print_rheader(struct frame *fr) |
{ |
static char *modes[4] = { "Stereo", "Joint-Stereo", "Dual-Channel", "Single-Channel" }; |
static char *layers[4] = { "Unknown" , "I", "II", "III" }; |
static char *mpeg_type[2] = { "1.0" , "2.0" }; |
/* version, layer, freq, mode, channels, bitrate, BPF */ |
fprintf(stderr,"@I %s %s %ld %s %d %d %d\n", |
mpeg_type[fr->lsf],layers[fr->lay],freqs[fr->sampling_frequency], |
modes[fr->mode],fr->stereo, |
tabsel_123[fr->lsf][fr->lay-1][fr->bitrate_index], |
fsize+4); |
} |
#endif |
void print_header(struct frame *fr) |
{ |
static char *modes[4] = { "Stereo", "Joint-Stereo", "Dual-Channel", "Single-Channel" }; |
static char *layers[4] = { "Unknown" , "I", "II", "III" }; |
fprintf(stderr,"MPEG %s, Layer: %s, Freq: %ld, mode: %s, modext: %d, BPF: %d\n", |
fr->mpeg25 ? "2.5" : (fr->lsf ? "2.0" : "1.0"), |
layers[fr->lay],freqs[fr->sampling_frequency], |
modes[fr->mode],fr->mode_ext,fsize+4); |
fprintf(stderr,"Channels: %d, copyright: %s, original: %s, CRC: %s, emphasis: %d.\n", |
fr->stereo,fr->copyright?"Yes":"No", |
fr->original?"Yes":"No",fr->error_protection?"Yes":"No", |
fr->emphasis); |
fprintf(stderr,"Bitrate: %d Kbits/s, Extension value: %d\n", |
tabsel_123[fr->lsf][fr->lay-1][fr->bitrate_index],fr->extension); |
} |
void print_header_compact(struct frame *fr) |
{ |
static char *modes[4] = { "stereo", "joint-stereo", "dual-channel", "mono" }; |
static char *layers[4] = { "Unknown" , "I", "II", "III" }; |
fprintf(stderr,"MPEG %s layer %s, %d kbit/s, %ld Hz %s\n", |
fr->mpeg25 ? "2.5" : (fr->lsf ? "2.0" : "1.0"), |
layers[fr->lay], |
tabsel_123[fr->lsf][fr->lay-1][fr->bitrate_index], |
freqs[fr->sampling_frequency], modes[fr->mode]); |
} |
/* |
* Allocate space for a new string containing the first |
* "num" characters of "src". The resulting string is |
* always zero-terminated. Returns NULL if malloc fails. |
*/ |
char *strndup (const char *src, int num) |
{ |
char *dst; |
if (!(dst = (char *) malloc(num+1))) |
return (NULL); |
dst[num] = '\0'; |
return (strncpy(dst, src, num)); |
} |
/* |
* Split "path" into directory and filename components. |
* |
* Return value is 0 if no directory was specified (i.e. |
* "path" does not contain a '/'), OR if the directory |
* is the same as on the previous call to this function. |
* |
* Return value is 1 if a directory was specified AND it |
* is different from the previous one (if any). |
*/ |
int split_dir_file (const char *path, char **dname, char **fname) |
{ |
static char *lastdir = NULL; |
char *slashpos; |
if ((slashpos = strrchr(path, '/'))) { |
*fname = slashpos + 1; |
*dname = strndup(path, 1 + slashpos - path); |
if (lastdir && !strcmp(lastdir, *dname)) { |
/*** same as previous directory ***/ |
free (*dname); |
*dname = lastdir; |
return 0; |
} |
else { |
/*** different directory ***/ |
if (lastdir) |
free (lastdir); |
lastdir = *dname; |
return 1; |
} |
} |
else { |
/*** no directory specified ***/ |
if (lastdir) { |
free (lastdir); |
lastdir = NULL; |
}; |
*dname = NULL; |
*fname = (char *)path; |
return 0; |
} |
} |
/* open the device to read the bit stream from it */ |
void open_stream(char *bs_filenam,int fd) |
{ |
filept_opened = 1; |
if (!bs_filenam) { |
if(fd < 0) { |
filept = stdin; |
filept_opened = 0; |
} |
else |
filept = fdopen(fd,"r"); |
} |
else if (!strncmp(bs_filenam, "http://", 7)) |
filept = http_open(bs_filenam); |
else if (!(filept = fopen(bs_filenam, "rb"))) { |
perror (bs_filenam); |
exit(1); |
} |
} |
/*close the device containing the bit stream after a read process*/ |
void close_stream(void) |
{ |
if (filept_opened) |
fclose(filept); |
} |
long tell_stream(void) |
{ |
return ftell(filept); |
} |
#if !defined(I386_ASSEM) || defined(DEBUG_GETBITS) |
#ifdef _gcc_ |
inline |
#endif |
unsigned int getbits(int number_of_bits) |
{ |
unsigned long rval; |
#ifdef DEBUG_GETBITS |
fprintf(stderr,"g%d",number_of_bits); |
#endif |
if(!number_of_bits) |
return 0; |
{ |
rval = wordpointer[0]; |
rval <<= 8; |
rval |= wordpointer[1]; |
rval <<= 8; |
rval |= wordpointer[2]; |
#if 0 |
rval = ((unsigned int) wordpointer[0] << 16)+((unsigned int) wordpointer[1]<<8)+ |
(unsigned int) wordpointer[2]; |
#endif |
rval <<= bitindex; |
rval &= 0xffffff; |
bitindex += number_of_bits; |
rval >>= (24-number_of_bits); |
wordpointer += (bitindex>>3); |
bitindex &= 7; |
} |
#ifdef DEBUG_GETBITS |
fprintf(stderr,":%x ",rval); |
#endif |
return rval; |
} |
#ifdef _gcc_ |
inline |
#endif |
unsigned int getbits_fast(int number_of_bits) |
{ |
unsigned long rval; |
#ifdef DEBUG_GETBITS |
fprintf(stderr,"g%d",number_of_bits); |
#endif |
{ |
rval = wordpointer[0]; |
rval <<= 8; |
rval |= wordpointer[1]; |
rval <<= bitindex; |
rval &= 0xffff; |
#if 0 |
rval = ((unsigned int) high << (8-bitindex) )+((unsigned int) (unsigned char) wordpointer[1]); |
#endif |
bitindex += number_of_bits; |
rval >>= (16-number_of_bits); |
wordpointer += (bitindex>>3); |
bitindex &= 7; |
} |
#ifdef DEBUG_GETBITS |
fprintf(stderr,":%x ",rval); |
#endif |
return rval; |
} |
#ifdef _gcc_ |
inline |
#endif |
unsigned int get1bit(void) |
{ |
unsigned char rval; |
#ifdef DEBUG_GETBITS |
fprintf(stderr,"g%d",1); |
#endif |
rval = *wordpointer << bitindex; |
bitindex++; |
wordpointer += (bitindex>>3); |
bitindex &= 7; |
#ifdef DEBUG_GETBITS |
fprintf(stderr,":%d ",rval>>7); |
#endif |
return rval>>7; |
} |
#endif |
void set_pointer(long backstep) |
{ |
wordpointer = bsbuf + ssize - backstep; |
if (backstep) |
memcpy(wordpointer,bsbufold+fsizeold-backstep,backstep); |
bitindex = 0; |
} |
/shark/trunk/ports/mpg123/huffman.h |
---|
0,0 → 1,332 |
/* |
* huffman tables ... recalcualted to work with my optimzed |
* decoder scheme (MH) |
* |
* probably we could save a few bytes of memory, because the |
* smaller tables are often the part of a bigger table |
*/ |
struct newhuff |
{ |
unsigned int linbits; |
short *table; |
}; |
static short tab0[] = |
{ |
0 |
}; |
static short tab1[] = |
{ |
-5, -3, -1, 17, 1, 16, 0 |
}; |
static short tab2[] = |
{ |
-15, -11, -9, -5, -3, -1, 34, 2, 18, -1, 33, 32, 17, -1, 1, |
16, 0 |
}; |
static short tab3[] = |
{ |
-13, -11, -9, -5, -3, -1, 34, 2, 18, -1, 33, 32, 16, 17, -1, |
1, 0 |
}; |
static short tab5[] = |
{ |
-29, -25, -23, -15, -7, -5, -3, -1, 51, 35, 50, 49, -3, -1, 19, |
3, -1, 48, 34, -3, -1, 18, 33, -1, 2, 32, 17, -1, 1, 16, |
0 |
}; |
static short tab6[] = |
{ |
-25, -19, -13, -9, -5, -3, -1, 51, 3, 35, -1, 50, 48, -1, 19, |
49, -3, -1, 34, 2, 18, -3, -1, 33, 32, 1, -1, 17, -1, 16, |
0 |
}; |
static short tab7[] = |
{ |
-69, -65, -57, -39, -29, -17, -11, -7, -3, -1, 85, 69, -1, 84, 83, |
-1, 53, 68, -3, -1, 37, 82, 21, -5, -1, 81, -1, 5, 52, -1, |
80, -1, 67, 51, -5, -3, -1, 36, 66, 20, -1, 65, 64, -11, -7, |
-3, -1, 4, 35, -1, 50, 3, -1, 19, 49, -3, -1, 48, 34, 18, |
-5, -1, 33, -1, 2, 32, 17, -1, 1, 16, 0 |
}; |
static short tab8[] = |
{ |
-65, -63, -59, -45, -31, -19, -13, -7, -5, -3, -1, 85, 84, 69, 83, |
-3, -1, 53, 68, 37, -3, -1, 82, 5, 21, -5, -1, 81, -1, 52, |
67, -3, -1, 80, 51, 36, -5, -3, -1, 66, 20, 65, -3, -1, 4, |
64, -1, 35, 50, -9, -7, -3, -1, 19, 49, -1, 3, 48, 34, -1, |
2, 32, -1, 18, 33, 17, -3, -1, 1, 16, 0 |
}; |
static short tab9[] = |
{ |
-63, -53, -41, -29, -19, -11, -5, -3, -1, 85, 69, 53, -1, 83, -1, |
84, 5, -3, -1, 68, 37, -1, 82, 21, -3, -1, 81, 52, -1, 67, |
-1, 80, 4, -7, -3, -1, 36, 66, -1, 51, 64, -1, 20, 65, -5, |
-3, -1, 35, 50, 19, -1, 49, -1, 3, 48, -5, -3, -1, 34, 2, |
18, -1, 33, 32, -3, -1, 17, 1, -1, 16, 0 |
}; |
static short tab10[] = |
{ |
-125,-121,-111, -83, -55, -35, -21, -13, -7, -3, -1, 119, 103, -1, 118, |
87, -3, -1, 117, 102, 71, -3, -1, 116, 86, -1, 101, 55, -9, -3, |
-1, 115, 70, -3, -1, 85, 84, 99, -1, 39, 114, -11, -5, -3, -1, |
100, 7, 112, -1, 98, -1, 69, 53, -5, -1, 6, -1, 83, 68, 23, |
-17, -5, -1, 113, -1, 54, 38, -5, -3, -1, 37, 82, 21, -1, 81, |
-1, 52, 67, -3, -1, 22, 97, -1, 96, -1, 5, 80, -19, -11, -7, |
-3, -1, 36, 66, -1, 51, 4, -1, 20, 65, -3, -1, 64, 35, -1, |
50, 3, -3, -1, 19, 49, -1, 48, 34, -7, -3, -1, 18, 33, -1, |
2, 32, 17, -1, 1, 16, 0 |
}; |
static short tab11[] = |
{ |
-121,-113, -89, -59, -43, -27, -17, -7, -3, -1, 119, 103, -1, 118, 117, |
-3, -1, 102, 71, -1, 116, -1, 87, 85, -5, -3, -1, 86, 101, 55, |
-1, 115, 70, -9, -7, -3, -1, 69, 84, -1, 53, 83, 39, -1, 114, |
-1, 100, 7, -5, -1, 113, -1, 23, 112, -3, -1, 54, 99, -1, 96, |
-1, 68, 37, -13, -7, -5, -3, -1, 82, 5, 21, 98, -3, -1, 38, |
6, 22, -5, -1, 97, -1, 81, 52, -5, -1, 80, -1, 67, 51, -1, |
36, 66, -15, -11, -7, -3, -1, 20, 65, -1, 4, 64, -1, 35, 50, |
-1, 19, 49, -5, -3, -1, 3, 48, 34, 33, -5, -1, 18, -1, 2, |
32, 17, -3, -1, 1, 16, 0 |
}; |
static short tab12[] = |
{ |
-115, -99, -73, -45, -27, -17, -9, -5, -3, -1, 119, 103, 118, -1, 87, |
117, -3, -1, 102, 71, -1, 116, 101, -3, -1, 86, 55, -3, -1, 115, |
85, 39, -7, -3, -1, 114, 70, -1, 100, 23, -5, -1, 113, -1, 7, |
112, -1, 54, 99, -13, -9, -3, -1, 69, 84, -1, 68, -1, 6, 5, |
-1, 38, 98, -5, -1, 97, -1, 22, 96, -3, -1, 53, 83, -1, 37, |
82, -17, -7, -3, -1, 21, 81, -1, 52, 67, -5, -3, -1, 80, 4, |
36, -1, 66, 20, -3, -1, 51, 65, -1, 35, 50, -11, -7, -5, -3, |
-1, 64, 3, 48, 19, -1, 49, 34, -1, 18, 33, -7, -5, -3, -1, |
2, 32, 0, 17, -1, 1, 16 |
}; |
static short tab13[] = |
{ |
-509,-503,-475,-405,-333,-265,-205,-153,-115, -83, -53, -35, -21, -13, -9, |
-7, -5, -3, -1, 254, 252, 253, 237, 255, -1, 239, 223, -3, -1, 238, |
207, -1, 222, 191, -9, -3, -1, 251, 206, -1, 220, -1, 175, 233, -1, |
236, 221, -9, -5, -3, -1, 250, 205, 190, -1, 235, 159, -3, -1, 249, |
234, -1, 189, 219, -17, -9, -3, -1, 143, 248, -1, 204, -1, 174, 158, |
-5, -1, 142, -1, 127, 126, 247, -5, -1, 218, -1, 173, 188, -3, -1, |
203, 246, 111, -15, -7, -3, -1, 232, 95, -1, 157, 217, -3, -1, 245, |
231, -1, 172, 187, -9, -3, -1, 79, 244, -3, -1, 202, 230, 243, -1, |
63, -1, 141, 216, -21, -9, -3, -1, 47, 242, -3, -1, 110, 156, 15, |
-5, -3, -1, 201, 94, 171, -3, -1, 125, 215, 78, -11, -5, -3, -1, |
200, 214, 62, -1, 185, -1, 155, 170, -1, 31, 241, -23, -13, -5, -1, |
240, -1, 186, 229, -3, -1, 228, 140, -1, 109, 227, -5, -1, 226, -1, |
46, 14, -1, 30, 225, -15, -7, -3, -1, 224, 93, -1, 213, 124, -3, |
-1, 199, 77, -1, 139, 184, -7, -3, -1, 212, 154, -1, 169, 108, -1, |
198, 61, -37, -21, -9, -5, -3, -1, 211, 123, 45, -1, 210, 29, -5, |
-1, 183, -1, 92, 197, -3, -1, 153, 122, 195, -7, -5, -3, -1, 167, |
151, 75, 209, -3, -1, 13, 208, -1, 138, 168, -11, -7, -3, -1, 76, |
196, -1, 107, 182, -1, 60, 44, -3, -1, 194, 91, -3, -1, 181, 137, |
28, -43, -23, -11, -5, -1, 193, -1, 152, 12, -1, 192, -1, 180, 106, |
-5, -3, -1, 166, 121, 59, -1, 179, -1, 136, 90, -11, -5, -1, 43, |
-1, 165, 105, -1, 164, -1, 120, 135, -5, -1, 148, -1, 119, 118, 178, |
-11, -3, -1, 27, 177, -3, -1, 11, 176, -1, 150, 74, -7, -3, -1, |
58, 163, -1, 89, 149, -1, 42, 162, -47, -23, -9, -3, -1, 26, 161, |
-3, -1, 10, 104, 160, -5, -3, -1, 134, 73, 147, -3, -1, 57, 88, |
-1, 133, 103, -9, -3, -1, 41, 146, -3, -1, 87, 117, 56, -5, -1, |
131, -1, 102, 71, -3, -1, 116, 86, -1, 101, 115, -11, -3, -1, 25, |
145, -3, -1, 9, 144, -1, 72, 132, -7, -5, -1, 114, -1, 70, 100, |
40, -1, 130, 24, -41, -27, -11, -5, -3, -1, 55, 39, 23, -1, 113, |
-1, 85, 7, -7, -3, -1, 112, 54, -1, 99, 69, -3, -1, 84, 38, |
-1, 98, 53, -5, -1, 129, -1, 8, 128, -3, -1, 22, 97, -1, 6, |
96, -13, -9, -5, -3, -1, 83, 68, 37, -1, 82, 5, -1, 21, 81, |
-7, -3, -1, 52, 67, -1, 80, 36, -3, -1, 66, 51, 20, -19, -11, |
-5, -1, 65, -1, 4, 64, -3, -1, 35, 50, 19, -3, -1, 49, 3, |
-1, 48, 34, -3, -1, 18, 33, -1, 2, 32, -3, -1, 17, 1, 16, |
0 |
}; |
static short tab15[] = |
{ |
-495,-445,-355,-263,-183,-115, -77, -43, -27, -13, -7, -3, -1, 255, 239, |
-1, 254, 223, -1, 238, -1, 253, 207, -7, -3, -1, 252, 222, -1, 237, |
191, -1, 251, -1, 206, 236, -7, -3, -1, 221, 175, -1, 250, 190, -3, |
-1, 235, 205, -1, 220, 159, -15, -7, -3, -1, 249, 234, -1, 189, 219, |
-3, -1, 143, 248, -1, 204, 158, -7, -3, -1, 233, 127, -1, 247, 173, |
-3, -1, 218, 188, -1, 111, -1, 174, 15, -19, -11, -3, -1, 203, 246, |
-3, -1, 142, 232, -1, 95, 157, -3, -1, 245, 126, -1, 231, 172, -9, |
-3, -1, 202, 187, -3, -1, 217, 141, 79, -3, -1, 244, 63, -1, 243, |
216, -33, -17, -9, -3, -1, 230, 47, -1, 242, -1, 110, 240, -3, -1, |
31, 241, -1, 156, 201, -7, -3, -1, 94, 171, -1, 186, 229, -3, -1, |
125, 215, -1, 78, 228, -15, -7, -3, -1, 140, 200, -1, 62, 109, -3, |
-1, 214, 227, -1, 155, 185, -7, -3, -1, 46, 170, -1, 226, 30, -5, |
-1, 225, -1, 14, 224, -1, 93, 213, -45, -25, -13, -7, -3, -1, 124, |
199, -1, 77, 139, -1, 212, -1, 184, 154, -7, -3, -1, 169, 108, -1, |
198, 61, -1, 211, 210, -9, -5, -3, -1, 45, 13, 29, -1, 123, 183, |
-5, -1, 209, -1, 92, 208, -1, 197, 138, -17, -7, -3, -1, 168, 76, |
-1, 196, 107, -5, -1, 182, -1, 153, 12, -1, 60, 195, -9, -3, -1, |
122, 167, -1, 166, -1, 192, 11, -1, 194, -1, 44, 91, -55, -29, -15, |
-7, -3, -1, 181, 28, -1, 137, 152, -3, -1, 193, 75, -1, 180, 106, |
-5, -3, -1, 59, 121, 179, -3, -1, 151, 136, -1, 43, 90, -11, -5, |
-1, 178, -1, 165, 27, -1, 177, -1, 176, 105, -7, -3, -1, 150, 74, |
-1, 164, 120, -3, -1, 135, 58, 163, -17, -7, -3, -1, 89, 149, -1, |
42, 162, -3, -1, 26, 161, -3, -1, 10, 160, 104, -7, -3, -1, 134, |
73, -1, 148, 57, -5, -1, 147, -1, 119, 9, -1, 88, 133, -53, -29, |
-13, -7, -3, -1, 41, 103, -1, 118, 146, -1, 145, -1, 25, 144, -7, |
-3, -1, 72, 132, -1, 87, 117, -3, -1, 56, 131, -1, 102, 71, -7, |
-3, -1, 40, 130, -1, 24, 129, -7, -3, -1, 116, 8, -1, 128, 86, |
-3, -1, 101, 55, -1, 115, 70, -17, -7, -3, -1, 39, 114, -1, 100, |
23, -3, -1, 85, 113, -3, -1, 7, 112, 54, -7, -3, -1, 99, 69, |
-1, 84, 38, -3, -1, 98, 22, -3, -1, 6, 96, 53, -33, -19, -9, |
-5, -1, 97, -1, 83, 68, -1, 37, 82, -3, -1, 21, 81, -3, -1, |
5, 80, 52, -7, -3, -1, 67, 36, -1, 66, 51, -1, 65, -1, 20, |
4, -9, -3, -1, 35, 50, -3, -1, 64, 3, 19, -3, -1, 49, 48, |
34, -9, -7, -3, -1, 18, 33, -1, 2, 32, 17, -3, -1, 1, 16, |
0 |
}; |
static short tab16[] = |
{ |
-509,-503,-461,-323,-103, -37, -27, -15, -7, -3, -1, 239, 254, -1, 223, |
253, -3, -1, 207, 252, -1, 191, 251, -5, -1, 175, -1, 250, 159, -3, |
-1, 249, 248, 143, -7, -3, -1, 127, 247, -1, 111, 246, 255, -9, -5, |
-3, -1, 95, 245, 79, -1, 244, 243, -53, -1, 240, -1, 63, -29, -19, |
-13, -7, -5, -1, 206, -1, 236, 221, 222, -1, 233, -1, 234, 217, -1, |
238, -1, 237, 235, -3, -1, 190, 205, -3, -1, 220, 219, 174, -11, -5, |
-1, 204, -1, 173, 218, -3, -1, 126, 172, 202, -5, -3, -1, 201, 125, |
94, 189, 242, -93, -5, -3, -1, 47, 15, 31, -1, 241, -49, -25, -13, |
-5, -1, 158, -1, 188, 203, -3, -1, 142, 232, -1, 157, 231, -7, -3, |
-1, 187, 141, -1, 216, 110, -1, 230, 156, -13, -7, -3, -1, 171, 186, |
-1, 229, 215, -1, 78, -1, 228, 140, -3, -1, 200, 62, -1, 109, -1, |
214, 155, -19, -11, -5, -3, -1, 185, 170, 225, -1, 212, -1, 184, 169, |
-5, -1, 123, -1, 183, 208, 227, -7, -3, -1, 14, 224, -1, 93, 213, |
-3, -1, 124, 199, -1, 77, 139, -75, -45, -27, -13, -7, -3, -1, 154, |
108, -1, 198, 61, -3, -1, 92, 197, 13, -7, -3, -1, 138, 168, -1, |
153, 76, -3, -1, 182, 122, 60, -11, -5, -3, -1, 91, 137, 28, -1, |
192, -1, 152, 121, -1, 226, -1, 46, 30, -15, -7, -3, -1, 211, 45, |
-1, 210, 209, -5, -1, 59, -1, 151, 136, 29, -7, -3, -1, 196, 107, |
-1, 195, 167, -1, 44, -1, 194, 181, -23, -13, -7, -3, -1, 193, 12, |
-1, 75, 180, -3, -1, 106, 166, 179, -5, -3, -1, 90, 165, 43, -1, |
178, 27, -13, -5, -1, 177, -1, 11, 176, -3, -1, 105, 150, -1, 74, |
164, -5, -3, -1, 120, 135, 163, -3, -1, 58, 89, 42, -97, -57, -33, |
-19, -11, -5, -3, -1, 149, 104, 161, -3, -1, 134, 119, 148, -5, -3, |
-1, 73, 87, 103, 162, -5, -1, 26, -1, 10, 160, -3, -1, 57, 147, |
-1, 88, 133, -9, -3, -1, 41, 146, -3, -1, 118, 9, 25, -5, -1, |
145, -1, 144, 72, -3, -1, 132, 117, -1, 56, 131, -21, -11, -5, -3, |
-1, 102, 40, 130, -3, -1, 71, 116, 24, -3, -1, 129, 128, -3, -1, |
8, 86, 55, -9, -5, -1, 115, -1, 101, 70, -1, 39, 114, -5, -3, |
-1, 100, 85, 7, 23, -23, -13, -5, -1, 113, -1, 112, 54, -3, -1, |
99, 69, -1, 84, 38, -3, -1, 98, 22, -1, 97, -1, 6, 96, -9, |
-5, -1, 83, -1, 53, 68, -1, 37, 82, -1, 81, -1, 21, 5, -33, |
-23, -13, -7, -3, -1, 52, 67, -1, 80, 36, -3, -1, 66, 51, 20, |
-5, -1, 65, -1, 4, 64, -1, 35, 50, -3, -1, 19, 49, -3, -1, |
3, 48, 34, -3, -1, 18, 33, -1, 2, 32, -3, -1, 17, 1, 16, |
0 |
}; |
static short tab24[] = |
{ |
-451,-117, -43, -25, -15, -7, -3, -1, 239, 254, -1, 223, 253, -3, -1, |
207, 252, -1, 191, 251, -5, -1, 250, -1, 175, 159, -1, 249, 248, -9, |
-5, -3, -1, 143, 127, 247, -1, 111, 246, -3, -1, 95, 245, -1, 79, |
244, -71, -7, -3, -1, 63, 243, -1, 47, 242, -5, -1, 241, -1, 31, |
240, -25, -9, -1, 15, -3, -1, 238, 222, -1, 237, 206, -7, -3, -1, |
236, 221, -1, 190, 235, -3, -1, 205, 220, -1, 174, 234, -15, -7, -3, |
-1, 189, 219, -1, 204, 158, -3, -1, 233, 173, -1, 218, 188, -7, -3, |
-1, 203, 142, -1, 232, 157, -3, -1, 217, 126, -1, 231, 172, 255,-235, |
-143, -77, -45, -25, -15, -7, -3, -1, 202, 187, -1, 141, 216, -5, -3, |
-1, 14, 224, 13, 230, -5, -3, -1, 110, 156, 201, -1, 94, 186, -9, |
-5, -1, 229, -1, 171, 125, -1, 215, 228, -3, -1, 140, 200, -3, -1, |
78, 46, 62, -15, -7, -3, -1, 109, 214, -1, 227, 155, -3, -1, 185, |
170, -1, 226, 30, -7, -3, -1, 225, 93, -1, 213, 124, -3, -1, 199, |
77, -1, 139, 184, -31, -15, -7, -3, -1, 212, 154, -1, 169, 108, -3, |
-1, 198, 61, -1, 211, 45, -7, -3, -1, 210, 29, -1, 123, 183, -3, |
-1, 209, 92, -1, 197, 138, -17, -7, -3, -1, 168, 153, -1, 76, 196, |
-3, -1, 107, 182, -3, -1, 208, 12, 60, -7, -3, -1, 195, 122, -1, |
167, 44, -3, -1, 194, 91, -1, 181, 28, -57, -35, -19, -7, -3, -1, |
137, 152, -1, 193, 75, -5, -3, -1, 192, 11, 59, -3, -1, 176, 10, |
26, -5, -1, 180, -1, 106, 166, -3, -1, 121, 151, -3, -1, 160, 9, |
144, -9, -3, -1, 179, 136, -3, -1, 43, 90, 178, -7, -3, -1, 165, |
27, -1, 177, 105, -1, 150, 164, -17, -9, -5, -3, -1, 74, 120, 135, |
-1, 58, 163, -3, -1, 89, 149, -1, 42, 162, -7, -3, -1, 161, 104, |
-1, 134, 119, -3, -1, 73, 148, -1, 57, 147, -63, -31, -15, -7, -3, |
-1, 88, 133, -1, 41, 103, -3, -1, 118, 146, -1, 25, 145, -7, -3, |
-1, 72, 132, -1, 87, 117, -3, -1, 56, 131, -1, 102, 40, -17, -7, |
-3, -1, 130, 24, -1, 71, 116, -5, -1, 129, -1, 8, 128, -1, 86, |
101, -7, -5, -1, 23, -1, 7, 112, 115, -3, -1, 55, 39, 114, -15, |
-7, -3, -1, 70, 100, -1, 85, 113, -3, -1, 54, 99, -1, 69, 84, |
-7, -3, -1, 38, 98, -1, 22, 97, -5, -3, -1, 6, 96, 53, -1, |
83, 68, -51, -37, -23, -15, -9, -3, -1, 37, 82, -1, 21, -1, 5, |
80, -1, 81, -1, 52, 67, -3, -1, 36, 66, -1, 51, 20, -9, -5, |
-1, 65, -1, 4, 64, -1, 35, 50, -1, 19, 49, -7, -5, -3, -1, |
3, 48, 34, 18, -1, 33, -1, 2, 32, -3, -1, 17, 1, -1, 16, |
0 |
}; |
static short tab_c0[] = |
{ |
-29, -21, -13, -7, -3, -1, 11, 15, -1, 13, 14, -3, -1, 7, 5, |
9, -3, -1, 6, 3, -1, 10, 12, -3, -1, 2, 1, -1, 4, 8, |
0 |
}; |
static short tab_c1[] = |
{ |
-15, -7, -3, -1, 15, 14, -1, 13, 12, -3, -1, 11, 10, -1, 9, |
8, -7, -3, -1, 7, 6, -1, 5, 4, -3, -1, 3, 2, -1, 1, |
0 |
}; |
static struct newhuff ht[] = |
{ |
{ /* 0 */ 0 , tab0 } , |
{ /* 2 */ 0 , tab1 } , |
{ /* 3 */ 0 , tab2 } , |
{ /* 3 */ 0 , tab3 } , |
{ /* 0 */ 0 , tab0 } , |
{ /* 4 */ 0 , tab5 } , |
{ /* 4 */ 0 , tab6 } , |
{ /* 6 */ 0 , tab7 } , |
{ /* 6 */ 0 , tab8 } , |
{ /* 6 */ 0 , tab9 } , |
{ /* 8 */ 0 , tab10 } , |
{ /* 8 */ 0 , tab11 } , |
{ /* 8 */ 0 , tab12 } , |
{ /* 16 */ 0 , tab13 } , |
{ /* 0 */ 0 , tab0 } , |
{ /* 16 */ 0 , tab15 } , |
{ /* 16 */ 1 , tab16 } , |
{ /* 16 */ 2 , tab16 } , |
{ /* 16 */ 3 , tab16 } , |
{ /* 16 */ 4 , tab16 } , |
{ /* 16 */ 6 , tab16 } , |
{ /* 16 */ 8 , tab16 } , |
{ /* 16 */ 10, tab16 } , |
{ /* 16 */ 13, tab16 } , |
{ /* 16 */ 4 , tab24 } , |
{ /* 16 */ 5 , tab24 } , |
{ /* 16 */ 6 , tab24 } , |
{ /* 16 */ 7 , tab24 } , |
{ /* 16 */ 8 , tab24 } , |
{ /* 16 */ 9 , tab24 } , |
{ /* 16 */ 11, tab24 } , |
{ /* 16 */ 13, tab24 } |
}; |
static struct newhuff htc[] = |
{ |
{ /* 1 , 1 , */ 0 , tab_c0 } , |
{ /* 1 , 1 , */ 0 , tab_c1 } |
}; |
/shark/trunk/ports/mpg123/version.h |
---|
0,0 → 1,3 |
char *prgVersion = "0.59k"; |
char *prgDate = "1997/07/13"; |
char *prgName; |
/shark/trunk/ports/mpg123/decode_i.c |
---|
0,0 → 1,169 |
/* |
* Mpeg Layer-1,2,3 audio decoder |
* ------------------------------ |
* copyright (c) 1995,1996,1997 by Michael Hipp, All rights reserved. |
* See also 'README' |
* |
* slighlty optimized for machines without autoincrement/decrement. |
* The performance is highly compiler dependend. Maybe |
* the decode.c version for 'normal' processor may be faster |
* even for Intel processors. |
*/ |
#include <stdlib.h> |
#include <math.h> |
#include <string.h> |
#include "mpg123.h" |
#define WRITE_SAMPLE(samples,sum,clip) \ |
if( (sum) > 32767.0) { *(samples) = 0x7fff; (clip)++; } \ |
else if( (sum) < -32768.0) { *(samples) = -0x8000; (clip)++; } \ |
else { *(samples) = sum; } |
int synth_1to1_8bit(real *bandPtr,int channel,unsigned char *samples) |
{ |
short samples_tmp[64]; |
short *tmp1 = samples_tmp + channel; |
int i,ret; |
samples += channel; |
ret = synth_1to1(bandPtr,channel,(unsigned char *)samples_tmp); |
for(i=0;i<32;i++) { |
*samples = conv16to8[*tmp1>>4]; |
samples += 2; |
tmp1 += 2; |
} |
return ret; |
} |
int synth_1to1_8bit_mono(real *bandPtr,unsigned char *samples) |
{ |
short samples_tmp[64]; |
short *tmp1 = samples_tmp; |
int i,ret; |
ret = synth_1to1(bandPtr,0,(unsigned char *)samples_tmp); |
for(i=0;i<32;i++) { |
*samples++ = conv16to8[*tmp1>>4]; |
*samples++ = conv16to8[*tmp1>>4]; |
tmp1 += 2; |
} |
return ret; |
} |
int synth_1to1_mono(real *bandPtr,unsigned char *samples) |
{ |
int i,ret = synth_1to1(bandPtr,0,samples); |
for(i=0;i<32;i++) { |
((short *)samples)[1] = ((short *)samples)[0]; |
samples+=4; |
} |
return ret; |
} |
int synth_1to1(real *bandPtr,int channel,unsigned char *out) |
{ |
static real buffs[2][2][0x110]; |
static const int step = 2; |
static int bo = 1; |
short *samples = (short *) out; |
real *b0,(*buf)[0x110]; |
int clip = 0; |
int bo1; |
if(!channel) { |
bo--; |
bo &= 0xf; |
buf = buffs[0]; |
} |
else { |
samples++; |
buf = buffs[1]; |
} |
if(bo & 0x1) { |
b0 = buf[0]; |
bo1 = bo; |
dct64(buf[1]+((bo+1)&0xf),buf[0]+bo,bandPtr); |
} |
else { |
b0 = buf[1]; |
bo1 = bo+1; |
dct64(buf[0]+bo,buf[1]+bo+1,bandPtr); |
} |
{ |
register int j; |
real *window = decwin + 16 - bo1; |
for (j=16;j;j--,b0+=0x10,window+=0x20,samples+=step) |
{ |
real sum; |
sum = window[0x0] * b0[0x0]; |
sum -= window[0x1] * b0[0x1]; |
sum += window[0x2] * b0[0x2]; |
sum -= window[0x3] * b0[0x3]; |
sum += window[0x4] * b0[0x4]; |
sum -= window[0x5] * b0[0x5]; |
sum += window[0x6] * b0[0x6]; |
sum -= window[0x7] * b0[0x7]; |
sum += window[0x8] * b0[0x8]; |
sum -= window[0x9] * b0[0x9]; |
sum += window[0xA] * b0[0xA]; |
sum -= window[0xB] * b0[0xB]; |
sum += window[0xC] * b0[0xC]; |
sum -= window[0xD] * b0[0xD]; |
sum += window[0xE] * b0[0xE]; |
sum -= window[0xF] * b0[0xF]; |
WRITE_SAMPLE(samples,sum,clip); |
} |
{ |
real sum; |
sum = window[0x0] * b0[0x0]; |
sum += window[0x2] * b0[0x2]; |
sum += window[0x4] * b0[0x4]; |
sum += window[0x6] * b0[0x6]; |
sum += window[0x8] * b0[0x8]; |
sum += window[0xA] * b0[0xA]; |
sum += window[0xC] * b0[0xC]; |
sum += window[0xE] * b0[0xE]; |
WRITE_SAMPLE(samples,sum,clip); |
b0-=0x10,window-=0x20,samples+=step; |
} |
window += bo1<<1; |
for (j=15;j;j--,b0-=0x10,window-=0x20,samples+=step) |
{ |
real sum; |
sum = -window[-0x1] * b0[0x0]; |
sum -= window[-0x2] * b0[0x1]; |
sum -= window[-0x3] * b0[0x2]; |
sum -= window[-0x4] * b0[0x3]; |
sum -= window[-0x5] * b0[0x4]; |
sum -= window[-0x6] * b0[0x5]; |
sum -= window[-0x7] * b0[0x6]; |
sum -= window[-0x8] * b0[0x7]; |
sum -= window[-0x9] * b0[0x8]; |
sum -= window[-0xA] * b0[0x9]; |
sum -= window[-0xB] * b0[0xA]; |
sum -= window[-0xC] * b0[0xB]; |
sum -= window[-0xD] * b0[0xC]; |
sum -= window[-0xE] * b0[0xD]; |
sum -= window[-0xF] * b0[0xE]; |
sum -= window[-0x0] * b0[0xF]; |
WRITE_SAMPLE(samples,sum,clip); |
} |
} |
return clip; |
} |
/shark/trunk/ports/mpg123/layer1.c |
---|
0,0 → 1,153 |
/* |
* Mpeg Layer-1 audio decoder |
* -------------------------- |
* copyright (c) 1995 by Michael Hipp, All rights reserved. See also 'README' |
* near unoptimzed ... |
* |
* may have a few bugs after last optimization ... |
* |
*/ |
#include "mpg123.h" |
void I_step_one(unsigned int balloc[], unsigned int scale_index[2][SBLIMIT],struct frame *fr) |
{ |
unsigned int *ba=balloc; |
unsigned int *sca = (unsigned int *) scale_index; |
if(fr->stereo) { |
int i; |
int jsbound = fr->jsbound; |
for (i=0;i<jsbound;i++) { |
*ba++ = getbits(4); |
*ba++ = getbits(4); |
} |
for (i=jsbound;i<SBLIMIT;i++) |
*ba++ = getbits(4); |
ba = balloc; |
for (i=0;i<jsbound;i++) { |
if ((*ba++)) |
*sca++ = getbits(6); |
if ((*ba++)) |
*sca++ = getbits(6); |
} |
for (i=jsbound;i<SBLIMIT;i++) |
if ((*ba++)) { |
*sca++ = getbits(6); |
*sca++ = getbits(6); |
} |
} |
else { |
int i; |
for (i=0;i<SBLIMIT;i++) |
*ba++ = getbits(4); |
ba = balloc; |
for (i=0;i<SBLIMIT;i++) |
if ((*ba++)) |
*sca++ = getbits(6); |
} |
} |
void I_step_two(real fraction[2][SBLIMIT],unsigned int balloc[2*SBLIMIT], |
unsigned int scale_index[2][SBLIMIT],struct frame *fr) |
{ |
int i,n; |
int smpb[2*SBLIMIT]; /* values: 0-65535 */ |
int *sample; |
register unsigned int *ba; |
register unsigned int *sca = (unsigned int *) scale_index; |
if(fr->stereo) { |
int jsbound = fr->jsbound; |
register real *f0 = fraction[0]; |
register real *f1 = fraction[1]; |
ba = balloc; |
for (sample=smpb,i=0;i<jsbound;i++) { |
if ((n = *ba++)) |
*sample++ = getbits(n+1); |
if ((n = *ba++)) |
*sample++ = getbits(n+1); |
} |
for (i=jsbound;i<SBLIMIT;i++) |
if ((n = *ba++)) |
*sample++ = getbits(n+1); |
ba = balloc; |
for (sample=smpb,i=0;i<jsbound;i++) { |
if((n=*ba++)) |
*f0++ = (real) ( ((-1)<<n) + (*sample++) + 1) * muls[n+1][*sca++]; |
else |
*f0++ = 0.0; |
if((n=*ba++)) |
*f1++ = (real) ( ((-1)<<n) + (*sample++) + 1) * muls[n+1][*sca++]; |
else |
*f1++ = 0.0; |
} |
for (sample=smpb,i=jsbound;i<SBLIMIT;i++) { |
if ((n=*ba++)) { |
real samp = ( ((-1)<<n) + (*sample++) + 1); |
*f0++ = samp * muls[n+1][*sca++]; |
*f1++ = samp * muls[n+1][*sca++]; |
} |
else |
*f0++ = *f1++ = 0.0; |
} |
for(i=SBLIMIT>>fr->down_sample;i<32;i++) |
fraction[0][i] = fraction[1][i] = 0.0; |
} |
else { |
register real *f0 = fraction[0]; |
ba = balloc; |
for (sample=smpb,i=0;i<SBLIMIT;i++) |
if ((n = *ba++)) |
*sample++ = getbits(n+1); |
ba = balloc; |
for (sample=smpb,i=0;i<SBLIMIT;i++) { |
if((n=*ba++)) |
*f0++ = (real) ( ((-1)<<n) + (*sample++) + 1) * muls[n+1][*sca++]; |
else |
*f0++ = 0.0; |
} |
for(i=SBLIMIT>>fr->down_sample;i<32;i++) |
fraction[0][i] = 0.0; |
} |
} |
int do_layer1(struct frame *fr,int outmode,struct audio_info_struct *ai) |
{ |
int clip=0; |
int i,stereo = fr->stereo; |
unsigned int balloc[2*SBLIMIT]; |
unsigned int scale_index[2][SBLIMIT]; |
real fraction[2][SBLIMIT]; |
int single = fr->single; |
if(stereo == 1 || single == 3) |
single = 0; |
I_step_one(balloc,scale_index,fr); |
for (i=0;i<SCALE_BLOCK;i++) |
{ |
I_step_two(fraction,balloc,scale_index,fr); |
if(single >= 0) |
{ |
clip += (fr->synth_mono)( (real *) fraction[single],pcm_sample+pcm_point); |
} |
else { |
clip += (fr->synth)( (real *) fraction[0],0,pcm_sample+pcm_point); |
clip += (fr->synth)( (real *) fraction[1],1,pcm_sample+pcm_point); |
} |
pcm_point += fr->block_size; |
if(pcm_point == audiobufsize) |
audio_flush(outmode,ai); |
} |
return clip; |
} |