}
/**
+ * \brief Convert `Return<Status>` to `binder::Status`.
+ *
+ * \param[in] t The source `Return<Status>`.
+ * \return The corresponding `binder::Status`.
+ */
+// convert: Return<Status> -> ::android::binder::Status
+inline ::android::binder::Status toBinderStatus(
+ Return<Status> const& t) {
+ return ::android::binder::Status::fromStatusT(
+ t.isOk() ? static_cast<status_t>(static_cast<Status>(t)) : UNKNOWN_ERROR);
+}
+
+/**
* \brief Convert `Return<Status>` to `status_t`. This is for legacy binder
* calls.
*
using ::android::hardware::Return;
using ::android::hardware::Void;
using ::android::sp;
-
using ::android::IOMXNode;
/**
* - TW = Treble Wrapper --- It wraps a legacy object inside a Treble object.
*/
-typedef ::android::IGraphicBufferSource LGraphicBufferSource;
+typedef ::android::binder::Status BnStatus;
typedef ::android::BnGraphicBufferSource BnGraphicBufferSource;
typedef ::android::hardware::media::omx::V1_0::IGraphicBufferSource
TGraphicBufferSource;
struct LWGraphicBufferSource : public BnGraphicBufferSource {
sp<TGraphicBufferSource> mBase;
LWGraphicBufferSource(sp<TGraphicBufferSource> const& base);
- ::android::binder::Status configure(
+ BnStatus configure(
const sp<IOMXNode>& omxNode, int32_t dataSpace) override;
- ::android::binder::Status setSuspend(bool suspend, int64_t timeUs) override;
- ::android::binder::Status setRepeatPreviousFrameDelayUs(
+ BnStatus setSuspend(bool suspend, int64_t timeUs) override;
+ BnStatus setRepeatPreviousFrameDelayUs(
int64_t repeatAfterUs) override;
- ::android::binder::Status setMaxFps(float maxFps) override;
- ::android::binder::Status setTimeLapseConfig(
- int64_t timePerFrameUs, int64_t timePerCaptureUs) override;
- ::android::binder::Status setStartTimeUs(int64_t startTimeUs) override;
- ::android::binder::Status setStopTimeUs(int64_t stopTimeUs) override;
- ::android::binder::Status setColorAspects(int32_t aspects) override;
- ::android::binder::Status setTimeOffsetUs(int64_t timeOffsetsUs) override;
- ::android::binder::Status signalEndOfInputStream() override;
-};
-
-struct TWGraphicBufferSource : public TGraphicBufferSource {
- sp<LGraphicBufferSource> mBase;
- TWGraphicBufferSource(sp<LGraphicBufferSource> const& base);
- Return<void> configure(
- const sp<IOmxNode>& omxNode, Dataspace dataspace) override;
- Return<void> setSuspend(bool suspend, int64_t timeUs) override;
- Return<void> setRepeatPreviousFrameDelayUs(int64_t repeatAfterUs) override;
- Return<void> setMaxFps(float maxFps) override;
- Return<void> setTimeLapseConfig(
+ BnStatus setMaxFps(float maxFps) override;
+ BnStatus setTimeLapseConfig(
int64_t timePerFrameUs, int64_t timePerCaptureUs) override;
- Return<void> setStartTimeUs(int64_t startTimeUs) override;
- Return<void> setStopTimeUs(int64_t stopTimeUs) override;
- Return<void> setColorAspects(const ColorAspects& aspects) override;
- Return<void> setTimeOffsetUs(int64_t timeOffsetUs) override;
- Return<void> signalEndOfInputStream() override;
+ BnStatus setStartTimeUs(int64_t startTimeUs) override;
+ BnStatus setStopTimeUs(int64_t stopTimeUs) override;
+ BnStatus setColorAspects(int32_t aspects) override;
+ BnStatus setTimeOffsetUs(int64_t timeOffsetsUs) override;
+ BnStatus signalEndOfInputStream() override;
};
} // namespace utils
sp<::android::IGraphicBufferSource>* bufferSource) override;
};
-struct TWOmx : public IOmx {
- sp<IOMX> mBase;
- TWOmx(sp<IOMX> const& base);
- Return<void> listNodes(listNodes_cb _hidl_cb) override;
- Return<void> allocateNode(
- const hidl_string& name,
- const sp<IOmxObserver>& observer,
- allocateNode_cb _hidl_cb) override;
- Return<void> createInputSurface(createInputSurface_cb _hidl_cb) override;
-
-};
-
} // namespace utils
} // namespace V1_0
} // namespace omx
* limitations under the License.
*/
-#include <stagefright/foundation/ColorUtils.h>
-
#include <media/omx/1.0/WGraphicBufferSource.h>
#include <media/omx/1.0/WOmxNode.h>
#include <media/omx/1.0/Conversion.h>
namespace V1_0 {
namespace utils {
-using android::ColorUtils;
-
// LWGraphicBufferSource
LWGraphicBufferSource::LWGraphicBufferSource(
sp<TGraphicBufferSource> const& base) : mBase(base) {
}
-::android::binder::Status LWGraphicBufferSource::configure(
+BnStatus LWGraphicBufferSource::configure(
const sp<IOMXNode>& omxNode, int32_t dataSpace) {
sp<IOmxNode> hOmxNode = omxNode->getHalInterface();
return toBinderStatus(mBase->configure(
toHardwareDataspace(dataSpace)));
}
-::android::binder::Status LWGraphicBufferSource::setSuspend(
+BnStatus LWGraphicBufferSource::setSuspend(
bool suspend, int64_t timeUs) {
return toBinderStatus(mBase->setSuspend(suspend, timeUs));
}
-::android::binder::Status LWGraphicBufferSource::setRepeatPreviousFrameDelayUs(
+BnStatus LWGraphicBufferSource::setRepeatPreviousFrameDelayUs(
int64_t repeatAfterUs) {
return toBinderStatus(mBase->setRepeatPreviousFrameDelayUs(repeatAfterUs));
}
-::android::binder::Status LWGraphicBufferSource::setMaxFps(float maxFps) {
+BnStatus LWGraphicBufferSource::setMaxFps(float maxFps) {
return toBinderStatus(mBase->setMaxFps(maxFps));
}
-::android::binder::Status LWGraphicBufferSource::setTimeLapseConfig(
+BnStatus LWGraphicBufferSource::setTimeLapseConfig(
int64_t timePerFrameUs, int64_t timePerCaptureUs) {
return toBinderStatus(mBase->setTimeLapseConfig(
timePerFrameUs, timePerCaptureUs));
}
-::android::binder::Status LWGraphicBufferSource::setStartTimeUs(
+BnStatus LWGraphicBufferSource::setStartTimeUs(
int64_t startTimeUs) {
return toBinderStatus(mBase->setStartTimeUs(startTimeUs));
}
-::android::binder::Status LWGraphicBufferSource::setStopTimeUs(
+BnStatus LWGraphicBufferSource::setStopTimeUs(
int64_t stopTimeUs) {
return toBinderStatus(mBase->setStopTimeUs(stopTimeUs));
}
-::android::binder::Status LWGraphicBufferSource::setColorAspects(
+BnStatus LWGraphicBufferSource::setColorAspects(
int32_t aspects) {
return toBinderStatus(mBase->setColorAspects(
toHardwareColorAspects(aspects)));
}
-::android::binder::Status LWGraphicBufferSource::setTimeOffsetUs(
+BnStatus LWGraphicBufferSource::setTimeOffsetUs(
int64_t timeOffsetsUs) {
return toBinderStatus(mBase->setTimeOffsetUs(timeOffsetsUs));
}
-::android::binder::Status LWGraphicBufferSource::signalEndOfInputStream() {
+BnStatus LWGraphicBufferSource::signalEndOfInputStream() {
return toBinderStatus(mBase->signalEndOfInputStream());
}
-// TWGraphicBufferSource
-TWGraphicBufferSource::TWGraphicBufferSource(
- sp<LGraphicBufferSource> const& base) : mBase(base) {
-}
-
-Return<void> TWGraphicBufferSource::configure(
- const sp<IOmxNode>& omxNode, Dataspace dataspace) {
- mBase->configure(new LWOmxNode(omxNode), toRawDataspace(dataspace));
- return Void();
-}
-
-Return<void> TWGraphicBufferSource::setSuspend(
- bool suspend, int64_t timeUs) {
- mBase->setSuspend(suspend, timeUs);
- return Void();
-}
-
-Return<void> TWGraphicBufferSource::setRepeatPreviousFrameDelayUs(
- int64_t repeatAfterUs) {
- mBase->setRepeatPreviousFrameDelayUs(repeatAfterUs);
- return Void();
-}
-
-Return<void> TWGraphicBufferSource::setMaxFps(float maxFps) {
- mBase->setMaxFps(maxFps);
- return Void();
-}
-
-Return<void> TWGraphicBufferSource::setTimeLapseConfig(
- int64_t timePerFrameUs, int64_t timePerCaptureUs) {
- mBase->setTimeLapseConfig(timePerFrameUs, timePerCaptureUs);
- return Void();
-}
-
-Return<void> TWGraphicBufferSource::setStartTimeUs(int64_t startTimeUs) {
- mBase->setStartTimeUs(startTimeUs);
- return Void();
-}
-
-Return<void> TWGraphicBufferSource::setStopTimeUs(int64_t stopTimeUs) {
- mBase->setStopTimeUs(stopTimeUs);
- return Void();
-}
-
-Return<void> TWGraphicBufferSource::setColorAspects(
- const ColorAspects& aspects) {
- mBase->setColorAspects(toCompactColorAspects(aspects));
- return Void();
-}
-
-Return<void> TWGraphicBufferSource::setTimeOffsetUs(int64_t timeOffsetUs) {
- mBase->setTimeOffsetUs(timeOffsetUs);
- return Void();
-}
-
-Return<void> TWGraphicBufferSource::signalEndOfInputStream() {
- mBase->signalEndOfInputStream();
- return Void();
-}
-
} // namespace utils
} // namespace V1_0
} // namespace omx
return transStatus == NO_ERROR ? fnStatus : transStatus;
}
-// TWOmx
-TWOmx::TWOmx(sp<IOMX> const& base) : mBase(base) {
-}
-
-Return<void> TWOmx::listNodes(listNodes_cb _hidl_cb) {
- List<IOMX::ComponentInfo> lList;
- Status status = toStatus(mBase->listNodes(&lList));
-
- hidl_vec<IOmx::ComponentInfo> tList;
- tList.resize(lList.size());
- size_t i = 0;
- for (auto const& lInfo : lList) {
- convertTo(&(tList[i++]), lInfo);
- }
- _hidl_cb(status, tList);
- return Void();
-}
-
-Return<void> TWOmx::allocateNode(
- const hidl_string& name,
- const sp<IOmxObserver>& observer,
- allocateNode_cb _hidl_cb) {
- sp<IOMXNode> omxNode;
- Status status = toStatus(mBase->allocateNode(
- name, new LWOmxObserver(observer), &omxNode));
- _hidl_cb(status, new TWOmxNode(omxNode));
- return Void();
-}
-
-Return<void> TWOmx::createInputSurface(createInputSurface_cb _hidl_cb) {
- sp<::android::IGraphicBufferProducer> lProducer;
- sp<::android::IGraphicBufferSource> lSource;
- status_t status = mBase->createInputSurface(&lProducer, &lSource);
- _hidl_cb(toStatus(status),
- new TWOmxBufferProducer(lProducer),
- new TWGraphicBufferSource(lSource));
- return Void();
-}
-
} // namespace utils
} // namespace V1_0
} // namespace omx
LOCAL_SRC_FILES:= \
FrameDropper.cpp \
GraphicBufferSource.cpp \
+ BWGraphicBufferSource.cpp \
OMX.cpp \
OMXMaster.cpp \
OMXNodeInstance.cpp \
--- /dev/null
+/*
+ * Copyright 2017, 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 "BWGraphicBufferSource"
+
+#include <OMX_Component.h>
+#include <OMX_IndexExt.h>
+
+#include <media/OMXBuffer.h>
+#include <IOMX.h>
+
+#include "OMXUtils.h"
+#include "BWGraphicBufferSource.h"
+
+namespace android {
+
+static const OMX_U32 kPortIndexInput = 0;
+
+struct BWGraphicBufferSource::BWOmxNodeWrapper : public IOmxNodeWrapper {
+ sp<IOMXNode> mOMXNode;
+
+ BWOmxNodeWrapper(const sp<IOMXNode> &omxNode): mOMXNode(omxNode) {
+ }
+
+ virtual status_t emptyBuffer(
+ int32_t bufferId, uint32_t flags,
+ const sp<GraphicBuffer> &buffer,
+ int64_t timestamp, int fenceFd) override {
+ return mOMXNode->emptyBuffer(bufferId, buffer, flags, timestamp, fenceFd);
+ }
+
+ virtual void dispatchDataSpaceChanged(
+ int32_t dataSpace, int32_t aspects, int32_t pixelFormat) override {
+ omx_message msg;
+ msg.type = omx_message::EVENT;
+ msg.fenceFd = -1;
+ msg.u.event_data.event = OMX_EventDataSpaceChanged;
+ msg.u.event_data.data1 = dataSpace;
+ msg.u.event_data.data2 = aspects;
+ msg.u.event_data.data3 = pixelFormat;
+ mOMXNode->dispatchMessage(msg);
+ }
+};
+
+struct BWGraphicBufferSource::BWOMXBufferSource : public BnOMXBufferSource {
+ sp<GraphicBufferSource> mSource;
+
+ BWOMXBufferSource(const sp<GraphicBufferSource> &source): mSource(source) {
+ }
+
+ Status onOmxExecuting() override {
+ return mSource->onOmxExecuting();
+ }
+
+ Status onOmxIdle() override {
+ return mSource->onOmxIdle();
+ }
+
+ Status onOmxLoaded() override {
+ return mSource->onOmxLoaded();
+ }
+
+ Status onInputBufferAdded(int bufferId) override {
+ return mSource->onInputBufferAdded(bufferId);
+ }
+
+ Status onInputBufferEmptied(
+ int bufferId, const OMXFenceParcelable& fenceParcel) override {
+ return mSource->onInputBufferEmptied(bufferId, fenceParcel.get());
+ }
+};
+
+BWGraphicBufferSource::BWGraphicBufferSource(
+ sp<GraphicBufferSource> const& base) :
+ mBase(base),
+ mOMXBufferSource(new BWOMXBufferSource(base)) {
+}
+
+::android::binder::Status BWGraphicBufferSource::configure(
+ const sp<IOMXNode>& omxNode, int32_t dataSpace) {
+ // Do setInputSurface() first, the node will try to enable metadata
+ // mode on input, and does necessary error checking. If this fails,
+ // we can't use this input surface on the node.
+ status_t err = omxNode->setInputSurface(mOMXBufferSource);
+ if (err != NO_ERROR) {
+ ALOGE("Unable to set input surface: %d", err);
+ return Status::fromStatusT(err);
+ }
+
+ // use consumer usage bits queried from encoder, but always add
+ // HW_VIDEO_ENCODER for backward compatibility.
+ uint32_t consumerUsage;
+ if (omxNode->getParameter(
+ (OMX_INDEXTYPE)OMX_IndexParamConsumerUsageBits,
+ &consumerUsage, sizeof(consumerUsage)) != OK) {
+ consumerUsage = 0;
+ }
+
+ OMX_PARAM_PORTDEFINITIONTYPE def;
+ InitOMXParams(&def);
+ def.nPortIndex = kPortIndexInput;
+
+ err = omxNode->getParameter(
+ OMX_IndexParamPortDefinition, &def, sizeof(def));
+ if (err != NO_ERROR) {
+ ALOGE("Failed to get port definition: %d", err);
+ return Status::fromStatusT(UNKNOWN_ERROR);
+ }
+
+ return Status::fromStatusT(mBase->configure(
+ new BWOmxNodeWrapper(omxNode),
+ dataSpace,
+ def.nBufferCountActual,
+ def.format.video.nFrameWidth,
+ def.format.video.nFrameHeight,
+ consumerUsage));
+}
+
+::android::binder::Status BWGraphicBufferSource::setSuspend(
+ bool suspend, int64_t timeUs) {
+ return Status::fromStatusT(mBase->setSuspend(suspend, timeUs));
+}
+
+::android::binder::Status BWGraphicBufferSource::setRepeatPreviousFrameDelayUs(
+ int64_t repeatAfterUs) {
+ return Status::fromStatusT(mBase->setRepeatPreviousFrameDelayUs(repeatAfterUs));
+}
+
+::android::binder::Status BWGraphicBufferSource::setMaxFps(float maxFps) {
+ return Status::fromStatusT(mBase->setMaxFps(maxFps));
+}
+
+::android::binder::Status BWGraphicBufferSource::setTimeLapseConfig(
+ int64_t timePerFrameUs, int64_t timePerCaptureUs) {
+ return Status::fromStatusT(mBase->setTimeLapseConfig(
+ timePerFrameUs, timePerCaptureUs));
+}
+
+::android::binder::Status BWGraphicBufferSource::setStartTimeUs(
+ int64_t startTimeUs) {
+ return Status::fromStatusT(mBase->setStartTimeUs(startTimeUs));
+}
+
+::android::binder::Status BWGraphicBufferSource::setStopTimeUs(
+ int64_t stopTimeUs) {
+ return Status::fromStatusT(mBase->setStopTimeUs(stopTimeUs));
+}
+
+::android::binder::Status BWGraphicBufferSource::setColorAspects(
+ int32_t aspects) {
+ return Status::fromStatusT(mBase->setColorAspects(aspects));
+}
+
+::android::binder::Status BWGraphicBufferSource::setTimeOffsetUs(
+ int64_t timeOffsetsUs) {
+ return Status::fromStatusT(mBase->setTimeOffsetUs(timeOffsetsUs));
+}
+
+::android::binder::Status BWGraphicBufferSource::signalEndOfInputStream() {
+ return Status::fromStatusT(mBase->signalEndOfInputStream());
+}
+
+} // namespace android
--- /dev/null
+/*
+ * Copyright 2017, 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.
+ */
+
+#ifndef BWGRAPHIC_BUFFER_SOURCE_H_
+#define BWGRAPHIC_BUFFER_SOURCE_H_
+
+#include <binder/Binder.h>
+#include <binder/Status.h>
+#include <android/BnGraphicBufferSource.h>
+#include <android/BnOMXBufferSource.h>
+#include <IOMX.h>
+
+#include "GraphicBufferSource.h"
+#include "IOmxNodeWrapper.h"
+
+namespace android {
+
+using ::android::binder::Status;
+using ::android::BnGraphicBufferSource;
+using ::android::GraphicBufferSource;
+using ::android::IOMXNode;
+using ::android::sp;
+
+struct BWGraphicBufferSource : public BnGraphicBufferSource {
+ struct BWOMXBufferSource;
+ struct BWOmxNodeWrapper;
+
+ sp<GraphicBufferSource> mBase;
+ sp<IOMXBufferSource> mOMXBufferSource;
+
+ BWGraphicBufferSource(sp<GraphicBufferSource> const &base);
+
+ Status configure(
+ const sp<IOMXNode>& omxNode, int32_t dataSpace) override;
+ Status setSuspend(bool suspend, int64_t timeUs) override;
+ Status setRepeatPreviousFrameDelayUs(
+ int64_t repeatAfterUs) override;
+ Status setMaxFps(float maxFps) override;
+ Status setTimeLapseConfig(
+ int64_t timePerFrameUs, int64_t timePerCaptureUs) override;
+ Status setStartTimeUs(int64_t startTimeUs) override;
+ Status setStopTimeUs(int64_t stopTimeUs) override;
+ Status setColorAspects(int32_t aspects) override;
+ Status setTimeOffsetUs(int64_t timeOffsetsUs) override;
+ Status signalEndOfInputStream() override;
+};
+
+} // namespace android
+
+#endif // ANDROID_HARDWARE_MEDIA_OMX_V1_0_WGRAPHICBUFFERSOURCE_H
namespace android {
-static const OMX_U32 kPortIndexInput = 0;
-
-class GraphicBufferSource::OmxBufferSource : public BnOMXBufferSource {
-public:
- GraphicBufferSource* mSource;
-
- OmxBufferSource(GraphicBufferSource* source): mSource(source) {
- }
-
- Status onOmxExecuting() override {
- return mSource->onOmxExecuting();
- }
-
- Status onOmxIdle() override {
- return mSource->onOmxIdle();
- }
-
- Status onOmxLoaded() override {
- return mSource->onOmxLoaded();
- }
-
- Status onInputBufferAdded(int bufferId) override {
- return mSource->onInputBufferAdded(bufferId);
- }
-
- Status onInputBufferEmptied(
- int bufferId, const OMXFenceParcelable& fenceParcel) override {
- return mSource->onInputBufferEmptied(bufferId, fenceParcel);
- }
-};
-
GraphicBufferSource::GraphicBufferSource() :
mInitCheck(UNKNOWN_ERROR),
mExecuting(false),
mTimePerFrameUs(-1ll),
mPrevCaptureUs(-1ll),
mPrevFrameUs(-1ll),
- mInputBufferTimeOffsetUs(0ll),
- mOmxBufferSource(new OmxBufferSource(this)) {
+ mInputBufferTimeOffsetUs(0ll) {
ALOGV("GraphicBufferSource");
String8 name("GraphicBufferSource");
return;
}
- memset(&mColorAspects, 0, sizeof(mColorAspects));
+ memset(&mColorAspectsPacked, 0, sizeof(mColorAspectsPacked));
CHECK(mInitCheck == NO_ERROR);
}
}
Status GraphicBufferSource::onInputBufferEmptied(
- int32_t bufferID, const OMXFenceParcelable &fenceParcel) {
- int fenceFd = fenceParcel.get();
-
+ int32_t bufferID, int fenceFd) {
Mutex::Autolock autoLock(mMutex);
if (!mExecuting) {
if (fenceFd >= 0) {
mLastDataSpace = dataSpace;
if (ColorUtils::convertDataSpaceToV0(dataSpace)) {
- omx_message msg;
- msg.type = omx_message::EVENT;
- msg.fenceFd = -1;
- msg.u.event_data.event = OMX_EventDataSpaceChanged;
- msg.u.event_data.data1 = mLastDataSpace;
- msg.u.event_data.data2 = ColorUtils::packToU32(mColorAspects);
- msg.u.event_data.data3 = pixelFormat;
-
- mOMXNode->dispatchMessage(msg);
+ mOMXNode->dispatchDataSpaceChanged(mLastDataSpace, mColorAspectsPacked, pixelFormat);
}
}
int fenceID = item.mFence->isValid() ? item.mFence->dup() : -1;
status_t err = mOMXNode->emptyBuffer(
- bufferID, buffer, OMX_BUFFERFLAG_ENDOFFRAME, codecTimeUs, fenceID);
+ bufferID, OMX_BUFFERFLAG_ENDOFFRAME, buffer, codecTimeUs, fenceID);
if (err != OK) {
ALOGW("WARNING: emptyGraphicBuffer failed: 0x%x", err);
CodecBuffer& codecBuffer(mCodecBuffers.editItemAt(cbi));
IOMX::buffer_id bufferID = codecBuffer.mBufferID;
- status_t err = mOMXNode->emptyBuffer(
- bufferID, (sp<GraphicBuffer>)NULL,
- OMX_BUFFERFLAG_ENDOFFRAME | OMX_BUFFERFLAG_EOS,
- 0 /* timestamp */, -1 /* fenceFd */);
+ status_t err = mOMXNode->emptyBuffer(bufferID,
+ OMX_BUFFERFLAG_ENDOFFRAME | OMX_BUFFERFLAG_EOS);
if (err != OK) {
ALOGW("emptyDirectBuffer EOS failed: 0x%x", err);
} else {
ALOG_ASSERT(false, "GraphicBufferSource can't consume sideband streams");
}
-Status GraphicBufferSource::configure(
- const sp<IOMXNode>& omxNode, int32_t dataSpace) {
+status_t GraphicBufferSource::configure(
+ const sp<IOmxNodeWrapper>& omxNode,
+ int32_t dataSpace,
+ int32_t bufferCount,
+ uint32_t frameWidth,
+ uint32_t frameHeight,
+ uint32_t consumerUsage) {
if (omxNode == NULL) {
- return Status::fromServiceSpecificError(BAD_VALUE);
- }
-
- // Do setInputSurface() first, the node will try to enable metadata
- // mode on input, and does necessary error checking. If this fails,
- // we can't use this input surface on the node.
- status_t err = omxNode->setInputSurface(mOmxBufferSource);
- if (err != NO_ERROR) {
- ALOGE("Unable to set input surface: %d", err);
- return Status::fromServiceSpecificError(err);
+ return BAD_VALUE;
}
- // use consumer usage bits queried from encoder, but always add
- // HW_VIDEO_ENCODER for backward compatibility.
- uint32_t consumerUsage;
- if (omxNode->getParameter(
- (OMX_INDEXTYPE)OMX_IndexParamConsumerUsageBits,
- &consumerUsage, sizeof(consumerUsage)) != OK) {
- consumerUsage = 0;
- }
-
- OMX_PARAM_PORTDEFINITIONTYPE def;
- InitOMXParams(&def);
- def.nPortIndex = kPortIndexInput;
-
- err = omxNode->getParameter(
- OMX_IndexParamPortDefinition, &def, sizeof(def));
- if (err != NO_ERROR) {
- ALOGE("Failed to get port definition: %d", err);
- return Status::fromServiceSpecificError(UNKNOWN_ERROR);
- }
// Call setMaxAcquiredBufferCount without lock.
// setMaxAcquiredBufferCount could call back to onBuffersReleased
// if the buffer count change results in releasing of existing buffers,
// which would lead to deadlock.
- err = mConsumer->setMaxAcquiredBufferCount(def.nBufferCountActual);
+ status_t err = mConsumer->setMaxAcquiredBufferCount(bufferCount);
if (err != NO_ERROR) {
ALOGE("Unable to set BQ max acquired buffer count to %u: %d",
- def.nBufferCountActual, err);
- return Status::fromServiceSpecificError(err);
+ bufferCount, err);
+ return err;
}
{
Mutex::Autolock autoLock(mMutex);
mOMXNode = omxNode;
- err = mConsumer->setDefaultBufferSize(
- def.format.video.nFrameWidth,
- def.format.video.nFrameHeight);
+ err = mConsumer->setDefaultBufferSize(frameWidth, frameHeight);
if (err != NO_ERROR) {
ALOGE("Unable to set BQ default buffer size to %ux%u: %d",
- def.format.video.nFrameWidth,
- def.format.video.nFrameHeight,
- err);
- return Status::fromServiceSpecificError(err);
+ frameWidth, frameHeight, err);
+ return err;
}
consumerUsage |= GRALLOC_USAGE_HW_VIDEO_ENCODER;
mActionQueue.clear();
}
- return Status::ok();
+ return OK;
}
-Status GraphicBufferSource::setSuspend(bool suspend, int64_t suspendStartTimeUs) {
+status_t GraphicBufferSource::setSuspend(bool suspend, int64_t suspendStartTimeUs) {
ALOGV("setSuspend=%d at time %lld us", suspend, (long long)suspendStartTimeUs);
Mutex::Autolock autoLock(mMutex);
if (mStopTimeUs != -1) {
ALOGE("setSuspend failed as STOP action is pending");
- return Status::fromServiceSpecificError(INVALID_OPERATION);
+ return INVALID_OPERATION;
}
// Push the action to the queue.
if (suspendStartTimeUs > currentSystemTimeUs) {
ALOGE("setSuspend failed. %lld is larger than current system time %lld us",
(long long)suspendStartTimeUs, (long long)currentSystemTimeUs);
- return Status::fromServiceSpecificError(INVALID_OPERATION);
+ return INVALID_OPERATION;
}
if (mLastActionTimeUs != -1 && suspendStartTimeUs < mLastActionTimeUs) {
ALOGE("setSuspend failed. %lld is smaller than last action time %lld us",
(long long)suspendStartTimeUs, (long long)mLastActionTimeUs);
- return Status::fromServiceSpecificError(INVALID_OPERATION);
+ return INVALID_OPERATION;
}
mLastActionTimeUs = suspendStartTimeUs;
ActionItem action;
releaseBuffer(item.mSlot, item.mFrameNumber, item.mFence);
}
- return Status::ok();
+ return OK;
} else {
mSuspended = false;
}
}
}
- return Status::ok();
+ return OK;
}
-Status GraphicBufferSource::setRepeatPreviousFrameDelayUs(int64_t repeatAfterUs) {
+status_t GraphicBufferSource::setRepeatPreviousFrameDelayUs(int64_t repeatAfterUs) {
ALOGV("setRepeatPreviousFrameDelayUs: delayUs=%lld", (long long)repeatAfterUs);
Mutex::Autolock autoLock(mMutex);
if (mExecuting || repeatAfterUs <= 0ll) {
- return Status::fromServiceSpecificError(INVALID_OPERATION);
+ return INVALID_OPERATION;
}
mRepeatAfterUs = repeatAfterUs;
- return Status::ok();
+ return OK;
}
-Status GraphicBufferSource::setTimeOffsetUs(int64_t timeOffsetUs) {
+status_t GraphicBufferSource::setTimeOffsetUs(int64_t timeOffsetUs) {
Mutex::Autolock autoLock(mMutex);
// timeOffsetUs must be negative for adjustment.
if (timeOffsetUs >= 0ll) {
- return Status::fromServiceSpecificError(INVALID_OPERATION);
+ return INVALID_OPERATION;
}
mInputBufferTimeOffsetUs = timeOffsetUs;
- return Status::ok();
+ return OK;
}
-Status GraphicBufferSource::setMaxFps(float maxFps) {
+status_t GraphicBufferSource::setMaxFps(float maxFps) {
ALOGV("setMaxFps: maxFps=%lld", (long long)maxFps);
Mutex::Autolock autoLock(mMutex);
if (mExecuting) {
- return Status::fromServiceSpecificError(INVALID_OPERATION);
+ return INVALID_OPERATION;
}
mFrameDropper = new FrameDropper();
status_t err = mFrameDropper->setMaxFrameRate(maxFps);
if (err != OK) {
mFrameDropper.clear();
- return Status::fromServiceSpecificError(err);
+ return err;
}
- return Status::ok();
+ return OK;
}
-Status GraphicBufferSource::setStartTimeUs(int64_t skipFramesBeforeUs) {
+status_t GraphicBufferSource::setStartTimeUs(int64_t skipFramesBeforeUs) {
ALOGV("setStartTimeUs: skipFramesBeforeUs=%lld", (long long)skipFramesBeforeUs);
Mutex::Autolock autoLock(mMutex);
mSkipFramesBeforeNs =
(skipFramesBeforeUs > 0) ? (skipFramesBeforeUs * 1000) : -1ll;
- return Status::ok();
+ return OK;
}
-Status GraphicBufferSource::setStopTimeUs(int64_t stopTimeUs) {
+status_t GraphicBufferSource::setStopTimeUs(int64_t stopTimeUs) {
ALOGV("setStopTimeUs: %lld us", (long long)stopTimeUs);
Mutex::Autolock autoLock(mMutex);
if (mStopTimeUs != -1) {
// Ignore if stop time has already been set
- return Status::ok();
+ return OK;
}
// stopTimeUs must be smaller or equal to current systemTime.
if (stopTimeUs > currentSystemTimeUs) {
ALOGE("setStopTimeUs failed. %lld is larger than current system time %lld us",
(long long)stopTimeUs, (long long)currentSystemTimeUs);
- return Status::fromServiceSpecificError(INVALID_OPERATION);
+ return INVALID_OPERATION;
}
if (mLastActionTimeUs != -1 && stopTimeUs < mLastActionTimeUs) {
ALOGE("setSuspend failed. %lld is smaller than last action time %lld us",
(long long)stopTimeUs, (long long)mLastActionTimeUs);
- return Status::fromServiceSpecificError(INVALID_OPERATION);
+ return INVALID_OPERATION;
}
mLastActionTimeUs = stopTimeUs;
ActionItem action;
action.mActionTimeUs = stopTimeUs;
mActionQueue.push_back(action);
mStopTimeUs = stopTimeUs;
- return Status::ok();
+ return OK;
}
-Status GraphicBufferSource::setTimeLapseConfig(int64_t timePerFrameUs, int64_t timePerCaptureUs) {
+status_t GraphicBufferSource::setTimeLapseConfig(int64_t timePerFrameUs, int64_t timePerCaptureUs) {
ALOGV("setTimeLapseConfig: timePerFrameUs=%lld, timePerCaptureUs=%lld",
(long long)timePerFrameUs, (long long)timePerCaptureUs);
Mutex::Autolock autoLock(mMutex);
if (mExecuting || timePerFrameUs <= 0ll || timePerCaptureUs <= 0ll) {
- return Status::fromServiceSpecificError(INVALID_OPERATION);
+ return INVALID_OPERATION;
}
mTimePerFrameUs = timePerFrameUs;
mTimePerCaptureUs = timePerCaptureUs;
- return Status::ok();
+ return OK;
}
-Status GraphicBufferSource::setColorAspects(int32_t aspectsPacked) {
+status_t GraphicBufferSource::setColorAspects(int32_t aspectsPacked) {
Mutex::Autolock autoLock(mMutex);
- mColorAspects = ColorUtils::unpackToColorAspects(aspectsPacked);
+ mColorAspectsPacked = aspectsPacked;
+ ColorAspects colorAspects = ColorUtils::unpackToColorAspects(aspectsPacked);
ALOGD("requesting color aspects (R:%d(%s), P:%d(%s), M:%d(%s), T:%d(%s))",
- mColorAspects.mRange, asString(mColorAspects.mRange),
- mColorAspects.mPrimaries, asString(mColorAspects.mPrimaries),
- mColorAspects.mMatrixCoeffs, asString(mColorAspects.mMatrixCoeffs),
- mColorAspects.mTransfer, asString(mColorAspects.mTransfer));
+ colorAspects.mRange, asString(colorAspects.mRange),
+ colorAspects.mPrimaries, asString(colorAspects.mPrimaries),
+ colorAspects.mMatrixCoeffs, asString(colorAspects.mMatrixCoeffs),
+ colorAspects.mTransfer, asString(colorAspects.mTransfer));
- return Status::ok();
+ return OK;
}
-Status GraphicBufferSource::signalEndOfInputStream() {
+status_t GraphicBufferSource::signalEndOfInputStream() {
Mutex::Autolock autoLock(mMutex);
ALOGV("signalEndOfInputStream: exec=%d avail=%zu eos=%d",
mExecuting, mNumFramesAvailable, mEndOfStream);
if (mEndOfStream) {
ALOGE("EOS was already signaled");
- return Status::fromStatusT(INVALID_OPERATION);
+ return INVALID_OPERATION;
}
// Set the end-of-stream flag. If no frames are pending from the
submitEndOfInputStream_l();
}
- return Status::ok();
+ return OK;
}
void GraphicBufferSource::onMessageReceived(const sp<AMessage> &msg) {
#include <android/BnGraphicBufferSource.h>
#include <android/BnOMXBufferSource.h>
+#include "IOmxNodeWrapper.h"
+
namespace android {
using ::android::binder::Status;
* before the codec is in the "executing" state, so we need to queue
* things up until we're ready to go.
*/
-class GraphicBufferSource : public BnGraphicBufferSource,
- public BufferQueue::ConsumerListener {
+class GraphicBufferSource : public BufferQueue::ConsumerListener {
public:
GraphicBufferSource();
// Called from OnEmptyBufferDone. If we have a BQ buffer available,
// fill it with a new frame of data; otherwise, just mark it as available.
Status onInputBufferEmptied(
- int32_t bufferID, const OMXFenceParcelable& fenceParcel);
+ int32_t bufferID, int fenceFd);
// Configure the buffer source to be used with an OMX node with the default
// data space.
- Status configure(const sp<IOMXNode>& omxNode, int32_t dataSpace) override;
+ status_t configure(
+ const sp<IOmxNodeWrapper> &omxNode,
+ int32_t dataSpace,
+ int32_t bufferCount,
+ uint32_t frameWidth,
+ uint32_t frameHeight,
+ uint32_t consumerUsage);
// This is called after the last input frame has been submitted or buffer
// timestamp is greater or equal than stopTimeUs. We need to submit an empty
// buffer with the EOS flag set. If we don't have a codec buffer ready,
// we just set the mEndOfStream flag.
- Status signalEndOfInputStream() override;
+ status_t signalEndOfInputStream();
// If suspend is true, all incoming buffers (including those currently
// in the BufferQueue) with timestamp larger than timeUs will be discarded
// until the suspension is lifted. If suspend is false, all incoming buffers
// including those currently in the BufferQueue) with timestamp larger than
// timeUs will be processed. timeUs uses SYSTEM_TIME_MONOTONIC time base.
- Status setSuspend(bool suspend, int64_t timeUs) override;
+ status_t setSuspend(bool suspend, int64_t timeUs);
// Specifies the interval after which we requeue the buffer previously
// queued to the encoder. This is useful in the case of surface flinger
// the decoder on the remote end would be unable to decode the latest frame.
// This API must be called before transitioning the encoder to "executing"
// state and once this behaviour is specified it cannot be reset.
- Status setRepeatPreviousFrameDelayUs(int64_t repeatAfterUs) override;
+ status_t setRepeatPreviousFrameDelayUs(int64_t repeatAfterUs);
// Sets the input buffer timestamp offset.
// When set, the sample's timestamp will be adjusted with the timeOffsetUs.
- Status setTimeOffsetUs(int64_t timeOffsetUs) override;
+ status_t setTimeOffsetUs(int64_t timeOffsetUs);
// When set, the max frame rate fed to the encoder will be capped at maxFps.
- Status setMaxFps(float maxFps) override;
+ status_t setMaxFps(float maxFps);
// Sets the time lapse (or slow motion) parameters.
// When set, the sample's timestamp will be modified to playback framerate,
// and capture timestamp will be modified to capture rate.
- Status setTimeLapseConfig(int64_t timePerFrameUs, int64_t timePerCaptureUs) override;
+ status_t setTimeLapseConfig(int64_t timePerFrameUs, int64_t timePerCaptureUs);
// Sets the start time us (in system time), samples before which should
// be dropped and not submitted to encoder
- Status setStartTimeUs(int64_t startTimeUs) override;
+ status_t setStartTimeUs(int64_t startTimeUs);
// Sets the stop time us (in system time), samples after which should be dropped
// and not submitted to encoder. timeUs uses SYSTEM_TIME_MONOTONIC time base.
- Status setStopTimeUs(int64_t stopTimeUs) override;
+ status_t setStopTimeUs(int64_t stopTimeUs);
// Sets the desired color aspects, e.g. to be used when producer does not specify a dataspace.
- Status setColorAspects(int32_t aspectsPacked) override;
+ status_t setColorAspects(int32_t aspectsPacked);
protected:
// BufferQueue::ConsumerListener interface, called when a new frame of
// Used to report constructor failure.
status_t mInitCheck;
- // Pointer back to the IOMXNode that created us. We send buffers here.
- sp<IOMXNode> mOMXNode;
+ // Pointer back to the Omx node that created us. We send buffers here.
+ sp<IOmxNodeWrapper> mOMXNode;
// Set by omxExecuting() / omxIdling().
bool mExecuting;
int64_t mInputBufferTimeOffsetUs;
- ColorAspects mColorAspects;
-
- class OmxBufferSource;
- sp<OmxBufferSource> mOmxBufferSource;
+ int32_t mColorAspectsPacked;
void onMessageReceived(const sp<AMessage> &msg);
--- /dev/null
+/*
+ * Copyright 2017, 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.
+ */
+
+#ifndef IOMX_NODE_WRAPPER_SOURCE_H_
+#define IOMX_NODE_WRAPPER_SOURCE_H_
+
+#include <utils/RefBase.h>
+#include <utils/StrongPointer.h>
+#include <ui/GraphicBuffer.h>
+
+#include <stdint.h>
+
+namespace android {
+
+struct IOmxNodeWrapper : public RefBase {
+ virtual status_t emptyBuffer(
+ int32_t bufferId, uint32_t flags,
+ const sp<GraphicBuffer> &buffer = nullptr,
+ int64_t timestamp = 0, int fenceFd = -1) = 0;
+ virtual void dispatchDataSpaceChanged(
+ int32_t dataSpace, int32_t aspects, int32_t pixelFormat) = 0;
+};
+
+} // namespace android
+
+#endif // ANDROID_HARDWARE_MEDIA_OMX_V1_0_WGRAPHICBUFFERSOURCE_H
#include "../include/OMXNodeInstance.h"
#include <media/stagefright/foundation/ADebug.h>
-#include "GraphicBufferSource.h"
+#include "BWGraphicBufferSource.h"
#include "OMXMaster.h"
#include "OMXUtils.h"
}
*bufferProducer = graphicBufferSource->getIGraphicBufferProducer();
- *bufferSource = graphicBufferSource;
+ *bufferSource = new BWGraphicBufferSource(graphicBufferSource);
return OK;
}
LOCAL_MODULE := android.hardware.media.omx@1.0-impl
LOCAL_SRC_FILES := \
WGraphicBufferSource.cpp \
- WOmx.cpp \
WOmxBufferProducer.cpp \
WOmxBufferSource.cpp \
WOmxNode.cpp \
}
/**
+ * \brief Wrap `GraphicBuffer` in `CodecBuffer`.
+ *
+ * \param[out] t The wrapper of type `CodecBuffer`.
+ * \param[in] l The source `GraphicBuffer`.
+ */
+// wrap: OMXBuffer -> CodecBuffer
+inline CodecBuffer *wrapAs(CodecBuffer *t, sp<GraphicBuffer> const& graphicBuffer) {
+ t->sharedMemory = hidl_memory();
+ t->nativeHandle = hidl_handle();
+ t->type = CodecBuffer::Type::ANW_BUFFER;
+ if (graphicBuffer == nullptr) {
+ t->attr.anwBuffer.width = 0;
+ t->attr.anwBuffer.height = 0;
+ t->attr.anwBuffer.stride = 0;
+ t->attr.anwBuffer.format = static_cast<PixelFormat>(1);
+ t->attr.anwBuffer.layerCount = 0;
+ t->attr.anwBuffer.usage = 0;
+ return t;
+ }
+ t->attr.anwBuffer.width = graphicBuffer->getWidth();
+ t->attr.anwBuffer.height = graphicBuffer->getHeight();
+ t->attr.anwBuffer.stride = graphicBuffer->getStride();
+ t->attr.anwBuffer.format = static_cast<PixelFormat>(
+ graphicBuffer->getPixelFormat());
+ t->attr.anwBuffer.layerCount = graphicBuffer->getLayerCount();
+ t->attr.anwBuffer.usage = graphicBuffer->getUsage();
+ t->nativeHandle = graphicBuffer->handle;
+ return t;
+}
+
+/**
* \brief Wrap `OMXBuffer` in `CodecBuffer`.
*
* \param[out] t The wrapper of type `CodecBuffer`.
return false;
}
case OMXBuffer::kBufferTypeANWBuffer: {
- t->type = CodecBuffer::Type::ANW_BUFFER;
- if (l.mGraphicBuffer == nullptr) {
- t->attr.anwBuffer.width = 0;
- t->attr.anwBuffer.height = 0;
- t->attr.anwBuffer.stride = 0;
- t->attr.anwBuffer.format = static_cast<PixelFormat>(1);
- t->attr.anwBuffer.layerCount = 0;
- t->attr.anwBuffer.usage = 0;
- return true;
- }
- t->attr.anwBuffer.width = l.mGraphicBuffer->getWidth();
- t->attr.anwBuffer.height = l.mGraphicBuffer->getHeight();
- t->attr.anwBuffer.stride = l.mGraphicBuffer->getStride();
- t->attr.anwBuffer.format = static_cast<PixelFormat>(
- l.mGraphicBuffer->getPixelFormat());
- t->attr.anwBuffer.layerCount = l.mGraphicBuffer->getLayerCount();
- t->attr.anwBuffer.usage = l.mGraphicBuffer->getUsage();
- t->nativeHandle = l.mGraphicBuffer->handle;
+ wrapAs(t, l.mGraphicBuffer);
return true;
}
case OMXBuffer::kBufferTypeNativeHandle: {
Return<void> Omx::createInputSurface(createInputSurface_cb _hidl_cb) {
sp<::android::IGraphicBufferProducer> bufferProducer;
- sp<::android::IGraphicBufferSource> bufferSource;
sp<GraphicBufferSource> graphicBufferSource = new GraphicBufferSource();
status_t err = graphicBufferSource->initCheck();
return Void();
}
bufferProducer = graphicBufferSource->getIGraphicBufferProducer();
- bufferSource = graphicBufferSource;
_hidl_cb(toStatus(OK),
new TWOmxBufferProducer(bufferProducer),
- new TWGraphicBufferSource(bufferSource));
+ new TWGraphicBufferSource(graphicBufferSource));
return Void();
}
* limitations under the License.
*/
-#include <stagefright/foundation/ColorUtils.h>
+//#define LOG_NDEBUG 0
+#define LOG_TAG "TWGraphicBufferSource"
+#include <android/hardware/media/omx/1.0/IOmxBufferSource.h>
+#include <android/hardware/media/omx/1.0/IOmxNode.h>
+#include <OMX_Component.h>
+#include <OMX_IndexExt.h>
+
+#include "omx/OMXUtils.h"
#include "WGraphicBufferSource.h"
#include "WOmxNode.h"
#include "Conversion.h"
namespace V1_0 {
namespace implementation {
-using android::ColorUtils;
-
-// LWGraphicBufferSource
-LWGraphicBufferSource::LWGraphicBufferSource(
- sp<TGraphicBufferSource> const& base) : mBase(base) {
-}
-
-::android::binder::Status LWGraphicBufferSource::configure(
- const sp<IOMXNode>& omxNode, int32_t dataSpace) {
- return toBinderStatus(mBase->configure(
- new TWOmxNode(omxNode), toHardwareDataspace(dataSpace)));
-}
-
-::android::binder::Status LWGraphicBufferSource::setSuspend(
- bool suspend, int64_t timeUs) {
- return toBinderStatus(mBase->setSuspend(suspend, timeUs));
-}
-
-::android::binder::Status LWGraphicBufferSource::setRepeatPreviousFrameDelayUs(
- int64_t repeatAfterUs) {
- return toBinderStatus(mBase->setRepeatPreviousFrameDelayUs(repeatAfterUs));
-}
-
-::android::binder::Status LWGraphicBufferSource::setMaxFps(float maxFps) {
- return toBinderStatus(mBase->setMaxFps(maxFps));
-}
-
-::android::binder::Status LWGraphicBufferSource::setTimeLapseConfig(
- int64_t timePerFrameUs, int64_t timePerCaptureUs) {
- return toBinderStatus(mBase->setTimeLapseConfig(
- timePerFrameUs, timePerCaptureUs));
-}
-
-::android::binder::Status LWGraphicBufferSource::setStartTimeUs(
- int64_t startTimeUs) {
- return toBinderStatus(mBase->setStartTimeUs(startTimeUs));
-}
-
-::android::binder::Status LWGraphicBufferSource::setStopTimeUs(
- int64_t stopTimeUs) {
- return toBinderStatus(mBase->setStopTimeUs(stopTimeUs));
-}
-
-::android::binder::Status LWGraphicBufferSource::setColorAspects(
- int32_t aspects) {
- return toBinderStatus(mBase->setColorAspects(
- toHardwareColorAspects(aspects)));
-}
-
-::android::binder::Status LWGraphicBufferSource::setTimeOffsetUs(
- int64_t timeOffsetsUs) {
- return toBinderStatus(mBase->setTimeOffsetUs(timeOffsetsUs));
-}
-
-::android::binder::Status LWGraphicBufferSource::signalEndOfInputStream() {
- return toBinderStatus(mBase->signalEndOfInputStream());
-}
+static const OMX_U32 kPortIndexInput = 0;
+
+struct TWGraphicBufferSource::TWOmxNodeWrapper : public IOmxNodeWrapper {
+ sp<IOmxNode> mOmxNode;
+
+ TWOmxNodeWrapper(const sp<IOmxNode> &omxNode): mOmxNode(omxNode) {
+ }
+
+ virtual status_t emptyBuffer(
+ int32_t bufferId, uint32_t flags,
+ const sp<GraphicBuffer> &buffer,
+ int64_t timestamp, int fenceFd) override {
+ CodecBuffer tBuffer;
+ return toStatusT(mOmxNode->emptyBuffer(
+ bufferId,
+ *wrapAs(&tBuffer, buffer),
+ flags,
+ toRawTicks(timestamp),
+ native_handle_create_from_fd(fenceFd)));
+ }
+
+ virtual void dispatchDataSpaceChanged(
+ int32_t dataSpace, int32_t aspects, int32_t pixelFormat) override {
+ Message tMsg;
+ tMsg.type = Message::Type::EVENT;
+ tMsg.fence = native_handle_create(0, 0);
+ tMsg.data.eventData.event = uint32_t(OMX_EventDataSpaceChanged);
+ tMsg.data.eventData.data1 = dataSpace;
+ tMsg.data.eventData.data2 = aspects;
+ tMsg.data.eventData.data3 = pixelFormat;
+ mOmxNode->dispatchMessage(tMsg);
+ }
+};
+
+struct TWGraphicBufferSource::TWOmxBufferSource : public IOmxBufferSource {
+ sp<GraphicBufferSource> mSource;
+
+ TWOmxBufferSource(const sp<GraphicBufferSource> &source): mSource(source) {
+ }
+
+ Return<void> onOmxExecuting() override {
+ mSource->onOmxExecuting();
+ return Void();
+ }
+
+ Return<void> onOmxIdle() override {
+ mSource->onOmxIdle();
+ return Void();
+ }
+
+ Return<void> onOmxLoaded() override {
+ mSource->onOmxLoaded();
+ return Void();
+ }
+
+ Return<void> onInputBufferAdded(uint32_t bufferId) override {
+ mSource->onInputBufferAdded(static_cast<int32_t>(bufferId));
+ return Void();
+ }
+
+ Return<void> onInputBufferEmptied(
+ uint32_t bufferId, hidl_handle const& tFence) override {
+ mSource->onInputBufferEmptied(
+ static_cast<int32_t>(bufferId),
+ native_handle_read_fd(tFence));
+ return Void();
+ }
+};
// TWGraphicBufferSource
TWGraphicBufferSource::TWGraphicBufferSource(
- sp<LGraphicBufferSource> const& base) : mBase(base) {
+ sp<GraphicBufferSource> const& base) :
+ mBase(base),
+ mOmxBufferSource(new TWOmxBufferSource(base)) {
}
-Return<void> TWGraphicBufferSource::configure(
+Return<Status> TWGraphicBufferSource::configure(
const sp<IOmxNode>& omxNode, Dataspace dataspace) {
- mBase->configure(new LWOmxNode(omxNode), toRawDataspace(dataspace));
- return Void();
-}
-
-Return<void> TWGraphicBufferSource::setSuspend(
+ if (omxNode == NULL) {
+ return toStatus(BAD_VALUE);
+ }
+
+ // Do setInputSurface() first, the node will try to enable metadata
+ // mode on input, and does necessary error checking. If this fails,
+ // we can't use this input surface on the node.
+ Return<Status> err(omxNode->setInputSurface(mOmxBufferSource));
+ status_t fnStatus = toStatusT(err);
+ if (fnStatus != NO_ERROR) {
+ ALOGE("Unable to set input surface: %d", fnStatus);
+ return err;
+ }
+
+ // use consumer usage bits queried from encoder, but always add
+ // HW_VIDEO_ENCODER for backward compatibility.
+ uint32_t consumerUsage;
+ void *_params = &consumerUsage;
+ uint8_t *params = static_cast<uint8_t*>(_params);
+ fnStatus = UNKNOWN_ERROR;
+ IOmxNode::getParameter_cb _hidl_cb(
+ [&fnStatus, ¶ms](Status status, hidl_vec<uint8_t> const& outParams) {
+ fnStatus = toStatusT(status);
+ std::copy(
+ outParams.data(),
+ outParams.data() + outParams.size(),
+ params);
+ });
+ omxNode->getParameter(
+ static_cast<uint32_t>(OMX_IndexParamConsumerUsageBits),
+ inHidlBytes(&consumerUsage, sizeof(consumerUsage)),
+ _hidl_cb);
+ if (fnStatus != OK) {
+ consumerUsage = 0;
+ }
+
+ OMX_PARAM_PORTDEFINITIONTYPE def;
+ InitOMXParams(&def);
+ def.nPortIndex = kPortIndexInput;
+
+ _params = &def;
+ params = static_cast<uint8_t*>(_params);
+ omxNode->getParameter(
+ static_cast<uint32_t>(OMX_IndexParamPortDefinition),
+ inHidlBytes(&def, sizeof(def)),
+ _hidl_cb);
+ if (fnStatus != NO_ERROR) {
+ ALOGE("Failed to get port definition: %d", fnStatus);
+ return toStatus(fnStatus);
+ }
+
+
+ return toStatus(mBase->configure(
+ new TWOmxNodeWrapper(omxNode),
+ toRawDataspace(dataspace),
+ def.nBufferCountActual,
+ def.format.video.nFrameWidth,
+ def.format.video.nFrameHeight,
+ consumerUsage));
+}
+
+Return<Status> TWGraphicBufferSource::setSuspend(
bool suspend, int64_t timeUs) {
- mBase->setSuspend(suspend, timeUs);
- return Void();
+ return toStatus(mBase->setSuspend(suspend, timeUs));
}
-Return<void> TWGraphicBufferSource::setRepeatPreviousFrameDelayUs(
+Return<Status> TWGraphicBufferSource::setRepeatPreviousFrameDelayUs(
int64_t repeatAfterUs) {
- mBase->setRepeatPreviousFrameDelayUs(repeatAfterUs);
- return Void();
+ return toStatus(mBase->setRepeatPreviousFrameDelayUs(repeatAfterUs));
}
-Return<void> TWGraphicBufferSource::setMaxFps(float maxFps) {
- mBase->setMaxFps(maxFps);
- return Void();
+Return<Status> TWGraphicBufferSource::setMaxFps(float maxFps) {
+ return toStatus(mBase->setMaxFps(maxFps));
}
-Return<void> TWGraphicBufferSource::setTimeLapseConfig(
+Return<Status> TWGraphicBufferSource::setTimeLapseConfig(
int64_t timePerFrameUs, int64_t timePerCaptureUs) {
- mBase->setTimeLapseConfig(timePerFrameUs, timePerCaptureUs);
- return Void();
+ return toStatus(mBase->setTimeLapseConfig(timePerFrameUs, timePerCaptureUs));
}
-Return<void> TWGraphicBufferSource::setStartTimeUs(int64_t startTimeUs) {
- mBase->setStartTimeUs(startTimeUs);
- return Void();
+Return<Status> TWGraphicBufferSource::setStartTimeUs(int64_t startTimeUs) {
+ return toStatus(mBase->setStartTimeUs(startTimeUs));
}
-Return<void> TWGraphicBufferSource::setStopTimeUs(int64_t stopTimeUs) {
- mBase->setStopTimeUs(stopTimeUs);
- return Void();
+Return<Status> TWGraphicBufferSource::setStopTimeUs(int64_t stopTimeUs) {
+ return toStatus(mBase->setStopTimeUs(stopTimeUs));
}
-Return<void> TWGraphicBufferSource::setColorAspects(
+Return<Status> TWGraphicBufferSource::setColorAspects(
const ColorAspects& aspects) {
- mBase->setColorAspects(toCompactColorAspects(aspects));
- return Void();
+ return toStatus(mBase->setColorAspects(toCompactColorAspects(aspects)));
}
-Return<void> TWGraphicBufferSource::setTimeOffsetUs(int64_t timeOffsetUs) {
- mBase->setTimeOffsetUs(timeOffsetUs);
- return Void();
+Return<Status> TWGraphicBufferSource::setTimeOffsetUs(int64_t timeOffsetUs) {
+ return toStatus(mBase->setTimeOffsetUs(timeOffsetUs));
}
-Return<void> TWGraphicBufferSource::signalEndOfInputStream() {
- mBase->signalEndOfInputStream();
- return Void();
+Return<Status> TWGraphicBufferSource::signalEndOfInputStream() {
+ return toStatus(mBase->signalEndOfInputStream());
}
} // namespace implementation
#include <hidl/MQDescriptor.h>
#include <hidl/Status.h>
-#include <media/IOMX.h>
-#include <binder/Binder.h>
-
+#include <android/hardware/media/omx/1.0/IGraphicBufferSource.h>
+#include <android/hardware/media/omx/1.0/IOmxNode.h>
#include <android/hardware/graphics/common/1.0/types.h>
#include <android/hardware/media/omx/1.0/IOmxNode.h>
#include <android/hardware/media/omx/1.0/IGraphicBufferSource.h>
#include <android/BnGraphicBufferSource.h>
+#include "../../../GraphicBufferSource.h"
+
namespace android {
namespace hardware {
namespace media {
namespace V1_0 {
namespace implementation {
+using ::android::GraphicBufferSource;
using ::android::hardware::graphics::common::V1_0::Dataspace;
using ::android::hardware::media::omx::V1_0::ColorAspects;
using ::android::hardware::media::omx::V1_0::IGraphicBufferSource;
using ::android::hardware::media::omx::V1_0::IOmxNode;
+using ::android::hardware::media::omx::V1_0::Status;
using ::android::hidl::base::V1_0::IBase;
using ::android::hardware::hidl_array;
using ::android::hardware::hidl_memory;
* - TW = Treble Wrapper --- It wraps a legacy object inside a Treble object.
*/
-typedef ::android::IGraphicBufferSource LGraphicBufferSource;
-typedef ::android::BnGraphicBufferSource BnGraphicBufferSource;
typedef ::android::hardware::media::omx::V1_0::IGraphicBufferSource
TGraphicBufferSource;
-struct LWGraphicBufferSource : public BnGraphicBufferSource {
- sp<TGraphicBufferSource> mBase;
- LWGraphicBufferSource(sp<TGraphicBufferSource> const& base);
- ::android::binder::Status configure(
- const sp<IOMXNode>& omxNode, int32_t dataSpace) override;
- ::android::binder::Status setSuspend(bool suspend, int64_t timeUs) override;
- ::android::binder::Status setRepeatPreviousFrameDelayUs(
- int64_t repeatAfterUs) override;
- ::android::binder::Status setMaxFps(float maxFps) override;
- ::android::binder::Status setTimeLapseConfig(
- int64_t timePerFrameUs, int64_t timePerCaptureUs) override;
- ::android::binder::Status setStartTimeUs(int64_t startTimeUs) override;
- ::android::binder::Status setStopTimeUs(int64_t stopTimeUs) override;
- ::android::binder::Status setColorAspects(int32_t aspects) override;
- ::android::binder::Status setTimeOffsetUs(int64_t timeOffsetsUs) override;
- ::android::binder::Status signalEndOfInputStream() override;
-};
-
struct TWGraphicBufferSource : public TGraphicBufferSource {
- sp<LGraphicBufferSource> mBase;
- TWGraphicBufferSource(sp<LGraphicBufferSource> const& base);
- Return<void> configure(
+ struct TWOmxNodeWrapper;
+ struct TWOmxBufferSource;
+ sp<GraphicBufferSource> mBase;
+ sp<IOmxBufferSource> mOmxBufferSource;
+
+ TWGraphicBufferSource(sp<GraphicBufferSource> const& base);
+ Return<Status> configure(
const sp<IOmxNode>& omxNode, Dataspace dataspace) override;
- Return<void> setSuspend(bool suspend, int64_t timeUs) override;
- Return<void> setRepeatPreviousFrameDelayUs(int64_t repeatAfterUs) override;
- Return<void> setMaxFps(float maxFps) override;
- Return<void> setTimeLapseConfig(
+ Return<Status> setSuspend(bool suspend, int64_t timeUs) override;
+ Return<Status> setRepeatPreviousFrameDelayUs(int64_t repeatAfterUs) override;
+ Return<Status> setMaxFps(float maxFps) override;
+ Return<Status> setTimeLapseConfig(
int64_t timePerFrameUs, int64_t timePerCaptureUs) override;
- Return<void> setStartTimeUs(int64_t startTimeUs) override;
- Return<void> setStopTimeUs(int64_t stopTimeUs) override;
- Return<void> setColorAspects(const ColorAspects& aspects) override;
- Return<void> setTimeOffsetUs(int64_t timeOffsetUs) override;
- Return<void> signalEndOfInputStream() override;
+ Return<Status> setStartTimeUs(int64_t startTimeUs) override;
+ Return<Status> setStopTimeUs(int64_t stopTimeUs) override;
+ Return<Status> setColorAspects(const ColorAspects& aspects) override;
+ Return<Status> setTimeOffsetUs(int64_t timeOffsetUs) override;
+ Return<Status> signalEndOfInputStream() override;
};
} // namespace implementation
+++ /dev/null
-/*
- * Copyright 2016, 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 "WOmx.h"
-#include "WOmxNode.h"
-#include "WOmxObserver.h"
-#include "WOmxBufferProducer.h"
-#include "WGraphicBufferSource.h"
-#include "Conversion.h"
-
-namespace android {
-namespace hardware {
-namespace media {
-namespace omx {
-namespace V1_0 {
-namespace implementation {
-
-// LWOmx
-LWOmx::LWOmx(sp<IOmx> const& base) : mBase(base) {
-}
-
-status_t LWOmx::listNodes(List<IOMX::ComponentInfo>* list) {
- status_t fnStatus;
- status_t transStatus = toStatusT(mBase->listNodes(
- [&fnStatus, list](
- Status status,
- hidl_vec<IOmx::ComponentInfo> const& nodeList) {
- fnStatus = toStatusT(status);
- list->clear();
- for (size_t i = 0; i < nodeList.size(); ++i) {
- auto newInfo = list->insert(
- list->end(), IOMX::ComponentInfo());
- convertTo(&*newInfo, nodeList[i]);
- }
- }));
- return transStatus == NO_ERROR ? fnStatus : transStatus;
-}
-
-status_t LWOmx::allocateNode(
- char const* name,
- sp<IOMXObserver> const& observer,
- sp<IOMXNode>* omxNode) {
- status_t fnStatus;
- status_t transStatus = toStatusT(mBase->allocateNode(
- name, new TWOmxObserver(observer),
- [&fnStatus, omxNode](Status status, sp<IOmxNode> const& node) {
- fnStatus = toStatusT(status);
- *omxNode = new LWOmxNode(node);
- }));
- return transStatus == NO_ERROR ? fnStatus : transStatus;
-}
-
-status_t LWOmx::createInputSurface(
- sp<::android::IGraphicBufferProducer>* bufferProducer,
- sp<::android::IGraphicBufferSource>* bufferSource) {
- status_t fnStatus;
- status_t transStatus = toStatusT(mBase->createInputSurface(
- [&fnStatus, bufferProducer, bufferSource] (
- Status status,
- sp<IOmxBufferProducer> const& tProducer,
- sp<IGraphicBufferSource> const& tSource) {
- fnStatus = toStatusT(status);
- *bufferProducer = new LWOmxBufferProducer(tProducer);
- *bufferSource = new LWGraphicBufferSource(tSource);
- }));
- return transStatus == NO_ERROR ? fnStatus : transStatus;
-}
-
-// TWOmx
-TWOmx::TWOmx(sp<IOMX> const& base) : mBase(base) {
-}
-
-Return<void> TWOmx::listNodes(listNodes_cb _hidl_cb) {
- List<IOMX::ComponentInfo> lList;
- Status status = toStatus(mBase->listNodes(&lList));
-
- hidl_vec<IOmx::ComponentInfo> tList;
- tList.resize(lList.size());
- size_t i = 0;
- for (auto const& lInfo : lList) {
- convertTo(&(tList[i++]), lInfo);
- }
- _hidl_cb(status, tList);
- return Void();
-}
-
-Return<void> TWOmx::allocateNode(
- const hidl_string& name,
- const sp<IOmxObserver>& observer,
- allocateNode_cb _hidl_cb) {
- sp<IOMXNode> omxNode;
- Status status = toStatus(mBase->allocateNode(
- name, new LWOmxObserver(observer), &omxNode));
- _hidl_cb(status, new TWOmxNode(omxNode));
- return Void();
-}
-
-Return<void> TWOmx::createInputSurface(createInputSurface_cb _hidl_cb) {
- sp<::android::IGraphicBufferProducer> lProducer;
- sp<::android::IGraphicBufferSource> lSource;
- status_t status = mBase->createInputSurface(&lProducer, &lSource);
- _hidl_cb(toStatus(status),
- new TWOmxBufferProducer(lProducer),
- new TWGraphicBufferSource(lSource));
- return Void();
-}
-
-} // namespace implementation
-} // namespace V1_0
-} // namespace omx
-} // namespace media
-} // namespace hardware
-} // namespace android
+++ /dev/null
-/*
- * Copyright 2016, 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.
- */
-
-#ifndef ANDROID_HARDWARE_MEDIA_OMX_V1_0_WOMX_H
-#define ANDROID_HARDWARE_MEDIA_OMX_V1_0_WOMX_H
-
-#include <hidl/MQDescriptor.h>
-#include <hidl/Status.h>
-
-#include "../../../../include/OMXNodeInstance.h"
-
-#include <android/hardware/media/omx/1.0/IOmx.h>
-
-namespace android {
-namespace hardware {
-namespace media {
-namespace omx {
-namespace V1_0 {
-namespace implementation {
-
-using ::android::hardware::media::omx::V1_0::IOmx;
-using ::android::hardware::media::omx::V1_0::IOmxNode;
-using ::android::hardware::media::omx::V1_0::IOmxObserver;
-using ::android::hardware::media::omx::V1_0::Status;
-using ::android::hidl::base::V1_0::IBase;
-using ::android::hardware::hidl_array;
-using ::android::hardware::hidl_memory;
-using ::android::hardware::hidl_string;
-using ::android::hardware::hidl_vec;
-using ::android::hardware::Return;
-using ::android::hardware::Void;
-using ::android::sp;
-
-using ::android::List;
-using ::android::IOMX;
-using ::android::BnOMX;
-
-/**
- * Wrapper classes for conversion
- * ==============================
- *
- * Naming convention:
- * - LW = Legacy Wrapper --- It wraps a Treble object inside a legacy object.
- * - TW = Treble Wrapper --- It wraps a legacy object inside a Treble object.
- */
-
-struct LWOmx : public BnOMX {
- sp<IOmx> mBase;
- LWOmx(sp<IOmx> const& base);
- status_t listNodes(List<IOMX::ComponentInfo>* list) override;
- status_t allocateNode(
- char const* name,
- sp<IOMXObserver> const& observer,
- sp<IOMXNode>* omxNode) override;
- status_t createInputSurface(
- sp<::android::IGraphicBufferProducer>* bufferProducer,
- sp<::android::IGraphicBufferSource>* bufferSource) override;
-};
-
-struct TWOmx : public IOmx {
- sp<IOMX> mBase;
- TWOmx(sp<IOMX> const& base);
- Return<void> listNodes(listNodes_cb _hidl_cb) override;
- Return<void> allocateNode(
- const hidl_string& name,
- const sp<IOmxObserver>& observer,
- allocateNode_cb _hidl_cb) override;
- Return<void> createInputSurface(createInputSurface_cb _hidl_cb) override;
-
-};
-
-} // namespace implementation
-} // namespace V1_0
-} // namespace omx
-} // namespace media
-} // namespace hardware
-} // namespace android
-
-#endif // ANDROID_HARDWARE_MEDIA_OMX_V1_0_WOMX_H
OSDN Git Service
