webrtc/modules/video_render/main/source/video_render_frames.cc

/*
 *  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 "video_render_frames.h"
#include "module_common_types.h"
#include "tick_util.h"
#include "trace.h"
#include <cassert>

namespace webrtc {

VideoRenderFrames::VideoRenderFrames() :
    _incomingFrames(), _renderDelayMs(10)
{
}

VideoRenderFrames::~VideoRenderFrames()
{
    ReleaseAllFrames();
}

WebRtc_Word32 VideoRenderFrames::AddFrame(VideoFrame* ptrNewFrame)
{
    const WebRtc_Word64 timeNow = TickTime::MillisecondTimestamp();

    if (ptrNewFrame->RenderTimeMs() + KOldRenderTimestampMS < timeNow)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceVideoRenderer, -1,
                     "%s: too old frame.", __FUNCTION__);
        return -1;
    }
    if (ptrNewFrame->RenderTimeMs() > timeNow + KFutureRenderTimestampMS)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceVideoRenderer, -1,
                     "%s: frame too long into the future.", __FUNCTION__);
        return -1;
    }

    // Get an empty frame
    VideoFrame* ptrFrameToAdd = NULL;
    if (!_emptyFrames.Empty())
    {
        ListItem* item = _emptyFrames.First();
        if (item)
        {
            ptrFrameToAdd = static_cast<VideoFrame*> (item->GetItem());
            _emptyFrames.Erase(item);
        }
    }
    if (!ptrFrameToAdd)
    {

        if (_emptyFrames.GetSize() + _incomingFrames.GetSize()
                > KMaxNumberOfFrames)
        {
            // Already allocated toom many frames...
            WEBRTC_TRACE(kTraceWarning, kTraceVideoRenderer,
                         -1, "%s: too many frames, limit: %d", __FUNCTION__,
                         KMaxNumberOfFrames);
            return -1;
        }

        // Allocate new memory
        WEBRTC_TRACE(kTraceMemory, kTraceVideoRenderer, -1,
                     "%s: allocating buffer %d", __FUNCTION__,
                     _emptyFrames.GetSize() + _incomingFrames.GetSize());

        ptrFrameToAdd = new VideoFrame();
        if (!ptrFrameToAdd)
        {
            WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, -1,
                         "%s: could not create new frame for", __FUNCTION__);
            return -1;
        }
    }

    ptrFrameToAdd->VerifyAndAllocate(ptrNewFrame->Length());
    ptrFrameToAdd->SwapFrame(const_cast<VideoFrame&> (*ptrNewFrame)); //remove const ness. Copying will be costly.
    _incomingFrames.PushBack(ptrFrameToAdd);

    return _incomingFrames.GetSize();
}

VideoFrame*
VideoRenderFrames::FrameToRender()
{
    VideoFrame* ptrRenderFrame = NULL;
    while (!_incomingFrames.Empty())
    {
        ListItem* item = _incomingFrames.First();
        if (item)
        {
            VideoFrame* ptrOldestFrameInList =
                    static_cast<VideoFrame*> (item->GetItem());
            if (ptrOldestFrameInList->RenderTimeMs()
                    <= TickTime::MillisecondTimestamp() + _renderDelayMs)
            {
                // This is the oldest one so far and it's ok to render
                if (ptrRenderFrame)
                {
                    // This one is older than the newly found frame, remove this one.
                    ptrRenderFrame->SetWidth(0);
                    ptrRenderFrame->SetHeight(0);
                    ptrRenderFrame->SetLength(0);
                    ptrRenderFrame->SetRenderTime(0);
                    ptrRenderFrame->SetTimeStamp(0);
                    _emptyFrames.PushFront(ptrRenderFrame);
                }
                ptrRenderFrame = ptrOldestFrameInList;
                _incomingFrames.Erase(item);
            }
            else
            {
                // We can't release this one yet, we're done here.
                break;
            }
        }
        else
        {
            assert(false);
        }
    }
    return ptrRenderFrame;
}

WebRtc_Word32 VideoRenderFrames::ReturnFrame(VideoFrame* ptrOldFrame)
{
    ptrOldFrame->SetWidth(0);
    ptrOldFrame->SetHeight(0);
    ptrOldFrame->SetRenderTime(0);
    ptrOldFrame->SetLength(0);
    _emptyFrames.PushBack(ptrOldFrame);

    return 0;
}

WebRtc_Word32 VideoRenderFrames::ReleaseAllFrames()
{
    while (!_incomingFrames.Empty())
    {
        ListItem* item = _incomingFrames.First();
        if (item)
        {
            VideoFrame* ptrFrame =
                    static_cast<VideoFrame*> (item->GetItem());
            assert(ptrFrame != NULL);
            ptrFrame->Free();
            delete ptrFrame;
        }
        _incomingFrames.Erase(item);
    }
    while (!_emptyFrames.Empty())
    {
        ListItem* item = _emptyFrames.First();
        if (item)
        {
            VideoFrame* ptrFrame =
                    static_cast<VideoFrame*> (item->GetItem());
            assert(ptrFrame != NULL);
            ptrFrame->Free();
            delete ptrFrame;
        }
        _emptyFrames.Erase(item);
    }
    return 0;
}

WebRtc_Word32 KEventMaxWaitTimeMs = 200;

WebRtc_UWord32 VideoRenderFrames::TimeToNextFrameRelease()
{
    WebRtc_Word64 timeToRelease = 0;
    ListItem* item = _incomingFrames.First();
    if (item)
    {
        VideoFrame* oldestFrame =
                static_cast<VideoFrame*> (item->GetItem());
        timeToRelease = oldestFrame->RenderTimeMs() - _renderDelayMs
                - TickTime::MillisecondTimestamp();
        if (timeToRelease < 0)
        {
            timeToRelease = 0;
        }
    }
    else
    {
        timeToRelease = KEventMaxWaitTimeMs;
    }

    return (WebRtc_UWord32) timeToRelease;
}

//
WebRtc_Word32 VideoRenderFrames::SetRenderDelay(
                                                const WebRtc_UWord32 renderDelay)
{
    _renderDelayMs = renderDelay;
    return 0;
}

} //namespace webrtc