Merge "AAudio: add missing "Added in API level" annotation" into rvc-dev
diff --git a/camera/ICameraClient.cpp b/camera/ICameraClient.cpp
index 8620f36..487b8b0 100644
--- a/camera/ICameraClient.cpp
+++ b/camera/ICameraClient.cpp
@@ -143,6 +143,11 @@
if (data.dataAvail() > 0) {
metadata = new camera_frame_metadata_t;
metadata->number_of_faces = data.readInt32();
+ if (metadata->number_of_faces <= 0 ||
+ metadata->number_of_faces > (int32_t)(INT32_MAX / sizeof(camera_face_t))) {
+ ALOGE("%s: Too large face count: %d", __FUNCTION__, metadata->number_of_faces);
+ return BAD_VALUE;
+ }
metadata->faces = (camera_face_t *) data.readInplace(
sizeof(camera_face_t) * metadata->number_of_faces);
}
diff --git a/media/codec2/sfplugin/CCodecBufferChannel.cpp b/media/codec2/sfplugin/CCodecBufferChannel.cpp
index e2be991..e902b5d 100644
--- a/media/codec2/sfplugin/CCodecBufferChannel.cpp
+++ b/media/codec2/sfplugin/CCodecBufferChannel.cpp
@@ -44,6 +44,7 @@
#include <media/stagefright/MediaCodecConstants.h>
#include <media/stagefright/SkipCutBuffer.h>
#include <media/MediaCodecBuffer.h>
+#include <mediadrm/ICrypto.h>
#include <system/window.h>
#include "CCodecBufferChannel.h"
@@ -127,6 +128,97 @@
count->value = -1;
}
+// CCodecBufferChannel::ReorderStash
+
+CCodecBufferChannel::ReorderStash::ReorderStash() {
+ clear();
+}
+
+void CCodecBufferChannel::ReorderStash::clear() {
+ mPending.clear();
+ mStash.clear();
+ mDepth = 0;
+ mKey = C2Config::ORDINAL;
+}
+
+void CCodecBufferChannel::ReorderStash::flush() {
+ mPending.clear();
+ mStash.clear();
+}
+
+void CCodecBufferChannel::ReorderStash::setDepth(uint32_t depth) {
+ mPending.splice(mPending.end(), mStash);
+ mDepth = depth;
+}
+
+void CCodecBufferChannel::ReorderStash::setKey(C2Config::ordinal_key_t key) {
+ mPending.splice(mPending.end(), mStash);
+ mKey = key;
+}
+
+bool CCodecBufferChannel::ReorderStash::pop(Entry *entry) {
+ if (mPending.empty()) {
+ return false;
+ }
+ entry->buffer = mPending.front().buffer;
+ entry->timestamp = mPending.front().timestamp;
+ entry->flags = mPending.front().flags;
+ entry->ordinal = mPending.front().ordinal;
+ mPending.pop_front();
+ return true;
+}
+
+void CCodecBufferChannel::ReorderStash::emplace(
+ const std::shared_ptr<C2Buffer> &buffer,
+ int64_t timestamp,
+ int32_t flags,
+ const C2WorkOrdinalStruct &ordinal) {
+ bool eos = flags & MediaCodec::BUFFER_FLAG_EOS;
+ if (!buffer && eos) {
+ // TRICKY: we may be violating ordering of the stash here. Because we
+ // don't expect any more emplace() calls after this, the ordering should
+ // not matter.
+ mStash.emplace_back(buffer, timestamp, flags, ordinal);
+ } else {
+ flags = flags & ~MediaCodec::BUFFER_FLAG_EOS;
+ auto it = mStash.begin();
+ for (; it != mStash.end(); ++it) {
+ if (less(ordinal, it->ordinal)) {
+ break;
+ }
+ }
+ mStash.emplace(it, buffer, timestamp, flags, ordinal);
+ if (eos) {
+ mStash.back().flags = mStash.back().flags | MediaCodec::BUFFER_FLAG_EOS;
+ }
+ }
+ while (!mStash.empty() && mStash.size() > mDepth) {
+ mPending.push_back(mStash.front());
+ mStash.pop_front();
+ }
+}
+
+void CCodecBufferChannel::ReorderStash::defer(
+ const CCodecBufferChannel::ReorderStash::Entry &entry) {
+ mPending.push_front(entry);
+}
+
+bool CCodecBufferChannel::ReorderStash::hasPending() const {
+ return !mPending.empty();
+}
+
+bool CCodecBufferChannel::ReorderStash::less(
+ const C2WorkOrdinalStruct &o1, const C2WorkOrdinalStruct &o2) {
+ switch (mKey) {
+ case C2Config::ORDINAL: return o1.frameIndex < o2.frameIndex;
+ case C2Config::TIMESTAMP: return o1.timestamp < o2.timestamp;
+ case C2Config::CUSTOM: return o1.customOrdinal < o2.customOrdinal;
+ default:
+ ALOGD("Unrecognized key; default to timestamp");
+ return o1.frameIndex < o2.frameIndex;
+ }
+}
+
// Input
CCodecBufferChannel::Input::Input() : extraBuffers("extra") {}
@@ -616,7 +708,7 @@
void CCodecBufferChannel::feedInputBufferIfAvailableInternal() {
if (mInputMetEos ||
- mOutput.lock()->buffers->hasPending() ||
+ mReorderStash.lock()->hasPending() ||
mPipelineWatcher.lock()->pipelineFull()) {
return;
} else {
@@ -889,6 +981,17 @@
return UNKNOWN_ERROR;
}
+ {
+ Mutexed<ReorderStash>::Locked reorder(mReorderStash);
+ reorder->clear();
+ if (reorderDepth) {
+ reorder->setDepth(reorderDepth.value);
+ }
+ if (reorderKey) {
+ reorder->setKey(reorderKey.value);
+ }
+ }
+
uint32_t inputDelayValue = inputDelay ? inputDelay.value : 0;
uint32_t pipelineDelayValue = pipelineDelay ? pipelineDelay.value : 0;
uint32_t outputDelayValue = outputDelay ? outputDelay.value : 0;
@@ -982,7 +1085,7 @@
// TODO: handle this without going into array mode
forceArrayMode = true;
} else {
- input->buffers.reset(new GraphicInputBuffers(numInputSlots, mName));
+ input->buffers.reset(new GraphicInputBuffers(mName));
}
} else {
if (hasCryptoOrDescrambler()) {
@@ -1150,20 +1253,13 @@
if (outputSurface || !buffersBoundToCodec) {
output->buffers.reset(new GraphicOutputBuffers(mName));
} else {
- output->buffers.reset(new RawGraphicOutputBuffers(numOutputSlots, mName));
+ output->buffers.reset(new RawGraphicOutputBuffers(mName));
}
} else {
output->buffers.reset(new LinearOutputBuffers(mName));
}
output->buffers->setFormat(outputFormat);
- output->buffers->clearStash();
- if (reorderDepth) {
- output->buffers->setReorderDepth(reorderDepth.value);
- }
- if (reorderKey) {
- output->buffers->setReorderKey(reorderKey.value);
- }
// Try to set output surface to created block pool if given.
if (outputSurface) {
@@ -1331,8 +1427,8 @@
{
Mutexed<Output>::Locked output(mOutput);
output->buffers->flush(flushedWork);
- output->buffers->flushStash();
}
+ mReorderStash.lock()->flush();
mPipelineWatcher.lock()->flush();
}
@@ -1368,34 +1464,45 @@
std::unique_ptr<C2Work> work,
const sp<AMessage> &outputFormat,
const C2StreamInitDataInfo::output *initData) {
- // Whether the output buffer should be reported to the client or not.
- bool notifyClient = false;
+ if (outputFormat != nullptr) {
+ Mutexed<Output>::Locked output(mOutput);
+ ALOGD("[%s] onWorkDone: output format changed to %s",
+ mName, outputFormat->debugString().c_str());
+ output->buffers->setFormat(outputFormat);
- if (work->result == C2_OK){
- notifyClient = true;
- } else if (work->result == C2_NOT_FOUND) {
- ALOGD("[%s] flushed work; ignored.", mName);
- } else {
- // C2_OK and C2_NOT_FOUND are the only results that we accept for processing
- // the config update.
- ALOGD("[%s] work failed to complete: %d", mName, work->result);
- mCCodecCallback->onError(work->result, ACTION_CODE_FATAL);
- return false;
+ AString mediaType;
+ if (outputFormat->findString(KEY_MIME, &mediaType)
+ && mediaType == MIMETYPE_AUDIO_RAW) {
+ int32_t channelCount;
+ int32_t sampleRate;
+ if (outputFormat->findInt32(KEY_CHANNEL_COUNT, &channelCount)
+ && outputFormat->findInt32(KEY_SAMPLE_RATE, &sampleRate)) {
+ output->buffers->updateSkipCutBuffer(sampleRate, channelCount);
+ }
+ }
}
- if ((work->input.ordinal.frameIndex -
- mFirstValidFrameIndex.load()).peek() < 0) {
+ if ((work->input.ordinal.frameIndex - mFirstValidFrameIndex.load()).peek() < 0) {
// Discard frames from previous generation.
ALOGD("[%s] Discard frames from previous generation.", mName);
- notifyClient = false;
+ return false;
}
if (mInputSurface == nullptr && (work->worklets.size() != 1u
|| !work->worklets.front()
- || !(work->worklets.front()->output.flags &
- C2FrameData::FLAG_INCOMPLETE))) {
- mPipelineWatcher.lock()->onWorkDone(
- work->input.ordinal.frameIndex.peeku());
+ || !(work->worklets.front()->output.flags & C2FrameData::FLAG_INCOMPLETE))) {
+ mPipelineWatcher.lock()->onWorkDone(work->input.ordinal.frameIndex.peeku());
+ }
+
+ if (work->result == C2_NOT_FOUND) {
+ ALOGD("[%s] flushed work; ignored.", mName);
+ return true;
+ }
+
+ if (work->result != C2_OK) {
+ ALOGD("[%s] work failed to complete: %d", mName, work->result);
+ mCCodecCallback->onError(work->result, ACTION_CODE_FATAL);
+ return false;
}
// NOTE: MediaCodec usage supposedly have only one worklet
@@ -1431,10 +1538,8 @@
case C2PortReorderBufferDepthTuning::CORE_INDEX: {
C2PortReorderBufferDepthTuning::output reorderDepth;
if (reorderDepth.updateFrom(*param)) {
- bool secure = mComponent->getName().find(".secure") !=
- std::string::npos;
- mOutput.lock()->buffers->setReorderDepth(
- reorderDepth.value);
+ bool secure = mComponent->getName().find(".secure") != std::string::npos;
+ mReorderStash.lock()->setDepth(reorderDepth.value);
ALOGV("[%s] onWorkDone: updated reorder depth to %u",
mName, reorderDepth.value);
size_t numOutputSlots = mOutput.lock()->numSlots;
@@ -1446,19 +1551,17 @@
output->maxDequeueBuffers += numInputSlots;
}
if (output->surface) {
- output->surface->setMaxDequeuedBufferCount(
- output->maxDequeueBuffers);
+ output->surface->setMaxDequeuedBufferCount(output->maxDequeueBuffers);
}
} else {
- ALOGD("[%s] onWorkDone: failed to read reorder depth",
- mName);
+ ALOGD("[%s] onWorkDone: failed to read reorder depth", mName);
}
break;
}
case C2PortReorderKeySetting::CORE_INDEX: {
C2PortReorderKeySetting::output reorderKey;
if (reorderKey.updateFrom(*param)) {
- mOutput.lock()->buffers->setReorderKey(reorderKey.value);
+ mReorderStash.lock()->setKey(reorderKey.value);
ALOGV("[%s] onWorkDone: updated reorder key to %u",
mName, reorderKey.value);
} else {
@@ -1473,8 +1576,7 @@
ALOGV("[%s] onWorkDone: updating pipeline delay %u",
mName, pipelineDelay.value);
newPipelineDelay = pipelineDelay.value;
- (void)mPipelineWatcher.lock()->pipelineDelay(
- pipelineDelay.value);
+ (void)mPipelineWatcher.lock()->pipelineDelay(pipelineDelay.value);
}
}
if (param->forInput()) {
@@ -1483,8 +1585,7 @@
ALOGV("[%s] onWorkDone: updating input delay %u",
mName, inputDelay.value);
newInputDelay = inputDelay.value;
- (void)mPipelineWatcher.lock()->inputDelay(
- inputDelay.value);
+ (void)mPipelineWatcher.lock()->inputDelay(inputDelay.value);
}
}
if (param->forOutput()) {
@@ -1492,10 +1593,8 @@
if (outputDelay.updateFrom(*param)) {
ALOGV("[%s] onWorkDone: updating output delay %u",
mName, outputDelay.value);
- bool secure = mComponent->getName().find(".secure") !=
- std::string::npos;
- (void)mPipelineWatcher.lock()->outputDelay(
- outputDelay.value);
+ bool secure = mComponent->getName().find(".secure") != std::string::npos;
+ (void)mPipelineWatcher.lock()->outputDelay(outputDelay.value);
bool outputBuffersChanged = false;
size_t numOutputSlots = 0;
@@ -1503,8 +1602,7 @@
{
Mutexed<Output>::Locked output(mOutput);
output->outputDelay = outputDelay.value;
- numOutputSlots = outputDelay.value +
- kSmoothnessFactor;
+ numOutputSlots = outputDelay.value + kSmoothnessFactor;
if (output->numSlots < numOutputSlots) {
output->numSlots = numOutputSlots;
if (output->buffers->isArrayMode()) {
@@ -1523,7 +1621,7 @@
mCCodecCallback->onOutputBuffersChanged();
}
- uint32_t depth = mOutput.lock()->buffers->getReorderDepth();
+ uint32_t depth = mReorderStash.lock()->depth();
Mutexed<OutputSurface>::Locked output(mOutputSurface);
output->maxDequeueBuffers = numOutputSlots + depth + kRenderingDepth;
if (!secure) {
@@ -1567,6 +1665,9 @@
ALOGV("[%s] onWorkDone: output EOS", mName);
}
+ sp<MediaCodecBuffer> outBuffer;
+ size_t index;
+
// WORKAROUND: adjust output timestamp based on client input timestamp and codec
// input timestamp. Codec output timestamp (in the timestamp field) shall correspond to
// the codec input timestamp, but client output timestamp should (reported in timeUs)
@@ -1587,18 +1688,8 @@
worklet->output.ordinal.timestamp.peekll(),
timestamp.peekll());
- // csd cannot be re-ordered and will always arrive first.
if (initData != nullptr) {
Mutexed<Output>::Locked output(mOutput);
- if (outputFormat) {
- output->buffers->updateSkipCutBuffer(outputFormat);
- output->buffers->setFormat(outputFormat);
- }
- if (!notifyClient) {
- return false;
- }
- size_t index;
- sp<MediaCodecBuffer> outBuffer;
if (output->buffers->registerCsd(initData, &index, &outBuffer) == OK) {
outBuffer->meta()->setInt64("timeUs", timestamp.peek());
outBuffer->meta()->setInt32("flags", MediaCodec::BUFFER_FLAG_CODECCONFIG);
@@ -1614,10 +1705,10 @@
}
}
- if (notifyClient && !buffer && !flags) {
+ if (!buffer && !flags) {
ALOGV("[%s] onWorkDone: Not reporting output buffer (%lld)",
mName, work->input.ordinal.frameIndex.peekull());
- notifyClient = false;
+ return true;
}
if (buffer) {
@@ -1636,60 +1727,63 @@
}
{
- Mutexed<Output>::Locked output(mOutput);
- output->buffers->pushToStash(
- buffer,
- notifyClient,
- timestamp.peek(),
- flags,
- outputFormat,
- worklet->output.ordinal);
+ Mutexed<ReorderStash>::Locked reorder(mReorderStash);
+ reorder->emplace(buffer, timestamp.peek(), flags, worklet->output.ordinal);
+ if (flags & MediaCodec::BUFFER_FLAG_EOS) {
+ // Flush reorder stash
+ reorder->setDepth(0);
+ }
}
sendOutputBuffers();
return true;
}
void CCodecBufferChannel::sendOutputBuffers() {
- OutputBuffers::BufferAction action;
- size_t index;
+ ReorderStash::Entry entry;
sp<MediaCodecBuffer> outBuffer;
- std::shared_ptr<C2Buffer> c2Buffer;
+ size_t index;
while (true) {
+ Mutexed<ReorderStash>::Locked reorder(mReorderStash);
+ if (!reorder->hasPending()) {
+ break;
+ }
+ if (!reorder->pop(&entry)) {
+ break;
+ }
+
Mutexed<Output>::Locked output(mOutput);
- action = output->buffers->popFromStashAndRegister(
- &c2Buffer, &index, &outBuffer);
- switch (action) {
- case OutputBuffers::SKIP:
- return;
- case OutputBuffers::DISCARD:
- break;
- case OutputBuffers::NOTIFY_CLIENT:
- output.unlock();
- mCallback->onOutputBufferAvailable(index, outBuffer);
- break;
- case OutputBuffers::REALLOCATE: {
+ status_t err = output->buffers->registerBuffer(entry.buffer, &index, &outBuffer);
+ if (err != OK) {
+ bool outputBuffersChanged = false;
+ if (err != WOULD_BLOCK) {
if (!output->buffers->isArrayMode()) {
- output->buffers =
- output->buffers->toArrayMode(output->numSlots);
+ output->buffers = output->buffers->toArrayMode(output->numSlots);
}
- static_cast<OutputBuffersArray*>(output->buffers.get())->
- realloc(c2Buffer);
- output.unlock();
+ OutputBuffersArray *array = (OutputBuffersArray *)output->buffers.get();
+ array->realloc(entry.buffer);
+ outputBuffersChanged = true;
+ }
+ ALOGV("[%s] sendOutputBuffers: unable to register output buffer", mName);
+ reorder->defer(entry);
+
+ output.unlock();
+ reorder.unlock();
+
+ if (outputBuffersChanged) {
mCCodecCallback->onOutputBuffersChanged();
}
return;
- case OutputBuffers::RETRY:
- ALOGV("[%s] sendOutputBuffers: unable to register output buffer",
- mName);
- return;
- default:
- LOG_ALWAYS_FATAL("[%s] sendOutputBuffers: "
- "corrupted BufferAction value (%d) "
- "returned from popFromStashAndRegister.",
- mName, int(action));
- return;
}
+ output.unlock();
+ reorder.unlock();
+
+ outBuffer->meta()->setInt64("timeUs", entry.timestamp);
+ outBuffer->meta()->setInt32("flags", entry.flags);
+ ALOGV("[%s] sendOutputBuffers: out buffer index = %zu [%p] => %p + %zu (%lld)",
+ mName, index, outBuffer.get(), outBuffer->data(), outBuffer->size(),
+ (long long)entry.timestamp);
+ mCallback->onOutputBufferAvailable(index, outBuffer);
}
}
diff --git a/media/codec2/sfplugin/CCodecBufferChannel.h b/media/codec2/sfplugin/CCodecBufferChannel.h
index da15724..0263211 100644
--- a/media/codec2/sfplugin/CCodecBufferChannel.h
+++ b/media/codec2/sfplugin/CCodecBufferChannel.h
@@ -296,6 +296,48 @@
Mutexed<PipelineWatcher> mPipelineWatcher;
+ class ReorderStash {
+ public:
+ struct Entry {
+ inline Entry() : buffer(nullptr), timestamp(0), flags(0), ordinal({0, 0, 0}) {}
+ inline Entry(
+ const std::shared_ptr<C2Buffer> &b,
+ int64_t t,
+ int32_t f,
+ const C2WorkOrdinalStruct &o)
+ : buffer(b), timestamp(t), flags(f), ordinal(o) {}
+ std::shared_ptr<C2Buffer> buffer;
+ int64_t timestamp;
+ int32_t flags;
+ C2WorkOrdinalStruct ordinal;
+ };
+
+ ReorderStash();
+
+ void clear();
+ void flush();
+ void setDepth(uint32_t depth);
+ void setKey(C2Config::ordinal_key_t key);
+ bool pop(Entry *entry);
+ void emplace(
+ const std::shared_ptr<C2Buffer> &buffer,
+ int64_t timestamp,
+ int32_t flags,
+ const C2WorkOrdinalStruct &ordinal);
+ void defer(const Entry &entry);
+ bool hasPending() const;
+ uint32_t depth() const { return mDepth; }
+
+ private:
+ std::list<Entry> mPending;
+ std::list<Entry> mStash;
+ uint32_t mDepth;
+ C2Config::ordinal_key_t mKey;
+
+ bool less(const C2WorkOrdinalStruct &o1, const C2WorkOrdinalStruct &o2);
+ };
+ Mutexed<ReorderStash> mReorderStash;
+
std::atomic_bool mInputMetEos;
std::once_flag mRenderWarningFlag;
diff --git a/media/codec2/sfplugin/CCodecBuffers.cpp b/media/codec2/sfplugin/CCodecBuffers.cpp
index 4ce13aa..a9120c4 100644
--- a/media/codec2/sfplugin/CCodecBuffers.cpp
+++ b/media/codec2/sfplugin/CCodecBuffers.cpp
@@ -21,9 +21,9 @@
#include <C2PlatformSupport.h>
#include <media/stagefright/foundation/ADebug.h>
-#include <media/stagefright/MediaCodec.h>
#include <media/stagefright/MediaCodecConstants.h>
#include <media/stagefright/SkipCutBuffer.h>
+#include <mediadrm/ICrypto.h>
#include "CCodecBuffers.h"
@@ -122,6 +122,11 @@
// OutputBuffers
+OutputBuffers::OutputBuffers(const char *componentName, const char *name)
+ : CCodecBuffers(componentName, name) { }
+
+OutputBuffers::~OutputBuffers() = default;
+
void OutputBuffers::initSkipCutBuffer(
int32_t delay, int32_t padding, int32_t sampleRate, int32_t channelCount) {
CHECK(mSkipCutBuffer == nullptr);
@@ -150,29 +155,16 @@
setSkipCutBuffer(delay, padding);
}
-void OutputBuffers::updateSkipCutBuffer(
- const sp<AMessage> &format, bool notify) {
- AString mediaType;
- if (format->findString(KEY_MIME, &mediaType)
- && mediaType == MIMETYPE_AUDIO_RAW) {
- int32_t channelCount;
- int32_t sampleRate;
- if (format->findInt32(KEY_CHANNEL_COUNT, &channelCount)
- && format->findInt32(KEY_SAMPLE_RATE, &sampleRate)) {
- updateSkipCutBuffer(sampleRate, channelCount);
- }
- }
- if (notify) {
- mUnreportedFormat = nullptr;
- }
-}
-
void OutputBuffers::submit(const sp<MediaCodecBuffer> &buffer) {
if (mSkipCutBuffer != nullptr) {
mSkipCutBuffer->submit(buffer);
}
}
+void OutputBuffers::transferSkipCutBuffer(const sp<SkipCutBuffer> &scb) {
+ mSkipCutBuffer = scb;
+}
+
void OutputBuffers::setSkipCutBuffer(int32_t skip, int32_t cut) {
if (mSkipCutBuffer != nullptr) {
size_t prevSize = mSkipCutBuffer->size();
@@ -183,179 +175,13 @@
mSkipCutBuffer = new SkipCutBuffer(skip, cut, mChannelCount);
}
-void OutputBuffers::clearStash() {
- mPending.clear();
- mReorderStash.clear();
- mDepth = 0;
- mKey = C2Config::ORDINAL;
- mUnreportedFormat = nullptr;
-}
-
-void OutputBuffers::flushStash() {
- for (StashEntry& e : mPending) {
- e.notify = false;
- }
- for (StashEntry& e : mReorderStash) {
- e.notify = false;
- }
-}
-
-uint32_t OutputBuffers::getReorderDepth() const {
- return mDepth;
-}
-
-void OutputBuffers::setReorderDepth(uint32_t depth) {
- mPending.splice(mPending.end(), mReorderStash);
- mDepth = depth;
-}
-
-void OutputBuffers::setReorderKey(C2Config::ordinal_key_t key) {
- mPending.splice(mPending.end(), mReorderStash);
- mKey = key;
-}
-
-void OutputBuffers::pushToStash(
- const std::shared_ptr<C2Buffer>& buffer,
- bool notify,
- int64_t timestamp,
- int32_t flags,
- const sp<AMessage>& format,
- const C2WorkOrdinalStruct& ordinal) {
- bool eos = flags & MediaCodec::BUFFER_FLAG_EOS;
- if (!buffer && eos) {
- // TRICKY: we may be violating ordering of the stash here. Because we
- // don't expect any more emplace() calls after this, the ordering should
- // not matter.
- mReorderStash.emplace_back(
- buffer, notify, timestamp, flags, format, ordinal);
- } else {
- flags = flags & ~MediaCodec::BUFFER_FLAG_EOS;
- auto it = mReorderStash.begin();
- for (; it != mReorderStash.end(); ++it) {
- if (less(ordinal, it->ordinal)) {
- break;
- }
- }
- mReorderStash.emplace(it,
- buffer, notify, timestamp, flags, format, ordinal);
- if (eos) {
- mReorderStash.back().flags =
- mReorderStash.back().flags | MediaCodec::BUFFER_FLAG_EOS;
- }
- }
- while (!mReorderStash.empty() && mReorderStash.size() > mDepth) {
- mPending.push_back(mReorderStash.front());
- mReorderStash.pop_front();
- }
- ALOGV("[%s] %s: pushToStash -- pending size = %zu", mName, __func__, mPending.size());
-}
-
-OutputBuffers::BufferAction OutputBuffers::popFromStashAndRegister(
- std::shared_ptr<C2Buffer>* c2Buffer,
- size_t* index,
- sp<MediaCodecBuffer>* outBuffer) {
- if (mPending.empty()) {
- return SKIP;
- }
-
- // Retrieve the first entry.
- StashEntry &entry = mPending.front();
-
- *c2Buffer = entry.buffer;
- sp<AMessage> outputFormat = entry.format;
-
- // The output format can be processed without a registered slot.
- if (outputFormat) {
- ALOGD("[%s] popFromStashAndRegister: output format changed to %s",
- mName, outputFormat->debugString().c_str());
- updateSkipCutBuffer(outputFormat, entry.notify);
- }
-
- if (entry.notify) {
- if (outputFormat) {
- setFormat(outputFormat);
- } else if (mUnreportedFormat) {
- outputFormat = mUnreportedFormat->dup();
- setFormat(outputFormat);
- }
- mUnreportedFormat = nullptr;
- } else {
- if (outputFormat) {
- mUnreportedFormat = outputFormat;
- } else if (!mUnreportedFormat) {
- mUnreportedFormat = mFormat;
- }
- }
-
- // Flushing mReorderStash because no other buffers should come after output
- // EOS.
- if (entry.flags & MediaCodec::BUFFER_FLAG_EOS) {
- // Flush reorder stash
- setReorderDepth(0);
- }
-
- if (!entry.notify) {
- mPending.pop_front();
- return DISCARD;
- }
-
- // Try to register the buffer.
- status_t err = registerBuffer(*c2Buffer, index, outBuffer);
- if (err != OK) {
- if (err != WOULD_BLOCK) {
- return REALLOCATE;
- }
- return RETRY;
- }
-
- // Append information from the front stash entry to outBuffer.
- (*outBuffer)->meta()->setInt64("timeUs", entry.timestamp);
- (*outBuffer)->meta()->setInt32("flags", entry.flags);
- ALOGV("[%s] popFromStashAndRegister: "
- "out buffer index = %zu [%p] => %p + %zu (%lld)",
- mName, *index, outBuffer->get(),
- (*outBuffer)->data(), (*outBuffer)->size(),
- (long long)entry.timestamp);
-
- // The front entry of mPending will be removed now that the registration
- // succeeded.
- mPending.pop_front();
- return NOTIFY_CLIENT;
-}
-
-bool OutputBuffers::popPending(StashEntry *entry) {
- if (mPending.empty()) {
- return false;
- }
- *entry = mPending.front();
- mPending.pop_front();
- return true;
-}
-
-void OutputBuffers::deferPending(const OutputBuffers::StashEntry &entry) {
- mPending.push_front(entry);
-}
-
-bool OutputBuffers::hasPending() const {
- return !mPending.empty();
-}
-
-bool OutputBuffers::less(
- const C2WorkOrdinalStruct &o1, const C2WorkOrdinalStruct &o2) const {
- switch (mKey) {
- case C2Config::ORDINAL: return o1.frameIndex < o2.frameIndex;
- case C2Config::TIMESTAMP: return o1.timestamp < o2.timestamp;
- case C2Config::CUSTOM: return o1.customOrdinal < o2.customOrdinal;
- default:
- ALOGD("Unrecognized key; default to timestamp");
- return o1.frameIndex < o2.frameIndex;
- }
-}
-
// LocalBufferPool
-std::shared_ptr<LocalBufferPool> LocalBufferPool::Create(size_t poolCapacity) {
- return std::shared_ptr<LocalBufferPool>(new LocalBufferPool(poolCapacity));
+constexpr size_t kInitialPoolCapacity = kMaxLinearBufferSize;
+constexpr size_t kMaxPoolCapacity = kMaxLinearBufferSize * 32;
+
+std::shared_ptr<LocalBufferPool> LocalBufferPool::Create() {
+ return std::shared_ptr<LocalBufferPool>(new LocalBufferPool(kInitialPoolCapacity));
}
sp<ABuffer> LocalBufferPool::newBuffer(size_t capacity) {
@@ -375,6 +201,11 @@
mUsedSize -= mPool.back().capacity();
mPool.pop_back();
}
+ while (mUsedSize + capacity > mPoolCapacity && mPoolCapacity * 2 <= kMaxPoolCapacity) {
+ ALOGD("Increasing local buffer pool capacity from %zu to %zu",
+ mPoolCapacity, mPoolCapacity * 2);
+ mPoolCapacity *= 2;
+ }
if (mUsedSize + capacity > mPoolCapacity) {
ALOGD("mUsedSize = %zu, capacity = %zu, mPoolCapacity = %zu",
mUsedSize, capacity, mPoolCapacity);
@@ -960,11 +791,10 @@
// GraphicInputBuffers
GraphicInputBuffers::GraphicInputBuffers(
- size_t numInputSlots, const char *componentName, const char *name)
+ const char *componentName, const char *name)
: InputBuffers(componentName, name),
mImpl(mName),
- mLocalBufferPool(LocalBufferPool::Create(
- kMaxLinearBufferSize * numInputSlots)) { }
+ mLocalBufferPool(LocalBufferPool::Create()) { }
bool GraphicInputBuffers::requestNewBuffer(size_t *index, sp<MediaCodecBuffer> *buffer) {
sp<Codec2Buffer> newBuffer = createNewBuffer();
@@ -1125,7 +955,7 @@
case C2BufferData::GRAPHIC: {
// This is only called for RawGraphicOutputBuffers.
mAlloc = [format = mFormat,
- lbp = LocalBufferPool::Create(kMaxLinearBufferSize * mImpl.arraySize())] {
+ lbp = LocalBufferPool::Create()] {
return ConstGraphicBlockBuffer::AllocateEmpty(
format,
[lbp](size_t capacity) {
@@ -1151,16 +981,6 @@
mImpl.grow(newSize, mAlloc);
}
-void OutputBuffersArray::transferFrom(OutputBuffers* source) {
- mFormat = source->mFormat;
- mSkipCutBuffer = source->mSkipCutBuffer;
- mUnreportedFormat = source->mUnreportedFormat;
- mPending = std::move(source->mPending);
- mReorderStash = std::move(source->mReorderStash);
- mDepth = source->mDepth;
- mKey = source->mKey;
-}
-
// FlexOutputBuffers
status_t FlexOutputBuffers::registerBuffer(
@@ -1203,12 +1023,13 @@
// track of the flushed work.
}
-std::unique_ptr<OutputBuffersArray> FlexOutputBuffers::toArrayMode(size_t size) {
+std::unique_ptr<OutputBuffers> FlexOutputBuffers::toArrayMode(size_t size) {
std::unique_ptr<OutputBuffersArray> array(new OutputBuffersArray(mComponentName.c_str()));
- array->transferFrom(this);
+ array->setFormat(mFormat);
+ array->transferSkipCutBuffer(mSkipCutBuffer);
std::function<sp<Codec2Buffer>()> alloc = getAlloc();
array->initialize(mImpl, size, alloc);
- return array;
+ return std::move(array);
}
size_t FlexOutputBuffers::numClientBuffers() const {
@@ -1271,10 +1092,9 @@
// RawGraphicOutputBuffers
RawGraphicOutputBuffers::RawGraphicOutputBuffers(
- size_t numOutputSlots, const char *componentName, const char *name)
+ const char *componentName, const char *name)
: FlexOutputBuffers(componentName, name),
- mLocalBufferPool(LocalBufferPool::Create(
- kMaxLinearBufferSize * numOutputSlots)) { }
+ mLocalBufferPool(LocalBufferPool::Create()) { }
sp<Codec2Buffer> RawGraphicOutputBuffers::wrap(const std::shared_ptr<C2Buffer> &buffer) {
if (buffer == nullptr) {
diff --git a/media/codec2/sfplugin/CCodecBuffers.h b/media/codec2/sfplugin/CCodecBuffers.h
index cadc4d8..6244acd 100644
--- a/media/codec2/sfplugin/CCodecBuffers.h
+++ b/media/codec2/sfplugin/CCodecBuffers.h
@@ -28,6 +28,8 @@
namespace android {
+struct ICrypto;
+class MemoryDealer;
class SkipCutBuffer;
constexpr size_t kLinearBufferSize = 1048576;
@@ -154,22 +156,15 @@
DISALLOW_EVIL_CONSTRUCTORS(InputBuffers);
};
-class OutputBuffersArray;
-
class OutputBuffers : public CCodecBuffers {
public:
- OutputBuffers(const char *componentName, const char *name = "Output")
- : CCodecBuffers(componentName, name) { }
- virtual ~OutputBuffers() = default;
+ OutputBuffers(const char *componentName, const char *name = "Output");
+ virtual ~OutputBuffers();
/**
* Register output C2Buffer from the component and obtain corresponding
- * index and MediaCodecBuffer object.
- *
- * Returns:
- * OK if registration succeeds.
- * NO_MEMORY if all buffers are available but not compatible.
- * WOULD_BLOCK if there are compatible buffers, but they are all in use.
+ * index and MediaCodecBuffer object. Returns false if registration
+ * fails.
*/
virtual status_t registerBuffer(
const std::shared_ptr<C2Buffer> &buffer,
@@ -204,7 +199,7 @@
* shall retain the internal state so that it will honor index and
* buffer from previous calls of registerBuffer().
*/
- virtual std::unique_ptr<OutputBuffersArray> toArrayMode(size_t size) = 0;
+ virtual std::unique_ptr<OutputBuffers> toArrayMode(size_t size) = 0;
/**
* Initialize SkipCutBuffer object.
@@ -213,164 +208,6 @@
int32_t delay, int32_t padding, int32_t sampleRate, int32_t channelCount);
/**
- * Update SkipCutBuffer from format. The @p format must not be null.
- * @p notify determines whether the format comes with a buffer that should
- * be reported to the client or not.
- */
- void updateSkipCutBuffer(const sp<AMessage> &format, bool notify = true);
-
- /**
- * Output Stash
- * ============
- *
- * The output stash is a place to hold output buffers temporarily before
- * they are registered to output slots. It has 2 main functions:
- * 1. Allow reordering of output frames as the codec may produce frames in a
- * different order.
- * 2. Act as a "buffer" between the codec and the client because the codec
- * may produce more buffers than available slots. This excess of codec's
- * output buffers should be registered to slots later, after the client
- * has released some slots.
- *
- * The stash consists of 2 lists of buffers: mPending and mReorderStash.
- * mPending is a normal FIFO queue with not size limit, while mReorderStash
- * is a sorted list with size limit mDepth.
- *
- * The normal flow of a non-csd output buffer is as follows:
- *
- * |----------------OutputBuffers---------------|
- * |----------Output stash----------| |
- * Codec --|-> mReorderStash --> mPending --|-> slots --|-> client
- * | | |
- * pushToStash() popFromStashAndRegister()
- *
- * The buffer that comes from the codec first enters mReorderStash. The
- * first buffer in mReorderStash gets moved to mPending when mReorderStash
- * overflows. Buffers in mPending are registered to slots and given to the
- * client as soon as slots are available.
- *
- * Every output buffer that is not a csd buffer should be put on the stash
- * by calling pushToStash(), then later registered to a slot by calling
- * popFromStashAndRegister() before notifying the client with
- * onOutputBufferAvailable().
- *
- * Reordering
- * ==========
- *
- * mReorderStash is a sorted list with a specified size limit. The size
- * limit can be set by calling setReorderDepth().
- *
- * Every buffer in mReorderStash has a C2WorkOrdinalStruct, which contains 3
- * members, all of which are comparable. Which member of C2WorkOrdinalStruct
- * should be used for reordering can be chosen by calling setReorderKey().
- */
-
- /**
- * Return the reorder depth---the size of mReorderStash.
- */
- uint32_t getReorderDepth() const;
-
- /**
- * Set the reorder depth.
- */
- void setReorderDepth(uint32_t depth);
-
- /**
- * Set the type of "key" to use in comparisons.
- */
- void setReorderKey(C2Config::ordinal_key_t key);
-
- /**
- * Return whether the output stash has any pending buffers.
- */
- bool hasPending() const;
-
- /**
- * Flush the stash and reset the depth and the key to their default values.
- */
- void clearStash();
-
- /**
- * Flush the stash.
- */
- void flushStash();
-
- /**
- * Push a buffer to the reorder stash.
- *
- * @param buffer C2Buffer object from the returned work.
- * @param notify Whether the returned work contains a buffer that should
- * be reported to the client. This may be false if the
- * caller wants to process the buffer without notifying the
- * client.
- * @param timestamp Buffer timestamp to report to the client.
- * @param flags Buffer flags to report to the client.
- * @param format Buffer format to report to the client.
- * @param ordinal Ordinal used in reordering. This determines when the
- * buffer will be popped from the output stash by
- * `popFromStashAndRegister()`.
- */
- void pushToStash(
- const std::shared_ptr<C2Buffer>& buffer,
- bool notify,
- int64_t timestamp,
- int32_t flags,
- const sp<AMessage>& format,
- const C2WorkOrdinalStruct& ordinal);
-
- enum BufferAction : int {
- SKIP,
- DISCARD,
- NOTIFY_CLIENT,
- REALLOCATE,
- RETRY,
- };
-
- /**
- * Try to atomically pop the first buffer from the reorder stash and
- * register it to an output slot. The function returns a value that
- * indicates a recommended course of action for the caller.
- *
- * If the stash is empty, the function will return `SKIP`.
- *
- * If the stash is not empty, the function will peek at the first (oldest)
- * entry in mPending process the buffer in the entry as follows:
- * - If the buffer should not be sent to the client, the function will
- * return `DISCARD`. The stash entry will be removed.
- * - If the buffer should be sent to the client, the function will attempt
- * to register the buffer to a slot. The registration may have 3 outcomes
- * corresponding to the following return values:
- * - `NOTIFY_CLIENT`: The buffer is successfully registered to a slot. The
- * output arguments @p index and @p outBuffer will contain valid values
- * that the caller can use to call onOutputBufferAvailable(). The stash
- * entry will be removed.
- * - `REALLOCATE`: The buffer is not registered because it is not
- * compatible with the current slots (which are available). The caller
- * should reallocate the OutputBuffers with slots that can fit the
- * returned @p c2Buffer. The stash entry will not be removed
- * - `RETRY`: All slots are currently occupied by the client. The caller
- * should try to call this function again after the client has released
- * some slots.
- *
- * @return What the caller should do afterwards.
- *
- * @param[out] c2Buffer Underlying C2Buffer associated to the first buffer
- * on the stash. This value is guaranteed to be valid
- * unless the return value is `SKIP`.
- * @param[out] index Slot index. This value is valid only if the return
- * value is `NOTIFY_CLIENT`.
- * @param[out] outBuffer Registered buffer. This value is valid only if the
- * return valu is `NOTIFY_CLIENT`.
- */
- BufferAction popFromStashAndRegister(
- std::shared_ptr<C2Buffer>* c2Buffer,
- size_t* index,
- sp<MediaCodecBuffer>* outBuffer);
-
-protected:
- sp<SkipCutBuffer> mSkipCutBuffer;
-
- /**
* Update the SkipCutBuffer object. No-op if it's never initialized.
*/
void updateSkipCutBuffer(int32_t sampleRate, int32_t channelCount);
@@ -380,8 +217,15 @@
*/
void submit(const sp<MediaCodecBuffer> &buffer);
+ /**
+ * Transfer SkipCutBuffer object to the other Buffers object.
+ */
+ void transferSkipCutBuffer(const sp<SkipCutBuffer> &scb);
+
+protected:
+ sp<SkipCutBuffer> mSkipCutBuffer;
+
private:
- // SkipCutBuffer
int32_t mDelay;
int32_t mPadding;
int32_t mSampleRate;
@@ -389,78 +233,7 @@
void setSkipCutBuffer(int32_t skip, int32_t cut);
- // Output stash
-
- // Output format that has not been made available to the client.
- sp<AMessage> mUnreportedFormat;
-
- // Struct for an entry in the output stash (mPending and mReorderStash)
- struct StashEntry {
- inline StashEntry()
- : buffer(nullptr),
- notify(false),
- timestamp(0),
- flags(0),
- format(),
- ordinal({0, 0, 0}) {}
- inline StashEntry(
- const std::shared_ptr<C2Buffer> &b,
- bool n,
- int64_t t,
- int32_t f,
- const sp<AMessage> &fmt,
- const C2WorkOrdinalStruct &o)
- : buffer(b),
- notify(n),
- timestamp(t),
- flags(f),
- format(fmt),
- ordinal(o) {}
- std::shared_ptr<C2Buffer> buffer;
- bool notify;
- int64_t timestamp;
- int32_t flags;
- sp<AMessage> format;
- C2WorkOrdinalStruct ordinal;
- };
-
- /**
- * FIFO queue of stash entries.
- */
- std::list<StashEntry> mPending;
- /**
- * Sorted list of stash entries.
- */
- std::list<StashEntry> mReorderStash;
- /**
- * Size limit of mReorderStash.
- */
- uint32_t mDepth{0};
- /**
- * Choice of key to use in ordering of stash entries in mReorderStash.
- */
- C2Config::ordinal_key_t mKey{C2Config::ORDINAL};
-
- /**
- * Return false if mPending is empty; otherwise, pop the first entry from
- * mPending and return true.
- */
- bool popPending(StashEntry *entry);
-
- /**
- * Push an entry as the first entry of mPending.
- */
- void deferPending(const StashEntry &entry);
-
- /**
- * Comparison of C2WorkOrdinalStruct based on mKey.
- */
- bool less(const C2WorkOrdinalStruct &o1,
- const C2WorkOrdinalStruct &o2) const;
-
DISALLOW_EVIL_CONSTRUCTORS(OutputBuffers);
-
- friend OutputBuffersArray;
};
/**
@@ -471,11 +244,9 @@
/**
* Create a new LocalBufferPool object.
*
- * \param poolCapacity max total size of buffers managed by this pool.
- *
* \return a newly created pool object.
*/
- static std::shared_ptr<LocalBufferPool> Create(size_t poolCapacity);
+ static std::shared_ptr<LocalBufferPool> Create();
/**
* Return an ABuffer object whose size is at least |capacity|.
@@ -907,8 +678,7 @@
class GraphicInputBuffers : public InputBuffers {
public:
- GraphicInputBuffers(
- size_t numInputSlots, const char *componentName, const char *name = "2D-BB-Input");
+ GraphicInputBuffers(const char *componentName, const char *name = "2D-BB-Input");
~GraphicInputBuffers() override = default;
bool requestNewBuffer(size_t *index, sp<MediaCodecBuffer> *buffer) override;
@@ -1000,7 +770,7 @@
bool isArrayMode() const final { return true; }
- std::unique_ptr<OutputBuffersArray> toArrayMode(size_t) final {
+ std::unique_ptr<OutputBuffers> toArrayMode(size_t) final {
return nullptr;
}
@@ -1039,12 +809,6 @@
*/
void grow(size_t newSize);
- /**
- * Transfer the SkipCutBuffer and the output stash from another
- * OutputBuffers.
- */
- void transferFrom(OutputBuffers* source);
-
private:
BuffersArrayImpl mImpl;
std::function<sp<Codec2Buffer>()> mAlloc;
@@ -1073,7 +837,7 @@
void flush(
const std::list<std::unique_ptr<C2Work>> &flushedWork) override;
- std::unique_ptr<OutputBuffersArray> toArrayMode(size_t size) override;
+ std::unique_ptr<OutputBuffers> toArrayMode(size_t size) override;
size_t numClientBuffers() const final;
@@ -1126,8 +890,7 @@
class RawGraphicOutputBuffers : public FlexOutputBuffers {
public:
- RawGraphicOutputBuffers(
- size_t numOutputSlots, const char *componentName, const char *name = "2D-BB-Output");
+ RawGraphicOutputBuffers(const char *componentName, const char *name = "2D-BB-Output");
~RawGraphicOutputBuffers() override = default;
sp<Codec2Buffer> wrap(const std::shared_ptr<C2Buffer> &buffer) override;
diff --git a/media/codec2/sfplugin/Codec2Buffer.cpp b/media/codec2/sfplugin/Codec2Buffer.cpp
index 5b3a62f..25e7da9 100644
--- a/media/codec2/sfplugin/Codec2Buffer.cpp
+++ b/media/codec2/sfplugin/Codec2Buffer.cpp
@@ -18,6 +18,8 @@
#define LOG_TAG "Codec2Buffer"
#include <utils/Log.h>
+#include <android/hardware/cas/native/1.0/types.h>
+#include <android/hardware/drm/1.0/types.h>
#include <hidlmemory/FrameworkUtils.h>
#include <media/hardware/HardwareAPI.h>
#include <media/stagefright/CodecBase.h>
@@ -25,6 +27,7 @@
#include <media/stagefright/foundation/ABuffer.h>
#include <media/stagefright/foundation/AMessage.h>
#include <media/stagefright/foundation/AUtils.h>
+#include <mediadrm/ICrypto.h>
#include <nativebase/nativebase.h>
#include <ui/Fence.h>
diff --git a/media/codec2/sfplugin/Codec2Buffer.h b/media/codec2/sfplugin/Codec2Buffer.h
index ff79946..dc788cd 100644
--- a/media/codec2/sfplugin/Codec2Buffer.h
+++ b/media/codec2/sfplugin/Codec2Buffer.h
@@ -20,16 +20,29 @@
#include <C2Buffer.h>
-#include <android/hardware/cas/native/1.0/types.h>
-#include <android/hardware/drm/1.0/types.h>
#include <binder/IMemory.h>
#include <media/hardware/VideoAPI.h>
#include <media/stagefright/foundation/ABuffer.h>
#include <media/MediaCodecBuffer.h>
-#include <mediadrm/ICrypto.h>
namespace android {
+namespace hardware {
+class HidlMemory;
+namespace cas {
+namespace native {
+namespace V1_0 {
+struct SharedBuffer;
+} // namespace V1_0
+} // namespace native
+} // namespace cas
+namespace drm {
+namespace V1_0 {
+struct SharedBuffer;
+} // namespace V1_0
+} // namespace drm
+} // namespace hardware
+
/**
* Copies a graphic view into a media image.
*
diff --git a/media/codec2/sfplugin/tests/Android.bp b/media/codec2/sfplugin/tests/Android.bp
index fe5fa68..8d1a9c3 100644
--- a/media/codec2/sfplugin/tests/Android.bp
+++ b/media/codec2/sfplugin/tests/Android.bp
@@ -2,12 +2,13 @@
name: "ccodec_unit_test",
srcs: [
+ "CCodecBuffers_test.cpp",
"CCodecConfig_test.cpp",
"ReflectedParamUpdater_test.cpp",
],
defaults: [
- "libcodec2-hidl-defaults@1.0",
+ "libcodec2-impl-defaults",
"libcodec2-internal-defaults",
],
@@ -16,14 +17,24 @@
],
shared_libs: [
+ "android.hardware.media.bufferpool@2.0",
+ "android.hardware.media.c2@1.0",
"libcodec2",
"libcodec2_client",
+ "libhidlbase",
+ "libfmq",
+ "libmedia_omx",
"libsfplugin_ccodec",
"libsfplugin_ccodec_utils",
"libstagefright_foundation",
"libutils",
],
+ static_libs: [
+ "libcodec2_hidl@1.0",
+ "libstagefright_bufferpool@2.0",
+ ],
+
cflags: [
"-Werror",
"-Wall",
diff --git a/media/codec2/sfplugin/tests/CCodecBuffers_test.cpp b/media/codec2/sfplugin/tests/CCodecBuffers_test.cpp
new file mode 100644
index 0000000..5bee605
--- /dev/null
+++ b/media/codec2/sfplugin/tests/CCodecBuffers_test.cpp
@@ -0,0 +1,99 @@
+/*
+ * Copyright 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.
+ */
+
+#include "CCodecBuffers.h"
+
+#include <gtest/gtest.h>
+
+#include <media/stagefright/MediaCodecConstants.h>
+
+#include <C2PlatformSupport.h>
+
+namespace android {
+
+TEST(RawGraphicOutputBuffersTest, ChangeNumSlots) {
+ constexpr int32_t kWidth = 3840;
+ constexpr int32_t kHeight = 2160;
+
+ std::shared_ptr<RawGraphicOutputBuffers> buffers =
+ std::make_shared<RawGraphicOutputBuffers>("test");
+ sp<AMessage> format{new AMessage};
+ format->setInt32("width", kWidth);
+ format->setInt32("height", kHeight);
+ buffers->setFormat(format);
+
+ std::shared_ptr<C2BlockPool> pool;
+ ASSERT_EQ(OK, GetCodec2BlockPool(C2BlockPool::BASIC_GRAPHIC, nullptr, &pool));
+
+ // Register 4 buffers
+ std::vector<sp<MediaCodecBuffer>> clientBuffers;
+ auto registerBuffer = [&buffers, &clientBuffers, &pool] {
+ std::shared_ptr<C2GraphicBlock> block;
+ ASSERT_EQ(OK, pool->fetchGraphicBlock(
+ kWidth, kHeight, HAL_PIXEL_FORMAT_YCbCr_420_888,
+ C2MemoryUsage{C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE}, &block));
+ std::shared_ptr<C2Buffer> c2Buffer = C2Buffer::CreateGraphicBuffer(block->share(
+ block->crop(), C2Fence{}));
+ size_t index;
+ sp<MediaCodecBuffer> clientBuffer;
+ ASSERT_EQ(OK, buffers->registerBuffer(c2Buffer, &index, &clientBuffer));
+ ASSERT_NE(nullptr, clientBuffer);
+ while (clientBuffers.size() <= index) {
+ clientBuffers.emplace_back();
+ }
+ ASSERT_EQ(nullptr, clientBuffers[index]) << "index = " << index;
+ clientBuffers[index] = clientBuffer;
+ };
+ for (int i = 0; i < 4; ++i) {
+ registerBuffer();
+ }
+
+ // Release 2 buffers
+ auto releaseBuffer = [&buffers, &clientBuffers, kWidth, kHeight](int index) {
+ std::shared_ptr<C2Buffer> c2Buffer;
+ ASSERT_TRUE(buffers->releaseBuffer(clientBuffers[index], &c2Buffer))
+ << "index = " << index;
+ clientBuffers[index] = nullptr;
+ // Sanity checks
+ ASSERT_TRUE(c2Buffer->data().linearBlocks().empty());
+ ASSERT_EQ(1u, c2Buffer->data().graphicBlocks().size());
+ C2ConstGraphicBlock block = c2Buffer->data().graphicBlocks().front();
+ ASSERT_EQ(kWidth, block.width());
+ ASSERT_EQ(kHeight, block.height());
+ };
+ for (int i = 0, index = 0; i < 2 && index < clientBuffers.size(); ++index) {
+ if (clientBuffers[index] == nullptr) {
+ continue;
+ }
+ releaseBuffer(index);
+ ++i;
+ }
+
+ // Simulate # of slots 4->16
+ for (int i = 2; i < 16; ++i) {
+ registerBuffer();
+ }
+
+ // Release everything
+ for (int index = 0; index < clientBuffers.size(); ++index) {
+ if (clientBuffers[index] == nullptr) {
+ continue;
+ }
+ releaseBuffer(index);
+ }
+}
+
+} // namespace android
diff --git a/media/libaaudio/src/core/AudioStream.cpp b/media/libaaudio/src/core/AudioStream.cpp
index 17d389e..0644368 100644
--- a/media/libaaudio/src/core/AudioStream.cpp
+++ b/media/libaaudio/src/core/AudioStream.cpp
@@ -106,21 +106,23 @@
}
void AudioStream::logOpen() {
- LOG_ALWAYS_FATAL_IF(mMetricsId.size() == 0, "mMetricsId is empty!");
- android::mediametrics::LogItem(mMetricsId)
- .set(AMEDIAMETRICS_PROP_PERFORMANCEMODE,
- AudioGlobal_convertPerformanceModeToText(getPerformanceMode()))
- .set(AMEDIAMETRICS_PROP_SHARINGMODE,
- AudioGlobal_convertSharingModeToText(getSharingMode()))
- .record();
+ if (mMetricsId.size() > 0) {
+ android::mediametrics::LogItem(mMetricsId)
+ .set(AMEDIAMETRICS_PROP_PERFORMANCEMODE,
+ AudioGlobal_convertPerformanceModeToText(getPerformanceMode()))
+ .set(AMEDIAMETRICS_PROP_SHARINGMODE,
+ AudioGlobal_convertSharingModeToText(getSharingMode()))
+ .record();
+ }
}
void AudioStream::logBufferState() {
- LOG_ALWAYS_FATAL_IF(mMetricsId.size() == 0, "mMetricsId is empty!");
- android::mediametrics::LogItem(mMetricsId)
- .set(AMEDIAMETRICS_PROP_BUFFERSIZEFRAMES, (int32_t) getBufferSize())
- .set(AMEDIAMETRICS_PROP_UNDERRUN, (int32_t) getXRunCount())
- .record();
+ if (mMetricsId.size() > 0) {
+ android::mediametrics::LogItem(mMetricsId)
+ .set(AMEDIAMETRICS_PROP_BUFFERSIZEFRAMES, (int32_t) getBufferSize())
+ .set(AMEDIAMETRICS_PROP_UNDERRUN, (int32_t) getXRunCount())
+ .record();
+ }
}
aaudio_result_t AudioStream::systemStart() {
diff --git a/media/libstagefright/MediaExtractorFactory.cpp b/media/libstagefright/MediaExtractorFactory.cpp
index 94267a1..c6e753d 100644
--- a/media/libstagefright/MediaExtractorFactory.cpp
+++ b/media/libstagefright/MediaExtractorFactory.cpp
@@ -302,6 +302,12 @@
#endif
"/extractors", NULL, *newList);
+ RegisterExtractors("/system_ext/lib"
+#ifdef __LP64__
+ "64"
+#endif
+ "/extractors", NULL, *newList);
+
newList->sort(compareFunc);
gPlugins = newList;
diff --git a/services/audioflinger/Threads.cpp b/services/audioflinger/Threads.cpp
index 105fa14..5d9c35a 100644
--- a/services/audioflinger/Threads.cpp
+++ b/services/audioflinger/Threads.cpp
@@ -3051,6 +3051,10 @@
{
if (!mMasterMute) {
char value[PROPERTY_VALUE_MAX];
+ if (mOutDeviceTypeAddrs.empty()) {
+ ALOGD("ro.audio.silent is ignored since no output device is set");
+ return;
+ }
if (isSingleDeviceType(outDeviceTypes(), AUDIO_DEVICE_OUT_REMOTE_SUBMIX)) {
ALOGD("ro.audio.silent will be ignored for threads on AUDIO_DEVICE_OUT_REMOTE_SUBMIX");
return;
@@ -4227,6 +4231,7 @@
(mPatch.sinks[0].id != sinkPortId);
mPatch = *patch;
mOutDeviceTypeAddrs = deviceTypeAddrs;
+ checkSilentMode_l();
if (mOutput->audioHwDev->supportsAudioPatches()) {
sp<DeviceHalInterface> hwDevice = mOutput->audioHwDev->hwDevice();
@@ -9153,6 +9158,7 @@
if (isOutput()) {
sendIoConfigEvent_l(AUDIO_OUTPUT_CONFIG_CHANGED);
mOutDeviceTypeAddrs = sinkDeviceTypeAddrs;
+ checkSilentMode_l();
} else {
sendIoConfigEvent_l(AUDIO_INPUT_CONFIG_CHANGED);
mInDeviceTypeAddr = sourceDeviceTypeAddr;
diff --git a/services/audiopolicy/common/managerdefinitions/src/HwModule.cpp b/services/audiopolicy/common/managerdefinitions/src/HwModule.cpp
index 886e4c9..d31e443 100644
--- a/services/audiopolicy/common/managerdefinitions/src/HwModule.cpp
+++ b/services/audiopolicy/common/managerdefinitions/src/HwModule.cpp
@@ -320,7 +320,7 @@
{
String8 devAddress = (address == nullptr || !matchAddress) ? String8("") : String8(address);
// handle legacy remote submix case where the address was not always specified
- if (device_distinguishes_on_address(deviceType) && (devAddress.length() == 0)) {
+ if (audio_is_remote_submix_device(deviceType) && (devAddress.length() == 0)) {
devAddress = String8("0");
}
diff --git a/services/audiopolicy/managerdefault/AudioPolicyManager.cpp b/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
index 5683e69..13e2093 100644
--- a/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
+++ b/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
@@ -3072,7 +3072,7 @@
for (size_t i = 0; i < devices.size(); i++) {
sp<DeviceDescriptor> devDesc = mHwModules.getDeviceDescriptor(
devices[i].mType, devices[i].mAddress.c_str(), String8(),
- AUDIO_FORMAT_DEFAULT, false /*allowToCreate*/, false /*matchAddress*/);
+ AUDIO_FORMAT_DEFAULT, false /*allowToCreate*/, true /*matchAddress*/);
if (devDesc == nullptr || (predicate != nullptr && !predicate(devices[i].mType))) {
ALOGE("%s: device type %#x address %s not supported or not an output device",
context, devices[i].mType, devices[i].mAddress.c_str());
@@ -4837,7 +4837,7 @@
if (output != AUDIO_IO_HANDLE_NONE) {
addOutput(output, desc);
- if (device_distinguishes_on_address(deviceType) && address != "0") {
+ if (audio_is_remote_submix_device(deviceType) && address != "0") {
sp<AudioPolicyMix> policyMix;
if (mPolicyMixes.getAudioPolicyMix(deviceType, address, policyMix)
== NO_ERROR) {
diff --git a/services/camera/libcameraservice/device3/ZoomRatioMapper.cpp b/services/camera/libcameraservice/device3/ZoomRatioMapper.cpp
index 84da45a..a87de77 100644
--- a/services/camera/libcameraservice/device3/ZoomRatioMapper.cpp
+++ b/services/camera/libcameraservice/device3/ZoomRatioMapper.cpp
@@ -243,10 +243,15 @@
if (weight == 0) {
continue;
}
- // Top-left is inclusively clamped
- scaleCoordinates(entry.data.i32 + j, 1, zoomRatio, ClampInclusive);
- // Bottom-right is exclusively clamped
- scaleCoordinates(entry.data.i32 + j + 2, 1, zoomRatio, ClampExclusive);
+ // Top left (inclusive)
+ scaleCoordinates(entry.data.i32 + j, 1, zoomRatio, true /*clamp*/);
+ // Bottom right (exclusive): Use adjacent inclusive pixel to
+ // calculate.
+ entry.data.i32[j+2] -= 1;
+ entry.data.i32[j+3] -= 1;
+ scaleCoordinates(entry.data.i32 + j + 2, 1, zoomRatio, true /*clamp*/);
+ entry.data.i32[j+2] += 1;
+ entry.data.i32[j+3] += 1;
}
}
@@ -258,7 +263,7 @@
if (isResult) {
for (auto pts : kResultPointsToCorrectNoClamp) {
entry = metadata->find(pts);
- scaleCoordinates(entry.data.i32, entry.count / 2, zoomRatio, ClampOff);
+ scaleCoordinates(entry.data.i32, entry.count / 2, zoomRatio, false /*clamp*/);
}
}
@@ -282,10 +287,15 @@
if (weight == 0) {
continue;
}
- // Top-left is inclusively clamped
- scaleCoordinates(entry.data.i32 + j, 1, 1.0 / zoomRatio, ClampInclusive);
- // Bottom-right is exclusively clamped
- scaleCoordinates(entry.data.i32 + j + 2, 1, 1.0 / zoomRatio, ClampExclusive);
+ // Top-left (inclusive)
+ scaleCoordinates(entry.data.i32 + j, 1, 1.0 / zoomRatio, true /*clamp*/);
+ // Bottom-right (exclusive): Use adjacent inclusive pixel to
+ // calculate.
+ entry.data.i32[j+2] -= 1;
+ entry.data.i32[j+3] -= 1;
+ scaleCoordinates(entry.data.i32 + j + 2, 1, 1.0 / zoomRatio, true /*clamp*/);
+ entry.data.i32[j+2] += 1;
+ entry.data.i32[j+3] += 1;
}
}
for (auto rect : kRectsToCorrect) {
@@ -295,7 +305,7 @@
if (isResult) {
for (auto pts : kResultPointsToCorrectNoClamp) {
entry = metadata->find(pts);
- scaleCoordinates(entry.data.i32, entry.count / 2, 1.0 / zoomRatio, ClampOff);
+ scaleCoordinates(entry.data.i32, entry.count / 2, 1.0 / zoomRatio, false /*clamp*/);
}
}
@@ -309,28 +319,31 @@
}
void ZoomRatioMapper::scaleCoordinates(int32_t* coordPairs, int coordCount,
- float scaleRatio, ClampMode clamp) {
+ float scaleRatio, bool clamp) {
+ // A pixel's coordinate is represented by the position of its top-left corner.
+ // To avoid the rounding error, we use the coordinate for the center of the
+ // pixel instead:
+ // 1. First shift the coordinate system half pixel both horizontally and
+ // vertically, so that [x, y] is the center of the pixel, not the top-left corner.
+ // 2. Do zoom operation to scale the coordinate relative to the center of
+ // the active array (shifted by 0.5 pixel as well).
+ // 3. Shift the coordinate system back by directly using the pixel center
+ // coordinate.
for (int i = 0; i < coordCount * 2; i += 2) {
float x = coordPairs[i];
float y = coordPairs[i + 1];
- float xCentered = x - mArrayWidth / 2;
- float yCentered = y - mArrayHeight / 2;
+ float xCentered = x - (mArrayWidth - 2) / 2;
+ float yCentered = y - (mArrayHeight - 2) / 2;
float scaledX = xCentered * scaleRatio;
float scaledY = yCentered * scaleRatio;
- scaledX += mArrayWidth / 2;
- scaledY += mArrayHeight / 2;
+ scaledX += (mArrayWidth - 2) / 2;
+ scaledY += (mArrayHeight - 2) / 2;
+ coordPairs[i] = static_cast<int32_t>(std::round(scaledX));
+ coordPairs[i+1] = static_cast<int32_t>(std::round(scaledY));
// Clamp to within activeArray/preCorrectionActiveArray
- coordPairs[i] = static_cast<int32_t>(scaledX);
- coordPairs[i+1] = static_cast<int32_t>(scaledY);
- if (clamp != ClampOff) {
- int32_t right, bottom;
- if (clamp == ClampInclusive) {
- right = mArrayWidth - 1;
- bottom = mArrayHeight - 1;
- } else {
- right = mArrayWidth;
- bottom = mArrayHeight;
- }
+ if (clamp) {
+ int32_t right = mArrayWidth - 1;
+ int32_t bottom = mArrayHeight - 1;
coordPairs[i] =
std::min(right, std::max(0, coordPairs[i]));
coordPairs[i+1] =
@@ -343,25 +356,25 @@
void ZoomRatioMapper::scaleRects(int32_t* rects, int rectCount,
float scaleRatio) {
for (int i = 0; i < rectCount * 4; i += 4) {
- // Map from (l, t, width, height) to (l, t, r, b).
- // [l, t] is inclusive, and [r, b] is exclusive.
+ // Map from (l, t, width, height) to (l, t, l+width-1, t+height-1),
+ // where both top-left and bottom-right are inclusive.
int32_t coords[4] = {
rects[i],
rects[i + 1],
- rects[i] + rects[i + 2],
- rects[i + 1] + rects[i + 3]
+ rects[i] + rects[i + 2] - 1,
+ rects[i + 1] + rects[i + 3] - 1
};
// top-left
- scaleCoordinates(coords, 1, scaleRatio, ClampInclusive);
+ scaleCoordinates(coords, 1, scaleRatio, true /*clamp*/);
// bottom-right
- scaleCoordinates(coords+2, 1, scaleRatio, ClampExclusive);
+ scaleCoordinates(coords+2, 1, scaleRatio, true /*clamp*/);
// Map back to (l, t, width, height)
rects[i] = coords[0];
rects[i + 1] = coords[1];
- rects[i + 2] = coords[2] - coords[0];
- rects[i + 3] = coords[3] - coords[1];
+ rects[i + 2] = coords[2] - coords[0] + 1;
+ rects[i + 3] = coords[3] - coords[1] + 1;
}
}
diff --git a/services/camera/libcameraservice/device3/ZoomRatioMapper.h b/services/camera/libcameraservice/device3/ZoomRatioMapper.h
index aa3d913..698f87f 100644
--- a/services/camera/libcameraservice/device3/ZoomRatioMapper.h
+++ b/services/camera/libcameraservice/device3/ZoomRatioMapper.h
@@ -65,14 +65,8 @@
status_t updateCaptureResult(CameraMetadata *request, bool requestedZoomRatioIs1);
public: // Visible for testing. Do not use concurently.
- enum ClampMode {
- ClampOff,
- ClampInclusive,
- ClampExclusive,
- };
-
void scaleCoordinates(int32_t* coordPairs, int coordCount,
- float scaleRatio, ClampMode clamp);
+ float scaleRatio, bool clamp);
bool isValid() { return mIsValid; }
private:
diff --git a/services/camera/libcameraservice/tests/ZoomRatioTest.cpp b/services/camera/libcameraservice/tests/ZoomRatioTest.cpp
index 300da09..4e94991 100644
--- a/services/camera/libcameraservice/tests/ZoomRatioTest.cpp
+++ b/services/camera/libcameraservice/tests/ZoomRatioTest.cpp
@@ -171,35 +171,35 @@
std::array<int32_t, 16> originalCoords = {
0, 0, // top-left
- width, 0, // top-right
- 0, height, // bottom-left
- width, height, // bottom-right
- width / 2, height / 2, // center
- width / 4, height / 4, // top-left after 2x
- width / 3, height * 2 / 3, // bottom-left after 3x zoom
- width * 7 / 8, height / 2, // middle-right after 1.33x zoom
+ width - 1, 0, // top-right
+ 0, height - 1, // bottom-left
+ width - 1, height - 1, // bottom-right
+ (width - 1) / 2, (height - 1) / 2, // center
+ (width - 1) / 4, (height - 1) / 4, // top-left after 2x
+ (width - 1) / 3, (height - 1) * 2 / 3, // bottom-left after 3x zoom
+ (width - 1) * 7 / 8, (height - 1) / 2, // middle-right after 1.33x zoom
};
// Verify 1.0x zoom doesn't change the coordinates
auto coords = originalCoords;
- mapper.scaleCoordinates(coords.data(), coords.size()/2, 1.0f, ZoomRatioMapper::ClampOff);
+ mapper.scaleCoordinates(coords.data(), coords.size()/2, 1.0f, false /*clamp*/);
for (size_t i = 0; i < coords.size(); i++) {
EXPECT_EQ(coords[i], originalCoords[i]);
}
// Verify 2.0x zoom work as expected (no clamping)
std::array<float, 16> expected2xCoords = {
- - width / 2.0f, - height / 2.0f,// top-left
- width * 3 / 2.0f, - height / 2.0f, // top-right
- - width / 2.0f, height * 3 / 2.0f, // bottom-left
- width * 3 / 2.0f, height * 3 / 2.0f, // bottom-right
- width / 2.0f, height / 2.0f, // center
+ - (width - 1) / 2.0f, - (height - 1) / 2.0f,// top-left
+ (width - 1) * 3 / 2.0f, - (height - 1) / 2.0f, // top-right
+ - (width - 1) / 2.0f, (height - 1) * 3 / 2.0f, // bottom-left
+ (width - 1) * 3 / 2.0f, (height - 1) * 3 / 2.0f, // bottom-right
+ (width - 1) / 2.0f, (height - 1) / 2.0f, // center
0, 0, // top-left after 2x
- width / 6.0f, height - height / 6.0f, // bottom-left after 3x zoom
- width + width / 4.0f, height / 2.0f, // middle-right after 1.33x zoom
+ (width - 1) / 6.0f, (height - 1) * 5.0f / 6.0f, // bottom-left after 3x zoom
+ (width - 1) * 5.0f / 4.0f, (height - 1) / 2.0f, // middle-right after 1.33x zoom
};
coords = originalCoords;
- mapper.scaleCoordinates(coords.data(), coords.size()/2, 2.0f, ZoomRatioMapper::ClampOff);
+ mapper.scaleCoordinates(coords.data(), coords.size()/2, 2.0f, false /*clamp*/);
for (size_t i = 0; i < coords.size(); i++) {
EXPECT_LE(std::abs(coords[i] - expected2xCoords[i]), kMaxAllowedPixelError);
}
@@ -207,16 +207,16 @@
// Verify 2.0x zoom work as expected (with inclusive clamping)
std::array<float, 16> expected2xCoordsClampedInc = {
0, 0, // top-left
- static_cast<float>(width) - 1, 0, // top-right
- 0, static_cast<float>(height) - 1, // bottom-left
- static_cast<float>(width) - 1, static_cast<float>(height) - 1, // bottom-right
- width / 2.0f, height / 2.0f, // center
+ width - 1.0f, 0, // top-right
+ 0, height - 1.0f, // bottom-left
+ width - 1.0f, height - 1.0f, // bottom-right
+ (width - 1) / 2.0f, (height - 1) / 2.0f, // center
0, 0, // top-left after 2x
- width / 6.0f, height - height / 6.0f , // bottom-left after 3x zoom
- static_cast<float>(width) - 1, height / 2.0f, // middle-right after 1.33x zoom
+ (width - 1) / 6.0f, (height - 1) * 5.0f / 6.0f , // bottom-left after 3x zoom
+ width - 1.0f, (height - 1) / 2.0f, // middle-right after 1.33x zoom
};
coords = originalCoords;
- mapper.scaleCoordinates(coords.data(), coords.size()/2, 2.0f, ZoomRatioMapper::ClampInclusive);
+ mapper.scaleCoordinates(coords.data(), coords.size()/2, 2.0f, true /*clamp*/);
for (size_t i = 0; i < coords.size(); i++) {
EXPECT_LE(std::abs(coords[i] - expected2xCoordsClampedInc[i]), kMaxAllowedPixelError);
}
@@ -224,33 +224,33 @@
// Verify 2.0x zoom work as expected (with exclusive clamping)
std::array<float, 16> expected2xCoordsClampedExc = {
0, 0, // top-left
- static_cast<float>(width), 0, // top-right
- 0, static_cast<float>(height), // bottom-left
- static_cast<float>(width), static_cast<float>(height), // bottom-right
+ width - 1.0f, 0, // top-right
+ 0, height - 1.0f, // bottom-left
+ width - 1.0f, height - 1.0f, // bottom-right
width / 2.0f, height / 2.0f, // center
0, 0, // top-left after 2x
- width / 6.0f, height - height / 6.0f , // bottom-left after 3x zoom
- static_cast<float>(width), height / 2.0f, // middle-right after 1.33x zoom
+ (width - 1) / 6.0f, (height - 1) * 5.0f / 6.0f , // bottom-left after 3x zoom
+ width - 1.0f, height / 2.0f, // middle-right after 1.33x zoom
};
coords = originalCoords;
- mapper.scaleCoordinates(coords.data(), coords.size()/2, 2.0f, ZoomRatioMapper::ClampExclusive);
+ mapper.scaleCoordinates(coords.data(), coords.size()/2, 2.0f, true /*clamp*/);
for (size_t i = 0; i < coords.size(); i++) {
EXPECT_LE(std::abs(coords[i] - expected2xCoordsClampedExc[i]), kMaxAllowedPixelError);
}
// Verify 0.33x zoom work as expected
std::array<float, 16> expectedZoomOutCoords = {
- width / 3.0f, height / 3.0f, // top-left
- width * 2 / 3.0f, height / 3.0f, // top-right
- width / 3.0f, height * 2 / 3.0f, // bottom-left
- width * 2 / 3.0f, height * 2 / 3.0f, // bottom-right
- width / 2.0f, height / 2.0f, // center
- width * 5 / 12.0f, height * 5 / 12.0f, // top-left after 2x
- width * 4 / 9.0f, height * 5 / 9.0f, // bottom-left after 3x zoom-in
- width * 5 / 8.0f, height / 2.0f, // middle-right after 1.33x zoom-in
+ (width - 1) / 3.0f, (height - 1) / 3.0f, // top-left
+ (width - 1) * 2 / 3.0f, (height - 1) / 3.0f, // top-right
+ (width - 1) / 3.0f, (height - 1) * 2 / 3.0f, // bottom-left
+ (width - 1) * 2 / 3.0f, (height - 1) * 2 / 3.0f, // bottom-right
+ (width - 1) / 2.0f, (height - 1) / 2.0f, // center
+ (width - 1) * 5 / 12.0f, (height - 1) * 5 / 12.0f, // top-left after 2x
+ (width - 1) * 4 / 9.0f, (height - 1) * 5 / 9.0f, // bottom-left after 3x zoom-in
+ (width - 1) * 5 / 8.0f, (height - 1) / 2.0f, // middle-right after 1.33x zoom-in
};
coords = originalCoords;
- mapper.scaleCoordinates(coords.data(), coords.size()/2, 1.0f/3, ZoomRatioMapper::ClampOff);
+ mapper.scaleCoordinates(coords.data(), coords.size()/2, 1.0f/3, false /*clamp*/);
for (size_t i = 0; i < coords.size(); i++) {
EXPECT_LE(std::abs(coords[i] - expectedZoomOutCoords[i]), kMaxAllowedPixelError);
}
@@ -323,7 +323,8 @@
entry = metadata.find(ANDROID_SCALER_CROP_REGION);
ASSERT_EQ(entry.count, 4U);
for (int i = 0; i < 4; i++) {
- EXPECT_EQ(entry.data.i32[i], testDefaultCropSize[index][i]);
+ EXPECT_LE(std::abs(entry.data.i32[i] - testDefaultCropSize[index][i]),
+ kMaxAllowedPixelError);
}
entry = metadata.find(ANDROID_CONTROL_ZOOM_RATIO);
EXPECT_NEAR(entry.data.f[0], 2.0f, kMaxAllowedRatioError);
@@ -335,7 +336,7 @@
entry = metadata.find(ANDROID_SCALER_CROP_REGION);
ASSERT_EQ(entry.count, 4U);
for (int i = 0; i < 4; i++) {
- EXPECT_EQ(entry.data.i32[i], test2xCropRegion[index][i]);
+ EXPECT_LE(std::abs(entry.data.i32[i] - test2xCropRegion[index][i]), kMaxAllowedPixelError);
}
// Letter boxing crop region, zoomRatio is 1.0