// MpegCoder.cpp: 定义 DLL 应用程序的导出函数。

#include "stdafx.h"

#define NO_IMPORT_ARRAY

#define PY_ARRAY_UNIQUE_SYMBOL MPEGARRAY_API

#include <numpy/arrayobject.h>

#include "MpegCoder.h"

#include "MpegStreamer.h"

int8_t cmpc::__dumpControl = 1;

cmpc::CMpegDecoder::CMpegDecoder(void)

: PFormatCtx(nullptr), PCodecCtx(nullptr), width(0), height(0), PVideoStream(nullptr), \

PVideoStreamIDX(-1), PVideoFrameCount(0), _duration(0), _predictFrameNum(0), RGBbuffer(nullptr), \

PswsCtx(nullptr), currentGOPTSM(0), EndofGOP(false), widthDst(0), heightDst(0), \

PPixelFormat(STREAM_PIX_FMT) {

videoPath.clear();

_str_codec.clear();

/* Enable or disable frame reference counting. You are not supposed to support

refcount = 1;

}

void cmpc::CMpegDecoder::meta_protected_clear(void) {

auto protectWidth = widthDst;

auto protectHeight = heightDst;

clear();

widthDst = protectWidth;

heightDst = protectHeight;

}

void cmpc::CMpegDecoder::clear(void) {

width = height = 0;

widthDst = heightDst = 0;

PVideoStreamIDX = -1;

PVideoFrameCount = 0;

_duration = 0;

_predictFrameNum = 0;

currentGOPTSM = 0;

EndofGOP = false;

PPixelFormat = STREAM_PIX_FMT;

_str_codec.clear();

//videoPath.clear();

PVideoStream = nullptr;

if (PswsCtx) {

sws_freeContext(PswsCtx);

PswsCtx = nullptr;

}

if (RGBbuffer) {

av_free(RGBbuffer);

RGBbuffer = nullptr;

}

if (PCodecCtx) {

avcodec_free_context(&PCodecCtx);

PCodecCtx = nullptr;

}

if (PFormatCtx) {

avformat_close_input(&PFormatCtx);

PFormatCtx = nullptr;

}

refcount = 1;

}

cmpc::CMpegDecoder::~CMpegDecoder() {

clear();

}

cmpc::CMpegDecoder::CMpegDecoder(const CMpegDecoder &ref) {

videoPath.assign(ref.videoPath);

if (!FFmpegSetup()) {

clear();

}

}

cmpc::CMpegDecoder& cmpc::CMpegDecoder::operator=(const CMpegDecoder &ref) {

videoPath.assign(ref.videoPath);

if (!FFmpegSetup()) {

clear();

}

return *this;

}

cmpc::CMpegDecoder::CMpegDecoder(CMpegDecoder &&ref) noexcept

: PFormatCtx(ref.PFormatCtx), PCodecCtx(ref.PCodecCtx), width(ref.width), height(ref.height), \

PVideoStream(ref.PVideoStream), PVideoStreamIDX(ref.PVideoStreamIDX), refcount(ref.refcount), \

PVideoFrameCount(ref.PVideoFrameCount), _str_codec(ref._str_codec), _duration(ref._duration), \

_predictFrameNum(ref._predictFrameNum), RGBbuffer(ref.RGBbuffer), PPixelFormat(ref.PPixelFormat) \

, PswsCtx(ref.PswsCtx), currentGOPTSM(ref.currentGOPTSM), EndofGOP(ref.EndofGOP), \

widthDst(ref.widthDst), heightDst(ref.heightDst){

ref.PFormatCtx = nullptr;

ref.PCodecCtx = nullptr;

ref.PVideoStream = nullptr;

ref.PswsCtx = nullptr;

}

cmpc::CMpegDecoder& cmpc::CMpegDecoder::operator=(CMpegDecoder &&ref) noexcept {

if (this != &ref) {

clear();

width = ref.width;

height = ref.height;

widthDst = ref.widthDst;

heightDst = ref.heightDst;

PVideoStreamIDX = ref.PVideoStreamIDX;

videoPath.assign(ref.videoPath);

_str_codec.assign(ref._str_codec);

_duration = ref._duration;

_predictFrameNum = ref._predictFrameNum;

PFormatCtx = ref.PFormatCtx;

PCodecCtx = ref.PCodecCtx;

PVideoStream = ref.PVideoStream;

PVideoFrameCount = ref.PVideoFrameCount;

currentGOPTSM = ref.currentGOPTSM;

EndofGOP = ref.EndofGOP;

RGBbuffer = ref.RGBbuffer;

PPixelFormat = ref.PPixelFormat;

PswsCtx = ref.PswsCtx;

ref.PFormatCtx = nullptr;

ref.PCodecCtx = nullptr;

ref.PVideoStream = nullptr;

ref.RGBbuffer = nullptr;

ref.PswsCtx = nullptr;

refcount = ref.refcount;

}

return *this;

}

void cmpc::CMpegDecoder::resetPath(string inVideoPath) {

videoPath.assign(inVideoPath);

}

void cmpc::CMpegDecoder::setGOPPosition(int64_t inpos) {

currentGOPTSM = __FrameToPts(inpos);

EndofGOP = false;

}

void cmpc::CMpegDecoder::setGOPPosition(double inpos) {

currentGOPTSM = __TimeToPts(inpos);

EndofGOP = false;

}

int cmpc::CMpegDecoder::_open_codec_context(int &stream_idx, AVCodecContext *&dec_ctx, \

AVFormatContext *PFormatCtx, enum AVMediaType type) { // Search the correct decoder, and make the configurations.

auto 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 file '" << 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 */

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);

}

