blob: 3527560999125f23c321301ebc9b7edf6ea3e48a [file]
/*
* Copyright (c) 2018-2021, Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is 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 Software.
*
* THE SOFTWARE IS 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 SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/
//!
//! \file encode_buffer_tracker.cpp
//! \brief Defines the interface for buffer tracker
//! \details The tracker manages the buffers with different type
//!
#include "encode_tracked_buffer.h"
#include <iterator>
#include <utility>
#include "encode_tracked_buffer_slot.h"
#include "mos_utilities.h"
namespace encode {
constexpr MapBufferResourceType TrackedBuffer::m_mapBufferResourceType[];
TrackedBuffer::TrackedBuffer(EncodeAllocator *allocator, uint8_t maxRefCnt, uint8_t maxNonRefCnt)
: m_maxRefSlotCnt(maxRefCnt),
m_maxNonRefSlotCnt(maxNonRefCnt),
m_allocator(allocator)
{
m_maxSlotCnt = m_maxRefSlotCnt + m_maxNonRefSlotCnt;
for (uint8_t i = 0; i < m_maxSlotCnt; i++)
{
m_bufferSlots.push_back(MOS_New(BufferSlot, this));
}
m_mutex = MosUtilities::MosCreateMutex();
}
TrackedBuffer::~TrackedBuffer()
{
for (auto it = m_bufferSlots.begin(); it != m_bufferSlots.end(); it++)
{
(*it)->Reset();
MOS_Delete(*it);
}
m_bufferQueue.clear();
m_oldQueue.clear();
MosUtilities::MosDestroyMutex(m_mutex);
}
MOS_STATUS TrackedBuffer::RegisterParam(BufferType type, MOS_ALLOC_GFXRES_PARAMS param)
{
auto iter = m_allocParams.find(type);
if (iter == m_allocParams.end())
{
m_allocParams.insert(std::make_pair(type, param));
}
else
{
// erase the older param and insert new one when resultion change happens
m_allocParams.erase(iter);
m_allocParams.insert(std::make_pair(type, param));
}
return MOS_STATUS_SUCCESS;
}
MOS_STATUS TrackedBuffer::ReleaseUnusedSlots(
CODEC_REF_LIST* refList,
bool lazyRelease)
{
ENCODE_CHK_NULL_RETURN(refList);
if (!refList->bUsedAsRef)
{
return MOS_STATUS_SUCCESS;
}
if (lazyRelease && m_bufferSlots.size() < m_maxSlotCnt)
{
return MOS_STATUS_SUCCESS;
}
// find all the slots which are not used by current reflist
uint8_t refIndex = 0;
for (uint8_t slotIndex = 0; slotIndex < m_maxSlotCnt; slotIndex++)
{
for (refIndex = 0; refIndex < refList->ucNumRef; refIndex++)
{
CODEC_PICTURE currRef = refList->RefList[refIndex];
if (currRef.FrameIdx == m_bufferSlots[slotIndex]->GetFrameIdx())
{
break;
}
}
if (refIndex == refList->ucNumRef)
{
ENCODE_CHK_STATUS_RETURN(m_bufferSlots[slotIndex]->Reset());
if (lazyRelease)
{
break;
}
}
}
return MOS_STATUS_SUCCESS;
}
MOS_STATUS TrackedBuffer::Acquire(
CODEC_REF_LIST* refList,
bool isIdrFrame,
bool lazyRelease)
{
ENCODE_CHK_NULL_RETURN(refList);
AutoLock lock(m_mutex);
//if encouter Idr frame, need to clear the reference slots
if (isIdrFrame)
{
for (auto it = m_bufferSlots.begin(); it != m_bufferSlots.end(); it++)
{
(*it)->Reset();
}
}
ENCODE_CHK_STATUS_RETURN(ReleaseUnusedSlots(refList, lazyRelease));
// get current free slot index
refList->ucScalingIdx = m_currSlotIndex = 0XFF;
for (uint8_t i = 0; i < m_maxSlotCnt; i++)
{
BufferSlot *slot = m_bufferSlots[i];
if (slot->IsFree())
{
m_currSlotIndex = i;
slot->SetBusy();
slot->SetFrameIdx(refList->RefPic.FrameIdx);
break;
}
}
//if not found, wait for previous slot returned
if (m_currSlotIndex == 0XFF)
{
MOS_STATUS status = m_condition.Wait(m_mutex);
if (status != MOS_STATUS_SUCCESS || m_currSlotIndex == 0XFF)
{
return MOS_STATUS_UNKNOWN;
}
ENCODE_ASSERT(m_currSlotIndex != 0XFF);
BufferSlot *slot = m_bufferSlots[m_currSlotIndex];
ENCODE_CHK_NULL_RETURN(slot);
slot->SetBusy();
slot->SetFrameIdx(refList->RefPic.FrameIdx);
}
refList->ucScalingIdx = m_currSlotIndex;
return MOS_STATUS_SUCCESS;
}
MOS_STATUS TrackedBuffer::Release(CODEC_REF_LIST* refList)
{
ENCODE_CHK_NULL_RETURN(refList);
AutoLock lock(m_mutex);
uint8_t slotIndex = refList->ucScalingIdx;
if (slotIndex >= m_maxSlotCnt)
{
return MOS_STATUS_SUCCESS;
}
//if the condition variable is waiting, assign the returned slot to m_currSlotIndex
//and signal the waiting condition
if (m_currSlotIndex == 0XFF && !refList->bUsedAsRef)
{
ENCODE_CHK_STATUS_RETURN(m_bufferSlots[slotIndex]->Reset());
m_currSlotIndex = slotIndex;
m_condition.Signal();
}
if (!m_oldQueue.empty())
{
for (auto iter = m_oldQueue.begin(); iter != m_oldQueue.end();)
{
if (iter->second->SafeToDestory())
{
iter = m_oldQueue.erase(iter);
}
else
{
iter++;
}
}
}
return MOS_STATUS_SUCCESS;
}
MOS_STATUS TrackedBuffer::OnSizeChange()
{
for (auto iter = m_bufferQueue.begin(); iter != m_bufferQueue.end();)
{
if (iter->second->SafeToDestory())
{
iter = m_bufferQueue.erase(iter);
}
else
{
iter++;
}
}
if (!m_bufferQueue.empty())
{
m_oldQueue.insert(std::make_move_iterator(m_bufferQueue.begin()),
std::make_move_iterator(m_bufferQueue.end()));
m_bufferQueue.clear();
}
return MOS_STATUS_SUCCESS;
}
MOS_SURFACE *TrackedBuffer::GetSurface(BufferType type, uint32_t index)
{
ResourceType resType = GetResourceType(type);
if (index > m_maxSlotCnt || resType != ResourceType::surfaceResource)
{
return nullptr;
}
return (MOS_SURFACE *)m_bufferSlots[index]->GetResource(type);
}
MOS_RESOURCE *TrackedBuffer::GetBuffer(BufferType type, uint32_t index)
{
ResourceType resType = GetResourceType(type);
if (index > m_maxSlotCnt || resType != ResourceType::bufferResource)
{
return nullptr;
}
return (MOS_RESOURCE *)m_bufferSlots[index]->GetResource(type);
}
std::shared_ptr<BufferQueue> TrackedBuffer::GetBufferQueue(BufferType type)
{
auto iter = m_bufferQueue.find(type);
if (iter == m_bufferQueue.end())
{
auto param = m_allocParams.find(type);
if (param == m_allocParams.end())
{
return nullptr;
}
ResourceType resType = GetResourceType(type);
auto alloc = std::make_shared<BufferQueue>(m_allocator, param->second, m_maxSlotCnt);
alloc->SetResourceType(resType);
m_bufferQueue.insert(std::make_pair(type, alloc));
return alloc;
}
else
{
return iter->second;
}
}
}