//==========================================================================;
//
//  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
//  KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
//  IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
//  PURPOSE.
//
//  Copyright (c) 1992 - 1997  Microsoft Corporation.  All Rights Reserved.
//
//--------------------------------------------------------------------------;

#include <windows.h>
#include <streams.h>
#include <initguid.h>
#include <olectl.h>
#if (1100 > _MSC_VER)
#include <olectlid.h>
#endif
#include "contuids.h"
#include "icontrst.h"
#include "contprop.h"
#include "contrast.h"

//
//
// What this sample illustrates
//
// A simple transform filter that adjusts contrast on a video stream. We use
// eight bit palettised images exclusively and can increase or decrease the
// contrast. The contrast is adjusted through a custom interface we support.
// We have a property page that uses this interface to respond to user action
//
// Summary
//
// This is a sample transform filter - we have a single input pin and also a
// single output pin. The input pin accepts only palettised eight bit video
// formats and our output pin also provides an eight bit palettised format.
// We will normally be put between a video decoder (AVI or MPEG) and a video
// renderer. We adjust the contrast of the video images sent through us, by
// increasing contrast the colours become more suturated and likewise less
// contrast reduces the colour into some grey shades and finally to all grey
//
//
// Implementation
//
// We adjust contrast using a neat trick with palettes, the colour palette of
// an image effectively determines how the image is interpreted. So in short
// how the value 23 (for example) is turned into an RGB triplet for display.
// By changing the palette we can reduce and increase contrast without doing
// anything to the actual image pixels themselves (which makes us go faster).
// So by adjusting the palette in band we can adjust the pixel interpretion.
//
// The runtime video renderer supports palette changes in band, when we want
// to change palettes we pick the new colours and attach a VIDEOINFO to the
// next image we send to the renderer. It will then take that palette out of
// the sample and realise a new palette in the window for us. The trigger to
// change the palette is through a custom interface this filter provides.
//
// The custom interface we implement is called IContrast, this allows someone
// to increase and decrease contrast levels for a given video. The normal way
// for the interface to be used is to right click on the contrast filter in
// GRAPHEDT and bring up our property page. This has a slider control on it
// that can be used to adjust the contrast level. Each time the slider moves
// it will ask for a contrast change by calling IContrast. To expose property
// pages a filter implements the ISpecifyPropertyPages interface (it has only
// one method called GetPages which returns the CLSIDs for the property pages)
//
//
// Demonstration instructions
//
// Start GRAPHEDT available in the ActiveMovie SDK tools. Drag and drop any
// MPEG, AVI or MOV file into the tool and it will be rendered. Then go to
// the filters in the graph and find the filter (box) titled "Video Renderer"
// Disconnect the renderer from its source filter and insert a contrast in
// between them (the contrast is added to the graph using the Graph Menu and
// selecting Insert Filters, the filter is in the dialog box list). Once the
// contrast filter is inserted run the graph. Right click on the contrast
// box and select properties which brings up a property page that contains a
// slider. The slider can be dragged up and down to adjust the contrast level
//
//
// Files
//
// contprop.cpp         Property page implementation with a slider control
// contprop.h           Class definition for the property page
// contprop.rc          Dialog box template for the property page
// contrast.cpp         Main contrast filter class implementation
// contrast.def         What APIs we import and export from this DLL
// contrast.h           Class definition for the contrast filter
// contrast.reg         What goes in the registry to make us work
// contuids.h           The transform filter CLSIDs
// icontrst.h           Defines the custom contrast filter interface
// makefile             How to build it...
// resource.h           Microsoft Visual C++ generated resource file
//
//
// Base classes we use
//
// CTransformFilter     A generic transform filter that has a single input
//                      and a single output pin. It has some PURE virtual
//                      methods we must override (such as the Transform
//                      method that does the real work). We also use it's
//                      CUnknown base class to implement IUnknown for the
//                      IContrast and ISpecifyPropertyPages we also support
//
//


// setup data

const AMOVIESETUP_MEDIATYPE sudPinTypes =
{
    &MEDIATYPE_Video,       // Major type
    &MEDIASUBTYPE_NULL      // Minor type
};

