MpegStreamer.cpp

#include "stdafx.h"

#define NO_IMPORT_ARRAY
#define PY_ARRAY_UNIQUE_SYMBOL MPEGARRAY_API
#include <numpy/arrayobject.h>
#include "MpegCoder.h"
#include "MpegStreamer.h"

cmpc::CMpegClient::CMpegClient(void) :
    videoPath(), width(0), height(0), widthDst(0), heightDst(0),
    PPixelFormat(AVPixelFormat::AV_PIX_FMT_NONE), PFormatCtx(nullptr), PCodecCtx(nullptr),
    PVideoStream(nullptr), frame(nullptr), PVideoStreamIDX(0), PVideoFrameCount(0),
    buffer(), PswsCtx(nullptr), cache_size(0), read_size(0),
    frameRate({ 0,0 }), read_handle(), read_check(), info_lock(), reading(false),
    _str_codec(), _duration(0), _predictFrameNum(0), nthread(0), refcount(1) {
}
cmpc::CMpegClient::~CMpegClient(void) {
    clear();
}
cmpc::CMpegClient::CMpegClient(CMpegClient&& ref) noexcept :
    videoPath(std::move(ref.videoPath)), width(ref.width), height(ref.height),
    widthDst(ref.widthDst), heightDst(ref.heightDst),
    PPixelFormat(ref.PPixelFormat), PFormatCtx(ref.PFormatCtx), PCodecCtx(ref.PCodecCtx),
    PVideoStream(ref.PVideoStream), frame(ref.frame),
    PVideoStreamIDX(ref.PVideoStreamIDX), PVideoFrameCount(ref.PVideoFrameCount),
    buffer(std::move(ref.buffer)), PswsCtx(ref.PswsCtx),
    cache_size(ref.cache_size), read_size(ref.read_size),
    frameRate(ref.frameRate), read_handle(std::move(std::thread())), read_check(), info_lock(),
    reading(ref.reading), _str_codec(std::move(ref._str_codec)), _duration(ref._duration),
    _predictFrameNum(ref._predictFrameNum), nthread(ref.nthread), refcount(ref.refcount) {
    ref.PFormatCtx = nullptr;
    ref.PCodecCtx = nullptr;
    ref.PVideoStream = nullptr;
    ref.frame = nullptr;
    ref.PswsCtx = nullptr;
}
cmpc::CMpegClient& cmpc::CMpegClient::operator=(CMpegClient&& ref) noexcept {
    if (this != &ref) {
        videoPath = std::move(ref.videoPath);
        width = ref.width;
        height = ref.height;
        widthDst = ref.widthDst;
        heightDst = ref.heightDst;
        PPixelFormat = ref.PPixelFormat;
        PVideoStreamIDX = ref.PVideoStreamIDX;
        PVideoFrameCount = ref.PVideoFrameCount;
        cache_size = ref.cache_size;
        read_size = ref.read_size;
        frameRate = ref.frameRate;
        reading = ref.reading;
        _duration = ref._duration;
        _predictFrameNum = ref._predictFrameNum;
        refcount = ref.refcount;
        PFormatCtx = ref.PFormatCtx;
        PCodecCtx = ref.PCodecCtx;
        PVideoStream = ref.PVideoStream;
        frame = ref.frame;
        PswsCtx = ref.PswsCtx;
        buffer = std::move(ref.buffer);
        read_handle = std::move(std::thread());
        nthread = ref.nthread;
        ref.PFormatCtx = nullptr;
        ref.PCodecCtx = nullptr;
        ref.PVideoStream = nullptr;
        ref.frame = nullptr;
        ref.PswsCtx = nullptr;
    }
    return *this;
}

void cmpc::CMpegClient::meta_protected_clear(void) {
    auto protectWidth = widthDst;
    auto protectHeight = heightDst;
    auto protectCacheSize = cache_size;
    auto protectReadSize = read_size;
    auto protectFrameRate = frameRate;
    auto protectNthread = nthread;
    clear();
    widthDst = protectWidth;
    heightDst = protectHeight;
    cache_size = protectCacheSize;
    read_size = protectReadSize;
    frameRate = protectFrameRate;
    nthread = protectNthread;
}

void cmpc::CMpegClient::clear(void) {
    if (read_handle.joinable()) {
        read_check.lock();
        reading = false;
        read_check.unlock();
        read_handle.join();
        //std::terminate();
        read_handle = std::move(std::thread());
    }
    else {
        read_handle = std::move(std::thread());
    }
    width = height = 0;
    widthDst = heightDst = 0;
    PPixelFormat = AVPixelFormat::AV_PIX_FMT_NONE;
    PVideoStreamIDX = -1;
    PVideoFrameCount = 0;
    _duration = 0;
    _predictFrameNum = 0;
    _str_codec.clear();
    //videoPath.clear();
    buffer.clear();
    cache_size = 0;
    read_size = 0;
    frameRate = _setAVRational(0, 0);
    read_check.lock();
    read_check.unlock();
    info_lock.lock();
    info_lock.unlock();
    nthread = 0;
    PVideoStream = nullptr;
    if (frame) {
        av_frame_free(&frame);
        frame = nullptr;
    }
    if (PswsCtx) {
        sws_freeContext(PswsCtx);
        PswsCtx = nullptr;
    }
    if (PCodecCtx) {
        avcodec_free_context(&PCodecCtx);
        PCodecCtx = nullptr;
    }
    if (PFormatCtx) {
        avformat_close_input(&PFormatCtx);
        PFormatCtx = nullptr;
    }
    refcount = 1;
}

