Merge "Moving libRS" (972ed580) · Commits · e / os / android_frameworks_base

CleanSpec.mk

+7 −0

Original line number	Diff line number	Diff line
		@@ -119,6 +119,13 @@ $(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/fonts/DroidSans*)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/media/audio/)
		$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/JAVA_LIBRARIES/framework_intermediates/src/core/java/android/content)
		$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/JAVA_LIBRARIES/android_stubs_current_intermediates/src/android/content)
		$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/APPS/*/src/renderscript)
		$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/JAVA_LIBRARIES/*/src/renderscript)
		$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/APPS/*/src/RenderScript.stamp)
		$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/JAVA_LIBRARIES/*/src/RenderScript.stamp)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/SHARED_LIBRARIES/libRS_intermediates)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/STATIC_LIBRARIES/libRSDriver_intermediates)
		$(call add-clean-step, rm -rf $(OUT_DIR)/host/$(HOST_PREBUILT_TAG)/obj/STATIC_LIBRARIES/libRS_intermediates)
		# ************************************************
		# NEWER CLEAN STEPS MUST BE AT THE END OF THE LIST
		# ************************************************

graphics/jni/Android.mk

+1 −1

Original line number	Diff line number	Diff line
		@@ -21,7 +21,7 @@ rs_generated_include_dir := $(call intermediates-dir-for,SHARED_LIBRARIES,libRS,

		LOCAL_C_INCLUDES += \
		$(JNI_H_INCLUDE) \
		$(LOCAL_PATH)/../../libs/rs \
		frameworks/rs \
		$(rs_generated_include_dir) \
		$(call include-path-for, corecg graphics)

libs/rs/Allocation.cpp

deleted100644 → 0

+0 −468

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2012 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_TAG "libRS_cpp"

		#include <utils/Log.h>
		#include <malloc.h>

		#include "RenderScript.h"
		#include "Element.h"
		#include "Type.h"
		#include "Allocation.h"


		void * Allocation::getIDSafe() const {
		//if (mAdaptedAllocation != NULL) {
		//return mAdaptedAllocation.getID();
		//}
		return getID();
		}

		void Allocation::updateCacheInfo(const Type *t) {
		mCurrentDimX = t->getX();
		mCurrentDimY = t->getY();
		mCurrentDimZ = t->getZ();
		mCurrentCount = mCurrentDimX;
		if (mCurrentDimY > 1) {
		mCurrentCount *= mCurrentDimY;
		}
		if (mCurrentDimZ > 1) {
		mCurrentCount *= mCurrentDimZ;
		}
		}

		Allocation::Allocation(void id, RenderScript rs, const Type *t, uint32_t usage) : BaseObj(id, rs) {
		if ((usage & ~(RS_ALLOCATION_USAGE_SCRIPT \|
		RS_ALLOCATION_USAGE_GRAPHICS_TEXTURE \|
		RS_ALLOCATION_USAGE_GRAPHICS_VERTEX \|
		RS_ALLOCATION_USAGE_GRAPHICS_CONSTANTS \|
		RS_ALLOCATION_USAGE_GRAPHICS_RENDER_TARGET \|
		RS_ALLOCATION_USAGE_IO_INPUT \|
		RS_ALLOCATION_USAGE_IO_OUTPUT)) != 0) {
		ALOGE("Unknown usage specified.");
		}

		if ((usage & RS_ALLOCATION_USAGE_IO_INPUT) != 0) {
		mWriteAllowed = false;
		if ((usage & ~(RS_ALLOCATION_USAGE_IO_INPUT \|
		RS_ALLOCATION_USAGE_GRAPHICS_TEXTURE \|
		RS_ALLOCATION_USAGE_SCRIPT)) != 0) {
		ALOGE("Invalid usage combination.");
		}
		}

		mType = t;
		mUsage = usage;

		if (t != NULL) {
		updateCacheInfo(t);
		}
		}

		void Allocation::validateIsInt32() {
		RsDataType dt = mType->getElement()->getDataType();
		if ((dt == RS_TYPE_SIGNED_32) \|\| (dt == RS_TYPE_UNSIGNED_32)) {
		return;
		}
		ALOGE("32 bit integer source does not match allocation type %i", dt);
		}

		void Allocation::validateIsInt16() {
		RsDataType dt = mType->getElement()->getDataType();
		if ((dt == RS_TYPE_SIGNED_16) \|\| (dt == RS_TYPE_UNSIGNED_16)) {
		return;
		}
		ALOGE("16 bit integer source does not match allocation type %i", dt);
		}

		void Allocation::validateIsInt8() {
		RsDataType dt = mType->getElement()->getDataType();
		if ((dt == RS_TYPE_SIGNED_8) \|\| (dt == RS_TYPE_UNSIGNED_8)) {
		return;
		}
		ALOGE("8 bit integer source does not match allocation type %i", dt);
		}

		void Allocation::validateIsFloat32() {
		RsDataType dt = mType->getElement()->getDataType();
		if (dt == RS_TYPE_FLOAT_32) {
		return;
		}
		ALOGE("32 bit float source does not match allocation type %i", dt);
		}

		void Allocation::validateIsObject() {
		RsDataType dt = mType->getElement()->getDataType();
		if ((dt == RS_TYPE_ELEMENT) \|\|
		(dt == RS_TYPE_TYPE) \|\|
		(dt == RS_TYPE_ALLOCATION) \|\|
		(dt == RS_TYPE_SAMPLER) \|\|
		(dt == RS_TYPE_SCRIPT) \|\|
		(dt == RS_TYPE_MESH) \|\|
		(dt == RS_TYPE_PROGRAM_FRAGMENT) \|\|
		(dt == RS_TYPE_PROGRAM_VERTEX) \|\|
		(dt == RS_TYPE_PROGRAM_RASTER) \|\|
		(dt == RS_TYPE_PROGRAM_STORE)) {
		return;
		}
		ALOGE("Object source does not match allocation type %i", dt);
		}

		void Allocation::updateFromNative() {
		BaseObj::updateFromNative();

		const void *typeID = rsaAllocationGetType(mRS->mContext, getID());
		if(typeID != NULL) {
		const Type *old = mType;
		Type t = new Type((void )typeID, mRS);
		t->updateFromNative();
		updateCacheInfo(t);
		mType = t;
		delete old;
		}
		}

		void Allocation::syncAll(RsAllocationUsageType srcLocation) {
		switch (srcLocation) {
		case RS_ALLOCATION_USAGE_SCRIPT:
		case RS_ALLOCATION_USAGE_GRAPHICS_CONSTANTS:
		case RS_ALLOCATION_USAGE_GRAPHICS_TEXTURE:
		case RS_ALLOCATION_USAGE_GRAPHICS_VERTEX:
		break;
		default:
		ALOGE("Source must be exactly one usage type.");
		}
		rsAllocationSyncAll(mRS->mContext, getIDSafe(), srcLocation);
		}

		void Allocation::ioSendOutput() {
		if ((mUsage & RS_ALLOCATION_USAGE_IO_OUTPUT) == 0) {
		ALOGE("Can only send buffer if IO_OUTPUT usage specified.");
		}
		rsAllocationIoSend(mRS->mContext, getID());
		}

		void Allocation::ioGetInput() {
		if ((mUsage & RS_ALLOCATION_USAGE_IO_INPUT) == 0) {
		ALOGE("Can only send buffer if IO_OUTPUT usage specified.");
		}
		rsAllocationIoReceive(mRS->mContext, getID());
		}

		/*
		void copyFrom(BaseObj[] d) {
		mRS.validate();
		validateIsObject();
		if (d.length != mCurrentCount) {
		ALOGE("Array size mismatch, allocation sizeX = " +
		mCurrentCount + ", array length = " + d.length);
		}
		int i[] = new int[d.length];
		for (int ct=0; ct < d.length; ct++) {
		i[ct] = d[ct].getID();
		}
		copy1DRangeFromUnchecked(0, mCurrentCount, i);
		}
		*/


		/*
		void Allocation::setFromFieldPacker(int xoff, FieldPacker fp) {
		mRS.validate();
		int eSize = mType.mElement.getSizeBytes();
		final byte[] data = fp.getData();

		int count = data.length / eSize;
		if ((eSize * count) != data.length) {
		ALOGE("Field packer length " + data.length +
		" not divisible by element size " + eSize + ".");
		}
		copy1DRangeFromUnchecked(xoff, count, data);
		}

		void setFromFieldPacker(int xoff, int component_number, FieldPacker fp) {
		mRS.validate();
		if (component_number >= mType.mElement.mElements.length) {
		ALOGE("Component_number " + component_number + " out of range.");
		}
		if(xoff < 0) {
		ALOGE("Offset must be >= 0.");
		}

		final byte[] data = fp.getData();
		int eSize = mType.mElement.mElements[component_number].getSizeBytes();
		eSize *= mType.mElement.mArraySizes[component_number];

		if (data.length != eSize) {
		ALOGE("Field packer sizelength " + data.length +
		" does not match component size " + eSize + ".");
		}

		mRS.nAllocationElementData1D(getIDSafe(), xoff, mSelectedLOD,
		component_number, data, data.length);
		}
		*/

		void Allocation::generateMipmaps() {
		rsAllocationGenerateMipmaps(mRS->mContext, getID());
		}

		void Allocation::copy1DRangeFromUnchecked(uint32_t off, size_t count, const void *data, size_t dataLen) {
		if(count < 1) {
		ALOGE("Count must be >= 1.");
		return;
		}
		if((off + count) > mCurrentCount) {
		ALOGE("Overflow, Available count %zu, got %zu at offset %zu.", mCurrentCount, count, off);
		return;
		}
		if((count * mType->getElement()->getSizeBytes()) > dataLen) {
		ALOGE("Array too small for allocation type.");
		return;
		}

		rsAllocation1DData(mRS->mContext, getIDSafe(), off, mSelectedLOD, count, data, dataLen);
		}

		void Allocation::copy1DRangeFrom(uint32_t off, size_t count, const int32_t *d, size_t dataLen) {
		validateIsInt32();
		copy1DRangeFromUnchecked(off, count, d, dataLen);
		}

		void Allocation::copy1DRangeFrom(uint32_t off, size_t count, const int16_t *d, size_t dataLen) {
		validateIsInt16();
		copy1DRangeFromUnchecked(off, count, d, dataLen);
		}

		void Allocation::copy1DRangeFrom(uint32_t off, size_t count, const int8_t *d, size_t dataLen) {
		validateIsInt8();
		copy1DRangeFromUnchecked(off, count, d, dataLen);
		}

		void Allocation::copy1DRangeFrom(uint32_t off, size_t count, const float *d, size_t dataLen) {
		validateIsFloat32();
		copy1DRangeFromUnchecked(off, count, d, dataLen);
		}

		void Allocation::copy1DRangeFrom(uint32_t off, size_t count, const Allocation *data, uint32_t dataOff) {
		rsAllocationCopy2DRange(mRS->mContext, getIDSafe(), off, 0,
		mSelectedLOD, mSelectedFace,
		count, 1, data->getIDSafe(), dataOff, 0,
		data->mSelectedLOD, data->mSelectedFace);
		}

		void Allocation::validate2DRange(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h) {
		if (mAdaptedAllocation != NULL) {

		} else {
		if (((xoff + w) > mCurrentDimX) \|\| ((yoff + h) > mCurrentDimY)) {
		ALOGE("Updated region larger than allocation.");
		}
		}
		}

		void Allocation::copy2DRangeFrom(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h,
		const int8_t *data, size_t dataLen) {
		validate2DRange(xoff, yoff, w, h);
		rsAllocation2DData(mRS->mContext, getIDSafe(), xoff, yoff, mSelectedLOD, mSelectedFace,
		w, h, data, dataLen);
		}

		void Allocation::copy2DRangeFrom(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h,
		const int16_t *data, size_t dataLen) {
		validate2DRange(xoff, yoff, w, h);
		rsAllocation2DData(mRS->mContext, getIDSafe(), xoff, yoff, mSelectedLOD, mSelectedFace,
		w, h, data, dataLen);
		}

		void Allocation::copy2DRangeFrom(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h,
		const int32_t *data, size_t dataLen) {
		validate2DRange(xoff, yoff, w, h);
		rsAllocation2DData(mRS->mContext, getIDSafe(), xoff, yoff, mSelectedLOD, mSelectedFace,
		w, h, data, dataLen);
		}

		void Allocation::copy2DRangeFrom(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h,
		const float *data, size_t dataLen) {
		validate2DRange(xoff, yoff, w, h);
		rsAllocation2DData(mRS->mContext, getIDSafe(), xoff, yoff, mSelectedLOD, mSelectedFace,
		w, h, data, dataLen);
		}

		void Allocation::copy2DRangeFrom(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h,
		const Allocation *data, size_t dataLen,
		uint32_t dataXoff, uint32_t dataYoff) {
		validate2DRange(xoff, yoff, w, h);
		rsAllocationCopy2DRange(mRS->mContext, getIDSafe(), xoff, yoff,
		mSelectedLOD, mSelectedFace,
		w, h, data->getIDSafe(), dataXoff, dataYoff,
		data->mSelectedLOD, data->mSelectedFace);
		}

		/*
		void copyTo(byte[] d) {
		validateIsInt8();
		mRS.validate();
		mRS.nAllocationRead(getID(), d);
		}

		void copyTo(short[] d) {
		validateIsInt16();
		mRS.validate();
		mRS.nAllocationRead(getID(), d);
		}

		void copyTo(int[] d) {
		validateIsInt32();
		mRS.validate();
		mRS.nAllocationRead(getID(), d);
		}

		void copyTo(float[] d) {
		validateIsFloat32();
		mRS.validate();
		mRS.nAllocationRead(getID(), d);
		}

		void resize(int dimX) {
		if ((mType.getY() > 0)\|\| (mType.getZ() > 0) \|\| mType.hasFaces() \|\| mType.hasMipmaps()) {
		throw new RSInvalidStateException("Resize only support for 1D allocations at this time.");
		}
		mRS.nAllocationResize1D(getID(), dimX);
		mRS.finish(); // Necessary because resize is fifoed and update is async.

		int typeID = mRS.nAllocationGetType(getID());
		mType = new Type(typeID, mRS);
		mType.updateFromNative();
		updateCacheInfo(mType);
		}

		void resize(int dimX, int dimY) {
		if ((mType.getZ() > 0) \|\| mType.hasFaces() \|\| mType.hasMipmaps()) {
		throw new RSInvalidStateException(
		"Resize only support for 2D allocations at this time.");
		}
		if (mType.getY() == 0) {
		throw new RSInvalidStateException(
		"Resize only support for 2D allocations at this time.");
		}
		mRS.nAllocationResize2D(getID(), dimX, dimY);
		mRS.finish(); // Necessary because resize is fifoed and update is async.

		int typeID = mRS.nAllocationGetType(getID());
		mType = new Type(typeID, mRS);
		mType.updateFromNative();
		updateCacheInfo(mType);
		}
		*/


		Allocation Allocation::createTyped(RenderScript rs, const Type *type,
		RsAllocationMipmapControl mips, uint32_t usage) {
		void *id = rsAllocationCreateTyped(rs->mContext, type->getID(), mips, usage, 0);
		if (id == 0) {
		ALOGE("Allocation creation failed.");
		return NULL;
		}
		return new Allocation(id, rs, type, usage);
		}

		Allocation Allocation::createTyped(RenderScript rs, const Type *type,
		RsAllocationMipmapControl mips, uint32_t usage, void *pointer) {
		void *id = rsAllocationCreateTyped(rs->mContext, type->getID(), mips, usage, (uint32_t)pointer);
		if (id == 0) {
		ALOGE("Allocation creation failed.");
		}
		return new Allocation(id, rs, type, usage);
		}

		Allocation Allocation::createTyped(RenderScript rs, const Type *type, uint32_t usage) {
		return createTyped(rs, type, RS_ALLOCATION_MIPMAP_NONE, usage);
		}

		Allocation Allocation::createSized(RenderScript rs, const Element *e, size_t count, uint32_t usage) {
		Type::Builder b(rs, e);
		b.setX(count);
		const Type *t = b.create();

		void *id = rsAllocationCreateTyped(rs->mContext, t->getID(), RS_ALLOCATION_MIPMAP_NONE, usage, 0);
		if (id == 0) {
		ALOGE("Allocation creation failed.");
		}
		return new Allocation(id, rs, t, usage);
		}


		/*
		SurfaceTexture getSurfaceTexture() {
		if ((mUsage & USAGE_GRAPHICS_SURFACE_TEXTURE_INPUT_OPAQUE) == 0) {
		throw new RSInvalidStateException("Allocation is not a surface texture.");
		}

		int id = mRS.nAllocationGetSurfaceTextureID(getID());
		return new SurfaceTexture(id);

		}

		void setSurfaceTexture(SurfaceTexture sur) {
		if ((mUsage & USAGE_IO_OUTPUT) == 0) {
		throw new RSInvalidStateException("Allocation is not USAGE_IO_OUTPUT.");
		}

		mRS.validate();
		mRS.nAllocationSetSurfaceTexture(getID(), sur);
		}


		static Allocation createFromBitmapResource(RenderScript rs,
		Resources res,
		int id,
		MipmapControl mips,
		int usage) {

		rs.validate();
		Bitmap b = BitmapFactory.decodeResource(res, id);
		Allocation alloc = createFromBitmap(rs, b, mips, usage);
		b.recycle();
		return alloc;
		}

		static Allocation createFromBitmapResource(RenderScript rs,
		Resources res,
		int id) {
		return createFromBitmapResource(rs, res, id,
		MipmapControl.MIPMAP_NONE,
		USAGE_GRAPHICS_TEXTURE);
		}

		static Allocation createFromString(RenderScript rs,
		String str,
		int usage) {
		rs.validate();
		byte[] allocArray = NULL;
		try {
		allocArray = str.getBytes("UTF-8");
		Allocation alloc = Allocation.createSized(rs, Element.U8(rs), allocArray.length, usage);
		alloc.copyFrom(allocArray);
		return alloc;
		}
		catch (Exception e) {
		throw new RSRuntimeException("Could not convert string to utf-8.");
		}
		}
		*/

libs/rs/Allocation.h

deleted100644 → 0

+0 −126

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2008-2012 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_ALLOCATION_H__
		#define __ANDROID_ALLOCATION_H__

		#include <pthread.h>
		#include <rs.h>

		#include "RenderScript.h"
		#include "Type.h"
		#include "Element.h"

		class Allocation : public BaseObj {
		protected:
		const Type *mType;
		uint32_t mUsage;
		Allocation *mAdaptedAllocation;

		bool mConstrainedLOD;
		bool mConstrainedFace;
		bool mConstrainedY;
		bool mConstrainedZ;
		bool mReadAllowed;
		bool mWriteAllowed;
		uint32_t mSelectedY;
		uint32_t mSelectedZ;
		uint32_t mSelectedLOD;
		RsAllocationCubemapFace mSelectedFace;

		uint32_t mCurrentDimX;
		uint32_t mCurrentDimY;
		uint32_t mCurrentDimZ;
		uint32_t mCurrentCount;


		void * getIDSafe() const;
		void updateCacheInfo(const Type *t);

		Allocation(void id, RenderScript rs, const Type *t, uint32_t usage);

		void validateIsInt32();
		void validateIsInt16();
		void validateIsInt8();
		void validateIsFloat32();
		void validateIsObject();

		virtual void updateFromNative();

		void validate2DRange(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h);

		public:
		const Type * getType() {
		return mType;
		}

		void syncAll(RsAllocationUsageType srcLocation);
		void ioSendOutput();
		void ioGetInput();

		//void copyFrom(BaseObj[] d);
		//void copyFromUnchecked(int[] d);
		//void copyFromUnchecked(short[] d);
		//void copyFromUnchecked(byte[] d);
		//void copyFromUnchecked(float[] d);
		//void copyFrom(int[] d);
		//void copyFrom(short[] d);
		//void copyFrom(byte[] d);
		//void copyFrom(float[] d);
		//void setFromFieldPacker(int xoff, FieldPacker fp);
		//void setFromFieldPacker(int xoff, int component_number, FieldPacker fp);
		void generateMipmaps();
		void copy1DRangeFromUnchecked(uint32_t off, size_t count, const void *data, size_t dataLen);
		void copy1DRangeFrom(uint32_t off, size_t count, const int32_t* d, size_t dataLen);
		void copy1DRangeFrom(uint32_t off, size_t count, const int16_t* d, size_t dataLen);
		void copy1DRangeFrom(uint32_t off, size_t count, const int8_t* d, size_t dataLen);
		void copy1DRangeFrom(uint32_t off, size_t count, const float* d, size_t dataLen);
		void copy1DRangeFrom(uint32_t off, size_t count, const Allocation *data, uint32_t dataOff);

		void copy2DRangeFrom(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h,
		const int32_t *data, size_t dataLen);
		void copy2DRangeFrom(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h,
		const int16_t *data, size_t dataLen);
		void copy2DRangeFrom(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h,
		const int8_t *data, size_t dataLen);
		void copy2DRangeFrom(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h,
		const float *data, size_t dataLen);
		void copy2DRangeFrom(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h,
		const Allocation *data, size_t dataLen,
		uint32_t dataXoff, uint32_t dataYoff);

		//void copyTo(byte[] d);
		//void copyTo(short[] d);
		//void copyTo(int[] d);
		//void copyTo(float[] d);
		void resize(int dimX);
		void resize(int dimX, int dimY);

		static Allocation createTyped(RenderScript rs, const Type *type,
		RsAllocationMipmapControl mips, uint32_t usage);
		static Allocation createTyped(RenderScript rs, const Type *type,
		RsAllocationMipmapControl mips, uint32_t usage, void * pointer);

		static Allocation createTyped(RenderScript rs, const Type *type,
		uint32_t usage = RS_ALLOCATION_USAGE_SCRIPT);
		static Allocation createSized(RenderScript rs, const Element *e, size_t count,
		uint32_t usage = RS_ALLOCATION_USAGE_SCRIPT);
		//SurfaceTexture *getSurfaceTexture();
		//void setSurfaceTexture(SurfaceTexture *sur);

		};

		#endif