//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1992 - 1995.

//  File:       CCodeFt.cxx

//  Contents:

//  Classes:

//  Functions:

//  History:    04-29-97   DanpoZ (Danpo Zhang)   Created


#include <eapp.h>

PerfDbgTag(tagDft,     "Pluggable MF", "Log CDataFt", DEB_PROT)
    DbgTag(tagDftErr,  "Pluggable MF", "Log CDataFtErrors", DEB_PROT|DEB_ERROR)
#define SZDFILTERROOT  "PROTOCOLS\\Filter\\Data Filter\\"




//  Method:     CStdZFilter::QueryInterface

//  Synopsis:

//  Arguments:

//  Returns:

//  History:    06-26-97   DanpoZ (Danpo Zhang)   Created

//  Notes:


STDMETHODIMP
CStdZFilter::QueryInterface(REFIID riid, void **ppvObj)
{
    PerfDbgLog(tagDft, this, "+CStdFilter::QueryInterface");

    VDATEPTROUT(ppvObj, void*);
    VDATETHIS(this);

    HRESULT hr = NOERROR;
    if( riid == IID_IUnknown ||
        riid == IID_IDataFilter )
    {
        *ppvObj = this;
        AddRef();
    }
    else
        hr = E_NOINTERFACE;

    PerfDbgLog1(
        tagDft, this, "-CStdZFilter::QueryInterface(hr:%1x)", hr);

    return hr;
}




//  Method:     CStdZFilter::AddRef

//  Synopsis:

//  Arguments:

//  Returns:

//  History:    06-26-97   DanpoZ (Danpo Zhang)   Created

//  Notes:


STDMETHODIMP_(ULONG)
CStdZFilter::AddRef()
{
    PerfDbgLog(tagDft, this, "+CStdZFilter::AddRef");
    LONG lRet = ++_CRefs;
    DllAddRef();
    PerfDbgLog1(tagDft, this, "-CStdZFilter::AddRef(cRef:%1d)", lRet);

    return lRet;
}




//  Method:     CStdZFilter::Release

//  Synopsis:

//  Arguments:

//  Returns:

//  History:    06-26-97   DanpoZ (Danpo Zhang)   Created

//  Notes:


STDMETHODIMP_(ULONG)
CStdZFilter::Release()
{
    PerfDbgLog(tagDft, this, "+CStdZFilter::Release");
    LONG lRet = --_CRefs;
    if(!lRet)
        delete this;
    DllRelease();
    PerfDbgLog1(tagDft, this, "-CStdZFilter::Release(cRef:%1d)", lRet);

    return lRet;
}




//  Method:     CStdZFilter::DoEncode

//  Synopsis:

//  Arguments:  [dwFlags]           - flags
//              [lInBufferSize]     - Input Buffer Size
//              [pbInBuffer]        - Input Buffer
//              [lOutBufferSize]    - Output Buffer Size
//              [pbOutBuffer]       - Output Buffer
//              [lInBytesAvailable] - Data available in Input Buffer
//              [plInBytesRead]     - Total data read from input buffer
//              [plOutBytesWritten] - Total data written to output buffer
//              [dwReserved]        - currently not used

//  Returns:    NOERROR or E_FAIL

//  History:    06-27-97   DanpoZ (Danpo Zhang)   Created

//  Notes:


STDMETHODIMP
CStdZFilter::DoEncode(
        DWORD dwFlags,
        LONG  lInBufferSize,
        BYTE* pbInBuffer,
        LONG  lOutBufferSize,
        BYTE* pbOutBuffer,
        LONG  lInBytesAvailable,
        LONG* plInBytesRead,
        LONG* plOutBytesWritten,
        DWORD dwReserved
)
{
    PerfDbgLog(tagDft, this, "+CStdZFilter::DoEncode");
    HRESULT hr = NOERROR;

    if( !_pEncodeCtx )
        hr = CreateCompression(&_pEncodeCtx, _ulSchema);

    if( _pEncodeCtx && !FAILED(hr) )
    {
        PProtAssert( pbInBuffer && pbOutBuffer &&
                     plInBytesRead && plOutBytesWritten);

        hr = Compress(
            _pEncodeCtx,
            pbInBuffer,
            lInBytesAvailable,
            pbOutBuffer,
            lOutBufferSize,
            plInBytesRead,
            plOutBytesWritten,
            _cEncLevel
        );
    }

    PerfDbgLog1(tagDft, this, "-CStdZFilter::DoEncode(hr:%1x)", hr);
    return hr;
}