const AMOVIESETUP_PIN psudPins[] =
{
    {
        L"Input",           // String pin name
        FALSE,              // Is it rendered
        FALSE,              // Is it an output
        FALSE,              // Allowed none
        FALSE,              // Allowed many
        &CLSID_NULL,        // Connects to filter
        L"Output",          // Connects to pin
        1,                  // Number of types
        &sudPinTypes },     // The pin details
      { L"Output",          // String pin name
        FALSE,              // Is it rendered
        TRUE,               // Is it an output
        FALSE,              // Allowed none
        FALSE,              // Allowed many
        &CLSID_NULL,        // Connects to filter
        L"Input",           // Connects to pin
        1,                  // Number of types
        &sudPinTypes        // The pin details
    }
};


const AMOVIESETUP_FILTER sudContrast =
{
    &CLSID_Contrast,        // Filter CLSID
    L"Video Contrast",      // Filter name
    MERIT_DO_NOT_USE,       // Its merit
    2,                      // Number of pins
    psudPins                // Pin details
};


// List of class IDs and creator functions for the class factory. This
// provides the link between the OLE entry point in the DLL and an object
// being created. The class factory will call the static CreateInstance

CFactoryTemplate g_Templates[2] = {

    { L"Video Contrast"
    , &CLSID_Contrast
    , CContrast::CreateInstance
    , NULL
    , &sudContrast }
  ,
    { L"Video Contrast Property Page"
    , &CLSID_ContrastPropertyPage
    , CContrastProperties::CreateInstance }
};
int g_cTemplates = sizeof(g_Templates) / sizeof(g_Templates[0]);


//
// Constructor
//
CContrast::CContrast(TCHAR *tszName,LPUNKNOWN punk,HRESULT *phr) :
    CTransformFilter(tszName, punk, CLSID_Contrast),
    m_DefaultContrastLevel(0),
    m_ContrastLevel(m_DefaultContrastLevel),
    m_PrevLevel(m_ContrastLevel),
    m_lBufferRequest(1)
{
    ASSERT(tszName);
    ASSERT(phr);

} // Contrast


//
// CreateInstance
//
// Provide the way for COM to create a CContrast object
//
CUnknown * WINAPI CContrast::CreateInstance(LPUNKNOWN punk, HRESULT *phr) {

    CContrast *pNewObject = new CContrast(NAME("Contrast"), punk, phr);
    if (pNewObject == NULL) {
        *phr = E_OUTOFMEMORY;
    }
    return pNewObject;

} // CreateInstance


//
// NonDelegatingQueryInterface
//
// Reveals IContrast and ISpecifyPropertyPages
//
STDMETHODIMP CContrast::NonDelegatingQueryInterface(REFIID riid, void **ppv)
{
    CheckPointer(ppv,E_POINTER);

    if (riid == IID_IContrast) {
        return GetInterface((IContrast *) this, ppv);
    } else if (riid == IID_ISpecifyPropertyPages) {
        return GetInterface((ISpecifyPropertyPages *) this, ppv);
    } else {
        return CTransformFilter::NonDelegatingQueryInterface(riid, ppv);
    }

} // NonDelegatingQueryInterface


//
// Transform
//
// Copy the input sample into the output sample
// Then transform the output sample 'in place'
//
HRESULT CContrast::Transform(IMediaSample *pIn, IMediaSample *pOut)
{
    HRESULT hr = Copy(pIn, pOut);
    if (FAILED(hr)) {
        return hr;
    }
    return Transform(pOut);

} // Transform


