1 /*
2  * Copyright (C) Texas Instruments - http://www.ti.com/
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 
18 
19 #include "CameraHal.h"
20 #include <ui/GraphicBufferMapper.h>
21 #include <hal_public.h>
22 
23 namespace Ti {
24 namespace Camera {
25 
26 /**
27  * Display handler class - This class basically handles the buffer posting to display
28  */
29 
30 class ANativeWindowDisplayAdapter : public DisplayAdapter
31 {
32 public:
33 
34     typedef struct
35         {
36         CameraBuffer *mBuffer;
37         void *mUser;
38         int mOffset;
39         int mWidth;
40         int mHeight;
41         int mWidthStride;
42         int mHeightStride;
43         int mLength;
44         CameraFrame::FrameType mType;
45         } DisplayFrame;
46 
47     enum DisplayStates
48         {
49         DISPLAY_INIT = 0,
50         DISPLAY_STARTED,
51         DISPLAY_STOPPED,
52         DISPLAY_EXITED
53         };
54 
55 public:
56 
57     ANativeWindowDisplayAdapter();
58     virtual ~ANativeWindowDisplayAdapter();
59 
60     ///Initializes the display adapter creates any resources required
61     virtual status_t initialize();
62 
63     virtual int setPreviewWindow(struct preview_stream_ops *window);
64     virtual int setFrameProvider(FrameNotifier *frameProvider);
65     virtual int setErrorHandler(ErrorNotifier *errorNotifier);
66     virtual int enableDisplay(int width, int height, struct timeval *refTime = NULL);
67     virtual int disableDisplay(bool cancel_buffer = true);
68     virtual status_t pauseDisplay(bool pause);
69 
70 #if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
71 
72     //Used for shot to snapshot measurement
73     virtual status_t setSnapshotTimeRef(struct timeval *refTime = NULL);
74 
75 #endif
76 
77     virtual bool supportsExternalBuffering();
78 
79     //Implementation of inherited interfaces
80     virtual CameraBuffer * allocateBufferList(int width, int height, const char* format, int &bytes, int numBufs);
81     virtual CameraBuffer *getBufferList(int *numBufs);
82     virtual uint32_t * getOffsets() ;
83     virtual int getFd() ;
84     virtual int freeBufferList(CameraBuffer * buflist);
85 
86     virtual status_t maxQueueableBuffers(unsigned int& queueable);
87     virtual status_t minUndequeueableBuffers(int& unqueueable);
88 
89     ///Class specific functions
90     static void frameCallbackRelay(CameraFrame* caFrame);
91     void frameCallback(CameraFrame* caFrame);
92 
93     void displayThread();
94 
95     private:
96     void destroy();
97     bool processHalMsg();
98     status_t PostFrame(ANativeWindowDisplayAdapter::DisplayFrame &dispFrame);
99     bool handleFrameReturn();
100     status_t returnBuffersToWindow();
101 
102 public:
103 
104     static const int DISPLAY_TIMEOUT;
105     static const int FAILED_DQS_TO_SUSPEND;
106 
107     class DisplayThread : public android::Thread
108         {
109         ANativeWindowDisplayAdapter* mDisplayAdapter;
110         Utils::MessageQueue mDisplayThreadQ;
111 
112         public:
DisplayThread(ANativeWindowDisplayAdapter * da)113             DisplayThread(ANativeWindowDisplayAdapter* da)
114             : Thread(false), mDisplayAdapter(da) { }
115 
116         ///Returns a reference to the display message Q for display adapter to post messages
msgQ()117             Utils::MessageQueue& msgQ()
118                 {
119                 return mDisplayThreadQ;
120                 }
121 
threadLoop()122             virtual bool threadLoop()
123                 {
124                 mDisplayAdapter->displayThread();
125                 return false;
126                 }
127 
128             enum DisplayThreadCommands
129                 {
130                 DISPLAY_START,
131                 DISPLAY_STOP,
132                 DISPLAY_FRAME,
133                 DISPLAY_EXIT
134                 };
135         };
136 
137     //friend declarations
138 friend class DisplayThread;
139 
140 private:
141     int postBuffer(void* displayBuf);
142 
143 private:
144     bool mFirstInit;
145     bool mSuspend;
146     int mFailedDQs;
147     bool mPaused; //Pause state
148     preview_stream_ops_t*  mANativeWindow;
149     android::sp<DisplayThread> mDisplayThread;
150     FrameProvider *mFrameProvider; ///Pointer to the frame provider interface
151     Utils::MessageQueue mDisplayQ;
152     unsigned int mDisplayState;
153     ///@todo Have a common class for these members
154     mutable android::Mutex mLock;
155     bool mDisplayEnabled;
156     int mBufferCount;
157     CameraBuffer *mBuffers;
158     //buffer_handle_t** mBufferHandleMap; // -> frames[i].BufferHandle
159     //IMG_native_handle_t** mGrallocHandleMap; // -> frames[i].GrallocHandle
160     uint32_t* mOffsetsMap; // -> frames[i].Offset
161     int mFD;
162     android::KeyedVector<buffer_handle_t *, int> mFramesWithCameraAdapterMap;
163     android::KeyedVector<int, int> mFramesType;
164     android::sp<ErrorNotifier> mErrorNotifier;
165 
166     uint32_t mFrameWidth;
167     uint32_t mFrameHeight;
168     uint32_t mPreviewWidth;
169     uint32_t mPreviewHeight;
170 
171     uint32_t mXOff;
172     uint32_t mYOff;
173 
174     const char *mPixelFormat;
175 
176 #if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
177     //Used for calculating standby to first shot
178     struct timeval mStandbyToShot;
179     bool mMeasureStandby;
180     //Used for shot to snapshot/shot calculation
181     struct timeval mStartCapture;
182     bool mShotToShot;
183 
184 #endif
185 
186 };
187 
188 } // namespace Camera
189 } // namespace Ti
190