//  Method:     CStdZFilter::DoDecode

//  Synopsis:

//  Arguments:  [dwFlags]           - flags
//              [lInBufferSize]     - Input Buffer Size
//              [pbInBuffer]        - Input Buffer
//              [lOutBufferSize]    - Output Buffer Size
//              [pbOutBuffer]       - Output Buffer
//              [lInBytesAvailable] - Data available in Input Buffer
//              [plInBytesRead]     - Total data read from input buffer
//              [plOutBytesWritten] - Total data written to output buffer
//              [dwReserved]        - reserved

//  Returns:    NOERROR or E_FAIL

//  History:    06-27-97   DanpoZ (Danpo Zhang)   Created

//  Notes:


STDMETHODIMP
CStdZFilter::DoDecode(
        DWORD dwFlags,
        LONG  lInBufferSize,
        BYTE* pbInBuffer,
        LONG  lOutBufferSize,
        BYTE* pbOutBuffer,
        LONG  lInBytesAvailable,
        LONG* plInBytesRead,
        LONG* plOutBytesWritten,
        DWORD dwReserved
)
{
    PerfDbgLog(tagDft, this, "+CStdZFilter::DoDecode");
    HRESULT hr = NOERROR;

    if( !_pDecodeCtx )
        hr = CreateDecompression(&_pDecodeCtx, _ulSchema);

    if( _pDecodeCtx && !FAILED(hr) )
    {
        PProtAssert( pbInBuffer && pbOutBuffer &&
                     plInBytesRead && plOutBytesWritten);

        hr = Decompress(
            _pDecodeCtx,
            pbInBuffer,
            lInBytesAvailable,
            pbOutBuffer,
            lOutBufferSize,
            plInBytesRead,
            plOutBytesWritten
        );
    }

    PerfDbgLog1(tagDft, this, "-CStdZFilter::DoDecode(hr:%1x)", hr);
    return hr;
}




//  Method:     CStdZFilter::SetEncodingLevel

//  Synopsis:

//  Arguments:  [cEncLevel]     - encoding level (between 1-100)

//  Returns:    NOERROR or E_FAIL

//  History:    06-27-97   DanpoZ (Danpo Zhang)   Created

//  Notes:


STDMETHODIMP
CStdZFilter::SetEncodingLevel(DWORD dwEncLevel)
{
    PerfDbgLog(tagDft, this, "+CStdZFilter::SetEncodingLevel");
    HRESULT hr = NOERROR;

    if( dwEncLevel >= 1 && dwEncLevel <= 100 )
    {
        // input value should be between 1 - 100]
        // our formula is _cEncLevel = dwEncLevel * 10 / 100
        _cEncLevel = (dwEncLevel * 10) / 100;
        if( !_cEncLevel )
            ++_cEncLevel;
    }
    else
        hr = E_INVALIDARG;

    PerfDbgLog1(
        tagDft, this, "-CStdZFilter::SetEncodingLevel(hr:%1x)", hr);
    return hr;
}



//  Method:     CStdZFilter::InitFilter

//  Synopsis:

//  Arguments:

//  Returns:    NOERROR or E_FAIL (dll init failed)

//  History:    06-27-97   DanpoZ (Danpo Zhang)   Created

//  Notes:


HRESULT
CStdZFilter::InitFilter()
{
    PerfDbgLog(tagDft, this, "+CStdZFilter::InitFilter");
    HRESULT hr = NOERROR;


    // init the compressor
    if (FAILED(InitCompression()))
        hr = E_FAIL;

    // init the decompressor
    if (FAILED(InitDecompression()))
        hr = E_FAIL;

    PerfDbgLog(tagDft, this, "-CStdZFilter::InitFilter");
    return hr;
}





