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

#include "stdafx.h"

#include "MpegCoder.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) {

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;

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

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) { //搜索合适的解码器，并进行相关设置

int ret, stream_index;

AVStream *st; // 流

AVCodec *dec = nullptr; // 解码器

AVDictionary *opts = nullptr; // 参数设置字典

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 {

stream_index = ret;

st = PFormatCtx->streams[stream_index];

/* find decoder for the stream */

dec = avcodec_find_decoder(st->codecpar->codec_id);

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 */

dec_ctx = avcodec_alloc_context3(dec);

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 */

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;

}

stream_idx = stream_index;

}

return 0;

}

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

videoPath.assign(inVideoPath);

return FFmpegSetup();

}

bool cmpc::CMpegDecoder::FFmpegSetup() { //打开指定路径的视频文件，并进行解码器的搜索与设置

meta_protected_clear();

int ret = 0;

// Register all formats and codecs.

#ifndef FFMPG3_4

av_register_all();

#endif

/* register all formats and codecs */

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, 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 */

if (__dumpControl > 1)

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

if (!PVideoStream) { //检查视频流是否正常开启

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, AV_PIX_FMT_RGB24, SCALE_FLAGS, nullptr, nullptr, nullptr);

auto numBytes = av_image_get_buffer_size(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, AV_PIX_FMT_RGB24, SCALE_FLAGS, nullptr, nullptr, nullptr);

auto numBytes = av_image_get_buffer_size(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(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;

}

if (__dumpControl > 0) {

cout << "video_frame" << (cached ? "(cached)" : "") << " n:" << PVideoFrameCount++ <<

" coded_n:" << frame->coded_picture_number << endl;

}

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

}

if (__dumpControl > 0) {

cout << "video_frame" << (cached ? "(cached)" : "") << " n:" << PVideoFrameCount++ <<

" coded_n:" << frame->coded_picture_number << endl;

}

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

if (PyArray_API == NULL) {

import_array();

}

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

auto newdata = new uint8_t[fHeight*fWidth * 3];

memcpy(newdata, data[0], fHeight*fWidth * 3);

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

return PyFrame;

}

attribute_deprecated

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

if (PyArray_API == NULL){

import_array();

}

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

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

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

PyList_ClearFreeList();

//Py_INCREF(PyFrame);

return PyFrame;

}

attribute_deprecated

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

PyObject *e_i, *e_ij;

PyObject *PyFrame = PyList_New(static_cast<Py_ssize_t>(fHeight));

uint8_t * pdata = data[0];

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

e_i = PyList_New(static_cast<Py_ssize_t>(fWidth));

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

e_ij = Py_BuildValue("[BBB]", pdata[0], pdata[1], pdata[2]);

PyList_SetItem(e_i, static_cast<Py_ssize_t>(j), e_ij);

}

PyList_SetItem(PyFrame, static_cast<Py_ssize_t>(i), e_i);

}

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

AVPacket pkt;

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 */

av_init_packet(&pkt);

pkt.data = nullptr;

pkt.size = 0;

if (PVideoStream && (__dumpControl > 0))

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

/* 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, AV_PIX_FMT_RGB24, widthDst, heightDst, 1);

}

else {

av_image_fill_arrays(frameRGB->data, frameRGB->linesize, RGBbuffer, 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;

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

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

AVPacket orig_pkt = pkt;

frameProcessed = false;

do {

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

if (ret < 0)

break;

pkt.data += ret;

pkt.size -= ret;

} while (pkt.size > 0);

av_packet_unref(&orig_pkt);

if (frameProcessed)

count++;

if (GOPstate == 2)

break;

}

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

EndofGOP = true;

}

/* flush cached frames */

pkt.data = nullptr;

pkt.size = 0;

do {

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

} while (got_frame);

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

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

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

}

//av_free(RGBbuffer);

//RGBbuffer = nullptr;

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

//sws_freeContext(PswsCtx);

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

//PswsCtx = nullptr;

av_frame_free(&frameRGB);