/* 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::CMpegDecoder::FFmpegSetup(string inVideoPath) {

resetPath(inVideoPath);

return FFmpegSetup();

}

bool cmpc::CMpegDecoder::FFmpegSetup() { // Open the video file, and search the correct codec.

meta_protected_clear();

int ret = 0;

/* open input file, and allocate format context */

if (avformat_open_input(&PFormatCtx, videoPath.c_str(), nullptr, nullptr) < 0) {

cerr << "Could not open source file " << videoPath << endl;

return false;

}

/* retrieve stream information */

if (avformat_find_stream_info(PFormatCtx, nullptr) < 0) {

cerr << "Could not find stream information" << endl;

return false;

}

if (_open_codec_context(PVideoStreamIDX, PCodecCtx, PFormatCtx, AVMediaType::AVMEDIA_TYPE_VIDEO) >= 0) {

PVideoStream = PFormatCtx->streams[PVideoStreamIDX];

auto time_base = PVideoStream->time_base;

auto frame_base = PVideoStream->avg_frame_rate;

/* allocate image where the decoded image will be put */

width = PCodecCtx->width;

height = PCodecCtx->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;

}

/* dump input information to stderr */

auto dump_level = av_log_get_level();

if (dump_level >= AV_LOG_INFO) {

av_dump_format(PFormatCtx, 0, videoPath.c_str(), 0);

}

if (!PVideoStream) { // Check whether the video stream is opened correctly.

cerr << "Could not find audio or video stream in the input, aborting" << endl;

clear();

return false;

}

// Initialize SWS context for software scaling.

if (widthDst > 0 && heightDst > 0) {

PswsCtx = sws_getContext(width, height, PPixelFormat, widthDst, heightDst, AVPixelFormat::AV_PIX_FMT_RGB24, SCALE_FLAGS, nullptr, nullptr, nullptr);

auto numBytes = av_image_get_buffer_size(AVPixelFormat::AV_PIX_FMT_RGB24, widthDst, heightDst, 1);

RGBbuffer = (uint8_t *)av_malloc(numBytes * sizeof(uint8_t));

}

else {

PswsCtx = sws_getContext(width, height, PPixelFormat, width, height, AVPixelFormat::AV_PIX_FMT_RGB24, SCALE_FLAGS, nullptr, nullptr, nullptr);

auto numBytes = av_image_get_buffer_size(AVPixelFormat::AV_PIX_FMT_RGB24, width, height, 1);

RGBbuffer = (uint8_t *)av_malloc(numBytes * sizeof(uint8_t));

}

return true;

}

void cmpc::CMpegDecoder::dumpFormat() {

if ((!videoPath.empty()) && PFormatCtx) {

av_dump_format(PFormatCtx, 0, videoPath.c_str(), 0);

}

else {

cerr << "Still need to FFmpegSetup()" << endl;

}

}

