/* Copyright (c) 2009 The Khronos Group Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and/or associated documentation files (the
 * "Materials"), to deal in the Materials without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Materials, and to
 * permit persons to whom the Materials are furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Materials.
 *
 * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
 */
/*! \ingroup wfc
 *  \file wfcimageprovider.c
 *
 *  \brief SI image providers
 */

#include <stdio.h>
#include <stdlib.h>

#include "wfcimageprovider.h"
#include "wfcdevice.h"
#include "wfccontext.h"
#include "wfcstructs.h"

#include "owfimage.h"
#include "owfarray.h"
#include "owfmemory.h"
#include "owfobject.h"
#include "owfnativestream.h"
#include "owfdebug.h"

#ifdef __cplusplus
extern "C"
{
#endif

#define FIRST_IMAGEPROVIDER_HANDLE   4000

static WFCint               nextImageProviderHandle =
                            FIRST_IMAGEPROVIDER_HANDLE;

OWF_API_CALL void
WFC_IMAGE_PROVIDER_Ctor(void* self)
{
    WFC_IMAGE_PROVIDER*     ip;

    ENTER(WFC_IMAGE_PROVIDER_Ctor);

    ip = IMAGE_PROVIDER(self);
    
    ip->lockedStream.image=NULL;
    ip->lockedStream.lockCount=0;
    
    LEAVE(WFC_IMAGE_PROVIDER_Dtor);
}

OWF_API_CALL void
WFC_IMAGE_PROVIDER_Dtor(void* self)
{

    WFC_IMAGE_PROVIDER*     ip;

    ENTER(WFC_IMAGE_PROVIDER_Dtor);

    ip = IMAGE_PROVIDER(self);

    DPRINT(("ptr=%p, handle=%d", ip, ip->handle));
    owfNativeStreamDestroy(ip->streamHandle);
    DESTROY(ip->owner);
    if (ip->lockedStream.image)
        {
        if (ip->lockedStream.lockCount)
            {   /* belts and braces: unlock the read buffer when image provider is destroyed */
            DPRINT(("Native stream buffer still locked when Image Provider destroyed ptr=%p, handle=%d", ip, ip->handle));
            owfNativeStreamReleaseReadBuffer(ip->streamHandle, ip->lockedStream.buffer);
            }
        OWF_Image_Destroy(ip->lockedStream.image);
        }
    LEAVE(WFC_IMAGE_PROVIDER_Dtor);
}

static WFC_IMAGE_PROVIDER*
WFC_ImageProvider_DoCreate(void* owner, /*WFC_CONTEXT* context,*/
                           OWFNativeStreamType stream,
                           WFC_IMAGE_PROVIDER_TYPE type)
{
    WFC_IMAGE_PROVIDER*         object;

    ENTER(WFC_ImageProvider_DoCreate);

    if (!stream)
    {
        return NULL;
    }
    object = CREATE(WFC_IMAGE_PROVIDER);

    if (!object)
    {
        return NULL;
    }

    owfNativeStreamAddReference(stream);
    object->streamHandle = stream;
    object->type            = type;
    object->contentUpdated  = WFC_FALSE;

    WFC_ImageProvider_LockForReading(object);
    if (object->lockedStream.image==NULL || object->lockedStream.image->data==NULL)
        {
        owfNativeStreamDestroy(stream);
        DESTROY(object);
        return NULL;
        }
    WFC_ImageProvider_Unlock(object);
    ADDREF(object->owner, owner);

    LEAVE(WFC_ImageProvider_DoCreate);
    return object;
}

OWF_API_CALL WFC_IMAGE_PROVIDER*
WFC_ImageProvider_Create(void* owner, /*WFC_CONTEXT* context,*/
                         OWFNativeStreamType stream,
                         WFC_IMAGE_PROVIDER_TYPE type)
{
    WFC_IMAGE_PROVIDER*               object;

    ENTER(WFC_ImageProvider_Create);

    object = WFC_ImageProvider_DoCreate(owner/*context*/, stream, type);

    if (object)
    {
        object->handle = nextImageProviderHandle++;
        DPRINT(("WFC_ImageProvider_Create: attaching image provider %d to "
                "stream %p",
               object->handle, object->streamHandle));
    }

    LEAVE(WFC_ImageProvider_Create);
    return object;
}

OWF_API_CALL void
WFC_ImageProvider_LockForReading(WFC_IMAGE_PROVIDER* provider)
{
    void*                   pixels;
    OWFint                  width, height, pixelSize = 0;
    OWF_IMAGE_FORMAT        imgf;
    OWFint                  stride;

    if (!provider) {
        DPRINT(("WFC_ImageProvider_LockForReading: provider = NULL"));
        return;
    }
    OWF_ASSERT(provider->streamHandle);

     DPRINT(("stream = %p", provider->streamHandle));

     if (!provider->lockedStream.lockCount)
     {
         DPRINT(("About to acquire & lock a read buffer"));
         /* acquire buffer */
         provider->lockedStream.buffer = owfNativeStreamAcquireReadBuffer(provider->streamHandle);
         DPRINT(("  Acquired read buffer stream=%p, buffer=%d",
                 provider->streamHandle, provider->lockedStream.buffer));

         /* Bind source image to pixel buffer */
         pixels = owfNativeStreamGetBufferPtr(provider->streamHandle, provider->lockedStream.buffer);
         if (provider->lockedStream.image)
             {
             OWF_Image_SetPixelBuffer(provider->lockedStream.image,pixels);
             }
         else
             {
             owfNativeStreamGetHeader(provider->streamHandle,
                                      &width, &height,
                                      &stride, &imgf, &pixelSize);
             provider->lockedStream.image = OWF_Image_Create(width, height, &imgf, pixels, stride);
             }
     }

     ++provider->lockedStream.lockCount;
     DPRINT(("lock count = %d", provider->lockedStream.lockCount));

}

OWF_API_CALL void
WFC_ImageProvider_Unlock(WFC_IMAGE_PROVIDER* provider)
{
    if (!provider) {
        DPRINT(("WFC_ImageProvider_Unlock: provider = NULL"));
        return;
    }

    if (provider->lockedStream.lockCount > 0)
    {
        --provider->lockedStream.lockCount;
        DPRINT(("lock count = %d", provider->lockedStream.lockCount));

        if (!provider->lockedStream.lockCount)
        {
            DPRINT(("  Releasing read buffer provider=%p, buffer=%d",
                    provider->handle, provider->lockedStream.buffer));
            owfNativeStreamReleaseReadBuffer(provider->streamHandle, provider->lockedStream.buffer);
        }
    }
}



#ifdef __cplusplus
}
#endif