int cmpc::CMpegClient::_open_codec_context(int& stream_idx, AVCodecContext*& dec_ctx, \
    AVFormatContext* PFormatCtx, enum cmpc::AVMediaType type) { // Search the correct decoder, and make the configurations.
    int ret;

    //search video stream
    ret = av_find_best_stream(PFormatCtx, type, -1, -1, nullptr, 0);
    if (ret < 0) {
        cerr << "Could not find " << av_get_media_type_string(type) << \
            " stream in input address: '" << videoPath << "'" << endl;
        return ret;
    }
    else {
        auto stream_index = ret;
        auto st = PFormatCtx->streams[stream_index];  // The AVStream object.

        /* find decoder for the stream */
        auto dec = avcodec_find_decoder(st->codecpar->codec_id);  // Decoder (AVCodec).
        if (!dec) {
            cerr << "Failed to find " << av_get_media_type_string(type) << " codec" << endl;
            return AVERROR(EINVAL);
        }
        _str_codec.assign(dec->name);

        /* Allocate a codec context for the decoder / Add this to allocate the context by codec */
        auto dec_ctx_ = avcodec_alloc_context3(dec);  // Decoder context (AVCodecContext).
        if (!dec_ctx_) {
            cerr << "Failed to allocate the " << av_get_media_type_string(type) << " codec context" << endl;
            return AVERROR(ENOMEM);
        }

        if (nthread > 0) {
            dec_ctx_->thread_count = nthread;
        }

        /* Copy codec parameters from input stream to output codec context */
        if ((ret = avcodec_parameters_to_context(dec_ctx_, st->codecpar)) < 0) {
            cerr << "Failed to copy " << av_get_media_type_string(type) << \
                " codec parameters to decoder context" << endl;
            return ret;
        }

        /* Init the decoders, with or without reference counting */
        AVDictionary* opts = nullptr;  // The uninitialized argument dictionary.
        av_dict_set(&opts, "refcounted_frames", refcount ? "1" : "0", 0);
        if ((ret = avcodec_open2(dec_ctx_, dec, &opts)) < 0) {
            cerr << "Failed to open " << av_get_media_type_string(type) << " codec" << endl;
            return ret;
        }
        dec_ctx = dec_ctx_;
        stream_idx = stream_index;
    }
    return 0;
}

bool cmpc::CMpegClient::__setup_check() const {
    if (cache_size > 0 && read_size > 0 && frameRate.den > 0 && frameRate.num > 0 && (!read_handle.joinable())) {
        return true;
    }
    else {
        return false;
    }
}

bool cmpc::CMpegClient::FFmpegSetup(string inVideoPath) {
    videoPath.assign(inVideoPath);
    return FFmpegSetup();
}

bool cmpc::CMpegClient::FFmpegSetup() {
    if (!__setup_check()) {
        cerr << "Have not get necessary and correct configurations, so FFmpegSetup() should not be called." << endl;
        return false;
    }
    meta_protected_clear();

    /* open Stream: register all formats and codecs */
    if (avformat_open_input(&PFormatCtx, videoPath.c_str(), nullptr, nullptr) < 0) {
        cerr << "Could not open source address " << videoPath << endl;
        clear();
        return false;
    } // For example, "rtsp://localhost:8554/h264.3gp"

    /* retrieve stream information */
    if (avformat_find_stream_info(PFormatCtx, nullptr) < 0) {
        cerr << "Could not find stream information" << endl;
        clear();
        return false;
    }
    AVRational time_base, frame_base;
    if (_open_codec_context(PVideoStreamIDX, PCodecCtx, PFormatCtx, AVMEDIA_TYPE_VIDEO) >= 0) {
        PVideoStream = PFormatCtx->streams[PVideoStreamIDX];
        time_base = PVideoStream->time_base;
        frame_base = PVideoStream->avg_frame_rate;

        /* allocate image where the decoded image will be put */
        width = PCodecCtx->width;
        height = PCodecCtx->height;
        if (widthDst <= 0) {
            widthDst = width;
        }
        if (heightDst <= 0) {
            heightDst = height;
        }
        PPixelFormat = PCodecCtx->pix_fmt;
        _duration = static_cast<double>(PVideoStream->duration) / static_cast<double>(time_base.den) * static_cast<double>(time_base.num);
        _predictFrameNum = av_rescale(static_cast<int64_t>(_duration * 0xFFFF), frame_base.num, frame_base.den) / 0xFFFF;
    }
    else {
        cerr << "Could not get codec context from the stream, aborting" << endl;
        clear();
        return false;
    }

    /* dump input information to stderr */
    if (__dumpControl > 1) {
        av_dump_format(PFormatCtx, 0, videoPath.c_str(), 0);
    }

    if (!PVideoStream) { // Check whether the video stream is correctly opened.
        cerr << "Could not find audio or video stream in the network, aborting" << endl;
        clear();
        return false;
    }

    if (width == 0 || height == 0) {
        cerr << "Could not get enough meta-data in the network, aborting" << endl;
        clear();
        return false;
    }

    PswsCtx = sws_getContext(width, height, PCodecCtx->pix_fmt, widthDst, heightDst, AV_PIX_FMT_RGB24,
        SCALE_FLAGS, nullptr, nullptr, nullptr);

    buffer.set(cache_size, width, height, widthDst, heightDst);
    buffer.set_timer(frameRate, time_base);
    if (!buffer.reset_memory()) { // Check whether the buffer is allocated correctly.
        cerr << "Could not allocate the memory of frame buffer list." << endl;
        clear();
        return false;
    }

    read_check.lock();
    reading = true;
    read_check.unlock();
    return true;
}

