doubango-android/plugins/pluginDirectShow/internals/wince/DSSampleGrabber.cxx

#if defined(_WIN32_WCE)

#include <ddraw.h>
#include <internals/wince/DSSampleGrabber.h>
#include <initguid.h>


// {38589364-71FD-4641-B426-E443DB023568}
TDSHOW_DEFINE_GUID(CLSID_SampleGrabber,
                   0x38589364, 0x71fd, 0x4641, 0xb4, 0x26, 0xe4, 0x43, 0xdb, 0x2, 0x35, 0x68);

#define RGB565_MASK_RED				0xF800
#define RGB565_MASK_GREEN           0x07E0
#define RGB565_MASK_BLUE            0x001F

DSSampleGrabber::DSSampleGrabber(TCHAR *tszName, LPUNKNOWN punk, HRESULT *phr)
    :CTransInPlaceFilter (tszName, punk, CLSID_SampleGrabber, phr)
{
#define FPS_INPUT  30
#define FPS_OUTPUT 5

    this->m_rtFrameLength = (10000000)/FPS_OUTPUT;

    this->m_inputFps = FPS_INPUT;
    this->m_outputFps = FPS_OUTPUT;

    this->m_iFrameNumber = 0;
    this->m_progress = 0;
    this->m_bProcessFrame = true;

    this->callback = NULL;
    this->m_rgb24 = NULL;

    m_cRef = 0;
}

DSSampleGrabber::~DSSampleGrabber()
{
    this->callback = NULL;
    if(this->m_rgb24) {
        delete[]this->m_rgb24;
        this->m_rgb24 = NULL;
    }
}

HRESULT DSSampleGrabber::SetFps(int inputFps, int outputFps)
{
    if (inputFps <= 0 || outputFps <= 0) {
        return E_FAIL;
    }

    // Stop prcessing
    this->m_bProcessFrame = false;

    if (inputFps < outputFps) {
        this->m_inputFps = this->m_outputFps = inputFps;
    }
    else {
        this->m_outputFps = outputFps;
        this->m_inputFps = inputFps;
    }

    // Restart processing
    this->m_iFrameNumber = 0;
    this->m_progress = 0;
    this->m_bProcessFrame = true;

    return S_OK;
}

HRESULT DSSampleGrabber::Transform(IMediaSample *pSample)
{
    BYTE *pData = NULL;
    HRESULT hr = S_OK;
    HRESULT ret = S_FALSE;

    if (!this->m_bProcessFrame) {
        return S_FALSE;
    }

    // Get pointer to the video buffer data
    if ( FAILED(pSample->GetPointer(&pData)) ) {
        ret = E_FAIL;
        goto bail;
    }

    pSample->SetTime(NULL, NULL);

    // Drop frame?
    if (this->m_iFrameNumber == 0) {
        ret = S_OK;
    }
    else if (this->m_progress >= this->m_inputFps) {
        this->m_progress -= this->m_inputFps;
        ret = S_OK;
    }

    // Mark frame as accepted
    if (ret == S_OK) {
        // Set TRUE on every sample for uncompressed frames
        pSample->SetSyncPoint(TRUE);

        long Size = pSample->GetSize();
        if ( this->callback ) {
            LONGLONG start, end;
            WORD *rgb565 = (WORD*)pData;

            for(int i = 0, i24 = 0, i565 = 0; i< (Size/2); i++, i24+=3, i565+=1) {
                BYTE *p24 = (this->m_rgb24+i24);
                WORD val565 = *(rgb565 + i565);

                // extract RGB
                p24[2] = (val565 & RGB565_MASK_RED) >> 11;
                p24[1] = (val565 & RGB565_MASK_GREEN) >> 5;
                p24[0] = (val565 & RGB565_MASK_BLUE);

                // amplify the image
                p24[2] <<= 3;
                p24[1] <<= 2;
                p24[0] <<= 3;
            }

            pSample->GetMediaTime(&start, &end);
            this->callback->BufferCB( (double)start, this->m_rgb24, ((Size >> 1) * 3));
        }
    }

    this->m_progress += this->m_outputFps;
    this->m_iFrameNumber++;

bail:
    SAFE_DELETE_ARRAY( pData );
    SAFE_RELEASE(pSample);

    return ret;
}

HRESULT DSSampleGrabber::CheckInputType(const CMediaType* mtIn)
{
    VIDEOINFO *video;
    if ( !IsEqualGUID( *mtIn->Subtype(), MEDIASUBTYPE_RGB565 ) || !(video=(VIDEOINFO *)mtIn->Format()) ) {
        return E_FAIL;
    }

    return S_OK;
}

STDMETHODIMP DSSampleGrabber::SetCallback( DSISampleGrabberCB* callback_ )
{
    if (!callback_) {
        return E_FAIL;
    }

    this->callback = callback_;
    return S_OK;
}

HRESULT DSSampleGrabber::SetSize(int width, int height)
{
    ZeroMemory(&this->mt, sizeof(CMediaType));

    VIDEOINFO *pvi = (VIDEOINFO *)this->mt.AllocFormatBuffer(sizeof(VIDEOINFO));
    if (NULL == pvi) {
        return E_OUTOFMEMORY;
    }

    ZeroMemory(pvi, sizeof(VIDEOINFO));

    pvi->bmiHeader.biCompression	= BI_RGB;
    pvi->bmiHeader.biBitCount		= 24;
    pvi->bmiHeader.biSize			= sizeof(BITMAPINFOHEADER);
    pvi->bmiHeader.biWidth			= width;
    pvi->bmiHeader.biHeight			= height;
    pvi->bmiHeader.biPlanes			= 1;
    pvi->bmiHeader.biSizeImage		= GetBitmapSize(&pvi->bmiHeader);
    pvi->bmiHeader.biClrImportant	= 0;

    // Frame rate
    pvi->AvgTimePerFrame			= 10000000/this->m_outputFps;

    SetRectEmpty(&(pvi->rcSource));	// we want the whole image area rendered.
    SetRectEmpty(&(pvi->rcTarget));	// no particular destination rectangle

    this->mt.SetType(&MEDIATYPE_Video);
    this->mt.SetFormatType(&FORMAT_VideoInfo);
    this->mt.SetTemporalCompression(FALSE);

    this->mt.SetSubtype(&MEDIASUBTYPE_RGB24);
    this->mt.SetSampleSize(pvi->bmiHeader.biSizeImage);

    this->m_rgb24 = new BYTE[pvi->bmiHeader.biSizeImage];

    return S_OK;
}

#endif /* _WIN32_WCE */