avi_PushSourceBitmapSet.cpp

Go to the documentation of this file.

//------------------------------------------------------------------------------
// File: PushSourceBitmapSet.cpp
//------------------------------------------------------------------------------
#pragma warning( disable : 4311 4312 4133)

#include <streams.h>
#include <stdio.h>

#include "avi_PushSource.h"
#include "avi_PushGuids.h"


extern "C" BYTE *GetNextBitmapFromTemporaryFile(long frame);

extern int gFirstF;
extern int gLastF;  
extern int gCurrentF;  

extern void Msg(TCHAR *szFormat, ...);

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

CPushPinBitmapSet::CPushPinBitmapSet(int nFrames, HRESULT *phr, CSource *pFilter)
      : CSourceStream(NAME("Push Source BitmapSet"), phr, pFilter, L"Out"),
        m_bZeroMemory(0),
        m_iFrameNumber(0),
        m_rtFrameLength(FPS_25), 
        m_bFilesLoaded(FALSE)
{
   // Load the first bitmap this will be used to set the parameters
   m_FirstF=gFirstF;
   m_LastF=gLastF;  
   //char ttt[256]; sprintf(ttt,"First frame %ld Last Frame %ld",m_FirstF,m_LastF);
   //MessageBox(NULL,ttt,"New reading Object",MB_OK);
   ZeroMemory(&m_cbBitmapInfo, sizeof(DWORD));
   ZeroMemory(&m_pBmi,    sizeof(BITMAPINFO *));
   ZeroMemory(&m_pFile,   sizeof(BYTE *));
   ZeroMemory(&m_pImage,  sizeof(BYTE *));

   m_pFile=GetNextBitmapFromTemporaryFile(m_FirstF+m_iFrameNumber);  // should return BITMAP
   m_cbBitmapInfo = (long)sizeof(BITMAPINFOHEADER);
   m_pBmi = (BITMAPINFO*)(m_pFile);
   m_pImage = m_pFile + m_cbBitmapInfo;
   m_bFilesLoaded=TRUE;
}

CPushPinBitmapSet::~CPushPinBitmapSet(){   
//MessageBox(NULL,"Push source PIN deleted",NULL,MB_OK);
}

void CPushPinBitmapSet::LoadNextBitmap(void){
   m_bFilesLoaded=FALSE;
   m_pFile=GetNextBitmapFromTemporaryFile(m_FirstF+m_iFrameNumber); 
   m_cbBitmapInfo = (long)sizeof(BITMAPINFOHEADER);
   m_pBmi = (BITMAPINFO*)(m_pFile);
   m_pImage = m_pFile + m_cbBitmapInfo;
   m_bFilesLoaded=TRUE;
   //Msg("Loaded %s",FileList[m_iFrameNumber]);
}


HRESULT CPushPinBitmapSet::GetMediaType(CMediaType *pMediaType){
    //MessageBox(NULL,"GetMediaType1",NULL,MB_OK);
    CAutoLock cAutoLock(m_pFilter->pStateLock());
    CheckPointer(pMediaType, E_POINTER);
    // If the bitmap files were not loaded, just fail here.
    if (!m_bFilesLoaded)return E_FAIL;
    // Allocate enough room for the VIDEOINFOHEADER and the color tables
    VIDEOINFOHEADER *pvi = 
        (VIDEOINFOHEADER*)pMediaType->AllocFormatBuffer(SIZE_PREHEADER + 
                                                        m_cbBitmapInfo);
    if (pvi == 0) 
        return(E_OUTOFMEMORY);
    // Initialize the video info header
    ZeroMemory(pvi, pMediaType->cbFormat);   
    pvi->AvgTimePerFrame = m_rtFrameLength;
    // Copy the header info from the current bitmap
    memcpy(&(pvi->bmiHeader), m_pBmi, m_cbBitmapInfo);
    // Set image size for use in FillBuffer
    pvi->bmiHeader.biSizeImage  = GetBitmapSize(&pvi->bmiHeader);
    // Clear source and target rectangles
    SetRectEmpty(&(pvi->rcSource)); // we want the whole image area rendered
    SetRectEmpty(&(pvi->rcTarget)); // no particular destination rectangle
    pMediaType->SetType(&MEDIATYPE_Video);
    pMediaType->SetFormatType(&FORMAT_VideoInfo);
    pMediaType->SetTemporalCompression(FALSE);
    // Work out the GUID for the subtype from the header info.
    const GUID SubTypeGUID = GetBitmapSubtype(&pvi->bmiHeader);
    pMediaType->SetSubtype(&SubTypeGUID);
    pMediaType->SetSampleSize(pvi->bmiHeader.biSizeImage);
    return S_OK;
}


