VideoFrameLoader.cpp

Go to the documentation of this file.

#include "VideoFrameLoader.h"

#include <Shlwapi.h>
#include <strsafe.h>
#include <Propvarutil.h>
#include <QDebug>


CVideoFrameLoader::CVideoFrameLoader(void)
{
    initializeFrameLoader();
}

CVideoFrameLoader::CVideoFrameLoader(PWSTR filePath)
{
    initializeFrameLoader();
    setVideoPath(filePath, false);
}

void CVideoFrameLoader::initializeFrameLoader()
{
    p_videoURL = NULL;
    p_videoArray = NULL;
    p_videoList = NULL;

    p_videoReader = NULL;

    m_frameCount = 0;
    m_totalFrameCount = 0;
    m_videoWidth = 0;
    m_videoHeight = 0;
    m_videoBufferTransfered = false;

    // Initialize the COM runtime.
    if (SUCCEEDED(CoInitializeEx(0, COINIT_MULTITHREADED)))
        m_comInitialisationSuccessful = true;

    // Initialize the Media Foundation platform.
    if (SUCCEEDED(MFStartup(MF_VERSION)))
        m_mediaFoundationInitalisationSuccessful = true;
}


CVideoFrameLoader::~CVideoFrameLoader(void)
{
    if (p_videoURL)
        delete p_videoURL;

    if (p_videoArray && !m_videoBufferTransfered)
        delete p_videoArray;

    if (p_videoList)
    {
        while (!p_videoList->empty())
        {
            PBYTE frame = p_videoList->front();
            p_videoList->pop_front();
            delete frame;
        }

        delete p_videoList;
        p_videoList = NULL;
    }

    SafeRelease((IUnknown**) &p_videoReader);

    if (m_mediaFoundationInitalisationSuccessful)
        MFShutdown();

    if (m_comInitialisationSuccessful)
        CoUninitialize();
}

VFLResult CVideoFrameLoader::resetProperties()
{
    reset();

    if (p_videoURL)
        delete p_videoURL;

    SafeRelease((IUnknown**) &p_videoReader);

    p_videoURL = NULL;
    m_videoWidth = 0;
    m_videoHeight = 0;

    return VFL_OK;
}

VFLResult CVideoFrameLoader::setVideoPath(PWSTR filePath)
{
    return setVideoPath(filePath, true);
}

VFLResult CVideoFrameLoader::setVideoPath(PWSTR filePath, bool reset)
{
    if (reset)
        resetProperties();

    p_videoURL = new WCHAR[MAXVideoURLLenght];

    DWORD videoURLLength = MAXVideoURLLenght;

    if(FAILED(UrlCreateFromPath(filePath, p_videoURL, &videoURLLength, NULL)))
        return VFL_COULD_NOT_CONVERT_PATH_TO_URL;

    return openFileInSourceReader();
}

VFLResult CVideoFrameLoader::setVideoURL(PWSTR fileURL)
{
    return setVideoURL(fileURL, true);
}

VFLResult CVideoFrameLoader::setVideoURL(PWSTR fileURL, bool reset)
{
    if (reset)
        resetProperties();

    p_videoURL = new WCHAR[MAXVideoURLLenght];

    if (StringCbCopy(p_videoURL, MAXVideoURLLenght, fileURL) == STRSAFE_E_INSUFFICIENT_BUFFER)
        return VFL_URL_TO_LONG;

    return openFileInSourceReader();
}

