ntv2task.cpp

Go to the documentation of this file.

/* SPDX-License-Identifier: MIT */
#include "ntv2task.h"
#include "ntv2debug.h"
#include "ntv2utils.h"

#include <string.h>
#include <iomanip>

#ifndef NULL
#define NULL (0)
#endif

using namespace std;


CNTV2Task::CNTV2Task()
{
    Init();
}

CNTV2Task::CNTV2Task(const CNTV2Task& other)
{
    *this = other;
}

CNTV2Task::~CNTV2Task()
{
}

void CNTV2Task::Init()
{
    m_AutoCircTask.taskVersion = AUTOCIRCULATE_TASK_VERSION;
    m_AutoCircTask.taskSize = sizeof(AutoCircGenericTask);
    m_AutoCircTask.maxTasks = AUTOCIRCULATE_TASK_MAX_TASKS;
    m_AutoCircTask.numTasks = 0;
    m_AutoCircTask.taskArray = m_TaskArray;
    InitTaskArray(m_TaskArray, AUTOCIRCULATE_TASK_MAX_TASKS);
}

void CNTV2Task::Clear()
{
    m_AutoCircTask.numTasks = 0;
}

AutoCircGenericTask* CNTV2Task::AddRegisterWriteTask(
    ULWord registerNum,
    ULWord registerValue,
    ULWord registerMask,
    ULWord registerShift)
{
    ULWord index = m_AutoCircTask.numTasks;

    if(index >= m_AutoCircTask.maxTasks)
    {
        return NULL;
    }

    AutoCircGenericTask* pGeneric = &m_TaskArray[index];
    pGeneric->taskType = eAutoCircTaskRegisterWrite;

    pGeneric->u.registerTask.regNum = registerNum;
    pGeneric->u.registerTask.mask = registerMask;
    pGeneric->u.registerTask.shift = registerShift;
    pGeneric->u.registerTask.value = registerValue;

    index++;
    m_AutoCircTask.numTasks = index;

    return pGeneric;
}

AutoCircGenericTask* CNTV2Task::AddRegisterReadTask(
    ULWord registerNum,
    ULWord registerMask,
    ULWord registerShift)
{
    ULWord index = m_AutoCircTask.numTasks;

    if(index >= m_AutoCircTask.maxTasks)
    {
        return NULL;
    }

    AutoCircGenericTask* pGeneric = &m_TaskArray[index];
    pGeneric->taskType = eAutoCircTaskRegisterRead;

    pGeneric->u.registerTask.regNum = registerNum;
    pGeneric->u.registerTask.mask = registerMask;
    pGeneric->u.registerTask.shift = registerShift;
    pGeneric->u.registerTask.value = 0;

    index++;
    m_AutoCircTask.numTasks = index;

    return pGeneric;
}