//  Method:     CStdZFilter::CStdZFilter

//  Synopsis:

//  Arguments:

//  Returns:

//  History:    06-26-97   DanpoZ (Danpo Zhang)   Created

//  Notes:


CStdZFilter::CStdZFilter(ULONG ulSchema)
    : _CRefs()
{
    PerfDbgLog(tagDft, this, "+CStdZFilter::CStdZFilter");
    _pEncodeCtx = NULL;
    _pDecodeCtx = NULL;

    // accepts the number between 1[fastest] - 10[most compres]
    // the formula is _cEncLevel/10 = 50/100
    _cEncLevel= 5;

    _ulSchema = ulSchema;

    PerfDbgLog(tagDft, this, "-CStdZFilter::CStdZFilter");
}



//  Method:     CStdZFilter::~CStdZFilter

//  Synopsis:

//  Arguments:

//  Returns:

//  History:    06-26-97   DanpoZ (Danpo Zhang)   Created

//  Notes:


CStdZFilter::~CStdZFilter()
{
    PerfDbgLog(tagDft, this, "+CStdZFilter::~CStdZFilter");
    if( _pEncodeCtx )
        DestroyCompression(_pEncodeCtx);
    if( _pDecodeCtx )
        DestroyDecompression(_pDecodeCtx);
    PerfDbgLog(tagDft, this, "-CStdZFilter::~CStdZFilter");
}




//  Method:     CEncodingFilterFactory::QueryInterface

//  Synopsis:

//  Arguments:

//  Returns:

//  History:    04-29-97   DanpoZ (Danpo Zhang)   Created

//  Notes:


STDMETHODIMP
CEncodingFilterFactory::QueryInterface(REFIID riid, void **ppvObj)
{
    PerfDbgLog(tagDft, this, "+CEncodingFilterFactory::QueryInterface");
    VDATEPTROUT(ppvObj, void*);
    VDATETHIS(this);

    HRESULT hr = NOERROR;
    if( riid == IID_IUnknown ||
        riid == IID_IEncodingFilterFactory )
    {
        *ppvObj = this;
        AddRef();
    }
    else
        hr = E_NOINTERFACE;

    PerfDbgLog1(
        tagDft, this, "-CEncodingFilterFactory::QueryInterface(hr:%1x)", hr);
    return hr;
}




//  Method:     CEncodingFilterFactory::AddRef

//  Synopsis:

//  Arguments:

//  Returns:

//  History:    04-29-97   DanpoZ (Danpo Zhang)   Created

//  Notes:


STDMETHODIMP_(ULONG)
CEncodingFilterFactory::AddRef()
{
    PerfDbgLog(tagDft, this, "+CEncodingFilterFactory::AddRef");
    LONG lRet = ++_CRefs;
    PerfDbgLog1(
        tagDft, this, "-CEncodingFilterFactory::AddRef(cRef:%1d)", lRet);
    return lRet;
}



//  Method:     CEncodingFilterFactory::Release

//  Synopsis:

//  Arguments:

//  Returns:

//  History:    04-29-97   DanpoZ (Danpo Zhang)   Created

//  Notes:


STDMETHODIMP_(ULONG)
CEncodingFilterFactory::Release()
{
    PerfDbgLog(tagDft, this, "+CEncodingFilterFactory::Release");
    LONG lRet = --_CRefs;
    if(!lRet)
        delete this;

    PerfDbgLog1(
        tagDft, this, "-CEncodingFilterFactory::Release(cRef:%1d)", lRet);
    return lRet;
}




//  Method:     CEncodingFilterFactory::FindBestFilter

//  Synopsis:

//  Arguments:  [grfETYPEIn]  - input encoding type
//              [grfETYPEOut] - output encoding type
//              [info]        - DATAINFO (what the data looks like)
//              [ppDF]        - output DataFilter pointer