void cmpc::CMpegDecoder::setParameter(string keyword, void *ptr) {

if (keyword.compare("widthDst") == 0) {

int *ref = reinterpret_cast<int *>(ptr);

widthDst = *ref;

}

else if (keyword.compare("heightDst") == 0) {

int *ref = reinterpret_cast<int *>(ptr);

heightDst = *ref;

}

}

PyObject* cmpc::CMpegDecoder::getParameter() {

auto res = PyDict_New();

string key;

PyObject* val = nullptr;

// Fill the values.

key.assign("videoPath");

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);

}

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;

}

PyObject * cmpc::CMpegDecoder::getParameter(string keyword) {

if (keyword.compare("videoPath") == 0) {

return Py_BuildValue("y", videoPath.c_str());

}

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) {

return Py_BuildValue("i", PVideoFrameCount);

}

else if (keyword.compare("coderName") == 0) {

return Py_BuildValue("y", _str_codec.c_str());

}

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("avgFrameRate") == 0) {

auto frame_base = PVideoStream->avg_frame_rate;

double frameRate = static_cast<double>(frame_base.num) / static_cast<double>(frame_base.den);

return Py_BuildValue("d", frameRate);

}

else {

Py_RETURN_NONE;

}

}

int cmpc::CMpegDecoder::__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;

}

int cmpc::CMpegDecoder::_SaveFrame(PyObject *PyFrameList, AVFrame *&frame, AVFrame *&frameRGB, AVPacket *&pkt, bool &got_frame, int64_t minPTS, bool &processed, int cached) {

int ret = 0;

int decoded = pkt->size;

PyObject *OneFrame = nullptr;

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->pts < minPTS) {

//cout << frame->pts << " < " << minPTS << endl;

processed = false;

return decoded;

}

if (frame->width != width || frame->height != height ||

frame->format != PPixelFormat) {

/* To handle this change, one could call av_image_alloc again and

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;

}

PVideoFrameCount++;

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, str_data_s.c_str());

}

/* copy decoded frame to destination buffer:

sws_scale(PswsCtx, frame->data, frame->linesize, 0, height, frameRGB->data, frameRGB->linesize);

/* write to rawvideo file */

if (widthDst>0 && heightDst>0)

OneFrame = _SaveFrame_castToPyFrameArray(frameRGB->data, widthDst, heightDst);

else

OneFrame = _SaveFrame_castToPyFrameArray(frameRGB->data, width, height);

PyList_Append(PyFrameList, OneFrame);

processed = true;

}

}

/* If we use frame reference counting, we own the data and need

if (got_frame && refcount)

av_frame_unref(frame);

return decoded;

}

int cmpc::CMpegDecoder::_SaveFrameForGOP(PyObject *PyFrameList, AVFrame *&frame, AVFrame *&frameRGB, AVPacket *&pkt, bool &got_frame, int &GOPstate, bool &processed, int cached) {

int ret = 0;

int decoded = pkt->size;

PyObject *OneFrame = nullptr;

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) {

currentGOPTSM = frame->pts+1;

switch (GOPstate) {

case 0:

if (frame->key_frame) {

GOPstate = 1;

}

else {

processed = false;

return decoded;

}

break;

case 1:

if (frame->key_frame) {

GOPstate = 2;

processed = false;

return decoded;

}

break;

default:

break;

}

if (frame->width != width || frame->height != height ||

frame->format != PPixelFormat) {

/* To handle this change, one could call av_image_alloc again and

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;

}

PVideoFrameCount++;

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, str_data_s.c_str());

}

/* copy decoded frame to destination buffer:

/*av_image_copy(video_dst_data, video_dst_linesize,

sws_scale(PswsCtx, frame->data, frame->linesize, 0, height, frameRGB->data, frameRGB->linesize);

/* write to rawvideo file */

if (widthDst>0 && heightDst>0)

OneFrame = _SaveFrame_castToPyFrameArray(frameRGB->data, widthDst, heightDst);

else

OneFrame = _SaveFrame_castToPyFrameArray(frameRGB->data, width, height);

PyList_Append(PyFrameList, OneFrame);

//cout << "[" << width << "-" << height << ", " << width*height << ", " << video_dst_bufsize << "]" << endl;

//cout << "PTS = " << frameRGB->pts << ", coded Fnum = " << frameRGB->coded_picture_number << endl;

processed = true;

}

}

