1 /*
2 Copyright (c) 2012-2016, 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 // System dependencies
31 #include <assert.h>
32 #include <errno.h>
33 #include <fcntl.h>
34 #define MMAN_H <SYSTEM_HEADER_PREFIX/mman.h>
35 #include MMAN_H
36
37 // Camera dependencies
38 #include "mm_qcamera_app.h"
39 #include "mm_qcamera_dbg.h"
40 #include "mm_qcamera_app.h"
41 #include <assert.h>
42 #include <sys/mman.h>
43 #include <semaphore.h>
44
mm_app_metadata_notify_cb(mm_camera_super_buf_t * bufs,void * user_data)45 static void mm_app_metadata_notify_cb(mm_camera_super_buf_t *bufs,
46 void *user_data)
47 {
48 uint32_t i = 0;
49 mm_camera_channel_t *channel = NULL;
50 mm_camera_stream_t *p_stream = NULL;
51 mm_camera_test_obj_t *pme = (mm_camera_test_obj_t *)user_data;
52 mm_camera_buf_def_t *frame;
53 metadata_buffer_t *pMetadata;
54
55 if (NULL == bufs || NULL == user_data) {
56 LOGE("bufs or user_data are not valid ");
57 return;
58 }
59 frame = bufs->bufs[0];
60
61 /* find channel */
62 for (i = 0; i < MM_CHANNEL_TYPE_MAX; i++) {
63 if (pme->channels[i].ch_id == bufs->ch_id) {
64 channel = &pme->channels[i];
65 break;
66 }
67 }
68
69 if (NULL == channel) {
70 LOGE("Channel object is NULL ");
71 return;
72 }
73
74 /* find preview stream */
75 for (i = 0; i < channel->num_streams; i++) {
76 if (channel->streams[i].s_config.stream_info->stream_type == CAM_STREAM_TYPE_METADATA) {
77 p_stream = &channel->streams[i];
78 break;
79 }
80 }
81
82 if (NULL == p_stream) {
83 LOGE("cannot find metadata stream");
84 return;
85 }
86
87 /* find preview frame */
88 for (i = 0; i < bufs->num_bufs; i++) {
89 if (bufs->bufs[i]->stream_id == p_stream->s_id) {
90 frame = bufs->bufs[i];
91 break;
92 }
93 }
94
95 if (pme->metadata == NULL) {
96 /* The app will free the meta data, we don't need to bother here */
97 pme->metadata = malloc(sizeof(metadata_buffer_t));
98 if (NULL == pme->metadata) {
99 LOGE("Canot allocate metadata memory\n");
100 return;
101 }
102 }
103 memcpy(pme->metadata, frame->buffer, sizeof(metadata_buffer_t));
104
105 pMetadata = (metadata_buffer_t *)frame->buffer;
106 IF_META_AVAILABLE(uint32_t, afState, CAM_INTF_META_AF_STATE, pMetadata) {
107 if ((cam_af_state_t)(*afState) == CAM_AF_STATE_FOCUSED_LOCKED ||
108 (cam_af_state_t)(*afState) == CAM_AF_STATE_NOT_FOCUSED_LOCKED) {
109 LOGE("AutoFocus Done Call Back Received\n");
110 mm_camera_app_done();
111 } else if ((cam_af_state_t)(*afState) == CAM_AF_STATE_NOT_FOCUSED_LOCKED) {
112 LOGE("AutoFocus failed\n");
113 mm_camera_app_done();
114 }
115 }
116
117 if (pme->user_metadata_cb) {
118 LOGD("[DBG] %s, user defined own metadata cb. calling it...");
119 pme->user_metadata_cb(frame);
120 }
121
122 if (MM_CAMERA_OK != pme->cam->ops->qbuf(bufs->camera_handle,
123 bufs->ch_id,
124 frame)) {
125 LOGE("Failed in Preview Qbuf\n");
126 }
127 mm_app_cache_ops((mm_camera_app_meminfo_t *)frame->mem_info,
128 ION_IOC_INV_CACHES);
129 }
130
mm_app_snapshot_notify_cb(mm_camera_super_buf_t * bufs,void * user_data)131 static void mm_app_snapshot_notify_cb(mm_camera_super_buf_t *bufs,
132 void *user_data)
133 {
134
135 int rc = 0;
136 uint32_t i = 0;
137 mm_camera_test_obj_t *pme = (mm_camera_test_obj_t *)user_data;
138 mm_camera_channel_t *channel = NULL;
139 mm_camera_stream_t *p_stream = NULL;
140 mm_camera_stream_t *m_stream = NULL;
141 mm_camera_buf_def_t *p_frame = NULL;
142 mm_camera_buf_def_t *m_frame = NULL;
143
144 /* find channel */
145 for (i = 0; i < MM_CHANNEL_TYPE_MAX; i++) {
146 if (pme->channels[i].ch_id == bufs->ch_id) {
147 channel = &pme->channels[i];
148 break;
149 }
150 }
151 if (NULL == channel) {
152 LOGE("Wrong channel id (%d)", bufs->ch_id);
153 rc = -1;
154 goto error;
155 }
156
157 /* find snapshot stream */
158 for (i = 0; i < channel->num_streams; i++) {
159 if (channel->streams[i].s_config.stream_info->stream_type == CAM_STREAM_TYPE_SNAPSHOT) {
160 m_stream = &channel->streams[i];
161 break;
162 }
163 }
164 if (NULL == m_stream) {
165 LOGE("cannot find snapshot stream");
166 rc = -1;
167 goto error;
168 }
169
170 /* find snapshot frame */
171 for (i = 0; i < bufs->num_bufs; i++) {
172 if (bufs->bufs[i]->stream_id == m_stream->s_id) {
173 m_frame = bufs->bufs[i];
174 break;
175 }
176 }
177 if (NULL == m_frame) {
178 LOGE("main frame is NULL");
179 rc = -1;
180 goto error;
181 }
182
183 mm_app_dump_frame(m_frame, "main", "yuv", m_frame->frame_idx);
184
185 /* find postview stream */
186 for (i = 0; i < channel->num_streams; i++) {
187 if (channel->streams[i].s_config.stream_info->stream_type == CAM_STREAM_TYPE_POSTVIEW) {
188 p_stream = &channel->streams[i];
189 break;
190 }
191 }
192 if (NULL != p_stream) {
193 /* find preview frame */
194 for (i = 0; i < bufs->num_bufs; i++) {
195 if (bufs->bufs[i]->stream_id == p_stream->s_id) {
196 p_frame = bufs->bufs[i];
197 break;
198 }
199 }
200 if (NULL != p_frame) {
201 mm_app_dump_frame(p_frame, "postview", "yuv", p_frame->frame_idx);
202 }
203 }
204
205 mm_app_cache_ops((mm_camera_app_meminfo_t *)m_frame->mem_info,
206 ION_IOC_CLEAN_INV_CACHES);
207
208 pme->jpeg_buf.buf.buffer = (uint8_t *)malloc(m_frame->frame_len);
209 if ( NULL == pme->jpeg_buf.buf.buffer ) {
210 LOGE("error allocating jpeg output buffer");
211 goto error;
212 }
213
214 pme->jpeg_buf.buf.frame_len = m_frame->frame_len;
215 /* create a new jpeg encoding session */
216 rc = createEncodingSession(pme, m_stream, m_frame);
217 if (0 != rc) {
218 LOGE("error creating jpeg session");
219 free(pme->jpeg_buf.buf.buffer);
220 goto error;
221 }
222
223 /* start jpeg encoding job */
224 rc = encodeData(pme, bufs, m_stream);
225 if (0 != rc) {
226 LOGE("error creating jpeg session");
227 free(pme->jpeg_buf.buf.buffer);
228 goto error;
229 }
230
231 error:
232 /* buf done rcvd frames in error case */
233 if ( 0 != rc ) {
234 for (i=0; i<bufs->num_bufs; i++) {
235 if (MM_CAMERA_OK != pme->cam->ops->qbuf(bufs->camera_handle,
236 bufs->ch_id,
237 bufs->bufs[i])) {
238 LOGE("Failed in Qbuf\n");
239 }
240 mm_app_cache_ops((mm_camera_app_meminfo_t *)bufs->bufs[i]->mem_info,
241 ION_IOC_INV_CACHES);
242 }
243 }
244
245 LOGD(" END\n");
246 }
247
mm_app_preview_notify_cb(mm_camera_super_buf_t * bufs,void * user_data)248 static void mm_app_preview_notify_cb(mm_camera_super_buf_t *bufs,
249 void *user_data)
250 {
251 uint32_t i = 0;
252 mm_camera_channel_t *channel = NULL;
253 mm_camera_stream_t *p_stream = NULL;
254 mm_camera_buf_def_t *frame = NULL;
255 mm_camera_test_obj_t *pme = (mm_camera_test_obj_t *)user_data;
256
257 if (NULL == bufs || NULL == user_data) {
258 LOGE("bufs or user_data are not valid ");
259 return;
260 }
261
262 frame = bufs->bufs[0];
263
264 /* find channel */
265 for (i = 0; i < MM_CHANNEL_TYPE_MAX; i++) {
266 if (pme->channels[i].ch_id == bufs->ch_id) {
267 channel = &pme->channels[i];
268 break;
269 }
270 }
271 if (NULL == channel) {
272 LOGE("Channel object is NULL ");
273 return;
274 }
275 /* find preview stream */
276 for (i = 0; i < channel->num_streams; i++) {
277 if (channel->streams[i].s_config.stream_info->stream_type == CAM_STREAM_TYPE_PREVIEW) {
278 p_stream = &channel->streams[i];
279 break;
280 }
281 }
282
283 if (NULL == p_stream) {
284 LOGE("cannot find preview stream");
285 return;
286 }
287
288 /* find preview frame */
289 for (i = 0; i < bufs->num_bufs; i++) {
290 if (bufs->bufs[i]->stream_id == p_stream->s_id) {
291 frame = bufs->bufs[i];
292 break;
293 }
294 }
295
296 if ( 0 < pme->fb_fd ) {
297 mm_app_overlay_display(pme, frame->fd);
298 }
299 #ifdef DUMP_PRV_IN_FILE
300 {
301 char file_name[64];
302 snprintf(file_name, sizeof(file_name), "P_C%d", pme->cam->camera_handle);
303 mm_app_dump_frame(frame, file_name, "yuv", frame->frame_idx);
304 }
305 #endif
306 if (pme->user_preview_cb) {
307 LOGE("[DBG] %s, user defined own preview cb. calling it...");
308 pme->user_preview_cb(frame);
309 }
310 if (MM_CAMERA_OK != pme->cam->ops->qbuf(bufs->camera_handle,
311 bufs->ch_id,
312 frame)) {
313 LOGE("Failed in Preview Qbuf\n");
314 }
315 mm_app_cache_ops((mm_camera_app_meminfo_t *)frame->mem_info,
316 ION_IOC_INV_CACHES);
317
318 LOGD(" END\n");
319 }
320
mm_app_zsl_notify_cb(mm_camera_super_buf_t * bufs,void * user_data)321 static void mm_app_zsl_notify_cb(mm_camera_super_buf_t *bufs,
322 void *user_data)
323 {
324 int rc = MM_CAMERA_OK;
325 uint32_t i = 0;
326 mm_camera_test_obj_t *pme = (mm_camera_test_obj_t *)user_data;
327 mm_camera_channel_t *channel = NULL;
328 mm_camera_stream_t *p_stream = NULL;
329 mm_camera_stream_t *m_stream = NULL;
330 mm_camera_stream_t *md_stream = NULL;
331 mm_camera_buf_def_t *p_frame = NULL;
332 mm_camera_buf_def_t *m_frame = NULL;
333 mm_camera_buf_def_t *md_frame = NULL;
334
335 LOGD(" BEGIN\n");
336
337 if (NULL == bufs || NULL == user_data) {
338 LOGE("bufs or user_data are not valid ");
339 return;
340 }
341
342 /* find channel */
343 for (i = 0; i < MM_CHANNEL_TYPE_MAX; i++) {
344 if (pme->channels[i].ch_id == bufs->ch_id) {
345 channel = &pme->channels[i];
346 break;
347 }
348 }
349 if (NULL == channel) {
350 LOGE("Wrong channel id (%d)", bufs->ch_id);
351 return;
352 }
353
354 /* find preview stream */
355 for (i = 0; i < channel->num_streams; i++) {
356 if (channel->streams[i].s_config.stream_info->stream_type == CAM_STREAM_TYPE_PREVIEW) {
357 p_stream = &channel->streams[i];
358 break;
359 }
360 }
361 if (NULL == p_stream) {
362 LOGE("cannot find preview stream");
363 return;
364 }
365
366 /* find snapshot stream */
367 for (i = 0; i < channel->num_streams; i++) {
368 if (channel->streams[i].s_config.stream_info->stream_type == CAM_STREAM_TYPE_SNAPSHOT) {
369 m_stream = &channel->streams[i];
370 break;
371 }
372 }
373 if (NULL == m_stream) {
374 LOGE("cannot find snapshot stream");
375 return;
376 }
377
378 /* find metadata stream */
379 for (i = 0; i < channel->num_streams; i++) {
380 if (channel->streams[i].s_config.stream_info->stream_type == CAM_STREAM_TYPE_METADATA) {
381 md_stream = &channel->streams[i];
382 break;
383 }
384 }
385 if (NULL == md_stream) {
386 LOGE("cannot find metadata stream");
387 }
388
389 /* find preview frame */
390 for (i = 0; i < bufs->num_bufs; i++) {
391 if (bufs->bufs[i]->stream_id == p_stream->s_id) {
392 p_frame = bufs->bufs[i];
393 break;
394 }
395 }
396
397 if(md_stream) {
398 /* find metadata frame */
399 for (i = 0; i < bufs->num_bufs; i++) {
400 if (bufs->bufs[i]->stream_id == md_stream->s_id) {
401 md_frame = bufs->bufs[i];
402 break;
403 }
404 }
405 if (!md_frame) {
406 LOGE("md_frame is null\n");
407 return;
408 }
409 if (!pme->metadata) {
410 /* App will free the metadata */
411 pme->metadata = malloc(sizeof(metadata_buffer_t));
412 if (!pme->metadata) {
413 ALOGE("not enough memory\n");
414 return;
415 }
416 }
417
418 memcpy(pme->metadata , md_frame->buffer, sizeof(metadata_buffer_t));
419 }
420 /* find snapshot frame */
421 for (i = 0; i < bufs->num_bufs; i++) {
422 if (bufs->bufs[i]->stream_id == m_stream->s_id) {
423 m_frame = bufs->bufs[i];
424 break;
425 }
426 }
427
428 if (!m_frame || !p_frame) {
429 LOGE("cannot find preview/snapshot frame");
430 return;
431 }
432
433 LOGD(" ZSL CB with fb_fd = %d, m_frame = %p, p_frame = %p \n",
434 pme->fb_fd,
435 m_frame,
436 p_frame);
437
438 if ( 0 < pme->fb_fd ) {
439 mm_app_overlay_display(pme, p_frame->fd);
440 }/* else {
441 mm_app_dump_frame(p_frame, "zsl_preview", "yuv", p_frame->frame_idx);
442 mm_app_dump_frame(m_frame, "zsl_main", "yuv", m_frame->frame_idx);
443 }*/
444
445 if ( pme->enable_reproc && ( NULL != pme->reproc_stream ) ) {
446
447 if (NULL != md_frame) {
448 rc = mm_app_do_reprocess(pme,
449 m_frame,
450 md_frame->buf_idx,
451 bufs,
452 md_stream);
453
454 if (MM_CAMERA_OK != rc ) {
455 LOGE("reprocess failed rc = %d", rc);
456 }
457 } else {
458 LOGE("md_frame is null\n");
459 }
460
461 return;
462 }
463
464 if ( pme->encodeJpeg ) {
465 pme->jpeg_buf.buf.buffer = (uint8_t *)malloc(m_frame->frame_len);
466 if ( NULL == pme->jpeg_buf.buf.buffer ) {
467 LOGE("error allocating jpeg output buffer");
468 goto exit;
469 }
470
471 pme->jpeg_buf.buf.frame_len = m_frame->frame_len;
472 /* create a new jpeg encoding session */
473 rc = createEncodingSession(pme, m_stream, m_frame);
474 if (0 != rc) {
475 LOGE("error creating jpeg session");
476 free(pme->jpeg_buf.buf.buffer);
477 goto exit;
478 }
479
480 /* start jpeg encoding job */
481 rc = encodeData(pme, bufs, m_stream);
482 pme->encodeJpeg = 0;
483 } else {
484 if (MM_CAMERA_OK != pme->cam->ops->qbuf(bufs->camera_handle,
485 bufs->ch_id,
486 m_frame)) {
487 LOGE("Failed in main Qbuf\n");
488 }
489 mm_app_cache_ops((mm_camera_app_meminfo_t *)m_frame->mem_info,
490 ION_IOC_INV_CACHES);
491 }
492
493 exit:
494
495 if (MM_CAMERA_OK != pme->cam->ops->qbuf(bufs->camera_handle,
496 bufs->ch_id,
497 p_frame)) {
498 LOGE("Failed in preview Qbuf\n");
499 }
500 mm_app_cache_ops((mm_camera_app_meminfo_t *)p_frame->mem_info,
501 ION_IOC_INV_CACHES);
502
503 if(md_frame) {
504 if (MM_CAMERA_OK != pme->cam->ops->qbuf(bufs->camera_handle,
505 bufs->ch_id,
506 md_frame)) {
507 LOGE("Failed in metadata Qbuf\n");
508 }
509 mm_app_cache_ops((mm_camera_app_meminfo_t *)md_frame->mem_info,
510 ION_IOC_INV_CACHES);
511 }
512
513 LOGD(" END\n");
514 }
515
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)516 mm_camera_stream_t * mm_app_add_metadata_stream(mm_camera_test_obj_t *test_obj,
517 mm_camera_channel_t *channel,
518 mm_camera_buf_notify_t stream_cb,
519 void *userdata,
520 uint8_t num_bufs)
521 {
522 int rc = MM_CAMERA_OK;
523 mm_camera_stream_t *stream = NULL;
524 cam_capability_t *cam_cap = (cam_capability_t *)(test_obj->cap_buf.buf.buffer);
525 stream = mm_app_add_stream(test_obj, channel);
526 if (NULL == stream) {
527 LOGE("add stream failed\n");
528 return NULL;
529 }
530
531 stream->s_config.mem_vtbl.get_bufs = mm_app_stream_initbuf;
532 stream->s_config.mem_vtbl.put_bufs = mm_app_stream_deinitbuf;
533 stream->s_config.mem_vtbl.clean_invalidate_buf =
534 mm_app_stream_clean_invalidate_buf;
535 stream->s_config.mem_vtbl.invalidate_buf = mm_app_stream_invalidate_buf;
536 stream->s_config.mem_vtbl.user_data = (void *)stream;
537 stream->s_config.stream_cb = stream_cb;
538 stream->s_config.stream_cb_sync = NULL;
539 stream->s_config.userdata = userdata;
540 stream->num_of_bufs = num_bufs;
541
542 stream->s_config.stream_info = (cam_stream_info_t *)stream->s_info_buf.buf.buffer;
543 memset(stream->s_config.stream_info, 0, sizeof(cam_stream_info_t));
544 stream->s_config.stream_info->stream_type = CAM_STREAM_TYPE_METADATA;
545 stream->s_config.stream_info->streaming_mode = CAM_STREAMING_MODE_CONTINUOUS;
546 stream->s_config.stream_info->fmt = DEFAULT_PREVIEW_FORMAT;
547 stream->s_config.stream_info->dim.width = sizeof(metadata_buffer_t);
548 stream->s_config.stream_info->dim.height = 1;
549 stream->s_config.padding_info = cam_cap->padding_info;
550
551 rc = mm_app_config_stream(test_obj, channel, stream, &stream->s_config);
552 if (MM_CAMERA_OK != rc) {
553 LOGE("config preview stream err=%d\n", rc);
554 return NULL;
555 }
556
557 return stream;
558 }
559
mm_app_get_analysis_stream_dim(const mm_camera_test_obj_t * test_obj,const cam_dimension_t * preview_dim)560 cam_dimension_t mm_app_get_analysis_stream_dim(
561 const mm_camera_test_obj_t *test_obj,
562 const cam_dimension_t* preview_dim)
563 {
564 cam_capability_t *cam_cap = (cam_capability_t *)(test_obj->cap_buf.buf.buffer);
565 cam_dimension_t max_analysis_dim = cam_cap->analysis_max_res;
566 cam_dimension_t analysis_dim = {0, 0};
567
568 if (preview_dim->width > max_analysis_dim.width ||
569 preview_dim->height > max_analysis_dim.height) {
570 double max_ratio, requested_ratio;
571
572 max_ratio = (double)max_analysis_dim.width / (double)max_analysis_dim.height;
573 requested_ratio = (double)preview_dim->width / (double)preview_dim->height;
574
575 if (max_ratio < requested_ratio) {
576 analysis_dim.width = analysis_dim.width;
577 analysis_dim.height = (int32_t)((double)analysis_dim.width / requested_ratio);
578 } else {
579 analysis_dim.height = analysis_dim.height;
580 analysis_dim.width = (int32_t)((double)analysis_dim.height * requested_ratio);
581 }
582 analysis_dim.width &= ~0x1;
583 analysis_dim.height &= ~0x1;
584 } else {
585 analysis_dim = *preview_dim;
586 }
587
588 LOGI("analysis stream dim (%d x %d)\n", analysis_dim.width, analysis_dim.height);
589 return analysis_dim;
590 }
591
mm_app_add_analysis_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)592 mm_camera_stream_t * mm_app_add_analysis_stream(mm_camera_test_obj_t *test_obj,
593 mm_camera_channel_t *channel,
594 mm_camera_buf_notify_t stream_cb,
595 void *userdata,
596 uint8_t num_bufs)
597 {
598 int rc = MM_CAMERA_OK;
599 mm_camera_stream_t *stream = NULL;
600 cam_capability_t *cam_cap = (cam_capability_t *)(test_obj->cap_buf.buf.buffer);
601 cam_dimension_t preview_dim = {0, 0};
602 cam_dimension_t analysis_dim = {0, 0};
603
604
605 stream = mm_app_add_stream(test_obj, channel);
606 if (NULL == stream) {
607 LOGE("add stream failed\n");
608 return NULL;
609 }
610
611 if ((test_obj->preview_resolution.user_input_display_width == 0) ||
612 ( test_obj->preview_resolution.user_input_display_height == 0)) {
613 preview_dim.width = DEFAULT_PREVIEW_WIDTH;
614 preview_dim.height = DEFAULT_PREVIEW_HEIGHT;
615 } else {
616 preview_dim.width = test_obj->preview_resolution.user_input_display_width;
617 preview_dim.height = test_obj->preview_resolution.user_input_display_height;
618 }
619
620 analysis_dim = mm_app_get_analysis_stream_dim(test_obj, &preview_dim);
621 LOGI("analysis stream dimesion: %d x %d\n",
622 analysis_dim.width, analysis_dim.height);
623
624 stream->s_config.mem_vtbl.get_bufs = mm_app_stream_initbuf;
625 stream->s_config.mem_vtbl.put_bufs = mm_app_stream_deinitbuf;
626 stream->s_config.mem_vtbl.clean_invalidate_buf =
627 mm_app_stream_clean_invalidate_buf;
628 stream->s_config.mem_vtbl.invalidate_buf = mm_app_stream_invalidate_buf;
629 stream->s_config.mem_vtbl.user_data = (void *)stream;
630 stream->s_config.stream_cb = stream_cb;
631 stream->s_config.userdata = userdata;
632 stream->num_of_bufs = num_bufs;
633
634 stream->s_config.stream_info = (cam_stream_info_t *)stream->s_info_buf.buf.buffer;
635 memset(stream->s_config.stream_info, 0, sizeof(cam_stream_info_t));
636 stream->s_config.stream_info->stream_type = CAM_STREAM_TYPE_ANALYSIS;
637 stream->s_config.stream_info->streaming_mode = CAM_STREAMING_MODE_CONTINUOUS;
638 stream->s_config.stream_info->fmt = DEFAULT_PREVIEW_FORMAT;
639 stream->s_config.stream_info->dim = analysis_dim;
640 stream->s_config.padding_info = cam_cap->analysis_padding_info;
641
642 rc = mm_app_config_stream(test_obj, channel, stream, &stream->s_config);
643 if (MM_CAMERA_OK != rc) {
644 LOGE("config preview stream err=%d\n", rc);
645 return NULL;
646 }
647
648 return stream;
649 }
650
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)651 mm_camera_stream_t * mm_app_add_preview_stream(mm_camera_test_obj_t *test_obj,
652 mm_camera_channel_t *channel,
653 mm_camera_buf_notify_t stream_cb,
654 void *userdata,
655 uint8_t num_bufs)
656 {
657 int rc = MM_CAMERA_OK;
658 mm_camera_stream_t *stream = NULL;
659 cam_capability_t *cam_cap = (cam_capability_t *)(test_obj->cap_buf.buf.buffer);
660 cam_dimension_t preview_dim = {0, 0};
661 cam_dimension_t analysis_dim = {0, 0};
662
663 if ((test_obj->preview_resolution.user_input_display_width == 0) ||
664 ( test_obj->preview_resolution.user_input_display_height == 0)) {
665 preview_dim.width = DEFAULT_PREVIEW_WIDTH;
666 preview_dim.height = DEFAULT_PREVIEW_HEIGHT;
667 } else {
668 preview_dim.width = test_obj->preview_resolution.user_input_display_width;
669 preview_dim.height = test_obj->preview_resolution.user_input_display_height;
670 }
671 LOGI("preview dimesion: %d x %d\n", preview_dim.width, preview_dim.height);
672
673 analysis_dim = mm_app_get_analysis_stream_dim(test_obj, &preview_dim);
674 LOGI("analysis stream dimesion: %d x %d\n",
675 analysis_dim.width, analysis_dim.height);
676
677 uint32_t analysis_pp_mask = cam_cap->qcom_supported_feature_mask &
678 (CAM_QCOM_FEATURE_SHARPNESS |
679 CAM_QCOM_FEATURE_EFFECT |
680 CAM_QCOM_FEATURE_DENOISE2D);
681 LOGI("analysis stream pp mask:%x\n", analysis_pp_mask);
682
683 cam_stream_size_info_t abc ;
684 memset (&abc , 0, sizeof (cam_stream_size_info_t));
685
686 abc.num_streams = 2;
687 abc.postprocess_mask[0] = 2178;
688 abc.stream_sizes[0].width = preview_dim.width;
689 abc.stream_sizes[0].height = preview_dim.height;
690 abc.type[0] = CAM_STREAM_TYPE_PREVIEW;
691
692 abc.postprocess_mask[1] = analysis_pp_mask;
693 abc.stream_sizes[1].width = analysis_dim.width;
694 abc.stream_sizes[1].height = analysis_dim.height;
695 abc.type[1] = CAM_STREAM_TYPE_ANALYSIS;
696
697 abc.buffer_info.min_buffers = 10;
698 abc.buffer_info.max_buffers = 10;
699 abc.is_type = IS_TYPE_NONE;
700
701 rc = setmetainfoCommand(test_obj, &abc);
702 if (rc != MM_CAMERA_OK) {
703 LOGE("meta info command failed\n");
704 }
705
706 stream = mm_app_add_stream(test_obj, channel);
707 if (NULL == stream) {
708 LOGE("add stream failed\n");
709 return NULL;
710 }
711 stream->s_config.mem_vtbl.get_bufs = mm_app_stream_initbuf;
712 stream->s_config.mem_vtbl.put_bufs = mm_app_stream_deinitbuf;
713 stream->s_config.mem_vtbl.clean_invalidate_buf =
714 mm_app_stream_clean_invalidate_buf;
715 stream->s_config.mem_vtbl.invalidate_buf = mm_app_stream_invalidate_buf;
716 stream->s_config.mem_vtbl.user_data = (void *)stream;
717 stream->s_config.stream_cb = stream_cb;
718 stream->s_config.stream_cb_sync = NULL;
719 stream->s_config.userdata = userdata;
720 stream->num_of_bufs = num_bufs;
721
722 stream->s_config.stream_info = (cam_stream_info_t *)stream->s_info_buf.buf.buffer;
723 memset(stream->s_config.stream_info, 0, sizeof(cam_stream_info_t));
724 stream->s_config.stream_info->stream_type = CAM_STREAM_TYPE_PREVIEW;
725 stream->s_config.stream_info->streaming_mode = CAM_STREAMING_MODE_CONTINUOUS;
726 stream->s_config.stream_info->fmt = DEFAULT_PREVIEW_FORMAT;
727
728 stream->s_config.stream_info->dim.width = preview_dim.width;
729 stream->s_config.stream_info->dim.height = preview_dim.height;
730
731 stream->s_config.padding_info = cam_cap->padding_info;
732
733 rc = mm_app_config_stream(test_obj, channel, stream, &stream->s_config);
734 if (MM_CAMERA_OK != rc) {
735 LOGE("config preview stream err=%d\n", rc);
736 return NULL;
737 }
738
739 return stream;
740 }
741
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)742 mm_camera_stream_t * mm_app_add_raw_stream(mm_camera_test_obj_t *test_obj,
743 mm_camera_channel_t *channel,
744 mm_camera_buf_notify_t stream_cb,
745 void *userdata,
746 uint8_t num_bufs,
747 uint8_t num_burst)
748 {
749 int rc = MM_CAMERA_OK;
750 mm_camera_stream_t *stream = NULL;
751 cam_capability_t *cam_cap = (cam_capability_t *)(test_obj->cap_buf.buf.buffer);
752
753 cam_stream_size_info_t abc ;
754 memset (&abc , 0, sizeof (cam_stream_size_info_t));
755
756 abc.num_streams = 1;
757 abc.postprocess_mask[0] = 0;
758
759 if ( test_obj->buffer_width == 0 || test_obj->buffer_height == 0 ) {
760 abc.stream_sizes[0].width = DEFAULT_SNAPSHOT_WIDTH;
761 abc.stream_sizes[0].height = DEFAULT_SNAPSHOT_HEIGHT;
762 } else {
763 abc.stream_sizes[0].width = (int32_t)test_obj->buffer_width;
764 abc.stream_sizes[0].height = (int32_t)test_obj->buffer_height;
765 }
766 abc.type[0] = CAM_STREAM_TYPE_RAW;
767
768 abc.buffer_info.min_buffers = num_bufs;
769 abc.buffer_info.max_buffers = num_bufs;
770 abc.is_type = IS_TYPE_NONE;
771
772 rc = setmetainfoCommand(test_obj, &abc);
773 if (rc != MM_CAMERA_OK) {
774 LOGE("meta info command failed\n");
775 }
776
777 stream = mm_app_add_stream(test_obj, channel);
778 if (NULL == stream) {
779 LOGE("add stream failed\n");
780 return NULL;
781 }
782
783 stream->s_config.mem_vtbl.get_bufs = mm_app_stream_initbuf;
784 stream->s_config.mem_vtbl.put_bufs = mm_app_stream_deinitbuf;
785 stream->s_config.mem_vtbl.invalidate_buf = mm_app_stream_invalidate_buf;
786 stream->s_config.mem_vtbl.user_data = (void *)stream;
787 stream->s_config.stream_cb = stream_cb;
788 stream->s_config.stream_cb_sync = NULL;
789 stream->s_config.userdata = userdata;
790 stream->num_of_bufs = num_bufs;
791
792 stream->s_config.stream_info = (cam_stream_info_t *)stream->s_info_buf.buf.buffer;
793 memset(stream->s_config.stream_info, 0, sizeof(cam_stream_info_t));
794 stream->s_config.stream_info->stream_type = CAM_STREAM_TYPE_RAW;
795 if (num_burst == 0) {
796 stream->s_config.stream_info->streaming_mode = CAM_STREAMING_MODE_CONTINUOUS;
797 } else {
798 stream->s_config.stream_info->streaming_mode = CAM_STREAMING_MODE_BURST;
799 stream->s_config.stream_info->num_of_burst = num_burst;
800 }
801 stream->s_config.stream_info->fmt = test_obj->buffer_format;
802 if ( test_obj->buffer_width == 0 || test_obj->buffer_height == 0 ) {
803 stream->s_config.stream_info->dim.width = DEFAULT_SNAPSHOT_WIDTH;
804 stream->s_config.stream_info->dim.height = DEFAULT_SNAPSHOT_HEIGHT;
805 } else {
806 stream->s_config.stream_info->dim.width = (int32_t)test_obj->buffer_width;
807 stream->s_config.stream_info->dim.height = (int32_t)test_obj->buffer_height;
808 }
809 stream->s_config.padding_info = cam_cap->padding_info;
810
811 rc = mm_app_config_stream(test_obj, channel, stream, &stream->s_config);
812 if (MM_CAMERA_OK != rc) {
813 LOGE("config preview stream err=%d\n", rc);
814 return NULL;
815 }
816
817 return stream;
818 }
819
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)820 mm_camera_stream_t * mm_app_add_snapshot_stream(mm_camera_test_obj_t *test_obj,
821 mm_camera_channel_t *channel,
822 mm_camera_buf_notify_t stream_cb,
823 void *userdata,
824 uint8_t num_bufs,
825 uint8_t num_burst)
826 {
827 int rc = MM_CAMERA_OK;
828 mm_camera_stream_t *stream = NULL;
829 cam_capability_t *cam_cap = (cam_capability_t *)(test_obj->cap_buf.buf.buffer);
830 cam_stream_size_info_t abc_snap ;
831 memset (&abc_snap , 0, sizeof (cam_stream_size_info_t));
832
833 abc_snap.num_streams = 2;
834 abc_snap.postprocess_mask[1] = 2178;
835 abc_snap.stream_sizes[1].width = DEFAULT_PREVIEW_WIDTH;
836 abc_snap.stream_sizes[1].height = DEFAULT_PREVIEW_HEIGHT;
837 abc_snap.type[1] = CAM_STREAM_TYPE_POSTVIEW;
838
839 abc_snap.postprocess_mask[0] = 0;
840 abc_snap.stream_sizes[0].width = DEFAULT_SNAPSHOT_WIDTH;
841 abc_snap.stream_sizes[0].height = DEFAULT_SNAPSHOT_HEIGHT;
842 abc_snap.type[0] = CAM_STREAM_TYPE_SNAPSHOT;
843
844 abc_snap.buffer_info.min_buffers = 7;
845 abc_snap.buffer_info.max_buffers = 7;
846 abc_snap.is_type = IS_TYPE_NONE;
847
848 rc = setmetainfoCommand(test_obj, &abc_snap);
849 if (rc != MM_CAMERA_OK) {
850 LOGE("meta info command snapshot failed\n");
851 }
852
853 stream = mm_app_add_stream(test_obj, channel);
854 if (NULL == stream) {
855 LOGE("add stream failed\n");
856 return NULL;
857 }
858
859 stream->s_config.mem_vtbl.get_bufs = mm_app_stream_initbuf;
860 stream->s_config.mem_vtbl.put_bufs = mm_app_stream_deinitbuf;
861 stream->s_config.mem_vtbl.clean_invalidate_buf =
862 mm_app_stream_clean_invalidate_buf;
863 stream->s_config.mem_vtbl.invalidate_buf = mm_app_stream_invalidate_buf;
864 stream->s_config.mem_vtbl.user_data = (void *)stream;
865 stream->s_config.stream_cb = stream_cb;
866 stream->s_config.stream_cb_sync = NULL;
867 stream->s_config.userdata = userdata;
868 stream->num_of_bufs = num_bufs;
869
870 stream->s_config.stream_info = (cam_stream_info_t *)stream->s_info_buf.buf.buffer;
871 memset(stream->s_config.stream_info, 0, sizeof(cam_stream_info_t));
872 stream->s_config.stream_info->stream_type = CAM_STREAM_TYPE_SNAPSHOT;
873 if (num_burst == 0) {
874 stream->s_config.stream_info->streaming_mode = CAM_STREAMING_MODE_CONTINUOUS;
875 } else {
876 stream->s_config.stream_info->streaming_mode = CAM_STREAMING_MODE_BURST;
877 stream->s_config.stream_info->num_of_burst = num_burst;
878 }
879 stream->s_config.stream_info->fmt = DEFAULT_SNAPSHOT_FORMAT;
880 if ( test_obj->buffer_width == 0 || test_obj->buffer_height == 0 ) {
881 stream->s_config.stream_info->dim.width = DEFAULT_SNAPSHOT_WIDTH;
882 stream->s_config.stream_info->dim.height = DEFAULT_SNAPSHOT_HEIGHT;
883 } else {
884 stream->s_config.stream_info->dim.width = DEFAULT_SNAPSHOT_WIDTH;
885 stream->s_config.stream_info->dim.height = DEFAULT_SNAPSHOT_HEIGHT;
886 }
887 stream->s_config.padding_info = cam_cap->padding_info;
888
889 rc = mm_app_config_stream(test_obj, channel, stream, &stream->s_config);
890 if (MM_CAMERA_OK != rc) {
891 LOGE("config preview stream err=%d\n", rc);
892 return NULL;
893 }
894
895 return stream;
896 }
897
mm_app_add_preview_channel(mm_camera_test_obj_t * test_obj)898 mm_camera_channel_t * mm_app_add_preview_channel(mm_camera_test_obj_t *test_obj)
899 {
900 mm_camera_channel_t *channel = NULL;
901 mm_camera_stream_t *stream = NULL;
902
903 channel = mm_app_add_channel(test_obj,
904 MM_CHANNEL_TYPE_PREVIEW,
905 NULL,
906 NULL,
907 NULL);
908 if (NULL == channel) {
909 LOGE("add channel failed");
910 return NULL;
911 }
912
913 stream = mm_app_add_preview_stream(test_obj,
914 channel,
915 mm_app_preview_notify_cb,
916 (void *)test_obj,
917 PREVIEW_BUF_NUM);
918 if (NULL == stream) {
919 LOGE("add stream failed\n");
920 mm_app_del_channel(test_obj, channel);
921 return NULL;
922 }
923
924 return channel;
925 }
926
mm_app_stop_and_del_channel(mm_camera_test_obj_t * test_obj,mm_camera_channel_t * channel)927 int mm_app_stop_and_del_channel(mm_camera_test_obj_t *test_obj,
928 mm_camera_channel_t *channel)
929 {
930 int rc = MM_CAMERA_OK;
931 mm_camera_stream_t *stream = NULL;
932 uint8_t i;
933 cam_stream_size_info_t abc ;
934 memset (&abc , 0, sizeof (cam_stream_size_info_t));
935
936 rc = mm_app_stop_channel(test_obj, channel);
937 if (MM_CAMERA_OK != rc) {
938 LOGE("Stop Preview failed rc=%d\n", rc);
939 }
940
941 if (channel->num_streams <= MAX_STREAM_NUM_IN_BUNDLE) {
942 for (i = 0; i < channel->num_streams; i++) {
943 stream = &channel->streams[i];
944 rc = mm_app_del_stream(test_obj, channel, stream);
945 if (MM_CAMERA_OK != rc) {
946 LOGE("del stream(%d) failed rc=%d\n", i, rc);
947 }
948 }
949 } else {
950 LOGE("num_streams = %d. Should not be more than %d\n",
951 channel->num_streams, MAX_STREAM_NUM_IN_BUNDLE);
952 }
953
954 rc = setmetainfoCommand(test_obj, &abc);
955 if (rc != MM_CAMERA_OK) {
956 LOGE("meta info command failed\n");
957 }
958
959 rc = mm_app_del_channel(test_obj, channel);
960 if (MM_CAMERA_OK != rc) {
961 LOGE("delete channel failed rc=%d\n", rc);
962 }
963
964 return rc;
965 }
966
mm_app_start_preview(mm_camera_test_obj_t * test_obj)967 int mm_app_start_preview(mm_camera_test_obj_t *test_obj)
968 {
969 int rc = MM_CAMERA_OK;
970 mm_camera_channel_t *channel = NULL;
971 mm_camera_stream_t *stream = NULL;
972 mm_camera_stream_t *s_metadata = NULL;
973 mm_camera_stream_t *s_analysis = NULL;
974 uint8_t i;
975
976 channel = mm_app_add_preview_channel(test_obj);
977 if (NULL == channel) {
978 LOGE("add channel failed");
979 return -MM_CAMERA_E_GENERAL;
980 }
981
982 s_metadata = mm_app_add_metadata_stream(test_obj,
983 channel,
984 mm_app_metadata_notify_cb,
985 (void *)test_obj,
986 PREVIEW_BUF_NUM);
987 if (NULL == s_metadata) {
988 LOGE("add metadata stream failed\n");
989 mm_app_del_channel(test_obj, channel);
990 return rc;
991 }
992
993 s_analysis = mm_app_add_analysis_stream(test_obj,
994 channel,
995 NULL,
996 (void *)test_obj,
997 PREVIEW_BUF_NUM);
998 if (NULL == s_analysis) {
999 LOGE("add metadata stream failed\n");
1000 mm_app_del_channel(test_obj, channel);
1001 return rc;
1002 }
1003
1004 rc = mm_app_start_channel(test_obj, channel);
1005 if (MM_CAMERA_OK != rc) {
1006 LOGE("start preview failed rc=%d\n", rc);
1007 if (channel->num_streams <= MAX_STREAM_NUM_IN_BUNDLE) {
1008 for (i = 0; i < channel->num_streams; i++) {
1009 stream = &channel->streams[i];
1010 mm_app_del_stream(test_obj, channel, stream);
1011 }
1012 }
1013 mm_app_del_channel(test_obj, channel);
1014 return rc;
1015 }
1016
1017 return rc;
1018 }
1019
mm_app_stop_preview(mm_camera_test_obj_t * test_obj)1020 int mm_app_stop_preview(mm_camera_test_obj_t *test_obj)
1021 {
1022 int rc = MM_CAMERA_OK;
1023 mm_camera_channel_t *channel =
1024 mm_app_get_channel_by_type(test_obj, MM_CHANNEL_TYPE_PREVIEW);
1025
1026 rc = mm_app_stop_and_del_channel(test_obj, channel);
1027 if (MM_CAMERA_OK != rc) {
1028 LOGE("Stop Preview failed rc=%d\n", rc);
1029 }
1030
1031 return rc;
1032 }
1033
mm_app_start_preview_zsl(mm_camera_test_obj_t * test_obj)1034 int mm_app_start_preview_zsl(mm_camera_test_obj_t *test_obj)
1035 {
1036 int32_t rc = MM_CAMERA_OK;
1037 mm_camera_channel_t *channel = NULL;
1038 mm_camera_stream_t *s_preview = NULL;
1039 mm_camera_stream_t *s_metadata = NULL;
1040 mm_camera_stream_t *s_main = NULL;
1041 mm_camera_channel_attr_t attr;
1042 memset(&attr, 0, sizeof(mm_camera_channel_attr_t));
1043 attr.notify_mode = MM_CAMERA_SUPER_BUF_NOTIFY_CONTINUOUS;
1044 attr.look_back = 2;
1045 attr.post_frame_skip = 0;
1046 attr.water_mark = 2;
1047 attr.max_unmatched_frames = 3;
1048 channel = mm_app_add_channel(test_obj,
1049 MM_CHANNEL_TYPE_ZSL,
1050 &attr,
1051 mm_app_zsl_notify_cb,
1052 test_obj);
1053 if (NULL == channel) {
1054 LOGE("add channel failed");
1055 return -MM_CAMERA_E_GENERAL;
1056 }
1057
1058 s_preview = mm_app_add_preview_stream(test_obj,
1059 channel,
1060 mm_app_preview_notify_cb,
1061 (void *)test_obj,
1062 PREVIEW_BUF_NUM);
1063 if (NULL == s_preview) {
1064 LOGE("add preview stream failed\n");
1065 mm_app_del_channel(test_obj, channel);
1066 return rc;
1067 }
1068
1069 s_main = mm_app_add_snapshot_stream(test_obj,
1070 channel,
1071 mm_app_snapshot_notify_cb,
1072 (void *)test_obj,
1073 PREVIEW_BUF_NUM,
1074 0);
1075 if (NULL == s_main) {
1076 LOGE("add main snapshot stream failed\n");
1077 mm_app_del_stream(test_obj, channel, s_preview);
1078 mm_app_del_channel(test_obj, channel);
1079 return rc;
1080 }
1081
1082 s_metadata = mm_app_add_metadata_stream(test_obj,
1083 channel,
1084 mm_app_metadata_notify_cb,
1085 (void *)test_obj,
1086 PREVIEW_BUF_NUM);
1087 if (NULL == s_metadata) {
1088 LOGE("add metadata stream failed\n");
1089 mm_app_del_channel(test_obj, channel);
1090 return rc;
1091 }
1092
1093 rc = mm_app_start_channel(test_obj, channel);
1094 if (MM_CAMERA_OK != rc) {
1095 LOGE("start zsl failed rc=%d\n", rc);
1096 mm_app_del_stream(test_obj, channel, s_preview);
1097 mm_app_del_stream(test_obj, channel, s_metadata);
1098 mm_app_del_stream(test_obj, channel, s_main);
1099 mm_app_del_channel(test_obj, channel);
1100 return rc;
1101 }
1102
1103 if ( test_obj->enable_reproc ) {
1104 if ( NULL == mm_app_add_reprocess_channel(test_obj, s_main) ) {
1105 LOGE("Reprocess channel failed to initialize \n");
1106 mm_app_del_stream(test_obj, channel, s_preview);
1107 #ifdef USE_METADATA_STREAM
1108 mm_app_del_stream(test_obj, channel, s_metadata);
1109 #endif
1110 mm_app_del_stream(test_obj, channel, s_main);
1111 mm_app_del_channel(test_obj, channel);
1112 return rc;
1113 }
1114 rc = mm_app_start_reprocess(test_obj);
1115 if (MM_CAMERA_OK != rc) {
1116 LOGE("reprocess start failed rc=%d\n", rc);
1117 mm_app_del_stream(test_obj, channel, s_preview);
1118 #ifdef USE_METADATA_STREAM
1119 mm_app_del_stream(test_obj, channel, s_metadata);
1120 #endif
1121 mm_app_del_stream(test_obj, channel, s_main);
1122 mm_app_del_channel(test_obj, channel);
1123 return rc;
1124 }
1125 }
1126
1127 return rc;
1128 }
1129
mm_app_stop_preview_zsl(mm_camera_test_obj_t * test_obj)1130 int mm_app_stop_preview_zsl(mm_camera_test_obj_t *test_obj)
1131 {
1132 int rc = MM_CAMERA_OK;
1133
1134 mm_camera_channel_t *channel =
1135 mm_app_get_channel_by_type(test_obj, MM_CHANNEL_TYPE_ZSL);
1136
1137 rc = mm_app_stop_and_del_channel(test_obj, channel);
1138 if (MM_CAMERA_OK != rc) {
1139 LOGE("Stop Preview failed rc=%d\n", rc);
1140 }
1141
1142 if ( test_obj->enable_reproc ) {
1143 rc |= mm_app_stop_reprocess(test_obj);
1144 }
1145
1146 return rc;
1147 }
1148
mm_app_initialize_fb(mm_camera_test_obj_t * test_obj)1149 int mm_app_initialize_fb(mm_camera_test_obj_t *test_obj)
1150 {
1151 int rc = MM_CAMERA_OK;
1152 int brightness_fd;
1153 const char brightness_level[] = BACKLIGHT_LEVEL;
1154 void *fb_base = NULL;
1155
1156 assert( ( NULL != test_obj ) && ( 0 == test_obj->fb_fd ) );
1157
1158 test_obj->fb_fd = open(FB_PATH, O_RDWR);
1159 if ( 0 > test_obj->fb_fd ) {
1160 LOGE("FB device open failed rc=%d, %s\n",
1161 -errno,
1162 strerror(errno));
1163 rc = -errno;
1164 goto FAIL;
1165 }
1166
1167 rc = ioctl(test_obj->fb_fd, FBIOGET_VSCREENINFO, &test_obj->vinfo);
1168 if ( MM_CAMERA_OK != rc ) {
1169 LOGE("Can not retrieve screen info rc=%d, %s\n",
1170 -errno,
1171 strerror(errno));
1172 rc = -errno;
1173 goto FAIL;
1174 }
1175
1176 if ( ( 0 == test_obj->vinfo.yres_virtual ) ||
1177 ( 0 == test_obj->vinfo.yres ) ||
1178 ( test_obj->vinfo.yres > test_obj->vinfo.yres_virtual ) ) {
1179 LOGE("Invalid FB virtual yres: %d, yres: %d\n",
1180 test_obj->vinfo.yres_virtual,
1181 test_obj->vinfo.yres);
1182 rc = MM_CAMERA_E_GENERAL;
1183 goto FAIL;
1184 }
1185
1186 if ( ( 0 == test_obj->vinfo.xres_virtual ) ||
1187 ( 0 == test_obj->vinfo.xres ) ||
1188 ( test_obj->vinfo.xres > test_obj->vinfo.xres_virtual ) ) {
1189 LOGE("Invalid FB virtual xres: %d, xres: %d\n",
1190 test_obj->vinfo.xres_virtual,
1191 test_obj->vinfo.xres);
1192 rc = MM_CAMERA_E_GENERAL;
1193 goto FAIL;
1194 }
1195
1196 brightness_fd = open(BACKLIGHT_CONTROL, O_RDWR);
1197 if ( brightness_fd >= 0 ) {
1198 write(brightness_fd, brightness_level, strlen(brightness_level));
1199 close(brightness_fd);
1200 }
1201
1202 test_obj->slice_size = test_obj->vinfo.xres * ( test_obj->vinfo.yres - 1 ) * DEFAULT_OV_FORMAT_BPP;
1203 memset(&test_obj->data_overlay, 0, sizeof(struct mdp_overlay));
1204 test_obj->data_overlay.src.width = test_obj->buffer_width;
1205 test_obj->data_overlay.src.height = test_obj->buffer_height;
1206 test_obj->data_overlay.src_rect.w = test_obj->buffer_width;
1207 test_obj->data_overlay.src_rect.h = test_obj->buffer_height;
1208 test_obj->data_overlay.dst_rect.w = test_obj->buffer_width;
1209 test_obj->data_overlay.dst_rect.h = test_obj->buffer_height;
1210 test_obj->data_overlay.src.format = DEFAULT_OV_FORMAT;
1211 test_obj->data_overlay.src_rect.x = 0;
1212 test_obj->data_overlay.src_rect.y = 0;
1213 test_obj->data_overlay.dst_rect.x = 0;
1214 test_obj->data_overlay.dst_rect.y = 0;
1215 test_obj->data_overlay.z_order = 2;
1216 test_obj->data_overlay.alpha = 0x80;
1217 test_obj->data_overlay.transp_mask = 0xffe0;
1218 test_obj->data_overlay.flags = MDP_FLIP_LR | MDP_FLIP_UD;
1219
1220 // Map and clear FB portion
1221 fb_base = mmap(0,
1222 test_obj->slice_size,
1223 PROT_WRITE,
1224 MAP_SHARED,
1225 test_obj->fb_fd,
1226 0);
1227 if ( MAP_FAILED == fb_base ) {
1228 LOGE("( Error while memory mapping frame buffer %s",
1229 strerror(errno));
1230 rc = -errno;
1231 goto FAIL;
1232 }
1233
1234 memset(fb_base, 0, test_obj->slice_size);
1235
1236 if (ioctl(test_obj->fb_fd, FBIOPAN_DISPLAY, &test_obj->vinfo) < 0) {
1237 LOGE("FBIOPAN_DISPLAY failed!");
1238 rc = -errno;
1239 goto FAIL;
1240 }
1241
1242 munmap(fb_base, test_obj->slice_size);
1243 test_obj->data_overlay.id = (uint32_t)MSMFB_NEW_REQUEST;
1244 rc = ioctl(test_obj->fb_fd, MSMFB_OVERLAY_SET, &test_obj->data_overlay);
1245 if (rc < 0) {
1246 LOGE("MSMFB_OVERLAY_SET failed! err=%d\n",
1247 test_obj->data_overlay.id);
1248 return MM_CAMERA_E_GENERAL;
1249 }
1250 LOGE("Overlay set with overlay id: %d", test_obj->data_overlay.id);
1251
1252 return rc;
1253
1254 FAIL:
1255
1256 if ( 0 < test_obj->fb_fd ) {
1257 close(test_obj->fb_fd);
1258 }
1259
1260 return rc;
1261 }
1262
mm_app_close_fb(mm_camera_test_obj_t * test_obj)1263 int mm_app_close_fb(mm_camera_test_obj_t *test_obj)
1264 {
1265 int rc = MM_CAMERA_OK;
1266
1267 assert( ( NULL != test_obj ) && ( 0 < test_obj->fb_fd ) );
1268
1269 if (ioctl(test_obj->fb_fd, MSMFB_OVERLAY_UNSET, &test_obj->data_overlay.id)) {
1270 LOGE("\nERROR! MSMFB_OVERLAY_UNSET failed! (Line %d)\n");
1271 }
1272
1273 if (ioctl(test_obj->fb_fd, FBIOPAN_DISPLAY, &test_obj->vinfo) < 0) {
1274 LOGE("ERROR: FBIOPAN_DISPLAY failed! line=%d\n");
1275 }
1276
1277 close(test_obj->fb_fd);
1278 test_obj->fb_fd = -1;
1279
1280 return rc;
1281 }
1282
memset16(void * pDst,uint16_t value,int count)1283 void memset16(void *pDst, uint16_t value, int count)
1284 {
1285 uint16_t *ptr = pDst;
1286 while (count--)
1287 *ptr++ = value;
1288 }
1289
mm_app_overlay_display(mm_camera_test_obj_t * test_obj,int bufferFd)1290 int mm_app_overlay_display(mm_camera_test_obj_t *test_obj, int bufferFd)
1291 {
1292 int rc = MM_CAMERA_OK;
1293 struct msmfb_overlay_data ovdata;
1294
1295
1296 memset(&ovdata, 0, sizeof(struct msmfb_overlay_data));
1297 ovdata.id = test_obj->data_overlay.id;
1298 ovdata.data.memory_id = bufferFd;
1299
1300 if (ioctl(test_obj->fb_fd, MSMFB_OVERLAY_PLAY, &ovdata)) {
1301 LOGE("MSMFB_OVERLAY_PLAY failed!");
1302 return MM_CAMERA_E_GENERAL;
1303 }
1304
1305 if (ioctl(test_obj->fb_fd, FBIOPAN_DISPLAY, &test_obj->vinfo) < 0) {
1306 LOGE("FBIOPAN_DISPLAY failed!");
1307 return MM_CAMERA_E_GENERAL;
1308 }
1309
1310 return rc;
1311 }
1312