path: root/camera/QCamera2/stack/mm-jpeg-interface/src/mm_jpeg_exif.c

/* Copyright (c) 2012-2016, 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.
 *
 */

// System dependencies
#include <pthread.h>
#include <string.h>
#include <math.h>

// JPEG dependencies
#include "mm_jpeg_dbg.h"
#include "mm_jpeg.h"


#define LOWER(a)               ((a) & 0xFFFF)
#define UPPER(a)               (((a)>>16) & 0xFFFF)
#define CHANGE_ENDIAN_16(a)  ((0x00FF & ((a)>>8)) | (0xFF00 & ((a)<<8)))
#define ROUND(a) \
        ((a >= 0) ? (uint32_t)(a + 0.5) : (uint32_t)(a - 0.5))


/** addExifEntry:
 *
 *  Arguments:
 *   @exif_info : Exif info struct
 *   @p_session: job session
 *   @tagid   : exif tag ID
 *   @type    : data type
 *   @count   : number of data in uint of its type
 *   @data    : input data ptr
 *
 *  Retrun     : int32_t type of status
 *               0  -- success
 *              none-zero failure code
 *
 *  Description:
 *       Function to add an entry to exif data
 *
 **/
int32_t addExifEntry(QOMX_EXIF_INFO *p_exif_info, exif_tag_id_t tagid,
  exif_tag_type_t type, uint32_t count, void *data)
{
    int32_t rc = 0;
    uint32_t numOfEntries = (uint32_t)p_exif_info->numOfEntries;
    QEXIF_INFO_DATA *p_info_data = p_exif_info->exif_data;
    if(numOfEntries >= MAX_EXIF_TABLE_ENTRIES) {
        LOGE("Number of entries exceeded limit");
        return -1;
    }

    p_info_data[numOfEntries].tag_id = tagid;
    p_info_data[numOfEntries].tag_entry.type = type;
    p_info_data[numOfEntries].tag_entry.count = count;
    p_info_data[numOfEntries].tag_entry.copy = 1;
    switch (type) {
    case EXIF_BYTE: {
      if (count > 1) {
        uint8_t *values = (uint8_t *)malloc(count);
        if (values == NULL) {
          LOGE("No memory for byte array");
          rc = -1;
        } else {
          memcpy(values, data, count);
          p_info_data[numOfEntries].tag_entry.data._bytes = values;
        }
      } else {
        p_info_data[numOfEntries].tag_entry.data._byte = *(uint8_t *)data;
      }
    }
    break;
    case EXIF_ASCII: {
      char *str = NULL;
      str = (char *)malloc(count + 1);
      if (str == NULL) {
        LOGE("No memory for ascii string");
        rc = -1;
      } else {
        memset(str, 0, count + 1);
        memcpy(str, data, count);
        p_info_data[numOfEntries].tag_entry.data._ascii = str;
      }
    }
    break;
    case EXIF_SHORT: {
      if (count > 1) {
        uint16_t *values = (uint16_t *)malloc(count * sizeof(uint16_t));
        if (values == NULL) {
          LOGE("No memory for short array");
          rc = -1;
        } else {
          memcpy(values, data, count * sizeof(uint16_t));
          p_info_data[numOfEntries].tag_entry.data._shorts = values;
        }
      } else {
        p_info_data[numOfEntries].tag_entry.data._short = *(uint16_t *)data;
      }
    }
    break;
    case EXIF_LONG: {
      if (count > 1) {
        uint32_t *values = (uint32_t *)malloc(count * sizeof(uint32_t));
        if (values == NULL) {
          LOGE("No memory for long array");
          rc = -1;
        } else {
          memcpy(values, data, count * sizeof(uint32_t));
          p_info_data[numOfEntries].tag_entry.data._longs = values;
        }
      } else {
        p_info_data[numOfEntries].tag_entry.data._long = *(uint32_t *)data;
      }
    }
    break;
    case EXIF_RATIONAL: {
      if (count > 1) {
        rat_t *values = (rat_t *)malloc(count * sizeof(rat_t));
        if (values == NULL) {
          LOGE("No memory for rational array");
          rc = -1;
        } else {
          memcpy(values, data, count * sizeof(rat_t));
          p_info_data[numOfEntries].tag_entry.data._rats = values;
        }
      } else {
        p_info_data[numOfEntries].tag_entry.data._rat = *(rat_t *)data;
      }
    }
    break;
    case EXIF_UNDEFINED: {
      uint8_t *values = (uint8_t *)malloc(count);
      if (values == NULL) {
        LOGE("No memory for undefined array");
        rc = -1;
      } else {
        memcpy(values, data, count);
        p_info_data[numOfEntries].tag_entry.data._undefined = values;
      }
    }
    break;
    case EXIF_SLONG: {
      if (count > 1) {
        int32_t *values = (int32_t *)malloc(count * sizeof(int32_t));
        if (values == NULL) {
          LOGE("No memory for signed long array");
          rc = -1;
        } else {
          memcpy(values, data, count * sizeof(int32_t));
          p_info_data[numOfEntries].tag_entry.data._slongs = values;
        }
      } else {
        p_info_data[numOfEntries].tag_entry.data._slong = *(int32_t *)data;
      }
    }
    break;
    case EXIF_SRATIONAL: {
      if (count > 1) {
        srat_t *values = (srat_t *)malloc(count * sizeof(srat_t));
        if (values == NULL) {
          LOGE("No memory for signed rational array");
          rc = -1;
        } else {
          memcpy(values, data, count * sizeof(srat_t));
          p_info_data[numOfEntries].tag_entry.data._srats = values;
        }
      } else {
        p_info_data[numOfEntries].tag_entry.data._srat = *(srat_t *)data;
      }
    }
    break;
    }

    // Increase number of entries
    p_exif_info->numOfEntries++;
    return rc;
}