/* If we use frame reference counting, we own the data and need

if (got_frame && refcount)

av_frame_unref(frame);

return decoded;

}

PyObject *cmpc::CMpegDecoder::_SaveFrame_castToPyFrameArray(uint8_t *data[], int fWidth, int fHeight) {

npy_intp dims[] = { fHeight, fWidth, 3 };

auto newdata = new uint8_t[static_cast<size_t>(fHeight) * static_cast<size_t>(fWidth) * 3];

memcpy(newdata, data[0], static_cast<size_t>(fHeight) * static_cast<size_t>(fWidth) * 3);

PyObject *PyFrame = PyArray_SimpleNewFromData(3, dims, NPY_UINT8, reinterpret_cast<void *>(newdata));

PyArray_ENABLEFLAGS((PyArrayObject*)PyFrame, NPY_ARRAY_OWNDATA);

return PyFrame;

}

attribute_deprecated

PyObject *cmpc::CMpegDecoder::_SaveFrame_castToPyFrameArrayOld(uint8_t *data[], int fWidth, int fHeight) {

npy_intp dims[] = { static_cast<size_t>(fHeight) * static_cast<size_t>(fWidth) * 3 };

PyObject *PyFrame = PyArray_SimpleNew(1, dims, NPY_UINT8);

if (PyFrame == NULL) {

Py_RETURN_NONE;

}

auto out_iter = NpyIter_New((PyArrayObject *)PyFrame, NPY_ITER_READWRITE,

NPY_CORDER, NPY_NO_CASTING, NULL);

if (out_iter == NULL) {

Py_DECREF(PyFrame);

Py_RETURN_NONE;

}

/*

auto iternext = NpyIter_GetIterNext(out_iter, NULL);

if (iternext == NULL) {

NpyIter_Deallocate(out_iter);

Py_DECREF(PyFrame);

Py_RETURN_NONE;

}

/* The location of the data pointer which the iterator may update */

auto dataptr = NpyIter_GetDataPtrArray(out_iter);

//auto out_iter = (PyArrayIterObject *)PyArray_IterNew(PyFrame);

uint8_t * pdata = data[0];

for (auto i = 0; i < fHeight; i++) {

for (auto j = 0; j < fWidth; j++) {

for (auto k = 0; k < 3; k++, pdata++ ) {

uint8_t * out_dataptr = (uint8_t *) (*dataptr);

*out_dataptr = *pdata;

iternext(out_iter);

}

}

}

PyObject *pyshape = Py_BuildValue("[iii]", fHeight, fWidth, 3);

PyFrame = PyArray_Reshape((PyArrayObject*)PyFrame, pyshape);

Py_DECREF(pyshape);

NpyIter_Deallocate(out_iter);

PyGC_Collect();

//Py_INCREF(PyFrame);

return PyFrame;

}

int64_t cmpc::CMpegDecoder::__FrameToPts(int64_t seekFrame) const{

auto time_base = PVideoStream->time_base;

auto frame_base = PVideoStream->avg_frame_rate;

//cout << "Frame_Base: den=" << frame_base.den << ", num=" << frame_base.num << endl;

auto seekTimeStamp = PVideoStream->start_time + av_rescale( av_rescale(seekFrame, time_base.den, time_base.num), frame_base.den, frame_base.num );

return seekTimeStamp;

}

int64_t cmpc::CMpegDecoder::__TimeToPts(double seekTime) const {

auto time_base = PVideoStream->time_base;

auto seekTimeStamp = PVideoStream->start_time + av_rescale(static_cast<int64_t>(seekTime*1000), time_base.den, time_base.num)/1000;

return seekTimeStamp;

}