void cmpc::CMpegClient::dumpFormat() {
    if ((!videoPath.empty()) && PFormatCtx) {
        av_dump_format(PFormatCtx, 0, videoPath.c_str(), 0);
    }
    else {
        cerr << "Still need to FFmpegSetup()" << endl;
    }
}

void cmpc::CMpegClient::resetPath(string inVideoPath) {
    videoPath.assign(inVideoPath);
}

cmpc::AVRational cmpc::CMpegClient::_setAVRational(int num, int den) {
    AVRational res;
    res.num = num; res.den = den;
    return res;
}

int cmpc::CMpegClient::__save_frame(AVFrame*& frame, AVPacket*& pkt, bool& got_frame, int cached) {
    int ret = 0;
    int decoded = pkt->size;

    got_frame = false;

    if (pkt->stream_index == PVideoStreamIDX) {
        /* decode video frame */
        ret = __avcodec_decode_video2(PCodecCtx, frame, got_frame, pkt);
        if (ret < 0) {
            cout << "Error decoding video frame (" << av_err2str(ret) << ")" << endl;
            return ret;
        }

        if (got_frame) {

            if (frame->width != width || frame->height != height ||
                frame->format != PPixelFormat) {
                /* To handle this change, one could call av_image_alloc again and
                * decode the following frames into another rawvideo file. */
                cout << "Error: Width, height and pixel format have to be "
                    "constant in a rawvideo file, but the width, height or "
                    "pixel format of the input video changed:\n"
                    "old: width = " << width << ", height = " << height << ", format = "
                    << av_get_pix_fmt_name(PPixelFormat) << endl <<
                    "new: width = " << frame->width << ", height = " << frame->height << ", format = "
                    << av_get_pix_fmt_name(static_cast<AVPixelFormat>(frame->format)) << endl;
                return -1;
            }

            info_lock.lock();
            PVideoFrameCount++;
            info_lock.unlock();
            if (__dumpControl > 0) {
                std::ostringstream str_data;
                str_data << "video_frame" << (cached ? "(cached)" : "") << " n:" << PVideoFrameCount <<
                    " coded_n:" << frame->coded_picture_number << endl;
                auto str_data_s = str_data.str();
                av_log(nullptr, AV_LOG_INFO, "%s", str_data_s.c_str());
            }

            /* copy decoded frame to destination buffer:
            * this is required since rawvideo expects non aligned data */

            buffer.write(PswsCtx, frame);
        }
    }

    /* If we use frame reference counting, we own the data and need
    * to de-reference it when we don't use it anymore */

    if (got_frame && refcount)
        av_frame_unref(frame);

    return decoded;
}