/** releaseExifEntry
 *
 *  Arguments:
 *   @p_exif_data : Exif info struct
 *
 *  Retrun     : int32_t type of status
 *               0  -- success
 *              none-zero failure code
 *
 *  Description:
 *       Function to release an entry from exif data
 *
 **/
int32_t releaseExifEntry(QEXIF_INFO_DATA *p_exif_data)
{
 switch (p_exif_data->tag_entry.type) {
  case EXIF_BYTE: {
    if (p_exif_data->tag_entry.count > 1 &&
      p_exif_data->tag_entry.data._bytes != NULL) {
      free(p_exif_data->tag_entry.data._bytes);
      p_exif_data->tag_entry.data._bytes = NULL;
    }
  }
  break;
  case EXIF_ASCII: {
    if (p_exif_data->tag_entry.data._ascii != NULL) {
      free(p_exif_data->tag_entry.data._ascii);
      p_exif_data->tag_entry.data._ascii = NULL;
    }
  }
  break;
  case EXIF_SHORT: {
    if (p_exif_data->tag_entry.count > 1 &&
      p_exif_data->tag_entry.data._shorts != NULL) {
      free(p_exif_data->tag_entry.data._shorts);
      p_exif_data->tag_entry.data._shorts = NULL;
    }
  }
  break;
  case EXIF_LONG: {
    if (p_exif_data->tag_entry.count > 1 &&
      p_exif_data->tag_entry.data._longs != NULL) {
      free(p_exif_data->tag_entry.data._longs);
      p_exif_data->tag_entry.data._longs = NULL;
    }
  }
  break;
  case EXIF_RATIONAL: {
    if (p_exif_data->tag_entry.count > 1 &&
      p_exif_data->tag_entry.data._rats != NULL) {
      free(p_exif_data->tag_entry.data._rats);
      p_exif_data->tag_entry.data._rats = NULL;
    }
  }
  break;
  case EXIF_UNDEFINED: {
    if (p_exif_data->tag_entry.data._undefined != NULL) {
      free(p_exif_data->tag_entry.data._undefined);
      p_exif_data->tag_entry.data._undefined = NULL;
    }
  }
  break;
  case EXIF_SLONG: {
    if (p_exif_data->tag_entry.count > 1 &&
      p_exif_data->tag_entry.data._slongs != NULL) {
      free(p_exif_data->tag_entry.data._slongs);
      p_exif_data->tag_entry.data._slongs = NULL;
    }
  }
  break;
  case EXIF_SRATIONAL: {
    if (p_exif_data->tag_entry.count > 1 &&
      p_exif_data->tag_entry.data._srats != NULL) {
      free(p_exif_data->tag_entry.data._srats);
      p_exif_data->tag_entry.data._srats = NULL;
    }
  }
  break;
  } /*end of switch*/

  return 0;
}

/** process_sensor_data:
 *
 *  Arguments:
 *   @p_sensor_params : ptr to sensor data
 *
 *  Return     : int32_t type of status
 *               NO_ERROR  -- success
 *              none-zero failure code
 *
 *  Description:
 *       process sensor data
 *
 *  Notes: this needs to be filled for the metadata
 **/
