| /* Copyright (c) 2012, The Linux Foundation. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials provided |
| * with the distribution. |
| * * Neither the name of The Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS |
| * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR |
| * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
| * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE |
| * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN |
| * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include <sys/types.h> |
| #include <stdbool.h> |
| #include <fcntl.h> |
| #include <dlfcn.h> |
| #include "OMX_Types.h" |
| #include "OMX_Index.h" |
| #include "OMX_Core.h" |
| #include "OMX_Component.h" |
| #include "omx_debug.h" |
| #include "omx_jpeg_ext.h" |
| #include "mm_omx_jpeg_encoder.h" |
| |
| static uint8_t hw_encode = true; |
| static int jpegRotation = 0; |
| static int isZSLMode = 0; |
| static int jpegThumbnailQuality = 75; |
| static int jpegMainimageQuality = 85; |
| static uint32_t phy_offset; |
| void *user_data; |
| |
| static int encoding = 0; |
| pthread_mutex_t jpege_mutex = PTHREAD_MUTEX_INITIALIZER; |
| pthread_mutex_t jpegcb_mutex = PTHREAD_MUTEX_INITIALIZER; |
| |
| jpegfragment_callback_t mmcamera_jpegfragment_callback; |
| jpeg_callback_t mmcamera_jpeg_callback; |
| |
| |
| #define INPUT_PORT 0 |
| #define OUTPUT_PORT 1 |
| #define INPUT_PORT1 2 |
| #define DEFAULT_COLOR_FORMAT YCRCBLP_H2V2 |
| |
| typedef struct { |
| cam_format_t isp_format; |
| jpeg_color_format_t jpg_format; |
| } color_format_map_t; |
| |
| |
| static const color_format_map_t color_format_map[] = { |
| {CAMERA_YUV_420_NV21, YCRCBLP_H2V2}, /*default*/ |
| {CAMERA_YUV_420_NV21_ADRENO, YCRCBLP_H2V2}, |
| {CAMERA_YUV_420_NV12, YCBCRLP_H2V2}, |
| {CAMERA_YUV_420_YV12, YCBCRLP_H2V2}, |
| {CAMERA_YUV_422_NV61, YCRCBLP_H2V1}, |
| {CAMERA_YUV_422_NV16, YCBCRLP_H2V1}, |
| }; |
| |
| static OMX_HANDLETYPE pHandle; |
| static OMX_CALLBACKTYPE callbacks; |
| static OMX_INDEXTYPE type; |
| static OMX_CONFIG_ROTATIONTYPE rotType; |
| static omx_jpeg_thumbnail thumbnail; |
| static OMX_CONFIG_RECTTYPE recttype; |
| static OMX_PARAM_PORTDEFINITIONTYPE * inputPort; |
| static OMX_PARAM_PORTDEFINITIONTYPE * outputPort; |
| static OMX_PARAM_PORTDEFINITIONTYPE * inputPort1; |
| static OMX_BUFFERHEADERTYPE* pInBuffers; |
| static OMX_BUFFERHEADERTYPE* pOutBuffers; |
| static OMX_BUFFERHEADERTYPE* pInBuffers1; |
| OMX_INDEXTYPE user_preferences; |
| omx_jpeg_user_preferences userpreferences; |
| OMX_INDEXTYPE exif; |
| static omx_jpeg_exif_info_tag tag; |
| |
| static void *libmmstillomx; |
| OMX_ERRORTYPE OMX_APIENTRY (*pOMX_GetHandle)( |
| OMX_OUT OMX_HANDLETYPE* pHandle, |
| OMX_IN OMX_STRING cComponentName, |
| OMX_IN OMX_PTR pAppData, |
| OMX_IN OMX_CALLBACKTYPE* pCallBacks); |
| OMX_ERRORTYPE OMX_APIENTRY (*pOMX_Init)(void); |
| OMX_ERRORTYPE OMX_APIENTRY (*pOMX_Deinit)(void); |
| |
| static pthread_mutex_t lock; |
| static pthread_cond_t cond; |
| static int expectedEvent = 0; |
| static int expectedValue1 = 0; |
| static int expectedValue2 = 0; |
| static omx_jpeg_pmem_info pmem_info; |
| static omx_jpeg_pmem_info pmem_info1; |
| static OMX_IMAGE_PARAM_QFACTORTYPE qFactor; |
| static omx_jpeg_thumbnail_quality thumbnailQuality; |
| static OMX_INDEXTYPE thumbnailQualityType; |
| static void *out_buffer; |
| static int * out_buffer_size; |
| static OMX_INDEXTYPE buffer_offset; |
| static omx_jpeg_buffer_offset bufferoffset; |
| |
| static jpeg_color_format_t get_jpeg_format_from_cam_format( |
| cam_format_t cam_format ) |
| { |
| jpeg_color_format_t jpg_format = DEFAULT_COLOR_FORMAT; |
| int i, j; |
| j = sizeof (color_format_map) / sizeof(color_format_map_t); |
| ALOGV("%s: j =%d, cam_format =%d", __func__, j, cam_format); |
| for(i =0; i< j; i++) { |
| if (color_format_map[i].isp_format == cam_format){ |
| jpg_format = color_format_map[i].jpg_format; |
| break; |
| } |
| } |
| ALOGV("%s x: i =%d, jpg_format=%d", __func__, i, jpg_format); |
| |
| return jpg_format; |
| } |
| static omx_jpeg_buffer_offset bufferoffset1; |
| void set_callbacks( |
| jpegfragment_callback_t fragcallback, |
| jpeg_callback_t eventcallback, void* userdata, |
| void* output_buffer, |
| int * outBufferSize) { |
| pthread_mutex_lock(&jpegcb_mutex); |
| mmcamera_jpegfragment_callback = fragcallback; |
| mmcamera_jpeg_callback = eventcallback; |
| user_data = userdata; |
| out_buffer = output_buffer; |
| out_buffer_size = outBufferSize; |
| pthread_mutex_unlock(&jpegcb_mutex); |
| } |
| |
| |
| OMX_ERRORTYPE etbdone(OMX_OUT OMX_HANDLETYPE hComponent, |
| OMX_OUT OMX_PTR pAppData, |
| OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer) |
| { |
| pthread_mutex_lock(&lock); |
| expectedEvent = OMX_EVENT_ETB_DONE; |
| expectedValue1 = 0; |
| expectedValue2 = 0; |
| pthread_cond_signal(&cond); |
| pthread_mutex_unlock(&lock); |
| return 0; |
| } |
| |
| OMX_ERRORTYPE ftbdone(OMX_OUT OMX_HANDLETYPE hComponent, |
| OMX_OUT OMX_PTR pAppData, |
| OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer) |
| { |
| ALOGV("%s", __func__); |
| *out_buffer_size = pBuffer->nFilledLen; |
| pthread_mutex_lock(&lock); |
| expectedEvent = OMX_EVENT_FTB_DONE; |
| expectedValue1 = 0; |
| expectedValue2 = 0; |
| pthread_cond_signal(&cond); |
| pthread_mutex_unlock(&lock); |
| ALOGV("%s:filled len = %u", __func__, (uint32_t)pBuffer->nFilledLen); |
| if (mmcamera_jpeg_callback && encoding) |
| mmcamera_jpeg_callback(0, user_data); |
| return 0; |
| } |
| |
| OMX_ERRORTYPE handleError(OMX_IN OMX_EVENTTYPE eEvent, OMX_IN OMX_U32 error) |
| { |
| ALOGV("%s", __func__); |
| if (error == OMX_EVENT_JPEG_ERROR) { |
| if (mmcamera_jpeg_callback && encoding) { |
| ALOGV("%s:OMX_EVENT_JPEG_ERROR\n", __func__); |
| mmcamera_jpeg_callback(JPEG_EVENT_ERROR, user_data); |
| } |
| } else if (error == OMX_EVENT_THUMBNAIL_DROPPED) { |
| if (mmcamera_jpeg_callback && encoding) { |
| ALOGV("%s:(OMX_EVENT_THUMBNAIL_DROPPED\n", __func__); |
| mmcamera_jpeg_callback(JPEG_EVENT_THUMBNAIL_DROPPED, user_data); |
| } |
| } |
| return 0; |
| } |
| |
| OMX_ERRORTYPE eventHandler( OMX_IN OMX_HANDLETYPE hComponent, |
| OMX_IN OMX_PTR pAppData, OMX_IN OMX_EVENTTYPE eEvent, |
| OMX_IN OMX_U32 nData1, OMX_IN OMX_U32 nData2, |
| OMX_IN OMX_PTR pEventData) |
| { |
| ALOGV("%s", __func__); |
| ALOGV("%s:got event %d ndata1 %u ndata2 %u", __func__, |
| eEvent, nData1, nData2); |
| pthread_mutex_lock(&lock); |
| expectedEvent = eEvent; |
| expectedValue1 = nData1; |
| expectedValue2 = nData2; |
| pthread_cond_signal(&cond); |
| pthread_mutex_unlock(&lock); |
| if ((nData1== OMX_EVENT_JPEG_ERROR)||(nData1== OMX_EVENT_THUMBNAIL_DROPPED)) |
| handleError(eEvent,nData1); |
| return 0; |
| } |
| |
| void waitForEvent(int event, int value1, int value2 ){ |
| pthread_mutex_lock(&lock); |
| ALOGV("%s:Waiting for:event=%d, value1=%d, value2=%d", |
| __func__, event, value1, value2); |
| while (! (expectedEvent == event && |
| expectedValue1 == value1 && expectedValue2 == value2)) { |
| pthread_cond_wait(&cond, &lock); |
| ALOGV("%s:After cond_wait:expectedEvent=%d, expectedValue1=%d, expectedValue2=%d", |
| __func__, expectedEvent, expectedValue1, expectedValue2); |
| ALOGV("%s:After cond_wait:event=%d, value1=%d, value2=%d", |
| __func__, event, value1, value2); |
| } |
| ALOGV("%s:done:expectedEvent=%d, expectedValue1=%d, expectedValue2=%d", |
| __func__, expectedEvent, expectedValue1, expectedValue2); |
| pthread_mutex_unlock(&lock); |
| } |
| |
| int8_t mm_jpeg_encoder_get_buffer_offset(uint32_t width, uint32_t height, |
| uint32_t* p_y_offset, uint32_t* p_cbcr_offset, uint32_t* p_buf_size, |
| uint8_t *num_planes, uint32_t planes[]) |
| { |
| ALOGV("%s:", __func__); |
| if ((NULL == p_y_offset) || (NULL == p_cbcr_offset)) { |
| return false; |
| } |
| *num_planes = 2; |
| if (hw_encode ) { |
| int cbcr_offset = 0; |
| uint32_t actual_size = width*height; |
| uint32_t padded_size = width * CEILING16(height); |
| *p_y_offset = 0; |
| *p_cbcr_offset = 0; |
| //if(!isZSLMode){ |
| if ((jpegRotation == 90) || (jpegRotation == 180)) { |
| *p_y_offset = padded_size - actual_size; |
| *p_cbcr_offset = ((padded_size - actual_size) >> 1); |
| } |
| *p_buf_size = (padded_size + (padded_size - actual_size)) * 3/2; |
| planes[0] = width * CEILING16(height); |
| planes[1] = width * CEILING16(height)/2; |
| } else { |
| *p_y_offset = 0; |
| *p_cbcr_offset = PAD_TO_WORD(width*height); |
| *p_buf_size = *p_cbcr_offset * 3/2; |
| planes[0] = PAD_TO_WORD(width*CEILING16(height)); |
| planes[1] = PAD_TO_WORD(width*CEILING16(height)/2); |
| } |
| return true; |
| } |
| |
| int8_t omxJpegOpen() |
| { |
| ALOGV("%s", __func__); |
| pthread_mutex_lock(&jpege_mutex); |
| libmmstillomx = dlopen("libmmstillomx.so", RTLD_NOW); |
| if (!libmmstillomx) { |
| ALOGE("%s: dlopen failed", __func__); |
| pthread_mutex_unlock(&jpege_mutex); |
| return false; |
| } |
| *(void **)(&pOMX_GetHandle) = dlsym(libmmstillomx, "OMX_GetHandle"); |
| *(void **)(&pOMX_Init) = dlsym(libmmstillomx, "OMX_Init"); |
| *(void **)(&pOMX_Deinit) = dlsym(libmmstillomx, "OMX_Deinit"); |
| if (!pOMX_GetHandle || !pOMX_Init || !pOMX_Deinit) { |
| ALOGE("%s: dlsym failed", __func__); |
| dlclose(libmmstillomx); |
| pthread_mutex_unlock(&jpege_mutex); |
| return false; |
| } |
| OMX_ERRORTYPE ret = (*pOMX_GetHandle)(&pHandle, "OMX.qcom.image.jpeg.encoder", |
| NULL, &callbacks); |
| pthread_mutex_unlock(&jpege_mutex); |
| return true; |
| } |
| |
| int8_t omxJpegStart(uint8_t hw_encode_enable) |
| { |
| int rc = 0; |
| ALOGV("%s", __func__); |
| pthread_mutex_lock(&jpege_mutex); |
| hw_encode = hw_encode_enable; |
| callbacks.EmptyBufferDone = etbdone; |
| callbacks.FillBufferDone = ftbdone; |
| callbacks.EventHandler = eventHandler; |
| pthread_mutex_init(&lock, NULL); |
| pthread_cond_init(&cond, NULL); |
| rc = (*pOMX_Init)(); |
| pthread_mutex_unlock(&jpege_mutex); |
| return rc; |
| } |
| |
| static omx_jpeg_color_format format_cam2jpeg(cam_format_t fmt) |
| { |
| omx_jpeg_color_format jpeg_fmt = OMX_YCRCBLP_H2V2; |
| switch (fmt) { |
| case CAMERA_YUV_420_NV12: |
| jpeg_fmt = OMX_YCBCRLP_H2V2; |
| break; |
| case CAMERA_YUV_420_NV21: |
| case CAMERA_YUV_420_NV21_ADRENO: |
| jpeg_fmt = OMX_YCRCBLP_H2V2; |
| break; |
| default: |
| ALOGV("Camera format %d not supported", fmt); |
| break; |
| } |
| return jpeg_fmt; |
| } |
| |
| int8_t omxJpegEncodeNext(omx_jpeg_encode_params *encode_params) |
| { |
| ALOGV("%s:E", __func__); |
| pthread_mutex_lock(&jpege_mutex); |
| encoding = 1; |
| int orientation; |
| if(inputPort == NULL || inputPort1 == NULL || outputPort == NULL) { |
| ALOGV("%s:pointer is null: X", __func__); |
| pthread_mutex_unlock(&jpege_mutex); |
| return -1; |
| } |
| inputPort->nPortIndex = INPUT_PORT; |
| outputPort->nPortIndex = OUTPUT_PORT; |
| inputPort1->nPortIndex = INPUT_PORT1; |
| OMX_GetParameter(pHandle, OMX_IndexParamPortDefinition, inputPort); |
| OMX_GetParameter(pHandle, OMX_IndexParamPortDefinition, outputPort); |
| |
| ALOGV("%s:nFrameWidth=%d nFrameHeight=%d nBufferSize=%d w=%d h=%d", |
| __func__, inputPort->format.image.nFrameWidth, |
| inputPort->format.image.nFrameHeight, inputPort->nBufferSize, |
| bufferoffset.width, bufferoffset.height); |
| OMX_GetExtensionIndex(pHandle,"omx.qcom.jpeg.exttype.buffer_offset", |
| &buffer_offset); |
| ALOGV("%s:Buffer w %d h %d yOffset %d cbcrOffset %d totalSize %d\n", |
| __func__, bufferoffset.width, bufferoffset.height, bufferoffset.yOffset, |
| bufferoffset.cbcrOffset,bufferoffset.totalSize); |
| OMX_SetParameter(pHandle, buffer_offset, &bufferoffset); |
| OMX_SetParameter(pHandle, OMX_IndexParamPortDefinition, inputPort1); |
| OMX_GetParameter(pHandle, OMX_IndexParamPortDefinition, inputPort1); |
| ALOGV("%s: thumbnail widht %d height %d", __func__, |
| thumbnail.width, thumbnail.height); |
| |
| userpreferences.color_format = |
| format_cam2jpeg(encode_params->dimension->main_img_format); |
| userpreferences.thumbnail_color_format = |
| format_cam2jpeg(encode_params->dimension->thumb_format); |
| |
| |
| pmem_info.fd = encode_params->snapshot_fd; |
| pmem_info.offset = 0; |
| |
| //Release previously allocated buffers before doing UseBuffer in burst mode |
| OMX_FreeBuffer(pHandle, 2, pInBuffers1); |
| OMX_FreeBuffer(pHandle, 0, pInBuffers); |
| OMX_FreeBuffer(pHandle, 1, pOutBuffers); |
| |
| OMX_UseBuffer(pHandle, &pInBuffers, 0, &pmem_info, inputPort->nBufferSize, |
| (void *) encode_params->snapshot_buf); |
| OMX_GetExtensionIndex(pHandle, "omx.qcom.jpeg.exttype.exif", &exif); |
| /*temporarily set rotation in EXIF data. This is done to avoid |
| image corruption issues in ZSL mode since roation is known |
| before hand. The orientation is set in the exif tag and |
| decoder will decode it will the right orientation. need to add double |
| padding to fix the issue */ |
| if (isZSLMode) { |
| /*Get the orientation tag values depending on rotation*/ |
| switch (jpegRotation) { |
| case 0: |
| orientation = 1; /*Normal*/ |
| break; |
| case 90: |
| orientation = 6; /*Rotated 90 CCW*/ |
| break; |
| case 180: |
| orientation = 3; /*Rotated 180*/ |
| break; |
| case 270: |
| orientation = 8; /*Rotated 90 CW*/ |
| break; |
| default: |
| orientation = 1; |
| break; |
| } |
| tag.tag_id = EXIFTAGID_ORIENTATION; |
| tag.tag_entry.type = EXIFTAGTYPE_ORIENTATION; |
| tag.tag_entry.count = 1; |
| tag.tag_entry.copy = 1; |
| tag.tag_entry.data._short = orientation; |
| ALOGV("%s jpegRotation = %d , orientation value =%d\n", __func__, |
| jpegRotation, orientation); |
| OMX_SetParameter(pHandle, exif, &tag); |
| } |
| |
| /*Set omx parameter for all exif tags*/ |
| int i; |
| for (i = 0; i < encode_params->exif_numEntries; i++) { |
| memcpy(&tag, encode_params->exif_data + i, |
| sizeof(omx_jpeg_exif_info_tag)); |
| OMX_SetParameter(pHandle, exif, &tag); |
| } |
| |
| pmem_info1.fd = encode_params->thumbnail_fd; |
| pmem_info1.offset = 0; |
| |
| ALOGV("%s: input1 buff size %d", __func__, inputPort1->nBufferSize); |
| OMX_UseBuffer(pHandle, &pInBuffers1, 2, &pmem_info1, |
| inputPort1->nBufferSize, (void *) encode_params->thumbnail_buf); |
| OMX_UseBuffer(pHandle, &pOutBuffers, 1, NULL, inputPort->nBufferSize, |
| (void *) out_buffer); |
| OMX_EmptyThisBuffer(pHandle, pInBuffers); |
| OMX_EmptyThisBuffer(pHandle, pInBuffers1); |
| OMX_FillThisBuffer(pHandle, pOutBuffers); |
| pthread_mutex_unlock(&jpege_mutex); |
| ALOGV("%s:X", __func__); |
| return true; |
| } |
| |
| int8_t omxJpegEncode(omx_jpeg_encode_params *encode_params) |
| { |
| int size = 0; |
| uint8_t num_planes; |
| uint32_t planes[10]; |
| int orientation; |
| ALOGV("%s:E", __func__); |
| |
| inputPort = malloc(sizeof(OMX_PARAM_PORTDEFINITIONTYPE)); |
| outputPort = malloc(sizeof(OMX_PARAM_PORTDEFINITIONTYPE)); |
| inputPort1 = malloc(sizeof(OMX_PARAM_PORTDEFINITIONTYPE)); |
| |
| pthread_mutex_lock(&jpege_mutex); |
| encoding = 1; |
| inputPort->nPortIndex = INPUT_PORT; |
| outputPort->nPortIndex = OUTPUT_PORT; |
| inputPort1->nPortIndex = INPUT_PORT1; |
| OMX_GetParameter(pHandle, OMX_IndexParamPortDefinition, inputPort); |
| OMX_GetParameter(pHandle, OMX_IndexParamPortDefinition, outputPort); |
| |
| bufferoffset.width = encode_params->dimension->orig_picture_dx; |
| bufferoffset.height = encode_params->dimension->orig_picture_dy; |
| |
| if (hw_encode) |
| userpreferences.preference = OMX_JPEG_PREF_HW_ACCELERATED_PREFERRED; |
| else |
| userpreferences.preference = OMX_JPEG_PREF_SOFTWARE_ONLY; |
| if (encode_params->a_cbcroffset > 0) { |
| userpreferences.preference = OMX_JPEG_PREF_SOFTWARE_ONLY; |
| hw_encode = 0; |
| } |
| mm_jpeg_encoder_get_buffer_offset(bufferoffset.width, bufferoffset.height, |
| &bufferoffset.yOffset, |
| &bufferoffset.cbcrOffset, |
| &bufferoffset.totalSize, &num_planes, planes); |
| if (encode_params->a_cbcroffset > 0) { |
| bufferoffset.totalSize = encode_params->a_cbcroffset * 1.5; |
| } |
| OMX_GetExtensionIndex(pHandle,"omx.qcom.jpeg.exttype.buffer_offset",&buffer_offset); |
| ALOGV(" Buffer width = %d, Buffer height = %d, yOffset =%d, cbcrOffset =%d, totalSize = %d\n", |
| bufferoffset.width, bufferoffset.height, bufferoffset.yOffset, |
| bufferoffset.cbcrOffset,bufferoffset.totalSize); |
| OMX_SetParameter(pHandle, buffer_offset, &bufferoffset); |
| |
| |
| if (encode_params->a_cbcroffset > 0) { |
| ALOGV("Using acbcroffset\n"); |
| bufferoffset1.cbcrOffset = encode_params->a_cbcroffset; |
| OMX_GetExtensionIndex(pHandle,"omx.qcom.jpeg.exttype.acbcr_offset",&buffer_offset); |
| OMX_SetParameter(pHandle, buffer_offset, &bufferoffset1); |
| } |
| |
| inputPort->format.image.nFrameWidth = encode_params->dimension->orig_picture_dx; |
| inputPort->format.image.nFrameHeight = encode_params->dimension->orig_picture_dy; |
| inputPort->format.image.nStride = encode_params->dimension->orig_picture_dx; |
| inputPort->format.image.nSliceHeight = encode_params->dimension->orig_picture_dy; |
| inputPort->nBufferSize = bufferoffset.totalSize; |
| |
| inputPort1->format.image.nFrameWidth = |
| encode_params->dimension->thumbnail_width; |
| inputPort1->format.image.nFrameHeight = |
| encode_params->dimension->thumbnail_height; |
| inputPort1->format.image.nStride = |
| encode_params->dimension->thumbnail_width; |
| inputPort1->format.image.nSliceHeight = |
| encode_params->dimension->thumbnail_height; |
| |
| OMX_SetParameter(pHandle, OMX_IndexParamPortDefinition, inputPort); |
| OMX_GetParameter(pHandle, OMX_IndexParamPortDefinition, inputPort); |
| size = inputPort->nBufferSize; |
| thumbnail.width = encode_params->dimension->thumbnail_width; |
| thumbnail.height = encode_params->dimension->thumbnail_height; |
| |
| OMX_SetParameter(pHandle, OMX_IndexParamPortDefinition, inputPort1); |
| OMX_GetParameter(pHandle, OMX_IndexParamPortDefinition, inputPort1); |
| ALOGV("%s: thumbnail width %d height %d", __func__, |
| encode_params->dimension->thumbnail_width, |
| encode_params->dimension->thumbnail_height); |
| |
| if(encode_params->a_cbcroffset > 0) |
| inputPort1->nBufferSize = inputPort->nBufferSize; |
| |
| userpreferences.color_format = |
| get_jpeg_format_from_cam_format(encode_params->main_format); |
| userpreferences.thumbnail_color_format = |
| get_jpeg_format_from_cam_format(encode_params->thumbnail_format); |
| |
| |
| |
| |
| ALOGV("%s:Scaling params in1_w %d in1_h %d out1_w %d out1_h %d" |
| "main_img in2_w %d in2_h %d out2_w %d out2_h %d\n", __func__, |
| encode_params->scaling_params->in1_w, |
| encode_params->scaling_params->in1_h, |
| encode_params->scaling_params->out1_w, |
| encode_params->scaling_params->out1_h, |
| encode_params->scaling_params->in2_w, |
| encode_params->scaling_params->in2_h, |
| encode_params->scaling_params->out2_w, |
| encode_params->scaling_params->out2_h); |
| /*Main image scaling*/ |
| ALOGV("%s:%d/n",__func__,__LINE__); |
| |
| |
| if (encode_params->scaling_params->in2_w && |
| encode_params->scaling_params->in2_h) { |
| |
| /* Scaler information for main image */ |
| recttype.nWidth = CEILING2(encode_params->scaling_params->in2_w); |
| recttype.nHeight = CEILING2(encode_params->scaling_params->in2_h); |
| ALOGV("%s:%d/n",__func__,__LINE__); |
| |
| if (encode_params->main_crop_offset) { |
| recttype.nLeft = encode_params->main_crop_offset->x; |
| recttype.nTop = encode_params->main_crop_offset->y; |
| ALOGV("%s:%d/n",__func__,__LINE__); |
| |
| } else { |
| recttype.nLeft = 0; |
| recttype.nTop = 0; |
| ALOGV("%s:%d/n",__func__,__LINE__); |
| |
| } |
| ALOGV("%s:%d/n",__func__,__LINE__); |
| |
| recttype.nPortIndex = 1; |
| OMX_SetConfig(pHandle, OMX_IndexConfigCommonInputCrop, &recttype); |
| ALOGV("%s:%d/n",__func__,__LINE__); |
| |
| if (encode_params->scaling_params->out2_w && |
| encode_params->scaling_params->out2_h) { |
| recttype.nWidth = (encode_params->scaling_params->out2_w); |
| recttype.nHeight = (encode_params->scaling_params->out2_h); |
| ALOGV("%s:%d/n",__func__,__LINE__); |
| |
| |
| recttype.nPortIndex = 1; |
| OMX_SetConfig(pHandle, OMX_IndexConfigCommonOutputCrop, &recttype); |
| ALOGV("%s:%d/n",__func__,__LINE__); |
| |
| } |
| |
| } else { |
| ALOGV("%s: There is no main image scaling information", |
| __func__); |
| } |
| /*case of thumbnail*/ |
| |
| if ((encode_params->scaling_params->in1_w && |
| encode_params->scaling_params->in1_h) || |
| ((encode_params->scaling_params->out1_w != |
| encode_params->dimension->thumbnail_width) && |
| (encode_params->scaling_params->out1_h != |
| encode_params->dimension->thumbnail_height))) { |
| |
| thumbnail.scaling = 0; |
| |
| if ((encode_params->scaling_params->out1_w != |
| encode_params->dimension->thumbnail_width)&& |
| (encode_params->scaling_params->out1_h != |
| encode_params->dimension->thumbnail_height)) { |
| |
| ALOGV("%s:%d/n",__func__,__LINE__); |
| thumbnail.cropWidth = CEILING2(encode_params->dimension->thumbnail_width); |
| thumbnail.cropHeight = CEILING2(encode_params->dimension->thumbnail_height); |
| } |
| if (encode_params->scaling_params->in1_w && |
| encode_params->scaling_params->in1_h) { |
| ALOGV("%s:%d/n",__func__,__LINE__); |
| thumbnail.cropWidth = CEILING2(encode_params->scaling_params->in1_w); |
| thumbnail.cropHeight = CEILING2(encode_params->scaling_params->in1_h); |
| } |
| thumbnail.width = encode_params->scaling_params->out1_w; |
| thumbnail.height = encode_params->scaling_params->out1_h; |
| |
| if (encode_params->thumb_crop_offset) { |
| ALOGV("%s:%d/n",__func__,__LINE__); |
| |
| thumbnail.left = encode_params->thumb_crop_offset->x; |
| thumbnail.top = encode_params->thumb_crop_offset->y; |
| thumbnail.scaling = 1; |
| } else { |
| thumbnail.left = 0; |
| thumbnail.top = 0; |
| } |
| } else { |
| thumbnail.scaling = 0; |
| ALOGV("%s: There is no thumbnail scaling information", |
| __func__); |
| } |
| OMX_GetExtensionIndex(pHandle,"omx.qcom.jpeg.exttype.user_preferences", |
| &user_preferences); |
| ALOGV("%s:User Preferences: color_format %d" |
| "thumbnail_color_format = %d encoder preference =%d\n", __func__, |
| userpreferences.color_format,userpreferences.thumbnail_color_format, |
| userpreferences.preference); |
| OMX_SetParameter(pHandle,user_preferences,&userpreferences); |
| |
| ALOGV("%s Thumbnail present? : %d ", __func__, |
| encode_params->hasThumbnail); |
| if (encode_params->hasThumbnail) { |
| OMX_GetExtensionIndex(pHandle, "omx.qcom.jpeg.exttype.thumbnail", &type); |
| OMX_SetParameter(pHandle, type, &thumbnail); |
| } |
| qFactor.nPortIndex = INPUT_PORT; |
| OMX_GetParameter(pHandle, OMX_IndexParamQFactor, &qFactor); |
| qFactor.nQFactor = jpegMainimageQuality; |
| OMX_SetParameter(pHandle, OMX_IndexParamQFactor, &qFactor); |
| |
| OMX_GetExtensionIndex(pHandle, "omx.qcom.jpeg.exttype.thumbnail_quality", |
| &thumbnailQualityType); |
| |
| ALOGV("%s: thumbnail quality %u %d", |
| __func__, thumbnailQualityType, jpegThumbnailQuality); |
| OMX_GetParameter(pHandle, thumbnailQualityType, &thumbnailQuality); |
| thumbnailQuality.nQFactor = jpegThumbnailQuality; |
| OMX_SetParameter(pHandle, thumbnailQualityType, &thumbnailQuality); |
| rotType.nPortIndex = OUTPUT_PORT; |
| rotType.nRotation = jpegRotation; |
| OMX_SetConfig(pHandle, OMX_IndexConfigCommonRotate, &rotType); |
| ALOGV("Set rotation to %d\n",jpegRotation); |
| OMX_GetExtensionIndex(pHandle, "omx.qcom.jpeg.exttype.exif", &exif); |
| |
| //Set omx parameter for all exif tags |
| int i; |
| for(i=0; i<encode_params->exif_numEntries; i++) { |
| memcpy(&tag, encode_params->exif_data + i, sizeof(omx_jpeg_exif_info_tag)); |
| OMX_SetParameter(pHandle, exif, &tag); |
| } |
| |
| pmem_info.fd = encode_params->snapshot_fd; |
| pmem_info.offset = 0; |
| |
| ALOGV("input buffer size is %d",size); |
| OMX_UseBuffer(pHandle, &pInBuffers, 0, &pmem_info, size, |
| (void *) encode_params->snapshot_buf); |
| |
| pmem_info1.fd = encode_params->thumbnail_fd; |
| pmem_info1.offset = 0; |
| |
| ALOGV("%s: input1 buff size %d", __func__, inputPort1->nBufferSize); |
| OMX_UseBuffer(pHandle, &pInBuffers1, 2, &pmem_info1, |
| inputPort1->nBufferSize, (void *) encode_params->thumbnail_buf); |
| |
| |
| OMX_UseBuffer(pHandle, &pOutBuffers, 1, NULL, size, (void *) out_buffer); |
| |
| waitForEvent(OMX_EventCmdComplete, OMX_CommandStateSet, OMX_StateIdle); |
| ALOGV("%s:State changed to OMX_StateIdle\n", __func__); |
| OMX_SendCommand(pHandle, OMX_CommandStateSet, OMX_StateExecuting, NULL); |
| waitForEvent(OMX_EventCmdComplete, OMX_CommandStateSet, OMX_StateExecuting); |
| |
| OMX_EmptyThisBuffer(pHandle, pInBuffers); |
| OMX_EmptyThisBuffer(pHandle, pInBuffers1); |
| OMX_FillThisBuffer(pHandle, pOutBuffers); |
| pthread_mutex_unlock(&jpege_mutex); |
| ALOGV("%s:X", __func__); |
| return true; |
| } |
| |
| void omxJpegFinish() |
| { |
| pthread_mutex_lock(&jpege_mutex); |
| ALOGV("%s:encoding=%d", __func__, encoding); |
| if (encoding) { |
| encoding = 0; |
| OMX_SendCommand(pHandle, OMX_CommandStateSet, OMX_StateIdle, NULL); |
| OMX_SendCommand(pHandle, OMX_CommandStateSet, OMX_StateLoaded, NULL); |
| OMX_FreeBuffer(pHandle, 0, pInBuffers); |
| OMX_FreeBuffer(pHandle, 2, pInBuffers1); |
| OMX_FreeBuffer(pHandle, 1, pOutBuffers); |
| (*pOMX_Deinit)(); |
| } |
| pthread_mutex_unlock(&jpege_mutex); |
| } |
| |
| void omxJpegClose() |
| { |
| ALOGV("%s:", __func__); |
| dlclose(libmmstillomx); |
| } |
| |
| void omxJpegAbort() |
| { |
| pthread_mutex_lock(&jpegcb_mutex); |
| mmcamera_jpegfragment_callback = NULL; |
| mmcamera_jpeg_callback = NULL; |
| user_data = NULL; |
| pthread_mutex_unlock(&jpegcb_mutex); |
| pthread_mutex_lock(&jpege_mutex); |
| ALOGV("%s: encoding=%d", __func__, encoding); |
| if (encoding) { |
| encoding = 0; |
| OMX_SendCommand(pHandle, OMX_CommandFlush, NULL, NULL); |
| ALOGV("%s:waitForEvent: OMX_CommandFlush", __func__); |
| waitForEvent(OMX_EVENT_JPEG_ABORT, 0, 0); |
| ALOGV("%s:waitForEvent: OMX_CommandFlush: DONE", __func__); |
| OMX_SendCommand(pHandle, OMX_CommandStateSet, OMX_StateIdle, NULL); |
| OMX_SendCommand(pHandle, OMX_CommandStateSet, OMX_StateLoaded, NULL); |
| OMX_FreeBuffer(pHandle, 0, pInBuffers); |
| OMX_FreeBuffer(pHandle, 2, pInBuffers1); |
| OMX_FreeBuffer(pHandle, 1, pOutBuffers); |
| (*pOMX_Deinit)(); |
| } |
| pthread_mutex_unlock(&jpege_mutex); |
| } |
| |
| |
| int8_t mm_jpeg_encoder_setMainImageQuality(uint32_t quality) |
| { |
| pthread_mutex_lock(&jpege_mutex); |
| ALOGV("%s: current main inage quality %d ," \ |
| " new quality : %d\n", __func__, jpegMainimageQuality, quality); |
| if (quality <= 100) |
| jpegMainimageQuality = quality; |
| pthread_mutex_unlock(&jpege_mutex); |
| return true; |
| } |
| |
| int8_t mm_jpeg_encoder_setThumbnailQuality(uint32_t quality) |
| { |
| pthread_mutex_lock(&jpege_mutex); |
| ALOGV("%s: current thumbnail quality %d ," \ |
| " new quality : %d\n", __func__, jpegThumbnailQuality, quality); |
| if (quality <= 100) |
| jpegThumbnailQuality = quality; |
| pthread_mutex_unlock(&jpege_mutex); |
| return true; |
| } |
| |
| int8_t mm_jpeg_encoder_setRotation(int rotation, int isZSL) |
| { |
| pthread_mutex_lock(&jpege_mutex); |
| |
| /*Set ZSL Mode*/ |
| isZSLMode = isZSL; |
| ALOGV("%s: Setting ZSL Mode to %d Rotation = %d\n",__func__,isZSLMode,rotation); |
| /* Set rotation configuration */ |
| switch (rotation) { |
| case 0: |
| case 90: |
| case 180: |
| case 270: |
| jpegRotation = rotation; |
| break; |
| default: |
| /* Invalid rotation mode, set to default */ |
| ALOGV("%s:Setting Default rotation mode", __func__); |
| jpegRotation = 0; |
| break; |
| } |
| pthread_mutex_unlock(&jpege_mutex); |
| return true; |
| } |
| |
| /*=========================================================================== |
| FUNCTION mm_jpege_set_phy_offset |
| |
| DESCRIPTION Set physical offset for the buffer |
| ===========================================================================*/ |
| void mm_jpege_set_phy_offset(uint32_t a_phy_offset) |
| { |
| phy_offset = a_phy_offset; |
| } |