//
// Copy
//
// Make destination an identical copy of source
//
HRESULT CContrast::Copy(IMediaSample *pSource, IMediaSample *pDest) const
{
    // Copy the sample data

    BYTE *pSourceBuffer, *pDestBuffer;
    long lSourceSize = pSource->GetActualDataLength();
    long lDestSize	= pDest->GetSize();

    ASSERT(lDestSize >= lSourceSize);

    pSource->GetPointer(&pSourceBuffer);
    pDest->GetPointer(&pDestBuffer);

    CopyMemory( (PVOID) pDestBuffer,(PVOID) pSourceBuffer,lSourceSize);

    // Copy the sample times

    REFERENCE_TIME TimeStart, TimeEnd;
    if (NOERROR == pSource->GetTime(&TimeStart, &TimeEnd)) {
        pDest->SetTime(&TimeStart, &TimeEnd);
    }

    LONGLONG MediaStart, MediaEnd;
    if (pSource->GetMediaTime(&MediaStart,&MediaEnd) == NOERROR) {
        pDest->SetMediaTime(&MediaStart,&MediaEnd);
    }

    // Copy the Sync point property

    HRESULT hr = pSource->IsSyncPoint();
    if (hr == S_OK) {
        pDest->SetSyncPoint(TRUE);
    }
    else if (hr == S_FALSE) {
        pDest->SetSyncPoint(FALSE);
    }
    else {  // an unexpected error has occured...
        return E_UNEXPECTED;
    }

    // Copy the media type

    AM_MEDIA_TYPE *pMediaType;
    pSource->GetMediaType(&pMediaType);
    pDest->SetMediaType(pMediaType);
    DeleteMediaType(pMediaType);

    // Copy the preroll property

    hr = pSource->IsPreroll();
    if (hr == S_OK) {
        pDest->SetPreroll(TRUE);
    }
    else if (hr == S_FALSE) {
        pDest->SetPreroll(FALSE);
    }
    else {  // an unexpected error has occured...
        return E_UNEXPECTED;
    }

    // Copy the discontinuity property

    hr = pSource->IsDiscontinuity();
    if (hr == S_OK) {
	pDest->SetDiscontinuity(TRUE);
    }
    else if (hr == S_FALSE) {
        pDest->SetDiscontinuity(FALSE);
    }
    else {  // an unexpected error has occured...
        return E_UNEXPECTED;
    }

    // Copy the actual data length

    long lDataLength = pSource->GetActualDataLength();
    pDest->SetActualDataLength(lDataLength);
    return NOERROR;

} // Copy


//
// Transform
//
// 'In place' adjust the contrast of this sample
//
HRESULT CContrast::Transform(IMediaSample *pMediaSample)
{
    signed char ContrastLevel;

    // Take a copy, so we dont hold the lock
    // for the whole transform. Also ensures
    // we use the same level throughout this!
    {
        CAutoLock cAutoLock(&m_ContrastLock);
	ContrastLevel = m_ContrastLevel;	
    }

    AM_MEDIA_TYPE *pAdjustedType = NULL;

    pMediaSample->GetMediaType(&pAdjustedType);
    if (pAdjustedType != NULL) {
        if (CheckInputType(&CMediaType(*pAdjustedType)) == S_OK) {
            m_pInput->CurrentMediaType() = *pAdjustedType;
	    CoTaskMemFree(pAdjustedType);
	} else {
	    CoTaskMemFree(pAdjustedType);
	    return E_FAIL;
	}
    }

    // Pass on format changes to downstream filters

    if ((pAdjustedType != NULL) || (m_PrevLevel != ContrastLevel)) {
	CMediaType AdjustedType((AM_MEDIA_TYPE) m_pInput->CurrentMediaType());
        HRESULT hr = Transform(&AdjustedType, ContrastLevel);
        if (hr == S_OK) {
            pMediaSample->SetMediaType(&AdjustedType);
	    m_PrevLevel = ContrastLevel;
        } else {
            return hr;
        }
    }
    return NOERROR;

} // Transform


//
// CheckInputType
//
// Check the input type is OK, return an error otherwise
//
HRESULT CContrast::CheckInputType(const CMediaType *mtIn)
{
    // Check this is a VIDEOINFO type

    if (*mtIn->FormatType() != FORMAT_VideoInfo) {
        return E_INVALIDARG;
    }

    // Is this a palettised format

    if (CanChangeContrastLevel(mtIn)) {
    	return NOERROR;
    }
    return E_FAIL;

} // CheckInputType


