pximage.cpp

linux下的一款播放器

/* ***** BEGIN LICENSE BLOCK *****
 * Source last modified: $Id: pximage.cpp,v 1.1.26.1 2004/07/09 01:54:51 hubbe Exp $
 * 
 * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
 * 
 * The contents of this file, and the files included with this file,
 * are subject to the current version of the RealNetworks Public
 * Source License (the "RPSL") available at
 * http://www.helixcommunity.org/content/rpsl unless you have licensed
 * the file under the current version of the RealNetworks Community
 * Source License (the "RCSL") available at
 * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
 * will apply. You may also obtain the license terms directly from
 * RealNetworks.  You may not use this file except in compliance with
 * the RPSL or, if you have a valid RCSL with RealNetworks applicable
 * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
 * the rights, obligations and limitations governing use of the
 * contents of the file.
 * 
 * Alternatively, the contents of this file may be used under the
 * terms of the GNU General Public License Version 2 or later (the
 * "GPL") in which case the provisions of the GPL are applicable
 * instead of those above. If you wish to allow use of your version of
 * this file only under the terms of the GPL, and not to allow others
 * to use your version of this file under the terms of either the RPSL
 * or RCSL, indicate your decision by deleting the provisions above
 * and replace them with the notice and other provisions required by
 * the GPL. If you do not delete the provisions above, a recipient may
 * use your version of this file under the terms of any one of the
 * RPSL, the RCSL or the GPL.
 * 
 * This file is part of the Helix DNA Technology. RealNetworks is the
 * developer of the Original Code and owns the copyrights in the
 * portions it created.
 * 
 * This file, and the files included with this file, is distributed
 * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
 * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
 * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
 * ENJOYMENT OR NON-INFRINGEMENT.
 * 
 * Technology Compatibility Kit Test Suite(s) Location:
 *    http://www.helixcommunity.org/content/tck
 * 
 * Contributor(s):
 * 
 * ***** END LICENSE BLOCK ***** */

// include
#include "hxtypes.h"
#include "hxwintyp.h"
#include "hxresult.h"
#include "hxcom.h"
#include "ihxpckts.h"
#include "hxvsurf.h"

// hxcont
#include "hxbuffer.h"

// hxmisc
#include "unkimp.h"
#include "baseobj.h"

// pxcomlib
#include "pxcolor.h"
#include "pxrect.h"
#include "pxeffect.h"
#include "pximage.h"

// hxdebug
#include "hxheap.h"
#ifdef _DEBUG
#undef HX_THIS_FILE		
static char HX_THIS_FILE[] = __FILE__;
#endif

PXImage::PXImage()
{
    ResetMembers();
    m_lRefCount   = 0;
    m_pImageStore = NULL;
}

PXImage::~PXImage()
{
    Destroy();
}

HX_RESULT PXImage::CreateObject(PXImage** ppImg)
{
    HX_RESULT retVal = HXR_FAIL;

    if (ppImg)
    {
        PXImage* pImg = new PXImage();
        if (pImg)
        {
            *ppImg = pImg;
            retVal = HXR_OK;
        }
    }

    return retVal;
}

HX_RESULT PXImage::CreateInstance(PXImage** ppImg)
{
    HX_RESULT retVal = HXR_FAIL;

    if (ppImg)
    {
        PXImage* pImg = new PXImage();
        if (pImg)
        {
            // AddRef the object
            pImg->AddRef();
            // Assign the out parameter
            *ppImg = pImg;
            retVal = HXR_OK;
        }
    }

    return retVal;
}

STDMETHODIMP PXImage::QueryInterface(REFIID riid, void** ppvObj)
{
    HX_RESULT retVal = HXR_OK;

    if (IsEqualIID(riid, IID_IUnknown))
    {
        AddRef();
        *ppvObj = (IUnknown *) this;
    }
    else
    {
        *ppvObj = NULL;
        retVal  = HXR_NOINTERFACE;
    }

    return retVal;
}

STDMETHODIMP_(UINT32) PXImage::AddRef()
{
    return InterlockedIncrement(&m_lRefCount);
}

STDMETHODIMP_(UINT32) PXImage::Release()
{
    
    if (InterlockedDecrement(&m_lRefCount) > 0)
        return m_lRefCount;

    delete this;

    return 0;
}

