622 lines
16 KiB
C++
622 lines
16 KiB
C++
#include "aja-card-manager.hpp"
|
|
#include "aja-common.hpp"
|
|
#include "aja-output.hpp"
|
|
#include "aja-source.hpp"
|
|
|
|
#include "obs-properties.h"
|
|
|
|
#include <util/base.h>
|
|
|
|
#include <ajantv2/includes/ntv2card.h>
|
|
#include <ajantv2/includes/ntv2devicescanner.h>
|
|
#include <ajantv2/includes/ntv2devicefeatures.h>
|
|
#include <ajantv2/includes/ntv2utils.h>
|
|
|
|
#include <ajabase/system/process.h>
|
|
#include <ajabase/system/systemtime.h>
|
|
|
|
static const uint32_t kStreamingAppID = NTV2_FOURCC('O', 'B', 'S', ' ');
|
|
|
|
namespace aja {
|
|
|
|
CardManager &CardManager::Instance()
|
|
{
|
|
static CardManager instance;
|
|
return instance;
|
|
}
|
|
|
|
CardEntry::CardEntry(uint32_t cardIndex, const std::string &cardID)
|
|
: mCardIndex{cardIndex},
|
|
mCardID{cardID},
|
|
mCard{std::make_unique<CNTV2Card>((UWord)cardIndex)},
|
|
mChannelPwnz{},
|
|
mMutex{}
|
|
{
|
|
}
|
|
|
|
CardEntry::~CardEntry()
|
|
{
|
|
if (mCard) {
|
|
mCard->Close();
|
|
mCard.reset();
|
|
}
|
|
}
|
|
|
|
CNTV2Card *CardEntry::GetCard()
|
|
{
|
|
return mCard.get();
|
|
}
|
|
|
|
bool CardEntry::Initialize()
|
|
{
|
|
if (!mCard) {
|
|
blog(LOG_ERROR, "Invalid card instance %s!", mCardID.c_str());
|
|
return false;
|
|
}
|
|
|
|
const NTV2DeviceID deviceID = mCard->GetDeviceID();
|
|
|
|
// Briefly enter Standard Tasks mode to reset card via AJA Daemon/Agent.
|
|
auto taskMode = NTV2_STANDARD_TASKS;
|
|
mCard->GetEveryFrameServices(taskMode);
|
|
if (taskMode != NTV2_STANDARD_TASKS) {
|
|
mCard->SetEveryFrameServices(NTV2_STANDARD_TASKS);
|
|
AJATime::Sleep(100);
|
|
}
|
|
|
|
mCard->SetEveryFrameServices(NTV2_OEM_TASKS);
|
|
|
|
const int32_t obsPid = (int32_t)AJAProcess::GetPid();
|
|
mCard->AcquireStreamForApplicationWithReference((ULWord)kStreamingAppID,
|
|
obsPid);
|
|
|
|
mCard->SetSuspendHostAudio(true);
|
|
|
|
mCard->ClearRouting();
|
|
|
|
if (NTV2DeviceCanDoMultiFormat(deviceID)) {
|
|
mCard->SetMultiFormatMode(true);
|
|
}
|
|
|
|
mCard->SetReference(NTV2_REFERENCE_FREERUN);
|
|
|
|
for (UWord i = 0; i < aja::CardNumAudioSystems(deviceID); i++) {
|
|
mCard->SetAudioLoopBack(NTV2_AUDIO_LOOPBACK_OFF,
|
|
static_cast<NTV2AudioSystem>(i));
|
|
}
|
|
|
|
auto numFramestores = aja::CardNumFramestores(deviceID);
|
|
|
|
for (UWord i = 0; i < NTV2DeviceGetNumVideoInputs(deviceID); i++) {
|
|
mCard->SetInputFrame(static_cast<NTV2Channel>(i), 0xff);
|
|
// Disable 3G Level B converter by default
|
|
if (NTV2DeviceCanDo3GLevelConversion(deviceID)) {
|
|
mCard->SetSDIInLevelBtoLevelAConversion(
|
|
static_cast<NTV2Channel>(i), false);
|
|
}
|
|
}
|
|
|
|
// SDI Outputs Default State
|
|
for (UWord i = 0; i < NTV2DeviceGetNumVideoOutputs(deviceID); i++) {
|
|
auto channel = GetNTV2ChannelForIndex(i);
|
|
if (NTV2DeviceCanDo3GOut(deviceID, i)) {
|
|
mCard->SetSDIOut3GEnable(channel, true);
|
|
mCard->SetSDIOut3GbEnable(channel, false);
|
|
}
|
|
if (NTV2DeviceCanDo12GOut(deviceID, i)) {
|
|
mCard->SetSDIOut6GEnable(channel, false);
|
|
mCard->SetSDIOut12GEnable(channel, false);
|
|
}
|
|
if (NTV2DeviceCanDo3GLevelConversion(deviceID)) {
|
|
mCard->SetSDIOutLevelAtoLevelBConversion(i, false);
|
|
mCard->SetSDIOutRGBLevelAConversion(i, false);
|
|
}
|
|
}
|
|
|
|
for (UWord i = 0; i < numFramestores; i++) {
|
|
auto channel = GetNTV2ChannelForIndex(i);
|
|
|
|
if (isAutoCirculateRunning(channel)) {
|
|
mCard->AutoCirculateStop(channel, true);
|
|
}
|
|
|
|
mCard->SetVideoFormat(NTV2_FORMAT_1080p_5994_A, false, false,
|
|
channel);
|
|
mCard->SetFrameBufferFormat(channel, NTV2_FBF_8BIT_YCBCR);
|
|
|
|
mCard->DisableChannel(channel);
|
|
}
|
|
|
|
blog(LOG_DEBUG, "NTV2 Card Initialized: %s", mCardID.c_str());
|
|
|
|
return true;
|
|
}
|
|
|
|
uint32_t CardEntry::GetCardIndex() const
|
|
{
|
|
return mCardIndex;
|
|
}
|
|
|
|
std::string CardEntry::GetCardID() const
|
|
{
|
|
return mCardID;
|
|
}
|
|
|
|
std::string CardEntry::GetDisplayName() const
|
|
{
|
|
if (mCard) {
|
|
std::ostringstream oss;
|
|
oss << mCard->GetIndexNumber() << " - "
|
|
<< mCard->GetModelName();
|
|
const std::string &serial = GetSerial();
|
|
if (!serial.empty())
|
|
oss << " (" << serial << ")";
|
|
|
|
return oss.str();
|
|
}
|
|
|
|
// very bad if we get here...
|
|
return "Unknown";
|
|
}
|
|
|
|
std::string CardEntry::GetSerial() const
|
|
{
|
|
std::string serial;
|
|
if (mCard)
|
|
mCard->GetSerialNumberString(serial);
|
|
|
|
return serial;
|
|
}
|
|
|
|
NTV2DeviceID CardEntry::GetDeviceID() const
|
|
{
|
|
NTV2DeviceID id = DEVICE_ID_NOTFOUND;
|
|
if (mCard)
|
|
id = mCard->GetDeviceID();
|
|
|
|
return id;
|
|
}
|
|
|
|
bool CardEntry::ChannelReady(NTV2Channel chan, const std::string &owner) const
|
|
{
|
|
const std::lock_guard<std::mutex> lock(mMutex);
|
|
for (const auto &pwn : mChannelPwnz) {
|
|
if (pwn.second & (1 << static_cast<int32_t>(chan))) {
|
|
return pwn.first == owner;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CardEntry::AcquireChannel(NTV2Channel chan, NTV2Mode mode,
|
|
const std::string &owner)
|
|
{
|
|
bool acquired = false;
|
|
|
|
if (ChannelReady(chan, owner)) {
|
|
const std::lock_guard<std::mutex> lock(mMutex);
|
|
if (mChannelPwnz.find(owner) != mChannelPwnz.end()) {
|
|
if (mChannelPwnz[owner] &
|
|
(1 << static_cast<int32_t>(chan))) {
|
|
acquired = true;
|
|
} else {
|
|
mChannelPwnz[owner] |=
|
|
(1 << static_cast<int32_t>(chan));
|
|
acquired = true;
|
|
}
|
|
} else {
|
|
mChannelPwnz[owner] |=
|
|
(1 << static_cast<int32_t>(chan));
|
|
acquired = true;
|
|
}
|
|
|
|
// Acquire interrupt handles
|
|
if (acquired && mCard) {
|
|
if (mode == NTV2_MODE_CAPTURE) {
|
|
mCard->EnableInputInterrupt(chan);
|
|
mCard->SubscribeInputVerticalEvent(chan);
|
|
} else if (mode == NTV2_MODE_DISPLAY) {
|
|
mCard->EnableOutputInterrupt(chan);
|
|
mCard->SubscribeOutputVerticalEvent(chan);
|
|
}
|
|
}
|
|
}
|
|
|
|
return acquired;
|
|
}
|
|
|
|
bool CardEntry::ReleaseChannel(NTV2Channel chan, NTV2Mode mode,
|
|
const std::string &owner)
|
|
{
|
|
const std::lock_guard<std::mutex> lock(mMutex);
|
|
for (const auto &pwn : mChannelPwnz) {
|
|
if (pwn.first == owner) {
|
|
if (mChannelPwnz[owner] &
|
|
(1 << static_cast<int32_t>(chan))) {
|
|
mChannelPwnz[owner] ^=
|
|
(1 << static_cast<int32_t>(chan));
|
|
|
|
// Release interrupt handles
|
|
if (mCard) {
|
|
if (mode == NTV2_MODE_CAPTURE) {
|
|
mCard->DisableInputInterrupt(
|
|
chan);
|
|
mCard->UnsubscribeInputVerticalEvent(
|
|
chan);
|
|
} else if (mode == NTV2_MODE_DISPLAY) {
|
|
mCard->DisableOutputInterrupt(
|
|
chan);
|
|
mCard->UnsubscribeOutputVerticalEvent(
|
|
chan);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CardEntry::InputSelectionReady(IOSelection io, NTV2DeviceID id,
|
|
const std::string &owner) const
|
|
{
|
|
if (id == DEVICE_ID_KONA1 && io == IOSelection::SDI1) {
|
|
return true;
|
|
} else {
|
|
NTV2InputSourceSet inputSources;
|
|
aja::IOSelectionToInputSources(io, inputSources);
|
|
if (inputSources.size() > 0) {
|
|
size_t channelsReady = 0;
|
|
for (auto &&src : inputSources) {
|
|
auto channel = NTV2InputSourceToChannel(src);
|
|
if (ChannelReady(channel, owner))
|
|
channelsReady++;
|
|
}
|
|
if (channelsReady == inputSources.size())
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CardEntry::OutputSelectionReady(IOSelection io, NTV2DeviceID id,
|
|
const std::string &owner) const
|
|
{
|
|
/* Handle checking special case outputs before all other outputs.
|
|
* 1. HDMI Monitor uses framestore 4
|
|
* 2. SDI Monitor on Io 4K/Io 4K Plus, etc. uses framestore 4.
|
|
* 3. Everything else...
|
|
*/
|
|
if (aja::CardCanDoHDMIMonitorOutput(id) &&
|
|
io == IOSelection::HDMIMonitorOut) {
|
|
NTV2Channel hdmiMonChannel = NTV2_CHANNEL4;
|
|
return ChannelReady(hdmiMonChannel, owner);
|
|
} else if (aja::CardCanDoSDIMonitorOutput(id) &&
|
|
io == IOSelection::SDI5) {
|
|
NTV2Channel sdiMonChannel = NTV2_CHANNEL4;
|
|
return ChannelReady(sdiMonChannel, owner);
|
|
} else if (id == DEVICE_ID_KONA1 && io == IOSelection::SDI1) {
|
|
return true;
|
|
} else {
|
|
NTV2OutputDestinations outputDests;
|
|
aja::IOSelectionToOutputDests(io, outputDests);
|
|
if (outputDests.size() > 0) {
|
|
size_t channelsReady = 0;
|
|
for (auto &&dst : outputDests) {
|
|
auto channel =
|
|
NTV2OutputDestinationToChannel(dst);
|
|
if (ChannelReady(channel, owner))
|
|
channelsReady++;
|
|
}
|
|
if (channelsReady == outputDests.size())
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CardEntry::AcquireInputSelection(IOSelection io, NTV2DeviceID id,
|
|
const std::string &owner)
|
|
{
|
|
UNUSED_PARAMETER(id);
|
|
|
|
NTV2InputSourceSet inputSources;
|
|
aja::IOSelectionToInputSources(io, inputSources);
|
|
|
|
std::vector<NTV2Channel> acquiredChannels;
|
|
for (auto &&src : inputSources) {
|
|
auto acqChan = NTV2InputSourceToChannel(src);
|
|
if (AcquireChannel(acqChan, NTV2_MODE_CAPTURE, owner)) {
|
|
blog(LOG_DEBUG, "Source %s acquired channel %s",
|
|
owner.c_str(),
|
|
NTV2ChannelToString(acqChan).c_str());
|
|
acquiredChannels.push_back(acqChan);
|
|
} else {
|
|
blog(LOG_DEBUG,
|
|
"Source %s could not acquire channel %s",
|
|
owner.c_str(),
|
|
NTV2ChannelToString(acqChan).c_str());
|
|
}
|
|
}
|
|
|
|
// Release channels if we couldn't acquire all required channels.
|
|
if (acquiredChannels.size() != inputSources.size()) {
|
|
for (auto &&ac : acquiredChannels) {
|
|
ReleaseChannel(ac, NTV2_MODE_CAPTURE, owner);
|
|
}
|
|
}
|
|
|
|
return acquiredChannels.size() == inputSources.size();
|
|
}
|
|
|
|
bool CardEntry::ReleaseInputSelection(IOSelection io, NTV2DeviceID id,
|
|
const std::string &owner)
|
|
{
|
|
UNUSED_PARAMETER(id);
|
|
|
|
NTV2InputSourceSet currentInputSources;
|
|
aja::IOSelectionToInputSources(io, currentInputSources);
|
|
uint32_t releasedCount = 0;
|
|
for (auto &&src : currentInputSources) {
|
|
auto relChan = NTV2InputSourceToChannel(src);
|
|
if (ReleaseChannel(relChan, NTV2_MODE_CAPTURE, owner)) {
|
|
blog(LOG_DEBUG, "Released Channel %s",
|
|
NTV2ChannelToString(relChan).c_str());
|
|
releasedCount++;
|
|
}
|
|
}
|
|
return releasedCount == currentInputSources.size();
|
|
}
|
|
|
|
bool CardEntry::AcquireOutputSelection(IOSelection io, NTV2DeviceID id,
|
|
const std::string &owner)
|
|
{
|
|
std::vector<NTV2Channel> acquiredChannels;
|
|
NTV2OutputDestinations outputDests;
|
|
aja::IOSelectionToOutputDests(io, outputDests);
|
|
|
|
// Handle acquiring special case outputs --
|
|
// HDMI Monitor uses framestore 4
|
|
if (aja::CardCanDoHDMIMonitorOutput(id) &&
|
|
io == IOSelection::HDMIMonitorOut) {
|
|
NTV2Channel hdmiMonChannel = NTV2_CHANNEL4;
|
|
if (AcquireChannel(hdmiMonChannel, NTV2_MODE_DISPLAY, owner)) {
|
|
blog(LOG_DEBUG, "Output %s acquired channel %s",
|
|
owner.c_str(),
|
|
NTV2ChannelToString(hdmiMonChannel).c_str());
|
|
acquiredChannels.push_back(hdmiMonChannel);
|
|
} else {
|
|
blog(LOG_DEBUG,
|
|
"Output %s could not acquire channel %s",
|
|
owner.c_str(),
|
|
NTV2ChannelToString(hdmiMonChannel).c_str());
|
|
}
|
|
} else if (aja::CardCanDoSDIMonitorOutput(id) &&
|
|
io == IOSelection::SDI5) {
|
|
// SDI Monitor on io4K/io4K+/etc. uses framestore 4
|
|
NTV2Channel sdiMonChannel = NTV2_CHANNEL4;
|
|
if (AcquireChannel(sdiMonChannel, NTV2_MODE_DISPLAY, owner)) {
|
|
blog(LOG_DEBUG, "Output %s acquired channel %s",
|
|
owner.c_str(),
|
|
NTV2ChannelToString(sdiMonChannel).c_str());
|
|
acquiredChannels.push_back(sdiMonChannel);
|
|
} else {
|
|
blog(LOG_DEBUG,
|
|
"Output %s could not acquire channel %s",
|
|
owner.c_str(),
|
|
NTV2ChannelToString(sdiMonChannel).c_str());
|
|
}
|
|
} else {
|
|
// Handle acquiring all other channels
|
|
for (auto &&dst : outputDests) {
|
|
auto acqChan = NTV2OutputDestinationToChannel(dst);
|
|
if (AcquireChannel(acqChan, NTV2_MODE_DISPLAY, owner)) {
|
|
acquiredChannels.push_back(acqChan);
|
|
blog(LOG_DEBUG, "Output %s acquired channel %s",
|
|
owner.c_str(),
|
|
NTV2ChannelToString(acqChan).c_str());
|
|
} else {
|
|
blog(LOG_DEBUG,
|
|
"Output %s could not acquire channel %s",
|
|
owner.c_str(),
|
|
NTV2ChannelToString(acqChan).c_str());
|
|
}
|
|
}
|
|
|
|
// Release channels if we couldn't acquire all required channels.
|
|
if (acquiredChannels.size() != outputDests.size()) {
|
|
for (auto &&ac : acquiredChannels) {
|
|
ReleaseChannel(ac, NTV2_MODE_DISPLAY, owner);
|
|
}
|
|
}
|
|
}
|
|
|
|
return acquiredChannels.size() == outputDests.size();
|
|
}
|
|
|
|
bool CardEntry::ReleaseOutputSelection(IOSelection io, NTV2DeviceID id,
|
|
const std::string &owner)
|
|
{
|
|
NTV2OutputDestinations currentOutputDests;
|
|
aja::IOSelectionToOutputDests(io, currentOutputDests);
|
|
uint32_t releasedCount = 0;
|
|
|
|
// Handle releasing special case outputs --
|
|
// HDMI Monitor uses framestore 4
|
|
if (aja::CardCanDoHDMIMonitorOutput(id) &&
|
|
io == IOSelection::HDMIMonitorOut) {
|
|
NTV2Channel hdmiMonChannel = NTV2_CHANNEL4;
|
|
if (ReleaseChannel(hdmiMonChannel, NTV2_MODE_DISPLAY, owner)) {
|
|
blog(LOG_DEBUG, "Released Channel %s",
|
|
NTV2ChannelToString(hdmiMonChannel).c_str());
|
|
releasedCount++;
|
|
}
|
|
} else if (aja::CardCanDoSDIMonitorOutput(id) &&
|
|
io == IOSelection::SDI5) {
|
|
// SDI Monitor on io4K/io4K+/etc. uses framestore 4
|
|
NTV2Channel sdiMonChannel = NTV2_CHANNEL4;
|
|
if (ReleaseChannel(sdiMonChannel, NTV2_MODE_DISPLAY, owner)) {
|
|
blog(LOG_DEBUG, "Released Channel %s",
|
|
NTV2ChannelToString(sdiMonChannel).c_str());
|
|
releasedCount++;
|
|
}
|
|
} else {
|
|
// Release all other channels
|
|
for (auto &&dst : currentOutputDests) {
|
|
auto relChan = NTV2OutputDestinationToChannel(dst);
|
|
if (ReleaseChannel(relChan, NTV2_MODE_DISPLAY, owner)) {
|
|
blog(LOG_DEBUG, "Released Channel %s",
|
|
NTV2ChannelToString(relChan).c_str());
|
|
releasedCount++;
|
|
}
|
|
}
|
|
}
|
|
return releasedCount == currentOutputDests.size();
|
|
}
|
|
|
|
bool CardEntry::UpdateChannelOwnerName(const std::string &oldName,
|
|
const std::string &newName)
|
|
{
|
|
const std::lock_guard<std::mutex> lock(mMutex);
|
|
for (const auto &pwn : mChannelPwnz) {
|
|
if (pwn.first == oldName) {
|
|
mChannelPwnz.insert(std::pair<std::string, int32_t>{
|
|
newName, pwn.second});
|
|
|
|
mChannelPwnz.erase(oldName);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CardEntry::isAutoCirculateRunning(NTV2Channel chan)
|
|
{
|
|
if (!mCard)
|
|
return false;
|
|
|
|
AUTOCIRCULATE_STATUS acStatus;
|
|
if (mCard->AutoCirculateGetStatus(chan, acStatus)) {
|
|
if (acStatus.acState != NTV2_AUTOCIRCULATE_RUNNING &&
|
|
acStatus.acState != NTV2_AUTOCIRCULATE_STARTING &&
|
|
acStatus.acState != NTV2_AUTOCIRCULATE_PAUSED &&
|
|
acStatus.acState != NTV2_AUTOCIRCULATE_INIT) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void CardManager::ClearCardEntries()
|
|
{
|
|
const std::lock_guard<std::mutex> lock(mMutex);
|
|
for (auto &&entry : mCardEntries) {
|
|
CNTV2Card *card = entry.second->GetCard();
|
|
if (card) {
|
|
card->SetSuspendHostAudio(false);
|
|
card->SetEveryFrameServices(NTV2_STANDARD_TASKS);
|
|
// Workaround for AJA internal bug #11378
|
|
// Set HDMI output back to Audio System 1 on card release
|
|
if (NTV2DeviceGetNumHDMIVideoOutputs(
|
|
card->GetDeviceID()) > 0) {
|
|
card->SetHDMIOutAudioSource8Channel(
|
|
NTV2_AudioChannel1_8,
|
|
NTV2_AUDIOSYSTEM_1);
|
|
}
|
|
|
|
int32_t pid = (int32_t)AJAProcess::GetPid();
|
|
card->ReleaseStreamForApplicationWithReference(
|
|
(ULWord)kStreamingAppID, pid);
|
|
}
|
|
}
|
|
|
|
mCardEntries.clear();
|
|
}
|
|
|
|
void CardManager::EnumerateCards()
|
|
{
|
|
const std::lock_guard<std::mutex> lock(mMutex);
|
|
CNTV2DeviceScanner scanner;
|
|
for (const auto &iter : scanner.GetDeviceInfoList()) {
|
|
CNTV2Card card((UWord)iter.deviceIndex);
|
|
const std::string &cardID = aja::MakeCardID(card);
|
|
|
|
// New Card Entry
|
|
if (mCardEntries.find(cardID) == mCardEntries.end()) {
|
|
CardEntryPtr cardEntry = std::make_shared<CardEntry>(
|
|
iter.deviceIndex, cardID);
|
|
if (cardEntry && cardEntry->Initialize())
|
|
mCardEntries.emplace(cardID, cardEntry);
|
|
} else {
|
|
// Card fell off of the bus and came back with a new physical index?
|
|
auto currEntry = mCardEntries[cardID];
|
|
if (currEntry) {
|
|
if (currEntry->GetCardIndex() !=
|
|
iter.deviceIndex) {
|
|
mCardEntries.erase(cardID);
|
|
CardEntryPtr cardEntry =
|
|
std::make_shared<CardEntry>(
|
|
iter.deviceIndex,
|
|
cardID);
|
|
if (cardEntry &&
|
|
cardEntry->Initialize())
|
|
mCardEntries.emplace(cardID,
|
|
cardEntry);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
size_t CardManager::NumCardEntries() const
|
|
{
|
|
const std::lock_guard<std::mutex> lock(mMutex);
|
|
return mCardEntries.size();
|
|
}
|
|
|
|
CNTV2Card *CardManager::GetCard(const std::string &cardID)
|
|
{
|
|
auto entry = GetCardEntry(cardID);
|
|
if (entry)
|
|
return entry->GetCard();
|
|
return nullptr;
|
|
}
|
|
|
|
const CardEntryPtr CardManager::GetCardEntry(const std::string &cardID) const
|
|
{
|
|
const std::lock_guard<std::mutex> lock(mMutex);
|
|
for (const auto &entry : mCardEntries) {
|
|
if (entry.second && entry.second->GetCardID() == cardID)
|
|
return entry.second;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
const CardEntries &CardManager::GetCardEntries() const
|
|
{
|
|
const std::lock_guard<std::mutex> lock(mMutex);
|
|
return mCardEntries;
|
|
}
|
|
|
|
const CardEntries::iterator CardManager::begin()
|
|
{
|
|
const std::lock_guard<std::mutex> lock(mMutex);
|
|
return mCardEntries.begin();
|
|
}
|
|
|
|
const CardEntries::iterator CardManager::end()
|
|
{
|
|
const std::lock_guard<std::mutex> lock(mMutex);
|
|
return mCardEntries.end();
|
|
}
|
|
|
|
} // aja
|