void cmpc::CMpegClient::__client_holder() {
    int ret;
    bool got_frame;
    if (frame) {
        cerr << "Current frame is occupied, could not start a new client." << endl;
        return;
    }
    frame = av_frame_alloc();
    auto pkt = av_packet_alloc();
    if (!frame) {
        cerr << "Could not allocate frame" << endl;
        ret = AVERROR(ENOMEM);
        return;
    }
    /* initialize packet, set data to NULL, let the demuxer fill it */
    if (PVideoStream && (__dumpControl > 0)) {
        std::ostringstream str_data;
        str_data << "Demuxing video from address '" << videoPath << "' into Python-List" << endl;
        auto str_data_s = str_data.str();
        av_log(nullptr, AV_LOG_INFO, "%s", str_data_s.c_str());
    }

    /* Reset the contex to remove the flushed state. */
    avcodec_flush_buffers(PCodecCtx);

    /* read frames from the file */
    info_lock.lock();
    PVideoFrameCount = 0;
    info_lock.unlock();

    //start reading packets from stream and write them to file
    av_read_play(PFormatCtx);    //play RTSP

    auto temp_pkt = av_packet_alloc();
    while (av_read_frame(PFormatCtx, pkt) >= 0) {
        //cout << "[Test - " << pkt.size << " ]" << endl;
        av_packet_ref(temp_pkt, pkt);
        do {
            ret = __save_frame(frame, temp_pkt, got_frame, 0);
            if (ret < 0)
                break;
            temp_pkt->data += ret;
            temp_pkt->size -= ret;
        } while (temp_pkt->size > 0);
        /* flush cached frames */
        av_packet_unref(pkt);
        av_packet_unref(temp_pkt);
        read_check.lock();
        if (!reading) {
            read_check.unlock();
            break;
        }
        else {
            read_check.unlock();
        }
    }
    av_packet_free(&temp_pkt);

    do {
        __save_frame(frame, pkt, got_frame, 1);
    } while (got_frame);

    //cout << "Demuxing succeeded." << endl;

    if (PVideoStream && (__dumpControl > 0)) {
        std::ostringstream str_data;
        str_data << "End of stream client." << endl;
        auto str_data_s = str_data.str();
        av_log(nullptr, AV_LOG_INFO, "%s", str_data_s.c_str());
    }

    if (frame) {
        av_frame_free(&frame);
        frame = nullptr;
    }
    if (pkt) {
        av_packet_free(&pkt);
    }

    read_check.lock();
    reading = false;
    read_check.unlock();
}

int cmpc::CMpegClient::__avcodec_decode_video2(AVCodecContext* avctx, AVFrame* frame, bool& got_frame, AVPacket* pkt) {
    int ret;

    got_frame = false;

    if (pkt) {
        ret = avcodec_send_packet(avctx, pkt);
        // In particular, we don't expect AVERROR(EAGAIN), because we read all
        // decoded frames with avcodec_receive_frame() until done.
        if (ret < 0) {
            //cout << ret << ", " << AVERROR(EAGAIN) << ", " << AVERROR_EOF << endl;
            return ret == AVERROR_EOF ? 0 : ret;
        }
    }

    ret = avcodec_receive_frame(avctx, frame);
    if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
        return ret;
    if (ret >= 0)
        got_frame = true;

    //cout << ret << ", " << AVERROR(EAGAIN) << ", " << AVERROR_EOF << endl;

    return 0;
}

PyObject* cmpc::CMpegClient::ExtractFrame() {
    return ExtractFrame(read_size);
}

PyObject* cmpc::CMpegClient::ExtractFrame(int64_t readsize) {
    if (readsize == 0 || readsize > cache_size) {
        cerr << "Read size of frames is out of range." << endl;
        return nullptr;
    }
    else if (frame == nullptr) {
        cerr << "Current frame object is empty, maybe the client has not been started." << endl;
        return nullptr;
    }
    buffer.freeze_write(readsize);
    auto res = buffer.read();
    if (res == nullptr) {
        cerr << "Unable to get frames from current buffer." << endl;
    }
    return res;
}

void cmpc::CMpegClient::setParameter(string keyword, void* ptr) {
    if (keyword.compare("widthDst") == 0) {
        auto ref = reinterpret_cast<int*>(ptr);
        widthDst = *ref;
    }
    else if (keyword.compare("heightDst") == 0) {
        auto ref = reinterpret_cast<int*>(ptr);
        heightDst = *ref;
    }
    else if (keyword.compare("cacheSize") == 0) {
        auto ref = reinterpret_cast<int64_t*>(ptr);
        cache_size = *ref;
    }
    else if (keyword.compare("readSize") == 0) {
        auto ref = reinterpret_cast<int64_t*>(ptr);
        read_size = *ref;
    }
    else if (keyword.compare("dstFrameRate") == 0) {
        PyObject* ref = reinterpret_cast<PyObject*>(ptr);
        auto refObj = PyTuple_GetItem(ref, 0);
        int num = static_cast<int>(PyLong_AsLong(refObj));
        refObj = PyTuple_GetItem(ref, 1);
        int den = static_cast<int>(PyLong_AsLong(refObj));
        frameRate = _setAVRational(num, den);
    }
    else if (keyword.compare("nthread") == 0) {
        auto ref = reinterpret_cast<int*>(ptr);
        if (PCodecCtx) {
            PCodecCtx->thread_count = *ref;
        }
        nthread = *ref;
    }
}