AutoCircGenericTask* CNTV2Task::AddTimeCodeWriteTask(
    RP188_STRUCT* pTCInOut1,
    RP188_STRUCT* pTCInOut2,
    RP188_STRUCT* pLTCEmbedded,
    RP188_STRUCT* pLTCAnalog,
    RP188_STRUCT* pLTCEmbedded2,
    RP188_STRUCT* pLTCAnalog2,
    RP188_STRUCT* pTCInOut3,
    RP188_STRUCT* pTCInOut4,
    RP188_STRUCT* pTCInOut5,
    RP188_STRUCT* pTCInOut6,
    RP188_STRUCT* pTCInOut7,
    RP188_STRUCT* pTCInOut8)
{
    ULWord index = m_AutoCircTask.numTasks;

    if(index >= m_AutoCircTask.maxTasks)
    {
        return NULL;
    }

    AutoCircGenericTask* pGeneric = &m_TaskArray[index];
    memset((void*)pGeneric, 0, sizeof(AutoCircGenericTask));

    pGeneric->taskType = eAutoCircTaskTimeCodeWrite;

    if(pTCInOut1 != NULL)
    {
        pGeneric->u.timeCodeTask.TCInOut1 = *pTCInOut1;
    }
    else
    {
        pGeneric->u.timeCodeTask.TCInOut1.Low = 0xffffffff;
    }
    if(pTCInOut2 != NULL)
    {
        pGeneric->u.timeCodeTask.TCInOut2 = *pTCInOut2;
    }
    else
    {
        pGeneric->u.timeCodeTask.TCInOut2.Low = 0xffffffff;
    }
    if(pTCInOut3 != NULL)
    {
        pGeneric->u.timeCodeTask.TCInOut3 = *pTCInOut3;
    }
    else
    {
        pGeneric->u.timeCodeTask.TCInOut3.Low = 0xffffffff;
    }
    if(pTCInOut4 != NULL)
    {
        pGeneric->u.timeCodeTask.TCInOut4 = *pTCInOut4;
    }
    else
    {
        pGeneric->u.timeCodeTask.TCInOut4.Low = 0xffffffff;
    }
    if(pTCInOut5 != NULL)
    {
        pGeneric->u.timeCodeTask.TCInOut5 = *pTCInOut5;
    }
    else
    {
        pGeneric->u.timeCodeTask.TCInOut5.Low = 0xffffffff;
    }
    if(pTCInOut6 != NULL)
    {
        pGeneric->u.timeCodeTask.TCInOut6 = *pTCInOut6;
    }
    else
    {
        pGeneric->u.timeCodeTask.TCInOut6.Low = 0xffffffff;
    }
    if(pTCInOut7 != NULL)
    {
        pGeneric->u.timeCodeTask.TCInOut7 = *pTCInOut7;
    }
    else
    {
        pGeneric->u.timeCodeTask.TCInOut7.Low = 0xffffffff;
    }
    if(pTCInOut8 != NULL)
    {
        pGeneric->u.timeCodeTask.TCInOut8 = *pTCInOut8;
    }
    else
    {
        pGeneric->u.timeCodeTask.TCInOut8.Low = 0xffffffff;
    }
    if(pLTCEmbedded != NULL)
    {
        pGeneric->u.timeCodeTask.LTCEmbedded = *pLTCEmbedded;
    }
    else
    {
        pGeneric->u.timeCodeTask.LTCEmbedded.Low = 0xffffffff;
    }
    if(pLTCAnalog != NULL)
    {
        pGeneric->u.timeCodeTask.LTCAnalog = *pLTCAnalog;
    }
    else
    {
        pGeneric->u.timeCodeTask.LTCAnalog.Low = 0xffffffff;
    }
    if(pLTCEmbedded2 != NULL)
    {
        pGeneric->u.timeCodeTask.LTCEmbedded2 = *pLTCEmbedded2;
    }
    else
    {
        pGeneric->u.timeCodeTask.LTCEmbedded2.Low = 0xffffffff;
    }
    if(pLTCAnalog2 != NULL)
    {
        pGeneric->u.timeCodeTask.LTCAnalog2 = *pLTCAnalog2;
    }
    else
    {
        pGeneric->u.timeCodeTask.LTCAnalog2.Low = 0xffffffff;
    }

    index++;
    m_AutoCircTask.numTasks = index;

    return pGeneric;
}

AutoCircGenericTask* CNTV2Task::AddTimeCodeReadTask()
{
    ULWord index = m_AutoCircTask.numTasks;

    if(index >= m_AutoCircTask.maxTasks)
    {
        return NULL;
    }

    AutoCircGenericTask* pGeneric = &m_TaskArray[index];
    memset((void*)pGeneric, 0, sizeof(AutoCircGenericTask));

    pGeneric->taskType = eAutoCircTaskTimeCodeRead;

    index++;
    m_AutoCircTask.numTasks = index;

    return pGeneric;
}

AutoCircGenericTask* CNTV2Task::GetTask(ULWord index)
{
    if(index >= m_AutoCircTask.numTasks)
    {
        return NULL;
    }

    return &m_TaskArray[index];
}


const AutoCircGenericTask & CNTV2Task::GetTask (const ULWord inIndex) const
{
    if (inIndex >= m_AutoCircTask.numTasks)
    {
        static AutoCircGenericTask  nullTask;
        ::memset ((void*)&nullTask, 0, sizeof (nullTask));
        return nullTask;
    }
    else
        return m_TaskArray [inIndex];
}


ULWord CNTV2Task::GetNumTasks (void) const
{
    return m_AutoCircTask.numTasks;
}

ULWord CNTV2Task::GetMaxTasks (void) const
{
    return m_AutoCircTask.maxTasks;
}

PAUTOCIRCULATE_TASK_STRUCT CNTV2Task::GetTaskStruct()
{
    return &m_AutoCircTask;
}

static const string AutoCircTaskTypeToString (const AutoCircTaskType inTaskType)
{
    switch (inTaskType)
    {
        case eAutoCircTaskNone:             return "<none>";
        case eAutoCircTaskRegisterWrite:    return "RegWrite";
        case eAutoCircTaskRegisterRead:     return "RegRead";
        case eAutoCircTaskTimeCodeWrite:    return "TCWrite";
        case eAutoCircTaskTimeCodeRead:     return "TCRead";
        case MAX_NUM_AutoCircTaskTypes:     break;
    }
    return "";
}