HX_RESULT PXImage::Create(INT32 lW, INT32 lH, UINT32 ulBpp, UINT32 ulFormat,
                          BOOL bRowsInverted, BOOL bAlloc)
{
    // Check for invalid input size
    if (lW <= 0          ||
        lW >  kMaxWidth  ||
        lH <= 0          ||
        lH >  kMaxHeight)
    {
        HX_ASSERT(FALSE);
        return HXR_FAIL;
    }

    // Check to see if we're asked to NOT alloc, but
    // don't have any image store
    if (!bAlloc && !m_pImageStore)
    {
        HX_ASSERT(FALSE);
        return HXR_FAIL;
    }

    // Filter out unsupported formats
    switch (ulBpp)
    {
        case 32:
            if (ulFormat != HX_RGB)
            {
                HX_ASSERT(FALSE);
                return HXR_FAIL;
            }
            break;
        default:
            HX_ASSERT(FALSE);
            return HXR_FAIL;
    }

    // Reset members (except image store)
    ResetMembers();

    // Assign member variables
    m_cBitmapInfo.biWidth       = lW;
    m_cBitmapInfo.biHeight      = lH;
    m_cBitmapInfo.biBitCount    = (UINT16) ulBpp;
    m_cBitmapInfo.biCompression = ulFormat;
    m_cSubImageRect.left        = 0;
    m_cSubImageRect.top         = 0;
    m_cSubImageRect.right       = lW;
    m_cSubImageRect.bottom      = lH;
    m_lSubImageWidth            = lW;
    m_lSubImageHeight           = lH;
    m_bRowsInverted             = bRowsInverted;
    m_ulBytesPerPixel           = (ulBpp + 7) >> 3;
    m_lRowBytes                 = lW * m_ulBytesPerPixel;
    m_lRowStride                = (m_lRowBytes + 3) & ~3;

    // Determine the number of bytes we need
    UINT32 ulNumBytes = m_lRowStride * m_cBitmapInfo.biHeight;

    // Check to see if we need to alloc memory. We will allocate
    // if the bAlloc parameter tells us to OR if bAlloc is FALSE
    // AND we have don't already have enough to satisfy the request.
    if (bAlloc || (!bAlloc && m_pImageStore->GetSize() < ulNumBytes))
    {
        // Now create the storage object
        HX_RELEASE(m_pImageStore);
        m_pImageStore = (IHXBuffer *) new CHXBuffer();
        if (!m_pImageStore)
        {
            ResetMembers();
            return HXR_OUTOFMEMORY;
        }
        m_pImageStore->AddRef();

        // Set its size
        HX_RESULT retVal = m_pImageStore->SetSize(ulNumBytes);
        if (retVal != HXR_OK)
        {
            HX_RELEASE(m_pImageStore);
            ResetMembers();
            return retVal;
        }
    }

    // Set the image buffer to beginning of storage
    if (m_bRowsInverted)
    {
        m_pImageBuffer = m_pImageStore->GetBuffer() + (m_cBitmapInfo.biHeight - 1) * m_lRowStride;
        m_lRowJump     = - m_lRowStride;
    }
    else
    {
        m_pImageBuffer = m_pImageStore->GetBuffer();
        m_lRowJump     = m_lRowStride;
    }

    // Set the initialization flag
    m_bInitialized = TRUE;

    return HXR_OK;
}

