1/* Copyright (c) 2012-2013, 2016, 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 */ 29 30// To remove 31#include <cutils/properties.h> 32 33// Camera dependencies 34#include "mm_qcamera_commands.h" 35#include "mm_qcamera_dbg.h" 36 37int tuneserver_initialize_prevtuningp(void * ctrl, 38 int pr_client_socket_id, cam_dimension_t dimension, 39 char **send_buf, uint32_t *send_len) 40{ 41 int result = 0; 42 mm_camera_lib_handle *lib_handle = (mm_camera_lib_handle *) ctrl; 43 tuningserver_t *tctrl = &lib_handle->tsctrl; 44 45 LOGD("E"); 46 if (tctrl->tuning_params.func_tbl->prevcommand_process == NULL) { 47 LOGE("prevcommand_process is NULL"); 48 return -1; 49 } 50 51 result = tctrl->tuning_params.func_tbl->prevcommand_process( 52 NULL, TUNE_PREVCMD_INIT, (void *)&pr_client_socket_id, 53 send_buf, send_len); 54 result = tctrl->tuning_params.func_tbl->prevcommand_process( 55 NULL, TUNE_PREVCMD_SETDIM, (void *)&dimension, 56 send_buf, send_len); 57 58 mm_camera_lib_set_preview_usercb(lib_handle, 59 (tctrl->tuning_params.func_tbl->prevframe_callback)); 60 61 return result; 62} 63 64int tuneserver_deinitialize_prevtuningp(void * ctrl, 65 char **send_buf, uint32_t *send_len) 66{ 67 int result = 0; 68 tuningserver_t *tctrl = (tuningserver_t *) ctrl; 69 70 LOGD("E"); 71 72 result = tctrl->tuning_params.func_tbl->prevcommand_process( 73 &tctrl->pr_proto, TUNE_PREVCMD_DEINIT, NULL, send_buf, send_len); 74 75 return result; 76} 77 78int tuneserver_preview_getinfo(void * ctrl, char **send_buf, uint32_t *send_len) 79{ 80 int result = 0; 81 tuningserver_t *tctrl = (tuningserver_t *) ctrl; 82 83 LOGD("E"); 84 result = tctrl->tuning_params.func_tbl->prevcommand_process( 85 &tctrl->pr_proto, TUNE_PREVCMD_GETINFO, NULL, send_buf, send_len); 86 87 return result; 88} 89 90int tuneserver_preview_getchunksize(void * ctrl, 91 char **send_buf, uint32_t *send_len) 92{ 93 int result = 0; 94 tuningserver_t *tctrl = (tuningserver_t *) ctrl; 95 96 LOGD("E"); 97 result = tctrl->tuning_params.func_tbl->prevcommand_process( 98 &tctrl->pr_proto, TUNE_PREVCMD_GETCHUNKSIZE, 99 (void *)&tctrl->pr_proto->new_cnk_size, send_buf, send_len); 100 101 return result; 102} 103 104int tuneserver_preview_getframe(void * ctrl, 105 char **send_buf, uint32_t *send_len) 106{ 107 int result = 0; 108 tuningserver_t *tctrl = (tuningserver_t *) ctrl; 109 110 LOGD("E"); 111 result = tctrl->tuning_params.func_tbl->prevcommand_process( 112 &tctrl->pr_proto, TUNE_PREVCMD_GETFRAME, NULL, send_buf, send_len); 113 114 return result; 115} 116 117int tuneserver_preview_unsupported(void * ctrl, 118 char **send_buf, uint32_t *send_len) 119{ 120 int result = 0; 121 tuningserver_t *tctrl = (tuningserver_t *) ctrl; 122 123 LOGD("E"); 124 result = tctrl->tuning_params.func_tbl->prevcommand_process( 125 &tctrl->pr_proto, TUNE_PREVCMD_UNSUPPORTED, NULL, send_buf, send_len); 126 127 return result; 128} 129 130int tuneserver_initialize_tuningp(void * ctrl, int client_socket_id, 131 char *send_buf, uint32_t send_len) 132{ 133 int result = 0; 134 mm_camera_lib_handle *lib_handle = (mm_camera_lib_handle *) ctrl; 135 tuningserver_t *tctrl = &lib_handle->tsctrl; 136 137 LOGD("E"); 138 result = tctrl->tuning_params.func_tbl->command_process( 139 lib_handle, TUNE_CMD_INIT, &client_socket_id, send_buf, send_len); 140 141 return result; 142} 143 144int tuneserver_deinitialize_tuningp(void * ctrl, int client_socket_id, 145 char *send_buf, uint32_t send_len) 146{ 147 int result = 0; 148 tuningserver_t *tctrl = (tuningserver_t *) ctrl; 149 150 LOGD("E"); 151 152 result = tctrl->tuning_params.func_tbl->command_process( 153 NULL, TUNE_CMD_DEINIT, &client_socket_id, send_buf, send_len); 154 155 return result; 156} 157 158int tuneserver_process_get_list_cmd(void * ctrl, void *recv_cmd, 159 char *send_buf, uint32_t send_len) 160{ 161 int result = 0; 162 tuningserver_t *tctrl = (tuningserver_t *) ctrl; 163 164 LOGD("E"); 165 result = tctrl->tuning_params.func_tbl->command_process( 166 recv_cmd, TUNE_CMD_GET_LIST, NULL, send_buf, send_len); 167 168 return result; 169} 170 171int tuneserver_process_get_params_cmd(void * ctrl, void *recv_cmd, 172 char *send_buf, uint32_t send_len) 173{ 174 int result = 0; 175 tuningserver_t *tctrl = (tuningserver_t *) ctrl; 176 177 LOGD("E"); 178 result = tctrl->tuning_params.func_tbl->command_process 179 (recv_cmd, TUNE_CMD_GET_PARAMS, NULL, send_buf, send_len); 180 181 return result; 182} 183 184int tuneserver_process_set_params_cmd(void * ctrl, void *recv_cmd, 185 char *send_buf, uint32_t send_len) 186{ 187 int result = 0; 188 tuningserver_t *tctrl = (tuningserver_t *) ctrl; 189 190 LOGD("E"); 191 result = tctrl->tuning_params.func_tbl->command_process( 192 recv_cmd, TUNE_CMD_SET_PARAMS, NULL, send_buf, send_len); 193 194 return result; 195} 196 197int tuneserver_process_misc_cmd(void * ctrl, void *recv_cmd, 198 char *send_buf, uint32_t send_len) 199{ 200 int result = 0; 201 tuningserver_t *tctrl = (tuningserver_t *) ctrl; 202 203 LOGD("E"); 204 result = tctrl->tuning_params.func_tbl->command_process( 205 recv_cmd, TUNE_CMD_MISC, NULL, send_buf, send_len); 206 207 return result; 208} 209 210/** tuneserver_close_cam 211 * @lib_handle: the camera handle object 212 * 213 * closes the camera 214 * 215 * Return: >=0 on success, -1 on failure. 216 **/ 217int tuneserver_close_cam(mm_camera_lib_handle *lib_handle) 218{ 219 int result = 0; 220 221 result = mm_camera_lib_close(lib_handle); 222 if (result < 0) { 223 printf(" Camera close failed\n"); 224 } else { 225 printf("Camera is closed \n"); 226 } 227 return result; 228} 229#if 0 230/** tuneserver_start_cam 231 * @lib_handle: the camera handle object 232 * 233 * starts the camera 234 * 235 * Return: >=0 on success, -1 on failure. 236 **/ 237static int tuneserver_start_cam(mm_camera_lib_handle *lib_handle) 238{ 239 int result = 0; 240 241 result = mm_camera_lib_start_stream(lib_handle); 242 if (result < 0) { 243 printf(" Camera start failed\n"); 244 goto error1; 245 } 246 return result; 247error1: 248 mm_camera_lib_close(lib_handle); 249 return result; 250} 251#endif 252 253/** tuneserver_stop_cam 254 * @lib_handle: the camera handle object 255 * 256 * stops the camera 257 * 258 * Return: >=0 on success, -1 on failure. 259 **/ 260int tuneserver_stop_cam(mm_camera_lib_handle *lib_handle) 261{ 262 int result = 0; 263 264 result = mm_camera_lib_stop_stream(lib_handle); 265 if (result < 0) { 266 printf(" Camera stop failed\n"); 267 } 268// result = mm_camera_lib_close(lib_handle); 269 return result; 270} 271 272/** tuneserver_open_cam 273 * @lib_handle: the camera handle object 274 * 275 * opens the camera 276 * 277 * Return: >=0 on success, -1 on failure. 278 **/ 279#if 1 280int tuneserver_open_cam(mm_camera_lib_handle *lib_handle) 281{ 282 int result = 0; 283 284 LOGD("E"); 285 result = mm_camera_load_tuninglibrary(&lib_handle->tsctrl.tuning_params); 286 if (result < 0) { 287 LOGE(" tuning library open failed\n"); 288 } 289 return result; 290} 291#endif 292