ostream & operator << (ostream & inOutStream, const AutoCircRegisterTask & inObj)
{
    return inOutStream  << "reg=" << inObj.regNum << ", mask=0x" << hex << setw (8) << setfill ('0') << inObj.mask << dec
                        << ", shift=" << inObj.shift << ", value=0x" << hex << setw (8) << setfill ('0') << inObj.value << dec;
}


ostream & operator << (ostream & inOutStream, const AutoCircTimeCodeTask & inObj)
{
    return inOutStream  << "    TCInOut1: " << inObj.TCInOut1 << endl
                        << "    TCInOut2: " << inObj.TCInOut2 << endl
                        << "    TCInOut3: " << inObj.TCInOut3 << endl
                        << "    TCInOut4: " << inObj.TCInOut4 << endl
                        << "    TCInOut5: " << inObj.TCInOut5 << endl
                        << "    TCInOut6: " << inObj.TCInOut6 << endl
                        << "    TCInOut7: " << inObj.TCInOut7 << endl
                        << "    TCInOut8: " << inObj.TCInOut8 << endl
                        << " LTCEmbedded: " << inObj.LTCEmbedded << endl
                        << "LTCEmbedded2: " << inObj.LTCEmbedded2 << endl
                        << "LTCEmbedded3: " << inObj.LTCEmbedded3 << endl
                        << "LTCEmbedded4: " << inObj.LTCEmbedded4 << endl
                        << "LTCEmbedded5: " << inObj.LTCEmbedded5 << endl
                        << "LTCEmbedded6: " << inObj.LTCEmbedded6 << endl
                        << "LTCEmbedded7: " << inObj.LTCEmbedded7 << endl
                        << "LTCEmbedded8: " << inObj.LTCEmbedded8 << endl
                        << "   LTCAnalog: " << inObj.LTCAnalog << endl
                        << "  LTCAnalog2: " << inObj.LTCAnalog2;
}


ostream & operator << (ostream & inOutStream, const AutoCircGenericTask & inObj)
{
    inOutStream << ::AutoCircTaskTypeToString (inObj.taskType);
    if (NTV2_IS_REGISTER_TASK (inObj.taskType))
        inOutStream << ": " << inObj.u.registerTask;
    else if (NTV2_IS_TIMECODE_TASK (inObj.taskType))
        inOutStream << ":" << endl << inObj.u.timeCodeTask;
    return inOutStream;
}


ostream & operator << (ostream & inOutStream, const CNTV2Task & inObj)
{
    const ULWord    nTasks  (inObj.GetNumTasks ());
    inOutStream << nTasks << " task(s):"    << endl;
    for (ULWord num (0);  num < nTasks;  num++)
    {
        const AutoCircGenericTask &     task (inObj.GetTask (num));
        inOutStream << "[" << num << "] " << task << endl;
    }
    return inOutStream;
}


bool CNTV2Task::InitTaskArray(AutoCircGenericTask* pTaskArray, ULWord numTasks)
{
    if(pTaskArray == NULL)
    {
        return false;
    }

    memset((void*)pTaskArray, 0, numTasks * sizeof(AutoCircGenericTask));

    return true;
}

ULWord CNTV2Task::CopyTaskArray(AutoCircGenericTask* pDstArray, ULWord dstSize, ULWord dstMax,
                              const AutoCircGenericTask* pSrcArray, ULWord srcSize, ULWord srcNum)
{
    ULWord i;

    // copy src to dst with support for changes in sizeof(AutoCircGenericTask)

    if((pSrcArray == NULL) || (pDstArray == NULL))
    {
        return false;
    }

    ULWord transferSize = srcSize;
    if(transferSize > dstSize)
    {
        transferSize = dstSize;
    }

    ULWord transferNum = srcNum;
    if(transferNum > dstMax)
    {
        transferNum = dstMax;
    }

    UByte* pSrc = (UByte*)pSrcArray;
    UByte* pDst = (UByte*)pDstArray;

    for(i = 0; i < transferNum; i++)
    {
        memcpy(pDst, pSrc, transferSize);
        pSrc += srcSize;
        pDst += dstSize;
    }

    return transferNum;
}

CNTV2Task& CNTV2Task::operator= (const CNTV2Task& other)
{
    InitTaskArray(m_TaskArray, AUTOCIRCULATE_TASK_MAX_TASKS);

    m_AutoCircTask.numTasks = CopyTaskArray(m_TaskArray, m_AutoCircTask.taskSize, m_AutoCircTask.maxTasks,
                                            other.m_TaskArray, other.m_AutoCircTask.taskSize, other.m_AutoCircTask.numTasks);

    return *this;
}