Merge changes I7ea9f150,Idd98a522 (6c17751f) · Commits · e / os / android_frameworks_av

cmds/screenrecord/screenrecord.cpp

+16 −2

Original line number	Diff line number	Diff line
		@@ -50,6 +50,7 @@
		#include <media/stagefright/MediaCodec.h>
		#include <media/stagefright/MediaErrors.h>
		#include <media/stagefright/MediaMuxer.h>
		#include <media/stagefright/PersistentSurface.h>
		#include <media/ICrypto.h>
		#include <media/MediaCodecBuffer.h>

		@@ -70,6 +71,7 @@ static const char* kMimeTypeAvc = "video/avc";
		static bool gVerbose = false; // chatty on stdout
		static bool gRotate = false; // rotate 90 degrees
		static bool gMonotonicTime = false; // use system monotonic time for timestamps
		static bool gPersistentSurface = false; // use persistent surface
		static enum {
		FORMAT_MP4, FORMAT_H264, FORMAT_FRAMES, FORMAT_RAW_FRAMES
		} gOutputFormat = FORMAT_MP4; // data format for output
		@@ -199,10 +201,18 @@ static status_t prepareEncoder(float displayFps, sp<MediaCodec>* pCodec,

		ALOGV("Creating encoder input surface");
		sp<IGraphicBufferProducer> bufferProducer;
		if (gPersistentSurface) {
		sp<PersistentSurface> surface = MediaCodec::CreatePersistentInputSurface();
		bufferProducer = surface->getBufferProducer();
		err = codec->setInputSurface(surface);
		} else {
		err = codec->createInputSurface(&bufferProducer);
		}
		if (err != NO_ERROR) {
		fprintf(stderr,
		"ERROR: unable to create encoder input surface (err=%d)\n", err);
		"ERROR: unable to %s encoder input surface (err=%d)\n",
		gPersistentSurface ? "set" : "create",
		err);
		codec->release();
		return err;
		}
		@@ -920,6 +930,7 @@ int main(int argc, char* const argv[]) {
		{ "output-format", required_argument, NULL, 'o' },
		{ "codec-name", required_argument, NULL, 'N' },
		{ "monotonic-time", no_argument, NULL, 'm' },
		{ "persistent-surface", no_argument, NULL, 'p' },
		{ NULL, 0, NULL, 0 }
		};

		@@ -1005,6 +1016,9 @@ int main(int argc, char* const argv[]) {
		case 'm':
		gMonotonicTime = true;
		break;
		case 'p':
		gPersistentSurface = true;
		break;
		default:
		if (ic != '?') {
		fprintf(stderr, "getopt_long returned unexpected value 0x%x\n", ic);

media/libmedia/include/media/OMXBuffer.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -91,6 +91,7 @@ public:

		private:
		friend struct OMXNodeInstance;
		friend struct C2OMXNode;

		// This is needed temporarily for OMX HIDL transition.
		friend inline bool (::android::hardware::media::omx::V1_0::implementation::

media/libstagefright/Android.bp

+5 −1

Original line number	Diff line number	Diff line
		@@ -60,6 +60,7 @@ cc_library_shared {
		"AudioPresentationInfo.cpp",
		"AudioSource.cpp",
		"BufferImpl.cpp",
		"C2OMXNode.cpp",
		"CCodec.cpp",
		"CCodecBufferChannel.cpp",
		"CodecBase.cpp",
		@@ -130,7 +131,6 @@ cc_library_shared {
		"libui",
		"libutils",
		"libmedia_helper",
		"libstagefright_bufferqueue_helper",
		"libstagefright_codec2",
		"libstagefright_codec2_vndk",
		"libstagefright_foundation",
		@@ -149,6 +149,10 @@ cc_library_shared {
		"android.hardware.media.omx@1.0",
		"android.hardware.graphics.allocator@2.0",
		"android.hardware.graphics.mapper@2.0",

		// TODO: do not link directly with impl
		"android.hardware.media.c2@1.0-service-impl",
		"libstagefright_bufferqueue_helper",
		],

		static_libs: [

media/libstagefright/C2OMXNode.cpp

0 → 100644

+281 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2018, 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.
		*/

		#ifdef __LP64__
		#define OMX_ANDROID_COMPILE_AS_32BIT_ON_64BIT_PLATFORMS
		#endif

		//#define LOG_NDEBUG 0
		#define LOG_TAG "C2OMXNode"
		#include <log/log.h>

		#include <C2AllocatorGralloc.h>
		#include <C2BlockInternal.h>
		#include <C2Component.h>
		#include <C2PlatformSupport.h>

		#include <OMX_Component.h>
		#include <OMX_Index.h>
		#include <OMX_IndexExt.h>

		#include <media/stagefright/omx/OMXUtils.h>
		#include <media/stagefright/MediaErrors.h>
		#include <ui/Fence.h>
		#include <ui/GraphicBuffer.h>

		#include "include/C2OMXNode.h"

		namespace android {

		namespace {

		class Buffer2D : public C2Buffer {
		public:
		explicit Buffer2D(C2ConstGraphicBlock block) : C2Buffer({ block }) {}
		};

		} // namespace

		C2OMXNode::C2OMXNode(const std::shared_ptr<C2Component> &comp) : mComp(comp) {}

		status_t C2OMXNode::freeNode() {
		mComp.reset();
		return OK;
		}

		status_t C2OMXNode::sendCommand(OMX_COMMANDTYPE cmd, OMX_S32 param) {
		(void)cmd;
		(void)param;
		return ERROR_UNSUPPORTED;
		}

		status_t C2OMXNode::getParameter(OMX_INDEXTYPE index, void *params, size_t size) {
		status_t err = ERROR_UNSUPPORTED;
		switch ((uint32_t)index) {
		case OMX_IndexParamConsumerUsageBits: {
		// TODO: read from intf()
		OMX_U32 usage = (OMX_U32 )params;
		*usage = GRALLOC_USAGE_SW_READ_OFTEN;
		err = OK;
		break;
		}
		case OMX_IndexParamPortDefinition: {
		if (size < sizeof(OMX_PARAM_PORTDEFINITIONTYPE)) {
		return BAD_VALUE;
		}
		OMX_PARAM_PORTDEFINITIONTYPE pDef = (OMX_PARAM_PORTDEFINITIONTYPE )params;
		// TODO: read these from intf()
		pDef->nBufferCountActual = 16;
		pDef->eDomain = OMX_PortDomainVideo;
		pDef->format.video.nFrameWidth = 1080;
		pDef->format.video.nFrameHeight = 1920;
		err = OK;
		break;
		}
		default:
		break;
		}
		return err;
		}

		status_t C2OMXNode::setParameter(OMX_INDEXTYPE index, const void *params, size_t size) {
		(void)index;
		(void)params;
		(void)size;
		return ERROR_UNSUPPORTED;
		}

		status_t C2OMXNode::getConfig(OMX_INDEXTYPE index, void *config, size_t size) {
		(void)index;
		(void)config;
		(void)size;
		return ERROR_UNSUPPORTED;
		}

		status_t C2OMXNode::setConfig(OMX_INDEXTYPE index, const void *config, size_t size) {
		(void)index;
		(void)config;
		(void)size;
		return ERROR_UNSUPPORTED;
		}

		status_t C2OMXNode::setPortMode(OMX_U32 portIndex, IOMX::PortMode mode) {
		(void)portIndex;
		(void)mode;
		return ERROR_UNSUPPORTED;
		}

		status_t C2OMXNode::prepareForAdaptivePlayback(
		OMX_U32 portIndex, OMX_BOOL enable,
		OMX_U32 maxFrameWidth, OMX_U32 maxFrameHeight) {
		(void)portIndex;
		(void)enable;
		(void)maxFrameWidth;
		(void)maxFrameHeight;
		return ERROR_UNSUPPORTED;
		}

		status_t C2OMXNode::configureVideoTunnelMode(
		OMX_U32 portIndex, OMX_BOOL tunneled,
		OMX_U32 audioHwSync, native_handle_t **sidebandHandle) {
		(void)portIndex;
		(void)tunneled;
		(void)audioHwSync;
		*sidebandHandle = nullptr;
		return ERROR_UNSUPPORTED;
		}

		status_t C2OMXNode::getGraphicBufferUsage(OMX_U32 portIndex, OMX_U32* usage) {
		(void)portIndex;
		*usage = 0;
		return ERROR_UNSUPPORTED;
		}

		status_t C2OMXNode::setInputSurface(const sp<IOMXBufferSource> &bufferSource) {
		c2_status_t err = GetCodec2PlatformAllocatorStore()->fetchAllocator(
		C2PlatformAllocatorStore::GRALLOC,
		&mAllocator);
		if (err != OK) {
		return UNKNOWN_ERROR;
		}
		mBufferSource = bufferSource;
		return OK;
		}

		status_t C2OMXNode::allocateSecureBuffer(
		OMX_U32 portIndex, size_t size, buffer_id *buffer,
		void *bufferData, sp<NativeHandle> nativeHandle) {
		(void)portIndex;
		(void)size;
		(void)nativeHandle;
		*buffer = 0;
		*bufferData = nullptr;
		return ERROR_UNSUPPORTED;
		}

		status_t C2OMXNode::useBuffer(
		OMX_U32 portIndex, const OMXBuffer &omxBuf, buffer_id *buffer) {
		(void)portIndex;
		(void)omxBuf;
		*buffer = 0;
		return ERROR_UNSUPPORTED;
		}

		status_t C2OMXNode::freeBuffer(OMX_U32 portIndex, buffer_id buffer) {
		(void)portIndex;
		(void)buffer;
		return ERROR_UNSUPPORTED;
		}

		status_t C2OMXNode::fillBuffer(
		buffer_id buffer, const OMXBuffer &omxBuf, int fenceFd) {
		(void)buffer;
		(void)omxBuf;
		(void)fenceFd;
		return ERROR_UNSUPPORTED;
		}

		status_t C2OMXNode::emptyBuffer(
		buffer_id buffer, const OMXBuffer &omxBuf,
		OMX_U32 flags, OMX_TICKS timestamp, int fenceFd) {
		// TODO: better fence handling
		if (fenceFd >= 0) {
		sp<Fence> fence = new Fence(fenceFd);
		fence->waitForever(LOG_TAG);
		}
		std::shared_ptr<C2Component> comp = mComp.lock();
		if (!comp) {
		return NO_INIT;
		}

		uint32_t c2Flags = 0;
		std::shared_ptr<C2GraphicBlock> block;

		C2Handle *handle = nullptr;
		if (omxBuf.mBufferType == OMXBuffer::kBufferTypeANWBuffer) {
		std::shared_ptr<C2GraphicAllocation> alloc;
		handle = WrapNativeCodec2GrallocHandle(
		native_handle_clone(omxBuf.mGraphicBuffer->handle),
		omxBuf.mGraphicBuffer->width,
		omxBuf.mGraphicBuffer->height,
		omxBuf.mGraphicBuffer->format,
		omxBuf.mGraphicBuffer->usage,
		omxBuf.mGraphicBuffer->stride);
		c2_status_t err = mAllocator->priorGraphicAllocation(handle, &alloc);
		if (err != OK) {
		return UNKNOWN_ERROR;
		}
		block = _C2BlockFactory::CreateGraphicBlock(alloc);
		} else if (flags & OMX_BUFFERFLAG_EOS) {
		c2Flags = C2FrameData::FLAG_END_OF_STREAM;
		} else {
		return BAD_VALUE;
		}

		std::unique_ptr<C2Work> work(new C2Work);
		work->input.flags = (C2FrameData::flags_t)c2Flags;
		work->input.ordinal.timestamp = timestamp;
		work->input.ordinal.frameIndex = mFrameIndex++;
		work->input.buffers.clear();
		if (block) {
		std::shared_ptr<C2Buffer> c2Buffer(
		// TODO: fence
		new Buffer2D(block->share(
		C2Rect(block->width(), block->height()), ::android::C2Fence())),
		[handle, buffer, source = getSource()](C2Buffer *ptr) {
		delete ptr;
		native_handle_delete(handle);
		// TODO: fence
		(void)source->onInputBufferEmptied(buffer, -1);
		});
		work->input.buffers.push_back(c2Buffer);
		}
		work->worklets.clear();
		work->worklets.emplace_back(new C2Worklet);
		std::list<std::unique_ptr<C2Work>> items;
		items.push_back(std::move(work));

		c2_status_t err = comp->queue_nb(&items);
		if (err != C2_OK) {
		return UNKNOWN_ERROR;
		}

		return OK;
		}

		status_t C2OMXNode::getExtensionIndex(
		const char parameterName, OMX_INDEXTYPE index) {
		(void)parameterName;
		*index = OMX_IndexMax;
		return ERROR_UNSUPPORTED;
		}

		status_t C2OMXNode::dispatchMessage(const omx_message& msg) {
		if (msg.type != omx_message::EVENT) {
		return ERROR_UNSUPPORTED;
		}
		if (msg.u.event_data.event != OMX_EventDataSpaceChanged) {
		return ERROR_UNSUPPORTED;
		}
		// TODO: fill intf() with info inside \|msg\|.
		return OK;
		}

		sp<IOMXBufferSource> C2OMXNode::getSource() {
		return mBufferSource;
		}

		} // namespace android

media/libstagefright/CCodec.cpp

+103 −15

Original line number	Diff line number	Diff line
		@@ -24,17 +24,23 @@
		#include <C2PlatformSupport.h>
		#include <C2V4l2Support.h>

		#include <android/IOMXBufferSource.h>
		#include <gui/bufferqueue/1.0/H2BGraphicBufferProducer.h>
		#include <gui/Surface.h>
		#include <media/stagefright/codec2/1.0/InputSurface.h>
		#include <media/stagefright/BufferProducerWrapper.h>
		#include <media/stagefright/CCodec.h>
		#include <media/stagefright/PersistentSurface.h>

		#include "include/C2OMXNode.h"
		#include "include/CCodecBufferChannel.h"

		using namespace std::chrono_literals;
		#include "include/InputSurfaceWrapper.h"

		namespace android {

		using namespace std::chrono_literals;
		using ::android::hardware::graphics::bufferqueue::V1_0::utils::H2BGraphicBufferProducer;

		namespace {

		class CCodecWatchdog : public AHandler {
		@@ -146,6 +152,76 @@ private:
		wp<CCodec> mCodec;
		};

		class C2InputSurfaceWrapper : public InputSurfaceWrapper {
		public:
		explicit C2InputSurfaceWrapper(const sp<InputSurface> &surface) : mSurface(surface) {}
		~C2InputSurfaceWrapper() override = default;

		status_t connect(const std::shared_ptr<C2Component> &comp) override {
		if (mConnection != nullptr) {
		return ALREADY_EXISTS;
		}
		mConnection = mSurface->connectToComponent(comp);
		return OK;
		}

		void disconnect() override {
		if (mConnection != nullptr) {
		mConnection->disconnect();
		mConnection.clear();
		}
		}

		private:
		sp<InputSurface> mSurface;
		sp<InputSurfaceConnection> mConnection;
		};

		class GraphicBufferSourceWrapper : public InputSurfaceWrapper {
		public:
		explicit GraphicBufferSourceWrapper(const sp<IGraphicBufferSource> &source) : mSource(source) {}
		~GraphicBufferSourceWrapper() override = default;

		status_t connect(const std::shared_ptr<C2Component> &comp) override {
		// TODO: proper color aspect & dataspace
		android_dataspace dataSpace = HAL_DATASPACE_BT709;

		mNode = new C2OMXNode(comp);
		mSource->configure(mNode, dataSpace);

		// TODO: configure according to intf().

		sp<IOMXBufferSource> source = mNode->getSource();
		if (source == nullptr) {
		return NO_INIT;
		}
		constexpr size_t kNumSlots = 16;
		for (size_t i = 0; i < kNumSlots; ++i) {
		source->onInputBufferAdded(i);
		}
		source->onOmxExecuting();
		return OK;
		}

		void disconnect() override {
		if (mNode == nullptr) {
		return;
		}
		sp<IOMXBufferSource> source = mNode->getSource();
		if (source == nullptr) {
		ALOGD("GBSWrapper::disconnect: node is not configured with OMXBufferSource.");
		return;
		}
		source->onOmxIdle();
		source->onOmxLoaded();
		mNode.clear();
		}

		private:
		sp<IGraphicBufferSource> mSource;
		sp<C2OMXNode> mNode;
		};

		} // namespace

		CCodec::CCodec()
		@@ -300,18 +376,18 @@ void CCodec::initiateCreateInputSurface() {
		}

		void CCodec::createInputSurface() {
		sp<IGraphicBufferProducer> producer;
		sp<GraphicBufferSource> source(new GraphicBufferSource);
		// TODO: get this from codec process
		sp<InputSurface> surface(InputSurface::Create());

		status_t err = source->initCheck();
		// TODO: get proper error code.
		status_t err = (surface == nullptr) ? UNKNOWN_ERROR : OK;
		if (err != OK) {
		ALOGE("Failed to initialize graphic buffer source: %d", err);
		ALOGE("Failed to initialize input surface: %d", err);
		mCallback->onInputSurfaceCreationFailed(err);
		return;
		}
		producer = source->getIGraphicBufferProducer();

		err = setupInputSurface(source);
		err = setupInputSurface(std::make_shared<C2InputSurfaceWrapper>(surface));
		if (err != OK) {
		ALOGE("Failed to set up input surface: %d", err);
		mCallback->onInputSurfaceCreationFailed(err);
		@@ -328,16 +404,16 @@ void CCodec::createInputSurface() {
		mCallback->onInputSurfaceCreated(
		inputFormat,
		outputFormat,
		new BufferProducerWrapper(producer));
		new BufferProducerWrapper(new H2BGraphicBufferProducer(surface)));
		}

		status_t CCodec::setupInputSurface(const sp<GraphicBufferSource> &source) {
		status_t err = mChannel->setGraphicBufferSource(source);
		status_t CCodec::setupInputSurface(const std::shared_ptr<InputSurfaceWrapper> &surface) {
		status_t err = mChannel->setInputSurface(surface);
		if (err != OK) {
		return err;
		}

		// TODO: configure \|source\| with other settings.
		// TODO: configure \|surface\| with other settings.
		return OK;
		}

		@@ -348,10 +424,22 @@ void CCodec::initiateSetInputSurface(const sp<PersistentSurface> &surface) {
		}

		void CCodec::setInputSurface(const sp<PersistentSurface> &surface) {
		// TODO
		(void)surface;
		status_t err = setupInputSurface(std::make_shared<GraphicBufferSourceWrapper>(
		surface->getBufferSource()));
		if (err != OK) {
		ALOGE("Failed to set up input surface: %d", err);
		mCallback->onInputSurfaceDeclined(err);
		return;
		}

		mCallback->onInputSurfaceDeclined(ERROR_UNSUPPORTED);
		sp<AMessage> inputFormat;
		sp<AMessage> outputFormat;
		{
		Mutexed<Formats>::Locked formats(mFormats);
		inputFormat = formats->inputFormat;
		outputFormat = formats->outputFormat;
		}
		mCallback->onInputSurfaceAccepted(inputFormat, outputFormat);
		}

		void CCodec::initiateStart() {