// 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/fxcodec/fx_codec.h"
#include "../../../include/fxcodec/fx_codec_flate.h"
#include "../../../include/fpdfapi/fpdf_module.h"
#include "filters_int.h"

extern "C" {

static void* my_alloc_func(void* opaque, unsigned int items, unsigned int size)
{
    return FX_Alloc2D(uint8_t, items, size);
}
static void my_free_func(void* opaque, void* address)
{
    FX_Free(address);
}

}  // extern "C"

CFX_DataFilter::CFX_DataFilter()
{
    m_bEOF = false;
    m_pDestFilter = NULL;
    m_SrcPos = 0;
}
CFX_DataFilter::~CFX_DataFilter()
{
    delete m_pDestFilter;
}
void CFX_DataFilter::SetDestFilter(CFX_DataFilter* pFilter)
{
    if (m_pDestFilter) {
        m_pDestFilter->SetDestFilter(pFilter);
    } else {
        m_pDestFilter = pFilter;
    }
}
void CFX_DataFilter::FilterIn(const uint8_t* src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf)
{
    if (m_bEOF) {
        return;
    }
    m_SrcPos += src_size;
    if (m_pDestFilter) {
        CFX_BinaryBuf temp_buf;
        temp_buf.EstimateSize(FPDF_FILTER_BUFFER_SIZE, FPDF_FILTER_BUFFER_SIZE);
        v_FilterIn(src_buf, src_size, temp_buf);
        m_pDestFilter->FilterIn(temp_buf.GetBuffer(), temp_buf.GetSize(), dest_buf);
    } else {
        v_FilterIn(src_buf, src_size, dest_buf);
    }
}
void CFX_DataFilter::FilterFinish(CFX_BinaryBuf& dest_buf)
{
    if (m_pDestFilter) {
        CFX_BinaryBuf temp_buf;
        v_FilterFinish(temp_buf);
        if (temp_buf.GetSize()) {
            m_pDestFilter->FilterIn(temp_buf.GetBuffer(), temp_buf.GetSize(), dest_buf);
        }
        m_pDestFilter->FilterFinish(dest_buf);
    } else {
        v_FilterFinish(dest_buf);
    }
    m_bEOF = true;
}
void CFX_DataFilter::ReportEOF(FX_DWORD left_input)
{
    if (m_bEOF) {
        return;
    }
    m_bEOF = true;
    m_SrcPos -= left_input;
}
CFX_DataFilter* FPDF_CreateFilter(const CFX_ByteStringC& name, const CPDF_Dictionary* pParam, int width, int height)
{
    FX_DWORD id = name.GetID();
    switch (id) {
        case FXBSTR_ID('F', 'l', 'a', 't'):
        case FXBSTR_ID('F', 'l', 0, 0):
        case FXBSTR_ID('L', 'Z', 'W', 'D'):
        case FXBSTR_ID('L', 'Z', 'W', 0): {
                CFX_DataFilter* pFilter;
                if (id == FXBSTR_ID('L', 'Z', 'W', 'D') || id == FXBSTR_ID('L', 'Z', 'W', 0)) {
                    pFilter = new CPDF_LzwFilter(pParam ? pParam->GetInteger("EarlyChange", 1) : 1);
                } else {
                    pFilter = new CPDF_FlateFilter;
                }
                if ((pParam ? pParam->GetInteger("Predictor", 1) : 1) > 1) {
                    CFX_DataFilter* pPredictor = new CPDF_PredictorFilter(pParam->GetInteger(FX_BSTRC("Predictor"), 1),
                                                 pParam->GetInteger(FX_BSTRC("Colors"), 1), pParam->GetInteger(FX_BSTRC("BitsPerComponent"), 8),
                                                 pParam->GetInteger(FX_BSTRC("Columns"), 1));
                    pFilter->SetDestFilter(pPredictor);
                }
                return pFilter;
            }
        case FXBSTR_ID('A', 'S', 'C', 'I'):
            if (name == "ASCIIHexDecode") {
                return new CPDF_AsciiHexFilter;
            }
            return new CPDF_Ascii85Filter;
        case FXBSTR_ID('A', 'H', 'x', 0):
            return new CPDF_AsciiHexFilter;
        case FXBSTR_ID('A', '8', '5', 0):
            return new CPDF_Ascii85Filter;
        case FXBSTR_ID('R', 'u', 'n', 'L'):
            return new CPDF_RunLenFilter;
        case FXBSTR_ID('C', 'C', 'I', 'T'): {
                int Encoding = 0;
                int bEndOfLine = false;
                int bByteAlign = false;
                int bBlack = false;
                int nRows = 0;
                int nColumns = 1728;
                if (pParam) {
                    Encoding = pParam->GetInteger(FX_BSTRC("K"));
                    bEndOfLine = pParam->GetInteger(FX_BSTRC("EndOfLine"));
                    bByteAlign = pParam->GetInteger(FX_BSTRC("EncodedByteAlign"));
                    bBlack = pParam->GetInteger(FX_BSTRC("BlackIs1"));
                    nColumns = pParam->GetInteger(FX_BSTRC("Columns"), 1728);
                    nRows = pParam->GetInteger(FX_BSTRC("Rows"));
                }
                if (nColumns == 0) {
                    nColumns = width;
                }
                if (nRows == 0) {
                    nRows = height;
                }
                CPDF_FaxFilter* pFilter = new CPDF_FaxFilter();
                pFilter->Initialize(Encoding, bEndOfLine, bByteAlign, bBlack, nRows, nColumns);
                return pFilter;
            }
        case FXBSTR_ID('D', 'C', 'T', 'D'):
            return new CPDF_JpegFilter;
        default:
            return NULL;
    }
}
CFX_DataFilter* _FPDF_CreateFilterFromDict(CPDF_Dictionary* pDict)
{
    CPDF_Object* pDecoder = pDict->GetElementValue("Filter");
    if (pDecoder == NULL) {
        return NULL;
    }
    CFX_DataFilter* pFirstFilter = NULL;
    int width = pDict->GetInteger(FX_BSTRC("Width")), height = pDict->GetInteger(FX_BSTRC("Height"));
    CPDF_Object* pParams = pDict->GetElementValue("DecodeParms");
    if (pDecoder->GetType() == PDFOBJ_ARRAY) {
        if (pParams && pParams->GetType() != PDFOBJ_ARRAY) {
            pParams = NULL;
        }
        for (FX_DWORD i = 0; i < ((CPDF_Array*)pDecoder)->GetCount(); i ++) {
            CFX_ByteString name = ((CPDF_Array*)pDecoder)->GetString(i);
            CPDF_Dictionary* pParam = NULL;
            if (pParams) {
                pParam = ((CPDF_Array*)pParams)->GetDict(i);
            }
            CFX_DataFilter* pDestFilter = FPDF_CreateFilter(name, pParam, width, height);
            if (pDestFilter) {
                if (pFirstFilter == NULL) {
                    pFirstFilter = pDestFilter;
                } else {
                    pFirstFilter->SetDestFilter(pDestFilter);
                }
            }
        }
    } else {
        if (pParams && pParams->GetType() != PDFOBJ_DICTIONARY) {
            pParams = NULL;
        }
        pFirstFilter = FPDF_CreateFilter(pDecoder->GetString(), (CPDF_Dictionary*)pParams, width, height);
    }
    return pFirstFilter;
}
CPDF_StreamFilter* CPDF_Stream::GetStreamFilter(bool bRaw) const
{
    CFX_DataFilter* pFirstFilter = NULL;
    if (m_pCryptoHandler) {
        pFirstFilter = new CPDF_DecryptFilter(m_pCryptoHandler, m_ObjNum, m_GenNum);
    }
    if (!bRaw) {
        CFX_DataFilter* pFilter = _FPDF_CreateFilterFromDict(m_pDict);
        if (pFilter) {
            if (pFirstFilter == NULL) {
                pFirstFilter = pFilter;
            } else {
                pFirstFilter->SetDestFilter(pFilter);
            }
        }
    }
    CPDF_StreamFilter* pStreamFilter = new CPDF_StreamFilter;
    pStreamFilter->m_pStream = this;
    pStreamFilter->m_pFilter = pFirstFilter;
    pStreamFilter->m_pBuffer = NULL;
    pStreamFilter->m_SrcOffset = 0;
    return pStreamFilter;
}
CPDF_StreamFilter::~CPDF_StreamFilter()
{
    delete m_pFilter;
    delete m_pBuffer;
}
#define FPDF_FILTER_BUFFER_IN_SIZE	FPDF_FILTER_BUFFER_SIZE
FX_DWORD CPDF_StreamFilter::ReadBlock(uint8_t* buffer, FX_DWORD buf_size)
{
    if (m_pFilter == NULL) {
        FX_DWORD read_size = m_pStream->GetRawSize() - m_SrcOffset;
        if (read_size == 0) {
            return 0;
        }
        if (read_size > buf_size) {
            read_size = buf_size;
        }
        m_pStream->ReadRawData(m_SrcOffset, buffer, read_size);
        m_SrcOffset += read_size;
        return read_size;
    }
    FX_DWORD read_size = 0;
    if (m_pBuffer) {
        read_size = ReadLeftOver(buffer, buf_size);
        if (read_size == buf_size) {
            return read_size;
        }
        buffer += read_size;
        buf_size -= read_size;
    }
    ASSERT(m_pBuffer == NULL);
    if (m_pFilter->IsEOF()) {
        return read_size;
    }
    m_pBuffer = new CFX_BinaryBuf;
    m_pBuffer->EstimateSize(FPDF_FILTER_BUFFER_SIZE, FPDF_FILTER_BUFFER_SIZE);
    m_BufOffset = 0;
    while (1) {
        int src_size = m_pStream->GetRawSize() - m_SrcOffset;
        if (src_size == 0) {
            m_pFilter->FilterFinish(*m_pBuffer);
            break;
        }
        if (src_size > FPDF_FILTER_BUFFER_IN_SIZE) {
            src_size = FPDF_FILTER_BUFFER_IN_SIZE;
        }
        if (!m_pStream->ReadRawData(m_SrcOffset, m_SrcBuffer, src_size)) {
            return 0;
        }
        m_SrcOffset += src_size;
        m_pFilter->FilterIn(m_SrcBuffer, src_size, *m_pBuffer);
        if (m_pBuffer->GetSize() >= (int)buf_size) {
            break;
        }
    }
    return read_size + ReadLeftOver(buffer, buf_size);
}
FX_DWORD CPDF_StreamFilter::ReadLeftOver(uint8_t* buffer, FX_DWORD buf_size)
{
    FX_DWORD read_size = m_pBuffer->GetSize() - m_BufOffset;
    if (read_size > buf_size) {
        read_size = buf_size;
    }
    FXSYS_memcpy(buffer, m_pBuffer->GetBuffer() + m_BufOffset, read_size);
    m_BufOffset += read_size;
    if (m_BufOffset == (FX_DWORD)m_pBuffer->GetSize()) {
        delete m_pBuffer;
        m_pBuffer = NULL;
    }
    return read_size;
}
CPDF_DecryptFilter::CPDF_DecryptFilter(CPDF_CryptoHandler* pCryptoHandler, FX_DWORD objnum, FX_DWORD gennum)
{
    m_pCryptoHandler = pCryptoHandler;
    m_pContext = NULL;
    m_ObjNum = objnum;
    m_GenNum = gennum;
}
CPDF_DecryptFilter::~CPDF_DecryptFilter()
{
    CFX_BinaryBuf buf;
    if (m_pContext) {
        m_pCryptoHandler->DecryptFinish(m_pContext, buf);
    }
}
void CPDF_DecryptFilter::v_FilterIn(const uint8_t* src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf)
{
    if (m_pContext == NULL) {
        m_pContext = m_pCryptoHandler->DecryptStart(m_ObjNum, m_GenNum);
    }
    m_pCryptoHandler->DecryptStream(m_pContext, src_buf, src_size, dest_buf);
}
void CPDF_DecryptFilter::v_FilterFinish(CFX_BinaryBuf& dest_buf)
{
    m_bEOF = true;
    if (m_pContext == NULL) {
        return;
    }
    m_pCryptoHandler->DecryptFinish(m_pContext, dest_buf);
    m_pContext = NULL;
}
CPDF_FlateFilter::CPDF_FlateFilter()
{
    m_pContext = NULL;
}
CPDF_FlateFilter::~CPDF_FlateFilter()
{
    if (m_pContext) {
        FPDFAPI_FlateEnd(m_pContext);
    }
}
void CPDF_FlateFilter::v_FilterIn(const uint8_t* src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf)
{
    if (m_pContext == NULL) {
        m_pContext = FPDFAPI_FlateInit(my_alloc_func, my_free_func);
    }
    FPDFAPI_FlateInput(m_pContext, src_buf, src_size);
    while (1) {
        int ret = FPDFAPI_FlateOutput(m_pContext, m_DestBuffer, FPDF_FILTER_BUFFER_SIZE);
        int out_size = FPDF_FILTER_BUFFER_SIZE - FPDFAPI_FlateGetAvailOut(m_pContext);
        dest_buf.AppendBlock(m_DestBuffer, out_size);
        if (ret == Z_BUF_ERROR) {
            break;
        }
        if (ret != Z_OK) {
            ReportEOF(FPDFAPI_FlateGetAvailIn(m_pContext));
            break;
        }
    }
}
CPDF_LzwFilter::CPDF_LzwFilter(bool bEarlyChange)
{
    m_bEarlyChange = bEarlyChange ? 1 : 0;
    m_CodeLen = 9;
    m_nCodes = 0;
    m_nLeftBits = 0;
    m_LeftBits = 0;
    m_OldCode = (FX_DWORD) - 1;
}
void CPDF_LzwFilter::v_FilterIn(const uint8_t* src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf)
{
    for (FX_DWORD i = 0; i < src_size; i ++) {
        if (m_nLeftBits + 8 < m_CodeLen) {
            m_nLeftBits += 8;
            m_LeftBits = (m_LeftBits << 8) | src_buf[i];
            continue;
        }
        FX_DWORD new_bits = m_CodeLen - m_nLeftBits;
        FX_DWORD code = (m_LeftBits << new_bits) | (src_buf[i] >> (8 - new_bits));
        m_nLeftBits = 8 - new_bits;
        m_LeftBits = src_buf[i] % (1 << m_nLeftBits);
        if (code < 256) {
            dest_buf.AppendByte((uint8_t)code);
            m_LastChar = (uint8_t)code;
            if (m_OldCode != -1) {
                AddCode(m_OldCode, m_LastChar);
            }
            m_OldCode = code;
        } else if (code == 256) {
            m_CodeLen = 9;
            m_nCodes = 0;
            m_OldCode = (FX_DWORD) - 1;
        } else if (code == 257) {
            ReportEOF(src_size - i - 1);
            return;
        } else {
            if (m_OldCode == -1) {
                ReportEOF(src_size - i - 1);
                return;
            }
            m_StackLen = 0;
            if (code >= m_nCodes + 258) {
                if (m_StackLen < sizeof(m_DecodeStack)) {
                    m_DecodeStack[m_StackLen++] = m_LastChar;
                }
                DecodeString(m_OldCode);
            } else {
                DecodeString(code);
            }
            dest_buf.AppendBlock(NULL, m_StackLen);
            uint8_t* pOutput = dest_buf.GetBuffer() + dest_buf.GetSize() - m_StackLen;
            for (FX_DWORD cc = 0; cc < m_StackLen; cc ++) {
                pOutput[cc] = m_DecodeStack[m_StackLen - cc - 1];
            }
            m_LastChar = m_DecodeStack[m_StackLen - 1];
            if (m_OldCode < 256) {
                AddCode(m_OldCode, m_LastChar);
            } else if (m_OldCode - 258 >= m_nCodes) {
                ReportEOF(src_size - i - 1);
                return;
            } else {
                AddCode(m_OldCode, m_LastChar);
            }
            m_OldCode = code;
        }
    }
}
void CPDF_LzwFilter::AddCode(FX_DWORD prefix_code, uint8_t append_char)
{
    if (m_nCodes + m_bEarlyChange == 4094) {
        return;
    }
    m_CodeArray[m_nCodes ++] = (prefix_code << 16) | append_char;
    if (m_nCodes + m_bEarlyChange == 512 - 258) {
        m_CodeLen = 10;
    } else if (m_nCodes + m_bEarlyChange == 1024 - 258) {
        m_CodeLen = 11;
    } else if (m_nCodes + m_bEarlyChange == 2048 - 258) {
        m_CodeLen = 12;
    }
}
void CPDF_LzwFilter::DecodeString(FX_DWORD code)
{
    while (1) {
        int index = code - 258;
        if (index < 0 || index >= (int)m_nCodes) {
            break;
        }
        FX_DWORD data = m_CodeArray[index];
        if (m_StackLen >= sizeof(m_DecodeStack)) {
            return;
        }
        m_DecodeStack[m_StackLen++] = (uint8_t)data;
        code = data >> 16;
    }
    if (m_StackLen >= sizeof(m_DecodeStack)) {
        return;
    }
    m_DecodeStack[m_StackLen++] = (uint8_t)code;
}
CPDF_PredictorFilter::CPDF_PredictorFilter(int predictor, int colors, int bpc, int cols)
{
    m_bTiff = predictor < 10;
    m_pRefLine = NULL;
    m_pCurLine = NULL;
    m_iLine = 0;
    m_LineInSize = 0;
    m_Bpp = (colors * bpc + 7) / 8;
    m_Pitch = (colors * bpc * cols + 7) / 8;
    if (!m_bTiff) {
        m_Pitch ++;
    }
}
CPDF_PredictorFilter::~CPDF_PredictorFilter()
{
    if (m_pCurLine) {
        FX_Free(m_pCurLine);
    }
    if (m_pRefLine) {
        FX_Free(m_pRefLine);
    }
}
static uint8_t PaethPredictor(int a, int b, int c)
{
    int p = a + b - c;
    int pa = FXSYS_abs(p - a);
    int pb = FXSYS_abs(p - b);
    int pc = FXSYS_abs(p - c);
    if (pa <= pb && pa <= pc) {
        return (uint8_t)a;
    }
    if (pb <= pc) {
        return (uint8_t)b;
    }
    return (uint8_t)c;
}
static void PNG_PredictorLine(uint8_t* cur_buf, uint8_t* ref_buf, int pitch, int Bpp)
{
    uint8_t tag = cur_buf[0];
    if (tag == 0) {
        return;
    }
    cur_buf ++;
    if (ref_buf) {
        ref_buf ++;
    }
    for (int byte = 0; byte < pitch; byte ++) {
        uint8_t raw_byte = cur_buf[byte];
        switch (tag) {
            case 1:	{
                    uint8_t left = 0;
                    if (byte >= Bpp) {
                        left = cur_buf[byte - Bpp];
                    }
                    cur_buf[byte] = raw_byte + left;
                    break;
                }
            case 2: {
                    uint8_t up = 0;
                    if (ref_buf) {
                        up = ref_buf[byte];
                    }
                    cur_buf[byte] = raw_byte + up;
                    break;
                }
            case 3: {
                    uint8_t left = 0;
                    if (byte >= Bpp) {
                        left = cur_buf[byte - Bpp];
                    }
                    uint8_t up = 0;
                    if (ref_buf) {
                        up = ref_buf[byte];
                    }
                    cur_buf[byte] = raw_byte + (up + left) / 2;
                    break;
                }
            case 4: {
                    uint8_t left = 0;
                    if (byte >= Bpp) {
                        left = cur_buf[byte - Bpp];
                    }
                    uint8_t up = 0;
                    if (ref_buf) {
                        up = ref_buf[byte];
                    }
                    uint8_t upper_left = 0;
                    if (byte >= Bpp && ref_buf) {
                        upper_left = ref_buf[byte - Bpp];
                    }
                    cur_buf[byte] = raw_byte + PaethPredictor(left, up, upper_left);
                    break;
                }
        }
    }
}
void CPDF_PredictorFilter::v_FilterIn(const uint8_t* src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf)
{
    if (m_pCurLine == NULL) {
        m_pCurLine = FX_Alloc(uint8_t, m_Pitch);
        if (!m_bTiff) {
            m_pRefLine = FX_Alloc(uint8_t, m_Pitch);
        }
    }
    while (1) {
        FX_DWORD read_size = m_Pitch - m_LineInSize;
        if (read_size > src_size) {
            read_size = src_size;
        }
        FXSYS_memcpy(m_pCurLine + m_LineInSize, src_buf, read_size);
        m_LineInSize += read_size;
        if (m_LineInSize < m_Pitch) {
            break;
        }
        src_buf += read_size;
        src_size -= read_size;
        if (m_bTiff) {
            for (FX_DWORD byte = m_Bpp; byte < m_Pitch; byte ++) {
                m_pCurLine[byte] += m_pCurLine[byte - m_Bpp];
            }
            dest_buf.AppendBlock(m_pCurLine, m_Pitch);
        } else {
            PNG_PredictorLine(m_pCurLine, m_iLine ? m_pRefLine : NULL, m_Pitch - 1, m_Bpp);
            dest_buf.AppendBlock(m_pCurLine + 1, m_Pitch - 1);
            m_iLine ++;
            uint8_t* temp = m_pCurLine;
            m_pCurLine = m_pRefLine;
            m_pRefLine = temp;
        }
        m_LineInSize = 0;
    }
}
CPDF_Ascii85Filter::CPDF_Ascii85Filter()
{
    m_State = 0;
    m_CharCount = 0;
}
void CPDF_Ascii85Filter::v_FilterIn(const uint8_t* src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf)
{
    for (FX_DWORD i = 0; i < src_size; i ++) {
        uint8_t byte = src_buf[i];
        if (PDF_CharType[byte] == 'W') {
            continue;
        }
        switch (m_State) {
            case 0:
                if (byte >= '!' && byte <= 'u') {
                    int digit = byte - '!';
                    m_CurDWord = digit;
                    m_CharCount = 1;
                    m_State = 1;
                } else if (byte == 'z') {
                    int zero = 0;
                    dest_buf.AppendBlock(&zero, 4);
                } else if (byte == '~') {
                    m_State = 2;
                }
                break;
            case 1: {
                    if (byte >= '!' && byte <= 'u') {
                        int digit = byte - '!';
                        m_CurDWord = m_CurDWord * 85 + digit;
                        m_CharCount ++;
                        if (m_CharCount == 5) {
                            for (int i = 0; i < 4; i ++) {
                                dest_buf.AppendByte((uint8_t)(m_CurDWord >> (3 - i) * 8));
                            }
                            m_State = 0;
                        }
                    } else if (byte == '~') {
                        if (m_CharCount > 1) {
                            int i;
                            for (i = m_CharCount; i < 5; i ++) {
                                m_CurDWord = m_CurDWord * 85 + 84;
                            }
                            for (i = 0; i < m_CharCount - 1; i ++) {
                                dest_buf.AppendByte((uint8_t)(m_CurDWord >> (3 - i) * 8));
                            }
                        }
                        m_State = 2;
                    }
                    break;
                }
            case 2:
                if (byte == '>') {
                    ReportEOF(src_size - i - 1);
                    return;
                }
                break;
        }
    }
}
CPDF_AsciiHexFilter::CPDF_AsciiHexFilter()
{
    m_State = 0;
}
void CPDF_AsciiHexFilter::v_FilterIn(const uint8_t* src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf)
{
    for (FX_DWORD i = 0; i < src_size; i ++) {
        uint8_t byte = src_buf[i];
        if (PDF_CharType[byte] == 'W') {
            continue;
        }
        int digit;
        if (byte >= '0' && byte <= '9') {
            digit = byte - '0';
        } else if (byte >= 'a' && byte <= 'f') {
            digit = byte - 'a' + 10;
        } else if (byte >= 'A' && byte <= 'F') {
            digit = byte - 'A' + 10;
        } else {
            if (m_State) {
                dest_buf.AppendByte(m_FirstDigit * 16);
            }
            ReportEOF(src_size - i - 1);
            return;
        }
        if (m_State == 0) {
            m_FirstDigit = digit;
            m_State ++;
        } else {
            dest_buf.AppendByte(m_FirstDigit * 16 + digit);
            m_State --;
        }
    }
}
CPDF_RunLenFilter::CPDF_RunLenFilter()
{
    m_State = 0;
    m_Count = 0;
}
void CPDF_RunLenFilter::v_FilterIn(const uint8_t* src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf)
{
    for (FX_DWORD i = 0; i < src_size; i ++) {
        uint8_t byte = src_buf[i];
        switch (m_State) {
            case 0:
                if (byte < 128) {
                    m_State = 1;
                    m_Count = byte + 1;
                } else if (byte == 128) {
                    ReportEOF(src_size - i - 1);
                    return;
                } else {
                    m_State = 2;
                    m_Count = 257 - byte;
                }
                break;
            case 1:
                dest_buf.AppendByte(byte);
                m_Count --;
                if (m_Count == 0) {
                    m_State = 0;
                }
                break;
            case 2:	{
                    dest_buf.AppendBlock(NULL, m_Count);
                    FXSYS_memset(dest_buf.GetBuffer() + dest_buf.GetSize() - m_Count, byte, m_Count);
                    m_State = 0;
                    break;
                }
        }
    }
}
CPDF_JpegFilter::CPDF_JpegFilter()
{
    m_pContext = NULL;
    m_bGotHeader = false;
    m_pScanline = NULL;
    m_iLine = 0;
}
CPDF_JpegFilter::~CPDF_JpegFilter()
{
    if (m_pScanline) {
        FX_Free(m_pScanline);
    }
    if (m_pContext) {
        CPDF_ModuleMgr::Get()->GetJpegModule()->Finish(m_pContext);
    }
}
void CPDF_JpegFilter::v_FilterIn(const uint8_t* src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf)
{
    if (m_pContext == NULL) {
        m_pContext = CPDF_ModuleMgr::Get()->GetJpegModule()->Start();
    }
    const uint8_t* jpeg_src_buf;
    FX_DWORD jpeg_src_size;
    CFX_BinaryBuf temp_buf;
    if (m_InputBuf.GetSize()) {
        temp_buf.EstimateSize(m_InputBuf.GetSize() + src_size);
        temp_buf.AppendBlock(m_InputBuf.GetBuffer(), m_InputBuf.GetSize());
        m_InputBuf.Clear();
        temp_buf.AppendBlock(src_buf, src_size);
        jpeg_src_buf = temp_buf.GetBuffer();
        jpeg_src_size = temp_buf.GetSize();
    } else {
        jpeg_src_buf = src_buf;
        jpeg_src_size = src_size;
    }
    CPDF_ModuleMgr::Get()->GetJpegModule()->Input(m_pContext, jpeg_src_buf, jpeg_src_size);
    if (!m_bGotHeader) {
        int ret = CPDF_ModuleMgr::Get()->GetJpegModule()->ReadHeader(m_pContext, &m_Width, &m_Height, &m_nComps);
        int left_size = CPDF_ModuleMgr::Get()->GetJpegModule()->GetAvailInput(m_pContext);
        if (ret == 1) {
            ReportEOF(left_size);
            return;
        }
        if (ret == 2) {
            m_InputBuf.AppendBlock(jpeg_src_buf + jpeg_src_size - left_size, left_size);
            return;
        }
        CPDF_ModuleMgr::Get()->GetJpegModule()->StartScanline(m_pContext, 1);
        m_bGotHeader = true;
        m_Pitch = m_Width * m_nComps;
    }
    if (m_pScanline == NULL) {
        m_pScanline = FX_Alloc(uint8_t, m_Pitch + 4);
    }
    while (1) {
        if (!CPDF_ModuleMgr::Get()->GetJpegModule()->ReadScanline(m_pContext, m_pScanline)) {
            int left_size = CPDF_ModuleMgr::Get()->GetJpegModule()->GetAvailInput(m_pContext);
            m_InputBuf.AppendBlock(jpeg_src_buf + jpeg_src_size - left_size, left_size);
            break;
        }
        dest_buf.AppendBlock(m_pScanline, m_Pitch);
        m_iLine ++;
        if (m_iLine == m_Height) {
            ReportEOF(CPDF_ModuleMgr::Get()->GetJpegModule()->GetAvailInput(m_pContext));
            return;
        }
    }
}
CPDF_FaxFilter::CPDF_FaxFilter()
{
    m_Encoding = 0;
    m_bEndOfLine = false;
    m_bByteAlign = false;
    m_bBlack = false;
    m_nRows = 0;
    m_nColumns = 0;
    m_Pitch = 0;
    m_pScanlineBuf = NULL;
    m_pRefBuf = NULL;
    m_iRow = 0;
    m_InputBitPos = 0;
}
CPDF_FaxFilter::~CPDF_FaxFilter()
{
    if (m_pScanlineBuf) {
        FX_Free(m_pScanlineBuf);
    }
    if (m_pRefBuf) {
        FX_Free(m_pRefBuf);
    }
}
bool CPDF_FaxFilter::Initialize(int Encoding, int bEndOfLine, int bByteAlign, int bBlack, int nRows, int nColumns)
{
    m_Encoding = Encoding;
    m_bEndOfLine = bEndOfLine;
    m_bByteAlign = bByteAlign;
    m_bBlack = bBlack;
    m_nRows = nRows;
    m_nColumns = nColumns;
    m_Pitch = (m_nColumns + 7) / 8;
    m_pScanlineBuf = FX_Alloc(uint8_t, m_Pitch);
    m_pRefBuf = FX_Alloc(uint8_t, m_Pitch);
    FXSYS_memset(m_pScanlineBuf, 0xff, m_Pitch);
    FXSYS_memset(m_pRefBuf, 0xff, m_Pitch);
    m_iRow = 0;
    m_InputBitPos = 0;
    return true;
}
void CPDF_FaxFilter::v_FilterIn(const uint8_t* src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf)
{
    const uint8_t* fax_src_buf;
    FX_DWORD fax_src_size;
    CFX_BinaryBuf temp_buf;
    int bitpos;
    if (m_InputBuf.GetSize()) {
        temp_buf.EstimateSize(m_InputBuf.GetSize() + src_size);
        temp_buf.AppendBlock(m_InputBuf.GetBuffer(), m_InputBuf.GetSize());
        m_InputBuf.Clear();
        temp_buf.AppendBlock(src_buf, src_size);
        fax_src_buf = temp_buf.GetBuffer();
        fax_src_size = temp_buf.GetSize();
        bitpos = m_InputBitPos;
    } else {
        fax_src_buf = src_buf;
        fax_src_size = src_size;
        bitpos = 0;
    }
    ProcessData(fax_src_buf, fax_src_size, bitpos, false, dest_buf);
    int left_bits = fax_src_size * 8 - bitpos;
    m_InputBuf.AppendBlock(fax_src_buf + bitpos / 8, (left_bits + 7) / 8);
    m_InputBitPos = bitpos % 8;
}
void CPDF_FaxFilter::v_FilterFinish(CFX_BinaryBuf& dest_buf)
{
    ProcessData(m_InputBuf.GetBuffer(), m_InputBuf.GetSize(), m_InputBitPos, true, dest_buf);
}
bool _FaxSkipEOL(const uint8_t* src_buf, int bitsize, int& bitpos);
bool _FaxG4GetRow(const uint8_t* src_buf, int bitsize, int& bitpos, uint8_t* dest_buf, const uint8_t* ref_buf, int columns);
bool _FaxGet1DLine(const uint8_t* src_buf, int bitsize, int& bitpos, uint8_t* dest_buf, int columns);
void CPDF_FaxFilter::ProcessData(const uint8_t* src_buf, FX_DWORD src_size, int& bitpos, bool bFinish,
                                 CFX_BinaryBuf& dest_buf)
{
    int bitsize = src_size * 8;
    while (1) {
        if ((bitsize < bitpos + 256) && !bFinish) {
            return;
        }
        int start_bitpos = bitpos;
        FXSYS_memset(m_pScanlineBuf, 0xff, m_Pitch);
        if (!ReadLine(src_buf, bitsize, bitpos)) {
            bitpos = start_bitpos;
            return;
        }
        if (m_Encoding) {
            FXSYS_memcpy(m_pRefBuf, m_pScanlineBuf, m_Pitch);
        }
        if (m_bBlack) {
            for (int i = 0; i < m_Pitch; i ++) {
                m_pScanlineBuf[i] = ~m_pScanlineBuf[i];
            }
        }
        dest_buf.AppendBlock(m_pScanlineBuf, m_Pitch);
        m_iRow ++;
        if (m_iRow == m_nRows) {
            ReportEOF(src_size - (bitpos + 7) / 8);
            return;
        }
    }
}
bool CPDF_FaxFilter::ReadLine(const uint8_t* src_buf, int bitsize, int& bitpos)
{
    if (!_FaxSkipEOL(src_buf, bitsize, bitpos)) {
        return false;
    }
    bool ret;
    if (m_Encoding < 0) {
        ret = _FaxG4GetRow(src_buf, bitsize, bitpos, m_pScanlineBuf, m_pRefBuf, m_nColumns);
    } else if (m_Encoding == 0) {
        ret = _FaxGet1DLine(src_buf, bitsize, bitpos, m_pScanlineBuf, m_nColumns);
    } else {
        if (bitpos == bitsize) {
            return false;
        }
        bool bNext1D = src_buf[bitpos / 8] & (1 << (7 - bitpos % 8));
        bitpos ++;
        if (bNext1D) {
            ret = _FaxGet1DLine(src_buf, bitsize, bitpos, m_pScanlineBuf, m_nColumns);
        } else {
            ret = _FaxG4GetRow(src_buf, bitsize, bitpos, m_pScanlineBuf, m_pRefBuf, m_nColumns);
        }
    }
    if (!ret) {
        return false;
    }
    if (m_bEndOfLine)
        if (!_FaxSkipEOL(src_buf, bitsize, bitpos)) {
            return false;
        }
    if (m_bByteAlign) {
        bitpos = (bitpos + 7) / 8 * 8;
    }
    return true;
}