int process_sensor_data(cam_sensor_params_t *p_sensor_params,
  QOMX_EXIF_INFO *exif_info)
{
  int rc = 0;
  rat_t val_rat;

  if (NULL == p_sensor_params) {
    LOGE("Sensor params are null");
    return 0;
  }

  LOGD("From metadata aperture = %f ",
    p_sensor_params->aperture_value );

  if (p_sensor_params->aperture_value >= 1.0) {
    double apex_value;
    apex_value = (double)2.0 * log(p_sensor_params->aperture_value) / log(2.0);
    val_rat.num = (uint32_t)(apex_value * 100);
    val_rat.denom = 100;
    rc = addExifEntry(exif_info, EXIFTAGID_APERTURE, EXIF_RATIONAL, 1, &val_rat);
    if (rc) {
      LOGE(": Error adding Exif Entry");
    }

    val_rat.num = (uint32_t)(p_sensor_params->aperture_value * 100);
    val_rat.denom = 100;
    rc = addExifEntry(exif_info, EXIFTAGID_F_NUMBER, EXIF_RATIONAL, 1, &val_rat);
    if (rc) {
      LOGE(": Error adding Exif Entry");
    }
  }

  /*Flash*/
  short val_short = 0;
  int flash_mode_exif, flash_fired;
  if (p_sensor_params->flash_state == CAM_FLASH_STATE_FIRED) {
    flash_fired = 1;
  } else {
    flash_fired = 0;
  }
  LOGD("Flash mode %d flash state %d",
    p_sensor_params->flash_mode, p_sensor_params->flash_state);

  switch(p_sensor_params->flash_mode) {
  case  CAM_FLASH_MODE_OFF:
    flash_mode_exif = MM_JPEG_EXIF_FLASH_MODE_OFF;
    break;
  case CAM_FLASH_MODE_ON:
    flash_mode_exif = MM_JPEG_EXIF_FLASH_MODE_ON;
    break;
  case CAM_FLASH_MODE_AUTO:
    flash_mode_exif = MM_JPEG_EXIF_FLASH_MODE_AUTO;
    break;
  default:
    flash_mode_exif = MM_JPEG_EXIF_FLASH_MODE_AUTO;
    LOGE(": Unsupported flash mode");
  }
  val_short = (short)(flash_fired | (flash_mode_exif << 3));

  rc = addExifEntry(exif_info, EXIFTAGID_FLASH, EXIF_SHORT, 1, &val_short);
  if (rc) {
    LOGE(": Error adding flash exif entry");
  }
  /* Sensing Method */
  val_short = (short) p_sensor_params->sensing_method;
  rc = addExifEntry(exif_info, EXIFTAGID_SENSING_METHOD, EXIF_SHORT,
    sizeof(val_short)/2, &val_short);
  if (rc) {
    LOGE(": Error adding flash Exif Entry");
  }

  /* Focal Length in 35 MM Film */
  val_short = (short)
    ((p_sensor_params->focal_length * p_sensor_params->crop_factor) + 0.5f);
  rc = addExifEntry(exif_info, EXIFTAGID_FOCAL_LENGTH_35MM, EXIF_SHORT,
    1, &val_short);
  if (rc) {
    LOGE(": Error adding Exif Entry");
  }

  /* F Number */
  val_rat.num = (uint32_t)(p_sensor_params->f_number * 100);
  val_rat.denom = 100;
  rc = addExifEntry(exif_info, EXIFTAGTYPE_F_NUMBER, EXIF_RATIONAL, 1, &val_rat);
  if (rc) {
    LOGE(": Error adding Exif Entry");
  }
  return rc;
}


/** process_3a_data:
 *
 *  Arguments:
 *   @p_3a_params : ptr to 3a data
 *   @exif_info : Exif info struct
 *
 *  Return     : int32_t type of status
 *               NO_ERROR  -- success
 *               none-zero failure code
 *
 *  Description:
 *       process 3a data
 *
 *  Notes: this needs to be filled for the metadata
 **/