VFLResult CVideoFrameLoader::openFileInSourceReader()
{
    IMFAttributes *pSourceReaderAttributes = NULL;

    MFCreateAttributes(&pSourceReaderAttributes, 1);

    pSourceReaderAttributes->SetUINT32(MF_SOURCE_READER_ENABLE_VIDEO_PROCESSING, TRUE);

    //Create the source reader.
    if(FAILED(MFCreateSourceReaderFromURL(p_videoURL, pSourceReaderAttributes, &p_videoReader)))
    {
        SafeRelease((IUnknown **) &pSourceReaderAttributes);
        return VFL_COULD_NOT_READ_SOURCE_FILE;
    }

    SafeRelease((IUnknown **) &pSourceReaderAttributes);

    if(FAILED(configureDecoder(p_videoReader)))
        return VFL_COULD_NOT_DECODE_FILE;

    IMFMediaType *pType;

    if (FAILED(p_videoReader->GetCurrentMediaType(MF_SOURCE_READER_FIRST_VIDEO_STREAM, &pType)))
        return VFL_COULD_NOT_GET_MEDIA_TYPE;

    if (FAILED(MFGetAttributeSize(pType, MF_MT_FRAME_SIZE, &m_videoWidth, &m_videoHeight)))
    {
        pType->Release();
        return VFL_COULD_NOT_GET_MEDIA_ATTRIBUTES;
    }

    pType->Release();

    return VFL_OK;
}

VFLResult CVideoFrameLoader::loadAllFramesIntoBuffer()
{
    return loadAllFramesIntoBuffer(0, 0);
}

VFLResult CVideoFrameLoader::loadAllFramesIntoBuffer(int offset, int distanceBetween)
{
    return loadAllFramesIntoBuffer(offset, distanceBetween, 0);
}

VFLResult CVideoFrameLoader::loadAllFramesIntoBuffer(int offset, int distanceBetween, int lastFrame)
{
    if (!p_videoReader)
        return VFL_NO_VIDEO_SOURCE;

    reset();

    VFLResult vr = addNextFrameToBuffer(offset);

    if (vr != VFL_OK)
        return vr;

    if (lastFrame != 0)
        while (vr == VFL_OK && m_totalFrameCount + distanceBetween < lastFrame)
            vr = addNextFrameToBuffer(distanceBetween);
    else
        while (vr == VFL_OK)
            vr = addNextFrameToBuffer(distanceBetween);

    return vr;
}

VFLResult CVideoFrameLoader::addNextFrameToBuffer()
{
    return addNextFrameToBuffer(0);
}

VFLResult CVideoFrameLoader::addNextFrameToBuffer(int distanceFromLast)
{
    if (!p_videoReader)
        return VFL_NO_VIDEO_SOURCE;

    if (p_videoList == NULL)
        p_videoList = new list<PBYTE>;

    IMFSample *pSample = NULL;
    DWORD streamIndex,flags;
    LONGLONG llTimeStamp;

    for (int frameCount = 0; frameCount < distanceFromLast + 1; frameCount++)
    {
        SafeRelease((IUnknown**) &pSample);

        p_videoReader->ReadSample(
            MF_SOURCE_READER_FIRST_VIDEO_STREAM,    // Stream index.
            0,                                      // Flags.
            &streamIndex,                           // Receives the actual stream index.
            &flags,                                 // Receives status flags.
            &llTimeStamp,                           // Receives the time stamp.
            &pSample                                // Receives the sample or NULL.
            );

        if (!pSample)
        {
            //SafeRelease((IUnknown**) &p_videoReader);
            return VFL_NO_MORE_FRAMES;
        }
        m_totalFrameCount++;
    }

    copyFrameToBuffer(pSample);
    SafeRelease((IUnknown**) &pSample);
    m_frameCount++;

    return VFL_OK;
}

VFLResult CVideoFrameLoader::getVideoResolution(int *width, int *height)
{
    if (m_videoWidth == 0 || m_videoHeight == 0)
        return VFL_VIDEO_ATTRIBUTES_NOT_SET;

    *width = m_videoWidth;
    *height = m_videoHeight;

    return VFL_OK;
}

VFLResult CVideoFrameLoader::getVideoBuffer(PBYTE *videoArray)
{
    if (!p_videoArray)
        return VFL_VIDEO_BUFFER_IS_NULL;

    if (p_videoArray == NULL)
        copyVideoListToVideoArray();

    *videoArray = p_videoArray;
    m_videoBufferTransfered = true;

    return VFL_OK;
}