PyObject* cmpc::CMpegClient::getParameter(string keyword) {
    if (keyword.compare("videoAddress") == 0) {
        return PyUnicode_DecodeFSDefaultAndSize(videoPath.c_str(), static_cast<Py_ssize_t>(videoPath.size()));
    }
    else if (keyword.compare("width") == 0) {
        return Py_BuildValue("i", width);
    }
    else if (keyword.compare("height") == 0) {
        return Py_BuildValue("i", height);
    }
    else if (keyword.compare("frameCount") == 0) {
        info_lock.lock();
        auto value = Py_BuildValue("i", PVideoFrameCount);
        info_lock.unlock();
        return value;
    }
    else if (keyword.compare("coderName") == 0) {
        return PyUnicode_DecodeFSDefaultAndSize(_str_codec.c_str(), static_cast<Py_ssize_t>(_str_codec.size()));
    }
    else if (keyword.compare("duration") == 0) {
        return Py_BuildValue("d", _duration);
    }
    else if (keyword.compare("estFrameNum") == 0) {
        return Py_BuildValue("L", _predictFrameNum);
    }
    else if (keyword.compare("srcFrameRate") == 0) {
        if (!PVideoStream) {
            return Py_BuildValue("d", 0.0);
        }
        auto frame_base = PVideoStream->avg_frame_rate;
        double srcFrameRate = static_cast<double>(frame_base.num) / static_cast<double>(frame_base.den);
        return Py_BuildValue("d", srcFrameRate);
    }
    else if (keyword.compare("nthread") == 0) {
        if (PCodecCtx) {
            return Py_BuildValue("i", PCodecCtx->thread_count);
        }
        else {
            return Py_BuildValue("i", nthread);
        }
    }
    else {
        Py_RETURN_NONE;
    }
}

PyObject* cmpc::CMpegClient::getParameter() {
    auto res = PyDict_New();
    string key;
    PyObject* val = nullptr;
    // Fill the values.
    key.assign("videoAddress");
    val = Py_BuildValue("y", videoPath.c_str());
    PyDict_SetItemString(res, key.c_str(), val);
    Py_DECREF(val);
    key.assign("codecName");
    val = Py_BuildValue("y", _str_codec.c_str());
    PyDict_SetItemString(res, key.c_str(), val);
    Py_DECREF(val);
    if (PCodecCtx) {
        key.assign("bitRate");
        val = Py_BuildValue("L", PCodecCtx->bit_rate);
        PyDict_SetItemString(res, key.c_str(), val);
        Py_DECREF(val);
        key.assign("GOPSize");
        val = Py_BuildValue("i", PCodecCtx->gop_size);
        PyDict_SetItemString(res, key.c_str(), val);
        Py_DECREF(val);
        key.assign("maxBframe");
        val = Py_BuildValue("i", PCodecCtx->max_b_frames);
        PyDict_SetItemString(res, key.c_str(), val);
        Py_DECREF(val);
        key.assign("nthread");
        val = Py_BuildValue("i", PCodecCtx->thread_count);
        PyDict_SetItemString(res, key.c_str(), val);
        Py_DECREF(val);
    }
    else {
        key.assign("nthread");
        val = Py_BuildValue("i", nthread);
        PyDict_SetItemString(res, key.c_str(), val);
        Py_DECREF(val);
    }
    if (widthDst > 0) {
        key.assign("widthDst");
        val = Py_BuildValue("i", widthDst);
        PyDict_SetItemString(res, key.c_str(), val);
        Py_DECREF(val);
    }
    if (heightDst > 0) {
        key.assign("heightDst");
        val = Py_BuildValue("i", heightDst);
        PyDict_SetItemString(res, key.c_str(), val);
        Py_DECREF(val);
    }
    key.assign("width");
    val = Py_BuildValue("i", width);
    PyDict_SetItemString(res, key.c_str(), val);
    Py_DECREF(val);
    key.assign("height");
    val = Py_BuildValue("i", height);
    PyDict_SetItemString(res, key.c_str(), val);
    Py_DECREF(val);
    if (PVideoStream) {
        key.assign("frameRate");
        auto& frame_rate = PVideoStream->avg_frame_rate;
        val = Py_BuildValue("(ii)", frame_rate.num, frame_rate.den);
        PyDict_SetItemString(res, key.c_str(), val);
        Py_DECREF(val);
    }
    return res;
}

