blob: e931cc1d84c44e2c6ef5a52f02e3a8e987a11c33 [file] [log] [blame]
/*
* Copyright (C) 2020 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// #define LOG_NDEBUG 0
#define LOG_TAG "MediaSampleWriter"
#include <android-base/logging.h>
#include <media/MediaSampleWriter.h>
#include <media/NdkCommon.h>
#include <media/NdkMediaMuxer.h>
#include <sys/prctl.h>
#include <utils/AndroidThreads.h>
namespace android {
class DefaultMuxer : public MediaSampleWriterMuxerInterface {
public:
// MediaSampleWriterMuxerInterface
ssize_t addTrack(AMediaFormat* trackFormat) override {
// If the track format has rotation, need to call AMediaMuxer_setOrientationHint
// to set the rotation. Muxer doesn't take rotation specified on the track.
const char* mime;
if (AMediaFormat_getString(trackFormat, AMEDIAFORMAT_KEY_MIME, &mime) &&
strncmp(mime, "video/", 6) == 0) {
int32_t rotation;
if (AMediaFormat_getInt32(trackFormat, AMEDIAFORMAT_KEY_ROTATION, &rotation) &&
(rotation != 0)) {
AMediaMuxer_setOrientationHint(mMuxer, rotation);
}
}
return AMediaMuxer_addTrack(mMuxer, trackFormat);
}
media_status_t start() override { return AMediaMuxer_start(mMuxer); }
media_status_t writeSampleData(size_t trackIndex, const uint8_t* data,
const AMediaCodecBufferInfo* info) override {
return AMediaMuxer_writeSampleData(mMuxer, trackIndex, data, info);
}
media_status_t stop() override { return AMediaMuxer_stop(mMuxer); }
// ~MediaSampleWriterMuxerInterface
static std::shared_ptr<DefaultMuxer> create(int fd) {
AMediaMuxer* ndkMuxer = AMediaMuxer_new(fd, AMEDIAMUXER_OUTPUT_FORMAT_MPEG_4);
if (ndkMuxer == nullptr) {
LOG(ERROR) << "Unable to create AMediaMuxer";
return nullptr;
}
return std::make_shared<DefaultMuxer>(ndkMuxer);
}
~DefaultMuxer() {
if (mMuxer != nullptr) {
AMediaMuxer_delete(mMuxer);
}
}
DefaultMuxer(AMediaMuxer* muxer) : mMuxer(muxer){};
DefaultMuxer() = delete;
private:
AMediaMuxer* mMuxer;
};
// static
std::shared_ptr<MediaSampleWriter> MediaSampleWriter::Create() {
return std::shared_ptr<MediaSampleWriter>(new MediaSampleWriter());
}
MediaSampleWriter::~MediaSampleWriter() {
if (mState == STARTED) {
stop();
}
}
bool MediaSampleWriter::init(int fd, const std::weak_ptr<CallbackInterface>& callbacks,
int64_t heartBeatIntervalUs) {
return init(DefaultMuxer::create(fd), callbacks, heartBeatIntervalUs);
}
bool MediaSampleWriter::init(const std::shared_ptr<MediaSampleWriterMuxerInterface>& muxer,
const std::weak_ptr<CallbackInterface>& callbacks,
int64_t heartBeatIntervalUs) {
if (callbacks.lock() == nullptr) {
LOG(ERROR) << "Callback object cannot be null";
return false;
} else if (muxer == nullptr) {
LOG(ERROR) << "Muxer cannot be null";
return false;
}
std::scoped_lock lock(mMutex);
if (mState != UNINITIALIZED) {
LOG(ERROR) << "Sample writer is already initialized";
return false;
}
mState = INITIALIZED;
mMuxer = muxer;
mCallbacks = callbacks;
mHeartBeatIntervalUs = heartBeatIntervalUs;
return true;
}
MediaSampleWriter::MediaSampleConsumerFunction MediaSampleWriter::addTrack(
const std::shared_ptr<AMediaFormat>& trackFormat) {
if (trackFormat == nullptr) {
LOG(ERROR) << "Track format must be non-null";
return nullptr;
}
std::scoped_lock lock(mMutex);
if (mState != INITIALIZED) {
LOG(ERROR) << "Muxer needs to be initialized when adding tracks.";
return nullptr;
}
AMediaFormat* trackFormatCopy = AMediaFormat_new();
AMediaFormat_copy(trackFormatCopy, trackFormat.get());
// Request muxer to use background priorities by default.
AMediaFormatUtils::SetDefaultFormatValueInt32(TBD_AMEDIACODEC_PARAMETER_KEY_BACKGROUND_MODE,
trackFormatCopy, 1 /* true */);
ssize_t trackIndexOrError = mMuxer->addTrack(trackFormatCopy);
AMediaFormat_delete(trackFormatCopy);
if (trackIndexOrError < 0) {
LOG(ERROR) << "Failed to add media track to muxer: " << trackIndexOrError;
return nullptr;
}
const size_t trackIndex = static_cast<size_t>(trackIndexOrError);
int64_t durationUs;
if (!AMediaFormat_getInt64(trackFormat.get(), AMEDIAFORMAT_KEY_DURATION, &durationUs)) {
durationUs = 0;
}
mTracks.emplace(trackIndex, durationUs);
std::shared_ptr<MediaSampleWriter> thisWriter = shared_from_this();
return [self = shared_from_this(), trackIndex](const std::shared_ptr<MediaSample>& sample) {
self->addSampleToTrack(trackIndex, sample);
};
}
void MediaSampleWriter::addSampleToTrack(size_t trackIndex,
const std::shared_ptr<MediaSample>& sample) {
if (sample == nullptr) return;
bool wasEmpty;
{
std::scoped_lock lock(mMutex);
wasEmpty = mSampleQueue.empty();
mSampleQueue.push(std::make_pair(trackIndex, sample));
}
if (wasEmpty) {
mSampleSignal.notify_one();
}
}
bool MediaSampleWriter::start() {
std::scoped_lock lock(mMutex);
if (mTracks.size() == 0) {
LOG(ERROR) << "No tracks to write.";
return false;
} else if (mState != INITIALIZED) {
LOG(ERROR) << "Sample writer is not initialized";
return false;
}
mState = STARTED;
std::thread([this] {
androidSetThreadPriority(0 /* tid (0 = current) */, ANDROID_PRIORITY_BACKGROUND);
prctl(PR_SET_NAME, (unsigned long)"SampleWriterTrd", 0, 0, 0);
bool wasStopped = false;
media_status_t status = writeSamples(&wasStopped);
if (auto callbacks = mCallbacks.lock()) {
if (wasStopped && status == AMEDIA_OK) {
callbacks->onStopped(this);
} else {
callbacks->onFinished(this, status);
}
}
}).detach();
return true;
}
void MediaSampleWriter::stop() {
{
std::scoped_lock lock(mMutex);
if (mState != STARTED) {
LOG(ERROR) << "Sample writer is not started.";
return;
}
mState = STOPPED;
}
mSampleSignal.notify_all();
}
media_status_t MediaSampleWriter::writeSamples(bool* wasStopped) {
media_status_t muxerStatus = mMuxer->start();
if (muxerStatus != AMEDIA_OK) {
LOG(ERROR) << "Error starting muxer: " << muxerStatus;
return muxerStatus;
}
media_status_t writeStatus = runWriterLoop(wasStopped);
if (writeStatus != AMEDIA_OK) {
LOG(ERROR) << "Error writing samples: " << writeStatus;
}
muxerStatus = mMuxer->stop();
if (muxerStatus != AMEDIA_OK) {
LOG(ERROR) << "Error stopping muxer: " << muxerStatus;
}
return writeStatus != AMEDIA_OK ? writeStatus : muxerStatus;
}
media_status_t MediaSampleWriter::runWriterLoop(bool* wasStopped) NO_THREAD_SAFETY_ANALYSIS {
AMediaCodecBufferInfo bufferInfo;
int32_t lastProgressUpdate = 0;
bool progressSinceLastReport = false;
int trackEosCount = 0;
// Set the "primary" track that will be used to determine progress to the track with longest
// duration.
int primaryTrackIndex = -1;
int64_t longestDurationUs = 0;
for (auto it = mTracks.begin(); it != mTracks.end(); ++it) {
if (it->second.mDurationUs > longestDurationUs) {
primaryTrackIndex = it->first;
longestDurationUs = it->second.mDurationUs;
}
}
std::chrono::microseconds updateInterval(mHeartBeatIntervalUs);
std::chrono::steady_clock::time_point nextUpdateTime =
std::chrono::steady_clock::now() + updateInterval;
while (true) {
if (trackEosCount >= mTracks.size()) {
break;
}
size_t trackIndex;
std::shared_ptr<MediaSample> sample;
{
std::unique_lock lock(mMutex);
while (mSampleQueue.empty() && mState == STARTED) {
if (mHeartBeatIntervalUs <= 0) {
mSampleSignal.wait(lock);
continue;
}
if (mSampleSignal.wait_until(lock, nextUpdateTime) == std::cv_status::timeout) {
// Send heart-beat if there is any progress since last update time.
if (progressSinceLastReport) {
if (auto callbacks = mCallbacks.lock()) {
callbacks->onHeartBeat(this);
}
progressSinceLastReport = false;
}
nextUpdateTime += updateInterval;
}
}
if (mState == STOPPED) {
*wasStopped = true;
return AMEDIA_OK;
}
auto& topEntry = mSampleQueue.top();
trackIndex = topEntry.first;
sample = topEntry.second;
mSampleQueue.pop();
}
TrackRecord& track = mTracks[trackIndex];
if (sample->info.flags & SAMPLE_FLAG_END_OF_STREAM) {
if (track.mReachedEos) {
continue;
}
// Track reached end of stream.
track.mReachedEos = true;
trackEosCount++;
// Preserve source track duration by setting the appropriate timestamp on the
// empty End-Of-Stream sample.
if (track.mDurationUs > 0 && track.mFirstSampleTimeSet) {
sample->info.presentationTimeUs = track.mDurationUs + track.mFirstSampleTimeUs;
}
}
track.mPrevSampleTimeUs = sample->info.presentationTimeUs;
if (!track.mFirstSampleTimeSet) {
// Record the first sample's timestamp in order to translate duration to EOS
// time for tracks that does not start at 0.
track.mFirstSampleTimeUs = sample->info.presentationTimeUs;
track.mFirstSampleTimeSet = true;
}
bufferInfo.offset = sample->dataOffset;
bufferInfo.size = sample->info.size;
bufferInfo.flags = sample->info.flags;
bufferInfo.presentationTimeUs = sample->info.presentationTimeUs;
media_status_t status = mMuxer->writeSampleData(trackIndex, sample->buffer, &bufferInfo);
if (status != AMEDIA_OK) {
LOG(ERROR) << "writeSampleData returned " << status;
return status;
}
sample.reset();
// TODO(lnilsson): Add option to toggle progress reporting on/off.
if (trackIndex == primaryTrackIndex) {
const int64_t elapsed = track.mPrevSampleTimeUs - track.mFirstSampleTimeUs;
int32_t progress = (elapsed * 100) / track.mDurationUs;
progress = std::clamp(progress, 0, 100);
if (progress > lastProgressUpdate) {
if (auto callbacks = mCallbacks.lock()) {
callbacks->onProgressUpdate(this, progress);
}
lastProgressUpdate = progress;
}
}
progressSinceLastReport = true;
}
return AMEDIA_OK;
}
} // namespace android