HX_RESULT PXImage::CreateFromBuffer(INT32 lW, INT32 lH, UINT32 ulBpp, UINT32 ulFormat,
                                    BOOL bRowsInverted, IHXBuffer* pBuffer)
{
    HX_RESULT retVal = HXR_OK;

    if (lW > 0 && lW <= kMaxWidth && lH > 0 && lH <= kMaxHeight &&
        ulBpp == 32 && ulFormat == HX_RGB && pBuffer)
    {
        // Reset members (except image store)
        ResetMembers();

        // Assign member variables
        m_cBitmapInfo.biWidth       = lW;
        m_cBitmapInfo.biHeight      = lH;
        m_cBitmapInfo.biBitCount    = (UINT16) ulBpp;
        m_cBitmapInfo.biCompression = ulFormat;
        m_cSubImageRect.left        = 0;
        m_cSubImageRect.top         = 0;
        m_cSubImageRect.right       = lW;
        m_cSubImageRect.bottom      = lH;
        m_lSubImageWidth            = lW;
        m_lSubImageHeight           = lH;
        m_bRowsInverted             = bRowsInverted;
        m_ulBytesPerPixel           = (ulBpp + 7) >> 3;
        m_lRowBytes                 = lW * m_ulBytesPerPixel;
        m_lRowStride                = (m_lRowBytes + 3) & ~3;

        // Determine the number of bytes we need
        UINT32 ulNumBytes = m_lRowStride * m_cBitmapInfo.biHeight;

        //  Make sure the provided buffer is big enough
        if (pBuffer->GetSize() >= ulNumBytes)
        {
            // Save the passed in buffer
            HX_RELEASE(m_pImageStore);
            m_pImageStore = pBuffer;
            m_pImageStore->AddRef();

            // Set the image buffer to beginning of storage
            if (m_bRowsInverted)
            {
                m_pImageBuffer = m_pImageStore->GetBuffer() + (m_cBitmapInfo.biHeight - 1) * m_lRowStride;
                m_lRowJump     = - m_lRowStride;
            }
            else
            {
                m_pImageBuffer = m_pImageStore->GetBuffer();
                m_lRowJump     = m_lRowStride;
            }

            // Set the initialization flag
            m_bInitialized = TRUE;
        }
        else
        {
            retVal = HXR_INVALID_PARAMETER;
        }
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    return retVal;
}

HX_RESULT PXImage::CreateSubImage(PXImage* pImg, INT32 lX, INT32 lY, INT32 lW, INT32 lH,
                                  BOOL bCopy, BOOL bAlloc)
{
    // Check for input error
    if (!pImg || lX < 0 || lY < 0 || lW < 0 || lH < 0)
    {
        HX_ASSERT(FALSE);
        return HXR_FAIL;
    }

    // Adjust for default input
    if (lW == 0)
    {
        lW = pImg->GetWidth();
    }
    if (lH == 0)
    {
        lH = pImg->GetHeight();
    }

    // Check for input error
    if (lX + lW >  pImg->GetWidth())
    {
        lW = pImg->GetWidth() - lX;
    }
    if (lY + lH >  pImg->GetHeight())
    {
        lH = pImg->GetHeight() - lY;
    }

    // Check to see if we're asked NOT to copy but to alloc
    if (!bCopy && bAlloc)
    {
        HX_ASSERT(FALSE);
        return HXR_FAIL;
    }

    // Reset everything (except image store)
    ResetMembers();

    // Are we copying or not?
    if (bCopy)
    {
        // Set member variables
        m_cBitmapInfo.biWidth       = lW;
        m_cBitmapInfo.biHeight      = lH;
        m_cBitmapInfo.biBitCount    = pImg->m_cBitmapInfo.biBitCount;
        m_cBitmapInfo.biCompression = pImg->m_cBitmapInfo.biCompression;
        m_cSubImageRect.left        = 0;
        m_cSubImageRect.top         = 0;
        m_cSubImageRect.right       = lW;
        m_cSubImageRect.bottom      = lH;
        m_lSubImageWidth            = lW;
        m_lSubImageHeight           = lH;
        m_bRowsInverted             = pImg->m_bRowsInverted;
        m_ulBytesPerPixel           = pImg->m_ulBytesPerPixel;
        m_lRowBytes                 = lW * m_ulBytesPerPixel;
        m_lRowStride                = (m_lRowBytes + 3) & ~3;
        m_bHasAlpha                 = pImg->m_bHasAlpha;

        // Determine the number of bytes we need
        UINT32 ulNumBytes = m_lRowStride * m_cBitmapInfo.biHeight;

        // Check to see if we need to alloc memory. We will allocate
        // if the bAlloc parameter tells us to OR if bAlloc is FALSE
        // AND we have don't already have enough to satisfy the request.
        if (bAlloc || (!bAlloc && m_pImageStore->GetSize() < ulNumBytes))
        {
            // Create a new image store
            HX_RELEASE(m_pImageStore);
            m_pImageStore = (IHXBuffer *) new CHXBuffer();
            if (!m_pImageStore)
            {