bool cmpc::CMpegDecoder::ExtractGOP(PyObject* PyFrameList) {

int ret;

bool got_frame;

if (EndofGOP)

return false;

AVFrame *frame = av_frame_alloc();

auto pkt = av_packet_alloc();

if (!frame) {

cerr << "Could not allocate frame" << endl;

ret = AVERROR(ENOMEM);

return false;

}

AVFrame *frameRGB = av_frame_alloc();

if (!frameRGB) {

cerr << "Could not allocate frameRGB" << endl;

return false;

}

/* initialize packet, set data to NULL, let the demuxer fill it */

if (PVideoStream && (__dumpControl > 0)) {

std::ostringstream str_data;

str_data << "Demuxing video from file '" << videoPath << "' into Python-List" << endl;

auto str_data_s = str_data.str();

av_log(nullptr, AV_LOG_INFO, str_data_s.c_str());

}

/* Reset the contex to remove the flushed state. */

avcodec_flush_buffers(PCodecCtx);

/* read frames from the file */

bool frameProcessed = false;

PVideoFrameCount = 0;

//cout << framePos_TimeBase << endl;

if (av_seek_frame(PFormatCtx, PVideoStreamIDX, currentGOPTSM, AVSEEK_FLAG_BACKWARD) < 0) {

cerr << "AV seek frame fail!" << endl;

av_seek_frame(PFormatCtx, -1, 0, AVSEEK_FLAG_BACKWARD);

}

// Assign appropriate parts of buffer to image planes in pFrameRGB Note that pFrameRGB is an AVFrame, but AVFrame is a superset of AVPicture

if (widthDst > 0 && heightDst > 0) {

av_image_fill_arrays(frameRGB->data, frameRGB->linesize, RGBbuffer, AVPixelFormat::AV_PIX_FMT_RGB24, widthDst, heightDst, 1);

}

else {

av_image_fill_arrays(frameRGB->data, frameRGB->linesize, RGBbuffer, AVPixelFormat::AV_PIX_FMT_RGB24, width, height, 1);

}

int GOPstate = 0; // 0: Have not meed key frame; 1: During GOP; 2: End of GOP

int count = 0;

auto temp_pkt = av_packet_alloc();

while (av_read_frame(PFormatCtx, pkt) >= 0) {

//cout << "[Test - " << pkt.size << " ]" << endl;

av_packet_ref(temp_pkt, pkt);

frameProcessed = false;

do {

ret = _SaveFrameForGOP(PyFrameList, frame, frameRGB, temp_pkt, got_frame, GOPstate, frameProcessed, 0);

if (ret < 0)

break;

temp_pkt->data += ret;

temp_pkt->size -= ret;

} while (temp_pkt->size > 0);

/* flush cached frames */

av_packet_unref(temp_pkt);

av_packet_unref(pkt);

if (frameProcessed)

count++;

if (GOPstate == 2)

break;

}

av_packet_free(&temp_pkt);

if (GOPstate == 1) { //If the end of reading is not raised by I frame, it indicates that the video reaches the end.

EndofGOP = true;

}

do {

_SaveFrameForGOP(PyFrameList, frame, frameRGB, pkt, got_frame, GOPstate, frameProcessed, 1);

} while (got_frame);

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

if (PVideoStream && (__dumpControl > 0)) {

std::ostringstream str_data;

str_data << "Succeed in convert GOP into Python_List, got " << count << " frames." << endl;

auto str_data_s = str_data.str();

av_log(nullptr, AV_LOG_INFO, str_data_s.c_str());

}

//av_free(RGBbuffer);

//RGBbuffer = nullptr;

//cout << "Free Buffer" << endl;

//sws_freeContext(PswsCtx);

//cout << "Free ctx" << endl;

//PswsCtx = nullptr;

if (frameRGB) {

av_frame_free(&frameRGB);

}

if (frame) {

av_frame_free(&frame);

}

if (pkt) {

av_packet_free(&pkt);

}

//cout << "End Process" << endl;

return true;

}

