HEADER

#include "GENERICVideoSubscriber.h"

extern "C" {
#include <libavutil/display.h>
}
#include <accel.h>
#include <pluglog.h>
#include <frameUtils.h>

const std::string TAG = "GENERIC";
const char sep = separator();

namespace jami {

GENERICVideoSubscriber::GENERICVideoSubscriber(const std::string& dataPath)
    : path_ {dataPath}
{}

GENERICVideoSubscriber::~GENERICVideoSubscriber()
{
    std::ostringstream oss;
    oss << "~GENERICMediaProcessor" << std::endl;
    Plog::log(Plog::LogPriority::INFO, TAG, oss.str());
}

void
GENERICVideoSubscriber::update(jami::Observable<AVFrame*>*, AVFrame* const& iFrame)
{
    if (!iFrame)
        return;
    AVFrame* pluginFrame = const_cast<AVFrame*>(iFrame);

    //======================================================================================
    // GET FRAME ROTATION
    AVFrameSideData* side_data = av_frame_get_side_data(iFrame, AV_FRAME_DATA_DISPLAYMATRIX);

    int angle {0};
    if (side_data) {
        auto matrix_rotation = reinterpret_cast<int32_t*>(side_data->data);
        angle = static_cast<int>(av_display_rotation_get(matrix_rotation));
    }

    //======================================================================================
    // GET RAW FRAME
    // Use a non-const Frame
    // Convert input frame to RGB
    int inputHeight = pluginFrame->height;
    int inputWidth = pluginFrame->width;
    AVFrame* temp = transferToMainMemory(pluginFrame, AV_PIX_FMT_NV12);
    AVFrame* bgrFrame = scaler.convertFormat(temp, AV_PIX_FMT_RGB24);
    av_frame_unref(temp);
    av_frame_free(&temp);
    if (!bgrFrame)
        return;
    // transferToMainMemory USED TO COPY FRAME TO MAIN MEMORY IF HW ACCEL IS ENABLED
    // NOT NEEDED TO BE USED IF ALL YOUR PROCESS WILL BE DONE WITHIN A
    // HW ACCEL PLATFORM

    if (firstRun) {
        // IMPLEMENT CODE TO CONFIGURE
        // VARIABLES UPON FIRST RUN
        firstRun = false;
    }

    // IMPLEMENT PROCESS

    //======================================================================================
    // REPLACE AVFRAME DATA WITH FRAME DATA
    if (bgrFrame->data[0]) {
        uint8_t* frameData = bgrFrame->data[0];
        if (angle == 90 || angle == -90) {
            std::memmove(frameData,
                         frameData, // PUT HERE YOUR PROCESSED FRAME VARIABLE DATA!
                         static_cast<size_t>(pluginFrame->width * pluginFrame->height * 3)
                             * sizeof(uint8_t));
        }

        av_frame_copy_props(bgrFrame, pluginFrame);
        moveFrom(pluginFrame, bgrFrame);
    }
    av_frame_unref(bgrFrame);
    av_frame_free(&bgrFrame);
}

void
GENERICVideoSubscriber::attached(jami::Observable<AVFrame*>* observable)
{
    std::ostringstream oss;
    oss << "::Attached ! " << std::endl;
    Plog::log(Plog::LogPriority::INFO, TAG, oss.str());
    observable_ = observable;
}

void
GENERICVideoSubscriber::detached(jami::Observable<AVFrame*>*)
{
    firstRun = true;
    observable_ = nullptr;
    std::ostringstream oss;
    oss << "::Detached()" << std::endl;
    Plog::log(Plog::LogPriority::INFO, TAG, oss.str());
}

void
GENERICVideoSubscriber::detach()
{
    if (observable_) {
        firstRun = true;
        std::ostringstream oss;
        oss << "::Calling detach()" << std::endl;
        Plog::log(Plog::LogPriority::INFO, TAG, oss.str());
        observable_->detach(this);
    }
}
} // namespace jami