bool cmpc::CMpegClient::start() {
    if (reading && (frame == nullptr)) {
        read_handle = std::move(std::thread(std::mem_fn(&CMpegClient::__client_holder), std::ref(*this)));
        return true;
    }
    return false;
}
void cmpc::CMpegClient::terminate() {
    read_check.lock();
    auto protectReading = reading;
    read_check.unlock();
    if (read_handle.joinable()) {
        read_check.lock();
        reading = false;
        read_check.unlock();
        read_handle.join();
        //std::terminate();
        read_handle = std::move(std::thread());
    }
    else {
        read_handle = std::move(std::thread());
    }
    info_lock.lock();
    info_lock.unlock();
    read_check.lock();
    reading = protectReading;
    read_check.unlock();
    if (frame) {
        av_frame_free(&frame);
    }
}
ostream& cmpc::operator<<(ostream& out, cmpc::CMpegClient& self_class) {
    double dstFrameRate;
    out << std::setw(1) << "/";
    out << std::setfill('*') << std::setw(44) << "" << std::setfill(' ') << endl;
    out << std::setw(1) << " * Packed FFmpeg Client - Y. Jin V" << MPEGCODER_CURRENT_VERSION << endl;
    out << " " << std::setfill('*') << std::setw(44) << "" << std::setfill(' ') << endl;
    out << std::setiosflags(std::ios::left) << std::setw(25) << " * VideoAddress: " \
        << self_class.videoPath << endl;
    out << std::setiosflags(std::ios::left) << std::setw(25) << " * (Width, Height): " \
        << self_class.width << ", " << self_class.height << endl;
    if (self_class.widthDst > 0 && self_class.heightDst > 0) {
        out << std::setiosflags(std::ios::left) << std::setw(25) << " * (WidthDst, HeightDst): " \
            << self_class.widthDst << ", " << self_class.heightDst << endl;
    }
    out << std::setiosflags(std::ios::left) << std::setw(25) << " * Deccoder: " \
        << self_class._str_codec << endl;
    if (self_class.PCodecCtx) {
        out << std::setiosflags(std::ios::left) << std::setw(25) << " * Thread number: " \
            << self_class.PCodecCtx->thread_count << endl;
    }
    else {
        out << std::setiosflags(std::ios::left) << std::setw(25) << " * Thread number (P): " \
            << self_class.nthread << endl;
    }
    out << std::setiosflags(std::ios::left) << std::setw(25) << " * Duration: " \
        << self_class._duration << " [s]" << endl;
    out << std::setiosflags(std::ios::left) << std::setw(25) << " * Predicted FrameNum: " \
        << self_class._predictFrameNum << endl;
    out << std::setiosflags(std::ios::left) << std::setw(25) << " * Read/Cache size: " \
        << self_class.read_size << "/" << self_class.cache_size << endl;
    if (self_class.PVideoStream) {
        auto frame_base = self_class.PVideoStream->avg_frame_rate;
        double srcFrameRate = static_cast<double>(frame_base.num) / static_cast<double>(frame_base.den);
        if (self_class.frameRate.den) {
            dstFrameRate = static_cast<double>(self_class.frameRate.num) / static_cast<double>(self_class.frameRate.den);
        }
        else {
            dstFrameRate = 0;
        }
        out << std::setiosflags(std::ios::left) << std::setw(25) << " * Dst./Src. frame rate: " \
            << std::setprecision(3) << dstFrameRate << "/" << srcFrameRate << std::setprecision(6) << endl;
    }
    else {
        if (self_class.frameRate.den) {
            dstFrameRate = static_cast<double>(self_class.frameRate.num) / static_cast<double>(self_class.frameRate.den);
        }
        else {
            dstFrameRate = 0;
        }
        out << std::setiosflags(std::ios::left) << std::setw(25) << " * Src. frame rate: " \
            << std::setprecision(3) << dstFrameRate << std::setprecision(6) << endl;
    }
    out << std::setw(1) << " */";
    return out;
}

