Reduce usage of operator LPCWSTR from CFX_WideString().
[pdfium.git] / core / src / fpdfapi / fpdf_parser / fpdf_parser_decode.cpp
index 74e81d4..0bb66da 100644 (file)
-// Copyright 2014 PDFium Authors. All rights reserved.\r
-// Use of this source code is governed by a BSD-style license that can be\r
-// found in the LICENSE file.\r
\r
-// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com\r
-\r
-#include "../../../include/fpdfapi/fpdf_parser.h"\r
-#include "../../../include/fpdfapi/fpdf_module.h"\r
-#include "../../../include/fxcodec/fx_codec.h"\r
-#include <limits.h>\r
-#define _STREAM_MAX_SIZE_              20 * 1024 * 1024\r
-FX_DWORD _A85Decode(const FX_BYTE* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size)\r
-{\r
-    dest_size = 0;\r
-    dest_buf = NULL;\r
-    if (src_size == 0) {\r
-        return 0;\r
-    }\r
-    FX_DWORD orig_size = dest_size;\r
-    FX_DWORD zcount = 0;\r
-    FX_DWORD pos = 0;\r
-    while (pos < src_size) {\r
-        FX_BYTE ch = src_buf[pos];\r
-        if (ch < '!' && ch != '\n' && ch != '\r' && ch != ' ' && ch != '\t') {\r
-            break;\r
-        }\r
-        if (ch == 'z') {\r
-            zcount ++;\r
-        } else if (ch > 'u') {\r
-            break;\r
-        }\r
-        pos ++;\r
-    }\r
-    if (pos == 0) {\r
-        return 0;\r
-    }\r
-    if (zcount > UINT_MAX / 4) {\r
-        return (FX_DWORD) - 1;\r
-    }\r
-    if (zcount * 4 > UINT_MAX - (pos - zcount)) {\r
-        return (FX_DWORD) - 1;\r
-    }\r
-    dest_buf = FX_Alloc(FX_BYTE, zcount * 4 + (pos - zcount));\r
-    if (dest_buf == NULL) {\r
-        return (FX_DWORD) - 1;\r
-    }\r
-    int state = 0, res = 0;\r
-    pos = dest_size = 0;\r
-    while (pos < src_size) {\r
-        FX_BYTE ch = src_buf[pos++];\r
-        if (ch == '\n' || ch == '\r' || ch == ' ' || ch == '\t') {\r
-            continue;\r
-        }\r
-        if (ch == 'z') {\r
-            FXSYS_memset32(dest_buf + dest_size, 0, 4);\r
-            state = 0;\r
-            res = 0;\r
-            dest_size += 4;\r
-        } else {\r
-            if (ch < '!' || ch > 'u') {\r
-                break;\r
-            }\r
-            res = res * 85 + ch - 33;\r
-            state ++;\r
-            if (state == 5) {\r
-                for (int i = 0; i < 4; i ++) {\r
-                    dest_buf[dest_size++] = (FX_BYTE)(res >> (3 - i) * 8);\r
-                }\r
-                state = 0;\r
-                res = 0;\r
-            }\r
-        }\r
-    }\r
-    if (state) {\r
-        int i;\r
-        for (i = state; i < 5; i ++) {\r
-            res = res * 85 + 84;\r
-        }\r
-        for (i = 0; i < state - 1; i ++) {\r
-            dest_buf[dest_size++] = (FX_BYTE)(res >> (3 - i) * 8);\r
-        }\r
-    }\r
-    if (pos < src_size && src_buf[pos] == '>') {\r
-        pos ++;\r
-    }\r
-    return pos;\r
-}\r
-FX_DWORD _HexDecode(const FX_BYTE* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size)\r
-{\r
-    FX_DWORD orig_size = dest_size;\r
-    FX_DWORD i;\r
-    for (i = 0; i < src_size; i ++)\r
-        if (src_buf[i] == '>') {\r
-            break;\r
-        }\r
-    dest_buf = FX_Alloc( FX_BYTE, i / 2 + 1);\r
-    dest_size = 0;\r
-    FX_BOOL bFirstDigit = TRUE;\r
-    for (i = 0; i < src_size; i ++) {\r
-        FX_BYTE ch = src_buf[i];\r
-        if (ch == ' ' || ch == '\n' || ch == '\t' || ch == '\r') {\r
-            continue;\r
-        }\r
-        int digit;\r
-        if (ch <= '9' && ch >= '0') {\r
-            digit = ch - '0';\r
-        } else if (ch <= 'f' && ch >= 'a') {\r
-            digit = ch - 'a' + 10;\r
-        } else if (ch <= 'F' && ch >= 'A') {\r
-            digit = ch - 'A' + 10;\r
-        } else if (ch == '>') {\r
-            i ++;\r
-            break;\r
-        } else {\r
-            continue;\r
-        }\r
-        if (bFirstDigit) {\r
-            dest_buf[dest_size] = digit * 16;\r
-        } else {\r
-            dest_buf[dest_size ++] += digit;\r
-        }\r
-        bFirstDigit = !bFirstDigit;\r
-    }\r
-    if (!bFirstDigit) {\r
-        dest_size ++;\r
-    }\r
-    return i;\r
-}\r
-FX_DWORD RunLengthDecode(const FX_BYTE* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size)\r
-{\r
-    FX_DWORD orig_size = dest_size;\r
-    FX_DWORD i = 0;\r
-    FX_DWORD old;\r
-    dest_size = 0;\r
-    while (i < src_size) {\r
-        if (src_buf[i] < 128) {\r
-            old = dest_size;\r
-            dest_size += src_buf[i] + 1;\r
-            if (dest_size < old) {\r
-                return (FX_DWORD) - 1;\r
-            }\r
-            i += src_buf[i] + 2;\r
-        } else if (src_buf[i] > 128) {\r
-            old = dest_size;\r
-            dest_size += 257 - src_buf[i];\r
-            if (dest_size < old) {\r
-                return (FX_DWORD) - 1;\r
-            }\r
-            i += 2;\r
-        } else {\r
-            break;\r
-        }\r
-    }\r
-    if (dest_size >= _STREAM_MAX_SIZE_) {\r
-        return -1;\r
-    }\r
-    dest_buf = FX_Alloc( FX_BYTE, dest_size);\r
-    if (!dest_buf) {\r
-        return -1;\r
-    }\r
-    i = 0;\r
-    int dest_count = 0;\r
-    while (i < src_size) {\r
-        if (src_buf[i] < 128) {\r
-            FX_DWORD copy_len = src_buf[i] + 1;\r
-            FX_DWORD buf_left = src_size - i - 1;\r
-            if (buf_left < copy_len) {\r
-                FX_DWORD delta = copy_len - buf_left;\r
-                copy_len = buf_left;\r
-                FXSYS_memset8(dest_buf + dest_count + copy_len, '\0', delta);\r
-            }\r
-            FXSYS_memcpy32(dest_buf + dest_count, src_buf + i + 1, copy_len);\r
-            dest_count += src_buf[i] + 1;\r
-            i += src_buf[i] + 2;\r
-        } else if (src_buf[i] > 128) {\r
-            int fill = 0;\r
-            if (i < src_size - 1) {\r
-                fill = src_buf[i + 1];\r
-            }\r
-            FXSYS_memset8(dest_buf + dest_count, fill, 257 - src_buf[i]);\r
-            dest_count += 257 - src_buf[i];\r
-            i += 2;\r
-        } else {\r
-            break;\r
-        }\r
-    }\r
-    FX_DWORD ret = i + 1;\r
-    if (ret > src_size) {\r
-        ret = src_size;\r
-    }\r
-    return ret;\r
-}\r
-ICodec_ScanlineDecoder* FPDFAPI_CreateFaxDecoder(FX_LPCBYTE src_buf, FX_DWORD src_size, int width, int height,\r
-        const CPDF_Dictionary* pParams)\r
-{\r
-    int K = 0;\r
-    FX_BOOL EndOfLine = FALSE;\r
-    FX_BOOL ByteAlign = FALSE;\r
-    FX_BOOL BlackIs1 = FALSE;\r
-    FX_BOOL Columns = 1728;\r
-    FX_BOOL Rows = 0;\r
-    if (pParams) {\r
-        K = pParams->GetInteger(FX_BSTRC("K"));\r
-        EndOfLine = pParams->GetInteger(FX_BSTRC("EndOfLine"));\r
-        ByteAlign = pParams->GetInteger(FX_BSTRC("EncodedByteAlign"));\r
-        BlackIs1 = pParams->GetInteger(FX_BSTRC("BlackIs1"));\r
-        Columns = pParams->GetInteger(FX_BSTRC("Columns"), 1728);\r
-        Rows = pParams->GetInteger(FX_BSTRC("Rows"));\r
-        if (Rows > USHRT_MAX) {\r
-            Rows = 0;\r
-        }\r
-        if (Columns <= 0 || Rows < 0 || Columns > USHRT_MAX || Rows > USHRT_MAX) {\r
-            return NULL;\r
-        }\r
-    }\r
-    return CPDF_ModuleMgr::Get()->GetFaxModule()->CreateDecoder(src_buf, src_size, width, height,\r
-            K, EndOfLine, ByteAlign, BlackIs1, Columns, Rows);\r
-}\r
-static FX_BOOL CheckFlateDecodeParams(int Colors, int BitsPerComponent, int Columns)\r
-{\r
-    if (Columns < 0) {\r
-        return FALSE;\r
-    }\r
-    int check = Columns;\r
-    if (Colors < 0 || (check > 0 && Colors > INT_MAX / check)) {\r
-        return FALSE;\r
-    }\r
-    check *= Colors;\r
-    if (BitsPerComponent < 0 ||\r
-            (check > 0 && BitsPerComponent > INT_MAX / check)) {\r
-        return FALSE;\r
-    }\r
-    check *= BitsPerComponent;\r
-    if (check > INT_MAX - 7) {\r
-        return FALSE;\r
-    }\r
-    return TRUE;\r
-}\r
-ICodec_ScanlineDecoder* FPDFAPI_CreateFlateDecoder(FX_LPCBYTE src_buf, FX_DWORD src_size, int width, int height,\r
-        int nComps, int bpc, const CPDF_Dictionary* pParams)\r
-{\r
-    int predictor = 0;\r
-    FX_BOOL bEarlyChange = TRUE;\r
-    int Colors = 0, BitsPerComponent = 0, Columns = 0;\r
-    if (pParams) {\r
-        predictor = ((CPDF_Dictionary*)pParams)->GetInteger(FX_BSTRC("Predictor"));\r
-        bEarlyChange = ((CPDF_Dictionary*)pParams)->GetInteger(FX_BSTRC("EarlyChange"), 1);\r
-        Colors = pParams->GetInteger(FX_BSTRC("Colors"), 1);\r
-        BitsPerComponent = pParams->GetInteger(FX_BSTRC("BitsPerComponent"), 8);\r
-        Columns = pParams->GetInteger(FX_BSTRC("Columns"), 1);\r
-        if (!CheckFlateDecodeParams(Colors, BitsPerComponent, Columns)) {\r
-            return NULL;\r
-        }\r
-    }\r
-    return CPDF_ModuleMgr::Get()->GetFlateModule()->CreateDecoder(src_buf, src_size, width, height,\r
-            nComps, bpc, predictor, Colors, BitsPerComponent, Columns);\r
-}\r
-FX_DWORD FPDFAPI_FlateOrLZWDecode(FX_BOOL bLZW, const FX_BYTE* src_buf, FX_DWORD src_size, CPDF_Dictionary* pParams,\r
-                                  FX_DWORD estimated_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size)\r
-{\r
-    int predictor = 0;\r
-    FX_BOOL bEarlyChange = TRUE;\r
-    int Colors = 0, BitsPerComponent = 0, Columns = 0;\r
-    if (pParams) {\r
-        predictor = ((CPDF_Dictionary*)pParams)->GetInteger(FX_BSTRC("Predictor"));\r
-        bEarlyChange = ((CPDF_Dictionary*)pParams)->GetInteger(FX_BSTRC("EarlyChange"), 1);\r
-        Colors = pParams->GetInteger(FX_BSTRC("Colors"), 1);\r
-        BitsPerComponent = pParams->GetInteger(FX_BSTRC("BitsPerComponent"), 8);\r
-        Columns = pParams->GetInteger(FX_BSTRC("Columns"), 1);\r
-        if (!CheckFlateDecodeParams(Colors, BitsPerComponent, Columns)) {\r
-            return (FX_DWORD) - 1;\r
-        }\r
-    }\r
-    return CPDF_ModuleMgr::Get()->GetFlateModule()->FlateOrLZWDecode(bLZW, src_buf, src_size,\r
-            bEarlyChange, predictor, Colors, BitsPerComponent, Columns, estimated_size,\r
-            dest_buf, dest_size);\r
-}\r
-FX_BOOL PDF_DataDecode(FX_LPCBYTE src_buf, FX_DWORD src_size, const CPDF_Dictionary* pDict,\r
-                       FX_LPBYTE& dest_buf, FX_DWORD& dest_size, CFX_ByteString& ImageEncoding,\r
-                       CPDF_Dictionary*& pImageParms, FX_DWORD last_estimated_size, FX_BOOL bImageAcc)\r
-\r
-{\r
-    CPDF_Object* pDecoder = pDict->GetElementValue(FX_BSTRC("Filter"));\r
-    if (pDecoder == NULL || (pDecoder->GetType() != PDFOBJ_ARRAY && pDecoder->GetType() != PDFOBJ_NAME)) {\r
-        return FALSE;\r
-    }\r
-    CPDF_Object* pParams = pDict->GetElementValue(FX_BSTRC("DecodeParms"));\r
-    CFX_ByteStringArray DecoderList;\r
-    CFX_PtrArray ParamList;\r
-    if (pDecoder->GetType() == PDFOBJ_ARRAY) {\r
-        if (pParams && pParams->GetType() != PDFOBJ_ARRAY) {\r
-            pParams = NULL;\r
-        }\r
-        CPDF_Array* pDecoders = (CPDF_Array*)pDecoder;\r
-        for (FX_DWORD i = 0; i < pDecoders->GetCount(); i ++) {\r
-            CFX_ByteStringC str = pDecoders->GetConstString(i);\r
-            DecoderList.Add(str);\r
-            if (pParams) {\r
-                ParamList.Add(((CPDF_Array*)pParams)->GetDict(i));\r
-            } else {\r
-                ParamList.Add(NULL);\r
-            }\r
-        }\r
-    } else {\r
-        DecoderList.Add(pDecoder->GetConstString());\r
-        ParamList.Add(pParams->GetDict());\r
-    }\r
-    FX_LPBYTE last_buf = (FX_LPBYTE)src_buf;\r
-    FX_DWORD last_size = src_size;\r
-    for (int i = 0; i < DecoderList.GetSize(); i ++) {\r
-        int estimated_size = i == DecoderList.GetSize() - 1 ? last_estimated_size : 0;\r
-        CFX_ByteString decoder = DecoderList[i];\r
-        CPDF_Dictionary* pParam = (CPDF_Dictionary*)ParamList[i];\r
-        FX_LPBYTE new_buf = NULL;\r
-        FX_DWORD new_size = (FX_DWORD) - 1;\r
-        int offset = -1;\r
-        if (decoder == FX_BSTRC("FlateDecode") || decoder == FX_BSTRC("Fl")) {\r
-            if (bImageAcc && i == DecoderList.GetSize() - 1) {\r
-                ImageEncoding = FX_BSTRC("FlateDecode");\r
-                dest_buf = (FX_LPBYTE)last_buf;\r
-                dest_size = last_size;\r
-                pImageParms = pParam;\r
-                return TRUE;\r
-            } else {\r
-                offset = FPDFAPI_FlateOrLZWDecode(FALSE, last_buf, last_size, pParam, estimated_size, new_buf, new_size);\r
-            }\r
-        } else if (decoder == FX_BSTRC("LZWDecode") || decoder == FX_BSTRC("LZW")) {\r
-            offset = FPDFAPI_FlateOrLZWDecode(TRUE, last_buf, last_size, pParam, estimated_size, new_buf, new_size);\r
-        } else if (decoder == FX_BSTRC("ASCII85Decode") || decoder == FX_BSTRC("A85")) {\r
-            offset = _A85Decode(last_buf, last_size, new_buf, new_size);\r
-        } else if (decoder == FX_BSTRC("ASCIIHexDecode") || decoder == FX_BSTRC("AHx")) {\r
-            offset = _HexDecode(last_buf, last_size, new_buf, new_size);\r
-        } else if (decoder == FX_BSTRC("RunLengthDecode") || decoder == FX_BSTRC("RL")) {\r
-            if (bImageAcc && i == DecoderList.GetSize() - 1) {\r
-                ImageEncoding = FX_BSTRC("RunLengthDecode");\r
-                dest_buf = (FX_LPBYTE)last_buf;\r
-                dest_size = last_size;\r
-                pImageParms = pParam;\r
-                return TRUE;\r
-            }\r
-            offset = RunLengthDecode(last_buf, last_size, new_buf, new_size);\r
-        } else {\r
-            if (decoder == FX_BSTRC("DCT")) {\r
-                decoder = "DCTDecode";\r
-            } else if (decoder == FX_BSTRC("CCF")) {\r
-                decoder = "CCITTFaxDecode";\r
-            } else if (decoder == FX_BSTRC("Crypt")) {\r
-                continue;\r
-            }\r
-            ImageEncoding = decoder;\r
-            pImageParms = pParam;\r
-            dest_buf = (FX_LPBYTE)last_buf;\r
-            dest_size = last_size;\r
-            return TRUE;\r
-        }\r
-        if (last_buf != src_buf) {\r
-            FX_Free(last_buf);\r
-        }\r
-        if (offset == -1) {\r
-            return FALSE;\r
-        }\r
-        last_buf = new_buf;\r
-        last_size = new_size;\r
-    }\r
-    ImageEncoding = "";\r
-    pImageParms = NULL;\r
-    dest_buf = last_buf;\r
-    dest_size = last_size;\r
-    return TRUE;\r
-}\r
-extern const FX_WORD PDFDocEncoding[256] = {\r
-    0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009,\r
-    0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f, 0x0010, 0x0011, 0x0012, 0x0013,\r
-    0x0014, 0x0015, 0x0016, 0x0017, 0x02d8, 0x02c7, 0x02c6, 0x02d9, 0x02dd, 0x02db,\r
-    0x02da, 0x02dc, 0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,\r
-    0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f, 0x0030, 0x0031,\r
-    0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b,\r
-    0x003c, 0x003d, 0x003e, 0x003f, 0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045,\r
-    0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,\r
-    0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059,\r
-    0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f, 0x0060, 0x0061, 0x0062, 0x0063,\r
-    0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d,\r
-    0x006e, 0x006f, 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,\r
-    0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x0000, 0x2022, 0x2020,\r
-    0x2021, 0x2026, 0x2014, 0x2013, 0x0192, 0x2044, 0x2039, 0x203a, 0x2212, 0x2030,\r
-    0x201e, 0x201c, 0x201d, 0x2018, 0x2019, 0x201a, 0x2122, 0xfb01, 0xfb02, 0x0141,\r
-    0x0152, 0x0160, 0x0178, 0x017d, 0x0131, 0x0142, 0x0153, 0x0161, 0x017e, 0x0000,\r
-    0x20ac, 0x00a1, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7, 0x00a8, 0x00a9,\r
-    0x00aa, 0x00ab, 0x00ac, 0x0000, 0x00ae, 0x00af, 0x00b0, 0x00b1, 0x00b2, 0x00b3,\r
-    0x00b4, 0x00b5, 0x00b6, 0x00b7, 0x00b8, 0x00b9, 0x00ba, 0x00bb, 0x00bc, 0x00bd,\r
-    0x00be, 0x00bf, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7,\r
-    0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf, 0x00d0, 0x00d1,\r
-    0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7, 0x00d8, 0x00d9, 0x00da, 0x00db,\r
-    0x00dc, 0x00dd, 0x00de, 0x00df, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5,\r
-    0x00e6, 0x00e7, 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,\r
-    0x00f0, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7, 0x00f8, 0x00f9,\r
-    0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x00ff\r
-};\r
-CFX_WideString PDF_DecodeText(FX_LPCBYTE src_data, FX_DWORD src_len, CFX_CharMap* pCharMap)\r
-{\r
-    CFX_WideString result;\r
-    if (src_len >= 2 && ((src_data[0] == 0xfe && src_data[1] == 0xff) || (src_data[0] == 0xff && src_data[1] == 0xfe))) {\r
-        FX_BOOL bBE = src_data[0] == 0xfe;\r
-        int max_chars = (src_len - 2) / 2;\r
-        if (!max_chars) {\r
-            return result;\r
-        }\r
-        if (src_data[0] == 0xff) {\r
-            bBE = !src_data[2];\r
-        }\r
-        FX_LPWSTR dest_buf = result.GetBuffer(max_chars);\r
-        FX_LPCBYTE uni_str = src_data + 2;\r
-        int dest_pos = 0;\r
-        for (int i = 0; i < max_chars * 2; i += 2) {\r
-            FX_WORD unicode = bBE ? (uni_str[i] << 8 | uni_str[i + 1]) : (uni_str[i + 1] << 8 | uni_str[i]);\r
-            if (unicode == 0x1b) {\r
-                i += 2;\r
-                while (i < max_chars * 2) {\r
-                    FX_WORD unicode = bBE ? (uni_str[i] << 8 | uni_str[i + 1]) : (uni_str[i + 1] << 8 | uni_str[i]);\r
-                    i += 2;\r
-                    if (unicode == 0x1b) {\r
-                        break;\r
-                    }\r
-                }\r
-            } else {\r
-                dest_buf[dest_pos++] = unicode;\r
-            }\r
-        }\r
-        result.ReleaseBuffer(dest_pos);\r
-    } else if (pCharMap == NULL) {\r
-        FX_LPWSTR dest_buf = result.GetBuffer(src_len);\r
-        for (FX_DWORD i = 0; i < src_len; i ++) {\r
-            dest_buf[i] = PDFDocEncoding[src_data[i]];\r
-        }\r
-        result.ReleaseBuffer(src_len);\r
-    } else {\r
-        return (*pCharMap->m_GetWideString)(pCharMap, CFX_ByteString((FX_LPCSTR)src_data, src_len));\r
-    }\r
-    return result;\r
-}\r
-CFX_WideString PDF_DecodeText(const CFX_ByteString& bstr, CFX_CharMap* pCharMap)\r
-{\r
-    return PDF_DecodeText((FX_LPCBYTE)(FX_LPCSTR)bstr, bstr.GetLength(), pCharMap);\r
-}\r
-CFX_ByteString PDF_EncodeText(FX_LPCWSTR pString, int len, CFX_CharMap* pCharMap)\r
-{\r
-    if (len == -1) {\r
-        len = (FX_STRSIZE)FXSYS_wcslen(pString);\r
-    }\r
-    CFX_ByteString result;\r
-    if (pCharMap == NULL) {\r
-        FX_LPSTR dest_buf1 = result.GetBuffer(len);\r
-        int i;\r
-        for (i = 0; i < len; i ++) {\r
-            int code;\r
-            for (code = 0; code < 256; code ++)\r
-                if (PDFDocEncoding[code] == pString[i]) {\r
-                    break;\r
-                }\r
-            if (code == 256) {\r
-                break;\r
-            }\r
-            dest_buf1[i] = code;\r
-        }\r
-        result.ReleaseBuffer(i);\r
-        if (i == len) {\r
-            return result;\r
-        }\r
-    }\r
-    FX_LPBYTE dest_buf2 = (FX_LPBYTE)result.GetBuffer(len * 2 + 2);\r
-    dest_buf2[0] = 0xfe;\r
-    dest_buf2[1] = 0xff;\r
-    dest_buf2 += 2;\r
-    for (int i = 0; i < len; i ++) {\r
-        *dest_buf2++ = pString[i] >> 8;\r
-        *dest_buf2++ = (FX_BYTE)pString[i];\r
-    }\r
-    result.ReleaseBuffer(len * 2 + 2);\r
-    return result;\r
-}\r
-CFX_ByteString PDF_EncodeString(const CFX_ByteString& src, FX_BOOL bHex)\r
-{\r
-    CFX_ByteTextBuf result;\r
-    int srclen = src.GetLength();\r
-    if (bHex) {\r
-        result.AppendChar('<');\r
-        for (int i = 0; i < srclen; i ++) {\r
-            result.AppendChar("0123456789ABCDEF"[src[i] / 16]);\r
-            result.AppendChar("0123456789ABCDEF"[src[i] % 16]);\r
-        }\r
-        result.AppendChar('>');\r
-        return result.GetByteString();\r
-    }\r
-    result.AppendChar('(');\r
-    for (int i = 0; i < srclen; i ++) {\r
-        FX_BYTE ch = src[i];\r
-        if (ch == ')' || ch == '\\' || ch == '(') {\r
-            result.AppendChar('\\');\r
-        } else if (ch == 0x0a) {\r
-            result << FX_BSTRC("\\n");\r
-            continue;\r
-        } else if (ch == 0x0d) {\r
-            result << FX_BSTRC("\\r");\r
-            continue;\r
-        }\r
-        result.AppendChar(ch);\r
-    }\r
-    result.AppendChar(')');\r
-    return result.GetByteString();\r
-}\r
-void FlateEncode(const FX_BYTE* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size)\r
-{\r
-    CCodec_ModuleMgr* pEncoders = CPDF_ModuleMgr::Get()->GetCodecModule();\r
-    if (pEncoders) {\r
-        pEncoders->GetFlateModule()->Encode(src_buf, src_size, dest_buf, dest_size);\r
-    }\r
-}\r
-void FlateEncode(FX_LPCBYTE src_buf, FX_DWORD src_size, int predictor, int Colors, int BitsPerComponent, int Columns,\r
-                 FX_LPBYTE& dest_buf, FX_DWORD& dest_size)\r
-{\r
-    CCodec_ModuleMgr* pEncoders = CPDF_ModuleMgr::Get()->GetCodecModule();\r
-    if (pEncoders) {\r
-        pEncoders->GetFlateModule()->Encode(src_buf, src_size, predictor, Colors, BitsPerComponent, Columns, dest_buf, dest_size);\r
-    }\r
-}\r
-FX_DWORD FlateDecode(const FX_BYTE* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size)\r
-{\r
-    CCodec_ModuleMgr* pEncoders = CPDF_ModuleMgr::Get()->GetCodecModule();\r
-    if (pEncoders) {\r
-        return pEncoders->GetFlateModule()->FlateOrLZWDecode(FALSE, src_buf, src_size, FALSE, 0, 0, 0, 0, 0, dest_buf, dest_size);\r
-    }\r
-    return 0;\r
-}\r
+// Copyright 2014 PDFium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
+
+#include "../../../include/fpdfapi/fpdf_parser.h"
+#include "../../../include/fpdfapi/fpdf_module.h"
+#include "../../../include/fxcodec/fx_codec.h"
+#include <limits.h>
+#define _STREAM_MAX_SIZE_              20 * 1024 * 1024
+FX_DWORD _A85Decode(const FX_BYTE* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size)
+{
+    dest_size = 0;
+    dest_buf = NULL;
+    if (src_size == 0) {
+        return 0;
+    }
+    FX_DWORD zcount = 0;
+    FX_DWORD pos = 0;
+    while (pos < src_size) {
+        FX_BYTE ch = src_buf[pos];
+        if (ch < '!' && ch != '\n' && ch != '\r' && ch != ' ' && ch != '\t') {
+            break;
+        }
+        if (ch == 'z') {
+            zcount ++;
+        } else if (ch > 'u') {
+            break;
+        }
+        pos ++;
+    }
+    if (pos == 0) {
+        return 0;
+    }
+    if (zcount > UINT_MAX / 4) {
+        return (FX_DWORD) - 1;
+    }
+    if (zcount * 4 > UINT_MAX - (pos - zcount)) {
+        return (FX_DWORD) - 1;
+    }
+    dest_buf = FX_Alloc(FX_BYTE, zcount * 4 + (pos - zcount));
+    if (dest_buf == NULL) {
+        return (FX_DWORD) - 1;
+    }
+    int state = 0;
+    FX_UINT32 res = 0;
+    pos = dest_size = 0;
+    while (pos < src_size) {
+        FX_BYTE ch = src_buf[pos++];
+        if (ch == '\n' || ch == '\r' || ch == ' ' || ch == '\t') {
+            continue;
+        }
+        if (ch == 'z') {
+            FXSYS_memset32(dest_buf + dest_size, 0, 4);
+            state = 0;
+            res = 0;
+            dest_size += 4;
+        } else {
+            if (ch < '!' || ch > 'u') {
+                break;
+            }
+            res = res * 85 + ch - 33;
+            state ++;
+            if (state == 5) {
+                for (int i = 0; i < 4; i ++) {
+                    dest_buf[dest_size++] = (FX_BYTE)(res >> (3 - i) * 8);
+                }
+                state = 0;
+                res = 0;
+            }
+        }
+    }
+    if (state) {
+        int i;
+        for (i = state; i < 5; i ++) {
+            res = res * 85 + 84;
+        }
+        for (i = 0; i < state - 1; i ++) {
+            dest_buf[dest_size++] = (FX_BYTE)(res >> (3 - i) * 8);
+        }
+    }
+    if (pos < src_size && src_buf[pos] == '>') {
+        pos ++;
+    }
+    return pos;
+}
+FX_DWORD _HexDecode(const FX_BYTE* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size)
+{
+    FX_DWORD i;
+    for (i = 0; i < src_size; i ++)
+        if (src_buf[i] == '>') {
+            break;
+        }
+    dest_buf = FX_Alloc( FX_BYTE, i / 2 + 1);
+    dest_size = 0;
+    FX_BOOL bFirstDigit = TRUE;
+    for (i = 0; i < src_size; i ++) {
+        FX_BYTE ch = src_buf[i];
+        if (ch == ' ' || ch == '\n' || ch == '\t' || ch == '\r') {
+            continue;
+        }
+        int digit;
+        if (ch <= '9' && ch >= '0') {
+            digit = ch - '0';
+        } else if (ch <= 'f' && ch >= 'a') {
+            digit = ch - 'a' + 10;
+        } else if (ch <= 'F' && ch >= 'A') {
+            digit = ch - 'A' + 10;
+        } else if (ch == '>') {
+            i ++;
+            break;
+        } else {
+            continue;
+        }
+        if (bFirstDigit) {
+            dest_buf[dest_size] = digit * 16;
+        } else {
+            dest_buf[dest_size ++] += digit;
+        }
+        bFirstDigit = !bFirstDigit;
+    }
+    if (!bFirstDigit) {
+        dest_size ++;
+    }
+    return i;
+}
+FX_DWORD RunLengthDecode(const FX_BYTE* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size)
+{
+    FX_DWORD i = 0;
+    FX_DWORD old;
+    dest_size = 0;
+    while (i < src_size) {
+        if (src_buf[i] < 128) {
+            old = dest_size;
+            dest_size += src_buf[i] + 1;
+            if (dest_size < old) {
+                return (FX_DWORD) - 1;
+            }
+            i += src_buf[i] + 2;
+        } else if (src_buf[i] > 128) {
+            old = dest_size;
+            dest_size += 257 - src_buf[i];
+            if (dest_size < old) {
+                return (FX_DWORD) - 1;
+            }
+            i += 2;
+        } else {
+            break;
+        }
+    }
+    if (dest_size >= _STREAM_MAX_SIZE_) {
+        return -1;
+    }
+    dest_buf = FX_Alloc( FX_BYTE, dest_size);
+    if (!dest_buf) {
+        return -1;
+    }
+    i = 0;
+    int dest_count = 0;
+    while (i < src_size) {
+        if (src_buf[i] < 128) {
+            FX_DWORD copy_len = src_buf[i] + 1;
+            FX_DWORD buf_left = src_size - i - 1;
+            if (buf_left < copy_len) {
+                FX_DWORD delta = copy_len - buf_left;
+                copy_len = buf_left;
+                FXSYS_memset8(dest_buf + dest_count + copy_len, '\0', delta);
+            }
+            FXSYS_memcpy32(dest_buf + dest_count, src_buf + i + 1, copy_len);
+            dest_count += src_buf[i] + 1;
+            i += src_buf[i] + 2;
+        } else if (src_buf[i] > 128) {
+            int fill = 0;
+            if (i < src_size - 1) {
+                fill = src_buf[i + 1];
+            }
+            FXSYS_memset8(dest_buf + dest_count, fill, 257 - src_buf[i]);
+            dest_count += 257 - src_buf[i];
+            i += 2;
+        } else {
+            break;
+        }
+    }
+    FX_DWORD ret = i + 1;
+    if (ret > src_size) {
+        ret = src_size;
+    }
+    return ret;
+}
+ICodec_ScanlineDecoder* FPDFAPI_CreateFaxDecoder(FX_LPCBYTE src_buf, FX_DWORD src_size, int width, int height,
+        const CPDF_Dictionary* pParams)
+{
+    int K = 0;
+    FX_BOOL EndOfLine = FALSE;
+    FX_BOOL ByteAlign = FALSE;
+    FX_BOOL BlackIs1 = FALSE;
+    int Columns = 1728;
+    int Rows = 0;
+    if (pParams) {
+        K = pParams->GetInteger(FX_BSTRC("K"));
+        EndOfLine = pParams->GetInteger(FX_BSTRC("EndOfLine"));
+        ByteAlign = pParams->GetInteger(FX_BSTRC("EncodedByteAlign"));
+        BlackIs1 = pParams->GetInteger(FX_BSTRC("BlackIs1"));
+        Columns = pParams->GetInteger(FX_BSTRC("Columns"), 1728);
+        Rows = pParams->GetInteger(FX_BSTRC("Rows"));
+        if (Rows > USHRT_MAX) {
+            Rows = 0;
+        }
+        if (Columns <= 0 || Rows < 0 || Columns > USHRT_MAX || Rows > USHRT_MAX) {
+            return NULL;
+        }
+    }
+    return CPDF_ModuleMgr::Get()->GetFaxModule()->CreateDecoder(src_buf, src_size, width, height,
+            K, EndOfLine, ByteAlign, BlackIs1, Columns, Rows);
+}
+static FX_BOOL CheckFlateDecodeParams(int Colors, int BitsPerComponent, int Columns)
+{
+    if (Columns < 0) {
+        return FALSE;
+    }
+    int check = Columns;
+    if (Colors < 0 || (check > 0 && Colors > INT_MAX / check)) {
+        return FALSE;
+    }
+    check *= Colors;
+    if (BitsPerComponent < 0 ||
+            (check > 0 && BitsPerComponent > INT_MAX / check)) {
+        return FALSE;
+    }
+    check *= BitsPerComponent;
+    if (check > INT_MAX - 7) {
+        return FALSE;
+    }
+    return TRUE;
+}
+ICodec_ScanlineDecoder* FPDFAPI_CreateFlateDecoder(FX_LPCBYTE src_buf, FX_DWORD src_size, int width, int height,
+        int nComps, int bpc, const CPDF_Dictionary* pParams)
+{
+    int predictor = 0;
+    FX_BOOL bEarlyChange = TRUE;
+    int Colors = 0, BitsPerComponent = 0, Columns = 0;
+    if (pParams) {
+        predictor = ((CPDF_Dictionary*)pParams)->GetInteger(FX_BSTRC("Predictor"));
+        bEarlyChange = ((CPDF_Dictionary*)pParams)->GetInteger(FX_BSTRC("EarlyChange"), 1);
+        Colors = pParams->GetInteger(FX_BSTRC("Colors"), 1);
+        BitsPerComponent = pParams->GetInteger(FX_BSTRC("BitsPerComponent"), 8);
+        Columns = pParams->GetInteger(FX_BSTRC("Columns"), 1);
+        if (!CheckFlateDecodeParams(Colors, BitsPerComponent, Columns)) {
+            return NULL;
+        }
+    }
+    return CPDF_ModuleMgr::Get()->GetFlateModule()->CreateDecoder(src_buf, src_size, width, height,
+            nComps, bpc, predictor, Colors, BitsPerComponent, Columns);
+}
+FX_DWORD FPDFAPI_FlateOrLZWDecode(FX_BOOL bLZW, const FX_BYTE* src_buf, FX_DWORD src_size, CPDF_Dictionary* pParams,
+                                  FX_DWORD estimated_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size)
+{
+    int predictor = 0;
+    FX_BOOL bEarlyChange = TRUE;
+    int Colors = 0, BitsPerComponent = 0, Columns = 0;
+    if (pParams) {
+        predictor = ((CPDF_Dictionary*)pParams)->GetInteger(FX_BSTRC("Predictor"));
+        bEarlyChange = ((CPDF_Dictionary*)pParams)->GetInteger(FX_BSTRC("EarlyChange"), 1);
+        Colors = pParams->GetInteger(FX_BSTRC("Colors"), 1);
+        BitsPerComponent = pParams->GetInteger(FX_BSTRC("BitsPerComponent"), 8);
+        Columns = pParams->GetInteger(FX_BSTRC("Columns"), 1);
+        if (!CheckFlateDecodeParams(Colors, BitsPerComponent, Columns)) {
+            return (FX_DWORD) - 1;
+        }
+    }
+    return CPDF_ModuleMgr::Get()->GetFlateModule()->FlateOrLZWDecode(bLZW, src_buf, src_size,
+            bEarlyChange, predictor, Colors, BitsPerComponent, Columns, estimated_size,
+            dest_buf, dest_size);
+}
+FX_BOOL PDF_DataDecode(FX_LPCBYTE src_buf, FX_DWORD src_size, const CPDF_Dictionary* pDict,
+                       FX_LPBYTE& dest_buf, FX_DWORD& dest_size, CFX_ByteString& ImageEncoding,
+                       CPDF_Dictionary*& pImageParms, FX_DWORD last_estimated_size, FX_BOOL bImageAcc)
+
+{
+    CPDF_Object* pDecoder = pDict ? pDict->GetElementValue(FX_BSTRC("Filter")) : NULL;
+    if (pDecoder == NULL || (pDecoder->GetType() != PDFOBJ_ARRAY && pDecoder->GetType() != PDFOBJ_NAME)) {
+        return FALSE;
+    }
+    CPDF_Object* pParams = pDict ? pDict->GetElementValue(FX_BSTRC("DecodeParms")) : NULL;
+    CFX_ByteStringArray DecoderList;
+    CFX_PtrArray ParamList;
+    if (pDecoder->GetType() == PDFOBJ_ARRAY) {
+        if (pParams && pParams->GetType() != PDFOBJ_ARRAY) {
+            pParams = NULL;
+        }
+        CPDF_Array* pDecoders = (CPDF_Array*)pDecoder;
+        for (FX_DWORD i = 0; i < pDecoders->GetCount(); i ++) {
+            CFX_ByteStringC str = pDecoders->GetConstString(i);
+            DecoderList.Add(str);
+            if (pParams) {
+                ParamList.Add(((CPDF_Array*)pParams)->GetDict(i));
+            } else {
+                ParamList.Add(NULL);
+            }
+        }
+    } else {
+        DecoderList.Add(pDecoder->GetConstString());
+        ParamList.Add(pParams ? pParams->GetDict() : NULL);
+    }
+    FX_LPBYTE last_buf = (FX_LPBYTE)src_buf;
+    FX_DWORD last_size = src_size;
+    for (int i = 0; i < DecoderList.GetSize(); i ++) {
+        int estimated_size = i == DecoderList.GetSize() - 1 ? last_estimated_size : 0;
+        CFX_ByteString decoder = DecoderList[i];
+        CPDF_Dictionary* pParam = (CPDF_Dictionary*)ParamList[i];
+        FX_LPBYTE new_buf = NULL;
+        FX_DWORD new_size = (FX_DWORD) - 1;
+        int offset = -1;
+        if (decoder == FX_BSTRC("FlateDecode") || decoder == FX_BSTRC("Fl")) {
+            if (bImageAcc && i == DecoderList.GetSize() - 1) {
+                ImageEncoding = FX_BSTRC("FlateDecode");
+                dest_buf = (FX_LPBYTE)last_buf;
+                dest_size = last_size;
+                pImageParms = pParam;
+                return TRUE;
+            } else {
+                offset = FPDFAPI_FlateOrLZWDecode(FALSE, last_buf, last_size, pParam, estimated_size, new_buf, new_size);
+            }
+        } else if (decoder == FX_BSTRC("LZWDecode") || decoder == FX_BSTRC("LZW")) {
+            offset = FPDFAPI_FlateOrLZWDecode(TRUE, last_buf, last_size, pParam, estimated_size, new_buf, new_size);
+        } else if (decoder == FX_BSTRC("ASCII85Decode") || decoder == FX_BSTRC("A85")) {
+            offset = _A85Decode(last_buf, last_size, new_buf, new_size);
+        } else if (decoder == FX_BSTRC("ASCIIHexDecode") || decoder == FX_BSTRC("AHx")) {
+            offset = _HexDecode(last_buf, last_size, new_buf, new_size);
+        } else if (decoder == FX_BSTRC("RunLengthDecode") || decoder == FX_BSTRC("RL")) {
+            if (bImageAcc && i == DecoderList.GetSize() - 1) {
+                ImageEncoding = FX_BSTRC("RunLengthDecode");
+                dest_buf = (FX_LPBYTE)last_buf;
+                dest_size = last_size;
+                pImageParms = pParam;
+                return TRUE;
+            }
+            offset = RunLengthDecode(last_buf, last_size, new_buf, new_size);
+        } else {
+            if (decoder == FX_BSTRC("DCT")) {
+                decoder = "DCTDecode";
+            } else if (decoder == FX_BSTRC("CCF")) {
+                decoder = "CCITTFaxDecode";
+            } else if (decoder == FX_BSTRC("Crypt")) {
+                continue;
+            }
+            ImageEncoding = decoder;
+            pImageParms = pParam;
+            dest_buf = (FX_LPBYTE)last_buf;
+            dest_size = last_size;
+            return TRUE;
+        }
+        if (last_buf != src_buf) {
+            FX_Free(last_buf);
+        }
+        if (offset == -1) {
+            return FALSE;
+        }
+        last_buf = new_buf;
+        last_size = new_size;
+    }
+    ImageEncoding = "";
+    pImageParms = NULL;
+    dest_buf = last_buf;
+    dest_size = last_size;
+    return TRUE;
+}
+extern const FX_WORD PDFDocEncoding[256] = {
+    0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009,
+    0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f, 0x0010, 0x0011, 0x0012, 0x0013,
+    0x0014, 0x0015, 0x0016, 0x0017, 0x02d8, 0x02c7, 0x02c6, 0x02d9, 0x02dd, 0x02db,
+    0x02da, 0x02dc, 0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+    0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f, 0x0030, 0x0031,
+    0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b,
+    0x003c, 0x003d, 0x003e, 0x003f, 0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045,
+    0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
+    0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059,
+    0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f, 0x0060, 0x0061, 0x0062, 0x0063,
+    0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d,
+    0x006e, 0x006f, 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+    0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x0000, 0x2022, 0x2020,
+    0x2021, 0x2026, 0x2014, 0x2013, 0x0192, 0x2044, 0x2039, 0x203a, 0x2212, 0x2030,
+    0x201e, 0x201c, 0x201d, 0x2018, 0x2019, 0x201a, 0x2122, 0xfb01, 0xfb02, 0x0141,
+    0x0152, 0x0160, 0x0178, 0x017d, 0x0131, 0x0142, 0x0153, 0x0161, 0x017e, 0x0000,
+    0x20ac, 0x00a1, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7, 0x00a8, 0x00a9,
+    0x00aa, 0x00ab, 0x00ac, 0x0000, 0x00ae, 0x00af, 0x00b0, 0x00b1, 0x00b2, 0x00b3,
+    0x00b4, 0x00b5, 0x00b6, 0x00b7, 0x00b8, 0x00b9, 0x00ba, 0x00bb, 0x00bc, 0x00bd,
+    0x00be, 0x00bf, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7,
+    0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf, 0x00d0, 0x00d1,
+    0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7, 0x00d8, 0x00d9, 0x00da, 0x00db,
+    0x00dc, 0x00dd, 0x00de, 0x00df, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5,
+    0x00e6, 0x00e7, 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
+    0x00f0, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7, 0x00f8, 0x00f9,
+    0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x00ff
+};
+CFX_WideString PDF_DecodeText(FX_LPCBYTE src_data, FX_DWORD src_len, CFX_CharMap* pCharMap)
+{
+    CFX_WideString result;
+    if (src_len >= 2 && ((src_data[0] == 0xfe && src_data[1] == 0xff) || (src_data[0] == 0xff && src_data[1] == 0xfe))) {
+        FX_BOOL bBE = src_data[0] == 0xfe;
+        FX_DWORD max_chars = (src_len - 2) / 2;
+        if (!max_chars) {
+            return result;
+        }
+        if (src_data[0] == 0xff) {
+            bBE = !src_data[2];
+        }
+        FX_LPWSTR dest_buf = result.GetBuffer(max_chars);
+        FX_LPCBYTE uni_str = src_data + 2;
+        int dest_pos = 0;
+        for (FX_DWORD i = 0; i < max_chars * 2; i += 2) {
+            FX_WORD unicode = bBE ? (uni_str[i] << 8 | uni_str[i + 1]) : (uni_str[i + 1] << 8 | uni_str[i]);
+            if (unicode == 0x1b) {
+                i += 2;
+                while (i < max_chars * 2) {
+                    FX_WORD unicode = bBE ? (uni_str[i] << 8 | uni_str[i + 1]) : (uni_str[i + 1] << 8 | uni_str[i]);
+                    i += 2;
+                    if (unicode == 0x1b) {
+                        break;
+                    }
+                }
+            } else {
+                dest_buf[dest_pos++] = unicode;
+            }
+        }
+        result.ReleaseBuffer(dest_pos);
+    } else if (pCharMap == NULL) {
+        FX_LPWSTR dest_buf = result.GetBuffer(src_len);
+        for (FX_DWORD i = 0; i < src_len; i ++) {
+            dest_buf[i] = PDFDocEncoding[src_data[i]];
+        }
+        result.ReleaseBuffer(src_len);
+    } else {
+        return (*pCharMap->m_GetWideString)(pCharMap, CFX_ByteString((FX_LPCSTR)src_data, src_len));
+    }
+    return result;
+}
+CFX_ByteString PDF_EncodeText(FX_LPCWSTR pString, int len, CFX_CharMap* pCharMap)
+{
+    if (len == -1) {
+        len = (FX_STRSIZE)FXSYS_wcslen(pString);
+    }
+    CFX_ByteString result;
+    if (pCharMap == NULL) {
+        FX_LPSTR dest_buf1 = result.GetBuffer(len);
+        int i;
+        for (i = 0; i < len; i ++) {
+            int code;
+            for (code = 0; code < 256; code ++)
+                if (PDFDocEncoding[code] == pString[i]) {
+                    break;
+                }
+            if (code == 256) {
+                break;
+            }
+            dest_buf1[i] = code;
+        }
+        result.ReleaseBuffer(i);
+        if (i == len) {
+            return result;
+        }
+    }
+
+    if(len > INT_MAX/2-1)
+    {
+        result.ReleaseBuffer(0);
+        return result;
+    }
+
+    int encLen = len * 2 + 2;
+
+    FX_LPBYTE dest_buf2 = (FX_LPBYTE)result.GetBuffer(encLen);
+    dest_buf2[0] = 0xfe;
+    dest_buf2[1] = 0xff;
+    dest_buf2 += 2;
+    for (int i = 0; i < len; i ++) {
+        *dest_buf2++ = pString[i] >> 8;
+        *dest_buf2++ = (FX_BYTE)pString[i];
+    }
+    result.ReleaseBuffer(encLen);
+    return result;
+}
+CFX_ByteString PDF_EncodeString(const CFX_ByteString& src, FX_BOOL bHex)
+{
+    CFX_ByteTextBuf result;
+    int srclen = src.GetLength();
+    if (bHex) {
+        result.AppendChar('<');
+        for (int i = 0; i < srclen; i ++) {
+            result.AppendChar("0123456789ABCDEF"[src[i] / 16]);
+            result.AppendChar("0123456789ABCDEF"[src[i] % 16]);
+        }
+        result.AppendChar('>');
+        return result.GetByteString();
+    }
+    result.AppendChar('(');
+    for (int i = 0; i < srclen; i ++) {
+        FX_BYTE ch = src[i];
+        if (ch == ')' || ch == '\\' || ch == '(') {
+            result.AppendChar('\\');
+        } else if (ch == 0x0a) {
+            result << FX_BSTRC("\\n");
+            continue;
+        } else if (ch == 0x0d) {
+            result << FX_BSTRC("\\r");
+            continue;
+        }
+        result.AppendChar(ch);
+    }
+    result.AppendChar(')');
+    return result.GetByteString();
+}
+void FlateEncode(const FX_BYTE* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size)
+{
+    CCodec_ModuleMgr* pEncoders = CPDF_ModuleMgr::Get()->GetCodecModule();
+    if (pEncoders) {
+        pEncoders->GetFlateModule()->Encode(src_buf, src_size, dest_buf, dest_size);
+    }
+}
+void FlateEncode(FX_LPCBYTE src_buf, FX_DWORD src_size, int predictor, int Colors, int BitsPerComponent, int Columns,
+                 FX_LPBYTE& dest_buf, FX_DWORD& dest_size)
+{
+    CCodec_ModuleMgr* pEncoders = CPDF_ModuleMgr::Get()->GetCodecModule();
+    if (pEncoders) {
+        pEncoders->GetFlateModule()->Encode(src_buf, src_size, predictor, Colors, BitsPerComponent, Columns, dest_buf, dest_size);
+    }
+}
+FX_DWORD FlateDecode(const FX_BYTE* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size)
+{
+    CCodec_ModuleMgr* pEncoders = CPDF_ModuleMgr::Get()->GetCodecModule();
+    if (pEncoders) {
+        return pEncoders->GetFlateModule()->FlateOrLZWDecode(FALSE, src_buf, src_size, FALSE, 0, 0, 0, 0, 0, dest_buf, dest_size);
+    }
+    return 0;
+}