av_frame_free(&frame);

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

AVFrame *frame = av_frame_alloc();

AVPacket pkt;

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 */

av_init_packet(&pkt);

pkt.data = nullptr;

pkt.size = 0;

if (PVideoStream && (__dumpControl > 0))

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

/* 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, AV_PIX_FMT_RGB24, widthDst, heightDst, 1);

}

else {

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

}

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

AVPacket orig_pkt = pkt;

frameProcessed = false;

do {

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

if (ret < 0)

break;

pkt.data += ret;

pkt.size -= ret;

} while (pkt.size > 0);

av_packet_unref(&orig_pkt);

if (frameProcessed)

count++;

if (count >= frameNum)

break;

}

/* flush cached frames */

pkt.data = nullptr;

pkt.size = 0;

do {

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

} while (got_frame);

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

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

}

av_frame_free(&frameRGB);

av_frame_free(&frame);

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;

}

//构造函数系，遵循三五法则

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

videoPath.assign(inVideoPath);

return FFmpegSetup();

}

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;

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

}

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;

/* Write the compressed frame to the media file. */

if (__dumpControl > 0)

__log_packet();

return av_interleaved_write_frame(PFormatCtx, Ppacket);

}

bool cmpc::CMpegEncoder::__add_stream(AVCodec **codec){

/* find the encoder */

AVCodecID codec_id;

auto srcwidth = widthSrc > 0 ? widthSrc : width;

auto srcheight = heightSrc > 0 ? heightSrc : height;

*codec = avcodec_find_encoder_by_name(codecName.c_str());

if (!(*codec)) {

codec_id = PFormatCtx->oformat->video_codec;

cerr << "Could not find encoder "<< codecName <<", use " << avcodec_get_name(codec_id) << " as an alternative." << endl;

*codec = avcodec_find_encoder(codec_id);

}

else {

codec_id = (*codec)->id;

PFormatCtx->oformat->video_codec = codec_id;

}

if (!(*codec)) {

cerr << "Could not find encoder for '" << avcodec_get_name(codec_id) << "'" << endl;

return false;

}

PStreamContex.st = avformat_new_stream(PFormatCtx, NULL);

if (!PStreamContex.st) {

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

return false;

}

PStreamContex.st->id = PFormatCtx->nb_streams - 1;

auto c = avcodec_alloc_context3(*codec);

if (!c) {

cerr << "Could not alloc an encoding context" << endl;

return false;

}

PStreamContex.enc = c;

switch ((*codec)->type) {

case AVMEDIA_TYPE_VIDEO:

c->codec_id = codec_id;

c->bit_rate = bitRate;

/* Resolution must be a multiple of two. */

c->width = width;

c->height = height;

/* timebase: This is the fundamental unit of time (in seconds) in terms

PStreamContex.st->time_base.den = 0;

PStreamContex.st->time_base.num = 0;

//av_stream_set_r_frame_rate(PStreamContex.st, frameRate);

//cout << "(" << frameRate.num << ", " << frameRate.den << ")" << endl;

//PStreamContex.st->r_frame_rate

c->time_base = timeBase;

//PStreamContex.st->frame

c->framerate = frameRate;

c->gop_size = GOPSize; /* emit one intra frame every twelve frames at most */

c->max_b_frames = MaxBFrame;

c->pix_fmt = STREAM_PIX_FMT;

if (c->codec_id == AV_CODEC_ID_FLV1) {

/* just for testing, we also add B-frames */

c->max_b_frames = 0;

}

if (c->codec_id == AV_CODEC_ID_MPEG2VIDEO) {

/* just for testing, we also add B-frames */

c->max_b_frames = 2;

}

if (c->codec_id == AV_CODEC_ID_MPEG1VIDEO) {

/* Needed to avoid using macroblocks in which some coeffs overflow.

c->mb_decision = 2;

}

if (c->pix_fmt != AV_PIX_FMT_YUV420P) {

/* as we only generate a YUV420P picture, we must convert it