diff options
Diffstat (limited to 'include')
50 files changed, 1530 insertions, 525 deletions
diff --git a/include/android/bitmap.h b/include/android/bitmap.h index 5078277..6e18763 100644 --- a/include/android/bitmap.h +++ b/include/android/bitmap.h @@ -24,11 +24,14 @@ extern "C" { #endif -#define ANDROID_BITMAP_RESUT_SUCCESS 0 +#define ANDROID_BITMAP_RESULT_SUCCESS 0 #define ANDROID_BITMAP_RESULT_BAD_PARAMETER -1 #define ANDROID_BITMAP_RESULT_JNI_EXCEPTION -2 #define ANDROID_BITMAP_RESULT_ALLOCATION_FAILED -3 +/* Backward compatibility: this macro used to be misspelled. */ +#define ANDROID_BITMAP_RESUT_SUCCESS ANDROID_BITMAP_RESULT_SUCCESS + enum AndroidBitmapFormat { ANDROID_BITMAP_FORMAT_NONE = 0, ANDROID_BITMAP_FORMAT_RGBA_8888 = 1, diff --git a/include/android/configuration.h b/include/android/configuration.h index 06cd3da..0f5c14a 100644 --- a/include/android/configuration.h +++ b/include/android/configuration.h @@ -93,6 +93,10 @@ enum { ACONFIGURATION_SMALLEST_SCREEN_WIDTH_DP_ANY = 0x0000, + ACONFIGURATION_LAYOUTDIR_ANY = 0x00, + ACONFIGURATION_LAYOUTDIR_LTR = 0x01, + ACONFIGURATION_LAYOUTDIR_RTL = 0x02, + ACONFIGURATION_MCC = 0x0001, ACONFIGURATION_MNC = 0x0002, ACONFIGURATION_LOCALE = 0x0004, @@ -107,6 +111,7 @@ enum { ACONFIGURATION_SCREEN_LAYOUT = 0x0800, ACONFIGURATION_UI_MODE = 0x1000, ACONFIGURATION_SMALLEST_SCREEN_SIZE = 0x2000, + ACONFIGURATION_LAYOUTDIR = 0x4000, }; /** @@ -331,6 +336,17 @@ int32_t AConfiguration_getSmallestScreenWidthDp(AConfiguration* config); void AConfiguration_setSmallestScreenWidthDp(AConfiguration* config, int32_t value); /** + * Return the configuration's layout direction, or + * ACONFIGURATION_LAYOUTDIR_ANY if not set. + */ +int32_t AConfiguration_getLayoutDirection(AConfiguration* config); + +/** + * Set the configuration's layout direction. + */ +void AConfiguration_setLayoutDirection(AConfiguration* config, int32_t value); + +/** * Perform a diff between two configurations. Returns a bit mask of * ACONFIGURATION_* constants, each bit set meaning that configuration element * is different between them. diff --git a/include/android/input.h b/include/android/input.h index f2befa9..26c4eb8 100644 --- a/include/android/input.h +++ b/include/android/input.h @@ -690,7 +690,7 @@ size_t AMotionEvent_getHistorySize(const AInputEvent* motion_event); /* Get the time that a historical movement occurred between this event and * the previous event, in the java.lang.System.nanoTime() time base. */ -int64_t AMotionEvent_getHistoricalEventTime(AInputEvent* motion_event, +int64_t AMotionEvent_getHistoricalEventTime(const AInputEvent* motion_event, size_t history_index); /* Get the historical raw X coordinate of this event for the given pointer index that @@ -717,14 +717,14 @@ float AMotionEvent_getHistoricalRawY(const AInputEvent* motion_event, size_t poi * occurred between this event and the previous motion event. * Whole numbers are pixels; the value may have a fraction for input devices * that are sub-pixel precise. */ -float AMotionEvent_getHistoricalX(AInputEvent* motion_event, size_t pointer_index, +float AMotionEvent_getHistoricalX(const AInputEvent* motion_event, size_t pointer_index, size_t history_index); /* Get the historical Y coordinate of this event for the given pointer index that * occurred between this event and the previous motion event. * Whole numbers are pixels; the value may have a fraction for input devices * that are sub-pixel precise. */ -float AMotionEvent_getHistoricalY(AInputEvent* motion_event, size_t pointer_index, +float AMotionEvent_getHistoricalY(const AInputEvent* motion_event, size_t pointer_index, size_t history_index); /* Get the historical pressure of this event for the given pointer index that @@ -732,7 +732,7 @@ float AMotionEvent_getHistoricalY(AInputEvent* motion_event, size_t pointer_inde * The pressure generally ranges from 0 (no pressure at all) to 1 (normal pressure), * although values higher than 1 may be generated depending on the calibration of * the input device. */ -float AMotionEvent_getHistoricalPressure(AInputEvent* motion_event, size_t pointer_index, +float AMotionEvent_getHistoricalPressure(const AInputEvent* motion_event, size_t pointer_index, size_t history_index); /* Get the current scaled value of the approximate size for the given pointer index that @@ -742,7 +742,7 @@ float AMotionEvent_getHistoricalPressure(AInputEvent* motion_event, size_t point * touch is normalized with the device specific range of values * and scaled to a value between 0 and 1. The value of size can be used to * determine fat touch events. */ -float AMotionEvent_getHistoricalSize(AInputEvent* motion_event, size_t pointer_index, +float AMotionEvent_getHistoricalSize(const AInputEvent* motion_event, size_t pointer_index, size_t history_index); /* Get the historical length of the major axis of an ellipse that describes the touch area diff --git a/include/binder/IPCThreadState.h b/include/binder/IPCThreadState.h index 691ba2f..3378d97 100644 --- a/include/binder/IPCThreadState.h +++ b/include/binder/IPCThreadState.h @@ -41,7 +41,6 @@ public: int getCallingPid(); int getCallingUid(); - int getOrigCallingUid(); void setStrictModePolicy(int32_t policy); int32_t getStrictModePolicy() const; @@ -117,7 +116,6 @@ private: status_t mLastError; pid_t mCallingPid; uid_t mCallingUid; - uid_t mOrigCallingUid; int32_t mStrictModePolicy; int32_t mLastTransactionBinderFlags; }; diff --git a/include/binder/MemoryHeapBase.h b/include/binder/MemoryHeapBase.h index bbbda9c..ea9b66c 100644 --- a/include/binder/MemoryHeapBase.h +++ b/include/binder/MemoryHeapBase.h @@ -58,10 +58,13 @@ public: /* implement IMemoryHeap interface */ virtual int getHeapID() const; + + /* virtual address of the heap. returns MAP_FAILED in case of error */ virtual void* getBase() const; + virtual size_t getSize() const; virtual uint32_t getFlags() const; - virtual uint32_t getOffset() const; + virtual uint32_t getOffset() const; const char* getDevice() const; diff --git a/include/binder/Parcel.h b/include/binder/Parcel.h index 33b2f00..3ff95d2 100644 --- a/include/binder/Parcel.h +++ b/include/binder/Parcel.h @@ -22,10 +22,12 @@ #include <utils/RefBase.h> #include <utils/String16.h> #include <utils/Vector.h> +#include <utils/Flattenable.h> // --------------------------------------------------------------------------- namespace android { +template <typename T> class LightFlattenable; class Flattenable; class IBinder; class IPCThreadState; @@ -102,6 +104,10 @@ public: status_t writeWeakBinder(const wp<IBinder>& val); status_t write(const Flattenable& val); + template<typename T> + status_t write(const LightFlattenable<T>& val); + + // Place a native_handle into the parcel (the native_handle's file- // descriptors are dup'ed, so it is safe to delete the native_handle // when this function returns). @@ -153,6 +159,9 @@ public: wp<IBinder> readWeakBinder() const; status_t read(Flattenable& val) const; + template<typename T> + status_t read(LightFlattenable<T>& val) const; + // Like Parcel.java's readExceptionCode(). Reads the first int32 // off of a Parcel's header, returning 0 or the negative error // code on exceptions, but also deals with skipping over rich @@ -267,6 +276,46 @@ public: // --------------------------------------------------------------------------- +template<typename T> +status_t Parcel::write(const LightFlattenable<T>& val) { + size_t size(val.getSize()); + if (!val.isFixedSize()) { + status_t err = writeInt32(size); + if (err != NO_ERROR) { + return err; + } + } + if (size) { + void* buffer = writeInplace(size); + return buffer == NULL ? NO_MEMORY : + val.flatten(buffer); + } + return NO_ERROR; +} + +template<typename T> +status_t Parcel::read(LightFlattenable<T>& val) const { + size_t size; + if (val.isFixedSize()) { + size = val.getSize(); + } else { + int32_t s; + status_t err = readInt32(&s); + if (err != NO_ERROR) { + return err; + } + size = s; + } + if (size) { + void const* buffer = readInplace(size); + return buffer == NULL ? NO_MEMORY : + val.unflatten(buffer, size); + } + return NO_ERROR; +} + +// --------------------------------------------------------------------------- + inline TextOutput& operator<<(TextOutput& to, const Parcel& parcel) { parcel.print(to); diff --git a/include/binder/PermissionCache.h b/include/binder/PermissionCache.h index 1171d48..bcdf0c2 100644 --- a/include/binder/PermissionCache.h +++ b/include/binder/PermissionCache.h @@ -22,6 +22,7 @@ #include <utils/String16.h> #include <utils/Singleton.h> +#include <utils/SortedVector.h> namespace android { // --------------------------------------------------------------------------- diff --git a/include/gui/BufferItemConsumer.h b/include/gui/BufferItemConsumer.h new file mode 100644 index 0000000..cd4df25 --- /dev/null +++ b/include/gui/BufferItemConsumer.h @@ -0,0 +1,91 @@ +/* + * 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. + */ + +#ifndef ANDROID_GUI_BUFFERITEMCONSUMER_H +#define ANDROID_GUI_BUFFERITEMCONSUMER_H + +#include <gui/ConsumerBase.h> + +#include <ui/GraphicBuffer.h> + +#include <utils/String8.h> +#include <utils/Vector.h> +#include <utils/threads.h> + +#define ANDROID_GRAPHICS_BUFFERITEMCONSUMER_JNI_ID "mBufferItemConsumer" + +namespace android { + +/** + * BufferItemConsumer is a BufferQueue consumer endpoint that allows clients + * access to the whole BufferItem entry from BufferQueue. Multiple buffers may + * be acquired at once, to be used concurrently by the client. This consumer can + * operate either in synchronous or asynchronous mode. + */ +class BufferItemConsumer: public ConsumerBase +{ + public: + typedef ConsumerBase::FrameAvailableListener FrameAvailableListener; + + typedef BufferQueue::BufferItem BufferItem; + + enum { INVALID_BUFFER_SLOT = BufferQueue::INVALID_BUFFER_SLOT }; + enum { NO_BUFFER_AVAILABLE = BufferQueue::NO_BUFFER_AVAILABLE }; + + // Create a new buffer item consumer. The consumerUsage parameter determines + // the consumer usage flags passed to the graphics allocator. The + // bufferCount parameter specifies how many buffers can be locked for user + // access at the same time. + BufferItemConsumer(uint32_t consumerUsage, + int bufferCount = BufferQueue::MIN_UNDEQUEUED_BUFFERS, + bool synchronousMode = false); + + virtual ~BufferItemConsumer(); + + // set the name of the BufferItemConsumer that will be used to identify it in + // log messages. + void setName(const String8& name); + + // Gets the next graphics buffer from the producer, filling out the + // passed-in BufferItem structure. Returns NO_BUFFER_AVAILABLE if the queue + // of buffers is empty, and INVALID_OPERATION if the maximum number of + // buffers is already acquired. + // + // Only a fixed number of buffers can be acquired at a time, determined by + // the construction-time bufferCount parameter. If INVALID_OPERATION is + // returned by acquireBuffer, then old buffers must be returned to the + // queue by calling releaseBuffer before more buffers can be acquired. + // + // If waitForFence is true, and the acquired BufferItem has a valid fence object, + // acquireBuffer will wait on the fence with no timeout before returning. + status_t acquireBuffer(BufferItem *item, bool waitForFence = true); + + // Returns an acquired buffer to the queue, allowing it to be reused. Since + // only a fixed number of buffers may be acquired at a time, old buffers + // must be released by calling releaseBuffer to ensure new buffers can be + // acquired by acquireBuffer. Once a BufferItem is released, the caller must + // not access any members of the BufferItem, and should immediately remove + // all of its references to the BufferItem itself. + status_t releaseBuffer(const BufferItem &item, + const sp<Fence>& releaseFence = Fence::NO_FENCE); + + sp<ISurfaceTexture> getProducerInterface() const { return getBufferQueue(); } + +}; + +} // namespace android + +#endif // ANDROID_GUI_CPUCONSUMER_H diff --git a/include/gui/BufferQueue.h b/include/gui/BufferQueue.h index 1c80d0c..9e265ba 100644 --- a/include/gui/BufferQueue.h +++ b/include/gui/BufferQueue.h @@ -23,6 +23,7 @@ #include <gui/IGraphicBufferAlloc.h> #include <gui/ISurfaceTexture.h> +#include <ui/Fence.h> #include <ui/GraphicBuffer.h> #include <utils/String8.h> @@ -40,6 +41,10 @@ public: enum { INVALID_BUFFER_SLOT = -1 }; enum { STALE_BUFFER_SLOT = 1, NO_BUFFER_AVAILABLE }; + // When in async mode we reserve two slots in order to guarantee that the + // producer and consumer can run asynchronously. + enum { MAX_MAX_ACQUIRED_BUFFERS = NUM_BUFFER_SLOTS - 2 }; + // ConsumerListener is the interface through which the BufferQueue notifies // the consumer of events that the consumer may wish to react to. Because // the consumer will generally have a mutex that is locked during calls from @@ -91,12 +96,12 @@ public: }; - // BufferQueue manages a pool of gralloc memory slots to be used - // by producers and consumers. - // allowSynchronousMode specifies whether or not synchronous mode can be - // enabled. - // bufferCount sets the minimum number of undequeued buffers for this queue - BufferQueue( bool allowSynchronousMode = true, int bufferCount = MIN_UNDEQUEUED_BUFFERS); + // BufferQueue manages a pool of gralloc memory slots to be used by + // producers and consumers. allowSynchronousMode specifies whether or not + // synchronous mode can be enabled by the producer. allocator is used to + // allocate all the needed gralloc buffers. + BufferQueue(bool allowSynchronousMode = true, + const sp<IGraphicBufferAlloc>& allocator = NULL); virtual ~BufferQueue(); virtual int query(int what, int* value); @@ -113,12 +118,18 @@ public: // pointed to by the buf argument and a status of OK is returned. If no // slot is available then a status of -EBUSY is returned and buf is // unmodified. + // + // The fence parameter will be updated to hold the fence associated with + // the buffer. The contents of the buffer must not be overwritten until the + // fence signals. If the fence is NULL, the buffer may be written + // immediately. + // // The width and height parameters must be no greater than the minimum of // GL_MAX_VIEWPORT_DIMS and GL_MAX_TEXTURE_SIZE (see: glGetIntegerv). // An error due to invalid dimensions might not be reported until // updateTexImage() is called. - virtual status_t dequeueBuffer(int *buf, uint32_t width, uint32_t height, - uint32_t format, uint32_t usage); + virtual status_t dequeueBuffer(int *buf, sp<Fence>& fence, + uint32_t width, uint32_t height, uint32_t format, uint32_t usage); // queueBuffer returns a filled buffer to the BufferQueue. In addition, a // timestamp must be provided for the buffer. The timestamp is in @@ -128,7 +139,7 @@ public: virtual status_t queueBuffer(int buf, const QueueBufferInput& input, QueueBufferOutput* output); - virtual void cancelBuffer(int buf); + virtual void cancelBuffer(int buf, sp<Fence> fence); // setSynchronousMode set whether dequeueBuffer is synchronous or // asynchronous. In synchronous mode, dequeueBuffer blocks until @@ -193,6 +204,9 @@ public: // mBuf is the slot index of this buffer int mBuf; + + // mFence is a fence that will signal when the buffer is idle. + sp<Fence> mFence; }; // The following public functions is the consumer facing interface @@ -209,9 +223,15 @@ public: // releaseBuffer releases a buffer slot from the consumer back to the // BufferQueue pending a fence sync. // + // If releaseBuffer returns STALE_BUFFER_SLOT, then the consumer must free + // any references to the just-released buffer that it might have, as if it + // had received a onBuffersReleased() call with a mask set for the released + // buffer. + // // Note that the dependencies on EGL will be removed once we switch to using // the Android HW Sync HAL. - status_t releaseBuffer(int buf, EGLDisplay display, EGLSyncKHR fence); + status_t releaseBuffer(int buf, EGLDisplay display, EGLSyncKHR fence, + const sp<Fence>& releaseFence); // consumerConnect connects a consumer to the BufferQueue. Only one // consumer may be connected, and when that consumer disconnects the @@ -234,10 +254,15 @@ public: // requestBuffers when a with and height of zero is requested. status_t setDefaultBufferSize(uint32_t w, uint32_t h); - // setBufferCountServer set the buffer count. If the client has requested + // setDefaultBufferCount set the buffer count. If the client has requested // a buffer count using setBufferCount, the server-buffer count will // take effect once the client sets the count back to zero. - status_t setBufferCountServer(int bufferCount); + status_t setDefaultMaxBufferCount(int bufferCount); + + // setMaxAcquiredBufferCount sets the maximum number of buffers that can + // be acquired by the consumer at one time. This call will fail if a + // producer is connected to the BufferQueue. + status_t setMaxAcquiredBufferCount(int maxAcquiredBuffers); // isSynchronousMode returns whether the SurfaceTexture is currently in // synchronous mode. @@ -280,7 +305,31 @@ private: // are freed except the current buffer. status_t drainQueueAndFreeBuffersLocked(); - status_t setBufferCountServerLocked(int bufferCount); + // setDefaultMaxBufferCountLocked sets the maximum number of buffer slots + // that will be used if the producer does not override the buffer slot + // count. + status_t setDefaultMaxBufferCountLocked(int count); + + // getMinBufferCountLocked returns the minimum number of buffers allowed + // given the current BufferQueue state. + int getMinMaxBufferCountLocked() const; + + // getMinUndequeuedBufferCountLocked returns the minimum number of buffers + // that must remain in a state other than DEQUEUED. + int getMinUndequeuedBufferCountLocked() const; + + // getMaxBufferCountLocked returns the maximum number of buffers that can + // be allocated at once. This value depends upon the following member + // variables: + // + // mSynchronousMode + // mMaxAcquiredBufferCount + // mDefaultMaxBufferCount + // mOverrideMaxBufferCount + // + // Any time one of these member variables is changed while a producer is + // connected, mDequeueCondition must be broadcast. + int getMaxBufferCountLocked() const; struct BufferSlot { @@ -292,7 +341,7 @@ private: mScalingMode(NATIVE_WINDOW_SCALING_MODE_FREEZE), mTimestamp(0), mFrameNumber(0), - mFence(EGL_NO_SYNC_KHR), + mEglFence(EGL_NO_SYNC_KHR), mAcquireCalled(false), mNeedsCleanupOnRelease(false) { mCrop.makeInvalid(); @@ -353,9 +402,11 @@ private: Rect mCrop; // mTransform is the current transform flags for this buffer slot. + // (example: NATIVE_WINDOW_TRANSFORM_ROT_90) uint32_t mTransform; // mScalingMode is the current scaling mode for this buffer slot. + // (example: NATIVE_WINDOW_SCALING_MODE_FREEZE) uint32_t mScalingMode; // mTimestamp is the current timestamp for this buffer slot. This gets @@ -365,11 +416,22 @@ private: // mFrameNumber is the number of the queued frame for this slot. uint64_t mFrameNumber; - // mFence is the EGL sync object that must signal before the buffer + // mEglFence is the EGL sync object that must signal before the buffer // associated with this buffer slot may be dequeued. It is initialized // to EGL_NO_SYNC_KHR when the buffer is created and (optionally, based // on a compile-time option) set to a new sync object in updateTexImage. - EGLSyncKHR mFence; + EGLSyncKHR mEglFence; + + // mFence is a fence which will signal when work initiated by the + // previous owner of the buffer is finished. When the buffer is FREE, + // the fence indicates when the consumer has finished reading + // from the buffer, or when the producer has finished writing if it + // called cancelBuffer after queueing some writes. When the buffer is + // QUEUED, it indicates when the producer has finished filling the + // buffer. When the buffer is DEQUEUED or ACQUIRED, the fence has been + // passed to the consumer or producer along with ownership of the + // buffer, and mFence is empty. + sp<Fence> mFence; // Indicates whether this buffer has been seen by a consumer yet bool mAcquireCalled; @@ -393,34 +455,27 @@ private: // in requestBuffers() if a width and height of zero is specified. uint32_t mDefaultHeight; - // mPixelFormat holds the pixel format of allocated buffers. It is used - // in requestBuffers() if a format of zero is specified. - uint32_t mPixelFormat; - - // mMinUndequeuedBuffers is a constraint on the number of buffers - // not dequeued at any time - int mMinUndequeuedBuffers; - - // mMinAsyncBufferSlots is a constraint on the minimum mBufferCount - // when this BufferQueue is in asynchronous mode - int mMinAsyncBufferSlots; - - // mMinSyncBufferSlots is a constraint on the minimum mBufferCount - // when this BufferQueue is in synchronous mode - int mMinSyncBufferSlots; - - // mBufferCount is the number of buffer slots that the client and server - // must maintain. It defaults to MIN_ASYNC_BUFFER_SLOTS and can be changed - // by calling setBufferCount or setBufferCountServer - int mBufferCount; - - // mClientBufferCount is the number of buffer slots requested by the client. - // The default is zero, which means the client doesn't care how many buffers - // there is. - int mClientBufferCount; - - // mServerBufferCount buffer count requested by the server-side - int mServerBufferCount; + // mMaxAcquiredBufferCount is the number of buffers that the consumer may + // acquire at one time. It defaults to 1 and can be changed by the + // consumer via the setMaxAcquiredBufferCount method, but this may only be + // done when no producer is connected to the BufferQueue. + // + // This value is used to derive the value returned for the + // MIN_UNDEQUEUED_BUFFERS query by the producer. + int mMaxAcquiredBufferCount; + + // mDefaultMaxBufferCount is the default limit on the number of buffers + // that will be allocated at one time. This default limit is set by the + // consumer. The limit (as opposed to the default limit) may be + // overridden by the producer. + int mDefaultMaxBufferCount; + + // mOverrideMaxBufferCount is the limit on the number of buffers that will + // be allocated at one time. This value is set by the image producer by + // calling setBufferCount. The default is zero, which means the producer + // doesn't care about the number of buffers in the pool. In that case + // mDefaultMaxBufferCount is used as the limit. + int mOverrideMaxBufferCount; // mGraphicBufferAlloc is the connection to SurfaceFlinger that is used to // allocate new GraphicBuffer objects. diff --git a/include/gui/ConsumerBase.h b/include/gui/ConsumerBase.h new file mode 100644 index 0000000..ee5cb29 --- /dev/null +++ b/include/gui/ConsumerBase.h @@ -0,0 +1,220 @@ +/* + * Copyright (C) 2010 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_GUI_CONSUMERBASE_H +#define ANDROID_GUI_CONSUMERBASE_H + +#include <gui/BufferQueue.h> + +#include <ui/GraphicBuffer.h> + +#include <utils/String8.h> +#include <utils/Vector.h> +#include <utils/threads.h> + +namespace android { +// ---------------------------------------------------------------------------- + +class String8; + +// ConsumerBase is a base class for BufferQueue consumer end-points. It +// handles common tasks like management of the connection to the BufferQueue +// and the buffer pool. +class ConsumerBase : public virtual RefBase, + protected BufferQueue::ConsumerListener { +public: + struct FrameAvailableListener : public virtual RefBase { + // onFrameAvailable() is called each time an additional frame becomes + // available for consumption. This means that frames that are queued + // while in asynchronous mode only trigger the callback if no previous + // frames are pending. Frames queued while in synchronous mode always + // trigger the callback. + // + // This is called without any lock held and can be called concurrently + // by multiple threads. + virtual void onFrameAvailable() = 0; + }; + + virtual ~ConsumerBase(); + + // abandon frees all the buffers and puts the ConsumerBase into the + // 'abandoned' state. Once put in this state the ConsumerBase can never + // leave it. When in the 'abandoned' state, all methods of the + // ISurfaceTexture interface will fail with the NO_INIT error. + // + // Note that while calling this method causes all the buffers to be freed + // from the perspective of the the ConsumerBase, if there are additional + // references on the buffers (e.g. if a buffer is referenced by a client + // or by OpenGL ES as a texture) then those buffer will remain allocated. + void abandon(); + + // set the name of the ConsumerBase that will be used to identify it in + // log messages. + void setName(const String8& name); + + // getBufferQueue returns the BufferQueue object to which this + // ConsumerBase is connected. + sp<BufferQueue> getBufferQueue() const; + + // dump writes the current state to a string. These methods should NOT be + // overridden by child classes. Instead they should override the + // dumpLocked method, which is called by these methods after locking the + // mutex. + void dump(String8& result) const; + void dump(String8& result, const char* prefix, char* buffer, size_t SIZE) const; + + // setFrameAvailableListener sets the listener object that will be notified + // when a new frame becomes available. + void setFrameAvailableListener(const sp<FrameAvailableListener>& listener); + +private: + ConsumerBase(const ConsumerBase&); + void operator=(const ConsumerBase&); + +protected: + + // ConsumerBase constructs a new ConsumerBase object to consume image + // buffers from the given BufferQueue. + ConsumerBase(const sp<BufferQueue> &bufferQueue); + + // Implementation of the BufferQueue::ConsumerListener interface. These + // calls are used to notify the ConsumerBase of asynchronous events in the + // BufferQueue. These methods should not need to be overridden by derived + // classes, but if they are overridden the ConsumerBase implementation + // must be called from the derived class. + virtual void onFrameAvailable(); + virtual void onBuffersReleased(); + + // freeBufferLocked frees up the given buffer slot. If the slot has been + // initialized this will release the reference to the GraphicBuffer in that + // slot. Otherwise it has no effect. + // + // Derived classes should override this method to clean up any state they + // keep per slot. If it is overridden, the derived class's implementation + // must call ConsumerBase::freeBufferLocked. + // + // This method must be called with mMutex locked. + virtual void freeBufferLocked(int slotIndex); + + // abandonLocked puts the BufferQueue into the abandoned state, causing + // all future operations on it to fail. This method rather than the public + // abandon method should be overridden by child classes to add abandon- + // time behavior. + // + // Derived classes should override this method to clean up any object + // state they keep (as opposed to per-slot state). If it is overridden, + // the derived class's implementation must call ConsumerBase::abandonLocked. + // + // This method must be called with mMutex locked. + virtual void abandonLocked(); + + // dumpLocked dumps the current state of the ConsumerBase object to the + // result string. Each line is prefixed with the string pointed to by the + // prefix argument. The buffer argument points to a buffer that may be + // used for intermediate formatting data, and the size of that buffer is + // indicated by the size argument. + // + // Derived classes should override this method to dump their internal + // state. If this method is overridden the derived class's implementation + // should call ConsumerBase::dumpLocked. + // + // This method must be called with mMutex locked. + virtual void dumpLocked(String8& result, const char* prefix, char* buffer, + size_t size) const; + + // acquireBufferLocked fetches the next buffer from the BufferQueue and + // updates the buffer slot for the buffer returned. + // + // Derived classes should override this method to perform any + // initialization that must take place the first time a buffer is assigned + // to a slot. If it is overridden the derived class's implementation must + // call ConsumerBase::acquireBufferLocked. + virtual status_t acquireBufferLocked(BufferQueue::BufferItem *item); + + // releaseBufferLocked relinquishes control over a buffer, returning that + // control to the BufferQueue. + // + // Derived classes should override this method to perform any cleanup that + // must take place when a buffer is released back to the BufferQueue. If + // it is overridden the derived class's implementation must call + // ConsumerBase::releaseBufferLocked. + virtual status_t releaseBufferLocked(int buf, EGLDisplay display, + EGLSyncKHR eglFence); + + // addReleaseFence* adds the sync points associated with a fence to the set + // of sync points that must be reached before the buffer in the given slot + // may be used after the slot has been released. This should be called by + // derived classes each time some asynchronous work is kicked off that + // references the buffer. + status_t addReleaseFence(int slot, const sp<Fence>& fence); + status_t addReleaseFenceLocked(int slot, const sp<Fence>& fence); + + // Slot contains the information and object references that + // ConsumerBase maintains about a BufferQueue buffer slot. + struct Slot { + // mGraphicBuffer is the Gralloc buffer store in the slot or NULL if + // no Gralloc buffer is in the slot. + sp<GraphicBuffer> mGraphicBuffer; + + // mFence is a fence which will signal when the buffer associated with + // this buffer slot is no longer being used by the consumer and can be + // overwritten. The buffer can be dequeued before the fence signals; + // the producer is responsible for delaying writes until it signals. + sp<Fence> mFence; + }; + + // mSlots stores the buffers that have been allocated by the BufferQueue + // for each buffer slot. It is initialized to null pointers, and gets + // filled in with the result of BufferQueue::acquire when the + // client dequeues a buffer from a + // slot that has not yet been used. The buffer allocated to a slot will also + // be replaced if the requested buffer usage or geometry differs from that + // of the buffer allocated to a slot. + Slot mSlots[BufferQueue::NUM_BUFFER_SLOTS]; + + // mAbandoned indicates that the BufferQueue will no longer be used to + // consume images buffers pushed to it using the ISurfaceTexture + // interface. It is initialized to false, and set to true in the abandon + // method. A BufferQueue that has been abandoned will return the NO_INIT + // error from all IConsumerBase methods capable of returning an error. + bool mAbandoned; + + // mName is a string used to identify the ConsumerBase in log messages. + // It can be set by the setName method. + String8 mName; + + // mFrameAvailableListener is the listener object that will be called when a + // new frame becomes available. If it is not NULL it will be called from + // queueBuffer. + sp<FrameAvailableListener> mFrameAvailableListener; + + // The ConsumerBase has-a BufferQueue and is responsible for creating this object + // if none is supplied + sp<BufferQueue> mBufferQueue; + + // mMutex is the mutex used to prevent concurrent access to the member + // variables of ConsumerBase objects. It must be locked whenever the + // member variables are accessed or when any of the *Locked methods are + // called. + // + // This mutex is intended to be locked by derived classes. + mutable Mutex mMutex; +}; + +// ---------------------------------------------------------------------------- +}; // namespace android + +#endif // ANDROID_GUI_CONSUMERBASE_H diff --git a/include/gui/CpuConsumer.h b/include/gui/CpuConsumer.h new file mode 100644 index 0000000..807a4b5 --- /dev/null +++ b/include/gui/CpuConsumer.h @@ -0,0 +1,103 @@ +/* + * 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. + */ + +#ifndef ANDROID_GUI_CPUCONSUMER_H +#define ANDROID_GUI_CPUCONSUMER_H + +#include <gui/ConsumerBase.h> + +#include <ui/GraphicBuffer.h> + +#include <utils/String8.h> +#include <utils/Vector.h> +#include <utils/threads.h> + +#define ANDROID_GRAPHICS_CPUCONSUMER_JNI_ID "mCpuConsumer" + +namespace android { + +/** + * CpuConsumer is a BufferQueue consumer endpoint that allows direct CPU + * access to the underlying gralloc buffers provided by BufferQueue. Multiple + * buffers may be acquired by it at once, to be used concurrently by the + * CpuConsumer owner. Sets gralloc usage flags to be software-read-only. + * This queue is synchronous by default. + */ + +class CpuConsumer: public ConsumerBase +{ + public: + typedef ConsumerBase::FrameAvailableListener FrameAvailableListener; + + struct LockedBuffer { + uint8_t *data; + uint32_t width; + uint32_t height; + PixelFormat format; + uint32_t stride; + Rect crop; + uint32_t transform; + uint32_t scalingMode; + int64_t timestamp; + uint64_t frameNumber; + }; + + // Create a new CPU consumer. The maxLockedBuffers parameter specifies + // how many buffers can be locked for user access at the same time. + CpuConsumer(uint32_t maxLockedBuffers); + + virtual ~CpuConsumer(); + + // set the name of the CpuConsumer that will be used to identify it in + // log messages. + void setName(const String8& name); + + // Gets the next graphics buffer from the producer and locks it for CPU use, + // filling out the passed-in locked buffer structure with the native pointer + // and metadata. Returns BAD_VALUE if no new buffer is available, and + // INVALID_OPERATION if the maximum number of buffers is already locked. + // + // Only a fixed number of buffers can be locked at a time, determined by the + // construction-time maxLockedBuffers parameter. If INVALID_OPERATION is + // returned by lockNextBuffer, then old buffers must be returned to the queue + // by calling unlockBuffer before more buffers can be acquired. + status_t lockNextBuffer(LockedBuffer *nativeBuffer); + + // Returns a locked buffer to the queue, allowing it to be reused. Since + // only a fixed number of buffers may be locked at a time, old buffers must + // be released by calling unlockBuffer to ensure new buffers can be acquired by + // lockNextBuffer. + status_t unlockBuffer(const LockedBuffer &nativeBuffer); + + sp<ISurfaceTexture> getProducerInterface() const { return getBufferQueue(); } + + private: + // Maximum number of buffers that can be locked at a time + uint32_t mMaxLockedBuffers; + + virtual void freeBufferLocked(int slotIndex); + + // Array for tracking pointers passed to the consumer, matching the + // mSlots indexing + void *mBufferPointers[BufferQueue::NUM_BUFFER_SLOTS]; + // Count of currently locked buffers + uint32_t mCurrentLockedBuffers; + +}; + +} // namespace android + +#endif // ANDROID_GUI_CPUCONSUMER_H diff --git a/include/gui/DisplayEventReceiver.h b/include/gui/DisplayEventReceiver.h index e631cca..f8267bf 100644 --- a/include/gui/DisplayEventReceiver.h +++ b/include/gui/DisplayEventReceiver.h @@ -40,13 +40,15 @@ class IDisplayEventConnection; class DisplayEventReceiver { public: enum { - DISPLAY_EVENT_VSYNC = 'vsyn' + DISPLAY_EVENT_VSYNC = 'vsyn', + DISPLAY_EVENT_HOTPLUG = 'plug' }; struct Event { struct Header { uint32_t type; + uint32_t id; nsecs_t timestamp; }; @@ -54,9 +56,14 @@ public: uint32_t count; }; + struct Hotplug { + bool connected; + }; + Header header; union { VSync vsync; + Hotplug hotplug; }; }; diff --git a/include/gui/GLConsumer.h b/include/gui/GLConsumer.h new file mode 100644 index 0000000..d53b04a --- /dev/null +++ b/include/gui/GLConsumer.h @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2010 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_GUI_CONSUMER_H +#define ANDROID_GUI_CONSUMER_H + +#include <gui/BufferQueue.h> +#include <gui/ConsumerBase.h> +#include <gui/ISurfaceTexture.h> + +namespace android { + +class GLConsumer : public ConsumerBase { +public: + GLConsumer(GLuint, bool = false, GLenum = 0, bool = false, const sp<BufferQueue>& = 0) : + ConsumerBase(0) {} + void incStrong(const void*) const {} + void decStrong(const void*) const {} + status_t updateTexImage() { return 0; } + void abandon() {} + sp<ISurfaceTexture> getBufferQueue() const { return 0; } + GLenum getCurrentTextureTarget() const { return 0; } + status_t setSynchronousMode(bool) { return 0; } + void getTransformMatrix(float[16]) {} + int64_t getTimestamp() {} + void setFrameAvailableListener(const wp<FrameAvailableListener>&) {} + sp<GraphicBuffer> getCurrentBuffer() const { return 0; } +}; + +}; // namespace android + +#endif // ANDROID_GUI_CONSUMER_H + diff --git a/include/gui/GuiConfig.h b/include/gui/GuiConfig.h new file mode 100644 index 0000000..b020ed9 --- /dev/null +++ b/include/gui/GuiConfig.h @@ -0,0 +1,29 @@ +/* + * 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. + */ + +#ifndef ANDROID_GUI_CONFIG_H +#define ANDROID_GUI_CONFIG_H + +#include <utils/String8.h> + +namespace android { + +// Append the libgui configuration details to configStr. +void appendGuiConfigString(String8& configStr); + +}; // namespace android + +#endif /*ANDROID_GUI_CONFIG_H*/ diff --git a/include/gui/ISurfaceComposer.h b/include/gui/ISurfaceComposer.h index 09e7771..6500ad5 100644 --- a/include/gui/ISurfaceComposer.h +++ b/include/gui/ISurfaceComposer.h @@ -34,70 +34,24 @@ namespace android { // ---------------------------------------------------------------------------- class ComposerState; +class DisplayState; +class DisplayInfo; class IDisplayEventConnection; class IMemoryHeap; -class ISurfaceComposer : public IInterface -{ +class ISurfaceComposer: public IInterface { public: DECLARE_META_INTERFACE(SurfaceComposer); - enum { // (keep in sync with Surface.java) - eHidden = 0x00000004, - eDestroyBackbuffer = 0x00000020, - eSecure = 0x00000080, - eNonPremultiplied = 0x00000100, - eOpaque = 0x00000400, - eProtectedByApp = 0x00000800, - eProtectedByDRM = 0x00001000, - - eFXSurfaceNormal = 0x00000000, - eFXSurfaceBlur = 0x00010000, - eFXSurfaceDim = 0x00020000, - eFXSurfaceScreenshot= 0x00030000, - eFXSurfaceMask = 0x000F0000, - }; - - enum { - ePositionChanged = 0x00000001, - eLayerChanged = 0x00000002, - eSizeChanged = 0x00000004, - eAlphaChanged = 0x00000008, - eMatrixChanged = 0x00000010, - eTransparentRegionChanged = 0x00000020, - eVisibilityChanged = 0x00000040, - eFreezeTintChanged = 0x00000080, - eCropChanged = 0x00000100, - }; - - enum { - eLayerHidden = 0x01, - eLayerFrozen = 0x02, - eLayerDither = 0x04, - eLayerFilter = 0x08, - eLayerBlurFreeze = 0x10 - }; - - enum { - eOrientationDefault = 0, - eOrientation90 = 1, - eOrientation180 = 2, - eOrientation270 = 3, - eOrientationUnchanged = 4, - eOrientationSwapMask = 0x01 - }; - - enum { - eSynchronous = 0x01, - }; - + // flags for setTransactionState() enum { - eElectronBeamAnimationOn = 0x01, - eElectronBeamAnimationOff = 0x10 + eSynchronous = 0x01, + eAnimation = 0x02, }; enum { - eDisplayIdMain = 0 + eDisplayIdMain = 0, + eDisplayIdHdmi = 1 }; /* create connection with surface flinger, requires @@ -109,46 +63,57 @@ public: */ virtual sp<IGraphicBufferAlloc> createGraphicBufferAlloc() = 0; - /* retrieve the control block */ - virtual sp<IMemoryHeap> getCblk() const = 0; + /* return an IDisplayEventConnection */ + virtual sp<IDisplayEventConnection> createDisplayEventConnection() = 0; + + /* create a display + * requires ACCESS_SURFACE_FLINGER permission. + */ + virtual sp<IBinder> createDisplay(const String8& displayName, + bool secure) = 0; + + /* get the token for the existing default displays. possible values + * for id are eDisplayIdMain and eDisplayIdHdmi. + */ + virtual sp<IBinder> getBuiltInDisplay(int32_t id) = 0; /* open/close transactions. requires ACCESS_SURFACE_FLINGER permission */ virtual void setTransactionState(const Vector<ComposerState>& state, - int orientation, uint32_t flags) = 0; + const Vector<DisplayState>& displays, uint32_t flags) = 0; /* signal that we're done booting. * Requires ACCESS_SURFACE_FLINGER permission */ virtual void bootFinished() = 0; + /* verify that an ISurfaceTexture was created by SurfaceFlinger. + */ + virtual bool authenticateSurfaceTexture( + const sp<ISurfaceTexture>& surface) const = 0; + /* Capture the specified screen. requires READ_FRAME_BUFFER permission * This function will fail if there is a secure window on screen. */ - virtual status_t captureScreen(DisplayID dpy, - sp<IMemoryHeap>* heap, + virtual status_t captureScreen(const sp<IBinder>& display, sp<IMemoryHeap>* heap, uint32_t* width, uint32_t* height, PixelFormat* format, uint32_t reqWidth, uint32_t reqHeight, uint32_t minLayerZ, uint32_t maxLayerZ) = 0; - /* triggers screen off animation */ - virtual status_t turnElectronBeamOff(int32_t mode) = 0; - /* triggers screen on animation */ - virtual status_t turnElectronBeamOn(int32_t mode) = 0; + /* triggers screen off and waits for it to complete */ + virtual void blank(const sp<IBinder>& display) = 0; - /* verify that an ISurfaceTexture was created by SurfaceFlinger. - */ - virtual bool authenticateSurfaceTexture( - const sp<ISurfaceTexture>& surface) const = 0; + /* triggers screen on and waits for it to complete */ + virtual void unblank(const sp<IBinder>& display) = 0; - /* return an IDisplayEventConnection */ - virtual sp<IDisplayEventConnection> createDisplayEventConnection() = 0; + /* returns information about a display + * intended to be used to get information about built-in displays */ + virtual status_t getDisplayInfo(const sp<IBinder>& display, DisplayInfo* info) = 0; }; // ---------------------------------------------------------------------------- -class BnSurfaceComposer : public BnInterface<ISurfaceComposer> -{ +class BnSurfaceComposer: public BnInterface<ISurfaceComposer> { public: enum { // Note: BOOT_FINISHED must remain this value, it is called from @@ -156,20 +121,20 @@ public: BOOT_FINISHED = IBinder::FIRST_CALL_TRANSACTION, CREATE_CONNECTION, CREATE_GRAPHIC_BUFFER_ALLOC, - GET_CBLK, + CREATE_DISPLAY_EVENT_CONNECTION, + CREATE_DISPLAY, + GET_BUILT_IN_DISPLAY, SET_TRANSACTION_STATE, - SET_ORIENTATION, - CAPTURE_SCREEN, - TURN_ELECTRON_BEAM_OFF, - TURN_ELECTRON_BEAM_ON, AUTHENTICATE_SURFACE, - CREATE_DISPLAY_EVENT_CONNECTION, + CAPTURE_SCREEN, + BLANK, + UNBLANK, + GET_DISPLAY_INFO, + CONNECT_DISPLAY, }; - virtual status_t onTransact( uint32_t code, - const Parcel& data, - Parcel* reply, - uint32_t flags = 0); + virtual status_t onTransact(uint32_t code, const Parcel& data, + Parcel* reply, uint32_t flags = 0); }; // ---------------------------------------------------------------------------- diff --git a/include/gui/ISurfaceComposerClient.h b/include/gui/ISurfaceComposerClient.h index c793933..e256e33 100644 --- a/include/gui/ISurfaceComposerClient.h +++ b/include/gui/ISurfaceComposerClient.h @@ -30,11 +30,6 @@ #include <gui/ISurface.h> namespace android { - -// ---------------------------------------------------------------------------- - -typedef int32_t DisplayID; - // ---------------------------------------------------------------------------- class ISurfaceComposerClient : public IInterface @@ -42,9 +37,26 @@ class ISurfaceComposerClient : public IInterface public: DECLARE_META_INTERFACE(SurfaceComposerClient); + // flags for createSurface() + enum { // (keep in sync with Surface.java) + eHidden = 0x00000004, + eDestroyBackbuffer = 0x00000020, + eSecure = 0x00000080, + eNonPremultiplied = 0x00000100, + eOpaque = 0x00000400, + eProtectedByApp = 0x00000800, + eProtectedByDRM = 0x00001000, + + eFXSurfaceNormal = 0x00000000, + eFXSurfaceBlur = 0x00010000, // deprecated, same as Dim + eFXSurfaceDim = 0x00020000, + eFXSurfaceScreenshot= 0x00030000, + eFXSurfaceMask = 0x000F0000, + }; + struct surface_data_t { - int32_t token; - int32_t identity; + int32_t token; + int32_t identity; status_t readFromParcel(const Parcel& parcel); status_t writeToParcel(Parcel* parcel) const; }; @@ -52,29 +64,22 @@ public: /* * Requires ACCESS_SURFACE_FLINGER permission */ - virtual sp<ISurface> createSurface( surface_data_t* data, - const String8& name, - DisplayID display, - uint32_t w, - uint32_t h, - PixelFormat format, - uint32_t flags) = 0; + virtual sp<ISurface> createSurface(surface_data_t* data, + const String8& name, uint32_t w, uint32_t h, + PixelFormat format, uint32_t flags) = 0; /* * Requires ACCESS_SURFACE_FLINGER permission */ - virtual status_t destroySurface(SurfaceID sid) = 0; + virtual status_t destroySurface(SurfaceID sid) = 0; }; // ---------------------------------------------------------------------------- -class BnSurfaceComposerClient : public BnInterface<ISurfaceComposerClient> -{ +class BnSurfaceComposerClient: public BnInterface<ISurfaceComposerClient> { public: - virtual status_t onTransact( uint32_t code, - const Parcel& data, - Parcel* reply, - uint32_t flags = 0); + virtual status_t onTransact(uint32_t code, const Parcel& data, + Parcel* reply, uint32_t flags = 0); }; // ---------------------------------------------------------------------------- diff --git a/include/gui/ISurfaceTexture.h b/include/gui/ISurfaceTexture.h index 1e33764..ae7c5c2 100644 --- a/include/gui/ISurfaceTexture.h +++ b/include/gui/ISurfaceTexture.h @@ -25,6 +25,7 @@ #include <binder/IInterface.h> +#include <ui/Fence.h> #include <ui/GraphicBuffer.h> #include <ui/Rect.h> @@ -38,9 +39,6 @@ class ISurfaceTexture : public IInterface public: DECLARE_META_INTERFACE(SurfaceTexture); -protected: - friend class SurfaceTextureClient; - enum { BUFFER_NEEDS_REALLOCATION = 0x1, RELEASE_ALL_BUFFERS = 0x2, @@ -67,8 +65,13 @@ protected: // in the contents of its associated buffer contents and call queueBuffer. // If dequeueBuffer return BUFFER_NEEDS_REALLOCATION, the client is // expected to call requestBuffer immediately. - virtual status_t dequeueBuffer(int *slot, uint32_t w, uint32_t h, - uint32_t format, uint32_t usage) = 0; + // + // The fence parameter will be updated to hold the fence associated with + // the buffer. The contents of the buffer must not be overwritten until the + // fence signals. If the fence is NULL, the buffer may be written + // immediately. + virtual status_t dequeueBuffer(int *slot, sp<Fence>& fence, + uint32_t w, uint32_t h, uint32_t format, uint32_t usage) = 0; // queueBuffer indicates that the client has finished filling in the // contents of the buffer associated with slot and transfers ownership of @@ -83,24 +86,37 @@ protected: // and height of the window and current transform applied to buffers, // respectively. - // QueueBufferInput must be a POD structure - struct QueueBufferInput { + struct QueueBufferInput : public Flattenable { + inline QueueBufferInput(const Parcel& parcel); inline QueueBufferInput(int64_t timestamp, - const Rect& crop, int scalingMode, uint32_t transform) + const Rect& crop, int scalingMode, uint32_t transform, + sp<Fence> fence) : timestamp(timestamp), crop(crop), scalingMode(scalingMode), - transform(transform) { } + transform(transform), fence(fence) { } inline void deflate(int64_t* outTimestamp, Rect* outCrop, - int* outScalingMode, uint32_t* outTransform) const { + int* outScalingMode, uint32_t* outTransform, + sp<Fence>* outFence) const { *outTimestamp = timestamp; *outCrop = crop; *outScalingMode = scalingMode; *outTransform = transform; + *outFence = fence; } + + // Flattenable interface + virtual size_t getFlattenedSize() const; + virtual size_t getFdCount() const; + virtual status_t flatten(void* buffer, size_t size, + int fds[], size_t count) const; + virtual status_t unflatten(void const* buffer, size_t size, + int fds[], size_t count); + private: int64_t timestamp; Rect crop; int scalingMode; uint32_t transform; + sp<Fence> fence; }; // QueueBufferOutput must be a POD structure @@ -135,7 +151,7 @@ protected: // cancelBuffer indicates that the client does not wish to fill in the // buffer associated with slot and transfers ownership of the slot back to // the server. - virtual void cancelBuffer(int slot) = 0; + virtual void cancelBuffer(int slot, sp<Fence> fence) = 0; // query retrieves some information for this surface // 'what' tokens allowed are that of android_natives.h diff --git a/include/gui/Sensor.h b/include/gui/Sensor.h index e59757a..2af2307 100644 --- a/include/gui/Sensor.h +++ b/include/gui/Sensor.h @@ -41,7 +41,7 @@ class Parcel; // ---------------------------------------------------------------------------- -class Sensor : public ASensor, public Flattenable +class Sensor : public ASensor, public LightFlattenable<Sensor> { public: enum { @@ -54,7 +54,7 @@ public: Sensor(); Sensor(struct sensor_t const* hwSensor); - virtual ~Sensor(); + ~Sensor(); const String8& getName() const; const String8& getVendor() const; @@ -68,13 +68,11 @@ public: nsecs_t getMinDelayNs() const; int32_t getVersion() const; - // Flattenable interface - virtual size_t getFlattenedSize() const; - virtual size_t getFdCount() const; - virtual status_t flatten(void* buffer, size_t size, - int fds[], size_t count) const; - virtual status_t unflatten(void const* buffer, size_t size, - int fds[], size_t count); + // LightFlattenable protocol + inline bool isFixedSize() const { return false; } + size_t getSize() const; + status_t flatten(void* buffer) const; + status_t unflatten(void const* buffer, size_t size); private: String8 mName; diff --git a/include/gui/Surface.h b/include/gui/Surface.h index 50bdf71..3411f0a 100644 --- a/include/gui/Surface.h +++ b/include/gui/Surface.h @@ -60,18 +60,16 @@ public: // release surface data from java void clear(); + status_t setLayerStack(int32_t layerStack); status_t setLayer(int32_t layer); status_t setPosition(int32_t x, int32_t y); status_t setSize(uint32_t w, uint32_t h); status_t hide(); - status_t show(int32_t layer = -1); - status_t freeze(); - status_t unfreeze(); + status_t show(); status_t setFlags(uint32_t flags, uint32_t mask); status_t setTransparentRegionHint(const Region& transparent); status_t setAlpha(float alpha=1.0f); status_t setMatrix(float dsdx, float dtdx, float dsdy, float dtdy); - status_t setFreezeTint(uint32_t tint); status_t setCrop(const Rect& crop); static status_t writeSurfaceToParcel( @@ -123,6 +121,8 @@ public: explicit Surface(const sp<ISurfaceTexture>& st); + Surface (sp<BufferQueue>&) {} + static status_t writeToParcel(const sp<Surface>& control, Parcel* parcel); static sp<Surface> readFromParcel(const Parcel& data); @@ -136,6 +136,7 @@ public: // the lock/unlock APIs must be used from the same thread status_t lock(SurfaceInfo* info, Region* dirty = NULL); + int lock(ANativeWindow_Buffer*, ARect*) { return 0; } status_t unlockAndPost(); sp<IBinder> asBinder() const; diff --git a/include/gui/SurfaceComposerClient.h b/include/gui/SurfaceComposerClient.h index 295bc02..ae5d69a 100644 --- a/include/gui/SurfaceComposerClient.h +++ b/include/gui/SurfaceComposerClient.h @@ -39,6 +39,7 @@ class DisplayInfo; class Composer; class IMemoryHeap; class ISurfaceComposerClient; +class ISurfaceTexture; class Region; // --------------------------------------------------------------------------- @@ -59,85 +60,87 @@ public: // Forcibly remove connection before all references have gone away. void dispose(); + // callback when the composer is dies + status_t linkToComposerDeath(const sp<IBinder::DeathRecipient>& recipient, + void* cookie = NULL, uint32_t flags = 0); + + // Get information about a display + static status_t getDisplayInfo(const sp<IBinder>& display, DisplayInfo* info); + + /* triggers screen off and waits for it to complete */ + static void blankDisplay(const sp<IBinder>& display); + + /* triggers screen on and waits for it to complete */ + static void unblankDisplay(const sp<IBinder>& display); + // ------------------------------------------------------------------------ // surface creation / destruction //! Create a surface sp<SurfaceControl> createSurface( const String8& name,// name of the surface - DisplayID display, // Display to create this surface on uint32_t w, // width in pixel uint32_t h, // height in pixel PixelFormat format, // pixel-format desired uint32_t flags = 0 // usage flags ); - sp<SurfaceControl> createSurface( - DisplayID display, // Display to create this surface on - uint32_t w, // width in pixel - uint32_t h, // height in pixel - PixelFormat format, // pixel-format desired - uint32_t flags = 0 // usage flags - ); + //! Create a display + static sp<IBinder> createDisplay(const String8& displayName, bool secure); + //! Get the token for the existing default displays. + //! Possible values for id are eDisplayIdMain and eDisplayIdHdmi. + static sp<IBinder> getBuiltInDisplay(int32_t id); // ------------------------------------------------------------------------ // Composer parameters // All composer parameters must be changed within a transaction // several surfaces can be updated in one transaction, all changes are // committed at once when the transaction is closed. - // closeGlobalTransaction() usually requires an IPC with the server. + // closeGlobalTransaction() requires an IPC with the server. //! Open a composer transaction on all active SurfaceComposerClients. static void openGlobalTransaction(); - + //! Close a composer transaction on all active SurfaceComposerClients. static void closeGlobalTransaction(bool synchronous = false); - - //! Freeze the specified display but not transactions. - static status_t freezeDisplay(DisplayID dpy, uint32_t flags = 0); - - //! Resume updates on the specified display. - static status_t unfreezeDisplay(DisplayID dpy, uint32_t flags = 0); - - //! Set the orientation of the given display - static int setOrientation(DisplayID dpy, int orientation, uint32_t flags); - - // Query the number of displays - static ssize_t getNumberOfDisplays(); - - // Get information about a display - static status_t getDisplayInfo(DisplayID dpy, DisplayInfo* info); - static ssize_t getDisplayWidth(DisplayID dpy); - static ssize_t getDisplayHeight(DisplayID dpy); - static ssize_t getDisplayOrientation(DisplayID dpy); - - static inline sp<IBinder> getBuiltInDisplay(int32_t dpy) { - return NULL; - } - - static inline status_t getDisplayInfo(const sp<IBinder>& dpy, DisplayInfo* info) { - return getDisplayInfo(0, info); - } - status_t linkToComposerDeath(const sp<IBinder::DeathRecipient>& recipient, - void* cookie = NULL, uint32_t flags = 0); + //! Flag the currently open transaction as an animation transaction. + static void setAnimationTransaction(); status_t hide(SurfaceID id); - status_t show(SurfaceID id, int32_t layer = -1); - status_t freeze(SurfaceID id); - status_t unfreeze(SurfaceID id); + status_t show(SurfaceID id); status_t setFlags(SurfaceID id, uint32_t flags, uint32_t mask); status_t setTransparentRegionHint(SurfaceID id, const Region& transparent); status_t setLayer(SurfaceID id, int32_t layer); status_t setAlpha(SurfaceID id, float alpha=1.0f); - status_t setFreezeTint(SurfaceID id, uint32_t tint); status_t setMatrix(SurfaceID id, float dsdx, float dtdx, float dsdy, float dtdy); status_t setPosition(SurfaceID id, float x, float y); status_t setSize(SurfaceID id, uint32_t w, uint32_t h); status_t setCrop(SurfaceID id, const Rect& crop); + status_t setLayerStack(SurfaceID id, uint32_t layerStack); status_t destroySurface(SurfaceID sid); + static void setDisplaySurface(const sp<IBinder>& token, + const sp<ISurfaceTexture>& surface); + static void setDisplayLayerStack(const sp<IBinder>& token, + uint32_t layerStack); + + /* setDisplayProjection() defines the projection of layer stacks + * to a given display. + * + * - orientation defines the display's orientation. + * - layerStackRect defines which area of the window manager coordinate + * space will be used. + * - displayRect defines where on the display will layerStackRect be + * mapped to. displayRect is specified post-orientation, that is + * it uses the orientation seen by the end-user. + */ + static void setDisplayProjection(const sp<IBinder>& token, + uint32_t orientation, + const Rect& layerStackRect, + const Rect& displayRect); + private: virtual void onFirstRef(); Composer& getComposer(); @@ -160,9 +163,11 @@ public: ScreenshotClient(); // frees the previous screenshot and capture a new one - status_t update(); - status_t update(uint32_t reqWidth, uint32_t reqHeight); - status_t update(uint32_t reqWidth, uint32_t reqHeight, + status_t update(const sp<IBinder>& display); + status_t update(const sp<IBinder>& display, + uint32_t reqWidth, uint32_t reqHeight); + status_t update(const sp<IBinder>& display, + uint32_t reqWidth, uint32_t reqHeight, uint32_t minLayerZ, uint32_t maxLayerZ); // release memory occupied by the screenshot diff --git a/include/gui/SurfaceTexture.h b/include/gui/SurfaceTexture.h index 2635e2f..7c519ae 100644 --- a/include/gui/SurfaceTexture.h +++ b/include/gui/SurfaceTexture.h @@ -24,6 +24,7 @@ #include <gui/ISurfaceTexture.h> #include <gui/BufferQueue.h> +#include <gui/ConsumerBase.h> #include <ui/GraphicBuffer.h> @@ -39,20 +40,9 @@ namespace android { class String8; -class SurfaceTexture : public virtual RefBase, - protected BufferQueue::ConsumerListener { +class SurfaceTexture : public ConsumerBase { public: - struct FrameAvailableListener : public virtual RefBase { - // onFrameAvailable() is called each time an additional frame becomes - // available for consumption. This means that frames that are queued - // while in asynchronous mode only trigger the callback if no previous - // frames are pending. Frames queued while in synchronous mode always - // trigger the callback. - // - // This is called without any lock held and can be called concurrently - // by multiple threads. - virtual void onFrameAvailable() = 0; - }; + typedef ConsumerBase::FrameAvailableListener FrameAvailableListener; // SurfaceTexture constructs a new SurfaceTexture object. tex indicates the // name of the OpenGL ES texture to which images are to be streamed. @@ -82,19 +72,28 @@ public: GLenum texTarget = GL_TEXTURE_EXTERNAL_OES, bool useFenceSync = true, const sp<BufferQueue> &bufferQueue = 0); - virtual ~SurfaceTexture(); - // updateTexImage sets the image contents of the target texture to that of // the most recently queued buffer. // // This call may only be made while the OpenGL ES context to which the // target texture belongs is bound to the calling thread. + // + // After calling this method the doGLFenceWait method must be called + // before issuing OpenGL ES commands that access the texture contents. status_t updateTexImage(); - // setBufferCountServer set the buffer count. If the client has requested - // a buffer count using setBufferCount, the server-buffer count will - // take effect once the client sets the count back to zero. - status_t setBufferCountServer(int bufferCount); + // setReleaseFence stores a fence file descriptor that will signal when the + // current buffer is no longer being read. This fence will be returned to + // the producer when the current buffer is released by updateTexImage(). + // Multiple fences can be set for a given buffer; they will be merged into + // a single union fence. The SurfaceTexture will close the file descriptor + // when finished with it. + void setReleaseFence(int fenceFd); + + // setDefaultMaxBufferCount sets the default limit on the maximum number + // of buffers that will be allocated at one time. The image producer may + // override the limit. + status_t setDefaultMaxBufferCount(int bufferCount); // getTransformMatrix retrieves the 4x4 texture coordinate transform matrix // associated with the texture image set by the most recent call to @@ -124,16 +123,6 @@ public: // documented by the source. int64_t getTimestamp(); - // setFrameAvailableListener sets the listener object that will be notified - // when a new frame becomes available. - void setFrameAvailableListener(const sp<FrameAvailableListener>& listener); - - // getAllocator retrieves the binder object that must be referenced as long - // as the GraphicBuffers dequeued from this SurfaceTexture are referenced. - // Holding this binder reference prevents SurfaceFlinger from freeing the - // buffers before the client is done with them. - sp<IBinder> getAllocator(); - // setDefaultBufferSize is used to set the size of buffers returned by // requestBuffers when a with and height of zero is requested. // A call to setDefaultBufferSize() may trigger requestBuffers() to @@ -164,21 +153,20 @@ public: // getCurrentScalingMode returns the scaling mode of the current buffer. uint32_t getCurrentScalingMode() const; + // getCurrentFence returns the fence indicating when the current buffer is + // ready to be read from. + sp<Fence> getCurrentFence() const; + + // doGLFenceWait inserts a wait command into the OpenGL ES command stream + // to ensure that it is safe for future OpenGL ES commands to access the + // current texture buffer. This must be called each time updateTexImage + // is called before issuing OpenGL ES commands that access the texture. + status_t doGLFenceWait() const; + // isSynchronousMode returns whether the SurfaceTexture is currently in // synchronous mode. bool isSynchronousMode() const; - // abandon frees all the buffers and puts the SurfaceTexture into the - // 'abandoned' state. Once put in this state the SurfaceTexture can never - // leave it. When in the 'abandoned' state, all methods of the - // ISurfaceTexture interface will fail with the NO_INIT error. - // - // Note that while calling this method causes all the buffers to be freed - // from the perspective of the the SurfaceTexture, if there are additional - // references on the buffers (e.g. if a buffer is referenced by a client or - // by OpenGL ES as a texture) then those buffer will remain allocated. - void abandon(); - // set the name of the SurfaceTexture that will be used to identify it in // log messages. void setName(const String8& name); @@ -192,7 +180,9 @@ public: // getBufferQueue returns the BufferQueue object to which this // SurfaceTexture is connected. - sp<BufferQueue> getBufferQueue() const; + sp<BufferQueue> getBufferQueue() const { + return mBufferQueue; + } // detachFromContext detaches the SurfaceTexture from the calling thread's // current OpenGL ES context. This context must be the same as the context @@ -221,17 +211,25 @@ public: // current at the time of the last call to detachFromContext. status_t attachToContext(GLuint tex); - // dump our state in a String - virtual void dump(String8& result) const; - virtual void dump(String8& result, const char* prefix, char* buffer, size_t SIZE) const; - protected: - // Implementation of the BufferQueue::ConsumerListener interface. These - // calls are used to notify the SurfaceTexture of asynchronous events in the - // BufferQueue. - virtual void onFrameAvailable(); - virtual void onBuffersReleased(); + // abandonLocked overrides the ConsumerBase method to clear + // mCurrentTextureBuf in addition to the ConsumerBase behavior. + virtual void abandonLocked(); + + // dumpLocked overrides the ConsumerBase method to dump SurfaceTexture- + // specific info in addition to the ConsumerBase behavior. + virtual void dumpLocked(String8& result, const char* prefix, char* buffer, + size_t size) const; + + // acquireBufferLocked overrides the ConsumerBase method to update the + // mEglSlots array in addition to the ConsumerBase behavior. + virtual status_t acquireBufferLocked(BufferQueue::BufferItem *item); + + // releaseBufferLocked overrides the ConsumerBase method to update the + // mEglSlots array in addition to the ConsumerBase. + virtual status_t releaseBufferLocked(int buf, EGLDisplay display, + EGLSyncKHR eglFence); static bool isExternalFormat(uint32_t format); @@ -248,7 +246,7 @@ private: virtual ~BufferRejecter() { } }; friend class Layer; - status_t updateTexImage(BufferRejecter* rejecter); + status_t updateTexImage(BufferRejecter* rejecter, bool skipSync); // createImage creates a new EGLImage from a GraphicBuffer. EGLImageKHR createImage(EGLDisplay dpy, @@ -259,12 +257,20 @@ private: // slot and destroy the EGLImage in that slot. Otherwise it has no effect. // // This method must be called with mMutex locked. - void freeBufferLocked(int slotIndex); + virtual void freeBufferLocked(int slotIndex); - // computeCurrentTransformMatrix computes the transform matrix for the + // computeCurrentTransformMatrixLocked computes the transform matrix for the // current texture. It uses mCurrentTransform and the current GraphicBuffer // to compute this matrix and stores it in mCurrentTransformMatrix. - void computeCurrentTransformMatrix(); + // mCurrentTextureBuf must not be NULL. + void computeCurrentTransformMatrixLocked(); + + // doGLFenceWaitLocked inserts a wait command into the OpenGL ES command + // stream to ensure that it is safe for future OpenGL ES commands to + // access the current texture buffer. This must be called each time + // updateTexImage is called before issuing OpenGL ES commands that access + // the texture. + status_t doGLFenceWaitLocked() const; // syncForReleaseLocked performs the synchronization needed to release the // current slot from an OpenGL ES context. If needed it will set the @@ -295,6 +301,9 @@ private: // set to each time updateTexImage is called. uint32_t mCurrentScalingMode; + // mCurrentFence is the fence received from BufferQueue in updateTexImage. + sp<Fence> mCurrentFence; + // mCurrentTransformMatrix is the transform matrix for the current texture. // It gets computed by computeTransformMatrix each time updateTexImage is // called. @@ -336,11 +345,9 @@ private: struct EGLSlot { EGLSlot() : mEglImage(EGL_NO_IMAGE_KHR), - mFence(EGL_NO_SYNC_KHR) { + mEglFence(EGL_NO_SYNC_KHR) { } - sp<GraphicBuffer> mGraphicBuffer; - // mEglImage is the EGLImage created from mGraphicBuffer. EGLImageKHR mEglImage; @@ -348,7 +355,7 @@ private: // associated with this buffer slot may be dequeued. It is initialized // to EGL_NO_SYNC_KHR when the buffer is created and (optionally, based // on a compile-time option) set to a new sync object in updateTexImage. - EGLSyncKHR mFence; + EGLSyncKHR mEglFence; }; // mEglDisplay is the EGLDisplay with which this SurfaceTexture is currently @@ -370,23 +377,7 @@ private: // slot that has not yet been used. The buffer allocated to a slot will also // be replaced if the requested buffer usage or geometry differs from that // of the buffer allocated to a slot. - EGLSlot mEGLSlots[BufferQueue::NUM_BUFFER_SLOTS]; - - // mAbandoned indicates that the BufferQueue will no longer be used to - // consume images buffers pushed to it using the ISurfaceTexture interface. - // It is initialized to false, and set to true in the abandon method. A - // BufferQueue that has been abandoned will return the NO_INIT error from - // all ISurfaceTexture methods capable of returning an error. - bool mAbandoned; - - // mName is a string used to identify the SurfaceTexture in log messages. - // It can be set by the setName method. - String8 mName; - - // mFrameAvailableListener is the listener object that will be called when a - // new frame becomes available. If it is not NULL it will be called from - // queueBuffer. - sp<FrameAvailableListener> mFrameAvailableListener; + EGLSlot mEglSlots[BufferQueue::NUM_BUFFER_SLOTS]; // mCurrentTexture is the buffer slot index of the buffer that is currently // bound to the OpenGL texture. It is initialized to INVALID_BUFFER_SLOT, @@ -396,22 +387,13 @@ private: // reset mCurrentTexture to INVALID_BUFFER_SLOT. int mCurrentTexture; - // The SurfaceTexture has-a BufferQueue and is responsible for creating this object - // if none is supplied - sp<BufferQueue> mBufferQueue; - - // mAttached indicates whether the SurfaceTexture is currently attached to + // mAttached indicates whether the ConsumerBase is currently attached to // an OpenGL ES context. For legacy reasons, this is initialized to true, - // indicating that the SurfaceTexture is considered to be attached to + // indicating that the ConsumerBase is considered to be attached to // whatever context is current at the time of the first updateTexImage call. // It is set to false by detachFromContext, and then set to true again by // attachToContext. bool mAttached; - - // mMutex is the mutex used to prevent concurrent access to the member - // variables of SurfaceTexture objects. It must be locked whenever the - // member variables are accessed. - mutable Mutex mMutex; }; // ---------------------------------------------------------------------------- diff --git a/include/gui/SurfaceTextureClient.h b/include/gui/SurfaceTextureClient.h index 8fa85b6..50fd1ba 100644 --- a/include/gui/SurfaceTextureClient.h +++ b/include/gui/SurfaceTextureClient.h @@ -61,14 +61,25 @@ private: void init(); // ANativeWindow hooks - static int hook_cancelBuffer(ANativeWindow* window, ANativeWindowBuffer* buffer); - static int hook_dequeueBuffer(ANativeWindow* window, ANativeWindowBuffer** buffer); - static int hook_lockBuffer(ANativeWindow* window, ANativeWindowBuffer* buffer); + static int hook_cancelBuffer(ANativeWindow* window, + ANativeWindowBuffer* buffer, int fenceFd); + static int hook_dequeueBuffer(ANativeWindow* window, + ANativeWindowBuffer** buffer, int* fenceFd); static int hook_perform(ANativeWindow* window, int operation, ...); static int hook_query(const ANativeWindow* window, int what, int* value); - static int hook_queueBuffer(ANativeWindow* window, ANativeWindowBuffer* buffer); + static int hook_queueBuffer(ANativeWindow* window, + ANativeWindowBuffer* buffer, int fenceFd); static int hook_setSwapInterval(ANativeWindow* window, int interval); + static int hook_cancelBuffer_DEPRECATED(ANativeWindow* window, + ANativeWindowBuffer* buffer); + static int hook_dequeueBuffer_DEPRECATED(ANativeWindow* window, + ANativeWindowBuffer** buffer); + static int hook_lockBuffer_DEPRECATED(ANativeWindow* window, + ANativeWindowBuffer* buffer); + static int hook_queueBuffer_DEPRECATED(ANativeWindow* window, + ANativeWindowBuffer* buffer); + int dispatchConnect(va_list args); int dispatchDisconnect(va_list args); int dispatchSetBufferCount(va_list args); @@ -86,14 +97,15 @@ private: int dispatchUnlockAndPost(va_list args); protected: - virtual int cancelBuffer(ANativeWindowBuffer* buffer); - virtual int dequeueBuffer(ANativeWindowBuffer** buffer); - virtual int lockBuffer(ANativeWindowBuffer* buffer); + virtual int dequeueBuffer(ANativeWindowBuffer** buffer, int* fenceFd); + virtual int cancelBuffer(ANativeWindowBuffer* buffer, int fenceFd); + virtual int queueBuffer(ANativeWindowBuffer* buffer, int fenceFd); virtual int perform(int operation, va_list args); virtual int query(int what, int* value) const; - virtual int queueBuffer(ANativeWindowBuffer* buffer); virtual int setSwapInterval(int interval); + virtual int lockBuffer_DEPRECATED(ANativeWindowBuffer* buffer); + virtual int connect(int api); virtual int disconnect(int api); virtual int setBufferCount(int bufferCount); diff --git a/include/media/hardware/CryptoAPI.h b/include/media/hardware/CryptoAPI.h index 810a443..44a0040 100644 --- a/include/media/hardware/CryptoAPI.h +++ b/include/media/hardware/CryptoAPI.h @@ -70,7 +70,9 @@ struct CryptoPlugin { // At the java level these special errors will then trigger a // MediaCodec.CryptoException that gives clients access to both // the error code and the errorDetailMsg. - virtual status_t decrypt( + // Returns a non-negative result to indicate the number of bytes written + // to the dstPtr, or a negative result to indicate an error. + virtual ssize_t decrypt( bool secure, const uint8_t key[16], const uint8_t iv[16], diff --git a/include/media/hardware/HDCPAPI.h b/include/media/hardware/HDCPAPI.h new file mode 100644 index 0000000..23e2bdd --- /dev/null +++ b/include/media/hardware/HDCPAPI.h @@ -0,0 +1,94 @@ +/* + * 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. + */ + +#ifndef HDCP_API_H_ + +#define HDCP_API_H_ + +#include <utils/Errors.h> + +namespace android { + +struct HDCPModule { + typedef void (*ObserverFunc)(void *cookie, int msg, int ext1, int ext2); + + // The msg argument in calls to the observer notification function. + enum { + // Sent in response to a call to "HDCPModule::initAsync" once + // initialization has either been successfully completed, + // i.e. the HDCP session is now fully setup (AKE, Locality Check, + // SKE and any authentication with repeaters completed) or failed. + // ext1 should be a suitable error code (status_t), ext2 is + // unused. + HDCP_INITIALIZATION_COMPLETE, + HDCP_INITIALIZATION_FAILED, + + // Sent upon completion of a call to "HDCPModule::shutdownAsync". + // ext1 should be a suitable error code, ext2 is unused. + HDCP_SHUTDOWN_COMPLETE, + HDCP_SHUTDOWN_FAILED, + + HDCP_UNAUTHENTICATED_CONNECTION, + HDCP_UNAUTHORIZED_CONNECTION, + HDCP_REVOKED_CONNECTION, + HDCP_TOPOLOGY_EXECEEDED, + HDCP_UNKNOWN_ERROR, + }; + + // Module can call the notification function to signal completion/failure + // of asynchronous operations (such as initialization) or out of band + // events. + HDCPModule(void *cookie, ObserverFunc observerNotify) {}; + + virtual ~HDCPModule() {}; + + // Request to setup an HDCP session with the specified host listening + // on the specified port. + virtual status_t initAsync(const char *host, unsigned port) = 0; + + // Request to shutdown the active HDCP session. + virtual status_t shutdownAsync() = 0; + + // Encrypt a data according to the HDCP spec. The data is to be + // encrypted in-place, only size bytes of data should be read/write, + // even if the size is not a multiple of 128 bit (16 bytes). + // This operation is to be synchronous, i.e. this call does not return + // until outData contains size bytes of encrypted data. + // streamCTR will be assigned by the caller (to 0 for the first PES stream, + // 1 for the second and so on) + // inputCTR will be maintained by the callee for each PES stream. + virtual status_t encrypt( + const void *inData, size_t size, uint32_t streamCTR, + uint64_t *outInputCTR, void *outData) = 0; + +private: + HDCPModule(const HDCPModule &); + HDCPModule &operator=(const HDCPModule &); +}; + +} // namespace android + +// A shared library exporting the following method should be included to +// support HDCP functionality. The shared library must be called +// "libstagefright_hdcp.so", it will be dynamically loaded into the +// mediaserver process. +extern "C" { + extern android::HDCPModule *createHDCPModule( + void *cookie, android::HDCPModule::ObserverFunc); +} + +#endif // HDCP_API_H_ + diff --git a/include/media/hardware/HardwareAPI.h b/include/media/hardware/HardwareAPI.h index 6d5b727..cc43bf6 100644 --- a/include/media/hardware/HardwareAPI.h +++ b/include/media/hardware/HardwareAPI.h @@ -105,6 +105,16 @@ struct GetAndroidNativeBufferUsageParams { // colorformat will be relayed by the GRalloc Buffers. // OMX_COLOR_FormatAndroidOpaque = 0x7F000001, +// A pointer to this struct is passed to OMX_SetParameter when the extension +// index for the 'OMX.google.android.index.prependSPSPPSToIDRFrames' extension +// is given. +// A successful result indicates that future IDR frames will be prefixed by +// SPS/PPS. +struct PrependSPSPPSToIDRFramesParams { + OMX_U32 nSize; + OMX_VERSIONTYPE nVersion; + OMX_BOOL bEnable; +}; } // namespace android diff --git a/include/media/openmax/OMX_IVCommon.h b/include/media/openmax/OMX_IVCommon.h index 8bb4ded..effbaae 100644 --- a/include/media/openmax/OMX_IVCommon.h +++ b/include/media/openmax/OMX_IVCommon.h @@ -159,6 +159,7 @@ typedef enum OMX_COLOR_FORMATTYPE { OMX_COLOR_FormatAndroidOpaque = 0x7F000789, OMX_TI_COLOR_FormatYUV420PackedSemiPlanar = 0x7F000100, OMX_QCOM_COLOR_FormatYVU420SemiPlanar = 0x7FA30C00, + OMX_QCOM_COLOR_FormatYUV420PackedSemiPlanar64x32Tile2m8ka = 0x7FA30C03, OMX_COLOR_FormatMax = 0x7FFFFFFF } OMX_COLOR_FORMATTYPE; diff --git a/include/private/gui/ComposerService.h b/include/private/gui/ComposerService.h index d04491a..ff2f9bf 100644 --- a/include/private/gui/ComposerService.h +++ b/include/private/gui/ComposerService.h @@ -30,21 +30,30 @@ namespace android { class IMemoryHeap; class ISurfaceComposer; -class surface_flinger_cblk_t; // --------------------------------------------------------------------------- +// This holds our connection to the composer service (i.e. SurfaceFlinger). +// If the remote side goes away, we will re-establish the connection. +// Users of this class should not retain the value from +// getComposerService() for an extended period. +// +// (It's not clear that using Singleton is useful here anymore.) class ComposerService : public Singleton<ComposerService> { - // these are constants sp<ISurfaceComposer> mComposerService; - sp<IMemoryHeap> mServerCblkMemory; - surface_flinger_cblk_t volatile* mServerCblk; + sp<IBinder::DeathRecipient> mDeathObserver; + Mutex mLock; + ComposerService(); + void connectLocked(); + void composerServiceDied(); friend class Singleton<ComposerService>; public: + + // Get a connection to the Composer Service. This will block until + // a connection is established. static sp<ISurfaceComposer> getComposerService(); - static surface_flinger_cblk_t const volatile * getControlBlock(); }; // --------------------------------------------------------------------------- diff --git a/include/private/gui/LayerState.h b/include/private/gui/LayerState.h index 9151c11..a7eb48c 100644 --- a/include/private/gui/LayerState.h +++ b/include/private/gui/LayerState.h @@ -33,10 +33,27 @@ class ISurfaceComposerClient; struct layer_state_t { + + enum { + eLayerHidden = 0x01, + }; + + enum { + ePositionChanged = 0x00000001, + eLayerChanged = 0x00000002, + eSizeChanged = 0x00000004, + eAlphaChanged = 0x00000008, + eMatrixChanged = 0x00000010, + eTransparentRegionChanged = 0x00000020, + eVisibilityChanged = 0x00000040, + eLayerStackChanged = 0x00000080, + eCropChanged = 0x00000100, + }; + layer_state_t() : surface(0), what(0), - x(0), y(0), z(0), w(0), h(0), - alpha(0), tint(0), flags(0), mask(0), + x(0), y(0), z(0), w(0), h(0), layerStack(0), + alpha(0), flags(0), mask(0), reserved(0) { matrix.dsdx = matrix.dtdy = 1.0f; @@ -60,8 +77,8 @@ struct layer_state_t { uint32_t z; uint32_t w; uint32_t h; + uint32_t layerStack; float alpha; - uint32_t tint; uint8_t flags; uint8_t mask; uint8_t reserved; @@ -78,6 +95,34 @@ struct ComposerState { status_t read(const Parcel& input); }; +struct DisplayState { + + enum { + eOrientationDefault = 0, + eOrientation90 = 1, + eOrientation180 = 2, + eOrientation270 = 3, + eOrientationUnchanged = 4, + eOrientationSwapMask = 0x01 + }; + + enum { + eSurfaceChanged = 0x01, + eLayerStackChanged = 0x02, + eDisplayProjectionChanged = 0x04 + }; + + uint32_t what; + sp<IBinder> token; + sp<ISurfaceTexture> surface; + uint32_t layerStack; + uint32_t orientation; + Rect viewport; + Rect frame; + status_t write(Parcel& output) const; + status_t read(const Parcel& input); +}; + }; // namespace android #endif // ANDROID_SF_LAYER_STATE_H diff --git a/include/private/gui/SharedBufferStack.h b/include/private/gui/SharedBufferStack.h deleted file mode 100644 index 0da03d1..0000000 --- a/include/private/gui/SharedBufferStack.h +++ /dev/null @@ -1,59 +0,0 @@ -/* - * Copyright (C) 2007 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_SF_SHARED_BUFFER_STACK_H -#define ANDROID_SF_SHARED_BUFFER_STACK_H - -#include <stdint.h> -#include <sys/types.h> - -#include <utils/Debug.h> - -namespace android { -// --------------------------------------------------------------------------- - -#define NUM_DISPLAY_MAX 4 - -struct display_cblk_t -{ - uint16_t w; - uint16_t h; - uint8_t format; - uint8_t orientation; - uint8_t reserved[2]; - float fps; - float density; - float xdpi; - float ydpi; - uint32_t pad[2]; -}; - -struct surface_flinger_cblk_t // 4KB max -{ - uint8_t connected; - uint8_t reserved[3]; - uint32_t pad[7]; - display_cblk_t displays[NUM_DISPLAY_MAX]; -}; - -// --------------------------------------------------------------------------- - -COMPILE_TIME_ASSERT(sizeof(surface_flinger_cblk_t) <= 4096) - -// --------------------------------------------------------------------------- -}; // namespace android - -#endif /* ANDROID_SF_SHARED_BUFFER_STACK_H */ diff --git a/include/private/ui/RegionHelper.h b/include/private/ui/RegionHelper.h index 421bdda..8c190dd 100644 --- a/include/private/ui/RegionHelper.h +++ b/include/private/ui/RegionHelper.h @@ -26,10 +26,10 @@ namespace android { template<typename RECT> class region_operator { +public: typedef typename RECT::value_type TYPE; static const TYPE max_value = 0x7FFFFFF; -public: /* * Common boolean operations: * value is computed as 0b101 op 0b110 diff --git a/include/ui/DisplayInfo.h b/include/ui/DisplayInfo.h index edd28a6..c3a4d6b 100644 --- a/include/ui/DisplayInfo.h +++ b/include/ui/DisplayInfo.h @@ -14,7 +14,6 @@ * limitations under the License. */ - #ifndef ANDROID_UI_DISPLAY_INFO_H #define ANDROID_UI_DISPLAY_INFO_H @@ -26,15 +25,17 @@ namespace android { struct DisplayInfo { - uint32_t w; - uint32_t h; - PixelFormatInfo pixelFormatInfo; - uint8_t orientation; - uint8_t reserved[3]; - float fps; - float density; - float xdpi; - float ydpi; + uint32_t w; + uint32_t h; + float xdpi; + float ydpi; + float fps; + float density; + uint8_t orientation; + bool secure; + uint8_t reserved[2]; + // TODO: this needs to go away (currently needed only by webkit) + PixelFormatInfo pixelFormatInfo; }; /* Display orientations as defined in Surface.java and ISurfaceComposer.h. */ @@ -45,8 +46,6 @@ enum { DISPLAY_ORIENTATION_270 = 3 }; - }; // namespace android #endif // ANDROID_COMPOSER_DISPLAY_INFO_H - diff --git a/include/ui/Fence.h b/include/ui/Fence.h new file mode 100644 index 0000000..ff6cefe --- /dev/null +++ b/include/ui/Fence.h @@ -0,0 +1,111 @@ +/* + * 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. + */ + +#ifndef ANDROID_FENCE_H +#define ANDROID_FENCE_H + +#include <stdint.h> +#include <sys/types.h> + +#include <ui/ANativeObjectBase.h> +#include <ui/PixelFormat.h> +#include <ui/Rect.h> +#include <utils/Flattenable.h> +#include <utils/String8.h> + +struct ANativeWindowBuffer; + +namespace android { + +// =========================================================================== +// Fence +// =========================================================================== + +class Fence + : public LightRefBase<Fence>, public Flattenable +{ +public: + static const sp<Fence> NO_FENCE; + + // Construct a new Fence object with an invalid file descriptor. This + // should be done when the Fence object will be set up by unflattening + // serialized data. + Fence(); + + // Construct a new Fence object to manage a given fence file descriptor. + // When the new Fence object is destructed the file descriptor will be + // closed. + Fence(int fenceFd); + + // Check whether the Fence has an open fence file descriptor. Most Fence + // methods treat an invalid file descriptor just like a valid fence that + // is already signalled, so using this is usually not necessary. + bool isValid() const { return mFenceFd != -1; } + + // wait waits for up to timeout milliseconds for the fence to signal. If + // the fence signals then NO_ERROR is returned. If the timeout expires + // before the fence signals then -ETIME is returned. A timeout of + // TIMEOUT_NEVER may be used to indicate that the call should wait + // indefinitely for the fence to signal. + status_t wait(unsigned int timeout); + + // waitForever is a convenience function for waiting forever for a fence to + // signal (just like wait(TIMEOUT_NEVER)), but issuing an error to the + // system log and fence state to the kernel log if the wait lasts longer + // than warningTimeout. The logname argument should be a string identifying + // the caller and will be included in the log message. + status_t waitForever(unsigned int warningTimeout, const char* logname); + + // TIMEOUT_NEVER may be passed to the wait method to indicate that it + // should wait indefinitely for the fence to signal. + enum { TIMEOUT_NEVER = -1 }; + + // merge combines two Fence objects, creating a new Fence object that + // becomes signaled when both f1 and f2 are signaled (even if f1 or f2 is + // destroyed before it becomes signaled). The name argument specifies the + // human-readable name to associated with the new Fence object. + static sp<Fence> merge(const String8& name, const sp<Fence>& f1, + const sp<Fence>& f2); + + // Return a duplicate of the fence file descriptor. The caller is + // responsible for closing the returned file descriptor. On error, -1 will + // be returned and errno will indicate the problem. + int dup() const; + + // Flattenable interface + size_t getFlattenedSize() const; + size_t getFdCount() const; + status_t flatten(void* buffer, size_t size, + int fds[], size_t count) const; + status_t unflatten(void const* buffer, size_t size, + int fds[], size_t count); + +private: + // Only allow instantiation using ref counting. + friend class LightRefBase<Fence>; + virtual ~Fence(); + + // Disallow copying + Fence(const Fence& rhs); + Fence& operator = (const Fence& rhs); + const Fence& operator = (const Fence& rhs) const; + + int mFenceFd; +}; + +}; // namespace android + +#endif // ANDROID_FENCE_H diff --git a/include/ui/FramebufferNativeWindow.h b/include/ui/FramebufferNativeWindow.h index b202b95..5ec738f 100644 --- a/include/ui/FramebufferNativeWindow.h +++ b/include/ui/FramebufferNativeWindow.h @@ -28,7 +28,8 @@ #include <ui/ANativeObjectBase.h> #include <ui/Rect.h> -#define NUM_FRAME_BUFFERS 2 +#define MIN_NUM_FRAME_BUFFERS 2 +#define MAX_NUM_FRAME_BUFFERS 3 extern "C" EGLNativeWindowType android_createDisplaySurface(void); @@ -65,16 +66,19 @@ private: friend class LightRefBase<FramebufferNativeWindow>; ~FramebufferNativeWindow(); // this class cannot be overloaded static int setSwapInterval(ANativeWindow* window, int interval); - static int dequeueBuffer(ANativeWindow* window, ANativeWindowBuffer** buffer); - static int lockBuffer(ANativeWindow* window, ANativeWindowBuffer* buffer); - static int queueBuffer(ANativeWindow* window, ANativeWindowBuffer* buffer); + static int dequeueBuffer(ANativeWindow* window, ANativeWindowBuffer** buffer, int* fenceFd); + static int queueBuffer(ANativeWindow* window, ANativeWindowBuffer* buffer, int fenceFd); static int query(const ANativeWindow* window, int what, int* value); static int perform(ANativeWindow* window, int operation, ...); - + + static int dequeueBuffer_DEPRECATED(ANativeWindow* window, ANativeWindowBuffer** buffer); + static int queueBuffer_DEPRECATED(ANativeWindow* window, ANativeWindowBuffer* buffer); + static int lockBuffer_DEPRECATED(ANativeWindow* window, ANativeWindowBuffer* buffer); + framebuffer_device_t* fbDev; alloc_device_t* grDev; - sp<NativeBuffer> buffers[NUM_FRAME_BUFFERS]; + sp<NativeBuffer> buffers[MAX_NUM_FRAME_BUFFERS]; sp<NativeBuffer> front; mutable Mutex mutex; diff --git a/include/ui/GraphicBufferAllocator.h b/include/ui/GraphicBufferAllocator.h index dffa788..479cd3e 100644 --- a/include/ui/GraphicBufferAllocator.h +++ b/include/ui/GraphicBufferAllocator.h @@ -84,6 +84,7 @@ private: static KeyedVector<buffer_handle_t, alloc_rec_t> sAllocList; friend class Singleton<GraphicBufferAllocator>; + friend class BufferLiberatorThread; GraphicBufferAllocator(); ~GraphicBufferAllocator(); diff --git a/include/ui/Point.h b/include/ui/Point.h index 1653120..1d7f64d 100644 --- a/include/ui/Point.h +++ b/include/ui/Point.h @@ -17,11 +17,12 @@ #ifndef ANDROID_UI_POINT #define ANDROID_UI_POINT +#include <utils/Flattenable.h> #include <utils/TypeHelpers.h> namespace android { -class Point +class Point : public LightFlattenablePod<Point> { public: int x; diff --git a/include/ui/Rect.h b/include/ui/Rect.h index c2c2675..47d37b6 100644 --- a/include/ui/Rect.h +++ b/include/ui/Rect.h @@ -17,6 +17,7 @@ #ifndef ANDROID_UI_RECT #define ANDROID_UI_RECT +#include <utils/Flattenable.h> #include <utils/TypeHelpers.h> #include <ui/Point.h> @@ -24,7 +25,7 @@ namespace android { -class Rect : public ARect +class Rect : public ARect, public LightFlattenablePod<Rect> { public: typedef ARect::value_type value_type; diff --git a/include/ui/Region.h b/include/ui/Region.h index f242f18..43a4450 100644 --- a/include/ui/Region.h +++ b/include/ui/Region.h @@ -23,28 +23,29 @@ #include <utils/Vector.h> #include <ui/Rect.h> +#include <utils/Flattenable.h> namespace android { // --------------------------------------------------------------------------- +class SharedBuffer; class String8; // --------------------------------------------------------------------------- -class Region +class Region : public LightFlattenable<Region> { public: Region(); Region(const Region& rhs); explicit Region(const Rect& rhs); - explicit Region(const void* buffer); ~Region(); Region& operator = (const Region& rhs); - inline bool isEmpty() const { return mBounds.isEmpty(); } - inline bool isRect() const { return mStorage.isEmpty(); } + inline bool isEmpty() const { return getBounds().isEmpty(); } + inline bool isRect() const { return mStorage.size() == 1; } - inline Rect getBounds() const { return mBounds; } + inline Rect getBounds() const { return mStorage[mStorage.size() - 1]; } inline Rect bounds() const { return getBounds(); } // the region becomes its bounds @@ -106,28 +107,32 @@ public: /* various ways to access the rectangle list */ + + // STL-like iterators typedef Rect const* const_iterator; - - const_iterator begin() const; - const_iterator end() const; + const_iterator begin() const; + const_iterator end() const; - /* no user serviceable parts here... */ - - size_t getRects(Vector<Rect>& rectList) const; - Rect const* getArray(size_t* count) const; + // returns an array of rect which has the same life-time has this + // Region object. + Rect const* getArray(size_t* count) const; + // returns a SharedBuffer as well as the number of rects. + // ownership is transfered to the caller. + // the caller must call SharedBuffer::release() to free the memory. + SharedBuffer const* getSharedBuffer(size_t* count) const; + + /* no user serviceable parts here... */ // add a rectangle to the internal list. This rectangle must // be sorted in Y and X and must not make the region invalid. void addRectUnchecked(int l, int t, int r, int b); - // flatten/unflatten a region to/from a raw buffer - ssize_t write(void* buffer, size_t size) const; - static ssize_t writeEmpty(void* buffer, size_t size); - - ssize_t read(const void* buffer); - static bool isEmpty(void* buffer); + inline bool isFixedSize() const { return false; } + size_t getSize() const; + status_t flatten(void* buffer) const; + status_t unflatten(void const* buffer, size_t size); void dump(String8& out, const char* what, uint32_t flags=0) const; void dump(const char* what, uint32_t flags=0) const; @@ -156,10 +161,14 @@ private: static void translate(Region& reg, int dx, int dy); static void translate(Region& dst, const Region& reg, int dx, int dy); - static bool validate(const Region& reg, const char* name); + static bool validate(const Region& reg, + const char* name, bool silent = false); - Rect mBounds; - Vector<Rect> mStorage; + // mStorage is a (manually) sorted array of Rects describing the region + // with an extra Rect as the last element which is set to the + // bounds of the region. However, if the region is + // a simple Rect then mStorage contains only that rect. + Vector<Rect> mStorage; }; diff --git a/include/ui/UiConfig.h b/include/ui/UiConfig.h new file mode 100644 index 0000000..fcf8ed5 --- /dev/null +++ b/include/ui/UiConfig.h @@ -0,0 +1,29 @@ +/* + * 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. + */ + +#ifndef ANDROID_UI_CONFIG_H +#define ANDROID_UI_CONFIG_H + +#include <utils/String8.h> + +namespace android { + +// Append the libui configuration details to configStr. +void appendUiConfigString(String8& configStr); + +}; // namespace android + +#endif /*ANDROID_UI_CONFIG_H*/ diff --git a/include/utils/Compat.h b/include/utils/Compat.h index 1819266..fb7748e 100644 --- a/include/utils/Compat.h +++ b/include/utils/Compat.h @@ -39,4 +39,27 @@ static inline ssize_t pread64(int fd, void* buf, size_t nbytes, off64_t offset) #endif /* !HAVE_OFF64_T */ +#if HAVE_PRINTF_ZD +# define ZD "%zd" +# define ZD_TYPE ssize_t +#else +# define ZD "%ld" +# define ZD_TYPE long +#endif + +/* + * TEMP_FAILURE_RETRY is defined by some, but not all, versions of + * <unistd.h>. (Alas, it is not as standard as we'd hoped!) So, if it's + * not already defined, then define it here. + */ +#ifndef TEMP_FAILURE_RETRY +/* Used to retry syscalls that can return EINTR. */ +#define TEMP_FAILURE_RETRY(exp) ({ \ + typeof (exp) _rc; \ + do { \ + _rc = (exp); \ + } while (_rc == -1 && errno == EINTR); \ + _rc; }) +#endif + #endif /* __LIB_UTILS_COMPAT_H */ diff --git a/include/utils/Flattenable.h b/include/utils/Flattenable.h index 852be3b..e40d289 100644 --- a/include/utils/Flattenable.h +++ b/include/utils/Flattenable.h @@ -24,6 +24,11 @@ namespace android { +/* + * The Flattenable interface allows an object to serialize itself out + * to a byte-buffer and an array of file descriptors. + */ + class Flattenable { public: @@ -56,6 +61,73 @@ protected: }; +/* + * LightFlattenable is a protocol allowing object to serialize themselves out + * to a byte-buffer. + * + * LightFlattenable objects must implement this protocol. + * + * LightFlattenable doesn't require the object to be virtual. + */ +template <typename T> +class LightFlattenable { +public: + // returns whether this object always flatten into the same size. + // for efficiency, this should always be inline. + inline bool isFixedSize() const; + + // returns size in bytes of the flattened object. must be a constant. + inline size_t getSize() const; + + // flattens the object into buffer. + inline status_t flatten(void* buffer) const; + + // unflattens the object from buffer of given size. + inline status_t unflatten(void const* buffer, size_t size); +}; + +template <typename T> +inline bool LightFlattenable<T>::isFixedSize() const { + return static_cast<T const*>(this)->T::isFixedSize(); +} +template <typename T> +inline size_t LightFlattenable<T>::getSize() const { + return static_cast<T const*>(this)->T::getSize(); +} +template <typename T> +inline status_t LightFlattenable<T>::flatten(void* buffer) const { + return static_cast<T const*>(this)->T::flatten(buffer); +} +template <typename T> +inline status_t LightFlattenable<T>::unflatten(void const* buffer, size_t size) { + return static_cast<T*>(this)->T::unflatten(buffer, size); +} + +/* + * LightFlattenablePod is an implementation of the LightFlattenable protocol + * for POD (plain-old-data) objects. + */ +template <typename T> +class LightFlattenablePod : public LightFlattenable<T> { +public: + inline bool isFixedSize() const { + return true; + } + + inline size_t getSize() const { + return sizeof(T); + } + inline status_t flatten(void* buffer) const { + *reinterpret_cast<T*>(buffer) = *static_cast<T const*>(this); + return NO_ERROR; + } + inline status_t unflatten(void const* buffer, size_t) { + *static_cast<T*>(this) = *reinterpret_cast<T const*>(buffer); + return NO_ERROR; + } +}; + + }; // namespace android diff --git a/include/utils/KeyedVector.h b/include/utils/KeyedVector.h index 20575ee..c4faae0 100644 --- a/include/utils/KeyedVector.h +++ b/include/utils/KeyedVector.h @@ -21,6 +21,8 @@ #include <stdint.h> #include <sys/types.h> +#include <cutils/log.h> + #include <utils/SortedVector.h> #include <utils/TypeHelpers.h> #include <utils/Errors.h> @@ -50,13 +52,16 @@ public: //! returns number of items in the vector inline size_t size() const { return mVector.size(); } - //! returns wether or not the vector is empty + //! returns whether or not the vector is empty inline bool isEmpty() const { return mVector.isEmpty(); } //! returns how many items can be stored without reallocating the backing store inline size_t capacity() const { return mVector.capacity(); } - //! setst the capacity. capacity can never be reduced less than size() + //! sets the capacity. capacity can never be reduced less than size() inline ssize_t setCapacity(size_t size) { return mVector.setCapacity(size); } - + + // returns true if the arguments is known to be identical to this vector + inline bool isIdenticalTo(const KeyedVector& rhs) const; + /*! * accessors */ @@ -64,6 +69,7 @@ public: const VALUE& valueAt(size_t index) const; const KEY& keyAt(size_t index) const; ssize_t indexOfKey(const KEY& key) const; + const VALUE& operator[] (size_t index) const; /*! * modifying the array @@ -123,6 +129,11 @@ KeyedVector<KEY,VALUE>::KeyedVector() } template<typename KEY, typename VALUE> inline +bool KeyedVector<KEY,VALUE>::isIdenticalTo(const KeyedVector<KEY,VALUE>& rhs) const { + return mVector.array() == rhs.mVector.array(); +} + +template<typename KEY, typename VALUE> inline ssize_t KeyedVector<KEY,VALUE>::indexOfKey(const KEY& key) const { return mVector.indexOf( key_value_pair_t<KEY,VALUE>(key) ); } @@ -130,7 +141,7 @@ ssize_t KeyedVector<KEY,VALUE>::indexOfKey(const KEY& key) const { template<typename KEY, typename VALUE> inline const VALUE& KeyedVector<KEY,VALUE>::valueFor(const KEY& key) const { ssize_t i = this->indexOfKey(key); - assert(i>=0); + LOG_ALWAYS_FATAL_IF(i<0, "%s: key not found", __PRETTY_FUNCTION__); return mVector.itemAt(i).value; } @@ -140,6 +151,11 @@ const VALUE& KeyedVector<KEY,VALUE>::valueAt(size_t index) const { } template<typename KEY, typename VALUE> inline +const VALUE& KeyedVector<KEY,VALUE>::operator[] (size_t index) const { + return valueAt(index); +} + +template<typename KEY, typename VALUE> inline const KEY& KeyedVector<KEY,VALUE>::keyAt(size_t index) const { return mVector.itemAt(index).key; } @@ -147,7 +163,7 @@ const KEY& KeyedVector<KEY,VALUE>::keyAt(size_t index) const { template<typename KEY, typename VALUE> inline VALUE& KeyedVector<KEY,VALUE>::editValueFor(const KEY& key) { ssize_t i = this->indexOfKey(key); - assert(i>=0); + LOG_ALWAYS_FATAL_IF(i<0, "%s: key not found", __PRETTY_FUNCTION__); return mVector.editItemAt(i).value; } diff --git a/include/utils/LinearAllocator.h b/include/utils/LinearAllocator.h new file mode 100644 index 0000000..cd2521d --- /dev/null +++ b/include/utils/LinearAllocator.h @@ -0,0 +1,42 @@ +/* + * Copyright 2012, The Android Open Source Project + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef ANDROID_LINEARALLOCATOR_H +#define ANDROID_LINEARALLOCATOR_H + +#include <stddef.h> + +namespace android { + +class LinearAllocator { +public: + void* alloc(size_t size) { return 0; } + void rewindIfLastAlloc(void* ptr, size_t allocSize) {} + void dumpMemoryStats(const char* prefix = "") {} +}; + +}; // namespace android + +#endif // ANDROID_LINEARALLOCATOR_H diff --git a/include/utils/Log.h b/include/utils/Log.h index 3c6cc8b..4259c86 100644 --- a/include/utils/Log.h +++ b/include/utils/Log.h @@ -29,5 +29,43 @@ #define _LIBS_UTILS_LOG_H #include <cutils/log.h> +#include <sys/types.h> + +#ifdef __cplusplus + +namespace android { + +/* + * A very simple utility that yells in the log when an operation takes too long. + */ +class LogIfSlow { +public: + LogIfSlow(const char* tag, android_LogPriority priority, + int timeoutMillis, const char* message); + ~LogIfSlow(); + +private: + const char* const mTag; + const android_LogPriority mPriority; + const int mTimeoutMillis; + const char* const mMessage; + const int64_t mStart; +}; + +/* + * Writes the specified debug log message if this block takes longer than the + * specified number of milliseconds to run. Includes the time actually taken. + * + * { + * ALOGD_IF_SLOW(50, "Excessive delay doing something."); + * doSomething(); + * } + */ +#define ALOGD_IF_SLOW(timeoutMillis, message) \ + android::LogIfSlow _logIfSlow(LOG_TAG, ANDROID_LOG_DEBUG, timeoutMillis, message); + +} // namespace android + +#endif // __cplusplus #endif // _LIBS_UTILS_LOG_H diff --git a/include/utils/SharedBuffer.h b/include/utils/SharedBuffer.h index 24508b0..b670953 100644 --- a/include/utils/SharedBuffer.h +++ b/include/utils/SharedBuffer.h @@ -44,9 +44,6 @@ public: * users. */ static ssize_t dealloc(const SharedBuffer* released); - - //! get the SharedBuffer from the data pointer - static inline const SharedBuffer* sharedBuffer(const void* data); //! access the data for read inline const void* data() const; @@ -94,9 +91,10 @@ public: private: inline SharedBuffer() { } inline ~SharedBuffer() { } - inline SharedBuffer(const SharedBuffer&); + SharedBuffer(const SharedBuffer&); + SharedBuffer& operator = (const SharedBuffer&); - // 16 bytes. must be sized to preserve correct alingment. + // 16 bytes. must be sized to preserve correct alignment. mutable int32_t mRefs; size_t mSize; uint32_t mReserved[2]; @@ -104,10 +102,6 @@ private: // --------------------------------------------------------------------------- -const SharedBuffer* SharedBuffer::sharedBuffer(const void* data) { - return data ? reinterpret_cast<const SharedBuffer *>(data)-1 : 0; -} - const void* SharedBuffer::data() const { return this + 1; } @@ -120,19 +114,16 @@ size_t SharedBuffer::size() const { return mSize; } -SharedBuffer* SharedBuffer::bufferFromData(void* data) -{ - return ((SharedBuffer*)data)-1; +SharedBuffer* SharedBuffer::bufferFromData(void* data) { + return data ? static_cast<SharedBuffer *>(data)-1 : 0; } -const SharedBuffer* SharedBuffer::bufferFromData(const void* data) -{ - return ((const SharedBuffer*)data)-1; +const SharedBuffer* SharedBuffer::bufferFromData(const void* data) { + return data ? static_cast<const SharedBuffer *>(data)-1 : 0; } -size_t SharedBuffer::sizeFromData(const void* data) -{ - return (((const SharedBuffer*)data)-1)->mSize; +size_t SharedBuffer::sizeFromData(const void* data) { + return data ? bufferFromData(data)->mSize : 0; } bool SharedBuffer::onlyOwner() const { diff --git a/include/utils/SortedVector.h b/include/utils/SortedVector.h index 2445525..2d3e82a 100644 --- a/include/utils/SortedVector.h +++ b/include/utils/SortedVector.h @@ -21,6 +21,8 @@ #include <stdint.h> #include <sys/types.h> +#include <cutils/log.h> + #include <utils/Vector.h> #include <utils/VectorImpl.h> #include <utils/TypeHelpers.h> @@ -61,11 +63,11 @@ public: //! returns number of items in the vector inline size_t size() const { return VectorImpl::size(); } - //! returns wether or not the vector is empty + //! returns whether or not the vector is empty inline bool isEmpty() const { return VectorImpl::isEmpty(); } //! returns how many items can be stored without reallocating the backing store inline size_t capacity() const { return VectorImpl::capacity(); } - //! setst the capacity. capacity can never be reduced less than size() + //! sets the capacity. capacity can never be reduced less than size() inline ssize_t setCapacity(size_t size) { return VectorImpl::setCapacity(size); } /*! @@ -76,7 +78,7 @@ public: inline const TYPE* array() const; //! read-write C-style access. BE VERY CAREFUL when modifying the array - //! you ust keep it sorted! You usually don't use this function. + //! you must keep it sorted! You usually don't use this function. TYPE* editArray(); //! finds the index of an item @@ -96,11 +98,9 @@ public: inline const TYPE& itemAt(size_t index) const; //! stack-usage of the vector. returns the top of the stack (last element) const TYPE& top() const; - //! same as operator [], but allows to access the vector backward (from the end) with a negative index - const TYPE& mirrorItemAt(ssize_t index) const; /*! - * modifing the array + * modifying the array */ //! add an item in the right place (and replace the one that is there) @@ -186,7 +186,9 @@ TYPE* SortedVector<TYPE>::editArray() { template<class TYPE> inline const TYPE& SortedVector<TYPE>::operator[](size_t index) const { - assert( index<size() ); + LOG_FATAL_IF(index>=size(), + "%s: index=%u out of range (%u)", __PRETTY_FUNCTION__, + int(index), int(size())); return *(array() + index); } @@ -196,12 +198,6 @@ const TYPE& SortedVector<TYPE>::itemAt(size_t index) const { } template<class TYPE> inline -const TYPE& SortedVector<TYPE>::mirrorItemAt(ssize_t index) const { - assert( (index>0 ? index : -index)<size() ); - return *(array() + ((index<0) ? (size()-index) : index)); -} - -template<class TYPE> inline const TYPE& SortedVector<TYPE>::top() const { return *(array() + size() - 1); } diff --git a/include/utils/SystemClock.h b/include/utils/SystemClock.h index 7c319be..d75264c 100644 --- a/include/utils/SystemClock.h +++ b/include/utils/SystemClock.h @@ -25,6 +25,7 @@ namespace android { int setCurrentTimeMillis(int64_t millis); int64_t uptimeMillis(); int64_t elapsedRealtime(); +int64_t elapsedRealtimeNano(); }; // namespace android diff --git a/include/utils/Timers.h b/include/utils/Timers.h index 8b4d322..92f66c9 100644 --- a/include/utils/Timers.h +++ b/include/utils/Timers.h @@ -78,9 +78,10 @@ enum { SYSTEM_TIME_REALTIME = 0, // system-wide realtime clock SYSTEM_TIME_MONOTONIC = 1, // monotonic time since unspecified starting point SYSTEM_TIME_PROCESS = 2, // high-resolution per-process clock - SYSTEM_TIME_THREAD = 3 // high-resolution per-thread clock + SYSTEM_TIME_THREAD = 3, // high-resolution per-thread clock + SYSTEM_TIME_BOOTTIME = 4 // same as SYSTEM_TIME_MONOTONIC, but including CPU suspend time }; - + // return the system-time according to the specified clock #ifdef __cplusplus nsecs_t systemTime(int clock = SYSTEM_TIME_MONOTONIC); diff --git a/include/utils/Trace.h b/include/utils/Trace.h index 4219206..41bce00 100644 --- a/include/utils/Trace.h +++ b/include/utils/Trace.h @@ -51,7 +51,10 @@ #define ATRACE_TAG_SYNC_MANAGER (1<<7) #define ATRACE_TAG_AUDIO (1<<8) #define ATRACE_TAG_VIDEO (1<<9) -#define ATRACE_TAG_LAST ATRACE_TAG_VIDEO +#define ATRACE_TAG_CAMERA (1<<10) +#define ATRACE_TAG_LAST ATRACE_TAG_CAMERA + +#define ATRACE_TAG_NOT_READY (1LL<<63) // Reserved for use during init #define ATRACE_TAG_VALID_MASK ((ATRACE_TAG_LAST - 1) | ATRACE_TAG_LAST) @@ -66,6 +69,11 @@ // function body. #define ATRACE_CALL() android::ScopedTrace ___tracer(ATRACE_TAG, __FUNCTION__) +// ATRACE_NAME traces the beginning and end of the current function. To trace +// the correct start and end times this macro should be the first line of the +// function body. +#define ATRACE_NAME(name) android::ScopedTrace ___tracer(ATRACE_TAG, name) + // ATRACE_INT traces a named integer value. This can be used to track how the // value changes over time in a trace. #define ATRACE_INT(name, value) android::Tracer::traceCounter(ATRACE_TAG, name, value) diff --git a/include/utils/Vector.h b/include/utils/Vector.h index e39a5b7..f3020d6 100644 --- a/include/utils/Vector.h +++ b/include/utils/Vector.h @@ -21,7 +21,8 @@ #include <stdint.h> #include <sys/types.h> -#include <utils/Log.h> +#include <cutils/log.h> + #include <utils/VectorImpl.h> #include <utils/TypeHelpers.h> @@ -72,11 +73,11 @@ public: //! returns number of items in the vector inline size_t size() const { return VectorImpl::size(); } - //! returns wether or not the vector is empty + //! returns whether or not the vector is empty inline bool isEmpty() const { return VectorImpl::isEmpty(); } //! returns how many items can be stored without reallocating the backing store inline size_t capacity() const { return VectorImpl::capacity(); } - //! setst the capacity. capacity can never be reduced less than size() + //! sets the capacity. capacity can never be reduced less than size() inline ssize_t setCapacity(size_t size) { return VectorImpl::setCapacity(size); } /*! @@ -98,16 +99,14 @@ public: inline const TYPE& itemAt(size_t index) const; //! stack-usage of the vector. returns the top of the stack (last element) const TYPE& top() const; - //! same as operator [], but allows to access the vector backward (from the end) with a negative index - const TYPE& mirrorItemAt(ssize_t index) const; /*! - * modifing the array + * modifying the array */ //! copy-on write support, grants write access to an item TYPE& editItemAt(size_t index); - //! grants right acces to the top of the stack (last element) + //! grants right access to the top of the stack (last element) TYPE& editTop(); /*! @@ -189,7 +188,8 @@ public: inline void push_back(const TYPE& item) { insertAt(item, size(), 1); } inline void push_front(const TYPE& item) { insertAt(item, 0, 1); } inline iterator erase(iterator pos) { - return begin() + removeItemsAt(pos-array()); + ssize_t index = removeItemsAt(pos-array()); + return begin() + index; } protected: @@ -271,8 +271,9 @@ TYPE* Vector<TYPE>::editArray() { template<class TYPE> inline const TYPE& Vector<TYPE>::operator[](size_t index) const { - LOG_FATAL_IF( index>=size(), - "itemAt: index %d is past size %d", (int)index, (int)size() ); + LOG_FATAL_IF(index>=size(), + "%s: index=%u out of range (%u)", __PRETTY_FUNCTION__, + int(index), int(size())); return *(array() + index); } @@ -282,14 +283,6 @@ const TYPE& Vector<TYPE>::itemAt(size_t index) const { } template<class TYPE> inline -const TYPE& Vector<TYPE>::mirrorItemAt(ssize_t index) const { - LOG_FATAL_IF( (index>0 ? index : -index)>=size(), - "mirrorItemAt: index %d is past size %d", - (int)index, (int)size() ); - return *(array() + ((index<0) ? (size()-index) : index)); -} - -template<class TYPE> inline const TYPE& Vector<TYPE>::top() const { return *(array() + size() - 1); } diff --git a/include/utils/misc.h b/include/utils/misc.h index d7d5bc1..f1aa432 100644 --- a/include/utils/misc.h +++ b/include/utils/misc.h @@ -23,41 +23,12 @@ #include <sys/time.h> #include <utils/Endian.h> -namespace android { - /* get #of elements in a static array */ #ifndef NELEM # define NELEM(x) ((int) (sizeof(x) / sizeof((x)[0]))) #endif -/* - * Make a copy of the string, using "new[]" instead of "malloc". Free the - * string with delete[]. - * - * Returns NULL if "str" is NULL. - */ -char* strdupNew(const char* str); - -/* - * Concatenate an argument vector into a single string. If argc is >= 0 - * it will be used; if it's < 0 then the last element in the arg vector - * must be NULL. - * - * This inserts a space between each argument. - * - * This does not automatically add double quotes around arguments with - * spaces in them. This practice is necessary for Win32, because Win32's - * CreateProcess call is stupid. - * - * The caller should delete[] the returned string. - */ -char* concatArgv(int argc, const char* const argv[]); - -/* - * Count up the number of arguments in "argv". The count does not include - * the final NULL entry. - */ -int countArgv(const char* const argv[]); +namespace android { /* * Some utility functions for working with files. These could be made @@ -79,15 +50,6 @@ FileType getFileType(const char* fileName); /* get the file's modification date; returns -1 w/errno set on failure */ time_t getFileModDate(const char* fileName); -/* - * Round up to the nearest power of 2. Handy for hash tables. - */ -unsigned int roundUpPower2(unsigned int val); - -void strreverse(char* begin, char* end); -void k_itoa(int value, char* str, int base); -char* itoa(int val, int base); - typedef void (*sysprop_change_callback)(void); void add_sysprop_change_callback(sysprop_change_callback cb, int priority); void report_sysprop_change(); |