cmpc::BufferList::BufferList(void) :
    _Buffer_pos(0), _Buffer_rpos(-1), _Buffer_size(0), __Read_size(0),
    next_pts(0), interval_pts(0), dst_width(0), dst_height(0),
    src_width(0), src_height(0), _Buffer_capacity(0),
    frameRGB(nullptr), _Buffer_List(nullptr) {
}
cmpc::BufferList::~BufferList(void) {
    if (_Buffer_List) {
        for (auto i = 0; i < _Buffer_size; i++) {
            if (_Buffer_List[i]) {
                av_free(_Buffer_List[i]);
                _Buffer_List[i] = nullptr;
            }
        }
        delete[]_Buffer_List;
        _Buffer_List = nullptr;
    }
    if (frameRGB) {
        av_frame_free(&frameRGB);
    }
}
cmpc::BufferList::BufferList(const BufferList& ref) :
    _Buffer_pos(ref._Buffer_pos), _Buffer_rpos(ref._Buffer_rpos), _Buffer_size(ref._Buffer_size),
    __Read_size(ref.__Read_size), next_pts(ref.next_pts), interval_pts(ref.interval_pts),
    dst_width(ref.dst_width), dst_height(ref.dst_height),
    src_width(ref.src_width), src_height(ref.src_height),
    _Buffer_capacity(ref._Buffer_capacity), frameRGB(ref.frameRGB), _Buffer_List(nullptr) {
    if (!(frameRGB = av_frame_alloc())) {
        cerr << "Could Allocate Temp Frame (RGB)" << endl;
        return;
    }
    _Buffer_List = new uint8_t * [_Buffer_size];
    memset(_Buffer_List, 0, _Buffer_size * sizeof(uint8_t*));
    if (_Buffer_capacity > 0) {
        for (auto i = 0; i < _Buffer_size; i++) {
            if (ref._Buffer_List[i] != nullptr) {
                _Buffer_List[i] = (uint8_t*)av_malloc(_Buffer_capacity * sizeof(uint8_t));
                memcpy(_Buffer_List[i], ref._Buffer_List[i], _Buffer_capacity * sizeof(uint8_t));
            }
        }
    }
}
cmpc::BufferList& cmpc::BufferList::operator=(const BufferList& ref) {
    if (this != &ref) {
        _Buffer_pos = ref._Buffer_pos;
        _Buffer_rpos = ref._Buffer_rpos;
        _Buffer_size = ref._Buffer_size;
        __Read_size = ref.__Read_size;
        next_pts = ref.next_pts;
        interval_pts = ref.interval_pts;
        dst_width = ref.dst_width;
        dst_height = ref.dst_height;
        src_width = ref.src_width;
        src_height = ref.src_height;
        _Buffer_capacity = ref._Buffer_capacity;
        if (!(frameRGB = av_frame_alloc())) {
            cerr << "Could Allocate Temp Frame (RGB)" << endl;
            return *this;
        }
        _Buffer_List = new uint8_t * [_Buffer_size];
        memset(_Buffer_List, 0, _Buffer_size * sizeof(uint8_t*));
        if (_Buffer_capacity > 0) {
            for (auto i = 0; i < _Buffer_size; i++) {
                if (ref._Buffer_List[i] != nullptr) {
                    _Buffer_List[i] = (uint8_t*)av_malloc(_Buffer_capacity * sizeof(uint8_t));
                    memcpy(_Buffer_List[i], ref._Buffer_List[i], _Buffer_capacity * sizeof(uint8_t));
                }
            }
        }
    }
    return *this;
}
cmpc::BufferList::BufferList(BufferList&& ref) noexcept :
    _Buffer_pos(ref._Buffer_pos), _Buffer_rpos(ref._Buffer_rpos), _Buffer_size(ref._Buffer_size),
    __Read_size(ref.__Read_size), next_pts(ref.next_pts), interval_pts(ref.interval_pts),
    dst_width(ref.dst_width), dst_height(ref.dst_height),
    src_width(ref.src_width), src_height(ref.src_height),
    _Buffer_capacity(ref._Buffer_capacity), frameRGB(ref.frameRGB), _Buffer_List(ref._Buffer_List) {
    ref._Buffer_List = nullptr;
    ref.frameRGB = nullptr;
}
cmpc::BufferList& cmpc::BufferList::operator=(BufferList&& ref) noexcept {
    if (this != &ref) {
        _Buffer_pos = ref._Buffer_pos;
        _Buffer_rpos = ref._Buffer_rpos;
        _Buffer_size = ref._Buffer_size;
        __Read_size = ref.__Read_size;
        interval_pts = ref.interval_pts;
        next_pts = ref.next_pts;
        dst_width = ref.dst_width;
        dst_height = ref.dst_height;
        src_width = ref.src_width;
        src_height = ref.src_height;
        _Buffer_capacity = ref._Buffer_capacity;
        _Buffer_List = ref._Buffer_List;
        frameRGB = ref.frameRGB;
        ref._Buffer_List = nullptr;
        ref.frameRGB = nullptr;
    }
    return *this;
}
void cmpc::BufferList::clear(void) {
    if (_Buffer_List) {
        for (auto i = 0; i < _Buffer_size; i++) {
            if (_Buffer_List[i]) {
                av_free(_Buffer_List[i]);
                _Buffer_List[i] = nullptr;
            }
        }
        delete[]_Buffer_List;
        _Buffer_List = nullptr;
    }
    _Buffer_pos = 0;
    _Buffer_rpos = -1;
    _Buffer_size = 0;
    __Read_size = 0;
    next_pts = 0;
    interval_pts = 0;
    src_width = 0;
    src_height = 0;
    dst_width = 0;
    dst_height = 0;
    if (frameRGB) {
        av_frame_free(&frameRGB);
    }
}
const int64_t cmpc::BufferList::size() const {
    return _Buffer_size;
}
void cmpc::BufferList::set(int64_t set_size, int width, int height, int widthDst, int heightDst) {
    _Buffer_size = set_size;
    if (widthDst != 0) {
        dst_width = widthDst;
    }
    else {
        dst_width = width;
    }
    if (heightDst != 0) {
        dst_height = heightDst;
    }
    else {
        dst_height = height;
    }
    src_width = width;
    src_height = height;
    _Buffer_capacity = av_image_get_buffer_size(AV_PIX_FMT_RGB24, dst_width, dst_height, 1);
}
void cmpc::BufferList::set_timer(AVRational targetFrameRate, AVRational timeBase) {
    interval_pts = av_rescale(av_rescale(1, timeBase.den, timeBase.num), targetFrameRate.den, targetFrameRate.num);
}
bool cmpc::BufferList::reset_memory() {
    if (!frameRGB) {
        if (!(frameRGB = av_frame_alloc())) {
            cerr << "Could Allocate Temp Frame (RGB)" << endl;
            return false;
        }
    }
    if (!_Buffer_List) {
        _Buffer_List = new uint8_t * [_Buffer_size];
        memset(_Buffer_List, 0, _Buffer_size * sizeof(uint8_t*));
    }
    for (auto i = 0; i < _Buffer_size; i++) {
        if (!_Buffer_List[i]) {
            _Buffer_List[i] = (uint8_t*)av_malloc(_Buffer_capacity * sizeof(uint8_t));
        }
        memset(_Buffer_List[i], 0, _Buffer_capacity * sizeof(uint8_t));
    }
    return true;
}
void cmpc::BufferList::freeze_write(int64_t read_size) {
    auto read_pos = _Buffer_pos - read_size;
    if (read_pos < 0) {
        read_pos += _Buffer_size;
    }
    _Buffer_rpos = read_pos;
    __Read_size = read_size;
}
bool cmpc::BufferList::write(SwsContext* PswsCtx, AVFrame* frame) {
    if (frame->pts < next_pts) {
        if (frame->pts > (next_pts - 2 * interval_pts)) {
            return false;
        }
        else {
            next_pts = frame->pts + interval_pts;
        }
    }
    else {
        if (next_pts > 0)
            next_pts += interval_pts;
        else
            next_pts = frame->pts;
    }
    if (_Buffer_pos == _Buffer_rpos) {
        return false;
    }
    av_image_fill_arrays(frameRGB->data, frameRGB->linesize, _Buffer_List[_Buffer_pos], AV_PIX_FMT_RGB24, dst_width, dst_height, 1);
    sws_scale(PswsCtx, frame->data, frame->linesize, 0, src_height, frameRGB->data, frameRGB->linesize);
    _Buffer_pos++;
    if (_Buffer_pos >= _Buffer_size)
        _Buffer_pos -= _Buffer_size;
    return true;
}
PyObject* cmpc::BufferList::read() {
    if (_Buffer_rpos < 0) {
        return nullptr;
    }
    auto _Buffer_rend = (_Buffer_rpos + __Read_size) % _Buffer_size;
    npy_intp dims[] = { __Read_size, dst_height, dst_width, 3 };
    auto newdata = new uint8_t[__Read_size * _Buffer_capacity];
    auto p = newdata;
    for (auto i = _Buffer_rpos; i != _Buffer_rend; i = (i + 1) % _Buffer_size) {
        memcpy(p, _Buffer_List[i], _Buffer_capacity * sizeof(uint8_t));
        p += _Buffer_capacity;
    }
    PyObject* PyFrame = PyArray_SimpleNewFromData(4, dims, NPY_UINT8, reinterpret_cast<void*>(newdata));
    PyArray_ENABLEFLAGS((PyArrayObject*)PyFrame, NPY_ARRAY_OWNDATA);
    _Buffer_rpos = -1;
    __Read_size = 0;
    return PyArray_Return((PyArrayObject*)PyFrame);
    //Py_RETURN_NONE;
}

