diff options
Diffstat (limited to 'cmds/screenrecord/Overlay.h')
-rw-r--r-- | cmds/screenrecord/Overlay.h | 157 |
1 files changed, 157 insertions, 0 deletions
diff --git a/cmds/screenrecord/Overlay.h b/cmds/screenrecord/Overlay.h new file mode 100644 index 0000000..b8473b4 --- /dev/null +++ b/cmds/screenrecord/Overlay.h @@ -0,0 +1,157 @@ +/* + * Copyright 2013 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 SCREENRECORD_OVERLAY_H +#define SCREENRECORD_OVERLAY_H + +#include "Program.h" +#include "TextRenderer.h" +#include "EglWindow.h" + +#include <gui/BufferQueue.h> +#include <gui/GLConsumer.h> +#include <utils/Thread.h> + +#include <EGL/egl.h> + +namespace android { + +/* + * Overlay "filter". This sits between the virtual display and the video + * encoder. + * + * Most functions run on a thread created by start(). + */ +class Overlay : public GLConsumer::FrameAvailableListener, Thread { +public: + Overlay() : Thread(false), + mThreadResult(UNKNOWN_ERROR), + mState(UNINITIALIZED), + mFrameAvailable(false), + mExtTextureName(0), + mStartMonotonicNsecs(0), + mStartRealtimeNsecs(0), + mLastFrameNumber(-1), + mTotalDroppedFrames(0) + {} + virtual ~Overlay() { assert(mState == UNINITIALIZED || mState == STOPPED); } + + // Creates a thread that performs the overlay. Pass in the surface that + // output will be sent to. + // + // This creates a dedicated thread for processing frames. + // + // Returns a reference to the producer side of a new BufferQueue that will + // be used by the virtual display. + status_t start(const sp<IGraphicBufferProducer>& outputSurface, + sp<IGraphicBufferProducer>* pBufferProducer); + + // Stops the thread and releases resources. It's okay to call this even + // if start() was never called. + status_t stop(); + + // This creates an EGL context and window surface, draws some informative + // text on it, swaps the buffer, and then tears the whole thing down. + static status_t drawInfoPage(const sp<IGraphicBufferProducer>& outputSurface); + +private: + Overlay(const Overlay&); + Overlay& operator=(const Overlay&); + + // Draw the initial info screen. + static void doDrawInfoPage(const EglWindow& window, + const Program& texRender, TextRenderer& textRenderer); + + // (overrides GLConsumer::FrameAvailableListener method) + virtual void onFrameAvailable(); + + // (overrides Thread method) + virtual bool threadLoop(); + + // One-time setup (essentially object construction on the overlay thread). + status_t setup_l(); + + // Release all resources held. + void release_l(); + + // Release EGL display, context, surface. + void eglRelease_l(); + + // Process a frame received from the virtual display. + void processFrame_l(); + + // Convert a monotonic time stamp into a string with the current time. + void getTimeString_l(nsecs_t monotonicNsec, char* buf, size_t bufLen); + + // Guards all fields below. + Mutex mMutex; + + // Initialization gate. + Condition mStartCond; + + // Thread status, mostly useful during startup. + status_t mThreadResult; + + // Overlay thread state. States advance from left to right; object may + // not be restarted. + enum { UNINITIALIZED, INIT, RUNNING, STOPPING, STOPPED } mState; + + // Event notification. Overlay thread sleeps on this until a frame + // arrives or it's time to shut down. + Condition mEventCond; + + // Set by the FrameAvailableListener callback. + bool mFrameAvailable; + + // The surface we send our output to, i.e. the video encoder's input + // surface. + sp<IGraphicBufferProducer> mOutputSurface; + + // Our queue. The producer side is passed to the virtual display, the + // consumer side feeds into our GLConsumer. + sp<BufferQueue> mBufferQueue; + + // This receives frames from the virtual display and makes them available + // as an external texture. + sp<GLConsumer> mGlConsumer; + + // EGL display / context / surface. + EglWindow mEglWindow; + + // GL rendering support. + Program mExtTexProgram; + Program mTexProgram; + + // Text rendering. + TextRenderer mTextRenderer; + + // External texture, updated by GLConsumer. + GLuint mExtTextureName; + + // Start time, used to map monotonic to wall-clock time. + nsecs_t mStartMonotonicNsecs; + nsecs_t mStartRealtimeNsecs; + + // Used for tracking dropped frames. + nsecs_t mLastFrameNumber; + size_t mTotalDroppedFrames; + + static const char* kPropertyNames[]; +}; + +}; // namespace android + +#endif /*SCREENRECORD_OVERLAY_H*/ |