VFLResult CVideoFrameLoader::getBufferFrameCount(int *frameCount)
{
    if (m_frameCount == 0)
        return VFL_VIDEO_ATTRIBUTES_NOT_SET;

    *frameCount = m_frameCount;

    return VFL_OK;
}

void CVideoFrameLoader::reset()
{
    if (p_videoReader != NULL)
        setPosition(0);

    if (p_videoList)
    {
        while (!p_videoList->empty())
        {
            PBYTE frame = p_videoList->front();
            p_videoList->pop_front();
            delete frame;
        }

        delete p_videoList;
        p_videoList = NULL;
    }

    if (p_videoArray && !m_videoBufferTransfered)
        delete p_videoArray;

    p_videoArray = NULL;
    m_frameCount = 0;
    m_totalFrameCount = 0;
    m_videoBufferTransfered = false;
}

HRESULT CVideoFrameLoader::configureDecoder(IMFSourceReader *pReader)
{
    IMFMediaType *pType = NULL;

    // Define the output type.
    HRESULT hr = MFCreateMediaType(&pType);
    if (FAILED(hr))
    {
        SafeRelease((IUnknown**) &pType);
        return hr;
    }

    hr = pType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video);
    if (FAILED(hr))
    {
        SafeRelease((IUnknown**) &pType);
        return hr;
    }

    hr = pType->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_RGB32);
    if (FAILED(hr))
    {
        SafeRelease((IUnknown**) &pType);
        return hr;
    }

    // Set the uncompressed format.
    hr = pReader->SetCurrentMediaType(MF_SOURCE_READER_FIRST_VIDEO_STREAM, NULL, pType);
    if (FAILED(hr))
    {
        SafeRelease((IUnknown**) &pType);
        return hr;
    }

    return hr;
}

HRESULT CVideoFrameLoader::setPosition(const LONGLONG& hnsPosition)
{
    PROPVARIANT var;
    HRESULT hr = InitPropVariantFromInt64(hnsPosition, &var);
    if (SUCCEEDED(hr))
    {
        hr = p_videoReader->SetCurrentPosition(GUID_NULL, var);
        PropVariantClear(&var);
    }
    return hr;
}


void CVideoFrameLoader::copyVideoListToVideoArray()
{
    int byteCount = m_videoWidth * m_videoHeight * 4;

    p_videoArray = new BYTE[(long) byteCount * (long) m_frameCount];

    for (int frameCounter = 0; frameCounter < m_frameCount; frameCounter++)
    {
        PBYTE frame = p_videoList->front();
        p_videoList->pop_front();

        for (int byteCounter = 0; byteCounter < byteCount; byteCounter++)
        {
            p_videoArray[(long) frameCounter * (long) byteCount + byteCounter] = frame[byteCounter];
        }

        delete frame;
    }

    //delete p_videoList;
    //p_videoList = NULL;
}

VFLResult CVideoFrameLoader::copyFrameToBuffer(IMFSample *pSample)
{
    IMFMediaBuffer * pSampleBuffer = NULL;

    pSample->ConvertToContiguousBuffer(&pSampleBuffer);

    PBYTE  singleFrameByteBuffer;

    int byteCount = m_videoWidth * m_videoHeight * 4;
    PBYTE singleFrameByteBufferCopy = new BYTE[byteCount];

    pSampleBuffer->Lock(&singleFrameByteBuffer, NULL, NULL);


    for (int byteCounter = 0; byteCounter < byteCount; byteCounter++)
        singleFrameByteBufferCopy[byteCounter] = singleFrameByteBuffer[byteCounter];

    //p_videoArray->append((char *)singleFrameByteBuffer, m_videoWidth * m_videoHeight * 4);

    pSampleBuffer->Unlock();
    pSampleBuffer->Release();

    p_videoList->push_back(singleFrameByteBufferCopy);

    return VFL_OK;
}

void CVideoFrameLoader::SafeRelease(IUnknown **ppT)
{
    if (*ppT)
    {
        (*ppT)->Release();
        *ppT = NULL;
    }
}