int process_3a_data(cam_3a_params_t *p_3a_params, QOMX_EXIF_INFO *exif_info)
{
  int rc = 0;
  srat_t val_srat;
  rat_t val_rat;
  double shutter_speed_value;

  if (NULL == p_3a_params) {
    LOGE("3A params are null");
    return 0;
  }

  LOGD("exp_time %f, iso_value %d, wb_mode %d",
    p_3a_params->exp_time, p_3a_params->iso_value, p_3a_params->wb_mode);

  /* Exposure time */
  if (p_3a_params->exp_time <= 0.0f) {
    val_rat.num = 0;
    val_rat.denom = 0;
  } else if (p_3a_params->exp_time < 1.0f) {
    val_rat.num = 1;
    val_rat.denom = ROUND(1.0/p_3a_params->exp_time);
  } else {
    val_rat.num = ROUND(p_3a_params->exp_time);
    val_rat.denom = 1;
  }
  LOGD("numer %d denom %d %zd", val_rat.num, val_rat.denom,
    sizeof(val_rat) / (8));

  rc = addExifEntry(exif_info, EXIFTAGID_EXPOSURE_TIME, EXIF_RATIONAL,
    (sizeof(val_rat)/(8)), &val_rat);
  if (rc) {
    LOGE(": Error adding Exif Entry Exposure time");
  }

  /* Shutter Speed*/
  if (p_3a_params->exp_time > 0) {
    shutter_speed_value = log10(1/p_3a_params->exp_time)/log10(2);
    val_srat.num = (int32_t)(shutter_speed_value * 1000);
    val_srat.denom = 1000;
  } else {
    val_srat.num = 0;
    val_srat.denom = 0;
  }
  rc = addExifEntry(exif_info, EXIFTAGID_SHUTTER_SPEED, EXIF_SRATIONAL,
    (sizeof(val_srat)/(8)), &val_srat);
  if (rc) {
    LOGE(": Error adding Exif Entry");
  }

  /*ISO*/
  short val_short;
  val_short = (short)p_3a_params->iso_value;
  rc = addExifEntry(exif_info, EXIFTAGID_ISO_SPEED_RATING, EXIF_SHORT,
    sizeof(val_short)/2, &val_short);
  if (rc) {
     LOGE(": Error adding Exif Entry");
  }

  /*WB mode*/
  if (p_3a_params->wb_mode == CAM_WB_MODE_AUTO)
    val_short = 0;
  else
    val_short = 1;
  rc = addExifEntry(exif_info, EXIFTAGID_WHITE_BALANCE, EXIF_SHORT,
    sizeof(val_short)/2, &val_short);
  if (rc) {
    LOGE(": Error adding Exif Entry");
  }

  /* Metering Mode   */
  val_short = (short) p_3a_params->metering_mode;
  rc = addExifEntry(exif_info,EXIFTAGID_METERING_MODE, EXIF_SHORT,
     sizeof(val_short)/2, &val_short);
  if (rc) {
     LOGE(": Error adding Exif Entry");
   }

  /*Exposure Program*/
   val_short = (short) p_3a_params->exposure_program;
   rc = addExifEntry(exif_info,EXIFTAGID_EXPOSURE_PROGRAM, EXIF_SHORT,
      sizeof(val_short)/2, &val_short);
   if (rc) {
      LOGE(": Error adding Exif Entry");
    }

   /*Exposure Mode */
    val_short = (short) p_3a_params->exposure_mode;
    rc = addExifEntry(exif_info,EXIFTAGID_EXPOSURE_MODE, EXIF_SHORT,
       sizeof(val_short)/2, &val_short);
    if (rc) {
       LOGE(": Error adding Exif Entry");
     }

    /*Scenetype*/
     uint8_t val_undef;
     val_undef = (uint8_t) p_3a_params->scenetype;
     rc = addExifEntry(exif_info,EXIFTAGID_SCENE_TYPE, EXIF_UNDEFINED,
        sizeof(val_undef), &val_undef);
     if (rc) {
        LOGE(": Error adding Exif Entry");
      }

     LOGD("brightness %f",
       p_3a_params->brightness);

    /* Brightness Value*/
     val_srat.num = (int32_t) (p_3a_params->brightness * 100.0f);
     val_srat.denom = 100;
     rc = addExifEntry(exif_info,EXIFTAGID_BRIGHTNESS, EXIF_SRATIONAL,
                 (sizeof(val_srat)/(8)), &val_srat);
     if (rc) {
        LOGE(": Error adding Exif Entry");
     }

  return rc;
}

/** process_meta_data
 *
 *  Arguments:
 *   @p_meta : ptr to metadata
 *   @exif_info: Exif info struct
 *   @mm_jpeg_exif_params: exif params
 *
 *  Return     : int32_t type of status
 *               NO_ERROR  -- success
 *              none-zero failure code
 *
 *  Description:
 *       Extract exif data from the metadata
 **/
