/*
 *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

#include "vie_frame_provider_base.h"
#include "critical_section_wrapper.h"
#include "tick_util.h"
#include "trace.h"
#include "vie_defines.h"

namespace webrtc {

ViEFrameProviderBase::ViEFrameProviderBase(int Id, int engineId):
_id(Id),
_engineId(engineId),
_frameCallbackMap(),
_providerCritSect(*CriticalSectionWrapper::CreateCriticalSection()),
_ptrExtraFrame(NULL),
_frameDelay(0)
{
}

ViEFrameProviderBase::~ViEFrameProviderBase()
{
    if(_frameCallbackMap.Size()>0)
    {
        WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceVideo, ViEId(_engineId,_id), "FramCallbacks still exist when Provider deleted %d",_frameCallbackMap.Size());
    }
    for(MapItem* item=_frameCallbackMap.First();item!=NULL;item=_frameCallbackMap.Next(item))
    {
        static_cast<ViEFrameCallback*>(item->GetItem())->ProviderDestroyed(_id);
    }

    while(_frameCallbackMap.Erase(_frameCallbackMap.First()) == 0)
        ;

    delete &_providerCritSect;
    delete _ptrExtraFrame;
}

int ViEFrameProviderBase::Id()
{
    return _id;
}

void ViEFrameProviderBase::DeliverFrame(webrtc::VideoFrame& videoFrame,int numCSRCs,
                                const WebRtc_UWord32 CSRC[kRtpCsrcSize])
{
#ifdef _DEBUG
    const TickTime startProcessTime=TickTime::Now();
#endif
    CriticalSectionScoped cs(_providerCritSect);

    // Deliver the frame to all registered callbacks
    if (_frameCallbackMap.Size() > 0)
    {
        if(_frameCallbackMap.Size()==1)
        {
            ViEFrameCallback* frameObserver = static_cast<ViEFrameCallback*>(_frameCallbackMap.First()->GetItem());
            frameObserver->DeliverFrame(_id,videoFrame,numCSRCs,CSRC);
        }
        else
        {
            // Make a copy of the frame for all callbacks
            for (MapItem* mapItem = _frameCallbackMap.First();
                mapItem != NULL;
                mapItem = _frameCallbackMap.Next(mapItem))
            {
                if (_ptrExtraFrame == NULL)
                {
                    _ptrExtraFrame = new webrtc::VideoFrame();
                }
                if (mapItem != NULL)
                {
                    ViEFrameCallback* frameObserver = static_cast<ViEFrameCallback*>(mapItem->GetItem());
                    if (frameObserver != NULL)
                    {
                        // We must copy the frame each time since the previous receiver might swap it...
                        _ptrExtraFrame->CopyFrame(videoFrame);
                        frameObserver->DeliverFrame(_id, *_ptrExtraFrame,numCSRCs,CSRC);
                    }
                }
            }
        }
    }

#ifdef _DEBUG
    const int processTime=(int) (TickTime::Now()-startProcessTime).Milliseconds();
    if(processTime>25) // Warn If the delivery time is too long.
    {
        WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceVideo, ViEId(_engineId,_id), "%s Too long time: %ums",__FUNCTION__,processTime);
    }
#endif
}

void ViEFrameProviderBase::SetFrameDelay(int frameDelay)
{

    CriticalSectionScoped cs(_providerCritSect);
    _frameDelay=frameDelay;

    for (MapItem* mapItem = _frameCallbackMap.First();
                mapItem != NULL;
                mapItem = _frameCallbackMap.Next(mapItem))
    {
        ViEFrameCallback* frameObserver = static_cast<ViEFrameCallback*>(mapItem->GetItem());
        assert(frameObserver);
        frameObserver->DelayChanged(_id,frameDelay);
    }

}

int ViEFrameProviderBase::FrameDelay()
{
    return _frameDelay;
}

int ViEFrameProviderBase::GetBestFormat(int& bestWidth,
                                              int& bestHeight,
                                              int& bestFrameRate)
{

    int largestWidth = 0;
    int largestHeight = 0;
    int highestFrameRate = 0;

    CriticalSectionScoped cs(_providerCritSect);

    // Check if this one already exists...
    for (MapItem* mapItem = _frameCallbackMap.First();
         mapItem != NULL;
         mapItem = _frameCallbackMap.Next(mapItem))
    {


        int preferedWidth=0;
        int preferedHeight=0;
        int preferedFrameRate=0;

        ViEFrameCallback* callbackObject = static_cast<ViEFrameCallback*>(mapItem->GetItem());
        assert(callbackObject);
        if(callbackObject->GetPreferedFrameSettings(preferedWidth,preferedHeight,preferedFrameRate)==0)
        {
            if (preferedWidth > largestWidth)
            {
                largestWidth = preferedWidth;
            }
            if (preferedHeight > largestHeight)
            {
                largestHeight = preferedHeight;
            }
            if (preferedFrameRate > highestFrameRate)
            {
                highestFrameRate = preferedFrameRate;
            }
        }
    }

    bestWidth = largestWidth;
    bestHeight = largestHeight;
    bestFrameRate = highestFrameRate;

    return 0;
}

int ViEFrameProviderBase::RegisterFrameCallback(int observerId,ViEFrameCallback* callbackObject)
{
    if (callbackObject == NULL)
    {
        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, ViEId(_engineId, _id),
            "%s: No argument", __FUNCTION__);
        return -1;
    }
    WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideo, ViEId(_engineId, _id),
        "%s(0x%p)", callbackObject);

    {
        CriticalSectionScoped cs(_providerCritSect);

        // Check if this one already exists...
        for (MapItem* mapItem = _frameCallbackMap.First();
             mapItem != NULL;
             mapItem = _frameCallbackMap.Next(mapItem))
        {
            const ViEFrameCallback* observer=static_cast<ViEFrameCallback*> (mapItem->GetItem());
            if (observer == callbackObject)
            {
                // This callback is already registered
                WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceVideo, ViEId(_engineId, _id),
                    "%s 0x%p already registered", __FUNCTION__, callbackObject);

                assert("!frameObserver already registered");
                return -1;
            }
        }

        if (_frameCallbackMap.Insert(observerId,callbackObject) != 0)
        {
            WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, ViEId(_engineId, _id),
                "%s: Could not add 0x%p to list", __FUNCTION__, callbackObject);
            return -1;
        }
    }
    // Report current capture delay
    callbackObject->DelayChanged(_id,_frameDelay);

    FrameCallbackChanged(); // Notify implementer of this class that the callback list have changed
    return 0;


}


// ----------------------------------------------------------------------------
// DeregisterFrameCallback
// ----------------------------------------------------------------------------

int ViEFrameProviderBase::DeregisterFrameCallback(const ViEFrameCallback* callbackObject)
{
    if (callbackObject == NULL)
    {
        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, ViEId(_engineId, _id),
            "%s: No argument", __FUNCTION__);
        return -1;
    }
    WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideo, ViEId(_engineId, _id),
        "%s(0x%p)", callbackObject);


    {
        CriticalSectionScoped cs(_providerCritSect);
        bool itemFound=false;


        // Try to find the callback in our list
        for (MapItem* mapItem = _frameCallbackMap.First();
             mapItem != NULL;
             mapItem = _frameCallbackMap.Next(mapItem))
        {
            const ViEFrameCallback* observer=static_cast<ViEFrameCallback*> (mapItem->GetItem());
            if (observer == callbackObject)
            {
                // We found it, remove it!
                _frameCallbackMap.Erase(mapItem);
                WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideo, ViEId(_engineId, _id),
                    "%s 0x%p deregistered", __FUNCTION__, callbackObject);
                itemFound=true;
                break;
            }
        }
        if(!itemFound)
        {
            WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceVideo, ViEId(_engineId, _id),
                    "%s 0x%p not found", __FUNCTION__, callbackObject);
            return -1;
        }
    }

    FrameCallbackChanged(); // Notify implementer of this class that the callback list have changed
    return 0;
}

// ----------------------------------------------------------------------------
// IsFrameCallbackRegistered
// ----------------------------------------------------------------------------

bool ViEFrameProviderBase::IsFrameCallbackRegistered(const ViEFrameCallback* callbackObject)
{
    if (callbackObject == NULL)
    {
        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, ViEId(_engineId, _id),
            "%s: No argument", __FUNCTION__);
        return false;
    }
    WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideo, ViEId(_engineId, _id),
        "%s(0x%p)", callbackObject);

    for (MapItem* mapItem = _frameCallbackMap.First();
         mapItem != NULL;
         mapItem = _frameCallbackMap.Next(mapItem))
    {
        if (callbackObject == mapItem->GetItem())
        {
            // We found the callback
            WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideo, ViEId(_engineId, _id),
                "%s 0x%p is registered", __FUNCTION__, callbackObject);
            return true;
        }
    }
    WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideo, ViEId(_engineId, _id),
        "%s 0x%p not registered", __FUNCTION__, callbackObject);
    return false;
}

// ----------------------------------------------------------------------------
// NumberOfRegistersFrameCallbacks
// ----------------------------------------------------------------------------

int ViEFrameProviderBase::NumberOfRegistersFrameCallbacks()
{
    CriticalSectionScoped cs(_providerCritSect);
    return _frameCallbackMap.Size();
}
} // namespac webrtc