//
// CheckTransform
//
// To be able to transform the formats must be identical
//
HRESULT CContrast::CheckTransform(const CMediaType *mtIn,const CMediaType *mtOut)
{
    HRESULT hr;
    if (FAILED(hr = CheckInputType(mtIn))) {
	return hr;
    }

    // format must be a VIDEOINFOHEADER
    if (*mtOut->FormatType() != FORMAT_VideoInfo) {
	return E_INVALIDARG;
    }
    
    // formats must be big enough 
    if (mtIn->FormatLength() < sizeof(VIDEOINFOHEADER) ||
	mtOut->FormatLength() < sizeof(VIDEOINFOHEADER))
	return E_INVALIDARG;
    
    VIDEOINFO *pInput = (VIDEOINFO *) mtIn->Format();
    VIDEOINFO *pOutput = (VIDEOINFO *) mtOut->Format();
    if (memcmp(&pInput->bmiHeader,&pOutput->bmiHeader,sizeof(BITMAPINFOHEADER)) == 0) {
	return NOERROR;
    }

    return E_INVALIDARG;
} // CheckTransform


//
// DecideBufferSize
//
// Tell the output pin's allocator what size buffers we
// require. Can only do this when the input is connected
//
HRESULT CContrast::DecideBufferSize(IMemAllocator *pAlloc,ALLOCATOR_PROPERTIES *pProperties)
{
    // Is the input pin connected

    if (m_pInput->IsConnected() == FALSE) {
        return E_UNEXPECTED;
    }

    ASSERT(pAlloc);
    ASSERT(pProperties);
    HRESULT hr = NOERROR;

    pProperties->cBuffers = 1;
    pProperties->cbBuffer = m_pInput->CurrentMediaType().GetSampleSize();

    ASSERT(pProperties->cbBuffer);

    // If we don't have fixed sized samples we must guess some size

    if (!m_pInput->CurrentMediaType().bFixedSizeSamples) {
        if (pProperties->cbBuffer < 100000) {
            // nothing more than a guess!!
            pProperties->cbBuffer = 100000;
        }
    }

    // Ask the allocator to reserve us some sample memory, NOTE the function
    // can succeed (that is return NOERROR) but still not have allocated the
    // memory that we requested, so we must check we got whatever we wanted

    ALLOCATOR_PROPERTIES Actual;
    hr = pAlloc->SetProperties(pProperties,&Actual);
    if (FAILED(hr)) {
        return hr;
    }

    ASSERT( Actual.cBuffers == 1 );

    if (pProperties->cBuffers > Actual.cBuffers ||
            pProperties->cbBuffer > Actual.cbBuffer) {
                return E_FAIL;
    }
    return NOERROR;

} // DecideBufferSize


//
// GetMediaType
//
// I support one type, namely the type of the input pin
// We must be connected to support the single output type
//
HRESULT CContrast::GetMediaType(int iPosition, CMediaType *pMediaType)
{
    // Is the input pin connected

    if (m_pInput->IsConnected() == FALSE) {
        return E_UNEXPECTED;
    }

    // This should never happen

    if (iPosition < 0) {
        return E_INVALIDARG;
    }

    // Do we have more items to offer

    if (iPosition > 0) {
        return VFW_S_NO_MORE_ITEMS;
    }

    *pMediaType = m_pInput->CurrentMediaType();
    return NOERROR;

} // GetMediaType


//
// get_ContrastLevel
//
// Return the current contrast level
//
STDMETHODIMP CContrast::get_ContrastLevel(signed char *ContrastLevel)
{
    CAutoLock cAutoLock(&m_ContrastLock);
    *ContrastLevel = m_ContrastLevel;
    return NOERROR;

} // get_ContrastLevel


//
// put_ContrastLevel
//
// Sets the contrast level for the filter
//
STDMETHODIMP CContrast::put_ContrastLevel(signed char ContrastLevel, unsigned long ChangeTime)
{
    CAutoLock cAutoLock(&m_ContrastLock);
    m_ContrastLevel = ContrastLevel;
    return NOERROR;

} // put_ContrastLevel


//
// put_DefaultContrastLevel
//
// Sets the default contrast level for the filter
//
STDMETHODIMP CContrast::put_DefaultContrastLevel()
{
    CAutoLock cAutoLock(&m_ContrastLock);
    m_ContrastLevel = m_DefaultContrastLevel;
    return NOERROR;

} // put_DefaultContrastLevel


