gugelfrei
/
android_frameworks_av
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge "Benchmark Timer : add support for frameSizes"

Browse Source
gugelfrei
Ray Essick 5 years ago committed by Gerrit Code Review
parent 0647d8c5f6 5a58ec0c66
commit 09df62407d
13 changed files with 101 additions and 106 deletions
Show Stats Download Patch File Download Diff File

2
media/tests/benchmark/src/native/common/Android.bp
Unescape View File

@ -23,7 +23,7 @@ cc_library_static {
srcs: [
"BenchmarkCommon.cpp",
"Timer.cpp",
"Stats.cpp",
],
export_include_dirs: ["."],

4
media/tests/benchmark/src/native/common/BenchmarkCommon.cpp
Unescape View File

@ -31,7 +31,7 @@ void CallBackHandle::ioThread() {
void OnInputAvailableCB(AMediaCodec *codec, void *userdata, int32_t index) {
ALOGV("OnInputAvailableCB: index(%d)", index);
CallBackHandle *self = (CallBackHandle *)userdata;
self->getTimer()->addInputTime();
self->getStats()->addInputTime();
self->mIOQueue.push([self, codec, index]() { self->onInputAvailable(codec, index); });
}
@ -40,7 +40,7 @@ void OnOutputAvailableCB(AMediaCodec *codec, void *userdata, int32_t index,
ALOGV("OnOutputAvailableCB: index(%d), (%d, %d, %lld, 0x%x)", index, bufferInfo->offset,
bufferInfo->size, (long long)bufferInfo->presentationTimeUs, bufferInfo->flags);
CallBackHandle *self = (CallBackHandle *)userdata;
self->getTimer()->addOutputTime();
self->getStats()->addOutputTime();
AMediaCodecBufferInfo bufferInfoCopy = *bufferInfo;
self->mIOQueue.push([self, codec, index, bufferInfoCopy]() {
AMediaCodecBufferInfo bc = bufferInfoCopy;

14
media/tests/benchmark/src/native/common/BenchmarkCommon.h
Unescape View File

@ -27,7 +27,7 @@
#include <media/NdkMediaCodec.h>
#include <media/NdkMediaError.h>
#include "Timer.h"
#include "Stats.h"
using namespace std;
@ -69,11 +69,13 @@ class CallBackQueue {
class CallBackHandle {
public:
CallBackHandle() : mSawError(false), mIsDone(false), mTimer(nullptr) {}
CallBackHandle() : mSawError(false), mIsDone(false), mStats(nullptr) {
mStats = new Stats();
}
virtual ~CallBackHandle() {
if (mIOThread.joinable()) mIOThread.join();
if (mTimer) delete mTimer;
if (mStats) delete mStats;
}
void ioThread();
@ -94,7 +96,7 @@ class CallBackHandle {
(void)bufferInfo;
}
virtual Timer *getTimer() { return mTimer; }
Stats *getStats() { return mStats; }
// Keep a queue of all function callbacks.
typedef function<void()> IOTask;
@ -103,8 +105,8 @@ class CallBackHandle {
bool mSawError;
bool mIsDone;
private:
Timer *mTimer;
protected:
Stats *mStats;
};
// Async API's callback

8
media/tests/benchmark/src/native/common/Timer.cpp → media/tests/benchmark/src/native/common/Stats.cpp
Unescape View File

@ -15,13 +15,13 @@
*/
//#define LOG_NDEBUG 0
#define LOG_TAG "Timer"
#define LOG_TAG "Stats"
#include <iostream>
#include <stdint.h>
#include <utils/Log.h>
#include "Timer.h"
#include "Stats.h"
/**
* Dumps the stats of the operation for a given input media.
@ -31,7 +31,7 @@
* \param inputReference input media
* \param duarationUs is a duration of the input media in microseconds.
*/
void Timer::dumpStatistics(std::string operation, std::string inputReference, int64_t duarationUs) {
void Stats::dumpStatistics(std::string operation, std::string inputReference, int64_t duarationUs) {
ALOGV("In %s", __func__);
if (!mOutputTimer.size()) {
ALOGE("No output produced");
@ -40,6 +40,7 @@ void Timer::dumpStatistics(std::string operation, std::string inputReference, in
nsecs_t totalTimeTakenNs = getTotalTime();
nsecs_t timeTakenPerSec = (totalTimeTakenNs * 1000000) / duarationUs;
nsecs_t timeToFirstFrameNs = *mOutputTimer.begin() - mStartTimeNs;
int32_t size = std::accumulate(mFrameSizes.begin(), mFrameSizes.end(), 0);
// get min and max output intervals.
nsecs_t intervalNs;
nsecs_t minTimeTakenNs = INT64_MAX;
@ -59,6 +60,7 @@ void Timer::dumpStatistics(std::string operation, std::string inputReference, in
std::cout << "Time to first frame in nano sec : " << timeToFirstFrameNs << endl;
std::cout << "Time taken (in nano sec) to " << operation
<< " 1 sec of content : " << timeTakenPerSec << endl;
std::cout << "Total bytes " << operation << "ed : " << size << endl;
std::cout << "Minimum Time in nano sec : " << minTimeTakenNs << endl;
std::cout << "Maximum Time in nano sec : " << maxTimeTakenNs << endl;
std::cout << "Destroy Time in nano sec : " << mDeInitTimeNs << endl;

21
media/tests/benchmark/src/native/common/Timer.h → media/tests/benchmark/src/native/common/Stats.h
Unescape View File

@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef __TIMER_H__
#define __TIMER_H__
#ifndef __STATS_H__
#define __STATS_H__
#include <sys/time.h>
#include <algorithm>
@ -25,22 +25,22 @@
using namespace std;
class Timer {
class Stats {
public:
Timer() {
Stats() {
mInitTimeNs = 0;
mDeInitTimeNs = 0;
}
~Timer() {
if (!mInputTimer.empty()) mInputTimer.clear();
if (!mOutputTimer.empty()) mOutputTimer.clear();
~Stats() {
reset();
}
private:
nsecs_t mInitTimeNs;
nsecs_t mDeInitTimeNs;
nsecs_t mStartTimeNs;
std::vector<int32_t> mFrameSizes;
std::vector<nsecs_t> mInputTimer;
std::vector<nsecs_t> mOutputTimer;
@ -53,11 +53,14 @@ class Timer {
void setStartTime() { mStartTimeNs = systemTime(CLOCK_MONOTONIC); }
void addFrameSize(int32_t size) { mFrameSizes.push_back(size); }
void addInputTime() { mInputTimer.push_back(systemTime(CLOCK_MONOTONIC)); }
void addOutputTime() { mOutputTimer.push_back(systemTime(CLOCK_MONOTONIC)); }
void resetTimers() {
void reset() {
if (!mFrameSizes.empty()) mFrameSizes.clear();
if (!mInputTimer.empty()) mInputTimer.clear();
if (!mOutputTimer.empty()) mOutputTimer.clear();
}
@ -78,4 +81,4 @@ class Timer {
void dumpStatistics(std::string operation, std::string inputReference, int64_t duarationUs);
};
#endif // __TIMER_H__
#endif // __STATS_H__

31
media/tests/benchmark/src/native/decoder/Decoder.cpp
Unescape View File

@ -81,6 +81,7 @@ void Decoder::onInputAvailable(AMediaCodec *mediaCodec, int32_t bufIdx) {
mDecoderDoneCondition.notify_one();
return;
}
mStats->addFrameSize(bytesRead);
mNumInputFrame++;
}
}
@ -128,7 +129,6 @@ void Decoder::onFormatChanged(AMediaCodec *mediaCodec, AMediaFormat *format) {
void Decoder::setupDecoder() {
if (!mFormat) mFormat = mExtractor->getFormat();
if (!mTimer) mTimer = new Timer();
}
int32_t Decoder::decode(uint8_t *inputBuffer, vector<AMediaCodecBufferInfo> &frameInfo,
@ -143,7 +143,7 @@ int32_t Decoder::decode(uint8_t *inputBuffer, vector<AMediaCodecBufferInfo> &fra
AMediaFormat_getString(mFormat, AMEDIAFORMAT_KEY_MIME, &mime);
if (!mime) return AMEDIA_ERROR_INVALID_OBJECT;
int64_t sTime = mTimer->getCurTime();
int64_t sTime = mStats->getCurTime();
mCodec = createMediaCodec(mFormat, mime, codecName, false /*isEncoder*/);
if (!mCodec) return AMEDIA_ERROR_INVALID_OBJECT;
@ -152,16 +152,15 @@ int32_t Decoder::decode(uint8_t *inputBuffer, vector<AMediaCodecBufferInfo> &fra
OnFormatChangedCB, OnErrorCB};
AMediaCodec_setAsyncNotifyCallback(mCodec, aCB, this);
CallBackHandle *callbackHandle = new CallBackHandle();
callbackHandle->mIOThread = thread(&CallBackHandle::ioThread, this);
mIOThread = thread(&CallBackHandle::ioThread, this);
}
AMediaCodec_start(mCodec);
int64_t eTime = mTimer->getCurTime();
int64_t timeTaken = mTimer->getTimeDiff(sTime, eTime);
mTimer->setInitTime(timeTaken);
int64_t eTime = mStats->getCurTime();
int64_t timeTaken = mStats->getTimeDiff(sTime, eTime);
mStats->setInitTime(timeTaken);
mTimer->setStartTime();
mStats->setStartTime();
if (!asyncMode) {
while (!mSawOutputEOS && !mSignalledError) {
/* Queue input data */
@ -171,7 +170,7 @@ int32_t Decoder::decode(uint8_t *inputBuffer, vector<AMediaCodecBufferInfo> &fra
ALOGE("AMediaCodec_dequeueInputBuffer returned invalid index %zd\n", inIdx);
return AMEDIA_ERROR_IO;
} else if (inIdx >= 0) {
mTimer->addInputTime();
mStats->addInputTime();
onInputAvailable(mCodec, inIdx);
}
}
@ -184,7 +183,7 @@ int32_t Decoder::decode(uint8_t *inputBuffer, vector<AMediaCodecBufferInfo> &fra
const char *s = AMediaFormat_toString(mFormat);
ALOGI("Output format: %s\n", s);
} else if (outIdx >= 0) {
mTimer->addOutputTime();
mStats->addOutputTime();
onOutputAvailable(mCodec, outIdx, &info);
} else if (!(outIdx == AMEDIACODEC_INFO_TRY_AGAIN_LATER ||
outIdx == AMEDIACODEC_INFO_OUTPUT_BUFFERS_CHANGED)) {
@ -207,7 +206,7 @@ int32_t Decoder::decode(uint8_t *inputBuffer, vector<AMediaCodecBufferInfo> &fra
}
void Decoder::deInitCodec() {
int64_t sTime = mTimer->getCurTime();
int64_t sTime = mStats->getCurTime();
if (mFormat) {
AMediaFormat_delete(mFormat);
mFormat = nullptr;
@ -215,19 +214,19 @@ void Decoder::deInitCodec() {
if (!mCodec) return;
AMediaCodec_stop(mCodec);
AMediaCodec_delete(mCodec);
int64_t eTime = mTimer->getCurTime();
int64_t timeTaken = mTimer->getTimeDiff(sTime, eTime);
mTimer->setDeInitTime(timeTaken);
int64_t eTime = mStats->getCurTime();
int64_t timeTaken = mStats->getTimeDiff(sTime, eTime);
mStats->setDeInitTime(timeTaken);
}
void Decoder::dumpStatistics(string inputReference) {
int64_t durationUs = mExtractor->getClipDuration();
string operation = "decode";
mTimer->dumpStatistics(operation, inputReference, durationUs);
mStats->dumpStatistics(operation, inputReference, durationUs);
}
void Decoder::resetDecoder() {
if (mTimer) mTimer->resetTimers();
if (mStats) mStats->reset();
if (mInputBuffer) mInputBuffer = nullptr;
if (!mFrameMetaData.empty()) mFrameMetaData.clear();
}

8
media/tests/benchmark/src/native/decoder/Decoder.h
Unescape View File

@ -25,7 +25,7 @@
#include "BenchmarkCommon.h"
#include "Extractor.h"
#include "Timer.h"
#include "Stats.h"
class Decoder : public CallBackHandle {
public:
@ -33,7 +33,6 @@ class Decoder : public CallBackHandle {
: mCodec(nullptr),
mFormat(nullptr),
mExtractor(nullptr),
mTimer(nullptr),
mNumInputFrame(0),
mNumOutputFrame(0),
mSawInputEOS(false),
@ -45,12 +44,9 @@ class Decoder : public CallBackHandle {
}
virtual ~Decoder() {
if (mTimer) delete mTimer;
if (mExtractor) delete mExtractor;
}
Timer *getTimer() override { return mTimer; }
Extractor *getExtractor() { return mExtractor; }
// Decoder related utilities
@ -80,8 +76,6 @@ class Decoder : public CallBackHandle {
Extractor *mExtractor;
Timer *mTimer;
int32_t mNumInputFrame;
int32_t mNumOutputFrame;

37
media/tests/benchmark/src/native/encoder/Encoder.cpp
Unescape View File

@ -112,6 +112,7 @@ void Encoder::onOutputAvailable(AMediaCodec *mediaCodec, int32_t bufIdx,
return;
}
mStats->addFrameSize(bufferInfo->size);
AMediaCodec_releaseOutputBuffer(mCodec, bufIdx, false);
mSawOutputEOS = (0 != (bufferInfo->flags & AMEDIACODEC_BUFFER_FLAG_END_OF_STREAM));
mNumOutputFrame++;
@ -134,24 +135,23 @@ void Encoder::onFormatChanged(AMediaCodec *mediaCodec, AMediaFormat *format) {
void Encoder::setupEncoder() {
if (!mFormat) mFormat = AMediaFormat_new();
if (!mTimer) mTimer = new Timer();
}
void Encoder::deInitCodec() {
int64_t sTime = mTimer->getCurTime();
int64_t sTime = mStats->getCurTime();
if (mFormat) {
AMediaFormat_delete(mFormat);
mFormat = nullptr;
}
AMediaCodec_stop(mCodec);
AMediaCodec_delete(mCodec);
int64_t eTime = mTimer->getCurTime();
int64_t timeTaken = mTimer->getTimeDiff(sTime, eTime);
mTimer->setDeInitTime(timeTaken);
int64_t eTime = mStats->getCurTime();
int64_t timeTaken = mStats->getTimeDiff(sTime, eTime);
mStats->setDeInitTime(timeTaken);
}
void Encoder::resetEncoder() {
if (mTimer) mTimer->resetTimers();
if (mStats) mStats->reset();
if (mEleStream) mEleStream = nullptr;
if (mMime) mMime = nullptr;
mInputBufferSize = 0;
@ -160,7 +160,7 @@ void Encoder::resetEncoder() {
void Encoder::dumpStatistics(string inputReference, int64_t durationUs) {
string operation = "encode";
mTimer->dumpStatistics(operation, inputReference, durationUs);
mStats->dumpStatistics(operation, inputReference, durationUs);
}
int32_t Encoder::encode(string &codecName, ifstream &eleStream, size_t eleSize,
@ -192,11 +192,11 @@ int32_t Encoder::encode(string &codecName, ifstream &eleStream, size_t eleSize,
const char *s = AMediaFormat_toString(mFormat);
ALOGV("Input format: %s\n", s);
int64_t sTime = mTimer->getCurTime();
int64_t sTime = mStats->getCurTime();
mCodec = createMediaCodec(mFormat, mMime, codecName, true /*isEncoder*/);
if (!mCodec) return AMEDIA_ERROR_INVALID_OBJECT;
int64_t eTime = mTimer->getCurTime();
int64_t timeTaken = mTimer->getTimeDiff(sTime, eTime);
int64_t eTime = mStats->getCurTime();
int64_t timeTaken = mStats->getTimeDiff(sTime, eTime);
if (!strncmp(mMime, "video/", 6)) {
mParams.frameSize = mParams.width * mParams.height * 3 / 2;
@ -215,20 +215,19 @@ int32_t Encoder::encode(string &codecName, ifstream &eleStream, size_t eleSize,
}
mParams.numFrames = (mInputBufferSize + mParams.frameSize - 1) / mParams.frameSize;
sTime = mTimer->getCurTime();
sTime = mStats->getCurTime();
if (asyncMode) {
AMediaCodecOnAsyncNotifyCallback aCB = {OnInputAvailableCB, OnOutputAvailableCB,
OnFormatChangedCB, OnErrorCB};
AMediaCodec_setAsyncNotifyCallback(mCodec, aCB, this);
CallBackHandle *callbackHandle = new CallBackHandle();
callbackHandle->mIOThread = thread(&CallBackHandle::ioThread, this);
mIOThread = thread(&CallBackHandle::ioThread, this);
}
AMediaCodec_start(mCodec);
eTime = mTimer->getCurTime();
timeTaken += mTimer->getTimeDiff(sTime, eTime);
mTimer->setInitTime(timeTaken);
eTime = mStats->getCurTime();
timeTaken += mStats->getTimeDiff(sTime, eTime);
mStats->setInitTime(timeTaken);
mTimer->setStartTime();
mStats->setStartTime();
if (!asyncMode) {
while (!mSawOutputEOS && !mSignalledError) {
// Queue input data
@ -238,7 +237,7 @@ int32_t Encoder::encode(string &codecName, ifstream &eleStream, size_t eleSize,
ALOGE("AMediaCodec_dequeueInputBuffer returned invalid index %zd\n", inIdx);
return AMEDIA_ERROR_IO;
} else if (inIdx >= 0) {
mTimer->addInputTime();
mStats->addInputTime();
onInputAvailable(mCodec, inIdx);
}
}
@ -251,7 +250,7 @@ int32_t Encoder::encode(string &codecName, ifstream &eleStream, size_t eleSize,
const char *s = AMediaFormat_toString(mFormat);
ALOGI("Output format: %s\n", s);
} else if (outIdx >= 0) {
mTimer->addOutputTime();
mStats->addOutputTime();
onOutputAvailable(mCodec, outIdx, &info);
} else if (!(outIdx == AMEDIACODEC_INFO_TRY_AGAIN_LATER ||
outIdx == AMEDIACODEC_INFO_OUTPUT_BUFFERS_CHANGED)) {

11
media/tests/benchmark/src/native/encoder/Encoder.h
Unescape View File

@ -24,7 +24,7 @@
#include <thread>
#include "BenchmarkCommon.h"
#include "Timer.h"
#include "Stats.h"
struct encParameter {
int32_t bitrate = -1;
@ -45,18 +45,13 @@ class Encoder : public CallBackHandle {
Encoder()
: mCodec(nullptr),
mFormat(nullptr),
mTimer(nullptr),
mNumInputFrame(0),
mNumOutputFrame(0),
mSawInputEOS(false),
mSawOutputEOS(false),
mSignalledError(false) {}
virtual ~Encoder() {
if (mTimer) delete mTimer;
}
Timer *getTimer() override { return mTimer; }
virtual ~Encoder() {}
// Encoder related utilities
void setupEncoder();
@ -83,8 +78,6 @@ class Encoder : public CallBackHandle {
AMediaCodec *mCodec;
AMediaFormat *mFormat;
Timer *mTimer;
int32_t mNumInputFrame;
int32_t mNumOutputFrame;
bool mSawInputEOS;

26
media/tests/benchmark/src/native/extractor/Extractor.cpp
Unescape View File

@ -22,21 +22,21 @@
#include "Extractor.h"
int32_t Extractor::initExtractor(int32_t fd, size_t fileSize) {
mTimer = new Timer();
mStats = new Stats();
mFrameBuf = (uint8_t *)calloc(kMaxBufferSize, sizeof(uint8_t));
if (!mFrameBuf) return -1;
int64_t sTime = mTimer->getCurTime();
int64_t sTime = mStats->getCurTime();
mExtractor = AMediaExtractor_new();
if (!mExtractor) return AMEDIACODEC_ERROR_INSUFFICIENT_RESOURCE;
media_status_t status = AMediaExtractor_setDataSourceFd(mExtractor, fd, 0, fileSize);
if (status != AMEDIA_OK) return status;
int64_t eTime = mTimer->getCurTime();
int64_t timeTaken = mTimer->getTimeDiff(sTime, eTime);
mTimer->setInitTime(timeTaken);
int64_t eTime = mStats->getCurTime();
int64_t timeTaken = mStats->getTimeDiff(sTime, eTime);
mStats->setInitTime(timeTaken);
return AMediaExtractor_getTrackCount(mExtractor);
}
@ -52,6 +52,7 @@ void *Extractor::getCSDSample(AMediaCodecBufferInfo &frameInfo, int32_t csdIndex
bool csdFound = AMediaFormat_getBuffer(mFormat, csdName, &csdBuffer, &size);
if (!csdFound) return nullptr;
frameInfo.size = (int32_t)size;
mStats->addFrameSize(frameInfo.size);
return csdBuffer;
}
@ -62,6 +63,7 @@ int32_t Extractor::getFrameSample(AMediaCodecBufferInfo &frameInfo) {
frameInfo.flags = AMediaExtractor_getSampleFlags(mExtractor);
frameInfo.size = size;
mStats->addFrameSize(frameInfo.size);
frameInfo.presentationTimeUs = AMediaExtractor_getSampleTime(mExtractor);
AMediaExtractor_advance(mExtractor);
@ -92,11 +94,11 @@ int32_t Extractor::extract(int32_t trackId) {
idx++;
}
mTimer->setStartTime();
mStats->setStartTime();
while (1) {
int32_t status = getFrameSample(frameInfo);
if (status || !frameInfo.size) break;
mTimer->addOutputTime();
mStats->addOutputTime();
}
if (mFormat) {
@ -111,7 +113,7 @@ int32_t Extractor::extract(int32_t trackId) {
void Extractor::dumpStatistics(string inputReference) {
string operation = "extract";
mTimer->dumpStatistics(operation, inputReference, mDurationUs);
mStats->dumpStatistics(operation, inputReference, mDurationUs);
}
void Extractor::deInitExtractor() {
@ -120,14 +122,14 @@ void Extractor::deInitExtractor() {
mFrameBuf = nullptr;
}
int64_t sTime = mTimer->getCurTime();
int64_t sTime = mStats->getCurTime();
if (mExtractor) {
// TODO: (b/140128505) Multiple calls result in DoS.
// Uncomment call to AMediaExtractor_delete() once this is resolved
// AMediaExtractor_delete(mExtractor);
mExtractor = nullptr;
}
int64_t eTime = mTimer->getCurTime();
int64_t deInitTime = mTimer->getTimeDiff(sTime, eTime);
mTimer->setDeInitTime(deInitTime);
int64_t eTime = mStats->getCurTime();
int64_t deInitTime = mStats->getTimeDiff(sTime, eTime);
mStats->setDeInitTime(deInitTime);
}

8
media/tests/benchmark/src/native/extractor/Extractor.h
Unescape View File

@ -20,19 +20,19 @@
#include <media/NdkMediaExtractor.h>
#include "BenchmarkCommon.h"
#include "Timer.h"
#include "Stats.h"
class Extractor {
public:
Extractor()
: mFormat(nullptr),
mExtractor(nullptr),
mTimer(nullptr),
mStats(nullptr),
mFrameBuf{nullptr},
mDurationUs{0} {}
~Extractor() {
if (mTimer) delete mTimer;
if (mStats) delete mStats;
}
int32_t initExtractor(int32_t fd, size_t fileSize);
@ -58,7 +58,7 @@ class Extractor {
private:
AMediaFormat *mFormat;
AMediaExtractor *mExtractor;
Timer *mTimer;
Stats *mStats;
uint8_t *mFrameBuf;
int64_t mDurationUs;
};

27
media/tests/benchmark/src/native/muxer/Muxer.cpp
Unescape View File

@ -24,9 +24,9 @@
int32_t Muxer::initMuxer(int32_t fd, MUXER_OUTPUT_T outputFormat) {
if (!mFormat) mFormat = mExtractor->getFormat();
if (!mTimer) mTimer = new Timer();
if (!mStats) mStats = new Stats();
int64_t sTime = mTimer->getCurTime();
int64_t sTime = mStats->getCurTime();
mMuxer = AMediaMuxer_new(fd, (OutputFormat)outputFormat);
if (!mMuxer) {
cout << "[ WARN ] Test Skipped. Unable to create muxer \n";
@ -42,14 +42,14 @@ int32_t Muxer::initMuxer(int32_t fd, MUXER_OUTPUT_T outputFormat) {
return index;
}
AMediaMuxer_start(mMuxer);
int64_t eTime = mTimer->getCurTime();
int64_t timeTaken = mTimer->getTimeDiff(sTime, eTime);
mTimer->setInitTime(timeTaken);
int64_t eTime = mStats->getCurTime();
int64_t timeTaken = mStats->getTimeDiff(sTime, eTime);
mStats->setInitTime(timeTaken);
return AMEDIA_OK;
}
void Muxer::deInitMuxer() {
int64_t sTime = mTimer->getCurTime();
int64_t sTime = mStats->getCurTime();
if (mFormat) {
AMediaFormat_delete(mFormat);
mFormat = nullptr;
@ -57,24 +57,24 @@ void Muxer::deInitMuxer() {
if (!mMuxer) return;
AMediaMuxer_stop(mMuxer);
AMediaMuxer_delete(mMuxer);
int64_t eTime = mTimer->getCurTime();
int64_t timeTaken = mTimer->getTimeDiff(sTime, eTime);
mTimer->setDeInitTime(timeTaken);
int64_t eTime = mStats->getCurTime();
int64_t timeTaken = mStats->getTimeDiff(sTime, eTime);
mStats->setDeInitTime(timeTaken);
}
void Muxer::resetMuxer() {
if (mTimer) mTimer->resetTimers();
if (mStats) mStats->reset();
}
void Muxer::dumpStatistics(string inputReference) {
string operation = "mux";
mTimer->dumpStatistics(operation, inputReference, mExtractor->getClipDuration());
mStats->dumpStatistics(operation, inputReference, mExtractor->getClipDuration());
}
int32_t Muxer::mux(uint8_t *inputBuffer, vector<AMediaCodecBufferInfo> &frameInfos) {
// Mux frame data
size_t frameIdx = 0;
mTimer->setStartTime();
mStats->setStartTime();
while (frameIdx < frameInfos.size()) {
AMediaCodecBufferInfo info = frameInfos.at(frameIdx);
media_status_t status = AMediaMuxer_writeSampleData(mMuxer, 0, inputBuffer, &info);
@ -82,7 +82,8 @@ int32_t Muxer::mux(uint8_t *inputBuffer, vector<AMediaCodecBufferInfo> &frameInf
ALOGE("Error in AMediaMuxer_writeSampleData");
return status;
}
mTimer->addOutputTime();
mStats->addOutputTime();
mStats->addFrameSize(info.size);
frameIdx++;
}
return AMEDIA_OK;

10
media/tests/benchmark/src/native/muxer/Muxer.h
Unescape View File

@ -20,7 +20,7 @@
#include <media/NdkMediaMuxer.h>
#include "BenchmarkCommon.h"
#include "Timer.h"
#include "Stats.h"
#include "Extractor.h"
typedef enum {
@ -33,14 +33,14 @@ typedef enum {
class Muxer {
public:
Muxer() : mFormat(nullptr), mMuxer(nullptr), mTimer(nullptr) { mExtractor = new Extractor(); }
Muxer() : mFormat(nullptr), mMuxer(nullptr), mStats(nullptr) { mExtractor = new Extractor(); }
virtual ~Muxer() {
if (mTimer) delete mTimer;
if (mStats) delete mStats;
if (mExtractor) delete mExtractor;
}
Timer *getTimer() { return mTimer; }
Stats *getStats() { return mStats; }
Extractor *getExtractor() { return mExtractor; }
/* Muxer related utilities */
@ -57,7 +57,7 @@ class Muxer {
AMediaFormat *mFormat;
AMediaMuxer *mMuxer;
Extractor *mExtractor;
Timer *mTimer;
Stats *mStats;
};
#endif // __MUXER_H__

Write Preview
Loading…
Cancel
Save