/**
 * Related with the encoder.
 */

 // Constructors following 3-5 law.
cmpc::CMpegServer::CMpegServer(void) :
    videoPath(), __formatName(), codecName(), bitRate(1024),
    __start_time(0), __cur_time(0), width(100), height(100), widthSrc(0), heightSrc(0),
    timeBase(_setAVRational(1, 25)), frameRate(_setAVRational(25, 1)),
    time_base_q(_setAVRational(1, AV_TIME_BASE)), GOPSize(10), MaxBFrame(1),
    PStreamContex({ 0 }), PFormatCtx(nullptr), Ppacket(nullptr), PswsCtx(nullptr),
    __frameRGB(nullptr), RGBbuffer(nullptr), __have_video(false), __enable_header(false),
    nthread(0) {
    __pts_ahead = av_rescale(av_rescale(20, timeBase.den, timeBase.num), frameRate.den, frameRate.num);
}

void cmpc::CMpegServer::meta_protected_clear(void) {
    auto protectWidth = width;
    auto protectHeight = height;
    auto protectWidthSrc = widthSrc;
    auto protectHeightSrc = heightSrc;
    auto protectBitRate = bitRate;
    auto protectGOPSize = GOPSize;
    auto protectMaxBFrame = MaxBFrame;
    auto protectPTSAhead = __pts_ahead;
    auto protectVideoPath(videoPath);
    auto protectFormatName(__formatName);
    auto protectCodecName(codecName);
    auto protectTimeBase(timeBase);
    auto protectFrameRate(frameRate);
    auto protectNthread = nthread;
    clear();
    width = protectWidth;
    height = protectHeight;
    widthSrc = protectWidthSrc;
    heightSrc = protectHeightSrc;
    bitRate = protectBitRate;
    GOPSize = protectGOPSize;
    MaxBFrame = protectMaxBFrame;
    timeBase = protectTimeBase;
    frameRate = protectFrameRate;
    __pts_ahead = protectPTSAhead;
    videoPath.assign(protectVideoPath);
    __formatName.assign(protectFormatName);
    codecName.assign(protectCodecName);
    nthread = protectNthread;
}

void cmpc::CMpegServer::clear(void) {
    FFmpegClose();
    videoPath.clear();
    __formatName.clear();
    codecName.clear();
    bitRate = 1024;