bool cmpc::CMpegDecoder::ExtractFrame(PyObject* PyFrameList, int64_t framePos, int64_t frameNum, double timePos, int mode) {

int ret;

bool got_frame;

auto frame = av_frame_alloc();

if (!frame) {

cerr << "Could not allocate frame" << endl;

ret = AVERROR(ENOMEM);

return false;

}

auto pkt = av_packet_alloc();

if (!pkt) {

cerr << "Could not allocate packet" << endl;

ret = AVERROR(ENOMEM);

return false;

}

auto frameRGB = av_frame_alloc();

if (!frameRGB) {

cerr << "Could not allocate frameRGB" << endl;

return false;

}

/* initialize packet, set data to NULL, let the demuxer fill it */

if (PVideoStream && (__dumpControl > 0)) {

std::ostringstream str_data;

str_data << "Demuxing video from file '" << videoPath << "' into Python-List" << endl;

auto str_data_s = str_data.str();

av_log(nullptr, AV_LOG_INFO, str_data_s.c_str());

}

/* Reset the contex to remove the flushed state. */

avcodec_flush_buffers(PCodecCtx);

/* read frames from the file */

int64_t count = 0;

bool frameProcessed = false;

PVideoFrameCount = 0;

int64_t framePos_TimeBase;

if (mode && 0x1) {

framePos_TimeBase = __TimeToPts(timePos);

}

else {

framePos_TimeBase = __FrameToPts(framePos);

}

if (av_seek_frame(PFormatCtx, PVideoStreamIDX, framePos_TimeBase, AVSEEK_FLAG_BACKWARD) < 0) {

cerr << "AV seek frame fail!" << endl;

av_seek_frame(PFormatCtx, -1, 0, AVSEEK_FLAG_BACKWARD);

}

// Assign appropriate parts of buffer to image planes in pFrameRGB Note that pFrameRGB is an AVFrame, but AVFrame is a superset of AVPicture

if (widthDst > 0 && heightDst > 0) {

av_image_fill_arrays(frameRGB->data, frameRGB->linesize, RGBbuffer, AVPixelFormat::AV_PIX_FMT_RGB24, widthDst, heightDst, 1);

}

else {

av_image_fill_arrays(frameRGB->data, frameRGB->linesize, RGBbuffer, AVPixelFormat::AV_PIX_FMT_RGB24, width, height, 1);

}

auto temp_pkt = av_packet_alloc();

while (av_read_frame(PFormatCtx, pkt) >= 0) {

av_packet_ref(temp_pkt, pkt);

frameProcessed = false;

do {

ret = _SaveFrame(PyFrameList, frame, frameRGB, temp_pkt, got_frame, framePos_TimeBase, frameProcessed, 0);

if (ret < 0)

break;

temp_pkt->data += ret;

temp_pkt->size -= ret;

} while (temp_pkt->size > 0);

/* flush cached frames */

av_packet_unref(temp_pkt);

av_packet_unref(pkt);

if (frameProcessed)

count++;

if (count >= frameNum)

break;

}

av_packet_free(&temp_pkt);

do {

_SaveFrame(PyFrameList, frame, frameRGB, pkt, got_frame, framePos_TimeBase, frameProcessed, 1);

} while (got_frame);

if (PVideoStream && count > 0 && (__dumpControl > 0)) {

std::ostringstream str_data;

str_data << "Succeed in convert frames into Python_List" << endl;

auto str_data_s = str_data.str();

av_log(nullptr, AV_LOG_INFO, str_data_s.c_str());

}

if (frameRGB) {

av_frame_free(&frameRGB);

}

if (frame) {

av_frame_free(&frame);

}

if (pkt) {

av_packet_free(&pkt);

}

return true;

}

ostream & cmpc::operator<<(ostream & out, cmpc::CMpegDecoder & self_class) {

out << std::setw(1) << "/";

out << std::setfill('*') << std::setw(44) << "" << std::setfill(' ') << endl;

out << std::setw(1) << " * Packed FFmpeg Decoder - 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) << " * VideoPath: " \

<< 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;

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::setw(1) << "*/";

return out;

}

// Constructors following 3-5 law.

cmpc::CMpegEncoder::CMpegEncoder(void):

bitRate(1024), width(100), height(100), timeBase(_setAVRational(1, 25)), frameRate(_setAVRational(25, 1)),\

GOPSize(10), MaxBFrame(1), PStreamContex({ 0 }), PFormatCtx(nullptr), PswsCtx(nullptr), RGBbuffer(nullptr), \

Ppacket(nullptr), __have_video(false), __enable_header(false), widthSrc(0), heightSrc(0), __frameRGB(nullptr){

videoPath.clear();

codecName.clear();

}

void cmpc::CMpegEncoder::clear(void) {

FFmpegClose();

videoPath.clear();

codecName.clear();

bitRate = 1024;

width = 100;

height = 100;

heightSrc = 0;

widthSrc = 0;

timeBase = _setAVRational(1, 25);

frameRate = _setAVRational(25, 1);

GOPSize = 10;

MaxBFrame = 1;

PStreamContex = { 0 };

__have_video = false;

__enable_header = false;

}

void cmpc::CMpegEncoder::__copyMetaData(const CMpegEncoder &ref) {

videoPath.assign(ref.videoPath);

codecName.assign(ref.codecName);

bitRate = ref.bitRate;

width = ref.width;

height = ref.height;

widthSrc = ref.widthSrc;

heightSrc = ref.heightSrc;

timeBase = ref.timeBase;

frameRate = ref.frameRate;

GOPSize = ref.GOPSize;

MaxBFrame = ref.MaxBFrame;

}

