Alien-FreeImage
view release on metacpan or search on metacpan
src/Source/OpenEXR/Half/halfFunction.h
src/Source/OpenEXR/Half/halfLimits.h
src/Source/OpenEXR/Half/toFloat.cpp
src/Source/OpenEXR/Half/toFloat.h
src/Source/OpenEXR/Iex/Iex.h
src/Source/OpenEXR/Iex/IexBaseExc.cpp
src/Source/OpenEXR/Iex/IexBaseExc.h
src/Source/OpenEXR/Iex/IexErrnoExc.h
src/Source/OpenEXR/Iex/IexExport.h
src/Source/OpenEXR/Iex/IexForward.h
src/Source/OpenEXR/Iex/IexMacros.h
src/Source/OpenEXR/Iex/IexMathExc.h
src/Source/OpenEXR/Iex/IexNamespace.h
src/Source/OpenEXR/Iex/IexThrowErrnoExc.cpp
src/Source/OpenEXR/Iex/IexThrowErrnoExc.h
src/Source/OpenEXR/IexMath/IexMathFloatExc.cpp
src/Source/OpenEXR/IexMath/IexMathFloatExc.h
src/Source/OpenEXR/IexMath/IexMathFpu.cpp
src/Source/OpenEXR/IexMath/IexMathFpu.h
src/Source/OpenEXR/IexMath/IexMathIeeeExc.h
src/Source/OpenEXR/IlmBaseConfig.h
src/Makefile.srcs view on Meta::CPAN
VER_MAJOR = 3
VER_MINOR = 17.0
SRCS = ./Source/FreeImage/BitmapAccess.cpp ./Source/FreeImage/ColorLookup.cpp ./Source/FreeImage/FreeImage.cpp ./Source/FreeImage/FreeImageC.c ./Source/FreeImage/FreeImageIO.cpp ./Source/FreeImage/GetType.cpp ./Source/FreeImage/MemoryIO.cpp ./Source/...
INCLS = ./Examples/OpenGL/TextureManager/TextureManager.h ./Examples/Plugin/PluginCradle.h ./Examples/Generic/FIIO_Mem.h ./Source/MapIntrospector.h ./Source/FreeImage - Copie.h ./Source/CacheFile.h ./Source/LibTIFF/tiffconf.vc.h ./Source/LibTIFF/tif_...
INCLUDE = -I. -ISource -ISource/Metadata -ISource/FreeImageToolkit -ISource/LibJPEG -ISource/LibPNG -ISource/LibTIFF4 -ISource/ZLib -ISource/LibOpenJPEG -ISource/OpenEXR -ISource/OpenEXR/Half -ISource/OpenEXR/Iex -ISource/OpenEXR/IlmImf -ISource/Open...
src/Source/FreeImage/PluginG3.cpp view on Meta::CPAN
#include "FreeImage.h"
#include "Utilities.h"
// ==========================================================
// Plugin Interface
// ==========================================================
static int s_format_id;
// ==========================================================
// Constant/Macro declarations
// ==========================================================
#define G3_DEFAULT_WIDTH 1728
#define TIFFhowmany8(x) (((x)&0x07)?((uint32)(x)>>3)+1:(uint32)(x)>>3)
// ==========================================================
// libtiff interface
// ==========================================================
src/Source/FreeImageLib/FreeImageLib.2013.vcxproj view on Meta::CPAN
<Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
<Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
<Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup>
<_ProjectFileVersion>12.0.21005.1</_ProjectFileVersion>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<OutDir>.\$(Platform)\$(Configuration)\</OutDir>
<IntDir>.\$(Platform)\$(Configuration)\</IntDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<OutDir>.\$(Platform)\$(Configuration)\</OutDir>
<IntDir>.\$(Platform)\$(Configuration)\</IntDir>
src/Source/FreeImageToolkit/Colors.cpp view on Meta::CPAN
// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
// THIS DISCLAIMER.
//
// Use at your own risk!
// ==========================================================
#include "FreeImage.h"
#include "Utilities.h"
// ----------------------------------------------------------
// Macros + structures
// ----------------------------------------------------------
#define GET_HI_NIBBLE(byte) ((byte) >> 4)
#define SET_HI_NIBBLE(byte, n) byte &= 0x0F, byte |= ((n) << 4)
#define GET_LO_NIBBLE(byte) ((byte) & 0x0F)
#define SET_LO_NIBBLE(byte, n) byte &= 0xF0, byte |= ((n) & 0x0F)
#define GET_NIBBLE(cn, byte) ((cn) ? (GET_HI_NIBBLE(byte)) : (GET_LO_NIBBLE(byte)))
#define SET_NIBBLE(cn, byte, n) if (cn) SET_HI_NIBBLE(byte, n); else SET_LO_NIBBLE(byte, n)
// ----------------------------------------------------------
src/Source/LibJPEG/LibJPEG.2013.vcxproj view on Meta::CPAN
<Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
<Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
<Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup>
<_ProjectFileVersion>12.0.21005.1</_ProjectFileVersion>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<OutDir>.\$(Platform)\$(Configuration)\</OutDir>
<IntDir>.\$(Platform)\$(Configuration)\</IntDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<OutDir>.\$(Platform)\$(Configuration)\</OutDir>
<IntDir>.\$(Platform)\$(Configuration)\</IntDir>
src/Source/LibJPEG/jdct.h view on Meta::CPAN
JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
EXTERN(void) jpeg_idct_2x4
JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
EXTERN(void) jpeg_idct_1x2
JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
/*
* Macros for handling fixed-point arithmetic; these are used by many
* but not all of the DCT/IDCT modules.
*
* All values are expected to be of type INT32.
* Fractional constants are scaled left by CONST_BITS bits.
* CONST_BITS is defined within each module using these macros,
* and may differ from one module to the next.
*/
#define ONE ((INT32) 1)
#define CONST_SCALE (ONE << CONST_BITS)
src/Source/LibJPEG/jdhuff.c view on Meta::CPAN
size_t bytes_in_buffer; /* # of bytes remaining in source buffer */
/* Bit input buffer --- note these values are kept in register variables,
* not in this struct, inside the inner loops.
*/
bit_buf_type get_buffer; /* current bit-extraction buffer */
int bits_left; /* # of unused bits in it */
/* Pointer needed by jpeg_fill_bit_buffer. */
j_decompress_ptr cinfo; /* back link to decompress master record */
} bitread_working_state;
/* Macros to declare and load/save bitread local variables. */
#define BITREAD_STATE_VARS \
register bit_buf_type get_buffer; \
register int bits_left; \
bitread_working_state br_state
#define BITREAD_LOAD_STATE(cinfop,permstate) \
br_state.cinfo = cinfop; \
br_state.next_input_byte = cinfop->src->next_input_byte; \
br_state.bytes_in_buffer = cinfop->src->bytes_in_buffer; \
get_buffer = permstate.get_buffer; \
src/Source/LibJPEG/jdmarker.c view on Meta::CPAN
/* Status of COM/APPn marker saving */
jpeg_saved_marker_ptr cur_marker; /* NULL if not processing a marker */
unsigned int bytes_read; /* data bytes read so far in marker */
/* Note: cur_marker is not linked into marker_list until it's all read. */
} my_marker_reader;
typedef my_marker_reader * my_marker_ptr;
/*
* Macros for fetching data from the data source module.
*
* At all times, cinfo->src->next_input_byte and ->bytes_in_buffer reflect
* the current restart point; we update them only when we have reached a
* suitable place to restart if a suspension occurs.
*/
/* Declare and initialize local copies of input pointer/count */
#define INPUT_VARS(cinfo) \
struct jpeg_source_mgr * datasrc = (cinfo)->src; \
const JOCTET * next_input_byte = datasrc->next_input_byte; \
src/Source/LibJPEG/jerror.h view on Meta::CPAN
#undef JMAKE_ENUM_LIST
#endif /* JMAKE_ENUM_LIST */
/* Zap JMESSAGE macro so that future re-inclusions do nothing by default */
#undef JMESSAGE
#ifndef JERROR_H
#define JERROR_H
/* Macros to simplify using the error and trace message stuff */
/* The first parameter is either type of cinfo pointer */
/* Fatal errors (print message and exit) */
#define ERREXIT(cinfo,code) \
((cinfo)->err->msg_code = (code), \
(*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
#define ERREXIT1(cinfo,code,p1) \
((cinfo)->err->msg_code = (code), \
(cinfo)->err->msg_parm.i[0] = (p1), \
(*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
src/Source/LibJPEG/jmemdos.c view on Meta::CPAN
* word & long accesses, but all 80x86 CPUs do.
*/
typedef void far * EMSPTR;
typedef union { /* EMS move specification structure */
long length; /* It's easy to access first 4 bytes */
char bytes[18]; /* Misaligned fields in here! */
} EMSspec;
/* Macros for accessing misaligned fields */
#define FIELD_AT(spec,offset,type) (*((type *) &(spec.bytes[offset])))
#define SRC_TYPE(spec) FIELD_AT(spec,4,char)
#define SRC_HANDLE(spec) FIELD_AT(spec,5,EMSH)
#define SRC_OFFSET(spec) FIELD_AT(spec,7,unsigned short)
#define SRC_PAGE(spec) FIELD_AT(spec,9,unsigned short)
#define SRC_PTR(spec) FIELD_AT(spec,7,EMSPTR)
#define DST_TYPE(spec) FIELD_AT(spec,11,char)
#define DST_HANDLE(spec) FIELD_AT(spec,12,EMSH)
#define DST_OFFSET(spec) FIELD_AT(spec,14,unsigned short)
#define DST_PAGE(spec) FIELD_AT(spec,16,unsigned short)
src/Source/LibJPEG/rdbmp.c view on Meta::CPAN
* the file is indeed BMP format).
*
* This code contributed by James Arthur Boucher.
*/
#include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */
#ifdef BMP_SUPPORTED
/* Macros to deal with unsigned chars as efficiently as compiler allows */
#ifdef HAVE_UNSIGNED_CHAR
typedef unsigned char U_CHAR;
#define UCH(x) ((int) (x))
#else /* !HAVE_UNSIGNED_CHAR */
#ifdef CHAR_IS_UNSIGNED
typedef char U_CHAR;
#define UCH(x) ((int) (x))
#else
typedef char U_CHAR;
src/Source/LibJPEG/rdppm.c view on Meta::CPAN
**
** Permission to use, copy, modify, and distribute this software and its
** documentation for any purpose and without fee is hereby granted, provided
** that the above copyright notice appear in all copies and that both that
** copyright notice and this permission notice appear in supporting
** documentation. This software is provided "as is" without express or
** implied warranty.
*/
/* Macros to deal with unsigned chars as efficiently as compiler allows */
#ifdef HAVE_UNSIGNED_CHAR
typedef unsigned char U_CHAR;
#define UCH(x) ((int) (x))
#else /* !HAVE_UNSIGNED_CHAR */
#ifdef CHAR_IS_UNSIGNED
typedef char U_CHAR;
#define UCH(x) ((int) (x))
#else
typedef char U_CHAR;
src/Source/LibJPEG/rdtarga.c view on Meta::CPAN
* the file is indeed Targa format).
*
* Based on code contributed by Lee Daniel Crocker.
*/
#include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */
#ifdef TARGA_SUPPORTED
/* Macros to deal with unsigned chars as efficiently as compiler allows */
#ifdef HAVE_UNSIGNED_CHAR
typedef unsigned char U_CHAR;
#define UCH(x) ((int) (x))
#else /* !HAVE_UNSIGNED_CHAR */
#ifdef CHAR_IS_UNSIGNED
typedef char U_CHAR;
#define UCH(x) ((int) (x))
#else
typedef char U_CHAR;
src/Source/LibJXR/LibJXR.2013.vcxproj view on Meta::CPAN
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup>
<_ProjectFileVersion>12.0.21005.1</_ProjectFileVersion>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<OutDir>.\$(Platform)\$(Configuration)\</OutDir>
<IntDir>.\$(Platform)\$(Configuration)\</IntDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<OutDir>.\$(Platform)\$(Configuration)\</OutDir>
<IntDir>.\$(Platform)\$(Configuration)\</IntDir>
src/Source/LibJXR/common/include/wmsal.h view on Meta::CPAN
#endif
extern "C" {
#else
#ifndef __nothrow
# define __nothrow
#endif
#endif /* #ifdef __cplusplus */
/*
-------------------------------------------------------------------------------
Helper Macro Definitions
These express behavior common to many of the high-level annotations.
DO NOT USE THESE IN YOUR CODE.
-------------------------------------------------------------------------------
*/
/*
The helper annotations are only understood by the compiler version used by various
defect detection tools. When the regular compiler is running, they are defined into
nothing, and do not affect the compiled code.
src/Source/LibJXR/common/include/wmsal.h view on Meta::CPAN
#define __refparam __deref __notreadonly
/*
__inner_*
Helper macros that directly correspond to certain high-level annotations.
*/
/*
Macros to classify the entrypoints and indicate their category.
Pre-defined control point categories include: RPC, LPC, DeviceDriver, UserToKernel, ISAPI, COM.
*/
#define __inner_control_entrypoint(category) __declspec("SAL_entrypoint(controlEntry, "SPECSTRINGIZE(category)")")
/*
Pre-defined data entry point categories include: Registry, File, Network.
*/
#define __inner_data_entrypoint(category) __declspec("SAL_entrypoint(dataEntry, "SPECSTRINGIZE(category)")")
src/Source/LibJXR/common/include/wmspecstrings_strict.h view on Meta::CPAN
/*************************************************************************
* This file documents all the macros approved for use in windows source
* code. It includes some experimental macros which should only be used by
* experts.
*
* DO NOT include this file directly. This file is include after
* specstrings.h. So we can undefine every possible old definition including
* private internal macros people should not be using, as well as macros from
* sal.h. Macros are redefined here in a way to cause syntax errors when used
* incorrectly during a normal build when specstrings.h is included and
* __SPECSTRINGS_STRICT_LEVEL is defined.
*
* There are several levels of strictness, each level includes the behavior of
* all previous levels.
*
* 0 - Disable strict checking
* 1 - Break on unapproved macros and misuse of statement
* macros such as __fallthrough (default)
* 2 - Deprecated some old macros that should not be used
src/Source/LibJXR/common/include/wmspecstrings_strict.h view on Meta::CPAN
#define __deref_in_range(lb,ub) __allowed(on_parameter)
#define __deref_out_range(lb,ub) __allowed(on_parameter)
#define __field_range(lb,ub) __allowed(on_field)
#define __bound __allowed(on_return)
#define __in_bound __allowed(on_parameter)
#define __out_bound __allowed(on_parameter)
#define __deref_out_bound __allowed(on_parameter)
#define __assume_bound(i) __allowed(as_statement_with_arg(i))
#define __allocator __allowed(on_function)
/***************************************************************************
* Expert Macros
***************************************************************************/
#define __null __allowed(on_typedecl)
#define __notnull __allowed(on_typedecl)
#define __maybenull __allowed(on_typedecl)
#define __exceptthat __allowed(on_typedecl)
/***************************************************************************
* Macros to classify fields of structures.
* Structure Annotations
*
* The buffer annotations are a convenient way of describing
* relationships between buffers and their size on a function by
* function basis. Very often struct or class data members have similar
* invariants, which can be expressed directly on the type.
*
* Similar to our buffer annotations we can summarize all the various
* structure annotations by one choosing an element from each column of
* this table to build a composite annotation.
src/Source/LibJXR/common/include/wmspecstrings_strict.h view on Meta::CPAN
#define __field_ecount_full(size) __allowed(on_field)
#define __field_bcount_full(size) __allowed(on_field)
#define __field_xcount_full(size) __allowed(on_field)
#define __field_ecount_full_opt(size) __allowed(on_field)
#define __field_bcount_full_opt(size) __allowed(on_field)
#define __field_xcount_full_opt(size) __allowed(on_field)
#define __struct_bcount(size) __allowed(on_struct)
#define __struct_xcount(size) __allowed(on_struct)
/***************************************************************************
* Macros to classify the entrypoints and indicate their category.
*
* Pre-defined control point categories include: RPC, KERNEL, GDI.
*
* Pre-defined control point macros include:
* __rpc_entry, __kernel_entry, __gdi_entry.
***************************************************************************/
#define __control_entrypoint(category) __allowed(on_function)
#define __rpc_entry __allowed(on_function)
#define __kernel_entry __allowed(on_function)
#define __gdi_entry __allowed(on_function)
/***************************************************************************
* Macros to track untrusted data and their validation. The list of untrusted
* sources include:
*
* FILE - File reading stream or API
* NETWORK - Socket readers
* INTERNET - WinInet and WinHttp readers
* USER_REGISTRY - HKCU portions of the registry
* USER_MODE - Parameters to kernel entry points
* RPC - Parameters to RPC entry points
* DRIVER - Device driver
***************************************************************************/
#define __in_data_source(src_sym) __allowed(on_parameter)
#define __out_data_source(src_sym) __allowed(on_parameter)
#define __field_data_source(src_sym) __allowed(on_field)
#define __this_out_data_source(src_syn) __allowed(on_function)
/**************************************************************************
* Macros to tag file parsing code. Predefined formats include:
* PNG - Portable Network Graphics
* JPEG - Joint Photographic Experts Group
* BMP - Bitmap
* RC_BMP - Resource bitmap
* WMF - Windows Metafile
* EMF - Windows Enhanced Metafile
* GIF - Graphics Interchange Format
* MIME_TYPE - MIME type from header tokens
* MAIL_MONIKER - MAIL information refered by URL moniker
* HTML - HyperText Markup Language
src/Source/LibJXR/common/include/wmspecstrings_strict.h view on Meta::CPAN
* AVI - Audio Visual Interchange
* ACM - Audio Compression Manager
**************************************************************************/
#define __out_validated(filetype_sym) __allowed(on_parameter)
#define __this_out_validated(filetype_sym) __allowed(on_function)
#define __file_parser(filetype_sym) __allowed(on_function)
#define __file_parser_class(filetype_sym) __allowed(on_struct)
#define __file_parser_library(filetype_sym) __allowed(as_global_decl)
/***************************************************************************
* Macros to track the code content in the file. The type of code
* contents currently tracked:
*
* NDIS_DRIVER - NDIS Device driver
***************************************************************************/
#define __source_code_content(codetype_sym) __allowed(as_global_decl)
/***************************************************************************
* Macros to track the code content in the class. The type of code
* contents currently tracked:
*
* DCOM - Class implementing DCOM
***************************************************************************/
#define __class_code_content(codetype_sym) __allowed(on_struct)
/*************************************************************************
* Macros to tag encoded function pointers
**************************************************************************/
#define __encoded_pointer
#define __encoded_array
#define __field_encoded_pointer __allowed(on_field)
#define __field_encoded_array __allowed(on_field)
#define __transfer(formal) __allowed(on_parameter_or_return)
#define __assume_validated(exp) __allowed(as_statement_with_arg(exp))
/*************************************************************************
src/Source/LibJXR/common/include/wmspecstrings_strict.h view on Meta::CPAN
* Current hints that are supported are:
*
* INLINE - inline this function during analysis overrides any
* default heuristics
* NOINLINE - do not inline this function during analysis overrides
* and default heuristics
*************************************************************************/
#define __analysis_hint(hint) __allowed(on_function)
/*************************************************************************
* Macros to encode abstract properties of values. Used by SALadt.h
*************************************************************************/
#define __type_has_adt_prop(adt,prop) __allowed(on_typdecl)
#define __out_has_adt_prop(adt,prop) __allowed(on_parameter)
#define __out_not_has_adt_prop(adt,prop) __allowed(on_parameter)
#define __out_transfer_adt_prop(arg) __allowed(on_parameter)
#define __out_has_type_adt_props(typ) __allowed(on_parameter)
#define __assume_ValidCompNameA(expr) __allowed(as_statement_with_arg(expr))
#define __assume_ValidCompNameW(expr) __allowed(as_statement_with_arg(expr))
/*************************************************************************
* Macros used by Prefast for Drivers
*
* __possibly_notnulltermiated :
*
* Used for return values of parameters or functions that do not
* guarantee nullterimination in all cases.
*
*************************************************************************/
#define __possibly_notnulltermiated __allowed(on_parameter_or_return)
/*************************************************************************
src/Source/LibJXR/common/include/wmspecstrings_strict.h view on Meta::CPAN
* 1) not to be in danger of being re-fetched or,
* 2) not to lead to incorrect results if they are re-fetched
*
*************************************************************************/
#define __volatile __allowed(on_global_or_field)
#define __deref_volatile __allowed(on_global_or_field)
#define __nonvolatile __allowed(on_global_or_field)
#define __deref_nonvolatile __allowed(on_global_or_field)
/*************************************************************************
* Macros deprecated with strict level greater then 1.
**************************************************************************/
#if (__SPECSTRINGS_STRICT_LEVEL > 1)
/* Must come before macro defintions */
#pragma deprecated(__in_nz)
#pragma deprecated(__in_ecount_nz)
#pragma deprecated(__in_bcount_nz)
#pragma deprecated(__out_nz)
#pragma deprecated(__out_nz_opt)
#pragma deprecated(__out_ecount_nz)
#pragma deprecated(__out_bcount_nz)
src/Source/LibJXR/image/decode/JXRTranscode.c view on Meta::CPAN
#include "windowsmediaphoto.h"
#include "strcodec.h"
#include "decode.h"
EXTERN_C Void freePredInfo(CWMImageStrCodec *);
EXTERN_C Int ReadWMIHeader(CWMImageInfo *, CWMIStrCodecParam *, CCoreParameters *);
EXTERN_C Int StrIODecInit(CWMImageStrCodec *);
EXTERN_C Int StrDecInit(CWMImageStrCodec *);
EXTERN_C Int readPackets(CWMImageStrCodec *);
EXTERN_C Int DecodeMacroblockDC(CWMImageStrCodec *, CCodingContext *, Int, Int);
EXTERN_C Int DecodeMacroblockLowpass(CWMImageStrCodec *, CCodingContext *, Int, Int);
EXTERN_C Int DecodeMacroblockHighpass(CWMImageStrCodec *, CCodingContext *, Int, Int);
EXTERN_C Void predDCACDec(CWMImageStrCodec *);
EXTERN_C Void predACDec(CWMImageStrCodec *);
EXTERN_C Void StrIODecTerm(CWMImageStrCodec *);
EXTERN_C Void FreeCodingContextDec(CWMImageStrCodec *);
EXTERN_C Int StrEncInit(CWMImageStrCodec *);
EXTERN_C Void StrIOEncTerm(CWMImageStrCodec *);
EXTERN_C Void FreeCodingContextEnc(CWMImageStrCodec *);
EXTERN_C Void encodeMB(CWMImageStrCodec *, Int, Int);
EXTERN_C Int writeIndexTableNull(CWMImageStrCodec *);
src/Source/LibJXR/image/decode/JXRTranscode.c view on Meta::CPAN
if(i == 2){
pSCDec->m_pNextSC->cTileColumn = pSCDec->cTileColumn;
pSCDec->m_pNextSC->cTileRow = pSCDec->cTileRow;
}
if(readPackets(pSCDec) != ICERR_OK)
return ICERR_ERROR;
pContext = &pSCDec->m_pCodingContext[pSCDec->cTileColumn];
if(DecodeMacroblockDC(pSCDec, pContext, cColumn, cRow) != ICERR_OK)
return ICERR_ERROR;
if(pSCDec->cSB > 1)
if(DecodeMacroblockLowpass(pSCDec, pContext, cColumn, cRow) != ICERR_OK)
return ICERR_ERROR;
predDCACDec(pSCDec);
if(pSCDec->cSB > 2)
if(DecodeMacroblockHighpass(pSCDec, pContext, cColumn, cRow) != ICERR_OK)
return ICERR_ERROR;
predACDec(pSCDec);
updatePredInfo(pSCDec, &pSCDec->MBInfo, cColumn, pSCDec->WMISCP.cfColorFormat);
pSCDec = pSCDec->m_pNextSC;
}
pSCDec = pSC;
src/Source/LibJXR/image/decode/decode.h view on Meta::CPAN
// table lookups for rotation and flip
size_t * pOffsetX;
size_t * pOffsetY;
} CWMDecoderParameters;
Void predCBPDec(CWMImageStrCodec *, CCodingContext *);
Void predDCACDec(CWMImageStrCodec *);
Void predACDec(CWMImageStrCodec *);
Int dequantizeMacroblock(CWMImageStrCodec *);
Int invTransformMacroblock(CWMImageStrCodec * pSC);
Int invTransformMacroblock_alteredOperators_hard(CWMImageStrCodec * pSC);
Int DecodeMacroblockDC(CWMImageStrCodec * pSC, CCodingContext *pContext, Int iMBX, Int iMBY);
Int DecodeMacroblockLowpass(CWMImageStrCodec * pSC, CCodingContext *pContext, Int iMBX, Int iMBY);
Int DecodeMacroblockHighpass(CWMImageStrCodec * pSC, CCodingContext *pContext, Int iMBX, Int iMBY);
Int AdaptLowpassDec(struct CCodingContext *);
Int AdaptHighpassDec(struct CCodingContext *);
Void ResetCodingContextDec(CCodingContext *pContext);
Void FreeCodingContextDec(struct CWMImageStrCodec *pSC);
/*************************************************************************/
// Inverse transform functions
// 2-point post filter for boundaries (only used in 420 UV DC subband)
src/Source/LibJXR/image/decode/segdec.c view on Meta::CPAN
U8 decodeQPIndex(BitIOInfo* pIO,U8 cBits)
{
if(_getBit16(pIO, 1) == 0)
return 0;
return (U8)(_getBit16(pIO, cBits) + 1);
}
/*************************************************************************
DecodeSecondStageCoeff
*************************************************************************/
Int DecodeMacroblockLowpass (CWMImageStrCodec * pSC, CCodingContext *pContext,
Int iMBX, Int iMBYdummy)
{
const COLORFORMAT cf = pSC->m_param.cfColorFormat;
const Int iChannels = (Int) pSC->m_param.cNumChannels;
const Int iFullPlanes = (cf == YUV_420 || cf == YUV_422) ? 2 : iChannels;
Int k;
CAdaptiveScan *pScan = pContext->m_aScanLowpass;
BitIOInfo* pIO = pContext->m_pIOLP;
Int iModelBits = pContext->m_aModelLP.m_iFlcBits[0];
Int aRLCoeffs[32], iNumNonzero = 0, iIndex = 0;
src/Source/LibJXR/image/decode/segdec.c view on Meta::CPAN
Y:
x x x [0..3]
x x x [4..7]
x x x [8..11]
[16..19] [20..23] [24..27] [28..31,12..15]
U, V:
x [0..3]
[8..11] [4..7,12..15]
*************************************************************************/
Int DecodeMacroblockDC(CWMImageStrCodec * pSC, CCodingContext *pContext, Int iMBX, Int iMBY)
{
CWMITile * pTile = pSC->pTile + pSC->cTileColumn;
CWMIMBInfo * pMBInfo = &pSC->MBInfo;
const COLORFORMAT cf = pSC->m_param.cfColorFormat;
const Int iChannels = (Int) pSC->m_param.cNumChannels;
BitIOInfo* pIO = pContext->m_pIODC;
Int iIndex, i;
Int aLaplacianMean[2] = { 0, 0}, *pLM = aLaplacianMean;
Int iModelBits = pContext->m_aModelDC.m_iFlcBits[0];
struct CAdaptiveHuffman *pAH;
src/Source/LibJXR/image/decode/segdec.c view on Meta::CPAN
if (ICERR_OK != AdaptDecFixed (pContext->m_pAHexpt[kk])) {
return ICERR_ERROR;
}
}
}
return ICERR_OK;
}
/*************************************************************************
DecodeMacroblockHighpass
*************************************************************************/
Int DecodeMacroblockHighpass (CWMImageStrCodec *pSC, CCodingContext *pContext,
Int iMBX, Int iMBY)
{
/** reset adaptive scan totals **/
if (pSC->m_bResetRGITotals) {
int iScale = 2, k;
int iWeight = iScale * 16;
pContext->m_aScanHoriz[0].uTotal = pContext->m_aScanVert[0].uTotal = MAXTOTAL;
for (k = 1; k < 16; k++) {
pContext->m_aScanHoriz[k].uTotal = pContext->m_aScanVert[k].uTotal = iWeight;
iWeight -= iScale;
src/Source/LibJXR/image/decode/strInvTransform.c view on Meta::CPAN
*pa = a;
*pb = b;
*pc = c;
*pd = d;
}
/*************************************************************************
Top-level function to inverse tranform possible part of a macroblock
*************************************************************************/
Int invTransformMacroblock(CWMImageStrCodec * pSC)
{
const OVERLAP olOverlap = pSC->WMISCP.olOverlap;
const COLORFORMAT cfColorFormat = pSC->m_param.cfColorFormat;
// const BITDEPTH_BITS bdBitDepth = pSC->WMII.bdBitDepth;
const Bool left = (pSC->cColumn == 0), right = (pSC->cColumn == pSC->cmbWidth);
const Bool top = (pSC->cRow == 0), bottom = (pSC->cRow == pSC->cmbHeight);
const Bool topORbottom = (top || bottom), leftORright = (left || right);
const Bool topORleft = (top || left), bottomORright = (bottom || right);
const size_t mbWidth = pSC->cmbWidth, mbX = pSC->cColumn;
PixelI * p = NULL;// * pt = NULL;
src/Source/LibJXR/image/decode/strInvTransform.c view on Meta::CPAN
{
strPost4x4Stage1Split(p0 + j + 48, p1 + j + 0, 0, iHPQP, bHPAbsent);
}
}
}
}
return ICERR_OK;
}
Int invTransformMacroblock_alteredOperators_hard(CWMImageStrCodec * pSC)
{
const OVERLAP olOverlap = pSC->WMISCP.olOverlap;
const COLORFORMAT cfColorFormat = pSC->m_param.cfColorFormat;
// const BITDEPTH_BITS bdBitDepth = pSC->WMII.bdBitDepth;
const Bool left = (pSC->cColumn == 0), right = (pSC->cColumn == pSC->cmbWidth);
const Bool top = (pSC->cRow == 0), bottom = (pSC->cRow == pSC->cmbHeight);
const Bool topORbottom = (top || bottom), leftORright = (left || right);
const Bool topORleft = (top || left), bottomORright = (bottom || right);
Bool leftAdjacentColumn = (pSC->cColumn == 1), rightAdjacentColumn = (pSC->cColumn == pSC->cmbWidth - 1);
// Bool topAdjacentRow = (pSC->cRow == 1), bottomAdjacentRow = (pSC->cRow == pSC->cmbHeight - 1);
src/Source/LibJXR/image/decode/strPredQuantDec.c view on Meta::CPAN
pRec[ 64] = DEQUANT(pOrg[1], iQPLP);
pRec[ 16] = DEQUANT(pOrg[2], iQPLP);
pRec[ 80] = DEQUANT(pOrg[3], iQPLP);
pRec[ 32] = DEQUANT(pOrg[4], iQPLP);
pRec[ 96] = DEQUANT(pOrg[5], iQPLP);
pRec[ 48] = DEQUANT(pOrg[6], iQPLP);
pRec[112] = DEQUANT(pOrg[7], iQPLP);
}
Int dequantizeMacroblock(CWMImageStrCodec * pSC)
{
const COLORFORMAT cf = pSC->m_param.cfColorFormat;
CWMIMBInfo *pMBInfo = &pSC->MBInfo;
CWMITile * pTile = pSC->pTile + pSC->cTileColumn;
const size_t iChannels = pSC->m_param.cNumChannels;
size_t i;
for(i = 0; i < iChannels; i ++){
//dequantize DC
pSC->p1MBbuffer[i][0] = DEQUANT(pMBInfo->iBlockDC[i][0], pTile->pQuantizerDC[i]->iQP);
src/Source/LibJXR/image/decode/strdec.c view on Meta::CPAN
#ifdef X86OPT_INLINE
#define _FORCEINLINE __forceinline
#else // X86OPT_INLINE
#define _FORCEINLINE
#endif // X86OPT_INLINE
#if defined(WMP_OPT_SSE2) || defined(WMP_OPT_CC_DEC) || defined(WMP_OPT_TRFM_DEC)
void StrDecOpt(CWMImageStrCodec* pSC);
#endif // OPT defined
Int processMacroblockDec(CWMImageStrCodec *);
U8 readQuantizerSB(U8 pQPIndex[MAX_CHANNELS], SimpleBitIO * pIO, size_t cChannel)
{
U8 cChMode = 0;
if(cChannel >= MAX_CHANNELS)
return 0;
if(cChannel > 1)
cChMode = (U8)getBit32_SB(pIO, 2); // Channel mode
src/Source/LibJXR/image/decode/strdec.c view on Meta::CPAN
readTileHeaderHP(pSC, pContext->m_pIOAC);
if(pSC->m_pNextSC != NULL)
readTileHeaderHP(pSC->m_pNextSC, pContext->m_pIOAC);
}
}
return ICERR_OK;
}
/* inverse transform and overlap possible part of a macroblock */
Int processMacroblockDec(CWMImageStrCodec * pSC)
{
const OVERLAP olOverlap = pSC->WMISCP.olOverlap;
// const Bool left = (pSC->cColumn == 0);
const Bool /*top = (pSC->cRow == 0),*/ bottom = (pSC->cRow == pSC->cmbHeight);
const Bool bottomORright = (bottom || pSC->cColumn == pSC->cmbWidth);
// const size_t mbWidth = pSC->cmbWidth, mbX = pSC->cColumn;
// Int iQIndex = 0;
ERR_CODE result = ICERR_OK;
size_t j, jend = (pSC->m_pNextSC != NULL);
src/Source/LibJXR/image/decode/strdec.c view on Meta::CPAN
size_t tRight = (pSC->cTileColumn != pSC->WMISCP.cNumOfSliceMinus1V ? pSC->WMISCP.uiTileX[pSC->cTileColumn + 1] : pSC->cmbWidth) * 16;
size_t tBottom = (pSC->cTileRow != pSC->WMISCP.cNumOfSliceMinus1H ? pSC->WMISCP.uiTileY[pSC->cTileRow + 1] : pSC->cmbHeight) * 16;
// tile overlaps with ROI?
pContext->m_bInROI = ((rLeft >= tRight + rExt || rTop >= tBottom + rExt || tLeft > rRight + rExt ||
tTop > rBottom + rExt || pSC->cRow * 16 > rBottom + rExt) ? FALSE : TRUE);
}
}
if(pSC->m_Dparam->bDecodeFullFrame || pContext->m_bInROI){
if ((result = DecodeMacroblockDC(pSC, pContext, (Int)pSC->cColumn, (Int)pSC->cRow)) != ICERR_OK)
return result;
if(pSC->m_Dparam->bDecodeLP){
if ((result = DecodeMacroblockLowpass(pSC, pContext, (Int)pSC->cColumn, (Int)pSC->cRow)) != ICERR_OK)
return result;
}
predDCACDec(pSC);
dequantizeMacroblock(pSC);
if(pSC->m_Dparam->bDecodeHP){
if ((result = DecodeMacroblockHighpass(pSC, pContext, (Int)pSC->cColumn, (Int)pSC->cRow)) != ICERR_OK)
return result;
predACDec(pSC);
}
/* keep necessary info for future prediction */
updatePredInfo(pSC, &pSC->MBInfo, (Int)pSC->cColumn, pSC->m_param.cfColorFormat);
}
}
if((!pSC->m_Dparam->bDecodeFullFrame) &&
src/Source/LibJXR/image/decode/strdec.c view on Meta::CPAN
pSC->WMISCP = pSCIn->WMISCP;
pSC->cRow = 0;
pSC->cColumn = 0;
pSC->cmbWidth = (pSC->WMII.cWidth + 15) / 16;
pSC->cmbHeight = (pSC->WMII.cHeight + 15) / 16;
pSC->Load = outputMBRow; // output decoding result (ICC, etc)
pSC->Transform = pParams->cSubVersion == CODEC_SUBVERSION ?
invTransformMacroblock : invTransformMacroblock_alteredOperators_hard;
pSC->TransformCenter = pSC->Transform;
pSC->ProcessTopLeft = processMacroblockDec;
pSC->ProcessTop = processMacroblockDec;
pSC->ProcessTopRight = processMacroblockDec;
pSC->ProcessLeft = processMacroblockDec;
pSC->ProcessCenter = processMacroblockDec;
pSC->ProcessRight = processMacroblockDec;
pSC->ProcessBottomLeft = processMacroblockDec;
pSC->ProcessBottom = processMacroblockDec;
pSC->ProcessBottomRight = processMacroblockDec;
pSC->m_pNextSC = NULL;
pSC->m_bSecondary = FALSE;
}
/*************************************************************************
ImageStrDecInit
*************************************************************************/
Int ImageStrDecInit(
CWMImageInfo* pII,
src/Source/LibJXR/image/decode/strdec.c view on Meta::CPAN
pSC->m_Dparam = (CWMDecoderParameters*)pb; pb += sizeof(CWMDecoderParameters);
pSC->cbChannel = cbChannel;
//pSC->cNumChannels = SC.WMISCP.cChannel;
pSC->bUseHardTileBoundaries = bUseHardTileBoundaries;
//================================================
InitializeStrDec(pSC, &SC.m_param, &SC);
//================================================
// 2 Macro Row buffers for each channel
pb = ALIGNUP(pb, 128);
for (i = 0; i < pSC->m_param.cNumChannels; i++) {
pSC->a0MBbuffer[i] = (PixelI*)pb; pb += cbMacBlockStride * pSC->cmbWidth;
pSC->a1MBbuffer[i] = (PixelI*)pb; pb += cbMacBlockStride * pSC->cmbWidth;
cbMacBlockStride = cbMacBlockChroma;
}
//================================================
// lay 2 aligned IO buffers just below pIO struct
pb = (char*)ALIGNUP(pb, PACKETLENGTH * 4) + PACKETLENGTH * 2;
src/Source/LibJXR/image/decode/strdec.c view on Meta::CPAN
pNextSC->cbChannel = cbChannel;
//================================================
// 3. initialize arrays
// InitializeStrDec(pNextSC, &SC.m_param, &SC);
pNextSC->m_param.cfColorFormat = Y_ONLY;
pNextSC->m_param.cNumChannels = 1;
pNextSC->m_param.bAlphaChannel = TRUE;
//================================================
// 2 Macro Row buffers for each channel
pb = ALIGNUP(pb, 128);
pNextSC->a0MBbuffer[0] = (PixelI*)pb; pb += cbMacBlockStride * pNextSC->cmbWidth;
pNextSC->a1MBbuffer[0] = (PixelI*)pb;
//================================================
pNextSC->pIOHeader = pSC->pIOHeader;
//================================================
// 4. link pSC->pNextSC = pNextSC
pNextSC->m_pNextSC = pSC;
pNextSC->m_bSecondary = TRUE;
src/Source/LibJXR/image/decode/strdec.c view on Meta::CPAN
//================================
// top row
#ifdef REENTRANT_MODE
#else
pSC->cRow = 0;
ProcessLeft = pSC->ProcessTopLeft;
ProcessCenter = pSC->ProcessTop;
ProcessRight = pSC->ProcessTopRight;
Transform = pSC->m_param.cSubVersion == CODEC_SUBVERSION ?
invTransformMacroblock : invTransformMacroblock_alteredOperators_hard;
#endif // REENTRANT_MODE
#ifdef REENTRANT_MODE
for (pSC->cRow = pSC->WMIBI.uiFirstMBRow; pSC->cRow <= pSC->WMIBI.uiLastMBRow; pSC->cRow++)
{
// const COLORFORMAT cfExt = (pSC->m_param.cfColorFormat == Y_ONLY ? Y_ONLY : pSC->WMII.cfColorFormat);
if (0 == pSC->cRow)
{
ProcessLeft = pSC->ProcessTopLeft;
ProcessCenter = pSC->ProcessTop;
ProcessRight = pSC->ProcessTopRight;
Transform = pSC->m_param.cSubVersion == CODEC_SUBVERSION ?
invTransformMacroblock : invTransformMacroblock_alteredOperators_hard;
}
else if (cMBRow == pSC->cRow)
{
//================================
// bottom row
ProcessLeft = pSC->ProcessBottomLeft;
ProcessCenter = pSC->ProcessBottom;
ProcessRight = pSC->ProcessBottomRight;
Transform = pSC->m_param.cSubVersion == CODEC_SUBVERSION ?
invTransformMacroblock : invTransformMacroblock_alteredOperators_hard;
}
else { // middle rows
ProcessLeft = pSC->ProcessLeft;
ProcessCenter = pSC->ProcessCenter;
ProcessRight = pSC->ProcessRight;
Transform = pSC->TransformCenter;
}
#else
//================================
// central rows
src/Source/LibJXR/image/decode/strdec.c view on Meta::CPAN
advanceMRPtr(pSC);
pSC->Transform = Transform;
for (pSC->cColumn = 1; pSC->cColumn < pSC->cmbWidth; ++pSC->cColumn)
{
if(ProcessCenter(pSC) != ICERR_OK)
return ICERR_ERROR;
advanceMRPtr(pSC);
}
pSC->Transform = pSC->m_param.cSubVersion == CODEC_SUBVERSION ?
invTransformMacroblock : invTransformMacroblock_alteredOperators_hard;
if(ProcessRight(pSC) != ICERR_OK)
return ICERR_ERROR;
if (pSC->cRow) {
if(pSC->m_Dparam->cThumbnailScale < 2 && (pSC->m_Dparam->bDecodeFullFrame ||
((pSC->cRow * 16 > pSC->m_Dparam->cROITopY) && (pSC->cRow * 16 <= pSC->m_Dparam->cROIBottomY + 16)))) {
if( pSC->Load(pSC) != ICERR_OK ) // bypass CC for thumbnail decode
return ICERR_ERROR;
}
src/Source/LibJXR/image/decode/strdec.c view on Meta::CPAN
#ifdef REENTRANT_MODE
*pcDecodedLines = pSC->WMIBI.cLinesDecoded;
#else
if (pSC->cRow == cMBRow - 1) {
//================================
// bottom row
ProcessLeft = pSC->ProcessBottomLeft;
ProcessCenter = pSC->ProcessBottom;
ProcessRight = pSC->ProcessBottomRight;
Transform = pSC->m_param.cSubVersion == CODEC_SUBVERSION ?
invTransformMacroblock : invTransformMacroblock_alteredOperators_hard;
}
else {
ProcessLeft = pSC->ProcessLeft;
ProcessCenter = pSC->ProcessCenter;
ProcessRight = pSC->ProcessRight;
Transform = pSC->TransformCenter;
}
#endif // REENTRANT_MODE
}
src/Source/LibJXR/image/decode/strdec_x86.c view on Meta::CPAN
//================
add esp, (4 + 4) * 16 + 4
pop edi
pop esi
pop ebx
pop ebp
ret 4 * 2
}
}
Int invTransformMacroblock_YUV444_Center5(CWMImageStrCodec * pSC)
{
const OVERLAP olOverlap = pSC->WMISCP.olOverlap;
int i = 0;
assert(0 < pSC->cRow && pSC->cRow < pSC->cmbHeight);
assert(0 < pSC->cColumn && pSC->cColumn < pSC->cmbWidth);
assert(0 == pSC->WMII.cPostProcStrength);
assert(YUV_444 == pSC->m_param.cfColorFormat);
src/Source/LibJXR/image/decode/strdec_x86.c view on Meta::CPAN
#endif // WMP_OPT_CC_DEC
}
if (YUV_444 == pSC->m_param.cfColorFormat &&
pSC->p1MBbuffer[1] - pSC->p1MBbuffer[0] == pSC->p1MBbuffer[2] - pSC->p1MBbuffer[1] &&
pSC->m_Dparam->bDecodeFullWidth &&
pSC->m_param.cSubVersion == CODEC_SUBVERSION_NEWSCALING_SOFT_TILES &&
1 == pSC->m_Dparam->cThumbnailScale)
{
#if defined(WMP_OPT_TRFM_DEC)
pSC->TransformCenter = invTransformMacroblock_YUV444_Center5;
#endif
}
}
#else
UNREFERENCED_PARAMETER( pSC );
#endif
}
src/Source/LibJXR/image/encode/encode.h view on Meta::CPAN
#ifndef WMI_ENCODE_H
#define WMI_ENCODE_H
#include "strcodec.h"
/*************************************************************************
struct / class definitions
*************************************************************************/
Int EncodeMacroblockDC(CWMImageStrCodec*, CCodingContext *, Int, Int);
Int EncodeMacroblockLowpass(CWMImageStrCodec*, CCodingContext *, Int, Int);
Int EncodeMacroblockHighpass(CWMImageStrCodec*, CCodingContext *, Int, Int);
Int quantizeMacroblock(CWMImageStrCodec *);
Void transformMacroblock(CWMImageStrCodec *);
Void predMacroblockEnc(CWMImageStrCodec *);
Void AdaptLowpassEnc(CCodingContext *pContext);
Void AdaptHighpassEnc(CCodingContext *pContext);
Void ResetCodingContextEnc(CCodingContext *pContext);
Int AllocateCodingContextEnc(struct CWMImageStrCodec *pSC, Int iNumContexts, Int iTrimFlexBits);
Void FreeCodingContextEnc(struct CWMImageStrCodec *pSC);
Void predCBPEnc(CWMImageStrCodec *pSC, CCodingContext *pContext);
/*************************************************************************
Forward transform definitions
src/Source/LibJXR/image/encode/segenc.c view on Meta::CPAN
iIndex = aIndex[iAbsLevel];
iFixed = aFixedLength[iIndex];
pAHexpt->m_iDiscriminant += pAHexpt->m_pDelta[iIndex];
putBit16z(pOut, pAHexpt->m_pTable[iIndex * 2 + 1], pAHexpt->m_pTable[iIndex * 2 + 2]);
putBit32(pOut, iAbsLevel, iFixed);
}
}
/*************************************************************************
EncodeMacroblockDC
*************************************************************************/
Void encodeQPIndex(BitIOInfo* pIO, U8 iIndex,U8 cBits)
{
if(iIndex == 0)
putBit16z(pIO, 0, 1);
else{
putBit16z(pIO, 1, 1);
putBit16z(pIO, iIndex - 1, cBits);
}
}
Int EncodeMacroblockDC (CWMImageStrCodec *pSC, CCodingContext *pContext, Int iMBX, Int iMBY)
{
CWMITile * pTile = pSC->pTile + pSC->cTileColumn;
BitIOInfo* pIO = pContext->m_pIODC;
CWMIMBInfo *pMBInfo = &pSC->MBInfo;
Int iIndex, j = 0;
struct CAdaptiveHuffman *pAH;
Int aLaplacianMean[2] = { 0, 0}, *pLM = aLaplacianMean;
Int iModelBits = pContext->m_aModelDC.m_iFlcBits[0];
COLORFORMAT cf = pSC->m_param.cfColorFormat;
const Int iChannels = (Int) pSC->m_param.cNumChannels;
src/Source/LibJXR/image/encode/segenc.c view on Meta::CPAN
if(pSC->WMISCP.bfBitstreamFormat == SPATIAL && pSC->WMISCP.sbSubband != SB_DC_ONLY){
if(pTile->cBitsLP > 0) // MB-based LP QP index
encodeQPIndex(pIO, pMBInfo->iQIndexLP, pTile->cBitsLP);
if( pSC->WMISCP.sbSubband != SB_NO_HIGHPASS && pTile->cBitsHP > 0) // MB-based HP QP index
encodeQPIndex(pIO, pMBInfo->iQIndexHP, pTile->cBitsHP);
}
if(pSC->m_param.bTranscode == FALSE)
pSC->Quantize(pSC);
predMacroblockEnc(pSC);
/** code path for Y_ONLY, CMYK and N_CHANNEL DC **/
if(cf == Y_ONLY || cf == CMYK || cf == NCOMPONENT) {
Int iQDC, iDC, iSign;
for (j = 0; j < iChannels; j++) {
iDC = pMBInfo->iBlockDC[j][0];
iSign = (iDC < 0);
iDC = abs(iDC);
iQDC = iDC >> iModelBits;
src/Source/LibJXR/image/encode/segenc.c view on Meta::CPAN
iLevel = ((iLevel + iTemp) >> iTrimBits) - iTemp; // round towards zero
iTemp = -(iLevel < 0);
pResidual[sk] = (iLevel ^ iTemp) * 4 + (6 & iTemp) + (iLevel != 0);
}
}
return iNumNonzero;
}
}
/*************************************************************************
EncodeMacroblockLowpass
*************************************************************************/
Int EncodeMacroblockLowpass (CWMImageStrCodec *pSC, CCodingContext *pContext, Int iMBX, Int iMBY)
{
const COLORFORMAT cf = pSC->m_param.cfColorFormat;
const Int iChannels = (Int) pSC->m_param.cNumChannels;
Int iFullChannels = (cf == YUV_420 || cf == YUV_422) ? 1 : iChannels;
CWMIMBInfo *pMBInfo = &pSC->MBInfo;
BitIOInfo* pIO = pContext->m_pIOLP;
CAdaptiveScan *pScan = pContext->m_aScanLowpass;
Int k, /*iPrevRun = -1,*/ iRun = 0;// iLastIndex = 0;
Int iModelBits = pContext->m_aModelLP.m_iFlcBits[0];
src/Source/LibJXR/image/encode/segenc.c view on Meta::CPAN
}
}
}
}
}
}
/*************************************************************************
macroblock encode function using 4x4 transforms
*************************************************************************/
Int EncodeMacroblockHighpass(CWMImageStrCodec * pSC, CCodingContext *pContext, Int iMBX, Int iMBY)
{
BitIOInfo* pIO = pContext->m_pIOAC;
BitIOInfo* pIOFL = pContext->m_pIOFL;
if((pSC->WMISCP.bfBitstreamFormat != SPATIAL) && (pSC->pTile[pSC->cTileColumn].cBitsHP > 0)) // MB-based HP QP index
encodeQPIndex(pIO, pSC->MBInfo.iQIndexHP, pSC->pTile[pSC->cTileColumn].cBitsHP);
/** reset adaptive scan totals **/
if (pSC->m_bResetRGITotals) {
Int iScale = 2;
src/Source/LibJXR/image/encode/strFwdTransform.c view on Meta::CPAN
*pa = a;
*pb = b;
*pc = c;
*pd = d;
}
/*************************************************************************
Top-level function to tranform possible part of a macroblock
*************************************************************************/
Void transformMacroblock(CWMImageStrCodec * pSC)
{
OVERLAP olOverlap = pSC->WMISCP.olOverlap;
COLORFORMAT cfColorFormat = pSC->m_param.cfColorFormat;
Bool left = (pSC->cColumn == 0), right = (pSC->cColumn == pSC->cmbWidth);
Bool top = (pSC->cRow == 0), bottom = (pSC->cRow == pSC->cmbHeight);
Bool leftORright = (left || right), topORbottom = (top || bottom);
Bool topORleft = (left || top);// rightORbottom = (right || bottom);
Bool leftAdjacentColumn = (pSC->cColumn == 1), rightAdjacentColumn = (pSC->cColumn == pSC->cmbWidth - 1);
// Bool topAdjacentRow = (pSC->cRow == 1), bottomAdjacentRow = (pSC->cRow == pSC->cmbHeight - 1);
PixelI * p = NULL;// * pt = NULL;
src/Source/LibJXR/image/encode/strPredQuantEnc.c view on Meta::CPAN
}
I32 QUANT(PixelI v, PixelI o, I32 man, I32 exp)
{
const I32 m = v >> 31;
assert(sizeof(PixelI) == sizeof(U32));
return (MUL32HR((v ^ m) - m + o, man, exp) ^ m) - m;
}
Int quantizeMacroblock(CWMImageStrCodec* pSC)
{
CWMITile * pTile = pSC->pTile + pSC->cTileColumn;
CWMIMBInfo * pMBInfo = &pSC->MBInfo;
const COLORFORMAT cf = pSC->m_param.cfColorFormat;
int iChannel, i, j;
if(/*pSC->m_param.bScaledArith && */pSC->m_param.bTranscode == FALSE)
for(iChannel = 0; iChannel < (int)pSC->m_param.cNumChannels; iChannel ++){
const Bool bUV = (iChannel > 0 && (cf == YUV_444 || cf == YUV_422 || cf == YUV_420));
const int iNumBlock = (bUV ? (cf == YUV_422 ? 8 : (cf == YUV_420 ? 4 : 16)) : 16);
src/Source/LibJXR/image/encode/strPredQuantEnc.c view on Meta::CPAN
for(i = 0; i < 16; i ++){
pDC[i] = pData[dctIndex[2][i]];
}
}
}
return 0;
}
/* frequency domain prediction */
Void predMacroblockEnc(CWMImageStrCodec * pSC)
{
const COLORFORMAT cf = pSC->m_param.cfColorFormat;
const Int iChannels = (cf == YUV_420 || cf == YUV_422) ? 1 : (Int) pSC->m_param.cNumChannels;
size_t mbX = pSC->cColumn - 1;// mbY = pSC->cRow - 1;
CWMIMBInfo *pMBInfo = &(pSC->MBInfo);
Int iDCACPredMode = getDCACPredMode(pSC, mbX);
Int iDCPredMode = (iDCACPredMode & 0x3);
Int iADPredMode = (iDCACPredMode & 0xC);
Int iACPredMode = getACPredMode(pMBInfo, cf);
PixelI * pOrg, * pRef;
src/Source/LibJXR/image/encode/strenc.c view on Meta::CPAN
writeTileHeaderHP(pSC, pContext->m_pIOAC);
}
if(pSC->cSB > 3) {
writePacketHeader(pContext->m_pIOFL, 4, pID);
if (pSC->m_param.bTrimFlexbitsFlag)
putBit16(pContext->m_pIOFL, pContext->m_iTrimFlexBits, 4);
}
}
}
if(EncodeMacroblockDC(pSC, pContext, iMBX, iMBY) != ICERR_OK)
return ICERR_ERROR;
if(pSC->WMISCP.sbSubband != SB_DC_ONLY)
if(EncodeMacroblockLowpass(pSC, pContext, iMBX, iMBY) != ICERR_OK)
return ICERR_ERROR;
if(pSC->WMISCP.sbSubband != SB_DC_ONLY && pSC->WMISCP.sbSubband != SB_NO_HIGHPASS)
if(EncodeMacroblockHighpass(pSC, pContext, iMBX, iMBY) != ICERR_OK)
return ICERR_ERROR;
if(iMBX + 1 == (int) pSC->cmbWidth && (iMBY + 1 == (int) pSC->cmbHeight ||
(pSC->cTileRow < pSC->WMISCP.cNumOfSliceMinus1H && iMBY == (int) pSC->WMISCP.uiTileY[pSC->cTileRow + 1] - 1)))
{ // end of a horizontal slice
size_t k, l;
// get sizes of each packet and update index table
if (pSC->m_pNextSC == NULL || pSC->m_bSecondary) {
for(k = 0; k < pSC->cNumBitIO; k ++){
src/Source/LibJXR/image/encode/strenc.c view on Meta::CPAN
ResetCodingContextEnc(&pSC->m_pCodingContext[k]);
}
}
return ICERR_OK;
}
/*************************************************************************
Top level function for processing a macroblock worth of input
*************************************************************************/
Int processMacroblock(CWMImageStrCodec *pSC)
{
Bool topORleft = (pSC->cColumn == 0 || pSC->cRow == 0);
ERR_CODE result = ICERR_OK;
size_t j, jend = (pSC->m_pNextSC != NULL);
for (j = 0; j <= jend; j++) {
transformMacroblock(pSC);
if(!topORleft){
getTilePos(pSC, (Int)pSC->cColumn - 1, (Int)pSC->cRow - 1);
if(jend){
pSC->m_pNextSC->cTileRow = pSC->cTileRow;
pSC->m_pNextSC->cTileColumn = pSC->cTileColumn;
}
if ((result = encodeMB(pSC, (Int)pSC->cColumn - 1, (Int)pSC->cRow - 1)) != ICERR_OK)
return result;
}
src/Source/LibJXR/image/encode/strenc.c view on Meta::CPAN
pSC->WMISCP.nExpBias = 4 + 128;//default
pSC->WMISCP.nExpBias += 128; // rollover arithmetic
pSC->cRow = 0;
pSC->cColumn = 0;
pSC->cmbWidth = (pSC->WMII.cWidth + 15) / 16;
pSC->cmbHeight = (pSC->WMII.cHeight + 15) / 16;
pSC->Load = inputMBRow;
pSC->Quantize = quantizeMacroblock;
pSC->ProcessTopLeft = processMacroblock;
pSC->ProcessTop = processMacroblock;
pSC->ProcessTopRight = processMacroblock;
pSC->ProcessLeft = processMacroblock;
pSC->ProcessCenter = processMacroblock;
pSC->ProcessRight = processMacroblock;
pSC->ProcessBottomLeft = processMacroblock;
pSC->ProcessBottom = processMacroblock;
pSC->ProcessBottomRight = processMacroblock;
pSC->m_pNextSC = NULL;
pSC->m_bSecondary = FALSE;
}
/*************************************************************************
Streaming API init
*************************************************************************/
Int ImageStrEncInit(
CWMImageInfo* pII,
src/Source/LibJXR/image/encode/strenc.c view on Meta::CPAN
= pSC->m_param.cExtraPixelsLeft = pSC->m_param.cExtraPixelsRight = 0;
pSC->cbChannel = cbChannel;
pSC->m_param.bTranscode = pSC->bTileExtraction = FALSE;
//================================================
InitializeStrEnc(pSC, pII, pSCP);
//================================================
// 2 Macro Row buffers for each channel
pb = ALIGNUP(pb, 128);
for (i = 0; i < pSC->m_param.cNumChannels; i++) {
pSC->a0MBbuffer[i] = (PixelI*)pb; pb += cbMacBlockStride * pSC->cmbWidth;
pSC->a1MBbuffer[i] = (PixelI*)pb; pb += cbMacBlockStride * pSC->cmbWidth;
cbMacBlockStride = cbMacBlockChroma;
}
//================================================
// lay 2 aligned IO buffers just below pIO struct
pb = (char*)ALIGNUP(pb, PACKETLENGTH * 4) + PACKETLENGTH * 2;
src/Source/LibJXR/image/encode/strenc.c view on Meta::CPAN
pNextSC->m_param.cfColorFormat = Y_ONLY;
pNextSC->m_param.cNumChannels = 1;
pNextSC->m_param.bAlphaChannel = TRUE;
pNextSC->cbChannel = cbChannel;
//================================================
// 3. initialize arrays
InitializeStrEnc(pNextSC, pII, pSCP);
//================================================
// 2 Macro Row buffers for each channel
pb = ALIGNUP(pb, 128);
pNextSC->a0MBbuffer[0] = (PixelI*)pb; pb += cbMacBlockStride * pNextSC->cmbWidth;
pNextSC->a1MBbuffer[0] = (PixelI*)pb; pb += cbMacBlockStride * pNextSC->cmbWidth;
//================================================
pNextSC->pIOHeader = pSC->pIOHeader;
//================================================
// 4. link pSC->pNextSC = pNextSC
pNextSC->m_pNextSC = pSC;
pNextSC->m_bSecondary = TRUE;
src/Source/LibJXR/image/encode/strenc_x86.c view on Meta::CPAN
assert(pbU - pbY == pbV - pbU);
RGB24_6(pbRGB + cbRGB * 0, cbRGB, pbY, pbU - pbY, cmbColumn);
return ICERR_OK;
}
#endif
//================================
#if defined(WMP_OPT_QT)
#if 0
Int quantizeMacroblock(CWMImageStrCodec* pSC)
{
assert(BD_8 == pSC->WMII.bdBitDepth);
assert(YUV_444 == pSC->m_param.cfColorFormat);
assert(pSC->m_param.bScaledArith);
assert(3 == pSC->m_param.cNumChannels);
assert(SB_ALL == pSC->WMISCP.sbSubband);
CWMITile* pTile = pSC->pTile + pSC->cTileColumn;
CWMIMBInfo* pMBInfo = &pSC->MBInfo;
int iChannel, i, j;
( run in 0.746 second using v1.01-cache-2.11-cpan-49f99fa48dc )