int process_meta_data(metadata_buffer_t *p_meta, QOMX_EXIF_INFO *exif_info,
  mm_jpeg_exif_params_t *p_cam_exif_params, cam_hal_version_t hal_version)
{
  int rc = 0;
  cam_sensor_params_t p_sensor_params;
  cam_3a_params_t p_3a_params;
  bool is_3a_meta_valid = false, is_sensor_meta_valid = false;

  memset(&p_3a_params,  0,  sizeof(cam_3a_params_t));
  memset(&p_sensor_params, 0, sizeof(cam_sensor_params_t));

  if (p_meta) {
    /* for HAL V1*/
    if (hal_version == CAM_HAL_V1) {

      IF_META_AVAILABLE(cam_3a_params_t, l_3a_params, CAM_INTF_META_AEC_INFO,
          p_meta) {
        p_3a_params = *l_3a_params;
        is_3a_meta_valid = true;
      }

      IF_META_AVAILABLE(int32_t, wb_mode, CAM_INTF_PARM_WHITE_BALANCE, p_meta) {
        p_3a_params.wb_mode = *wb_mode;
      }

      IF_META_AVAILABLE(cam_sensor_params_t, l_sensor_params,
          CAM_INTF_META_SENSOR_INFO, p_meta) {
        p_sensor_params = *l_sensor_params;
        is_sensor_meta_valid = true;
      }
    } else {
      /* HAL V3 */
      IF_META_AVAILABLE(int32_t, iso, CAM_INTF_META_SENSOR_SENSITIVITY, p_meta) {
        p_3a_params.iso_value= *iso;
      } else {
        LOGE("Cannot extract Iso value");
      }

      IF_META_AVAILABLE(int64_t, sensor_exposure_time,
          CAM_INTF_META_SENSOR_EXPOSURE_TIME, p_meta) {
        p_3a_params.exp_time =
          (float)((double)(*sensor_exposure_time) / 1000000000.0);
      } else {
        LOGE("Cannot extract Exp time value");
      }

      IF_META_AVAILABLE(int32_t, wb_mode, CAM_INTF_PARM_WHITE_BALANCE, p_meta) {
        p_3a_params.wb_mode = *wb_mode;
      } else {
        LOGE("Cannot extract white balance mode");
      }

      /* Process sensor data */
      IF_META_AVAILABLE(float, aperture, CAM_INTF_META_LENS_APERTURE, p_meta) {
        p_sensor_params.aperture_value = *aperture;
      } else {
        LOGE("Cannot extract Aperture value");
      }

      IF_META_AVAILABLE(uint32_t, flash_mode, CAM_INTF_META_FLASH_MODE, p_meta) {
        p_sensor_params.flash_mode = *flash_mode;
      } else {
        LOGE("Cannot extract flash mode value");
      }

      IF_META_AVAILABLE(int32_t, flash_state, CAM_INTF_META_FLASH_STATE, p_meta) {
        p_sensor_params.flash_state = (cam_flash_state_t) *flash_state;
      } else {
        LOGE("Cannot extract flash state value");
      }
    }
  }

  /* take the cached values if meta is invalid */
  if ((!is_3a_meta_valid) && (hal_version == CAM_HAL_V1)) {
    p_3a_params = p_cam_exif_params->cam_3a_params;
    LOGW("Warning using cached values for 3a");
  }

  if ((!is_sensor_meta_valid) && (hal_version == CAM_HAL_V1)) {
    p_sensor_params = p_cam_exif_params->sensor_params;
    LOGW("Warning using cached values for sensor");
  }

  if ((hal_version != CAM_HAL_V1) || (p_sensor_params.sens_type != CAM_SENSOR_YUV)) {
    rc = process_3a_data(&p_3a_params, exif_info);
    if (rc) {
      LOGE("Failed to add 3a exif params");
    }
  }

  rc = process_sensor_data(&p_sensor_params, exif_info);
  if (rc) {
    LOGE("Failed to extract sensor params");
  }

  if (p_meta) {
    short val_short = 0;
    cam_asd_decision_t *scene_info = NULL;

    IF_META_AVAILABLE(cam_asd_decision_t, scene_cap_type,
        CAM_INTF_META_ASD_SCENE_INFO, p_meta) {
      scene_info = (cam_asd_decision_t*)scene_cap_type;
      val_short = (short) scene_info->detected_scene;
    }

    rc = addExifEntry(exif_info, EXIFTAGID_SCENE_CAPTURE_TYPE, EXIF_SHORT,
      sizeof(val_short)/2, &val_short);
    if (rc) {
      LOGE(": Error adding ASD Exif Entry");
    }
  } else {
    LOGE(": Error adding ASD Exif Entry, no meta");
  }
  return rc;
}