1 /*
2 ** Copyright (c) 2012 The Linux Foundation. All rights reserved.
3 **
4 ** Not a Contribution, Apache license notifications and license are retained
5 ** for attribution purposes only.
6 **
7 ** Licensed under the Apache License, Version 2.0 (the "License");
8 ** you may not use this file except in compliance with the License.
9 ** You may obtain a copy of the License at
10 **
11 ** http://www.apache.org/licenses/LICENSE-2.0
12 **
13 ** Unless required by applicable law or agreed to in writing, software
14 ** distributed under the License is distributed on an "AS IS" BASIS,
15 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 ** See the License for the specific language governing permissions and
17 ** limitations under the License.
18 */
19
20 /*#error uncomment this for compiler test!*/
21
22 #define LOG_NDEBUG 0
23 #define LOG_NDDEBUG 0
24 #define LOG_NIDEBUG 0
25 #define LOG_TAG "QCameraHWI_Still"
26 #include <utils/Log.h>
27 #include <utils/threads.h>
28 #include <fcntl.h>
29 #include <sys/mman.h>
30 #include <media/mediarecorder.h>
31 #include <math.h>
32 #include "QCameraHAL.h"
33 #include "QCameraHWI.h"
34 #include "mm_jpeg_interface.h"
35
36
37 /* following code implement the still image capture & encoding logic of this class*/
38 namespace android {
39
40 QCameraStream_SnapshotMain::
QCameraStream_SnapshotMain(uint32_t CameraHandle,uint32_t ChannelId,uint32_t Width,uint32_t Height,uint32_t Format,uint8_t NumBuffers,mm_camera_vtbl_t * mm_ops,mm_camera_img_mode imgmode,camera_mode_t mode,QCameraHardwareInterface * camCtrl)41 QCameraStream_SnapshotMain(uint32_t CameraHandle,
42 uint32_t ChannelId,
43 uint32_t Width,
44 uint32_t Height,
45 uint32_t Format,
46 uint8_t NumBuffers,
47 mm_camera_vtbl_t *mm_ops,
48 mm_camera_img_mode imgmode,
49 camera_mode_t mode,
50 QCameraHardwareInterface* camCtrl)
51 :QCameraStream(CameraHandle,
52 ChannelId,
53 Width,
54 Height,
55 Format,
56 NumBuffers,
57 mm_ops,
58 imgmode,
59 mode,
60 camCtrl)
61 {
62 }
63
~QCameraStream_SnapshotMain()64 QCameraStream_SnapshotMain::~QCameraStream_SnapshotMain()
65 {
66 release();
67 }
68
release()69 void QCameraStream_SnapshotMain::release()
70 {
71 streamOff(0);
72 deinitStream();
73
74 }
75
initStream(uint8_t no_cb_needed,uint8_t stream_on)76 status_t QCameraStream_SnapshotMain::initStream(uint8_t no_cb_needed, uint8_t stream_on)
77 {
78 status_t ret = NO_ERROR;
79
80 if(mHalCamCtrl->isZSLMode()) {
81 mNumBuffers = mHalCamCtrl->getZSLQueueDepth() + 3;
82 } else if (mHalCamCtrl->mHdrInfo.hdr_on) {
83 mNumBuffers = mHalCamCtrl->mHdrInfo.num_frame;
84 } else {
85 mNumBuffers = mHalCamCtrl->getNumOfSnapshots();
86 }
87 ret = QCameraStream::initStream(no_cb_needed, stream_on);
88 return ret;;
89 }
90
getBuf(mm_camera_frame_len_offset * frame_offset_info,uint8_t num_bufs,uint8_t * initial_reg_flag,mm_camera_buf_def_t * bufs)91 int QCameraStream_SnapshotMain::getBuf(mm_camera_frame_len_offset *frame_offset_info,
92 uint8_t num_bufs,
93 uint8_t *initial_reg_flag,
94 mm_camera_buf_def_t *bufs)
95 {
96 int ret = MM_CAMERA_OK;
97 ALOGE("%s : E", __func__);
98
99 if (mNumBuffers < num_bufs) {
100 mNumBuffers = num_bufs;
101 }
102 if ((mNumBuffers == 0) || (mNumBuffers > MM_CAMERA_MAX_NUM_FRAMES)) {
103 ALOGE("%s: Invalid number of buffers (=%d) requested!",
104 __func__, mNumBuffers);
105 return BAD_VALUE;
106 }
107
108 memset(mSnapshotStreamBuf, 0, sizeof(mSnapshotStreamBuf));
109 memcpy(&mFrameOffsetInfo, frame_offset_info, sizeof(mFrameOffsetInfo));
110 ret = mHalCamCtrl->initHeapMem(&mHalCamCtrl->mSnapshotMemory,
111 mNumBuffers,
112 mFrameOffsetInfo.frame_len,
113 MSM_PMEM_MAINIMG,
114 &mFrameOffsetInfo,
115 mSnapshotStreamBuf);
116
117 if(MM_CAMERA_OK == ret) {
118 for(int i = 0; i < num_bufs; i++) {
119 bufs[i] = mSnapshotStreamBuf[i];
120 initial_reg_flag[i] = (TRUE == m_flag_stream_on)? TRUE : FALSE;
121 }
122 }
123
124 /* If we have reached here successfully, we have allocated buffer.
125 Set state machine.*/
126 ALOGD("%s: X", __func__);
127 return ret;
128
129 }
130
putBuf(uint8_t num_bufs,mm_camera_buf_def_t * bufs)131 int QCameraStream_SnapshotMain::putBuf(uint8_t num_bufs, mm_camera_buf_def_t *bufs)
132 {
133 ALOGE("%s: Release Snapshot main Memory",__func__);
134 return mHalCamCtrl->releaseHeapMem(&mHalCamCtrl->mSnapshotMemory);
135 }
136
putBuf(uint8_t num_bufs,mm_camera_buf_def_t * bufs)137 int QCameraStream_SnapshotThumbnail::putBuf(uint8_t num_bufs, mm_camera_buf_def_t *bufs)
138 {
139 ALOGE("%s: Release Snapshot thumbnail Memory",__func__);
140 return mHalCamCtrl->releaseHeapMem(&mHalCamCtrl->mThumbnailMemory);
141 }
142
143 QCameraStream_SnapshotThumbnail::
QCameraStream_SnapshotThumbnail(uint32_t CameraHandle,uint32_t ChannelId,uint32_t Width,uint32_t Height,uint32_t Format,uint8_t NumBuffers,mm_camera_vtbl_t * mm_ops,mm_camera_img_mode imgmode,camera_mode_t mode,QCameraHardwareInterface * camCtrl)144 QCameraStream_SnapshotThumbnail(uint32_t CameraHandle,
145 uint32_t ChannelId,
146 uint32_t Width,
147 uint32_t Height,
148 uint32_t Format,
149 uint8_t NumBuffers,
150 mm_camera_vtbl_t *mm_ops,
151 mm_camera_img_mode imgmode,
152 camera_mode_t mode,
153 QCameraHardwareInterface* camCtrl)
154 :QCameraStream(CameraHandle,
155 ChannelId,
156 Width,
157 Height,
158 Format,
159 NumBuffers,
160 mm_ops,
161 imgmode,
162 mode,
163 camCtrl)
164 {
165
166 }
167
~QCameraStream_SnapshotThumbnail()168 QCameraStream_SnapshotThumbnail::~QCameraStream_SnapshotThumbnail()
169 {
170 release();
171 }
172
release()173 void QCameraStream_SnapshotThumbnail::release()
174 {
175 streamOff(0);
176 deinitStream();
177 }
178
initStream(uint8_t no_cb_needed,uint8_t stream_on)179 status_t QCameraStream_SnapshotThumbnail::initStream(uint8_t no_cb_needed, uint8_t stream_on)
180 {
181 status_t ret = NO_ERROR;
182
183 if(mHalCamCtrl->isZSLMode()) {
184 mNumBuffers = mHalCamCtrl->getZSLQueueDepth() + 3;
185 } else if (mHalCamCtrl->mHdrInfo.hdr_on) {
186 mNumBuffers = mHalCamCtrl->mHdrInfo.num_frame;
187 } else {
188 mNumBuffers = mHalCamCtrl->getNumOfSnapshots();
189 }
190 ret = QCameraStream::initStream(no_cb_needed, stream_on);
191 return ret;;
192 }
193
getBuf(mm_camera_frame_len_offset * frame_offset_info,uint8_t num_bufs,uint8_t * initial_reg_flag,mm_camera_buf_def_t * bufs)194 status_t QCameraStream_SnapshotThumbnail::getBuf(mm_camera_frame_len_offset *frame_offset_info,
195 uint8_t num_bufs,
196 uint8_t *initial_reg_flag,
197 mm_camera_buf_def_t *bufs)
198 {
199 int ret = MM_CAMERA_OK;
200
201 if (mNumBuffers < num_bufs) {
202 mNumBuffers = num_bufs;
203 }
204 if ((mNumBuffers == 0) || (mNumBuffers > MM_CAMERA_MAX_NUM_FRAMES)) {
205 ALOGE("%s: Invalid number of buffers (=%d) requested!",
206 __func__, mNumBuffers);
207 return BAD_VALUE;
208 }
209
210 memset(mPostviewStreamBuf, 0, sizeof(mPostviewStreamBuf));
211 memcpy(&mFrameOffsetInfo, frame_offset_info, sizeof(mFrameOffsetInfo));
212 ret = mHalCamCtrl->initHeapMem(
213 &mHalCamCtrl->mThumbnailMemory,
214 mNumBuffers,
215 mFrameOffsetInfo.frame_len,
216 MSM_PMEM_THUMBNAIL,
217 &mFrameOffsetInfo,
218 mPostviewStreamBuf);
219 if(MM_CAMERA_OK == ret) {
220 for(int i = 0; i < num_bufs; i++) {
221 bufs[i] = mPostviewStreamBuf[i];
222 initial_reg_flag[i] = true;
223 }
224 }
225
226 return ret;
227 }
228
229
230 }; // namespace android
231
232