//  Returns:

//  History:    04-29-97   DanpoZ (Danpo Zhang)   Created

//  Notes:      currently it calls FindDefaultFilter()


STDMETHODIMP
CEncodingFilterFactory::FindBestFilter(
        LPCWSTR         pwzCodeIn,
        LPCWSTR         pwzCodeOut,
        DATAINFO        info,
        IDataFilter**   ppDF
)
{
    PerfDbgLog(tagDft, this, "+CEncodingFilterFactory::FindBestFilter");
    HRESULT hr = NOERROR;
    hr = GetDefaultFilter(pwzCodeIn, pwzCodeOut, ppDF);
    PerfDbgLog1(
        tagDft, this, "-CEncodingFilterFactory::FindBestFilter(hr:%1x)", hr);
    return hr;
}




//  Method:     CEncodingFilterFactory::GetDefaultFilter

//  Synopsis:

//  Arguments:  [tIn]       - input encoding type
//              [tOut]      - output encoding type
//              [ppDF]      - output DataFilter pointer

//  Returns:

//  History:    04-29-97   DanpoZ (Danpo Zhang)   Created

//  Notes:


STDMETHODIMP
CEncodingFilterFactory::GetDefaultFilter(
        LPCWSTR         pwzCodeIn,
        LPCWSTR         pwzCodeOut,
        IDataFilter**   ppDF
)
{
    PerfDbgLog(tagDft, this, "+CEncodingFilterFactory::GetDefaultFilter");
    VDATEPTROUT(ppDF, void*);
    *ppDF = NULL;

    HRESULT hr = E_FAIL;
    BOOL fBuiltIn = FALSE;

    if( (!_wcsicmp(pwzCodeIn, L"gzip") && !_wcsicmp(pwzCodeOut, L"text")) ||
        (!_wcsicmp(pwzCodeIn, L"text") && !_wcsicmp(pwzCodeOut, L"gzip") ) )
    {
        // GZIP
        *ppDF = new CStdZFilter(COMPRESSION_FLAG_GZIP);
        fBuiltIn = TRUE;
        if( !(*ppDF) )
        {
            hr = E_OUTOFMEMORY;
        }
    }
    else
    if((!_wcsicmp(pwzCodeIn, L"deflate") && !_wcsicmp(pwzCodeOut, L"text"))||        (!_wcsicmp(pwzCodeIn, L"text") && !_wcsicmp(pwzCodeOut, L"deflate")) )
    {
        // deflate
        *ppDF = new CStdZFilter(COMPRESSION_FLAG_DEFLATE);
        fBuiltIn = TRUE;
        if( !(*ppDF) )
        {
            hr = E_OUTOFMEMORY;
        }
    }
    else
    {
        // lookup reg to find out the class
        CLSID   clsid = CLSID_NULL;
        hr = LookupClsIDFromReg(pwzCodeIn, pwzCodeOut, &clsid, 0);
        if( hr == NOERROR )
        {   // Get Clsid
            IClassFactory*  pCF = NULL;
            hr = CoGetClassObject(clsid, CLSCTX_INPROC_SERVER, NULL, IID_IClassFactory, (void**)&pCF );
            if( hr == NOERROR )
            {   // Get Class Fac
                IUnknown*   pUnk = NULL;
                hr = pCF->CreateInstance(NULL, IID_IUnknown, (void**)&pUnk);

                if( hr == NOERROR )
                {   // Created Instance
                    hr = pUnk->QueryInterface(IID_IDataFilter, (void**)ppDF);

                    pUnk->Release();
                }   // Created Instance

                pCF->Release();

            }   // Get Class Fac
        }   // Get Clsid
    }   // lookup reg to find out the class

    // only do this for built-in filter (this is not universal)
    if( (*ppDF) && fBuiltIn )
    {
        hr = ((CStdZFilter*)(*ppDF))->InitFilter();
    }

    PerfDbgLog1(
        tagDft, this, "-CEncodingFilterFactory::GetDefaultFilter(hr:%1x)",hr);
    return hr;
}