cmpc::CMpegEncoder::~CMpegEncoder(void) {

clear();

}

cmpc::CMpegEncoder::CMpegEncoder(const CMpegEncoder &ref) {

__copyMetaData(ref);

if (!FFmpegSetup()) {

clear();

}

}

cmpc::CMpegEncoder& cmpc::CMpegEncoder::operator=(const CMpegEncoder &ref) {

__copyMetaData(ref);

if (!FFmpegSetup()) {

clear();

}

return *this;

}

cmpc::CMpegEncoder::CMpegEncoder(CMpegEncoder &&ref) noexcept:

bitRate(ref.bitRate), width(ref.width), height(ref.height), timeBase(ref.timeBase), frameRate(ref.frameRate), \

GOPSize(ref.GOPSize), MaxBFrame(ref.MaxBFrame), PStreamContex(ref.PStreamContex), PswsCtx(ref.PswsCtx), \

RGBbuffer(ref.RGBbuffer), Ppacket(ref.Ppacket), PFormatCtx(ref.PFormatCtx), __have_video(ref.__have_video), \

__enable_header(ref.__enable_header), widthSrc(ref.widthSrc), heightSrc(ref.heightSrc), __frameRGB(ref.__frameRGB){

videoPath.assign(ref.videoPath);

codecName.assign(ref.codecName);

}

cmpc::CMpegEncoder& cmpc::CMpegEncoder::operator=(CMpegEncoder &&ref) noexcept {

videoPath.assign(ref.videoPath);

codecName.assign(ref.codecName);

bitRate = ref.bitRate;

width = ref.width;

height = ref.height;

widthSrc = ref.widthSrc;

heightSrc = ref.heightSrc;

timeBase = ref.timeBase;

frameRate = ref.frameRate;

GOPSize = ref.GOPSize;

MaxBFrame = ref.MaxBFrame;

PFormatCtx = ref.PFormatCtx;

PStreamContex = ref.PStreamContex;

PswsCtx = ref.PswsCtx;

RGBbuffer = ref.RGBbuffer;

Ppacket = ref.Ppacket;

__frameRGB = ref.__frameRGB;

__have_video = ref.__have_video;

__enable_header = ref.__enable_header;

ref.PFormatCtx = nullptr;

ref.PStreamContex = { 0 };

ref.PswsCtx = nullptr;

ref.RGBbuffer = nullptr;

ref.Ppacket = nullptr;

ref.__frameRGB = nullptr;

return *this;

}

void cmpc::CMpegEncoder::resetPath(string inVideoPath) {

videoPath.assign(inVideoPath);

}

bool cmpc::CMpegEncoder::FFmpegSetup(string inVideoPath) {

resetPath(inVideoPath);

return FFmpegSetup();

}

cmpc::AVRational cmpc::CMpegEncoder::_setAVRational(int num, int den) {

AVRational res;

res.num = num; res.den = den;

return res;

}

int64_t cmpc::CMpegEncoder::__FrameToPts(int64_t seekFrame) const {

return av_rescale(av_rescale(seekFrame, timeBase.den, timeBase.num), frameRate.den, frameRate.num);

}

int64_t cmpc::CMpegEncoder::__TimeToPts(double seekTime) const {

return av_rescale(static_cast<int64_t>(seekTime * 1000), timeBase.den, timeBase.num) / 1000;

}

void cmpc::CMpegEncoder::__log_packet(){

AVRational *time_base = &PFormatCtx->streams[Ppacket->stream_index]->time_base;

std::ostringstream str_data;

str_data << "pts:" << av_ts2str(Ppacket->pts) << " pts_time:" << av_ts2timestr(Ppacket->pts, time_base)

<< " dts:" << av_ts2str(Ppacket->dts) << " dts_time:" << av_ts2timestr(Ppacket->dts, time_base) << endl;

auto str_data_s = str_data.str();

av_log(nullptr, AV_LOG_INFO, str_data_s.c_str());

}

int cmpc::CMpegEncoder::__write_frame(){

/* rescale output packet timestamp values from codec to stream timebase */

av_packet_rescale_ts(Ppacket, PStreamContex.enc->time_base, PStreamContex.st->time_base);

Ppacket->stream_index = PStreamContex.st->index;