1 /* Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
2  *
3  * Redistribution and use in source and binary forms, with or without
4  * modification, are permitted provided that the following conditions are
5  * met:
6  *     * Redistributions of source code must retain the above copyright
7  *       notice, this list of conditions and the following disclaimer.
8  *     * Redistributions in binary form must reproduce the above
9  *       copyright notice, this list of conditions and the following
10  *       disclaimer in the documentation and/or other materials provided
11  *       with the distribution.
12  *     * Neither the name of The Linux Foundation nor the names of its
13  *       contributors may be used to endorse or promote products derived
14  *       from this software without specific prior written permission.
15  *
16  * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
17  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
20  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
23  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
24  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
25  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
26  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28  /*#error uncomment this for compiler test!*/
29 //#define ALOG_NDEBUG 0
30 #define ALOG_NIDEBUG 0
31 #define LOG_TAG "QualcommUsbCamera"
32 
33 #include <utils/Log.h>
34 #include <utils/threads.h>
35 #include <fcntl.h>
36 #include <sys/mman.h>
37 #include <sys/stat.h>
38 #include <unistd.h>
39 #include <sys/prctl.h>
40 #include <sys/resource.h>
41 #include <pthread.h>
42 #include <linux/uvcvideo.h>
43 
44 #include "QCameraHAL.h"
45 #include "QualcommUsbCamera.h"
46 #include "QCameraUsbPriv.h"
47 #include "QCameraMjpegDecode.h"
48 #include "QCameraUsbParm.h"
49 #include <gralloc_priv.h>
50 #include <genlock.h>
51 
52 extern "C" {
53 #include <sys/time.h>
54 }
55 
56 camera_device_ops_t usbcam_camera_ops = {
57   set_preview_window:         android::usbcam_set_preview_window,
58   set_callbacks:              android::usbcam_set_CallBacks,
59   enable_msg_type:            android::usbcam_enable_msg_type,
60   disable_msg_type:           android::usbcam_disable_msg_type,
61   msg_type_enabled:           android::usbcam_msg_type_enabled,
62 
63   start_preview:              android::usbcam_start_preview,
64   stop_preview:               android::usbcam_stop_preview,
65   preview_enabled:            android::usbcam_preview_enabled,
66   store_meta_data_in_buffers: android::usbcam_store_meta_data_in_buffers,
67 
68   start_recording:            android::usbcam_start_recording,
69   stop_recording:             android::usbcam_stop_recording,
70   recording_enabled:          android::usbcam_recording_enabled,
71   release_recording_frame:    android::usbcam_release_recording_frame,
72 
73   auto_focus:                 android::usbcam_auto_focus,
74   cancel_auto_focus:          android::usbcam_cancel_auto_focus,
75 
76   take_picture:               android::usbcam_take_picture,
77   cancel_picture:             android::usbcam_cancel_picture,
78 
79   set_parameters:             android::usbcam_set_parameters,
80   get_parameters:             android::usbcam_get_parameters,
81   put_parameters:             android::usbcam_put_parameters,
82   send_command:               android::usbcam_send_command,
83 
84   release:                    android::usbcam_release,
85   dump:                       android::usbcam_dump,
86 };
87 
88 #define CAPTURE                 1
89 #define DISPLAY                 1
90 #define CALL_BACK               1
91 #define MEMSET                  0
92 #define FREAD_JPEG_PICTURE      0
93 #define JPEG_ON_USB_CAMERA      1
94 #define FILE_DUMP_CAMERA        0
95 #define FILE_DUMP_B4_DISP       0
96 
97 namespace android {
98 
99 static int initUsbCamera(               camera_hardware_t *camHal,
100                                         int width, int height,
101                                         int pixelFormat);
102 static int startUsbCamCapture(          camera_hardware_t *camHal);
103 static int stopUsbCamCapture(           camera_hardware_t *camHal);
104 static int initV4L2mmap(                camera_hardware_t *camHal);
105 static int unInitV4L2mmap(              camera_hardware_t *camHal);
106 static int launch_preview_thread(       camera_hardware_t *camHal);
107 static int launchTakePictureThread(     camera_hardware_t *camHal);
108 static int initDisplayBuffers(          camera_hardware_t *camHal);
109 static int deInitDisplayBuffers(        camera_hardware_t *camHal);
110 static int stopPreviewInternal(         camera_hardware_t *camHal);
111 static int get_buf_from_cam(            camera_hardware_t *camHal);
112 static int put_buf_to_cam(              camera_hardware_t *camHal);
113 static int prvwThreadTakePictureInternal(camera_hardware_t *camHal);
114 static int get_buf_from_display( camera_hardware_t *camHal, int *buffer_id);
115 static int put_buf_to_display(   camera_hardware_t *camHal, int buffer_id);
116 static int convert_data_frm_cam_to_disp(camera_hardware_t *camHal, int buffer_id);
117 static void * previewloop(void *);
118 static void * takePictureThread(void *);
119 static int convert_YUYV_to_420_NV12(char *in_buf, char *out_buf, int wd, int ht);
120 static int get_uvc_device(char *devname);
121 static int getPreviewCaptureFmt(camera_hardware_t *camHal);
122 static int allocate_ion_memory(QCameraHalMemInfo_t *mem_info, int ion_type);
123 static int deallocate_ion_memory(QCameraHalMemInfo_t *mem_info);
124 static int ioctlLoop(int fd, int ioctlCmd, void *args);
125 static int readFromFile(char* fileName, char* buffer, int bufferSize);
126 static int fileDump(const char* fileName, char* data, int length, int* frm_cnt);
127 static int encodeJpeg(                  camera_hardware_t *camHal);
128 void jpegEncodeCb   (jpeg_job_status_t status,
129                        uint8_t thumbnailDroppedFlag,
130                        uint32_t client_hdl,
131                        uint32_t jobId,
132                        uint8_t* out_data,
133                        uint32_t data_size,
134                        void *userData);
135 
136 /* HAL function implementation goes here*/
137 
138 /**
139  * The functions need to be provided by the camera HAL.
140  *
141  * If getNumberOfCameras() returns N, the valid cameraId for getCameraInfo()
142  * and openCameraHardware() is 0 to N-1.
143  */
144 
usbcam_get_number_of_cameras()145 extern "C" int usbcam_get_number_of_cameras()
146 {
147     /* TBR: This is hardcoded currently to 1 USB camera */
148     int numCameras = 1;
149     ALOGI("%s: E", __func__);
150     ALOGI("%s: X", __func__);
151 
152     return numCameras;
153 }
154 
usbcam_get_camera_info(int camera_id,struct camera_info * info)155 extern "C" int usbcam_get_camera_info(int camera_id, struct camera_info *info)
156 {
157     int rc = -1;
158     ALOGI("%s: E", __func__);
159 
160     /* TBR: This info is hardcoded currently irrespective of camera_id */
161     if(info) {
162         struct CameraInfo camInfo;
163         memset(&camInfo, -1, sizeof (struct CameraInfo));
164 
165         info->facing = CAMERA_FACING_FRONT;//CAMERA_FACING_BACK;
166         info->orientation = 0;
167         rc = 0;
168     }
169     ALOGI("%s: X", __func__);
170     return rc;
171 }
172 
173 /* HAL should return NULL handle if it fails to open camera hardware. */
usbcam_camera_device_open(const struct hw_module_t * module,const char * id,struct hw_device_t ** hw_device)174 extern "C" int  usbcam_camera_device_open(
175   const struct hw_module_t* module, const char* id,
176           struct hw_device_t** hw_device)
177 {
178     int rc = -1;
179     camera_device       *device = NULL;
180     camera_hardware_t   *camHal;
181     char                *dev_name;
182 
183     ALOGI("%s: E", __func__);
184 
185     /* initialize return handle value to NULL */
186     *hw_device = NULL;
187 
188     camHal = new camera_hardware_t();
189     if(!camHal) {
190 
191             ALOGE("%s:  end in no mem", __func__);
192             return -1;
193     }
194 
195     rc = usbCamInitDefaultParameters(camHal);
196     if(0 != rc)
197     {
198         ALOGE("%s: usbCamInitDefaultParameters error", __func__);
199         return rc;
200     }
201 #if CAPTURE
202 
203     dev_name = camHal->dev_name;
204 
205     rc = get_uvc_device(dev_name);
206     if(rc || *dev_name == '\0'){
207         ALOGE("%s: No UVC node found \n", __func__);
208         return -1;
209     }
210 
211     camHal->fd = open(dev_name, O_RDWR /* required */ | O_NONBLOCK, 0);
212 
213     if (camHal->fd <  0) {
214         ALOGE("%s: Cannot open '%s'", __func__, dev_name);
215         free(camHal);
216         rc = -1;
217     }else{
218         rc = 0;
219     }
220 
221 #else /* CAPTURE */
222     rc = 0;
223 #endif /* CAPTURE */
224 
225     device                  = &camHal->hw_dev;
226     device->common.close    = usbcam_close_camera_device;
227     device->ops             = &usbcam_camera_ops;
228     device->priv            = (void *)camHal;
229     *hw_device              = &(device->common);
230 
231     ALOGD("%s: camHal: %p", __func__, camHal);
232     ALOGI("%s: X %d", __func__, rc);
233 
234     return rc;
235 }
236 
usbcam_close_camera_device(hw_device_t * hw_dev)237 extern "C"  int usbcam_close_camera_device( hw_device_t *hw_dev)
238 {
239     ALOGI("%s: device =%p E", __func__, hw_dev);
240     int rc =  -1;
241     camera_device_t *device     = (camera_device_t *)hw_dev;
242 
243     if(device) {
244         camera_hardware_t *camHal   = (camera_hardware_t *)device->priv;
245         if(camHal) {
246             rc = close(camHal->fd);
247             if(rc < 0) {
248                 ALOGE("%s: close failed ", __func__);
249             }
250             camHal->fd = 0;
251             delete camHal;
252         }else{
253                 ALOGE("%s: camHal is NULL pointer ", __func__);
254         }
255     }
256     ALOGI("%s: X device =%p, rc = %d", __func__, hw_dev, rc);
257     return rc;
258 }
259 
usbcam_set_preview_window(struct camera_device * device,struct preview_stream_ops * window)260 int usbcam_set_preview_window(struct camera_device * device,
261         struct preview_stream_ops *window)
262 {
263     ALOGI("%s: E", __func__);
264     int rc = 0;
265     camera_hardware_t *camHal;
266 
267     VALIDATE_DEVICE_HDL(camHal, device, -1);
268     Mutex::Autolock autoLock(camHal->lock);
269 
270     /* if window is already set, then de-init previous buffers */
271     if(camHal->window){
272         rc = deInitDisplayBuffers(camHal);
273         if(rc < 0) {
274             ALOGE("%s: deInitDisplayBuffers returned error", __func__);
275         }
276     }
277     camHal->window = window;
278 
279     if(camHal->window){
280         rc = initDisplayBuffers(camHal);
281         if(rc < 0) {
282             ALOGE("%s: initDisplayBuffers returned error", __func__);
283         }
284     }
285     ALOGI("%s: X. rc = %d", __func__, rc);
286     return rc;
287 }
288 
usbcam_set_CallBacks(struct camera_device * device,camera_notify_callback notify_cb,camera_data_callback data_cb,camera_data_timestamp_callback data_cb_timestamp,camera_request_memory get_memory,void * user)289 void usbcam_set_CallBacks(struct camera_device * device,
290         camera_notify_callback notify_cb,
291         camera_data_callback data_cb,
292         camera_data_timestamp_callback data_cb_timestamp,
293         camera_request_memory get_memory,
294         void *user)
295 {
296     ALOGI("%s: E", __func__);
297     camera_hardware_t *camHal;
298 
299     if(device && device->priv){
300         camHal = (camera_hardware_t *)device->priv;
301     }else{
302         ALOGE("%s: Null device or device->priv", __func__);
303         return;
304     }
305 
306     Mutex::Autolock autoLock(camHal->lock);
307 
308     camHal->notify_cb           = notify_cb;
309     camHal->data_cb             = data_cb;
310     camHal->data_cb_timestamp   = data_cb_timestamp;
311     camHal->get_memory          = get_memory;
312     camHal->cb_ctxt             = user;
313 
314     ALOGI("%s: X", __func__);
315 }
316 
usbcam_enable_msg_type(struct camera_device * device,int32_t msg_type)317 void usbcam_enable_msg_type(struct camera_device * device, int32_t msg_type)
318 {
319     ALOGI("%s: E", __func__);
320     ALOGI("%s: msg_type: %d", __func__, msg_type);
321 
322     camera_hardware_t *camHal;
323 
324     if(device && device->priv){
325         camHal = (camera_hardware_t *)device->priv;
326     }else{
327         ALOGE("%s: Null device or device->priv", __func__);
328         return;
329     }
330 
331     Mutex::Autolock autoLock(camHal->lock);
332 
333     camHal->msgEnabledFlag |= msg_type;
334 
335     ALOGI("%s: X", __func__);
336 }
337 
usbcam_disable_msg_type(struct camera_device * device,int32_t msg_type)338 void usbcam_disable_msg_type(struct camera_device * device, int32_t msg_type)
339 {
340     ALOGI("%s: E", __func__);
341     ALOGI("%s: msg_type: %d", __func__, msg_type);
342 
343     camera_hardware_t *camHal;
344     if(device && device->priv){
345         camHal = (camera_hardware_t *)device->priv;
346     }else{
347         ALOGE("%s: Null device or device->priv", __func__);
348         return;
349     }
350 
351     Mutex::Autolock autoLock(camHal->lock);
352 
353     camHal->msgEnabledFlag &= ~msg_type;
354 
355     ALOGI("%s: X", __func__);
356 }
357 
usbcam_msg_type_enabled(struct camera_device * device,int32_t msg_type)358 int usbcam_msg_type_enabled(struct camera_device * device, int32_t msg_type)
359 {
360     ALOGI("%s: E", __func__);
361 
362     camera_hardware_t *camHal;
363     if(device && device->priv){
364         camHal = (camera_hardware_t *)device->priv;
365     }else{
366         ALOGE("%s: Null device or device->priv", __func__);
367         return -1;
368     }
369 
370     Mutex::Autolock autoLock(camHal->lock);
371 
372     ALOGI("%s: X", __func__);
373     return (camHal->msgEnabledFlag & msg_type);
374 }
375 
usbcam_start_preview(struct camera_device * device)376 int usbcam_start_preview(struct camera_device * device)
377 {
378     ALOGI("%s: E", __func__);
379 
380     int rc = -1;
381     camera_hardware_t *camHal = NULL;
382 
383     VALIDATE_DEVICE_HDL(camHal, device, -1);
384     Mutex::Autolock autoLock(camHal->lock);
385 
386     /* If preivew is already running, nothing to be done */
387     if(camHal->previewEnabledFlag){
388         ALOGI("%s: Preview is already running", __func__);
389         return 0;
390     }
391 
392 #if CAPTURE
393     rc = initUsbCamera(camHal, camHal->prevWidth,
394                         camHal->prevHeight, getPreviewCaptureFmt(camHal));
395     if(rc < 0) {
396         ALOGE("%s: Failed to intialize the device", __func__);
397     }else{
398         rc = startUsbCamCapture(camHal);
399         if(rc < 0) {
400             ALOGE("%s: Failed to startUsbCamCapture", __func__);
401         }else{
402             rc = launch_preview_thread(camHal);
403             if(rc < 0) {
404                 ALOGE("%s: Failed to launch_preview_thread", __func__);
405             }
406         }
407     }
408 #else /* CAPTURE */
409     rc = launch_preview_thread(camHal);
410     if(rc < 0) {
411         ALOGE("%s: Failed to launch_preview_thread", __func__);
412     }
413 #endif /* CAPTURE */
414     /* if no errors, then set the flag */
415     if(!rc)
416         camHal->previewEnabledFlag = 1;
417 
418     ALOGD("%s: X", __func__);
419     return rc;
420 }
421 
usbcam_stop_preview(struct camera_device * device)422 void usbcam_stop_preview(struct camera_device * device)
423 {
424     ALOGD("%s: E", __func__);
425 
426     int rc = 0;
427     camera_hardware_t *camHal;
428 
429     if(device && device->priv){
430         camHal = (camera_hardware_t *)device->priv;
431     }else{
432         ALOGE("%s: Null device or device->priv", __func__);
433         return;
434     }
435 
436     Mutex::Autolock autoLock(camHal->lock);
437 
438     rc = stopPreviewInternal(camHal);
439     if(rc)
440         ALOGE("%s: stopPreviewInternal returned error", __func__);
441 
442     ALOGI("%s: X", __func__);
443     return;
444 }
445 
446 /* This function is equivalent to is_preview_enabled */
usbcam_preview_enabled(struct camera_device * device)447 int usbcam_preview_enabled(struct camera_device * device)
448 {
449     ALOGI("%s: E", __func__);
450     camera_hardware_t *camHal;
451 
452     if(device && device->priv){
453         camHal = (camera_hardware_t *)device->priv;
454     }else{
455         ALOGE("%s: Null device or device->priv", __func__);
456         return -1;
457     }
458     Mutex::Autolock autoLock(camHal->lock);
459 
460     ALOGI("%s: X", __func__);
461     return camHal->previewEnabledFlag;
462 }
463 
464 /* TBD */
usbcam_store_meta_data_in_buffers(struct camera_device * device,int enable)465 int usbcam_store_meta_data_in_buffers(struct camera_device * device, int enable)
466 {
467     ALOGI("%s: E", __func__);
468     int rc = 0;
469 
470     ALOGI("%s: X", __func__);
471     return rc;
472 }
473 
474 /* TBD */
usbcam_start_recording(struct camera_device * device)475 int usbcam_start_recording(struct camera_device * device)
476 {
477     int rc = 0;
478     ALOGD("%s: E", __func__);
479 
480     ALOGD("%s: X", __func__);
481 
482     return rc;
483 }
484 
485 /* TBD */
usbcam_stop_recording(struct camera_device * device)486 void usbcam_stop_recording(struct camera_device * device)
487 {
488     ALOGD("%s: E", __func__);
489 
490     ALOGD("%s: X", __func__);
491 }
492 
493 /* TBD */
usbcam_recording_enabled(struct camera_device * device)494 int usbcam_recording_enabled(struct camera_device * device)
495 {
496     int rc = 0;
497     ALOGD("%s: E", __func__);
498 
499     ALOGD("%s: X", __func__);
500     return rc;
501 }
502 
503 /* TBD */
usbcam_release_recording_frame(struct camera_device * device,const void * opaque)504 void usbcam_release_recording_frame(struct camera_device * device,
505                 const void *opaque)
506 {
507     ALOGV("%s: E", __func__);
508 
509     ALOGD("%s: X", __func__);
510 }
511 
512 /* TBD */
usbcam_auto_focus(struct camera_device * device)513 int usbcam_auto_focus(struct camera_device * device)
514 {
515     ALOGD("%s: E", __func__);
516     int rc = 0;
517 
518     ALOGD("%s: X", __func__);
519     return rc;
520 }
521 
522 /* TBD */
usbcam_cancel_auto_focus(struct camera_device * device)523 int usbcam_cancel_auto_focus(struct camera_device * device)
524 {
525     int rc = 0;
526     ALOGD("%s: E", __func__);
527 
528     ALOGD("%s: X", __func__);
529     return rc;
530 }
531 
usbcam_take_picture(struct camera_device * device)532 int usbcam_take_picture(struct camera_device * device)
533 {
534     ALOGI("%s: E", __func__);
535     int rc = 0;
536     camera_hardware_t *camHal;
537 
538     VALIDATE_DEVICE_HDL(camHal, device, -1);
539 
540     Mutex::Autolock autoLock(camHal->lock);
541 
542     /* If take picture is already in progress, nothing t be done */
543     if(camHal->takePictInProgress){
544         ALOGI("%s: Take picture already in progress", __func__);
545         return 0;
546     }
547 
548     if(camHal->previewEnabledFlag)
549     {
550         rc = stopPreviewInternal(camHal);
551         if(rc){
552             ALOGE("%s: stopPreviewInternal returned error", __func__);
553         }
554         USB_CAM_CLOSE(camHal);
555         camHal->prvwStoppedForPicture = 1;
556     }
557     /* TBD: Need to handle any dependencies on video recording state */
558     rc = launchTakePictureThread(camHal);
559     if(rc)
560         ALOGE("%s: launchTakePictureThread error", __func__);
561 
562 #if 0
563     /* This implementation requests preview thread to take picture */
564     if(camHal->previewEnabledFlag)
565     {
566         camHal->prvwCmdPending++;
567         camHal->prvwCmd         = USB_CAM_PREVIEW_TAKEPIC;
568         ALOGD("%s: Take picture command set ", __func__);
569     }else{
570         ALOGE("%s: Take picture without preview started!", __func__);
571         rc = -1;
572     }
573 #endif
574 
575     if(!rc)
576         camHal->takePictInProgress = 1;
577 
578     ALOGI("%s: X", __func__);
579     return rc;
580 }
581 
582 /* TBD */
usbcam_cancel_picture(struct camera_device * device)583 int usbcam_cancel_picture(struct camera_device * device)
584 
585 {
586     ALOGI("%s: E", __func__);
587     int rc = 0;
588 
589     ALOGI("%s: X", __func__);
590     return rc;
591 }
592 
usbcam_set_parameters(struct camera_device * device,const char * params)593 int usbcam_set_parameters(struct camera_device * device, const char *params)
594 
595 {
596     ALOGI("%s: E", __func__);
597     int rc = 0;
598     camera_hardware_t *camHal;
599 
600     VALIDATE_DEVICE_HDL(camHal, device, -1);
601 
602     Mutex::Autolock autoLock(camHal->lock);
603 
604     rc = usbCamSetParameters(camHal, params);
605 
606     ALOGI("%s: X", __func__);
607     return rc;
608 }
609 
usbcam_get_parameters(struct camera_device * device)610 char* usbcam_get_parameters(struct camera_device * device)
611 {
612     char *parms;
613     ALOGI("%s: E", __func__);
614 
615     camera_hardware_t *camHal;
616     VALIDATE_DEVICE_HDL(camHal, device, NULL);
617 
618     Mutex::Autolock autoLock(camHal->lock);
619 
620     parms = usbCamGetParameters(camHal);
621 
622     ALOGI("%s: X", __func__);
623     return parms;
624 }
625 
usbcam_put_parameters(struct camera_device * device,char * parm)626 void usbcam_put_parameters(struct camera_device * device, char *parm)
627 
628 {
629     ALOGI("%s: E", __func__);
630 
631     camera_hardware_t *camHal;
632 
633     if(device && device->priv){
634         camHal = (camera_hardware_t *)device->priv;
635     }else{
636         ALOGE("%s: Null device or device->priv", __func__);
637         return;
638     }
639 
640     usbCamPutParameters(camHal, parm);
641 
642     ALOGI("%s: X", __func__);
643     return;
644 }
645 
646 /* TBD */
usbcam_send_command(struct camera_device * device,int32_t cmd,int32_t arg1,int32_t arg2)647 int usbcam_send_command(struct camera_device * device,
648             int32_t cmd, int32_t arg1, int32_t arg2)
649 {
650     int rc = 0;
651     ALOGI("%s: E", __func__);
652     ALOGI("%d", cmd);
653 
654     ALOGI("%s: X", __func__);
655     return rc;
656 }
657 
658 /* TBD */
usbcam_release(struct camera_device * device)659 void usbcam_release(struct camera_device * device)
660 {
661     ALOGI("%s: E", __func__);
662 #if 0
663     Mutex::Autolock l(&mLock);
664 
665     switch(mPreviewState) {
666     case QCAMERA_HAL_PREVIEW_STOPPED:
667         break;
668     case QCAMERA_HAL_PREVIEW_START:
669         break;
670     case QCAMERA_HAL_PREVIEW_STARTED:
671         stopPreviewInternal();
672     break;
673     case QCAMERA_HAL_RECORDING_STARTED:
674         stopRecordingInternal();
675         stopPreviewInternal();
676         break;
677     case QCAMERA_HAL_TAKE_PICTURE:
678         cancelPictureInternal();
679         break;
680     default:
681         break;
682     }
683     mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED;
684 #endif
685     ALOGI("%s: X", __func__);
686 }
687 
688 /* TBD */
usbcam_dump(struct camera_device * device,int fd)689 int usbcam_dump(struct camera_device * device, int fd)
690 {
691     ALOGI("%s: E", __func__);
692     int rc = 0;
693 
694     ALOGI("%s: X", __func__);
695     return rc;
696 }
697 /*****************************************************************************
698 *  Static function definitions below
699 *****************************************************************************/
700 
701 /******************************************************************************/
702 /* No in place conversion supported. Output buffer and input MUST should be   */
703 /* different input buffer for a 4x4 pixel video                             ***/
704 /******                  YUYVYUYV          00 01 02 03 04 05 06 07 ************/
705 /******                  YUYVYUYV          08 09 10 11 12 13 14 15 ************/
706 /******                  YUYVYUYV          16 17 18 19 20 21 22 23 ************/
707 /******                  YUYVYUYV          24 25 26 27 28 29 30 31 ************/
708 /******************************************************************************/
709 /* output generated by this function ******************************************/
710 /************************** YYYY            00 02 04 06            ************/
711 /************************** YYYY            08 10 12 14            ************/
712 /************************** YYYY            16 18 20 22            ************/
713 /************************** YYYY            24 26 28 30            ************/
714 /************************** VUVU            03 01 07 05            ************/
715 /************************** VUVU            19 17 23 21            ************/
716 /******************************************************************************/
717 
convert_YUYV_to_420_NV12(char * in_buf,char * out_buf,int wd,int ht)718 static int convert_YUYV_to_420_NV12(char *in_buf, char *out_buf, int wd, int ht)
719 {
720     int rc =0;
721     int row, col, uv_row;
722 
723     ALOGD("%s: E", __func__);
724     /* Arrange Y */
725     for(row = 0; row < ht; row++)
726         for(col = 0; col < wd * 2; col += 2)
727         {
728             out_buf[row * wd + col / 2] = in_buf[row * wd * 2 + col];
729         }
730 
731     /* Arrange UV */
732     for(row = 0, uv_row = ht; row < ht; row += 2, uv_row++)
733         for(col = 1; col < wd * 2; col += 4)
734         {
735             out_buf[uv_row * wd + col / 2]= in_buf[row * wd * 2 + col + 2];
736             out_buf[uv_row * wd + col / 2 + 1]  = in_buf[row * wd * 2 + col];
737         }
738 
739     ALOGD("%s: X", __func__);
740     return rc;
741 }
742 
743 /******************************************************************************
744  * Function: initDisplayBuffers
745  * Description: This function initializes the preview buffers
746  *
747  * Input parameters:
748  *   camHal              - camera HAL handle
749  *
750  * Return values:
751  *      0   Success
752  *      -1  Error
753  * Notes: none
754  *****************************************************************************/
initDisplayBuffers(camera_hardware_t * camHal)755 static int initDisplayBuffers(camera_hardware_t *camHal)
756 {
757     preview_stream_ops    *mPreviewWindow;
758     struct ion_fd_data    ion_info_fd;
759     int                   numMinUndequeuedBufs = 0;
760     int                   rc = 0;
761     int                   gralloc_usage = 0;
762     int                   err;
763     int                   color=30;
764 
765     ALOGD("%s: E", __func__);
766 
767 #if DISPLAY
768     if(camHal == NULL) {
769         ALOGE("%s: camHal = NULL", __func__);
770         return -1;
771     }
772 
773     mPreviewWindow = camHal->window;
774     if(!mPreviewWindow) {
775         ALOGE("%s: mPreviewWindow = NULL", __func__);
776         return -1;
777     }
778 
779     /************************************************************************/
780     /* - get_min_undequeued_buffer_count                                    */
781     /* - set_buffer_count                                                   */
782     /* - set_buffers_geometry                                               */
783     /* - set_usage                                                          */
784     /* - dequeue all the display buffers                                    */
785     /* - cancel buffers: release w/o displaying                             */
786     /************************************************************************/
787 
788     /************************************************************************/
789     /* - get_min_undequeued_buffer_count                                    */
790     /************************************************************************/
791     if(mPreviewWindow->get_min_undequeued_buffer_count) {
792         rc = mPreviewWindow->get_min_undequeued_buffer_count(
793             mPreviewWindow, &numMinUndequeuedBufs);
794         if (0 != rc) {
795             ALOGE("%s: get_min_undequeued_buffer_count returned error", __func__);
796         }
797         else
798             ALOGD("%s: get_min_undequeued_buffer_count returned: %d ",
799                __func__, numMinUndequeuedBufs);
800     }
801     else
802         ALOGE("%s: get_min_undequeued_buffer_count is NULL pointer", __func__);
803 
804     /************************************************************************/
805     /* - set_buffer_count                                                   */
806     /************************************************************************/
807     if(mPreviewWindow->set_buffer_count) {
808         camHal->previewMem.buffer_count = numMinUndequeuedBufs
809                                             + PRVW_DISP_BUF_CNT;
810         rc = mPreviewWindow->set_buffer_count(
811             mPreviewWindow,
812             camHal->previewMem.buffer_count);
813         if (rc != 0) {
814             ALOGE("%s: set_buffer_count returned error", __func__);
815         }else
816             ALOGD("%s: set_buffer_count returned success", __func__);
817     }else
818         ALOGE("%s: set_buffer_count is NULL pointer", __func__);
819 
820     /************************************************************************/
821     /* - set_buffers_geometry                                               */
822     /************************************************************************/
823     if(mPreviewWindow->set_buffers_geometry) {
824         rc = mPreviewWindow->set_buffers_geometry(mPreviewWindow,
825                                                 camHal->dispWidth,
826                                                 camHal->dispHeight,
827                                                 camHal->dispFormat);
828         if (rc != 0) {
829             ALOGE("%s: set_buffers_geometry returned error. %s (%d)",
830                __func__, strerror(-rc), -rc);
831         }else
832             ALOGD("%s: set_buffers_geometry returned success", __func__);
833     }else
834         ALOGE("%s: set_buffers_geometry is NULL pointer", __func__);
835 
836     /************************************************************************/
837     /* - set_usage                                                          */
838     /************************************************************************/
839     gralloc_usage = CAMERA_GRALLOC_HEAP_ID | CAMERA_GRALLOC_FALLBACK_HEAP_ID |
840                     GRALLOC_USAGE_PRIVATE_UNCACHED;
841 
842     if(mPreviewWindow->set_usage) {
843         rc = mPreviewWindow->set_usage(mPreviewWindow, gralloc_usage);
844         if (rc != 0) {
845             ALOGE("%s: set_usage returned error", __func__);
846         }else
847             ALOGD("%s: set_usage returned success", __func__);
848     }
849     else
850         ALOGE("%s: set_usage is NULL pointer", __func__);
851 
852     /************************************************************************/
853     /* - dequeue all the display buffers                                    */
854     /************************************************************************/
855     for (int cnt = 0; cnt < camHal->previewMem.buffer_count; cnt++) {
856         int stride;
857         err = mPreviewWindow->dequeue_buffer(
858                 mPreviewWindow,
859                 &camHal->previewMem.buffer_handle[cnt],
860                 &camHal->previewMem.stride[cnt]);
861         if(!err) {
862             ALOGD("%s: dequeue buf: %p\n",
863                  __func__, camHal->previewMem.buffer_handle[cnt]);
864 
865             if(mPreviewWindow->lock_buffer) {
866                 err = mPreviewWindow->lock_buffer(
867                     mPreviewWindow,
868                     camHal->previewMem.buffer_handle[cnt]);
869                 ALOGD("%s: mPreviewWindow->lock_buffer success",
870                      __func__);
871             }
872 
873             // lock the buffer using genlock
874             ALOGD("%s: camera call genlock_lock, hdl=%p",
875                 __func__, (*camHal->previewMem.buffer_handle[cnt]));
876 
877             if (GENLOCK_NO_ERROR !=
878                 genlock_lock_buffer(
879                     (native_handle_t *) (*camHal->previewMem.buffer_handle[cnt]),
880                     GENLOCK_WRITE_LOCK, GENLOCK_MAX_TIMEOUT))
881             {
882                 ALOGE("%s: genlock_lock_buffer(WRITE) failed",
883                     __func__);
884                 camHal->previewMem.local_flag[cnt] = BUFFER_UNLOCKED;
885             }else {
886                 ALOGD("%s: genlock_lock_buffer hdl =%p",
887                   __func__, *camHal->previewMem.buffer_handle[cnt]);
888                 camHal->previewMem.local_flag[cnt] = BUFFER_LOCKED;
889             }
890 
891             /* Store this buffer details in the context */
892             camHal->previewMem.private_buffer_handle[cnt] =
893                 (struct private_handle_t *) (*camHal->previewMem.buffer_handle[cnt]);
894 
895             ALOGD("%s: idx = %d, fd = %d, size = %d, offset = %d", __func__,
896                 cnt, camHal->previewMem.private_buffer_handle[cnt]->fd,
897                 camHal->previewMem.private_buffer_handle[cnt]->size,
898                 camHal->previewMem.private_buffer_handle[cnt]->offset);
899 
900             camHal->previewMem.camera_memory[cnt] =
901                 camHal->get_memory(
902                     camHal->previewMem.private_buffer_handle[cnt]->fd,
903                     camHal->previewMem.private_buffer_handle[cnt]->size,
904                     1, camHal->cb_ctxt);
905 
906             ALOGD("%s: data = %p, size = %d, handle = %p", __func__,
907                 camHal->previewMem.camera_memory[cnt]->data,
908                 camHal->previewMem.camera_memory[cnt]->size,
909                 camHal->previewMem.camera_memory[cnt]->handle);
910 
911 #ifdef USE_ION
912             /* In case of ION usage, open ION fd */
913             camHal->previewMem.mem_info[cnt].main_ion_fd =
914                                                 open("/dev/ion", O_RDONLY);
915             if (camHal->previewMem.mem_info[cnt].main_ion_fd < 0) {
916                 ALOGE("%s: failed: could not open ion device\n", __func__);
917             }else{
918                 memset(&ion_info_fd, 0, sizeof(ion_info_fd));
919                 ion_info_fd.fd =
920                     camHal->previewMem.private_buffer_handle[cnt]->fd;
921                 if (ioctl(camHal->previewMem.mem_info[cnt].main_ion_fd,
922                           ION_IOC_IMPORT, &ion_info_fd) < 0) {
923                     ALOGE("ION import failed\n");
924                 }
925             }
926             camHal->previewMem.mem_info[cnt].fd =
927                 camHal->previewMem.private_buffer_handle[cnt]->fd;
928             camHal->previewMem.mem_info[cnt].size =
929                 camHal->previewMem.private_buffer_handle[cnt]->size;
930             camHal->previewMem.mem_info[cnt].handle = ion_info_fd.handle;
931 
932 #endif
933         }
934         else
935             ALOGE("%s: dequeue buf %d failed \n", __func__, cnt);
936     }
937     /************************************************************************/
938     /* - cancel buffers: queue w/o displaying                               */
939     /************************************************************************/
940     for (int cnt = 0; cnt < camHal->previewMem.buffer_count; cnt++) {
941         if (GENLOCK_FAILURE == genlock_unlock_buffer(
942                 (native_handle_t *)(*(camHal->previewMem.buffer_handle[cnt])))){
943             ALOGE("%s: genlock_unlock_buffer failed: hdl =%p", __func__,
944                 (*(camHal->previewMem.buffer_handle[cnt])) );
945         } else {
946             camHal->previewMem.local_flag[cnt] = BUFFER_UNLOCKED;
947             ALOGD("%s: genlock_unlock_buffer success: hdl = %p",
948                __func__, (*(camHal->previewMem.buffer_handle[cnt])));
949         }
950 
951         err = mPreviewWindow->cancel_buffer(mPreviewWindow,
952             (buffer_handle_t *)camHal->previewMem.buffer_handle[cnt]);
953         if(!err) {
954             ALOGD("%s: cancel_buffer successful: %p\n",
955                  __func__, camHal->previewMem.buffer_handle[cnt]);
956         }else
957             ALOGE("%s: cancel_buffer failed: %p\n", __func__,
958                  camHal->previewMem.buffer_handle[cnt]);
959     }
960 #else
961     rc = 0;
962 #endif /* #if DISPLAY */
963     ALOGD("%s: X", __func__);
964     return rc;
965 }
966 
967 /******************************************************************************
968  * Function: deInitDisplayBuffers
969  * Description: This function de-initializes all the display buffers allocated
970  *              in initDisplayBuffers
971  *
972  * Input parameters:
973  *   camHal              - camera HAL handle
974  *
975  * Return values:
976  *      0   Success
977  *      -1  Error
978  * Notes: none
979  *****************************************************************************/
deInitDisplayBuffers(camera_hardware_t * camHal)980 static int deInitDisplayBuffers(camera_hardware_t *camHal)
981 {
982     int rc = 0;
983     preview_stream_ops    *previewWindow;
984 
985     ALOGD("%s: E", __func__);
986 
987     if(!camHal || !camHal->window) {
988       ALOGE("%s: camHal = NULL or window = NULL ", __func__);
989       return -1;
990     }
991 
992     previewWindow = camHal->window;
993 
994     /************************************************************************/
995     /* - Release all buffers that were acquired using get_memory            */
996     /* - If using ION memory, free ION related resources                    */
997     /* - genUnlock if buffer is genLocked                                   */
998     /* - Cancel buffers: queue w/o displaying                               */
999     /************************************************************************/
1000 
1001 #if DISPLAY
1002     for (int cnt = 0; cnt < camHal->previewMem.buffer_count; cnt++) {
1003 
1004         /* Release all buffers that were acquired using get_memory */
1005         camHal->previewMem.camera_memory[cnt]->release(
1006                                 camHal->previewMem.camera_memory[cnt]);
1007 
1008 #ifdef USE_ION
1009         /* If using ION memory, free ION related resources */
1010         struct ion_handle_data ion_handle;
1011         memset(&ion_handle, 0, sizeof(ion_handle));
1012         ion_handle.handle = camHal->previewMem.mem_info[cnt].handle;
1013         if (ioctl(camHal->previewMem.mem_info[cnt].main_ion_fd,
1014             ION_IOC_FREE, &ion_handle) < 0) {
1015             ALOGE("%s: ion free failed\n", __func__);
1016         }
1017         close(camHal->previewMem.mem_info[cnt].main_ion_fd);
1018 #endif
1019 
1020         /* genUnlock if buffer is genLocked */
1021         if(camHal->previewMem.local_flag[cnt] == BUFFER_LOCKED){
1022             if (GENLOCK_FAILURE == genlock_unlock_buffer(
1023                     (native_handle_t *)(*(camHal->previewMem.buffer_handle[cnt])))){
1024                 ALOGE("%s: genlock_unlock_buffer failed: hdl =%p", __func__,
1025                     (*(camHal->previewMem.buffer_handle[cnt])) );
1026             } else {
1027                 camHal->previewMem.local_flag[cnt] = BUFFER_UNLOCKED;
1028                 ALOGD("%s: genlock_unlock_buffer success: hdl = %p",
1029                    __func__, (*(camHal->previewMem.buffer_handle[cnt])));
1030             }
1031         }
1032         /* cancel buffers: enqueue w/o displaying */
1033         rc = previewWindow->cancel_buffer(previewWindow,
1034             (buffer_handle_t *)camHal->previewMem.buffer_handle[cnt]);
1035         if(!rc) {
1036             ALOGD("%s: cancel_buffer successful: %p\n",
1037                  __func__, camHal->previewMem.buffer_handle[cnt]);
1038         }else
1039             ALOGE("%s: cancel_buffer failed: %p\n", __func__,
1040                  camHal->previewMem.buffer_handle[cnt]);
1041     }
1042 #endif /* #if DISPLAY */
1043     memset(&camHal->previewMem, 0, sizeof(camHal->previewMem));
1044 
1045     ALOGD("%s: X", __func__);
1046     return rc;
1047 }
1048 
1049 /******************************************************************************
1050  * Function: getPreviewCaptureFmt
1051  * Description: This function implements the logic to decide appropriate
1052  *              capture format from the USB camera
1053  *
1054  * Input parameters:
1055  *   camHal              - camera HAL handle
1056  *
1057  * Return values:
1058  *      Capture format. Default (V4L2_PIX_FMT_MJPEG)
1059  *
1060  * Notes: none
1061  *****************************************************************************/
getPreviewCaptureFmt(camera_hardware_t * camHal)1062 static int getPreviewCaptureFmt(camera_hardware_t *camHal)
1063 {
1064     int     i = 0, mjpegSupported = 0, h264Supported = 0;
1065     struct v4l2_fmtdesc fmtdesc;
1066 
1067     memset(&fmtdesc, 0, sizeof(v4l2_fmtdesc));
1068 
1069     /************************************************************************/
1070     /* - Query the camera for all supported formats                         */
1071     /* - Based on the resolution, pick an apporpriate format                */
1072     /************************************************************************/
1073 
1074     /************************************************************************/
1075     /* - Query the camera for all supported formats                         */
1076     /************************************************************************/
1077     for(i = 0; ; i++) {
1078         fmtdesc.index = i;
1079         fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1080         if (-1 == ioctlLoop(camHal->fd, VIDIOC_ENUM_FMT, &fmtdesc)) {
1081             if (EINVAL == errno) {
1082                 ALOGI("%s: Queried all formats till index %d\n", __func__, i);
1083                 break;
1084             } else {
1085                 ALOGE("%s: VIDIOC_ENUM_FMT failed", __func__);
1086             }
1087         }
1088         if(V4L2_PIX_FMT_MJPEG == fmtdesc.pixelformat){
1089             mjpegSupported = 1;
1090             ALOGI("%s: V4L2_PIX_FMT_MJPEG is supported", __func__ );
1091         }
1092         if(V4L2_PIX_FMT_H264 == fmtdesc.pixelformat){
1093             h264Supported = 1;
1094             ALOGI("%s: V4L2_PIX_FMT_H264 is supported", __func__ );
1095         }
1096 
1097     }
1098 
1099     /************************************************************************/
1100     /* - Based on the resolution, pick an apporpriate format                */
1101     /************************************************************************/
1102     //V4L2_PIX_FMT_MJPEG; V4L2_PIX_FMT_YUYV; V4L2_PIX_FMT_H264 = 0x34363248;
1103     camHal->captureFormat = V4L2_PIX_FMT_YUYV;
1104     if(camHal->prevWidth > 640){
1105         if(1 == mjpegSupported)
1106             camHal->captureFormat = V4L2_PIX_FMT_MJPEG;
1107         else if(1 == h264Supported)
1108             camHal->captureFormat = V4L2_PIX_FMT_H264;
1109     }
1110     ALOGI("%s: Capture format chosen: 0x%x. 0x%x:YUYV. 0x%x:MJPEG. 0x%x: H264",
1111         __func__, camHal->captureFormat, V4L2_PIX_FMT_YUYV,
1112         V4L2_PIX_FMT_MJPEG, V4L2_PIX_FMT_H264);
1113 
1114     return camHal->captureFormat;
1115 }
1116 
1117 /******************************************************************************
1118  * Function: getMjpegdOutputFormat
1119  * Description: This function maps display pixel format enum to JPEG output
1120  *              format enum
1121  *
1122  * Input parameters:
1123  *   dispFormat              - Display pixel format
1124  *
1125  * Return values:
1126  *      (int)mjpegOutputFormat
1127  *
1128  * Notes: none
1129  *****************************************************************************/
getMjpegdOutputFormat(int dispFormat)1130 static int getMjpegdOutputFormat(int dispFormat)
1131 {
1132     int mjpegOutputFormat = YCRCBLP_H2V2;
1133 
1134     if(HAL_PIXEL_FORMAT_YCrCb_420_SP == dispFormat)
1135         mjpegOutputFormat = YCRCBLP_H2V2;
1136 
1137     return mjpegOutputFormat;
1138 }
1139 
1140 /******************************************************************************
1141  * Function: ioctlLoop
1142  * Description: This function is a blocking call around ioctl
1143  *
1144  * Input parameters:
1145  *   fd             - IOCTL fd
1146  *   ioctlCmd       - IOCTL command
1147  *   args           - IOCTL arguments
1148  *
1149  * Return values:
1150  *      (int)mjpegOutputFormat
1151  *
1152  * Notes: none
1153  *****************************************************************************/
ioctlLoop(int fd,int ioctlCmd,void * args)1154 static int ioctlLoop(int fd, int ioctlCmd, void *args)
1155 {
1156     int rc = -1;
1157 
1158     while(1)
1159     {
1160         rc = ioctl(fd, ioctlCmd, args);
1161         if(!((-1 == rc) && (EINTR == errno)))
1162             break;
1163     }
1164     return rc;
1165 }
1166 
1167 /******************************************************************************
1168  * Function: initV4L2mmap
1169  * Description: This function requests for V4L2 driver allocated buffers
1170  *
1171  * Input parameters:
1172  *   camHal              - camera HAL handle
1173  *
1174  * Return values:
1175  *   0      No error
1176  *   -1     Error
1177  *
1178  * Notes: none
1179  *****************************************************************************/
initV4L2mmap(camera_hardware_t * camHal)1180 static int initV4L2mmap(camera_hardware_t *camHal)
1181 {
1182     int rc = -1;
1183     struct v4l2_requestbuffers  reqBufs;
1184     struct v4l2_buffer          tempBuf;
1185 
1186     ALOGD("%s: E", __func__);
1187     memset(&reqBufs, 0, sizeof(v4l2_requestbuffers));
1188     reqBufs.type    = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1189     reqBufs.memory  = V4L2_MEMORY_MMAP;
1190     reqBufs.count   = PRVW_CAP_BUF_CNT;
1191 
1192     if (-1 == ioctlLoop(camHal->fd, VIDIOC_REQBUFS, &reqBufs)) {
1193         if (EINVAL == errno) {
1194             ALOGE("%s: does not support memory mapping\n", __func__);
1195         } else {
1196             ALOGE("%s: VIDIOC_REQBUFS failed", __func__);
1197         }
1198     }
1199     ALOGD("%s: VIDIOC_REQBUFS success", __func__);
1200 
1201     if (reqBufs.count < PRVW_CAP_BUF_CNT) {
1202         ALOGE("%s: Insufficient buffer memory on\n", __func__);
1203     }
1204 
1205     camHal->buffers =
1206         ( bufObj* ) calloc(reqBufs.count, sizeof(bufObj));
1207 
1208     if (!camHal->buffers) {
1209         ALOGE("%s: Out of memory\n", __func__);
1210     }
1211 
1212     /* Store the indexes in the context. Useful during releasing */
1213     for (camHal->n_buffers = 0;
1214          camHal->n_buffers < reqBufs.count;
1215          camHal->n_buffers++) {
1216 
1217         memset(&tempBuf, 0, sizeof(tempBuf));
1218 
1219         tempBuf.index       = camHal->n_buffers;
1220         tempBuf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1221         tempBuf.memory      = V4L2_MEMORY_MMAP;
1222 
1223         if (-1 == ioctlLoop(camHal->fd, VIDIOC_QUERYBUF, &tempBuf))
1224             ALOGE("%s: VIDIOC_QUERYBUF failed", __func__);
1225 
1226         ALOGD("%s: VIDIOC_QUERYBUF success", __func__);
1227 
1228         camHal->buffers[camHal->n_buffers].len = tempBuf.length;
1229         camHal->buffers[camHal->n_buffers].data =
1230         mmap(NULL /* start anywhere */,
1231                   tempBuf.length,
1232                   PROT_READ | PROT_WRITE,
1233                   MAP_SHARED,
1234                   camHal->fd, tempBuf.m.offset);
1235 
1236         if (MAP_FAILED == camHal->buffers[camHal->n_buffers].data)
1237             ALOGE("%s: mmap failed", __func__);
1238     }
1239     ALOGD("%s: X", __func__);
1240     return 0;
1241 }
1242 
1243 /******************************************************************************
1244  * Function: unInitV4L2mmap
1245  * Description: This function unmaps the V4L2 driver buffers
1246  *
1247  * Input parameters:
1248  *   camHal              - camera HAL handle
1249  *
1250  * Return values:
1251  *   0      No error
1252  *   -1     Error
1253  *
1254  * Notes: none
1255  *****************************************************************************/
unInitV4L2mmap(camera_hardware_t * camHal)1256 static int unInitV4L2mmap(camera_hardware_t *camHal)
1257 {
1258     int i, rc = 0;
1259     ALOGD("%s: E", __func__);
1260 
1261     for (i = 0; i < camHal->n_buffers; i++)
1262         if (-1 == munmap(camHal->buffers[i].data, camHal->buffers[i].len)){
1263             ALOGE("%s: munmap failed for buffer: %d", __func__, i);
1264             rc = -1;
1265         }
1266 
1267     ALOGD("%s: X", __func__);
1268     return rc;
1269 }
1270 
1271 /******************************************************************************
1272  * Function: initUsbCamera
1273  * Description: This function sets the resolution and pixel format of the
1274  *              USB camera
1275  *
1276  * Input parameters:
1277  *  camHal              - camera HAL handle
1278  *  width               - picture width in pixels
1279  *  height              - picture height in pixels
1280  *  pixelFormat         - capture format for the camera
1281  *
1282  * Return values:
1283  *   0      No error
1284  *   -1     Error
1285  *
1286  * Notes: none
1287  *****************************************************************************/
initUsbCamera(camera_hardware_t * camHal,int width,int height,int pixelFormat)1288 static int initUsbCamera(camera_hardware_t *camHal, int width, int height,
1289                         int pixelFormat)
1290 {
1291     int     rc = -1;
1292     struct  v4l2_capability     cap;
1293     struct  v4l2_cropcap        cropcap;
1294     struct  v4l2_crop           crop;
1295     struct  v4l2_format         v4l2format;
1296     unsigned int                min;
1297 
1298     ALOGI("%s: E", __func__);
1299 
1300     if (-1 == ioctlLoop(camHal->fd, VIDIOC_QUERYCAP, &cap)) {
1301         if (EINVAL == errno) {
1302             ALOGE( "%s: This is not V4L2 device\n", __func__);
1303             return -1;
1304         } else {
1305             ALOGE("%s: VIDIOC_QUERYCAP errno: %d", __func__, errno);
1306         }
1307     }
1308     ALOGD("%s: VIDIOC_QUERYCAP success", __func__);
1309 
1310     if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
1311         ALOGE("%s: This is not video capture device\n", __func__);
1312         return -1;
1313     }
1314 
1315     if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
1316         ALOGE("%s: This does not support streaming i/o\n", __func__);
1317         return -1;
1318     }
1319 
1320     /* Select video input, video standard and tune here. */
1321     memset(&cropcap, 0, sizeof(cropcap));
1322 
1323     cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1324 
1325     if (0 == ioctlLoop(camHal->fd, VIDIOC_CROPCAP, &cropcap)) {
1326 
1327         /* reset to default */
1328         crop.c = cropcap.defrect;
1329         crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1330 
1331         ALOGD("%s: VIDIOC_CROPCAP success", __func__);
1332         if (-1 == ioctlLoop(camHal->fd, VIDIOC_S_CROP, &crop)) {
1333         switch (errno) {
1334             case EINVAL:
1335             /* Cropping not supported. */
1336                 break;
1337             default:
1338             /* Errors ignored. */
1339                 break;
1340             }
1341         }
1342                 ALOGD("%s: VIDIOC_S_CROP success", __func__);
1343 
1344     } else {
1345         /* Errors ignored. */
1346                ALOGE("%s: VIDIOC_S_CROP failed", __func__);
1347     }
1348 
1349 
1350     memset(&v4l2format, 0, sizeof(v4l2format));
1351 
1352     v4l2format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1353     {
1354         v4l2format.fmt.pix.field       = V4L2_FIELD_NONE;
1355         v4l2format.fmt.pix.pixelformat = pixelFormat;
1356         v4l2format.fmt.pix.width       = width;
1357         v4l2format.fmt.pix.height      = height;
1358 
1359         if (-1 == ioctlLoop(camHal->fd, VIDIOC_S_FMT, &v4l2format))
1360         {
1361             ALOGE("%s: VIDIOC_S_FMT failed", __func__);
1362             return -1;
1363         }
1364         ALOGD("%s: VIDIOC_S_FMT success", __func__);
1365 
1366         /* Note VIDIOC_S_FMT may change width and height. */
1367     }
1368 
1369     /* TBR: In case of user pointer buffers, v4l2format.fmt.pix.sizeimage */
1370     /* might have to be calculated as per V4L2 sample application due to */
1371     /* open source driver bug */
1372 
1373     rc = initV4L2mmap(camHal);
1374     ALOGI("%s: X", __func__);
1375     return rc;
1376 }
1377 
1378 /******************************************************************************
1379  * Function: startUsbCamCapture
1380  * Description: This function queues buffer objects to the driver and sends
1381  *              STREAM ON command to the USB camera driver
1382  *
1383  * Input parameters:
1384  *   camHal              - camera HAL handle
1385  *
1386  * Return values:
1387  *   0      No error
1388  *   -1     Error
1389  *
1390  * Notes: none
1391  *****************************************************************************/
startUsbCamCapture(camera_hardware_t * camHal)1392 static int startUsbCamCapture(camera_hardware_t *camHal)
1393 {
1394     int         rc = -1;
1395     unsigned    int i;
1396     enum        v4l2_buf_type   v4l2BufType;
1397     ALOGD("%s: E", __func__);
1398 
1399     for (i = 0; i < camHal->n_buffers; ++i) {
1400         struct v4l2_buffer tempBuf;
1401 
1402         memset(&tempBuf, 0, sizeof(tempBuf));
1403         tempBuf.type    = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1404         tempBuf.memory  = V4L2_MEMORY_MMAP;
1405         tempBuf.index   = i;
1406 
1407         if (-1 == ioctlLoop(camHal->fd, VIDIOC_QBUF, &tempBuf))
1408             ALOGE("%s: VIDIOC_QBUF for %d buffer failed", __func__, i);
1409         else
1410             ALOGD("%s: VIDIOC_QBUF for %d buffer success", __func__, i);
1411     }
1412 
1413     v4l2BufType = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1414     if (-1 == ioctlLoop(camHal->fd, VIDIOC_STREAMON, &v4l2BufType))
1415         ALOGE("%s: VIDIOC_STREAMON failed", __func__);
1416     else
1417     {
1418         ALOGD("%s: VIDIOC_STREAMON success", __func__);
1419         rc = 0;
1420     }
1421 
1422     ALOGD("%s: X", __func__);
1423     return rc;
1424 }
1425 
1426 /******************************************************************************
1427  * Function: stopUsbCamCapture
1428  * Description: This function sends STREAM OFF command to the USB camera driver
1429  *
1430  * Input parameters:
1431  *   camHal              - camera HAL handle
1432  *
1433  * Return values:
1434  *   0      No error
1435  *   -1     Error
1436  *
1437  * Notes: none
1438  *****************************************************************************/
stopUsbCamCapture(camera_hardware_t * camHal)1439 static int stopUsbCamCapture(camera_hardware_t *camHal)
1440 {
1441     int         rc = -1;
1442     unsigned    int i;
1443     enum        v4l2_buf_type   v4l2BufType;
1444     ALOGD("%s: E", __func__);
1445 
1446     if(!camHal->fd){
1447         ALOGE("%s: camHal->fd = NULL ", __func__);
1448         return -1;
1449     }
1450     v4l2BufType = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1451     if (-1 == ioctlLoop(camHal->fd, VIDIOC_STREAMOFF, &v4l2BufType)){
1452         ALOGE("%s: VIDIOC_STREAMOFF failed", __func__);
1453         rc = -1;
1454     }else{
1455         ALOGD("%s: VIDIOC_STREAMOFF success", __func__);
1456         rc = 0;
1457     }
1458 
1459     ALOGD("%s: X", __func__);
1460     return rc;
1461 }
1462 
1463 /******************************************************************************
1464  * Function: stopPreviewInternal
1465  * Description: This function sends EXIT command to prview loop thread,
1466  *              stops usb camera capture and uninitializes MMAP. This function
1467  *              assumes that calling function has locked camHal->lock
1468  *
1469  * Input parameters:
1470  *   camHal              - camera HAL handle
1471  *
1472  * Return values:
1473  *   0      No error
1474  *   -1     Error
1475  *
1476  * Notes: none
1477  *****************************************************************************/
stopPreviewInternal(camera_hardware_t * camHal)1478 static int stopPreviewInternal(camera_hardware_t *camHal)
1479 {
1480     int rc = 0;
1481     ALOGD("%s: E", __func__);
1482 
1483     if(camHal->previewEnabledFlag)
1484     {
1485         camHal->prvwCmdPending++;
1486         camHal->prvwCmd         = USB_CAM_PREVIEW_EXIT;
1487 
1488         /* yield lock while waiting for the preview thread to exit */
1489         camHal->lock.unlock();
1490         if(pthread_join(camHal->previewThread, NULL)){
1491             ALOGE("%s: Error in pthread_join preview thread", __func__);
1492         }
1493         camHal->lock.lock();
1494 
1495         if(stopUsbCamCapture(camHal)){
1496             ALOGE("%s: Error in stopUsbCamCapture", __func__);
1497             rc = -1;
1498         }
1499         if(unInitV4L2mmap(camHal)){
1500             ALOGE("%s: Error in stopUsbCamCapture", __func__);
1501             rc = -1;
1502         }
1503         camHal->previewEnabledFlag = 0;
1504     }
1505 
1506     ALOGD("%s: X, rc: %d", __func__, rc);
1507     return rc;
1508 }
1509 #if 1
1510 /******************************************************************************
1511  * Function: prvwThreadTakePictureInternal
1512  * Description: This function processes one camera frame to get JPEG encoded
1513  *              picture.
1514  *
1515  * Input parameters:
1516  *   camHal              - camera HAL handle
1517  *
1518  * Return values:
1519  *   0      No error
1520  *   -1     Error
1521  *
1522  * Notes: none
1523  *****************************************************************************/
prvwThreadTakePictureInternal(camera_hardware_t * camHal)1524 static int prvwThreadTakePictureInternal(camera_hardware_t *camHal)
1525 {
1526     int     rc = 0;
1527     QCameraHalMemInfo_t     *mem_info;
1528     ALOGD("%s: E", __func__);
1529 
1530     /************************************************************************/
1531     /* - If requested for shutter notfication, callback                     */
1532     /* - Dequeue capture buffer from USB camera                             */
1533     /* - Send capture buffer to JPEG encoder for JPEG compression           */
1534     /* - If jpeg frames callback is requested, callback with jpeg buffers   */
1535     /* - Enqueue capture buffer back to USB camera                          */
1536     /************************************************************************/
1537 
1538     /************************************************************************/
1539     /* - If requested for shutter notfication, callback                     */
1540     /************************************************************************/
1541     if (camHal->msgEnabledFlag & CAMERA_MSG_SHUTTER){
1542         camHal->lock.unlock();
1543         camHal->notify_cb(CAMERA_MSG_SHUTTER, 0, 0, camHal->cb_ctxt);
1544         camHal->lock.lock();
1545     }
1546 
1547 #if CAPTURE
1548     /************************************************************************/
1549     /* - Dequeue capture buffer from USB camera                             */
1550     /************************************************************************/
1551     if (0 == get_buf_from_cam(camHal))
1552         ALOGD("%s: get_buf_from_cam success", __func__);
1553     else
1554         ALOGE("%s: get_buf_from_cam error", __func__);
1555 #endif
1556 
1557     /************************************************************************/
1558     /* - Send capture buffer to JPEG encoder for JPEG compression           */
1559     /************************************************************************/
1560     /* Optimization: If camera capture is JPEG format, need not compress! */
1561     /* instead, just data copy from capture buffer to picture buffer */
1562     if(V4L2_PIX_FMT_MJPEG == camHal->captureFormat){
1563         /* allocate heap memory for JPEG output */
1564         mem_info = &camHal->pictMem.mem_info[0];
1565         mem_info->size = camHal->curCaptureBuf.bytesused;
1566         /* TBD: allocate_ion_memory
1567         rc = QCameraHardwareInterface::allocate_ion_memory(mem_info,
1568                             ((0x1 << CAMERA_ZSL_ION_HEAP_ID) |
1569                             (0x1 << CAMERA_ZSL_ION_FALLBACK_HEAP_ID)));
1570         */
1571         if(rc)
1572             ALOGE("%s: ION memory allocation failed", __func__);
1573 
1574         camHal->pictMem.camera_memory[0] = camHal->get_memory(
1575                             mem_info->fd, mem_info->size, 1, camHal->cb_ctxt);
1576         if(!camHal->pictMem.camera_memory[0])
1577             ALOGE("%s: get_mem failed", __func__);
1578 
1579         memcpy( camHal->pictMem.camera_memory[0]->data,
1580                 (char *)camHal->buffers[camHal->curCaptureBuf.index].data,
1581                 camHal->curCaptureBuf.bytesused);
1582     }
1583 
1584     /************************************************************************/
1585     /* - If jpeg frames callback is requested, callback with jpeg buffers   */
1586     /************************************************************************/
1587     if ((camHal->msgEnabledFlag & CAMERA_MSG_COMPRESSED_IMAGE) &&
1588             (camHal->data_cb)){
1589         camHal->lock.unlock();
1590         camHal->data_cb(CAMERA_MSG_COMPRESSED_IMAGE,
1591                         camHal->pictMem.camera_memory[0],
1592                         0, NULL, camHal->cb_ctxt);
1593         camHal->lock.lock();
1594     }
1595     /* release heap memory after the call back */
1596     if(camHal->pictMem.camera_memory[0])
1597         camHal->pictMem.camera_memory[0]->release(
1598             camHal->pictMem.camera_memory[0]);
1599 
1600     /* TBD: deallocate_ion_memory */
1601     //rc = QCameraHardwareInterface::deallocate_ion_memory(mem_info);
1602     if(rc)
1603         ALOGE("%s: ION memory de-allocation failed", __func__);
1604 
1605 #if CAPTURE
1606     /************************************************************************/
1607     /* - Enqueue capture buffer back to USB camera                          */
1608     /************************************************************************/
1609        if(0 == put_buf_to_cam(camHal)) {
1610             ALOGD("%s: put_buf_to_cam success", __func__);
1611         }
1612         else
1613             ALOGE("%s: put_buf_to_cam error", __func__);
1614 #endif
1615 
1616     ALOGD("%s: X, rc: %d", __func__, rc);
1617     return rc;
1618 }
1619 #endif //#if 0
1620 /******************************************************************************
1621  * Function: cache_ops
1622  * Description: This function calls ION ioctl for cache related operations
1623  *
1624  * Input parameters:
1625  *  mem_info                - QCameraHalMemInfo_t structure with ION info
1626  *  buf_ptr                 - Buffer pointer that needs to be cache operated
1627  *  cmd                     - Cache command - clean/invalidate
1628  *
1629  * Return values:
1630  *   MM_CAMERA_OK       No error
1631  *   -1                 Error
1632  *
1633  * Notes: none
1634  *****************************************************************************/
cache_ops(QCameraHalMemInfo_t * mem_info,void * buf_ptr,unsigned int cmd)1635 int cache_ops(QCameraHalMemInfo_t *mem_info,
1636                                     void *buf_ptr,
1637                                     unsigned int cmd)
1638 {
1639     struct ion_flush_data cache_inv_data;
1640     struct ion_custom_data custom_data;
1641     int ret = MM_CAMERA_OK;
1642 
1643 #ifdef USE_ION
1644     if (NULL == mem_info) {
1645         ALOGE("%s: mem_info is NULL, return here", __func__);
1646         return -1;
1647     }
1648 
1649     memset(&cache_inv_data, 0, sizeof(cache_inv_data));
1650     memset(&custom_data, 0, sizeof(custom_data));
1651     cache_inv_data.vaddr = buf_ptr;
1652     cache_inv_data.fd = mem_info->fd;
1653     cache_inv_data.handle = mem_info->handle;
1654     cache_inv_data.length = mem_info->size;
1655     custom_data.cmd = cmd;
1656     custom_data.arg = (unsigned long)&cache_inv_data;
1657 
1658     ALOGD("%s: addr = %p, fd = %d, handle = %p length = %d, ION Fd = %d",
1659          __func__, cache_inv_data.vaddr, cache_inv_data.fd,
1660          cache_inv_data.handle, cache_inv_data.length,
1661          mem_info->main_ion_fd);
1662     if(mem_info->main_ion_fd > 0) {
1663         if(ioctl(mem_info->main_ion_fd, ION_IOC_CUSTOM, &custom_data) < 0) {
1664             ALOGE("%s: Cache Invalidate failed\n", __func__);
1665             ret = -1;
1666         }
1667     }
1668 #endif
1669 
1670     return ret;
1671 }
1672 
1673 /******************************************************************************
1674  * Function: get_buf_from_cam
1675  * Description: This funtions gets/acquires 1 capture buffer from the camera
1676  *              driver. The fetched buffer is stored in curCaptureBuf
1677  *
1678  * Input parameters:
1679  *   camHal              - camera HAL handle
1680  *
1681  * Return values:
1682  *   0      No error
1683  *   -1     Error
1684  *
1685  * Notes: none
1686  *****************************************************************************/
get_buf_from_cam(camera_hardware_t * camHal)1687 static int get_buf_from_cam(camera_hardware_t *camHal)
1688 {
1689     int rc = -1;
1690 
1691     ALOGD("%s: E", __func__);
1692     {
1693         memset(&camHal->curCaptureBuf, 0, sizeof(camHal->curCaptureBuf));
1694 
1695         camHal->curCaptureBuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1696         camHal->curCaptureBuf.memory = V4L2_MEMORY_MMAP;
1697 
1698         if (-1 == ioctlLoop(camHal->fd, VIDIOC_DQBUF, &camHal->curCaptureBuf)){
1699             switch (errno) {
1700             case EAGAIN:
1701                 ALOGE("%s: EAGAIN error", __func__);
1702                 return 1;
1703 
1704             case EIO:
1705             /* Could ignore EIO, see spec. */
1706 
1707             /* fall through */
1708 
1709             default:
1710             ALOGE("%s: VIDIOC_DQBUF error", __func__);
1711             }
1712         }
1713         else
1714         {
1715             rc = 0;
1716             ALOGD("%s: VIDIOC_DQBUF: %d successful, %d bytes",
1717                  __func__, camHal->curCaptureBuf.index,
1718                  camHal->curCaptureBuf.bytesused);
1719         }
1720     }
1721     ALOGD("%s: X", __func__);
1722     return rc;
1723 }
1724 
1725 /******************************************************************************
1726  * Function: put_buf_to_cam
1727  * Description: This funtion puts/releases 1 capture buffer back to the camera
1728  *              driver
1729  *
1730  * Input parameters:
1731  *   camHal              - camera HAL handle
1732  *
1733  * Return values:
1734  *   0      No error
1735  *   -1     Error
1736  *
1737  * Notes: none
1738  *****************************************************************************/
put_buf_to_cam(camera_hardware_t * camHal)1739 static int put_buf_to_cam(camera_hardware_t *camHal)
1740 {
1741     ALOGD("%s: E", __func__);
1742 
1743     camHal->curCaptureBuf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1744     camHal->curCaptureBuf.memory      = V4L2_MEMORY_MMAP;
1745 
1746 
1747     if (-1 == ioctlLoop(camHal->fd, VIDIOC_QBUF, &camHal->curCaptureBuf))
1748     {
1749         ALOGE("%s: VIDIOC_QBUF failed ", __func__);
1750         return 1;
1751     }
1752     ALOGD("%s: X", __func__);
1753     return 0;
1754 }
1755 
1756 /******************************************************************************
1757  * Function: put_buf_to_cam
1758  * Description: This funtion gets/acquires 1 display buffer from the display
1759  *              window
1760  *
1761  * Input parameters:
1762  *  camHal                  - camera HAL handle
1763  *  buffer_id               - Buffer id pointer. The id of buffer obtained
1764  *                              by this function is returned in this arg
1765  *
1766  * Return values:
1767  *   0      No error
1768  *   -1     Error
1769  *
1770  * Notes: none
1771  *****************************************************************************/
get_buf_from_display(camera_hardware_t * camHal,int * buffer_id)1772 static int get_buf_from_display(camera_hardware_t *camHal, int *buffer_id)
1773 {
1774     int                     err = 0;
1775     preview_stream_ops      *mPreviewWindow = NULL;
1776     int                     stride = 0, cnt = 0;
1777     buffer_handle_t         *buffer_handle = NULL;
1778     struct private_handle_t *private_buffer_handle = NULL;
1779 
1780     ALOGD("%s: E", __func__);
1781 
1782     if (camHal == NULL) {
1783         ALOGE("%s: camHal = NULL", __func__);
1784         return -1;
1785     }
1786 
1787     mPreviewWindow = camHal->window;
1788     if( mPreviewWindow == NULL) {
1789         ALOGE("%s: mPreviewWindow = NULL", __func__);
1790         return -1;
1791     }
1792     err = mPreviewWindow->dequeue_buffer(mPreviewWindow,
1793                                     &buffer_handle,
1794                                     &stride);
1795     if(!err) {
1796         ALOGD("%s: dequeue buf buffer_handle: %p\n", __func__, buffer_handle);
1797 
1798         ALOGD("%s: mPreviewWindow->lock_buffer: %p",
1799              __func__, mPreviewWindow->lock_buffer);
1800         if(mPreviewWindow->lock_buffer) {
1801             err = mPreviewWindow->lock_buffer(mPreviewWindow, buffer_handle);
1802             ALOGD("%s: mPreviewWindow->lock_buffer success", __func__);
1803         }
1804         ALOGD("%s: camera call genlock_lock, hdl=%p",
1805              __func__, (*buffer_handle));
1806 
1807         if (GENLOCK_NO_ERROR !=
1808             genlock_lock_buffer((native_handle_t *)(*buffer_handle),
1809                                 GENLOCK_WRITE_LOCK, GENLOCK_MAX_TIMEOUT)) {
1810            ALOGE("%s: genlock_lock_buffer(WRITE) failed", __func__);
1811        } else {
1812          ALOGD("%s: genlock_lock_buffer hdl =%p", __func__, *buffer_handle);
1813        }
1814 
1815         private_buffer_handle = (struct private_handle_t *)(*buffer_handle);
1816 
1817         ALOGD("%s: fd = %d, size = %d, offset = %d, stride = %d",
1818              __func__, private_buffer_handle->fd,
1819         private_buffer_handle->size, private_buffer_handle->offset, stride);
1820 
1821         for(cnt = 0; cnt < camHal->previewMem.buffer_count + 2; cnt++) {
1822             if(private_buffer_handle->fd ==
1823                camHal->previewMem.private_buffer_handle[cnt]->fd) {
1824                 *buffer_id = cnt;
1825                 ALOGD("%s: deQueued fd = %d, index: %d",
1826                      __func__, private_buffer_handle->fd, cnt);
1827                 break;
1828             }
1829         }
1830     }
1831     else
1832         ALOGE("%s: dequeue buf failed \n", __func__);
1833 
1834     ALOGD("%s: X", __func__);
1835 
1836     return err;
1837 }
1838 
1839 /******************************************************************************
1840  * Function: put_buf_to_display
1841  * Description: This funtion puts/enqueues 1 buffer back to the display window
1842  *
1843  * Input parameters:
1844  *  camHal                  - camera HAL handle
1845  *  buffer_id               - id of the buffer that needs to be enqueued
1846  *
1847  * Return values:
1848  *   0      No error
1849  *   -1     Error
1850  *
1851  * Notes: none
1852  *****************************************************************************/
put_buf_to_display(camera_hardware_t * camHal,int buffer_id)1853 static int put_buf_to_display(camera_hardware_t *camHal, int buffer_id)
1854 {
1855     int err = 0;
1856     preview_stream_ops    *mPreviewWindow;
1857 
1858     ALOGD("%s: E", __func__);
1859 
1860     if (camHal == NULL) {
1861         ALOGE("%s: camHal = NULL", __func__);
1862         return -1;
1863     }
1864 
1865     mPreviewWindow = camHal->window;
1866     if( mPreviewWindow == NULL) {
1867         ALOGE("%s: mPreviewWindow = NULL", __func__);
1868         return -1;
1869     }
1870 
1871     if (GENLOCK_FAILURE ==
1872         genlock_unlock_buffer(
1873             (native_handle_t *)
1874             (*(camHal->previewMem.buffer_handle[buffer_id])))) {
1875        ALOGE("%s: genlock_unlock_buffer failed: hdl =%p",
1876             __func__, (*(camHal->previewMem.buffer_handle[buffer_id])) );
1877     } else {
1878       ALOGD("%s: genlock_unlock_buffer success: hdl =%p",
1879            __func__, (*(camHal->previewMem.buffer_handle[buffer_id])) );
1880     }
1881 
1882     /* Cache clean the output buffer so that cache is written back */
1883     cache_ops(&camHal->previewMem.mem_info[buffer_id],
1884                          (void *)camHal->previewMem.camera_memory[buffer_id]->data,
1885                          ION_IOC_CLEAN_CACHES);
1886                          /*
1887     cache_ops(&camHal->previewMem.mem_info[buffer_id],
1888                          (void *)camHal->previewMem.camera_memory[buffer_id]->data,
1889                          ION_IOC_CLEAN_INV_CACHES);
1890 */
1891     err = mPreviewWindow->enqueue_buffer(mPreviewWindow,
1892       (buffer_handle_t *)camHal->previewMem.buffer_handle[buffer_id]);
1893     if(!err) {
1894         ALOGD("%s: enqueue buf successful: %p\n",
1895              __func__, camHal->previewMem.buffer_handle[buffer_id]);
1896     }else
1897         ALOGE("%s: enqueue buf failed: %p\n",
1898              __func__, camHal->previewMem.buffer_handle[buffer_id]);
1899 
1900     ALOGD("%s: X", __func__);
1901 
1902     return err;
1903 }
1904 
1905 /******************************************************************************
1906  * Function: put_buf_to_display
1907  * Description: This funtion transfers the content from capture buffer to
1908  *              preiew display buffer after appropriate conversion
1909  *
1910  * Input parameters:
1911  *  camHal                  - camera HAL handle
1912  *  buffer_id               - id of the buffer that needs to be enqueued
1913  *
1914  * Return values:
1915  *   0      No error
1916  *   -1     Error
1917  *
1918  * Notes: none
1919  *****************************************************************************/
convert_data_frm_cam_to_disp(camera_hardware_t * camHal,int buffer_id)1920 static int convert_data_frm_cam_to_disp(camera_hardware_t *camHal, int buffer_id)
1921 {
1922     int rc = -1;
1923 
1924     if(!camHal) {
1925         ALOGE("%s: camHal is NULL", __func__);
1926         return -1;
1927     }
1928     /* If input and output are raw formats, but different color format, */
1929     /* call color conversion routine                                    */
1930     if( (V4L2_PIX_FMT_YUYV == camHal->captureFormat) &&
1931         (HAL_PIXEL_FORMAT_YCrCb_420_SP == camHal->dispFormat))
1932     {
1933         convert_YUYV_to_420_NV12(
1934             (char *)camHal->buffers[camHal->curCaptureBuf.index].data,
1935             (char *)camHal->previewMem.camera_memory[buffer_id]->data,
1936             camHal->prevWidth,
1937             camHal->prevHeight);
1938         ALOGD("%s: Copied %d bytes from camera buffer %d to display buffer: %d",
1939              __func__, camHal->curCaptureBuf.bytesused,
1940              camHal->curCaptureBuf.index, buffer_id);
1941         rc = 0;
1942     }
1943 
1944     /* If camera buffer is MJPEG encoded, call mjpeg decode call */
1945     if(V4L2_PIX_FMT_MJPEG == camHal->captureFormat)
1946     {
1947         if(NULL == camHal->mjpegd)
1948         {
1949             rc = mjpegDecoderInit(&camHal->mjpegd);
1950             if(rc < 0)
1951                 ALOGE("%s: mjpegDecoderInit Error: %d", __func__, rc);
1952         }
1953         if(camHal->mjpegd)
1954         {
1955             rc = mjpegDecode(
1956                 (void*)camHal->mjpegd,
1957                 (char *)camHal->buffers[camHal->curCaptureBuf.index].data,
1958                 camHal->curCaptureBuf.bytesused,
1959                 (char *)camHal->previewMem.camera_memory[buffer_id]->data,
1960                 (char *)camHal->previewMem.camera_memory[buffer_id]->data +
1961                     camHal->prevWidth * camHal->prevHeight,
1962                 getMjpegdOutputFormat(camHal->dispFormat));
1963             if(rc < 0)
1964                 ALOGE("%s: mjpegDecode Error: %d", __func__, rc);
1965         }
1966     }
1967     return rc;
1968 }
1969 
1970 /******************************************************************************
1971  * Function: launch_preview_thread
1972  * Description: This is a wrapper function to start preview thread
1973  *
1974  * Input parameters:
1975  *  camHal                  - camera HAL handle
1976  *
1977  * Return values:
1978  *   0      No error
1979  *   -1     Error
1980  *
1981  * Notes: none
1982  *****************************************************************************/
launch_preview_thread(camera_hardware_t * camHal)1983 static int launch_preview_thread(camera_hardware_t *camHal)
1984 {
1985     ALOGD("%s: E", __func__);
1986     int rc = 0;
1987 
1988     if(!camHal) {
1989         ALOGE("%s: camHal is NULL", __func__);
1990         return -1;
1991     }
1992 
1993     pthread_attr_t attr;
1994     pthread_attr_init(&attr);
1995     pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
1996     pthread_create(&camHal->previewThread, &attr, previewloop, camHal);
1997 
1998     ALOGD("%s: X", __func__);
1999     return rc;
2000 }
2001 
2002 /******************************************************************************
2003  * Function: launch_preview_thread
2004  * Description: This is thread funtion for preivew loop
2005  *
2006  * Input parameters:
2007  *  hcamHal                 - camera HAL handle
2008  *
2009  * Return values:
2010  *   0      No error
2011  *   -1     Error
2012  *
2013  * Notes: none
2014  *****************************************************************************/
previewloop(void * hcamHal)2015 static void * previewloop(void *hcamHal)
2016 {
2017     int                 rc;
2018     int                 buffer_id   = 0;
2019     pid_t               tid         = 0;
2020     camera_hardware_t   *camHal     = NULL;
2021     int                 msgType     = 0;
2022     camera_memory_t     *data       = NULL;
2023     camera_frame_metadata_t *metadata= NULL;
2024     camera_memory_t     *previewMem = NULL;
2025 
2026     camHal = (camera_hardware_t *)hcamHal;
2027     ALOGD("%s: E", __func__);
2028 
2029     if(!camHal) {
2030         ALOGE("%s: camHal is NULL", __func__);
2031         return NULL ;
2032     }
2033 
2034     tid  = gettid();
2035     /* TBR: Set appropriate thread priority */
2036     androidSetThreadPriority(tid, ANDROID_PRIORITY_NORMAL);
2037     prctl(PR_SET_NAME, (unsigned long)"Camera HAL preview thread", 0, 0, 0);
2038 
2039     /************************************************************************/
2040     /* - Time wait (select) on camera fd for input read buffer              */
2041     /* - Check if any preview thread commands are set. If set, process      */
2042     /* - Dequeue display buffer from surface                                */
2043     /* - Dequeue capture buffer from USB camera                             */
2044     /* - Convert capture format to display format                           */
2045     /* - If preview frames callback is requested, callback with prvw buffers*/
2046     /* - Enqueue display buffer back to surface                             */
2047     /* - Enqueue capture buffer back to USB camera                          */
2048     /************************************************************************/
2049     while(1) {
2050         fd_set fds;
2051         struct timeval tv;
2052         int r = 0;
2053 
2054         FD_ZERO(&fds);
2055 #if CAPTURE
2056         FD_SET(camHal->fd, &fds);
2057 #endif /* CAPTURE */
2058 
2059     /************************************************************************/
2060     /* - Time wait (select) on camera fd for input read buffer              */
2061     /************************************************************************/
2062         tv.tv_sec = 0;
2063         tv.tv_usec = 500000;
2064 
2065         ALOGD("%s: b4 select on camHal->fd + 1,fd: %d", __func__, camHal->fd);
2066 #if CAPTURE
2067         r = select(camHal->fd + 1, &fds, NULL, NULL, &tv);
2068 #else
2069         r = select(1, NULL, NULL, NULL, &tv);
2070 #endif /* CAPTURE */
2071         ALOGD("%s: after select : %d", __func__, camHal->fd);
2072 
2073         if (-1 == r) {
2074             if (EINTR == errno)
2075                 continue;
2076             ALOGE("%s: FDSelect error: %d", __func__, errno);
2077         }
2078 
2079         if (0 == r) {
2080             ALOGD("%s: select timeout\n", __func__);
2081         }
2082 
2083         /* Protect the context for one iteration of preview loop */
2084         /* this gets unlocked at the end of the while */
2085         Mutex::Autolock autoLock(camHal->lock);
2086 
2087     /************************************************************************/
2088     /* - Check if any preview thread commands are set. If set, process      */
2089     /************************************************************************/
2090         if(camHal->prvwCmdPending)
2091         {
2092             /* command is serviced. Hence command pending = 0  */
2093             camHal->prvwCmdPending--;
2094             //sempost(ack)
2095             if(USB_CAM_PREVIEW_EXIT == camHal->prvwCmd){
2096                 /* unlock before exiting the thread */
2097                 camHal->lock.unlock();
2098                 ALOGI("%s: Exiting coz USB_CAM_PREVIEW_EXIT", __func__);
2099                 return (void *)0;
2100             }else if(USB_CAM_PREVIEW_TAKEPIC == camHal->prvwCmd){
2101                 rc = prvwThreadTakePictureInternal(camHal);
2102                 if(rc)
2103                     ALOGE("%s: prvwThreadTakePictureInternal returned error",
2104                     __func__);
2105             }
2106         }
2107 
2108         /* Null check on preview window. If null, sleep */
2109         if(!camHal->window) {
2110             ALOGD("%s: sleeping coz camHal->window = NULL",__func__);
2111             camHal->lock.unlock();
2112             sleep(2);
2113             continue;
2114         }
2115 #if DISPLAY
2116     /************************************************************************/
2117     /* - Dequeue display buffer from surface                                */
2118     /************************************************************************/
2119         if(0 == get_buf_from_display(camHal, &buffer_id)) {
2120             ALOGD("%s: get_buf_from_display success: %d",
2121                  __func__, buffer_id);
2122         }else{
2123             ALOGE("%s: get_buf_from_display failed. Skipping the loop",
2124                  __func__);
2125             continue;
2126         }
2127 #endif
2128 
2129 #if CAPTURE
2130     /************************************************************************/
2131     /* - Dequeue capture buffer from USB camera                             */
2132     /************************************************************************/
2133         if (0 == get_buf_from_cam(camHal))
2134             ALOGD("%s: get_buf_from_cam success", __func__);
2135         else
2136             ALOGE("%s: get_buf_from_cam error", __func__);
2137 #endif
2138 
2139 #if FILE_DUMP_CAMERA
2140         /* Debug code to dump frames from camera */
2141         {
2142             static int frame_cnt = 0;
2143             /* currently hardcoded for Bytes-Per-Pixel = 1.5 */
2144             fileDump("/data/USBcam.yuv",
2145             (char*)camHal->buffers[camHal->curCaptureBuf.index].data,
2146             camHal->prevWidth * camHal->prevHeight * 1.5,
2147             &frame_cnt);
2148         }
2149 #endif
2150 
2151 #if MEMSET
2152         static int color = 30;
2153         color += 50;
2154         if(color > 200) {
2155             color = 30;
2156         }
2157         ALOGE("%s: Setting to the color: %d\n", __func__, color);
2158         /* currently hardcoded for format of type Bytes-Per-Pixel = 1.5 */
2159         memset(camHal->previewMem.camera_memory[buffer_id]->data,
2160                color, camHal->dispWidth * camHal->dispHeight * 1.5 + 2 * 1024);
2161 #else
2162         convert_data_frm_cam_to_disp(camHal, buffer_id);
2163         ALOGD("%s: Copied data to buffer_id: %d", __func__, buffer_id);
2164 #endif
2165 
2166 #if FILE_DUMP_B4_DISP
2167         /* Debug code to dump display buffers */
2168         {
2169             static int frame_cnt = 0;
2170             /* currently hardcoded for Bytes-Per-Pixel = 1.5 */
2171             fileDump("/data/display.yuv",
2172                 (char*) camHal->previewMem.camera_memory[buffer_id]->data,
2173                 camHal->dispWidth * camHal->dispHeight * 1.5,
2174                 &frame_cnt);
2175             ALOGD("%s: Written buf_index: %d ", __func__, buffer_id);
2176         }
2177 #endif
2178 
2179 #if DISPLAY
2180     /************************************************************************/
2181     /* - Enqueue display buffer back to surface                             */
2182     /************************************************************************/
2183        if(0 == put_buf_to_display(camHal, buffer_id)) {
2184             ALOGD("%s: put_buf_to_display success: %d", __func__, buffer_id);
2185         }
2186         else
2187             ALOGE("%s: put_buf_to_display error", __func__);
2188 #endif
2189 
2190 #if CAPTURE
2191      /************************************************************************/
2192     /* - Enqueue capture buffer back to USB camera                          */
2193     /************************************************************************/
2194        if(0 == put_buf_to_cam(camHal)) {
2195             ALOGD("%s: put_buf_to_cam success", __func__);
2196         }
2197         else
2198             ALOGE("%s: put_buf_to_cam error", __func__);
2199 #endif
2200 
2201 #if CALL_BACK
2202     /************************************************************************/
2203     /* - If preview frames callback is requested, callback with prvw buffers*/
2204     /************************************************************************/
2205         /* TBD: change the 1.5 hardcoding to Bytes Per Pixel */
2206         int previewBufSize = camHal->prevWidth * camHal->prevHeight * 1.5;
2207 
2208         msgType |=  CAMERA_MSG_PREVIEW_FRAME;
2209 
2210         if(previewBufSize !=
2211             camHal->previewMem.private_buffer_handle[buffer_id]->size) {
2212 
2213             previewMem = camHal->get_memory(
2214                 camHal->previewMem.private_buffer_handle[buffer_id]->fd,
2215                 previewBufSize,
2216                 1,
2217                 camHal->cb_ctxt);
2218 
2219               if (!previewMem || !previewMem->data) {
2220                   ALOGE("%s: get_memory failed.\n", __func__);
2221               }
2222               else {
2223                   data = previewMem;
2224                   ALOGD("%s: GetMemory successful. data = %p",
2225                             __func__, data);
2226                   ALOGD("%s: previewBufSize = %d, priv_buf_size: %d",
2227                     __func__, previewBufSize,
2228                     camHal->previewMem.private_buffer_handle[buffer_id]->size);
2229               }
2230         }
2231         else{
2232             data =   camHal->previewMem.camera_memory[buffer_id];
2233             ALOGD("%s: No GetMemory, no invalid fmt. data = %p, idx=%d",
2234                 __func__, data, buffer_id);
2235         }
2236         /* Unlock and lock around the callback. */
2237         /* Sometimes 'disable_msg' is issued in the callback context, */
2238         /* leading to deadlock */
2239         camHal->lock.unlock();
2240         if((camHal->msgEnabledFlag & CAMERA_MSG_PREVIEW_FRAME) &&
2241             camHal->data_cb){
2242             ALOGD("%s: before data callback", __func__);
2243             camHal->data_cb(msgType, data, 0,metadata, camHal->cb_ctxt);
2244             ALOGD("%s: after data callback: %p", __func__, camHal->data_cb);
2245         }
2246         camHal->lock.lock();
2247         if (previewMem)
2248             previewMem->release(previewMem);
2249 #endif
2250 
2251     }//while(1)
2252     ALOGD("%s: X", __func__);
2253     return (void *)0;
2254 }
2255 
2256 /******************************************************************************
2257  * Function: get_uvc_device
2258  * Description: This function loops through /dev/video entries and probes with
2259  *              UVCIOC query. If the device responds to the query, then it is
2260  *              detected as UVC webcam
2261  * Input parameters:
2262  *   devname             - String pointer. The function return dev entry
2263  *                          name in this string
2264  * Return values:
2265  *      0   Success
2266  *      -1  Error
2267  * Notes: none
2268  *****************************************************************************/
get_uvc_device(char * devname)2269 static int get_uvc_device(char *devname)
2270 {
2271     char    temp_devname[FILENAME_LENGTH];
2272     FILE    *fp = NULL;
2273     int     i = 0, ret = 0, fd;
2274 
2275     ALOGD("%s: E", __func__);
2276 #if 1
2277     strncpy(devname, "/dev/video1", FILENAME_LENGTH);
2278 
2279 /*
2280     struct          stat st;
2281 
2282     strncpy(dev_name, "/dev/video1", FILENAME_LENGTH);
2283     if (-1 == stat(dev_name, &st)) {
2284         ALOGE("%s: Cannot identify '%s': %d, %s\n",
2285              __func__, dev_name, errno, strerror(errno));
2286     }
2287 
2288     if (!S_ISCHR(st.st_mode)) {
2289         ALOGE("%s: %s is no device\n", __func__, dev_name);
2290         rc = -1;
2291     }
2292 */
2293 
2294 #else
2295 
2296     *devname = '\0';
2297     /************************************************************************/
2298     /* - List all /dev/video* entries to a file                             */
2299     /* - Open the video list file and loop through the list                 */
2300     /* - Send UVC specific control query and check the response             */
2301     /* - If device responds to the query as success, device is UVC webcam   */
2302     /************************************************************************/
2303 
2304     /************************************************************************/
2305     /* - List all /dev/video* entries to a file                             */
2306     /************************************************************************/
2307     /* Temporarily commented out. This logic doesnt seem to be working */
2308     //system("ls > /data/video_dev_list");
2309 
2310     /************************************************************************/
2311     /* - Open the video list file and loop through the list                 */
2312     /************************************************************************/
2313 
2314     /* Temporarily commented out. This logic doesnt seem to be working */
2315     /*
2316     fp = fopen("/data/video_dev_list", "rb");
2317     if(!fp) {
2318         ALOGE("%s: Error in opening /data/video_dev_list ", __func__);
2319         return -1;
2320     }
2321     */
2322 
2323     /* Temporarily commented out. Looping logic changed due to issue in */
2324     /* executing system("ls > /data/video_dev_list") */
2325     //while(EOF != fscanf(fp, "%s", devname)){
2326     while(1){
2327         uvc_xu_control_query    xqry;
2328 
2329         sprintf(temp_devname, "/dev/video%d", i);
2330         ALOGD("%s: Probing %s \n", __func__, temp_devname);
2331 
2332         fd = open(temp_devname, O_RDWR /* required */ | O_NONBLOCK, 0);
2333         if(-1 != fd){
2334             memset(&xqry, 0, sizeof(uvc_xu_control_query));
2335             ret = ioctl(fd, UVCIOC_CTRL_QUERY, &xqry);
2336             ALOGD("%s: UVCIOC ret: %d, errno: %d", __func__, ret, errno);
2337             /****************************************************************/
2338             /* if UVCIOC is executed successfully, ret = 0                  */
2339             /* if UVCIOC is executed but Control Unit = 0 does not exist,   */
2340             /*      ret = -1 and errno = ENOENT                             */
2341             /* if UVCIOC doesnot execute, ret = -1 and errno = EINVAL       */
2342             /****************************************************************/
2343             if((0 == ret) || (ret && (ENOENT == errno))){
2344                 ALOGD("%s: Found UVC node: %s\n", __func__, temp_devname);
2345                 strncpy(devname, temp_devname, FILENAME_LENGTH);
2346                 /* Exit the loop at the first UVC node detection */
2347                 break;
2348             }
2349             close(fd);
2350         }
2351         /* Temporarily logic to probe video0 to video10 nodes */
2352         if(i++ > 10)
2353         {
2354             if(fp)
2355                 fclose(fp);
2356             break;
2357         }
2358     }
2359 #endif /* #if 0 */
2360     ALOGD("%s: X", __func__);
2361     return 0;
2362 } /* get_uvc_device */
2363 
2364 /******************************************************************************
2365  * Function: fileDump
2366  * Description: This is a utility function to dump buffers into a file
2367  *
2368  * Input parameters:
2369  *  fn              - File name string
2370  *  data            - pointer to character buffer that needs to be dumped
2371  *  length          - Length of the buffer to be dumped
2372  *  frm_cnt         - Pointer to frame count. This count is incremented by this
2373  *                      function on successful file write
2374  * Return values:
2375  *      0   Success
2376  *      -1  Error
2377  * Notes: none
2378  *****************************************************************************/
fileDump(const char * fn,char * data,int length,int * frm_cnt)2379 static int fileDump(const char* fn, char* data, int length, int* frm_cnt)
2380 {
2381 
2382     FILE *fp = NULL;
2383     if (0 == *frm_cnt) {
2384         fp = fopen(fn, "wb");
2385         if (NULL == fp) {
2386             ALOGE("%s: Error in opening %s", __func__, fn);
2387         }
2388         fclose(fp);
2389     }
2390     fp = fopen(fn, "ab");
2391     if (NULL == fp) {
2392         ALOGE("%s: Error in opening %s", __func__, fn);
2393     }
2394     fwrite(data, 1, length, fp);
2395     fclose(fp);
2396     (*frm_cnt)++;
2397     ALOGD("%s: Written %d bytes for frame:%d, in %s",
2398         __func__, length, *frm_cnt, fn);
2399 
2400     return 0;
2401 }
2402 
2403 /******************************************************************************
2404  * Function: launchTakePictureThread
2405  * Description: This is a wrapper function to start take picture thread
2406  *
2407  * Input parameters:
2408  *  camHal                  - camera HAL handle
2409  *
2410  * Return values:
2411  *   0      No error
2412  *   -1     Error
2413  *
2414  * Notes: none
2415  *****************************************************************************/
launchTakePictureThread(camera_hardware_t * camHal)2416 static int launchTakePictureThread(camera_hardware_t *camHal)
2417 {
2418     ALOGD("%s: E", __func__);
2419     int rc = 0;
2420 
2421     if(!camHal) {
2422         ALOGE("%s: camHal is NULL", __func__);
2423         return -1;
2424     }
2425 
2426     pthread_attr_t attr;
2427     pthread_attr_init(&attr);
2428     /* create the thread in detatched state, when the thread exits all */
2429     /* memory resources are freed up */
2430     pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
2431     pthread_create(&camHal->takePictureThread, &attr, takePictureThread, camHal);
2432 
2433     ALOGD("%s: X", __func__);
2434     return rc;
2435 }
2436 
2437 /******************************************************************************
2438  * Function: takePictureThread
2439  * Description: This function is associated with take picture thread
2440  *
2441  * Input parameters:
2442  *  camHal                  - camera HAL handle
2443  *
2444  * Return values:
2445  *   0      No error
2446  *   -1     Error
2447  *
2448  * Notes: none
2449  *****************************************************************************/
takePictureThread(void * hcamHal)2450 static void * takePictureThread(void *hcamHal)
2451 {
2452     int                 rc = 0;
2453     int                 buffer_id   = 0;
2454     pid_t               tid         = 0;
2455     camera_hardware_t   *camHal     = NULL;
2456     int                 msgType     = 0;
2457     int                 jpegLength  = 0;
2458     QCameraHalMemInfo_t *mem_info   = NULL;
2459 
2460     camHal = (camera_hardware_t *)hcamHal;
2461     ALOGI("%s: E", __func__);
2462 
2463     if(!camHal) {
2464         ALOGE("%s: camHal is NULL", __func__);
2465         return NULL ;
2466     }
2467 
2468     tid  = gettid();
2469     /* TBR: Set appropriate thread priority */
2470     androidSetThreadPriority(tid, ANDROID_PRIORITY_NORMAL);
2471     prctl(PR_SET_NAME, (unsigned long)"Camera HAL preview thread", 0, 0, 0);
2472 
2473     /************************************************************************/
2474     /* - If requested for shutter notfication, notify                       */
2475     /* - Initialize USB camera with snapshot parameters                     */
2476     /* - Time wait (select) on camera fd for camera frame availability      */
2477     /* - Dequeue capture buffer from USB camera                             */
2478     /* - Send capture buffer to JPEG encoder for JPEG compression           */
2479     /* - If jpeg frames callback is requested, callback with jpeg buffers   */
2480     /* - Enqueue capture buffer back to USB camera                          */
2481     /* - Free USB camera resources and close camera                         */
2482     /* - If preview was stopped for taking picture, restart the preview     */
2483     /************************************************************************/
2484 
2485     Mutex::Autolock autoLock(camHal->lock);
2486     /************************************************************************/
2487     /* - If requested for shutter notfication, notify                       */
2488     /************************************************************************/
2489 #if 0 /* TBD: Temporarily commented out due to an issue. Sometimes it takes */
2490     /* long time to get back the lock once unlocked and notify callback */
2491     if (camHal->msgEnabledFlag & CAMERA_MSG_SHUTTER){
2492         camHal->lock.unlock();
2493         camHal->notify_cb(CAMERA_MSG_SHUTTER, 0, 0, camHal->cb_ctxt);
2494         camHal->lock.lock();
2495     }
2496 #endif
2497     /************************************************************************/
2498     /* - Initialize USB camera with snapshot parameters                     */
2499     /************************************************************************/
2500     USB_CAM_OPEN(camHal);
2501 
2502 #if JPEG_ON_USB_CAMERA
2503     rc = initUsbCamera(camHal, camHal->pictWidth, camHal->pictHeight,
2504                         V4L2_PIX_FMT_MJPEG);
2505 #else
2506     rc = initUsbCamera(camHal, camHal->pictWidth, camHal->pictHeight,
2507                         V4L2_PIX_FMT_YUYV);
2508 #endif
2509     ERROR_CHECK_EXIT_THREAD(rc, "initUsbCamera");
2510 
2511     rc = startUsbCamCapture(camHal);
2512     ERROR_CHECK_EXIT_THREAD(rc, "startUsbCamCapture");
2513 
2514     /************************************************************************/
2515     /* - Time wait (select) on camera fd for camera frame availability      */
2516     /************************************************************************/
2517     {
2518         fd_set fds;
2519         struct timeval tv;
2520         int r = 0;
2521 
2522         FD_ZERO(&fds);
2523         FD_SET(camHal->fd, &fds);
2524 
2525         tv.tv_sec = 1;
2526         tv.tv_usec = 0;
2527 
2528         do{
2529             ALOGD("%s: b4 select on camHal->fd : %d", __func__, camHal->fd);
2530             r = select(camHal->fd + 1, &fds, NULL, NULL, &tv);
2531             ALOGD("%s: after select", __func__);
2532         }while((0 == r) || ((-1 == r) && (EINTR == errno)));
2533 
2534         if ((-1 == r) && (EINTR != errno)){
2535             ALOGE("%s: FDSelect ret = %d error: %d", __func__, r, errno);
2536             return (void *)-1;
2537         }
2538 
2539     }
2540     /************************************************************************/
2541     /* - Dequeue capture buffer from USB camera                             */
2542     /************************************************************************/
2543     if (0 == get_buf_from_cam(camHal))
2544         ALOGD("%s: get_buf_from_cam success", __func__);
2545     else
2546         ALOGE("%s: get_buf_from_cam error", __func__);
2547 
2548     /************************************************************************/
2549     /* - Send capture buffer to JPEG encoder for JPEG compression           */
2550     /************************************************************************/
2551     mem_info = &camHal->pictMem.mem_info[0];
2552     mem_info->size = MAX_JPEG_BUFFER_SIZE;
2553 
2554     rc = allocate_ion_memory(mem_info,
2555                         ((0x1 << CAMERA_ZSL_ION_HEAP_ID) |
2556                         (0x1 << CAMERA_ZSL_ION_FALLBACK_HEAP_ID)));
2557     if(rc)
2558         ALOGE("%s: ION memory allocation failed", __func__);
2559 
2560     camHal->pictMem.camera_memory[0] = camHal->get_memory(
2561                         mem_info->fd, mem_info->size, 1, camHal->cb_ctxt);
2562     if(!camHal->pictMem.camera_memory[0])
2563         ALOGE("%s: get_mem failed", __func__);
2564 
2565 #if FREAD_JPEG_PICTURE
2566     jpegLength = readFromFile("/data/tempVGA.jpeg",
2567                     (char*)camHal->pictMem.camera_memory[0]->data,
2568                     camHal->pictMem.camera_memory[0]->size);
2569     camHal->pictMem.camera_memory[0]->size = jpegLength;
2570 
2571 #elif JPEG_ON_USB_CAMERA
2572     memcpy((char*)camHal->pictMem.camera_memory[0]->data,
2573             (char *)camHal->buffers[camHal->curCaptureBuf.index].data,
2574             camHal->curCaptureBuf.bytesused);
2575     camHal->pictMem.camera_memory[0]->size = camHal->curCaptureBuf.bytesused;
2576     jpegLength = camHal->curCaptureBuf.bytesused;
2577 
2578 #else
2579     rc = encodeJpeg(camHal);
2580     ERROR_CHECK_EXIT_THREAD(rc, "jpeg_encode");
2581 #endif
2582     if(jpegLength <= 0)
2583         ALOGI("%s: jpegLength : %d", __func__, jpegLength);
2584 
2585      ALOGD("%s: jpegLength : %d", __func__, jpegLength);
2586     /************************************************************************/
2587     /* - If jpeg frames callback is requested, callback with jpeg buffers   */
2588     /************************************************************************/
2589     /* TBD: CAMERA_MSG_RAW_IMAGE data call back */
2590 
2591     if ((camHal->msgEnabledFlag & CAMERA_MSG_COMPRESSED_IMAGE) &&
2592             (camHal->data_cb)){
2593         /* Unlock temporarily, callback might call HAL api in turn */
2594         camHal->lock.unlock();
2595 
2596         camHal->data_cb(CAMERA_MSG_COMPRESSED_IMAGE,
2597                         camHal->pictMem.camera_memory[0],
2598                         0, NULL, camHal->cb_ctxt);
2599         camHal->lock.lock();
2600     }
2601 
2602     /* release heap memory after the call back */
2603     if(camHal->pictMem.camera_memory[0])
2604         camHal->pictMem.camera_memory[0]->release(
2605             camHal->pictMem.camera_memory[0]);
2606 
2607     rc = deallocate_ion_memory(mem_info);
2608     if(rc)
2609         ALOGE("%s: ION memory de-allocation failed", __func__);
2610 
2611     /************************************************************************/
2612     /* - Enqueue capture buffer back to USB camera                          */
2613     /************************************************************************/
2614     if(0 == put_buf_to_cam(camHal)) {
2615         ALOGD("%s: put_buf_to_cam success", __func__);
2616     }
2617     else
2618         ALOGE("%s: put_buf_to_cam error", __func__);
2619 
2620     /************************************************************************/
2621     /* - Free USB camera resources and close camera                         */
2622     /************************************************************************/
2623     rc = stopUsbCamCapture(camHal);
2624     ERROR_CHECK_EXIT_THREAD(rc, "stopUsbCamCapture");
2625 
2626     rc = unInitV4L2mmap(camHal);
2627     ERROR_CHECK_EXIT_THREAD(rc, "unInitV4L2mmap");
2628 
2629     USB_CAM_CLOSE(camHal);
2630     /************************************************************************/
2631     /* - If preview was stopped for taking picture, restart the preview     */
2632     /************************************************************************/
2633     if(camHal->prvwStoppedForPicture)
2634     {
2635         struct camera_device    device;
2636         device.priv = (void *)camHal;
2637 
2638         USB_CAM_OPEN(camHal);
2639         /* Unlock temporarily coz usbcam_start_preview has a lock */
2640         camHal->lock.unlock();
2641         rc = usbcam_start_preview(&device);
2642         if(rc)
2643             ALOGE("%s: start_preview error after take picture", __func__);
2644         camHal->lock.lock();
2645         camHal->prvwStoppedForPicture = 0;
2646     }
2647 
2648     /* take picture activity is done */
2649     camHal->takePictInProgress = 0;
2650 
2651     ALOGI("%s: X", __func__);
2652     return (void *)0;
2653 }
2654 
2655 /******************************************************************************
2656  * Function: allocate_ion_memory
2657  * Description: This function is allocates ION memory
2658  *
2659  * Input parameters:
2660  *  camHal                  - camera HAL handle
2661  *
2662  * Return values:
2663  *   0      No error
2664  *   -1     Error
2665  *
2666  * Notes: none
2667  *****************************************************************************/
allocate_ion_memory(QCameraHalMemInfo_t * mem_info,int ion_type)2668 static int allocate_ion_memory(QCameraHalMemInfo_t *mem_info, int ion_type)
2669 {
2670     int                         rc = 0;
2671     struct ion_handle_data      handle_data;
2672     struct ion_allocation_data  alloc;
2673     struct ion_fd_data          ion_info_fd;
2674     int                         main_ion_fd = 0;
2675 
2676     main_ion_fd = open("/dev/ion", O_RDONLY);
2677     if (main_ion_fd <= 0) {
2678         ALOGE("Ion dev open failed %s\n", strerror(errno));
2679         goto ION_OPEN_FAILED;
2680     }
2681 
2682     memset(&alloc, 0, sizeof(alloc));
2683     alloc.len = mem_info->size;
2684     /* to make it page size aligned */
2685     alloc.len = (alloc.len + 4095) & (~4095);
2686     alloc.align = 4096;
2687     alloc.flags = ION_FLAG_CACHED;
2688     alloc.heap_id_mask = ion_type;
2689     rc = ioctl(main_ion_fd, ION_IOC_ALLOC, &alloc);
2690     if (rc < 0) {
2691         ALOGE("ION allocation failed\n");
2692         goto ION_ALLOC_FAILED;
2693     }
2694 
2695     memset(&ion_info_fd, 0, sizeof(ion_info_fd));
2696     ion_info_fd.handle = alloc.handle;
2697     rc = ioctl(main_ion_fd, ION_IOC_SHARE, &ion_info_fd);
2698     if (rc < 0) {
2699         ALOGE("ION map failed %s\n", strerror(errno));
2700         goto ION_MAP_FAILED;
2701     }
2702 
2703     mem_info->main_ion_fd = main_ion_fd;
2704     mem_info->fd = ion_info_fd.fd;
2705     mem_info->handle = ion_info_fd.handle;
2706     mem_info->size = alloc.len;
2707     return 0;
2708 
2709 ION_MAP_FAILED:
2710     memset(&handle_data, 0, sizeof(handle_data));
2711     handle_data.handle = ion_info_fd.handle;
2712     ioctl(main_ion_fd, ION_IOC_FREE, &handle_data);
2713 ION_ALLOC_FAILED:
2714     close(main_ion_fd);
2715 ION_OPEN_FAILED:
2716     return -1;
2717 }
2718 
2719 /******************************************************************************
2720  * Function: deallocate_ion_memory
2721  * Description: This function de allocates ION memory
2722  *
2723  * Input parameters:
2724  *  camHal                  - camera HAL handle
2725  *
2726  * Return values:
2727  *   0      No error
2728  *   -1     Error
2729  *
2730  * Notes: none
2731  *****************************************************************************/
deallocate_ion_memory(QCameraHalMemInfo_t * mem_info)2732 static int deallocate_ion_memory(QCameraHalMemInfo_t *mem_info)
2733 {
2734   struct ion_handle_data handle_data;
2735   int rc = 0;
2736 
2737   if (mem_info->fd > 0) {
2738       close(mem_info->fd);
2739       mem_info->fd = 0;
2740   }
2741 
2742   if (mem_info->main_ion_fd > 0) {
2743       memset(&handle_data, 0, sizeof(handle_data));
2744       handle_data.handle = mem_info->handle;
2745       ioctl(mem_info->main_ion_fd, ION_IOC_FREE, &handle_data);
2746       close(mem_info->main_ion_fd);
2747       mem_info->main_ion_fd = 0;
2748   }
2749   return rc;
2750 }
2751 
2752 /******************************************************************************
2753  * Function: readFromFile
2754  * Description: This function reads data from the given file into given buffer
2755  *
2756  * Input parameters:
2757  *  camHal                  - camera HAL handle
2758  *
2759  * Return values:
2760  *   int    bytesRead
2761  *
2762  * Notes: none
2763  *****************************************************************************/
readFromFile(char * fileName,char * buffer,int bufferSize)2764 static int readFromFile(char* fileName, char* buffer, int bufferSize)
2765 {
2766     int bytesRead = 0, fileSize = 0;
2767     FILE *fp;
2768 
2769     fp = fopen(fileName, "rb");
2770     if(!fp){
2771         ALOGE("%s: Error in opening %s ", __func__, fileName);
2772         return bytesRead;
2773     }
2774 
2775     /* If file is bigger for given buffer, exit */
2776     if (fileSize > bufferSize){
2777         ALOGE("%s: Error %d > %d", __func__, fileSize, bufferSize);
2778         return bytesRead;
2779     }
2780 
2781     bytesRead = fread(buffer, 1, bufferSize, fp);
2782     ALOGD(" %s: bytesRead: %d", __func__, bytesRead);
2783 
2784     return bytesRead;
2785 }
2786 
2787 /******************************************************************************
2788  * Function: encodeJpeg
2789  * Description: This function initializes Jpeg encoder and calls jpeg encoder
2790  *              call and waits for the encode to complete
2791  *
2792  * Input parameters:
2793  *  camHal                  - camera HAL handle
2794  *
2795  * Return values:
2796  *   0  No Error
2797  *  -1  Error
2798  *
2799  * Notes: none
2800  *****************************************************************************/
encodeJpeg(camera_hardware_t * camHal)2801 int encodeJpeg(camera_hardware_t *camHal)
2802 {
2803     int                 rc = 0;
2804     mm_jpeg_ops_t       mmJpegOps;
2805     int                 jpegEncHdl  = 0;
2806     mm_jpeg_job         mmJpegJob;
2807     src_image_buffer_info   *srcBuf = NULL;
2808     QCameraHalMemInfo_t jpegInMemInfo;
2809     camera_memory_t*    jpegInMem;
2810     uint32_t            jobId;
2811 
2812     ALOGI("%s: E", __func__);
2813 
2814     /************************************************************************/
2815     /* - Allocate Jpeg input buffer from ION memory                         */
2816     /************************************************************************/
2817     jpegInMemInfo.size = camHal->pictWidth * camHal->pictHeight * 2;
2818     rc = allocate_ion_memory(&jpegInMemInfo,
2819                         ((0x1 << CAMERA_ZSL_ION_HEAP_ID) |
2820                         (0x1 << CAMERA_ZSL_ION_FALLBACK_HEAP_ID)));
2821     ERROR_CHECK_EXIT(rc, "allocate_ion_memory");
2822 
2823     jpegInMem = camHal->get_memory(
2824                         jpegInMemInfo.fd, jpegInMemInfo.size, 1, camHal->cb_ctxt);
2825     if(!jpegInMem){
2826         ALOGE("%s: get_mem failed", __func__);
2827         return -1;
2828     }
2829 
2830     rc = convert_YUYV_to_420_NV12(
2831         (char *)camHal->buffers[camHal->curCaptureBuf.index].data,
2832         (char *)jpegInMem->data, camHal->pictWidth, camHal->pictHeight);
2833     ERROR_CHECK_EXIT(rc, "convert_YUYV_to_420_NV12");
2834     /************************************************************************/
2835     /* - Populate JPEG encoding parameters from the camHal context          */
2836     /************************************************************************/
2837     memset(&mmJpegJob, 0, sizeof(mmJpegJob));
2838 
2839     mmJpegJob.job_type              = JPEG_JOB_TYPE_ENCODE;
2840     mmJpegJob.encode_job.jpeg_cb    = jpegEncodeCb;
2841     mmJpegJob.encode_job.userdata   = (void *)camHal;
2842     /* TBD: Rotation to be set from settings sent from app */
2843     mmJpegJob.encode_job.encode_parm.rotation           = 0;
2844     mmJpegJob.encode_job.encode_parm.exif_numEntries    = 0;
2845     mmJpegJob.encode_job.encode_parm.exif_data          = NULL;
2846 
2847     /* TBD: Add thumbnail support */
2848     mmJpegJob.encode_job.encode_parm.buf_info.src_imgs.src_img_num = 1;
2849     mmJpegJob.encode_job.encode_parm.buf_info.src_imgs.is_video_frame = 0;
2850 
2851     /* Fill main image information */
2852     srcBuf = &mmJpegJob.encode_job.encode_parm.buf_info.src_imgs.src_img[0];
2853     srcBuf->type                = JPEG_SRC_IMAGE_TYPE_MAIN;
2854     srcBuf->img_fmt             = JPEG_SRC_IMAGE_FMT_YUV;
2855     /* TBD: convert from YUYV to CRCBH2V2 */
2856     srcBuf->color_format        = MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V2;
2857     srcBuf->num_bufs            = 1;
2858     srcBuf->src_image[0].fd        = jpegInMemInfo.fd;
2859     srcBuf->src_image[0].buf_vaddr = (uint8_t*)jpegInMem->data;
2860     //srcBuf->src_image[0].offset    = 0;
2861     srcBuf->src_dim.width       = camHal->pictWidth;
2862     srcBuf->src_dim.height      = camHal->pictHeight;
2863     srcBuf->out_dim.width       = camHal->pictWidth;
2864     srcBuf->out_dim.height      = camHal->pictHeight;
2865     srcBuf->crop.offset_x       = 0;
2866     srcBuf->crop.offset_y       = 0;
2867     srcBuf->crop.width          = srcBuf->src_dim.width;
2868     srcBuf->crop.height         = srcBuf->src_dim.height;
2869     srcBuf->quality             = camHal->pictJpegQlty;
2870 
2871     /* TBD:Fill thumbnail image information */
2872 
2873     /* Fill out buf information */
2874     mmJpegJob.encode_job.encode_parm.buf_info.sink_img.buf_vaddr =
2875                             (uint8_t*)camHal->pictMem.camera_memory[0]->data;
2876     mmJpegJob.encode_job.encode_parm.buf_info.sink_img.fd = 0;
2877     /* TBD: hard coded for 1.5 bytes per pixel */
2878     mmJpegJob.encode_job.encode_parm.buf_info.sink_img.buf_len =
2879                             camHal->pictWidth * camHal->pictHeight * 1.5;
2880 
2881     /************************************************************************/
2882     /* - Initialize jpeg encoder and call Jpeg encoder start                */
2883     /************************************************************************/
2884     memset(&mmJpegOps, 0, sizeof(mm_jpeg_ops_t));
2885     jpegEncHdl = jpeg_open(&mmJpegOps);
2886     if(!jpegEncHdl){
2887         ALOGE("%s: Failed to open Jpeg Encoder instance", __func__);
2888     }else
2889         ALOGD("%s: jpegEncHdl = %d", __func__, jpegEncHdl);
2890 
2891     camHal->jpegEncInProgress = 1;
2892     rc = mmJpegOps.start_job(jpegEncHdl, &mmJpegJob, &jobId);
2893 
2894     /************************************************************************/
2895     /* - Wait for JPEG encoder to complete encoding                         */
2896     /************************************************************************/
2897     pthread_mutex_init(&camHal->jpegEncMutex, NULL);
2898     pthread_cond_init(&camHal->jpegEncCond, NULL);
2899 
2900     pthread_mutex_lock(&camHal->jpegEncMutex);
2901     while(camHal->jpegEncInProgress)
2902         pthread_cond_wait(&camHal->jpegEncCond, &camHal->jpegEncMutex);
2903     pthread_mutex_unlock(&camHal->jpegEncMutex);
2904 
2905     /************************************************************************/
2906     /* - De-allocate Jpeg input buffer from ION memory                      */
2907     /************************************************************************/
2908     if(jpegInMem)
2909         jpegInMem->release(jpegInMem);
2910 
2911     rc = deallocate_ion_memory(&jpegInMemInfo);
2912     if(rc)
2913         ALOGE("%s: ION memory de-allocation failed", __func__);
2914 
2915     ALOGI("%s: X rc = %d", __func__, rc);
2916     return rc;
2917 }
2918 
2919 /******************************************************************************
2920  * Function: jpegEncodeCb
2921  * Description: This is a call back function registered with JPEG encoder.
2922  *              Jpeg encoder calls this function on completion of encoding
2923  *
2924  * Input parameters:
2925  *  camHal                  - camera HAL handle
2926  *
2927  * Return values:
2928  *   0  No Error
2929  *  -1  Error
2930  *
2931  * Notes: none
2932  *****************************************************************************/
jpegEncodeCb(jpeg_job_status_t status,uint8_t thumbnailDroppedFlag,uint32_t client_hdl,uint32_t jobId,uint8_t * out_data,uint32_t data_size,void * userData)2933 void jpegEncodeCb   (jpeg_job_status_t status,
2934                        uint8_t thumbnailDroppedFlag,
2935                        uint32_t client_hdl,
2936                        uint32_t jobId,
2937                        uint8_t* out_data,
2938                        uint32_t data_size,
2939                        void *userData)
2940 {
2941     int rc = 0;
2942     camera_hardware_t *camHal = NULL;
2943 
2944     ALOGI("%s: E status = %d", __func__, status);
2945 
2946     camHal = (camera_hardware_t*) userData;
2947 
2948     if(JPEG_JOB_STATUS_DONE == status){
2949         ALOGD("%s: JPEG encode successful. out_data:%p, size: %d", __func__,
2950             out_data, data_size);
2951         camHal->jpegEncInProgress = 0;
2952     }
2953 
2954     pthread_mutex_lock(&camHal->jpegEncMutex);
2955     pthread_cond_signal(&camHal->jpegEncCond);
2956     pthread_mutex_unlock(&camHal->jpegEncMutex);
2957 
2958     ALOGI("%s: X", __func__);
2959     return;
2960 }
2961 
2962 /******************************************************************************/
2963 }; // namespace android
2964