1 /*
2 Copyright (c) 2012-2014, The Linux Foundation. All rights reserved.
3
4 Redistribution and use in source and binary forms, with or without
5 modification, are permitted provided that the following conditions are
6 met:
7 * Redistributions of source code must retain the above copyright
8 notice, this list of conditions and the following disclaimer.
9 * Redistributions in binary form must reproduce the above
10 copyright notice, this list of conditions and the following
11 disclaimer in the documentation and/or other materials provided
12 with the distribution.
13 * Neither the name of The Linux Foundation nor the names of its
14 contributors may be used to endorse or promote products derived
15 from this software without specific prior written permission.
16
17 THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
18 WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
19 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
20 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
21 BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
24 BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
25 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
26 OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
27 IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30 #include "mm_qcamera_dbg.h"
31 #include "mm_qcamera_app.h"
32 #include <assert.h>
33 #include <sys/mman.h>
34 #include <semaphore.h>
35
mm_app_metadata_notify_cb(mm_camera_super_buf_t * bufs,void * user_data)36 static void mm_app_metadata_notify_cb(mm_camera_super_buf_t *bufs,
37 void *user_data)
38 {
39 int i = 0;
40 mm_camera_channel_t *channel = NULL;
41 mm_camera_stream_t *p_stream = NULL;
42 mm_camera_test_obj_t *pme = (mm_camera_test_obj_t *)user_data;
43 mm_camera_buf_def_t *frame = bufs->bufs[0];
44 metadata_buffer_t *pMetadata;
45 cam_auto_focus_data_t *focus_data;
46
47 if (NULL == bufs || NULL == user_data) {
48 CDBG_ERROR("%s: bufs or user_data are not valid ", __func__);
49 return;
50 }
51
52 /* find channel */
53 for (i = 0; i < MM_CHANNEL_TYPE_MAX; i++) {
54 if (pme->channels[i].ch_id == bufs->ch_id) {
55 channel = &pme->channels[i];
56 break;
57 }
58 }
59 /* find preview stream */
60 for (i = 0; i < channel->num_streams; i++) {
61 if (channel->streams[i].s_config.stream_info->stream_type == CAM_STREAM_TYPE_METADATA) {
62 p_stream = &channel->streams[i];
63 break;
64 }
65 }
66 /* find preview frame */
67 for (i = 0; i < bufs->num_bufs; i++) {
68 if (bufs->bufs[i]->stream_id == p_stream->s_id) {
69 frame = bufs->bufs[i];
70 break;
71 }
72 }
73
74 if (NULL == p_stream) {
75 CDBG_ERROR("%s: cannot find metadata stream", __func__);
76 return;
77 }
78 if (pme->metadata == NULL) {
79 /* The app will free the meta data, we don't need to bother here */
80 pme->metadata = malloc(sizeof(metadata_buffer_t));
81 if (NULL == pme->metadata) {
82 CDBG_ERROR("%s: Canot allocate metadata memory\n", __func__);
83 return;
84 }
85 }
86 memcpy(pme->metadata, frame->buffer, sizeof(metadata_buffer_t));
87
88 pMetadata = (metadata_buffer_t *)frame->buffer;
89 if (IS_META_AVAILABLE(CAM_INTF_META_AUTOFOCUS_DATA, pMetadata)) {
90 focus_data = (cam_auto_focus_data_t *)
91 POINTER_OF_META(CAM_INTF_META_AUTOFOCUS_DATA, pMetadata);
92 if (focus_data->focus_state == CAM_AF_FOCUSED ||
93 focus_data->focus_state == CAM_AF_NOT_FOCUSED) {
94 CDBG_ERROR("%s: AutoFocus Done Call Back Received\n",__func__);
95 mm_camera_app_done();
96 } else if (focus_data->focus_state == CAM_AF_NOT_FOCUSED) {
97 CDBG_ERROR("%s: AutoFocus failed\n",__func__);
98 mm_camera_app_done();
99 }
100 }
101
102 if (MM_CAMERA_OK != pme->cam->ops->qbuf(bufs->camera_handle,
103 bufs->ch_id,
104 frame)) {
105 CDBG_ERROR("%s: Failed in Preview Qbuf\n", __func__);
106 }
107 mm_app_cache_ops((mm_camera_app_meminfo_t *)frame->mem_info,
108 ION_IOC_INV_CACHES);
109 }
110
mm_app_preview_notify_cb(mm_camera_super_buf_t * bufs,void * user_data)111 static void mm_app_preview_notify_cb(mm_camera_super_buf_t *bufs,
112 void *user_data)
113 {
114 int i = 0;
115 mm_camera_channel_t *channel = NULL;
116 mm_camera_stream_t *p_stream = NULL;
117 mm_camera_buf_def_t *frame = bufs->bufs[0];
118 mm_camera_test_obj_t *pme = (mm_camera_test_obj_t *)user_data;
119
120 CDBG_ERROR("%s: BEGIN - length=%d, frame idx = %d\n",
121 __func__, frame->frame_len, frame->frame_idx);
122
123 if (NULL == bufs || NULL == user_data) {
124 CDBG_ERROR("%s: bufs or user_data are not valid ", __func__);
125 return;
126 }
127
128 /* find channel */
129 for (i = 0; i < MM_CHANNEL_TYPE_MAX; i++) {
130 if (pme->channels[i].ch_id == bufs->ch_id) {
131 channel = &pme->channels[i];
132 break;
133 }
134 }
135 /* find preview stream */
136 for (i = 0; i < channel->num_streams; i++) {
137 if (channel->streams[i].s_config.stream_info->stream_type == CAM_STREAM_TYPE_PREVIEW) {
138 p_stream = &channel->streams[i];
139 break;
140 }
141 }
142 /* find preview frame */
143 for (i = 0; i < bufs->num_bufs; i++) {
144 if (bufs->bufs[i]->stream_id == p_stream->s_id) {
145 frame = bufs->bufs[i];
146 break;
147 }
148 }
149
150 if (NULL == p_stream) {
151 CDBG_ERROR("%s: cannot find preview stream", __func__);
152 return;
153 }
154
155 if ( 0 < pme->fb_fd ) {
156 mm_app_overlay_display(pme, frame->fd);
157 }
158 #ifdef DUMP_PRV_IN_FILE
159 {
160 char file_name[64];
161 snprintf(file_name, sizeof(file_name), "P_C%d", pme->cam->camera_handle);
162 mm_app_dump_frame(frame, file_name, "yuv", frame->frame_idx);
163 }
164 #endif
165 if (pme->user_preview_cb) {
166 CDBG_ERROR("[DBG] %s, user defined own preview cb. calling it...", __func__);
167 pme->user_preview_cb(frame);
168 }
169 if (MM_CAMERA_OK != pme->cam->ops->qbuf(bufs->camera_handle,
170 bufs->ch_id,
171 frame)) {
172 CDBG_ERROR("%s: Failed in Preview Qbuf\n", __func__);
173 }
174 mm_app_cache_ops((mm_camera_app_meminfo_t *)frame->mem_info,
175 ION_IOC_INV_CACHES);
176
177 CDBG("%s: END\n", __func__);
178 }
179
mm_app_zsl_notify_cb(mm_camera_super_buf_t * bufs,void * user_data)180 static void mm_app_zsl_notify_cb(mm_camera_super_buf_t *bufs,
181 void *user_data)
182 {
183 int rc = 0;
184 int i = 0;
185 mm_camera_test_obj_t *pme = (mm_camera_test_obj_t *)user_data;
186 mm_camera_channel_t *channel = NULL;
187 mm_camera_stream_t *p_stream = NULL;
188 mm_camera_stream_t *m_stream = NULL;
189 mm_camera_stream_t *md_stream = NULL;
190 mm_camera_buf_def_t *p_frame = NULL;
191 mm_camera_buf_def_t *m_frame = NULL;
192 mm_camera_buf_def_t *md_frame = NULL;
193
194 CDBG("%s: BEGIN\n", __func__);
195
196 if (NULL == bufs || NULL == user_data) {
197 CDBG_ERROR("%s: bufs or user_data are not valid ", __func__);
198 return;
199 }
200
201 /* find channel */
202 for (i = 0; i < MM_CHANNEL_TYPE_MAX; i++) {
203 if (pme->channels[i].ch_id == bufs->ch_id) {
204 channel = &pme->channels[i];
205 break;
206 }
207 }
208 if (NULL == channel) {
209 CDBG_ERROR("%s: Wrong channel id (%d)", __func__, bufs->ch_id);
210 return;
211 }
212
213 /* find preview stream */
214 for (i = 0; i < channel->num_streams; i++) {
215 if (channel->streams[i].s_config.stream_info->stream_type == CAM_STREAM_TYPE_PREVIEW) {
216 p_stream = &channel->streams[i];
217 break;
218 }
219 }
220 if (NULL == p_stream) {
221 CDBG_ERROR("%s: cannot find preview stream", __func__);
222 return;
223 }
224
225 /* find snapshot stream */
226 for (i = 0; i < channel->num_streams; i++) {
227 if (channel->streams[i].s_config.stream_info->stream_type == CAM_STREAM_TYPE_SNAPSHOT) {
228 m_stream = &channel->streams[i];
229 break;
230 }
231 }
232 if (NULL == m_stream) {
233 CDBG_ERROR("%s: cannot find snapshot stream", __func__);
234 return;
235 }
236
237 /* find metadata stream */
238 for (i = 0; i < channel->num_streams; i++) {
239 if (channel->streams[i].s_config.stream_info->stream_type == CAM_STREAM_TYPE_METADATA) {
240 md_stream = &channel->streams[i];
241 break;
242 }
243 }
244 if (NULL == md_stream) {
245 CDBG_ERROR("%s: cannot find metadata stream", __func__);
246 }
247
248 /* find preview frame */
249 for (i = 0; i < bufs->num_bufs; i++) {
250 if (bufs->bufs[i]->stream_id == p_stream->s_id) {
251 p_frame = bufs->bufs[i];
252 break;
253 }
254 }
255
256 if(md_stream) {
257 /* find metadata frame */
258 for (i = 0; i < bufs->num_bufs; i++) {
259 if (bufs->bufs[i]->stream_id == md_stream->s_id) {
260 md_frame = bufs->bufs[i];
261 break;
262 }
263 }
264 if (!pme->metadata) {
265 /* App will free the metadata */
266 pme->metadata = malloc(sizeof(metadata_buffer_t));
267 }
268 memcpy(pme->metadata , md_frame->buffer, sizeof(metadata_buffer_t));
269 }
270 /* find snapshot frame */
271 for (i = 0; i < bufs->num_bufs; i++) {
272 if (bufs->bufs[i]->stream_id == m_stream->s_id) {
273 m_frame = bufs->bufs[i];
274 break;
275 }
276 }
277
278 if (!m_frame || !p_frame) {
279 CDBG_ERROR("%s: cannot find preview/snapshot frame", __func__);
280 return;
281 }
282
283 CDBG("%s: ZSL CB with fb_fd = %d, m_frame = 0x%x, p_frame = 0x%x \n",
284 __func__,
285 pme->fb_fd,
286 (uint32_t )m_frame,
287 (uint32_t )p_frame);
288
289 if ( 0 < pme->fb_fd ) {
290 mm_app_overlay_display(pme, p_frame->fd);
291 }/* else {
292 mm_app_dump_frame(p_frame, "zsl_preview", "yuv", p_frame->frame_idx);
293 mm_app_dump_frame(m_frame, "zsl_main", "yuv", m_frame->frame_idx);
294 }*/
295
296 if ( pme->enable_reproc && ( NULL != pme->reproc_stream ) ) {
297 rc = mm_app_do_reprocess(pme,
298 m_frame,
299 md_frame->buf_idx,
300 bufs,
301 md_stream);
302 if (MM_CAMERA_OK != rc ) {
303 CDBG_ERROR("%s: reprocess failed rc = %d", __func__, rc);
304 }
305
306 return;
307 }
308
309 if ( pme->encodeJpeg ) {
310 pme->jpeg_buf.buf.buffer = (uint8_t *)malloc(m_frame->frame_len);
311 if ( NULL == pme->jpeg_buf.buf.buffer ) {
312 CDBG_ERROR("%s: error allocating jpeg output buffer", __func__);
313 goto exit;
314 }
315
316 pme->jpeg_buf.buf.frame_len = m_frame->frame_len;
317 /* create a new jpeg encoding session */
318 rc = createEncodingSession(pme, m_stream, m_frame);
319 if (0 != rc) {
320 CDBG_ERROR("%s: error creating jpeg session", __func__);
321 free(pme->jpeg_buf.buf.buffer);
322 goto exit;
323 }
324
325 /* start jpeg encoding job */
326 rc = encodeData(pme, bufs, m_stream);
327 pme->encodeJpeg = 0;
328 } else {
329 if (MM_CAMERA_OK != pme->cam->ops->qbuf(bufs->camera_handle,
330 bufs->ch_id,
331 m_frame)) {
332 CDBG_ERROR("%s: Failed in main Qbuf\n", __func__);
333 }
334 mm_app_cache_ops((mm_camera_app_meminfo_t *)m_frame->mem_info,
335 ION_IOC_INV_CACHES);
336 }
337
338 exit:
339
340 if (MM_CAMERA_OK != pme->cam->ops->qbuf(bufs->camera_handle,
341 bufs->ch_id,
342 p_frame)) {
343 CDBG_ERROR("%s: Failed in preview Qbuf\n", __func__);
344 }
345 mm_app_cache_ops((mm_camera_app_meminfo_t *)p_frame->mem_info,
346 ION_IOC_INV_CACHES);
347
348 if(md_frame) {
349 if (MM_CAMERA_OK != pme->cam->ops->qbuf(bufs->camera_handle,
350 bufs->ch_id,
351 md_frame)) {
352 CDBG_ERROR("%s: Failed in metadata Qbuf\n", __func__);
353 }
354 mm_app_cache_ops((mm_camera_app_meminfo_t *)md_frame->mem_info,
355 ION_IOC_INV_CACHES);
356 }
357
358 CDBG("%s: END\n", __func__);
359 }
360
mm_app_add_metadata_stream(mm_camera_test_obj_t * test_obj,mm_camera_channel_t * channel,mm_camera_buf_notify_t stream_cb,void * userdata,uint8_t num_bufs)361 mm_camera_stream_t * mm_app_add_metadata_stream(mm_camera_test_obj_t *test_obj,
362 mm_camera_channel_t *channel,
363 mm_camera_buf_notify_t stream_cb,
364 void *userdata,
365 uint8_t num_bufs)
366 {
367 int rc = MM_CAMERA_OK;
368 mm_camera_stream_t *stream = NULL;
369 cam_capability_t *cam_cap = (cam_capability_t *)(test_obj->cap_buf.buf.buffer);
370
371 stream = mm_app_add_stream(test_obj, channel);
372 if (NULL == stream) {
373 CDBG_ERROR("%s: add stream failed\n", __func__);
374 return NULL;
375 }
376
377 stream->s_config.mem_vtbl.get_bufs = mm_app_stream_initbuf;
378 stream->s_config.mem_vtbl.put_bufs = mm_app_stream_deinitbuf;
379 stream->s_config.mem_vtbl.clean_invalidate_buf =
380 mm_app_stream_clean_invalidate_buf;
381 stream->s_config.mem_vtbl.invalidate_buf = mm_app_stream_invalidate_buf;
382 stream->s_config.mem_vtbl.user_data = (void *)stream;
383 stream->s_config.stream_cb = stream_cb;
384 stream->s_config.userdata = userdata;
385 stream->num_of_bufs = num_bufs;
386
387 stream->s_config.stream_info = (cam_stream_info_t *)stream->s_info_buf.buf.buffer;
388 memset(stream->s_config.stream_info, 0, sizeof(cam_stream_info_t));
389 stream->s_config.stream_info->stream_type = CAM_STREAM_TYPE_METADATA;
390 stream->s_config.stream_info->streaming_mode = CAM_STREAMING_MODE_CONTINUOUS;
391 stream->s_config.stream_info->fmt = DEFAULT_PREVIEW_FORMAT;
392 stream->s_config.stream_info->dim.width = sizeof(metadata_buffer_t);
393 stream->s_config.stream_info->dim.height = 1;
394 stream->s_config.padding_info = cam_cap->padding_info;
395
396 rc = mm_app_config_stream(test_obj, channel, stream, &stream->s_config);
397 if (MM_CAMERA_OK != rc) {
398 CDBG_ERROR("%s:config preview stream err=%d\n", __func__, rc);
399 return NULL;
400 }
401
402 return stream;
403 }
404
mm_app_add_preview_stream(mm_camera_test_obj_t * test_obj,mm_camera_channel_t * channel,mm_camera_buf_notify_t stream_cb,void * userdata,uint8_t num_bufs)405 mm_camera_stream_t * mm_app_add_preview_stream(mm_camera_test_obj_t *test_obj,
406 mm_camera_channel_t *channel,
407 mm_camera_buf_notify_t stream_cb,
408 void *userdata,
409 uint8_t num_bufs)
410 {
411 int rc = MM_CAMERA_OK;
412 mm_camera_stream_t *stream = NULL;
413 cam_capability_t *cam_cap = (cam_capability_t *)(test_obj->cap_buf.buf.buffer);
414
415 stream = mm_app_add_stream(test_obj, channel);
416 if (NULL == stream) {
417 CDBG_ERROR("%s: add stream failed\n", __func__);
418 return NULL;
419 }
420 stream->s_config.mem_vtbl.get_bufs = mm_app_stream_initbuf;
421 stream->s_config.mem_vtbl.put_bufs = mm_app_stream_deinitbuf;
422 stream->s_config.mem_vtbl.clean_invalidate_buf =
423 mm_app_stream_clean_invalidate_buf;
424 stream->s_config.mem_vtbl.invalidate_buf = mm_app_stream_invalidate_buf;
425 stream->s_config.mem_vtbl.user_data = (void *)stream;
426 stream->s_config.stream_cb = stream_cb;
427 stream->s_config.userdata = userdata;
428 stream->num_of_bufs = num_bufs;
429
430 stream->s_config.stream_info = (cam_stream_info_t *)stream->s_info_buf.buf.buffer;
431 memset(stream->s_config.stream_info, 0, sizeof(cam_stream_info_t));
432 stream->s_config.stream_info->stream_type = CAM_STREAM_TYPE_PREVIEW;
433 stream->s_config.stream_info->streaming_mode = CAM_STREAMING_MODE_CONTINUOUS;
434 stream->s_config.stream_info->fmt = DEFAULT_PREVIEW_FORMAT;
435
436 if ((test_obj->preview_resolution.user_input_display_width == 0) ||
437 ( test_obj->preview_resolution.user_input_display_height == 0)) {
438 stream->s_config.stream_info->dim.width = DEFAULT_PREVIEW_WIDTH;
439 stream->s_config.stream_info->dim.height = DEFAULT_PREVIEW_HEIGHT;
440 } else {
441 stream->s_config.stream_info->dim.width = test_obj->preview_resolution.user_input_display_width;
442 stream->s_config.stream_info->dim.height = test_obj->preview_resolution.user_input_display_height;
443 }
444
445 stream->s_config.padding_info = cam_cap->padding_info;
446
447 rc = mm_app_config_stream(test_obj, channel, stream, &stream->s_config);
448 if (MM_CAMERA_OK != rc) {
449 CDBG_ERROR("%s:config preview stream err=%d\n", __func__, rc);
450 return NULL;
451 }
452
453 return stream;
454 }
455
mm_app_add_raw_stream(mm_camera_test_obj_t * test_obj,mm_camera_channel_t * channel,mm_camera_buf_notify_t stream_cb,void * userdata,uint8_t num_bufs,uint8_t num_burst)456 mm_camera_stream_t * mm_app_add_raw_stream(mm_camera_test_obj_t *test_obj,
457 mm_camera_channel_t *channel,
458 mm_camera_buf_notify_t stream_cb,
459 void *userdata,
460 uint8_t num_bufs,
461 uint8_t num_burst)
462 {
463 int rc = MM_CAMERA_OK;
464 mm_camera_stream_t *stream = NULL;
465 cam_capability_t *cam_cap = (cam_capability_t *)(test_obj->cap_buf.buf.buffer);
466
467 stream = mm_app_add_stream(test_obj, channel);
468 if (NULL == stream) {
469 CDBG_ERROR("%s: add stream failed\n", __func__);
470 return NULL;
471 }
472
473 stream->s_config.mem_vtbl.get_bufs = mm_app_stream_initbuf;
474 stream->s_config.mem_vtbl.put_bufs = mm_app_stream_deinitbuf;
475 stream->s_config.mem_vtbl.invalidate_buf = mm_app_stream_invalidate_buf;
476 stream->s_config.mem_vtbl.user_data = (void *)stream;
477 stream->s_config.stream_cb = stream_cb;
478 stream->s_config.userdata = userdata;
479 stream->num_of_bufs = num_bufs;
480
481 stream->s_config.stream_info = (cam_stream_info_t *)stream->s_info_buf.buf.buffer;
482 memset(stream->s_config.stream_info, 0, sizeof(cam_stream_info_t));
483 stream->s_config.stream_info->stream_type = CAM_STREAM_TYPE_RAW;
484 if (num_burst == 0) {
485 stream->s_config.stream_info->streaming_mode = CAM_STREAMING_MODE_CONTINUOUS;
486 } else {
487 stream->s_config.stream_info->streaming_mode = CAM_STREAMING_MODE_BURST;
488 stream->s_config.stream_info->num_of_burst = num_burst;
489 }
490 stream->s_config.stream_info->fmt = test_obj->buffer_format;
491 if ( test_obj->buffer_width == 0 || test_obj->buffer_height == 0 ) {
492 stream->s_config.stream_info->dim.width = DEFAULT_SNAPSHOT_WIDTH;
493 stream->s_config.stream_info->dim.height = DEFAULT_SNAPSHOT_HEIGHT;
494 } else {
495 stream->s_config.stream_info->dim.width = test_obj->buffer_width;
496 stream->s_config.stream_info->dim.height = test_obj->buffer_height;
497 }
498 stream->s_config.padding_info = cam_cap->padding_info;
499
500 rc = mm_app_config_stream(test_obj, channel, stream, &stream->s_config);
501 if (MM_CAMERA_OK != rc) {
502 CDBG_ERROR("%s:config preview stream err=%d\n", __func__, rc);
503 return NULL;
504 }
505
506 return stream;
507 }
508
mm_app_add_snapshot_stream(mm_camera_test_obj_t * test_obj,mm_camera_channel_t * channel,mm_camera_buf_notify_t stream_cb,void * userdata,uint8_t num_bufs,uint8_t num_burst)509 mm_camera_stream_t * mm_app_add_snapshot_stream(mm_camera_test_obj_t *test_obj,
510 mm_camera_channel_t *channel,
511 mm_camera_buf_notify_t stream_cb,
512 void *userdata,
513 uint8_t num_bufs,
514 uint8_t num_burst)
515 {
516 int rc = MM_CAMERA_OK;
517 mm_camera_stream_t *stream = NULL;
518 cam_capability_t *cam_cap = (cam_capability_t *)(test_obj->cap_buf.buf.buffer);
519
520 stream = mm_app_add_stream(test_obj, channel);
521 if (NULL == stream) {
522 CDBG_ERROR("%s: add stream failed\n", __func__);
523 return NULL;
524 }
525
526 stream->s_config.mem_vtbl.get_bufs = mm_app_stream_initbuf;
527 stream->s_config.mem_vtbl.put_bufs = mm_app_stream_deinitbuf;
528 stream->s_config.mem_vtbl.clean_invalidate_buf =
529 mm_app_stream_clean_invalidate_buf;
530 stream->s_config.mem_vtbl.invalidate_buf = mm_app_stream_invalidate_buf;
531 stream->s_config.mem_vtbl.user_data = (void *)stream;
532 stream->s_config.stream_cb = stream_cb;
533 stream->s_config.userdata = userdata;
534 stream->num_of_bufs = num_bufs;
535
536 stream->s_config.stream_info = (cam_stream_info_t *)stream->s_info_buf.buf.buffer;
537 memset(stream->s_config.stream_info, 0, sizeof(cam_stream_info_t));
538 stream->s_config.stream_info->stream_type = CAM_STREAM_TYPE_SNAPSHOT;
539 if (num_burst == 0) {
540 stream->s_config.stream_info->streaming_mode = CAM_STREAMING_MODE_CONTINUOUS;
541 } else {
542 stream->s_config.stream_info->streaming_mode = CAM_STREAMING_MODE_BURST;
543 stream->s_config.stream_info->num_of_burst = num_burst;
544 }
545 stream->s_config.stream_info->fmt = DEFAULT_SNAPSHOT_FORMAT;
546 if ( test_obj->buffer_width == 0 || test_obj->buffer_height == 0 ) {
547 stream->s_config.stream_info->dim.width = DEFAULT_SNAPSHOT_WIDTH;
548 stream->s_config.stream_info->dim.height = DEFAULT_SNAPSHOT_HEIGHT;
549 } else {
550 stream->s_config.stream_info->dim.width = test_obj->buffer_width;
551 stream->s_config.stream_info->dim.height = test_obj->buffer_height;
552 }
553 stream->s_config.padding_info = cam_cap->padding_info;
554
555 rc = mm_app_config_stream(test_obj, channel, stream, &stream->s_config);
556 if (MM_CAMERA_OK != rc) {
557 CDBG_ERROR("%s:config preview stream err=%d\n", __func__, rc);
558 return NULL;
559 }
560
561 return stream;
562 }
563
mm_app_add_preview_channel(mm_camera_test_obj_t * test_obj)564 mm_camera_channel_t * mm_app_add_preview_channel(mm_camera_test_obj_t *test_obj)
565 {
566 mm_camera_channel_t *channel = NULL;
567 mm_camera_stream_t *stream = NULL;
568
569 channel = mm_app_add_channel(test_obj,
570 MM_CHANNEL_TYPE_PREVIEW,
571 NULL,
572 NULL,
573 NULL);
574 if (NULL == channel) {
575 CDBG_ERROR("%s: add channel failed", __func__);
576 return NULL;
577 }
578
579 stream = mm_app_add_preview_stream(test_obj,
580 channel,
581 mm_app_preview_notify_cb,
582 (void *)test_obj,
583 PREVIEW_BUF_NUM);
584 if (NULL == stream) {
585 CDBG_ERROR("%s: add stream failed\n", __func__);
586 mm_app_del_channel(test_obj, channel);
587 return NULL;
588 }
589
590 return channel;
591 }
592
mm_app_stop_and_del_channel(mm_camera_test_obj_t * test_obj,mm_camera_channel_t * channel)593 int mm_app_stop_and_del_channel(mm_camera_test_obj_t *test_obj,
594 mm_camera_channel_t *channel)
595 {
596 int rc = MM_CAMERA_OK;
597 mm_camera_stream_t *stream = NULL;
598 uint8_t i;
599
600 rc = mm_app_stop_channel(test_obj, channel);
601 if (MM_CAMERA_OK != rc) {
602 CDBG_ERROR("%s:Stop Preview failed rc=%d\n", __func__, rc);
603 }
604
605 if (channel->num_streams <= MAX_STREAM_NUM_IN_BUNDLE) {
606 for (i = 0; i < channel->num_streams; i++) {
607 stream = &channel->streams[i];
608 rc = mm_app_del_stream(test_obj, channel, stream);
609 if (MM_CAMERA_OK != rc) {
610 CDBG_ERROR("%s:del stream(%d) failed rc=%d\n", __func__, i, rc);
611 }
612 }
613 } else {
614 CDBG_ERROR("%s: num_streams = %d. Should not be more than %d\n",
615 __func__, channel->num_streams, MAX_STREAM_NUM_IN_BUNDLE);
616 }
617 rc = mm_app_del_channel(test_obj, channel);
618 if (MM_CAMERA_OK != rc) {
619 CDBG_ERROR("%s:delete channel failed rc=%d\n", __func__, rc);
620 }
621
622 return rc;
623 }
624
mm_app_start_preview(mm_camera_test_obj_t * test_obj)625 int mm_app_start_preview(mm_camera_test_obj_t *test_obj)
626 {
627 int rc = MM_CAMERA_OK;
628 mm_camera_channel_t *channel = NULL;
629 mm_camera_stream_t *stream = NULL;
630 mm_camera_stream_t *s_metadata = NULL;
631 uint8_t i;
632
633 channel = mm_app_add_preview_channel(test_obj);
634 if (NULL == channel) {
635 CDBG_ERROR("%s: add channel failed", __func__);
636 return -MM_CAMERA_E_GENERAL;
637 }
638
639 s_metadata = mm_app_add_metadata_stream(test_obj,
640 channel,
641 mm_app_metadata_notify_cb,
642 (void *)test_obj,
643 PREVIEW_BUF_NUM);
644 if (NULL == s_metadata) {
645 CDBG_ERROR("%s: add metadata stream failed\n", __func__);
646 mm_app_del_channel(test_obj, channel);
647 return rc;
648 }
649
650 rc = mm_app_start_channel(test_obj, channel);
651 if (MM_CAMERA_OK != rc) {
652 CDBG_ERROR("%s:start preview failed rc=%d\n", __func__, rc);
653 if (channel->num_streams <= MAX_STREAM_NUM_IN_BUNDLE) {
654 for (i = 0; i < channel->num_streams; i++) {
655 stream = &channel->streams[i];
656 mm_app_del_stream(test_obj, channel, stream);
657 }
658 }
659 mm_app_del_channel(test_obj, channel);
660 return rc;
661 }
662
663 return rc;
664 }
665
mm_app_stop_preview(mm_camera_test_obj_t * test_obj)666 int mm_app_stop_preview(mm_camera_test_obj_t *test_obj)
667 {
668 int rc = MM_CAMERA_OK;
669
670 mm_camera_channel_t *channel =
671 mm_app_get_channel_by_type(test_obj, MM_CHANNEL_TYPE_PREVIEW);
672
673 rc = mm_app_stop_and_del_channel(test_obj, channel);
674 if (MM_CAMERA_OK != rc) {
675 CDBG_ERROR("%s:Stop Preview failed rc=%d\n", __func__, rc);
676 }
677
678 return rc;
679 }
680
mm_app_start_preview_zsl(mm_camera_test_obj_t * test_obj)681 int mm_app_start_preview_zsl(mm_camera_test_obj_t *test_obj)
682 {
683 int32_t rc = MM_CAMERA_OK;
684 mm_camera_channel_t *channel = NULL;
685 mm_camera_stream_t *s_preview = NULL;
686 mm_camera_stream_t *s_metadata = NULL;
687 mm_camera_stream_t *s_main = NULL;
688 mm_camera_channel_attr_t attr;
689
690 memset(&attr, 0, sizeof(mm_camera_channel_attr_t));
691 attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_CONTINUOUS;
692 attr.look_back = 2;
693 attr.post_frame_skip = 0;
694 attr.water_mark = 2;
695 attr.max_unmatched_frames = 3;
696 channel = mm_app_add_channel(test_obj,
697 MM_CHANNEL_TYPE_ZSL,
698 &attr,
699 mm_app_zsl_notify_cb,
700 test_obj);
701 if (NULL == channel) {
702 CDBG_ERROR("%s: add channel failed", __func__);
703 return -MM_CAMERA_E_GENERAL;
704 }
705
706 s_preview = mm_app_add_preview_stream(test_obj,
707 channel,
708 mm_app_preview_notify_cb,
709 (void *)test_obj,
710 PREVIEW_BUF_NUM);
711 if (NULL == s_preview) {
712 CDBG_ERROR("%s: add preview stream failed\n", __func__);
713 mm_app_del_channel(test_obj, channel);
714 return rc;
715 }
716
717 s_metadata = mm_app_add_metadata_stream(test_obj,
718 channel,
719 mm_app_metadata_notify_cb,
720 (void *)test_obj,
721 PREVIEW_BUF_NUM);
722 if (NULL == s_metadata) {
723 CDBG_ERROR("%s: add metadata stream failed\n", __func__);
724 mm_app_del_channel(test_obj, channel);
725 return rc;
726 }
727
728 s_main = mm_app_add_snapshot_stream(test_obj,
729 channel,
730 NULL,
731 NULL,
732 PREVIEW_BUF_NUM,
733 0);
734 if (NULL == s_main) {
735 CDBG_ERROR("%s: add main snapshot stream failed\n", __func__);
736 mm_app_del_stream(test_obj, channel, s_preview);
737 mm_app_del_channel(test_obj, channel);
738 return rc;
739 }
740
741 rc = mm_app_start_channel(test_obj, channel);
742 if (MM_CAMERA_OK != rc) {
743 CDBG_ERROR("%s:start zsl failed rc=%d\n", __func__, rc);
744 mm_app_del_stream(test_obj, channel, s_preview);
745 mm_app_del_stream(test_obj, channel, s_metadata);
746 mm_app_del_stream(test_obj, channel, s_main);
747 mm_app_del_channel(test_obj, channel);
748 return rc;
749 }
750
751 if ( test_obj->enable_reproc ) {
752 if ( NULL == mm_app_add_reprocess_channel(test_obj, s_main) ) {
753 CDBG_ERROR("%s: Reprocess channel failed to initialize \n", __func__);
754 mm_app_del_stream(test_obj, channel, s_preview);
755 #ifdef USE_METADATA_STREAM
756 mm_app_del_stream(test_obj, channel, s_metadata);
757 #endif
758 mm_app_del_stream(test_obj, channel, s_main);
759 mm_app_del_channel(test_obj, channel);
760 return rc;
761 }
762 rc = mm_app_start_reprocess(test_obj);
763 if (MM_CAMERA_OK != rc) {
764 CDBG_ERROR("%s: reprocess start failed rc=%d\n", __func__, rc);
765 mm_app_del_stream(test_obj, channel, s_preview);
766 #ifdef USE_METADATA_STREAM
767 mm_app_del_stream(test_obj, channel, s_metadata);
768 #endif
769 mm_app_del_stream(test_obj, channel, s_main);
770 mm_app_del_channel(test_obj, channel);
771 return rc;
772 }
773 }
774
775 return rc;
776 }
777
mm_app_stop_preview_zsl(mm_camera_test_obj_t * test_obj)778 int mm_app_stop_preview_zsl(mm_camera_test_obj_t *test_obj)
779 {
780 int rc = MM_CAMERA_OK;
781
782 mm_camera_channel_t *channel =
783 mm_app_get_channel_by_type(test_obj, MM_CHANNEL_TYPE_ZSL);
784
785 rc = mm_app_stop_and_del_channel(test_obj, channel);
786 if (MM_CAMERA_OK != rc) {
787 CDBG_ERROR("%s:Stop Preview failed rc=%d\n", __func__, rc);
788 }
789
790 if ( test_obj->enable_reproc ) {
791 rc |= mm_app_stop_reprocess(test_obj);
792 }
793
794 return rc;
795 }
796
mm_app_initialize_fb(mm_camera_test_obj_t * test_obj)797 int mm_app_initialize_fb(mm_camera_test_obj_t *test_obj)
798 {
799 int rc = MM_CAMERA_OK;
800 int brightness_fd;
801 const char brightness_level[] = BACKLIGHT_LEVEL;
802 void *fb_base = NULL;
803
804 assert( ( NULL != test_obj ) && ( 0 == test_obj->fb_fd ) );
805
806 test_obj->fb_fd = open(FB_PATH, O_RDWR);
807 if ( 0 > test_obj->fb_fd ) {
808 CDBG_ERROR("%s: FB device open failed rc=%d, %s\n",
809 __func__,
810 -errno,
811 strerror(errno));
812 rc = -errno;
813 goto FAIL;
814 }
815
816 rc = ioctl(test_obj->fb_fd, FBIOGET_VSCREENINFO, &test_obj->vinfo);
817 if ( MM_CAMERA_OK != rc ) {
818 CDBG_ERROR("%s: Can not retrieve screen info rc=%d, %s\n",
819 __func__,
820 -errno,
821 strerror(errno));
822 rc = -errno;
823 goto FAIL;
824 }
825
826 if ( ( 0 == test_obj->vinfo.yres_virtual ) ||
827 ( 0 == test_obj->vinfo.yres ) ||
828 ( test_obj->vinfo.yres > test_obj->vinfo.yres_virtual ) ) {
829 CDBG_ERROR("%s: Invalid FB virtual yres: %d, yres: %d\n",
830 __func__,
831 test_obj->vinfo.yres_virtual,
832 test_obj->vinfo.yres);
833 rc = MM_CAMERA_E_GENERAL;
834 goto FAIL;
835 }
836
837 if ( ( 0 == test_obj->vinfo.xres_virtual ) ||
838 ( 0 == test_obj->vinfo.xres ) ||
839 ( test_obj->vinfo.xres > test_obj->vinfo.xres_virtual ) ) {
840 CDBG_ERROR("%s: Invalid FB virtual xres: %d, xres: %d\n",
841 __func__,
842 test_obj->vinfo.xres_virtual,
843 test_obj->vinfo.xres);
844 rc = MM_CAMERA_E_GENERAL;
845 goto FAIL;
846 }
847
848 brightness_fd = open(BACKLIGHT_CONTROL, O_RDWR);
849 if ( brightness_fd >= 0 ) {
850 write(brightness_fd, brightness_level, strlen(brightness_level));
851 close(brightness_fd);
852 }
853
854 test_obj->slice_size = test_obj->vinfo.xres * ( test_obj->vinfo.yres - 1 ) * DEFAULT_OV_FORMAT_BPP;
855 memset(&test_obj->data_overlay, 0, sizeof(struct mdp_overlay));
856 test_obj->data_overlay.src.width = test_obj->buffer_width;
857 test_obj->data_overlay.src.height = test_obj->buffer_height;
858 test_obj->data_overlay.src_rect.w = test_obj->buffer_width;
859 test_obj->data_overlay.src_rect.h = test_obj->buffer_height;
860 test_obj->data_overlay.dst_rect.w = test_obj->buffer_width;
861 test_obj->data_overlay.dst_rect.h = test_obj->buffer_height;
862 test_obj->data_overlay.src.format = DEFAULT_OV_FORMAT;
863 test_obj->data_overlay.src_rect.x = 0;
864 test_obj->data_overlay.src_rect.y = 0;
865 test_obj->data_overlay.dst_rect.x = 0;
866 test_obj->data_overlay.dst_rect.y = 0;
867 test_obj->data_overlay.z_order = 2;
868 test_obj->data_overlay.alpha = 0x80;
869 test_obj->data_overlay.transp_mask = 0xffe0;
870 test_obj->data_overlay.flags = MDP_FLIP_LR | MDP_FLIP_UD;
871
872 // Map and clear FB portion
873 fb_base = mmap(0,
874 test_obj->slice_size,
875 PROT_WRITE,
876 MAP_SHARED,
877 test_obj->fb_fd,
878 0);
879 if ( MAP_FAILED == fb_base ) {
880 CDBG_ERROR("%s: ( Error while memory mapping frame buffer %s",
881 __func__,
882 strerror(errno));
883 rc = -errno;
884 goto FAIL;
885 }
886
887 memset(fb_base, 0, test_obj->slice_size);
888
889 if (ioctl(test_obj->fb_fd, FBIOPAN_DISPLAY, &test_obj->vinfo) < 0) {
890 CDBG_ERROR("%s : FBIOPAN_DISPLAY failed!", __func__);
891 rc = -errno;
892 goto FAIL;
893 }
894
895 munmap(fb_base, test_obj->slice_size);
896 test_obj->data_overlay.id = MSMFB_NEW_REQUEST;
897 rc = ioctl(test_obj->fb_fd, MSMFB_OVERLAY_SET, &test_obj->data_overlay);
898 if (rc < 0) {
899 CDBG_ERROR("%s : MSMFB_OVERLAY_SET failed! err=%d\n",
900 __func__,
901 test_obj->data_overlay.id);
902 return MM_CAMERA_E_GENERAL;
903 }
904 CDBG_ERROR("%s: Overlay set with overlay id: %d", __func__, test_obj->data_overlay.id);
905
906 return rc;
907
908 FAIL:
909
910 if ( 0 < test_obj->fb_fd ) {
911 close(test_obj->fb_fd);
912 }
913
914 return rc;
915 }
916
mm_app_close_fb(mm_camera_test_obj_t * test_obj)917 int mm_app_close_fb(mm_camera_test_obj_t *test_obj)
918 {
919 int rc = MM_CAMERA_OK;
920
921 assert( ( NULL != test_obj ) && ( 0 < test_obj->fb_fd ) );
922
923 if (ioctl(test_obj->fb_fd, MSMFB_OVERLAY_UNSET, &test_obj->data_overlay.id)) {
924 CDBG_ERROR("\nERROR! MSMFB_OVERLAY_UNSET failed! (Line %d)\n", __LINE__);
925 }
926
927 if (ioctl(test_obj->fb_fd, FBIOPAN_DISPLAY, &test_obj->vinfo) < 0) {
928 CDBG_ERROR("ERROR: FBIOPAN_DISPLAY failed! line=%d\n", __LINE__);
929 }
930
931 close(test_obj->fb_fd);
932 test_obj->fb_fd = 0;
933
934 return rc;
935 }
936
memset16(void * pDst,uint16_t value,int count)937 void memset16(void *pDst, uint16_t value, int count)
938 {
939 uint16_t *ptr = pDst;
940 while (count--)
941 *ptr++ = value;
942 }
943
mm_app_overlay_display(mm_camera_test_obj_t * test_obj,int bufferFd)944 int mm_app_overlay_display(mm_camera_test_obj_t *test_obj, int bufferFd)
945 {
946 int rc = MM_CAMERA_OK;
947 struct msmfb_overlay_data ovdata;
948
949
950 memset(&ovdata, 0, sizeof(struct msmfb_overlay_data));
951 ovdata.id = test_obj->data_overlay.id;
952 ovdata.data.memory_id = bufferFd;
953
954 if (ioctl(test_obj->fb_fd, MSMFB_OVERLAY_PLAY, &ovdata)) {
955 CDBG_ERROR("%s : MSMFB_OVERLAY_PLAY failed!", __func__);
956 return MM_CAMERA_E_GENERAL;
957 }
958
959 if (ioctl(test_obj->fb_fd, FBIOPAN_DISPLAY, &test_obj->vinfo) < 0) {
960 CDBG_ERROR("%s : FBIOPAN_DISPLAY failed!", __func__);
961 return MM_CAMERA_E_GENERAL;
962 }
963
964 return rc;
965 }
966