//  Method:     CEncodingFilterFactory::LookupClsIDFromReg

//  Synopsis:

//  Arguments:

//  Returns:

//  History:    08-20-97   DanpoZ (Danpo Zhang)   Created

//  Notes:


STDMETHODIMP
CEncodingFilterFactory::LookupClsIDFromReg(
        LPCWSTR         pwzCodeIn,
        LPCWSTR         pwzCodeOut,
        CLSID*          pclsid,
        DWORD           dwFlags
)
{
    HRESULT hr = E_FAIL;

    CHAR szCodeIn[ULPROTOCOLLEN];
    CHAR szCodeOut[ULPROTOCOLLEN];
    CHAR szCodeKey[2*ULPROTOCOLLEN+1];
    DWORD dwLen = 256;
    CHAR szDFilterKey[MAX_PATH];
    BOOL fFoundKey = FALSE;
    HKEY hDFKey = NULL;
    DWORD dwType;

    W2A(pwzCodeIn, szCodeIn, ULPROTOCOLLEN);
    W2A(pwzCodeOut, szCodeOut, ULPROTOCOLLEN);

    // check buffer overrun
    if( (strlen(szCodeIn) + strlen(szCodeOut) + strlen(szDFilterKey) + 2)
        <= MAX_PATH )
    {

        // try key#1
        strcpy(szDFilterKey, SZDFILTERROOT);
        strcat(szDFilterKey, szCodeIn);
        strcat(szDFilterKey, "#");
        strcat(szDFilterKey, szCodeOut);

        if( RegOpenKeyEx(HKEY_CLASSES_ROOT, szDFilterKey, 0, KEY_QUERY_VALUE, &hDFKey ) == ERROR_SUCCESS)
        {
            if( RegQueryValueEx(hDFKey, SZCLASS, NULL, &dwType, (LPBYTE)szDFilterKey, &dwLen) == ERROR_SUCCESS)
            {
                hr = CLSIDFromStringA(szDFilterKey, pclsid);
                fFoundKey = TRUE;
            }

            RegCloseKey(hDFKey);
        }


        // try key#2
        if( !fFoundKey )
        {
            strcpy(szDFilterKey, SZDFILTERROOT);
            strcat(szDFilterKey, szCodeOut);
            strcat(szDFilterKey, "#");
            strcat(szDFilterKey, szCodeIn);

            if( RegOpenKeyEx(HKEY_CLASSES_ROOT, szDFilterKey, 0, KEY_QUERY_VALUE, &hDFKey ) == ERROR_SUCCESS )
            {
                if( RegQueryValueEx(hDFKey, SZCLASS, NULL, &dwType, (LPBYTE)szDFilterKey, &dwLen) == ERROR_SUCCESS)
                {
                    hr = CLSIDFromStringA(szDFilterKey, pclsid);
                }

                RegCloseKey(hDFKey);
            }
        }
    }

    return hr;
}



//  Method:     CEncodingFilterFactory::CEncodingFilterFactory

//  Synopsis:

//  Arguments:

//  Returns:

//  History:    04-29-97   DanpoZ (Danpo Zhang)   Created

//  Notes:


CEncodingFilterFactory::CEncodingFilterFactory()
    : _CRefs()
{
    PerfDbgLog(
        tagDft, this, "+CEncodingFilterFactory::CEncodingFilterFactory");

    PerfDbgLog(
        tagDft, this, "-CEncodingFilterFactory::CEncodingFilterFactory");
}



//  Method:     CEncodingFilterFactory::~CEncodingFilterFactory

//  Synopsis:

//  Arguments:

//  Returns:

//  History:    04-29-97   DanpoZ (Danpo Zhang)   Created

//  Notes:


CEncodingFilterFactory::~CEncodingFilterFactory()
{
    PerfDbgLog(
        tagDft, this, "+CEncodingFilterFactory::~CEncodingFilterFactory");

    PerfDbgLog(
        tagDft, this, "-CEncodingFilterFactory::~CEncodingFilterFactory");
}