//
// GetPages
//
// This is the sole member of ISpecifyPropertyPages
// Returns the clsid's of the property pages we support
//
STDMETHODIMP CContrast::GetPages(CAUUID *pPages)
{
    pPages->cElems = 1;
    pPages->pElems = (GUID *) CoTaskMemAlloc(sizeof(GUID));
    if (pPages->pElems == NULL) {
        return E_OUTOFMEMORY;
    }
    *(pPages->pElems) = CLSID_ContrastPropertyPage;
    return NOERROR;

} // GetPages


//
// CanChangeContrastLevel
//
// Check if this is a paletised format
//
BOOL CContrast::CanChangeContrastLevel(const CMediaType *pMediaType) const
{
    if ((IsEqualGUID(*pMediaType->Type(), MEDIATYPE_Video))
         && (IsEqualGUID(*pMediaType->Subtype(), MEDIASUBTYPE_RGB8))) {

        // I think I can process this format (8 bit palettised)
	// So do a quick sanity check on the palette information

	VIDEOINFO *pvi = (VIDEOINFO *) pMediaType->Format();
	return (pvi->bmiHeader.biBitCount == 8);

    } else {
        return FALSE;
    }

} // CanChangeContrastLevel


//
// Transform
//
// Adjust the palette entries of pType to reflect the specified contrast level
//
HRESULT CContrast::Transform(AM_MEDIA_TYPE *pType, const signed char ContrastLevel) const
{
    VIDEOINFO *pvi = (VIDEOINFO *) pType->pbFormat;

    if (ContrastLevel >= 0) {
        int Low	= 0 + m_ContrastLevel;
        int High	= 255 - m_ContrastLevel;
	float Grad	= ((float)(High - Low)) / 255;

        for (UINT i = 0; i < pvi->bmiHeader.biClrUsed; i++) {

            IncreaseContrast(&pvi->bmiColors[i], Low, High, Grad);
        }
    } else {
        float Grad = 255 / (255 + (float) ContrastLevel + (float) ContrastLevel);

        for (UINT i = 0; i < pvi->bmiHeader.biClrUsed; i++) {
            DecreaseContrast(&pvi->bmiColors[i], ContrastLevel, Grad);
        }
    }
    return NOERROR;

} // Transform


//
// IncreaseContrast
//
// Adjust the contrast of this palette element
//
inline
void CContrast::IncreaseContrast(RGBQUAD *pElem, const int Low, const int High, const float Grad) const
{
    IncreaseContrast(&pElem->rgbRed, Low, High, Grad);
    IncreaseContrast(&pElem->rgbGreen, Low, High, Grad);
    IncreaseContrast(&pElem->rgbBlue, Low, High, Grad);

} // IncreaseContrast


//
// IncreaseContrast
//
// Change this byte's contrast
//
inline
void CContrast::IncreaseContrast(BYTE *pByte, const int Low, const int High, const float Grad) const
{
    if (*pByte <= Low) {
        *pByte = 0;
    }
    else if ((Low < *pByte) && (*pByte <  High)) {
	*pByte = (BYTE)( (*pByte - Low) / Grad);
    }
    else {	// pElem->rgbGreen >= High
        *pByte = 255;
    }

} // IncreaseContrast


//
// DecreaseContrast
//
// Adjust the contrast of this palette element
//
inline
void CContrast::DecreaseContrast(RGBQUAD *pElem, const int Level, const float Grad) const
{
    DecreaseContrast(&pElem->rgbRed, Level, Grad);
    DecreaseContrast(&pElem->rgbGreen, Level, Grad);
    DecreaseContrast(&pElem->rgbBlue, Level, Grad);

} // DecreaseContrast


//
// DecreaseContrast
//
// Use different maths to calculate the 'decreasing contrast' line
//
inline
void CContrast::DecreaseContrast(BYTE *pByte, const int Level, const float Grad) const
{
    ASSERT(pByte);
    ASSERT(Grad != 0.0);
    *pByte = (BYTE) ( ((int) (*pByte / Grad)) - Level);

} // DecreaseContrast


//
// DllRegisterServer
//
// Handle registration of this filter
//
STDAPI DllRegisterServer()
{
    return AMovieDllRegisterServer2( TRUE );

} // DllRegisterServer


//
// DllUnregisterServer
//
STDAPI DllUnregisterServer()
{
    return AMovieDllRegisterServer2( FALSE );

} // DllUnregisterServer

