suyu/Yucom
25
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

build: Stop building FAudio and jxrlib.

Browse source
This commit is contained in:
Rémi Bernon 2021-10-22 11:26:36 +02:00
parent 7b8a0edb7b
commit e300e73ee2
No known key found for this signature in database
GPG key ID: 38D0E5827B54E5C9
66 changed files with 1 additions and 37208 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
.gitmodules vendored
View file

@ -10,9 +10,6 @@
[submodule "fonts/liberation-fonts"]
path = fonts/liberation-fonts
url = https://github.com/liberationfonts/liberation-fonts
[submodule "FAudio"]
path = FAudio
url = https://github.com/FNA-XNA/FAudio
[submodule "gstreamer"]
path = gstreamer
url = https://gitlab.freedesktop.org/gstreamer/gstreamer.git

1
FAudio

@ -1 +0,0 @@
Subproject commit 0c352eb92de9a4901030c1bce4fc3ddf3b3f1aac

28
build/makefile_base.mak
View file

@ -545,32 +545,6 @@ $(eval $(call rules-meson,gst_good,32))
$(eval $(call rules-meson,gst_good,64))
##
## FAudio
##
FAUDIO_CMAKE_ARGS = -DGSTREAMER=ON -DFORCE_ENABLE_DEBUGCONFIGURATION=ON -DLOG_ASSERTIONS=ON -DXNASONG=OFF
FAUDIO_DEPENDS = gst_orc gstreamer gst_base
$(eval $(call rules-source,faudio,$(SRCDIR)/FAudio))
$(eval $(call rules-cmake,faudio,32))
$(eval $(call rules-cmake,faudio,64))
##
## jxrlib
##
JXRLIB_CMAKE_ARGS64 = -DJXRLIB_INSTALL_LIB_DIR=lib64
JXRLIB_INCDIR32 = $(JXRLIB_DST32)/include/jxrlib
JXRLIB_INCDIR64 = $(JXRLIB_DST64)/include/jxrlib
$(eval $(call rules-source,jxrlib,$(SRCDIR)/jxrlib))
$(eval $(call rules-cmake,jxrlib,32))
$(eval $(call rules-cmake,jxrlib,64))
##
## Vulkan-Headers
##
@ -700,7 +674,7 @@ WINE_CONFIGURE_ARGS = \
WINE_CONFIGURE_ARGS64 = --enable-win64
WINE_DEPENDS = gst_orc gstreamer gst_base faudio jxrlib
WINE_DEPENDS = gst_orc gstreamer gst_base
$(eval $(call rules-source,wine,$(SRCDIR)/wine))
$(eval $(call rules-autoconf,wine,32))

135
jxrlib/CMakeLists.txt
View file

@ -1,135 +0,0 @@
# Copyright Mathieu Malaterre <malat@debian.org>
# BSD (Same as jxrlib)
cmake_minimum_required(VERSION 2.8)
project(jxrlib C)
# Need shared libs for ABI
set(BUILD_SHARED_LIBS ON)
# helper macro to preserve original Makefile convention
macro(JXR_MAKE_OBJ SET_NAME)
foreach(src ${SRC_${SET_NAME}})
list(APPEND OBJ_${SET_NAME} ${DIR_${SET_NAME}}/${src})
endforeach()
endmacro()
include(TestBigEndian)
test_big_endian(ISBIGENDIAN)
if(ISBIGENDIAN)
set(DEF_ENDIAN _BIG__ENDIAN_)
endif()
set(DIR_SYS image/sys)
set(DIR_DEC image/decode)
set(DIR_ENC image/encode)
set(DIR_GLUE jxrgluelib)
set(DIR_TEST jxrtestlib)
set(DIR_EXEC jxrencoderdecoder)
if(NOT JXRLIB_INSTALL_BIN_DIR)
set(JXRLIB_INSTALL_BIN_DIR "bin")
endif()
if(NOT JXRLIB_INSTALL_LIB_DIR)
set(JXRLIB_INSTALL_LIB_DIR "lib")
endif()
if(NOT JXRLIB_INSTALL_INCLUDE_DIR)
set(JXRLIB_INSTALL_INCLUDE_DIR "include/jxrlib")
endif()
include_directories(
common/include
${DIR_SYS}
${DIR_GLUE}
${DIR_TEST}
)
# where is strlcpy ?
include(CheckSymbolExists)
check_symbol_exists(strlcpy "string.h" HAVE_STRLCPY)
#set(CMAKE_REQUIRED_LIBRARIES bsd)
#CHECK_SYMBOL_EXISTS(strlcpy "string.h" HAVE_STRLCPY4)
# on linux, strlcpy is in -lbsd:
#if(NOT HAVE_STRLCPY)
# include(CheckLibraryExists)
# find_library(BSD_LIBRARY bsd)
# check_library_exists(bsd "strlcpy" ${BSD_LIBRARY} HAVE_STRLCPY_BSD)
#endif()
# JPEG-XR
set(SRC_SYS adapthuff.c image.c strcodec.c strPredQuant.c strTransform.c perfTimerANSI.c)
JXR_MAKE_OBJ(SYS)
set(SRC_DEC decode.c postprocess.c segdec.c strdec.c strInvTransform.c strPredQuantDec.c JXRTranscode.c)
JXR_MAKE_OBJ(DEC)
set(SRC_ENC encode.c segenc.c strenc.c strFwdTransform.c strPredQuantEnc.c)
JXR_MAKE_OBJ(ENC)
add_library(jpegxr ${OBJ_ENC} ${OBJ_DEC} ${OBJ_SYS})
set_property(TARGET jpegxr
PROPERTY COMPILE_DEFINITIONS __ANSI__ DISABLE_PERF_MEASUREMENT ${DEF_ENDIAN}
)
set_property(TARGET jpegxr PROPERTY LINK_INTERFACE_LIBRARIES "")
set_property(TARGET jpegxr PROPERTY COMPILE_FLAGS -w)
# VERSION/SOVERSION
set_property(TARGET jpegxr PROPERTY VERSION 1.1)
set_property(TARGET jpegxr PROPERTY SOVERSION 0)
install(TARGETS jpegxr
EXPORT JXRLibTargets
RUNTIME DESTINATION ${JXRLIB_INSTALL_BIN_DIR} COMPONENT Applications
LIBRARY DESTINATION ${JXRLIB_INSTALL_LIB_DIR} COMPONENT Libraries
)
# JXR-GLUE
set(SRC_GLUE JXRGlue.c JXRMeta.c JXRGluePFC.c JXRGlueJxr.c)
JXR_MAKE_OBJ(GLUE)
set(SRC_TEST JXRTest.c JXRTestBmp.c JXRTestHdr.c JXRTestPnm.c JXRTestTif.c JXRTestYUV.c)
JXR_MAKE_OBJ(TEST)
add_library(jxrglue ${OBJ_GLUE} ${OBJ_TEST})
set_property(TARGET jxrglue
PROPERTY COMPILE_DEFINITIONS __ANSI__ DISABLE_PERF_MEASUREMENT ${DEF_ENDIAN}
)
#set_property(TARGET jxrglue PROPERTY LINK_INTERFACE_LIBRARIES "")
set_property(TARGET jxrglue PROPERTY COMPILE_FLAGS -w)
# VERSION/SOVERSION
set_property(TARGET jxrglue PROPERTY VERSION 1.1)
set_property(TARGET jxrglue PROPERTY SOVERSION 0)
install(TARGETS jxrglue
EXPORT JXRLibTargets
RUNTIME DESTINATION ${JXRLIB_INSTALL_BIN_DIR} COMPONENT Applications
LIBRARY DESTINATION ${JXRLIB_INSTALL_LIB_DIR} COMPONENT Libraries
)
#if(HAVE_STRLCPY_BSD)
# target_link_libraries(jxrglue ${BSD_LIBRARY})
#endif()
#target_link_libraries(jxrglue m)
target_link_libraries(jxrglue PRIVATE jpegxr m)
# Enc app files
set(ENCAPP JxrEncApp)
add_executable(${ENCAPP} ${DIR_EXEC}/${ENCAPP}.c)
set_property(TARGET ${ENCAPP}
PROPERTY COMPILE_DEFINITIONS __ANSI__ DISABLE_PERF_MEASUREMENT ${DEF_ENDIAN}
)
#set_property(TARGET ${ENCAPP} PROPERTY COMPILE_FLAGS -w)
target_link_libraries(${ENCAPP} jxrglue) # jpegxr)
install(TARGETS ${ENCAPP} RUNTIME DESTINATION ${JXRLIB_INSTALL_BIN_DIR})
# Dec app files
set(DECAPP JxrDecApp)
add_executable(${DECAPP} ${DIR_EXEC}/${DECAPP}.c)
set_property(TARGET ${DECAPP}
PROPERTY COMPILE_DEFINITIONS __ANSI__ DISABLE_PERF_MEASUREMENT ${DEF_ENDIAN}
)
set_property(TARGET ${DECAPP} PROPERTY COMPILE_FLAGS -w)
target_link_libraries(${DECAPP} jxrglue) # jpegxr)
install(TARGETS ${DECAPP} RUNTIME DESTINATION ${JXRLIB_INSTALL_BIN_DIR})
# install rules
install(FILES jxrgluelib/JXRGlue.h jxrgluelib/JXRMeta.h jxrtestlib/JXRTest.h
image/sys/windowsmediaphoto.h
DESTINATION ${JXRLIB_INSTALL_INCLUDE_DIR} COMPONENT Headers
)
install(DIRECTORY common/include/ DESTINATION ${JXRLIB_INSTALL_INCLUDE_DIR}
FILES_MATCHING PATTERN "*.h"
)

147
jxrlib/Makefile
View file

@ -1,147 +0,0 @@
##//*@@@+++@@@@******************************************************************
##//
##// Copyright © Microsoft Corp.
##// All rights reserved.
##//
##// Redistribution and use in source and binary forms, with or without
##// modification, are permitted provided that the following conditions are met:
##//
##// • Redistributions of source code must retain the above copyright notice,
##// this list of conditions and the following disclaimer.
##// • Redistributions in binary form must reproduce the above copyright notice,
##// this list of conditions and the following disclaimer in the documentation
##// and/or other materials provided with the distribution.
##//
##// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
##// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
##// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
##// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
##// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
##// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
##// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
##// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
##// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
##// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
##// POSSIBILITY OF SUCH DAMAGE.
##//
##//*@@@---@@@@******************************************************************
## Makefile for building JPEG XR Porting Kit
##
build: all
CC=cc
DIR_SYS=image/sys
DIR_DEC=image/decode
DIR_ENC=image/encode
DIR_GLUE=jxrgluelib
DIR_TEST=jxrtestlib
DIR_EXEC=jxrencoderdecoder
CFLAGS=-I. -Icommon/include -I$(DIR_SYS) -D__ANSI__ -DDISABLE_PERF_MEASUREMENT -w -O
##
## Add following flag to CFLAGS above if target is a big endian machine
## -D_BIG__ENDIAN_
##
##--------------------------------
##
## Common files
##
OBJ_SYS=adapthuff.o image.o strcodec.o strPredQuant.o strTransform.o perfTimerANSI.o
$(OBJ_SYS):
$(CC) $(CFLAGS) -c $(DIR_SYS)/$*.c
##--------------------------------
##
## Decode files
##
OBJ_DEC=decode.o postprocess.o segdec.o strdec.o strInvTransform.o strPredQuantDec.o JXRTranscode.o
$(OBJ_DEC):
$(CC) $(CFLAGS) -c $(DIR_DEC)/$*.c
##--------------------------------
##
## Encode files
##
OBJ_ENC=encode.o segenc.o strenc.o strFwdTransform.o strPredQuantEnc.o
$(OBJ_ENC):
$(CC) $(CFLAGS) -c $(DIR_ENC)/$*.c
##--------------------------------
##
## JPEG XR library
##
libjpegxr.a: $(OBJ_ENC) $(OBJ_DEC) $(OBJ_SYS)
ar rvu $@ $(OBJ_ENC) $(OBJ_DEC) $(OBJ_SYS)
ranlib $@
##--------------------------------
##
## Glue files
##
OBJ_GLUE=JXRGlue.o JXRMeta.o JXRGluePFC.o JXRGlueJxr.o
$(OBJ_GLUE):
$(CC) $(CFLAGS) -I$(DIR_GLUE) -c $(DIR_GLUE)/$*.c
##--------------------------------
##
## Test files
##
OBJ_TEST=JXRTest.o JXRTestBmp.o JXRTestHdr.o JXRTestPnm.o JXRTestTif.o JXRTestYUV.o
$(OBJ_TEST):
$(CC) $(CFLAGS) -I$(DIR_GLUE) -I$(DIR_TEST) -c $(DIR_TEST)/$*.c
##--------------------------------
##
## JPEG XR Glue library
##
libjxrglue.a: $(OBJ_GLUE) $(OBJ_TEST)
ar rvu $@ $(OBJ_GLUE) $(OBJ_TEST)
ranlib $@
##--------------------------------
##
## Enc app files
##
LIBRARIES=libjxrglue.a libjpegxr.a
LIBS=-L. $(LIBRARIES) -lm
ENCAPP=JxrEncApp
$(ENCAPP): $(LIBRARIES)
$(CC) $(DIR_EXEC)/$(ENCAPP).c -o $(ENCAPP) $(CFLAGS) -I$(DIR_GLUE) -I$(DIR_TEST) $(LIBS)
##--------------------------------
##
## Dec app files
##
DECAPP=JxrDecApp
$(DECAPP): $(LIBRARIES)
$(CC) $(DIR_EXEC)/$(DECAPP).c -o $(DECAPP) $(CFLAGS) -I$(DIR_GLUE) -I$(DIR_TEST) $(LIBS)
##--------------------------------
##
## JPEG XR library
##
all: $(ENCAPP) $(DECAPP)
clean:
rm -rf *App *.o libj*.a
##

230
jxrlib/common/include/guiddef.h
View file

@ -1,230 +0,0 @@
//+---------------------------------------------------------------------------
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// File: guiddef.h
//
// Contents: GUID definition
//
//----------------------------------------------------------------------------
#ifndef GUID_DEFINED
#define GUID_DEFINED
#if defined(__midl)
typedef struct {
unsigned long Data1;
unsigned short Data2;
unsigned short Data3;
byte Data4[ 8 ];
} GUID;
#else
typedef struct _GUID {
#if defined(_WINDOWS_) || !__LP64__
unsigned long Data1;
#else
unsigned int Data1;
#endif
unsigned short Data2;
unsigned short Data3;
unsigned char Data4[ 8 ];
} GUID;
#endif
#endif
#ifndef FAR
#if defined(_WIN32) || defined(__ANSI__)
#define FAR
#else
#define FAR _far
#endif
#endif
#ifndef DECLSPEC_SELECTANY
#if (_MSC_VER >= 1100)
#define DECLSPEC_SELECTANY __declspec(selectany)
#else
#define DECLSPEC_SELECTANY
#endif
#endif
#ifndef EXTERN_C
#ifdef __cplusplus
#define EXTERN_C extern "C"
#else
#define EXTERN_C extern
#endif
#endif
#ifdef DEFINE_GUID
#undef DEFINE_GUID
#endif
#ifdef INITGUID
#define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
const GUID DECLSPEC_SELECTANY name \
= { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }
#else
#define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
EXTERN_C const GUID FAR name
#endif // INITGUID
#define DEFINE_OLEGUID(name, l, w1, w2) DEFINE_GUID(name, l, w1, w2, 0xC0,0,0,0,0,0,0,0x46)
#ifndef _GUIDDEF_H_
#define _GUIDDEF_H_
#ifndef __LPGUID_DEFINED__
#define __LPGUID_DEFINED__
typedef GUID *LPGUID;
#endif
#ifndef __LPCGUID_DEFINED__
#define __LPCGUID_DEFINED__
typedef const GUID *LPCGUID;
#endif
#ifndef __IID_DEFINED__
#define __IID_DEFINED__
typedef GUID IID;
typedef IID *LPIID;
#define IID_NULL GUID_NULL
#define IsEqualIID(riid1, riid2) IsEqualGUID(riid1, riid2)
typedef GUID CLSID;
typedef CLSID *LPCLSID;
#define CLSID_NULL GUID_NULL
#define IsEqualCLSID(rclsid1, rclsid2) IsEqualGUID(rclsid1, rclsid2)
typedef GUID FMTID;
typedef FMTID *LPFMTID;
#define FMTID_NULL GUID_NULL
#define IsEqualFMTID(rfmtid1, rfmtid2) IsEqualGUID(rfmtid1, rfmtid2)
#ifdef __midl_proxy
#define __MIDL_CONST
#else
#define __MIDL_CONST const
#endif
#ifndef _REFGUID_DEFINED
#define _REFGUID_DEFINED
#ifdef __cplusplus
#define REFGUID const GUID &
#else
#define REFGUID const GUID * __MIDL_CONST
#endif
#endif
#ifndef _REFIID_DEFINED
#define _REFIID_DEFINED
#ifdef __cplusplus
#define REFIID const IID &
#else
#define REFIID const IID * __MIDL_CONST
#endif
#endif
#ifndef _REFCLSID_DEFINED
#define _REFCLSID_DEFINED
#ifdef __cplusplus
#define REFCLSID const IID &
#else
#define REFCLSID const IID * __MIDL_CONST
#endif
#endif
#ifndef _REFFMTID_DEFINED
#define _REFFMTID_DEFINED
#ifdef __cplusplus
#define REFFMTID const IID &
#else
#define REFFMTID const IID * __MIDL_CONST
#endif
#endif
#endif // !__IID_DEFINED__
#if !defined (__midl)
#if !defined (_SYS_GUID_OPERATORS_)
#define _SYS_GUID_OPERATORS_
#include <string.h>
// Faster (but makes code fatter) inline version...use sparingly
#ifdef __cplusplus
__inline int InlineIsEqualGUID(REFGUID rguid1, REFGUID rguid2)
{
return (
((unsigned long *) &rguid1)[0] == ((unsigned long *) &rguid2)[0] &&
((unsigned long *) &rguid1)[1] == ((unsigned long *) &rguid2)[1] &&
((unsigned long *) &rguid1)[2] == ((unsigned long *) &rguid2)[2] &&
((unsigned long *) &rguid1)[3] == ((unsigned long *) &rguid2)[3]);
}
__inline int IsEqualGUID(REFGUID rguid1, REFGUID rguid2)
{
return !memcmp(&rguid1, &rguid2, sizeof(GUID));
}
#else // ! __cplusplus
#define InlineIsEqualGUID(rguid1, rguid2) \
(((unsigned long *) rguid1)[0] == ((unsigned long *) rguid2)[0] && \
((unsigned long *) rguid1)[1] == ((unsigned long *) rguid2)[1] && \
((unsigned long *) rguid1)[2] == ((unsigned long *) rguid2)[2] && \
((unsigned long *) rguid1)[3] == ((unsigned long *) rguid2)[3])
#define IsEqualGUID(rguid1, rguid2) (!memcmp(rguid1, rguid2, sizeof(GUID)))
#endif // __cplusplus
#ifdef __INLINE_ISEQUAL_GUID
#undef IsEqualGUID
#define IsEqualGUID(rguid1, rguid2) InlineIsEqualGUID(rguid1, rguid2)
#endif
// Same type, different name
#define IsEqualIID(riid1, riid2) IsEqualGUID(riid1, riid2)
#define IsEqualCLSID(rclsid1, rclsid2) IsEqualGUID(rclsid1, rclsid2)
#if !defined _SYS_GUID_OPERATOR_EQ_ && !defined _NO_SYS_GUID_OPERATOR_EQ_
#define _SYS_GUID_OPERATOR_EQ_
// A couple of C++ helpers
#ifdef __cplusplus
__inline int operator==(REFGUID guidOne, REFGUID guidOther)
{
return IsEqualGUID(guidOne,guidOther);
}
__inline int operator!=(REFGUID guidOne, REFGUID guidOther)
{
return !(guidOne == guidOther);
}
#endif
#endif // _SYS_GUID_OPERATOR_EQ_
#endif // _SYS_GUID_OPERATORS_
#endif // __midl
#endif // _GUIDDEF_H_

757
jxrlib/common/include/wmsal.h
View file

@ -1,757 +0,0 @@
/***
*sal.h - markers for documenting the semantics of APIs
*
* Copyright © Microsoft Corp.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* • Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* • Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
*Purpose:
* sal.h provides a set of annotations to describe how a function uses its
* parameters - the assumptions it makes about them, and the guarantees it makes
* upon finishing.
*
* [Public]
*
****/
/*
-------------------------------------------------------------------------------
Introduction
sal.h provides a set of annotations to describe how a function uses its
parameters - the assumptions it makes about them, and the guarantees it makes
upon finishing.
Annotations may be placed before either a function parameter's type or its return
type, and describe the function's behavior regarding the parameter or return value.
There are two classes of annotations: buffer annotations and advanced annotations.
Buffer annotations describe how functions use their pointer parameters, and
advanced annotations either describe complex/unusual buffer behavior, or provide
additional information about a parameter that is not otherwise expressible.
-------------------------------------------------------------------------------
Buffer Annotations
The most important annotations in sal.h provide a consistent way to annotate
buffer parameters or return values for a function. Each of these annotations describes
a single buffer (which could be a string, a fixed-length or variable-length array,
or just a pointer) that the function interacts with: where it is, how large it is,
how much is initialized, and what the function does with it.
The appropriate macro for a given buffer can be constructed using the table below.
Just pick the appropriate values from each category, and combine them together
with a leading underscore. Some combinations of values do not make sense as buffer
annotations. Only meaningful annotations can be added to your code; for a list of
these, see the buffer annotation definitions section.
Only a single buffer annotation should be used for each parameter.
|------------|------------|---------|--------|----------|----------|---------------|
| Level | Usage | Size | Output | NullTerm | Optional | Parameters |
|------------|------------|---------|--------|----------|----------|---------------|
| <> | <> | <> | <> | _z | <> | <> |
| _deref | _in | _ecount | _full | _nz | _opt | (size) |
| _deref_opt | _out | _bcount | _part | | | (size,length) |
| | _inout | | | | | |
| | | | | | | |
|------------|------------|---------|--------|----------|----------|---------------|
Level: Describes the buffer pointer's level of indirection from the parameter or
return value 'p'.
<> : p is the buffer pointer.
_deref : *p is the buffer pointer. p must not be NULL.
_deref_opt : *p may be the buffer pointer. p may be NULL, in which case the rest of
the annotation is ignored.
Usage: Describes how the function uses the buffer.
<> : The buffer is not accessed. If used on the return value or with _deref, the
function will provide the buffer, and it will be uninitialized at exit.
Otherwise, the caller must provide the buffer. This should only be used
for alloc and free functions.
_in : The function will only read from the buffer. The caller must provide the
buffer and initialize it. Cannot be used with _deref.
_out : The function will only write to the buffer. If used on the return value or
with _deref, the function will provide the buffer and initialize it.
Otherwise, the caller must provide the buffer, and the function will
initialize it.
_inout : The function may freely read from and write to the buffer. The caller must
provide the buffer and initialize it. If used with _deref, the buffer may
be reallocated by the function.
Size: Describes the total size of the buffer. This may be less than the space actually
allocated for the buffer, in which case it describes the accessible amount.
<> : No buffer size is given. If the type specifies the buffer size (such as
with LPSTR and LPWSTR), that amount is used. Otherwise, the buffer is one
element long. Must be used with _in, _out, or _inout.
_ecount : The buffer size is an explicit element count.
_bcount : The buffer size is an explicit byte count.
Output: Describes how much of the buffer will be initialized by the function. For
_inout buffers, this also describes how much is initialized at entry. Omit this
category for _in buffers; they must be fully initialized by the caller.
<> : The type specifies how much is initialized. For instance, a function initializing
an LPWSTR must NULL-terminate the string.
_full : The function initializes the entire buffer.
_part : The function initializes part of the buffer, and explicitly indicates how much.
NullTerm: States if the present of a '\0' marks the end of valid elements in the buffer.
_z : A '\0' indicated the end of the buffer
_nz : The buffer may not be null terminated and a '\0' does not indicate the end of the
buffer.
Optional: Describes if the buffer itself is optional.
<> : The pointer to the buffer must not be NULL.
_opt : The pointer to the buffer might be NULL. It will be checked before being dereferenced.
Parameters: Gives explicit counts for the size and length of the buffer.
<> : There is no explicit count. Use when neither _ecount nor _bcount is used.
(size) : Only the buffer's total size is given. Use with _ecount or _bcount but not _part.
(size,length) : The buffer's total size and initialized length are given. Use with _ecount_part
and _bcount_part.
-------------------------------------------------------------------------------
Buffer Annotation Examples
LWSTDAPI_(BOOL) StrToIntExA(
LPCSTR pszString, -- No annotation required, const implies __in.
DWORD dwFlags,
__out int *piRet -- A pointer whose dereference will be filled in.
);
void MyPaintingFunction(
__in HWND hwndControl, -- An initialized read-only parameter.
__in_opt HDC hdcOptional, -- An initialized read-only parameter that might be NULL.
__inout IPropertyStore *ppsStore -- An initialized parameter that may be freely used
-- and modified.
);
LWSTDAPI_(BOOL) PathCompactPathExA(
__out_ecount(cchMax) LPSTR pszOut, -- A string buffer with cch elements that will
-- be NULL terminated on exit.
LPCSTR pszSrc, -- No annotation required, const implies __in.
UINT cchMax,
DWORD dwFlags
);
HRESULT SHLocalAllocBytes(
size_t cb,
__deref_bcount(cb) T **ppv -- A pointer whose dereference will be set to an
-- uninitialized buffer with cb bytes.
);
__inout_bcount_full(cb) : A buffer with cb elements that is fully initialized at
entry and exit, and may be written to by this function.
__out_ecount_part(count, *countOut) : A buffer with count elements that will be
partially initialized by this function. The function indicates how much it
initialized by setting *countOut.
-------------------------------------------------------------------------------
Advanced Annotations
Advanced annotations describe behavior that is not expressible with the regular
buffer macros. These may be used either to annotate buffer parameters that involve
complex or conditional behavior, or to enrich existing annotations with additional
information.
__success(expr) f :
<expr> indicates whether function f succeeded or not. If <expr> is true at exit,
all the function's guarantees (as given by other annotations) must hold. If <expr>
is false at exit, the caller should not expect any of the function's guarantees
to hold. If not used, the function must always satisfy its guarantees. Added
automatically to functions that indicate success in standard ways, such as by
returning an HRESULT.
__nullterminated p :
Pointer p is a buffer that may be read or written up to and including the first
NULL character or pointer. May be used on typedefs, which marks valid (properly
initialized) instances of that type as being NULL-terminated.
__nullnullterminated p :
Pointer p is a buffer that may be read or written up to and including the first
sequence of two NULL characters or pointers. May be used on typedefs, which marks
valid instances of that type as being double-NULL terminated.
__reserved v :
Value v must be 0/NULL, reserved for future use.
__checkReturn v :
Return value v must not be ignored by callers of this function.
__typefix(ctype) v :
Value v should be treated as an instance of ctype, rather than its declared type.
__override f :
Specify C#-style 'override' behaviour for overriding virtual methods.
__callback f :
Function f can be used as a function pointer.
__format_string p :
Pointer p is a string that contains % markers in the style of printf.
__blocksOn(resource) f :
Function f blocks on the resource 'resource'.
__fallthrough :
Annotates switch statement labels where fall-through is desired, to distinguish
from forgotten break statements.
-------------------------------------------------------------------------------
Advanced Annotation Examples
__success(return == TRUE) LWSTDAPI_(BOOL)
PathCanonicalizeA(__out_ecount(MAX_PATH) LPSTR pszBuf, LPCSTR pszPath) :
pszBuf is only guaranteed to be NULL-terminated when TRUE is returned.
typedef __nullterminated WCHAR* LPWSTR : Initialized LPWSTRs are NULL-terminated strings.
__out_ecount(cch) __typefix(LPWSTR) void *psz : psz is a buffer parameter which will be
a NULL-terminated WCHAR string at exit, and which initially contains cch WCHARs.
-------------------------------------------------------------------------------
*/
#pragma once
#ifndef __specstrings
#define __specstrings
#ifdef __cplusplus
#ifndef __nothrow
# define __nothrow __declspec(nothrow)
#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.
*/
#if !defined(__midl) && defined(_PREFAST_)
/*
In the primitive __declspec("SAL_*") annotations "SAL" stands for Standard
Annotation Language. These __declspec("SAL_*") annotations are the
primitives the compiler understands and all high-level SpecString MACROs
will decompose into these primivates.
*/
#define SPECSTRINGIZE( x ) #x
/*
__null p
__notnull p
__maybenull p
Annotates a pointer p. States that pointer p is null. Commonly used
in the negated form __notnull or the possibly null form __maybenull.
*/
// #define __null __declspec("SAL_null")
#define __notnull __declspec("SAL_notnull")
#define __maybenull __declspec("SAL_maybenull")
/*
__readonly l
__notreadonly l
__mabyereadonly l
Annotates a location l. States that location l is not modified after
this point. If the annotation is placed on the precondition state of
a function, the restriction only applies until the postcondition state
of the function. __maybereadonly states that the annotated location
may be modified, whereas __notreadonly states that a location must be
modified.
*/
#define __readonly __declspec("SAL_readonly")
#define __notreadonly __declspec("SAL_notreadonly")
#define __maybereadonly __declspec("SAL_maybereadonly")
/*
__valid v
__notvalid v
__maybevalid v
Annotates any value v. States that the value satisfies all properties of
valid values of its type. For example, for a string buffer, valid means
that the buffer pointer is either NULL or points to a NULL-terminated string.
*/
#define __valid __declspec("SAL_valid")
#define __notvalid __declspec("SAL_notvalid")
#define __maybevalid __declspec("SAL_maybevalid")
/*
__readableTo(extent) p
Annotates a buffer pointer p. If the buffer can be read, extent describes
how much of the buffer is readable. For a reader of the buffer, this is
an explicit permission to read up to that amount, rather than a restriction to
read only up to it.
*/
#define __readableTo(extent) __declspec("SAL_readableTo("SPECSTRINGIZE(extent)")")
/*
__elem_readableTo(size)
Annotates a buffer pointer p as being readable to size elements.
*/
#define __elem_readableTo(size) __declspec("SAL_readableTo(elementCount("SPECSTRINGIZE(size)"))")
/*
__byte_readableTo(size)
Annotates a buffer pointer p as being readable to size bytes.
*/
#define __byte_readableTo(size) __declspec("SAL_readableTo(byteCount("SPECSTRINGIZE(size)"))")
/*
__writableTo(extent) p
Annotates a buffer pointer p. If the buffer can be modified, extent
describes how much of the buffer is writable (usually the allocation
size). For a writer of the buffer, this is an explicit permission to
write up to that amount, rather than a restriction to write only up to it.
*/
#define __writableTo(size) __declspec("SAL_writableTo("SPECSTRINGIZE(size)")")
/*
__elem_writableTo(size)
Annotates a buffer pointer p as being writable to size elements.
*/
#define __elem_writableTo(size) __declspec("SAL_writableTo(elementCount("SPECSTRINGIZE(size)"))")
/*
__byte_writableTo(size)
Annotates a buffer pointer p as being writable to size bytes.
*/
#define __byte_writableTo(size) __declspec("SAL_writableTo(byteCount("SPECSTRINGIZE(size)"))")
/*
__deref p
Annotates a pointer p. The next annotation applies one dereference down
in the type. If readableTo(p, size) then the next annotation applies to
all elements *(p+i) for which i satisfies the size. If p is a pointer
to a struct, the next annotation applies to all fields of the struct.
*/
#define __deref __declspec("SAL_deref")
/*
__pre __next_annotation
The next annotation applies in the precondition state
*/
#define __pre __declspec("SAL_pre")
/*
__post __next_annotation
The next annotation applies in the postcondition state
*/
#define __post __declspec("SAL_post")
/*
__precond(<expr>)
When <expr> is true, the next annotation applies in the precondition state
(currently not enabled)
*/
#define __precond(expr) __pre
/*
__postcond(<expr>)
When <expr> is true, the next annotation applies in the postcondition state
(currently not enabled)
*/
#define __postcond(expr) __post
/*
__exceptthat
Given a set of annotations Q containing __exceptthat maybeP, the effect of
the except clause is to erase any P or notP annotations (explicit or
implied) within Q at the same level of dereferencing that the except
clause appears, and to replace it with maybeP.
Example 1: __valid __exceptthat __maybenull on a pointer p means that the
pointer may be null, and is otherwise valid, thus overriding
the implicit notnull annotation implied by __valid on
pointers.
Example 2: __valid __deref __exceptthat __maybenull on an int **p means
that p is not null (implied by valid), but the elements
pointed to by p could be null, and are otherwise valid.
*/
#define __exceptthat __declspec("SAL_except")
#define __execeptthat __exceptthat
/*
_refparam
Added to all out parameter macros to indicate that they are all reference
parameters.
*/
#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)")")
#define __inner_success(expr) __declspec("SAL_success("SPECSTRINGIZE(expr)")")
#define __inner_checkReturn __declspec("SAL_checkReturn")
#define __inner_typefix(ctype) __declspec("SAL_typefix("SPECSTRINGIZE(ctype)")")
#define __inner_override __declspec("__override")
#define __inner_callback __declspec("__callback")
#define __inner_blocksOn(resource) __declspec("SAL_blocksOn("SPECSTRINGIZE(resource)")")
#define __inner_fallthrough_dec __inline __nothrow void __FallThrough() {}
#define __inner_fallthrough __FallThrough();
#else
// This conflicts with gcc definition of __null.
// #define __null
#define __notnull
#define __maybenull
#define __readonly
#define __notreadonly
#define __maybereadonly
#define __valid
#define __notvalid
#define __maybevalid
#define __readableTo(extent)
#define __elem_readableTo(size)
#define __byte_readableTo(size)
#define __writableTo(size)
#define __elem_writableTo(size)
#define __byte_writableTo(size)
#define __deref
#define __pre
#define __post
#define __precond(expr)
#define __postcond(expr)
#define __exceptthat
#define __execeptthat
#define __inner_success(expr)
#define __inner_checkReturn
#define __inner_typefix(ctype)
#define __inner_override
#define __inner_callback
#define __inner_blocksOn(resource)
#define __inner_fallthrough_dec
#define __inner_fallthrough
#define __refparam
#define __inner_control_entrypoint(category)
#define __inner_data_entrypoint(category)
#endif /* #if !defined(__midl) && defined(_PREFAST_) */
/*
-------------------------------------------------------------------------------
Buffer Annotation Definitions
Any of these may be used to directly annotate functions, but only one should
be used for each parameter. To determine which annotation to use for a given
buffer, use the table in the buffer annotations section.
-------------------------------------------------------------------------------
*/
#define __ecount(size) __notnull __elem_writableTo(size)
#define __bcount(size) __notnull __byte_writableTo(size)
//#define __in __pre __valid __pre __deref __readonly
#define __in_win __pre __valid __pre __deref __readonly
#define __in_ecount(size) __in_win __pre __elem_readableTo(size)
#define __in_bcount(size) __in_win __pre __byte_readableTo(size)
#define __in_z __in_win __pre __nullterminated
#define __in_ecount_z(size) __in_ecount(size) __pre __nullterminated
#define __in_bcount_z(size) __in_bcount(size) __pre __nullterminated
#define __in_nz __in_win
#define __in_ecount_nz(size) __in_ecount(size)
#define __in_bcount_nz(size) __in_bcount(size)
//#define __out __ecount(1) __post __valid __refparam
#define __out_win __ecount(1) __post __valid __refparam
#define __out_ecount(size) __ecount(size) __post __valid __refparam
#define __out_bcount(size) __bcount(size) __post __valid __refparam
#define __out_ecount_part(size,length) __out_ecount(size) __post __elem_readableTo(length)
#define __out_bcount_part(size,length) __out_bcount(size) __post __byte_readableTo(length)
#define __out_ecount_full(size) __out_ecount_part(size,size)
#define __out_bcount_full(size) __out_bcount_part(size,size)
#define __out_z __post __valid __refparam __post __nullterminated
#define __out_z_opt __post __valid __refparam __post __nullterminated __exceptthat __maybenull
#define __out_ecount_z(size) __ecount(size) __post __valid __refparam __post __nullterminated
#define __out_bcount_z(size) __bcount(size) __post __valid __refparam __post __nullterminated
#define __out_ecount_part_z(size,length) __out_ecount_part(size,length) __post __nullterminated
#define __out_bcount_part_z(size,length) __out_bcount_part(size,length) __post __nullterminated
#define __out_ecount_full_z(size) __out_ecount_full(size) __post __nullterminated
#define __out_bcount_full_z(size) __out_bcount_full(size) __post __nullterminated
#define __out_nz __post __valid __refparam __post
#define __out_nz_opt __post __valid __refparam __post __exceptthat __maybenull
#define __out_ecount_nz(size) __ecount(size) __post __valid __refparam
#define __out_bcount_nz(size) __bcount(size) __post __valid __refparam
#define __inout __pre __valid __post __valid __refparam
#define __inout_ecount(size) __out_ecount(size) __pre __valid
#define __inout_bcount(size) __out_bcount(size) __pre __valid
#define __inout_ecount_part(size,length) __out_ecount_part(size,length) __pre __valid __pre __elem_readableTo(length)
#define __inout_bcount_part(size,length) __out_bcount_part(size,length) __pre __valid __pre __byte_readableTo(length)
#define __inout_ecount_full(size) __inout_ecount_part(size,size)
#define __inout_bcount_full(size) __inout_bcount_part(size,size)
#define __inout_z __inout __pre __nullterminated __post __nullterminated
#define __inout_ecount_z(size) __inout_ecount(size) __pre __nullterminated __post __nullterminated
#define __inout_bcount_z(size) __inout_bcount(size) __pre __nullterminated __post __nullterminated
#define __inout_nz __inout
#define __inout_ecount_nz(size) __inout_ecount(size)
#define __inout_bcount_nz(size) __inout_bcount(size)
#define __ecount_opt(size) __ecount(size) __exceptthat __maybenull
#define __bcount_opt(size) __bcount(size) __exceptthat __maybenull
#define __in_opt __in_win __exceptthat __maybenull
#define __in_ecount_opt(size) __in_ecount(size) __exceptthat __maybenull
#define __in_bcount_opt(size) __in_bcount(size) __exceptthat __maybenull
#define __in_z_opt __in_opt __pre __nullterminated
#define __in_ecount_z_opt(size) __in_ecount_opt(size) __pre __nullterminated
#define __in_bcount_z_opt(size) __in_bcount_opt(size) __pre __nullterminated
#define __in_nz_opt __in_opt
#define __in_ecount_nz_opt(size) __in_ecount_opt(size)
#define __in_bcount_nz_opt(size) __in_bcount_opt(size)
#define __out_opt __out_win __exceptthat __maybenull
#define __out_ecount_opt(size) __out_ecount(size) __exceptthat __maybenull
#define __out_bcount_opt(size) __out_bcount(size) __exceptthat __maybenull
#define __out_ecount_part_opt(size,length) __out_ecount_part(size,length) __exceptthat __maybenull
#define __out_bcount_part_opt(size,length) __out_bcount_part(size,length) __exceptthat __maybenull
#define __out_ecount_full_opt(size) __out_ecount_full(size) __exceptthat __maybenull
#define __out_bcount_full_opt(size) __out_bcount_full(size) __exceptthat __maybenull
#define __out_ecount_z_opt(size) __out_ecount_opt(size) __post __nullterminated
#define __out_bcount_z_opt(size) __out_bcount_opt(size) __post __nullterminated
#define __out_ecount_part_z_opt(size,length) __out_ecount_part_opt(size,length) __post __nullterminated
#define __out_bcount_part_z_opt(size,length) __out_bcount_part_opt(size,length) __post __nullterminated
#define __out_ecount_full_z_opt(size) __out_ecount_full_opt(size) __post __nullterminated
#define __out_bcount_full_z_opt(size) __out_bcount_full_opt(size) __post __nullterminated
#define __out_ecount_nz_opt(size) __out_ecount_opt(size) __post __nullterminated
#define __out_bcount_nz_opt(size) __out_bcount_opt(size) __post __nullterminated
#define __inout_opt __inout __exceptthat __maybenull
#define __inout_ecount_opt(size) __inout_ecount(size) __exceptthat __maybenull
#define __inout_bcount_opt(size) __inout_bcount(size) __exceptthat __maybenull
#define __inout_ecount_part_opt(size,length) __inout_ecount_part(size,length) __exceptthat __maybenull
#define __inout_bcount_part_opt(size,length) __inout_bcount_part(size,length) __exceptthat __maybenull
#define __inout_ecount_full_opt(size) __inout_ecount_full(size) __exceptthat __maybenull
#define __inout_bcount_full_opt(size) __inout_bcount_full(size) __exceptthat __maybenull
#define __inout_z_opt __inout_opt __pre __nullterminated __post __nullterminated
#define __inout_ecount_z_opt(size) __inout_ecount_opt(size) __pre __nullterminated __post __nullterminated
#define __inout_ecount_z_opt(size) __inout_ecount_opt(size) __pre __nullterminated __post __nullterminated
#define __inout_bcount_z_opt(size) __inout_bcount_opt(size)
#define __inout_nz_opt __inout_opt
#define __inout_ecount_nz_opt(size) __inout_ecount_opt(size)
#define __inout_bcount_nz_opt(size) __inout_bcount_opt(size)
#define __deref_ecount(size) __ecount(1) __post __elem_readableTo(1) __post __deref __notnull __post __deref __elem_writableTo(size)
#define __deref_bcount(size) __ecount(1) __post __elem_readableTo(1) __post __deref __notnull __post __deref __byte_writableTo(size)
#define __deref_out __deref_ecount(1) __post __deref __valid __refparam
#define __deref_out_ecount(size) __deref_ecount(size) __post __deref __valid __refparam
#define __deref_out_bcount(size) __deref_bcount(size) __post __deref __valid __refparam
#define __deref_out_ecount_part(size,length) __deref_out_ecount(size) __post __deref __elem_readableTo(length)
#define __deref_out_bcount_part(size,length) __deref_out_bcount(size) __post __deref __byte_readableTo(length)
#define __deref_out_ecount_full(size) __deref_out_ecount_part(size,size)
#define __deref_out_bcount_full(size) __deref_out_bcount_part(size,size)
#define __deref_out_z __post __deref __valid __refparam __post __deref __nullterminated
#define __deref_out_ecount_z(size) __deref_out_ecount(size) __post __deref __nullterminated
#define __deref_out_bcount_z(size) __deref_out_ecount(size) __post __deref __nullterminated
#define __deref_out_nz __deref_out
#define __deref_out_ecount_nz(size) __deref_out_ecount(size)
#define __deref_out_bcount_nz(size) __deref_out_ecount(size)
#define __deref_inout __notnull __elem_readableTo(1) __pre __deref __valid __post __deref __valid __refparam
#define __deref_inout_z __deref_inout __pre __deref __nullterminated __post __deref __nullterminated
#define __deref_inout_ecount(size) __deref_inout __pre __deref __elem_writableTo(size) __post __deref __elem_writableTo(size)
#define __deref_inout_bcount(size) __deref_inout __pre __deref __byte_writableTo(size) __post __deref __byte_writableTo(size)
#define __deref_inout_ecount_part(size,length) __deref_inout_ecount(size) __pre __deref __elem_readableTo(length) __post __deref __elem_readableTo(length)
#define __deref_inout_bcount_part(size,length) __deref_inout_bcount(size) __pre __deref __byte_readableTo(length) __post __deref __byte_readableTo(length)
#define __deref_inout_ecount_full(size) __deref_inout_ecount_part(size,size)
#define __deref_inout_bcount_full(size) __deref_inout_bcount_part(size,size)
#define __deref_inout_z __deref_inout __pre __deref __nullterminated __post __deref __nullterminated
#define __deref_inout_ecount_z(size) __deref_inout_ecount(size) __pre __deref __nullterminated __post __deref __nullterminated
#define __deref_inout_bcount_z(size) __deref_inout_ecount(size) __pre __deref __nullterminated __post __deref __nullterminated
#define __deref_inout_nz __deref_inout
#define __deref_inout_ecount_nz(size) __deref_inout_ecount(size)
#define __deref_inout_bcount_nz(size) __deref_inout_ecount(size)
#define __deref_ecount_opt(size) __deref_ecount(size) __post __deref __exceptthat __maybenull
#define __deref_bcount_opt(size) __deref_bcount(size) __post __deref __exceptthat __maybenull
#define __deref_out_opt __deref_out __post __deref __exceptthat __maybenull
#define __deref_out_ecount_opt(size) __deref_out_ecount(size) __post __deref __exceptthat __maybenull
#define __deref_out_bcount_opt(size) __deref_out_bcount(size) __post __deref __exceptthat __maybenull
#define __deref_out_ecount_part_opt(size,length) __deref_out_ecount_part(size,length) __post __deref __exceptthat __maybenull
#define __deref_out_bcount_part_opt(size,length) __deref_out_bcount_part(size,length) __post __deref __exceptthat __maybenull
#define __deref_out_ecount_full_opt(size) __deref_out_ecount_full(size) __post __deref __exceptthat __maybenull
#define __deref_out_bcount_full_opt(size) __deref_out_bcount_full(size) __post __deref __exceptthat __maybenull
#define __deref_out_z_opt __post __deref __valid __refparam __execeptthat __maybenull __post __deref __nullterminated
#define __deref_out_ecount_z_opt(size) __deref_out_ecount_opt(size) __post __deref __nullterminated
#define __deref_out_bcount_z_opt(size) __deref_out_bcount_opt(size) __post __deref __nullterminated
#define __deref_out_nz_opt __deref_out_opt
#define __deref_out_ecount_nz_opt(size) __deref_out_ecount_opt(size)
#define __deref_out_bcount_nz_opt(size) __deref_out_bcount_opt(size)
#define __deref_inout_opt __deref_inout __pre __deref __exceptthat __maybenull __post __deref __exceptthat __maybenull
#define __deref_inout_ecount_opt(size) __deref_inout_ecount(size) __pre __deref __exceptthat __maybenull __post __deref __exceptthat __maybenull
#define __deref_inout_bcount_opt(size) __deref_inout_bcount(size) __pre __deref __exceptthat __maybenull __post __deref __exceptthat __maybenull
#define __deref_inout_ecount_part_opt(size,length) __deref_inout_ecount_part(size,length) __pre __deref __exceptthat __maybenull __post __deref __exceptthat __maybenull
#define __deref_inout_bcount_part_opt(size,length) __deref_inout_bcount_part(size,length) __pre __deref __exceptthat __maybenull __post __deref __exceptthat __maybenull
#define __deref_inout_ecount_full_opt(size) __deref_inout_ecount_full(size) __pre __deref __exceptthat __maybenull __post __deref __exceptthat __maybenull
#define __deref_inout_bcount_full_opt(size) __deref_inout_bcount_full(size) __pre __deref __exceptthat __maybenull __post __deref __exceptthat __maybenull
#define __deref_inout_z_opt __deref_inout_opt __pre __deref __nullterminated __post __deref __nullterminated
#define __deref_inout_ecount_z_opt(size) __deref_inout_ecount_opt(size) __pre __deref __nullterminated __post __deref __nullterminated
#define __deref_inout_bcount_z_opt(size) __deref_inout_bcount_opt(size) __pre __deref __nullterminated __post __deref __nullterminated
#define __deref_inout_nz_opt __deref_inout_opt
#define __deref_inout_ecount_nz_opt(size) __deref_inout_ecount_opt(size)
#define __deref_inout_bcount_nz_opt(size) __deref_inout_bcount_opt(size)
#define __deref_opt_ecount(size) __deref_ecount(size) __exceptthat __maybenull
#define __deref_opt_bcount(size) __deref_bcount(size) __exceptthat __maybenull
#define __deref_opt_out __deref_out __exceptthat __maybenull
#define __deref_opt_out_z __deref_opt_out __post __deref __nullterminated
#define __deref_opt_out_ecount(size) __deref_out_ecount(size) __exceptthat __maybenull
#define __deref_opt_out_bcount(size) __deref_out_bcount(size) __exceptthat __maybenull
#define __deref_opt_out_ecount_part(size,length) __deref_out_ecount_part(size,length) __exceptthat __maybenull
#define __deref_opt_out_bcount_part(size,length) __deref_out_bcount_part(size,length) __exceptthat __maybenull
#define __deref_opt_out_ecount_full(size) __deref_out_ecount_full(size) __exceptthat __maybenull
#define __deref_opt_out_bcount_full(size) __deref_out_bcount_full(size) __exceptthat __maybenull
#define __deref_opt_inout __deref_inout __exceptthat __maybenull
#define __deref_opt_inout_ecount(size) __deref_inout_ecount(size) __exceptthat __maybenull
#define __deref_opt_inout_bcount(size) __deref_inout_bcount(size) __exceptthat __maybenull
#define __deref_opt_inout_ecount_part(size,length) __deref_inout_ecount_part(size,length) __exceptthat __maybenull
#define __deref_opt_inout_bcount_part(size,length) __deref_inout_bcount_part(size,length) __exceptthat __maybenull
#define __deref_opt_inout_ecount_full(size) __deref_inout_ecount_full(size) __exceptthat __maybenull
#define __deref_opt_inout_bcount_full(size) __deref_inout_bcount_full(size) __exceptthat __maybenull
#define __deref_opt_inout_z __deref_opt_inout __pre __deref __nullterminated __post __deref __nullterminated
#define __deref_opt_inout_ecount_z(size) __deref_opt_inout_ecount(size) __pre __deref __nullterminated __post __deref __nullterminated
#define __deref_opt_inout_bcount_z(size) __deref_opt_inout_bcount(size) __pre __deref __nullterminated __post __deref __nullterminated
#define __deref_opt_inout_nz __deref_opt_inout
#define __deref_opt_inout_ecount_nz(size) __deref_opt_inout_ecount(size)
#define __deref_opt_inout_bcount_nz(size) __deref_opt_inout_bcount(size)
#define __deref_opt_ecount_opt(size) __deref_ecount_opt(size) __exceptthat __maybenull
#define __deref_opt_bcount_opt(size) __deref_bcount_opt(size) __exceptthat __maybenull
#define __deref_opt_out_opt __deref_out_opt __exceptthat __maybenull
#define __deref_opt_out_ecount_opt(size) __deref_out_ecount_opt(size) __exceptthat __maybenull
#define __deref_opt_out_bcount_opt(size) __deref_out_bcount_opt(size) __exceptthat __maybenull
#define __deref_opt_out_ecount_part_opt(size,length) __deref_out_ecount_part_opt(size,length) __exceptthat __maybenull
#define __deref_opt_out_bcount_part_opt(size,length) __deref_out_bcount_part_opt(size,length) __exceptthat __maybenull
#define __deref_opt_out_ecount_full_opt(size) __deref_out_ecount_full_opt(size) __exceptthat __maybenull
#define __deref_opt_out_bcount_full_opt(size) __deref_out_bcount_full_opt(size) __exceptthat __maybenull
#define __deref_opt_out_z_opt __post __deref __valid __refparam __exceptthat __maybenull __pre __deref __exceptthat __maybenull __post __deref __exceptthat __maybenull __post __deref __nullterminated
#define __deref_opt_out_ecount_z_opt(size) __deref_opt_out_ecount_opt(size) __post __deref __nullterminated
#define __deref_opt_out_bcount_z_opt(size) __deref_opt_out_bcount_opt(size) __post __deref __nullterminated
#define __deref_opt_out_nz_opt __deref_opt_out_opt
#define __deref_opt_out_ecount_nz_opt(size) __deref_opt_out_ecount_opt(size)
#define __deref_opt_out_bcount_nz_opt(size) __deref_opt_out_bcount_opt(size)
#define __deref_opt_inout_opt __deref_inout_opt __exceptthat __maybenull
#define __deref_opt_inout_ecount_opt(size) __deref_inout_ecount_opt(size) __exceptthat __maybenull
#define __deref_opt_inout_bcount_opt(size) __deref_inout_bcount_opt(size) __exceptthat __maybenull
#define __deref_opt_inout_ecount_part_opt(size,length) __deref_inout_ecount_part_opt(size,length) __exceptthat __maybenull
#define __deref_opt_inout_bcount_part_opt(size,length) __deref_inout_bcount_part_opt(size,length) __exceptthat __maybenull
#define __deref_opt_inout_ecount_full_opt(size) __deref_inout_ecount_full_opt(size) __exceptthat __maybenull
#define __deref_opt_inout_bcount_full_opt(size) __deref_inout_bcount_full_opt(size) __exceptthat __maybenull
#define __deref_opt_inout_z_opt __deref_opt_inout_opt __pre __deref __nullterminated __post __deref __nullterminated
#define __deref_opt_inout_ecount_z_opt(size) __deref_opt_inout_ecount_opt(size) __pre __deref __nullterminated __post __deref __nullterminated
#define __deref_opt_inout_bcount_z_opt(size) __deref_opt_inout_bcount_opt(size) __pre __deref __nullterminated __post __deref __nullterminated
#define __deref_opt_inout_nz_opt __deref_opt_inout_opt
#define __deref_opt_inout_ecount_nz_opt(size) __deref_opt_inout_ecount_opt(size)
#define __deref_opt_inout_bcount_nz_opt(size) __deref_opt_inout_bcount_opt(size)
/*
-------------------------------------------------------------------------------
Advanced Annotation Definitions
Any of these may be used to directly annotate functions, and may be used in
combination with each other or with regular buffer macros. For an explanation
of each annotation, see the advanced annotations section.
-------------------------------------------------------------------------------
*/
#define __success(expr) __inner_success(expr)
#define __nullterminated __readableTo(sentinel(0))
#define __nullnullterminated
#define __reserved __pre __null
#define __checkReturn __inner_checkReturn
#define __typefix(ctype) __inner_typefix(ctype)
#define __override __inner_override
#define __callback __inner_callback
#define __format_string
#define __blocksOn(resource) __inner_blocksOn(resource)
#define __control_entrypoint(category) __inner_control_entrypoint(category)
#define __data_entrypoint(category) __inner_data_entrypoint(category)
#ifndef __fallthrough
__inner_fallthrough_dec
#define __fallthrough __inner_fallthrough
#endif
#ifndef __analysis_assume
#ifdef _PREFAST_
#define __analysis_assume(expr) __assume(expr)
#else
#define __analysis_assume(expr)
#endif
#endif
#ifdef __cplusplus
}
#endif
#endif //__specstrings

342
jxrlib/common/include/wmspecstring.h
View file

@ -1,342 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#ifndef _WMSPECSTRING_H_
#define _WMSPECSTRING_H_
#if (!defined UNDER_CE && !defined NO_WINDOWS && !defined SPECSTRINGS_H)
#define SPECSTRINGS_H
/*************************************************************************
* See specstrings_strict.h for documentation of all user visible macros.
*************************************************************************/
#if _MSC_VER
#pragma once
#endif
#include <wmsal.h>
#ifndef __SAL_H_FULL_VER
#define __SAL_H_FULL_VER 140050727
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* version specific fixes to bring sal.h upto date */
#if __SAL_H_FULL_VER <= 140050727
/* Missing from RTM sal.h */
#if !defined(__midl) && defined(_PREFAST_) && _MSC_VER >= 1000
#define __inexpressible_readableTo(size) __declspec("SAL_readableTo(inexpressibleCount('" SPECSTRINGIZE(size) "'))")
#define __inexpressible_writableTo(size) __declspec("SAL_writableTo(inexpressibleCount('" SPECSTRINGIZE(size) "'))")
#define __inner_bound __declspec("SAL_bound")
#define __inner_range(lb,ub) __declspec("SAL_range(" SPECSTRINGIZE(lb) "," SPECSTRINGIZE(ub) ")")
#define __inner_assume_bound_dec __inline __nothrow void __AssumeBoundInt(__post __inner_bound int i) {i;}
#define __inner_assume_bound(i) __AssumeBoundInt(i);
#define __inner_allocator __declspec("SAL_allocator")
#else
#define __inexpressible_readableTo(size)
#define __inexpressible_writableTo(size)
#define __inner_bound
#define __inner_range(lb,ub)
#define __inner_assume_bound_dec
#define __inner_assume_bound(i)
#define __inner_allocator
#endif
#define __xcount(size) __notnull __inexpressible_writableTo(size)
#define __in_xcount(size) __in __pre __inexpressible_readableTo(size)
#define __out_xcount(size) __xcount(size) __post __valid __refparam
#define __out_xcount_part(size,length) __out_xcount(size) __post __inexpressible_readableTo(length)
#define __out_xcount_full(size) __out_xcount_part(size,size)
#define __inout_xcount(size) __out_xcount(size) __pre __valid
#define __inout_xcount_part(size,length) __out_xcount_part(size,length) __pre __valid __pre __inexpressible_readableTo(length)
#define __inout_xcount_full(size) __inout_xcount_part(size,size)
#define __xcount_opt(size) __xcount(size) __exceptthat __maybenull
#define __in_xcount_opt(size) __in_xcount(size) __exceptthat __maybenull
#define __out_xcount_opt(size) __out_xcount(size) __exceptthat __maybenull
#define __out_xcount_part_opt(size,length) __out_xcount_part(size,length) __exceptthat __maybenull
#define __out_xcount_full_opt(size) __out_xcount_full(size) __exceptthat __maybenull
#define __inout_xcount_opt(size) __inout_xcount(size) __exceptthat __maybenull
#define __inout_xcount_part_opt(size,length) __inout_xcount_part(size,length) __exceptthat __maybenull
#define __inout_xcount_full_opt(size) __inout_xcount_full(size) __exceptthat __maybenull
#define __deref_xcount(size) __ecount(1) __post __elem_readableTo(1) __post __deref __notnull __post __deref __inexpressible_writableTo(size)
#define __deref_in __in __pre __deref __deref __readonly
#define __deref_in_ecount(size) __deref_in __pre __deref __elem_readableTo(size)
#define __deref_in_bcount(size) __deref_in __pre __deref __byte_readableTo(size)
#define __deref_in_xcount(size) __deref_in __pre __deref __inexpressible_readableTo(size)
#define __deref_out_xcount(size) __deref_xcount(size) __post __deref __valid __refparam
#define __deref_out_xcount_part(size,length) __deref_out_xcount(size) __post __deref __inexpressible_readableTo(length)
#define __deref_out_xcount_full(size) __deref_out_xcount_part(size,size)
#define __deref_out_xcount(size) __deref_xcount(size) __post __deref __valid __refparam
#define __inout_xcount_opt(size) __inout_xcount(size) __exceptthat __maybenull
#define __inout_xcount_part_opt(size,length) __inout_xcount_part(size,length) __exceptthat __maybenull
#define __inout_xcount_full_opt(size) __inout_xcount_full(size) __exceptthat __maybenull
#define __deref_xcount(size) __ecount(1) __post __elem_readableTo(1) __post __deref __notnull __post __deref __inexpressible_writableTo(size)
#define __deref_in __in __pre __deref __deref __readonly
#define __deref_in_ecount(size) __deref_in __pre __deref __elem_readableTo(size)
#define __deref_in_bcount(size) __deref_in __pre __deref __byte_readableTo(size)
#define __deref_in_xcount(size) __deref_in __pre __deref __inexpressible_readableTo(size)
#define __deref_out_xcount(size) __deref_xcount(size) __post __deref __valid __refparam
#define __deref_out_xcount_part(size,length) __deref_out_xcount(size) __post __deref __inexpressible_readableTo(length)
#define __deref_out_xcount_full(size) __deref_out_xcount_part(size,size)
#define __deref_out_xcount(size) __deref_xcount(size) __post __deref __valid __refparam
#define __deref_inout_xcount(size) __deref_inout __pre __deref __inexpressible_writableTo(size) __post __deref __inexpressible_writableTo(size)
#define __deref_inout_xcount_part(size,length) __deref_inout_xcount(size) __pre __deref __inexpressible_readableTo(length) __post __deref __inexpressible_readableTo(length)
#define __deref_inout_xcount_full(size) __deref_inout_xcount_part(size,size)
#define __deref_xcount_opt(size) __deref_xcount(size) __post __deref __exceptthat __maybenull
#define __deref_in_opt __deref_in __pre __deref __exceptthat __maybenull
#define __deref_in_ecount_opt(size) __deref_in_ecount(size) __pre __deref __exceptthat __maybenull
#define __deref_in_bcount_opt(size) __deref_in_bcount(size) __pre __deref __exceptthat __maybenull
#define __deref_in_xcount_opt(size) __deref_in_xcount(size) __pre __deref __exceptthat __maybenull
#define __deref_out_xcount_opt(size) __deref_out_xcount(size) __post __deref __exceptthat __maybenull
#define __deref_out_xcount_part_opt(size,length) __deref_out_xcount_part(size,length) __post __deref __exceptthat __maybenull
#define __deref_out_xcount_full_opt(size) __deref_out_xcount_full(size) __post __deref __exceptthat __maybenull
#define __deref_inout_xcount_opt(size) __deref_inout_xcount(size) __pre __deref __exceptthat __maybenull __post __deref __exceptthat __maybenull
#define __deref_inout_xcount_part_opt(size,length) __deref_inout_xcount_part(size,length) __pre __deref __exceptthat __maybenull __post __deref __exceptthat __maybenull
#define __deref_inout_xcount_full_opt(size) __deref_inout_xcount_full(size) __pre __deref __exceptthat __maybenull __post __deref __exceptthat __maybenull
#define __deref_opt_xcount(size) __deref_xcount(size) __exceptthat __maybenull
#define __deref_opt_in __deref_in __exceptthat __maybenull
#define __deref_opt_in_ecount(size) __deref_in_ecount(size) __exceptthat __maybenull
#define __deref_opt_in_bcount(size) __deref_in_bcount(size) __exceptthat __maybenull
#define __deref_opt_in_xcount(size) __deref_in_xcount(size) __exceptthat __maybenull
#define __deref_opt_out_xcount(size) __deref_out_xcount(size) __exceptthat __maybenull
#define __deref_opt_out_xcount_part(size,length) __deref_out_xcount_part(size,length) __exceptthat __maybenull
#define __deref_opt_out_xcount_full(size) __deref_out_xcount_full(size) __exceptthat __maybenull
#define __deref_opt_inout_xcount(size) __deref_inout_xcount(size) __exceptthat __maybenull
#define __deref_opt_inout_xcount_part(size,length) __deref_inout_xcount_part(size,length) __exceptthat __maybenull
#define __deref_opt_inout_xcount_full(size) __deref_inout_xcount_full(size) __exceptthat __maybenull
#define __deref_opt_xcount_opt(size) __deref_xcount_opt(size) __exceptthat __maybenull
#define __deref_opt_in_opt __deref_in_opt __exceptthat __maybenull
#define __deref_opt_in_ecount_opt(size) __deref_in_ecount_opt(size) __exceptthat __maybenull
#define __deref_opt_in_bcount_opt(size) __deref_in_bcount_opt(size) __exceptthat __maybenull
#define __deref_opt_in_xcount_opt(size) __deref_in_xcount_opt(size) __exceptthat __maybenull
#define __deref_opt_out_xcount_opt(size) __deref_out_xcount_opt(size) __exceptthat __maybenull
#define __deref_opt_out_xcount_part_opt(size,length) __deref_out_xcount_part_opt(size,length) __exceptthat __maybenull
#define __deref_opt_out_xcount_full_opt(size) __deref_out_xcount_full_opt(size) __exceptthat __maybenull
#define __deref_opt_inout_xcount_opt(size) __deref_inout_xcount_opt(size) __exceptthat __maybenull
#define __deref_opt_inout_xcount_part_opt(size,length) __deref_inout_xcount_part_opt(size,length) __exceptthat __maybenull
#define __deref_opt_inout_xcount_full_opt(size) __deref_inout_xcount_full_opt(size) __exceptthat __maybenull
/* Must protect redfinitions of macros to workaround rc.exe issues. */
#ifndef RC_INVOKED
#undef __nullnullterminated
#define __nullnullterminated __xcount("string terminated by two nulls")
#undef __checkReturn
#define __checkReturn __post __inner_checkReturn
#endif
#endif //__SAL_H_FULL_VER <= 140050727
/************************************************************************
New extensions to sal.h follow here.
*************************************************************************/
#if (_MSC_VER >= 1000) && !defined(__midl) && defined(_PREFAST_)
#define __file_parser(typ) __declspec("SAL_file_parser(function, " #typ ")")
#define __file_parser_class(typ) __declspec("SAL_file_parser(class, " #typ ")")
#define __file_parser_library(typ) extern int __declspec("SAL_file_parser(library, " #typ ")") __iSALFileParserLibrary##typ;
#define __source_code_content(typ) extern int __declspec("SAL_source_code_content(" #typ ")") __iSAL_Source_Code_Content##typ;
#define __class_code_content(typ) __declspec("SAL_class_code_content(" #typ ")")
#define __analysis_assert(e) __assume(e)
#define __analysis_hint(hint) __declspec("SAL_analysisHint(" #hint ")")
/* Internal defintions */
#define __inner_data_source(src_raw) __declspec("SAL_untrusted_data_source(" src_raw ")")
#define __inner_this_data_source(src_raw) __declspec("SAL_untrusted_data_source_this(" src_raw ")")
#define __inner_out_validated(typ_raw) __declspec("SAL_post") __declspec("SAL_validated(" typ_raw ")")
#define __inner_this_out_validated(typ_raw) __declspec("SAL_validated_this(" typ_raw ")")
#define __inner_assume_validated_dec __inline __nothrow void __AssumeValidated(__inner_out_validated("BY_DESIGN") const void *p) {p;}
#define __inner_assume_validated(p) __AssumeValidated(p)
#define __inner_transfer(formal) __declspec("SAL_transfer_adt_property_from(" SPECSTRINGIZE(formal) ")")
#define __inner_encoded __declspec("SAL_encoded")
#define __$adt_prop(adt,prop) __declspec("SAL_adt("#adt","#prop")")
#define __$adt_add_prop(adt,prop) __declspec("SAL_add_adt_property("#adt","#prop")")
#define __$adt_remove_prop(adt,prop) __declspec("SAL_remove_adt_property("#adt","#prop")")
#define __$adt_transfer_prop(arg) __declspec("SAL_transfer_adt_property_from("#arg")")
#define __$adt_type_props(typ) __declspec("SAL_post_type("#typ")")
#define __$volatile __declspec("SAL_volatile")
#define __$nonvolatile __declspec("SAL_nonvolatile")
#define __$possibly_notnulltermiated __declspec("SAL_RequiresZeroTermination(sometimes)")
#else
#define __file_parser(typ)
#define __file_parser_class(typ)
#define __file_parser_library(typ)
#define __source_code_content(typ)
#define __class_code_content(typ)
#define __analysis_assert(e)
#define __analysis_hint(hint)
/* Internal defintions */
#define __inner_data_source(src_raw)
#define __inner_this_data_source(src_raw)
#define __inner_out_validated(typ_raw)
#define __inner_this_out_validated(typ_raw)
#define __inner_assume_validated_dec
#define __inner_assume_validated(p)
#define __inner_transfer(formal)
#define __inner_encoded
#define __$adt_prop(adt,prop)
#define __$adt_add_prop(adt,prop)
#define __$adt_remove_prop(adt,prop)
#define __$adt_transfer_prop(arg)
#define __$adt_type_props(typ)
#define __$volatile
#define __$nonvolatile
#define __$possibly_notnulltermiated
#endif // #if (_MSC_VER >= 1000) && !defined(__midl) && defined(_PREFAST_)
#define __field_ecount(size) __notnull __elem_writableTo(size)
#define __field_bcount(size) __notnull __byte_writableTo(size)
#define __field_xcount(size) __notnull __inexpressible_writableTo(size)
#define __field_ecount_opt(size) __maybenull __elem_writableTo(size)
#define __field_bcount_opt(size) __maybenull __byte_writableTo(size)
#define __field_xcount_opt(size) __maybenull __inexpressible_writableTo(size)
#define __field_ecount_part(size,init) __notnull __elem_writableTo(size) __elem_readableTo(init)
#define __field_bcount_part(size,init) __notnull __byte_writableTo(size) __byte_readableTo(init)
#define __field_xcount_part(size,init) __notnull __inexpressible_writableTo(size) __inexpressible_readableTo(init)
#define __field_ecount_part_opt(size,init) __maybenull __elem_writableTo(size) __elem_readableTo(init)
#define __field_bcount_part_opt(size,init) __maybenull __byte_writableTo(size) __byte_readableTo(init)
#define __field_xcount_part_opt(size,init) __maybenull __inexpressible_writableTo(size) __inexpressible_readableTo(init)
#define __field_ecount_full(size) __field_ecount_part(size,size)
#define __field_bcount_full(size) __field_bcount_part(size,size)
#define __field_xcount_full(size) __field_xcount_part(size,size)
#define __field_ecount_full_opt(size) __field_ecount_part_opt(size,size)
#define __field_bcount_full_opt(size) __field_bcount_part_opt(size,size)
#define __field_xcount_full_opt(size) __field_xcount_part_opt(size,size)
#define __struct_bcount(size) __field_bcount(size)
#define __struct_xcount(size) __field_xcount(size)
#if !defined(__out_awcount)
#define __out_awcount(expr,size) __pre __notnull \
__byte_writableTo((expr) ? (size) : (size) * 2) \
__post __valid __refparam
#endif
#if !defined(__in_awcount)
#define __in_awcount(expr,size) __pre __valid \
__pre __deref __readonly \
__byte_readableTo((expr) ? (size) : (size) * 2)
#endif
/* integer related macros */
#define __allocator __inner_allocator
#define __bound __inner_bound
#define __range(lb,ub) __inner_range(lb,ub)
#define __in_bound __pre __inner_bound
#define __out_bound __post __inner_bound
#define __deref_out_bound __post __deref __inner_bound
#define __in_range(lb,ub) __pre __inner_range(lb,ub)
#define __out_range(lb,ub) __post __inner_range(lb,ub)
#define __deref_in_range(lb,ub) __pre __deref __inner_range(lb,ub)
#define __deref_out_range(lb,ub) __post __deref __inner_range(lb,ub)
#define __field_range(lb,ub) __range(lb,ub)
#define __field_data_source(src_sym) __inner_data_source(#src_sym)
/* Pentraion review macros */
#define __in_data_source(src_sym) __pre __inner_data_source(#src_sym)
#define __out_data_source(src_sym) __post __inner_data_source(#src_sym)
#define __out_validated(typ_sym) __inner_out_validated(#typ_sym)
#define __this_out_data_source(src_sym) __inner_this_data_source(#src_sym)
#define __this_out_validated(typ_sym) __inner_this_out_validated(#typ_sym)
#define __transfer(formal) __post __inner_transfer(formal)
#define __rpc_entry __inner_control_entrypoint(RPC)
#define __kernel_entry __inner_control_entrypoint(UserToKernel)
#define __gdi_entry __inner_control_entrypoint(GDI)
#define __encoded_pointer __inner_encoded
#define __encoded_array __inner_encoded
#define __field_encoded_pointer __inner_encoded
#define __field_encoded_array __inner_encoded
#define __type_has_adt_prop(adt,prop) __$adt_prop(adt,prop)
#define __out_has_adt_prop(adt,prop) __post __$adt_add_prop(adt,prop)
#define __out_not_has_adt_prop(adt,prop) __post __$adt_remove_prop(adt,prop)
#define __out_transfer_adt_prop(arg) __post __$adt_transfer_prop(arg)
#define __out_has_type_adt_props(typ) __post __$adt_type_props(typ)
/* useful PFD related macros */
#define __possibly_notnulltermiated __post __$possibly_notnulltermiated
#if defined(_WINDOWS_)
/* Windows Internal */
#define __volatile __$volatile
#define __nonvolatile __$nonvolatile
#define __deref_volatile __deref __volatile
#define __deref_nonvolatile __deref __nonvolatile
#endif
/* declare stub functions for macros */
__inner_assume_validated_dec
__inner_assume_bound_dec
#define __assume_validated(p) __inner_assume_validated(p)
#define __assume_bound(i) __inner_assume_bound(i)
#ifdef __cplusplus
}
#endif
#include <wmspecstrings_adt.h>
#ifdef _PREFIX_
/**************************************************************************
* Defintion of __pfx_assume and __pfx_assert. Thse should be the only
* defintions of these functions.
***************************************************************************/
#if __cplusplus
extern "C" void __pfx_assert(bool, const char *);
extern "C" void __pfx_assume(bool, const char *);
#else
void __pfx_assert(int, const char *);
void __pfx_assume(int, const char *);
#endif
/**************************************************************************
* Redefintion of __analysis_assume and __analysis_assert for PREFIX build
**************************************************************************/
#undef __analysis_assume
#undef __analysis_assert
#define __analysis_assume(e) (__pfx_assume(e,"pfx_assume"),__assume(e));
#define __analysis_assert(e) (__pfx_assert(e,"pfx_assert"),__assume(e));
#endif /* ifdef _PREFIX_ */
/**************************************************************************
* This include should always be the last thing in this file.
* Must avoid redfinitions of macros to workaround rc.exe issues.
***************************************************************************/
#if !(defined(RC_INVOKED) || defined(SORTPP_PASS))
#include <wmspecstrings_strict.h>
#endif /* if !(defined(RC_INVOKED) || defined(SORTPP_PASS)) */
#endif /* #ifndef SPECSTRINGS_H */
// Some CE versions don't have specstrings.h, some have very old version without
// __specstrings defined. So we handle CE separately in wmasalce.h
#if defined(UNDER_CE) || defined(NO_WINDOWS)
#include "wmspecstringce.h"
#endif
#endif //_WMSPECSTRING_H_

71
jxrlib/common/include/wmspecstrings_adt.h
View file

@ -1,71 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#pragma once
/*************************************************************************
* DEFINITIONS OF NEW TYPES
*************************************************************************/
#if !defined(__midl)
#define __$compname_props \
__type_has_adt_prop(compname,nullterminated) \
__type_has_adt_prop(compname,valid_schars) \
__type_has_adt_prop(compname,correct_len) \
__nullterminated
#if defined(UNICODE) || defined(_UNICODE)
#define __$TCHAR unsigned short
#else
#define __$TCHAR char
#endif
typedef __$compname_props char* ValidCompNameA;
typedef __$compname_props unsigned short* ValidCompNameW;
typedef __$compname_props const unsigned short* ConstValidCompNameW;
typedef __$compname_props __$TCHAR* SAL_ValidCompNameT;
typedef __$compname_props const __$TCHAR* SAL_ConstValidCompNameT;
#undef __$compname_props
#undef __$TCHAR
#endif
/*************************************************************************
* DEFINITIONS OF INLINE FUNCTIONS FOR CASTING TO THE NEW TYPES : USER
*************************************************************************/
#if (_MSC_VER >= 1000) && !defined(__midl) && defined(_PREFAST_)
#ifdef __cplusplus
extern "C" {
#endif
void __inline __nothrow __SAL_ValidCompNameA(__out_has_type_adt_props(ValidCompNameA) const void *expr) { expr;}
void __inline __nothrow __SAL_ValidCompNameW(__out_has_type_adt_props(ValidCompNameW) const void *expr) { expr;}
#ifdef __cplusplus
}
#endif
#define __assume_ValidCompNameA(expr) __SAL_ValidCompNameA(expr)
#define __assume_ValidCompNameW(expr) __SAL_ValidCompNameW(expr)
#else
#define __assume_ValidCompNameA(expr)
#define __assume_ValidCompNameW(expr)
#endif

1096
jxrlib/common/include/wmspecstrings_strict.h
View file

File diff suppressed because it is too large Load diff

406
jxrlib/common/include/wmspecstrings_undef.h
View file

@ -1,406 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#undef __$adt_add_prop
#undef __$adt_prop
#undef __$adt_remove_prop
#undef __$adt_transfer_prop
#undef __$adt_type_props
#undef __$nonvolatile
#undef __$possibly_notnulltermiated
#undef __$volatile
#undef __allocator
#undef __analysis_assert
#undef __analysis_assume
#undef __analysis_hint
#undef __assume_ValidCompNameA
#undef __assume_ValidCompNameW
#undef __assume_bound
#undef __assume_validated
#undef __bcount
#undef __bcount_opt
#undef __blocksOn
#undef __bound
#undef __byte_readableTo
#undef __byte_writableTo
#undef __callback
#undef __checkReturn
#undef __class_code_content
#undef __control_entrypoint
#undef __data_entrypoint
#undef __deref
#undef __deref_bcount
#undef __deref_bcount_opt
#undef __deref_ecount
#undef __deref_ecount_opt
#undef __deref_in
#undef __deref_in_bcount
#undef __deref_in_bcount_opt
#undef __deref_in_ecount
#undef __deref_in_ecount_opt
#undef __deref_in_opt
#undef __deref_in_range
#undef __deref_in_xcount
#undef __deref_in_xcount_opt
#undef __deref_inout
#undef __deref_inout_bcount
#undef __deref_inout_bcount_full
#undef __deref_inout_bcount_full_opt
#undef __deref_inout_bcount_nz
#undef __deref_inout_bcount_nz_opt
#undef __deref_inout_bcount_opt
#undef __deref_inout_bcount_part
#undef __deref_inout_bcount_part_opt
#undef __deref_inout_bcount_z
#undef __deref_inout_bcount_z_opt
#undef __deref_inout_ecount
#undef __deref_inout_ecount_full
#undef __deref_inout_ecount_full_opt
#undef __deref_inout_ecount_nz
#undef __deref_inout_ecount_nz_opt
#undef __deref_inout_ecount_opt
#undef __deref_inout_ecount_part
#undef __deref_inout_ecount_part_opt
#undef __deref_inout_ecount_z
#undef __deref_inout_ecount_z_opt
#undef __deref_inout_nz
#undef __deref_inout_nz_opt
#undef __deref_inout_opt
#undef __deref_inout_xcount
#undef __deref_inout_xcount_full
#undef __deref_inout_xcount_full_opt
#undef __deref_inout_xcount_opt
#undef __deref_inout_xcount_part
#undef __deref_inout_xcount_part_opt
#undef __deref_inout_z
#undef __deref_inout_z_opt
#undef __deref_nonvolatile
#undef __deref_opt_bcount
#undef __deref_opt_bcount_opt
#undef __deref_opt_ecount
#undef __deref_opt_ecount_opt
#undef __deref_opt_in
#undef __deref_opt_in_bcount
#undef __deref_opt_in_bcount_opt
#undef __deref_opt_in_ecount
#undef __deref_opt_in_ecount_opt
#undef __deref_opt_in_opt
#undef __deref_opt_in_xcount
#undef __deref_opt_in_xcount_opt
#undef __deref_opt_inout
#undef __deref_opt_inout_bcount
#undef __deref_opt_inout_bcount_full
#undef __deref_opt_inout_bcount_full_opt
#undef __deref_opt_inout_bcount_nz
#undef __deref_opt_inout_bcount_nz_opt
#undef __deref_opt_inout_bcount_opt
#undef __deref_opt_inout_bcount_part
#undef __deref_opt_inout_bcount_part_opt
#undef __deref_opt_inout_bcount_z
#undef __deref_opt_inout_bcount_z_opt
#undef __deref_opt_inout_ecount
#undef __deref_opt_inout_ecount_full
#undef __deref_opt_inout_ecount_full_opt
#undef __deref_opt_inout_ecount_nz
#undef __deref_opt_inout_ecount_nz_opt
#undef __deref_opt_inout_ecount_opt
#undef __deref_opt_inout_ecount_part
#undef __deref_opt_inout_ecount_part_opt
#undef __deref_opt_inout_ecount_z
#undef __deref_opt_inout_ecount_z_opt
#undef __deref_opt_inout_nz
#undef __deref_opt_inout_nz_opt
#undef __deref_opt_inout_opt
#undef __deref_opt_inout_xcount
#undef __deref_opt_inout_xcount_full
#undef __deref_opt_inout_xcount_full_opt
#undef __deref_opt_inout_xcount_opt
#undef __deref_opt_inout_xcount_part
#undef __deref_opt_inout_xcount_part_opt
#undef __deref_opt_inout_z
#undef __deref_opt_inout_z_opt
#undef __deref_opt_out
#undef __deref_opt_out_bcount
#undef __deref_opt_out_bcount_full
#undef __deref_opt_out_bcount_full_opt
#undef __deref_opt_out_bcount_nz_opt
#undef __deref_opt_out_bcount_opt
#undef __deref_opt_out_bcount_part
#undef __deref_opt_out_bcount_part_opt
#undef __deref_opt_out_bcount_z_opt
#undef __deref_opt_out_ecount
#undef __deref_opt_out_ecount_full
#undef __deref_opt_out_ecount_full_opt
#undef __deref_opt_out_ecount_nz_opt
#undef __deref_opt_out_ecount_opt
#undef __deref_opt_out_ecount_part
#undef __deref_opt_out_ecount_part_opt
#undef __deref_opt_out_ecount_z_opt
#undef __deref_opt_out_nz_opt
#undef __deref_opt_out_opt
#undef __deref_opt_out_xcount
#undef __deref_opt_out_xcount_full
#undef __deref_opt_out_xcount_full_opt
#undef __deref_opt_out_xcount_opt
#undef __deref_opt_out_xcount_part
#undef __deref_opt_out_xcount_part_opt
#undef __deref_opt_out_z_opt
#undef __deref_opt_xcount
#undef __deref_opt_xcount_opt
#undef __deref_out
#undef __deref_out_bcount
#undef __deref_out_bcount_full
#undef __deref_out_bcount_full_opt
#undef __deref_out_bcount_nz
#undef __deref_out_bcount_nz_opt
#undef __deref_out_bcount_opt
#undef __deref_out_bcount_part
#undef __deref_out_bcount_part_opt
#undef __deref_out_bcount_z
#undef __deref_out_bcount_z_opt
#undef __deref_out_bound
#undef __deref_out_ecount
#undef __deref_out_ecount_full
#undef __deref_out_ecount_full_opt
#undef __deref_out_ecount_nz
#undef __deref_out_ecount_nz_opt
#undef __deref_out_ecount_opt
#undef __deref_out_ecount_part
#undef __deref_out_ecount_part_opt
#undef __deref_out_ecount_z
#undef __deref_out_ecount_z_opt
#undef __deref_out_nz
#undef __deref_out_nz_opt
#undef __deref_out_opt
#undef __deref_out_range
#undef __deref_out_range
#undef __deref_out_xcount
#undef __deref_out_xcount
#undef __deref_out_xcount_full
#undef __deref_out_xcount_full_opt
#undef __deref_out_xcount_opt
#undef __deref_out_xcount_part
#undef __deref_out_xcount_part_opt
#undef __deref_out_z
#undef __deref_out_z_opt
#undef __deref_volatile
#undef __deref_xcount
#undef __deref_xcount_opt
#undef __ecount
#undef __ecount_opt
#undef __elem_readableTo
#undef __elem_writableTo
#undef __encoded_array
#undef __encoded_pointer
#undef __exceptthat
#undef __fallthrough
#undef __field_bcount
#undef __field_bcount_full
#undef __field_bcount_full_opt
#undef __field_bcount_opt
#undef __field_bcount_part
#undef __field_bcount_part_opt
#undef __field_data_source
#undef __field_ecount
#undef __field_ecount_full
#undef __field_ecount_full_opt
#undef __field_ecount_opt
#undef __field_ecount_part
#undef __field_ecount_part_opt
#undef __field_encoded_array
#undef __field_encoded_pointer
#undef __field_range
#undef __field_xcount
#undef __field_xcount_full
#undef __field_xcount_full_opt
#undef __field_xcount_opt
#undef __field_xcount_part
#undef __field_xcount_part_opt
#undef __file_parser
#undef __file_parser_class
#undef __file_parser_library
#undef __format_string
#undef __format_string
#undef __gdi_entry
#undef __in
#undef __in_awcount
#undef __in_bcount
#undef __in_bcount_nz
#undef __in_bcount_nz_opt
#undef __in_bcount_opt
#undef __in_bcount_z
#undef __in_bcount_z_opt
#undef __in_bound
#undef __in_data_source
#undef __in_ecount
#undef __in_ecount_nz
#undef __in_ecount_nz_opt
#undef __in_ecount_opt
#undef __in_ecount_z
#undef __in_ecount_z_opt
#undef __in_nz
#undef __in_nz_opt
#undef __in_opt
#undef __in_range
#undef __in_xcount
#undef __in_xcount_opt
#undef __in_z
#undef __in_z_opt
#undef __inexpressible_readableTo
#undef __inexpressible_writableTo
#undef __inner_assume_bound
#undef __inner_assume_bound_dec
#undef __inner_assume_validated
#undef __inner_assume_validated_dec
#undef __inner_blocksOn
#undef __inner_bound
#undef __inner_callback
#undef __inner_checkReturn
#undef __inner_control_entrypoint
#undef __inner_data_entrypoint
#undef __inner_data_source
#undef __inner_encoded
#undef __inner_fallthrough
#undef __inner_fallthrough_dec
#undef __inner_out_validated
#undef __inner_override
#undef __inner_range
#undef __inner_success
#undef __inner_transfer
#undef __inner_typefix
#undef __inout
#undef __inout_bcount
#undef __inout_bcount_full
#undef __inout_bcount_full_opt
#undef __inout_bcount_nz
#undef __inout_bcount_nz_opt
#undef __inout_bcount_opt
#undef __inout_bcount_part
#undef __inout_bcount_part_opt
#undef __inout_bcount_z
#undef __inout_bcount_z_opt
#undef __inout_ecount
#undef __inout_ecount_full
#undef __inout_ecount_full_opt
#undef __inout_ecount_nz
#undef __inout_ecount_nz_opt
#undef __inout_ecount_opt
#undef __inout_ecount_part
#undef __inout_ecount_part_opt
#undef __inout_ecount_z
#undef __inout_ecount_z_opt
#undef __inout_ecount_z_opt
#undef __inout_nz
#undef __inout_nz_opt
#undef __inout_opt
#undef __inout_xcount
#undef __inout_xcount_full
#undef __inout_xcount_full_opt
#undef __inout_xcount_opt
#undef __inout_xcount_part
#undef __inout_xcount_part_opt
#undef __inout_z
#undef __inout_z_opt
#undef __kernel_entry
#undef __maybenull
#undef __maybereadonly
#undef __maybevalid
#undef __nonvolatile
#undef __notnull
#undef __notreadonly
#undef __notvalid
#undef __null
#undef __nullnullterminated
#undef __nullterminated
#undef __out
#undef __out_awcount
#undef __out_bcount
#undef __out_bcount_full
#undef __out_bcount_full_opt
#undef __out_bcount_nz
#undef __out_bcount_nz_opt
#undef __out_bcount_opt
#undef __out_bcount_part
#undef __out_bcount_part_opt
#undef __out_bcount_z
#undef __out_bcount_z_opt
#undef __out_bound
#undef __out_data_source
#undef __out_ecount
#undef __out_ecount_full
#undef __out_ecount_full_opt
#undef __out_ecount_nz
#undef __out_ecount_nz_opt
#undef __out_ecount_opt
#undef __out_ecount_part
#undef __out_ecount_part_opt
#undef __out_ecount_z
#undef __out_ecount_z_opt
#undef __out_has_adt_prop
#undef __out_has_type_adt_props
#undef __out_not_has_adt_prop
#undef __out_nz
#undef __out_nz_opt
#undef __out_opt
#undef __out_range
#undef __out_transfer_adt_prop
#undef __out_validated
#undef __out_xcount
#undef __out_xcount_full
#undef __out_xcount_full_opt
#undef __out_xcount_opt
#undef __out_xcount_part
#undef __out_xcount_part_opt
#undef __out_z
#undef __override
#undef __possibly_notnulltermiated
#undef __post
#undef __postcond
#undef __pre
#undef __precond
#undef __range
#undef __readableTo
#undef __readonly
#undef __refparam
#undef __reserved
#undef __rpc_entry
#undef __source_code_content
#undef __struct_bcount
#undef __struct_xcount
#undef __success
#undef __this_out_data_source
#undef __this_out_validated
#undef __transfer
#undef __type_has_adt_prop
#undef __typefix
#undef __valid
#undef __volatile
#undef __writableTo
#undef __xcount
#undef __xcount_opt

BIN
jxrlib/doc/JPEGXR_DPK_Spec_1.0.doc
View file

Binary file not shown.

95
jxrlib/doc/readme.txt
View file

@ -1,95 +0,0 @@
JPEG XR Device Porting Kit v1.0 - April 2013
---------------------------------------------------------------------------------
JPEG XR
-------
This device porting kit (DPK) supports the JPEG XR still image format, based on
technology originally developed by Mirosoft under the name HD Photo (formerly
Windows Media™ Photo). The JPEG XR format is similar, but not identical, to the
HD Photo/Windows Media™ Photo format.
The JPEG XR format replaces the HD Photo/Windows Media™ Photo format in both
Windows 8 and the Windows Image Component (WIC). WIC accompanies the Internet
Explorer 10 redistributable packages for down-level versions of Windows.
Some “Windows Media™ Photo” (WMP) naming conventions are still used internally
with this release of the DPK.
JPEG XR files use the .jxr extension. Applications that support the JPEG XR
file format should recognize and decode HD Photo/Windows Media™ Photo
.hdp/.wdp files, but only offer to create files with the .jxr extension.
Device Porting Kit Contents
---------------------------
This device porting kit contains documentation, reference source code, sample
applications and utilities for the evaluation and implementation of the JPEG XR
file format and compression technology.
Assuming the installation dir is C:\jxrlib, all the paths mentioned below are
relative to this base path.
The Visual Studio 2010 main solution is:
jxrencoderdecoder\JXR.sln
The Visual Studio 2012 main solution is:
jxrencoderdecoder\JXR_vc11.sln
Build JXR.sln Debug Configuration, you will get:
jxrencoderdecoder\Debug\JXRDecApp\JXRDecApp.exe
jxrencoderdecoder\Debug\JXREncApp\JXREncApp.exe
The main directory contains a Unix/Linux compatible make file for building the
encoder and decoder, including support for big endian or little endian processor
architecture. It is the developer's responsibility to properly organize all the
source files according to the paths defined in this make file for its correct
operation. This is provided as a convenience for cross-platform developers and
to demonstrate the correct operation of the encoder and decoder on big endian
systems.
The JPEG XR Image Coding Spectification provides a detailed specification of the
compression encoder and decoder algorithms plus the detailed structure of the
compressed data (elementary) bit stream. This document is designed to be used in
conjunction with the included source code. If you find instances where the code
differs from the documentation, the code implementation should be used as the
reference.
The JPEG XR Image Coding Spectification is an international standard and is
available at: http://www.itu.int/rec/T-REC-T.832 while the reference software is
available at: http://www.itu.int/rec/T-REC-T.835.
"JPEGXR_DPK_1.0.doc" documents the contents of this porting kit, the usage of
the command line file conversion utilities (JXREncApp.exe and JXRDecApp.exe), and
technical details of the API's and data structures between these sample command
line applications and the core codec.
The code and documentation in this release represent the final design and
specification of the 1.0 bit stream, and can be used as the reference for final
implementations of encoders and decoders for JPEG XR.
This release of the DPK has received extensive testing of all the various pixel
formats, encoder options and modes of operation. We are confident that most errors
and other bugs have been resolved. Any code bugs, documentation errors or other
discrepancies found in this release candidate should be reported to Microsoft as
promptly as possible. These can be submitted to hdview@microsoft.com.
This DPK provides basic support for big endian architectures. We have
successfully tested the encoder and decoder using a big endian processor. This
support is provided as a starting reference to be adapted to the specific
platform and hardware architecture of the target system.
Contact Information
-------------------
For any and all technical questions or feedback about any part of this Device
Porting Kit, including the documentation, please send email to:
hdview@microsoft.com
We will respond as promptly as possible with answers to your questions.
Additional information, best practices, tools, utilities, sample code, sample
image content, links to additional resources and community discussion can
currently be found at http://hdview.wordpress.com/.
- The Microsoft JPEG XR Development Team
---------------------------------------------------------------------------------

987
jxrlib/image/decode/JXRTranscode.c
View file

@ -1,987 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#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 Int encodeMB(CWMImageStrCodec *, Int, Int);
EXTERN_C Int writeIndexTableNull(CWMImageStrCodec *);
EXTERN_C Void writePacketHeader(BitIOInfo *, U8, U8);
EXTERN_C Int WriteWMIHeader(CWMImageStrCodec *);
EXTERN_C Int ReadImagePlaneHeader(CWMImageInfo *, CWMIStrCodecParam *, CCoreParameters *, SimpleBitIO *);
EXTERN_C Int WriteImagePlaneHeader(CWMImageStrCodec *);
EXTERN_C Int writeIndexTable(CWMImageStrCodec *);
EXTERN_C Int copyTo(struct WMPStream *, struct WMPStream *, size_t);
const static Bool bFlipV[O_MAX] = {FALSE, TRUE , FALSE, TRUE, TRUE , TRUE, FALSE, FALSE};
const static Bool bFlipH[O_MAX] = {FALSE, FALSE, TRUE , TRUE, FALSE, TRUE, FALSE, TRUE};
typedef struct CTileQPInfo
{
U8 dcMode;
U8 dcIndex[MAX_CHANNELS];
Bool bUseDC;
U8 lpNum;
Bool bUseDCAlpha;
U8 lpNumAlpha;
U8 lpMode[16];
U8 lpIndex[16][MAX_CHANNELS];
Bool bUseLP;
U8 hpNum;
Bool bUseLPAlpha;
U8 hpNumAlpha;
U8 hpMode[16];
U8 hpIndex[16][MAX_CHANNELS];
} CTileQPInfo;
Void transcodeQuantizer(BitIOInfo * pIO, U8 cIndex[MAX_CHANNELS], U8 cChMode, size_t cChannel)
{
if(cChMode > 2)
cChMode = 2;
if(cChannel > 1)
putBit16(pIO, cChMode, 2); // Channel mode
else
cChMode = 0;
putBit16(pIO, cIndex[0], 8); // Y
if(cChMode == 1) // MIXED
putBit16(pIO, cIndex[1], 8); // UV
else if(cChMode > 0){ // INDEPENDENT
size_t i;
for(i = 1; i < cChannel; i ++)
putBit16(pIO, cIndex[i], 8); // UV
}
}
Void transcodeQuantizers(BitIOInfo * pIO, U8 cIndex[16][MAX_CHANNELS], U8 cChMode[16], U32 cNum, size_t cChannel, Bool bCopy)
{
putBit16(pIO, bCopy == TRUE ? 1 : 0, 1);
if(bCopy == FALSE){
U32 i;
putBit16(pIO, cNum - 1, 4);
for(i = 0; i < cNum; i ++)
transcodeQuantizer(pIO, cIndex[i], cChMode[i], cChannel);
}
}
Void transcodeQuantizersAlpha(BitIOInfo * pIO, U8 cIndex[16][MAX_CHANNELS], U32 cNum, size_t iChannel, Bool bCopy)
{
putBit16(pIO, bCopy == TRUE ? 1 : 0, 1);
if(bCopy == FALSE){
U32 i;
putBit16(pIO, cNum - 1, 4);
for(i = 0; i < cNum; i ++)
putBit16(pIO, cIndex[i][iChannel], 8);
}
}
Void transcodeTileHeader(CWMImageStrCodec * pSC, CTileQPInfo * pTileQPInfo)
{
if(pSC->m_bCtxLeft && pSC->m_bCtxTop && pSC->m_bSecondary == FALSE){ // write packet headers
CCodingContext * pContext = &pSC->m_pCodingContext[pSC->cTileColumn];
CWMITile * pTile = pSC->pTile + pSC->cTileColumn;
U8 pID = (U8)((pSC->cTileRow * (pSC->WMISCP.cNumOfSliceMinus1V + 1) + pSC->cTileColumn) & 0x1F);
CWMImageStrCodec * pSCAlpha = (pSC->m_param.bAlphaChannel ? pSC->m_pNextSC : NULL);
const size_t iAlphaPos = pSC->m_param.cNumChannels;
writePacketHeader(pContext->m_pIODC, pSC->WMISCP.bfBitstreamFormat == SPATIAL ? 0 : 1, pID);
if (pSC->m_param.bTrimFlexbitsFlag && pSC->WMISCP.bfBitstreamFormat == SPATIAL)
putBit16(pContext->m_pIODC, pContext->m_iTrimFlexBits, 4);
if((pSC->m_param.uQPMode & 1) != 0) // not DC uniform
transcodeQuantizer(pContext->m_pIODC, pTileQPInfo->dcIndex, pTileQPInfo->dcMode, pSC->WMISCP.cChannel);
if(pSCAlpha != NULL && (pSCAlpha->m_param.uQPMode & 1) != 0) // not DC uniform
putBit16(pContext->m_pIODC, pTileQPInfo->dcIndex[iAlphaPos], 8);
if(pSC->WMISCP.bfBitstreamFormat == SPATIAL) {
if(pSC->WMISCP.sbSubband != SB_DC_ONLY){
if((pSC->m_param.uQPMode & 2) != 0) // not LP uniform
transcodeQuantizers(pContext->m_pIODC, pTileQPInfo->lpIndex, pTileQPInfo->lpMode, pTileQPInfo->lpNum, pSC->WMISCP.cChannel, pTileQPInfo->bUseDC);
if(pSCAlpha != NULL && (pSCAlpha->m_param.uQPMode & 2) != 0) // not LP uniform
transcodeQuantizersAlpha(pContext->m_pIODC, pTileQPInfo->lpIndex, pTileQPInfo->lpNumAlpha, iAlphaPos, pTileQPInfo->bUseDCAlpha);
if(pSC->WMISCP.sbSubband != SB_NO_HIGHPASS){
if((pSC->m_param.uQPMode & 4) != 0) // not HP uniform
transcodeQuantizers(pContext->m_pIODC, pTileQPInfo->hpIndex, pTileQPInfo->hpMode, pTileQPInfo->hpNum, pSC->WMISCP.cChannel, pTileQPInfo->bUseLP);
if(pSCAlpha != NULL && (pSCAlpha->m_param.uQPMode & 4) != 0) // not HP uniform
transcodeQuantizersAlpha(pContext->m_pIODC, pTileQPInfo->hpIndex, pTileQPInfo->hpNumAlpha, iAlphaPos, pTileQPInfo->bUseLPAlpha);
}
}
}
else{
if(pSC->WMISCP.sbSubband != SB_DC_ONLY){
writePacketHeader(pContext->m_pIOLP, 2, pID);
if((pSC->m_param.uQPMode & 2) != 0) // not LP uniform
transcodeQuantizers(pContext->m_pIOLP, pTileQPInfo->lpIndex, pTileQPInfo->lpMode, pTileQPInfo->lpNum, pSC->WMISCP.cChannel, pTileQPInfo->bUseDC);
if(pSCAlpha != NULL && (pSCAlpha->m_param.uQPMode & 2) != 0) // not LP uniform
transcodeQuantizersAlpha(pContext->m_pIOLP, pTileQPInfo->lpIndex, pTileQPInfo->lpNumAlpha, iAlphaPos, pTileQPInfo->bUseDCAlpha);
if(pSC->WMISCP.sbSubband != SB_NO_HIGHPASS){
writePacketHeader(pContext->m_pIOAC, 3, pID);
if((pSC->m_param.uQPMode & 4) != 0) // not HP uniform
transcodeQuantizers(pContext->m_pIOAC, pTileQPInfo->hpIndex, pTileQPInfo->hpMode, pTileQPInfo->hpNum, pSC->WMISCP.cChannel, pTileQPInfo->bUseLP);
if(pSCAlpha != NULL && (pSCAlpha->m_param.uQPMode & 4) != 0) // not HP uniform
transcodeQuantizersAlpha(pContext->m_pIOAC, pTileQPInfo->hpIndex, pTileQPInfo->hpNumAlpha, iAlphaPos, pTileQPInfo->bUseLPAlpha);
if(pSC->WMISCP.sbSubband != SB_NO_FLEXBITS){
writePacketHeader(pContext->m_pIOFL, 4, pID);
if (pSC->m_param.bTrimFlexbitsFlag)
putBit16(pContext->m_pIOFL, pContext->m_iTrimFlexBits, 4);
}
}
}
}
pTile->cBitsLP = (pTileQPInfo->bUseDC ? 0 : dquantBits(pTileQPInfo->lpNum));
pTile->cBitsHP = (pTileQPInfo->bUseLP ? 0 : dquantBits(pTileQPInfo->hpNum));
if(pSCAlpha != NULL){
pTile = pSCAlpha->pTile + pSC->cTileColumn;
pTile->cBitsLP = (pTileQPInfo->bUseDCAlpha ? 0 : dquantBits(pTileQPInfo->lpNumAlpha));
pTile->cBitsHP = (pTileQPInfo->bUseLPAlpha ? 0 : dquantBits(pTileQPInfo->hpNumAlpha));
}
}
}
Void transformDCBlock(PixelI * pOrg, PixelI * pDst, ORIENTATION oOrientation)
{
size_t i;
if(bFlipV[oOrientation])
for(i = 0; i < 16; i += 4)
pOrg[i + 1] = -pOrg[i + 1], pOrg[i + 3] = -pOrg[i + 3];
if(bFlipH[oOrientation])
for(i = 0; i < 4; i ++)
pOrg[i + 4] = -pOrg[i + 4], pOrg[i + 12] = -pOrg[i + 12];
if(oOrientation < O_RCW)
memcpy(pDst, pOrg, 16 * sizeof(PixelI));
else
for(i = 0; i < 16; i ++)
pDst[i] = pOrg[(i >> 2) + ((i & 3) << 2)];
}
Void transformDCBlock422(PixelI * pOrg, PixelI * pDst, ORIENTATION oOrientation)
{
assert(oOrientation < O_RCW);
if(bFlipV[oOrientation])
pOrg[1] = -pOrg[1], pOrg[3] = -pOrg[3], pOrg[4] = -pOrg[4], pOrg[5] = -pOrg[5], pOrg[7] = -pOrg[7];
if(bFlipH[oOrientation])
pOrg[2] = -pOrg[2], pOrg[3] = -pOrg[3], pOrg[6] = -pOrg[6], pOrg[7] = -pOrg[7];
if(bFlipV[oOrientation])
pDst[0] = pOrg[0], pDst[1] = pOrg[5], pDst[2] = pOrg[6], pDst[3] = pOrg[7], pDst[4] = pOrg[4], pDst[5] = pOrg[1], pDst[6] = pOrg[2], pDst[7] = pOrg[3];
else
memcpy(pDst, pOrg, 8 * sizeof(PixelI));
}
Void transformDCBlock420(PixelI * pOrg, PixelI * pDst, ORIENTATION oOrientation)
{
if(bFlipV[oOrientation])
pOrg[1] = -pOrg[1], pOrg[3] = -pOrg[3];
if(bFlipH[oOrientation])
pOrg[2] = -pOrg[2], pOrg[3] = -pOrg[3];
pDst[0] = pOrg[0], pDst[3] = pOrg[3];
if(oOrientation < O_RCW)
pDst[1] = pOrg[1], pDst[2] = pOrg[2];
else
pDst[1] = pOrg[2], pDst[2] = pOrg[1];
}
Void transformACBlocks(PixelI * pOrg, PixelI * pDst, ORIENTATION oOrientation)
{
PixelI * pO, * pD;
const Int * pT = dctIndex[0];
size_t i, j, k;
for(j = 0, pO = pOrg; j < 16; j ++, pO += 16){
if(bFlipV[oOrientation])
for(i = 0; i < 16; i += 4)
pO[pT[i + 1]] = -pO[pT[i + 1]], pO[pT[i + 3]] = -pO[pT[i + 3]];
if(bFlipH[oOrientation])
for(i = 0; i < 4; i ++)
pO[pT[i + 4]] = -pO[pT[i + 4]], pO[pT[i + 12]] = -pO[pT[i + 12]];
}
for(j = 0; j < 4; j ++)
for(i = 0; i < 4; i ++){
size_t ii = (bFlipV[oOrientation] ? 3 - i : i);
size_t jj = (bFlipH[oOrientation] ? 3 - j : j);
if(oOrientation < O_RCW)
memcpy(pDst + (jj * 4 + ii) * 16, pOrg + (j * 4 + i) * 16, 16 * sizeof(PixelI));
else{
pO = pOrg + (j * 4 + i) * 16;
pD = pDst + (ii * 4 + jj) * 16;
for(k = 1; k < 16; k ++)
pD[pT[k]] = pO[pT[(k >> 2) + ((k & 3) << 2)]];
}
}
}
Void transformACBlocks422(PixelI * pOrg, PixelI * pDst, ORIENTATION oOrientation)
{
PixelI * pO;
const Int * pT = dctIndex[0];
size_t i, j;
assert(oOrientation < O_RCW);
for(j = 0, pO = pOrg; j < 8; j ++, pO += 16){
if(bFlipV[oOrientation])
for(i = 0; i < 16; i += 4)
pO[pT[i + 1]] = -pO[pT[i + 1]], pO[pT[i + 3]] = -pO[pT[i + 3]];
if(bFlipH[oOrientation])
for(i = 0; i < 4; i ++)
pO[pT[i + 4]] = -pO[pT[i + 4]], pO[pT[i + 12]] = -pO[pT[i + 12]];
}
for(j = 0; j < 2; j ++)
for(i = 0; i < 4; i ++){
size_t ii = (bFlipV[oOrientation] ? 3 - i : i);
size_t jj = (bFlipH[oOrientation] ? 1 - j : j);
memcpy(pDst + (jj * 4 + ii) * 16, pOrg + (j * 4 + i) * 16, 16 * sizeof(PixelI));
}
}
Void transformACBlocks420(PixelI * pOrg, PixelI * pDst, ORIENTATION oOrientation)
{
PixelI * pO, * pD;
const Int * pT = dctIndex[0];
size_t i, j, k;
for(j = 0, pO = pOrg; j < 4; j ++, pO += 16){
if(bFlipV[oOrientation])
for(i = 0; i < 16; i += 4)
pO[pT[i + 1]] = -pO[pT[i + 1]], pO[pT[i + 3]] = -pO[pT[i + 3]];
if(bFlipH[oOrientation])
for(i = 0; i < 4; i ++)
pO[pT[i + 4]] = -pO[pT[i + 4]], pO[pT[i + 12]] = -pO[pT[i + 12]];
}
for(j = 0; j < 2; j ++)
for(i = 0; i < 2; i ++){
size_t ii = (bFlipV[oOrientation] ? 1 - i : i);
size_t jj = (bFlipH[oOrientation] ? 1 - j : j);
if(oOrientation < O_RCW)
memcpy(pDst + (jj * 2 + ii) * 16, pOrg + (j * 2 + i) * 16, 16 * sizeof(PixelI));
else{
pO = pOrg + (j * 2 + i) * 16;
pD = pDst + (ii * 2 + jj) * 16;
for(k = 1; k < 16; k ++)
pD[pT[k]] = pO[pT[(k >> 2) + ((k & 3) << 2)]];
}
}
}
Int getROI(CWMImageInfo * pII, CCoreParameters * pCore, CWMIStrCodecParam * pSCP, CWMTranscodingParam * pParam)
{
const ORIENTATION oO = pParam->oOrientation;
size_t iLeft, iTop, cWidth, cHeight, i, j;
size_t mbLeft, mbRight, mbTop, mbBottom;
size_t * iTile = (size_t *)malloc(MAX_TILES * sizeof(size_t));
if(iTile == NULL)
return ICERR_ERROR;
if(pParam->cLeftX + pParam->cWidth > pII->cWidth || pParam->cTopY + pParam->cHeight > pII->cHeight) // invalid region
return ICERR_ERROR;
cWidth = pParam->cWidth, cHeight = pParam->cHeight;
iLeft = pParam->cLeftX + pCore->cExtraPixelsLeft, iTop = pParam->cTopY + pCore->cExtraPixelsTop;
if(pSCP->olOverlap != OL_NONE && pParam->bIgnoreOverlap == FALSE){ // include pixels borrowed
size_t cBlurred = (pSCP->olOverlap == OL_TWO ? 10 : 2);
if(iLeft > cBlurred)
iLeft -= cBlurred, cWidth += cBlurred;
else
cWidth += iLeft, iLeft = 0;
if(iTop > cBlurred)
iTop -= cBlurred, cHeight += cBlurred;
else
cHeight += iTop, iTop = 0;
cWidth += cBlurred, cHeight += cBlurred;
if(iLeft + cWidth > pII->cWidth + pCore->cExtraPixelsLeft + pCore->cExtraPixelsRight)
cWidth = pII->cWidth + pCore->cExtraPixelsLeft + pCore->cExtraPixelsRight - iLeft;
if(iTop + cHeight > pII->cHeight + pCore->cExtraPixelsTop + pCore->cExtraPixelsBottom)
cHeight = pII->cHeight + pCore->cExtraPixelsTop + pCore->cExtraPixelsBottom - iTop;
}
mbTop = (iTop >> 4), mbLeft = (iLeft >> 4);
mbBottom = (iTop + cHeight + 15) >> 4, mbRight = (iLeft + cWidth + 15) >> 4;
pCore->cExtraPixelsLeft += pParam->cLeftX - (mbLeft << 4);
pCore->cExtraPixelsRight = ((mbRight - mbLeft) << 4) - pParam->cWidth - pCore->cExtraPixelsLeft;
pCore->cExtraPixelsTop += pParam->cTopY - (mbTop << 4);
pCore->cExtraPixelsBottom = ((mbBottom - mbTop) << 4) - pParam->cHeight - pCore->cExtraPixelsTop;
pII->cWidth = ((mbRight - mbLeft) << 4) - pCore->cExtraPixelsLeft - pCore->cExtraPixelsRight;
pII->cHeight = ((mbBottom - mbTop) << 4) - pCore->cExtraPixelsTop - pCore->cExtraPixelsBottom;
pParam->cLeftX = iLeft, pParam->cTopY = iTop;
pParam->cWidth = cWidth, pParam->cHeight = cHeight;
// extra pixels in transformed space
#define SWAP(a, b) i = a, a = b, b = i
if(oO == O_FLIPH || oO == O_FLIPVH || oO == O_RCW_FLIPV || oO == O_RCW_FLIPVH)
SWAP(pCore->cExtraPixelsLeft, pCore->cExtraPixelsRight);
if(oO == O_FLIPV || oO == O_FLIPVH || oO == O_RCW || oO == O_RCW_FLIPV)
SWAP(pCore->cExtraPixelsTop, pCore->cExtraPixelsBottom);
if(oO >= O_RCW){
SWAP(pCore->cExtraPixelsLeft, pCore->cExtraPixelsTop);
SWAP(pCore->cExtraPixelsRight, pCore->cExtraPixelsBottom);
}
// adjust tiling
for(i = 0, j = 0, iTile[0] = 0; i <= (size_t)pSCP->cNumOfSliceMinus1V; i ++)
if((size_t)pSCP->uiTileX[i] >= mbLeft && (size_t)pSCP->uiTileX[i] < mbRight){
if(j >= MAX_TILES)
j = MAX_TILES - 1;
iTile[j] = (size_t)pSCP->uiTileX[i] - mbLeft, j ++;
}
if(iTile[0] == 0)
for(i = 0, pSCP->cNumOfSliceMinus1V = (j == 0 ? 0 : (U32)(j - 1)); i < j; i ++)
pSCP->uiTileX[i] = (U32)iTile[i];
else
for(i = 1, pSCP->uiTileX[0] = 0, pSCP->cNumOfSliceMinus1V = (U32)j; i <= j; i ++)
pSCP->uiTileX[i] = (U32)iTile[i - 1];
if(oO == O_FLIPH || oO == O_FLIPVH || oO == O_RCW_FLIPV || oO == O_RCW_FLIPVH){ // reverse order
for(i = 0; i <= (size_t)pSCP->cNumOfSliceMinus1V; i ++)
iTile[i] = mbRight - mbLeft - (size_t)pSCP->uiTileX[i];
for(i = 1, pSCP->uiTileX[0] = 0; i <= (size_t)pSCP->cNumOfSliceMinus1V; i ++)
pSCP->uiTileX[i] = (U32)(iTile[(size_t)pSCP->cNumOfSliceMinus1V - i + 1]);
}
for(i = 0, j = 0, iTile[0] = 0; i <= (size_t)pSCP->cNumOfSliceMinus1H; i ++)
if(pSCP->uiTileY[i] >= mbTop && pSCP->uiTileY[i] < mbBottom){
if(j >= MAX_TILES)
j = MAX_TILES - 1;
iTile[j] = (size_t)pSCP->uiTileY[i] - mbTop, j ++;
}
if(iTile[0] == 0)
for(i = 0, pSCP->cNumOfSliceMinus1H = (j == 0 ? 0 : (U32)(j - 1)); i < j; i ++)
pSCP->uiTileY[i] = (U32)iTile[i];
else
for(i = 1, pSCP->uiTileY[0] = 0, pSCP->cNumOfSliceMinus1H = (U32)j; i <= j; i ++)
pSCP->uiTileY[i] = (U32)iTile[i - 1];
if(oO == O_FLIPV || oO == O_FLIPVH || oO == O_RCW || oO == O_RCW_FLIPV){ // reverse order
for(i = 0; i <= (size_t)pSCP->cNumOfSliceMinus1H; i ++)
iTile[i] = mbBottom - mbTop - (size_t)pSCP->uiTileY[i];
for(i = 1, pSCP->uiTileY[0] = 0; i <= (size_t)pSCP->cNumOfSliceMinus1H; i ++)
pSCP->uiTileY[i] = (U32)(iTile[(size_t)pSCP->cNumOfSliceMinus1H - i + 1]);
}
if(oO >= O_RCW){ // switch X & Y
for(i = 0; i <= (size_t)pSCP->cNumOfSliceMinus1V; i ++)
iTile[i] = (size_t)pSCP->uiTileX[i];
for(i = 0; i <= (size_t)pSCP->cNumOfSliceMinus1H; i ++)
pSCP->uiTileX[i] = pSCP->uiTileY[i];
for(i = 0; i <= (size_t)pSCP->cNumOfSliceMinus1V; i ++)
pSCP->uiTileY[i] = (U32)iTile[i];
i = (size_t)pSCP->cNumOfSliceMinus1H, pSCP->cNumOfSliceMinus1H = pSCP->cNumOfSliceMinus1V, pSCP->cNumOfSliceMinus1V = (U32)i;
}
free(iTile);
return ICERR_OK;
}
Bool isTileBoundary(U32 * pTilePos, U32 cTiles, U32 cMBs, U32 iPos)
{
U32 i;
for(i = 0; i < cTiles; i ++)
if(iPos == pTilePos[i] * 16)
break;
return ((i < cTiles || (iPos + 15) / 16 >= cMBs) ? TRUE : FALSE);
}
Bool isTileExtraction(CWMImageStrCodec * pSC, CWMTranscodingParam * pParam)
{
if(pParam->bIgnoreOverlap == FALSE && pSC->WMISCP.olOverlap == OL_NONE)
pParam->bIgnoreOverlap = TRUE;
if(pParam->bIgnoreOverlap == TRUE && pParam->oOrientation == O_NONE && pParam->bfBitstreamFormat == pSC->WMISCP.bfBitstreamFormat){
if(pParam->bfBitstreamFormat == SPATIAL && pParam->sbSubband != pSC->WMISCP.sbSubband)
return FALSE;
return (isTileBoundary(pSC->WMISCP.uiTileX, pSC->WMISCP.cNumOfSliceMinus1V + 1, (U32)pSC->cmbWidth, (U32)(pParam->cLeftX + pSC->m_param.cExtraPixelsLeft)) &&
isTileBoundary(pSC->WMISCP.uiTileY, pSC->WMISCP.cNumOfSliceMinus1H + 1, (U32)pSC->cmbHeight, (U32)(pParam->cTopY + pSC->m_param.cExtraPixelsTop)) &&
isTileBoundary(pSC->WMISCP.uiTileX, pSC->WMISCP.cNumOfSliceMinus1V + 1, (U32)pSC->cmbWidth, (U32)(pParam->cLeftX + pParam->cWidth + pSC->m_param.cExtraPixelsLeft)) &&
isTileBoundary(pSC->WMISCP.uiTileY, pSC->WMISCP.cNumOfSliceMinus1H + 1, (U32)pSC->cmbHeight, (U32)(pParam->cTopY + pParam->cHeight + pSC->m_param.cExtraPixelsTop)));
}
return FALSE;
}
Int WMPhotoTranscode(struct WMPStream * pStreamIn, struct WMPStream * pStreamOut, CWMTranscodingParam * pParam)
{
PixelI * pMBBuf, MBBufAlpha[256]; // shared buffer, decoder <=> encoder bridge
PixelI * pFrameBuf = NULL, * pFrameBufAlpha = NULL;
CWMIMBInfo * pMBInfo = NULL, * pMBInfoAlpha = NULL;
CWMImageStrCodec * pSCDec, * pSCEnc, * pSC;
CWMDecoderParameters aDecoderParam = {0};
U8 * pIOHeaderDec, * pIOHeaderEnc;
CCodingContext * pContext;
CTileQPInfo * pTileQPInfo = NULL;
ORIENTATION oO = pParam->oOrientation;
size_t iAlphaPos = 0;
size_t cUnit;
size_t i, j, mbLeft, mbRight, mbTop, mbBottom, mbWidth, mbHeight;
if(pStreamIn == NULL || pStreamOut == NULL || pParam == NULL)
return ICERR_ERROR;
// initialize decoder
if((pSCDec = (CWMImageStrCodec *)malloc(sizeof(CWMImageStrCodec))) == NULL)
return ICERR_ERROR;
memset(pSCDec, 0, sizeof(CWMImageStrCodec));
pSCDec->WMISCP.pWStream = pStreamIn;
if(ReadWMIHeader(&pSCDec->WMII, &pSCDec->WMISCP, &pSCDec->m_param) != ICERR_OK)
return ICERR_ERROR;
if(pSCDec->WMISCP.cfColorFormat == YUV_422 && oO >= O_RCW)
pParam->oOrientation = oO = O_NONE; // Can not rotate 422 in compressed domain!
pSCDec->cmbWidth = (pSCDec->WMII.cWidth + pSCDec->m_param.cExtraPixelsLeft + pSCDec->m_param.cExtraPixelsRight + 15) / 16;
pSCDec->cmbHeight = (pSCDec->WMII.cHeight + pSCDec->m_param.cExtraPixelsTop + pSCDec->m_param.cExtraPixelsBottom + 15) / 16;
pSCDec->m_param.cNumChannels = pSCDec->WMISCP.cChannel;
pSCDec->m_Dparam = &aDecoderParam;
pSCDec->m_Dparam->bSkipFlexbits = (pSCDec->WMISCP.sbSubband == SB_NO_FLEXBITS);
pSCDec->m_param.bTranscode = TRUE;
pParam->bIgnoreOverlap = isTileExtraction(pSCDec, pParam);
cUnit = (pSCDec->m_param.cfColorFormat == YUV_420 ? 384 : (pSCDec->m_param.cfColorFormat == YUV_422 ? 512 : 256 * pSCDec->m_param.cNumChannels));
if(cUnit > 256 * MAX_CHANNELS)
return ICERR_ERROR;
pSCDec->p1MBbuffer[0] = pMBBuf = (PixelI *)malloc(cUnit * sizeof(PixelI));
if(pMBBuf == NULL)
return ICERR_ERROR;
pSCDec->p1MBbuffer[1] = pSCDec->p1MBbuffer[0] + 256;
for(i = 2; i < pSCDec->m_param.cNumChannels; i ++)
pSCDec->p1MBbuffer[i] = pSCDec->p1MBbuffer[i - 1] + (pSCDec->m_param.cfColorFormat == YUV_420 ? 64 : (pSCDec->m_param.cfColorFormat == YUV_422 ? 128 : 256));
if(pSCDec->m_param.bAlphaChannel){ // alpha channel
SimpleBitIO SB = {0};
iAlphaPos = pSCDec->m_param.cNumChannels;
if((pSCDec->m_pNextSC = (CWMImageStrCodec *)malloc(sizeof(CWMImageStrCodec))) == NULL)
return ICERR_ERROR;
*pSCDec->m_pNextSC = *pSCDec;
pSCDec->m_pNextSC->p1MBbuffer[0] = MBBufAlpha;
pSCDec->m_pNextSC->WMISCP.cfColorFormat = pSCDec->m_pNextSC->WMII.cfColorFormat = pSCDec->m_pNextSC->m_param.cfColorFormat = Y_ONLY;
pSCDec->m_pNextSC->WMISCP.cChannel = pSCDec->m_pNextSC->m_param.cNumChannels = 1;
pSCDec->m_pNextSC->m_bSecondary = TRUE;
pSCDec->m_pNextSC->m_pNextSC = pSCDec;
// read plane header of second image plane
if(attach_SB(&SB, pSCDec->WMISCP.pWStream) != ICERR_OK)
return ICERR_ERROR;
ReadImagePlaneHeader(&pSCDec->m_pNextSC->WMII, &pSCDec->m_pNextSC->WMISCP, &pSCDec->m_pNextSC->m_param, &SB);
detach_SB(&SB);
if(StrDecInit(pSCDec->m_pNextSC) != ICERR_OK)
return ICERR_ERROR;
}
else
pParam->uAlphaMode = 0;
pIOHeaderDec = (U8 *)malloc((PACKETLENGTH * 4 - 1) + PACKETLENGTH * 4 + sizeof(BitIOInfo));
if(pIOHeaderDec == NULL)
return ICERR_ERROR;
memset(pIOHeaderDec, 0, (PACKETLENGTH * 4 - 1) + PACKETLENGTH * 4 + sizeof(BitIOInfo));
pSCDec->pIOHeader = (BitIOInfo *)((U8 *)ALIGNUP(pIOHeaderDec, PACKETLENGTH * 4) + PACKETLENGTH * 2);
if(StrIODecInit(pSCDec) != ICERR_OK)
return ICERR_ERROR;
if(StrDecInit(pSCDec) != ICERR_OK)
return ICERR_ERROR;
if(pSCDec->m_param.bAlphaChannel){ // alpha channel
if(StrDecInit(pSCDec->m_pNextSC) != ICERR_OK)
return ICERR_ERROR;
}
// initialize encoder
if((pSCEnc = (CWMImageStrCodec *)malloc(sizeof(CWMImageStrCodec))) == NULL)
return ICERR_ERROR;
memset(pSCEnc, 0, sizeof(CWMImageStrCodec));
pSCEnc->WMII = pSCDec->WMII;
pSCEnc->WMISCP = pSCDec->WMISCP;
pSCEnc->m_param = pSCDec->m_param;
pSCEnc->WMISCP.pWStream = pStreamOut;
pSCEnc->WMISCP.bfBitstreamFormat = pParam->bfBitstreamFormat;
// pSCEnc->m_param.cfColorFormat = pSCEnc->WMISCP.cfColorFormat = pParam->cfColorFormat;
pSCEnc->m_param.cfColorFormat = pSCEnc->WMISCP.cfColorFormat;
pSCEnc->m_param.cNumChannels = (pSCEnc->WMISCP.cfColorFormat == Y_ONLY ? 1 : (pSCEnc->WMISCP.cfColorFormat == YUV_444 ? 3 : pSCEnc->WMISCP.cChannel));
pSCEnc->m_param.bAlphaChannel = (pParam->uAlphaMode > 0);
pSCEnc->m_param.bTranscode = TRUE;
if(pParam->sbSubband >= SB_MAX)
pParam->sbSubband = SB_ALL;
if(pParam->sbSubband > pSCEnc->WMISCP.sbSubband)
pSCEnc->WMISCP.sbSubband = pParam->sbSubband;
pSCEnc->m_bSecondary = FALSE;
pIOHeaderEnc = (U8 *)malloc((PACKETLENGTH * 4 - 1) + PACKETLENGTH * 4 + sizeof(BitIOInfo));
if(pIOHeaderEnc == NULL)
return ICERR_ERROR;
memset(pIOHeaderEnc, 0, (PACKETLENGTH * 4 - 1) + PACKETLENGTH * 4 + sizeof(BitIOInfo));
pSCEnc->pIOHeader = (BitIOInfo *)((U8 *)ALIGNUP(pIOHeaderEnc, PACKETLENGTH * 4) + PACKETLENGTH * 2);
for(i = 0; i < pSCEnc->m_param.cNumChannels; i ++)
pSCEnc->pPlane[i] = pSCDec->p1MBbuffer[i];
for(i = 1; i < pSCDec->cNumBitIO * (pSCDec->WMISCP.cNumOfSliceMinus1H + 1); i ++){
if(pSCDec->pIndexTable[i] == 0 && i + 1 != pSCDec->cNumBitIO * (pSCDec->WMISCP.cNumOfSliceMinus1H + 1)) // empty packet
pSCDec->pIndexTable[i] = pSCDec->pIndexTable[i + 1];
if(pSCDec->pIndexTable[i] != 0 && pSCDec->pIndexTable[i] < pSCDec->pIndexTable[i - 1]) // out of order bitstream, can not do fast tile extraction!
pParam->bIgnoreOverlap = FALSE;
}
if(getROI(&pSCEnc->WMII, &pSCEnc->m_param, &pSCEnc->WMISCP, pParam) != ICERR_OK)
return ICERR_ERROR;
mbLeft = (pParam->cLeftX >> 4);
mbRight = ((pParam->cLeftX + pParam->cWidth + 15) >> 4);
mbTop = (pParam->cTopY >> 4);
mbBottom = ((pParam->cTopY + pParam->cHeight + 15) >> 4);
if(pSCDec->WMISCP.uiTileX[pSCDec->WMISCP.cNumOfSliceMinus1V] >= mbLeft && pSCDec->WMISCP.uiTileX[pSCDec->WMISCP.cNumOfSliceMinus1V] <= mbRight &&
pSCDec->WMISCP.uiTileY[pSCDec->WMISCP.cNumOfSliceMinus1H] >= mbTop && pSCDec->WMISCP.uiTileY[pSCDec->WMISCP.cNumOfSliceMinus1H] <= mbBottom)
pParam->bIgnoreOverlap = FALSE;
pSCEnc->bTileExtraction = pParam->bIgnoreOverlap;
mbWidth = pSCEnc->cmbWidth = mbRight - mbLeft;
mbHeight = pSCEnc->cmbHeight = mbBottom - mbTop;
if(oO >= O_RCW){
SWAP(pSCEnc->WMII.cWidth, pSCEnc->WMII.cHeight);
SWAP(pSCEnc->cmbWidth, pSCEnc->cmbHeight);
}
if(oO != O_NONE){
pFrameBuf = (PixelI *)malloc(pSCEnc->cmbWidth * pSCEnc->cmbHeight * cUnit * sizeof(PixelI));
if(pFrameBuf == NULL || (pSCEnc->cmbWidth * pSCEnc->cmbHeight * cUnit * sizeof(PixelI) < pSCEnc->cmbWidth * pSCEnc->cmbHeight * cUnit))
return ICERR_ERROR;
pMBInfo = (CWMIMBInfo *)malloc(pSCEnc->cmbWidth * pSCEnc->cmbHeight * sizeof(CWMIMBInfo));
if(pMBInfo == NULL || (pSCEnc->cmbWidth * pSCEnc->cmbHeight * sizeof(CWMIMBInfo) < pSCEnc->cmbWidth * pSCEnc->cmbHeight))
return ICERR_ERROR;
if(pParam->uAlphaMode > 0){ // alpha channel
pFrameBufAlpha = (PixelI *)malloc(pSCEnc->cmbWidth * pSCEnc->cmbHeight * 256 * sizeof(PixelI));
if(pFrameBufAlpha == NULL || (pSCEnc->cmbWidth * pSCEnc->cmbHeight * 256 * sizeof(PixelI) < pSCEnc->cmbWidth * pSCEnc->cmbHeight * 256))
return ICERR_ERROR;
pMBInfoAlpha = (CWMIMBInfo *)malloc(pSCEnc->cmbWidth * pSCEnc->cmbHeight * sizeof(CWMIMBInfo));
if(pMBInfoAlpha == NULL || (pSCEnc->cmbWidth * pSCEnc->cmbHeight * sizeof(CWMIMBInfo) < pSCEnc->cmbWidth * pSCEnc->cmbHeight))
return ICERR_ERROR;
}
}
if(oO < O_RCW && pSCEnc->WMII.oOrientation < O_RCW)
pSCEnc->WMII.oOrientation ^= oO;
else if(oO >= O_RCW && pSCEnc->WMII.oOrientation >= O_RCW){
pSCEnc->WMII.oOrientation ^= oO;
pSCEnc->WMII.oOrientation = (pSCEnc->WMII.oOrientation & 1) * 2 + (pSCEnc->WMII.oOrientation >> 1);
}
else if(oO >= O_RCW && pSCEnc->WMII.oOrientation < O_RCW)
pSCEnc->WMII.oOrientation = oO ^ ((pSCEnc->WMII.oOrientation & 1) * 2 + (pSCEnc->WMII.oOrientation >> 1));
else
pSCEnc->WMII.oOrientation ^= ((oO & 1) * 2 + (oO >> 1));
// pSCEnc->WMISCP.nExpBias += 128;
if(pParam->bIgnoreOverlap == TRUE){
attachISWrite(pSCEnc->pIOHeader, pSCEnc->WMISCP.pWStream);
pSCEnc->pTile = pSCDec->pTile;
if(pSCEnc->WMISCP.cNumOfSliceMinus1H + pSCEnc->WMISCP.cNumOfSliceMinus1V == 0 && pSCEnc->WMISCP.bfBitstreamFormat == SPATIAL)
pSCEnc->m_param.bIndexTable = FALSE;
WriteWMIHeader(pSCEnc);
}
else{
pTileQPInfo = (CTileQPInfo *)malloc((oO == O_NONE ? 1 : (pSCEnc->WMISCP.cNumOfSliceMinus1H + 1) * (pSCEnc->WMISCP.cNumOfSliceMinus1V + 1)) * sizeof( CTileQPInfo));
if(pTileQPInfo == NULL || ((oO == O_NONE ? 1 : (pSCEnc->WMISCP.cNumOfSliceMinus1H + 1) * (pSCEnc->WMISCP.cNumOfSliceMinus1V + 1)) * sizeof( CTileQPInfo) < (oO == O_NONE ? 1 : (pSCEnc->WMISCP.cNumOfSliceMinus1H + 1) * (pSCEnc->WMISCP.cNumOfSliceMinus1V + 1))))
return ICERR_ERROR;
if(StrEncInit(pSCEnc) != ICERR_OK)
return ICERR_ERROR;
}
if(pParam->uAlphaMode > 0){ // alpha channel
// pSCEnc->WMISCP.nExpBias -= 128;
if((pSCEnc->m_pNextSC = (CWMImageStrCodec *)malloc(sizeof(CWMImageStrCodec))) == NULL)
return ICERR_ERROR;
*pSCEnc->m_pNextSC = *pSCEnc;
pSCEnc->m_pNextSC->pPlane[0] = pSCDec->m_pNextSC->p1MBbuffer[0];
pSCEnc->m_pNextSC->WMISCP.cfColorFormat = pSCEnc->m_pNextSC->WMII.cfColorFormat = pSCEnc->m_pNextSC->m_param.cfColorFormat = Y_ONLY;
pSCEnc->m_pNextSC->WMISCP.cChannel = pSCEnc->m_pNextSC->m_param.cNumChannels = 1;
pSCEnc->m_pNextSC->m_bSecondary = TRUE;
pSCEnc->m_pNextSC->m_pNextSC = pSCEnc;
pSCEnc->m_pNextSC->m_param = pSCDec->m_pNextSC->m_param;
pSCEnc->m_param.bAlphaChannel = TRUE;
if(pParam->bIgnoreOverlap == TRUE)
pSCEnc->m_pNextSC->pTile = pSCDec->m_pNextSC->pTile;
else if(StrEncInit(pSCEnc->m_pNextSC) != ICERR_OK)
return ICERR_ERROR;
WriteImagePlaneHeader(pSCEnc->m_pNextSC);
}
if(pParam->bIgnoreOverlap == TRUE){
SUBBAND sbEnc = pSCEnc->WMISCP.sbSubband, sbDec = pSCDec->WMISCP.sbSubband;
size_t cfEnc = ((pSCEnc->WMISCP.bfBitstreamFormat == SPATIAL || sbEnc == SB_DC_ONLY) ? 1 : (sbEnc == SB_NO_HIGHPASS ? 2 : (sbEnc == SB_NO_FLEXBITS ? 3 : 4)));
size_t cfDec = ((pSCDec->WMISCP.bfBitstreamFormat == SPATIAL || sbDec == SB_DC_ONLY) ? 1 : (sbDec == SB_NO_HIGHPASS ? 2 : (sbDec == SB_NO_FLEXBITS ? 3 : 4)));
size_t k, l = 0;
pSCEnc->pIndexTable = (size_t *)malloc(sizeof(size_t) * (pSCEnc->WMISCP.cNumOfSliceMinus1H + 1) * (pSCEnc->WMISCP.cNumOfSliceMinus1V + 1) * cfEnc);
if(pSCEnc->pIndexTable == NULL || cfEnc > cfDec)
return ICERR_ERROR;
pSCEnc->cNumBitIO = cfEnc * (pSCEnc->WMISCP.cNumOfSliceMinus1V + 1);
for(j = 0; j <= pSCDec->WMISCP.cNumOfSliceMinus1H; j ++){
for(i = 0; i <= pSCDec->WMISCP.cNumOfSliceMinus1V; i ++)
if(pSCDec->WMISCP.uiTileX[i] >= mbLeft && pSCDec->WMISCP.uiTileX[i] < mbRight &&
pSCDec->WMISCP.uiTileY[j] >= mbTop && pSCDec->WMISCP.uiTileY[j] < mbBottom){
for(k = 0; k < cfEnc; k ++, l ++)
pSCEnc->pIndexTable[l] = pSCDec->pIndexTable[(j * (pSCDec->WMISCP.cNumOfSliceMinus1V + 1) + i) * cfDec + k + 1] - pSCDec->pIndexTable[(j * (pSCDec->WMISCP.cNumOfSliceMinus1V + 1) + i) * cfDec + k];
}
}
if(pSCEnc->WMISCP.cNumOfSliceMinus1H + pSCEnc->WMISCP.cNumOfSliceMinus1V == 0 && pSCEnc->WMISCP.bfBitstreamFormat == SPATIAL){
pSCEnc->m_param.bIndexTable = FALSE;
pSCEnc->cNumBitIO = 0;
writeIndexTableNull(pSCEnc);
}
else
writeIndexTable(pSCEnc);
detachISWrite(pSCEnc, pSCEnc->pIOHeader);
for(j = l = 0; j <= pSCDec->WMISCP.cNumOfSliceMinus1H; j ++){
for(i = 0; i <= pSCDec->WMISCP.cNumOfSliceMinus1V; i ++)
if(pSCDec->WMISCP.uiTileX[i] >= mbLeft && pSCDec->WMISCP.uiTileX[i] < mbRight &&
pSCDec->WMISCP.uiTileY[j] >= mbTop && pSCDec->WMISCP.uiTileY[j] < mbBottom){
for(k = 0; k < cfEnc; k ++){
pSCDec->WMISCP.pWStream->SetPos(pSCDec->WMISCP.pWStream, pSCDec->pIndexTable[(j * (pSCDec->WMISCP.cNumOfSliceMinus1V + 1) + i) * cfDec + k] + pSCDec->cHeaderSize);
copyTo(pSCDec->WMISCP.pWStream, pSCEnc->WMISCP.pWStream, pSCEnc->pIndexTable[l++]);
}
}
}
free(pSCEnc->pIndexTable);
}
else
writeIndexTableNull(pSCEnc);
for(pSCDec->cRow = 0; pSCDec->cRow < mbBottom && pParam->bIgnoreOverlap == FALSE; pSCDec->cRow ++){
for(pSCDec->cColumn = 0; pSCDec->cColumn < pSCDec->cmbWidth; pSCDec->cColumn ++){
Int cRow = (Int)pSCDec->cRow, cColumn = (Int)pSCDec->cColumn;
CWMITile * pTile;
memset(pMBBuf, 0, sizeof(PixelI) * cUnit);
if(pSCDec->m_param.bAlphaChannel){ // alpha channel
memset(pSCDec->m_pNextSC->p1MBbuffer[0], 0, sizeof(PixelI) * 256);
pSCDec->m_pNextSC->cRow = pSCDec->cRow;
pSCDec->m_pNextSC->cColumn = pSCDec->cColumn;
}
// decode
pSC = pSCDec;
for(i = (pSCDec->m_param.bAlphaChannel ? 2 : 1); i > 0; i --){
getTilePos(pSCDec, cColumn, cRow);
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;
if(pSCDec->cRow >= mbTop && pSCDec->cColumn >= mbLeft && pSCDec->cColumn < mbRight){
cRow = (Int)(pSCDec->cRow - mbTop);
if(bFlipV[oO])
cRow = (Int)mbHeight - cRow - 1;
cColumn = (Int)(pSCDec->cColumn - mbLeft);
if(bFlipH[oO])
cColumn = (Int)mbWidth - cColumn - 1;
pSCEnc->m_bCtxLeft = pSCEnc->m_bCtxTop = FALSE;
for(i = 0; i <= pSCEnc->WMISCP.cNumOfSliceMinus1H; i ++)
if(pSCEnc->WMISCP.uiTileY[i] == (U32)(oO < O_RCW ? cRow : cColumn)){
pSCEnc->cTileRow = i;
pSCEnc->m_bCtxTop = TRUE;
break;
}
for(i = 0; i <= pSCEnc->WMISCP.cNumOfSliceMinus1V; i ++)
if(pSCEnc->WMISCP.uiTileX[i] == (U32)(oO < O_RCW ? cColumn : cRow)){
pSCEnc->cTileColumn = i;
pSCEnc->m_bCtxLeft = TRUE;
break;
}
if(pSCEnc->m_bCtxLeft && pSCEnc->m_bCtxTop){ // a new tile, buffer tile DQuant info
CTileQPInfo * pTmp = pTileQPInfo;
pTile = pSCDec->pTile + pSCDec->cTileColumn;
if(oO != O_NONE)
pTmp += pSCEnc->cTileRow * (pSCEnc->WMISCP.cNumOfSliceMinus1V + 1) + pSCEnc->cTileColumn;
pTmp->dcMode = pTile->cChModeDC;
for(i = 0; i < pSCEnc->WMISCP.cChannel; i ++)
pTmp->dcIndex[i] = pTile->pQuantizerDC[i][0].iIndex;
if(pSCEnc->WMISCP.sbSubband != SB_DC_ONLY){
pTmp->bUseDC = pTile->bUseDC;
pTmp->lpNum = pTile->cNumQPLP;
if(pTmp->bUseDC == FALSE)
for(j = 0; j < pTmp->lpNum; j ++){
pTmp->lpMode[j] = pTile->cChModeLP[j];
for(i = 0; i < pSCEnc->WMISCP.cChannel; i ++)
pTmp->lpIndex[j][i] = pTile->pQuantizerLP[i][j].iIndex;
}
if(pSCEnc->WMISCP.sbSubband != SB_NO_HIGHPASS){
pTmp->bUseLP = pTile->bUseLP;
pTmp->hpNum = pTile->cNumQPHP;
if(pTmp->bUseLP == FALSE)
for(j = 0; j < pTmp->hpNum; j ++){
pTmp->hpMode[j] = pTile->cChModeHP[j];
for(i = 0; i < pSCEnc->WMISCP.cChannel; i ++)
pTmp->hpIndex[j][i] = pTile->pQuantizerHP[i][j].iIndex;
}
}
}
if(pParam->uAlphaMode > 0){
pTile = pSCDec->m_pNextSC->pTile + pSCDec->cTileColumn;
pTmp->dcIndex[iAlphaPos] = pTile->pQuantizerDC[0][0].iIndex;
if(pSCEnc->WMISCP.sbSubband != SB_DC_ONLY){
pTmp->bUseDCAlpha = pTile->bUseDC;
pTmp->lpNumAlpha = pTile->cNumQPLP;
if(pTmp->bUseDCAlpha == FALSE)
for(j = 0; j < pTmp->lpNumAlpha; j ++)
pTmp->lpIndex[j][iAlphaPos] = pTile->pQuantizerLP[0][j].iIndex;
if(pSCEnc->WMISCP.sbSubband != SB_NO_HIGHPASS){
pTmp->bUseLPAlpha = pTile->bUseLP;
pTmp->hpNumAlpha = pTile->cNumQPHP;
if(pTmp->bUseLPAlpha == FALSE)
for(j = 0; j < pTmp->hpNumAlpha; j ++)
pTmp->hpIndex[j][iAlphaPos] = pTile->pQuantizerHP[0][j].iIndex;
}
}
}
}
if(oO == O_NONE){
// encode
pSCEnc->cColumn = pSCDec->cColumn - mbLeft + 1;
pSCEnc->cRow = pSCDec->cRow + 1 - mbTop;
pSCEnc->MBInfo = pSCDec->MBInfo;
getTilePos(pSCEnc, cColumn, cRow);
if(pSCEnc->m_bCtxLeft && pSCEnc->m_bCtxTop)
transcodeTileHeader(pSCEnc, pTileQPInfo);
encodeMB(pSCEnc, cColumn, cRow);
if(pParam->uAlphaMode > 0){
pSCEnc->m_pNextSC->cColumn = pSCDec->cColumn - mbLeft + 1;
pSCEnc->m_pNextSC->cRow = pSCDec->cRow + 1 - mbTop;
getTilePos(pSCEnc->m_pNextSC, cColumn, cRow);
pSCEnc->m_pNextSC->MBInfo = pSCDec->m_pNextSC->MBInfo;
encodeMB(pSCEnc->m_pNextSC, cColumn, cRow);
}
}
else{
size_t cOff = (oO < O_RCW ? (size_t)cRow * mbWidth + (size_t)cColumn : (size_t)cRow + mbHeight * (size_t)cColumn);
pMBInfo[cOff] = pSCDec->MBInfo;
memcpy(&pFrameBuf[cOff * cUnit], pMBBuf, cUnit * sizeof(PixelI));
if(pParam->uAlphaMode > 0){
pMBInfoAlpha[cOff] = pSCDec->m_pNextSC->MBInfo;
memcpy(&pFrameBufAlpha[cOff * 256], MBBufAlpha, 256 * sizeof(PixelI));
}
}
}
}
advanceOneMBRow(pSCDec);
if(oO == O_NONE)
advanceOneMBRow(pSCEnc);
}
if(oO != O_NONE){
for(pSCEnc->cRow = 1; pSCEnc->cRow <= pSCEnc->cmbHeight; pSCEnc->cRow ++){
for(pSCEnc->cColumn = 1; pSCEnc->cColumn <= pSCEnc->cmbWidth; pSCEnc->cColumn ++){
Int cRow, cColumn;
size_t cOff = (pSCEnc->cRow - 1) * pSCEnc->cmbWidth + pSCEnc->cColumn - 1;
for(i = 0; i < ((pSCEnc->m_param.cfColorFormat == YUV_420 || pSCEnc->m_param.cfColorFormat == YUV_422) ? 1 : pSCEnc->m_param.cNumChannels); i ++){
transformDCBlock(pMBInfo[cOff].iBlockDC[i], pSCEnc->MBInfo.iBlockDC[i], oO);
transformACBlocks(pFrameBuf + cOff * cUnit + i * 256, pMBBuf + 256 * i, oO);
}
if(pSCEnc->WMISCP.cfColorFormat == YUV_420)
for(i = 0; i < 2; i ++){
transformDCBlock420(pMBInfo[cOff].iBlockDC[i + 1], pSCEnc->MBInfo.iBlockDC[i + 1], oO);
transformACBlocks420(pFrameBuf + cOff * cUnit + 256 + i * 64, pMBBuf + 256 + i * 64, oO);
}
else if(pSCEnc->WMISCP.cfColorFormat == YUV_422)
for(i = 0; i < 2; i ++){
transformDCBlock422(pMBInfo[cOff].iBlockDC[i + 1], pSCEnc->MBInfo.iBlockDC[i + 1], oO);
transformACBlocks422(pFrameBuf + cOff * cUnit + 256 + i * 128, pMBBuf + 256 + i * 128, oO);
}
pSCEnc->MBInfo.iQIndexLP = pMBInfo[cOff].iQIndexLP;
pSCEnc->MBInfo.iQIndexHP = pMBInfo[cOff].iQIndexHP;
cRow = (Int)pSCEnc->cRow - 1;
cColumn = (Int)pSCEnc->cColumn - 1;
getTilePos(pSCEnc, cColumn, cRow);
if(pSCEnc->m_bCtxLeft && pSCEnc->m_bCtxTop)
transcodeTileHeader(pSCEnc, pTileQPInfo + pSCEnc->cTileRow * (pSCEnc->WMISCP.cNumOfSliceMinus1V + 1) + pSCEnc->cTileColumn);
encodeMB(pSCEnc, cColumn, cRow);
if(pParam->uAlphaMode > 0){
pSCEnc->m_pNextSC->cColumn = pSCEnc->cColumn;
pSCEnc->m_pNextSC->cRow = pSCEnc->cRow;
getTilePos(pSCEnc->m_pNextSC, cColumn, cRow);
pSCEnc->m_pNextSC->MBInfo = pSCDec->m_pNextSC->MBInfo;
transformDCBlock(pMBInfoAlpha[cOff].iBlockDC[0], pSCEnc->m_pNextSC->MBInfo.iBlockDC[0], oO);
transformACBlocks(pFrameBufAlpha + cOff * 256, MBBufAlpha, oO);
pSCEnc->m_pNextSC->MBInfo.iQIndexLP = pMBInfoAlpha[cOff].iQIndexLP;
pSCEnc->m_pNextSC->MBInfo.iQIndexHP = pMBInfoAlpha[cOff].iQIndexHP;
encodeMB(pSCEnc->m_pNextSC, cColumn, cRow);
}
}
advanceOneMBRow(pSCEnc);
}
}
free(pMBBuf);
if(oO != O_NONE){
free(pFrameBuf);
free(pMBInfo);
if(pParam->uAlphaMode > 0){ // alpha channel
free(pFrameBufAlpha);
free(pMBInfoAlpha);
}
}
freePredInfo(pSCDec);
freeTileInfo(pSCDec);
StrIODecTerm(pSCDec);
FreeCodingContextDec(pSCDec);
if(pSCDec->m_param.bAlphaChannel)
free(pSCDec->m_pNextSC);
free(pSCDec);
free(pIOHeaderDec);
if(pParam->bIgnoreOverlap == FALSE){
freePredInfo(pSCEnc);
freeTileInfo(pSCEnc);
StrIOEncTerm(pSCEnc);
free(pTileQPInfo);
FreeCodingContextEnc(pSCEnc);
}
free(pSCEnc);
free(pIOHeaderEnc);
return ICERR_OK;
}

200
jxrlib/image/decode/decode.c
View file

@ -1,200 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
/******************************************************************************
Module Name:
decode.c
Abstract:
Defines the entry point for the console application.
Author:
Revision History:
*******************************************************************************/
#include "strcodec.h"
#include "decode.h"
#ifdef MEM_TRACE
#define TRACE_MALLOC 1
#define TRACE_NEW 0
#define TRACE_HEAP 0
#include "memtrace.h"
#endif
/******************************************************************
Free Adaptive Huffman Table
******************************************************************/
static Void CleanAH(CAdaptiveHuffman **ppAdHuff)
{
CAdaptiveHuffman *pAdHuff;
if (NULL != ppAdHuff) {
pAdHuff = *ppAdHuff;
if (NULL != pAdHuff) {
free(pAdHuff);
}
*ppAdHuff = NULL;
}
}
static Void CleanAHDec(CCodingContext * pSC)
{
Int kk;
for (kk = 0; kk < NUMVLCTABLES; kk++) {
CleanAH(&(pSC->m_pAHexpt[kk]));
}
CleanAH(&(pSC->m_pAdaptHuffCBPCY));
CleanAH(&(pSC->m_pAdaptHuffCBPCY1));
}
/*************************************************************************
Initialize an adaptive huffman table
*************************************************************************/
static Int InitializeAH(CAdaptiveHuffman **ppAdHuff, Int iSym)
{
Int iMemStatus = 0;
CAdaptiveHuffman *pAdHuff = Allocate(iSym, DECODER);
if (pAdHuff == NULL) {
iMemStatus = -1; // out of memory
goto ErrorExit;
}
//Adapt(pAdHuff, bFixedTables);
//InitHuffman(pAdHuff->m_pHuffman);
//if (ICERR_OK != initHuff(pAdHuff->m_pHuffman, 1, pAdHuff->m_pTable, NULL)) {
// goto ErrorExit;
//}
*ppAdHuff = pAdHuff;
return ICERR_OK;
ErrorExit:
if (pAdHuff) {
free(pAdHuff);
}
*ppAdHuff = NULL;
if (-1 == iMemStatus) {
printf("Insufficient memory to init decoder.\n");
}
return ICERR_ERROR;
}
/*************************************************************************
Context allocation
*************************************************************************/
Int AllocateCodingContextDec(CWMImageStrCodec *pSC, Int iNumContexts)
{
Int i, iCBPSize, k;
static const Int aAlphabet[] = {5,4,8,7,7, 12,6,6,12,6,6,7,7, 12,6,6,12,6,6,7,7};
if (iNumContexts > MAX_TILES || iNumContexts < 1) // only between 1 and MAX_TILES allowed
return ICERR_ERROR;
if (pSC == NULL)
return ICERR_ERROR;
pSC->m_pCodingContext = malloc (iNumContexts * sizeof (CCodingContext));
if (pSC->m_pCodingContext == NULL) {
pSC->cNumCodingContext = 0;
return ICERR_ERROR;
}
memset (pSC->m_pCodingContext, 0, iNumContexts * sizeof (CCodingContext));
pSC->cNumCodingContext = iNumContexts;
iCBPSize = (pSC->m_param.cfColorFormat == Y_ONLY || pSC->m_param.cfColorFormat == NCOMPONENT
|| pSC->m_param.cfColorFormat == CMYK) ? 5 : 9;
/** allocate / initialize members **/
for (i = 0; i < iNumContexts; i++) {
CCodingContext *pContext = &(pSC->m_pCodingContext[i]);
/** allocate adaptive Huffman encoder **/
if (InitializeAH(&pContext->m_pAdaptHuffCBPCY, iCBPSize) != ICERR_OK) {
return ICERR_ERROR;
}
if (InitializeAH(&pContext->m_pAdaptHuffCBPCY1, 5) != ICERR_OK) {
return ICERR_ERROR;
}
for(k = 0; k < NUMVLCTABLES; k ++){
if (InitializeAH(&pContext->m_pAHexpt[k], aAlphabet[k]) != ICERR_OK) {
return ICERR_ERROR;
}
}
ResetCodingContextDec(pContext);
}
return ICERR_OK;
}
/*************************************************************************
Context reset on encoder
*************************************************************************/
Void ResetCodingContextDec(CCodingContext *pContext)
{
Int k;
/** set flags **/
pContext->m_pAdaptHuffCBPCY->m_bInitialize = FALSE;
pContext->m_pAdaptHuffCBPCY1->m_bInitialize = FALSE;
for(k = 0; k < NUMVLCTABLES; k ++)
pContext->m_pAHexpt[k]->m_bInitialize = FALSE;
// reset VLC tables
AdaptLowpassDec (pContext);
AdaptHighpassDec (pContext);
// reset zigzag patterns, totals
InitZigzagScan(pContext);
// reset bit reduction and cbp models
ResetCodingContext(pContext);
}
/*************************************************************************
Context deletion
*************************************************************************/
Void FreeCodingContextDec(CWMImageStrCodec *pSC)
{
Int iContexts = (Int)(pSC->cNumCodingContext), i, k;
if (iContexts > 0 && pSC->m_pCodingContext) {
for (i = 0; i < iContexts; i++) {
CCodingContext *pContext = &(pSC->m_pCodingContext[i]);
CleanAH (&pContext->m_pAdaptHuffCBPCY);
CleanAH (&pContext->m_pAdaptHuffCBPCY1);
for (k = 0; k < NUMVLCTABLES; k++)
CleanAH (&pContext->m_pAHexpt[k]);
}
free (pSC->m_pCodingContext);
}
}

143
jxrlib/image/decode/decode.h
View file

@ -1,143 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#ifndef WMI_DECODE_H
#define WMI_DECODE_H
typedef struct CWMDecoderParameters {
/** ROI decode **/
Bool bDecodeFullFrame;
Bool bDecodeFullWidth;
/** thumbnail decode **/
Bool bSkipFlexbits;
size_t cThumbnailScale; // 1: cThumbnailScale thumbnail, only supports cThumbnailScale = 2^m for now
Bool bDecodeHP;
Bool bDecodeLP;
// Region of interest decoding
size_t cROILeftX;
size_t cROIRightX;
size_t cROITopY;
size_t cROIBottomY;
// 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)
Void strPost2(PixelI *, PixelI *);
// 2x2 post filter (only used in 420 UV DC subband)
Void strPost2x2(PixelI *, PixelI *, PixelI *, PixelI *);
/** 4-point post filter for boundaries **/
Void strPost4(PixelI *, PixelI *, PixelI *, PixelI *);
/** data allocation in working buffer (first stage) **/
/** Y, 444 U and V **/
/** 0 1 2 3 **/
/** 32 33 34 35 **/
/** 64 65 66 67 **/
/** 96 97 98 99 **/
/** 420 U and V **/
/** 0 2 4 6 **/
/** 64 66 68 70 **/
/** 128 130 132 134 **/
/** 192 194 196 198 **/
/** 4x4 inverse DCT for first stage **/
Void strIDCT4x4FirstStage(PixelI *);
Void strIDCT4x4Stage1(PixelI*);
Void strIDCT4x4FirstStage420UV(PixelI *);
/** 4x4 post filter for first stage **/
Void strPost4x4FirstStage(PixelI *);
Void strPost4x4Stage1Split(PixelI*, PixelI*, Int, Int, Bool);
Void strPost4x4Stage1(PixelI*, Int, Int, Bool);
Void strPost4x4Stage1Split_alternate(PixelI*, PixelI*, Int);
Void strPost4x4Stage1_alternate(PixelI*, Int);
//Void strPost4x4Stage1Split_420(PixelI*, PixelI*);
//Void strPost4x4Stage1_420(PixelI*);
Void strPost4x4FirstStage420UV(PixelI *);
/** data allocation in working buffer (second stage)**/
/** Y, 444 U and V **/
/** 0 4 8 12 **/
/** 128 132 136 140 **/
/** 256 260 264 268 **/
/** 384 388 392 396 **/
/** 420 U and V **/
/** 0 8 **/
/** 256 264 **/
/** 4x4 invesr DCT for second stage **/
//Void strIDCT4x4SecondStage(PixelI *);
Void strIDCT4x4Stage2(PixelI*);
Void strNormalizeDec(PixelI*, Bool);
Void strDCT2x2dnDec(PixelI *, PixelI *, PixelI *, PixelI *);
/** 4x4 post filter for second stage **/
Void strPost4x4SecondStage(PixelI *);
Void strPost4x4Stage2Split(PixelI*, PixelI*);
Void strPost4x4Stage2Split_alternate(PixelI*, PixelI*);
/** Huffman decode related defines **/
#define HUFFMAN_DECODE_ROOT_BITS_LOG 3
#define HUFFMAN_DECODE_ROOT_BITS (5)
Int getHuff(const short *pDecodeTable, BitIOInfo* pIO);
#endif // WMI_DECODE_H

288
jxrlib/image/decode/postprocess.c
View file

@ -1,288 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#include "windowsmediaphoto.h"
#include "strcodec.h"
Void smoothMB(PixelI * p1, PixelI * p0, PixelI * q0, PixelI * q1)
{
// p1 p0 | q0 q1
PixelI delta = ((((*q0 - *p0) << 2) + (*p1 - *q1)) >> 3);
*q0 -= delta;
*p0 += delta;
}
Void smooth(PixelI * p2, PixelI * p1, PixelI * p0, PixelI * q0, PixelI * q1, PixelI * q2)
{
// p2 p1 p0 | q0 q1 q2
PixelI delta = ((((*q0 - *p0) << 2) + (*p1 - *q1)) >> 3);
*q0 -= delta;
*p0 += delta;
*p1 = (*p1 >> 1) + ((*p0 + *p2) >> 2);
*q1 = (*q1 >> 1) + ((*q0 + *q2) >> 2);
}
Int initPostProc(struct tagPostProcInfo * strPostProcInfo[MAX_CHANNELS][2], size_t mbWidth, size_t iNumChannels)
{
size_t i, j, k, l;
Bool b32bit = sizeof(int) == 4;
for(j = 0; j < iNumChannels; j ++){
for(i = 0; i < 2; i ++){
// 2 more are allocated to avoid boundary check
if(b32bit) // integer overlow/underflow check for 32-bit system
if((((mbWidth + 2) >> 16) * sizeof(struct tagPostProcInfo)) & 0xffff0000)
return ICERR_ERROR;
strPostProcInfo[j][i] = (struct tagPostProcInfo *)malloc((mbWidth + 2) * sizeof(struct tagPostProcInfo));
assert(strPostProcInfo[j][i] != NULL);
if(strPostProcInfo[j][i] == NULL){
return ICERR_ERROR;
}
strPostProcInfo[j][i] ++;
// initialize out-of-bound MBs as bumpy (no post at all) to avoid boundary check
// left boundary
strPostProcInfo[j][i][-1].ucMBTexture = 3;
for(l = 0; l < 4; l ++){
for(k = 0; k < 4; k ++){
strPostProcInfo[j][i][-1].ucBlockTexture[l][k] = 3;
}
}
// right boundary
strPostProcInfo[j][i][mbWidth] = strPostProcInfo[j][i][-1];
}
}
return ICERR_OK;
}
Void termPostProc(struct tagPostProcInfo * strPostProcInfo[MAX_CHANNELS][2], size_t iNumChannels)
{
size_t i, j;
for(j = 0; j < iNumChannels; j ++){
for(i = 0; i < 2; i ++){
if(strPostProcInfo[j][i] != NULL){
free(strPostProcInfo[j][i] - 1);
}
}
}
}
Void slideOneMBRow(struct tagPostProcInfo * strPostProcInfo[MAX_CHANNELS][2], size_t iNumChannels, size_t mbWidth, Bool top, Bool bottom)
{
size_t i, j;
struct tagPostProcInfo * bar;
for(i = 0; i < iNumChannels; i ++){
// swap previous row and current row
bar = strPostProcInfo[i][0];
strPostProcInfo[i][0] = strPostProcInfo[i][1];
strPostProcInfo[i][1] = bar;
if(top){ // if top row, previous row is out of boundary
for(j = 0; j < mbWidth; j ++){
strPostProcInfo[i][0][j] = strPostProcInfo[i][0][-1]; // set as bumpy
}
}
if(bottom){ // if bottom bottom row, set current row of MBs (out of boundary) as bumpy
for(j = 0; j < mbWidth; j ++){
strPostProcInfo[i][1][j] = strPostProcInfo[i][1][-1]; // set as bumpy
}
}
}
}
// get DC and texture infomation right before transform
Void updatePostProcInfo(struct tagPostProcInfo * strPostProcInfo[MAX_CHANNELS][2], PixelI * pMB, size_t mbX, size_t cc)
{
size_t i, j;
struct tagPostProcInfo * pMBInfo = strPostProcInfo[cc][1] + mbX;
// DC of MB
pMBInfo->iMBDC = pMB[0];
// texture of MB
pMBInfo->ucMBTexture = 0; // smooth
for(i = 16; i < 256; i += 16){
if(pMB[i] != 0){
pMBInfo->ucMBTexture = 3; // bumpy
break;
}
}
// DCs of blocks not available yet, will collect after demacroblocking
// textures of blocks
for(j = 0; j < 4; j ++)
for(i = 0; i < 4; i ++){
PixelI * p = pMB + i * 64 + j * 16;
size_t k;
for(k = 1, pMBInfo->ucBlockTexture[j][i] = 0; k < 16; k ++){
if(p[k] != 0){
pMBInfo->ucBlockTexture[j][i] = 3;
break;
}
}
}
}
// demacroblock critirion: two MBs have same texture other than bumpy and DCs differ less than 1
#define DMB(a, b) (a->ucMBTexture + b->ucMBTexture == 0) && (abs(a->iMBDC - b->iMBDC) <= threshold)
// demacroblock and get DCs of blocks
Void postProcMB(struct tagPostProcInfo * strPostProcInfo[MAX_CHANNELS][2], PixelI * p0, PixelI * p1, size_t mbX, size_t cc, Int threshold)
{
/* 4 MBs involved, current MB is d, we have 4 2-pixel boundary segments */
/* | */
/* a | b */
/* - - + + */
/* c ! d */
/* ! */
struct tagPostProcInfo * pMBb = strPostProcInfo[cc][0] + mbX, * pMBa = pMBb - 1, * pMBd = strPostProcInfo[cc][1] + mbX, * pMBc = pMBd - 1;
// demacroblock segment --
if(DMB(pMBa, pMBc)){
smoothMB(p0 - 256 + 10 * 16, p0 - 256 + 11 * 16, p1 - 256 + 8 * 16, p1 - 256 + 9 * 16);
smoothMB(p0 - 256 + 14 * 16, p0 - 256 + 15 * 16, p1 - 256 + 12 * 16, p1 - 256 + 13 * 16);
}
// demacroblock segment ++
if(DMB(pMBb, pMBd)){
smoothMB(p0 + 2 * 16, p0 + 3 * 16, p1 + 0 * 16, p1 + 1 * 16);
smoothMB(p0 + 6 * 16, p0 + 7 * 16, p1 + 4 * 16, p1 + 5 * 16);
}
// demacroblock segment |
if(DMB(pMBa, pMBb)){
smoothMB(p0 - 256 + 10 * 16, p0 - 256 + 14 * 16, p0 + 2 * 16, p0 + 6 * 16);
smoothMB(p0 - 256 + 11 * 16, p0 - 256 + 15 * 16, p0 + 3 * 16, p0 + 7 * 16);
}
// demacroblock segment !
if(DMB(pMBc, pMBd)){
smoothMB(p1 - 256 + 8 * 16, p1 - 256 + 12 * 16, p1 + 0 * 16, p1 + 4 * 16);
smoothMB(p1 - 256 + 9 * 16, p1 - 256 + 13 * 16, p1 + 1 * 16, p1 + 5 * 16);
}
/* update DCs of blocks */
// MB d
pMBd->iBlockDC[0][0] = p1[0 * 16];
pMBd->iBlockDC[0][1] = p1[4 * 16];
pMBd->iBlockDC[1][0] = p1[1 * 16];
pMBd->iBlockDC[1][1] = p1[5 * 16];
// MB b
pMBb->iBlockDC[2][0] = p0[2 * 16];
pMBb->iBlockDC[2][1] = p0[6 * 16];
pMBb->iBlockDC[3][0] = p0[3 * 16];
pMBb->iBlockDC[3][1] = p0[7 * 16];
// MB c
pMBc->iBlockDC[0][2] = p1[ 8 * 16 - 256];
pMBc->iBlockDC[0][3] = p1[12 * 16 - 256];
pMBc->iBlockDC[1][2] = p1[ 9 * 16 - 256];
pMBc->iBlockDC[1][3] = p1[13 * 16 - 256];
// MB a
pMBa->iBlockDC[2][2] = p0[10 * 16 - 256];
pMBa->iBlockDC[2][3] = p0[14 * 16 - 256];
pMBa->iBlockDC[3][2] = p0[11 * 16 - 256];
pMBa->iBlockDC[3][3] = p0[15 * 16 - 256];
}
/* deblock and destair blocks */
/* 4 MBs involved, need to process 16 blocks of a */
/* | */
/* a | b */
/* - - - - */
/* c | d */
/* | */
Void postProcBlock(struct tagPostProcInfo * strPostProcInfo[MAX_CHANNELS][2], PixelI * p0, PixelI * p1, size_t mbX, size_t cc, Int threshold)
{
size_t i, j, k;
Int dc[5][5];
U8 texture[5][5];
struct tagPostProcInfo * pMBb = strPostProcInfo[cc][0] + mbX, * pMBa = pMBb - 1, * pMBd = strPostProcInfo[cc][1] + mbX, * pMBc = pMBd - 1;
PixelI * pc, * pt;
/* copy DC and Texture info, can be optimized out */
for(j = 0; j < 4; j ++){
// from MB a
for(i = 0; i < 4; i ++){
dc[j][i] = pMBa->iBlockDC[j][i];
texture[j][i] = pMBa->ucBlockTexture[j][i];
}
// 4 blocks from MB c
dc[4][j] = pMBc->iBlockDC[0][j];
texture[4][j] = pMBc->ucBlockTexture[0][j];
// 4 blocks from MB b
dc[j][4] = pMBb->iBlockDC[j][0];
texture[j][4] = pMBb->ucBlockTexture[j][0];
}
// 1 block from MB d
dc[4][4] = pMBd->iBlockDC[0][0];
texture[4][4] = pMBd->ucBlockTexture[0][0];
/* block boundaries */
/* | */
/* | */
/* --- */
for(j = 0; j < 4; j ++){
for(i = 0; i < 4; i ++){
pc = p0 - 256 + i * 64 + j * 16;
// deblock
if(texture[j][i] + texture[j + 1][i] < 3 && abs(dc[j][i] - dc[j + 1][i]) <= threshold){
// smooth horizontal boundary ----
pt = (j < 3 ? pc + 16 : p1 - 256 + i * 64);
for(k = 0; k < 4; k ++){
smooth(pc + idxCC[1][k], pc + idxCC[2][k], pc + idxCC[3][k], pt + idxCC[0][k], pt + idxCC[1][k], pt + idxCC[2][k]);
}
}
// two horizontally adjacent blocks have same texture and similiar DCs
if(texture[j][i] + texture[j][i + 1] < 3 && abs(dc[j][i] - dc[j][i + 1]) <= threshold){
// smooth vertical boundary |
pt = pc + 64;
for(k = 0; k < 4; k ++){
smooth(pc + idxCC[k][1], pc + idxCC[k][2], pc + idxCC[k][3], pt + idxCC[k][0], pt + idxCC[k][1], pt + idxCC[k][2]);
}
}
}
}
}

1205
jxrlib/image/decode/segdec.c
View file

File diff suppressed because it is too large Load diff

1888
jxrlib/image/decode/strInvTransform.c
View file

File diff suppressed because it is too large Load diff

539
jxrlib/image/decode/strPredQuantDec.c
View file

@ -1,539 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#include "strcodec.h"
#define DEQUANT(iRaw, iQP) ((iRaw) * (iQP))
Void dequantizeBlock4x4(PixelI * pRec, Int * pOrg, const Int * pIndex, Int iQPLP)
{
Int i;
for(i = 1; i < 16; i ++)
pRec[pIndex[i]] = DEQUANT(pOrg[i], iQPLP);
}
Void dequantizeBlock2x2(PixelI * pRec, Int * pOrg, Int iQPLP)
{
pRec[32] = DEQUANT(pOrg[1], iQPLP);
pRec[16] = DEQUANT(pOrg[2], iQPLP);
pRec[48] = DEQUANT(pOrg[3], iQPLP);
}
Void dequantizeBlock4x2(PixelI * pRec, Int * pOrg, Int iQPLP)
{
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);
// dequantize LP
if(pSC->WMISCP.sbSubband != SB_DC_ONLY)
if(i == 0 || (cf != YUV_422 && cf != YUV_420))
dequantizeBlock4x4(pSC->p1MBbuffer[i] , pMBInfo->iBlockDC[i], dctIndex[2], pTile->pQuantizerLP[i][pMBInfo->iQIndexLP].iQP);
else if(cf == YUV_422)
dequantizeBlock4x2(pSC->p1MBbuffer[i], pMBInfo->iBlockDC[i], pTile->pQuantizerLP[i][pMBInfo->iQIndexLP].iQP);
else // 420
dequantizeBlock2x2(pSC->p1MBbuffer[i], pMBInfo->iBlockDC[i], pTile->pQuantizerLP[i][pMBInfo->iQIndexLP].iQP);
}
return ICERR_OK;
}
/* frequency domain inverse DCAC prediction */
Void predDCACDec(CWMImageStrCodec * pSC)
{
const COLORFORMAT cf = pSC->m_param.cfColorFormat;
const Int iChannels = (cf == YUV_420 || cf == YUV_422) ? 1 : (Int) pSC->m_param.cNumChannels;
CWMIMBInfo *pMBInfo = &(pSC->MBInfo);
size_t mbX = pSC->cColumn;// mbY = pSC->cRow;
Int iDCACPredMode = getDCACPredMode(pSC, mbX);
Int iDCPredMode = (iDCACPredMode & 0x3);
Int iADPredMode = (iDCACPredMode & 0xC);
PixelI * pOrg, * pRef;
Int ii;
for(ii = 0; ii < iChannels; ii ++){
pOrg = pMBInfo->iBlockDC[ii];//[dcBlkIdx + (i >> 4)]; // current DC block
/* DC prediction */
if(iDCPredMode == 1){ // predict DC from top
pOrg[0] += pSC->PredInfoPrevRow[ii][mbX].iDC;
}
else if(iDCPredMode == 0){ // predict DC from left
pOrg[0] += (pSC->PredInfo[ii] + mbX - 1)->iDC;
}
else if(iDCPredMode == 2){// predict DC from top&left
pOrg[0] += ((pSC->PredInfo[ii] + mbX - 1)->iDC + (pSC->PredInfoPrevRow[ii] + mbX)->iDC) >> 1;
}
/* AD prediction */
if(iADPredMode == 4){// predict AD from top
pRef = (pSC->PredInfoPrevRow[ii] + mbX)->piAD;
pOrg[4] += pRef[3], pOrg[8] += pRef[4], pOrg[12] += pRef[5];
}
else if(iADPredMode == 0){// predict AD from left
pRef = (pSC->PredInfo[ii] + mbX - 1)->piAD;
pOrg[1] += pRef[0], pOrg[2] += pRef[1], pOrg[3] += pRef[2];
}
}
if(cf == YUV_420){
for(ii = 1; ii < 3; ii ++){
pOrg = pMBInfo->iBlockDC[ii];//dcBlkIdx + ii]; // current DC block
/* DC prediction */
if(iDCPredMode == 1){ // predict DC from top
pOrg[0] += (pSC->PredInfoPrevRow[ii] + mbX)->iDC;
}
else if(iDCPredMode == 0){ // predict DC from left
pOrg[0] += (pSC->PredInfo[ii] + mbX - 1)->iDC;
}
else if(iDCPredMode == 2){ // predict DC from top&left
pOrg[0] += (((pSC->PredInfo[ii] + mbX - 1)->iDC + (pSC->PredInfoPrevRow[ii] + mbX)->iDC + 1) >> 1);
}
/* AD prediciton */
if(iADPredMode == 4){// predict AD from top
pOrg[2] += (pSC->PredInfoPrevRow[ii] + mbX)->piAD[1];
}
else if(iADPredMode == 0){// predict AD from left
pOrg[1] += (pSC->PredInfo[ii] + mbX - 1)->piAD[0];
}
}
}
else if(cf == YUV_422){
for(ii = 1; ii < 3; ii ++){
pOrg = pMBInfo->iBlockDC[ii];//[dcBlkIdx + ii]; // current DC block
/* DC prediciton */
if(iDCPredMode == 1){ // predict DC from top
pOrg[0] += (pSC->PredInfoPrevRow[ii] + mbX)->iDC;
}
else if(iDCPredMode == 0){ // predict DC from left
pOrg[0] += (pSC->PredInfo[ii] + mbX - 1)->iDC;
}
else if(iDCPredMode == 2){ // predict DC from top&left
pOrg[0] += (((pSC->PredInfo[ii] + mbX - 1)->iDC + (pSC->PredInfoPrevRow[ii] + mbX)->iDC + 1) >> 1);
}
/* AD prediction */
if(iADPredMode == 4){// predict AD from top
pOrg[4] += (pSC->PredInfoPrevRow[ii] + mbX)->piAD[4]; // AC of HT !!!
pOrg[2] += (pSC->PredInfoPrevRow[ii] + mbX)->piAD[3];
pOrg[6] += pOrg[2];
}
else if(iADPredMode == 0){// predict AD from left
pOrg[4] += (pSC->PredInfo[ii] + mbX - 1)->piAD[4]; // AC of HT !!!
pOrg[1] += (pSC->PredInfo[ii] + mbX - 1)->piAD[0];
pOrg[5] += (pSC->PredInfo[ii] + mbX - 1)->piAD[2];
}
else if(iDCPredMode == 1){
pOrg[6] += pOrg[2];
}
}
}
pMBInfo->iOrientation = 2 - getACPredMode(pMBInfo, cf);
}
/*************************************************************************
Frequency domain inverse AC prediction
*************************************************************************/
Void predACDec(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, mbY = pSC->cRow;
CWMIMBInfo *pMBInfo = &pSC->MBInfo;
Int iACPredMode = 2 - pMBInfo->iOrientation;
PixelI * pOrg, * pRef;
Int i, j;
/* AC prediction */
for(i = 0; i < iChannels; i++){
// prediction only happens inside MB
PixelI* pSrc = pSC->p1MBbuffer[i];//0 == i ? pSC->pY1 : (1 == i ? pSC->pU1 : pSC->pV1);
switch (iACPredMode)
{
case 1:
{
// predict from top
static U8 blkIdx[] = {1, 2, 3, 5, 6, 7, 9, 10, 11, 13, 14, 15};
for (j = 0; j < sizeof(blkIdx) / sizeof(*blkIdx); ++j)
{
pOrg = pSrc + 16 * blkIdx[j];
pRef = pOrg - 16;
pOrg[ 2] += pRef[ 2];
pOrg[10] += pRef[10];
pOrg[ 9] += pRef[ 9];
}
break;
}
case 0:
// predict from left
for (j = 64; j < 256; j += 16)
{
pOrg = pSrc + j;
pRef = pOrg - 64;
pOrg[1] += pRef[1];
pOrg[5] += pRef[5];
pOrg[6] += pRef[6];
}
break;
default:
// no prediction
break;
}
}
if(cf == YUV_420){
for(i = 16; i <= 20; i += 4){
PixelI* pSrc = pSC->p1MBbuffer[(i >> 2) - 3];//16 == i ? pSC->pU1 : pSC->pV1;
switch (iACPredMode)
{
case 1:
{
// predict from top
for (j = 1; j <= 3; j += 2)
{
pOrg = pSrc + 16 * j;
pRef = pOrg - 16;
pOrg[ 2] += pRef[ 2];
pOrg[10] += pRef[10];
pOrg[ 9] += pRef[ 9];
}
break;
}
case 0:
// predict from left
for (j = 2; j <= 3; ++j)
{
pOrg = pSrc + 16 * j;
pRef = pOrg - 32;
pOrg[1] += pRef[1];
pOrg[5] += pRef[5];
pOrg[6] += pRef[6];
}
break;
default:
// no prediction
break;
}
}
}
else if(cf == YUV_422){
for(i = 16; i < 32; i += 8){
PixelI* pSrc = pSC->p1MBbuffer[(i >> 3) - 1];//16 == i ? pSC->pU1 : pSC->pV1;
switch (iACPredMode)
{
case 1:
{
// predict from top
for (j = 2; j < 8; j ++)
{
pOrg = pSrc + blkOffsetUV_422[j];
pRef = pOrg - 16;
pOrg[10] += pRef[10];
pOrg[ 2] += pRef[ 2];
pOrg[ 9] += pRef[ 9];
}
break;
}
case 0:
// predict from left
for (j = 1; j < 8; j += 2)
{
pOrg = pSrc + blkOffsetUV_422[j];
pRef = pOrg - 64;
pOrg[1] += pRef[1];
pOrg[5] += pRef[5];
pOrg[6] += pRef[6];
}
break;
default:
// no prediction
break;
}
}
}
}
/*************************************************************************
CBP
*************************************************************************/
static int NumOnes(int i)
{
int retval = 0;
static const int g_Count[] = { 0,1,1,2, 1,2,2,3, 1,2,2,3, 2,3,3,4 };
i = i & 0xffff;
while (i) {
retval += g_Count[i & 0xf];
i >>= 4;
}
return retval;
}
#define SATURATE32(x) if((unsigned int)(x + 16) >= 32) { if (x < 0) x = -16; else x = 15; }
/* CBP prediction for 16 x 16 MB */
/* block index */
/* 0 1 4 5 */
/* 2 3 6 7 */
/* 8 9 12 13 */
/* 10 11 14 15 */
static Int predCBPCDec(CWMImageStrCodec * pSC, Int iCBP, size_t mbX, size_t mbY, size_t c, CCBPModel *pModel)
{
Int iNOrig;
const int iNDiff = AVG_NDIFF;
size_t c1 = c ? 1 : 0;
UNREFERENCED_PARAMETER( mbY );
if (pModel->m_iState[c1] == 0) {
if(pSC->m_bCtxLeft) {
if (pSC->m_bCtxTop) {
iCBP ^= 1;
}
else {
Int iTopCBP = (pSC->PredInfoPrevRow[c] + mbX)->iCBP;
iCBP ^= (iTopCBP >> 10) & 1; // left: top(10) => 0
}
}
else {
Int iLeftCBP = (pSC->PredInfo[c] + mbX - 1)->iCBP;
iCBP ^= ((iLeftCBP >> 5) & 1); // left(5) => 0
}
iCBP ^= (0x02 & (iCBP << 1)); // 0 => 1
iCBP ^= (0x10 & (iCBP << 3)); // 1 => 4
iCBP ^= (0x20 & (iCBP << 1)); // 4 => 5
iCBP ^= ((iCBP & 0x33) << 2);
iCBP ^= ((iCBP & 0xcc) << 6);
iCBP ^= ((iCBP & 0x3300) << 2);
}
else if (pModel->m_iState[c1] == 2) {
iCBP ^= 0xffff;
}
iNOrig = NumOnes(iCBP);
pModel->m_iCount0[c1] += iNOrig - iNDiff;
SATURATE32(pModel->m_iCount0[c1]);
pModel->m_iCount1[c1] += 16 - iNOrig - iNDiff;
SATURATE32(pModel->m_iCount1[c1]);
if (pModel->m_iCount0[c1] < 0) {
if (pModel->m_iCount0[c1] < pModel->m_iCount1[c1]) {
pModel->m_iState[c1] = 1;
}
else {
pModel->m_iState[c1] = 2;
}
}
else if (pModel->m_iCount1[c1] < 0) {
pModel->m_iState[c1] = 2;
}
else {
pModel->m_iState[c1] = 0;
}
return iCBP;
}
static Int predCBPC420Dec(CWMImageStrCodec * pSC, Int iCBP, size_t mbX, size_t mbY, size_t c, CCBPModel *pModel)
{
Int iNOrig;
const int iNDiff = AVG_NDIFF;
UNREFERENCED_PARAMETER( mbY );
if (pModel->m_iState[1] == 0) {
if(pSC->m_bCtxLeft) {
if (pSC->m_bCtxTop) {
iCBP ^= 1;
}
else {
Int iTopCBP = (pSC->PredInfoPrevRow[c] + mbX)->iCBP;
iCBP ^= (iTopCBP >> 2) & 1; // left: top(2) => 0
}
}
else {
Int iLeftCBP = (pSC->PredInfo[c] + mbX - 1)->iCBP;
iCBP ^= ((iLeftCBP >> 1) & 1); // left(1) => 0
}
iCBP ^= (0x02 & (iCBP << 1)); // 0 => 1
iCBP ^= ((iCBP & 0x3) << 2); // [0 1] -> [2 3]
}
else if (pModel->m_iState[1] == 2) {
iCBP ^= 0xf;
}
iNOrig = NumOnes(iCBP) * 4;
pModel->m_iCount0[1] += iNOrig - iNDiff;
SATURATE32(pModel->m_iCount0[1]);
pModel->m_iCount1[1] += 16 - iNOrig - iNDiff;
SATURATE32(pModel->m_iCount1[1]);
if (pModel->m_iCount0[1] < 0) {
if (pModel->m_iCount0[1] < pModel->m_iCount1[1]) {
pModel->m_iState[1] = 1;
}
else {
pModel->m_iState[1] = 2;
}
}
else if (pModel->m_iCount1[1] < 0) {
pModel->m_iState[1] = 2;
}
else {
pModel->m_iState[1] = 0;
}
return iCBP;
}
static Int predCBPC422Dec(CWMImageStrCodec * pSC, Int iCBP, size_t mbX, size_t mbY, size_t c, CCBPModel *pModel)
{
Int iNOrig;
const int iNDiff = AVG_NDIFF;
UNREFERENCED_PARAMETER( mbY );
if (pModel->m_iState[1] == 0) {
if(pSC->m_bCtxLeft) {
if (pSC->m_bCtxTop) {
iCBP ^= 1;
}
else {
Int iTopCBP = (pSC->PredInfoPrevRow[c] + mbX)->iCBP;
iCBP ^= (iTopCBP >> 6) & 1; // left: top(6) => 0
}
}
else {
Int iLeftCBP = (pSC->PredInfo[c] + mbX - 1)->iCBP;
iCBP ^= ((iLeftCBP >> 1) & 1); // left(1) => 0
}
iCBP ^= (iCBP & 0x1) << 1; // [0]->[1]
iCBP ^= (iCBP & 0x3) << 2; // [0 1]->[2 3]
iCBP ^= (iCBP & 0xc) << 2; // [2 3]->[4 5]
iCBP ^= (iCBP & 0x30) << 2; // [4 5]->[6 7]
}
else if (pModel->m_iState[1] == 2) {
iCBP ^= 0xff;
}
iNOrig = NumOnes(iCBP) * 2;
pModel->m_iCount0[1] += iNOrig - iNDiff;
SATURATE32(pModel->m_iCount0[1]);
pModel->m_iCount1[1] += 16 - iNOrig - iNDiff;
SATURATE32(pModel->m_iCount1[1]);
if (pModel->m_iCount0[1] < 0) {
if (pModel->m_iCount0[1] < pModel->m_iCount1[1]) {
pModel->m_iState[1] = 1;
}
else {
pModel->m_iState[1] = 2;
}
}
else if (pModel->m_iCount1[1] < 0) {
pModel->m_iState[1] = 2;
}
else {
pModel->m_iState[1] = 0;
}
return iCBP;
}
/* Coded Block Pattern (CBP) prediction */
Void predCBPDec(CWMImageStrCodec *pSC, CCodingContext *pContext)
{
const COLORFORMAT cf = pSC->m_param.cfColorFormat;
const size_t iChannels = (cf == YUV_420 || cf == YUV_422) ? 1 : pSC->m_param.cNumChannels;
size_t i, mbX = pSC->cColumn, mbY = pSC->cRow;
CWMIMBInfo *pMBInfo = &(pSC->MBInfo);
for (i = 0; i < iChannels; i++) {
(pSC->PredInfo[i] + mbX)->iCBP = pMBInfo->iCBP[i] = predCBPCDec(pSC, pMBInfo->iDiffCBP[i], mbX, mbY, i, &pContext->m_aCBPModel); // Y Channel
}
if (cf == YUV_422){
(pSC->PredInfo[1] + mbX)->iCBP = pMBInfo->iCBP[1] = predCBPC422Dec(pSC, pMBInfo->iDiffCBP[1], mbX, mbY, 1, &pContext->m_aCBPModel);
(pSC->PredInfo[2] + mbX)->iCBP = pMBInfo->iCBP[2] = predCBPC422Dec(pSC, pMBInfo->iDiffCBP[2], mbX, mbY, 2, &pContext->m_aCBPModel);
}
else if (cf == YUV_420) {
(pSC->PredInfo[1] + mbX)->iCBP = pMBInfo->iCBP[1] = predCBPC420Dec(pSC, pMBInfo->iDiffCBP[1], mbX, mbY, 1, &pContext->m_aCBPModel);
(pSC->PredInfo[2] + mbX)->iCBP = pMBInfo->iCBP[2] = predCBPC420Dec(pSC, pMBInfo->iDiffCBP[2], mbX, mbY, 2, &pContext->m_aCBPModel);
}
//}
}

3630
jxrlib/image/decode/strdec.c
View file

File diff suppressed because it is too large Load diff

1624
jxrlib/image/decode/strdec_x86.c
View file

File diff suppressed because it is too large Load diff

144
jxrlib/image/encode/encode.c
View file

@ -1,144 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#include <stdio.h>
#include <stdlib.h>
#include "encode.h"
#include "strcodec.h"
#include "common.h"
#ifdef MEM_TRACE
#define TRACE_MALLOC 1
#define TRACE_NEW 0
#define TRACE_HEAP 0
#include "memtrace.h"
#endif
/*************************************************************************
Context allocation
In theory it is possible to independently set uiTrimFlexBits for
each tile, but for now we assume only one user specified value is
used for the entire image
*************************************************************************/
Int AllocateCodingContextEnc(CWMImageStrCodec *pSC, Int iNumContexts, Int iTrimFlexBits)
{
Int i, iCBPSize, k;
static const Int aAlphabet[] = {5,4,8,7,7, 12,6,6,12,6,6,7,7, 12,6,6,12,6,6,7,7};
if (iTrimFlexBits < 0)
iTrimFlexBits = 0;
else if (iTrimFlexBits > 15)
iTrimFlexBits = 15;
pSC->m_param.bTrimFlexbitsFlag = (iTrimFlexBits > 0);
if (iNumContexts < 1 || iNumContexts > MAX_TILES) // only between 1 and 256 allowed
return ICERR_ERROR;
if (pSC == NULL)
return ICERR_ERROR;
pSC->m_pCodingContext = malloc (iNumContexts * sizeof (CCodingContext));
if (pSC->m_pCodingContext == NULL) {
pSC->cNumCodingContext = 0;
return ICERR_ERROR;
}
memset (pSC->m_pCodingContext, 0, iNumContexts * sizeof (CCodingContext));
pSC->cNumCodingContext = iNumContexts;
iCBPSize = (pSC->m_param.cfColorFormat == Y_ONLY || pSC->m_param.cfColorFormat == NCOMPONENT
|| pSC->m_param.cfColorFormat == CMYK) ? 5 : 9;
/** allocate / initialize members **/
for (i = 0; i < iNumContexts; i++) {
CCodingContext *pContext = &(pSC->m_pCodingContext[i]);
/** allocate adaptive Huffman encoder **/
pContext->m_pAdaptHuffCBPCY = Allocate (iCBPSize, ENCODER);
if(pContext->m_pAdaptHuffCBPCY == NULL) {
return ICERR_ERROR;
}
pContext->m_pAdaptHuffCBPCY1 = Allocate(5, ENCODER);
if(pContext->m_pAdaptHuffCBPCY1 == NULL){
return ICERR_ERROR;
}
for(k = 0; k < NUMVLCTABLES; k ++){
pContext->m_pAHexpt[k] = Allocate(aAlphabet[k], ENCODER);
if(pContext->m_pAHexpt[k] == NULL){
return ICERR_ERROR;
}
}
ResetCodingContextEnc(pContext);
pContext->m_iTrimFlexBits = iTrimFlexBits;
}
return ICERR_OK;
}
/*************************************************************************
Context reset on encoder
*************************************************************************/
Void ResetCodingContextEnc(CCodingContext *pContext)
{
Int k;
/** set flags **/
pContext->m_pAdaptHuffCBPCY->m_bInitialize = FALSE;
pContext->m_pAdaptHuffCBPCY1->m_bInitialize = FALSE;
for(k = 0; k < NUMVLCTABLES; k ++)
pContext->m_pAHexpt[k]->m_bInitialize = FALSE;
// reset VLC tables
AdaptLowpassEnc (pContext);
AdaptHighpassEnc (pContext);
// reset zigzag patterns, totals
InitZigzagScan(pContext);
// reset bit reduction and cbp models
ResetCodingContext(pContext);
}
/*************************************************************************
Context deletion
*************************************************************************/
Void FreeCodingContextEnc(CWMImageStrCodec *pSC)
{
Int iContexts = (Int)(pSC->cNumCodingContext), i, k;
if (iContexts > 0 && pSC->m_pCodingContext) {
for (i = 0; i < iContexts; i++) {
CCodingContext *pContext = &(pSC->m_pCodingContext[i]);
Clean (pContext->m_pAdaptHuffCBPCY);
Clean (pContext->m_pAdaptHuffCBPCY1);
for (k = 0; k < NUMVLCTABLES; k++)
Clean (pContext->m_pAHexpt[k]);
}
free (pSC->m_pCodingContext);
}
}

113
jxrlib/image/encode/encode.h
View file

@ -1,113 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#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
*************************************************************************/
/** 2-point pre filter for boundaries (only used in 420 UV DC subband) **/
Void strPre2(PixelI *, PixelI *);
/** 2x2 pre filter (only used in 420 UV DC subband) **/
Void strPre2x2(PixelI *, PixelI *, PixelI *, PixelI *);
/** 4-point pre filter for boundaries **/
Void strPre4(PixelI *, PixelI *, PixelI *, PixelI *);
/** data allocation in working buffer (first stage) **/
/** Y, 444 U and V **/
/** 0 1 2 3 **/
/** 32 33 34 35 **/
/** 64 65 66 67 **/
/** 96 97 98 99 **/
/** 420 U and V **/
/** 0 2 4 6 **/
/** 64 66 68 70 **/
/** 128 130 132 134 **/
/** 192 194 196 198 **/
/** 4x4 foward DCT for first stage **/
Void strDCT4x4FirstStage(PixelI *);
Void strDCT4x4FirstStage420UV(PixelI *);
Void strDCT4x4Stage1(PixelI*);
/** 4x4 pre filter for first stage **/
Void strPre4x4FirstStage(PixelI *);
Void strPre4x4FirstStage420UV(PixelI *);
Void strPre4x4Stage1Split(PixelI* p0, PixelI* p1, Int iOffset);
Void strPre4x4Stage1(PixelI* p, Int iOffset);
/** data allocation in working buffer (second stage)**/
/** Y, 444 U and V **/
/** 0 4 8 12 **/
/** 128 132 136 140 **/
/** 256 260 264 268 **/
/** 384 388 392 396 **/
/** 420 U and V **/
/** 0 8 **/
/** 256 264 **/
/** 4x4 foward DCT for second stage **/
Void strDCT4x4SecondStage(PixelI *);
Void strNormalizeEnc(PixelI *, Bool);
Void strDCT2x2dnEnc(PixelI *, PixelI *, PixelI *, PixelI *);
/** 4x4 pre filter for second stage **/
Void strPre4x4Stage2Split(PixelI* p0, PixelI* p1);
#endif // ENCODE_H

1186
jxrlib/image/encode/segenc.c
View file

File diff suppressed because it is too large Load diff

1111
jxrlib/image/encode/strFwdTransform.c
View file

File diff suppressed because it is too large Load diff

511
jxrlib/image/encode/strPredQuantEnc.c
View file

@ -1,511 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#include "strcodec.h"
#include "encode.h"
I32 QUANT_Mulless(PixelI v, PixelI o, I32 r)
{
const I32 m = v >> 31;
assert(sizeof(PixelI) == sizeof(U32));
return ((((v ^ m) - m + o) >> r) ^ m) - m;
}
I32 MUL32HR(U32 a, U32 b, U32 r)
{
return (I32)((U32)((U64)a * b >> 32) >> r);
}
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);
const int * pOffset = (iNumBlock == 4 ? blkOffsetUV : (iNumBlock == 8 ? blkOffsetUV_422 : blkOffset));
CWMIQuantizer * pQPDC = pTile->pQuantizerDC[iChannel];
CWMIQuantizer * pQPLP = pTile->pQuantizerLP[iChannel] + pMBInfo->iQIndexLP;
CWMIQuantizer * pQPHP = pTile->pQuantizerHP[iChannel] + pMBInfo->iQIndexHP;
for(j = 0; j < iNumBlock; j ++){
PixelI * pData = pSC->pPlane[iChannel] + pOffset[j];
if(j == 0) // DC
pData[0] = (pQPDC->iMan == 0 ? QUANT_Mulless(pData[0], pQPDC->iOffset, pQPDC->iExp) : QUANT(pData[0], pQPDC->iOffset, pQPDC->iMan, pQPDC->iExp));
else if(pSC->WMISCP.sbSubband != SB_DC_ONLY) // LP
pData[0] = (pQPLP->iMan == 0 ? QUANT_Mulless(pData[0], pQPLP->iOffset, pQPLP->iExp) : QUANT(pData[0], pQPLP->iOffset, pQPLP->iMan, pQPLP->iExp));
// quantize HP
if(pSC->WMISCP.sbSubband != SB_DC_ONLY && pSC->WMISCP.sbSubband != SB_NO_HIGHPASS)
for(i = 1; i < 16; i ++)
pData[i] = (pQPHP->iMan == 0 ? QUANT_Mulless(pData[i], pQPHP->iOffset, pQPHP->iExp) : QUANT(pData[i], pQPHP->iOffset, pQPHP->iMan, pQPHP->iExp));
}
}
for(iChannel = 0; iChannel < (int)pSC->m_param.cNumChannels; iChannel ++){
I32 * pDC = pSC->MBInfo.iBlockDC[iChannel];
PixelI * pData = pSC->pPlane[iChannel];
if(iChannel > 0 && cf == YUV_422){
for(i = 0; i < 8; i ++){
pDC[i] = pData[blkOffsetUV_422[i]];
}
}
else if(iChannel > 0 && cf == YUV_420){
for(i = 0; i < 4; i ++){
pDC[i] = pData[blkOffsetUV[i]];
}
}
else{
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;
Int i, j, k;
pMBInfo->iOrientation = 2 - iACPredMode;
/* keep necessary info for future prediction */
updatePredInfo(pSC, pMBInfo, mbX, cf);
for(i = 0; i < iChannels; i ++){
pOrg = pMBInfo->iBlockDC[i]; // current DC block
/* DC prediction */
if(iDCPredMode == 1){ // predict DC from top
pOrg[0] -= (pSC->PredInfoPrevRow[i] + mbX)->iDC;
}
else if(iDCPredMode == 0){ // predict DC from left
pOrg[0] -= (pSC->PredInfo[i] + mbX - 1)->iDC;
}
else if(iDCPredMode == 2){// predict DC from top&left
pOrg[0] -= ((pSC->PredInfo[i] + mbX - 1)->iDC + (pSC->PredInfoPrevRow[i] + mbX)->iDC) >> 1;
}
/* AD prediction */
if(iADPredMode == 4){// predict AD from top
pRef = (pSC->PredInfoPrevRow[i] + mbX)->piAD;
pOrg[4] -= pRef[3], pOrg[8] -= pRef[4], pOrg[12] -= pRef[5];
}
else if(iADPredMode == 0){// predict AD from left
pRef = (pSC->PredInfo[i] + mbX - 1)->piAD;
pOrg[1] -= pRef[0], pOrg[2] -= pRef[1], pOrg[3] -= pRef[2];
}
pOrg = pSC->pPlane[i];
/* AC prediction */
if(iACPredMode == 1){ // predict from top
for(k = 0; k <= 192; k += 64){
/* inside macroblock, in reverse order */
for(j = 48; j > 0; j -= 16){
pOrg[k + j + 10] -= pOrg[k + j + 10 - 16];
pOrg[k + j + 2] -= pOrg[k + j + 2 - 16];
pOrg[k + j + 9] -= pOrg[k + j + 9 - 16];
}
}
}
else if(iACPredMode == 0){ // predict from left
for(k = 0; k < 64; k += 16){
/* inside macroblock, in reverse order */
for(j = 192; j > 0; j -= 64){
pOrg[k + j + 5] -= pOrg[k + j + 5 - 64];
pOrg[k + j + 1] -= pOrg[k + j + 1 - 64];
pOrg[k + j + 6] -= pOrg[k + j + 6 - 64];
}
}
}
}
if(cf == YUV_420){
for(i = 1; i < 3; i ++){
pOrg = pMBInfo->iBlockDC[i]; // current DC block
/* DC prediciton */
if(iDCPredMode == 1){ // predict DC from top
pOrg[0] -= (pSC->PredInfoPrevRow[i] + mbX)->iDC;
}
else if(iDCPredMode == 0){ // predict DC from left
pOrg[0] -= (pSC->PredInfo[i] + mbX - 1)->iDC;
}
else if(iDCPredMode == 2){ // predict DC from top&left
pOrg[0] -= (((pSC->PredInfo[i] + mbX - 1)->iDC + (pSC->PredInfoPrevRow[i] + mbX)->iDC + 1) >> 1);
}
/* AD prediction */
if(iADPredMode == 4){// predict AD from top
pOrg[2] -= (pSC->PredInfoPrevRow[i] + mbX)->piAD[1];
}
else if(iADPredMode == 0){// predict AD from left
pOrg[1] -= (pSC->PredInfo[i] + mbX - 1)->piAD[0];
}
pOrg = pSC->pPlane[i];
/* AC prediction */
if(iACPredMode == 1){ // predict from top
for(j = 16; j <= 48; j += 32){
/* inside macroblock */
pOrg[j + 10] -= pOrg[j + 10 - 16];
pOrg[j + 2] -= pOrg[j + 2 - 16];
pOrg[j + 9] -= pOrg[j + 9 - 16];
}
}
else if(iACPredMode == 0){ // predict from left
for(j = 32; j <= 48; j += 16){
/* inside macroblock */
pOrg[j + 5] -= pOrg[j + 5 - 32];
pOrg[j + 1] -= pOrg[j + 1 - 32];
pOrg[j + 6] -= pOrg[j + 6 - 32];
}
}
}
}
else if(cf == YUV_422){
for(i = 1; i < 3; i ++){
pOrg = pMBInfo->iBlockDC[i]; // current DC block
/* DC prediciton */
if(iDCPredMode == 1){ // predict DC from top
pOrg[0] -= (pSC->PredInfoPrevRow[i] + mbX)->iDC;
}
else if(iDCPredMode == 0){ // predict DC from left
pOrg[0] -= (pSC->PredInfo[i] + mbX - 1)->iDC;
}
else if(iDCPredMode == 2){ // predict DC from top&left
pOrg[0] -= (((pSC->PredInfo[i] + mbX - 1)->iDC + (pSC->PredInfoPrevRow[i] + mbX)->iDC + 1) >> 1);
}
/* AD prediction */
if(iADPredMode == 4){// predict AD from top
pOrg[4] -= (pSC->PredInfoPrevRow[i] + mbX)->piAD[4]; // AC of HT !!!
pOrg[6] -= pOrg[2];
pOrg[2] -= (pSC->PredInfoPrevRow[i] + mbX)->piAD[3];
}
else if(iADPredMode == 0){// predict AD from left
pOrg[4] -= (pSC->PredInfo[i] + mbX - 1)->piAD[4]; // AC of HT !!!
pOrg[1] -= (pSC->PredInfo[i] + mbX - 1)->piAD[0];
pOrg[5] -= (pSC->PredInfo[i] + mbX - 1)->piAD[2];
}
else if(iDCPredMode == 1){
pOrg[6] -= pOrg[2];
}
pOrg = pSC->pPlane[i]; // current MB
/* AC prediction */
if(iACPredMode == 1){ // predict from top
for(j = 48; j > 0; j -= 16){
for(k = 0; k <= 64; k += 64){
/* inside macroblock */
pOrg[j + k + 10] -= pOrg[j + k + 10 - 16];
pOrg[j + k + 2] -= pOrg[j + k + 2 - 16];
pOrg[j + k + 9] -= pOrg[j + k + 9 - 16];
}
}
}
else if(iACPredMode == 0){ // predict from left
for(j = 64; j <= 112; j += 16){
/* inside macroblock */
pOrg[j + 5] -= pOrg[j + 5 - 64];
pOrg[j + 1] -= pOrg[j + 1 - 64];
pOrg[j + 6] -= pOrg[j + 6 - 64];
}
}
}
}
}
/* CBP prediction for 16 x 16 MB */
/* block index */
/* 0 1 4 5 */
/* 2 3 6 7 */
/* 8 9 12 13 */
/* 10 11 14 15 */
static int NumOnes(int i)
{
int retval = 0;
static const int g_Count[] = { 0,1,1,2, 1,2,2,3, 1,2,2,3, 2,3,3,4 };
i = i & 0xffff;
while (i) {
retval += g_Count[i & 0xf];
i >>= 4;
}
return retval;
}
#define SATURATE32(x) if((unsigned int)(x + 16) >= 32) { if (x < 0) x = -16; else x = 15; }
static Int predCBPCEnc(CWMImageStrCodec *pSC, Int iCBP, size_t mbX, size_t mbY, size_t c, CCBPModel *pModel)
{
Int iPredCBP = 0, iRetval = 0;
Int iNOrig = NumOnes(iCBP), iNDiff = AVG_NDIFF;//NumOnes(iPredCBP ^ iCBP);
UNREFERENCED_PARAMETER( mbY );
/* only top left block pattern is predicted from neighbour */
if(pSC->m_bCtxLeft) {
if (pSC->m_bCtxTop) {
iPredCBP = 1;
}
else {
Int iTopCBP = (pSC->PredInfoPrevRow[c] + mbX)->iCBP;
iPredCBP = (iTopCBP >> 10) & 1; // left: top(10) => 0
}
}
else {
Int iLeftCBP = (pSC->PredInfo[c] + mbX - 1)->iCBP;
iPredCBP = ((iLeftCBP >> 5) & 1); // left(5) => 0
}
iPredCBP |= (iCBP & 0x3300) << 2; // [8 9 12 13]->[10 11 14 15]
iPredCBP |= (iCBP & 0xcc) << 6; // [2 3 6 7]->[8 9 12 13]
iPredCBP |= (iCBP & 0x33) << 2; // [0 1 4 5]->[2 3 6 7]
iPredCBP |= (iCBP & 0x11) << 1; // [0 4]->[1 5]
iPredCBP |= (iCBP & 0x2) << 3; // [1]->[4]
if (c) c = 1;
if (pModel->m_iState[c] == 0) {
iRetval = iPredCBP ^ iCBP;
}
else if (pModel->m_iState[c] == 1) {
iRetval = iCBP;
}
else {
iRetval = iCBP ^ 0xffff;
}
pModel->m_iCount0[c] += iNOrig - iNDiff;
SATURATE32(pModel->m_iCount0[c]);
pModel->m_iCount1[c] += 16 - iNOrig - iNDiff;
SATURATE32(pModel->m_iCount1[c]);
if (pModel->m_iCount0[c] < 0) {
if (pModel->m_iCount0[c] < pModel->m_iCount1[c]) {
pModel->m_iState[c] = 1;
}
else {
pModel->m_iState[c] = 2;
}
}
else if (pModel->m_iCount1[c] < 0) {
pModel->m_iState[c] = 2;
}
else {
pModel->m_iState[c] = 0;
}
return iRetval;
}
static Int predCBPC420Enc(CWMImageStrCodec *pSC, Int iCBP, size_t mbX, size_t mbY, size_t c, CCBPModel *pModel)
{
Int iPredCBP = 0, iRetval = 0;
Int iNOrig = NumOnes(iCBP) * 4, iNDiff = AVG_NDIFF;//NumOnes(iPredCBP ^ iCBP);
UNREFERENCED_PARAMETER( mbY );
/* only top left block pattern is predicted from neighbour */
if(pSC->m_bCtxLeft) {
if (pSC->m_bCtxTop) {
iPredCBP = 1;
}
else {
Int iTopCBP = (pSC->PredInfoPrevRow[c] + mbX)->iCBP;
iPredCBP = (iTopCBP >> 2) & 1; // left: top(2) => 0
}
}
else {
Int iLeftCBP = (pSC->PredInfo[c] + mbX - 1)->iCBP;
iPredCBP = ((iLeftCBP >> 1) & 1); // left(1) => 0
}
iPredCBP |= (iCBP & 0x1) << 1; // [0]->[1]
iPredCBP |= (iCBP & 0x3) << 2; // [0 1]->[2 3]
if (pModel->m_iState[1] == 0) {
iRetval = iPredCBP ^ iCBP;
}
else if (pModel->m_iState[1] == 1) {
iRetval = iCBP;
}
else {
iRetval = iCBP ^ 0xf;
}
pModel->m_iCount0[1] += iNOrig - iNDiff;
SATURATE32(pModel->m_iCount0[1]);
pModel->m_iCount1[1] += 16 - iNOrig - iNDiff;
SATURATE32(pModel->m_iCount1[1]);
if (pModel->m_iCount0[1] < 0) {
if (pModel->m_iCount0[1] < pModel->m_iCount1[1]) {
pModel->m_iState[1] = 1;
}
else {
pModel->m_iState[1] = 2;
}
}
else if (pModel->m_iCount1[1] < 0) {
pModel->m_iState[1] = 2;
}
else {
pModel->m_iState[1] = 0;
}
return iRetval;
}
static Int predCBPC422Enc(CWMImageStrCodec *pSC, Int iCBP, size_t mbX, size_t mbY, size_t c, CCBPModel *pModel)
{
Int iPredCBP = 0, iRetval = 0;
Int iNOrig = NumOnes(iCBP) * 2, iNDiff = AVG_NDIFF;//NumOnes(iPredCBP ^ iCBP);
UNREFERENCED_PARAMETER( mbY );
/* only top left block pattern is predicted from neighbour */
if(pSC->m_bCtxLeft) {
if (pSC->m_bCtxTop) {
iPredCBP = 1;
}
else {
Int iTopCBP = (pSC->PredInfoPrevRow[c] + mbX)->iCBP;
iPredCBP = (iTopCBP >> 6) & 1; // left: top(6) => 0
}
}
else {
Int iLeftCBP = (pSC->PredInfo[c] + mbX - 1)->iCBP;
iPredCBP = ((iLeftCBP >> 1) & 1); // left(1) => 0
}
iPredCBP |= (iCBP & 0x1) << 1; // [0]->[1]
iPredCBP |= (iCBP & 0x3) << 2; // [0 1]->[2 3]
iPredCBP |= (iCBP & 0xc) << 2; // [2 3]->[4 5]
iPredCBP |= (iCBP & 0x30) << 2; // [4 5]->[6 7]
if (pModel->m_iState[1] == 0) {
iRetval = iPredCBP ^ iCBP;
}
else if (pModel->m_iState[1] == 1) {
iRetval = iCBP;
}
else {
iRetval = iCBP ^ 0xff;
}
pModel->m_iCount0[1] += iNOrig - iNDiff;
SATURATE32(pModel->m_iCount0[1]);
pModel->m_iCount1[1] += 16 - iNOrig - iNDiff;
SATURATE32(pModel->m_iCount1[1]);
if (pModel->m_iCount0[1] < 0) {
if (pModel->m_iCount0[1] < pModel->m_iCount1[1]) {
pModel->m_iState[1] = 1;
}
else {
pModel->m_iState[1] = 2;
}
}
else if (pModel->m_iCount1[1] < 0) {
pModel->m_iState[1] = 2;
}
else {
pModel->m_iState[1] = 0;
}
return iRetval;
}
Void predCBPEnc(CWMImageStrCodec* pSC, CCodingContext *pContext)
{
size_t mbX = pSC->cColumn - 1, mbY = pSC->cRow - 1;
CWMIMBInfo * pMBInfo = &(pSC->MBInfo);
int iChannel, i, j;
for(iChannel = 0; iChannel < (int)pSC->m_param.cNumChannels; iChannel ++){
const COLORFORMAT cf = pSC->m_param.cfColorFormat;
const Bool bUV = (iChannel > 0);
const int iNumBlock = (bUV ? (cf == YUV_422 ? 8 : (cf == YUV_420 ? 4 : 16)) : 16);
const int * pOffset = (iNumBlock == 4 ? blkOffsetUV : (iNumBlock == 8 ? blkOffsetUV_422 : blkOffset));
const Int threshold = (1 << pContext->m_aModelAC.m_iFlcBits[bUV ? 1 : 0]) - 1, threshold2 = threshold * 2 + 1;
Int iCBP = 0;
for(j = 0; j < iNumBlock; j ++){
PixelI * pData = pSC->pPlane[iChannel] + pOffset[j];
for(i = 1; i < 16; i ++){
if((unsigned int)(pData[i] + threshold) >= (unsigned int) threshold2){ // significant coeff
iCBP |= (1 << j); // update CBP
break;
}
}
}
pMBInfo->iCBP[iChannel] = (pSC->PredInfo[iChannel] + mbX)->iCBP = iCBP;
if(iNumBlock == 16){
pMBInfo->iDiffCBP[iChannel] = predCBPCEnc(pSC, pMBInfo->iCBP[iChannel], mbX, mbY, iChannel, &pContext->m_aCBPModel);
}
else if(iNumBlock == 8){
pSC->MBInfo.iDiffCBP[iChannel] = predCBPC422Enc(pSC, pMBInfo->iCBP[iChannel], mbX, mbY, iChannel, &pContext->m_aCBPModel);
}
else{
pSC->MBInfo.iDiffCBP[iChannel] = predCBPC420Enc(pSC, pMBInfo->iCBP[iChannel], mbX, mbY, iChannel, &pContext->m_aCBPModel);
}
}
}

2369
jxrlib/image/encode/strenc.c
View file

File diff suppressed because it is too large Load diff

409
jxrlib/image/encode/strenc_x86.c
View file

@ -1,409 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#include "strcodec.h"
#if defined(WMP_OPT_SSE2)
#include <emmintrin.h>
#include <windows.h>
//================================
__m128i g_const_d1;
__m128i g_const_d0x400;
__m128i g_const_d0x7f8;
//================================
#if defined(WMP_OPT_CC_ENC)
__declspec(naked) void __stdcall RGB24_6(
const U8* pbRGB,
size_t cbRGB,
U8* pbYCoCg,
size_t cbYCoCg,
size_t cmb)
{
UNREFERENCED_PARAMETER( pbRGB );
UNREFERENCED_PARAMETER( cbRGB );
UNREFERENCED_PARAMETER( pbYCoCg );
UNREFERENCED_PARAMETER( cbYCoCg );
UNREFERENCED_PARAMETER( cmb );
__asm {
push ebp
push ebx
push esi
push edi
mov ebp, [esp + 36] // $ebp = cmb
mov edx, [esp + 20] // $edx = pbRGB
lea ebp, [ebp + ebp * 2] // $ebp = cmb * 3
mov ecx, [esp + 24] // $ecx = cbRGB
shl ebp, 4 // $ebp = cmb * 3 * 16
mov edi, [esp + 28] // $edi = pbYCoCg
add edx, ebp // $edx = pbRGB + 3 * 16 * cmb
mov ebx, [esp + 32] // $ebx = cbYCoCg
neg ebp
mov eax, esp
and esp, 0xffffff80
sub esp, 64 + 4 * 6
mov [esp], ecx // cbRGB
mov [esp + 4], edx // pbRGB + 3 * 16 * cmb
mov [esp + 8], edi // pbYCoCg
mov dword ptr [esp + 12], 4 // cLoop0 = 4
mov [esp + 16], ebp // -3 * 16 * cmb
mov [esp + 20], eax // original $esp
movdqa xmm3, [g_const_d1]
}
Loop0:
__asm mov edi, [esp + 8] // $edi = pbYCoCg
__asm mov ebp, [esp + 16] // $ebp = -3 * 16 * cmb
Loop1:
__asm {
mov esi, [esp + 4] // $esi = pbRGB + 3 * 16 * cmb
//================
// scanline 0
mov eax, [esi + ebp]
mov edx, [esi + ebp + 4]
mov ecx, [esi + ebp + 8]
add esi, [esp] // $esi += cbRGB
mov [esp + 24], eax
shrd eax, edx, 24
shrd edx, ecx, 16
shr ecx, 8
mov [esp + 24 + 4], eax
mov [esp + 24 + 20], edx
mov [esp + 24 + 16], ecx
// scanline 1
mov eax, [esi + ebp]
mov edx, [esi + ebp + 4]
mov ecx, [esi + ebp + 8]
add esi, [esp]
mov [esp + 24 + 8], eax
shrd eax, edx, 24
shrd edx, ecx, 16
shr ecx, 8
mov [esp + 24 + 12], eax
mov [esp + 24 + 28], edx
mov [esp + 24 + 24], ecx
// scanline 2
mov eax, [esi + ebp]
mov edx, [esi + ebp + 4]
mov ecx, [esi + ebp + 8]
add esi, [esp]
mov [esp + 24 + 40], eax
shrd eax, edx, 24
shrd edx, ecx, 16
shr ecx, 8
mov [esp + 24 + 44], eax
mov [esp + 24 + 60], edx
mov [esp + 24 + 56], ecx
// scanline 3
mov eax, [esi + ebp]
mov edx, [esi + ebp + 4]
mov ecx, [esi + ebp + 8]
add esi, [esp]
mov [esp + 24 + 32], eax
shrd eax, edx, 24
shrd edx, ecx, 16
shr ecx, 8
mov [esp + 24 + 36], eax
mov [esp + 24 + 52], edx
mov [esp + 24 + 48], ecx
//================
// CC 0,1
movdqa xmm0, [esp + 24]
movdqa xmm4, [esp + 24 + 16]
movdqa xmm7, [g_const_d0x7f8]
movdqa xmm1, xmm0
movdqa xmm5, xmm4
movdqa xmm2, xmm0
movdqa xmm6, xmm4
pslld xmm0, 3
pslld xmm4, 3
psrad xmm5, 5
psrad xmm1, 5
psrad xmm2, 13
psrad xmm6, 13
pand xmm0, xmm7 // R
pand xmm4, xmm7
pand xmm1, xmm7 // G
pand xmm5, xmm7
pand xmm2, xmm7 // B
pand xmm6, xmm7
psubd xmm2, xmm0 // b -= r
psubd xmm6, xmm4
movntdq [edi + ebx * 2], xmm2
movntdq [edi + ebx * 2 + 16], xmm6
paddd xmm2, xmm3 // r += ((b + 1) >> 1) - g
paddd xmm6, xmm3
psubd xmm0, xmm1
psubd xmm4, xmm5
psrad xmm2, 1
psrad xmm6, 1
paddd xmm0, xmm2
paddd xmm4, xmm6
movdqa xmm2, xmm0 // g += r >> 1
movdqa xmm6, xmm4
movdqa xmm7, [g_const_d0x400]
psrad xmm2, 1
psrad xmm6, 1
paddd xmm1, xmm2
paddd xmm5, xmm6
pxor xmm2, xmm2
pxor xmm6, xmm6
psubd xmm1, xmm7 // g -= offset
psubd xmm5, xmm7
psubd xmm2, xmm0 // r = -r
psubd xmm6, xmm4
movntdq [edi], xmm1
movntdq [edi + 16], xmm5
movntdq [edi + ebx], xmm2
movntdq [edi + ebx + 16], xmm6
//================
// CC 2,3
movdqa xmm4, [esp + 24 + 48]
movdqa xmm0, [esp + 24 + 32]
movdqa xmm7, [g_const_d0x7f8]
movdqa xmm1, xmm0
movdqa xmm5, xmm4
movdqa xmm2, xmm0
movdqa xmm6, xmm4
pslld xmm0, 3
pslld xmm4, 3
psrad xmm1, 5
psrad xmm5, 5
psrad xmm2, 13
psrad xmm6, 13
pand xmm0, xmm7 // R
pand xmm4, xmm7
pand xmm1, xmm7 // G
pand xmm5, xmm7
pand xmm2, xmm7 // B
pand xmm6, xmm7
psubd xmm2, xmm0 // b -= r
psubd xmm6, xmm4
movntdq [edi + ebx * 2 + 32], xmm2
movntdq [edi + ebx * 2 + 48], xmm6
paddd xmm2, xmm3 // r += ((b + 1) >> 1) - g
paddd xmm6, xmm3
psubd xmm0, xmm1
psubd xmm4, xmm5
psrad xmm2, 1
psrad xmm6, 1
paddd xmm0, xmm2
paddd xmm4, xmm6
movdqa xmm2, xmm0 // g += r >> 1
movdqa xmm6, xmm4
movdqa xmm7, [g_const_d0x400]
psrad xmm2, 1
psrad xmm6, 1
paddd xmm1, xmm2
paddd xmm5, xmm6
pxor xmm2, xmm2
pxor xmm6, xmm6
psubd xmm1, xmm7 // g -= offset
psubd xmm5, xmm7
psubd xmm2, xmm0 // r = -r
psubd xmm6, xmm4
movntdq [edi + 32], xmm1
movntdq [edi + 48], xmm5
movntdq [edi + ebx + 32], xmm2
movntdq [edi + ebx + 48], xmm6
//================
add edi, 256 // pbYCoCg += 256
add ebp, 12 // pbRGB += 12
jnz Loop1
//================
add dword ptr [esp + 8], 64 // pbYCoCg += 64
sub dword ptr [esp + 12], 1 // --cLoop0
mov [esp + 4], esi // pbRGB += cbRGB * 4
jnz Loop0
//================
mov esp, [esp + 20]
pop edi
pop esi
pop ebx
pop ebp
ret 20
}
}
Int inputMBRow_RGB24_6(CWMImageStrCodec* pSC)
{
const U8* const pbRGB = (U8*)pSC->WMIBI.pv;
const size_t cbRGB = pSC->WMIBI.cbStride;
U8* const pbY = (U8*)pSC->p1MBbuffer[0];
U8* const pbU = (U8*)pSC->p1MBbuffer[1];
// U8* const pbV = (U8*)pSC->p1MBbuffer[2];
const size_t cmbColumn = (pSC->WMII.cWidth + 15) / 16;
assert(BD_8 == pSC->WMII.bdBitDepth);
assert(CF_RGB == pSC->WMII.cfColorFormat);
assert(24 == pSC->WMII.cBitsPerUnit);
assert(pSC->WMII.bRGB);
assert(pSC->m_param.bScaledArith);
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;
__m128 owQT[2];
for (iChannel = 0; iChannel < 3; iChannel ++) {
CWMIQuantizer* pQPDC = pTile->pQuantizerDC[iChannel];
CWMIQuantizer* pQPLP = pTile->pQuantizerLP[iChannel] + pMBInfo->iQIndexLP;
CWMIQuantizer* pQPHP = pTile->pQuantizerHP[iChannel] + pMBInfo->iQIndexHP;
__m128 owQT[4] = {
{pQPDC->f1_QP, pQPHP->f1_QP, pQPHP->f1_QP, pQPHP->f1_QP,},
{pQPLP->f1_QP, pQPHP->f1_QP, pQPHP->f1_QP, pQPHP->f1_QP,},
};
owQT[0].m128_f32[0] = pQPDC->f1_QP;
owQT[0].m128_f32[1] = pQPHP->f1_QP;
owQT[0].m128_f32[2] = pQPHP->f1_QP;
owQT[0].m128_f32[3] = pQPHP->f1_QP;
owQT[1].m128_f32[0] = pQPDC->f1_QP;
owQT[1].m128_f32[1] = pQPHP->f1_QP;
owQT[1].m128_f32[2] = pQPHP->f1_QP;
owQT[1].m128_f32[3] = pQPHP->f1_QP;
for(j = 0; j < 16; j ++){
PixelI* pData = pSC->pPlane[iChannel] + blkOffset[j];
if(j == 0) // DC
pData[0] = (pQPDC->iMan == 0 ? QUANT_Mulless(pData[0], pQPDC->iOffset, pQPDC->iExp) : QUANT(pData[0], pQPDC->iOffset, pQPDC->iMan, pQPDC->iExp));
else // LP
pData[0] = (pQPLP->iMan == 0 ? QUANT_Mulless(pData[0], pQPLP->iOffset, pQPLP->iExp) : QUANT(pData[0], pQPLP->iOffset, pQPLP->iMan, pQPLP->iExp));
// quantize HP
for(i = 1; i < 16; i ++)
pData[i] = (pQPHP->iMan == 0 ? QUANT_Mulless(pData[i], pQPHP->iOffset, pQPHP->iExp) : QUANT(pData[i], pQPHP->iOffset, pQPHP->iMan, pQPHP->iExp));
}
}
for (iChannel = 0; iChannel < 3; iChannel ++) {
I32* pDC = pSC->MBInfo.iBlockDC[iChannel];
PixelI* pData = pSC->pPlane[iChannel];
for(i = 0; i < 16; i ++){
pDC[i] = pData[dctIndex[2][i]];
}
}
return 0;
}
#endif
#endif
#endif
//================================
void StrEncOpt(CWMImageStrCodec* pSC)
{
#if defined(WMP_OPT_SSE2)
if (IsProcessorFeaturePresent(PF_XMMI64_INSTRUCTIONS_AVAILABLE) &&
pSC->WMII.fPaddedUserBuffer &&
1)
{
CWMImageInfo* pII = &pSC->WMII;
// CWMIStrCodecParam* pSCP = &pSC->WMISCP;
g_const_d1 = _mm_set_epi32(1, 1, 1, 1);
g_const_d0x400 = _mm_set_epi32(0x400, 0x400, 0x400, 0x400);
g_const_d0x7f8 = _mm_set_epi32(0x7f8, 0x7f8, 0x7f8, 0x7f8);
if (BD_8 == pII->bdBitDepth &&
CF_RGB == pII->cfColorFormat &&
YUV_444 == pSC->m_param.cfColorFormat &&
24 == pII->cBitsPerUnit &&
pII->bRGB &&
pSC->m_param.bScaledArith &&
pSC->p1MBbuffer[1] - pSC->p1MBbuffer[0] == pSC->p1MBbuffer[2] - pSC->p1MBbuffer[1] &&
1)
{
#if defined(WMP_OPT_CC_ENC)
pSC->Load = inputMBRow_RGB24_6;
#endif
}
}
#else
UNREFERENCED_PARAMETER( pSC );
#endif
}

511
jxrlib/image/sys/adapthuff.c
View file

@ -1,511 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#include "strcodec.h"
#ifdef MEM_TRACE
#define TRACE_MALLOC 1
#define TRACE_NEW 0
#define TRACE_HEAP 0
#include "memtrace.h"
#endif
// Huffman lookup tables
static const short g4HuffLookupTable[40] = {
19,19,19,19,27,27,27,27,10,10,10,10,10,10,10,10,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
0,0,0,0,0,0,0,0 };
static const short g5HuffLookupTable[2][42] = {{
28,28,36,36,19,19,19,19,10,10,10,10,10,10,10,10,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
0,0,0,0,0,0,0,0,0,0 },
{
11,11,11,11,19,19,19,19,27,27,27,27,35,35,35,35,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
0,0,0,0,0,0,0,0,0,0 }};
static const short g6HuffLookupTable[4][44] = {{
13,29,44,44,19,19,19,19,34,34,34,34,34,34,34,34,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
0,0,0,0,0,0,0,0,0,0,0,0 },
{
12,12,28,28,43,43,43,43,2,2,2,2,2,2,2,2,
18,18,18,18,18,18,18,18,34,34,34,34,34,34,34,34,
0,0,0,0,0,0,0,0,0,0,0,0 },
{
4,4,12,12,43,43,43,43,18,18,18,18,18,18,18,18,
26,26,26,26,26,26,26,26,34,34,34,34,34,34,34,34,
0,0,0,0,0,0,0,0,0,0,0,0 },
{
5,13,36,36,43,43,43,43,18,18,18,18,18,18,18,18,
25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,
0,0,0,0,0,0,0,0,0,0,0,0 }};
static const short g7HuffLookupTable[2][46] = {{
45,53,36,36,27,27,27,27,2,2,2,2,2,2,2,2,
10,10,10,10,10,10,10,10,18,18,18,18,18,18,18,18,
0,0,0,0,0,0,0,0,0,0,0,0,0,0 },
{
-32736,37,28,28,19,19,19,19,10,10,10,10,10,10,10,10,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
5,6,0,0,0,0,0,0,0,0,0,0,0,0 }};
static const short g8HuffLookupTable[2][48] = {{
53,21,28,28,11,11,11,11,43,43,43,43,59,59,59,59,
2,2,2,2,2,2,2,2,34,34,34,34,34,34,34,34,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },
{
52,52,20,20,3,3,3,3,11,11,11,11,27,27,27,27,
35,35,35,35,43,43,43,43,58,58,58,58,58,58,58,58,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }};
static const short g9HuffLookupTable[2][50] = {{
13,29,37,61,20,20,68,68,3,3,3,3,51,51,51,51,
41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0 },
{
-32736,53,28,28,11,11,11,11,19,19,19,19,43,43,43,43,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-32734,4,7,8,0,0,0,0,0,0,0,0,0,0,0,0,
0,0 }};
static const short g12HuffLookupTable[5][56] = {{
-32736,5,76,76,37,53,69,85,43,43,43,43,91,91,91,91,
57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,
-32734,1,2,3,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0 },
{
-32736,85,13,53,4,4,36,36,43,43,43,43,67,67,67,67,
75,75,75,75,91,91,91,91,58,58,58,58,58,58,58,58,
2,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0 },
{
-32736,37,92,92,11,11,11,11,43,43,43,43,59,59,59,59,
67,67,67,67,75,75,75,75,2,2,2,2,2,2,2,2,
-32734,-32732,2,3,6,10,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0 },
{
-32736,29,37,69,3,3,3,3,43,43,43,43,59,59,59,59,
75,75,75,75,91,91,91,91,10,10,10,10,10,10,10,10,
-32734,10,2,6,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0 },
{
-32736,93,28,28,60,60,76,76,3,3,3,3,43,43,43,43,
9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
-32734,-32732,-32730,2,4,8,6,10,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0 }};
/**********************************************************************
Allocation and dellocation
**********************************************************************/
Void Clean (CAdaptiveHuffman *pAdHuff)
{
if (pAdHuff == NULL)
return;
free (pAdHuff);
}
CAdaptiveHuffman *Allocate (Int iNSymbols, CODINGMODE cm)
{
CAdaptiveHuffman *pAdHuff = (CAdaptiveHuffman *) malloc (sizeof (CAdaptiveHuffman));
UNREFERENCED_PARAMETER(cm);
if (pAdHuff == NULL)
return NULL;
if (iNSymbols > 255 || iNSymbols <= 0)
goto ErrorExit;
memset (pAdHuff, 0, sizeof (CAdaptiveHuffman));
pAdHuff->m_iNSymbols = iNSymbols;
pAdHuff->m_pDelta = NULL;
pAdHuff->m_iDiscriminant = pAdHuff->m_iUpperBound = pAdHuff->m_iLowerBound = 0;
return pAdHuff;
ErrorExit:
Clean (pAdHuff);
return NULL;
}
/**********************************************************************
Adapt Huffman table
**********************************************************************/
// Alphabet size = 4
static const Int g_Index4Table[] = {
1,2,3,3
};
static const Int g4CodeTable[] = {
4,
1, 1,
1, 2,
0, 3,
1, 3
};
// Alphabet size = 5
static const Int g_Index5Table[] = {
1,2,3,4,4,
1,3,3,3,3
};
static const Int g5CodeTable[] = {
5,
1, 1,
1, 2,
1, 3,
0, 4,
1, 4,
5,
1, 1,
0, 3,
1, 3,
2, 3,
3, 3,
};
static const Int g5DeltaTable[] = { 0,-1,0,1,1 };
// Alphabet size = 6
static const Int g_Index6Table[] = {
1,5,3,5,2,4,
2,4,2,4,2,3,
4,4,2,2,2,3,
5,5,2,1,4,3,
};
static const Int g6CodeTable[] = {
6,
1, 1,
0, 5,
1, 3,
1, 5,
1, 2,
1, 4,
6,
1, 2,
0, 4,
2, 2,
1, 4,
3, 2,
1, 3,
6,
0, 4,
1, 4,
1, 2,
2, 2,
3, 2,
1, 3,
6,
0, 5,
1, 5,
1, 2,
1, 1,
1, 4,
1, 3
};
static const Int g6DeltaTable[] = {
-1, 1, 1, 1, 0, 1,
-2, 0, 0, 2, 0, 0,
-1,-1, 0, 1,-2, 0
};
// Alphabet size = 7
static const Int g_Index7Table[] = { 2,2,2,3,4,5,5,
1,2,3,4,5,6,6 };
static const Int g7CodeTable[] = {
7,
1, 2,
2, 2,
3, 2,
1, 3,
1, 4,
0, 5,
1, 5,
7,
1, 1,
1, 2,
1, 3,
1, 4,
1, 5,
0, 6,
1, 6
};
static const Int g7DeltaTable[] = { 1,0,-1,-1,-1,-1,-1 };
// Alphabet size = 8
static const Int g_Index8Table[] = { 2,3,5,4,2,3,5,3,
3,3,4,3,3,3,4,2};
static const Int g8CodeTable[] = {
8,
2, 2,
1, 3,
1, 5,
1, 4,
3, 2,
2, 3,
0, 5,
3, 3,
8,
1, 3,
2, 3,
1, 4,
3, 3,
4, 3,
5, 3,
0, 4,
3, 2
};
static const Int g8DeltaTable[] = { -1,0,1,1,-1,0,1,1 };
static const Int g_Index9Table[] = {
3,5,4,5,5,1,3,5,4,
1,3,3,4,6,3,5,7,7,
};
static const Int g9CodeTable[] = {
9,
2, 3,
0, 5,
2, 4,
1, 5,
2, 5,
1, 1,
3, 3,
3, 5,
3, 4,
9,
1, 1,
1, 3,
2, 3,
1, 4,
1, 6,
3, 3,
1, 5,
0, 7,
1, 7,
};
static const Int g9DeltaTable[] = { 2,2,1,1,-1,-2,-2,-2,-3 };
// Alphabet size = 12
static const Int g_Index12Table[] = { // index12 is the most critical symbol
5,6,7,7,5,3,5,1,5,4,5,3,
4,5,6,6,4,3,5,2,3,3,5,3,
2,3,7,7,5,3,7,3,3,3,7,4,
3,2,7,5,5,3,7,3,5,3,6,3,
3,1,7,4,7,3,8,4,7,4,8,5,
};
static const Int g12CodeTable[] = {
12,
1, 5,
1, 6,
0, 7,
1, 7,
4, 5,
2, 3,
5, 5,
1, 1,
6, 5,
1, 4,
7, 5,
3, 3,
12,
2, 4,
2, 5,
0, 6,
1, 6,
3, 4,
2, 3,
3, 5,
3, 2,
3, 3,
4, 3,
1, 5,
5, 3,
12,
3, 2,
1, 3,
0, 7,
1, 7,
1, 5,
2, 3,
2, 7,
3, 3,
4, 3,
5, 3,
3, 7,
1, 4,
12,
1, 3,
3, 2,
0, 7,
1, 5,
2, 5,
2, 3,
1, 7,
3, 3,
3, 5,
4, 3,
1, 6,
5, 3,
12,
2, 3,
1, 1,
1, 7,
1, 4,
2, 7,
3, 3,
0, 8,
2, 4,
3, 7,
3, 4,
1, 8,
1, 5
};
static const Int g12DeltaTable[] = {
1, 1, 1, 1, 1, 0, 0,-1, 2, 1, 0, 0,
2, 2,-1,-1,-1, 0,-2,-1, 0, 0,-2,-1,
-1, 1, 0, 2, 0, 0, 0, 0,-2, 0, 1, 1,
0, 1, 0, 1,-2, 0,-1,-1,-2,-1,-2,-2
};
/**********************************************************************
Adapt fixed length codes based on discriminant
**********************************************************************/
static const Int THRESHOLD = 8;
static const Int MEMORY = 8;
Void AdaptDiscriminant (CAdaptiveHuffman *pAdHuff)
{
Int iSym = pAdHuff->m_iNSymbols, t, dL, dH;
const Int *pCodes, *pDelta = NULL;
Bool bChange = FALSE;
static const Int gMaxTables[] = { 0,0,0,0, 1,2, 4,2, 2,2, 0,0,5 };
static const Int gSecondDisc[]= { 0,0,0,0, 0,0, 1,0, 0,0, 0,0,1 };
if (!pAdHuff->m_bInitialize) {
pAdHuff->m_bInitialize = 1;
pAdHuff->m_iDiscriminant = pAdHuff->m_iDiscriminant1 = 0;
pAdHuff->m_iTableIndex = gSecondDisc[iSym];//(gMaxTables[iSym] - 1) >> 1;
}
dL = dH = pAdHuff->m_iDiscriminant;
if (gSecondDisc[iSym]) {
dH = pAdHuff->m_iDiscriminant1;
}
if (dL < pAdHuff->m_iLowerBound) {
pAdHuff->m_iTableIndex--;
bChange = TRUE;
}
else if (dH > pAdHuff->m_iUpperBound) {
pAdHuff->m_iTableIndex++;
bChange = TRUE;
}
if (bChange) {
/** if initialization is fixed, we can exit on !bChange **/
pAdHuff->m_iDiscriminant = 0;
pAdHuff->m_iDiscriminant1 = 0;
}
{
if (pAdHuff->m_iDiscriminant < -THRESHOLD * MEMORY)
pAdHuff->m_iDiscriminant = -THRESHOLD * MEMORY;
else if (pAdHuff->m_iDiscriminant > THRESHOLD * MEMORY)
pAdHuff->m_iDiscriminant = THRESHOLD * MEMORY;
if (pAdHuff->m_iDiscriminant1 < -THRESHOLD * MEMORY)
pAdHuff->m_iDiscriminant1 = -THRESHOLD * MEMORY;
else if (pAdHuff->m_iDiscriminant1 > THRESHOLD * MEMORY)
pAdHuff->m_iDiscriminant1 = THRESHOLD * MEMORY;
}
t = pAdHuff->m_iTableIndex;
assert (t >= 0);
assert (t < gMaxTables[iSym]);
//pAdHuff->m_iDiscriminant >>= 1;
pAdHuff->m_iLowerBound = (t == 0) ? (-1 << 31) : -THRESHOLD;
pAdHuff->m_iUpperBound = (t == gMaxTables[iSym] - 1) ? (1 << 30) : THRESHOLD;
switch (iSym) {
case 4:
pCodes = g4CodeTable;
pAdHuff->m_hufDecTable = (short *) g4HuffLookupTable;
break;
case 5:
pCodes = g5CodeTable + (iSym * 2 + 1) * t;
pDelta = g5DeltaTable;
pAdHuff->m_hufDecTable = g5HuffLookupTable[t];
break;
case 6:
pCodes = g6CodeTable + (iSym * 2 + 1) * t;
pAdHuff->m_pDelta1 = g6DeltaTable + iSym * (t - (t + 1 == gMaxTables[iSym]));
pDelta = g6DeltaTable + (t - 1 + (t == 0)) * iSym;
pAdHuff->m_hufDecTable = g6HuffLookupTable[t];
break;
case 7:
pCodes = g7CodeTable + (iSym * 2 + 1) * t;
pDelta = g7DeltaTable;
pAdHuff->m_hufDecTable = g7HuffLookupTable[t];
break;
case 8:
//printf ("%d ", t);
pCodes = g8CodeTable;// + (iSym * 2 + 1) * t;
//pDelta = g8DeltaTable;
pAdHuff->m_hufDecTable = g8HuffLookupTable[0];
break;
case 9:
pCodes = g9CodeTable + (iSym * 2 + 1) * t;
pDelta = g9DeltaTable;
pAdHuff->m_hufDecTable = g9HuffLookupTable[t];
break;
case 12:
pCodes = g12CodeTable + (iSym * 2 + 1) * t;
pAdHuff->m_pDelta1 = g12DeltaTable + iSym * (t - (t + 1 == gMaxTables[iSym]));
pDelta = g12DeltaTable + (t - 1 + (t == 0)) * iSym;
pAdHuff->m_hufDecTable = g12HuffLookupTable[t];
break;
default:
assert (0); // undefined fixed length table
return;
}
pAdHuff->m_pTable = pCodes;
pAdHuff->m_pDelta = pDelta;
}

61
jxrlib/image/sys/ansi.h
View file

@ -1,61 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#pragma once
//================================
// bitio functions
//================================
#define PACKETLENGTH (1U<<12) // 4kB
#define readIS_L1(pSC, pIO) readIS(pSC, pIO)
#define readIS_L2(pSC, pIO) (void)(pSC, pIO)
#define writeIS_L1(pSC, pIO) writeIS(pSC, pIO)
#define writeIS_L2(pSC, pIO) (void)(pSC, pIO)
//================================
// common defines
//================================
#define FORCE_INLINE
#define CDECL
#if __LP64__
#define UINTPTR_T unsigned long long
#define INTPTR_T long long
#else
#define UINTPTR_T unsigned int
#define INTPTR_T int
#endif
//================================
// quantization optimization
//================================
//#define RECIP_QUANT_OPT

131
jxrlib/image/sys/common.h
View file

@ -1,131 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#ifndef WMI_COMMON_H
#define WMI_COMMON_H
/*************************************************************************
// Common typedef's
*************************************************************************/
typedef enum { ENCODER = 0, DECODER = 1 } CODINGMODE;
typedef enum tagBand
{
BAND_HEADER = 0,
BAND_DC = 1,
BAND_LP = 2,
BAND_AC = 3,
BAND_FL = 4
} BAND;
/*************************************************************************
struct / class definitions
*************************************************************************/
//#define SIGNATURE_BYTES 8 // Bytes for GDI+ signature
#define CODEC_VERSION 1
#define CODEC_SUBVERSION 0
#define CODEC_SUBVERSION_NEWSCALING_SOFT_TILES 1
#define CODEC_SUBVERSION_NEWSCALING_HARD_TILES 9
#define CONTEXTX 8
#define CTDC 5
#define NUMVLCTABLES 21 // CONTEXTX * 2 + CTDC
#define AVG_NDIFF 3
#define MAXTOTAL 32767 // 511 should be enough
/** Quantization related defines **/
#define SHIFTZERO 1 /* >= 0 */
#define QPFRACBITS 2 /* or 0 only supported */
/** adaptive huffman encoding / decoding struct **/
typedef struct CAdaptiveHuffman
{
Int m_iNSymbols;
const Int *m_pTable;
const Int *m_pDelta, *m_pDelta1;
Int m_iTableIndex;
const short *m_hufDecTable;
Bool m_bInitialize;
//Char m_pLabel[8]; // for debugging - label attached to constructor
Int m_iDiscriminant, m_iDiscriminant1;
Int m_iUpperBound;
Int m_iLowerBound;
} CAdaptiveHuffman;
/************************************************************************************
Context structures
************************************************************************************/
typedef struct CAdaptiveModel {
Int m_iFlcState[2];
Int m_iFlcBits[2];
BAND m_band;
} CAdaptiveModel;
typedef struct CCBPModel {
Int m_iCount0[2];
Int m_iCount1[2];
Int m_iState[2];
} CCBPModel;
/*************************************************************************
globals
*************************************************************************/
extern Int grgiZigzagInv4x4_lowpass[];
extern Int grgiZigzagInv4x4H[];
extern Int grgiZigzagInv4x4V[];
extern const Int gSignificantRunBin[];
extern const Int gSignificantRunFixedLength[];
static const Int cblkChromas[] = {0,4,8,16, 16,16,16, 0,0};
/*************************************************************************
function declarations
*************************************************************************/
// common utilities
Void Clean (CAdaptiveHuffman *pAdHuff);
CAdaptiveHuffman *Allocate (Int iNSymbols, CODINGMODE cm);
/* Timing functions */
void reset_timing(double *time);
void report_timing(const char *s, double time);
// static double timeperclock;
/** adaptive model functions **/
Void UpdateModelMB (COLORFORMAT cf, Int iChannels, Int iLaplacianMean[], CAdaptiveModel *m_pModel);
/** adaptive huffman encoder / decoder functions **/
Void Adapt (CAdaptiveHuffman *pAdHuff, Bool bFixedTables);
Void AdaptFixed (CAdaptiveHuffman *pAdHuff);
Void AdaptDiscriminant (CAdaptiveHuffman *pAdHuff);
#ifndef _PREFAST_
#pragma warning(disable:4068)
#endif
#endif // WMI_COMMON_H

183
jxrlib/image/sys/image.c
View file

@ -1,183 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#include "strcodec.h"
// #include "xplatform_image.h"
#ifdef MEM_TRACE
#define TRACE_MALLOC 1
#define TRACE_NEW 0
#define TRACE_HEAP 0
#include "memtrace.h"
#endif
#include <stdlib.h>
#include <string.h>
#if !(defined(__ANSI__))
// Desktop
#include <windows.h>
#else
// ANSI
#include <time.h>
#endif
Int grgiZigzagInv4x4_lowpass [] = {
0, 1, 4, 5, 2, 8, 6, 9,
3, 12, 10, 7, 13, 11, 14, 15
};
Int grgiZigzagInv4x4H [] = {
0, 1, 4, 5, 2, 8, 6, 9,
3, 12, 10, 7, 13, 11, 14, 15
};
Int grgiZigzagInv4x4V [] = {
0, 4, 8, 5, 1, 12, 9, 6, 2, 13, 3, 15, 7, 10, 14, 11
};
const Int gSignificantRunBin[] = {
-1,-1,-1,-1,
2,2,2,
1,1,1,1,
0,0,0,0
};
const Int gSignificantRunFixedLength[] = {
0,0,1,1,3,
0,0,1,1,2,
0,0,0,0,1,
};
/*************************************************************************
UpdateModelMB : update adaptive model at end of macroblock
(for lowest resolution only)
*************************************************************************/
#define MODELWEIGHT 70//90
Void UpdateModelMB (COLORFORMAT cf, Int iChannels, Int iLaplacianMean[], CAdaptiveModel *pModel)
{
Int j;
static const Int aWeight0[3] = { 240/*DC*/, 12/*LP*/, 1 };
static const Int aWeight1[3][MAX_CHANNELS] = {
{ 0,240,120,80, 60,48,40,34, 30,27,24,22, 20,18,17,16 },
{ 0,12,6,4, 3,2,2,2, 2,1,1,1, 1,1,1,1 },
{ 0,16,8,5, 4,3,3,2, 2,2,2,1, 1,1,1,1 }
};
static const Int aWeight2[6] = { 120,37,2,/*420*/ 120,18,1/*422*/ };
iLaplacianMean[0] *= aWeight0[pModel->m_band - BAND_DC];
if (cf == YUV_420) {
iLaplacianMean[1] *= aWeight2[pModel->m_band - BAND_DC];
}
else if (cf == YUV_422) {
iLaplacianMean[1] *= aWeight2[3 + (pModel->m_band) - BAND_DC];
}
else {
iLaplacianMean[1] *= aWeight1[pModel->m_band - BAND_DC][iChannels - 1];
if (pModel->m_band == BAND_AC)
iLaplacianMean[1] >>= 4;
}
for (j = 0; j < 2; j++) {
Int iLM = iLaplacianMean[j];
Int iMS = pModel->m_iFlcState[j];
Int iDelta = (iLM - MODELWEIGHT) >> 2;
if (iDelta <= -8) {
iDelta += 4;
if (iDelta < -16)
iDelta = -16;
iMS += iDelta;
if (iMS < -8) {
if (pModel->m_iFlcBits[j] == 0)
iMS = -8;
else {
iMS = 0;
pModel->m_iFlcBits[j]--;
}
}
}
else if (iDelta >= 8) {
iDelta -= 4;
if (iDelta > 15)
iDelta = 15;
iMS += iDelta;
if (iMS > 8) {
if (pModel->m_iFlcBits[j] >= 15) {
pModel->m_iFlcBits[j] = 15;
iMS = 8;
}
else {
iMS = 0;
pModel->m_iFlcBits[j]++;
}
}
}
pModel->m_iFlcState[j] = iMS;
if (cf == Y_ONLY)
break;
}
}
Void ResetCodingContext(CCodingContext *pContext)
{
// reset bit reduction models
memset (&(pContext->m_aModelAC), 0, sizeof(CAdaptiveModel));
pContext->m_aModelAC.m_band = BAND_AC;
memset (&(pContext->m_aModelLP), 0, sizeof(CAdaptiveModel));
pContext->m_aModelLP.m_band = BAND_LP;
pContext->m_aModelLP.m_iFlcBits[0] = pContext->m_aModelLP.m_iFlcBits[1] = 4;
memset (&(pContext->m_aModelDC), 0, sizeof(CAdaptiveModel));
pContext->m_aModelDC.m_band = BAND_DC;
pContext->m_aModelDC.m_iFlcBits[0] = pContext->m_aModelDC.m_iFlcBits[1] = 8;
// reset CBP models
pContext->m_iCBPCountMax = pContext->m_iCBPCountZero = 1;
pContext->m_aCBPModel.m_iCount0[0] = pContext->m_aCBPModel.m_iCount0[1] = -4;
pContext->m_aCBPModel.m_iCount1[0] = pContext->m_aCBPModel.m_iCount1[1] = 4;
pContext->m_aCBPModel.m_iState[0] = pContext->m_aCBPModel.m_iState[1] = 0;
}
/*************************************************************************
Initialize zigzag scan parameters
*************************************************************************/
Void InitZigzagScan(CCodingContext * pContext)
{
if (NULL != pContext) {
Int i;
for (i=0; i<16; i++) {
pContext->m_aScanLowpass[i].uScan = grgiZigzagInv4x4_lowpass[i];
pContext->m_aScanHoriz[i].uScan = dctIndex[0][grgiZigzagInv4x4H[i]];
pContext->m_aScanVert[i].uScan = dctIndex[0][grgiZigzagInv4x4V[i]];
}
}
}

115
jxrlib/image/sys/perfTimer.h
View file

@ -1,115 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#ifndef __PERFTIMER_H_
#define __PERFTIMER_H_
//***************************************************************************
// Description
//
// Performance timer API used to measure codec performance. The underlying
// implementation of this API may vary - from ANSI-C implementation via clock,
// Win32 implementation via QueryPerformanceCounter or GetProcessTimes. At
// present we only support one implementation of this PerfTimer "object".
// You choose the implementation by choosing which one of the many files
// to compile and link with your application.
//***************************************************************************
#ifdef DISABLE_PERF_MEASUREMENT
#define PERFTIMER_ONLY(code)
#define PERFTIMER_NEW(fPerf, ppPerfTimer)
#define PERFTIMER_DELETE(fPerf, ppPerfTimer)
#define PERFTIMER_START(fPerf, pPerfTimer)
#define PERFTIMER_STOP(fPerf, pPerfTimer)
#define PERFTIMER_GETRESULTS(fPerf, pPerfTimer, pResults)
#define PERFTIMER_COPYSTARTTIME(fPerf, pDst, pSrc)
#define PERFTIMER_REPORT(fPerf, pCodec)
#else // DISABLE_PERF_MEASUREMENT
#define PERFTIMER_ONLY(code) code
#define PERFTIMER_NEW(fPerf, ppPerfTimer) if (fPerf) {Bool b = b = PerfTimerNew(ppPerfTimer); assert(b);};
#define PERFTIMER_DELETE(fPerf, pPerfTimer) if (fPerf) {PerfTimerDelete(pPerfTimer);};
#define PERFTIMER_START(fPerf, pPerfTimer) if (fPerf) {Bool b = b = PerfTimerStart(pPerfTimer); assert(b);};
#define PERFTIMER_STOP(fPerf, pPerfTimer) if (fPerf) {Bool b = b = PerfTimerStop(pPerfTimer); assert(b);};
#define PERFTIMER_GETRESULTS(fPerf, pPerfTimer, pResults) \
if (fPerf) {Bool b = b = PerfTimerGetResults((pPerfTimer), (pResults)); assert(b);};
#define PERFTIMER_COPYSTARTTIME(fPerf, pDst, pSrc) \
if (fPerf) {Bool b = b = PerfTimerCopyStartTime((pDst), (pSrc)); assert(b);};
#define PERFTIMER_REPORT(fPerf, pCodec) \
if (fPerf) {OutputPerfTimerReport(pCodec);};
#endif // DISABLE_PERF_MEASUREMENT
//***************************************************************************
// Data Types
//***************************************************************************
typedef U64 PERFTIMERTIME;
typedef struct PERFTIMERRESULTS
{
PERFTIMERTIME iElapsedTime; // In nanoseconds or CPU cycles
PERFTIMERTIME iTicksPerSecond; // Number of ticks per second (clock frequency)
PERFTIMERTIME iZeroTimeIntervals; // Number of zero-time intervals.
// Presence of zero-time intervals may indicate insufficient clock precision
} PERFTIMERRESULTS;
#define NANOSECONDS_PER_SECOND 1000000000
//***************************************************************************
// Data Declarations
//***************************************************************************
typedef enum
{
CS_UNINIT,
CS_RUNNING,
CS_STOPPED,
} CLOCKSTATE;
typedef struct PERFTIMERSTATE
{
CLOCKSTATE eState;
PERFTIMERTIME iElapsedTime;
PERFTIMERTIME iPrevStartTime;
PERFTIMERTIME iZeroTimeIntervals;
} PERFTIMERSTATE;
//***************************************************************************
// Functions and Macros
//***************************************************************************
Bool PerfTimerNew(PERFTIMERSTATE **ppNewPerfTimer);
void PerfTimerDelete(PERFTIMERSTATE *pThisPerfTimer);
Bool PerfTimerStart(PERFTIMERSTATE *pThisPerfTimer);
Bool PerfTimerStop(PERFTIMERSTATE *pThisPerfTimer);
Bool PerfTimerGetResults(PERFTIMERSTATE *pThisPerfTimer,
PERFTIMERRESULTS *pPerfTimerResults);
Bool PerfTimerCopyStartTime(PERFTIMERSTATE *pDestPerfTimer,
PERFTIMERSTATE *pSrcPerfTimer);
#endif // __PERFTIMER_H_

274
jxrlib/image/sys/perfTimerANSI.c
View file

@ -1,274 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
//***************************************************************************
// Includes
//***************************************************************************
#include <time.h>
#include "strcodec.h"
#include "perfTimer.h"
#ifndef DISABLE_PERF_MEASUREMENT
//***************************************************************************
// Private Functions
//***************************************************************************
Bool AccumulateTime(PERFTIMERSTATE *pState, PERFTIMERTIME *ptAccumulator)
{
Bool fResult = FALSE;
clock_t iStopTime;
clock_t iIntervalTime;
iStopTime = clock();
// Check clock result
if ((clock_t)-1 == iStopTime)
{
TraceResult(WM_E_CLOCKFAILURE);
goto exit;
}
iIntervalTime = (iStopTime - (clock_t) pState->iPrevStartTime);
// Check for zero-time interval
if (0 == iIntervalTime)
pState->iZeroTimeIntervals += 1;
// Accumulate current interval's time
*ptAccumulator += iIntervalTime;
fResult = TRUE;
exit:
return fResult;
}
//***************************************************************************
// Public Functions
//***************************************************************************
Bool PerfTimerNew(PERFTIMERSTATE **ppNewPerfTimer)
{
Bool fResult = FALSE;
PERFTIMERSTATE *pState = NULL;
clock_t ctResult;
// Check if this clock works
ctResult = clock();
if ((clock_t)-1 == ctResult)
{
TraceResult(WM_E_CLOCKFAILURE);
goto exit;
}
pState = malloc(sizeof(*pState));
if (NULL == pState)
{
TraceResult(E_OUTOFMEMORY);
goto exit;
}
memset(pState, 0, sizeof(*pState));
pState->eState = CS_STOPPED;
pState->iElapsedTime = 0;
pState->iPrevStartTime = 0;
pState->iZeroTimeIntervals = 0;
*ppNewPerfTimer = pState;
fResult = TRUE;
exit:
assert(fResult || NULL == pState); // If error, we need to free pState
return fResult;
} // PerfTimerNew
void PerfTimerDelete(PERFTIMERSTATE *pState)
{
free(pState);
} // PerfTimerDelete
Bool PerfTimerStart(PERFTIMERSTATE *pState)
{
Bool fResult = FALSE;
if (NULL == pState)
{
// Can happen because we typically ignore errors and use a single bool to
// control all perf timing (some of which can fail to init)
goto exit;
}
// Make sure we are in the right state
if (CS_STOPPED != pState->eState)
{
assert(FALSE);
goto exit;
}
pState->iPrevStartTime = clock();
// Check clock result
if ((clock_t)-1 == pState->iPrevStartTime)
{
TraceResult(WM_E_CLOCKFAILURE);
goto exit;
}
pState->eState = CS_RUNNING;
fResult = TRUE;
exit:
return fResult;
} // PerfTimerStart
Bool PerfTimerStop(PERFTIMERSTATE *pState)
{
Bool fResult = FALSE;
if (NULL == pState)
{
// Can happen because we typically ignore errors and use a single bool to
// control all perf timing (some of which can fail to init)
goto exit;
}
// Make sure we are in the right state
if (CS_RUNNING != pState->eState)
{
assert(FALSE);
goto exit;
}
fResult = AccumulateTime(pState, &pState->iElapsedTime);
pState->eState = CS_STOPPED;
fResult = TRUE;
exit:
return fResult;
} // PerfTimerStop
Bool PerfTimerGetResults(PERFTIMERSTATE *pState, PERFTIMERRESULTS *pResults)
{
Bool fResult = FALSE;
PERFTIMERTIME iElapsedTime;
if (NULL == pState)
{
// Can happen because we typically ignore errors and use a single bool to
// control all perf timing (some of which can fail to init)
goto exit;
}
// Make sure we are in the right state
if (CS_STOPPED != pState->eState && CS_RUNNING != pState->eState)
{
assert(FALSE);
goto exit;
}
iElapsedTime = pState->iElapsedTime;
if (CS_RUNNING == pState->eState)
{
// Must take a "checkpoint" time reading
fResult = AccumulateTime(pState, &iElapsedTime);
if (FALSE == fResult)
goto exit;
}
// Convert clock ticks to nanoseconds.
// Use floating point for ease of math. If your platform really blows
// with floating point, replace this with appropriate integer calculation
// based on your clock interval.
pResults->iElapsedTime = (PERFTIMERTIME)((float)iElapsedTime *
((float)NANOSECONDS_PER_SECOND / (float)CLOCKS_PER_SEC));
pResults->iTicksPerSecond = CLOCKS_PER_SEC;
pResults->iZeroTimeIntervals = pState->iZeroTimeIntervals;
fResult = TRUE;
exit:
return fResult;
} // PerfTimerGetResults
Bool PerfTimerCopyStartTime(PERFTIMERSTATE *pDestPerfTimer,
PERFTIMERSTATE *pSrcPerfTimer)
{
Bool fResult = FALSE;
if (NULL == pDestPerfTimer)
{
TraceResult(E_INVALIDARG);
goto exit;
}
if (NULL == pSrcPerfTimer)
{
TraceResult(E_INVALIDARG);
goto exit;
}
// Check that both timers are in proper state - both must be running
if (CS_RUNNING != pDestPerfTimer->eState)
{
TraceResult(WM_E_INVALIDSTATE);
goto exit;
}
if (CS_RUNNING != pSrcPerfTimer->eState)
{
TraceResult(WM_E_INVALIDSTATE);
goto exit;
}
if (0 != pDestPerfTimer->iElapsedTime)
{
// If iElapsedTime is non-zero, caller won't get what he is expecting
// when he calls PerfTimerGetResults
TraceResult(WM_E_INVALIDSTATE);
goto exit;
}
pDestPerfTimer->iPrevStartTime = pSrcPerfTimer->iPrevStartTime;
fResult = TRUE;
exit:
return fResult;
} // PerfTimerCopyStartTime
#endif // DISABLE_PERF_MEASUREMENT

306
jxrlib/image/sys/strPredQuant.c
View file

@ -1,306 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#include "strcodec.h"
#define ORIENT_WEIGHT 4
/* reciprocal (pMantissa, exponent) lookup table */
typedef struct tagQPManExp
{
int iMan;
int iExp;
} QPManExp;
static QPManExp gs_QPRecipTable[32] = {
{0x0, 0}, // 0, invalid
{0x0, 0}, // 1, lossless
{0x0, 1}, // 2
{0xaaaaaaab, 1},
{0x0, 2}, // 4
{0xcccccccd, 2},
{0xaaaaaaab, 2},
{0x92492493, 2},
{0x0, 3}, // 8
{0xe38e38e4, 3},
{0xcccccccd, 3},
{0xba2e8ba3, 3},
{0xaaaaaaab, 3},
{0x9d89d89e, 3},
{0x92492493, 3},
{0x88888889, 3},
{0x0, 4}, // 16
{0xf0f0f0f1, 4},
{0xe38e38e4, 4},
{0xd79435e6, 4},
{0xcccccccd, 4},
{0xc30c30c4, 4},
{0xba2e8ba3, 4},
{0xb21642c9, 4},
{0xaaaaaaab, 4},
{0xa3d70a3e, 4},
{0x9d89d89e, 4},
{0x97b425ee, 4},
{0x92492493, 4},
{0x8d3dcb09, 4},
{0x88888889, 4},
{0x84210843, 4},
};
/*************************************************************************
QPRemapping
*************************************************************************/
Void remapQP(CWMIQuantizer * pQP, I32 iShift, Bool bScaledArith)
{
U8 uiQPIndex = pQP->iIndex;
if(uiQPIndex == 0) // Lossless mode!
pQP->iQP = 1, pQP->iMan = pQP->iExp = pQP->iOffset = 0;
else if (!bScaledArith) {
I32 man = 0, exp = 0;
const I32 ciShift = SHIFTZERO - (SHIFTZERO + QPFRACBITS); // == -QPFRACBITS
if (pQP->iIndex < 32)
man = (pQP->iIndex + 3) >> 2, exp = ciShift + 2;
else if (pQP->iIndex < 48)
man = (16 + (pQP->iIndex & 0xf) + 1) >> 1, exp = ((pQP->iIndex >> 4) - 1) + 1 + ciShift;
else
man = 16 + (pQP->iIndex & 0xf), exp = ((pQP->iIndex >> 4) - 1) + ciShift;
pQP->iQP = man << exp;
pQP->iMan = gs_QPRecipTable[man].iMan;
pQP->iExp = gs_QPRecipTable[man].iExp + exp;
pQP->iOffset = ((pQP->iQP * 3 + 1) >> 3);
#if defined(WMP_OPT_QT)
pQP->f1_QP = 1.0f / pQP->iQP;
pQP->d1_QP = 1.0 / pQP->iQP;
#endif
}
else {
I32 man = 0, exp = 0;
if(pQP->iIndex < 16)
man = pQP->iIndex, exp = iShift;
else
man = 16 + (pQP->iIndex & 0xf), exp = ((pQP->iIndex >> 4) - 1) + iShift;
pQP->iQP = man << exp;
pQP->iMan = gs_QPRecipTable[man].iMan;
pQP->iExp = gs_QPRecipTable[man].iExp + exp;
pQP->iOffset = ((pQP->iQP * 3 + 1) >> 3);
#if defined(WMP_OPT_QT)
pQP->f1_QP = 1.0f / pQP->iQP;
pQP->d1_QP = 1.0 / pQP->iQP;
#endif
}
}
/* allocate PredInfo buffers */
Int allocatePredInfo(CWMImageStrCodec *pSC)
{
size_t i, j;
// COLORFORMAT cf = pSC->m_param.cfColorFormat;
const size_t mbWidth = pSC->cmbWidth;
const size_t iChannels = pSC->m_param.cNumChannels;
CWMIPredInfo* pMemory;
Bool b32Bit = sizeof(size_t) == 4;
if(b32Bit) // integer overlow/underflow check for 32-bit system
if(((mbWidth >> 16) * iChannels * 2 * sizeof(CWMIPredInfo)) & 0xffff0000)
return ICERR_ERROR;
pMemory = (CWMIPredInfo *)malloc(mbWidth * iChannels * 2 * sizeof(CWMIPredInfo));
if (pMemory == NULL)
return ICERR_ERROR;
pSC->pPredInfoMemory = pMemory;
for(i = 0; i < iChannels; i ++){
pSC->PredInfo[i] = pMemory;
pMemory += mbWidth;
pSC->PredInfoPrevRow[i] = pMemory;
pMemory += mbWidth;
for(j = 0; j < mbWidth; j ++){
pSC->PredInfo[i][j].piAD = pSC->PredInfo[i][j].iAD;
pSC->PredInfoPrevRow[i][j].piAD = pSC->PredInfoPrevRow[i][j].iAD;
}
}
return ICERR_OK;
}
/* clear PredInfo buffers */
Void freePredInfo(CWMImageStrCodec *pSC)
{
if (pSC->pPredInfoMemory)
free (pSC->pPredInfoMemory);
pSC->pPredInfoMemory = NULL;
}
/* get AC prediction mode: 0(from left) 1(from top) 2(none) */
Int getACPredMode(CWMIMBInfo * pMBInfo, COLORFORMAT cf)
{
//Int blkIdx = (cf == Y_ONLY ? 16 : (cf == YUV_420 ? 24 : (cf == YUV_422 ? 32 : 48)));
PixelI * pCoeffs = pMBInfo->iBlockDC[0];
Int StrH = abs(pCoeffs[1]) + abs(pCoeffs[2]) + abs(pCoeffs[3]);
Int StrV = abs(pCoeffs[4]) + abs(pCoeffs[8]) + abs(pCoeffs[12]);
if(cf != Y_ONLY && cf != NCOMPONENT){
PixelI * pCoeffsU = pMBInfo->iBlockDC[1];
PixelI * pCoeffsV = pMBInfo->iBlockDC[2];
StrH += abs(pCoeffsU[1]) + abs(pCoeffsV[1]);
if(cf == YUV_420){
StrV += abs(pCoeffsU[2]) + abs(pCoeffsV[2]);
}
else if (cf == YUV_422){
StrV += abs(pCoeffsU[2]) + abs(pCoeffsV[2]) + abs(pCoeffsU[6]) + abs(pCoeffsV[6]);
StrH += abs(pCoeffsU[5]) + abs(pCoeffsV[5]);
}
else { // YUV_444 or CMYK
StrV += abs(pCoeffsU[4]) + abs(pCoeffsV[4]);
}
}
return (StrH * ORIENT_WEIGHT < StrV ? 1 : (StrV * ORIENT_WEIGHT < StrH ? 0 : 2));
}
/* get DCAC prediction mode: 0(from left) 1(from top) 2(none) */
Int getDCACPredMode(CWMImageStrCodec *pSC, size_t mbX)
{
Int iDCMode, iADMode = 2; // DC: 0(left) 1(top) 2(mean) 3(no)
// AD: 0(left) 1(top) 2(no)
if(pSC->m_bCtxLeft && pSC->m_bCtxTop){ // topleft corner, no prediction
iDCMode = 3;
}
else if(pSC->m_bCtxLeft){
iDCMode = 1; // left column, predict from top
}
else if(pSC->m_bCtxTop){
iDCMode = 0; // top row, predict from left
}
else{
COLORFORMAT cf = pSC->m_param.cfColorFormat;
Int iL = pSC->PredInfo[0][mbX - 1].iDC, iT = pSC->PredInfoPrevRow[0][mbX].iDC, iTL = pSC->PredInfoPrevRow[0][mbX - 1].iDC;
Int StrH, StrV;
if(cf == Y_ONLY || cf == NCOMPONENT){ // CMYK uses YUV metric
StrH = abs(iTL - iL);
StrV = abs(iTL - iT);
}
else{
CWMIPredInfo * pTU = pSC->PredInfoPrevRow[1] + mbX, * pLU = pSC->PredInfo[1] + mbX - 1, * pTLU = pTU - 1;
CWMIPredInfo * pTV = pSC->PredInfoPrevRow[2] + mbX, * pLV = pSC->PredInfo[2] + mbX - 1, * pTLV = pTV - 1;
Int scale = (cf == YUV_420 ? 8 : (cf == YUV_422 ? 4 : 2));
StrH = abs(iTL - iL) * scale + abs(pTLU->iDC - pLU->iDC) + abs(pTLV->iDC - pLV->iDC);
StrV = abs(iTL - iT) * scale + abs(pTLU->iDC - pTU->iDC) + abs(pTLV->iDC - pTV->iDC);
}
iDCMode = (StrH * ORIENT_WEIGHT < StrV ? 1 : (StrV * ORIENT_WEIGHT < StrH ? 0 : 2));
}
if(iDCMode == 1 && pSC->MBInfo.iQIndexLP == pSC->PredInfoPrevRow[0][mbX].iQPIndex)
iADMode = 1;
if(iDCMode == 0 && pSC->MBInfo.iQIndexLP == pSC->PredInfo[0][mbX - 1].iQPIndex)
iADMode = 0;
return (iDCMode + (iADMode << 2));
}
Void copyAC(PixelI * src, PixelI * dst)
{
/* first row of ACs */
dst[0] = src[1];
dst[1] = src[2];
dst[2] = src[3];
/* first column of ACs */
dst[3] = src[4];
dst[4] = src[8];
dst[5] = src[12];
}
/* info of current MB to be saved for future prediction */
Void updatePredInfo(CWMImageStrCodec *pSC, CWMIMBInfo * pMBInfo, size_t mbX, COLORFORMAT cf)
{
CWMIPredInfo *pPredInfo;
PixelI * p;
Int i, iChannels = (cf == YUV_420 || cf == YUV_422) ? 1 : (Int) pSC->m_param.cNumChannels;
for(i = 0; i < iChannels; i ++){
pPredInfo = pSC->PredInfo[i] + mbX;
p = pMBInfo->iBlockDC[i];//[dcBlkIdx + i];
/* DC of DC block */
pPredInfo->iDC = p[0];
/* QP Index */
pPredInfo->iQPIndex = pMBInfo->iQIndexLP;
/* first row and first column of ACs of DC block */
copyAC(p, pPredInfo->piAD);
}
if(cf == YUV_420){ // 420 UV channels
for(i = 1U; i < 3U; i ++){
pPredInfo = pSC->PredInfo[i] + mbX;
p = pMBInfo->iBlockDC[i];//[dcBlkIdx + i];
/* DC of DC block */
pPredInfo->iDC = p[0];
/* QP Index */
pPredInfo->iQPIndex = pMBInfo->iQIndexLP;
/* first row and first column of ACs of DC block */
pPredInfo->piAD[0] = p[1];
pPredInfo->piAD[1] = p[2];
}
}
else if(cf == YUV_422){ // 420 UV channels
for(i = 1U; i < 3U; i ++){
pPredInfo = pSC->PredInfo[i] + mbX;
/* QP Index */
pPredInfo->iQPIndex = pMBInfo->iQIndexLP;
p = pMBInfo->iBlockDC[i];//[dcBlkIdx + i];
/* DC of DC block */
pPredInfo->iDC = p[0];
/* first row and first column of ACs of first DC block */
pPredInfo->piAD[0] = p[1];
pPredInfo->piAD[1] = p[2];
/* first row and first column of ACs of second DC block */
pPredInfo->piAD[2] = p[5];
pPredInfo->piAD[3] = p[6];
pPredInfo->piAD[4] = p[4]; //AC of 1D HT!!!
}
}
}

85
jxrlib/image/sys/strTransform.c
View file

@ -1,85 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#include "strTransform.h"
/** need to swap b and c **/
/** rounding behavior: [0 0 0 0] <-> [+ - - -]
[+ + + +] <-> [+3/4 - - -]
[- - - -] <-> [- - - -] **/
Void strDCT2x2dn(PixelI *pa, PixelI *pb, PixelI *pc, PixelI *pd)
{
PixelI a, b, c, d, C, t;
a = *pa;
b = *pb;
C = *pc;
d = *pd;
a += d;
b -= C;
t = ((a - b) >> 1);
c = t - d;
d = t - C;
a -= d;
b += c;
*pa = a;
*pb = b;
*pc = c;
*pd = d;
}
Void strDCT2x2up(PixelI *pa, PixelI *pb, PixelI *pc, PixelI *pd)
{
PixelI a, b, c, d, C, t;
a = *pa;
b = *pb;
C = *pc;
d = *pd;
a += d;
b -= C;
t = ((a - b + 1) >> 1);
c = t - d;
d = t - C;
a -= d;
b += c;
*pa = a;
*pb = b;
*pc = c;
*pd = d;
}
Void FOURBUTTERFLY_HARDCODED1(PixelI *p)
{
strDCT2x2dn(&p[0], &p[4], &p[8], &p[12]);
strDCT2x2dn(&p[1], &p[5], &p[9], &p[13]);
strDCT2x2dn(&p[2], &p[6], &p[10], &p[14]);
strDCT2x2dn(&p[3], &p[7], &p[11], &p[15]);
}

50
jxrlib/image/sys/strTransform.h
View file

@ -1,50 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#ifndef WMI_STRTRANSFORM_H
#define WMI_STRTRANSFORM_H
#include "windowsmediaphoto.h"
#define COMPUTE_CORNER_PRED_DIFF(a, b) (*(a) -= (b))
#define COMPUTE_CORNER_PRED_ADD(a, b) (*(a) += (b))
/** 2x2 foward DCT == 2x2 inverse DCT **/
Void strDCT2x2dn(PixelI *, PixelI *, PixelI *, PixelI *);
Void strDCT2x2up(PixelI *, PixelI *, PixelI *, PixelI *);
Void FOURBUTTERFLY_HARDCODED1(PixelI *p);
/** 2x2 dct of a group of 4**/
#define FOURBUTTERFLY(p, i00, i01, i02, i03, i10, i11, i12, i13,\
i20, i21, i22, i23, i30, i31, i32, i33) \
strDCT2x2dn(&p[i00], &p[i01], &p[i02], &p[i03]); \
strDCT2x2dn(&p[i10], &p[i11], &p[i12], &p[i13]); \
strDCT2x2dn(&p[i20], &p[i21], &p[i22], &p[i23]); \
strDCT2x2dn(&p[i30], &p[i31], &p[i32], &p[i33])
#endif // WMI_STRTRANSFORM_H

1251
jxrlib/image/sys/strcodec.c
View file

File diff suppressed because it is too large Load diff

678
jxrlib/image/sys/strcodec.h
View file

@ -1,678 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#pragma once
#include <stddef.h>
#include "windowsmediaphoto.h"
#include "common.h"
// #include "xplatform_image.h"
// added for Xcode PK universal binary
#ifdef __ppc__
#define _BIG__ENDIAN_
#endif
//================================================================
#ifdef ENABLE_OPTIMIZATIONS
#if defined(WIN32) && !defined(_WIN64)
#define WMP_OPT_SSE2
#define WMP_OPT_CC_ENC
//#define WMP_OPT_TRFM_ENC
//#define WMP_OPT_QT
#define WMP_OPT_CC_DEC
#define WMP_OPT_TRFM_DEC
#define X86OPT_INLINE
#endif
#endif // ENABLE_OPTIMIZATIONS
//================================================================
//#ifdef WIN32
#if defined(WIN32) && !defined(UNDER_CE) // WIN32 seems to be defined always in VS2005 for ARM platform
#define PLATFORM_X86
#include "..\x86\x86.h"
#endif
#ifndef UNREFERENCED_PARAMETER
#define UNREFERENCED_PARAMETER(P) { (P) = (P); }
#endif UNREFERENCED_PARAMETER
#ifdef UNDER_CE
#define PLATFORM_WCE
#include "arm.h"
#endif
#ifdef __ANSI__
#define PLATFORM_ANSI
#include "ansi.h"
#endif
//================================================================
#ifdef PLATFORM_ANSI
typedef unsigned long long U64;
#else // PLATFORM_ANSI
typedef unsigned __int64 U64;
#endif // PLATFORM_ANSI
//================================================================
#define MARKERCOUNT (PACKETLENGTH * 2)
// The following macros depend on UINTPTR_T and INTPTR_T being properly defined
// so that they are equal to pointer width. Confirm and fail if our assumptions are wrong.
CT_ASSERT(sizeof(UINTPTR_T) == sizeof(void*), strcodec1);
CT_ASSERT(sizeof(INTPTR_T) == sizeof(void*), strcodec2);
// wrap around pointer, s=pow(2,n), p wraps aligned to s
#define WRAPPTR(p, s) ((void*)((UINTPTR_T)(p) & ~(UINTPTR_T)(s)))
// mask certain bit inside a pointer, simulate wrap around
#define MASKPTR(p, m) ((void*)((UINTPTR_T)(p) & (INTPTR_T)(m)))
// test for more than 1 packet data
#define PACKET1(ps, pc, s) (((INTPTR_T)(ps) ^ (INTPTR_T)(pc)) & ((UINTPTR_T)(s)))
// alternate pointer p between 2 values aligned to s, s=pow(2,n)
//#define ALTPTR(p, s) ((void*)((uintptr_t)(p) ^ (s)))
// align point, s=pow(2,n), p aligns to s
#define ALIGNUP(p, s) ((void*)(((UINTPTR_T)(p) + ((UINTPTR_T)(s) - 1)) & ~((UINTPTR_T)(s) - 1)))
#define ALIGNDOWN(p, s) ((void*)((UINTPTR_T)(p) & ~((UINTPTR_T)(s) - 1)))
//================================================================
// timer support
//================================================================
#define TraceResult(a)
//================================================================
typedef enum tagPacketType
{
PK_NULL = 0,
PK_DC = 1, PK_AD, PK_AC, PK_CP,
PK_MAX,
} PACKETTYPE;
typedef struct tagIOContext
{
U8 P0[PACKETLENGTH]; // packet circular buffer 0
U8 P1[PACKETLENGTH]; // packet circular buffer 1
union
{
U8 P2[PACKETLENGTH];
struct
{
U32 uiShadow; // shadow of P0[0]-P0[3]
U32 uiAccumulator; // 32bit acc as bit field cache
U32 cBitsUsed; // # of bits used of acc, [0,16)
U8* pbPacket; // packet pointer
U8* pbCurrent; // current pointer
struct WMPStream* pWS; // pointer to WMPStream
long offPacket; // byte offset into stream
//ULARGE_INTEGER u64Acc;
//========================================
// index packet, used for packet retrieval
//========================================
U32 cIndex; // current index for index packet
long offIndex; // byte offset into stream for index packet
}State;
}P2Info;
U8 P3[PACKETLENGTH]; // index packet buffer
} IOContext;
typedef struct tagMemReadState
{
U8* pbBuf;
size_t cbBuf;
size_t cbCur;
} MemReadState;
typedef struct tagBitIOInfo
{
U32 uiShadow; // shadow of first 4B of circular buffer
U32 uiAccumulator; // 32bit acc as bit field cache
U32 cBitsUsed; // # of bits used of acc, [0,16)
#ifdef ARMOPT_BITIO
U32 cBitsUnused; // # of bits remain unused in acc, [0,32]
#endif
I32 iMask; // mask used simulate pointer wrap around
U8* pbStart; // start pointer
#ifndef ARMOPT_BITIO
U8* pbCurrent; // current pointer
#else
U32* pbCurrent; // current pointer
#endif
struct WMPStream* pWS; // pointer to WMPStream
size_t offRef; // reference offset on IStream,
// for read, it moves along the stream
// for write, it stays at the attach point
} BitIOInfo;
//================================================================
typedef struct tagCWMIQuantizer {
U8 iIndex;
I32 iQP;
I32 iOffset;
I32 iMan;
I32 iExp;
#if defined(WMP_OPT_QT)
float f1_QP;
double d1_QP;
#endif
} CWMIQuantizer;
/* temporary bridge between old APIs and streaming APIs */
typedef struct tagCWMIMBInfo {
I32 iBlockDC[MAX_CHANNELS][16];
I32 iOrientation;
Int iCBP[MAX_CHANNELS];
Int iDiffCBP[MAX_CHANNELS];
U8 iQIndexLP; // 0 - 15
U8 iQIndexHP; // 0 - 15
} CWMIMBInfo;
struct CWMImageStrCodec;
typedef Int (*ImageDataProc)(struct CWMImageStrCodec*);
/** scan model **/
typedef struct CAdaptiveScan {
U32 uTotal;
U32 uScan;
} CAdaptiveScan;
/** Adaptive context model **/
typedef struct CCodingContext {
BitIOInfo * m_pIODC;
BitIOInfo * m_pIOLP;
BitIOInfo * m_pIOAC;
BitIOInfo * m_pIOFL;
/** adaptive huffman structs **/
CAdaptiveHuffman *m_pAdaptHuffCBPCY;
CAdaptiveHuffman *m_pAdaptHuffCBPCY1;
CAdaptiveHuffman *m_pAHexpt[NUMVLCTABLES];
/** 4x4 zigzag patterns */
CAdaptiveScan m_aScanLowpass[16];
CAdaptiveScan m_aScanHoriz[16];
CAdaptiveScan m_aScanVert[16];
/** Adaptive bit reduction model **/
CAdaptiveModel m_aModelAC;
CAdaptiveModel m_aModelLP;
CAdaptiveModel m_aModelDC;
/** Adaptive lowpass CBP model **/
Int m_iCBPCountZero;
Int m_iCBPCountMax;
/** Adaptive AC CBP model **/
CCBPModel m_aCBPModel;
/** Trim flex bits - externally set **/
Int m_iTrimFlexBits;
Bool m_bInROI; // inside ROI (for region decode and compressed domain cropping)?
} CCodingContext;
// Following stuff used to be in strPredQuant.h
/* circulant buffer for 2 MB rows: current row and previous row */
typedef struct tagCWMIPredInfo {
Int iQPIndex; // QP Index
Int iCBP; // coded block pattern
PixelI iDC; // DC of MB
PixelI iAD[6];
PixelI * piAD; // AC of DC block: [2] 420UV [4] 422UV [6] elsewhere
}CWMIPredInfo;
// the following is used on decode side while reading image info
typedef struct CWMImageStrCodecParameters {
size_t cVersion;
size_t cSubVersion;
COLORFORMAT cfColorFormat; // color format
Bool bRBSwapped; // blue and red shall be swapped in BGR555,565,101010
Bool bAlphaChannel; // alpha channel present
Bool bScaledArith; // lossless mode
Bool bIndexTable; // index table present
Bool bTrimFlexbitsFlag; // trimmed flexbits indicated in packet header
Bool bUseHardTileBoundaries; //default is soft tile boundaries
size_t cNumChannels;
size_t cExtraPixelsTop;
size_t cExtraPixelsLeft;
size_t cExtraPixelsBottom;
size_t cExtraPixelsRight;
Bool bTranscode; // transcoding flag
U32 uQPMode; // 0/1: no dquant/with dquant, first bit for DC, second bit for LP, third bit for HP
U8 uiQPIndexDC[MAX_CHANNELS];
U8 uiQPIndexLP[MAX_CHANNELS];
U8 uiQPIndexHP[MAX_CHANNELS];
}CCoreParameters;
typedef struct CWMITile
{
CWMIQuantizer * pQuantizerDC[MAX_CHANNELS];
CWMIQuantizer * pQuantizerLP[MAX_CHANNELS];
CWMIQuantizer * pQuantizerHP[MAX_CHANNELS];
U8 cNumQPLP;
U8 cNumQPHP;
U8 cBitsLP;
U8 cBitsHP;
Bool bUseDC;
Bool bUseLP;
U8 cChModeDC;
U8 cChModeLP[16];
U8 cChModeHP[16];
} CWMITile;
#ifdef ARMOPT_COLORCONVERSION_C
#include "ARM_InvColorConversion.h"
#endif
struct tagPostProcInfo{
Int iMBDC; // DC of MB
U8 ucMBTexture; // MB texture : 0(flat) 1(horizontal) 2(vertical) 3(bumpy)
Int iBlockDC[4][4]; // DC of block
U8 ucBlockTexture[4][4]; // block texture: 0(flat) 1(horizontal) 2(vertical) 3(bumpy)
};
typedef struct CWMImageStrCodec {
#ifdef ARMOPT_COLORCONVERSION_C
CWMImageStrInvCCParam InvCCParam;
#endif
size_t cbStruct;
CWMImageInfo WMII;
CWMIStrCodecParam WMISCP;
CWMImageBufferInfo WMIBI;
CWMIMBInfo MBInfo;
/** core parameters **/
CCoreParameters m_param;
struct CWMDecoderParameters *m_Dparam; // this is specified thru pointer because the same set of parameters may be used by multiple image planes
U8 cSB;
Bool m_bUVResolutionChange;
Bool bTileExtraction;
BitIOInfo * pIOHeader;
Bool bUseHardTileBoundaries; //default is soft tile boundaries
PixelI * pInterU;
PixelI * pInterV;
//============== tile related info begins here ===========
// index table
size_t *pIndexTable;
// current tile position
size_t cTileRow;
size_t cTileColumn;
// tile boundary
Bool m_bCtxLeft;
Bool m_bCtxTop;
Bool m_bResetRGITotals;
Bool m_bResetContext;
CWMITile * pTile;
// BitIOs
BitIOInfo ** m_ppBitIO;
size_t cNumBitIO;
size_t cHeaderSize;
// coding contexts
struct CCodingContext *m_pCodingContext;
size_t cNumCodingContext;
//============== tile related info ends here ===========
size_t cNumOfQPIndex; // number of QP indexes
U8 cBitsDQUANT; // number of bits to encode DQUANT
size_t cRow; // row for current macro block
size_t cColumn; // column for current macro block
size_t cmbWidth; // macro block/image width
size_t cmbHeight; // macro block/image height
size_t cbChannel; // byte/channel
size_t mbX, mbY;
size_t tileX, tileY;
Bool bVertTileBoundary, bHoriTileBoundary;
Bool bOneMBLeftVertTB, bOneMBRightVertTB; //Macroblock to the left and to the right of tile boundaries
PixelI iPredBefore[2][2];
PixelI iPredAfter[2][2];
//================================
// input data into
// macro block 3 of 2x2 working widow
//================================
ImageDataProc Load;
//ImageDataProc Load2;
ImageDataProc Transform;
ImageDataProc TransformCenter;
//================================
ImageDataProc Quantize;
//ImageDataProc QuantizeLuma;
//ImageDataProc QuantizeChroma;
//================================
// process and store data from
// macro block 0 of 2x2 working window
//================================
ImageDataProc ProcessTopLeft;
ImageDataProc ProcessTop;
ImageDataProc ProcessTopRight;
ImageDataProc ProcessLeft;
ImageDataProc ProcessCenter;
ImageDataProc ProcessRight;
ImageDataProc ProcessBottomLeft;
ImageDataProc ProcessBottom;
ImageDataProc ProcessBottomRight;
//================================
// 2 MB working window for encoder
//================================
PixelI *pPlane[MAX_CHANNELS];
//================================
// 2 rows of MB buffer
//================================
PixelI *a0MBbuffer[MAX_CHANNELS]; // pointer to start of previous MB row
PixelI *a1MBbuffer[MAX_CHANNELS]; // pointer to start of current MB row
PixelI *p0MBbuffer[MAX_CHANNELS]; // working pointer to start of previous row MB
PixelI *p1MBbuffer[MAX_CHANNELS]; // working pointer to start of current row MB
//================================
// downsampling buffer for UV
//================================
PixelI * pResU;
PixelI * pResV;
//================================
// circular buffer for 2 MB rows: current row and previous row
//================================
CWMIPredInfo *PredInfo[MAX_CHANNELS];
CWMIPredInfo *PredInfoPrevRow[MAX_CHANNELS];
CWMIPredInfo *pPredInfoMemory;
struct WMPStream ** ppWStream;
#ifdef WIN32
TCHAR **ppTempFile;
#else
char **ppTempFile;
#endif
// interleaved alpha support - linked structure for Alpha channel
struct CWMImageStrCodec *m_pNextSC;
Bool m_bSecondary;
//================================
// Perf Timers
//================================
#ifndef DISABLE_PERF_MEASUREMENT
Bool m_fMeasurePerf;
struct PERFTIMERSTATE *m_ptEndToEndPerf; // Measures from Init to Term, including I/O
struct PERFTIMERSTATE *m_ptEncDecPerf; // Measures time spent in ImageStrEncEncode/ImageStrDecDecode, excluding I/O
#endif // DISABLE_PERF_MEASUREMENT
// postproc information for 2 MB rows: 0(previous row) 1(current row)
struct tagPostProcInfo * pPostProcInfo[MAX_CHANNELS][2];
} CWMImageStrCodec;
//================================================================
ERR WMPAlloc(void** ppv, size_t cb);
ERR WMPFree(void** ppv);
//================================================================
Void initMRPtr(CWMImageStrCodec*);
Void advanceMRPtr(CWMImageStrCodec*);
Void swapMRPtr(CWMImageStrCodec*);
Int IDPEmpty(CWMImageStrCodec*);
//================================================================
extern const int dctIndex[3][16];
extern const int blkOffset[16];
extern const int blkOffsetUV[4];
extern const int blkOffsetUV_422[8];
extern const U8 idxCC[16][16];
extern const U8 idxCC_420[8][8];
extern const Char gGDISignature[];
//================================================================
Int allocatePredInfo(CWMImageStrCodec*);
Void freePredInfo(CWMImageStrCodec*);
Void advanceOneMBRow(CWMImageStrCodec*);
//================================================================
// bit I/O
//================================================================
Int allocateBitIOInfo(CWMImageStrCodec*);
Int setBitIOPointers(CWMImageStrCodec* pSC);
#ifndef ARMOPT_BITIO
U32 peekBit16(BitIOInfo* pIO, U32 cBits);
U32 flushBit16(BitIOInfo* pIO, U32 cBits);
U32 getBit16(BitIOInfo* pIO, U32 cBits);
U32 getBool16(BitIOInfo* pIO);
I32 getBit16s(BitIOInfo* pIO, U32 cBits);
U32 getBit32(BitIOInfo* pIO, U32 cBits);
U32 flushToByte(BitIOInfo* pIO);
#endif // ARMOPT_BITIO
Void putBit16z(BitIOInfo* pIO, U32 uiBits, U32 cBits);
Void putBit16(BitIOInfo* pIO, U32 uiBits, U32 cBits);
Void putBit32(BitIOInfo* pIO, U32 uiBits, U32 cBits);
Void fillToByte(BitIOInfo* pIO);
U32 getSizeRead(BitIOInfo* pIO);
U32 getSizeWrite(BitIOInfo* pIO);
U32 getPosRead(BitIOInfo* pIO);
// safe function, solely for the convenience of test code
#ifndef ARMOPT_BITIO
U32 getBit16_S(CWMImageStrCodec* pSC, BitIOInfo* pIO, U32 cBits);
#endif // ARMOPT_BITIO
//================================================================
// packet I/O
//================================================================
ERR attachISRead(BitIOInfo* pIO, struct WMPStream* pWS, CWMImageStrCodec* pSC);
ERR readIS(CWMImageStrCodec* pSC, BitIOInfo* pIO);
ERR detachISRead(CWMImageStrCodec* pSC, BitIOInfo* pIO);
ERR attachISWrite(BitIOInfo* pIO, struct WMPStream* pWS);
ERR writeIS(CWMImageStrCodec* pSC, BitIOInfo* pIO);
ERR detachISWrite(CWMImageStrCodec* pSC, BitIOInfo* pIO);
//================================================================
// post processing for decoder
//================================================================
Int initPostProc(struct tagPostProcInfo * strPostProcInfo[MAX_CHANNELS][2], size_t mbWidth, size_t iNumChannels);
Void termPostProc(struct tagPostProcInfo * strPostProcInfo[MAX_CHANNELS][2], size_t iNumChannels);
Void slideOneMBRow(struct tagPostProcInfo * strPostProcInfo[MAX_CHANNELS][2], size_t iNumChannels, size_t mbWidth, Bool top, Bool bottom);
Void updatePostProcInfo(struct tagPostProcInfo * strPostProcInfo[MAX_CHANNELS][2], PixelI * p, size_t mbX, size_t cc);
Void postProcMB(struct tagPostProcInfo * strPostProcInfo[MAX_CHANNELS][2], PixelI * p0, PixelI * p1, size_t mbX, size_t cc, Int threshold);
Void postProcBlock(struct tagPostProcInfo * strPostProcInfo[MAX_CHANNELS][2], PixelI * p0, PixelI * p1, size_t mbX, size_t cc, Int threshold);
//================================================================
// Simple BitIO access functions
//================================================================
typedef struct tagSimpleBitIO
{
struct WMPStream* pWS;
U32 cbRead;
U8 bAccumulator;
U32 cBitLeft;
} SimpleBitIO;
ERR attach_SB(SimpleBitIO* pSB, struct WMPStream* pWS);
U32 getBit32_SB(SimpleBitIO* pSB, U32 cBits);
Void flushToByte_SB(SimpleBitIO* pSB);
U32 getByteRead_SB(SimpleBitIO* pSB);
ERR detach_SB(SimpleBitIO* pSB);
//----------------------------------------------------------------
EXTERN_C Bool EOSWS_File(struct WMPStream* pWS);
EXTERN_C ERR ReadWS_File(struct WMPStream* pWS, void* pv, size_t cb);
EXTERN_C ERR WriteWS_File(struct WMPStream* pWS, const void* pv, size_t cb);
//EXTERN_C ERR GetLineWS_File(struct WMPStream* pWS, void* pv, size_t cb);
EXTERN_C ERR SetPosWS_File(struct WMPStream* pWS, size_t offPos);
EXTERN_C ERR GetPosWS_File(struct WMPStream* pWS, size_t* poffPos);
//----------------------------------------------------------------
EXTERN_C Bool EOSWS_Memory(struct WMPStream* pWS);
EXTERN_C ERR ReadWS_Memory(struct WMPStream* pWS, void* pv, size_t cb);
EXTERN_C ERR WriteWS_Memory(struct WMPStream* pWS, const void* pv, size_t cb);
//EXTERN_C ERR GetLineWS_Memory(struct WMPStream* pWS, void* pv, size_t cb);
EXTERN_C ERR SetPosWS_Memory(struct WMPStream* pWS, size_t offPos);
EXTERN_C ERR GetPosWS_Memory(struct WMPStream* pWS, size_t* poffPos);
//EXTERN_C ERR GetPtrWS_Memory(struct WMPStream* pWS, size_t align, U8** ppb);
//----------------------------------------------------------------
EXTERN_C Bool EOSWS_List(struct WMPStream* pWS);
EXTERN_C ERR ReadWS_List(struct WMPStream* pWS, void* pv, size_t cb);
EXTERN_C ERR WriteWS_List(struct WMPStream* pWS, const void* pv, size_t cb);
EXTERN_C ERR SetPosWS_List(struct WMPStream* pWS, size_t offPos);
EXTERN_C ERR GetPosWS_List(struct WMPStream* pWS, size_t* poffPos);
EXTERN_C ERR CreateWS_List(struct WMPStream** ppWS);
EXTERN_C ERR CloseWS_List(struct WMPStream** ppWS);
/********************************************************************/
// Stuff related to scale/spatial ordering
typedef struct PacketInfo
{
BAND m_iBand;
size_t m_iSize;
size_t m_iOffset;
struct PacketInfo *m_pNext;
} PacketInfo;
/********************************************************************/
/********************************************************************/
const static Int blkIdxByRow[4][4] = {{0, 1, 4, 5}, {2, 3, 6, 7}, {8, 9, 12, 13}, {10, 11, 14, 15}};
const static Int blkIdxByColumn[4][4] = {{0, 2, 8, 10}, {1, 3, 9, 11},{4, 6, 12, 14},{5, 7, 13, 15}};
Int getACPredMode(CWMIMBInfo *, COLORFORMAT);
Int getDCACPredMode(CWMImageStrCodec *, size_t);
Void updatePredInfo(CWMImageStrCodec* pSC, CWMIMBInfo *, size_t, COLORFORMAT);
Int AllocateCodingContextDec(struct CWMImageStrCodec *pSC, Int iNumContexts);
Void ResetCodingContext(CCodingContext *pContext);
Void getTilePos(CWMImageStrCodec* pSC, size_t mbX, size_t mbY);
Void InitZigzagScan(CCodingContext * pSC);
Int checkImageBuffer(CWMImageStrCodec *, size_t, size_t);
//U32 log2(U32);
//DQUANT stuff
EXTERN_C Void remapQP(CWMIQuantizer *, I32, Bool);
Int allocateTileInfo(CWMImageStrCodec *);
Void freeTileInfo(CWMImageStrCodec *);
Int allocateQuantizer(CWMIQuantizer * pQuantizer[MAX_CHANNELS], size_t, size_t);
Void freeQuantizer(CWMIQuantizer * pQuantizer[MAX_CHANNELS]);
Void setUniformQuantizer(CWMImageStrCodec *, size_t);
Void useDCQuantizer(CWMImageStrCodec *, size_t);
Void useLPQuantizer(CWMImageStrCodec *, size_t, size_t);
Void formatQuantizer(CWMIQuantizer * pQuantizer[MAX_CHANNELS], U8, size_t, size_t, Bool, Bool);
U8 dquantBits(U8);
#ifdef ARMOPT_BITIO
#define peekBit16 peekBits
#define flushBit16 flushBits
#define getBit16 getBits
#define getBit32 getBits
#define getBit16s getBitsS
#define getBool16(pIO) getBits(pIO, 1)
U32 peekBits(BitIOInfo* pIO, U32 cBits);
void flushBits(BitIOInfo* pIO, U32 cBits);
U32 getBits(BitIOInfo* pIO, U32 cBits);
U32 getBitsS(BitIOInfo* pIO, U32 cBits);
void flushToByte(BitIOInfo* pIO);
#endif // ARMOPT_BITIO
/*************************************************************************
Bitio defines
*************************************************************************/
#define PEEKBIT16(pIO, cBits) \
assert(0 <= (I32)cBits && cBits <= 16);\
return (pIO->uiAccumulator >> (32 - cBits/* - pIO->cBitsUsed*/));
#define FLUSHBIT16(pIO, cBits) \
assert(0 <= (I32)cBits && cBits <= 16);\
assert((pIO->iMask & 1) == 0);\
pIO->cBitsUsed += cBits;\
pIO->pbCurrent = MASKPTR(pIO->pbCurrent + ((pIO->cBitsUsed >> 3)/* & 2*/), pIO->iMask);\
pIO->cBitsUsed &= 16 - 1;\
pIO->uiAccumulator = LOAD16(pIO->pbCurrent) << pIO->cBitsUsed;\
return 0;
// pIO->uiAccumulator = LOAD16(pIO->pbCurrent) & ((U32)(-1) >> pIO->cBitsUsed);\
void OutputPerfTimerReport(CWMImageStrCodec *pState);

515
jxrlib/image/sys/windowsmediaphoto.h
View file

@ -1,515 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#ifndef WMI_WINDOWSMEDIAPHOTO_H
#define WMI_WINDOWSMEDIAPHOTO_H
//================================================================
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#if defined(__cplusplus) && !defined(EXTERN_C)
#define EXTERN_C extern "C"
#elif !defined(EXTERN_C)// __cplusplus
#define EXTERN_C extern
#endif // __cplusplus
/********************************************************************************
Type definitions
********************************************************************************/
typedef int Bool;
typedef char Char;
typedef double Double;
typedef int Int;
typedef signed char I8;
typedef short I16; // 16 bit int
typedef int I32;
typedef long Long;
typedef unsigned char PixelC;
typedef int PixelI;
typedef unsigned int UInt;
typedef unsigned long ULong;
typedef unsigned char U8; // 8 bit uint
typedef unsigned short U16;
typedef unsigned int U32; // 32 bit uint
typedef void Void;
typedef void* CTXSTRCODEC;
#define REENTRANT_MODE 1
/*
DESCRIPTION OF COMPILER FLAG REENTRANT_MODE:
//#define REENTRANT_MODE 1
This compiler flag is related to the capability of banded decode
(decoding only one MB row of the source JPEG XR image at a time).
With REENTRANT_MODE defined, the decoder decodes one MB row on each call to
ImageStrDecDecode().
The decoder acts as if it can only write to the single MBRow whose pointer was passed to it.
This acts as a proof of concept that the API would work if you passed it a small buffer
on each call to ImageStrDecDecode().
The REENTRANT_MODE flag only works when the output image is in Orientations 0, 1
(vertically flipped) or 2 (horizontally flipped).
With REENTRANT_MODE defined, the function PKImageDecode_Copy_WMP()
decodes only as far as the pRect parameter indicates. The width of the rectangle must be the width
of the image, but on each call, this function will decode the image up to the end of the MB Row
which contains the i-th pixel row, where i = pRect->Y.
A target use of this version would be to have PKImageDecode_Copy_WMP() called in a loop, once for
each MB row. On each call, pRect would specify a 1-MB-Row-tall rectangle that is the width of the
image. The decoder state is preserved until the Decoder finishes decoding the image.
If, at a certain point, a request is made for a rectangle _above_ the last row decoded, then the
decoder instance is terminated and re-initiated, and decoding re-starts, going from the beginning
of the image to the end of the current rectangle.
***
We've chosen to uncomment-out this definition in this header file. An alternate method would be
to allow the user to define this in the PREPROCESSOR DEFINITIONS section of the properties page
for each of the following projects: CommonLib, DecodeLib, JXRDecApp and JXRGlueLib.
*/
/*************************************************************************
enums
*************************************************************************/
typedef enum {
ICERR_OK = 0, ICERR_ERROR = -1
} ERR_CODE;
typedef enum BITDEPTH {
BD_SHORT, BD_LONG,
/* add new BITDEPTH here */ BD_MAX
} BITDEPTH;
typedef enum BITDEPTH_BITS {
// regular ones
BD_1, //White is foreground
BD_8, BD_16, BD_16S, BD_16F, BD_32, BD_32S, BD_32F,
// irregular ones
BD_5, BD_10, BD_565,
/* add new BITDEPTH_BITS here */ BDB_MAX,
BD_1alt = 0xf, //Black is foreground
} BITDEPTH_BITS;
typedef enum OVERLAP {
OL_NONE = 0, OL_ONE, OL_TWO,
/* add new OVERLAP here */ OL_MAX
} OVERLAP;
typedef enum BITSTREAMFORMAT {
SPATIAL = 0, // spatial order
FREQUENCY, // frequency order
} BITSTREAMFORMAT;
typedef enum COLORFORMAT {
Y_ONLY = 0,
YUV_420 = 1,
YUV_422 = 2,
YUV_444 = 3,
CMYK = 4,
//CMYKDIRECT = 5,
NCOMPONENT = 6,
// these are external-only
CF_RGB = 7,
CF_RGBE = 8,
/* add new COLORFORMAT here */ CFT_MAX
} COLORFORMAT;
// rotation and flip
typedef enum ORIENTATION {
// CRW: Clock Wise 90% Rotation; FlipH: Flip Horizontally; FlipV: Flip Vertically
// Peform rotation FIRST!
// CRW FlipH FlipV
O_NONE = 0, // 0 0 0
O_FLIPV, // 0 0 1
O_FLIPH, // 0 1 0
O_FLIPVH, // 0 1 1
O_RCW, // 1 0 0
O_RCW_FLIPV, // 1 0 1
O_RCW_FLIPH, // 1 1 0
O_RCW_FLIPVH, // 1 1 1
/* add new ORIENTATION here */ O_MAX
} ORIENTATION;
typedef enum SUBBAND {
SB_ALL = 0, // keep all subbands
SB_NO_FLEXBITS, // skip flex bits
SB_NO_HIGHPASS, // skip highpass
SB_DC_ONLY, // skip lowpass and highpass, DC only
SB_ISOLATED, // not decodable
/* add new SUBBAND here */ SB_MAX
} SUBBAND;
enum { RAW = 0, BMP = 1, PPM = 2, TIF = 3, HDR = 4, IYUV = 5, YUV422 = 6, YUV444 = 7};
typedef enum {ERROR_FAIL = -1, SUCCESS_DONE, PRE_READ_HDR, PRE_SETUP, PRE_DECODE, POST_READ_HDR } WMIDecoderStatus;
#ifndef FALSE
#define FALSE 0
#endif // FALSE
#ifndef TRUE
#define TRUE 1
#endif // TRUE
#define MAX_CHANNELS 16
#define LOG_MAX_TILES 12
#define MAX_TILES (1 << LOG_MAX_TILES)
//================================================================
// Codec-specific constants
#define MB_WIDTH_PIXEL 16
#define MB_HEIGHT_PIXEL 16
#define BLK_WIDTH_PIXEL 4
#define BLK_HEIGHT_PIXEL 4
#define MB_WIDTH_BLK 4
#define MB_HEIGHT_BLK 4
// The codec operates most efficiently when the framebuffers for encoder input
// and decoder output are: 1) aligned on a particular boundary, and 2) the stride
// is also aligned to this boundary (so that each scanline is also aligned).
// This boundary is defined below.
#define FRAMEBUFFER_ALIGNMENT 128
//================================================================
#define WMP_errSuccess 0
#define WMP_errFail -1
#define WMP_errNotYetImplemented -2
#define WMP_errAbstractMethod -3
#define WMP_errOutOfMemory -101
#define WMP_errFileIO -102
#define WMP_errBufferOverflow -103
#define WMP_errInvalidParameter -104
#define WMP_errInvalidArgument -105
#define WMP_errUnsupportedFormat -106
#define WMP_errIncorrectCodecVersion -107
#define WMP_errIndexNotFound -108
#define WMP_errOutOfSequence -109
#define WMP_errNotInitialized -110
#define WMP_errMustBeMultipleOf16LinesUntilLastCall -111
#define WMP_errPlanarAlphaBandedEncRequiresTempFile -112
#define WMP_errAlphaModeCannotBeTranscoded -113
#define WMP_errIncorrectCodecSubVersion -114
//================================================================
typedef long ERR;
#define Failed(err) ((err)<0)
#define CRLF "\r\n"
#define CT_ASSERT(exp, uniq) typedef char __CT_ASSERT__##uniq[(exp) ? 1 : -1] // Caller must provide a unique tag, or this fails to compile under GCC
#if defined(_DEBUG) || defined(DBG)
#define Report(err, szExp, szFile, nLine) \
fprintf(stderr, "FAILED: %ld=%s" CRLF, (err), (szExp)); \
fprintf(stderr, " %s:%ld" CRLF, (szFile), (nLine)); \
#else
#define Report(err, szExp, szFile, lLine) err = err
#endif
#define Call(exp) \
if (Failed(err = (exp))) \
{ \
Report(err, #exp, __FILE__, (long)__LINE__); \
goto Cleanup; \
} \
else err = err
#define CallIgnoreError(errTmp, exp) \
if (Failed(errTmp = (exp))) \
{ \
Report(errTmp, #exp, __FILE__, (long)__LINE__); \
} \
else errTmp = errTmp
#define Test(exp, err) Call((exp) ? WMP_errSuccess : (err))
#define FailIf(exp, err) Call((exp) ? (err) : WMP_errSuccess)
//================================================================
// WMPStream interface
//================================================================
struct WMPStream
{
union
{
struct tagFile
{
FILE* pFile;
} file;
struct tagBuf
{
U8* pbBuf;
size_t cbBuf;
size_t cbCur;
size_t cbBufCount;
} buf;
void* pvObj;
} state;
Bool fMem;
ERR (*Close)(struct WMPStream** pme);
Bool (*EOS)(struct WMPStream* me);
ERR (*Read)(struct WMPStream* me, void* pv, size_t cb);
ERR (*Write)(struct WMPStream* me, const void* pv, size_t cb);
//ERR (*GetLine)(struct WMPStream* me, void* pv, size_t cb);
ERR (*SetPos)(struct WMPStream* me, size_t offPos);
ERR (*GetPos)(struct WMPStream* me, size_t* poffPos);
};
EXTERN_C ERR CreateWS_File(struct WMPStream** ppWS, const char* szFilename, const char* szMode);
EXTERN_C ERR CloseWS_File(struct WMPStream** ppWS);
EXTERN_C ERR CreateWS_Memory(struct WMPStream** ppWS, void* pv, size_t cb);
EXTERN_C ERR CloseWS_Memory(struct WMPStream** ppWS);
//================================================================
// Enc/Dec data structure
//================================================================
typedef struct tagCWMImageInfo {
size_t cWidth;
size_t cHeight;
COLORFORMAT cfColorFormat;
BITDEPTH_BITS bdBitDepth;
size_t cBitsPerUnit;
size_t cLeadingPadding; // number of leading padding
Bool bRGB; // true: RGB; false: BGR
U8 cChromaCenteringX; // Relative location of Chroma w.r.t Luma
U8 cChromaCenteringY; // Relative location of Chroma w.r.t Luma
// Region of interest decoding
size_t cROILeftX;
size_t cROIWidth;
size_t cROITopY;
size_t cROIHeight;
// thumbnail decode
Bool bSkipFlexbits;
size_t cThumbnailWidth;
size_t cThumbnailHeight;
// image orientation
ORIENTATION oOrientation;
// post processing
U8 cPostProcStrength; // 0(none) 1(light) 2(medium) 3(strong) 4(very strong)
// user buffer is always padded to whole MB
Bool fPaddedUserBuffer;
} CWMImageInfo;
typedef struct tagCWMIStrCodecParam {
Bool bVerbose;
// for macroblock quantization (DQUANT)
U8 uiDefaultQPIndex;
U8 uiDefaultQPIndexYLP;
U8 uiDefaultQPIndexYHP;
U8 uiDefaultQPIndexU;
U8 uiDefaultQPIndexULP;
U8 uiDefaultQPIndexUHP;
U8 uiDefaultQPIndexV;
U8 uiDefaultQPIndexVLP;
U8 uiDefaultQPIndexVHP;
U8 uiDefaultQPIndexAlpha;
COLORFORMAT cfColorFormat;
BITDEPTH bdBitDepth;
OVERLAP olOverlap;
BITSTREAMFORMAT bfBitstreamFormat;
size_t cChannel; // number of color channels including alpha
U8 uAlphaMode; // 0:no alpha 1: alpha only else: something + alpha
SUBBAND sbSubband; // which subbands to keep
U8 uiTrimFlexBits;
struct WMPStream* pWStream;
size_t cbStream;
// tiling info
U32 cNumOfSliceMinus1V; // # of vertical slices
U32 uiTileX[MAX_TILES]; // width in MB of each veritical slice
U32 cNumOfSliceMinus1H; // # of horizontal slices
U32 uiTileY[MAX_TILES]; // height in MB of each horizontal slice
//32f and 32s conversion parameters
U8 nLenMantissaOrShift;
I8 nExpBias;
Bool bBlackWhite;
Bool bUseHardTileBoundaries; //default is soft tile boundaries
Bool bProgressiveMode; //default is sequential mode
Bool bYUVData; //default is cfColorFormat data
Bool bUnscaledArith; //force unscaled arithmetic
// Perf measurement
Bool fMeasurePerf;
} CWMIStrCodecParam;
typedef struct tagCWMImageBufferInfo {
void* pv; // pointer to scanline buffer
size_t cLine; // count of scanlines
size_t cbStride; // count of BYTE for stride
#ifdef REENTRANT_MODE
unsigned int uiFirstMBRow; // Current First MB Row being decoded
unsigned int uiLastMBRow; // Current Last MB Row being decoded
size_t cLinesDecoded; // Number of lines decoded and returned in low-mem mode
#endif // REENTRANT_MODE
} CWMImageBufferInfo;
/****************************************************************/
/* Encode API */
/****************************************************************/
EXTERN_C Int ImageStrEncInit(
CWMImageInfo* pII,
CWMIStrCodecParam *pSCP,
CTXSTRCODEC* pctxSC);
EXTERN_C Int ImageStrEncEncode(
CTXSTRCODEC ctxSC,
const CWMImageBufferInfo* pBI);
EXTERN_C Int ImageStrEncTerm(
CTXSTRCODEC ctxSC);
/****************************************************************/
/* Decode API */
/****************************************************************/
struct CWMImageStrCodec;
EXTERN_C Int ImageStrDecGetInfo(
CWMImageInfo* pII,
CWMIStrCodecParam *pSCP);
EXTERN_C Int ImageStrDecInit(
CWMImageInfo* pII,
CWMIStrCodecParam *pSCP,
CTXSTRCODEC* pctxSC);
EXTERN_C Int ImageStrDecDecode(
CTXSTRCODEC ctxSC,
const CWMImageBufferInfo* pBI
#ifdef REENTRANT_MODE
, size_t *pcDecodedLines
#endif
);
EXTERN_C Int ImageStrDecTerm(
CTXSTRCODEC ctxSC);
EXTERN_C Int WMPhotoValidate(
CWMImageInfo * pII,
CWMIStrCodecParam * pSCP);
/****************************************************************/
/* Transcoding API */
/****************************************************************/
typedef struct tagCWMTranscodingParam {
size_t cLeftX;
size_t cWidth;
size_t cTopY;
size_t cHeight; // interested region
BITSTREAMFORMAT bfBitstreamFormat; // desired bitstream format
// COLORFORMAT cfColorFormat; // desired color format
U8 uAlphaMode; // 0:no alpha 1: alpha only else: something + alpha
SUBBAND sbSubband; // which subbands to keep
ORIENTATION oOrientation; // flip / right angle rotation
Bool bIgnoreOverlap;
} CWMTranscodingParam;
EXTERN_C Int WMPhotoTranscode(
struct WMPStream* pStreamDec, // input bitstrean
struct WMPStream* pStreamEnc, // output bitstream
CWMTranscodingParam* pParam // transcoding parameters
);
typedef struct tagCWMDetilingParam {
size_t cWidth;
size_t cHeight; // image size
size_t cChannel; // # of channels
OVERLAP olOverlap; // overlap
BITDEPTH_BITS bdBitdepth; // bit depth
// tiling info
U32 cNumOfSliceMinus1V; // # of vertical slices
U32 uiTileX[MAX_TILES]; // position in MB of each veritical slice
U32 cNumOfSliceMinus1H; // # of horizontal slices
U32 uiTileY[MAX_TILES]; // position in MB of each horizontal slice
// image info
void * pImage;
size_t cbStride;
} CWMDetilingParam;
EXTERN_C Int WMPhotoDetile(
CWMDetilingParam * pParam // detiling parameters
);
#endif // WMI_WINDOWSMEDIAPHOTO_H

84
jxrlib/image/sys/xplatform_image.h
View file

@ -1,84 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#ifndef XPLATFORM_IMAGE_H
#define XPLATFORM_IMAGE_H
#ifdef __ANSI__
// ANSI
#define FORCE_INLINE
#define CDECL
#define UINTPTR_T unsigned int
#define INTPTR_T int
#define DECLSPEC_ALIGN(bytes)
#endif // __ANSI__
//#if defined(WIN32)
#if defined(WIN32) && !defined(UNDER_CE) // WIN32 seems to be defined always in VS2005 for ARM platform
// x86
//#define CDECL __cdecl
#define DECLSPEC_ALIGN(bytes) __declspec(align(bytes))
#endif // x86
#if defined(_ARM_) || defined(UNDER_CE)
// ARM, WinCE
#define FORCE_INLINE inline
#define CDECL
#define UINTPTR_T unsigned int
#define INTPTR_T int
#define DECLSPEC_ALIGN(bytes)
// parser
#define FULL_PATH_CONFIG_FILE_ENCODE "\\ConfigFile_encode.txt"
#define FULL_PATH_CONFIG_FILE_DECODE "\\ConfigFile_decode.txt"
#define MAX_ARGC 14
#define MaxCharReadCount 10
#define MAX_FNAME 256
#define DELIMITER "filelist:"
#define CODEC_ENCODE "encode"
#define CODEC_DECODE "decode"
#define PHOTON "ptn"
#define OUTRAW "raw"
#define OUTBMP "bmp"
#define OUTPPM "ppm"
#define OUTTIF "tif"
#define OUTHDR "hdr"
#define OUTIYUV "iyuv"
#define OUTYUV422 "yuv422"
#define OUTYUV444 "yuv444"
int XPLATparser(char *pcARGV[], char *pcCodec);
void freeXPLATparser(int iARGC, char *pcARGV[]);
// WinCE intrinsic
#include <Cmnintrin.h>
#endif // ARM, WinCE
#endif // XPLATFORM_IMAGE_H

191
jxrlib/image/vc11projects/CommonLib_vc11.vcxproj
View file

@ -1,191 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectName>JXRCommonLib</ProjectName>
<ProjectGuid>{4B4C055C-170E-4DCF-8F73-BED91BE7CFA4}</ProjectGuid>
<RootNamespace>CommonLib</RootNamespace>
<Keyword>Win32Proj</Keyword>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v110</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v110</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v110</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v110</PlatformToolset>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" 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|Win32'" 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)'=='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>10.0.30319.1</_ProjectFileVersion>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(Configuration)/$(ProjectName)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(OutDir)</IntDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(Configuration)\$(ProjectName)\$(Platform)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)</IntDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(Configuration)/$(ProjectName)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(OutDir)</IntDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(Configuration)\$(ProjectName)\$(Platform)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)</IntDir>
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" />
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" />
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" />
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>..\sys;..\..\Network\client\debughlp\memtrace;..\x86;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;_DEBUG;_LIB;DISABLE_PERF_MEASUREMENT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<ProgramDataBaseFileName>$(IntDir)$(ProjectName).pdb</ProgramDataBaseFileName>
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Lib>
<OutputFile>$(OutDir)$(ProjectName).lib</OutputFile>
</Lib>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Midl>
<TargetEnvironment>X64</TargetEnvironment>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>..\sys;..\..\Network\client\debughlp\memtrace;..\x86;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;_DEBUG;_LIB;DISABLE_PERF_MEASUREMENT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<ProgramDataBaseFileName>$(IntDir)$(ProjectName).pdb</ProgramDataBaseFileName>
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Lib>
<OutputFile>$(OutDir)$(ProjectName).lib</OutputFile>
</Lib>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<WholeProgramOptimization>true</WholeProgramOptimization>
<AdditionalIncludeDirectories>..\sys;..\..\Network\client\debughlp\memtrace;..\x86;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;NDEBUG;_LIB;ENABLE_OPTIMIZATIONS;DISABLE_PERF_MEASUREMENT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Lib>
<AdditionalOptions>/LTCG %(AdditionalOptions)</AdditionalOptions>
<OutputFile>$(OutDir)$(ProjectName).lib</OutputFile>
<LinkTimeCodeGeneration>true</LinkTimeCodeGeneration>
</Lib>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Midl>
<TargetEnvironment>X64</TargetEnvironment>
</Midl>
<ClCompile>
<AdditionalIncludeDirectories>..\sys;..\..\Network\client\debughlp\memtrace;..\x86;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;NDEBUG;_LIB;ENABLE_OPTIMIZATIONS;DISABLE_PERF_MEASUREMENT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<WholeProgramOptimization>true</WholeProgramOptimization>
</ClCompile>
<Lib>
<OutputFile>$(OutDir)$(ProjectName).lib</OutputFile>
<LinkTimeCodeGeneration>true</LinkTimeCodeGeneration>
</Lib>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="..\sys\adaptHuff.c" />
<ClCompile Include="..\sys\image.c" />
<ClCompile Include="..\sys\perfTimerANSI.c">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="..\sys\strcodec.c" />
<ClCompile Include="..\sys\strPredQuant.c" />
<ClCompile Include="..\sys\strTransform.c" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\sys\ansi.h" />
<ClInclude Include="..\sys\common.h" />
<ClInclude Include="..\sys\perfTimer.h" />
<ClInclude Include="..\sys\strcodec.h" />
<ClInclude Include="..\sys\strTransform.h" />
<ClInclude Include="..\sys\windowsmediaphoto.h" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

185
jxrlib/image/vc11projects/DecodeLib_vc11.vcxproj
View file

@ -1,185 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectName>JXRDecodeLib</ProjectName>
<ProjectGuid>{F3DED308-7A6F-4B9F-8EDF-AF99DEC8BDE3}</ProjectGuid>
<RootNamespace>DecodeLib</RootNamespace>
<Keyword>Win32Proj</Keyword>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v110</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v110</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v110</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v110</PlatformToolset>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" 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|Win32'" 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)'=='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>10.0.30319.1</_ProjectFileVersion>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(Configuration)/$(ProjectName)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(OutDir)</IntDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(Configuration)\$(ProjectName)\$(Platform)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)</IntDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(Configuration)/$(ProjectName)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(OutDir)</IntDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(Configuration)\$(ProjectName)\$(Platform)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)</IntDir>
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" />
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" />
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" />
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>..\sys;..\..\Network\client\debughlp\memtrace;..\x86;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;_DEBUG;_LIB;DISABLE_PERF_MEASUREMENT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<ProgramDataBaseFileName>$(IntDir)$(ProjectName).pdb</ProgramDataBaseFileName>
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Lib>
<OutputFile>$(OutDir)$(ProjectName).lib</OutputFile>
</Lib>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Midl>
<TargetEnvironment>X64</TargetEnvironment>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>..\sys;..\..\Network\client\debughlp\memtrace;..\x86;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;_DEBUG;_LIB;DISABLE_PERF_MEASUREMENT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<ProgramDataBaseFileName>$(IntDir)$(ProjectName).pdb</ProgramDataBaseFileName>
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Lib>
<OutputFile>$(OutDir)$(ProjectName).lib</OutputFile>
</Lib>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<WholeProgramOptimization>true</WholeProgramOptimization>
<AdditionalIncludeDirectories>..\sys;..\..\Network\client\debughlp\memtrace;..\x86;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;NDEBUG;_LIB;ENABLE_OPTIMIZATIONS;DISABLE_PERF_MEASUREMENT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Lib>
<AdditionalOptions>/LTCG %(AdditionalOptions)</AdditionalOptions>
<OutputFile>$(OutDir)$(ProjectName).lib</OutputFile>
<LinkTimeCodeGeneration>true</LinkTimeCodeGeneration>
</Lib>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Midl>
<TargetEnvironment>X64</TargetEnvironment>
</Midl>
<ClCompile>
<AdditionalIncludeDirectories>..\sys;..\..\Network\client\debughlp\memtrace;..\x86;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;NDEBUG;_LIB;ENABLE_OPTIMIZATIONS;DISABLE_PERF_MEASUREMENT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<WholeProgramOptimization>true</WholeProgramOptimization>
</ClCompile>
<Lib>
<OutputFile>$(OutDir)$(ProjectName).lib</OutputFile>
<LinkTimeCodeGeneration>true</LinkTimeCodeGeneration>
</Lib>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="..\decode\decode.c" />
<ClCompile Include="..\decode\postprocess.c" />
<ClCompile Include="..\decode\segdec.c" />
<ClCompile Include="..\decode\strdec.c" />
<ClCompile Include="..\decode\strdec_x86.c" />
<ClCompile Include="..\decode\strInvTransform.c" />
<ClCompile Include="..\decode\strPredQuantDec.c" />
<ClCompile Include="..\decode\JXRTranscode.c" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\sys\common.h" />
<ClInclude Include="..\decode\decode.h" />
<ClInclude Include="..\sys\windowsmediaphoto.h" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

183
jxrlib/image/vc11projects/EncodeLib_vc11.vcxproj
View file

@ -1,183 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectName>JXREncodeLib</ProjectName>
<ProjectGuid>{F99F7B19-47A6-4677-94F2-93C12CF1FB97}</ProjectGuid>
<RootNamespace>EncodeLib</RootNamespace>
<Keyword>Win32Proj</Keyword>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v110</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v110</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v110</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v110</PlatformToolset>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" 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|Win32'" 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)'=='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>10.0.30319.1</_ProjectFileVersion>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(Configuration)/$(ProjectName)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(OutDir)</IntDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(Configuration)\$(ProjectName)\$(Platform)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)</IntDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(Configuration)/$(ProjectName)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(OutDir)</IntDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(Configuration)\$(ProjectName)\$(Platform)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)</IntDir>
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" />
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" />
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" />
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>..\sys;..\..\Network\client\debughlp\memtrace;..\x86;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;_DEBUG;_LIB;DISABLE_PERF_MEASUREMENT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<ProgramDataBaseFileName>$(IntDir)$(ProjectName).pdb</ProgramDataBaseFileName>
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Lib>
<OutputFile>$(OutDir)$(ProjectName).lib</OutputFile>
</Lib>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Midl>
<TargetEnvironment>X64</TargetEnvironment>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>..\sys;..\..\Network\client\debughlp\memtrace;..\x86;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;_DEBUG;_LIB;DISABLE_PERF_MEASUREMENT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<ProgramDataBaseFileName>$(IntDir)$(ProjectName).pdb</ProgramDataBaseFileName>
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Lib>
<OutputFile>$(OutDir)$(ProjectName).lib</OutputFile>
</Lib>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<WholeProgramOptimization>true</WholeProgramOptimization>
<AdditionalIncludeDirectories>..\sys;..\..\Network\client\debughlp\memtrace;..\x86;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;NDEBUG;_LIB;ENABLE_OPTIMIZATIONS;DISABLE_PERF_MEASUREMENT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Lib>
<AdditionalOptions>/LTCG %(AdditionalOptions)</AdditionalOptions>
<OutputFile>$(OutDir)$(ProjectName).lib</OutputFile>
<LinkTimeCodeGeneration>true</LinkTimeCodeGeneration>
</Lib>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Midl>
<TargetEnvironment>X64</TargetEnvironment>
</Midl>
<ClCompile>
<AdditionalIncludeDirectories>..\sys;..\..\Network\client\debughlp\memtrace;..\x86;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;NDEBUG;_LIB;ENABLE_OPTIMIZATIONS;DISABLE_PERF_MEASUREMENT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<WholeProgramOptimization>true</WholeProgramOptimization>
</ClCompile>
<Lib>
<OutputFile>$(OutDir)$(ProjectName).lib</OutputFile>
<LinkTimeCodeGeneration>true</LinkTimeCodeGeneration>
</Lib>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="..\encode\encode.c" />
<ClCompile Include="..\encode\segenc.c" />
<ClCompile Include="..\encode\strenc.c" />
<ClCompile Include="..\encode\strenc_x86.c" />
<ClCompile Include="..\encode\strFwdTransform.c" />
<ClCompile Include="..\encode\strPredQuantEnc.c" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\sys\common.h" />
<ClInclude Include="..\encode\encode.h" />
<ClInclude Include="..\sys\windowsmediaphoto.h" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

58
jxrlib/image/x86/x86.h
View file

@ -1,58 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#pragma once
#include <assert.h>
#include <windows.h>
//================================
// bitio functions
//================================
#define PACKETLENGTH (1U<<12) // 4kB
#define readIS_L1(pSC, pIO) readIS(pSC, pIO)
#define readIS_L2(pSC, pIO) (void)(pSC, pIO)
#define writeIS_L1(pSC, pIO) writeIS(pSC, pIO)
#define writeIS_L2(pSC, pIO) (void)(pSC, pIO)
//================================
// common defines
//================================
#define FORCE_INLINE __forceinline
#define UINTPTR_T uintptr_t
#define INTPTR_T intptr_t
//================================
// quantization optimization
//================================
#define RECIP_QUANT_OPT

224
jxrlib/jxrencoderdecoder/JXRDecApp_vc11.vcxproj
View file

@ -1,224 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectGuid>{472FCCAF-BDFE-4F36-BEEF-09C242F4A98A}</ProjectGuid>
<Keyword>Win32Proj</Keyword>
<ProjectName>JXRDecApp</ProjectName>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v110</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v110</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v110</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v110</PlatformToolset>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" 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|Win32'" 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)'=='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>10.0.40219.1</_ProjectFileVersion>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(Configuration)/$(ProjectName)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(OutDir)</IntDir>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</LinkIncremental>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(Configuration)/$(ProjectName)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(OutDir)</IntDir>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(Configuration)\$(ProjectName)\$(Platform)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)</IntDir>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</LinkIncremental>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(Configuration)\$(ProjectName)\$(Platform)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)</IntDir>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</LinkIncremental>
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" />
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" />
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" />
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>..\JXRTestLib;..\JXRGlueLib;..\image\sys;..\common\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>EditAndContinue</DebugInformationFormat>
</ClCompile>
<Link>
<OutputFile>$(OutDir)$(ProjectName).exe</OutputFile>
<GenerateDebugInformation>true</GenerateDebugInformation>
<ProgramDatabaseFile>$(OutDir)$(ProjectName).pdb</ProgramDatabaseFile>
<SubSystem>Console</SubSystem>
<TargetMachine>MachineX86</TargetMachine>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<AdditionalIncludeDirectories>..\JXRTestLib;..\JXRGlueLib;..\image\sys;..\common\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<WholeProgramOptimization>true</WholeProgramOptimization>
</ClCompile>
<Link>
<OutputFile>$(OutDir)$(ProjectName).exe</OutputFile>
<GenerateDebugInformation>true</GenerateDebugInformation>
<ProgramDatabaseFile>$(OutDir)$(ProjectName).pdb</ProgramDatabaseFile>
<SubSystem>Console</SubSystem>
<OptimizeReferences>true</OptimizeReferences>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<TargetMachine>MachineX86</TargetMachine>
<LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Midl>
<TargetEnvironment>X64</TargetEnvironment>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>..\JXRTestLib;..\JXRGlueLib;..\image\sys;..\common\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Link>
<OutputFile>$(OutDir)$(ProjectName).exe</OutputFile>
<GenerateDebugInformation>true</GenerateDebugInformation>
<ProgramDatabaseFile>$(OutDir)$(ProjectName).pdb</ProgramDatabaseFile>
<SubSystem>Console</SubSystem>
<TargetMachine>MachineX64</TargetMachine>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Midl>
<TargetEnvironment>X64</TargetEnvironment>
</Midl>
<ClCompile>
<AdditionalIncludeDirectories>..\JXRTestLib;..\JXRGlueLib;..\image\sys;..\common\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<WholeProgramOptimization>true</WholeProgramOptimization>
</ClCompile>
<Link>
<OutputFile>$(OutDir)$(ProjectName).exe</OutputFile>
<GenerateDebugInformation>true</GenerateDebugInformation>
<ProgramDatabaseFile>$(OutDir)$(ProjectName).pdb</ProgramDatabaseFile>
<SubSystem>Console</SubSystem>
<OptimizeReferences>true</OptimizeReferences>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<TargetMachine>MachineX64</TargetMachine>
<LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="JxrDecApp.c" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\image\VC11Projects\CommonLib_vc11.vcxproj">
<Project>{4b4c055c-170e-4dcf-8f73-bed91be7cfa4}</Project>
<Private>true</Private>
<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
<CopyLocalSatelliteAssemblies>false</CopyLocalSatelliteAssemblies>
<LinkLibraryDependencies>true</LinkLibraryDependencies>
<UseLibraryDependencyInputs>false</UseLibraryDependencyInputs>
</ProjectReference>
<ProjectReference Include="..\image\VC11Projects\DecodeLib_vc11.vcxproj">
<Project>{f3ded308-7a6f-4b9f-8edf-af99dec8bde3}</Project>
<Private>true</Private>
<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
<CopyLocalSatelliteAssemblies>false</CopyLocalSatelliteAssemblies>
<LinkLibraryDependencies>true</LinkLibraryDependencies>
<UseLibraryDependencyInputs>false</UseLibraryDependencyInputs>
</ProjectReference>
<ProjectReference Include="..\image\VC11Projects\EncodeLib_vc11.vcxproj">
<Project>{f99f7b19-47a6-4677-94f2-93c12cf1fb97}</Project>
<Private>true</Private>
<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
<CopyLocalSatelliteAssemblies>false</CopyLocalSatelliteAssemblies>
<LinkLibraryDependencies>true</LinkLibraryDependencies>
<UseLibraryDependencyInputs>false</UseLibraryDependencyInputs>
</ProjectReference>
<ProjectReference Include="..\JXRGlueLib\JXRGlueLib_vc11.vcxproj">
<Project>{a69603cc-65e8-443f-8e31-737dbd6bb0db}</Project>
</ProjectReference>
<ProjectReference Include="..\JXRtestlib\JXRTestLib_vc11.vcxproj">
<Project>{a69603cc-65e8-443f-8e31-737dbd6bb0dc}</Project>
</ProjectReference>
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

222
jxrlib/jxrencoderdecoder/JXREncApp_vc11.vcxproj
View file

@ -1,222 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectGuid>{FCC17C5C-51B5-44CA-9D70-6C8384AE86E6}</ProjectGuid>
<Keyword>Win32Proj</Keyword>
<ProjectName>JXREncApp</ProjectName>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v110</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v110</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v110</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v110</PlatformToolset>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" 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|Win32'" 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)'=='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>10.0.40219.1</_ProjectFileVersion>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(Configuration)/$(ProjectName)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(OutDir)</IntDir>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</LinkIncremental>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(Configuration)/$(ProjectName)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(OutDir)</IntDir>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(Configuration)\$(ProjectName)\$(Platform)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)</IntDir>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</LinkIncremental>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(Configuration)\$(ProjectName)\$(Platform)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)</IntDir>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</LinkIncremental>
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" />
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" />
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" />
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>..\JXRTestLib;..\JXRGlueLib;..\image\sys;..\common\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>EditAndContinue</DebugInformationFormat>
</ClCompile>
<Link>
<OutputFile>$(OutDir)$(ProjectName).exe</OutputFile>
<GenerateDebugInformation>true</GenerateDebugInformation>
<ProgramDatabaseFile>$(OutDir)$(ProjectName).pdb</ProgramDatabaseFile>
<SubSystem>Console</SubSystem>
<TargetMachine>MachineX86</TargetMachine>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<AdditionalIncludeDirectories>..\JXRTestLib;..\JXRGlueLib;..\image\sys;..\common\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<WholeProgramOptimization>true</WholeProgramOptimization>
</ClCompile>
<Link>
<OutputFile>$(OutDir)$(ProjectName).exe</OutputFile>
<GenerateDebugInformation>true</GenerateDebugInformation>
<SubSystem>Console</SubSystem>
<OptimizeReferences>true</OptimizeReferences>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<TargetMachine>MachineX86</TargetMachine>
<LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Midl>
<TargetEnvironment>X64</TargetEnvironment>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>..\JXRTestLib;..\JXRGlueLib;..\image\sys;..\common\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Link>
<OutputFile>$(OutDir)$(ProjectName).exe</OutputFile>
<GenerateDebugInformation>true</GenerateDebugInformation>
<ProgramDatabaseFile>$(OutDir)$(ProjectName).pdb</ProgramDatabaseFile>
<SubSystem>Console</SubSystem>
<TargetMachine>MachineX64</TargetMachine>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Midl>
<TargetEnvironment>X64</TargetEnvironment>
</Midl>
<ClCompile>
<AdditionalIncludeDirectories>..\JXRTestLib;..\JXRGlueLib;..\image\sys;..\common\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<WholeProgramOptimization>true</WholeProgramOptimization>
</ClCompile>
<Link>
<OutputFile>$(OutDir)$(ProjectName).exe</OutputFile>
<GenerateDebugInformation>true</GenerateDebugInformation>
<SubSystem>Console</SubSystem>
<OptimizeReferences>true</OptimizeReferences>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<TargetMachine>MachineX64</TargetMachine>
<LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="JxrEncApp.c" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\image\VC11Projects\CommonLib_vc11.vcxproj">
<Project>{4b4c055c-170e-4dcf-8f73-bed91be7cfa4}</Project>
<Private>true</Private>
<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
<CopyLocalSatelliteAssemblies>false</CopyLocalSatelliteAssemblies>
<LinkLibraryDependencies>true</LinkLibraryDependencies>
<UseLibraryDependencyInputs>false</UseLibraryDependencyInputs>
</ProjectReference>
<ProjectReference Include="..\image\VC11Projects\DecodeLib_vc11.vcxproj">
<Project>{f3ded308-7a6f-4b9f-8edf-af99dec8bde3}</Project>
<Private>true</Private>
<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
<CopyLocalSatelliteAssemblies>false</CopyLocalSatelliteAssemblies>
<LinkLibraryDependencies>true</LinkLibraryDependencies>
<UseLibraryDependencyInputs>false</UseLibraryDependencyInputs>
</ProjectReference>
<ProjectReference Include="..\image\VC11Projects\EncodeLib_vc11.vcxproj">
<Project>{f99f7b19-47a6-4677-94f2-93c12cf1fb97}</Project>
<Private>true</Private>
<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
<CopyLocalSatelliteAssemblies>false</CopyLocalSatelliteAssemblies>
<LinkLibraryDependencies>true</LinkLibraryDependencies>
<UseLibraryDependencyInputs>false</UseLibraryDependencyInputs>
</ProjectReference>
<ProjectReference Include="..\JXRGlueLib\JXRGlueLib_vc11.vcxproj">
<Project>{a69603cc-65e8-443f-8e31-737dbd6bb0db}</Project>
</ProjectReference>
<ProjectReference Include="..\JXRTestlib\JXRTestLib_vc11.vcxproj">
<Project>{a69603cc-65e8-443f-8e31-737dbd6bb0dc}</Project>
</ProjectReference>
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

85
jxrlib/jxrencoderdecoder/JXR_vc11.sln
View file

@ -1,85 +0,0 @@
Microsoft Visual Studio Solution File, Format Version 11.00
# Visual Studio 2010
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "JXRGlueLib", "..\JXRGlueLib\JXRGlueLib_vc11.vcxproj", "{A69603CC-65E8-443F-8E31-737DBD6BB0DB}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "JXRCommonLib", "..\image\VC11Projects\CommonLib_vc11.vcxproj", "{4B4C055C-170E-4DCF-8F73-BED91BE7CFA4}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "JXREncodeLib", "..\image\VC11Projects\EncodeLib_vc11.vcxproj", "{F99F7B19-47A6-4677-94F2-93C12CF1FB97}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "JXRDecodeLib", "..\image\VC11Projects\DecodeLib_vc11.vcxproj", "{F3DED308-7A6F-4B9F-8EDF-AF99DEC8BDE3}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "JXRDecApp", "JXRDecApp_vc11.vcxproj", "{472FCCAF-BDFE-4F36-BEEF-09C242F4A98A}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "JXREncApp", "JXREncApp_vc11.vcxproj", "{FCC17C5C-51B5-44CA-9D70-6C8384AE86E6}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "JXRTestLib", "..\JXRTestlib\JXRTestLib_vc11.vcxproj", "{A69603CC-65E8-443F-8E31-737DBD6BB0DC}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Win32 = Debug|Win32
Debug|x64 = Debug|x64
Release|Win32 = Release|Win32
Release|x64 = Release|x64
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{A69603CC-65E8-443F-8E31-737DBD6BB0DB}.Debug|Win32.ActiveCfg = Debug|Win32
{A69603CC-65E8-443F-8E31-737DBD6BB0DB}.Debug|Win32.Build.0 = Debug|Win32
{A69603CC-65E8-443F-8E31-737DBD6BB0DB}.Debug|x64.ActiveCfg = Debug|x64
{A69603CC-65E8-443F-8E31-737DBD6BB0DB}.Debug|x64.Build.0 = Debug|x64
{A69603CC-65E8-443F-8E31-737DBD6BB0DB}.Release|Win32.ActiveCfg = Release|Win32
{A69603CC-65E8-443F-8E31-737DBD6BB0DB}.Release|Win32.Build.0 = Release|Win32
{A69603CC-65E8-443F-8E31-737DBD6BB0DB}.Release|x64.ActiveCfg = Release|x64
{A69603CC-65E8-443F-8E31-737DBD6BB0DB}.Release|x64.Build.0 = Release|x64
{4B4C055C-170E-4DCF-8F73-BED91BE7CFA4}.Debug|Win32.ActiveCfg = Debug|Win32
{4B4C055C-170E-4DCF-8F73-BED91BE7CFA4}.Debug|Win32.Build.0 = Debug|Win32
{4B4C055C-170E-4DCF-8F73-BED91BE7CFA4}.Debug|x64.ActiveCfg = Debug|x64
{4B4C055C-170E-4DCF-8F73-BED91BE7CFA4}.Debug|x64.Build.0 = Debug|x64
{4B4C055C-170E-4DCF-8F73-BED91BE7CFA4}.Release|Win32.ActiveCfg = Release|Win32
{4B4C055C-170E-4DCF-8F73-BED91BE7CFA4}.Release|Win32.Build.0 = Release|Win32
{4B4C055C-170E-4DCF-8F73-BED91BE7CFA4}.Release|x64.ActiveCfg = Release|x64
{4B4C055C-170E-4DCF-8F73-BED91BE7CFA4}.Release|x64.Build.0 = Release|x64
{F99F7B19-47A6-4677-94F2-93C12CF1FB97}.Debug|Win32.ActiveCfg = Debug|Win32
{F99F7B19-47A6-4677-94F2-93C12CF1FB97}.Debug|Win32.Build.0 = Debug|Win32
{F99F7B19-47A6-4677-94F2-93C12CF1FB97}.Debug|x64.ActiveCfg = Debug|x64
{F99F7B19-47A6-4677-94F2-93C12CF1FB97}.Debug|x64.Build.0 = Debug|x64
{F99F7B19-47A6-4677-94F2-93C12CF1FB97}.Release|Win32.ActiveCfg = Release|Win32
{F99F7B19-47A6-4677-94F2-93C12CF1FB97}.Release|Win32.Build.0 = Release|Win32
{F99F7B19-47A6-4677-94F2-93C12CF1FB97}.Release|x64.ActiveCfg = Release|x64
{F99F7B19-47A6-4677-94F2-93C12CF1FB97}.Release|x64.Build.0 = Release|x64
{F3DED308-7A6F-4B9F-8EDF-AF99DEC8BDE3}.Debug|Win32.ActiveCfg = Debug|Win32
{F3DED308-7A6F-4B9F-8EDF-AF99DEC8BDE3}.Debug|Win32.Build.0 = Debug|Win32
{F3DED308-7A6F-4B9F-8EDF-AF99DEC8BDE3}.Debug|x64.ActiveCfg = Debug|x64
{F3DED308-7A6F-4B9F-8EDF-AF99DEC8BDE3}.Debug|x64.Build.0 = Debug|x64
{F3DED308-7A6F-4B9F-8EDF-AF99DEC8BDE3}.Release|Win32.ActiveCfg = Release|Win32
{F3DED308-7A6F-4B9F-8EDF-AF99DEC8BDE3}.Release|Win32.Build.0 = Release|Win32
{F3DED308-7A6F-4B9F-8EDF-AF99DEC8BDE3}.Release|x64.ActiveCfg = Release|x64
{F3DED308-7A6F-4B9F-8EDF-AF99DEC8BDE3}.Release|x64.Build.0 = Release|x64
{472FCCAF-BDFE-4F36-BEEF-09C242F4A98A}.Debug|Win32.ActiveCfg = Debug|Win32
{472FCCAF-BDFE-4F36-BEEF-09C242F4A98A}.Debug|Win32.Build.0 = Debug|Win32
{472FCCAF-BDFE-4F36-BEEF-09C242F4A98A}.Debug|x64.ActiveCfg = Debug|x64
{472FCCAF-BDFE-4F36-BEEF-09C242F4A98A}.Debug|x64.Build.0 = Debug|x64
{472FCCAF-BDFE-4F36-BEEF-09C242F4A98A}.Release|Win32.ActiveCfg = Release|Win32
{472FCCAF-BDFE-4F36-BEEF-09C242F4A98A}.Release|Win32.Build.0 = Release|Win32
{472FCCAF-BDFE-4F36-BEEF-09C242F4A98A}.Release|x64.ActiveCfg = Release|x64
{472FCCAF-BDFE-4F36-BEEF-09C242F4A98A}.Release|x64.Build.0 = Release|x64
{FCC17C5C-51B5-44CA-9D70-6C8384AE86E6}.Debug|Win32.ActiveCfg = Debug|Win32
{FCC17C5C-51B5-44CA-9D70-6C8384AE86E6}.Debug|Win32.Build.0 = Debug|Win32
{FCC17C5C-51B5-44CA-9D70-6C8384AE86E6}.Debug|x64.ActiveCfg = Debug|x64
{FCC17C5C-51B5-44CA-9D70-6C8384AE86E6}.Debug|x64.Build.0 = Debug|x64
{FCC17C5C-51B5-44CA-9D70-6C8384AE86E6}.Release|Win32.ActiveCfg = Release|Win32
{FCC17C5C-51B5-44CA-9D70-6C8384AE86E6}.Release|Win32.Build.0 = Release|Win32
{FCC17C5C-51B5-44CA-9D70-6C8384AE86E6}.Release|x64.ActiveCfg = Release|x64
{FCC17C5C-51B5-44CA-9D70-6C8384AE86E6}.Release|x64.Build.0 = Release|x64
{A69603CC-65E8-443F-8E31-737DBD6BB0DC}.Debug|Win32.ActiveCfg = Debug|Win32
{A69603CC-65E8-443F-8E31-737DBD6BB0DC}.Debug|Win32.Build.0 = Debug|Win32
{A69603CC-65E8-443F-8E31-737DBD6BB0DC}.Debug|x64.ActiveCfg = Debug|x64
{A69603CC-65E8-443F-8E31-737DBD6BB0DC}.Debug|x64.Build.0 = Debug|x64
{A69603CC-65E8-443F-8E31-737DBD6BB0DC}.Release|Win32.ActiveCfg = Release|Win32
{A69603CC-65E8-443F-8E31-737DBD6BB0DC}.Release|Win32.Build.0 = Release|Win32
{A69603CC-65E8-443F-8E31-737DBD6BB0DC}.Release|x64.ActiveCfg = Release|x64
{A69603CC-65E8-443F-8E31-737DBD6BB0DC}.Release|x64.Build.0 = Release|x64
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal

644
jxrlib/jxrencoderdecoder/JxrDecApp.c
View file

@ -1,644 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#include <JXRTest.h>
#include <time.h>
//================================================================
static const size_t SKIPFLEXBITS = 0xff;
//================================================================
// Command line argument support
//================================================================
typedef struct tagWMPDECAPPARGS
{
char* szInputFile;
char* szOutputFile;
Bool bVerbose;
PKPixelFormatGUID guidPixFormat;
// Bool bFlagRGB_BGR;
// region decode
size_t rLeftX;
size_t rTopY;
size_t rWidth;
size_t rHeight;
// thumbnail
size_t tThumbnailFactor;
// orientation
ORIENTATION oOrientation;
// post processing
U8 cPostProcStrength;
U8 uAlphaMode; // 0:no alpha 1: alpha only else: something + alpha
SUBBAND sbSubband; // which subbands to keep (for transcoding)
BITSTREAMFORMAT bfBitstreamFormat; // desired bitsream format (for transcoding)
CWMIStrCodecParam wmiSCP;
Bool bIgnoreOverlap;
} WMPDECAPPARGS;
//----------------------------------------------------------------
void WmpDecAppUsage(const char* szExe)
{
printf(CRLF);
printf("JPEG XR Decoder Utility" CRLF);
printf("Copyright 2013 Microsoft Corporation - All Rights Reserved" CRLF);
printf(CRLF);
printf("%s [options]..." CRLF, szExe);
printf(CRLF);
printf(" -i input.jxr/wdp Input JPEG XR/HD Photo file name" CRLF);
printf(CRLF);
printf(" -o output.bmp/tif/jxr Output image file name" CRLF);
printf(" bmp: <=8bpc, BGR" CRLF);
printf(" tif: >=8bpc, RGB" CRLF);
printf(" jxr: for compressed domain transcode" CRLF);
printf(CRLF);
printf(" -c format Specifies the uncompressed output format" CRLF);
printf(" 0: 24bppBGR" CRLF);
printf(" 1: 1bppBlackWhite" CRLF);
printf(" 2: 8bppGray" CRLF);
printf(" 3: 16bppGray" CRLF);
printf(" 4: 16bppGrayFixedPoint" CRLF);
printf(" 5: 16bppGrayHalf" CRLF);
// printf(" 6: 32bppGray" CRLF);
printf(" 7: 32bppGrayFixedPoint" CRLF);
printf(" 8: 32bppGrayFloat" CRLF);
printf(" 9: 24bppRGB" CRLF);
printf(" 10: 48bppRGB" CRLF);
printf(" 11: 48bppRGBFixedPoint" CRLF);
printf(" 12: 48bppRGBHalf" CRLF);
// printf(" 13: 96bppRGB" CRLF);
printf(" 14: 96bppRGBFixedPoint" CRLF);
printf(" 15: 128bppRGBFloat" CRLF);
printf(" 16: 32bppRGBE" CRLF);
printf(" 17: 32bppCMYK" CRLF);
printf(" 18: 64bppCMYK" CRLF);
/*
printf(" 19 - YUV 420" CRLF);
printf(" 20 - YUV 422" CRLF);
printf(" 21 - YUV 444" CRLF);
*/
printf(" 22: 32bppBGRA" CRLF);
printf(" 23: 64bppRGBA" CRLF);
printf(" 24: 64bppRGBAFixedPoint" CRLF);
printf(" 25: 64bppRGBAHalf" CRLF);
// printf(" 26 - 128bpp RGBA" CRLF);
printf(" 27: 128bppRGBAFixedPoint" CRLF);
printf(" 28: 128bppRGBAFloat" CRLF);
printf(" 29: 16bppBGR555" CRLF);
printf(" 30: 16bppBGR565" CRLF);
printf(" 31: 32bppBGR101010" CRLF);
//printf(" 101..116 - 1..16 channel 8bpp" CRLF);
printf(" 32: 40bppCMYKA" CRLF);
printf(" 33: 80bppCMYKA" CRLF);
printf(" 34: 32bppBGR" CRLF);
/*
printf(" 35: 32bppPBGRA" CRLF);
printf(" 36: 64bppPRGBA" CRLF);
printf(" 37: 128bppPRGBA Float" CRLF);
*/
printf(CRLF);
printf(" -r top left height width Specifies the rectangle for region decode" CRLF);
printf(CRLF);
printf(" -T m Reduced resolution (mipmap) decode" CRLF);
printf(" 0: Full resolution (default)" CRLF);
printf(" 1: 1/2 res (down-sampled from full res)" CRLF);
printf(" 2: 1/4 res (native decode)" CRLF);
printf(" 3: 1/8 res (down-sampled from 1/4 res)" CRLF);
printf(" 4: 1/16 res (native decode)" CRLF);
printf(" >4: 1/(2^m) res (down-sampled from 1/16 res) " CRLF);
printf(CRLF);
printf(" -O orientation 0: No transformation (default)" CRLF);
printf(" 1: Flip vertically" CRLF);
printf(" 2: Flip horizontally" CRLF);
printf(" 3: Flip vertically & horizontally" CRLF);
printf(" 4: Rotate 90 degrees CW" CRLF);
printf(" 5: Rotate 90 degrees CW & flip vertically" CRLF);
printf(" 6: Rotate 90 degrees CW & flip horizontally" CRLF);
printf(" 7: Rotate 90 degrees CW & flip vert & horiz" CRLF);
printf(CRLF);
printf(" -s skip subbands Used for compressed domain transcoding" CRLF);
printf(" 0: All subbands included (default)" CRLF);
printf(" 1: Skip flexbits" CRLF);
printf(" 2: Skip highpass" CRLF);
printf(" 3: Skip highpass & lowpass (DC only)" CRLF);
printf(CRLF);
printf(" -a alpha decode 0: Decode without alpha channel" CRLF);
printf(" 1: Decode only alpha channel" CRLF);
printf(" 2: Decode image & alpha (default)" CRLF);
printf(CRLF);
printf(" -p strength Post processing filter strength" CRLF);
printf(" 0: None (default)" CRLF);
printf(" 1: Light" CRLF);
printf(" 2: Medium" CRLF);
printf(" 3: Strong" CRLF);
printf(" 4: Very strong" CRLF);
printf(CRLF);
printf(" -C Suppress overlapping boundary macro blocks" CRLF);
printf(" (Used for compressed domain tile extraction)" CRLF);
printf(CRLF);
printf(" -t Display timing information" CRLF);
printf(CRLF);
printf(" -v Display verbose decoder information" CRLF);
printf(CRLF);
printf("Eg: %s -i input.jxr -o output.bmp -c 0" CRLF, szExe);
}
void WmpDecAppShowArgs(WMPDECAPPARGS* args)
{
GUID guidPF = args->guidPixFormat;
printf("================================" CRLF);
printf("Input file: %s" CRLF, args->szInputFile);
printf("Output file: %s" CRLF, args->szOutputFile);
printf("Color format: %08X-%04X-%04X-%02X%02X%02X%02X%02X%02X%02X%02X" CRLF,
guidPF.Data1, guidPF.Data2, guidPF.Data3, guidPF.Data4[0], guidPF.Data4[1], guidPF.Data4[2],
guidPF.Data4[3], guidPF.Data4[4], guidPF.Data4[5], guidPF.Data4[6], guidPF.Data4[7]);
printf("Post processing strength: %d" CRLF, args->cPostProcStrength);
printf("Thumbnail: %d" CRLF, (int) args->tThumbnailFactor);
printf("================================" CRLF);
}
//----------------------------------------------------------------
void WmpDecAppInitDefaultArgs(WMPDECAPPARGS* args)
{
memset(args, 0, sizeof(*args));
args->guidPixFormat = GUID_PKPixelFormatDontCare;
// args->bFlagRGB_BGR = FALSE; //default BGR
args->bVerbose = FALSE;
args->tThumbnailFactor = 0;
args->oOrientation = O_NONE;
args->cPostProcStrength = 0;
args->uAlphaMode = 255;
args->sbSubband = SB_ALL;
}
ERR WmpDecAppValidateArgs(WMPDECAPPARGS* args)
{
ERR err = WMP_errSuccess;
Test(NULL != args->szInputFile, WMP_errInvalidParameter);
Test(NULL != args->szOutputFile, WMP_errInvalidParameter);
//Test(GUID_PKPixelFormatDontCare != args->enPixelFormat, WMP_errInvalidParameter);
Cleanup:
return err;
}
ERR WmpDecAppParseArgs(int argc, char* argv[], WMPDECAPPARGS* args)
{
ERR err = WMP_errSuccess;
int c = 0, i = 1;
// char* arg = NULL;
static const PKPixelFormatGUID* pixelFormat[] =
{
&GUID_PKPixelFormat24bppRGB,
&GUID_PKPixelFormatBlackWhite,
&GUID_PKPixelFormat8bppGray,
&GUID_PKPixelFormat16bppGray,
&GUID_PKPixelFormat16bppGrayFixedPoint,
&GUID_PKPixelFormat16bppGrayHalf,
&GUID_PKPixelFormatDontCare, // &GUID_PKPixelFormat32bppGray,
&GUID_PKPixelFormat32bppGrayFixedPoint,
&GUID_PKPixelFormat32bppGrayFloat,
&GUID_PKPixelFormat24bppRGB,
&GUID_PKPixelFormat48bppRGB,
&GUID_PKPixelFormat48bppRGBFixedPoint,
&GUID_PKPixelFormat48bppRGBHalf,
&GUID_PKPixelFormatDontCare, // &GUID_PKPixelFormat96bppRGB,
&GUID_PKPixelFormat96bppRGBFixedPoint,
&GUID_PKPixelFormat128bppRGBFloat,
&GUID_PKPixelFormat32bppRGBE,
&GUID_PKPixelFormat32bppCMYK,
&GUID_PKPixelFormat64bppCMYK,
&GUID_PKPixelFormat12bppYUV420,
&GUID_PKPixelFormat16bppYUV422,
&GUID_PKPixelFormat24bppYUV444,
// &GUID_PKPixelFormat32bppRGBA,
&GUID_PKPixelFormat32bppBGRA,
&GUID_PKPixelFormat64bppRGBA,
&GUID_PKPixelFormat64bppRGBAFixedPoint,
&GUID_PKPixelFormat64bppRGBAHalf,
&GUID_PKPixelFormatDontCare, // &GUID_PKPixelFormat128bppRGBA,
&GUID_PKPixelFormat128bppRGBAFixedPoint,
&GUID_PKPixelFormat128bppRGBAFloat,
&GUID_PKPixelFormat16bppRGB555,
&GUID_PKPixelFormat16bppRGB565,
&GUID_PKPixelFormat32bppRGB101010,
&GUID_PKPixelFormat40bppCMYKAlpha,
&GUID_PKPixelFormat80bppCMYKAlpha,
&GUID_PKPixelFormat32bppBGR,
&GUID_PKPixelFormat32bppPBGRA,
&GUID_PKPixelFormat64bppPRGBA,
&GUID_PKPixelFormat128bppPRGBAFloat,
};
size_t InvalidPF[9] = {6, 13, 19, 20, 21, 26, 35, 36, 37};
int k;
WmpDecAppInitDefaultArgs(args);
while(i < argc && argv[i][0] == '-')
// while (EOF != (c = argit(argc, argv, "i:o:c:ptv", &arg)))
{
/* separate out the no-argument switches */
switch ((c = argv[i][1])) {
case 't':
// NOOP - now we always print timing info
break;
case 'v':
args->bVerbose = !FALSE;
break;
case 'C':
args->bIgnoreOverlap = TRUE;
break;
case 'f':
args->bfBitstreamFormat = FREQUENCY;
break;
default:
i ++;
if (i == argc || argv[i][0] == '-') // need more info
Call(WMP_errInvalidArgument);
switch (c)
{
case 'i':
args->szInputFile= argv[i];
break;
case 'o':
args->szOutputFile = argv[i];
break;
case 'p':
args->cPostProcStrength = (U8)atoi(argv[i]);
break;
case 'c':
{
size_t idxPF = (size_t)atol(argv[i]);
FailIf(sizeof2(pixelFormat) <= idxPF, WMP_errUnsupportedFormat);
for (k = 0; k < 9; k++)
{
if (InvalidPF[k] == idxPF)
{
printf("*** ERROR: Unsupported format in JPEG XR ***\n");
Call(WMP_errInvalidArgument);
}
}
args->guidPixFormat = *pixelFormat[idxPF];
break;
}
/* case 'R':
args->bFlagRGB_BGR = (Bool)atoi(argv[i]);
break;
*/
case 'a':
args->uAlphaMode = (U8)atoi(argv[i]);
break;
case 's':
args->sbSubband = (SUBBAND)atoi(argv[i]);
break;
case 'r': // Region decode
if(i + 3 >= argc || argv[i + 1][0] == '-' || argv[i + 2][0] == '-' || argv[i + 3][0] == '-') // not a valid region
Call(WMP_errInvalidArgument);
args->rTopY = (size_t)atoi(argv[i]);
args->rLeftX = (size_t)atoi(argv[i + 1]);
args->rHeight = (size_t)atoi(argv[i + 2]);
args->rWidth = (size_t)atoi(argv[i + 3]);
i += 3;
break;
case 'T': // thumnail decode
args->tThumbnailFactor = (size_t)atoi(argv[i]);
if (args->tThumbnailFactor == 0) { // skip flexbits
args->tThumbnailFactor = SKIPFLEXBITS;
}
break;
case 'O': // orientation
args->oOrientation = (atoi(argv[i]) < 8 ? atoi(argv[i]) : O_NONE);
break;
default:
Call(WMP_errInvalidArgument);
break;
}
}
i ++;
}
Call(WmpDecAppValidateArgs(args));
Cleanup:
return err;
}
//================================================================
// Encoder factory on file extension
//================================================================
ERR WmpDecAppCreateEncoderFromExt(
PKCodecFactory* pCFactory,
const char* szExt,
PKImageEncode** ppIE)
{
ERR err = WMP_errSuccess;
const PKIID* pIID = NULL;
UNREFERENCED_PARAMETER( pCFactory );
// get encod PKIID
Call(GetTestEncodeIID(szExt, &pIID));
// Create encoder
Call(PKTestFactory_CreateCodec(pIID, ppIE));
Cleanup:
return err;
}
//================================================================
// main function
//================================================================
int
#ifndef __ANSI__
__cdecl
#endif // __ANSI__
main(int argc, char* argv[])
{
ERR err = WMP_errSuccess;
PKFactory* pFactory = NULL;
PKCodecFactory* pCodecFactory = NULL;
PKImageDecode* pDecoder = NULL;
WMPDECAPPARGS args = {0};
char* pExt = NULL;
U32 cFrame = 0;
U32 i = 0;
PKPixelInfo PI;
// static size_t cChannels[CFT_MAX] = {1, 3, 3, 3, 4, 4, -1, 3, 3, -1};
//================================
// parse command line parameters
if (1 == argc)
{
WmpDecAppUsage(argv[0]);
return 0;
}
Call(WmpDecAppParseArgs(argc, argv, &args));
if (args.bVerbose)
{
WmpDecAppShowArgs(&args);
}
//================================
pExt = strrchr(args.szOutputFile, '.');
FailIf(NULL == pExt, WMP_errUnsupportedFormat);
//================================
Call(PKCreateFactory(&pFactory, PK_SDK_VERSION));
Call(PKCreateCodecFactory(&pCodecFactory, WMP_SDK_VERSION));
Call(pCodecFactory->CreateDecoderFromFile(args.szInputFile, &pDecoder));
//==== set default color format
if(IsEqualGUID(&args.guidPixFormat, &GUID_PKPixelFormatDontCare)) {
// take deocder color format and try to look up better one
// (e.g. 32bppBGR -> 24bppBGR etc.)
PKPixelInfo newPI;
newPI.pGUIDPixFmt = PI.pGUIDPixFmt = &pDecoder->guidPixFormat;
Call(PixelFormatLookup(&newPI, LOOKUP_FORWARD));
Call(PixelFormatLookup(&newPI, LOOKUP_BACKWARD_TIF));
args.guidPixFormat = *newPI.pGUIDPixFmt;
}
else
PI.pGUIDPixFmt = &args.guidPixFormat;
// pDecoder->WMP.wmiI.bRGB = args.bFlagRGB_BGR;
// == color transcoding,
if(IsEqualGUID(&args.guidPixFormat, &GUID_PKPixelFormat8bppGray) || IsEqualGUID(&args.guidPixFormat, &GUID_PKPixelFormat16bppGray)){ // ** => Y transcoding
pDecoder->guidPixFormat = args.guidPixFormat;
pDecoder->WMP.wmiI.cfColorFormat = Y_ONLY;
}
else if(IsEqualGUID(&args.guidPixFormat, &GUID_PKPixelFormat24bppRGB) && pDecoder->WMP.wmiI.cfColorFormat == CMYK){ // CMYK = > RGB
pDecoder->WMP.wmiI.cfColorFormat = CF_RGB;
pDecoder->guidPixFormat = args.guidPixFormat;
pDecoder->WMP.wmiI.bRGB = 1; //RGB
}
PixelFormatLookup(&PI, LOOKUP_FORWARD);
if(255 == args.uAlphaMode)//user didn't set
{
if(!!(PI.grBit & PK_pixfmtHasAlpha))
args.uAlphaMode = 2;//default is image & alpha for formats with alpha
else
args.uAlphaMode = 0;//otherwise, 0
}
pDecoder->WMP.wmiSCP.bfBitstreamFormat = args.bfBitstreamFormat;
pDecoder->WMP.wmiSCP.uAlphaMode = args.uAlphaMode;
pDecoder->WMP.wmiSCP.sbSubband = args.sbSubband;
pDecoder->WMP.bIgnoreOverlap = args.bIgnoreOverlap;
pDecoder->WMP.wmiI.cfColorFormat = PI.cfColorFormat;
pDecoder->WMP.wmiI.bdBitDepth = PI.bdBitDepth;
pDecoder->WMP.wmiI.cBitsPerUnit = PI.cbitUnit;
//==== Validate thumbnail decode parameters =====
pDecoder->WMP.wmiI.cThumbnailWidth = pDecoder->WMP.wmiI.cWidth;
pDecoder->WMP.wmiI.cThumbnailHeight = pDecoder->WMP.wmiI.cHeight;
pDecoder->WMP.wmiI.bSkipFlexbits = FALSE;
if(args.tThumbnailFactor > 0 && args.tThumbnailFactor != SKIPFLEXBITS){
size_t tSize = ((size_t)1 << args.tThumbnailFactor);
pDecoder->WMP.wmiI.cThumbnailWidth = (pDecoder->WMP.wmiI.cWidth + tSize - 1) / tSize;
pDecoder->WMP.wmiI.cThumbnailHeight = (pDecoder->WMP.wmiI.cHeight + tSize - 1) / tSize;
if(pDecoder->WMP.wmiI.cfColorFormat == YUV_420 || pDecoder->WMP.wmiI.cfColorFormat == YUV_422){ // unsupported thumbnail format
pDecoder->WMP.wmiI.cfColorFormat = YUV_444;
}
}
else if (args.tThumbnailFactor == SKIPFLEXBITS) {
pDecoder->WMP.wmiI.bSkipFlexbits = TRUE;
}
if(args.rWidth == 0 || args.rHeight == 0){ // no region decode
args.rLeftX = args.rTopY = 0;
args.rWidth = pDecoder->WMP.wmiI.cThumbnailWidth;
args.rHeight = pDecoder->WMP.wmiI.cThumbnailHeight;
}
pDecoder->WMP.wmiI.cROILeftX = args.rLeftX;
pDecoder->WMP.wmiI.cROITopY = args.rTopY;
pDecoder->WMP.wmiI.cROIWidth = args.rWidth;
pDecoder->WMP.wmiI.cROIHeight = args.rHeight;
pDecoder->WMP.wmiI.oOrientation = args.oOrientation;
pDecoder->WMP.wmiI.cPostProcStrength = args.cPostProcStrength;
pDecoder->WMP.wmiSCP.bVerbose = args.bVerbose;
Call(pDecoder->GetFrameCount(pDecoder, &cFrame));
//================================
for (i = 0; ; ++i)
{
struct WMPStream* pEncodeStream = NULL;
PKImageEncode* pEncoder = NULL;
PKFormatConverter* pConverter = NULL;
Float rX = 0.0, rY = 0.0;
PKRect rect = {0, 0, 0, 0};
//================================
Call(pCodecFactory->CreateFormatConverter(&pConverter));
Call(pConverter->Initialize(pConverter, pDecoder, pExt, args.guidPixFormat));
//================================
Call(pFactory->CreateStreamFromFilename(&pEncodeStream, args.szOutputFile, "wb"));
Call(WmpDecAppCreateEncoderFromExt(pCodecFactory, pExt, &pEncoder));
if(pEncoder->bWMP)
Call(pEncoder->Initialize(pEncoder, pEncodeStream, &args.wmiSCP, sizeof(args.wmiSCP)));
else
Call(pEncoder->Initialize(pEncoder, pEncodeStream, NULL, 0));
//================================
Call(pEncoder->SetPixelFormat(pEncoder, args.guidPixFormat));
pEncoder->WMP.wmiSCP.bBlackWhite = pDecoder->WMP.wmiSCP.bBlackWhite;
//Call(pDecoder->GetSize(pDecoder, &rect.Width, &rect.Height));
rect.Width = (I32)(pDecoder->WMP.wmiI.cROIWidth);
rect.Height = (I32)(pDecoder->WMP.wmiI.cROIHeight);
if(args.oOrientation > O_FLIPVH){ // allocate memory for rotated image!
I32 bah = rect.Width;
rect.Width = rect.Height;
rect.Height = bah;
}
Call(pEncoder->SetSize(pEncoder, rect.Width, rect.Height));
Call(pDecoder->GetResolution(pDecoder, &rX, &rY));
if(args.oOrientation > O_FLIPVH)
Call(pEncoder->SetResolution(pEncoder, rY, rX));
else
Call(pEncoder->SetResolution(pEncoder, rX, rY));
if(pEncoder->bWMP && args.tThumbnailFactor > 0){
printf("-T can not be used for compressed domain operation!\n");
return 0;
}
//================================
pEncoder->WriteSource = PKImageEncode_Transcode;
Call(pEncoder->WriteSource(pEncoder, pConverter, &rect));
//================================
// Call(pEncoder->Terminate(pEncoder));
pEncoder->Release(&pEncoder);
// multi-frame support NYI
if (i + 1 == cFrame)
{
break;
}
Call(pDecoder->SelectFrame(pDecoder, i + 1));
}
pDecoder->Release(&pDecoder);
Cleanup:
if (WMP_errUnsupportedFormat == err)
{
printf("*** ERROR: Unsupported format in JPEG XR ***\n");
}
else if (WMP_errSuccess != err)
{
WmpDecAppUsage(argv[0]);
}
return (int)err;
}

745
jxrlib/jxrencoderdecoder/JxrEncApp.c
View file

@ -1,745 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#include <JXRTest.h>
#include <time.h>
//================================================================
// Command line argument support
//================================================================
typedef struct tagWMPENCAPPARGS
{
char* szInputFile;
char* szOutputFile;
PKPixelFormatGUID guidPixFormat;
// Bool bFlagRGB_BGR;
CWMIStrCodecParam wmiSCP;
float fltImageQuality;
Bool bOverlapSet;
Bool bColorFormatSet;
} WMPENCAPPARGS;
//----------------------------------------------------------------
void WmpEncAppUsage(const char* szExe)
{
printf(CRLF);
printf("JPEG XR Encoder Utility" CRLF);
printf("Copyright 2013 Microsoft Corporation - All Rights Reserved" CRLF);
printf(CRLF);
printf("%s [options]..." CRLF, szExe);
printf(CRLF);
printf(" -i input.bmp/tif/hdr Input image file name" CRLF);
printf(" bmp: <=8bpc, BGR" CRLF);
printf(" tif: >=8bpc, RGB" CRLF);
printf(" hdr: 24bppRGBE only" CRLF);
printf(CRLF);
printf(" -o output.jxr Output JPEG XR file name" CRLF);
printf(CRLF);
printf(" -q quality [0.0 - 1.0) Default = 1.0, lossless" CRLF);
printf(" or quantization [1 - 255] Default = 1, lossless" CRLF);
printf(CRLF);
printf(" -c format Required to define uncompressed source pixel format" CRLF);
printf(" 0: 24bppBGR" CRLF);
printf(" 1: 1bppBlackWhite" CRLF);
printf(" 2: 8bppGray" CRLF);
printf(" 3: 16bppGray" CRLF);
printf(" 4: 16bppGrayFixedPoint" CRLF);
printf(" 5: 16bppGrayHalf" CRLF);
// printf(" 6: 32bppGray" CRLF);
printf(" 7: 32bppGrayFixedPoint" CRLF);
printf(" 8: 32bppGrayFloat" CRLF);
printf(" 9: 24bppRGB" CRLF);
printf(" 10: 48bppRGB" CRLF);
printf(" 11: 48bppRGBFixedPoint" CRLF);
printf(" 12: 48bppRGBHalf" CRLF);
// printf(" 13: 96bppRGB" CRLF);
printf(" 14: 96bppRGBFixedPoint" CRLF);
printf(" 15: 128bppRGBFloat" CRLF);
printf(" 16: 32bppRGBE" CRLF);
printf(" 17: 32bppCMYK" CRLF);
printf(" 18: 64bppCMYK" CRLF);
/*
printf(" 19 - YUV 420" CRLF);
printf(" 20 - YUV 422" CRLF);
printf(" 21 - YUV 444" CRLF);
*/
printf(" 22: 32bppBGRA" CRLF);
printf(" 23: 64bppRGBA" CRLF);
printf(" 24: 64bppRGBAFixedPoint" CRLF);
printf(" 25: 64bppRGBAHalf" CRLF);
// printf(" 26 - 128bpp RGBA" CRLF);
printf(" 27: 128bppRGBAFixedPoint" CRLF);
printf(" 28: 128bppRGBAFloat" CRLF);
printf(" 29: 16bppBGR555" CRLF);
printf(" 30: 16bppBGR565" CRLF);
printf(" 31: 32bppBGR101010" CRLF);
//printf(" 101..116 - 1..16 channel 8bpp" CRLF);
printf(" 32: 40bppCMYKA" CRLF);
printf(" 33: 80bppCMYKA" CRLF);
printf(" 34: 32bppBGR" CRLF);
/*
printf(" 35: 32bppPBGRA" CRLF);
printf(" 36: 64bppPRGBA" CRLF);
printf(" 37: 128bppPRGBA Float" CRLF);
*/
printf(CRLF);
printf(" -d chroma sub-sampling 0: Y-only" CRLF);
printf(" 1: YCoCg 4:2:0" CRLF);
printf(" 2: YCoCg 4:2:2" CRLF);
printf(" 3: YCoCg 4:4:4 (default)" CRLF);
printf(" (if not set is 4:4:4 for quality >= 0.5 or 4:2:0 for quality < 0.5)" CRLF);
printf(CRLF);
printf(" -l overlapping 0: No overlapping" CRLF);
printf(" 1: One level overlapping (default)" CRLF);
printf(" 2: Two level overlapping" CRLF);
printf(" (if not set is One for quality > 0.4 or Two for quality <= 0.4)" CRLF);
printf(CRLF);
printf(" -f Turn off frequency order bit stream (to spatial)" CRLF);
printf(CRLF);
printf(" -p Turn off progressive mode (to sequential)" CRLF);
printf(CRLF);
printf(" -t Display timing information" CRLF);
printf(CRLF);
printf(" -v Display verbose encoder information" CRLF);
printf(CRLF);
printf(" -V tile_wd0 [tile_wd1 ... ] Macro block columns per tile " CRLF);
printf(CRLF);
printf(" -H tile_ht0 [tile_ht1 ... ] Macro block rows per tile" CRLF);
printf(CRLF);
printf(" -U num_v_tiles num_h_tiles Vertical & horizontal tile count for uniform tiling" CRLF);
printf(CRLF);
printf(" -b Black/White Applies to 1bpp black/white images" CRLF);
printf(" 0: 0 = black (default)" CRLF);
printf(" 1: 0 = white" CRLF);
printf(CRLF);
printf(" -a alpha channel format Required for any pixel format with an alpha channel" CRLF);
printf(" 2: Planar alpha (default)" CRLF);
printf(" 3: Interleaved alpha" CRLF);
printf(" Other: Reserved, do not use" CRLF);
printf(CRLF);
printf(" -Q quantization for alpha [1 - 255] Default = 1, lossless" CRLF);
printf(CRLF);
printf(" -F trimmed flexbits [0 - 15] 0: no trimming (default)" CRLF);
printf(" 15: trim all" CRLF);
printf(CRLF);
printf(" -s skip subbands 0: All subbands included (default)" CRLF);
printf(" 1: Skip flexbits" CRLF);
printf(" 2: Skip highpass" CRLF);
printf(" 3: Skip highpass & lowpass (DC only)" CRLF);
printf(CRLF);
printf("Eg: %s -i input.bmp -o output.jxr -q 10" CRLF, szExe);
}
void WmpEncAppShowArgs(WMPENCAPPARGS* args)
{
const char *szCF[] = {"Y_ONLY", "YUV_420", "YUV_422", "YUV_444", "CMYK"};
GUID guidPF = args->guidPixFormat;
printf("================================" CRLF);
printf("Input file: %s" CRLF, args->szInputFile);
printf("Output file: %s" CRLF, args->szOutputFile);
printf("Color format: %08X-%04X-%04X-%02X%02X%02X%02X%02X%02X%02X%02X" CRLF,
guidPF.Data1, guidPF.Data2, guidPF.Data3, guidPF.Data4[0], guidPF.Data4[1], guidPF.Data4[2],
guidPF.Data4[3], guidPF.Data4[4], guidPF.Data4[5], guidPF.Data4[6], guidPF.Data4[7]);
printf("Internal cf: %s" CRLF, szCF[args->wmiSCP.cfColorFormat]);
printf("Overlap: %s" CRLF, 0 < args->wmiSCP.olOverlap ? "yes" : "no");
printf("DCOverlap: %s" CRLF, 1 < args->wmiSCP.olOverlap ? "yes" : "no");
printf("Alpha: %s" CRLF, 1 < args->wmiSCP.uAlphaMode ? "yes" : "no");
printf("================================" CRLF);
}
//----------------------------------------------------------------
void WmpEncAppInitDefaultArgs(WMPENCAPPARGS* args)
{
memset(args, 0, sizeof(*args));
args->guidPixFormat = GUID_PKPixelFormatDontCare;
args->wmiSCP.bVerbose = FALSE;
args->wmiSCP.cfColorFormat = YUV_444;
// args->bFlagRGB_BGR = FALSE; //default BGR
args->wmiSCP.bdBitDepth = BD_LONG;
args->wmiSCP.bfBitstreamFormat = FREQUENCY;
args->wmiSCP.bProgressiveMode = TRUE;
args->wmiSCP.olOverlap = OL_ONE;
args->wmiSCP.cNumOfSliceMinus1H = args->wmiSCP.cNumOfSliceMinus1V = 0;
args->wmiSCP.sbSubband = SB_ALL;
args->wmiSCP.uAlphaMode = 0;
args->wmiSCP.uiDefaultQPIndex = 1;
args->wmiSCP.uiDefaultQPIndexAlpha = 1;
args->fltImageQuality = 1.f;
args->bOverlapSet = 0;
args->bColorFormatSet = 0;
}
ERR WmpEncAppValidateArgs(WMPENCAPPARGS* args)
{
ERR err = WMP_errSuccess;
Test(NULL != args->szInputFile, WMP_errInvalidParameter);
Test(NULL != args->szOutputFile, WMP_errInvalidParameter);
Cleanup:
return err;
}
ERR WmpEncAppParseArgs(int argc, char* argv[], WMPENCAPPARGS* args)
{
ERR err = WMP_errSuccess;
static const PKPixelFormatGUID* pixelFormat[] =
{
&GUID_PKPixelFormat24bppBGR,
&GUID_PKPixelFormatBlackWhite,
&GUID_PKPixelFormat8bppGray,
&GUID_PKPixelFormat16bppGray,
&GUID_PKPixelFormat16bppGrayFixedPoint,
&GUID_PKPixelFormat16bppGrayHalf,
&GUID_PKPixelFormatDontCare, // &GUID_PKPixelFormat32bppGray,
&GUID_PKPixelFormat32bppGrayFixedPoint,
&GUID_PKPixelFormat32bppGrayFloat,
&GUID_PKPixelFormat24bppRGB,
&GUID_PKPixelFormat48bppRGB,
&GUID_PKPixelFormat48bppRGBFixedPoint,
&GUID_PKPixelFormat48bppRGBHalf,
&GUID_PKPixelFormatDontCare, // &GUID_PKPixelFormat96bppRGB,
&GUID_PKPixelFormat96bppRGBFixedPoint,
&GUID_PKPixelFormat128bppRGBFloat,
&GUID_PKPixelFormat32bppRGBE,
&GUID_PKPixelFormat32bppCMYK,
&GUID_PKPixelFormat64bppCMYK,
&GUID_PKPixelFormat12bppYUV420,
&GUID_PKPixelFormat16bppYUV422,
&GUID_PKPixelFormat24bppYUV444,
//&GUID_PKPixelFormat32bppRGBA,
&GUID_PKPixelFormat32bppBGRA,
&GUID_PKPixelFormat64bppRGBA,
&GUID_PKPixelFormat64bppRGBAFixedPoint,
&GUID_PKPixelFormat64bppRGBAHalf,
&GUID_PKPixelFormatDontCare, // &GUID_PKPixelFormat128bppRGBA,
&GUID_PKPixelFormat128bppRGBAFixedPoint,
&GUID_PKPixelFormat128bppRGBAFloat,
//&GUID_PKPixelFormat32bppPBGRA
&GUID_PKPixelFormat16bppRGB555,
&GUID_PKPixelFormat16bppRGB565,
&GUID_PKPixelFormat32bppRGB101010,
&GUID_PKPixelFormat40bppCMYKAlpha,
&GUID_PKPixelFormat80bppCMYKAlpha,
&GUID_PKPixelFormat32bppBGR,
&GUID_PKPixelFormat32bppPBGRA,
&GUID_PKPixelFormat64bppPRGBA,
&GUID_PKPixelFormat128bppPRGBAFloat,
};
size_t InvalidPF[9] = {6, 13, 19, 20, 21, 26, 35, 36, 37};
size_t AlphaPF[8] = {22, 23, 24, 25, 27, 28, 32, 33};
int i = 1, j = 0, k;
char c;
int idxPF = -1;
WmpEncAppInitDefaultArgs(args);
while (i < argc && argv[i][0] == '-')
{
switch ((c = argv[i][1])) {
/* the no-argument switches */
case 't':
// NOOP - now we always print timing info
break;
case 'v':
args->wmiSCP.bVerbose = !FALSE;
break;
/* simple flag argument */
case 'f':
args->wmiSCP.bfBitstreamFormat = SPATIAL;
break;
case 'p':
args->wmiSCP.bProgressiveMode = FALSE;
break;
case 'u':
args->wmiSCP.bUnscaledArith = TRUE;
break;
default:
i ++;
if (i == argc || argv[i][0] == '-') // need more info
Call(WMP_errInvalidArgument);
switch (c)
{
case 'i':
args->szInputFile = argv[i];
break;
case 'o':
args->szOutputFile = argv[i];
break;
case 'q':
{
args->fltImageQuality = (float) atof(argv[i]);
if (args->fltImageQuality < 0.f || args->fltImageQuality > 255.f)
Call(WMP_errInvalidArgument);
}
break;
case 'Q':
args->wmiSCP.uiDefaultQPIndexAlpha = (U8)(atoi(argv[i]));
break;
case 's':
args->wmiSCP.sbSubband = (SUBBAND)(atoi(argv[i]));
break;
case 'c':
idxPF = (size_t)atol(argv[i]);
for (k = 0; k < 9; k++)
{
if (InvalidPF[k] == (size_t) idxPF)
{
printf("*** Unsupported format in JPEG XR ***\n");
Call(WMP_errInvalidArgument);
}
}
break;
case 'a':
args->wmiSCP.uAlphaMode = (U8)atoi(argv[i]);
break;
/* case 'R':
args->bFlagRGB_BGR = (Bool)atoi(argv[i]);
break;
*/
case 'l':
args->wmiSCP.olOverlap = (OVERLAP)atoi(argv[i]);
args->bOverlapSet = 1;
break;
case 'd':
args->wmiSCP.cfColorFormat = (COLORFORMAT)atoi(argv[i]);
args->bColorFormatSet = 1;
break;
case 'H': // horizontal tiling
for(j = 0;;i ++, j ++){
args->wmiSCP.uiTileY[j] = atoi(argv[i]);
if(i + 1 == argc || argv[i + 1][0] == '-' || j >= MAX_TILES-1)
break;
}
args->wmiSCP.cNumOfSliceMinus1H = (U8)j;
break;
case 'V': // vertical tiling
for(j = 0;;i ++, j ++){
args->wmiSCP.uiTileX[j] = atoi(argv[i]);
if(i + 1 == argc || argv[i + 1][0] == '-' || j >= MAX_TILES-1)
break;
}
args->wmiSCP.cNumOfSliceMinus1V = (U8)j;
break;
case 'U': // uniform tiling
if(i + 1 < argc && argv[i + 1][0] != '-'){
if(atoi(argv[i]) > 0 && atoi(argv[i + 1]) > 0){
args->wmiSCP.cNumOfSliceMinus1H = atoi(argv[i]) - 1;
args->wmiSCP.cNumOfSliceMinus1V = atoi(argv[i + 1]) - 1;
}
i ++;
}
break;
case 'm':
args->wmiSCP.nLenMantissaOrShift = (U8)atoi(argv[i]);
break;
case 'C':
args->wmiSCP.nExpBias = (I8) atoi(argv[i]) + 128; // rollover arithmetic
break;
case 'b':
args->wmiSCP.bBlackWhite = (Bool)atoi(argv[i]);
break;
case 'F':
args->wmiSCP.uiTrimFlexBits = (U8)atoi(argv[i]);
if (args->wmiSCP.uiTrimFlexBits > 15)
args->wmiSCP.uiTrimFlexBits = 15;
break;
default:
Call(WMP_errInvalidArgument);
}
}
i ++;
}
FailIf((int) sizeof2(pixelFormat) <= idxPF, WMP_errUnsupportedFormat);
if (idxPF >= 0)
args->guidPixFormat = *pixelFormat[idxPF];
if ((idxPF >= 1) && (idxPF <= 8))
args->wmiSCP.cfColorFormat = Y_ONLY;
else if ((idxPF == 17) || (idxPF == 18) || (idxPF == 32) || (idxPF == 33))
args->wmiSCP.cfColorFormat = CMYK;
for (k = 0; k < 8; k++)
{
if (AlphaPF[k] == (size_t) idxPF)
{
if(0 == args->wmiSCP.uAlphaMode)//with Alpha and no default, set default as Planar
{
args->wmiSCP.uAlphaMode = 2;
}
break;
}
}
//================================
Call(WmpEncAppValidateArgs(args));
Cleanup:
return err;
}
// Y, U, V, YHP, UHP, VHP
int DPK_QPS_420[12][6] = { // for 8 bit only
{ 66, 65, 70, 72, 72, 77 },
{ 59, 58, 63, 64, 63, 68 },
{ 52, 51, 57, 56, 56, 61 },
{ 48, 48, 54, 51, 50, 55 },
{ 43, 44, 48, 46, 46, 49 },
{ 37, 37, 42, 38, 38, 43 },
{ 26, 28, 31, 27, 28, 31 },
{ 16, 17, 22, 16, 17, 21 },
{ 10, 11, 13, 10, 10, 13 },
{ 5, 5, 6, 5, 5, 6 },
{ 2, 2, 3, 2, 2, 2 }
};
int DPK_QPS_8[12][6] = {
{ 67, 79, 86, 72, 90, 98 },
{ 59, 74, 80, 64, 83, 89 },
{ 53, 68, 75, 57, 76, 83 },
{ 49, 64, 71, 53, 70, 77 },
{ 45, 60, 67, 48, 67, 74 },
{ 40, 56, 62, 42, 59, 66 },
{ 33, 49, 55, 35, 51, 58 },
{ 27, 44, 49, 28, 45, 50 },
{ 20, 36, 42, 20, 38, 44 },
{ 13, 27, 34, 13, 28, 34 },
{ 7, 17, 21, 8, 17, 21 }, // Photoshop 100%
{ 2, 5, 6, 2, 5, 6 }
};
int DPK_QPS_16[11][6] = {
{ 197, 203, 210, 202, 207, 213 },
{ 174, 188, 193, 180, 189, 196 },
{ 152, 167, 173, 156, 169, 174 },
{ 135, 152, 157, 137, 153, 158 },
{ 119, 137, 141, 119, 138, 142 },
{ 102, 120, 125, 100, 120, 124 },
{ 82, 98, 104, 79, 98, 103 },
{ 60, 76, 81, 58, 76, 81 },
{ 39, 52, 58, 36, 52, 58 },
{ 16, 27, 33, 14, 27, 33 },
{ 5, 8, 9, 4, 7, 8 }
};
int DPK_QPS_16f[11][6] = {
{ 148, 177, 171, 165, 187, 191 },
{ 133, 155, 153, 147, 172, 181 },
{ 114, 133, 138, 130, 157, 167 },
{ 97, 118, 120, 109, 137, 144 },
{ 76, 98, 103, 85, 115, 121 },
{ 63, 86, 91, 62, 96, 99 },
{ 46, 68, 71, 43, 73, 75 },
{ 29, 48, 52, 27, 48, 51 },
{ 16, 30, 35, 14, 29, 34 },
{ 8, 14, 17, 7, 13, 17 },
{ 3, 5, 7, 3, 5, 6 }
};
int DPK_QPS_32f[11][6] = {
{ 194, 206, 209, 204, 211, 217 },
{ 175, 187, 196, 186, 193, 205 },
{ 157, 170, 177, 167, 180, 190 },
{ 133, 152, 156, 144, 163, 168 },
{ 116, 138, 142, 117, 143, 148 },
{ 98, 120, 123, 96, 123, 126 },
{ 80, 99, 102, 78, 99, 102 },
{ 65, 79, 84, 63, 79, 84 },
{ 48, 61, 67, 45, 60, 66 },
{ 27, 41, 46, 24, 40, 45 },
{ 3, 22, 24, 2, 21, 22 }
};
//================================================================
// main function
//================================================================
int
#ifndef __ANSI__
__cdecl
#endif // __ANSI__
main(int argc, char* argv[])
{
ERR err = WMP_errSuccess;
PKFactory* pFactory = NULL;
struct WMPStream* pEncodeStream = NULL;
PKCodecFactory* pCodecFactory = NULL;
PKCodecFactory* pTestFactory = NULL;
PKImageEncode* pEncoder = NULL;
// clock_t start = 0, finish = 0;
WMPENCAPPARGS args;
char* pExt = NULL;
//================================
// parse command line parameters
if (1 == argc)
{
WmpEncAppUsage(argv[0]);
return 0;
}
Call(WmpEncAppParseArgs(argc, argv, &args));
if (args.wmiSCP.bVerbose)
{
WmpEncAppShowArgs(&args);
}
//================================
pExt = strrchr(args.szInputFile, '.');
FailIf(NULL == pExt, WMP_errUnsupportedFormat);
//================================
Call(PKCreateFactory(&pFactory, PK_SDK_VERSION));
Call(pFactory->CreateStreamFromFilename(&pEncodeStream, args.szOutputFile, "wb"));
//================================
Call(PKCreateCodecFactory(&pCodecFactory, WMP_SDK_VERSION));
Call(pCodecFactory->CreateCodec(&IID_PKImageWmpEncode, (void**)&pEncoder));
//----------------------------------------------------------------
Call(PKCreateTestFactory(&pTestFactory, WMP_SDK_VERSION));
//
// go through each image
//
//for (i = 0; ; ++i)
{
PKImageDecode* pDecoder = NULL;
PKFormatConverter* pConverter = NULL;
PKPixelInfo PI;
Float rX = 0.0, rY = 0.0;
PKRect rect = {0, 0, 0, 0};
//================================
Call(pTestFactory->CreateDecoderFromFile(args.szInputFile, &pDecoder));
if (IsEqualGUID(&args.guidPixFormat, &GUID_PKPixelFormatDontCare))
Call(pDecoder->GetPixelFormat(pDecoder, &args.guidPixFormat));
PI.pGUIDPixFmt = &args.guidPixFormat;
Call(PixelFormatLookup(&PI, LOOKUP_FORWARD));
if ((PI.grBit & PK_pixfmtHasAlpha) && args.wmiSCP.uAlphaMode == 0)
args.wmiSCP.uAlphaMode = 2; // with Alpha and no default, set default as Planar
FailIf(PI.uSamplePerPixel > 1 && PI.uBitsPerSample > 8 && args.wmiSCP.cfColorFormat != YUV_444,
WMP_errInvalidArgument);
//================================
Call(pCodecFactory->CreateFormatConverter(&pConverter));
Call(pConverter->Initialize(pConverter, pDecoder, pExt, args.guidPixFormat));
//================================
Call(pDecoder->GetSize(pDecoder, &rect.Width, &rect.Height));
if (args.wmiSCP.cNumOfSliceMinus1H == 0 && args.wmiSCP.uiTileY[0] > 0)
{
// # of horizontal slices, rounded down by half tile size.
U32 uTileY = args.wmiSCP.uiTileY[0] * MB_HEIGHT_PIXEL;
args.wmiSCP.cNumOfSliceMinus1H = (U32) rect.Height < (uTileY >> 1) ? 0 :
(rect.Height + (uTileY >> 1)) / uTileY - 1;
}
if (args.wmiSCP.cNumOfSliceMinus1V == 0 && args.wmiSCP.uiTileX[0] > 0)
{
// # of vertical slices, rounded down by half tile size.
U32 uTileX = args.wmiSCP.uiTileX[0] * MB_HEIGHT_PIXEL;
args.wmiSCP.cNumOfSliceMinus1V = (U32) rect.Width < (uTileX >> 1) ? 0 :
(rect.Width + (uTileX >> 1)) / uTileX - 1;
}
Call(pEncoder->Initialize(pEncoder, pEncodeStream, &args.wmiSCP, sizeof(args.wmiSCP)));
//ImageQuality Q (BD==1) Q (BD==8) Q (BD==16) Q (BD==32F) Subsample Overlap
//[0.0, 0.4] 8-IQ*5 (see table) (see table) (see table) 4:4:4 2
//(0.4, 0.8) 8-IQ*5 (see table) (see table) (see table) 4:4:4 1
//[0.8, 1.0) 8-IQ*5 (see table) (see table) (see table) 4:4:4 1
//[1.0, 1.0] 1 1 1 1 4:4:4 0
if (args.fltImageQuality < 1.0F)
{
if (!args.bOverlapSet)
{
if (args.fltImageQuality > 0.4F)
pEncoder->WMP.wmiSCP.olOverlap = OL_ONE;
else
pEncoder->WMP.wmiSCP.olOverlap = OL_TWO;
}
if (!args.bColorFormatSet)
{
if (args.fltImageQuality >= 0.5F || PI.uBitsPerSample > 8)
pEncoder->WMP.wmiSCP.cfColorFormat = YUV_444;
else
pEncoder->WMP.wmiSCP.cfColorFormat = YUV_420;
}
if (PI.bdBitDepth == BD_1)
{
pEncoder->WMP.wmiSCP.uiDefaultQPIndex = (U8)(8 - 5.0F *
args.fltImageQuality + 0.5F);
}
else
{
// remap [0.8, 0.866, 0.933, 1.0] to [0.8, 0.9, 1.0, 1.1]
// to use 8-bit DPK QP table (0.933 == Photoshop JPEG 100)
int qi;
float qf;
int* pQPs;
if (args.fltImageQuality > 0.8f && PI.bdBitDepth == BD_8 &&
pEncoder->WMP.wmiSCP.cfColorFormat != YUV_420 &&
pEncoder->WMP.wmiSCP.cfColorFormat != YUV_422)
args.fltImageQuality = 0.8f + (args.fltImageQuality - 0.8f) * 1.5f;
qi = (int) (10.f * args.fltImageQuality);
qf = 10.f * args.fltImageQuality - (float) qi;
pQPs =
(pEncoder->WMP.wmiSCP.cfColorFormat == YUV_420 ||
pEncoder->WMP.wmiSCP.cfColorFormat == YUV_422) ?
DPK_QPS_420[qi] :
(PI.bdBitDepth == BD_8 ? DPK_QPS_8[qi] :
(PI.bdBitDepth == BD_16 ? DPK_QPS_16[qi] :
(PI.bdBitDepth == BD_16F ? DPK_QPS_16f[qi] :
DPK_QPS_32f[qi])));
pEncoder->WMP.wmiSCP.uiDefaultQPIndex = (U8) (0.5f +
(float) pQPs[0] * (1.f - qf) + (float) (pQPs + 6)[0] * qf);
pEncoder->WMP.wmiSCP.uiDefaultQPIndexU = (U8) (0.5f +
(float) pQPs[1] * (1.f - qf) + (float) (pQPs + 6)[1] * qf);
pEncoder->WMP.wmiSCP.uiDefaultQPIndexV = (U8) (0.5f +
(float) pQPs[2] * (1.f - qf) + (float) (pQPs + 6)[2] * qf);
pEncoder->WMP.wmiSCP.uiDefaultQPIndexYHP = (U8) (0.5f +
(float) pQPs[3] * (1.f - qf) + (float) (pQPs + 6)[3] * qf);
pEncoder->WMP.wmiSCP.uiDefaultQPIndexUHP = (U8) (0.5f +
(float) pQPs[4] * (1.f - qf) + (float) (pQPs + 6)[4] * qf);
pEncoder->WMP.wmiSCP.uiDefaultQPIndexVHP = (U8) (0.5f +
(float) pQPs[5] * (1.f - qf) + (float) (pQPs + 6)[5] * qf);
}
}
else
{
pEncoder->WMP.wmiSCP.uiDefaultQPIndex = (U8) args.fltImageQuality;
}
if(pEncoder->WMP.wmiSCP.uAlphaMode == 2)
pEncoder->WMP.wmiSCP_Alpha.uiDefaultQPIndex = args.wmiSCP.uiDefaultQPIndexAlpha;
Call(pEncoder->SetPixelFormat(pEncoder, args.guidPixFormat));
Call(pEncoder->SetSize(pEncoder, rect.Width, rect.Height));
Call(pDecoder->GetResolution(pDecoder, &rX, &rY));
Call(pEncoder->SetResolution(pEncoder, rX, rY));
//================================
// re-encode the input source to the output
//
pEncoder->WriteSource = PKImageEncode_WriteSource;
Call(pEncoder->WriteSource(pEncoder, pConverter, &rect));
pConverter->Release(&pConverter);
pDecoder->Release(&pDecoder);
//if (i + 1 == 5)
//{
// break;
//}
// multi-frame support NYI
//Call(pEncoder->CreateNewFrame(pEncoder, &wmiSCP, sizeof(wmiSCP)));
}
// Call(pEncoder->Terminate(pEncoder));
pEncoder->Release(&pEncoder);
Cleanup:
if (WMP_errSuccess != err)
{
WmpEncAppUsage(argv[0]);
}
return (int)err;
}

930
jxrlib/jxrgluelib/JXRGlue.c
View file

@ -1,930 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#include <stdlib.h>
#include <ctype.h>
#define INITGUID
#include <JXRGlue.h>
//================================================================
const PKIID IID_PKImageScanEncode = 1;
const PKIID IID_PKImageFrameEncode = 2;
const PKIID IID_PKImageUnsupported = 100;
const PKIID IID_PKImageWmpEncode = 101;
const PKIID IID_PKImageWmpDecode = 201;
//================================================================
// Misc supporting functions
//================================================================
ERR PKAlloc(void** ppv, size_t cb)
{
*ppv = calloc(1, cb);
return *ppv ? WMP_errSuccess : WMP_errOutOfMemory;
}
ERR PKFree(void** ppv)
{
if (ppv)
{
free(*ppv);
*ppv = NULL;
}
return WMP_errSuccess;
}
ERR PKAllocAligned(void** ppv, size_t cb, size_t iAlign)
{
U8 *pOrigPtr;
U8 *pReturnedPtr;
size_t iAlignmentCorrection;
const size_t c_cbBlockSize = cb + sizeof(void*) + iAlign - 1;
*ppv = NULL;
pOrigPtr = calloc(1, c_cbBlockSize);
if (NULL == pOrigPtr)
return WMP_errOutOfMemory;
iAlignmentCorrection = iAlign - ((size_t)pOrigPtr % iAlign);
if (iAlignmentCorrection < sizeof(void*))
// Alignment correction won't leave us enough space to store pOrigPtr - advance to next block
iAlignmentCorrection += iAlign;
assert(iAlignmentCorrection >= sizeof(void*)); // Alignment correction must have space for pOrigPtr
assert(iAlignmentCorrection + cb <= c_cbBlockSize); // Don't exceed right edge of memory block
pReturnedPtr = pOrigPtr + iAlignmentCorrection;
*(void**)(pReturnedPtr - sizeof(void*)) = pOrigPtr;
assert(0 == ((size_t)pReturnedPtr % iAlign)); // Are we in fact aligned?
*ppv = pReturnedPtr;
return WMP_errSuccess;
}
ERR PKFreeAligned(void** ppv)
{
if (ppv && *ppv)
{
U8 **ppOrigPtr = (U8**)((U8*)(*ppv) - sizeof(void*));
assert(*ppOrigPtr <= (U8*)ppOrigPtr); // Something's wrong if pOrigPtr points forward
free(*ppOrigPtr);
*ppv = NULL;
}
return WMP_errSuccess;
}
int PKStrnicmp(const char* s1, const char* s2, size_t c)
{
for(; tolower(*s1) == tolower(*s2) && *s1 && *s2 && c; ++s1, ++s2, --c);
return c ? *s1 - *s2 : 0;
}
static const PKPixelInfo pixelInfo[] =
{
{&GUID_PKPixelFormatDontCare, 1, Y_ONLY, BD_8, 8, PK_pixfmtNul, 0, 0, 0, 0},
// Gray
//{&GUID_PKPixelFormat2bppGray, 1, Y_ONLY, BD_8, 2, PK_pixfmtNul},
//{&GUID_PKPixelFormat4bppGray, 1, Y_ONLY, BD_8, 4, PK_pixfmtNul},
{&GUID_PKPixelFormatBlackWhite, 1, Y_ONLY, BD_1, 1, PK_pixfmtNul, 1, 1, 1, 1},//BlackIsZero is default for GUID_PKPixelFormatBlackWhite
{&GUID_PKPixelFormatBlackWhite, 1, Y_ONLY, BD_1, 1, PK_pixfmtNul, 0, 1, 1, 1},//WhiteIsZero
{&GUID_PKPixelFormat8bppGray, 1, Y_ONLY, BD_8, 8, PK_pixfmtNul, 1, 1, 8, 1},
{&GUID_PKPixelFormat16bppGray, 1, Y_ONLY, BD_16, 16, PK_pixfmtNul, 1, 1, 16, 1},
{&GUID_PKPixelFormat16bppGrayFixedPoint, 1, Y_ONLY, BD_16S, 16, PK_pixfmtNul, 1, 1, 16, 2},
{&GUID_PKPixelFormat16bppGrayHalf, 1, Y_ONLY, BD_16F, 16, PK_pixfmtNul, 1, 1, 16, 3},
//{&GUID_PKPixelFormat32bppGray, 1, Y_ONLY, BD_32, 32, PK_pixfmtNul, 1, 1, 32, 1},
{&GUID_PKPixelFormat32bppGrayFixedPoint, 1, Y_ONLY, BD_32S, 32, PK_pixfmtNul, 1, 1, 32, 2},
{&GUID_PKPixelFormat32bppGrayFloat, 1, Y_ONLY, BD_32F, 32, PK_pixfmtNul, 1, 1, 32, 3},
// RGB
{&GUID_PKPixelFormat24bppRGB, 3, CF_RGB, BD_8, 24, PK_pixfmtNul, 2, 3, 8, 1},
{&GUID_PKPixelFormat24bppBGR, 3, CF_RGB, BD_8, 24, PK_pixfmtBGR, 2, 3, 8, 1},
{&GUID_PKPixelFormat32bppRGB, 3, CF_RGB, BD_8, 32, PK_pixfmtNul, 2, 3, 8, 1},
{&GUID_PKPixelFormat32bppBGR, 3, CF_RGB, BD_8, 32, PK_pixfmtBGR, 2, 3, 8, 1},
{&GUID_PKPixelFormat48bppRGB, 3, CF_RGB, BD_16, 48, PK_pixfmtNul, 2, 3, 16, 1},
{&GUID_PKPixelFormat48bppRGBFixedPoint, 3, CF_RGB, BD_16S, 48, PK_pixfmtNul, 2, 3, 16, 2},
{&GUID_PKPixelFormat48bppRGBHalf, 3, CF_RGB, BD_16F, 48, PK_pixfmtNul, 2, 3, 16, 3},
{&GUID_PKPixelFormat64bppRGBFixedPoint, 3, CF_RGB, BD_16S, 64, PK_pixfmtNul, 2, 3, 16, 2},
{&GUID_PKPixelFormat64bppRGBHalf, 3, CF_RGB, BD_16F, 64, PK_pixfmtNul, 2, 3, 16, 3},
//{&GUID_PKPixelFormat96bppRGB, 3, CF_RGB, BD_32, 96, PK_pixfmtNul, 2, 3, 32, 1},
{&GUID_PKPixelFormat96bppRGBFixedPoint, 3, CF_RGB, BD_32S, 96, PK_pixfmtNul, 2, 3, 32, 2},
{&GUID_PKPixelFormat96bppRGBFloat, 3, CF_RGB, BD_32F, 96, PK_pixfmtNul, 2, 3, 32, 3},
{&GUID_PKPixelFormat128bppRGBFixedPoint, 3, CF_RGB, BD_32S, 128, PK_pixfmtNul, 2, 3, 32, 2},
{&GUID_PKPixelFormat128bppRGBFloat, 3, CF_RGB, BD_32F, 128, PK_pixfmtNul, 2, 3, 32, 3},
// RGBA
{&GUID_PKPixelFormat32bppBGRA, 4, CF_RGB, BD_8, 32, PK_pixfmtHasAlpha | PK_pixfmtBGR, 2, 4, 8, 1},
{&GUID_PKPixelFormat32bppRGBA, 4, CF_RGB, BD_8, 32, PK_pixfmtHasAlpha, 2, 4, 8, 1},
{&GUID_PKPixelFormat64bppRGBA, 4, CF_RGB, BD_16, 64, PK_pixfmtHasAlpha, 2, 4, 16, 1},
{&GUID_PKPixelFormat64bppRGBAFixedPoint, 4, CF_RGB, BD_16S, 64, PK_pixfmtHasAlpha, 2, 4, 16, 2},
{&GUID_PKPixelFormat64bppRGBAHalf, 4, CF_RGB, BD_16F, 64, PK_pixfmtHasAlpha, 2, 4, 16, 3},
//{&GUID_PKPixelFormat128bppRGBA, 4, CF_RGB, BD_32, 128, PK_pixfmtHasAlpha, 2, 4, 32, 1},
{&GUID_PKPixelFormat128bppRGBAFixedPoint, 4, CF_RGB, BD_32S, 128, PK_pixfmtHasAlpha, 2, 4, 32, 2},
{&GUID_PKPixelFormat128bppRGBAFloat, 4, CF_RGB, BD_32F, 128, PK_pixfmtHasAlpha, 2, 4, 32, 3},
// PRGBA
{&GUID_PKPixelFormat32bppPBGRA, 4, CF_RGB, BD_8, 32, PK_pixfmtHasAlpha | PK_pixfmtPreMul | PK_pixfmtBGR, 2, 4, 8, 1},
{&GUID_PKPixelFormat32bppPRGBA, 4, CF_RGB, BD_8, 32, PK_pixfmtHasAlpha | PK_pixfmtPreMul, 2, 4, 8, 1},
{&GUID_PKPixelFormat64bppPRGBA, 4, CF_RGB, BD_16, 64, PK_pixfmtHasAlpha | PK_pixfmtPreMul, 2, 4, 16, 1},
//{&GUID_PKPixelFormat64bppPRGBAFixedPoint, 4, CF_RGB, BD_16S, 64, PK_pixfmtHasAlpha, 2, 4, 16, 2},
//{&GUID_PKPixelFormat64bppPRGBAHalf, 4, CF_RGB, BD_16F, 64, PK_pixfmtHasAlpha, 2, 4, 16, 3},
//{&GUID_PKPixelFormat128bppPRGBAFixedPoint, 4, CF_RGB, BD_32S, 128, PK_pixfmtHasAlpha, 2, 4, 32, 2},
{&GUID_PKPixelFormat128bppPRGBAFloat, 4, CF_RGB, BD_32F, 128, PK_pixfmtHasAlpha | PK_pixfmtPreMul, 2, 4, 32, 3},
// Packed formats
{&GUID_PKPixelFormat16bppRGB555, 3, CF_RGB, BD_5, 16, PK_pixfmtNul, 2, 3, 5, 1},
{&GUID_PKPixelFormat16bppRGB565, 3, CF_RGB, BD_565, 16, PK_pixfmtNul, 2, 3, 6, 1},
{&GUID_PKPixelFormat32bppRGB101010, 3, CF_RGB, BD_10, 32, PK_pixfmtNul, 2, 3, 10, 1},
// CMYK
{&GUID_PKPixelFormat32bppCMYK, 4, CMYK, BD_8, 32, PK_pixfmtNul, 5, 4, 8, 1},
{&GUID_PKPixelFormat40bppCMYKAlpha, 5, CMYK, BD_8, 40, PK_pixfmtHasAlpha, 5, 5, 8, 1},
{&GUID_PKPixelFormat64bppCMYK, 4, CMYK, BD_16, 64, PK_pixfmtNul, 5, 4, 16, 1},
{&GUID_PKPixelFormat80bppCMYKAlpha, 5, CMYK, BD_16, 80, PK_pixfmtHasAlpha, 5, 5, 16, 1},
// N_CHANNEL
{&GUID_PKPixelFormat24bpp3Channels, 3, NCOMPONENT, BD_8, 24, PK_pixfmtNul, PK_PI_NCH, 3, 8, 1},//the N channel TIF by PS has PhotometricInterpretation of PK_PI_RGB
{&GUID_PKPixelFormat32bpp4Channels, 4, NCOMPONENT, BD_8, 32, PK_pixfmtNul, PK_PI_NCH, 4, 8, 1},
{&GUID_PKPixelFormat40bpp5Channels, 5, NCOMPONENT, BD_8, 40, PK_pixfmtNul, PK_PI_NCH, 5, 8, 1},
{&GUID_PKPixelFormat48bpp6Channels, 6, NCOMPONENT, BD_8, 48, PK_pixfmtNul, PK_PI_NCH, 6, 8, 1},
{&GUID_PKPixelFormat56bpp7Channels, 7, NCOMPONENT, BD_8, 56, PK_pixfmtNul, PK_PI_NCH, 7, 8, 1},
{&GUID_PKPixelFormat64bpp8Channels, 8, NCOMPONENT, BD_8, 64, PK_pixfmtNul, PK_PI_NCH, 8, 8, 1},
{&GUID_PKPixelFormat32bpp3ChannelsAlpha, 4, NCOMPONENT, BD_8, 32, PK_pixfmtHasAlpha, PK_PI_NCH, 4, 8, 1},
{&GUID_PKPixelFormat40bpp4ChannelsAlpha, 5, NCOMPONENT, BD_8, 40, PK_pixfmtHasAlpha, PK_PI_NCH, 5, 8, 1},
{&GUID_PKPixelFormat48bpp5ChannelsAlpha, 6, NCOMPONENT, BD_8, 48, PK_pixfmtHasAlpha, PK_PI_NCH, 6, 8, 1},
{&GUID_PKPixelFormat56bpp6ChannelsAlpha, 7, NCOMPONENT, BD_8, 56, PK_pixfmtHasAlpha, PK_PI_NCH, 7, 8, 1},
{&GUID_PKPixelFormat64bpp7ChannelsAlpha, 8, NCOMPONENT, BD_8, 64, PK_pixfmtHasAlpha, PK_PI_NCH, 8, 8, 1},
{&GUID_PKPixelFormat72bpp8ChannelsAlpha, 9, NCOMPONENT, BD_8, 72, PK_pixfmtHasAlpha, PK_PI_NCH, 9, 8, 1},
{&GUID_PKPixelFormat48bpp3Channels, 3, NCOMPONENT, BD_16, 48, PK_pixfmtNul, PK_PI_NCH, 3, 16, 1},
{&GUID_PKPixelFormat64bpp4Channels, 4, NCOMPONENT, BD_16, 64, PK_pixfmtNul, PK_PI_NCH, 4, 16, 1},
{&GUID_PKPixelFormat80bpp5Channels, 5, NCOMPONENT, BD_16, 80, PK_pixfmtNul, PK_PI_NCH, 5, 16, 1},
{&GUID_PKPixelFormat96bpp6Channels, 6, NCOMPONENT, BD_16, 96, PK_pixfmtNul, PK_PI_NCH, 6, 16, 1},
{&GUID_PKPixelFormat112bpp7Channels, 7, NCOMPONENT, BD_16, 112, PK_pixfmtNul, PK_PI_NCH, 7, 16, 1},
{&GUID_PKPixelFormat128bpp8Channels, 8, NCOMPONENT, BD_16, 128, PK_pixfmtNul, PK_PI_NCH, 8, 16, 1},
{&GUID_PKPixelFormat64bpp3ChannelsAlpha, 4, NCOMPONENT, BD_16, 64, PK_pixfmtHasAlpha, PK_PI_NCH, 4, 16, 1},
{&GUID_PKPixelFormat80bpp4ChannelsAlpha, 5, NCOMPONENT, BD_16, 80, PK_pixfmtHasAlpha, PK_PI_NCH, 5, 16, 1},
{&GUID_PKPixelFormat96bpp5ChannelsAlpha, 6, NCOMPONENT, BD_16, 96, PK_pixfmtHasAlpha, PK_PI_NCH, 6, 16, 1},
{&GUID_PKPixelFormat112bpp6ChannelsAlpha, 7, NCOMPONENT, BD_16, 112, PK_pixfmtHasAlpha, PK_PI_NCH, 7, 16, 1},
{&GUID_PKPixelFormat128bpp7ChannelsAlpha, 8, NCOMPONENT, BD_16, 128, PK_pixfmtHasAlpha, PK_PI_NCH, 8, 16, 1},
{&GUID_PKPixelFormat144bpp8ChannelsAlpha, 9, NCOMPONENT, BD_16, 144, PK_pixfmtHasAlpha, PK_PI_NCH, 9, 16, 1},
//RGBE
{&GUID_PKPixelFormat32bppRGBE, 4, CF_RGBE, BD_8, 32, PK_pixfmtNul, PK_PI_RGBE, 4, 8, 1},
//YUV
{&GUID_PKPixelFormat12bppYUV420, 3, YUV_420, BD_8, 48, PK_pixfmtNul},
{&GUID_PKPixelFormat16bppYUV422, 3, YUV_422, BD_8, 32, PK_pixfmtNul},
{&GUID_PKPixelFormat24bppYUV444, 3, YUV_444, BD_8, 24, PK_pixfmtNul},
};
//----------------------------------------------------------------
//ERR GetPixelInfo(PKPixelFormatGUID enPixelFormat, const PKPixelInfo** ppPI)
ERR PixelFormatLookup(PKPixelInfo* pPI, U8 uLookupType)
{
ERR err = WMP_errSuccess;
size_t i;
for (i = 0; i < sizeof2(pixelInfo); ++i)
{
if (LOOKUP_FORWARD == uLookupType)
{
if (IsEqualGUID(pPI->pGUIDPixFmt, pixelInfo[i].pGUIDPixFmt))
{
*pPI = pixelInfo[i];
goto Cleanup;
}
}
else if (LOOKUP_BACKWARD_TIF == uLookupType)
{
if (pPI->uSamplePerPixel == pixelInfo[i].uSamplePerPixel &&
pPI->uBitsPerSample == pixelInfo[i].uBitsPerSample &&
pPI->uSampleFormat == pixelInfo[i].uSampleFormat &&
pPI->uInterpretation == pixelInfo[i].uInterpretation)
{
// match alpha & premult
if ((pPI->grBit & (PK_pixfmtHasAlpha | PK_pixfmtPreMul)) ==
(pixelInfo[i].grBit & (PK_pixfmtHasAlpha | PK_pixfmtPreMul)))
{
*pPI = pixelInfo[i];
goto Cleanup;
}
}
}
}
Call(WMP_errUnsupportedFormat);
Cleanup:
return err;
}
const PKPixelFormatGUID* GetPixelFormatFromHash(const U8 uPFHash)
{
int i;
for (i = 0; i < sizeof2(pixelInfo); i++)
{
if (pixelInfo[i].pGUIDPixFmt->Data4[7] == uPFHash)
return pixelInfo[i].pGUIDPixFmt;
}
// If we reached this point, we did not find anything which matched the hash
return NULL;
}
//----------------------------------------------------------------
typedef struct tagPKIIDInfo
{
const char* szExt;
const PKIID* pIIDEnc;
const PKIID* pIIDDec;
} PKIIDInfo;
static ERR GetIIDInfo(const char* szExt, const PKIIDInfo** ppInfo)
{
ERR err = WMP_errSuccess;
static PKIIDInfo iidInfo[] = {
{".jxr", &IID_PKImageWmpEncode, &IID_PKImageWmpDecode},
{".wdp", &IID_PKImageUnsupported, &IID_PKImageWmpDecode},
{".hdp", &IID_PKImageUnsupported, &IID_PKImageWmpDecode},
};
size_t i = 0;
*ppInfo = NULL;
for (i = 0; i < sizeof2(iidInfo); ++i)
{
if (0 == PKStrnicmp(szExt, iidInfo[i].szExt, strlen(iidInfo[i].szExt)))
{
*ppInfo = &iidInfo[i];
goto Cleanup;
}
}
Call(WMP_errUnsupportedFormat);
Cleanup:
return err;
}
ERR GetImageEncodeIID(const char* szExt, const PKIID** ppIID)
{
ERR err = WMP_errSuccess;
const PKIIDInfo* pInfo = NULL;
Call(GetIIDInfo(szExt, &pInfo));
*ppIID = pInfo->pIIDEnc;
Cleanup:
return err;
}
ERR GetImageDecodeIID(const char* szExt, const PKIID** ppIID)
{
ERR err = WMP_errSuccess;
const PKIIDInfo* pInfo = NULL;
Call(GetIIDInfo(szExt, &pInfo));
*ppIID = pInfo->pIIDDec;
Cleanup:
return err;
}
//================================================================
// PKFactory
//================================================================
ERR PKCreateFactory_CreateStream(PKStream** ppStream)
{
ERR err = WMP_errSuccess;
Call(PKAlloc((void **) ppStream, sizeof(**ppStream)));
Cleanup:
return err;
}
ERR PKCreateFactory_Release(PKFactory** ppFactory)
{
ERR err = WMP_errSuccess;
Call(PKFree((void **) ppFactory));
Cleanup:
return err;
}
//----------------------------------------------------------------
ERR PKCreateFactory(PKFactory** ppFactory, U32 uVersion)
{
ERR err = WMP_errSuccess;
PKFactory* pFactory = NULL;
UNREFERENCED_PARAMETER( uVersion );
Call(PKAlloc((void **) ppFactory, sizeof(**ppFactory)));
pFactory = *ppFactory;
pFactory->CreateStream = PKCreateFactory_CreateStream;
pFactory->CreateStreamFromFilename = CreateWS_File;
pFactory->CreateStreamFromMemory = CreateWS_Memory;
pFactory->Release = PKCreateFactory_Release;
Cleanup:
return err;
}
//================================================================
// PKCodecFactory
//================================================================
ERR PKCodecFactory_CreateCodec(const PKIID* iid, void** ppv)
{
ERR err = WMP_errSuccess;
if (IID_PKImageWmpEncode == *iid)
{
Call(PKImageEncode_Create_WMP((PKImageEncode**)ppv));
}
else if (IID_PKImageWmpDecode == *iid)
{
Call(PKImageDecode_Create_WMP((PKImageDecode**)ppv));
}
else
{
Call(WMP_errUnsupportedFormat);
}
Cleanup:
return err;
}
ERR PKCodecFactory_CreateDecoderFromFile(const char* szFilename, PKImageDecode** ppDecoder)
{
ERR err = WMP_errSuccess;
char *pExt = NULL;
const PKIID* pIID = NULL;
struct WMPStream* pStream = NULL;
PKImageDecode* pDecoder = NULL;
// get file extension
pExt = strrchr(szFilename, '.');
FailIf(NULL == pExt, WMP_errUnsupportedFormat);
// get decode PKIID
Call(GetImageDecodeIID(pExt, &pIID));
// create stream
Call(CreateWS_File(&pStream, szFilename, "rb"));
// Create decoder
Call(PKCodecFactory_CreateCodec(pIID, (void **) ppDecoder));
pDecoder = *ppDecoder;
// attach stream to decoder
Call(pDecoder->Initialize(pDecoder, pStream));
pDecoder->fStreamOwner = !0;
Cleanup:
return err;
}
ERR PKCodecFactory_CreateFormatConverter(PKFormatConverter** ppFConverter)
{
ERR err = WMP_errSuccess;
PKFormatConverter* pFC = NULL;
Call(PKAlloc((void **) ppFConverter, sizeof(**ppFConverter)));
pFC = *ppFConverter;
pFC->Initialize = PKFormatConverter_Initialize;
pFC->InitializeConvert = PKFormatConverter_InitializeConvert;
pFC->GetPixelFormat = PKFormatConverter_GetPixelFormat;
pFC->GetSourcePixelFormat = PKFormatConverter_GetSourcePixelFormat;
pFC->GetSize = PKFormatConverter_GetSize;
pFC->GetResolution = PKFormatConverter_GetResolution;
pFC->Copy = PKFormatConverter_Copy;
pFC->Convert = PKFormatConverter_Convert;
pFC->Release = PKFormatConverter_Release;
Cleanup:
return err;
}
ERR PKCreateCodecFactory_Release(PKCodecFactory** ppCFactory)
{
ERR err = WMP_errSuccess;
Call(PKFree((void **) ppCFactory));
Cleanup:
return err;
}
ERR PKCreateCodecFactory(PKCodecFactory** ppCFactory, U32 uVersion)
{
ERR err = WMP_errSuccess;
PKCodecFactory* pCFactory = NULL;
UNREFERENCED_PARAMETER( uVersion );
Call(PKAlloc((void **) ppCFactory, sizeof(**ppCFactory)));
pCFactory = *ppCFactory;
pCFactory->CreateCodec = PKCodecFactory_CreateCodec;
pCFactory->CreateDecoderFromFile = PKCodecFactory_CreateDecoderFromFile;
pCFactory->CreateFormatConverter = PKCodecFactory_CreateFormatConverter;
pCFactory->Release = PKCreateCodecFactory_Release;
Cleanup:
return err;
}
//================================================================
// PKImageEncode
//================================================================
ERR PKImageEncode_Initialize(
PKImageEncode* pIE,
struct WMPStream* pStream,
void* pvParam,
size_t cbParam)
{
ERR err = WMP_errSuccess;
UNREFERENCED_PARAMETER( pIE );
UNREFERENCED_PARAMETER( pvParam );
UNREFERENCED_PARAMETER( cbParam );
pIE->pStream = pStream;
pIE->guidPixFormat = GUID_PKPixelFormatDontCare;
pIE->fResX = 96;
pIE->fResY = 96;
pIE->cFrame = 1;
Call(pIE->pStream->GetPos(pIE->pStream, &pIE->offStart));
Cleanup:
return err;
}
ERR PKImageEncode_Terminate(
PKImageEncode* pIE)
{
UNREFERENCED_PARAMETER( pIE );
return WMP_errSuccess;
}
ERR PKImageEncode_SetPixelFormat(
PKImageEncode* pIE,
PKPixelFormatGUID enPixelFormat)
{
pIE->guidPixFormat = enPixelFormat;
return WMP_errSuccess;
}
ERR PKImageEncode_SetSize(
PKImageEncode* pIE,
I32 iWidth,
I32 iHeight)
{
ERR err = WMP_errSuccess;
pIE->uWidth = (U32)iWidth;
pIE->uHeight = (U32)iHeight;
return err;
}
ERR PKImageEncode_SetResolution(
PKImageEncode* pIE,
Float fResX,
Float fResY)
{
pIE->fResX = fResX;
pIE->fResY = fResY;
return WMP_errSuccess;
}
ERR PKImageEncode_SetColorContext(PKImageEncode *pIE,
const U8 *pbColorContext,
U32 cbColorContext)
{
UNREFERENCED_PARAMETER( pIE );
UNREFERENCED_PARAMETER( pbColorContext );
UNREFERENCED_PARAMETER( cbColorContext );
return WMP_errNotYetImplemented;
}
ERR PKImageEncode_SetDescriptiveMetadata(PKImageEncode *pIE, const DESCRIPTIVEMETADATA *pDescMetadata)
{
UNREFERENCED_PARAMETER( pIE );
UNREFERENCED_PARAMETER( pDescMetadata );
return WMP_errNotYetImplemented;
}
ERR PKImageEncode_WritePixels(
PKImageEncode* pIE,
U32 cLine,
U8* pbPixels,
U32 cbStride)
{
UNREFERENCED_PARAMETER( pIE );
UNREFERENCED_PARAMETER( cLine );
UNREFERENCED_PARAMETER( pbPixels );
UNREFERENCED_PARAMETER( cbStride );
return WMP_errAbstractMethod;
}
ERR PKImageEncode_WriteSource(
PKImageEncode* pIE,
PKFormatConverter* pFC,
PKRect* pRect)
{
ERR err = WMP_errSuccess;
PKPixelFormatGUID enPFFrom = GUID_PKPixelFormatDontCare;
PKPixelFormatGUID enPFTo = GUID_PKPixelFormatDontCare;
PKPixelInfo pPIFrom;
PKPixelInfo pPITo;
U32 cbStrideTo = 0;
U32 cbStrideFrom = 0;
U32 cbStride = 0;
U8* pb = NULL;
// CWMTranscodingParam* pParam = NULL;
// get pixel format
Call(pFC->GetSourcePixelFormat(pFC, &enPFFrom));
Call(pFC->GetPixelFormat(pFC, &enPFTo));
FailIf(!IsEqualGUID(&pIE->guidPixFormat, &enPFTo), WMP_errUnsupportedFormat);
// calc common stride
// Call(GetPixelInfo(enPFFrom, &pPIFrom));
pPIFrom.pGUIDPixFmt = &enPFFrom;
PixelFormatLookup(&pPIFrom, LOOKUP_FORWARD);
// Call(GetPixelInfo(enPFTo, &pPITo));
pPITo.pGUIDPixFmt = &enPFTo;
PixelFormatLookup(&pPITo, LOOKUP_FORWARD);
// cbStrideFrom = (pPIFrom->cbPixel * pRect->Width + pPIFrom->cbPixelDenom - 1) / pPIFrom->cbPixelDenom;
cbStrideFrom = (BD_1 == pPIFrom.bdBitDepth ? ((pPIFrom.cbitUnit * pRect->Width + 7) >> 3) : (((pPIFrom.cbitUnit + 7) >> 3) * pRect->Width));
if (&GUID_PKPixelFormat12bppYUV420 == pPIFrom.pGUIDPixFmt
|| &GUID_PKPixelFormat16bppYUV422 == pPIFrom.pGUIDPixFmt)
cbStrideFrom >>= 1;
// cbStrideTo = (pPITo->cbPixel * pIE->uWidth + pPITo->cbPixelDenom - 1) / pPITo->cbPixelDenom;
cbStrideTo = (BD_1 == pPITo.bdBitDepth ? ((pPITo.cbitUnit * pIE->uWidth + 7) >> 3) : (((pPITo.cbitUnit + 7) >> 3) * pIE->uWidth));
if (&GUID_PKPixelFormat12bppYUV420 == pPITo.pGUIDPixFmt
|| &GUID_PKPixelFormat16bppYUV422 == pPITo.pGUIDPixFmt)
cbStrideTo >>= 1;
cbStride = max(cbStrideFrom, cbStrideTo);
// actual dec/enc with local buffer
Call(PKAllocAligned((void **) &pb, cbStride * pRect->Height, 128));
Call(pFC->Copy(pFC, pRect, pb, cbStride));
Call(pIE->WritePixels(pIE, pRect->Height, pb, cbStride));
Cleanup:
PKFreeAligned((void **) &pb);
return err;
}
ERR PKImageEncode_WritePixelsBandedBegin(PKImageEncode* pEncoder, struct WMPStream *pPATempFile)
{
UNREFERENCED_PARAMETER( pEncoder );
UNREFERENCED_PARAMETER( pPATempFile );
return WMP_errAbstractMethod;
}
ERR PKImageEncode_WritePixelsBanded(PKImageEncode* pEncoder, U32 cLines, U8* pbPixels, U32 cbStride, Bool fLastCall)
{
UNREFERENCED_PARAMETER( pEncoder );
UNREFERENCED_PARAMETER( cLines );
UNREFERENCED_PARAMETER( pbPixels );
UNREFERENCED_PARAMETER( cbStride );
UNREFERENCED_PARAMETER( fLastCall );
return WMP_errAbstractMethod;
}
ERR PKImageEncode_WritePixelsBandedEnd(PKImageEncode* pEncoder)
{
UNREFERENCED_PARAMETER( pEncoder );
return WMP_errAbstractMethod;
}
ERR PKImageEncode_Transcode(
PKImageEncode* pIE,
PKFormatConverter* pFC,
PKRect* pRect)
{
ERR err = WMP_errSuccess;
PKPixelFormatGUID enPFFrom = GUID_PKPixelFormatDontCare;
PKPixelFormatGUID enPFTo = GUID_PKPixelFormatDontCare;
PKPixelInfo pPIFrom;
PKPixelInfo pPITo;
U32 cbStrideTo = 0;
U32 cbStrideFrom = 0;
U32 cbStride = 0;
U8* pb = NULL;
CWMTranscodingParam cParam = {0};
// get pixel format
Call(pFC->GetSourcePixelFormat(pFC, &enPFFrom));
Call(pFC->GetPixelFormat(pFC, &enPFTo));
FailIf(!IsEqualGUID(&pIE->guidPixFormat, &enPFTo), WMP_errUnsupportedFormat);
// calc common stride
// Call(GetPixelInfo(enPFFrom, &pPIFrom));
pPIFrom.pGUIDPixFmt = &enPFFrom;
PixelFormatLookup(&pPIFrom, LOOKUP_FORWARD);
// Call(GetPixelInfo(enPFTo, &pPITo));
pPITo.pGUIDPixFmt = &enPFTo;
PixelFormatLookup(&pPITo, LOOKUP_FORWARD);
// cbStrideFrom = (pPIFrom->cbPixel * pRect->Width + pPIFrom->cbPixelDenom - 1) / pPIFrom->cbPixelDenom;
cbStrideFrom = (BD_1 == pPIFrom.bdBitDepth ? ((pPIFrom.cbitUnit * pRect->Width + 7) >> 3) : (((pPIFrom.cbitUnit + 7) >> 3) * pRect->Width));
if (&GUID_PKPixelFormat12bppYUV420 == pPIFrom.pGUIDPixFmt
|| &GUID_PKPixelFormat16bppYUV422 == pPIFrom.pGUIDPixFmt)
cbStrideFrom >>= 1;
// cbStrideTo = (pPITo->cbPixel * pIE->uWidth + pPITo->cbPixelDenom - 1) / pPITo->cbPixelDenom;
cbStrideTo = (BD_1 == pPITo.bdBitDepth ? ((pPITo.cbitUnit * pIE->uWidth + 7) >> 3) : (((pPITo.cbitUnit + 7) >> 3) * pIE->uWidth));
if (&GUID_PKPixelFormat12bppYUV420 == pPITo.pGUIDPixFmt
|| &GUID_PKPixelFormat16bppYUV422 == pPITo.pGUIDPixFmt)
cbStrideTo >>= 1;
cbStride = max(cbStrideFrom, cbStrideTo);
if(pIE->bWMP){
cParam.cLeftX = pFC->pDecoder->WMP.wmiI.cROILeftX;
cParam.cTopY = pFC->pDecoder->WMP.wmiI.cROITopY;
cParam.cWidth = pFC->pDecoder->WMP.wmiI.cROIWidth;
cParam.cHeight = pFC->pDecoder->WMP.wmiI.cROIHeight;
cParam.oOrientation = pFC->pDecoder->WMP.wmiI.oOrientation;
// cParam.cfColorFormat = pFC->pDecoder->WMP.wmiI.cfColorFormat;
cParam.uAlphaMode = pFC->pDecoder->WMP.wmiSCP.uAlphaMode;
cParam.bfBitstreamFormat = pFC->pDecoder->WMP.wmiSCP.bfBitstreamFormat;
cParam.sbSubband = pFC->pDecoder->WMP.wmiSCP.sbSubband;
cParam.bIgnoreOverlap = pFC->pDecoder->WMP.bIgnoreOverlap;
Call(pIE->Transcode(pIE, pFC->pDecoder, &cParam));
}
else
{
// actual dec/enc with local buffer
Call(PKAllocAligned((void **) &pb, cbStride * pRect->Height, 128));
Call(pFC->Copy(pFC, pRect, pb, cbStride));
Call(pIE->WritePixels(pIE, pRect->Height, pb, cbStride));
}
Cleanup:
PKFreeAligned((void **) &pb);
return err;
}
ERR PKImageEncode_CreateNewFrame(
PKImageEncode* pIE,
void* pvParam,
size_t cbParam)
{
UNREFERENCED_PARAMETER( pIE );
UNREFERENCED_PARAMETER( pvParam );
UNREFERENCED_PARAMETER( cbParam );
// NYI
return WMP_errSuccess;
}
ERR PKImageEncode_Release(
PKImageEncode** ppIE)
{
PKImageEncode *pIE = *ppIE;
pIE->pStream->Close(&pIE->pStream);
return PKFree((void **) ppIE);
}
ERR PKImageEncode_Create(PKImageEncode** ppIE)
{
ERR err = WMP_errSuccess;
PKImageEncode* pIE = NULL;
Call(PKAlloc((void **) ppIE, sizeof(**ppIE)));
pIE = *ppIE;
pIE->Initialize = PKImageEncode_Initialize;
pIE->Terminate = PKImageEncode_Terminate;
pIE->SetPixelFormat = PKImageEncode_SetPixelFormat;
pIE->SetSize = PKImageEncode_SetSize;
pIE->SetResolution = PKImageEncode_SetResolution;
pIE->SetColorContext = PKImageEncode_SetColorContext;
pIE->SetDescriptiveMetadata = PKImageEncode_SetDescriptiveMetadata;
pIE->WritePixels = PKImageEncode_WritePixels;
// pIE->WriteSource = PKImageEncode_WriteSource;
pIE->WritePixelsBandedBegin = PKImageEncode_WritePixelsBandedBegin;
pIE->WritePixelsBanded = PKImageEncode_WritePixelsBanded;
pIE->WritePixelsBandedEnd = PKImageEncode_WritePixelsBandedEnd;
pIE->CreateNewFrame = PKImageEncode_CreateNewFrame;
pIE->Release = PKImageEncode_Release;
pIE->bWMP = FALSE;
Cleanup:
return err;
}
//================================================================
// PKImageDecode
//================================================================
ERR PKImageDecode_Initialize(
PKImageDecode* pID,
struct WMPStream* pStream)
{
ERR err = WMP_errSuccess;
pID->pStream = pStream;
pID->guidPixFormat = GUID_PKPixelFormatDontCare;
pID->fResX = 96;
pID->fResY = 96;
pID->cFrame = 1;
Call(pID->pStream->GetPos(pID->pStream, &pID->offStart));
memset(&pID->WMP.wmiDEMisc, 0, sizeof(pID->WMP.wmiDEMisc));
Cleanup:
return WMP_errSuccess;
}
ERR PKImageDecode_GetPixelFormat(
PKImageDecode* pID,
PKPixelFormatGUID* pPF)
{
*pPF = pID->guidPixFormat;
return WMP_errSuccess;
}
ERR PKImageDecode_GetSize(
PKImageDecode* pID,
I32* piWidth,
I32* piHeight)
{
*piWidth = (I32)pID->uWidth;
*piHeight = (I32)pID->uHeight;
return WMP_errSuccess;
}
ERR PKImageDecode_GetResolution(
PKImageDecode* pID,
Float* pfResX,
Float* pfResY)
{
*pfResX = pID->fResX;
*pfResY = pID->fResY;
return WMP_errSuccess;
}
ERR PKImageDecode_GetColorContext(PKImageDecode *pID, U8 *pbColorContext, U32 *pcbColorContext)
{
UNREFERENCED_PARAMETER( pID );
UNREFERENCED_PARAMETER( pbColorContext );
UNREFERENCED_PARAMETER( pcbColorContext );
return WMP_errNotYetImplemented;
}
ERR PKImageDecode_GetDescriptiveMetadata(PKImageDecode *pIE, DESCRIPTIVEMETADATA *pDescMetadata)
{
UNREFERENCED_PARAMETER( pIE );
UNREFERENCED_PARAMETER( pDescMetadata );
return WMP_errNotYetImplemented;
}
ERR PKImageDecode_Copy(
PKImageDecode* pID,
const PKRect* pRect,
U8* pb,
U32 cbStride)
{
UNREFERENCED_PARAMETER( pID );
UNREFERENCED_PARAMETER( pRect );
UNREFERENCED_PARAMETER( pb );
UNREFERENCED_PARAMETER( cbStride );
return WMP_errAbstractMethod;
}
ERR PKImageDecode_GetFrameCount(
PKImageDecode* pID,
U32* puCount)
{
*puCount = pID->cFrame;
return WMP_errSuccess;
}
ERR PKImageDecode_SelectFrame(
PKImageDecode* pID,
U32 uFrame)
{
UNREFERENCED_PARAMETER( pID );
UNREFERENCED_PARAMETER( uFrame );
// NYI
return WMP_errSuccess;
}
ERR PKImageDecode_Release(
PKImageDecode** ppID)
{
PKImageDecode* pID = *ppID;
pID->fStreamOwner && pID->pStream->Close(&pID->pStream);
return PKFree((void **) ppID);
}
ERR PKImageDecode_Create(
PKImageDecode** ppID)
{
ERR err = WMP_errSuccess;
PKImageDecode* pID = NULL;
Call(PKAlloc((void **) ppID, sizeof(**ppID)));
pID = *ppID;
pID->Initialize = PKImageDecode_Initialize;
pID->GetPixelFormat = PKImageDecode_GetPixelFormat;
pID->GetSize = PKImageDecode_GetSize;
pID->GetResolution = PKImageDecode_GetResolution;
pID->GetColorContext = PKImageDecode_GetColorContext;
pID->GetDescriptiveMetadata = PKImageDecode_GetDescriptiveMetadata;
pID->Copy = PKImageDecode_Copy;
pID->GetFrameCount = PKImageDecode_GetFrameCount;
pID->SelectFrame = PKImageDecode_SelectFrame;
pID->Release = PKImageDecode_Release;
Cleanup:
return err;
}

636
jxrlib/jxrgluelib/JXRGlue.h
View file

@ -1,636 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
#include <JXRMeta.h>
#include <guiddef.h>
//================================================================
#define WMP_SDK_VERSION 0x0101
#define PK_SDK_VERSION 0x0101
#define sizeof2(array) (sizeof(array)/sizeof(*(array)))
#ifndef max
#define max(a,b) ((a) > (b) ? (a) : (b))
#endif
#ifndef min
#define min(b,a) ((a) < (b) ? (a) : (b))
#endif
#ifdef __ANSI__
#define STRCPY_SAFE(pszDest, cbDest, pszSrc) (strncpy((pszDest), (pszSrc), (cbDest)) == (pszDest) ? 0 : 1)
#else
#define STRCPY_SAFE(pszDest, cbDest, pszSrc) (strcpy_s((pszDest), (cbDest), (pszSrc)))
#endif // __ANSI__
//================================================================
typedef struct tagPKRect
{
I32 X;
I32 Y;
I32 Width;
I32 Height;
} PKRect;
//================================================================
typedef U32 PKIID;
EXTERN_C const PKIID IID_PKImageScanEncode;
EXTERN_C const PKIID IID_PKImageFrameEncode;
EXTERN_C const PKIID IID_PKImageWmpEncode;
EXTERN_C const PKIID IID_PKImageWmpDecode;
struct IFDEntry
{
U16 uTag;
U16 uType;
U32 uCount;
U32 uValue;
};
EXTERN_C const U32 IFDEntryTypeSizes[13];
EXTERN_C const U32 SizeofIFDEntry;
//================================================================
typedef float Float;
typedef enum tagPKStreamFlags
{
PKStreamOpenRead = 0x00000000UL,
PKStreamOpenWrite = 0x00000001UL,
PKStreamOpenReadWrite = 0x00000002UL,
PKStreamNoLock = 0x00010000UL,
PKStreamNoSeek = 0x00020000UL,
PKStreamCompress = 0x00040000UL,
} PKStreamFlags;
/* Undefined formats */
#define GUID_PKPixelFormatUndefined GUID_PKPixelFormatDontCare
DEFINE_GUID(GUID_PKPixelFormatDontCare, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x00);
/* Indexed formats */
//DEFINE_GUID(GUID_PKPixelFormat1bppIndexed, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x01);
//DEFINE_GUID(GUID_PKPixelFormat2bppIndexed, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x02);
//DEFINE_GUID(GUID_PKPixelFormat4bppIndexed, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x03);
//DEFINE_GUID(GUID_PKPixelFormat8bppIndexed, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x04);
DEFINE_GUID(GUID_PKPixelFormatBlackWhite, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x05);
//DEFINE_GUID(GUID_PKPixelFormat2bppGray, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x06);
//DEFINE_GUID(GUID_PKPixelFormat4bppGray, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x07);
DEFINE_GUID(GUID_PKPixelFormat8bppGray, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x08);
/* sRGB formats (gamma is approx. 2.2) */
/* For a full definition, see the sRGB spec */
/* 16bpp formats */
DEFINE_GUID(GUID_PKPixelFormat16bppRGB555, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x09);
DEFINE_GUID(GUID_PKPixelFormat16bppRGB565, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x0a);
DEFINE_GUID(GUID_PKPixelFormat16bppGray, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x0b);
/* 24bpp formats */
DEFINE_GUID(GUID_PKPixelFormat24bppBGR, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x0c);
DEFINE_GUID(GUID_PKPixelFormat24bppRGB, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x0d);
/* 32bpp format */
DEFINE_GUID(GUID_PKPixelFormat32bppBGR, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x0e);
DEFINE_GUID(GUID_PKPixelFormat32bppBGRA, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x0f);
DEFINE_GUID(GUID_PKPixelFormat32bppPBGRA, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x10);
DEFINE_GUID(GUID_PKPixelFormat32bppGrayFloat, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x11);
DEFINE_GUID(GUID_PKPixelFormat32bppRGB, 0xd98c6b95, 0x3efe, 0x47d6, 0xbb, 0x25, 0xeb, 0x17, 0x48, 0xab, 0x0c, 0xf1);
DEFINE_GUID(GUID_PKPixelFormat32bppRGBA, 0xf5c7ad2d, 0x6a8d, 0x43dd, 0xa7, 0xa8, 0xa2, 0x99, 0x35, 0x26, 0x1a, 0xe9);
DEFINE_GUID(GUID_PKPixelFormat32bppPRGBA, 0x3cc4a650, 0xa527, 0x4d37, 0xa9, 0x16, 0x31, 0x42, 0xc7, 0xeb, 0xed, 0xba);
/* 48bpp format */
DEFINE_GUID(GUID_PKPixelFormat48bppRGBFixedPoint, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x12);
/* scRGB formats. Gamma is 1.0 */
/* For a full definition, see the scRGB spec */
/* 16bpp format */
DEFINE_GUID(GUID_PKPixelFormat16bppGrayFixedPoint, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x13);
/* 32bpp format */
DEFINE_GUID(GUID_PKPixelFormat32bppRGB101010, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x14);
/* 48bpp format */
DEFINE_GUID(GUID_PKPixelFormat48bppRGB, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x15);
/* 64bpp format */
DEFINE_GUID(GUID_PKPixelFormat64bppRGBA, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x16);
DEFINE_GUID(GUID_PKPixelFormat64bppPRGBA, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x17);
/* 96bpp format */
DEFINE_GUID(GUID_PKPixelFormat96bppRGBFixedPoint, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x18);
DEFINE_GUID(GUID_PKPixelFormat96bppRGBFloat, 0xe3fed78f, 0xe8db, 0x4acf, 0x84, 0xc1, 0xe9, 0x7f, 0x61, 0x36, 0xb3, 0x27);
/* Floating point scRGB formats */
DEFINE_GUID(GUID_PKPixelFormat128bppRGBAFloat, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x19);
DEFINE_GUID(GUID_PKPixelFormat128bppPRGBAFloat, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x1a);
DEFINE_GUID(GUID_PKPixelFormat128bppRGBFloat, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x1b);
/* CMYK formats. */
DEFINE_GUID(GUID_PKPixelFormat32bppCMYK, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x1c);
/* Photon formats */
DEFINE_GUID(GUID_PKPixelFormat64bppRGBAFixedPoint, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x1d);
DEFINE_GUID(GUID_PKPixelFormat64bppRGBFixedPoint, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x40);
DEFINE_GUID(GUID_PKPixelFormat128bppRGBAFixedPoint, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x1e);
DEFINE_GUID(GUID_PKPixelFormat128bppRGBFixedPoint, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x41);
DEFINE_GUID(GUID_PKPixelFormat64bppRGBAHalf, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x3a);
DEFINE_GUID(GUID_PKPixelFormat64bppRGBHalf, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x42);
DEFINE_GUID(GUID_PKPixelFormat48bppRGBHalf, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x3b);
DEFINE_GUID(GUID_PKPixelFormat32bppRGBE, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x3d);
DEFINE_GUID(GUID_PKPixelFormat16bppGrayHalf, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x3e);
DEFINE_GUID(GUID_PKPixelFormat32bppGrayFixedPoint, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x3f);
/* More CMYK formats and n-Channel formats */
DEFINE_GUID(GUID_PKPixelFormat64bppCMYK, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x1f);
DEFINE_GUID(GUID_PKPixelFormat24bpp3Channels, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x20);
DEFINE_GUID(GUID_PKPixelFormat32bpp4Channels, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x21);
DEFINE_GUID(GUID_PKPixelFormat40bpp5Channels, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x22);
DEFINE_GUID(GUID_PKPixelFormat48bpp6Channels, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x23);
DEFINE_GUID(GUID_PKPixelFormat56bpp7Channels, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x24);
DEFINE_GUID(GUID_PKPixelFormat64bpp8Channels, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x25);
DEFINE_GUID(GUID_PKPixelFormat48bpp3Channels, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x26);
DEFINE_GUID(GUID_PKPixelFormat64bpp4Channels, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x27);
DEFINE_GUID(GUID_PKPixelFormat80bpp5Channels, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x28);
DEFINE_GUID(GUID_PKPixelFormat96bpp6Channels, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x29);
DEFINE_GUID(GUID_PKPixelFormat112bpp7Channels, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x2a);
DEFINE_GUID(GUID_PKPixelFormat128bpp8Channels, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x2b);
DEFINE_GUID(GUID_PKPixelFormat40bppCMYKAlpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x2c);
DEFINE_GUID(GUID_PKPixelFormat80bppCMYKAlpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x2d);
DEFINE_GUID(GUID_PKPixelFormat32bpp3ChannelsAlpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x2e);
DEFINE_GUID(GUID_PKPixelFormat40bpp4ChannelsAlpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x2f);
DEFINE_GUID(GUID_PKPixelFormat48bpp5ChannelsAlpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x30);
DEFINE_GUID(GUID_PKPixelFormat56bpp6ChannelsAlpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x31);
DEFINE_GUID(GUID_PKPixelFormat64bpp7ChannelsAlpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x32);
DEFINE_GUID(GUID_PKPixelFormat72bpp8ChannelsAlpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x33);
DEFINE_GUID(GUID_PKPixelFormat64bpp3ChannelsAlpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x34);
DEFINE_GUID(GUID_PKPixelFormat80bpp4ChannelsAlpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x35);
DEFINE_GUID(GUID_PKPixelFormat96bpp5ChannelsAlpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x36);
DEFINE_GUID(GUID_PKPixelFormat112bpp6ChannelsAlpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x37);
DEFINE_GUID(GUID_PKPixelFormat128bpp7ChannelsAlpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x38);
DEFINE_GUID(GUID_PKPixelFormat144bpp8ChannelsAlpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x39);
/* YCrCb from Advanced Profile */
DEFINE_GUID(GUID_PKPixelFormat12bppYCC420, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x44);
DEFINE_GUID(GUID_PKPixelFormat16bppYCC422, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x45);
DEFINE_GUID(GUID_PKPixelFormat20bppYCC422, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x46);
DEFINE_GUID(GUID_PKPixelFormat32bppYCC422, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x47);
DEFINE_GUID(GUID_PKPixelFormat24bppYCC444, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x48);
DEFINE_GUID(GUID_PKPixelFormat30bppYCC444, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x49);
DEFINE_GUID(GUID_PKPixelFormat48bppYCC444, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x4a);
DEFINE_GUID(GUID_PKPixelFormat16bpp48bppYCC444FixedPoint, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x4b);
DEFINE_GUID(GUID_PKPixelFormat20bppYCC420Alpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x4c);
DEFINE_GUID(GUID_PKPixelFormat24bppYCC422Alpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x4d);
DEFINE_GUID(GUID_PKPixelFormat30bppYCC422Alpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x4e);
DEFINE_GUID(GUID_PKPixelFormat48bppYCC422Alpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x4f);
DEFINE_GUID(GUID_PKPixelFormat32bppYCC444Alpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x50);
DEFINE_GUID(GUID_PKPixelFormat40bppYCC444Alpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x51);
DEFINE_GUID(GUID_PKPixelFormat64bppYCC444Alpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x52);
DEFINE_GUID(GUID_PKPixelFormat64bppYCC444AlphaFixedPoint, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x53);
//YUV
#define GUID_PKPixelFormat12bppYUV420 GUID_PKPixelFormat12bppYCC420
#define GUID_PKPixelFormat16bppYUV422 GUID_PKPixelFormat16bppYCC422
#define GUID_PKPixelFormat24bppYUV444 GUID_PKPixelFormat24bppYCC444
/* CMYKDIRECT from Advanced Profile */
DEFINE_GUID(GUID_PKPixelFormat32bppCMYKDIRECT, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x54);
DEFINE_GUID(GUID_PKPixelFormat64bppCMYKDIRECT, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x55);
DEFINE_GUID(GUID_PKPixelFormat40bppCMYKDIRECTAlpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x56);
DEFINE_GUID(GUID_PKPixelFormat80bppCMYKDIRECTAlpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x43);
// PhotometricInterpretation
#define PK_PI_W0 0 // WhiteIsZero
#define PK_PI_B0 1 // BlackIsZero
#define PK_PI_RGB 2
#define PK_PI_RGBPalette 3
#define PK_PI_TransparencyMask 4
#define PK_PI_CMYK 5
#define PK_PI_YCbCr 6
#define PK_PI_CIELab 8
#define PK_PI_NCH 100
#define PK_PI_RGBE 101
#define PK_pixfmtNul 0x00000000
#define PK_pixfmtHasAlpha 0x00000010
#define PK_pixfmtPreMul 0x00000020
#define PK_pixfmtBGR 0x00000040
#define PK_pixfmtNeedConvert 0x80000000
#define LOOKUP_FORWARD 0
#define LOOKUP_BACKWARD_TIF 1
typedef unsigned long WMP_GRBIT;
typedef GUID PKPixelFormatGUID;
typedef struct tagPKPixelInfo
{
const PKPixelFormatGUID* pGUIDPixFmt;
size_t cChannel;
COLORFORMAT cfColorFormat;
BITDEPTH_BITS bdBitDepth;
U32 cbitUnit;
WMP_GRBIT grBit;
// TIFF
U32 uInterpretation;
U32 uSamplePerPixel;
U32 uBitsPerSample;
U32 uSampleFormat;
} PKPixelInfo;
//================================================================
ERR PKAlloc(void** ppv, size_t cb);
ERR PKFree(void** ppv);
//----------------------------------------------------------------
//ERR GetPixelInfo(PKPixelFormatGUID enPixelFormat, const PKPixelInfo** ppPI);
ERR PixelFormatLookup(PKPixelInfo* pPI, U8 uLookupType);
const PKPixelFormatGUID* GetPixelFormatFromHash(const U8 uPFHash);
ERR GetImageEncodeIID(const char* szExt, const PKIID** ppIID);
ERR GetImageDecodeIID(const char* szExt, const PKIID** ppIID);
//================================================================
#ifdef __ANSI__
struct tagPKFactory;
struct tagPKCodecFactory;
struct tagPKImageDecode;
struct tagPKImageEncode;
struct tagPKFormatConverter;
#define PKFactory struct tagPKFactory
#define PKCodecFactory struct tagPKCodecFactory
#define PKImageDecode struct tagPKImageDecode
#define PKImageEncode struct tagPKImageEncode
#define PKFormatConverter struct tagPKFormatConverter
#else // __ANSI__
typedef struct tagPKFactory PKFactory;
typedef struct tagPKCodecFactory PKCodecFactory;
typedef struct tagPKImageDecode PKImageDecode;
typedef struct tagPKImageEncode PKImageEncode;
typedef struct tagPKFormatConverter PKFormatConverter;
#endif // __ANSI__
//================================================================
typedef struct tagPKStream
{
ERR (*InitializeFromFilename)(const char*, ULong);
ERR (*Release)(void);
FILE* fp;
} PKStream;
//================================================================
typedef struct tagPKFactory
{
ERR (*CreateStream)(PKStream**);
ERR (*CreateStreamFromFilename)(struct WMPStream**, const char*, const char*);
ERR (*CreateStreamFromMemory)(struct WMPStream**, void*, size_t);
ERR (*Release)(PKFactory**);
#ifdef __ANSI__
#undef PKFactory
#endif // __ANSI__
} PKFactory;
//----------------------------------------------------------------
ERR PKCreateFactory_CreateStream(PKStream** ppStream);
ERR PKCreateFactory_Release(PKFactory** ppFactory);
EXTERN_C ERR PKCreateFactory(PKFactory**, U32);
//================================================================
typedef struct tagPKCodecFactory
{
ERR (*CreateCodec)(const PKIID*, void**);
ERR (*CreateDecoderFromFile)(const char*, PKImageDecode**);
ERR (*CreateFormatConverter)(PKFormatConverter**);
ERR (*Release)(PKCodecFactory**);
#ifdef __ANSI__
#undef PKCodecFactory
#endif // __ANSI__
} PKCodecFactory;
//----------------------------------------------------------------
ERR PKCodecFactory_CreateCodec(const PKIID* iid, void** ppv);
ERR PKCreateCodecFactory_Release(PKCodecFactory** ppCFactory);
EXTERN_C ERR PKCreateCodecFactory(PKCodecFactory**, U32);
//================================================================
typedef enum BANDEDENCSTATE
{
BANDEDENCSTATE_UNINITIALIZED = 0,
BANDEDENCSTATE_INIT,
BANDEDENCSTATE_ENCODING,
BANDEDENCSTATE_TERMINATED,
BANDEDENCSTATE_NONBANDEDENCODE,
} BANDEDENCSTATE;
typedef struct tagPKImageEncode
{
//ERR (*GetPixelFormat)(MILPixelFormat*));
ERR (*Initialize)(PKImageEncode*, struct WMPStream*, void*, size_t);
ERR (*Terminate)(PKImageEncode*);
ERR (*SetPixelFormat)(PKImageEncode*, PKPixelFormatGUID);
ERR (*SetSize)(PKImageEncode*, I32, I32);
ERR (*SetResolution)(PKImageEncode*, Float, Float);
ERR (*SetColorContext)(PKImageEncode *pIE, const U8 *pbColorContext,
U32 cbColorContext);
ERR (*SetDescriptiveMetadata)(PKImageEncode *pIE,
const DESCRIPTIVEMETADATA *pDescMetadata);
ERR (*WritePixels)(PKImageEncode*, U32, U8*, U32);
ERR (*WriteSource)(PKImageEncode*, PKFormatConverter*, PKRect*);
// Banded encode API - currently only implemented for WMP encoder
ERR (*WritePixelsBandedBegin)(PKImageEncode* pEncoder, struct WMPStream *pPlanarAlphaTempFile);
ERR (*WritePixelsBanded)(PKImageEncode* pEncoder, U32 cLines, U8* pbPixels, U32 cbStride, Bool fLastCall);
ERR (*WritePixelsBandedEnd)(PKImageEncode* pEncoder);
#define TEMPFILE_COPYBUF_SIZE 8192 // Means when using tempfile for planar alpha banded encode, copy this many bytes at a time
ERR (*Transcode)(PKImageEncode*, PKImageDecode*, CWMTranscodingParam*);
ERR (*CreateNewFrame)(PKImageEncode*, void*, size_t);
ERR (*Release)(PKImageEncode**);
struct WMPStream* pStream;
size_t offStart;
PKPixelFormatGUID guidPixFormat;
U32 uWidth;
U32 uHeight;
U32 idxCurrentLine;
Float fResX;
Float fResY;
U32 cFrame;
Bool fHeaderDone;
size_t offPixel;
size_t cbPixel;
U8 *pbColorContext;
U32 cbColorContext;
U8 *pbEXIFMetadata;
U32 cbEXIFMetadataByteCount;
U8 *pbGPSInfoMetadata;
U32 cbGPSInfoMetadataByteCount;
U8 *pbIPTCNAAMetadata;
U32 cbIPTCNAAMetadataByteCount;
U8 *pbXMPMetadata;
U32 cbXMPMetadataByteCount;
U8 *pbPhotoshopMetadata;
U32 cbPhotoshopMetadataByteCount;
DESCRIPTIVEMETADATA sDescMetadata;
Bool bWMP;//for the encoder in decoding
struct
{
WmpDEMisc wmiDEMisc;
CWMImageInfo wmiI;
CWMIStrCodecParam wmiSCP;
CTXSTRCODEC ctxSC;
CWMImageInfo wmiI_Alpha;
CWMIStrCodecParam wmiSCP_Alpha;
CTXSTRCODEC ctxSC_Alpha;
Bool bHasAlpha;
Long nOffImage;
Long nCbImage;
Long nOffAlpha;
Long nCbAlpha;
ORIENTATION oOrientation;
// Banded encode state variables
BANDEDENCSTATE eBandedEncState;
struct WMPStream *pPATempFile;
} WMP;
#ifdef __ANSI__
#undef PKImageEncode
#endif // __ANSI__
} PKImageEncode;
//----------------------------------------------------------------
ERR PKImageEncode_Create_WMP(PKImageEncode** ppIE);
ERR PKImageEncode_Initialize(PKImageEncode* pIE, struct WMPStream* pStream, void* pvParam, size_t cbParam);
ERR PKImageEncode_Terminate(PKImageEncode* pIE);
ERR PKImageEncode_SetPixelFormat(PKImageEncode* pIE, PKPixelFormatGUID enPixelFormat);
ERR PKImageEncode_SetSize(PKImageEncode* pIE, I32 iWidth, I32 iHeight);
ERR PKImageEncode_SetResolution(PKImageEncode* pIE, Float rX, Float rY);
ERR PKImageEncode_SetColorContext(PKImageEncode *pIE, const U8 *pbColorContext, U32 cbColorContext);
ERR PKImageEncode_SetDescriptiveMetadata(PKImageEncode *pIE, const DESCRIPTIVEMETADATA *pDescMetadata);
ERR PKImageEncode_WritePixels(PKImageEncode* pIE, U32 cLine, U8* pbPixel, U32 cbStride);
ERR PKImageEncode_CreateNewFrame(PKImageEncode* pIE, void* pvParam, size_t cbParam);
ERR PKImageEncode_Release(PKImageEncode** ppIE);
ERR PKImageEncode_SetXMPMetadata_WMP(PKImageEncode *pIE, const U8 *pbXMPMetadata, U32 cbXMPMetadata);
ERR PKImageEncode_SetEXIFMetadata_WMP(PKImageEncode *pIE, const U8 *pbEXIFMetadata, U32 cbEXIFMetadata);
ERR PKImageEncode_SetGPSInfoMetadata_WMP(PKImageEncode *pIE, const U8 *pbGPSInfoMetadata, U32 cbGPSInfoMetadata);
ERR PKImageEncode_SetIPTCNAAMetadata_WMP(PKImageEncode *pIE, const U8 *pbIPTCNAAMetadata, U32 cbIPTCNAAMetadata);
ERR PKImageEncode_SetPhotoshopMetadata_WMP(PKImageEncode *pIE, const U8 *pbPhotoshopMetadata, U32 cbPhotoshopMetadata);
void FreeDescMetadata(DPKPROPVARIANT *pvar);
ERR PKImageEncode_Create(PKImageEncode** ppIE);
//================================================================
typedef struct tagPKImageDecode
{
ERR (*Initialize)(PKImageDecode*, struct WMPStream* pStream);
ERR (*GetPixelFormat)(PKImageDecode*, PKPixelFormatGUID*);
ERR (*GetSize)(PKImageDecode*, I32*, I32*);
ERR (*GetResolution)(PKImageDecode*, Float*, Float*);
ERR (*GetColorContext)(PKImageDecode *pID, U8 *pbColorContext,
U32 *pcbColorContext);
ERR (*GetDescriptiveMetadata)(PKImageDecode *pIE,
DESCRIPTIVEMETADATA *pDescMetadata);
ERR (*GetRawStream)(PKImageDecode*, struct WMPStream**);
ERR (*Copy)(PKImageDecode*, const PKRect*, U8*, U32);
ERR (*GetFrameCount)(PKImageDecode*, U32*);
ERR (*SelectFrame)(PKImageDecode*, U32);
ERR (*Release)(PKImageDecode**);
struct WMPStream* pStream;
Bool fStreamOwner;
size_t offStart;
PKPixelFormatGUID guidPixFormat;
U32 uWidth;
U32 uHeight;
U32 idxCurrentLine;
Float fResX;
Float fResY;
U32 cFrame;
struct
{
WmpDEMisc wmiDEMisc;
CWMImageInfo wmiI;
CWMIStrCodecParam wmiSCP;
CTXSTRCODEC ctxSC;
CWMImageInfo wmiI_Alpha;
CWMIStrCodecParam wmiSCP_Alpha;
CTXSTRCODEC ctxSC_Alpha;
Bool bHasAlpha;
Long nOffImage;
Long nCbImage;
Long nOffAlpha;
Long nCbAlpha;
Bool bIgnoreOverlap;
size_t DecoderCurrMBRow;
size_t DecoderCurrAlphaMBRow;
size_t cMarker;
size_t cLinesDecoded;
size_t cLinesCropped; // Lines may be cropped from the top - buffer for subsequent decodes must be adjusted
Bool fFirstNonZeroDecode;
Bool fOrientationFromContainer;
ORIENTATION oOrientationFromContainer; // Tag 0xBC02 in HD Photo container
DESCRIPTIVEMETADATA sDescMetadata;
} WMP;
#ifdef __ANSI__
#undef PKImageDecode
#endif // __ANSI__
} PKImageDecode;
//----------------------------------------------------------------
ERR PKImageDecode_Create_WMP(PKImageDecode** ppID);
ERR PKImageDecode_Initialize(PKImageDecode* pID, struct WMPStream* pStream);
ERR PKImageDecode_GetPixelFormat(PKImageDecode* pID, PKPixelFormatGUID* pPF);
ERR PKImageDecode_GetSize(PKImageDecode* pID, I32* piWidth, I32* piHeight);
ERR PKImageDecode_GetResolution(PKImageDecode* pID, Float* pfrX, Float* pfrY);
ERR PKImageDecode_GetColorContext(PKImageDecode *pID, U8 *pbColorContext, U32 *pcbColorContext);
ERR PKImageDecode_GetDescriptiveMetadata(PKImageDecode *pID, DESCRIPTIVEMETADATA *pDescMetadata);
ERR PKImageDecode_Copy(PKImageDecode* pID, const PKRect* pRect, U8* pb, U32 cbStride);
ERR PKImageDecode_GetFrameCount(PKImageDecode* pID, U32* puCount);
ERR PKImageDecode_SelectFrame(PKImageDecode* pID, U32 uFrame);
ERR PKImageDecode_Release(PKImageDecode** ppID);
ERR PKImageDecode_Create(PKImageDecode** ppID);
ERR PKCodecFactory_CreateDecoderFromFile(const char* szFilename, PKImageDecode** ppDecoder);
//================================================================
typedef struct tagPKFormatConverter
{
ERR (*Initialize)(PKFormatConverter*, PKImageDecode*, char *pExt, PKPixelFormatGUID);
ERR (*InitializeConvert)(PKFormatConverter* pFC, const PKPixelFormatGUID enPFFrom,
char *pExt, PKPixelFormatGUID enPFTTo);
ERR (*GetPixelFormat)(PKFormatConverter*, PKPixelFormatGUID*);
ERR (*GetSourcePixelFormat)(PKFormatConverter*, PKPixelFormatGUID*);
ERR (*GetSize)(PKFormatConverter*, I32*, I32*);
ERR (*GetResolution)(PKFormatConverter*, Float*, Float*);
ERR (*Copy)(PKFormatConverter*, const PKRect*, U8*, U32);
ERR (*Convert)(PKFormatConverter*, const PKRect*, U8*, U32);
ERR (*Release)(PKFormatConverter**);
PKImageDecode* pDecoder;
PKPixelFormatGUID enPixelFormat;
#ifdef __ANSI__
#undef PKFormatConverter
#endif // __ANSI__
} PKFormatConverter;
//----------------------------------------------------------------
ERR PKImageEncode_Transcode(PKImageEncode* pIE, PKFormatConverter* pFC, PKRect* pRect);
ERR PKImageEncode_WriteSource(PKImageEncode* pIE, PKFormatConverter* pFC, PKRect* pRect);
ERR PKFormatConverter_Initialize(PKFormatConverter* pFC, PKImageDecode* pID, char *pExt, PKPixelFormatGUID enPF);
ERR PKFormatConverter_InitializeConvert(PKFormatConverter* pFC, const PKPixelFormatGUID enPFFrom,
char *pExt, PKPixelFormatGUID enPFTo);
ERR PKFormatConverter_GetPixelFormat(PKFormatConverter* pFC, PKPixelFormatGUID* pPF);
ERR PKFormatConverter_GetSourcePixelFormat(PKFormatConverter* pFC, PKPixelFormatGUID* pPF);
ERR PKFormatConverter_GetSize(PKFormatConverter* pFC, I32* piWidth, I32* piHeight);
ERR PKFormatConverter_GetResolution(PKFormatConverter* pFC, Float* pfrX, Float* pfrY);
ERR PKFormatConverter_Copy(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride);
ERR PKFormatConverter_Convert(PKFormatConverter* pFC, const PKRect* pRect, U8* pb, U32 cbStride);
ERR PKFormatConverter_Release(PKFormatConverter** ppFC);
// Think of this as static member of PKFormatConverter "class"
ERR PKFormatConverter_EnumConversions(const PKPixelFormatGUID *pguidSourcePF,
const U32 iIndex,
const PKPixelFormatGUID **ppguidTargetPF);
ERR PKCodecFactory_CreateFormatConverter(PKFormatConverter** ppFConverter);
//----------------------------------------------------------------
ERR PKAlloc(void** ppv, size_t cb);
ERR PKFree(void** ppv);
ERR PKAllocAligned(void** ppv, size_t cb, size_t iAlign);
ERR PKFreeAligned(void** ppv);
#ifdef __cplusplus
} // extern "C"
#endif

2234
jxrlib/jxrgluelib/JXRGlueJxr.c
View file

File diff suppressed because it is too large Load diff

178
jxrlib/jxrgluelib/JXRGlueLib_vc11.vcxproj
View file

@ -1,178 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectName>JXRGlueLib</ProjectName>
<ProjectGuid>{A69603CC-65E8-443F-8E31-737DBD6BB0DB}</ProjectGuid>
<RootNamespace>JXRGlueLib</RootNamespace>
<Keyword>Win32Proj</Keyword>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v110</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v110</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v110</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v110</PlatformToolset>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" 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|Win32'" 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)'=='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>10.0.30319.1</_ProjectFileVersion>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(Configuration)/$(ProjectName)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(OutDir)</IntDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(Configuration)\$(ProjectName)\$(Platform)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)</IntDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(Configuration)/$(ProjectName)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(OutDir)</IntDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(Configuration)\$(ProjectName)\$(Platform)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)</IntDir>
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" />
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" />
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" />
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>..\image\sys;..\image\x86;..\JXRGlueLib;..\common\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Lib>
<OutputFile>$(OutDir)$(ProjectName).lib</OutputFile>
</Lib>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Midl>
<TargetEnvironment>X64</TargetEnvironment>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>..\image\sys;..\image\x86;..\JXRGlueLib;..\common\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Lib>
<OutputFile>$(OutDir)$(ProjectName).lib</OutputFile>
</Lib>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<WholeProgramOptimization>true</WholeProgramOptimization>
<AdditionalIncludeDirectories>..\image\sys;..\image\x86;..\JXRGlueLib;..\common\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;NDEBUG;_LIB;ENABLE_OPTIMIZATIONS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Lib>
<AdditionalOptions>/LTCG %(AdditionalOptions)</AdditionalOptions>
<OutputFile>$(OutDir)$(ProjectName).lib</OutputFile>
<LinkTimeCodeGeneration>true</LinkTimeCodeGeneration>
</Lib>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Midl>
<TargetEnvironment>X64</TargetEnvironment>
</Midl>
<ClCompile>
<AdditionalIncludeDirectories>..\image\sys;..\image\x86;..\JXRGlueLib;..\common\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<WholeProgramOptimization>true</WholeProgramOptimization>
</ClCompile>
<Lib>
<OutputFile>$(OutDir)$(ProjectName).lib</OutputFile>
<LinkTimeCodeGeneration>true</LinkTimeCodeGeneration>
</Lib>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="JXRGlue.c" />
<ClCompile Include="JXRGluePFC.c" />
<ClCompile Include="JXRGlueJxr.c" />
<ClCompile Include="JXRMeta.c" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="JXRGlue.h" />
<ClInclude Include="JXRMeta.h" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

2338
jxrlib/jxrgluelib/JXRGluePFC.c
View file

File diff suppressed because it is too large Load diff

905
jxrlib/jxrgluelib/JXRMeta.c
View file

@ -1,905 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#include "JXRMeta.h"
#include "JXRGlue.h"
// read and write big and little endian words/dwords from a buffer on both big and little endian cpu's
// with full buffer overflow checking
ERR getbfcpy(U8* pbdest, const U8* pb, size_t cb, size_t ofs, U32 n)
{
ERR err = WMP_errSuccess;
FailIf(ofs + n > cb, WMP_errBufferOverflow);
memcpy(pbdest, &pb[ofs], n);
Cleanup:
return err;
}
ERR getbfw(const U8* pb, size_t cb, size_t ofs, U16* pw)
{
ERR err = WMP_errSuccess;
FailIf(ofs + sizeof(U16) > cb, WMP_errBufferOverflow);
*pw = (U16)( pb[ofs] + ( pb[ofs + 1] << 8 ) );
Cleanup:
return err;
}
ERR getbfdw(const U8* pb, size_t cb, size_t ofs, U32* pdw)
{
ERR err = WMP_errSuccess;
FailIf(ofs + sizeof(U32) > cb, WMP_errBufferOverflow);
*pdw = pb[ofs] + ( pb[ofs + 1] << 8 ) + ( pb[ofs + 2] << 16UL ) + ( pb[ofs + 3] << 24UL );
Cleanup:
return err;
}
ERR getbfwbig(const U8* pb, size_t cb, size_t ofs, U16* pw)
{
ERR err = WMP_errSuccess;
FailIf(ofs + sizeof(U16) > cb, WMP_errBufferOverflow);
*pw = (U16)( pb[ofs + 1] + ( pb[ofs] << 8 ) );
Cleanup:
return err;
}
ERR getbfdwbig(const U8* pb, size_t cb, size_t ofs, U32* pdw)
{
ERR err = WMP_errSuccess;
FailIf(ofs + sizeof(U32) > cb, WMP_errBufferOverflow);
*pdw = pb[ofs + 3] + ( pb[ofs + 2] << 8 ) + ( pb[ofs + 1] << 16UL ) + ( pb[ofs] << 24UL );
Cleanup:
return err;
}
ERR getbfwe(const U8* pb, size_t cb, size_t ofs, U16* pw, U8 endian)
{
if ( endian == WMP_INTEL_ENDIAN )
return ( getbfw(pb, cb, ofs, pw) );
else
return ( getbfwbig(pb, cb, ofs, pw) );
}
ERR getbfdwe(const U8* pb, size_t cb, size_t ofs, U32* pdw, U8 endian)
{
if ( endian == WMP_INTEL_ENDIAN )
return ( getbfdw(pb, cb, ofs, pdw) );
else
return ( getbfdwbig(pb, cb, ofs, pdw) );
}
ERR setbfcpy(U8* pb, size_t cb, size_t ofs, const U8* pbset, size_t cbset)
{
ERR err = WMP_errSuccess;
FailIf(ofs + cbset > cb, WMP_errBufferOverflow);
memcpy(&pb[ofs], pbset, cbset);
Cleanup:
return err;
}
ERR setbfw(U8* pb, size_t cb, size_t ofs, U16 dw)
{
ERR err = WMP_errSuccess;
FailIf(ofs + sizeof(U16) > cb, WMP_errBufferOverflow);
pb[ofs] = (U8)dw;
pb[ofs + 1] = (U8)( dw >> 8 );
Cleanup:
return err;
}
ERR setbfdw(U8* pb, size_t cb, size_t ofs, U32 dw)
{
ERR err = WMP_errSuccess;
FailIf(ofs + sizeof(U32) > cb, WMP_errBufferOverflow);
pb[ofs] = (U8)dw;
pb[ofs + 1] = (U8)( dw >> 8 );
pb[ofs + 2] = (U8)( dw >> 16 );
pb[ofs + 3] = (U8)( dw >> 24 );
Cleanup:
return err;
}
ERR setbfwbig(U8* pb, size_t cb, size_t ofs, U16 dw)
{
ERR err = WMP_errSuccess;
FailIf(ofs + sizeof(U16) > cb, WMP_errBufferOverflow);
pb[ofs + 1] = (U8)dw;
pb[ofs] = (U8)( dw >> 8 );
Cleanup:
return err;
}
ERR setbfdwbig(U8* pb, size_t cb, size_t ofs, U32 dw)
{
ERR err = WMP_errSuccess;
FailIf(ofs + sizeof(U32) > cb, WMP_errBufferOverflow);
pb[ofs + 3] = (U8)dw;
pb[ofs + 2] = (U8)( dw >> 8 );
pb[ofs + 1] = (U8)( dw >> 16 );
pb[ofs] = (U8)( dw >> 24 );
Cleanup:
return err;
}
//================================================================
// BufferCalcIFDSize (arbitrary endian)
// StreamCalcIFDSize (little endian)
//
// count up the number of bytes needed to store the IFD and all
// associated data including a subordinate interoperability IFD if any
//================================================================
ERR BufferCalcIFDSize(const U8* pbdata, size_t cbdata, U32 ofsifd, U8 endian, U32* pcbifd)
{
ERR err = WMP_errSuccess;
U16 cDir;
U16 i;
U32 ofsdir;
U32 cbifd = 0;
U32 cbEXIFIFD = 0;
U32 cbGPSInfoIFD = 0;
U32 cbInteroperabilityIFD = 0;
*pcbifd = 0;
Call(getbfwe(pbdata, cbdata, ofsifd, &cDir, endian));
cbifd = sizeof(U16) + cDir * SizeofIFDEntry + sizeof(U32);
ofsdir = ofsifd + sizeof(U16);
for ( i = 0; i < cDir; i++ )
{
U16 tag;
U16 type;
U32 count;
U32 value;
U32 datasize;
Call(getbfwe(pbdata, cbdata, ofsdir, &tag, endian));
Call(getbfwe(pbdata, cbdata, ofsdir + sizeof(U16), &type, endian));
Call(getbfdwe(pbdata, cbdata, ofsdir + 2 * sizeof(U16), &count, endian));
Call(getbfdwe(pbdata, cbdata, ofsdir + 2 * sizeof(U16) + sizeof(U32), &value, endian));
FailIf(type == 0 || type >= sizeof(IFDEntryTypeSizes) / sizeof(IFDEntryTypeSizes[0]), WMP_errFail);
if ( tag == WMP_tagEXIFMetadata )
{
Call(BufferCalcIFDSize(pbdata, cbdata, value, endian, &cbEXIFIFD));
}
else if ( tag == WMP_tagGPSInfoMetadata )
{
Call(BufferCalcIFDSize(pbdata, cbdata, value, endian, &cbGPSInfoIFD));
}
else if ( tag == WMP_tagInteroperabilityIFD )
{
Call(BufferCalcIFDSize(pbdata, cbdata, value, endian, &cbInteroperabilityIFD));
}
else
{
datasize = IFDEntryTypeSizes[type] * count;
if ( datasize > 4 )
cbifd += datasize;
}
ofsdir += SizeofIFDEntry;
}
if ( cbEXIFIFD != 0 )
cbifd += ( cbifd & 1 ) + cbEXIFIFD;
if ( cbGPSInfoIFD != 0 )
cbifd += ( cbifd & 1 ) + cbGPSInfoIFD;
if ( cbInteroperabilityIFD != 0 )
cbifd += ( cbifd & 1 ) + cbInteroperabilityIFD;
*pcbifd = cbifd;
Cleanup:
return err;
}
ERR StreamCalcIFDSize(struct WMPStream* pWS, U32 uIFDOfs, U32 *pcbifd)
{
ERR err = WMP_errSuccess;
size_t offCurPos = 0;
Bool GetPosOK = FALSE;
U16 cDir;
U32 i;
U32 ofsdir;
U32 cbifd = 0;
U32 cbEXIFIFD = 0;
U32 cbGPSInfoIFD = 0;
U32 cbInteroperabilityIFD = 0;
*pcbifd = 0;
Call(pWS->GetPos(pWS, &offCurPos));
GetPosOK = TRUE;
Call(GetUShort(pWS, uIFDOfs, &cDir));
cbifd = sizeof(U16) + cDir * SizeofIFDEntry + sizeof(U32);
ofsdir = uIFDOfs + sizeof(U16);
for ( i = 0; i < cDir; i++ )
{
U16 tag;
U16 type;
U32 count;
U32 value;
U32 datasize;
Call(GetUShort(pWS, ofsdir, &tag));
Call(GetUShort(pWS, ofsdir + sizeof(U16), &type));
Call(GetULong(pWS, ofsdir + 2 * sizeof(U16), &count));
Call(GetULong(pWS, ofsdir + 2 * sizeof(U16) + sizeof(U32), &value));
FailIf(type == 0 || type >= sizeof(IFDEntryTypeSizes) / sizeof(IFDEntryTypeSizes[0]), WMP_errUnsupportedFormat);
if ( tag == WMP_tagEXIFMetadata )
{
Call(StreamCalcIFDSize(pWS, value, &cbEXIFIFD));
}
else if ( tag == WMP_tagGPSInfoMetadata )
{
Call(StreamCalcIFDSize(pWS, value, &cbGPSInfoIFD));
}
else if ( tag == WMP_tagInteroperabilityIFD )
{
Call(StreamCalcIFDSize(pWS, value, &cbInteroperabilityIFD));
}
else
{
datasize = IFDEntryTypeSizes[type] * count;
if ( datasize > 4 )
cbifd += datasize;
}
ofsdir += SizeofIFDEntry;
}
if ( cbEXIFIFD != 0 )
cbifd += ( cbifd & 1 ) + cbEXIFIFD;
if ( cbGPSInfoIFD != 0 )
cbifd += ( cbifd & 1 ) + cbGPSInfoIFD;
if ( cbInteroperabilityIFD != 0 )
cbifd += ( cbifd & 1 ) + cbInteroperabilityIFD;
*pcbifd = cbifd;
Cleanup:
if ( GetPosOK )
Call(pWS->SetPos(pWS, offCurPos));
return ( err );
}
// src IFD copied to dst IFD with any nested IFD's
// src IFD is arbitrary endian, arbitrary data arrangement
// dst IFD is little endian, data arranged in tag order
// dst IFD tags are ordered the same as src IFD so src IFD tags must be in order
ERR BufferCopyIFD(const U8* pbsrc, U32 cbsrc, U32 ofssrc, U8 endian, U8* pbdst, U32 cbdst, U32* pofsdst)
{
ERR err = WMP_errSuccess;
U16 cDir;
U16 i;
U16 ofsEXIFIFDEntry = 0;
U16 ofsGPSInfoIFDEntry = 0;
U16 ofsInteroperabilityIFDEntry = 0;
U32 ofsEXIFIFD = 0;
U32 ofsGPSInfoIFD = 0;
U32 ofsInteroperabilityIFD = 0;
U32 ofsdstnextdata;
U32 ofsdst = *pofsdst;
U32 ofssrcdir;
U32 ofsdstdir;
U32 ofsnextifd;
Call(getbfwe(pbsrc, cbsrc, ofssrc, &cDir, endian));
Call(setbfw(pbdst, cbdst, ofsdst, cDir));
ofsnextifd = ofsdst + sizeof(U16) + SizeofIFDEntry * cDir;
ofsdstnextdata = ofsnextifd + sizeof(U32);
ofssrcdir = ofssrc + sizeof(U16);
ofsdstdir = ofsdst + sizeof(U16);
for ( i = 0; i < cDir; i++ )
{
U16 tag;
U16 type;
U32 count;
U32 value;
U32 size;
Call(getbfwe(pbsrc, cbsrc, ofssrcdir, &tag, endian));
Call(setbfw(pbdst, cbdst, ofsdstdir, tag));
Call(getbfwe(pbsrc, cbsrc, ofssrcdir + sizeof(U16), &type, endian));
Call(setbfw(pbdst, cbdst, ofsdstdir + sizeof(U16), type));
Call(getbfdwe(pbsrc, cbsrc, ofssrcdir + 2 * sizeof(U16), &count, endian));
Call(setbfdw(pbdst, cbdst, ofsdstdir + 2 * sizeof(U16), count));
Call(getbfdwe(pbsrc, cbsrc, ofssrcdir + 2 * sizeof(U16) + sizeof(U32), &value, endian));
Call(setbfdw(pbdst, cbdst, ofsdstdir + 2 * sizeof(U16) + sizeof(U32), 0));
FailIf(type == 0 || type >= sizeof(IFDEntryTypeSizes) / sizeof(IFDEntryTypeSizes[0]), WMP_errFail);
if ( tag == WMP_tagEXIFMetadata )
{
ofsEXIFIFDEntry = (U16) ofsdstdir;
ofsEXIFIFD = value;
}
else if ( tag == WMP_tagGPSInfoMetadata )
{
ofsGPSInfoIFDEntry = (U16) ofsdstdir;
ofsGPSInfoIFD = value;
}
else if ( tag == WMP_tagInteroperabilityIFD )
{
ofsInteroperabilityIFDEntry = (U16) ofsdstdir;
ofsInteroperabilityIFD = value;
}
else
{
U32 ofsdstdata = ofsdstdir + 2 * sizeof(U16) + sizeof(U32);
U32 ofssrcdata = ofssrcdir + 2 * sizeof(U16) + sizeof(U32);
size = count * IFDEntryTypeSizes[type];
if ( size > 4 )
{
ofssrcdata = value;
Call(setbfdw(pbdst, cbdst, ofsdstdata, ofsdstnextdata));
ofsdstdata = ofsdstnextdata;
ofsdstnextdata += size;
}
FailIf(ofssrcdata + size > cbsrc || ofsdstdata + size > cbdst, WMP_errBufferOverflow);
if ( size == count || endian == WMP_INTEL_ENDIAN )
// size == count means 8-bit data means endian doesn't matter
memcpy(&pbdst[ofsdstdata], &pbsrc[ofssrcdata], size);
else
{ // big endian source and endian matters
U32 j;
switch ( IFDEntryTypeSizes[type] )
{
case 2:
for ( j = 0; j < count; j++ )
{
U16 w;
getbfwbig(pbsrc, cbsrc, ofssrcdata + j * sizeof(U16), &w);
setbfw(pbdst, cbdst, ofsdstdata + j * sizeof(U16), w);
}
break;
case 8:
if ( type == WMP_typDOUBLE )
{
for ( j = 0; j < count; j++ )
{
U32 dwlo;
U32 dwhi;
getbfdwbig(pbsrc, cbsrc, ofssrcdata + j * 8, &dwhi);
getbfdwbig(pbsrc, cbsrc, ofssrcdata + j * 8 + sizeof(U32), &dwlo);
setbfdw(pbdst, cbdst, ofsdstdata + j * 8, dwlo);
setbfdw(pbdst, cbdst, ofsdstdata + j * 8 + sizeof(U32), dwhi);
}
break;
}
count *= 2;
// RATIONAL's fall through to be handled as LONG's
case 4:
for ( j = 0; j < count; j++ )
{
U32 dw;
getbfdwbig(pbsrc, cbsrc, ofssrcdata + j * sizeof(U32), &dw);
setbfdw(pbdst, cbdst, ofsdstdata + j * sizeof(U32), dw);
}
break;
}
}
}
ofssrcdir += SizeofIFDEntry;
ofsdstdir += SizeofIFDEntry;
}
Call(setbfdw(pbdst, cbdst, ofsnextifd, 0)); // no nextIFD
if ( ofsEXIFIFDEntry != 0 )
{
ofsdstnextdata += ( ofsdstnextdata & 1 );
Call(setbfdw(pbdst, cbdst, ofsEXIFIFDEntry + 2 * sizeof(U16) + sizeof(U32), ofsdstnextdata));
Call(BufferCopyIFD(pbsrc, cbsrc, ofsEXIFIFD, endian, pbdst, cbdst, &ofsdstnextdata));
}
if ( ofsGPSInfoIFDEntry != 0 )
{
ofsdstnextdata += ( ofsdstnextdata & 1 );
Call(setbfdw(pbdst, cbdst, ofsGPSInfoIFDEntry + 2 * sizeof(U16) + sizeof(U32), ofsdstnextdata));
Call(BufferCopyIFD(pbsrc, cbsrc, ofsGPSInfoIFD, endian, pbdst, cbdst, &ofsdstnextdata));
}
if ( ofsInteroperabilityIFDEntry != 0 )
{
ofsdstnextdata += ( ofsdstnextdata & 1 );
Call(setbfdw(pbdst, cbdst, ofsInteroperabilityIFDEntry + 2 * sizeof(U16) + sizeof(U32), ofsdstnextdata));
Call(BufferCopyIFD(pbsrc, cbsrc, ofsInteroperabilityIFD, endian, pbdst, cbdst, &ofsdstnextdata));
}
*pofsdst = ofsdstnextdata;
Cleanup:
return err;
}
// src IFD copied to dst IFD with any nested IFD's
// src IFD is little endian, arbitrary data arrangement
// dst IFD is little endian, data arranged in tag order
// dst IFD tags are ordered the same as src IFD so src IFD tags must be in order
ERR StreamCopyIFD(struct WMPStream* pWS, U32 ofssrc, U8* pbdst, U32 cbdst, U32* pofsdst)
{
ERR err = WMP_errSuccess;
size_t offCurPos = 0;
Bool GetPosOK = FALSE;
U16 cDir;
U16 i;
U16 ofsEXIFIFDEntry = 0;
U16 ofsGPSInfoIFDEntry = 0;
U16 ofsInteroperabilityIFDEntry = 0;
U32 ofsEXIFIFD = 0;
U32 ofsGPSInfoIFD = 0;
U32 ofsInteroperabilityIFD = 0;
U32 ofsdstnextdata;
U32 ofsdst = *pofsdst;
U32 ofssrcdir;
U32 ofsdstdir;
U32 ofsnextifd;
Call(pWS->GetPos(pWS, &offCurPos));
GetPosOK = TRUE;
Call(GetUShort(pWS, ofssrc, &cDir));
Call(setbfw(pbdst, cbdst, ofsdst, cDir));
ofsnextifd = ofsdst + sizeof(U16) + SizeofIFDEntry * cDir;
ofsdstnextdata = ofsnextifd + sizeof(U32);
ofssrcdir = ofssrc + sizeof(U16);
ofsdstdir = ofsdst + sizeof(U16);
for ( i = 0; i < cDir; i++ )
{
U16 tag;
U16 type;
U32 count;
U32 value;
U32 size;
Call(GetUShort(pWS, ofssrcdir, &tag));
Call(setbfw(pbdst, cbdst, ofsdstdir, tag));
Call(GetUShort(pWS, ofssrcdir + sizeof(U16), &type));
Call(setbfw(pbdst, cbdst, ofsdstdir + sizeof(U16), type));
Call(GetULong(pWS, ofssrcdir + 2 * sizeof(U16), &count));
Call(setbfdw(pbdst, cbdst, ofsdstdir + 2 * sizeof(U16), count));
Call(GetULong(pWS, ofssrcdir + 2 * sizeof(U16) + sizeof(U32), &value));
Call(setbfdw(pbdst, cbdst, ofsdstdir + 2 * sizeof(U16) + sizeof(U32), 0));
FailIf(type == 0 || type >= sizeof(IFDEntryTypeSizes) / sizeof(IFDEntryTypeSizes[0]), WMP_errFail);
if ( tag == WMP_tagEXIFMetadata )
{
ofsEXIFIFDEntry = (U16) ofsdstdir;
ofsEXIFIFD = value;
}
else if ( tag == WMP_tagGPSInfoMetadata )
{
ofsGPSInfoIFDEntry = (U16) ofsdstdir;
ofsGPSInfoIFD = value;
}
else if ( tag == WMP_tagInteroperabilityIFD )
{
ofsInteroperabilityIFDEntry = (U16) ofsdstdir;
ofsInteroperabilityIFD = value;
}
else
{
U32 ofsdstdata = ofsdstdir + 2 * sizeof(U16) + sizeof(U32);
U32 ofssrcdata = ofssrcdir + 2 * sizeof(U16) + sizeof(U32);
size = count * IFDEntryTypeSizes[type];
if ( size > 4 )
{
ofssrcdata = value;
Call(setbfdw(pbdst, cbdst, ofsdstdata, ofsdstnextdata));
ofsdstdata = ofsdstnextdata;
ofsdstnextdata += size;
}
FailIf(ofsdstdata + size > cbdst, WMP_errBufferOverflow);
Call(pWS->SetPos(pWS, ofssrcdata));
Call(pWS->Read(pWS, &pbdst[ofsdstdata], size));
}
ofssrcdir += SizeofIFDEntry;
ofsdstdir += SizeofIFDEntry;
}
Call(setbfdw(pbdst, cbdst, ofsnextifd, 0)); // no nextIFD
if ( ofsEXIFIFDEntry != 0 )
{
ofsdstnextdata += ( ofsdstnextdata & 1 );
Call(setbfdw(pbdst, cbdst, ofsEXIFIFDEntry + 2 * sizeof(U16) + sizeof(U32), ofsdstnextdata));
Call(StreamCopyIFD(pWS, ofsEXIFIFD, pbdst, cbdst, &ofsdstnextdata));
}
if ( ofsGPSInfoIFDEntry != 0 )
{
ofsdstnextdata += ( ofsdstnextdata & 1 );
Call(setbfdw(pbdst, cbdst, ofsGPSInfoIFDEntry + 2 * sizeof(U16) + sizeof(U32), ofsdstnextdata));
Call(StreamCopyIFD(pWS, ofsGPSInfoIFD, pbdst, cbdst, &ofsdstnextdata));
}
if ( ofsInteroperabilityIFDEntry != 0 )
{
ofsdstnextdata += ( ofsdstnextdata & 1 );
Call(setbfdw(pbdst, cbdst, ofsInteroperabilityIFDEntry + 2 * sizeof(U16) + sizeof(U32), ofsdstnextdata));
Call(StreamCopyIFD(pWS, ofsInteroperabilityIFD, pbdst, cbdst, &ofsdstnextdata));
}
*pofsdst = ofsdstnextdata;
Cleanup:
if ( GetPosOK )
Call(pWS->SetPos(pWS, offCurPos));
return err;
}
//================================================================
ERR GetUShort(
__in_ecount(1) struct WMPStream* pWS,
size_t offPos,
__out_ecount(1) U16* puValue)
{
ERR err = WMP_errSuccess;
U8 cVal;
Call(pWS->SetPos(pWS, offPos));
Call(pWS->Read(pWS, &cVal, sizeof(cVal)));
puValue[0] = (U16) cVal;
Call(pWS->Read(pWS, &cVal, sizeof(cVal)));
puValue[0] += ((U16) cVal) << 8;
Cleanup:
return err;
}
ERR PutUShort(
__in_ecount(1) struct WMPStream* pWS,
size_t offPos,
U16 uValue)
{
ERR err = WMP_errSuccess;
U8 cVal = (U8) uValue;
Call(pWS->SetPos(pWS, offPos));
Call(pWS->Write(pWS, &cVal, sizeof(cVal)));
cVal = (U8) (uValue >> 8);
Call(pWS->Write(pWS, &cVal, sizeof(cVal)));
Cleanup:
return err;
}
ERR GetULong(
__in_ecount(1) struct WMPStream* pWS,
size_t offPos,
__out_ecount(1) U32* puValue)
{
ERR err = WMP_errSuccess;
U8 cVal;
Call(pWS->SetPos(pWS, offPos));
Call(pWS->Read(pWS, &cVal, sizeof(cVal)));
puValue[0] = (U32) cVal;
Call(pWS->Read(pWS, &cVal, sizeof(cVal)));
puValue[0] += ((U32) cVal) << 8;
Call(pWS->Read(pWS, &cVal, sizeof(cVal)));
puValue[0] += ((U32) cVal) << 16;
Call(pWS->Read(pWS, &cVal, sizeof(cVal)));
puValue[0] += ((U32) cVal) << 24;
Cleanup:
return err;
}
ERR PutULong(
__in_ecount(1) struct WMPStream* pWS,
size_t offPos,
U32 uValue)
{
ERR err = WMP_errSuccess;
U8 cVal = (U8) uValue;
Call(pWS->SetPos(pWS, offPos));
Call(pWS->Write(pWS, &cVal, sizeof(cVal)));
cVal = (U8) (uValue >> 8);
Call(pWS->Write(pWS, &cVal, sizeof(cVal)));
cVal = (U8) (uValue >> 16);
Call(pWS->Write(pWS, &cVal, sizeof(cVal)));
cVal = (U8) (uValue >> 24);
Call(pWS->Write(pWS, &cVal, sizeof(cVal)));
Cleanup:
return err;
}
ERR ReadBinaryData(__in_ecount(1) struct WMPStream* pWS,
const __in_win U32 uCount,
const __in_win U32 uValue,
U8 **ppbData)
{
ERR err = WMP_errSuccess;
U8 *pbData = NULL;
Call(PKAlloc((void **) &pbData, uCount + 2)); // Allocate buffer to store data with space for an added ascii or unicode null
if (uCount <= 4)
{
unsigned int i;
for (i = 0; i < uCount; i++)
pbData[i] = ((U8*)&uValue)[i]; // Copy least sig bytes - we assume 'II' type TIFF files
}
else
{
size_t offPosPrev;
Call(pWS->GetPos(pWS, &offPosPrev));
Call(pWS->SetPos(pWS, uValue));
Call(pWS->Read(pWS, pbData, uCount));
Call(pWS->SetPos(pWS, offPosPrev));
}
*ppbData = pbData;
Cleanup:
if (Failed(err))
{
if (pbData)
PKFree((void **) &pbData);
}
return err;
}
ERR ReadPropvar(__in_ecount(1) struct WMPStream* pWS,
const __in_win U16 uType,
const __in_win U32 uCount,
const __in_win U32 uValue,
__out_win DPKPROPVARIANT *pvar)
{
ERR err = WMP_errSuccess;
// U8 *pbData = NULL;
memset(pvar, 0, sizeof(*pvar));
if (uCount == 0)
goto Cleanup; // Nothing to read in here
switch (uType)
{
case WMP_typASCII:
pvar->vt = DPKVT_LPSTR;
Call(ReadBinaryData(pWS, uCount, uValue, (U8 **) &pvar->VT.pszVal));
assert(0 == pvar->VT.pszVal[uCount - 1]); // Check that it's null-terminated
// make sure (ReadBinaryData allocated uCount + 2 so this and unicode can have forced nulls)
pvar->VT.pszVal[uCount] = 0;
break;
case WMP_typBYTE:
case WMP_typUNDEFINED:
// Return as regular C array rather than safearray, as this type is sometimes
// used to convey unicode (which does not require a count field). Caller knows
// uCount and can convert to safearray if necessary.
pvar->vt = (DPKVT_BYREF | DPKVT_UI1);
Call(ReadBinaryData(pWS, uCount, uValue, &pvar->VT.pbVal));
break;
case WMP_typSHORT:
if (1 == uCount)
{
pvar->vt = DPKVT_UI2;
pvar->VT.uiVal = (U16)(uValue & 0x0000FFFF);
}
else if (2 == uCount)
{
pvar->vt = DPKVT_UI4;
pvar->VT.ulVal = uValue;
}
else
{
assert(FALSE); // NYI
FailIf(TRUE, WMP_errNotYetImplemented);
}
break;
default:
assert(FALSE); // Unhandled type
FailIf(TRUE, WMP_errNotYetImplemented);
break;
}
Cleanup:
return err;
}
ERR WriteWmpDE(
__in_ecount(1) struct WMPStream* pWS,
size_t *pOffPos,
const __in_ecount(1) WmpDE* pDE,
const U8 *pbData,
U32 *pcbDataWrittenToOffset)
{
ERR err = WMP_errSuccess;
size_t offPos = *pOffPos;
assert(-1 != pDE->uCount);
assert(-1 != pDE->uValueOrOffset);
if (pcbDataWrittenToOffset)
{
assert(pbData); // Makes no sense to provide this arg without pbData
*pcbDataWrittenToOffset = 0;
}
Call(PutUShort(pWS, offPos, pDE->uTag)); offPos += 2;
Call(PutUShort(pWS, offPos, pDE->uType)); offPos += 2;
Call(PutULong(pWS, offPos, pDE->uCount)); offPos += 4;
switch (pDE->uType)
{
case WMP_typASCII:
case WMP_typUNDEFINED:
case WMP_typBYTE:
if (pDE->uCount <= 4)
{
U8 pad[4] = {0};
Call(pWS->SetPos(pWS, offPos));
if (NULL == pbData)
pbData = (U8*)&pDE->uValueOrOffset;
Call(pWS->Write(pWS, pbData, pDE->uCount));
Call(pWS->Write(pWS, pad, 4 - pDE->uCount)); offPos += 4;
}
else
{
Call(PutULong(pWS, offPos, pDE->uValueOrOffset)); offPos += 4;
// Write the data if requested to do so
if (pbData)
{
Call(pWS->SetPos(pWS, pDE->uValueOrOffset));
Call(pWS->Write(pWS, pbData, pDE->uCount));
Call(pWS->SetPos(pWS, offPos));
*pcbDataWrittenToOffset = pDE->uCount;
}
}
break;
case WMP_typSHORT:
if (pDE->uCount <= 2)
{
U16 uiShrt1 = 0;
U16 uiShrt2 = 0;
if (NULL == pbData)
pbData = (U8*)&pDE->uValueOrOffset;
if (pDE->uCount > 0)
uiShrt1 = *((U16*)pbData);
if (pDE->uCount > 1)
{
assert(FALSE); // Untested - remove this assert after this has been tested
uiShrt2 = *(U16*)(pbData + 2);
}
Call(PutUShort(pWS, offPos, uiShrt1)); offPos += 2;
Call(PutUShort(pWS, offPos, uiShrt2)); offPos += 2;
}
else
{
assert(FALSE); // Untested - remove this assert after this has been tested
Call(PutULong(pWS, offPos, pDE->uValueOrOffset)); offPos += 4;
// Write the data if requested to do so
if (pbData)
{
U32 i;
Call(pWS->SetPos(pWS, pDE->uValueOrOffset));
for (i = 0; i < pDE->uCount; i++)
{
const U16 uiShort = *(U16*)(pbData + i*sizeof(U16));
Call(PutUShort(pWS, offPos, uiShort)); // Write one at a time for endian purposes - but inefficient
}
Call(pWS->SetPos(pWS, offPos));
*pcbDataWrittenToOffset = pDE->uCount * sizeof(U16);
}
}
break;
case WMP_typFLOAT:
case WMP_typLONG:
if (pDE->uCount <= 1)
{
if (NULL == pbData)
pbData = (U8*)&pDE->uValueOrOffset;
Call(PutULong(pWS, offPos, *(U32*)pbData)); offPos += 4;
}
else
{
assert(FALSE); // Untested - remove this assert after this has been tested
Call(PutULong(pWS, offPos, pDE->uValueOrOffset)); offPos += 4;
// Write the data if requested to do so
if (pbData)
{
U32 i;
Call(pWS->SetPos(pWS, pDE->uValueOrOffset));
for (i = 0; i < pDE->uCount; i++)
{
const U32 uLong = *(U32*)(pbData + i*sizeof(U32));
Call(PutULong(pWS, offPos, uLong)); // Write one at a time for endian purposes - but inefficient
}
Call(pWS->SetPos(pWS, offPos));
*pcbDataWrittenToOffset = pDE->uCount * sizeof(U32);
}
}
break;
default:
assert(FALSE); // Alert the programmer
Call(WMP_errInvalidParameter);
break;
}
Cleanup:
*pOffPos = offPos;
return err;
}

258
jxrlib/jxrgluelib/JXRMeta.h
View file

@ -1,258 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#pragma once
#include <windowsmediaphoto.h>
#ifndef WIN32
#include <wmspecstring.h>
#endif
#ifndef UNREFERENCED_PARAMETER
#define UNREFERENCED_PARAMETER(P) { (P) = (P); }
#endif /*UNREFERENCED_PARAMETER*/
//================================================================
// Container
//================================================================
// Keep these in sort order so that we can easily confirm we are outputting tags in ascending order
#define WMP_tagNull 0
#define WMP_tagDocumentName 0x010d // Descriptive metadata tag
#define WMP_tagImageDescription 0x010e // Descriptive metadata tag
#define WMP_tagCameraMake 0x010f // Descriptive metadata tag
#define WMP_tagCameraModel 0x0110 // Descriptive metadata tag
#define WMP_tagPageName 0x011d // Descriptive metadata tag
#define WMP_tagPageNumber 0x0129 // Descriptive metadata tag
#define WMP_tagSoftware 0x0131 // Descriptive metadata tag
#define WMP_tagDateTime 0x0132 // Descriptive metadata tag
#define WMP_tagArtist 0x013b // Descriptive metadata tag
#define WMP_tagHostComputer 0x013c // Descriptive metadata tag
#define WMP_tagXMPMetadata 0x02bc
#define WMP_tagRatingStars 0x4746 // Descriptive metadata tag
#define WMP_tagRatingValue 0x4749 // Descriptive metadata tag
#define WMP_tagCopyright 0x8298 // Descriptive metadata tag
#define WMP_tagEXIFMetadata 0x8769
#define WMP_tagGPSInfoMetadata 0x8825
#define WMP_tagIPTCNAAMetadata 0x83bb
#define WMP_tagPhotoshopMetadata 0x8649
#define WMP_tagInteroperabilityIFD 0xa005
#define WMP_tagIccProfile 0x8773 // Need to use same tag as TIFF!!
#define WMP_tagCaption 0x9c9b // Descriptive metadata tag
#define WMP_tagPixelFormat 0xbc01
#define WMP_tagTransformation 0xbc02
#define WMP_tagCompression 0xbc03
#define WMP_tagImageType 0xbc04
#define WMP_tagImageWidth 0xbc80
#define WMP_tagImageHeight 0xbc81
#define WMP_tagWidthResolution 0xbc82
#define WMP_tagHeightResolution 0xbc83
#define WMP_tagImageOffset 0xbcc0
#define WMP_tagImageByteCount 0xbcc1
#define WMP_tagAlphaOffset 0xbcc2
#define WMP_tagAlphaByteCount 0xbcc3
#define WMP_tagImageDataDiscard 0xbcc4
#define WMP_tagAlphaDataDiscard 0xbcc5
#define WMP_typBYTE 1
#define WMP_typASCII 2
#define WMP_typSHORT 3
#define WMP_typLONG 4
#define WMP_typRATIONAL 5
#define WMP_typSBYTE 6
#define WMP_typUNDEFINED 7
#define WMP_typSSHORT 8
#define WMP_typSLONG 9
#define WMP_typSRATIONAL 10
#define WMP_typFLOAT 11
#define WMP_typDOUBLE 12
#define WMP_valCompression 0xbc
#define WMP_valWMPhotoID WMP_valCompression
#ifdef WIN32
#define __in_win __in
#define __out_win __out
#endif
//================================================================
typedef enum
{
DPKVT_EMPTY = 0,
DPKVT_UI1 = 17,
DPKVT_UI2 = 18,
DPKVT_UI4 = 19,
DPKVT_LPSTR = 30,
DPKVT_LPWSTR = 31,
DPKVT_BYREF = 0x4000,
} DPKVARTYPE;
typedef struct DPKPROPVARIANT
{
DPKVARTYPE vt;
union
{
U8 bVal; // DPKVT_UI1
U16 uiVal; // DPKVT_UI2
U32 ulVal; // DPKVT_UI4
char *pszVal; // DPKVT_LPSTR
U16 *pwszVal; // DPKVT_LPWSTR
U8 *pbVal; // DPKVT_BYREF | DPKVT_UI1
} VT;
} DPKPROPVARIANT;
typedef struct DESCRIPTIVEMETADATA
{
DPKPROPVARIANT pvarImageDescription; // WMP_tagImageDescription
DPKPROPVARIANT pvarCameraMake; // WMP_tagCameraMake
DPKPROPVARIANT pvarCameraModel; // WMP_tagCameraModel
DPKPROPVARIANT pvarSoftware; // WMP_tagSoftware
DPKPROPVARIANT pvarDateTime; // WMP_tagDateTime
DPKPROPVARIANT pvarArtist; // WMP_tagArtist
DPKPROPVARIANT pvarCopyright; // WMP_tagCopyright
DPKPROPVARIANT pvarRatingStars; // WMP_tagRatingStars
DPKPROPVARIANT pvarRatingValue; // WMP_tagRatingValue
DPKPROPVARIANT pvarCaption; // WMP_tagCaption
DPKPROPVARIANT pvarDocumentName; // WMP_tagDocumentName
DPKPROPVARIANT pvarPageName; // WMP_tagPageName
DPKPROPVARIANT pvarPageNumber; // WMP_tagPageNumber
DPKPROPVARIANT pvarHostComputer; // WMP_tagHostComputer
} DESCRIPTIVEMETADATA;
typedef struct tagWmpDE
{
U16 uTag;
U16 uType;
U32 uCount;
U32 uValueOrOffset;
} WmpDE;
typedef struct tagWmpDEMisc
{
U32 uImageOffset;
U32 uImageByteCount;
U32 uAlphaOffset;
U32 uAlphaByteCount;
U32 uOffPixelFormat;
U32 uOffImageByteCount;
U32 uOffAlphaOffset;
U32 uOffAlphaByteCount;
U32 uColorProfileOffset;
U32 uColorProfileByteCount;
U32 uXMPMetadataOffset;
U32 uXMPMetadataByteCount;
U32 uEXIFMetadataOffset;
U32 uEXIFMetadataByteCount;
U32 uGPSInfoMetadataOffset;
U32 uGPSInfoMetadataByteCount;
U32 uIPTCNAAMetadataOffset;
U32 uIPTCNAAMetadataByteCount;
U32 uPhotoshopMetadataOffset;
U32 uPhotoshopMetadataByteCount;
U32 uDescMetadataOffset;
U32 uDescMetadataByteCount;
} WmpDEMisc;
//================================================================
EXTERN_C ERR GetUShort(
__in_ecount(1) struct WMPStream* pWS,
size_t offPos,
__out_ecount(1) U16* puValue
);
EXTERN_C ERR PutUShort(
__in_ecount(1) struct WMPStream* pWS,
size_t offPos,
U16 uValue
);
EXTERN_C ERR GetULong(
__in_ecount(1) struct WMPStream* pWS,
size_t offPos,
__out_ecount(1) U32* puValue
);
EXTERN_C ERR PutULong(
__in_ecount(1) struct WMPStream* pWS,
size_t offPos,
U32 uValue
);
EXTERN_C ERR WriteWmpDE(
__in_ecount(1) struct WMPStream* pWS,
size_t *pOffPos,
const __in_ecount(1) WmpDE* pDE,
const U8 *pbData,
U32 *pcbDataWrittenToOffset
);
EXTERN_C ERR ReadPropvar(__in_ecount(1) struct WMPStream* pWS,
const __in_win U16 uType,
const __in_win U32 uCount,
const __in_win U32 uValue,
__out_win DPKPROPVARIANT *pvar);
// read and write little endian words/dwords from a buffer on both big and little endian cpu's
// with full buffer overflow checking
#define WMP_INTEL_ENDIAN ('I')
EXTERN_C ERR getbfcpy(U8* pbdest, const U8* pb, size_t cb, size_t ofs, U32 n);
EXTERN_C ERR getbfw(const U8* pb, size_t cb, size_t ofs, U16* pw);
EXTERN_C ERR getbfdw(const U8* pb, size_t cb, size_t ofs, U32* pdw);
EXTERN_C ERR getbfwbig(const U8* pb, size_t cb, size_t ofs, U16* pw);
EXTERN_C ERR getbfdwbig(const U8* pb, size_t cb, size_t ofs, U32* pdw);
EXTERN_C ERR getbfwe(const U8* pb, size_t cb, size_t ofs, U16* pw, U8 endian);
EXTERN_C ERR getbfdwe(const U8* pb, size_t cb, size_t ofs, U32* pdw, U8 endian);
EXTERN_C ERR setbfcpy(U8* pb, size_t cb, size_t ofs, const U8* pbset, size_t cbset);
EXTERN_C ERR setbfw(U8* pb, size_t cb, size_t ofs, U16 dw);
EXTERN_C ERR setbfdw(U8* pb, size_t cb, size_t ofs, U32 dw);
EXTERN_C ERR setbfwbig(U8* pb, size_t cb, size_t ofs, U16 dw);
EXTERN_C ERR setbfdwbig(U8* pb, size_t cb, size_t ofs, U32 dw);
EXTERN_C ERR BufferCalcIFDSize(const U8* pb, size_t cb, U32 uIFDOfs, U8 endian, U32 *pcbifd);
EXTERN_C ERR StreamCalcIFDSize(struct WMPStream* pWS, U32 uIFDOfs, U32 *pcbifd);
EXTERN_C ERR BufferCopyIFD(const U8* pbsrc, U32 cbsrc, U32 ofssrc, U8 endian, U8* pbdest, U32 cbdest, U32* pofsdest);
EXTERN_C ERR StreamCopyIFD(struct WMPStream* pWS, U32 ofssrc, U8* pbdest, U32 cbdest, U32* pofsdest);

315
jxrlib/jxrtestlib/JXRTest.c
View file

@ -1,315 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#include <JXRTest.h>
//================================================================
const PKIID IID_PKImagePnmEncode = 102;
const PKIID IID_PKImageBmpEncode = 103;
const PKIID IID_PKImageTifEncode = 104;
const PKIID IID_PKImageHdrEncode = 105;
const PKIID IID_PKImageIyuvEncode = 106;
const PKIID IID_PKImageYuv422Encode = 107;
const PKIID IID_PKImageYuv444Encode = 108;
const PKIID IID_PKImageBmpDecode = 202;
const PKIID IID_PKImagePnmDecode = 203;
const PKIID IID_PKImageTifDecode = 204;
const PKIID IID_PKImageHdrDecode = 205;
const PKIID IID_PKImageIyuvDecode = 206;
const PKIID IID_PKImageYuv422Decode = 207;
const PKIID IID_PKImageYuv444Decode = 208;
//================================================================
// Misc supporting functions
//================================================================
extern int PKStrnicmp(const char* s1, const char* s2, size_t c);
//----------------------------------------------------------------
typedef struct tagPKIIDInfo
{
const char* szExt;
const PKIID* pIIDEnc;
const PKIID* pIIDDec;
} PKIIDInfo;
static ERR GetTestInfo(const char* szExt, const PKIIDInfo** ppInfo)
{
ERR err = WMP_errSuccess;
static PKIIDInfo iidInfo[] = {
{".bmp", &IID_PKImageBmpEncode, &IID_PKImageBmpDecode},
{".ppm", &IID_PKImagePnmEncode, &IID_PKImagePnmDecode},
{".pgm", &IID_PKImagePnmEncode, &IID_PKImagePnmDecode},
{".pnm", &IID_PKImagePnmEncode, &IID_PKImagePnmDecode},
{".pfm", &IID_PKImagePnmEncode, &IID_PKImagePnmDecode},
{".tif", &IID_PKImageTifEncode, &IID_PKImageTifDecode},
{".hdr", &IID_PKImageHdrEncode, &IID_PKImageHdrDecode},
{".iyuv", &IID_PKImageIyuvEncode, &IID_PKImageIyuvDecode},
{".yuv422", &IID_PKImageYuv422Encode, &IID_PKImageYuv422Decode},
{".yuv444", &IID_PKImageYuv444Encode, &IID_PKImageYuv444Decode},
};
size_t i = 0;
*ppInfo = NULL;
for (i = 0; i < sizeof2(iidInfo); ++i)
{
if (0 == PKStrnicmp(szExt, iidInfo[i].szExt, strlen(iidInfo[i].szExt)))
{
*ppInfo = &iidInfo[i];
goto Cleanup;
}
}
Call(WMP_errUnsupportedFormat);
Cleanup:
return err;
}
ERR GetTestEncodeIID(const char* szExt, const PKIID** ppIID)
{
ERR err = WMP_errSuccess;
const PKIIDInfo* pInfo = NULL;
Call(GetTestInfo(szExt, &pInfo));
*ppIID = pInfo->pIIDEnc;
Cleanup:
return err;
}
ERR GetTestDecodeIID(const char* szExt, const PKIID** ppIID)
{
ERR err = WMP_errSuccess;
const PKIIDInfo* pInfo = NULL;
Call(GetTestInfo(szExt, &pInfo));
*ppIID = pInfo->pIIDDec;
Cleanup:
return err;
}
//================================================================
// PKTestFactory
//================================================================
ERR PKTestFactory_CreateCodec(const PKIID* iid, void** ppv)
{
ERR err = WMP_errSuccess;
if (IID_PKImageBmpEncode == *iid)
{
Call(PKImageEncode_Create_BMP((PKImageEncode**)ppv));
}
else if (IID_PKImagePnmEncode == *iid)
{
Call(PKImageEncode_Create_PNM((PKImageEncode**)ppv));
}
else if (IID_PKImageTifEncode == *iid)
{
Call(PKImageEncode_Create_TIF((PKImageEncode**)ppv));
}
else if (IID_PKImageHdrEncode == *iid)
{
Call(PKImageEncode_Create_HDR((PKImageEncode**)ppv));
}
else if (IID_PKImageIyuvEncode == *iid)
{
Call(PKImageEncode_Create_IYUV((PKImageEncode**)ppv));
}
else if (IID_PKImageYuv422Encode == *iid)
{
Call(PKImageEncode_Create_YUV422((PKImageEncode**)ppv));
}
else if (IID_PKImageYuv444Encode == *iid)
{
Call(PKImageEncode_Create_YUV444((PKImageEncode**)ppv));
}
else if (IID_PKImageBmpDecode == *iid)
{
Call(PKImageDecode_Create_BMP((PKTestDecode**)ppv));
}
else if (IID_PKImagePnmDecode == *iid)
{
Call(PKImageDecode_Create_PNM((PKTestDecode**)ppv));
}
else if (IID_PKImageTifDecode == *iid)
{
Call(PKImageDecode_Create_TIF((PKTestDecode**)ppv));
}
else if (IID_PKImageHdrDecode == *iid)
{
Call(PKImageDecode_Create_HDR((PKTestDecode**)ppv));
}
else if (IID_PKImageIyuvDecode == *iid)
{
Call(PKImageDecode_Create_IYUV((PKTestDecode**)ppv));
}
else if (IID_PKImageYuv422Decode == *iid)
{
Call(PKImageDecode_Create_YUV422((PKTestDecode**)ppv));
}
else if (IID_PKImageYuv444Decode == *iid)
{
Call(PKImageDecode_Create_YUV444((PKTestDecode**)ppv));
}
else
{
Call(WMP_errUnsupportedFormat);
}
Cleanup:
return err;
}
ERR PKTestFactory_CreateDecoderFromFile(const char* szFilename, PKImageDecode** ppDecoder)
{
ERR err = WMP_errSuccess;
char *pExt = NULL;
PKIID* pIID = NULL;
struct WMPStream* pStream = NULL;
PKImageDecode* pDecoder = NULL;
// get file extension
pExt = strrchr(szFilename, '.');
FailIf(NULL == pExt, WMP_errUnsupportedFormat);
// get decode PKIID
Call(GetTestDecodeIID(pExt, &pIID));
// create stream
Call(CreateWS_File(&pStream, szFilename, "rb"));
// Create decoder
Call(PKTestFactory_CreateCodec(pIID, ppDecoder));
pDecoder = *ppDecoder;
// attach stream to decoder
Call(pDecoder->Initialize(pDecoder, pStream));
pDecoder->fStreamOwner = !0;
Cleanup:
return err;
}
ERR PKCreateTestFactory(PKCodecFactory** ppCFactory, U32 uVersion)
{
ERR err = WMP_errSuccess;
PKCodecFactory* pCFactory = NULL;
UNREFERENCED_PARAMETER( uVersion );
Call(PKAlloc(ppCFactory, sizeof(**ppCFactory)));
pCFactory = *ppCFactory;
pCFactory->CreateCodec = PKTestFactory_CreateCodec;
pCFactory->CreateDecoderFromFile = PKTestFactory_CreateDecoderFromFile;
pCFactory->CreateFormatConverter = PKCodecFactory_CreateFormatConverter;
pCFactory->Release = PKCreateCodecFactory_Release;
Cleanup:
return err;
}
//================================================================
// PKTestDecode
//================================================================
ERR PKTestDecode_Initialize(
PKTestDecode* pID,
struct WMPStream* pStream)
{
ERR err = WMP_errSuccess;
pID->pStream = pStream;
pID->guidPixFormat = GUID_PKPixelFormatDontCare;
pID->fResX = 96;
pID->fResY = 96;
pID->cFrame = 1;
Call(pID->pStream->GetPos(pID->pStream, &pID->offStart));
Cleanup:
return WMP_errSuccess;
}
ERR PKTestDecode_Copy(
PKTestDecode* pID,
const PKRect* pRect,
U8* pb,
U32 cbStride)
{
UNREFERENCED_PARAMETER( pID );
UNREFERENCED_PARAMETER( pRect );
UNREFERENCED_PARAMETER( pb );
UNREFERENCED_PARAMETER( cbStride );
return WMP_errAbstractMethod;
}
ERR PKTestDecode_Release(
PKTestDecode** ppID)
{
PKTestDecode* pID = *ppID;
pID->fStreamOwner && pID->pStream->Close(&pID->pStream);
return PKFree(ppID);
}
ERR PKTestDecode_Create(
PKTestDecode** ppID)
{
ERR err = WMP_errSuccess;
PKTestDecode* pID = NULL;
Call(PKAlloc(ppID, sizeof(**ppID)));
pID = *ppID;
pID->Initialize = PKTestDecode_Initialize;
pID->GetPixelFormat = PKImageDecode_GetPixelFormat;
pID->GetSize = PKImageDecode_GetSize;
pID->GetResolution = PKImageDecode_GetResolution;
pID->GetColorContext = PKImageDecode_GetColorContext;
pID->GetDescriptiveMetadata = PKImageDecode_GetDescriptiveMetadata;
pID->Copy = PKTestDecode_Copy;
pID->GetFrameCount = PKImageDecode_GetFrameCount;
pID->SelectFrame = PKImageDecode_SelectFrame;
pID->Release = PKTestDecode_Release;
Cleanup:
return err;
}

164
jxrlib/jxrtestlib/JXRTest.h
View file

@ -1,164 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
#include <JXRGlue.h>
EXTERN_C const PKIID IID_PKImageBmpEncode;
EXTERN_C const PKIID IID_PKImagePnmEncode;
EXTERN_C const PKIID IID_PKImageTifEncode;
EXTERN_C const PKIID IID_PKImageBmpDecode;
EXTERN_C const PKIID IID_PKImagePnmDecode;
EXTERN_C const PKIID IID_PKImageTifDecode;
//----------------------------------------------------------------
ERR GetTestEncodeIID(const char* szExt, const PKIID** ppIID);
ERR GetTestDecodeIID(const char* szExt, const PKIID** ppIID);
//================================================================
#ifdef __ANSI__
#define PKTestDecode struct tagPKTestDecode
#else // __ANSI__
typedef struct tagPKTestDecode PKTestDecode;
#endif // __ANSI__
//================================================================
//----------------------------------------------------------------
ERR PKTestFactory_CreateCodec(const PKIID* iid, void** ppv);
EXTERN_C ERR PKCreateTestFactory(PKCodecFactory**, U32);
//----------------------------------------------------------------
ERR PKImageEncode_Create_BMP(PKImageEncode** ppIE);
ERR PKImageEncode_Create_PNM(PKImageEncode** ppIE);
ERR PKImageEncode_Create_TIF(PKImageEncode** ppIE);
ERR PKImageEncode_Create_HDR(PKImageEncode** ppIE);
ERR PKImageEncode_Create_IYUV(PKImageEncode** ppIE);
ERR PKImageEncode_Create_YUV422(PKImageEncode** ppIE);
ERR PKImageEncode_Create_YUV444(PKImageEncode** ppIE);
//================================================================
typedef struct tagPKTestDecode
{
ERR (*Initialize)(PKTestDecode*, struct WMPStream* pStream);
ERR (*GetPixelFormat)(PKImageDecode*, PKPixelFormatGUID*);
ERR (*GetSize)(PKImageDecode*, I32*, I32*);
ERR (*GetResolution)(PKImageDecode*, Float*, Float*);
ERR (*GetColorContext)(PKImageDecode *pID, U8 *pbColorContext,
U32 *pcbColorContext);
ERR (*GetDescriptiveMetadata)(PKImageDecode *pIE,
DESCRIPTIVEMETADATA *pDescMetadata);
ERR (*GetRawStream)(PKImageDecode*, struct WMPStream**);
ERR (*Copy)(PKTestDecode*, const PKRect*, U8*, U32);
ERR (*GetFrameCount)(PKImageDecode*, U32*);
ERR (*SelectFrame)(PKImageDecode*, U32);
ERR (*Release)(PKTestDecode**);
struct WMPStream* pStream;
Bool fStreamOwner;
size_t offStart;
PKPixelFormatGUID guidPixFormat;
U32 uWidth;
U32 uHeight;
U32 idxCurrentLine;
Float fResX;
Float fResY;
U32 cFrame;
union
{
struct
{
size_t offPixel;
size_t cbPixel;
} BMP;
struct
{
size_t offPixel;
size_t cbPixel;
} HDR;
struct
{
size_t offPixel;
} PNM;
struct
{
U32 uRowsPerStrip;
U32* uStripOffsets;
U32* uStripByteCounts;
U32 uInterpretation;
U32 uSamplePerPixel;
U32 uBitsPerSample;
U32 uSampleFormat;
U32 uExtraSamples;
U16 uResolutionUnit;
Float fResX;
Float fResY;
Bool fLittleEndian;
} TIF;
} EXT;
#ifdef __ANSI__
#undef PKTestDecode
#endif // __ANSI__
} PKTestDecode;
//----------------------------------------------------------------
ERR PKImageDecode_Create_BMP(PKTestDecode** ppID);
ERR PKImageDecode_Create_PNM(PKTestDecode** ppID);
ERR PKImageDecode_Create_TIF(PKTestDecode** ppID);
ERR PKImageDecode_Create_HDR(PKTestDecode** ppID);
ERR PKImageDecode_Create_IYUV(PKTestDecode** ppID);
ERR PKImageDecode_Create_YUV422(PKTestDecode** ppID);
ERR PKImageDecode_Create_YUV444(PKTestDecode** ppID);
ERR PKTestDecode_Initialize(PKTestDecode* pID, struct WMPStream* pStream);
ERR PKTestDecode_Copy(PKTestDecode* pID, const PKRect* pRect, U8* pb, U32 cbStride);
ERR PKTestDecode_Release(PKTestDecode** ppID);
ERR PKTestDecode_Create(PKTestDecode** ppID);
#ifdef __cplusplus
} // extern "C"
#endif

401
jxrlib/jxrtestlib/JXRTestBmp.c
View file

@ -1,401 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#include <stdlib.h>
#include <string.h>
#include <JXRTest.h>
#pragma pack(push, 1)
#define BI_RGB 0
#define BI_BITFIELDS 3
#define BI_RGB555_MASK_B 0x001F
#define BI_RGB555_MASK_G 0x03E0
#define BI_RGB555_MASK_R 0x7C00
#define BI_RGB565_MASK_B 0x001F
#define BI_RGB565_MASK_G 0x07E0
#define BI_RGB565_MASK_R 0xF800
#define BI_RGB101010_MASK_B 0x000003FF
#define BI_RGB101010_MASK_G 0x000FFC00
#define BI_RGB101010_MASK_R 0x3FF00000
typedef struct tagBITMAPFILEHEADER {
U8 szBM[2];
U32 uSize;
U16 reserved1;
U16 reserved2;
U32 uOffBits;
} BITMAPFILEHEADER, *PBITMAPFILEHEADER;
typedef struct tagBITMAPINFOHEADER{
U32 uSize;
I32 iWidth;
I32 iHeight;
I16 iPlanes;
I16 iBitCount;
U32 uCompression;
U32 uImageSize;
I32 iPelsPerMeterX;
I32 iPelsPerMeterY;
U32 uColorUsed;
U32 uColorImportant;
} BITMAPINFOHEADER, *PBITMAPINFOHEADER;
typedef struct tagBITMAPINFOHEADEREXT{
U32 uA;
U32 uB;
U32 uC;
U32 uD;
} BITMAPINFOHEADEREXT, *PBITMAPINFOHEADEREXT;
#pragma pack(pop)
//================================================================
// PKImageEncode_BMP
//================================================================
ERR WriteBMPHeader(
PKImageEncode* pIE)
{
ERR err = WMP_errSuccess;
static U32 rguColorTable[256] = {0};
size_t cbColorTable = 0;
size_t cbLineS = 0;
U32 i = 0;
struct WMPStream* pS = pIE->pStream;
BITMAPFILEHEADER bmpFH = { 0, };
BITMAPINFOHEADER bmpIH = {sizeof(bmpIH), 0, };
bmpFH.szBM[0] = 'B';
bmpFH.szBM[1] = 'M';
if (IsEqualGUID(&GUID_PKPixelFormat24bppRGB, &pIE->guidPixFormat) || IsEqualGUID(&GUID_PKPixelFormat24bppBGR, &pIE->guidPixFormat))
{
pIE->cbPixel = 3;
cbColorTable = 0;
}
else if (IsEqualGUID(&GUID_PKPixelFormat32bppBGRA, &pIE->guidPixFormat)
|| IsEqualGUID(&GUID_PKPixelFormat32bppBGR, &pIE->guidPixFormat)
|| IsEqualGUID(&GUID_PKPixelFormat32bppPBGRA, &pIE->guidPixFormat))
{
pIE->cbPixel = 4;
cbColorTable = 0;
}
else if (IsEqualGUID(&GUID_PKPixelFormat8bppGray, &pIE->guidPixFormat))
{
pIE->cbPixel = 1;
cbColorTable = sizeof(rguColorTable);
for (i = 0; i < sizeof2(rguColorTable); ++i)
{
rguColorTable[i] = i | (i << 8) | (i << 16);
}
}
else if (IsEqualGUID(&GUID_PKPixelFormat16bppRGB555, &pIE->guidPixFormat))
{
pIE->cbPixel = 2;
bmpIH.uCompression = BI_BITFIELDS;
cbColorTable = sizeof(rguColorTable[0]) * 3;
rguColorTable[0] = BI_RGB555_MASK_R;
rguColorTable[1] = BI_RGB555_MASK_G;
rguColorTable[2] = BI_RGB555_MASK_B;
}
else if (IsEqualGUID(&GUID_PKPixelFormat16bppRGB565, &pIE->guidPixFormat))
{
pIE->cbPixel = 2;
bmpIH.uCompression = BI_BITFIELDS;
cbColorTable = sizeof(rguColorTable[0]) * 3;
rguColorTable[0] = BI_RGB565_MASK_R;
rguColorTable[1] = BI_RGB565_MASK_G;
rguColorTable[2] = BI_RGB565_MASK_B;
}
else if (IsEqualGUID(&GUID_PKPixelFormat32bppRGB101010, &pIE->guidPixFormat))
{
pIE->cbPixel = 4;
bmpIH.uCompression = BI_BITFIELDS;
cbColorTable = sizeof(rguColorTable[0]) * 3;
rguColorTable[0] = BI_RGB101010_MASK_R;
rguColorTable[1] = BI_RGB101010_MASK_G;
rguColorTable[2] = BI_RGB101010_MASK_B;
}
else
Call(WMP_errUnsupportedFormat);
cbLineS = (pIE->cbPixel * pIE->uWidth + 3) / 4 * 4;
bmpFH.uOffBits = (U32)(sizeof(bmpFH) + sizeof(bmpIH) + cbColorTable);
bmpFH.uSize = (U32)(bmpFH.uOffBits + cbLineS * pIE->uHeight);
bmpIH.iWidth = pIE->uWidth;
bmpIH.iHeight = pIE->uHeight;
bmpIH.iPlanes = 1;
bmpIH.iBitCount = (I16)(8 * pIE->cbPixel);
bmpIH.uImageSize = (U32)(cbLineS * pIE->uHeight);
bmpIH.iPelsPerMeterX = (I32)(pIE->fResX * 39.37);
bmpIH.iPelsPerMeterY = (I32)(pIE->fResY * 39.37);
Call(pS->Write(pS, &bmpFH, sizeof(bmpFH)));
Call(pS->Write(pS, &bmpIH, sizeof(bmpIH)));
Call(pS->Write(pS, rguColorTable, cbColorTable));
pIE->offPixel = pIE->offStart + bmpFH.uOffBits;
pIE->fHeaderDone = !FALSE;
Cleanup:
return err;
}
ERR PKImageEncode_WritePixels_BMP(
PKImageEncode* pIE,
U32 cLine,
U8* pbPixel,
U32 cbStride)
{
ERR err = WMP_errSuccess;
struct WMPStream* pS = pIE->pStream;
size_t cbLineM = 0, cbLineS = 0;
I32 i = 0;
static U8 pPadding[4] = {0};
// header
if (!pIE->fHeaderDone)
{
// WriteBMPHeader() also inits this object
Call(WriteBMPHeader(pIE));
}
// body
// calculate line size in memory and in stream
cbLineM = pIE->cbPixel * pIE->uWidth;
cbLineS = (cbLineM + 3) / 4 * 4;
//FailIf(pRect->X < 0 || pID->uWidth <= pRect->X, WMP_errInvalidParameter);
//FailIf(pRect->Y < 0 || pID->uHeight <= pRect->Y, WMP_errInvalidParameter);
//FailIf(pRect->Width < 0 || pID->uWidth < pRect->X + pRect->Width, WMP_errInvalidParameter);
//FailIf(pRect->Height < 0 || pID->uHeight < pRect->Y + pRect->Height, WMP_errInvalidParameter);
FailIf(cbStride < cbLineM, WMP_errInvalidParameter);
for (i = cLine - 1; 0 <= i; --i)
{
size_t offM = cbStride * i;
size_t offS = cbLineS * (pIE->uHeight - (pIE->idxCurrentLine + i + 1));
Call(pS->SetPos(pS, pIE->offPixel + offS));
Call(pS->Write(pS, pbPixel + offM, cbLineM));
}
Call(pS->Write(pS, pPadding, (cbLineS - cbLineM)));
pIE->idxCurrentLine += cLine;
Cleanup:
return err;
}
ERR PKImageEncode_Create_BMP(
PKImageEncode** ppIE)
{
ERR err = WMP_errSuccess;
PKImageEncode* pIE = NULL;
Call(PKImageEncode_Create(ppIE));
pIE = *ppIE;
pIE->WritePixels = PKImageEncode_WritePixels_BMP;
Cleanup:
return err;
}
//================================================================
// PKImageDecode_BMP
//================================================================
ERR ParseBMPHeader(
PKTestDecode* pID,
struct WMPStream* pWS)
{
ERR err = WMP_errSuccess;
BITMAPFILEHEADER bmpFH = {0};
BITMAPINFOHEADER bmpIH = {0};
static U32 bmpIHE[32] = {0}; // should be >= sizeof(BITMAPV5HEADER) - sizeof(BITMAPINFOHEADER)
static U32 rguColorTable[256] = {0};
U32 i = 0;
Call(pWS->Read(pWS, &bmpFH, sizeof(bmpFH)));
FailIf(bmpFH.szBM != (U8 *) strstr((char *) bmpFH.szBM, "BM"), WMP_errUnsupportedFormat);
Call(pWS->Read(pWS, &bmpIH, sizeof(bmpIH)));
FailIf(((sizeof(bmpIH) > bmpIH.uSize) || ((sizeof(bmpIH) + sizeof(bmpIHE)) < bmpIH.uSize)), WMP_errUnsupportedFormat);
if (sizeof(bmpIH) < bmpIH.uSize)
Call(pWS->Read(pWS, &bmpIHE, bmpIH.uSize - sizeof(bmpIH)));
switch (bmpIH.iBitCount)
{
case 8:
// check the color table to verify the image is actually gray scale
Call(pWS->Read(pWS, rguColorTable, sizeof(rguColorTable)));
for (i = 0; i < sizeof2(rguColorTable); ++i)
{
U32 c = i | (i << 8) | (i << 16);
FailIf(c != rguColorTable[i], WMP_errUnsupportedFormat);
}
pID->guidPixFormat = GUID_PKPixelFormat8bppGray;
pID->EXT.BMP.cbPixel = 1;
break;
case 16:
// Call(pWS->Read(pWS, rguColorTable, sizeof(rguColorTable[0] * 3)));
/* if (BI_RGB555_MASK_B == rguColorTable[0] && BI_RGB555_MASK_G == rguColorTable[1] && BI_RGB555_MASK_R == rguColorTable[2])
{
pID->guidPixFormat = GUID_PKPixelFormat16bppRGB555;
}
if (BI_RGB565_MASK_B == rguColorTable[0] && BI_RGB565_MASK_G == rguColorTable[1] && BI_RGB565_MASK_R == rguColorTable[2])
{
pID->guidPixFormat = GUID_PKPixelFormat16bppRGB565;
}
else
{
Call(WMP_errUnsupportedFormat);
}
*/
pID->EXT.BMP.cbPixel = 2;
break;
case 24:
pID->guidPixFormat = GUID_PKPixelFormat24bppBGR;
pID->EXT.BMP.cbPixel = 3;
break;
case 32:
/* Call(pWS->Read(pWS, rguColorTable, sizeof(rguColorTable[0] * 3)));
if (BI_RGB101010_MASK_B == rguColorTable[0] && BI_RGB101010_MASK_G == rguColorTable[1] && BI_RGB101010_MASK_R == rguColorTable[2])
{
pID->guidPixFormat = GUID_PKPixelFormat32bppRGB101010;
}
else
{
Call(WMP_errUnsupportedFormat);
}
*/
// pID->guidPixFormat = GUID_PKPixelFormat32bppBGRA;
pID->EXT.BMP.cbPixel = 4;
break;
default:
Call(WMP_errUnsupportedFormat);
break;
}
pID->uWidth = (U32)bmpIH.iWidth;
pID->uHeight = (U32)bmpIH.iHeight;
pID->fResX = (0 == bmpIH.iPelsPerMeterX ? 96 : (Float)(bmpIH.iPelsPerMeterX * .0254));
pID->fResY = (0 == bmpIH.iPelsPerMeterY ? 96 : (Float)(bmpIH.iPelsPerMeterY * .0254));
pID->EXT.BMP.offPixel = pID->offStart + bmpFH.uOffBits;
Cleanup:
return err;
}
ERR PKImageDecode_Initialize_BMP(
PKTestDecode* pID,
struct WMPStream* pWS)
{
ERR err = WMP_errSuccess;
Call(PKTestDecode_Initialize(pID, pWS));
Call(ParseBMPHeader(pID, pWS));
Cleanup:
return err;
}
ERR PKImageDecode_Copy_BMP(
PKTestDecode* pID,
const PKRect* pRect,
U8* pb,
U32 cbStride)
{
ERR err = WMP_errSuccess;
struct WMPStream* pS = pID->pStream;
size_t cbLineS = (pID->EXT.BMP.cbPixel * pID->uWidth + 3) / 4 * 4;
size_t cbLineM = pID->EXT.BMP.cbPixel * pRect->Width;
I32 i = 0;
//FailIf(pRect->X < 0 || pID->uWidth <= pRect->X, WMP_errInvalidParameter);
//FailIf(pRect->Y < 0 || pID->uHeight <= pRect->Y, WMP_errInvalidParameter);
//FailIf(pRect->Width < 0 || pID->uWidth < pRect->X + pRect->Width, WMP_errInvalidParameter);
//FailIf(pRect->Height < 0 || pID->uHeight < pRect->Y + pRect->Height, WMP_errInvalidParameter);
FailIf(cbStride < cbLineM, WMP_errInvalidParameter);
for (i = pRect->Y + pRect->Height - 1; pRect->Y <= i; --i)
{
size_t offLine = pID->EXT.BMP.cbPixel * pRect->X;
size_t offS = cbLineS * (pID->uHeight - i - 1) + offLine;
size_t offM = cbStride * (i - pRect->Y) + offLine;
Call(pS->SetPos(pS, pID->EXT.BMP.offPixel + offS));
Call(pS->Read(pS, pb + offM, cbLineM));
}
Cleanup:
return err;
}
ERR PKImageDecode_Create_BMP(
PKTestDecode** ppID)
{
ERR err = WMP_errSuccess;
PKTestDecode* pID = NULL;
Call(PKTestDecode_Create(ppID));
pID = *ppID;
pID->Initialize = PKImageDecode_Initialize_BMP;
pID->Copy = PKImageDecode_Copy_BMP;
Cleanup:
return err;
}

242
jxrlib/jxrtestlib/JXRTestHdr.c
View file

@ -1,242 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#ifndef ANSI
#define _CRT_SECURE_NO_WARNINGS
#endif ANSI
#include <stdlib.h>
#include <string.h>
#include <JXRTest.h>
#pragma pack(push, 1)
#pragma pack(pop)
//================================================================
// PKImageEncode_HDR
//================================================================
ERR WriteHDRHeader(
PKImageEncode* pIE)
{
ERR err = WMP_errSuccess;
struct WMPStream* pS = pIE->pStream;
char txtbuff[100];
strcpy(txtbuff, "#?RADIANCE\nFORMAT=32-bit_rle_rgbe\n\n");
Call(pS->Write(pS, txtbuff, strlen(txtbuff)));
pIE->offPixel = strlen(txtbuff);
sprintf(txtbuff, "-Y %d +X %d\n", pIE->uHeight, pIE->uWidth);
Call(pS->Write(pS, txtbuff, strlen(txtbuff)));
pIE->offPixel += strlen(txtbuff);
pIE->cbPixel = 4;
pIE->fHeaderDone = !FALSE;
Cleanup:
return err;
}
ERR PKImageEncode_WritePixels_HDR(
PKImageEncode* pIE,
U32 cLine,
U8* pbPixel,
U32 cbStride)
{
ERR err = WMP_errSuccess;
struct WMPStream* pS = pIE->pStream;
size_t cbLineM = 0, cbLineS = 0;
size_t i = 0;
// header
if (!pIE->fHeaderDone)
{
// WriteHDRHeader() also inits this object
Call(WriteHDRHeader(pIE));
}
// body
// calculate line size in memory and in stream
cbLineM = pIE->cbPixel * pIE->uWidth;
cbLineS = (cbLineM + 3) / 4 * 4;
//FailIf(pRect->X < 0 || pID->uWidth <= pRect->X, WMP_errInvalidParameter);
//FailIf(pRect->Y < 0 || pID->uHeight <= pRect->Y, WMP_errInvalidParameter);
//FailIf(pRect->Width < 0 || pID->uWidth < pRect->X + pRect->Width, WMP_errInvalidParameter);
//FailIf(pRect->Height < 0 || pID->uHeight < pRect->Y + pRect->Height, WMP_errInvalidParameter);
FailIf(cbStride < cbLineM, WMP_errInvalidParameter);
for (i = 0; i <= cLine - 1; i++)
{
size_t offM = cbStride * i;
size_t offS = cbLineS * (pIE->idxCurrentLine + i);
Call(pS->SetPos(pS, pIE->offPixel + offS));
Call(pS->Write(pS, pbPixel + offM, cbLineM));
}
pIE->idxCurrentLine += cLine;
Cleanup:
return err;
}
ERR PKImageEncode_Create_HDR(
PKImageEncode** ppIE)
{
ERR err = WMP_errSuccess;
PKImageEncode* pIE = NULL;
Call(PKImageEncode_Create(ppIE));
pIE = *ppIE;
pIE->WritePixels = PKImageEncode_WritePixels_HDR;
Cleanup:
return err;
}
//================================================================
// PKImageDecode_HDR
//================================================================
ERR ParseHDRHeader(
PKTestDecode* pID,
struct WMPStream* pWS)
{
ERR err = WMP_errSuccess;
char txtbuff[512];
Bool done = FALSE;
FailIf(NULL == fgets(txtbuff, 12, pWS->state.file.pFile), WMP_errUnsupportedFormat);
FailIf(0 != strcmp(txtbuff, "#?RADIANCE\n"), WMP_errUnsupportedFormat);
// Read lines to image size
while (!done) {
FailIf(NULL == fgets(txtbuff, 512, pWS->state.file.pFile), WMP_errUnsupportedFormat);
if (0 == strncmp(txtbuff, "FORMAT", 6)) {
FailIf(0 != strcmp(txtbuff, "FORMAT=32-bit_rle_rgbe\n"), WMP_errUnsupportedFormat);
}
if (0 == strncmp(txtbuff, "-Y", 2)) {
sscanf(txtbuff, "-Y %d +X %d\n", &pID->uHeight, &pID->uWidth);
done = TRUE;
}
}
Call(pWS->Read(pWS, txtbuff, 3));
if(((2 == txtbuff[0]) && (2 == txtbuff[1]) && (0 == (txtbuff[2] & 0x80))) ||
((1 == txtbuff[0]) && (1 == txtbuff[1]) && (1 == txtbuff[2])))
{
printf("Doesn't support compressed HDR files.\n");
err = WMP_errUnsupportedFormat;
goto Cleanup;
}
// Set header other header parameters
pID->guidPixFormat = GUID_PKPixelFormat32bppRGBE;
pID->EXT.HDR.cbPixel = 4;
// Set pointer to first pixel
Call(pWS->GetPos(pWS, &pID->EXT.HDR.offPixel));
pID->EXT.HDR.offPixel -= 3;
Call(pWS->SetPos(pWS, pID->EXT.HDR.offPixel));
// We don't need: pID->fResX and pID->fResY
Cleanup:
return err;
}
ERR PKImageDecode_Initialize_HDR(
PKTestDecode* pID,
struct WMPStream* pWS)
{
ERR err = WMP_errSuccess;
Call(PKTestDecode_Initialize(pID, pWS));
Call(ParseHDRHeader(pID, pWS));
Cleanup:
return err;
}
ERR PKImageDecode_Copy_HDR(
PKTestDecode* pID,
const PKRect* pRect,
U8* pb,
U32 cbStride)
{
ERR err = WMP_errSuccess;
struct WMPStream* pS = pID->pStream;
size_t cbLineS = (pID->EXT.HDR.cbPixel * pID->uWidth + 3) / 4 * 4;
size_t cbLineM = pID->EXT.HDR.cbPixel * pRect->Width;
I32 i = 0;
//FailIf(pRect->X < 0 || pID->uWidth <= pRect->X, WMP_errInvalidParameter);
//FailIf(pRect->Y < 0 || pID->uHeight <= pRect->Y, WMP_errInvalidParameter);
//FailIf(pRect->Width < 0 || pID->uWidth < pRect->X + pRect->Width, WMP_errInvalidParameter);
//FailIf(pRect->Height < 0 || pID->uHeight < pRect->Y + pRect->Height, WMP_errInvalidParameter);
FailIf(cbStride < cbLineM, WMP_errInvalidParameter);
for (i = pRect->Y ; i < pRect->Y + pRect->Height ; i++)
{
size_t offLine = pID->EXT.HDR.cbPixel * pRect->X;
size_t offS = cbLineS * i + offLine;
size_t offM = cbStride * (i - pRect->Y) + offLine;
Call(pS->SetPos(pS, pID->EXT.HDR.offPixel + offS));
Call(pS->Read(pS, pb + offM, cbLineM));
}
Cleanup:
return err;
}
ERR PKImageDecode_Create_HDR(
PKTestDecode** ppID)
{
ERR err = WMP_errSuccess;
PKTestDecode* pID = NULL;
Call(PKTestDecode_Create(ppID));
pID = *ppID;
pID->Initialize = PKImageDecode_Initialize_HDR;
pID->Copy = PKImageDecode_Copy_HDR;
Cleanup:
return err;
}

179
jxrlib/jxrtestlib/JXRTestLib_vc11.vcxproj
View file

@ -1,179 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectName>JXRTestLib</ProjectName>
<ProjectGuid>{A69603CC-65E8-443F-8E31-737DBD6BB0DC}</ProjectGuid>
<RootNamespace>JXRTestLib</RootNamespace>
<Keyword>Win32Proj</Keyword>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v110</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v110</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v110</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v110</PlatformToolset>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" 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|Win32'" 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)'=='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>10.0.30319.1</_ProjectFileVersion>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(Configuration)/$(ProjectName)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(OutDir)</IntDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(Configuration)\$(ProjectName)\$(Platform)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)</IntDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(Configuration)/$(ProjectName)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(OutDir)</IntDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(Configuration)\$(ProjectName)\$(Platform)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)</IntDir>
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" />
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" />
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" />
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>..\image\sys;..\image\x86;..\JXRTestLib;..\JXRGlueLib;..\common\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Lib>
<OutputFile>$(OutDir)$(ProjectName).lib</OutputFile>
</Lib>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Midl>
<TargetEnvironment>X64</TargetEnvironment>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>..\image\sys;..\image\x86;..\JXRTestLib;..\JXRGlueLib;..\common\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Lib>
<OutputFile>$(OutDir)$(ProjectName).lib</OutputFile>
</Lib>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<WholeProgramOptimization>true</WholeProgramOptimization>
<AdditionalIncludeDirectories>..\image\sys;..\image\x86;..\JXRTestLib;..\JXRGlueLib;..\common\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;NDEBUG;_LIB;ENABLE_OPTIMIZATIONS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Lib>
<AdditionalOptions>/LTCG %(AdditionalOptions)</AdditionalOptions>
<OutputFile>$(OutDir)$(ProjectName).lib</OutputFile>
<LinkTimeCodeGeneration>true</LinkTimeCodeGeneration>
</Lib>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Midl>
<TargetEnvironment>X64</TargetEnvironment>
</Midl>
<ClCompile>
<AdditionalIncludeDirectories>..\image\sys;..\image\x86;..\JXRTestLib;..\JXRGlueLib;..\common\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<WholeProgramOptimization>true</WholeProgramOptimization>
</ClCompile>
<Lib>
<OutputFile>$(OutDir)$(ProjectName).lib</OutputFile>
<LinkTimeCodeGeneration>true</LinkTimeCodeGeneration>
</Lib>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="JXRTest.c" />
<ClCompile Include="JXRTestBmp.c" />
<ClCompile Include="JXRTestHdr.c" />
<ClCompile Include="JXRTestPnm.c" />
<ClCompile Include="JXRTestTif.c" />
<ClCompile Include="JXRTestYUV.c" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="JXRTest.h" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

331
jxrlib/jxrtestlib/JXRTestPnm.c
View file

@ -1,331 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#ifndef ANSI
#define _CRT_SECURE_NO_WARNINGS
#endif ANSI
#include <stdlib.h>
#include <JXRTest.h>
//================================================================
// PKImageEncode_PNM helpers
//================================================================
ERR WritePNMHeader(PKImageEncode* pIE)
{
ERR err = WMP_errSuccess;
PKPixelInfo PI;
struct WMPStream* pS = pIE->pStream;
U8 buf[64] = {0};
int cb = 0;
char szSig[2];
U32 uMaxVal = 0;
PI.pGUIDPixFmt = &pIE->guidPixFormat;
PixelFormatLookup(&PI, LOOKUP_FORWARD);
if (IsEqualGUID(&GUID_PKPixelFormatBlackWhite, PI.pGUIDPixFmt))
{
szSig[0] = 'P', szSig[1] = '5';
uMaxVal = 1;
}
else if (IsEqualGUID(&GUID_PKPixelFormat8bppGray, PI.pGUIDPixFmt))
{
szSig[0] = 'P', szSig[1] = '5';
uMaxVal = 255;
}
else if (IsEqualGUID(&GUID_PKPixelFormat24bppRGB, PI.pGUIDPixFmt))
{
szSig[0] = 'P', szSig[1] = '6';
uMaxVal = 255;
}
else if (IsEqualGUID(&GUID_PKPixelFormat48bppRGB, PI.pGUIDPixFmt))
{
szSig[0] = 'P', szSig[1] = '6';
uMaxVal = 65535;
}
else if (IsEqualGUID(&GUID_PKPixelFormat16bppGray, PI.pGUIDPixFmt))
{
szSig[0] = 'P', szSig[1] = '6';
uMaxVal = 65535;
}
else if (IsEqualGUID(&GUID_PKPixelFormat96bppRGBFloat, PI.pGUIDPixFmt))
{
szSig[0] = 'P', szSig[1] = 'F';
}
else
Call(WMP_errUnsupportedFormat);
if('P' == szSig[0] && 'F' == szSig[1])
cb = sprintf((char *) buf, "%c%c\n%u\n%u\n%s\n",
szSig[0], szSig[1], (int)pIE->uWidth, (int)pIE->uHeight, "-1.0000");
else
cb = sprintf((char *) buf, "%c%c\n%u %u\n%u\n",
szSig[0], szSig[1], (int)pIE->uWidth, (int)pIE->uHeight, (int)uMaxVal);
assert(cb < sizeof2(buf));
Call(pS->Write(pS, buf, cb));
Call(pS->GetPos(pS, &pIE->offPixel));
pIE->cbPixel = ((PI.cbitUnit + 7) >> 3);// ->cbPixel / pPI->cbPixelDenom;
pIE->fHeaderDone = !FALSE;
Cleanup:
return err;
}
//================================================================
// PKImageEncode_PNM
//================================================================
ERR PKImageEncode_WritePixels_PNM(
PKImageEncode* pIE,
U32 cLine,
U8* pbPixel,
U32 cbStride)
{
ERR err = WMP_errSuccess;
struct WMPStream* pS = pIE->pStream;
size_t cbLine = 0;
size_t offPos = 0;
size_t i = 0;
// header
if (!pIE->fHeaderDone)
{
Call(WritePNMHeader(pIE));
}
// body
cbLine = pIE->cbPixel * pIE->uWidth;
FailIf(cbStride < cbLine, WMP_errInvalidParameter);
offPos = pIE->offPixel + cbLine * pIE->idxCurrentLine;
Call(pS->SetPos(pS, offPos));
for (i = 0; i < cLine; ++i)
{
Call(pS->Write(pS, pbPixel + cbStride * i, cbLine));
}
pIE->idxCurrentLine += cLine;
Cleanup:
return err;
}
ERR PKImageEncode_Create_PNM(
PKImageEncode** ppIE)
{
ERR err = WMP_errSuccess;
PKImageEncode* pIE = NULL;
Call(PKImageEncode_Create(ppIE));
pIE = *ppIE;
pIE->WritePixels = PKImageEncode_WritePixels_PNM;
Cleanup:
return err;
}
//================================================================
// PKImageDecode_PNM helpers
//================================================================
ERR GetLineSkipPound(struct WMPStream* pWS, U8* pb, size_t cb)
{
ERR err = WMP_errSuccess;
U8 *pb1;
size_t cb1;
do
{
pb1 = pb;
cb1 = cb;
do {
Call(pWS->Read(pWS, pb1, 1));
cb1--;
pb1++;
}
while (cb1 > 0 && pb1[-1] != '\n');
//Call(pWS->GetLine(pWS, pb, cb));
} while('#' == pb[0]);
Cleanup:
return err;
}
ERR ParsePNMHeader(
PKTestDecode* pID,
struct WMPStream* pWS)
{
ERR err = WMP_errSuccess;
U8 line[128] = {0};
size_t idxChannel = 0, idxBitDepth = 0;
unsigned int width = 0, height = 0, maxval = 0;
static const PKPixelFormatGUID* pixFormat[2][2] =
{
{&GUID_PKPixelFormat8bppGray, &GUID_PKPixelFormat16bppGray,},
{&GUID_PKPixelFormat24bppRGB, &GUID_PKPixelFormat48bppRGB,},
};
//================================
Call(GetLineSkipPound(pWS, line, sizeof2(line)));
if (line == (U8 *) strstr((char *) line, "P5"))
{
idxChannel = 0;
Call(GetLineSkipPound(pWS, line, sizeof2(line)));
FailIf(2 != sscanf((char *) line, "%u %u", &width, &height), WMP_errUnsupportedFormat);
}
else if(line == (U8 *) strstr((char *) line, "P6"))
{
idxChannel = 1;
Call(GetLineSkipPound(pWS, line, sizeof2(line)));
FailIf(2 != sscanf((char *) line, "%u %u", &width, &height), WMP_errUnsupportedFormat);
}
else if(line == (U8 *) strstr((char *) line, "PF"))
{
idxChannel = 2;
Call(GetLineSkipPound(pWS, line, sizeof2(line)));
FailIf(1 != sscanf((char *) line, "%u", &width), WMP_errUnsupportedFormat);
Call(GetLineSkipPound(pWS, line, sizeof2(line)));
FailIf(1 != sscanf((char *) line, "%u", &height), WMP_errUnsupportedFormat);
}
else
{
Call(WMP_errUnsupportedFormat);
}
//================================
// Call(GetLineSkipPound(pWS, line, sizeof2(line)));
// FailIf(2 != sscanf(line, "%u %u", &width, &height), WMP_errUnsupportedFormat);
FailIf(0 == width || 0 == height, WMP_errUnsupportedFormat);
pID->uWidth = (U32)width;
pID->uHeight = (U32)height;
//================================
Call(GetLineSkipPound(pWS, line, sizeof2(line)));
FailIf(1 != sscanf((char *) line, "%u", &maxval), WMP_errUnsupportedFormat);
if (2==idxChannel)
{
FailIf(maxval != -1, WMP_errUnsupportedFormat);
pID->guidPixFormat = GUID_PKPixelFormat96bppRGBFloat;
}
else
{
FailIf(maxval < 1 || 65535 < maxval, WMP_errUnsupportedFormat);
idxBitDepth = 255 < maxval;
pID->guidPixFormat = *pixFormat[idxChannel][idxBitDepth];
}
Call(pWS->GetPos(pWS, &pID->EXT.PNM.offPixel));
Cleanup:
return err;
}
//================================================================
// PKImageDecode_PNM
//================================================================
ERR PKImageDecode_Initialize_PNM(
PKTestDecode* pID,
struct WMPStream* pWS)
{
ERR err = WMP_errSuccess;
Call(PKTestDecode_Initialize(pID, pWS));
Call(ParsePNMHeader(pID, pWS));
Cleanup:
return err;
}
ERR PKImageDecode_Copy_PNM(
PKTestDecode* pID,
const PKRect* pRect,
U8* pb,
U32 cbStride)
{
ERR err = WMP_errSuccess;
struct WMPStream* pS = pID->pStream;
PKPixelInfo PI;
size_t cbLineS = 0;
size_t cbLineM = 0;
I32 i = 0;
PI.pGUIDPixFmt = &pID->guidPixFormat;
PixelFormatLookup(&PI, LOOKUP_FORWARD);
cbLineS = (BD_1 == PI.bdBitDepth ? ((PI.cbitUnit * pID->uWidth + 7) >> 3) : (((PI.cbitUnit + 7) >> 3) * pID->uWidth));
cbLineM = (BD_1 == PI.bdBitDepth ? ((PI.cbitUnit * pRect->Width + 7) >> 3) : (((PI.cbitUnit + 7) >> 3) * pRect->Width));
FailIf(cbStride < cbLineM, WMP_errInvalidParameter);
for (i = 0; i < pRect->Height; ++i)
{
size_t offLine = (BD_1 == PI.bdBitDepth ? ((PI.cbitUnit * pRect->X + 7) >> 3) : (((PI.cbitUnit + 7) >> 3) * pRect->X));
size_t offS = cbLineS * (pRect->Y + i) + offLine;
size_t offM = cbStride * i + offLine;
Call(pS->SetPos(pS, pID->EXT.PNM.offPixel + offS));
Call(pS->Read(pS, pb + offM, cbLineM));
}
Cleanup:
return err;
}
ERR PKImageDecode_Create_PNM(
PKTestDecode** ppID)
{
ERR err = WMP_errSuccess;
PKTestDecode* pID = NULL;
Call(PKTestDecode_Create(ppID));
pID = *ppID;
pID->Initialize = PKImageDecode_Initialize_PNM;
pID->Copy = PKImageDecode_Copy_PNM;
Cleanup:
return err;
}

936
jxrlib/jxrtestlib/JXRTestTif.c
View file

@ -1,936 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#include <stdlib.h>
#include <string.h>
#include <strcodec.h>
#include <JXRTest.h>
//================================================================
#define TIF_tagNull 0
#define TIF_tagSubfileType 0xff
#define TIF_tagNewSubfileType 0xfe
#define TIF_tagImageWidth 0x100
#define TIF_tagImageLength 0x101
#define TIF_tagBitsPerSample 0x102
#define TIF_tagCompression 0x103
#define TIF_tagPhotometricInterpretation 0x106
#define TIF_tagStripOffsets 0x111
#define TIF_tagOrientation 0x112
#define TIF_tagSamplesPerPixel 0x115
#define TIF_tagRowsPerStrip 0x116
#define TIF_tagStripByteCounts 0x117
#define TIF_tagXResolution 0x11a
#define TIF_tagYResolution 0x11b
#define TIF_tagPlanarConfiguration 0x11c
#define TIF_tagResolutionUnit 0x128
#define TIF_tagSoftware 0x131
#define TIF_tagColorMap 0x140
#define TIF_tagPredictor 0x13d
#define TIF_tagInkSet 0x14c
#define TIF_tagExtraSamples 0x152
#define TIF_tagSampleFormat 0x153
#define TIF_typBYTE 1
#define TIF_typASCII 2
#define TIF_typSHORT 3
#define TIF_typLONG 4
#define TIF_typRATIOAL 5
#define TIF_typSBYTE 6
#define TIF_typUNDEFINED 7
#define TIF_typSSHORT 8
#define TIF_typSLONG 9
#define TIF_typSRATIONAL 10
#define TIF_typFLOAT 11
#define TIF_typDOUBLE 12
//================================================================
typedef float FLOAT;
typedef double DOUBLE;
//================================================================
// PKImageEncode_TIF helpers
//================================================================
typedef struct tagTifDE
{
U16 uTag;
U16 uType;
U32 uCount;
U32 uValueOrOffset;
} TifDE;
typedef struct tagTifDEMisc
{
U32 offBitsPerSample;
U32 offSampleFormat;
U32 bps, spp, sf;
U32 iPhotometricInterpretation;
U32 offXResolution;
U32 resXF, resXD;
U32 offYResolution;
U32 resYF, resYD;
} TifDEMisc;
ERR PutTifUShort(
struct WMPStream* pS,
size_t offPos,
U16 uValue)
{
ERR err = WMP_errSuccess;
Call(pS->SetPos(pS, offPos));
Call(pS->Write(pS, &uValue, sizeof(uValue)));
Cleanup:
return err;
}
ERR PutTifULong(
struct WMPStream* pS,
size_t offPos,
U32 uValue)
{
ERR err = WMP_errSuccess;
Call(pS->SetPos(pS, offPos));
Call(pS->Write(pS, &uValue, sizeof(uValue)));
Cleanup:
return err;
}
ERR WriteTifDE(
struct WMPStream* pS,
size_t offPos,
TifDE* pDE)
{
ERR err = WMP_errSuccess;
assert(-1 != pDE->uCount);
assert(-1 != pDE->uValueOrOffset);
Call(PutTifUShort(pS, offPos, pDE->uTag)); offPos += 2;
Call(PutTifUShort(pS, offPos, pDE->uType)); offPos += 2;
Call(PutTifULong(pS, offPos, pDE->uCount)); offPos += 4;
switch (pDE->uType)
{
case TIF_typSHORT:
if (1 == pDE->uCount)
{
Call(PutTifUShort(pS, offPos, (U16)pDE->uValueOrOffset)); offPos += 2;
Call(PutTifUShort(pS, offPos, 0)); offPos += 2;
break;
}
case TIF_typLONG:
case TIF_typRATIOAL:
Call(PutTifULong(pS, offPos, pDE->uValueOrOffset)); offPos += 4;
break;
default:
Call(WMP_errInvalidParameter);
break;
}
Cleanup:
return err;
}
ERR WriteTifHeader(
PKImageEncode* pIE)
{
ERR err = WMP_errSuccess;
struct WMPStream* pS = pIE->pStream;
size_t offPos = 0;
#ifdef _BIG__ENDIAN_
U8 IIMM[3] = "MM";
#else // _BIG__ENDIAN_
U8 IIMM[3] = "II";
#endif // _BIG__ENDIAN_
TifDEMisc tifDEMisc = {
(U32) -1, (U32) -1, (U32) -1, (U32) -1, (U32) -1,
2, // photometric interpretation
(U32) -1, 10000, 10000,
(U32) -1, 10000, 10000,
};
// const U32 cbTifDEMisc = sizeof(U16) * 10 + sizeof(U32) * 2 * 2;
const static TifDE tifDEs[] =
{
{0x100, 4, 1, (U32) -1}, // TIF_tagImageWidth
{0x101, 4, 1, (U32) -1}, // TIF_tagImageLength
{0x102, 3, (U32) -1, (U32) -1}, // TIF_tagBitsPerSample
{0x103, 3, 1, 1}, // TIF_tagCompression
{0x106, 3, 1, (U32) -1}, // TIF_tagPhotometricInterpretation
{0x111, 4, 1, (U32) -1}, // TIF_tagStripOffsets
{0x112, 3, 1, 1}, // TIF_tagOrientation
{0x115, 3, 1, (U32) -1}, // TIF_tagSamplesPerPixel
{0x116, 4, 1, (U32) -1}, // TIF_tagRowsPerStrip
{0x117, 4, 1, (U32) -1}, // TIF_tagStripByteCounts
{0x11a, 5, 1, (U32) -1}, // TIF_tagXResolution
{0x11b, 5, 1, (U32) -1}, // TIF_tagYResolution
{0x11c, 3, 1, 1}, // TIF_tagPlanarConfiguration
{0x128, 3, 1, 2}, // TIF_tagResolutionUnit
{0x153, 3, (U32) -1, (U32) -1}, // TIF_tagSampleFormat
// {0x131, 2, -1, -1}, // TIF_tagSoftware
// {0x140, 3, -1, -1}, // TIF_tagColorMap
};
U16 cTifDEs = sizeof2(tifDEs);
TifDE tifDE = {0};
PKPixelInfo PI;
size_t cbLine = 0;
size_t i = 0;
size_t j;
tifDEMisc.resXF = (U32)(pIE->fResX * 10000);
tifDEMisc.resYF = (U32)(pIE->fResY * 10000);
Call(pS->GetPos(pS, &offPos));
FailIf(0 != offPos, WMP_errUnsupportedFormat);
//================
// TifHeader
Call(pS->Write(pS, IIMM, 2)); offPos += 2;
Call(PutTifUShort(pS, offPos, 42)); offPos += 2;
Call(PutTifULong(pS, offPos, (U32)(offPos + 4))); offPos += 4;
//================
// TifDEMisc
PI.pGUIDPixFmt = &pIE->guidPixFormat;
PixelFormatLookup(&PI, LOOKUP_FORWARD);
tifDEMisc.iPhotometricInterpretation =
//the N channel TIF by PS has PhotometricInterpretation of PK_PI_RGB
PI.uInterpretation == PK_PI_NCH || PI.uInterpretation == PK_PI_RGBE ? PK_PI_RGB :
(PI.uInterpretation == PK_PI_B0 && pIE->WMP.wmiSCP.bBlackWhite ? PK_PI_W0 : PI.uInterpretation);
tifDEMisc.spp = PI.uSamplePerPixel;
tifDEMisc.bps = PI.uBitsPerSample;
tifDEMisc.sf = PI.uSampleFormat;
if (tifDEMisc.iPhotometricInterpretation == PK_PI_CMYK)
cTifDEs++;
if (PI.grBit & PK_pixfmtHasAlpha)
cTifDEs++;
tifDEMisc.offBitsPerSample = (U32)offPos + sizeof(U16) + 12 * cTifDEs + sizeof(U32);
tifDEMisc.offSampleFormat = tifDEMisc.offBitsPerSample + (tifDEMisc.spp == 1 ? 0 : tifDEMisc.spp * 2);
tifDEMisc.offXResolution = tifDEMisc.offSampleFormat + (tifDEMisc.spp == 1 ? 0 : tifDEMisc.spp * 2);
tifDEMisc.offYResolution = tifDEMisc.offXResolution + 8;
//================
// TifIFD
pIE->offPixel = tifDEMisc.offYResolution + 8;
Call(PutTifUShort(pS, offPos, cTifDEs)); offPos += 2;
//================
tifDE = tifDEs[i++];
assert(TIF_tagImageWidth == tifDE.uTag);
tifDE.uValueOrOffset = pIE->uWidth;
Call(WriteTifDE(pS, offPos, &tifDE)); offPos += 12;
tifDE = tifDEs[i++];
assert(TIF_tagImageLength == tifDE.uTag);
tifDE.uValueOrOffset = pIE->uHeight;
Call(WriteTifDE(pS, offPos, &tifDE)); offPos += 12;
tifDE = tifDEs[i++];
assert(TIF_tagBitsPerSample == tifDE.uTag);
tifDE.uCount = tifDEMisc.spp;
tifDE.uValueOrOffset = 1 == tifDE.uCount ? tifDEMisc.bps : tifDEMisc.offBitsPerSample;
Call(WriteTifDE(pS, offPos, &tifDE)); offPos += 12;
tifDE = tifDEs[i++];
assert(TIF_tagCompression == tifDE.uTag);
Call(WriteTifDE(pS, offPos, &tifDE)); offPos += 12;
tifDE = tifDEs[i++];
assert(TIF_tagPhotometricInterpretation == tifDE.uTag);
tifDE.uValueOrOffset = tifDEMisc.iPhotometricInterpretation;
Call(WriteTifDE(pS, offPos, &tifDE)); offPos += 12;
tifDE = tifDEs[i++];
assert(TIF_tagStripOffsets == tifDE.uTag);
tifDE.uValueOrOffset = (U32)pIE->offPixel;
Call(WriteTifDE(pS, offPos, &tifDE)); offPos += 12;
tifDE = tifDEs[i++];
assert(TIF_tagOrientation == tifDE.uTag);
Call(WriteTifDE(pS, offPos, &tifDE)); offPos += 12;
tifDE = tifDEs[i++];
assert(TIF_tagSamplesPerPixel == tifDE.uTag);
tifDE.uValueOrOffset = tifDEMisc.spp;
Call(WriteTifDE(pS, offPos, &tifDE)); offPos += 12;
tifDE = tifDEs[i++];
assert(TIF_tagRowsPerStrip == tifDE.uTag);
tifDE.uValueOrOffset = pIE->uHeight;
Call(WriteTifDE(pS, offPos, &tifDE)); offPos += 12;
tifDE = tifDEs[i++];
assert(TIF_tagStripByteCounts == tifDE.uTag);
cbLine = (BD_1 == PI.bdBitDepth ? ((PI.cbitUnit * pIE->uWidth + 7) >> 3) : (((PI.cbitUnit + 7) >> 3) * pIE->uWidth));
tifDE.uValueOrOffset = (U32)(cbLine * pIE->uHeight);
Call(WriteTifDE(pS, offPos, &tifDE)); offPos += 12;
tifDE = tifDEs[i++];
assert(TIF_tagXResolution == tifDE.uTag);
tifDE.uValueOrOffset = tifDEMisc.offXResolution;
Call(WriteTifDE(pS, offPos, &tifDE)); offPos += 12;
tifDE = tifDEs[i++];
assert(TIF_tagYResolution == tifDE.uTag);
tifDE.uValueOrOffset = tifDEMisc.offYResolution;
Call(WriteTifDE(pS, offPos, &tifDE)); offPos += 12;
tifDE = tifDEs[i++];
assert(TIF_tagPlanarConfiguration == tifDE.uTag);
Call(WriteTifDE(pS, offPos, &tifDE)); offPos += 12;
tifDE = tifDEs[i++];
assert(TIF_tagResolutionUnit == tifDE.uTag);
Call(WriteTifDE(pS, offPos, &tifDE)); offPos += 12;
if (tifDEMisc.iPhotometricInterpretation == PK_PI_CMYK)
{
TifDE tifDE = {TIF_tagInkSet, 3, 1, 1};
Call(WriteTifDE(pS, offPos, &tifDE)); offPos += 12;
}
if (PI.grBit & PK_pixfmtHasAlpha)
{
TifDE tifDE = {TIF_tagExtraSamples, 3, 1, 1};
if (!(PI.grBit & PK_pixfmtPreMul))
tifDE.uValueOrOffset++;
Call(WriteTifDE(pS, offPos, &tifDE)); offPos += 12;
}
tifDE = tifDEs[i++];
assert(TIF_tagSampleFormat == tifDE.uTag);
tifDE.uCount = tifDEMisc.spp;
tifDE.uValueOrOffset = 1 == tifDE.uCount ? tifDEMisc.sf : tifDEMisc.offSampleFormat;
Call(WriteTifDE(pS, offPos, &tifDE)); offPos += 12;
//================
Call(PutTifULong(pS, offPos, 0)); offPos += 4;
//================
// TifDEMisc
if (tifDE.uCount > 1)
{
assert(tifDEMisc.offBitsPerSample == offPos);
if (PI.bdBitDepth == BD_565)
{
Call(PutTifUShort(pS, offPos, 5)); offPos += 2;
Call(PutTifUShort(pS, offPos, 6)); offPos += 2;
Call(PutTifUShort(pS, offPos, 5)); offPos += 2;
}
else
{
for (j = 0; j < tifDE.uCount; j++)
{
Call(PutTifUShort(pS, offPos, (U16)tifDEMisc.bps)); offPos += 2;
}
}
assert(tifDEMisc.offSampleFormat == offPos);
for (j = 0; j < tifDE.uCount; j++)
{
Call(PutTifUShort(pS, offPos, (U16)tifDEMisc.sf)); offPos += 2;
}
}
assert(tifDEMisc.offXResolution == offPos);
Call(PutTifULong(pS, offPos, tifDEMisc.resXF)); offPos += 4;
Call(PutTifULong(pS, offPos, tifDEMisc.resXD)); offPos += 4;
assert(tifDEMisc.offYResolution == offPos);
Call(PutTifULong(pS, offPos, tifDEMisc.resYF)); offPos += 4;
Call(PutTifULong(pS, offPos, tifDEMisc.resYD)); offPos += 4;
assert(pIE->offPixel == offPos);
pIE->fHeaderDone = !FALSE;
Cleanup:
return err;
}
//================================================================
// PKImageEncode_TIF
//================================================================
ERR PKImageEncode_WritePixels_TIF(
PKImageEncode* pIE,
U32 cLine,
U8* pbPixel,
U32 cbStride)
{
ERR err = WMP_errSuccess;
struct WMPStream* pS = pIE->pStream;
PKPixelInfo PI;
size_t cbLine = 0;
size_t offPos = 0;
size_t i = 0;
// header
if (!pIE->fHeaderDone)
{
Call(WriteTifHeader(pIE));
}
// body
PI.pGUIDPixFmt = &pIE->guidPixFormat;
PixelFormatLookup(&PI, LOOKUP_FORWARD);
cbLine = (BD_1 == PI.bdBitDepth ? ((PI.cbitUnit * pIE->uWidth + 7) >> 3) : (((PI.cbitUnit + 7) >> 3) * pIE->uWidth));
FailIf(cbStride < cbLine, WMP_errInvalidParameter);
offPos = pIE->offPixel + cbLine * pIE->idxCurrentLine;
Call(pS->SetPos(pS, offPos));
for (i = 0; i < cLine; ++i)
{
Call(pS->Write(pS, pbPixel + cbStride * i, cbLine));
}
pIE->idxCurrentLine += cLine;
Cleanup:
return err;
}
ERR PKImageEncode_Create_TIF(PKImageEncode** ppIE)
{
ERR err = WMP_errSuccess;
PKImageEncode* pIE = NULL;
Call(PKImageEncode_Create(ppIE));
pIE = *ppIE;
pIE->WritePixels = PKImageEncode_WritePixels_TIF;
Cleanup:
return err;
}
//================================================================
// PKImageDecode_TIF helpers
//================================================================
ERR GetTifUShort(
struct WMPStream* pWS,
size_t offPos,
Bool fLittleEndian,
U16* puValue)
{
ERR err = WMP_errSuccess;
U8 buf[2];
Call(pWS->SetPos(pWS, offPos));
Call(pWS->Read(pWS, buf, sizeof2(buf)));
if (fLittleEndian)
{
*puValue = buf[0] + ((U16)buf[1] << 8);
}
else
{
*puValue = ((U16)buf[0] << 8) + buf[1];
}
Cleanup:
return err;
}
ERR GetTifULong(
struct WMPStream* pWS,
size_t offPos,
Bool fLittleEndian,
U32* puValue)
{
ERR err = WMP_errSuccess;
U8 buf[4];
Call(pWS->SetPos(pWS, offPos));
Call(pWS->Read(pWS, buf, sizeof2(buf)));
if (fLittleEndian)
{
*puValue = buf[0] + ((U32)buf[1] << 8) + ((U32)buf[2] << 16) + ((U32)buf[3] << 24);
}
else
{
*puValue = ((U32)buf[0] << 24) + ((U32)buf[1] << 16) + ((U32)buf[2] << 8) + buf[3];
}
Cleanup:
return err;
}
ERR GetTifULongArray(
struct WMPStream* pWS,
size_t offPos,
size_t cElements,
Bool fLittleEndian,
U32* puValue)
{
ERR err = WMP_errSuccess;
if (1 == cElements)
{
puValue[0] = (U32)offPos;
}
else
{
size_t i = 0;
for (i = 0; i < cElements; ++i)
{
Call(GetTifULong(pWS, offPos, fLittleEndian, &puValue[i]));
offPos += sizeof(*puValue);
}
}
Cleanup:
return err;
}
ERR ParseTifDEValue(
PKTestDecode* pID,
U16 uTag,
U16 uType,
U32 uCount)
{
ERR err = WMP_errSuccess;
struct WMPStream* pWS = pID->pStream;
U16 bpc[9] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
U16 sf[9] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
U32 uPos = 0;
U16 usValue = 0;
U32 uValue0 = 0;
U32 uValue1 = 0;
size_t i, offPos = 0;
//================================
Call(pWS->GetPos(pWS, &offPos));
//================================
switch (uType)
{
case TIF_typSHORT:
Call(GetTifUShort(pWS, offPos, pID->EXT.TIF.fLittleEndian, &usValue));
uValue0 = usValue;
break;
case TIF_typLONG:
Call(GetTifULong(pWS, offPos, pID->EXT.TIF.fLittleEndian, &uValue0));
break;
}
//================================
switch (uTag)
{
case TIF_tagNewSubfileType:
FailIf(0 != uValue0, WMP_errUnsupportedFormat);
break;
case TIF_tagSubfileType:
case TIF_tagPredictor:
FailIf(1 != uValue0, WMP_errUnsupportedFormat);
break;
case TIF_tagImageWidth:
pID->uWidth = uValue0;
break;
case TIF_tagImageLength:
pID->uHeight = uValue0;
break;
case TIF_tagBitsPerSample:
if (1 == uCount)
{
pID->EXT.TIF.uBitsPerSample = uValue0;
}
else
{
Bool bpcAnd = 1;
Call(GetTifULong(pWS, offPos, pID->EXT.TIF.fLittleEndian, &uPos));
offPos = uPos;
Call(GetTifUShort(pWS, offPos, pID->EXT.TIF.fLittleEndian, &bpc[0]));
for (i = 1; i < uCount; i++)
{
Call(GetTifUShort(pWS, offPos + (i << 1) , pID->EXT.TIF.fLittleEndian, &bpc[i]));
bpcAnd = (bpcAnd && (bpc[0] == bpc[i]));
}
if (bpcAnd)
pID->EXT.TIF.uBitsPerSample = bpc[0];
else
Call(WMP_errUnsupportedFormat);
}
break;
case TIF_tagExtraSamples:
FailIf(0 != uValue0 && 1 != uValue0 && 2 != uValue0, WMP_errUnsupportedFormat);
pID->EXT.TIF.uExtraSamples = uValue0;
break;
case TIF_tagSampleFormat:
if (1 == uCount)
{
pID->EXT.TIF.uSampleFormat = uValue0;
}
else
{
Bool sfAnd = 1;
Call(GetTifULong(pWS, offPos, pID->EXT.TIF.fLittleEndian, &uPos));
offPos = uPos;
Call(GetTifUShort(pWS, offPos, pID->EXT.TIF.fLittleEndian, &sf[0]));
for (i = 1; i < uCount; i++)
{
Call(GetTifUShort(pWS, offPos + (i << 1) , pID->EXT.TIF.fLittleEndian, &sf[i]));
sfAnd = (sfAnd && (sf[0] == sf[i]));
}
if (sfAnd)
pID->EXT.TIF.uSampleFormat = sf[0];
else
Call(WMP_errUnsupportedFormat);
}
break;
case TIF_tagCompression:
FailIf(1 != uValue0, WMP_errUnsupportedFormat);
break;
case TIF_tagPhotometricInterpretation:
Test(PK_PI_W0 == uValue0 || PK_PI_B0 == uValue0 || PK_PI_RGB == uValue0
|| PK_PI_RGBPalette == uValue0 || PK_PI_TransparencyMask == uValue0
|| PK_PI_CMYK == uValue0 || PK_PI_YCbCr == uValue0
|| PK_PI_CIELab == uValue0, WMP_errUnsupportedFormat);
pID->EXT.TIF.uInterpretation = uValue0;
break;
case TIF_tagStripOffsets:
Call(WMPAlloc((void **) &pID->EXT.TIF.uStripOffsets, sizeof(*pID->EXT.TIF.uStripOffsets) * uCount));
Call(GetTifULong(pWS, offPos, pID->EXT.TIF.fLittleEndian, &uValue0));
Call(GetTifULongArray(pWS, uValue0, uCount, pID->EXT.TIF.fLittleEndian, pID->EXT.TIF.uStripOffsets));
break;
case TIF_tagOrientation:
case TIF_tagSamplesPerPixel:
pID->EXT.TIF.uSamplePerPixel = uValue0;
break;
case TIF_tagRowsPerStrip:
pID->EXT.TIF.uRowsPerStrip = uValue0;
break;
case TIF_tagStripByteCounts:
Call(WMPAlloc((void **) &pID->EXT.TIF.uStripByteCounts, sizeof(*pID->EXT.TIF.uStripByteCounts) * uCount));
Call(GetTifULong(pWS, offPos, pID->EXT.TIF.fLittleEndian, &uValue0));
Call(GetTifULongArray(pWS, uValue0, uCount, pID->EXT.TIF.fLittleEndian, pID->EXT.TIF.uStripByteCounts));
break;
case TIF_tagXResolution:
Call(GetTifULong(pWS, offPos, pID->EXT.TIF.fLittleEndian, &uPos));
offPos = uPos;
Call(GetTifULong(pWS, offPos, pID->EXT.TIF.fLittleEndian, &uValue0));//numerator
Call(GetTifULong(pWS, offPos + 4, pID->EXT.TIF.fLittleEndian, &uValue1));//denominator
pID->EXT.TIF.fResX = (Float)uValue0/(Float)uValue1;
break;
case TIF_tagYResolution:
Call(GetTifULong(pWS, offPos, pID->EXT.TIF.fLittleEndian, &uPos));
offPos = uPos;
Call(GetTifULong(pWS, offPos, pID->EXT.TIF.fLittleEndian, &uValue0));//numerator
Call(GetTifULong(pWS, offPos + 4, pID->EXT.TIF.fLittleEndian, &uValue1));//denominator
pID->EXT.TIF.fResY = (Float)uValue0/(Float)uValue1;
break;
case TIF_tagResolutionUnit:
pID->EXT.TIF.uResolutionUnit = usValue;
break;
case TIF_tagPlanarConfiguration:
case TIF_tagSoftware:
case TIF_tagColorMap:
break;
default:
printf("Unrecognized TIFTag: %d(%#x), %d, %d" CRLF, (int)uTag, (int)uTag, (int)uType, (int)uCount);
break;
}
Cleanup:
return err;
}
ERR ParseTifDEArray(
PKTestDecode* pID,
size_t offPos)
{
ERR err = WMP_errSuccess;
struct WMPStream* pWS = pID->pStream;
U16 uTag = 0;
U16 uType = 0;
U32 uCount = 0;
Call(GetTifUShort(pWS, offPos, pID->EXT.TIF.fLittleEndian, &uTag));
offPos += 2;
Call(GetTifUShort(pWS, offPos, pID->EXT.TIF.fLittleEndian, &uType));
offPos += 2;
Call(GetTifULong(pWS, offPos, pID->EXT.TIF.fLittleEndian, &uCount));
offPos += 4;
Call(ParseTifDEValue(pID, uTag, uType, uCount));
Cleanup:
return err;
}
ERR ParseTifHeader(
PKTestDecode* pID,
struct WMPStream* pWS)
{
ERR err = WMP_errSuccess;
PKPixelInfo PI;
size_t offPosBase = 0;
size_t offPos = 0;
U8 szSig[3] = {0, 0, '\0'};
U16 uTiffId = 0;
U32 uOffNextIFD = 0;
U16 uCountDE = 0, i = 0;
//default
pID->EXT.TIF.uRowsPerStrip = (U32) -1;
pID->EXT.TIF.uInterpretation = (U32) -1;
pID->EXT.TIF.uSamplePerPixel = (U32) -1;
pID->EXT.TIF.uBitsPerSample = (U32) -1;
pID->EXT.TIF.uSampleFormat = 1;
pID->EXT.TIF.uResolutionUnit = 2;
pID->EXT.TIF.fResX = 96;
pID->EXT.TIF.fResY = 96;
//================================
Call(pWS->GetPos(pWS, &offPosBase));
FailIf(0 != offPosBase, WMP_errUnsupportedFormat);
//================================
// Header
Call(pWS->Read(pWS, szSig, 2));
offPos += 2;
if (szSig == (U8 *) strstr((char *) szSig, "II"))
{
pID->EXT.TIF.fLittleEndian = !FALSE;
}
else if (szSig == (U8 *) strstr((char *) szSig, "MM"))
{
pID->EXT.TIF.fLittleEndian = FALSE;
}
else
{
Call(WMP_errUnsupportedFormat);
}
Call(GetTifUShort(pWS, offPos, pID->EXT.TIF.fLittleEndian, &uTiffId));
offPos += 2;
FailIf(42 != uTiffId, WMP_errUnsupportedFormat);
Call(GetTifULong(pWS, offPos, pID->EXT.TIF.fLittleEndian, &uOffNextIFD));
offPos += 4;
//================================
// IFD
offPos = (size_t)uOffNextIFD;
Call(GetTifUShort(pWS, offPos, pID->EXT.TIF.fLittleEndian, &uCountDE));
offPos += 2;
for (i = 0; i < uCountDE; ++i)
{
Call(ParseTifDEArray(pID, offPos));
offPos += 12;
}
if(pID->EXT.TIF.uRowsPerStrip == -1)
pID->EXT.TIF.uRowsPerStrip = pID->uHeight;//default
FailIf((-1 == pID->EXT.TIF.uInterpretation
|| -1 == pID->EXT.TIF.uSamplePerPixel
|| -1 == pID->EXT.TIF.uBitsPerSample), WMP_errUnsupportedFormat);
PI.uInterpretation = pID->EXT.TIF.uInterpretation;
PI.uSamplePerPixel = pID->EXT.TIF.uSamplePerPixel;
PI.uBitsPerSample = pID->EXT.TIF.uBitsPerSample;
PI.uSampleFormat = pID->EXT.TIF.uSampleFormat;
PI.grBit = pID->EXT.TIF.uExtraSamples == 1 || pID->EXT.TIF.uExtraSamples == 2 ||
/* Workaround for some images without correct info about alpha channel */
(pID->EXT.TIF.uExtraSamples == 0 && pID->EXT.TIF.uSamplePerPixel > 3) ? PK_pixfmtHasAlpha : 0x0;
PI.grBit |= pID->EXT.TIF.uExtraSamples == 1 ? PK_pixfmtPreMul : 0x0;
pID->fResX = (3 == pID->EXT.TIF.uResolutionUnit ? (Float)(pID->EXT.TIF.fResX * 2.54) : pID->EXT.TIF.fResX);//cm -> inch
pID->fResY = (3 == pID->EXT.TIF.uResolutionUnit ? (Float)(pID->EXT.TIF.fResY * 2.54) : pID->EXT.TIF.fResY);//cm -> inch
Call(PixelFormatLookup(&PI, LOOKUP_BACKWARD_TIF));
pID->guidPixFormat = *(PI.pGUIDPixFmt);
Cleanup:
return err;
}
//================================================================
// PKImageDecode_TIF
//================================================================
ERR PKImageDecode_Initialize_TIF(
PKTestDecode* pID,
struct WMPStream* pWS)
{
ERR err = WMP_errSuccess;
Call(PKTestDecode_Initialize(pID, pWS));
Call(ParseTifHeader(pID, pWS));
Cleanup:
return err;
}
ERR GetScanLineOffset(
PKTestDecode* pID,
I32 iLine,
U32 cbLine,
U32 *offLine)
{
*offLine = pID->EXT.TIF.uRowsPerStrip ?
(pID->EXT.TIF.uStripOffsets[iLine / pID->EXT.TIF.uRowsPerStrip] +
cbLine * (iLine % pID->EXT.TIF.uRowsPerStrip)) :
0;
return WMP_errSuccess;
}
ERR PKImageDecode_Copy_TIF(
PKTestDecode* pID,
const PKRect* pRect,
U8* pb,
U32 cbStride)
{
ERR err = WMP_errSuccess;
struct WMPStream* pS = pID->pStream;
PKPixelInfo PI;
U32 cbLine = 0;
I32 i = 0;
PI.pGUIDPixFmt = &pID->guidPixFormat;
PixelFormatLookup(&PI, LOOKUP_FORWARD);
cbLine = (BD_1 == PI.bdBitDepth ? ((PI.cbitUnit * pRect->Width + 7) >> 3) : (((PI.cbitUnit + 7) >> 3) * pRect->Width));
assert(0 == pRect->X && pID->uWidth == (U32)pRect->Width);
assert(cbLine <= cbStride);
for (i = 0; i < pRect->Height; ++i)
{
U32 offPixels = 0;
Call(GetScanLineOffset(pID, pRect->Y + i, cbLine, &offPixels));
Call(pS->SetPos(pS, offPixels));
Call(pS->Read(pS, pb + cbStride * i, cbLine));
if (PK_PI_W0 == pID->EXT.TIF.uInterpretation)
{
U32 j, begin = cbStride * (U32)i, end = begin + cbLine;
for (j = begin; j < end; ++j)
{
pb[j] = ~pb[j];
}
}
}
Cleanup:
return err;
}
ERR PKImageDecode_Release_TIF(PKTestDecode** ppID)
{
ERR err = WMP_errSuccess;
PKTestDecode *pID = *ppID;
Call(WMPFree(&pID->EXT.TIF.uStripOffsets));
Call(WMPFree(&pID->EXT.TIF.uStripByteCounts));
Call(PKTestDecode_Release(ppID));
Cleanup:
return err;
}
ERR PKImageDecode_Create_TIF(PKTestDecode** ppID)
{
ERR err = WMP_errSuccess;
PKTestDecode* pID = NULL;
Call(PKTestDecode_Create(ppID));
pID = *ppID;
pID->Initialize = PKImageDecode_Initialize_TIF;
pID->Copy = PKImageDecode_Copy_TIF;
pID->Release = PKImageDecode_Release_TIF;
Cleanup:
return err;
}

723
jxrlib/jxrtestlib/JXRTestYUV.c
View file

@ -1,723 +0,0 @@
//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#include <stdlib.h>
#include <string.h>
#include <JXRGlue.h>
#pragma pack(push, 1)
#pragma pack(pop)
//================================================================
// PKImageEncode_Iyuv
//================================================================
ERR WriteIYUVHeader(
PKImageEncode* pIE)
{
ERR err = WMP_errSuccess;
// struct WMPStream* pS = pIE->pStream;
pIE->offPixel = 0;
pIE->cbPixel = 3;
pIE->fHeaderDone = !FALSE;
return err;
}
//================================================================
// PKImageEncode_Yuv422
//================================================================
ERR WriteYUV422Header(
PKImageEncode* pIE)
{
ERR err = WMP_errSuccess;
// struct WMPStream* pS = pIE->pStream;
pIE->offPixel = 0;
pIE->cbPixel = 3;
pIE->fHeaderDone = !FALSE;
return err;
}
//================================================================
// PKImageEncode_Yuv444
//================================================================
ERR WriteYUV444Header(
PKImageEncode* pIE)
{
ERR err = WMP_errSuccess;
// struct WMPStream* pS = pIE->pStream;
pIE->offPixel = 0;
pIE->cbPixel = 3;
pIE->fHeaderDone = !FALSE;
return err;
}
ERR PKImageEncode_WritePixels_IYUV(
PKImageEncode* pIE,
U32 cLine,
U8* pbPixel,
U32 cbStride)
{
ERR err = WMP_errSuccess;
struct WMPStream* pS = pIE->pStream;
size_t iRow, iCol;
U32 uYSize, uUVSize;
U8 *pY;
U8 *pU;
U8 *pV;
UNREFERENCED_PARAMETER( cbStride );
// header
if (!pIE->fHeaderDone)
{
Call(WriteIYUVHeader(pIE));
}
//from packed to planar:
uYSize = cLine * pIE->uWidth;
uUVSize = (uYSize >> 2);
pY = (U8 *)malloc(uYSize);
pU = (U8 *)malloc(uUVSize);
pV = (U8 *)malloc(uUVSize);
if(pY == NULL || pU == NULL || pV == NULL)
{
return ICERR_ERROR;
}
for (iRow = 0; iRow < pIE->uHeight; iRow += 2, pY += pIE->uWidth)
{
for (iCol = 0; iCol < pIE->uWidth; iCol += 2, pY += 2)
{
*pY = *pbPixel;
pbPixel++;
*(pY + 1)= *pbPixel;
pbPixel++;
*(pY + pIE->uWidth) = *pbPixel;
pbPixel++;
*(pY + pIE->uWidth + 1) = *pbPixel;
pbPixel++;
*pU = *pbPixel;
pbPixel++; pU++;
*pV = *pbPixel;
pbPixel++; pV++;
}
}
pY-=uYSize;
pU-=uUVSize;
pV-=uUVSize;
Call(pS->Write(pS, pY, uYSize));
Call(pS->Write(pS, pU, uUVSize));
Call(pS->Write(pS, pV, uUVSize));
if(pY!=NULL)
free(pY);
if(pU!=NULL)
free(pU);
if(pV!=NULL)
free(pV);
pIE->idxCurrentLine += cLine;
Cleanup:
return err;
}
ERR PKImageEncode_WritePixels_YUV422(
PKImageEncode* pIE,
U32 cLine,
U8* pbPixel,
U32 cbStride)
{
ERR err = WMP_errSuccess;
struct WMPStream* pS = pIE->pStream;
size_t iRow, iCol;
U32 uYSize, uUVSize;
U8 *pY;
U8 *pU;
U8 *pV;
UNREFERENCED_PARAMETER( cbStride );
// header
if (!pIE->fHeaderDone)
{
Call(WriteIYUVHeader(pIE));
}
//from packed to planar:
uYSize = cLine * pIE->uWidth;
uUVSize = (uYSize >> 1);
pY = (U8 *)malloc(uYSize);
pU = (U8 *)malloc(uUVSize);
pV = (U8 *)malloc(uUVSize);
if(pY == NULL || pU == NULL || pV == NULL)
{
return ICERR_ERROR;
}
//YYUV
for (iRow = 0; iRow < pIE->uHeight; iRow += 1)
{
for (iCol = 0; iCol < pIE->uWidth; iCol += 2)
{
*pU = *pbPixel;
pbPixel++; pU++;
*pY = *pbPixel;
pbPixel++; pY++;
*pV = *pbPixel;
pbPixel++; pV++;
*pY = *pbPixel;
pbPixel++; pY++;
}
}
pY-=uYSize;
pU-=uUVSize;
pV-=uUVSize;
Call(pS->Write(pS, pY, uYSize));
Call(pS->Write(pS, pU, uUVSize));
Call(pS->Write(pS, pV, uUVSize));
if(pY!=NULL)
free(pY);
if(pU!=NULL)
free(pU);
if(pV!=NULL)
free(pV);
pIE->idxCurrentLine += cLine;
Cleanup:
return err;
}
ERR PKImageEncode_WritePixels_YUV444(
PKImageEncode* pIE,
U32 cLine,
U8* pbPixel,
U32 cbStride)
{
ERR err = WMP_errSuccess;
struct WMPStream* pS = pIE->pStream;
size_t iRow, iCol;
U32 uYSize, uUVSize;
U8 *pY;
U8 *pU;
U8 *pV;
UNREFERENCED_PARAMETER( cbStride );
// header
if (!pIE->fHeaderDone)
{
Call(WriteIYUVHeader(pIE));
}
//from packed to planar:
uYSize = cLine * pIE->uWidth;
uUVSize = uYSize;
pY = (U8 *)malloc(uYSize);
pU = (U8 *)malloc(uUVSize);
pV = (U8 *)malloc(uUVSize);
if(pY == NULL || pU == NULL || pV == NULL)
{
return ICERR_ERROR;
}
for (iRow = 0; iRow < pIE->uHeight; iRow += 1)
{
for (iCol = 0; iCol < pIE->uWidth; iCol += 1)
{
*pY = *pbPixel;
pbPixel++; pY++;
*pU = *pbPixel;
pbPixel++; pU++;
*pV = *pbPixel;
pbPixel++; pV++;
}
}
pY-=uYSize;
pU-=uUVSize;
pV-=uUVSize;
Call(pS->Write(pS, pY, uYSize));
Call(pS->Write(pS, pU, uUVSize));
Call(pS->Write(pS, pV, uUVSize));
if(pY!=NULL)
free(pY);
if(pU!=NULL)
free(pU);
if(pV!=NULL)
free(pV);
pIE->idxCurrentLine += cLine;
Cleanup:
return err;
}
ERR PKImageEncode_Create_IYUV(
PKImageEncode** ppIE)
{
ERR err = WMP_errSuccess;
PKImageEncode* pIE = NULL;
Call(PKImageEncode_Create(ppIE));
pIE = *ppIE;
pIE->WritePixels = PKImageEncode_WritePixels_IYUV;
Cleanup:
return err;
}
ERR PKImageEncode_Create_YUV422(
PKImageEncode** ppIE)
{
ERR err = WMP_errSuccess;
PKImageEncode* pIE = NULL;
Call(PKImageEncode_Create(ppIE));
pIE = *ppIE;
pIE->WritePixels = PKImageEncode_WritePixels_YUV422;
Cleanup:
return err;
}
ERR PKImageEncode_Create_YUV444(
PKImageEncode** ppIE)
{
ERR err = WMP_errSuccess;
PKImageEncode* pIE = NULL;
Call(PKImageEncode_Create(ppIE));
pIE = *ppIE;
pIE->WritePixels = PKImageEncode_WritePixels_YUV444;
Cleanup:
return err;
}
//================================================================
// PKImageDecode_IYUV
//================================================================
ERR ParseIYUVHeader(
PKImageDecode* pID,
struct WMPStream* pWS)
{
ERR err = WMP_errSuccess;
UNREFERENCED_PARAMETER( pWS );
// Set header other header parameters
pID->guidPixFormat = GUID_PKPixelFormat12bppYUV420;
pID->uHeight = 144;
pID->uWidth = 176;
//I don't need offpixel for raw data! Call(pWS->GetPos(pWS, &pID->YUV420.offPixel));
return err;
}
//================================================================
// PKImageDecode_YUV422
//================================================================
ERR ParseYUV422Header(
PKImageDecode* pID,
struct WMPStream* pWS)
{
ERR err = WMP_errSuccess;
UNREFERENCED_PARAMETER( pWS );
// Set header other header parameters
pID->guidPixFormat = GUID_PKPixelFormat16bppYUV422;
pID->uHeight = 144;
pID->uWidth = 176;
return err;
}
//================================================================
// PKImageDecode_YUV422
//================================================================
ERR ParseYUV444Header(
PKImageDecode* pID,
struct WMPStream* pWS)
{
ERR err = WMP_errSuccess;
UNREFERENCED_PARAMETER( pWS );
// Set header other header parameters
pID->guidPixFormat = GUID_PKPixelFormat24bppYUV444;
pID->uHeight = 144;
pID->uWidth = 176;
return err;
}
ERR PKImageDecode_Initialize_IYUV(
PKImageDecode* pID,
struct WMPStream* pWS)
{
ERR err = WMP_errSuccess;
Call(PKImageDecode_Initialize(pID, pWS));
Call(ParseIYUVHeader(pID, pWS));
Cleanup:
return err;
}
ERR PKImageDecode_Initialize_YUV422(
PKImageDecode* pID,
struct WMPStream* pWS)
{
ERR err = WMP_errSuccess;
Call(PKImageDecode_Initialize(pID, pWS));
Call(ParseYUV422Header(pID, pWS));
Cleanup:
return err;
}
ERR PKImageDecode_Initialize_YUV444(
PKImageDecode* pID,
struct WMPStream* pWS)
{
ERR err = WMP_errSuccess;
Call(PKImageDecode_Initialize(pID, pWS));
Call(ParseYUV444Header(pID, pWS));
Cleanup:
return err;
}
ERR PKImageDecode_Copy_IYUV(
PKImageDecode* pID,
const PKRect* pRect,
U8* pb,
U32 cbStride)
{
ERR err = WMP_errSuccess;
U32 uYSize, uUVSize;
U8 *pY;
U8 *pU;
U8 *pV;
struct WMPStream* pS = pID->pStream;
size_t iRow, iCol;
UNREFERENCED_PARAMETER( pRect );
UNREFERENCED_PARAMETER( cbStride );
//from planar to packed! YYYYUV YYYYUV
uYSize = pID->uWidth * pID->uHeight;
uUVSize = (uYSize >> 2);
pY = (U8 *)malloc(uYSize);
pU = (U8 *)malloc(uUVSize);
pV = (U8 *)malloc(uUVSize);
if(pY == NULL || pU == NULL || pV == NULL)
{
return ICERR_ERROR;
}
Call(pS->Read(pS, pY, uYSize));
Call(pS->Read(pS, pU, uUVSize));
Call(pS->Read(pS, pV, uUVSize));
//re-organize it to Y0 Y1
// Y2 Y3 U V
for (iRow = 0; iRow < pID->uHeight; iRow += 2, pY += pID->uWidth)
{
for (iCol = 0; iCol < pID->uWidth; iCol += 2, pY += 2)
{
*pb = *pY;
pb++;
*pb = *(pY + 1);
pb++;
*pb = *(pY + pID->uWidth);
pb++;
*pb = *(pY + pID->uWidth + 1);
pb++;
*pb = *pU;
pb++; pU++;
*pb = *pV;
pb++; pV++;
}
}
pY-=uYSize;
pU-=uUVSize;
pV-=uUVSize;
if(pY!=NULL)
free(pY);
if(pU!=NULL)
free(pU);
if(pV!=NULL)
free(pV);
Cleanup:
return err;
}
ERR PKImageDecode_Copy_YUV422(
PKImageDecode* pID,
const PKRect* pRect,
U8* pb,
U32 cbStride)
{
ERR err = WMP_errSuccess;
U32 uYSize, uUVSize;
U8 *pY;
U8 *pU;
U8 *pV;
struct WMPStream* pS = pID->pStream;
size_t iRow, iCol;
UNREFERENCED_PARAMETER( pRect );
UNREFERENCED_PARAMETER( cbStride );
uYSize = pID->uWidth * pID->uHeight;
uUVSize = (uYSize >> 1);
pY = (U8 *)malloc(uYSize);
pU = (U8 *)malloc(uUVSize);
pV = (U8 *)malloc(uUVSize);
if(pY == NULL || pU == NULL || pV == NULL)
{
return ICERR_ERROR;
}
Call(pS->Read(pS, pY, uYSize));
Call(pS->Read(pS, pU, uUVSize));
Call(pS->Read(pS, pV, uUVSize));
//re-organize to iMode 0 : YYUV
for (iRow = 0; iRow < pID->uHeight; iRow += 1)
{
for (iCol = 0; iCol < pID->uWidth; iCol += 2)
{
*pb = *pU;
pb++; pU++;
*pb = *pY;
pb++; pY++;
*pb = *pV;
pb++; pV++;
*pb = *pY;
pb++; pY++;
}
}
pY-=uYSize;
pU-=uUVSize;
pV-=uUVSize;
if(pY!=NULL)
free(pY);
if(pU!=NULL)
free(pU);
if(pV!=NULL)
free(pV);
Cleanup:
return err;
}
ERR PKImageDecode_Copy_YUV444(
PKImageDecode* pID,
const PKRect* pRect,
U8* pb,
U32 cbStride)
{
ERR err = WMP_errSuccess;
U32 uYSize, uUVSize;
U8 *pY;
U8 *pU;
U8 *pV;
struct WMPStream* pS = pID->pStream;
size_t iRow, iCol;
UNREFERENCED_PARAMETER( pRect );
UNREFERENCED_PARAMETER( cbStride );
//from planar to packed! YYYYUV YYYYUV
uYSize = pID->uWidth * pID->uHeight;
uUVSize = uYSize;
pY = (U8 *)malloc(uYSize);
pU = (U8 *)malloc(uUVSize);
pV = (U8 *)malloc(uUVSize);
if(pY == NULL || pU == NULL || pV == NULL)
{
return ICERR_ERROR;
}
Call(pS->Read(pS, pY, uYSize));
Call(pS->Read(pS, pU, uUVSize));
Call(pS->Read(pS, pV, uUVSize));
//Organize it as YUVYUVYUV...
for (iRow = 0; iRow < pID->uHeight; iRow += 1)
{
for (iCol = 0; iCol < pID->uWidth; iCol += 1)
{
*pb = *pY;
pb++; pY++;
*pb = *pU;
pb++; pU++;
*pb = *pV;
pb++; pV++;
}
}
pY-=uYSize;
pU-=uUVSize;
pV-=uUVSize;
if(pY!=NULL)
free(pY);
if(pU!=NULL)
free(pU);
if(pV!=NULL)
free(pV);
Cleanup:
return err;
}
ERR PKImageDecode_Create_IYUV(
PKImageDecode** ppID)
{
ERR err = WMP_errSuccess;
PKImageDecode* pID = NULL;
Call(PKImageDecode_Create(ppID));
pID = *ppID;
pID->Initialize = PKImageDecode_Initialize_IYUV;
pID->Copy = PKImageDecode_Copy_IYUV;
Cleanup:
return err;
}
ERR PKImageDecode_Create_YUV422(
PKImageDecode** ppID)
{
ERR err = WMP_errSuccess;
PKImageDecode* pID = NULL;
Call(PKImageDecode_Create(ppID));
pID = *ppID;
pID->Initialize = PKImageDecode_Initialize_YUV422;
pID->Copy = PKImageDecode_Copy_YUV422;
Cleanup:
return err;
}
ERR PKImageDecode_Create_YUV444(
PKImageDecode** ppID)
{
ERR err = WMP_errSuccess;
PKImageDecode* pID = NULL;
Call(PKImageDecode_Create(ppID));
pID = *ppID;
pID->Initialize = PKImageDecode_Initialize_YUV444;
pID->Copy = PKImageDecode_Copy_YUV444;
Cleanup:
return err;
}