HRESULT CPushPinBitmapSet::DecideBufferSize(IMemAllocator *pAlloc, ALLOCATOR_PROPERTIES *pRequest){
    HRESULT hr;
    CAutoLock cAutoLock(m_pFilter->pStateLock());
    // If the bitmap files were not loaded, just fail here.
    if (!m_bFilesLoaded) return E_FAIL;
    CheckPointer(pAlloc, E_POINTER);
    CheckPointer(pRequest, E_POINTER);
    VIDEOINFOHEADER *pvi = (VIDEOINFOHEADER*) m_mt.Format();
    // Ensure a minimum number of buffers
    if (pRequest->cBuffers == 0)    {
        pRequest->cBuffers = 2;
    }
    pRequest->cbBuffer = pvi->bmiHeader.biSizeImage;
    ALLOCATOR_PROPERTIES Actual;
    hr = pAlloc->SetProperties(pRequest, &Actual);
    if (FAILED(hr)) { return hr;   }
    // Is this allocator unsuitable?
    if (Actual.cbBuffer < pRequest->cbBuffer) { return E_FAIL;    }
    return S_OK;
}

// This is where we insert the DIB bits into the video stream.
// FillBuffer is called once for every sample in the stream.
HRESULT CPushPinBitmapSet::FillBuffer(IMediaSample *pSample){
    BYTE *pData;
    long cbData;
    if(m_iFrameNumber + m_FirstF >= m_LastF)return E_FAIL;  // this terminates the writing
    if(m_iFrameNumber > 0){ // Now we need to load the bitmap
      LoadNextBitmap();
      gCurrentF=m_iFrameNumber+m_FirstF;
    }
    if(!m_bFilesLoaded)return E_FAIL;
    CheckPointer(pSample, E_POINTER);
    CAutoLock cAutoLockShared(&m_cSharedState);
    // Access the sample's data buffer
    pSample->GetPointer(&pData);
    cbData = pSample->GetSize();
    // Check that we're still using video
    ASSERT(m_mt.formattype == FORMAT_VideoInfo);
    VIDEOINFOHEADER *pVih = (VIDEOINFOHEADER*)m_mt.pbFormat;
    // Copy the DIB bits over into our filter's output buffer.
    // Since sample size may be larger than the image size, bound the copy size.
    // Remember that the new data has the same format that we specified in GetMediaType.
    memcpy(pData, m_pImage, min(pVih->bmiHeader.biSizeImage, (DWORD) cbData));
    // Set the timestamps that will govern playback frame rate.
    // If this file is getting written out as an AVI,
    // then you'll also need to configure the AVI Mux filter to 
    // set the Average Time Per Frame for the AVI Header.
    // The current time is the sample's start
    REFERENCE_TIME rtStart = m_iFrameNumber * m_rtFrameLength;
    REFERENCE_TIME rtStop  = rtStart + m_rtFrameLength;
    pSample->SetTime(&rtStart, &rtStop);
    m_iFrameNumber++;
    // Set TRUE on every sample for uncompressed frames
    pSample->SetSyncPoint(TRUE);
    // Increment the current buffer so that the next FillBuffer() call 
    // will use the bits from the next bitmap in the set.
    return S_OK;
}

// Filter's class
CPushSourceBitmapSet::CPushSourceBitmapSet(int Nframes, IUnknown *pUnk, HRESULT *phr)
           : CSource(NAME("PushSourceBitmapSet"), pUnk, 
           __uuidof(CLSID_PushSourceBitmapSet)){
    m_pPin = new CPushPinBitmapSet(Nframes, phr, this);
    if (phr)    {
        if (m_pPin == NULL)
            *phr = E_OUTOFMEMORY;
        else
            *phr = S_OK;
    }  
}

CPushSourceBitmapSet::~CPushSourceBitmapSet(){
//MessageBox(NULL,"Push source to be deleted",NULL,MB_OK);
    delete m_pPin;
//MessageBox(NULL,"Push source deleted",NULL,MB_OK);
}