GST_MAJORMINOR=0.10
GST_REQUIRED=0.10.0
GSTPB_REQUIRED=0.10.0
-#LIBMFLD_REQUIRED=0.10.0
+LIBMFLD_REQUIRED=0.10.0
dnl fill in your package name and version here
dnl the fourth (nano) number should be 0 for a release, 1 for CVS,
AC_SUBST(plugindir)
dnl set proper LDFLAGS for plugins
-GST_PLUGIN_LDFLAGS='-module -avoid-version -Bstatic -lmfldadvci -export-symbols-regex [_]*\(gst_\|Gst\|GST_\).*'
+GST_PLUGIN_LDFLAGS='-module -avoid-version -export-symbols-regex [_]*\(gst_\|Gst\|GST_\).*'
AC_SUBST(GST_PLUGIN_LDFLAGS)
dnl LDFLAGS really should only contain flags, not libs - they get added before
AC_SUBST(GST_CHECK_CFLAGS)
AC_SUBST(GST_CHECK_LIBS)
-
+dnl check gst check 3a support
+dnl LIBMFLDADVCI_CFLAGS
+dnl LIBMFLDADVCI_LIBS
HAVE_LIBMFLDADVCI=yes
-PKG_CHECK_MODULES(LIBMFLDADVCI, libmfdldadvci >= $LIBMFLD_REQUIRED, HAVE_LIBMFLDADVCI=yes, HAVE_LIBMFLDADVCI=no)
-AM_CONDITIONAL(HAVE_LIBMFLDADVCI, test ! "x$LIBMFLDADVCI" = "xno")
+PKG_CHECK_MODULES(LIBMFLDADVCI, libmfldadvci >= $LIBMFLD_REQUIRED, HAVE_LIBMFLDADVCI=yes, HAVE_LIBMFLDADVCI=no)
+AM_CONDITIONAL(HAVE_LIBMFLDADVCI, test ! "x$LIBMFLDADVCI" = "xyes")
+if test "x$HAVE_LIBMFLDADVCI" = "xyes"; then
+LIBMFLDADVCI_CFLAGS="-DUSE_STATIC_3A -I/usr/include/libmfldadvci/"
+LIBMFLDADVCI_LIBS="-Bstatic -lmfldadvci"
AC_SUBST(LIBMFLDADVCI_CFLAGS)
AC_SUBST(LIBMFLDADVCI_LIBS)
-
+fi
AC_PATH_PROG(VALGRIND_PATH, valgrind, no)
AM_CONDITIONAL(HAVE_VALGRIND, test ! "x$VALGRIND_PATH" = "xno")
sh_css_types.h
libgstatomisphal_@GST_MAJORMINOR@_la_CFLAGS = $(GST_CFLAGS)\
- -DSTDC99 -D__user=
+ -DSTDC99 -D__user= \
+ $(LIBMFLDADVCI_CFLAGS)
libgstatomisphal_@GST_MAJORMINOR@_la_LIBADD = $(GST_LIBS)
-libgstatomisphal_@GST_MAJORMINOR@_la_LDFLAGS = $(GST_LDFLAGS)
+libgstatomisphal_@GST_MAJORMINOR@_la_LDFLAGS = $(GST_LDFLAGS)\
+ $(LIBMFLDADVCI_LIBS)
noinst_HEADERS = mfld_driver.h
#include <math.h>
#include <sys/ioctl.h>
#include <gst/gst.h>
-#include "ci_adv_pub.h"
+
void cam_lib_3a_dbg(const char *format, ...);
/* for debug message and error message output
*
*/
-static bool use_3A_debug = FALSE;
+static gboolean use_3A_debug = FALSE;
void
cam_lib_3a_dbg (const char *format, ...)
}
static void
-wrapper_default_do_redeye_removal (ia_frame *ia_frame)
+wrapper_default_do_redeye_removal (advci_frame_t *frame)
{
}
static void
-wrapper_default_still_compose (ia_frame *com_buf,
- ia_frame bufs[],
+wrapper_default_still_compose (advci_frame_t *com_buf,
+ advci_frame_t bufs[],
int frame_dis,
struct atomisp_dis_vector vectors[])
{
}
static void
-wrapper_default_AeSetFlickerMode(ia_3a_ae_flicker_mode mode)
+wrapper_default_AeSetFlickerMode(advci_ae_flicker_mode mode)
{
}
static void
-wrapper_default_AeGetFlickerMode(ia_3a_ae_flicker_mode *mode)
+wrapper_default_AeGetFlickerMode(advci_ae_flicker_mode *mode)
{
}
static void
-wrapper_default_AeSetExposureProgram(ia_3a_ae_exposure_program program)
+wrapper_default_AeSetExposureProgram(advci_ae_exposure_program program)
{
}
static void
-wrapper_default_AeGetExposureProgram(ia_3a_ae_exposure_program *program)
+wrapper_default_AeGetExposureProgram(advci_ae_exposure_program *program)
{
}
-static void wrapper_default_AfSetMode(ia_3a_af_mode mode)
+static void wrapper_default_AfSetMode(advci_af_mode mode)
{
}
-static void wrapper_default_AfGetMode(ia_3a_af_mode *mode)
+static void wrapper_default_AfGetMode(advci_af_mode *mode)
{
}
-static void wrapper_default_AfSetRange(ia_3a_af_range range)
+static void wrapper_default_AfSetRange(advci_af_range range)
{
}
-static void wrapper_default_AfGetRange(ia_3a_af_range *range)
+static void wrapper_default_AfGetRange(advci_af_range *range)
{
}
-static void wrapper_default_AwbSetMode(ia_3a_awb_mode mode)
+static void wrapper_default_AwbSetMode(advci_awb_mode mode)
{
}
-static void wrapper_default_AwbGetMode(ia_3a_awb_mode *mode)
+static void wrapper_default_AwbGetMode(advci_awb_mode *mode)
{
}
-static void wrapper_default_AwbSetLightSource(ia_3a_awb_light_source ls)
+static void wrapper_default_AwbSetLightSource(advci_awb_light_source ls)
{
}
static void
-wrapper_default_AwbGetLightSource(ia_3a_awb_light_source *ls)
+wrapper_default_AwbGetLightSource(advci_awb_light_source *ls)
{
}
}
static void
-wrapper_default_switch_mode (ia_3a_isp_mode mode, float frame_rate)
+wrapper_default_switch_mode (advci_isp_mode mode, float frame_rate)
{
}
{
}
-static void wrapper_default_AfGetStillAfStatus(ia_3a_af_status *status)
+static void wrapper_default_AfGetStillAfStatus(advci_af_status *status)
{
}
-static bool wrapper_default_af_is_complete(void)
+static gboolean wrapper_default_af_is_complete(void)
{
return TRUE;
}
{
}
-static void wrapper_default_AeGetFlashMode(ia_3a_ae_flash_mode *mode)
+static void wrapper_default_AeGetFlashMode(advci_ae_flash_mode *mode)
{
}
-static void wrapper_default_AeSetFlashMode(ia_3a_ae_flash_mode mode)
+static void wrapper_default_AeSetFlashMode(advci_ae_flash_mode mode)
{
}
}
static void
-wrapper_default_AeSetMeteringMode(ia_3a_ae_metering_mode mode)
+wrapper_default_AeSetMeteringMode(advci_ae_metering_mode mode)
{
}
static void
-wrapper_default_AeGetMeteringMode(ia_3a_ae_metering_mode *mode)
+wrapper_default_AeGetMeteringMode(advci_ae_metering_mode *mode)
{
}
static void
-wrapper_default_AfSetMeteringMode(ia_3a_af_metering_mode mode)
+wrapper_default_AfSetMeteringMode(advci_af_metering_mode mode)
{
}
static void
-wrapper_default_AfGetMeteringMode(ia_3a_af_metering_mode *mode)
+wrapper_default_AfGetMeteringMode(advci_af_metering_mode *mode)
{
}
static void
-wrapper_default_Ae_Af_GetWindow(ia_3a_window *window)
+wrapper_default_Ae_Af_GetWindow(advci_window *window)
{
}
static void
-wrapper_default_Ae_Af_SetWindow( ia_3a_window *window)
+wrapper_default_Ae_Af_SetWindow( advci_window *window)
{
}
static void wrapper_default_af_start( )
static void wrapper_default_awb_apply_results( )
{
}
-static void wrapper_default_AwbSetImageEffect(ia_3a_image_effect effect)
+static void wrapper_default_AwbSetImageEffect(advci_image_effect effect)
{
}
static void
-wrapper_default_AwbGetImageEffect(ia_3a_image_effect *effect)
+wrapper_default_AwbGetImageEffect(advci_image_effect *effect)
{
}
static void
-wrapper_default_is_flash_needed(bool *useflash)
+wrapper_default_is_flash_needed(gboolean *useflash)
{
}
static ci_adv_Err wrapper_default_AeSetManualIso(int sensitivity)
{
- return ci_adv_success;
+ return 0;
}
static ci_adv_Err wrapper_default_AeGetManualIso(int *sensitivity)
{
- return ci_adv_success;
-}
-
-static void
-wrapper_default_GetMakerNote(ia_3a_mknote_mode mknMode, ia_3a_mknote *note)
-{
+ return 0;
}
static void
-wrapper_default_AddMakerNoteRecord(ia_3a_mknote_field_type mkn_format_id,
- ia_3a_mknote_field_name mkn_name_id,
- const void *record,
- unsigned short record_size)
+wrapper_default_GetMakerNote(advci_mknote_mode mknMode, advci_mknote *note)
{
-
}
static void
-wrapper_default_PutMakerNote(ia_3a_mknote *mknData)
+wrapper_default_PutMakerNote(advci_mknote *mknData)
{
}
}
static void
-lib_3a_do_redeye_removal (ia_frame *ia_frame)
+lib_3a_do_redeye_removal (advci_frame_t *frame)
{
cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
}
static void
-lib_3a_still_compose (ia_frame *com_buf,
- ia_frame bufs[],
+lib_3a_still_compose (advci_frame_t *com_buf,
+ advci_frame_t bufs[],
int frame_dis,
struct atomisp_dis_vector vectors[])
{
}
static void
-lib_3a_AeSetFlickerMode(ia_3a_ae_flicker_mode mode)
+lib_3a_AeSetFlickerMode(advci_ae_flicker_mode mode)
{
cam_lib_3a_dbg("%s:%d mode:%d\n", __func__, __LINE__,mode);
- ci_adv_ae_set_flicker_mode(mode);
+ ci_adv_ae_set_flicker_mode((advci_ae_flicker_mode)mode);
}
static void
-lib_3a_AeGetFlickerMode(ia_3a_ae_flicker_mode *mode)
+lib_3a_AeGetFlickerMode(advci_ae_flicker_mode *mode)
{
cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
*mode= ia_3a_ae_get_flicker_mode();
}
static void
-lib_3a_AeSetExposureProgram(ia_3a_ae_exposure_program program)
+lib_3a_AeSetExposureProgram(advci_ae_exposure_program program)
{
cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
ci_adv_ae_set_exposure_program(program);
}
static void
-lib_3a_AeGetExposureProgram(ia_3a_ae_exposure_program *program)
+lib_3a_AeGetExposureProgram(advci_ae_exposure_program *program)
{
cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
ci_adv_ae_get_exposure_program(program);
}
static void
-lib_3a_AfSetMode(ia_3a_af_mode mode)
+lib_3a_AfSetMode(advci_af_mode mode)
{
cam_lib_3a_dbg("%s:%d mode:%d\n", __func__, __LINE__,mode);
ci_adv_af_set_mode(mode);
}
static void
-lib_3a_AfGetMode(ia_3a_af_mode *mode)
+lib_3a_AfGetMode(advci_af_mode *mode)
{
cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
*mode = ia_3a_af_get_focus_mode();
}
static void
-lib_3a_AfSetRange(ia_3a_af_range range)
+lib_3a_AfSetRange(advci_af_range range)
{
cam_lib_3a_dbg ("%s:%d\n", __func__, __LINE__);
ci_adv_af_set_range(range);
}
static void
-lib_3a_AfGetRange(ia_3a_af_range *range)
+lib_3a_AfGetRange(advci_af_range *range)
{
cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
*range = ia_3a_af_get_focus_range();
}
static void
-lib_3a_AwbSetMode(ia_3a_awb_mode mode)
+lib_3a_AwbSetMode(advci_awb_mode mode)
{
cam_lib_3a_dbg("%s:%d mode:%d\n" , __func__, __LINE__,mode);
ci_adv_awb_set_mode(mode);
}
static void
-lib_3a_AwbGetMode(ia_3a_awb_mode *mode)
+lib_3a_AwbGetMode(advci_awb_mode *mode)
{
*mode = ia_3a_awb_get_mode();
}
static void
-lib_3a_AwbSetLightSource(ia_3a_awb_light_source ls)
+lib_3a_AwbSetLightSource(advci_awb_light_source ls)
{
cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
ci_adv_awb_set_light_source(ls);
}
static void
-lib_3a_AwbGetLightSource(ia_3a_awb_light_source *ls)
+lib_3a_AwbGetLightSource(advci_awb_light_source *ls)
{
cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
*ls = ia_3a_awb_get_light_source();
lib_3a_isp_set_fd (int fd, const char *sensor_id)
{
int sensor_type;
- ia_3a_window window;
+ advci_window window;
cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
if (ci_adv_init(sensor_id, fd, NULL) == 0) {
ci_adv_ae_set_window(&window);
- ci_adv_ae_set_exposure_program(ia_3a_ae_exposure_program_auto);
+ ci_adv_ae_set_exposure_program(advci_ae_exposure_program_auto);
ci_adv_ae_set_mode(ia_3a_ae_mode_auto);
- ci_adv_ae_set_metering_mode(ia_3a_ae_metering_mode_center);
- ci_adv_af_set_range (ia_3a_af_range_full);
- ci_adv_awb_set_mode(ia_3a_awb_mode_auto);
- ci_adv_af_set_mode(ia_3a_af_mode_auto);
- ci_adv_af_set_metering_mode (ia_3a_af_metering_mode_auto);
+ ci_adv_ae_set_metering_mode(advci_ae_metering_mode_center);
+ ci_adv_af_set_range (advci_af_range_full);
+ ci_adv_awb_set_mode(advci_awb_mode_auto);
+ ci_adv_af_set_mode(advci_af_mode_auto);
+ ci_adv_af_set_metering_mode (advci_af_metering_mode_auto);
}
}
static void
-lib_3a_switch_mode (ia_3a_isp_mode mode, float frame_rate)
+lib_3a_switch_mode (advci_isp_mode mode, float frame_rate)
{
cam_lib_3a_dbg("%s:%d mode:%d frame_rate:%f\n", __func__, __LINE__, mode,frame_rate);
- ci_adv_configure(mode, frame_rate);
+ ci_adv_configure((ia_3a_isp_mode)mode, frame_rate);
}
static ci_adv_Err lib_3a_AeGetWindowsNum(int *num)
ci_adv_af_version(major,minor);
}
-static void lib_3a_AfGetStillAfStatus(ia_3a_af_status *status)
+static void lib_3a_AfGetStillAfStatus(advci_af_status *status)
{
*status = ci_adv_af_get_status();
}
-static bool lib_3a_af_is_complete(void)
+static gboolean lib_3a_af_is_complete(void)
{
ia_3a_af_status status;
- bool completed = FALSE;
+ gboolean completed = FALSE;
lib_3a_AfGetStillAfStatus(&status);
*aperture = (int)ia_3a_ae_get_manual_aperture();
}
-static void lib_3a_AeGetFlashMode(ia_3a_ae_flash_mode *mode)
+static void lib_3a_AeGetFlashMode(advci_ae_flash_mode *mode)
{
cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
*mode= ia_3a_ae_get_flash_mode();
}
-static void lib_3a_AeSetFlashMode(ia_3a_ae_flash_mode mode)
+static void lib_3a_AeSetFlashMode(advci_ae_flash_mode mode)
{
cam_lib_3a_dbg("%s:%d mode:%d \n", __func__, __LINE__, mode);
ci_adv_ae_set_flash_mode(mode);
}
static void
-lib_3a_AeSetMeteringMode(ia_3a_ae_metering_mode mode)
+lib_3a_AeSetMeteringMode(advci_ae_metering_mode mode)
{
cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- ci_adv_ae_set_metering_mode(mode);
+ ci_adv_ae_set_metering_mode((ia_3a_ae_metering_mode)mode);
}
static void
-lib_3a_AeGetMeteringMode(ia_3a_ae_metering_mode *mode)
+lib_3a_AeGetMeteringMode(advci_ae_metering_mode *mode)
{
cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
*mode = ia_3a_ae_get_metering_mode();
}
static void
-lib_3a_AfSetMeteringMode(ia_3a_af_metering_mode mode)
+lib_3a_AfSetMeteringMode(advci_af_metering_mode mode)
{
cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
ci_adv_af_set_metering_mode(mode);
}
static void
-lib_3a_AfGetMeteringMode(ia_3a_af_metering_mode *mode)
+lib_3a_AfGetMeteringMode(advci_af_metering_mode *mode)
{
cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
ci_adv_af_get_metering_mode(mode);
}
static void
-lib_3a_Ae_Af_GetWindow(ia_3a_window *window)
+lib_3a_Ae_Af_GetWindow(advci_window *window)
{
cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
ia_3a_ae_get_window(window);
}
static void
-lib_3a_Ae_Af_SetWindow( ia_3a_window *window)
+lib_3a_Ae_Af_SetWindow( advci_window *window)
{
cam_lib_3a_dbg("%s:window....%d:%d:%d:%d:%d\n",
__func__, window->x_left,window->x_right,
{
}
static void
-lib_3a_AwbSetImageEffect(ia_3a_image_effect effect)
+lib_3a_AwbSetImageEffect(advci_image_effect effect)
{
cam_lib_3a_dbg("%s:%d effect %d\n", __func__, __LINE__, effect);
}
static void
-lib_3a_AwbGetImageEffect(ia_3a_image_effect *effect)
+lib_3a_AwbGetImageEffect(advci_image_effect *effect)
{
*effect = ci_adv_isp_get_image_effect();
cam_lib_3a_dbg("%s:%d effect: %d\n", __func__, __LINE__, *effect);
}
static void
-lib_ae_is_flash_needed(bool *useflash)
+lib_ae_is_flash_needed(gboolean *useflash)
{
ci_adv_ae_is_flash_necessary(useflash);
cam_lib_3a_dbg("%s:%d useflash: %d\n", __func__, __LINE__, *useflash);
}
static void
-lib_3a_GetMakerNote(ia_3a_mknote_mode mknMode, ia_3a_mknote *note)
+lib_3a_GetMakerNote(advci_mknote_mode mknMode, advci_mknote *note)
{
note = ci_adv_get_maker_note(mknMode);
}
static void
-lib_3a_AddMakerNoteRecord(ia_3a_mknote_field_type mkn_format_id,
- ia_3a_mknote_field_name mkn_name_id,
- const void *record,
- unsigned short record_size)
-{
- ci_adv_add_maker_note_record(mkn_format_id, mkn_name_id, record, record_size);
-}
-
-static void
-lib_3a_PutMakerNote(ia_3a_mknote *mknData)
+lib_3a_PutMakerNote(advci_mknote *mknData)
{
if (mknData != NULL)
{
mfldadvci->Awbmatrix = lib_3a_Awbmatrix;
mfldadvci->GetGridInfo = lib_3a_GetGridInfo;
mfldadvci->GetMakerNote = lib_3a_GetMakerNote;
- mfldadvci->AddMakerNoteRecord = lib_3a_AddMakerNoteRecord;
mfldadvci->PutMakerNote = lib_3a_PutMakerNote;
mfldadvci->ResetMakerNote = lib_3a_ResetMakerNote;
}
mfldadvci->Awbmatrix = wrapper_default_Awbmatrix;
mfldadvci->GetGridInfo = wrapper_default_GetGridInfo;
mfldadvci->GetMakerNote = wrapper_default_GetMakerNote;
- mfldadvci->AddMakerNoteRecord = wrapper_default_AddMakerNoteRecord;
mfldadvci->PutMakerNote = wrapper_default_PutMakerNote;
mfldadvci->ResetMakerNote = wrapper_default_ResetMakerNote;
}
#include <stdlib.h>
#include <stdio.h>
-
+#include <glib.h>
#include "atomisp.h"
-
+#ifdef USE_STATIC_3A
#include "ci_adv_pub.h"
#include "ia_types.h"
#include "ia_redeye.h"
#include "ia_dvs.h"
#include "ia_dis.h"
-
+#endif /* USE_STATIC_3A */
typedef enum {
ci_adv_Success,
report all possible errors. */
} ci_adv_Err;
+typedef enum
+{
+ advci_isp_mode_preview,
+ advci_isp_mode_video,
+ advci_isp_mode_capture,
+ advci_isp_mode_continuous
+} advci_isp_mode;
+
+typedef struct {
+ void *addr;
+ int length;
+ int width;
+ int height;
+ int format;
+} advci_frame_t;
+
+typedef enum {
+ advci_ae_flicker_mode_off, /* No flicker correction */
+ advci_ae_flicker_mode_50hz, /* Correct 50Hz flicker */
+ advci_ae_flicker_mode_60hz, /* Correct 60Hz flicker */
+ advci_ae_flicker_mode_auto /* Auto detect and correct flicker */
+} advci_ae_flicker_mode;
+
+typedef enum {
+ advci_ae_exposure_program_auto,
+ advci_ae_exposure_program_portrait,
+ advci_ae_exposure_program_sports,
+ advci_ae_exposure_program_landscape,
+ advci_ae_exposure_program_night,
+ advci_ae_exposure_program_fireworks
+} advci_ae_exposure_program;
+
+typedef enum {
+ advci_ae_metering_mode_auto, /* Automatic */
+ advci_ae_metering_mode_spot, /* Spot metering, */
+ advci_ae_metering_mode_center, /* Center-weighted metering */
+ advci_ae_metering_mode_customized, /* Customized */
+ advci_ae_metering_mode_average, /* Average metering */
+} advci_ae_metering_mode;
+
+
+typedef struct {
+ int x_left;
+ int x_right;
+ int y_top;
+ int y_bottom;
+ int weight;
+} advci_window;
+
+typedef enum {
+ advci_af_metering_mode_auto,
+ advci_af_metering_mode_spot,
+ advci_af_metering_mode_multi,
+} advci_af_metering_mode;
+
+
+typedef enum {
+ advci_af_range_norm,
+ advci_af_range_macro,
+ advci_af_range_full
+} advci_af_range;
+
+/* Auto White Balance */
+typedef enum {
+ advci_awb_mode_auto, /* Corrected colors are calibrated to match changes in illuminant color */
+ advci_awb_mode_manual /* The current color balance is retained */
+} advci_awb_mode;
+
+typedef enum {
+ advci_image_effect_none = 0,
+ advci_image_effect_bw,
+ advci_image_effect_sepia,
+ advci_image_effect_negative
+} advci_image_effect;
+
+typedef enum {
+ advci_awb_light_source_other,
+ advci_awb_light_source_filament_lamp,
+ advci_awb_light_source_clear_sky,
+ advci_awb_light_source_cloudiness,
+ advci_awb_light_source_shadow_area,
+ advci_awb_light_source_fluorlamp_w,
+ advci_awb_light_source_fluorlamp_n,
+ advci_awb_light_source_fluorlamp_d,
+} advci_awb_light_source;
+
+typedef enum {
+ advci_ae_flash_mode_auto, /* Automatic (don't flash when it's dark) */
+ advci_ae_flash_mode_off, /* Off */
+ advci_ae_flash_mode_on, /* On */
+ advci_ae_flash_mode_day_sync, /* Day Sync */
+ advci_ae_flash_mode_slow_sync, /* Slow Sync */
+} advci_ae_flash_mode;
+
+typedef struct {
+ char *data;
+ unsigned int bytes;
+} advci_mknote;
+
+typedef enum {
+ advci_mknote_mode_jpeg, /* Returns makernote data for JPEG EXIF */
+ advci_mknote_mode_raw /* Returns makernote data for RAW Header */
+} advci_mknote_mode;
enum {
- SENSOR_TYPE_RAW = 1,
- SENSOR_TYPE_SOC
+ SENSOR_TYPE_RAW = 1,
+ SENSOR_TYPE_SOC
};
+typedef enum {
+ advci_af_mode_auto,
+ advci_af_mode_manual,
+ advci_af_mode_video
+} advci_af_mode;
+
+typedef enum {
+ advci_af_status_error, /* Cannot focus */
+ advci_af_status_success, /* Successfully focussed */
+ advci_af_status_cancelled, /* Canceled by user */
+ advci_af_status_busy, /* Busy focussing */
+ advci_af_status_idle /* AF not running */
+} advci_af_status;
+
+
typedef struct _GstV4l2MFLDAdvCI GstV4l2MFLDAdvCI;
/**
* GstV4l2MFLDAdvCI
/* 3A control API */
int (*mode_spec_init)(void);
- void (*switch_mode)(ia_3a_isp_mode mode, float frame_rate);
+ void (*switch_mode)(advci_isp_mode mode, float frame_rate);
void (*init) (void);
void (*uninit) (void);
int (*isp_set_fd)(int fd, const char *sensor_id);
void (*ae_calc_for_flash)(void);
void (*ae_calc_without_flash)(void);
void (*ae_calc_with_flash)(void);
- void (*ae_is_flash_needed) (bool *useflash);
+ void (*ae_is_flash_needed)(gboolean *useflash);
void (*ae_apply_results)(void);
void (*af_start)(void);
void (*af_stop)(void);
- bool (*af_is_complete)(void);
+ gboolean (*af_is_complete)(void);
void (*awb_apply_results)(void);
void (*awb_calc_flash)(void);
void (*dis_calc_still)(struct atomisp_dis_vector *vector, int frame_number);
- void (*do_redeye_removal) (ia_frame *user_buf);
+ void (*do_redeye_removal) (advci_frame_t *user_buf);
- void (*still_compose) (ia_frame *com_buf, ia_frame bufs[],
+ void (*still_compose) (advci_frame_t *com_buf, advci_frame_t bufs[],
int frame_dis, struct atomisp_dis_vector vectors[]);
void (*load_gdc_table)(void);
/* 3A property API */
ci_adv_Err (*AeSetBias)(int bias); /* bias: -2.0(EV) to +2.0(EV) */
ci_adv_Err (*AeGetBias)(int *bias); /* bias: -2.0(EV) to +2.0(EV) */
- void (*AeSetFlickerMode)(ia_3a_ae_flicker_mode mode);
- void (*AeGetFlickerMode)(ia_3a_ae_flicker_mode *mode);
- void (*AeSetExposureProgram)(ia_3a_ae_exposure_program program);
- void (*AeGetExposureProgram)(ia_3a_ae_exposure_program *program);
- void (*AeSetMeteringMode)(ia_3a_ae_metering_mode mode);
- void (*AeGetMeteringMode)(ia_3a_ae_metering_mode *mode);
- void (*AeSetWindow)(ia_3a_window *window);
- void (*AeGetWindow)(ia_3a_window *window);
+ void (*AeSetFlickerMode)(advci_ae_flicker_mode mode);
+ void (*AeGetFlickerMode)(advci_ae_flicker_mode *mode);
+ void (*AeSetExposureProgram)(advci_ae_exposure_program program);
+ void (*AeGetExposureProgram)(advci_ae_exposure_program *program);
+ void (*AeSetMeteringMode)(advci_ae_metering_mode mode);
+ void (*AeGetMeteringMode)(advci_ae_metering_mode *mode);
+ void (*AeSetWindow)(advci_window *window);
+ void (*AeGetWindow)(advci_window *window);
ci_adv_Err (*AeSetIso)(int sensitivity);
ci_adv_Err (*AeGetIso)(int *sensitivity);
- void (*AfSetMode)(ia_3a_af_mode mode);
- void (*AfGetMode)(ia_3a_af_mode *mode);
- void (*AfSetMeteringMode)(ia_3a_af_metering_mode mode);
- void (*AfGetMeteringMode)(ia_3a_af_metering_mode *mode);
- void (*AfSetWindow)(ia_3a_window *window);
- void (*AfGetWindow)(ia_3a_window *window);
-
- /*
- ci_adv_Err (*AfStartStillAf)(void);
- ci_adv_Err (*AfStopStillAf)(void);
- ci_adv_Err (*AfGetStillAfStatus)(ci_adv_AfStatus *status);
- */
- void (*AfSetRange)(ia_3a_af_range range);
- void (*AfGetRange)(ia_3a_af_range *range);
+ void (*AfSetMode)(advci_af_mode mode);
+ void (*AfGetMode)(advci_af_mode *mode);
+ void (*AfSetMeteringMode)(advci_af_metering_mode mode);
+ void (*AfGetMeteringMode)(advci_af_metering_mode *mode);
+ void (*AfSetWindow)(advci_window *window);
+ void (*AfGetWindow)(advci_window *window);
+
+ void (*AfSetRange)(advci_af_range range);
+ void (*AfGetRange)(advci_af_range *range);
/* AWB mode */
- void (*AwbSetMode)(ia_3a_awb_mode mode);
- void (*AwbGetMode)(ia_3a_awb_mode *mode);
+ void (*AwbSetMode)(advci_awb_mode mode);
+ void (*AwbGetMode)(advci_awb_mode *mode);
/* color tone */
- void (*AwbSetImageEffect) (ia_3a_image_effect effect);
- void (*AwbGetImageEffect)(ia_3a_image_effect *effect);
+ void (*AwbSetImageEffect) (advci_image_effect effect);
+ void (*AwbGetImageEffect)(advci_image_effect *effect);
/* AWB Light Source */
- void (*AwbSetLightSource)(ia_3a_awb_light_source ls);
- void (*AwbGetLightSource)(ia_3a_awb_light_source *ls);
+ void (*AwbSetLightSource)(advci_awb_light_source ls);
+ void (*AwbGetLightSource)(advci_awb_light_source *ls);
ci_adv_Err (*AeGetWindowsNum)(int *num);
void (*AwbVersion)(int * major, int * minor);
void (*AeVersion)(int * major, int * minor);
void (*AfVersion)(int * major, int * minor);
- void (*AfGetStillAfStatus)(ia_3a_af_status *status);
+ void (*AfGetStillAfStatus)(advci_af_status *status);
void (*RerVersion)(int * major, int * minor);
ci_adv_Err (*AeGetManualShutter)(int *time);
void (*Awbdata)(unsigned * num_p, unsigned * avg_r, unsigned * avg_gr,
unsigned * avg_b, unsigned * avg_gb);
void (*AeGetManualAperture)(int *aperture);
- void (*AeGetFlashMode)(ia_3a_ae_flash_mode *mode);
- void (*AeSetFlashMode)(ia_3a_ae_flash_mode mode);
+ void (*AeGetFlashMode)(advci_ae_flash_mode *mode);
+ void (*AeSetFlashMode)(advci_ae_flash_mode mode);
void (*AwbGetManualColorTemperature)(int *ctemp);
void (*Awbmatrix)(int msqWbGain[3], int msqCcMtrx[9], unsigned short * shift);
void (*GetGridInfo) (void * grid_info);
- void (*GetMakerNote) (ia_3a_mknote_mode mknMode, ia_3a_mknote * note);
- void (*AddMakerNoteRecord) (ia_3a_mknote_field_type mkn_format_id,
- ia_3a_mknote_field_name mkn_name_id,
- const void *record,
- unsigned short record_size);
- void (*PutMakerNote)(ia_3a_mknote *mknData);
+ void (*GetMakerNote) (advci_mknote_mode mknMode, advci_mknote * note);
+ void (*PutMakerNote)(advci_mknote *mknData);
void (*ResetMakerNote)(void);
-
-
-
-
int fd;
};
#include "mfld_cam.h"
#include "mfld_driver.h"
-#include "ia_types.h"
-#include "ia_3a_types.h"
-
#include <glib.h>
#include <pthread.h>
#include <errno.h>
/* Focus Status Map */
static const int focus_status_map[][2] =
{
- { CAM_FOCUS_STATUS_IDLE , ia_3a_af_status_idle}, /* AF not running */
- { CAM_FOCUS_STATUS_RUNNING, ia_3a_af_status_busy}, /* Busy focusing */
- { CAM_FOCUS_STATUS_SUCCESS, ia_3a_af_status_success}, /* Successfully focussed */
- { CAM_FOCUS_STATUS_FAIL, ia_3a_af_status_error}, /* Cannot focus */
- { CAM_FOCUS_STATUS_SUCCESS, ia_3a_af_status_cancelled,},/* Canceled by user */
+ { CAM_FOCUS_STATUS_IDLE , advci_af_status_idle}, /* AF not running */
+ { CAM_FOCUS_STATUS_RUNNING, advci_af_status_busy}, /* Busy focusing */
+ { CAM_FOCUS_STATUS_SUCCESS, advci_af_status_success}, /* Successfully focussed */
+ { CAM_FOCUS_STATUS_FAIL, advci_af_status_error}, /* Cannot focus */
+ { CAM_FOCUS_STATUS_SUCCESS, advci_af_status_cancelled,},/* Canceled by user */
{ -1, -1 }
};
struct mfld_driver_t
{
int fd;
- ia_3a_isp_mode mode;
+ advci_isp_mode mode;
int rer_enabled;
int dis_enabled, dvs_enabled;
int af_enabled, ae_enabled, awb_enabled;
switch (wb_mode) {
case CAM_AWB_MODE_AUTO:
- mfldadvci->AwbSetMode (ia_3a_awb_mode_auto);
+ mfldadvci->AwbSetMode (advci_awb_mode_auto);
break;
case CAM_AWB_MODE_DAYLIGHT:
- mfldadvci->AwbSetMode (ia_3a_awb_mode_manual);
- mfldadvci->AwbSetLightSource (ia_3a_awb_light_source_clear_sky);
+ mfldadvci->AwbSetMode (advci_awb_mode_manual);
+ mfldadvci->AwbSetLightSource (advci_awb_light_source_clear_sky);
break;
case CAM_AWB_MODE_CLOUDY:
- mfldadvci->AwbSetMode (ia_3a_awb_mode_manual);
- mfldadvci->AwbSetLightSource (ia_3a_awb_light_source_cloudiness);
+ mfldadvci->AwbSetMode (advci_awb_mode_manual);
+ mfldadvci->AwbSetLightSource (advci_awb_light_source_cloudiness);
break;
case CAM_AWB_MODE_SUNSET:
- mfldadvci->AwbSetMode (ia_3a_awb_mode_manual);
- mfldadvci->AwbSetLightSource (ia_3a_awb_light_source_shadow_area);
+ mfldadvci->AwbSetMode (advci_awb_mode_manual);
+ mfldadvci->AwbSetLightSource (advci_awb_light_source_shadow_area);
break;
case CAM_AWB_MODE_TUNGSTEN:
- mfldadvci->AwbSetMode (ia_3a_awb_mode_manual);
- mfldadvci->AwbSetLightSource (ia_3a_awb_light_source_filament_lamp);
+ mfldadvci->AwbSetMode (advci_awb_mode_manual);
+ mfldadvci->AwbSetLightSource (advci_awb_light_source_filament_lamp);
break;
case CAM_AWB_MODE_FLUORESCENT:
- mfldadvci->AwbSetMode (ia_3a_awb_mode_manual);
- mfldadvci->AwbSetLightSource (ia_3a_awb_light_source_fluorlamp_w);
+ mfldadvci->AwbSetMode (advci_awb_mode_manual);
+ mfldadvci->AwbSetLightSource (advci_awb_light_source_fluorlamp_w);
break;
default:
cam_driver_dbg ("Not support awb mode\n");
cam_err_t
get_wb_mode (int *wb_mode)
{
- ia_3a_awb_light_source ls;
- ia_3a_awb_mode mode;
+ advci_awb_light_source ls;
+ advci_awb_mode mode;
mfldadvci->AwbGetMode (&mode);
- if (mode == ia_3a_awb_mode_auto) {
+ if (mode == advci_awb_mode_auto) {
*wb_mode = CAM_AWB_MODE_AUTO;
return CAM_ERR_NONE;
}
//Manual Mode, check the error?
mfldadvci->AwbGetLightSource (&ls);
switch (ls) {
- case ia_3a_awb_light_source_filament_lamp:
+ case advci_awb_light_source_filament_lamp:
*wb_mode = CAM_AWB_MODE_TUNGSTEN;
break;
- case ia_3a_awb_light_source_clear_sky:
+ case advci_awb_light_source_clear_sky:
*wb_mode = CAM_AWB_MODE_DAYLIGHT;
break;
- case ia_3a_awb_light_source_cloudiness:
+ case advci_awb_light_source_cloudiness:
*wb_mode = CAM_AWB_MODE_CLOUDY;
break;
- case ia_3a_awb_light_source_shadow_area:
+ case advci_awb_light_source_shadow_area:
*wb_mode = CAM_AWB_MODE_SUNSET;
break;
- case ia_3a_awb_light_source_fluorlamp_w:
- case ia_3a_awb_light_source_fluorlamp_n:
- case ia_3a_awb_light_source_fluorlamp_d:
+ case advci_awb_light_source_fluorlamp_w:
+ case advci_awb_light_source_fluorlamp_n:
+ case advci_awb_light_source_fluorlamp_d:
*wb_mode = CAM_AWB_MODE_FLUORESCENT;
break;
default:
static cam_err_t
set_scene_mode (int mode)
{
- ia_3a_ae_exposure_program scene;
+ advci_ae_exposure_program scene;
switch (mode) {
case CAM_GENERAL_SCENE_MODE_PORTRAIT:
- scene = ia_3a_ae_exposure_program_portrait;
+ scene = advci_ae_exposure_program_portrait;
break;
case CAM_GENERAL_SCENE_MODE_LANDSCAPE:
- scene = ia_3a_ae_exposure_program_landscape;
+ scene = advci_ae_exposure_program_landscape;
break;
case CAM_GENERAL_SCENE_MODE_SPORT:
- scene = ia_3a_ae_exposure_program_sports;
+ scene = advci_ae_exposure_program_sports;
break;
case CAM_GENERAL_SCENE_MODE_NIGHT:
- scene = ia_3a_ae_exposure_program_night;
+ scene = advci_ae_exposure_program_night;
break;
case CAM_GENERAL_SCENE_MODE_AUTO:
- scene = ia_3a_ae_exposure_program_auto;
+ scene = advci_ae_exposure_program_auto;
break;
case CAM_GENERAL_SCENE_MODE_FIREWORKS:
- scene = ia_3a_ae_exposure_program_fireworks;
+ scene = advci_ae_exposure_program_fireworks;
break;
default:
cam_driver_dbg ("%s Not supported Scene Mode %d\n", __func__, mode);
/* Convert camera genreral flicker mode to AE flicker mode */
switch (mode) {
case CAM_GENERAL_FLICKER_REDUCTION_MODE_OFF:
- mfldadvci->AeSetFlickerMode (ia_3a_ae_flicker_mode_off);
+ mfldadvci->AeSetFlickerMode (advci_ae_flicker_mode_off);
break;
case CAM_GENERAL_FLICKER_REDUCTION_MODE_50HZ:
- mfldadvci->AeSetFlickerMode (ia_3a_ae_flicker_mode_50hz);
+ mfldadvci->AeSetFlickerMode (advci_ae_flicker_mode_50hz);
break;
case CAM_GENERAL_FLICKER_REDUCTION_MODE_60HZ:
- mfldadvci->AeSetFlickerMode (ia_3a_ae_flicker_mode_60hz);
+ mfldadvci->AeSetFlickerMode (advci_ae_flicker_mode_60hz);
break;
case CAM_GENERAL_FLICKER_REDUCTION_MODE_AUTO:
- mfldadvci->AeSetFlickerMode (ia_3a_ae_flicker_mode_auto);
+ mfldadvci->AeSetFlickerMode (advci_ae_flicker_mode_auto);
break;
default:
cam_driver_dbg ("Not supported flicker mode\n");
get_flicker_mode (int *mode)
{
int ret = 0;
- ia_3a_ae_flicker_mode flicker_mode;
+ advci_ae_flicker_mode flicker_mode;
mfldadvci->AeGetFlickerMode (&flicker_mode);
/* Convert AE flicker mode to camera general flicker mode */
switch (flicker_mode) {
- case ia_3a_ae_flicker_mode_off:
+ case advci_ae_flicker_mode_off:
*mode = CAM_GENERAL_FLICKER_REDUCTION_MODE_OFF;
break;
- case ia_3a_ae_flicker_mode_50hz:
+ case advci_ae_flicker_mode_50hz:
*mode = CAM_GENERAL_FLICKER_REDUCTION_MODE_50HZ;
break;
- case ia_3a_ae_flicker_mode_60hz:
+ case advci_ae_flicker_mode_60hz:
*mode = CAM_GENERAL_FLICKER_REDUCTION_MODE_60HZ;
break;
- case ia_3a_ae_flicker_mode_auto:
+ case advci_ae_flicker_mode_auto:
*mode = CAM_GENERAL_FLICKER_REDUCTION_MODE_AUTO;
break;
default:
if (mfld_driver.sensor_type == SENSOR_TYPE_RAW){
switch (mode) {
case CAM_FOCUS_MODE_AUTO:
- mfldadvci->AfSetMode (ia_3a_af_mode_auto);
+ mfldadvci->AfSetMode (advci_af_mode_auto);
break;
case CAM_FOCUS_MODE_MACRO:
- mfldadvci->AfSetMode (ia_3a_af_mode_auto);
- mfldadvci->AfSetRange (ia_3a_af_range_macro);
+ mfldadvci->AfSetMode (advci_af_mode_auto);
+ mfldadvci->AfSetRange (advci_af_range_macro);
break;
case CAM_FOCUS_MODE_NORM:
- mfldadvci->AfSetMode (ia_3a_af_mode_auto);
- mfldadvci->AfSetRange (ia_3a_af_range_norm);
+ mfldadvci->AfSetMode (advci_af_mode_auto);
+ mfldadvci->AfSetRange (advci_af_range_norm);
break;
case CAM_FOCUS_MODE_FULL:
- mfldadvci->AfSetMode (ia_3a_af_mode_auto);
- mfldadvci->AfSetRange (ia_3a_af_range_full);
+ mfldadvci->AfSetMode (advci_af_mode_auto);
+ mfldadvci->AfSetRange (advci_af_range_full);
break;
default:
cam_driver_dbg ("Not supported mode\n");
if (mfld_driver.sensor_type == SENSOR_TYPE_RAW){
switch (mode) {
case CAM_CAPTURE_MODE_VIEWFINDER:
- mfldadvci->switch_mode (ia_3a_isp_mode_preview, mfld_driver.frame_rate);
+ mfldadvci->switch_mode (advci_isp_mode_preview, mfld_driver.frame_rate);
set_flash_mode(fd, mfld_cam_settings.flash_mode);
if (mfld_driver.ae_enabled)
mfld_driver.first_frame = 1;
cam_driver_dbg ("%s: VIEWFINDER Mode is set\n", __func__);
break;
case CAM_CAPTURE_MODE_VIDEO_RECORD:
- mfldadvci->switch_mode (ia_3a_isp_mode_video, mfld_driver.frame_rate);
+ mfldadvci->switch_mode (advci_isp_mode_video, mfld_driver.frame_rate);
if (mfld_driver.ae_enabled)
mfld_driver.first_frame = 1;
cam_driver_dbg ("%s: VIDEO Mode is set\n", __func__);
break;
case CAM_CAPTURE_MODE_STILL_CAPTURE:
- mfldadvci->switch_mode (ia_3a_isp_mode_capture, mfld_driver.frame_rate);
+ mfldadvci->switch_mode (advci_isp_mode_capture, mfld_driver.frame_rate);
if (mfld_driver.ae_enabled)
mfld_driver.first_frame = 1;
cam_driver_dbg ("%s: STILL Mode is set\n", __func__);
break;
default:
- mfldadvci->switch_mode (ia_3a_isp_mode_preview, mfld_driver.frame_rate);
+ mfldadvci->switch_mode (advci_isp_mode_preview, mfld_driver.frame_rate);
mfld_driver.first_frame = 1;
cam_driver_dbg ("%s: NULL Mode is set\n", __func__);
break;
int
cam_checkfocus_status (cam_focus_status_t * status, int force_update)
{
- ia_3a_af_status af_status;
- bool do_read = FALSE;
+ advci_af_status af_status;
+ gboolean do_read = FALSE;
if (mfld_driver.focus_done >= FOCUS_REALLY_DONE) {
mfld_driver.focus_done = 0;
* For Red Eye Reduction and Still Image Stabilization
*/
static void
-cam_copy_v4l2buf_to_user (ia_frame *user, struct v4l2_buffer *buf)
+cam_copy_v4l2buf_to_user (advci_frame_t *user, struct v4l2_buffer *buf)
{
void *addr;
if (mfld_driver.mmap) {
}
static void
-cam_free_bufs (ia_frame *bufs)
+cam_free_bufs (advci_frame_t *bufs)
{
int i;
for (i = 0; i < DIS_COMPOSITE_FRAMES; i++) {
}
static void
-cam_still_compose (struct v4l2_buffer *buf, ia_frame bufs[],
+cam_still_compose (struct v4l2_buffer *buf, advci_frame_t bufs[],
int frame_dis, struct atomisp_dis_vector vectors[])
{
- ia_frame com_buf;
+ advci_frame_t com_buf;
cam_driver_dbg ("Still Compose Phase 1: Begin\n");
com_buf.length = buf->length;
{
- ia_frame user_buf;
+ advci_frame_t user_buf;
user_buf.length = buf->length;
if (mfld_driver.mmap)
user_buf.addr = mmap (NULL, buf->length, PROT_READ | PROT_WRITE, MAP_SHARED,
}
}
-static bool
+static gboolean
get_flash_status(void)
{
int cur_flash_mode = CAM_LIGHT_FLASH_MODE_OFF;
- bool flash_en = FALSE;
+ gboolean flash_en = FALSE;
get_flash_mode(&cur_flash_mode);
}
static void
-cam_dis_dvs_processing (struct atomisp_dis_vector *vectors, ia_frame *bufs,
+cam_dis_dvs_processing (struct atomisp_dis_vector *vectors, advci_frame_t *bufs,
struct v4l2_buffer *buffer, int frame_cnt, int dis_enabled)
{
struct atomisp_dis_vector *dvs_vector;
cam_driver_dbg ("Begin cam_dis_still_process\n");
- if (mfld_driver.mode == ia_3a_isp_mode_video)
+ if (mfld_driver.mode == advci_isp_mode_video)
dvs_vector = &mfld_driver.dvs_vector;
else
dvs_vector = NULL;
{
int frame_cnt, frame_dis;
struct atomisp_dis_vector vectors[DIS_COMPOSITE_FRAMES];
- ia_frame bufs[DIS_COMPOSITE_FRAMES];
+ advci_frame_t bufs[DIS_COMPOSITE_FRAMES];
int dis_enabled = mfld_driver.dis_enabled &&
/* Still AF processing */
if (mfld_driver.still_af_count) {
- bool complete = TRUE; /* AF status */
+ gboolean complete = TRUE; /* AF status */
if (mfld_driver.af_enabled)
complete = mfldadvci->af_is_complete ();
int index;
int frame_dis = 1, frame_cnt;
cam_err_t ret = 0;
- bool flash_en = FALSE;
+ gboolean flash_en = FALSE;
cam_capture_init (fd, buffer, capture_settings);
cam_err_t get_af_status(int fd, unsigned * status)
{
- ia_3a_af_status st;
+ advci_af_status st;
mfldadvci->AfGetStillAfStatus(&st);
- if(ia_3a_af_status_success == st)
+ if(advci_af_status_success == st)
*status = 1;
else
*status = 0;
cam_err_t get_exp_mode(int fd, cam_scene_mode_t *expmode)
{
- ia_3a_ae_exposure_program mode;
+ advci_ae_exposure_program mode;
mfldadvci->AeGetExposureProgram(&mode);
/* Convert AE flicker mode to camera general flicker mode */
switch (mode) {
- case ia_3a_ae_exposure_program_auto:
+ case advci_ae_exposure_program_auto:
*expmode = CAM_GENERAL_SCENE_MODE_AUTO;
break;
- case ia_3a_ae_exposure_program_portrait:
+ case advci_ae_exposure_program_portrait:
*expmode = CAM_GENERAL_SCENE_MODE_PORTRAIT;
break;
- case ia_3a_ae_exposure_program_sports:
+ case advci_ae_exposure_program_sports:
*expmode = CAM_GENERAL_SCENE_MODE_SPORT;
break;
- case ia_3a_ae_exposure_program_landscape:
+ case advci_ae_exposure_program_landscape:
*expmode = CAM_GENERAL_SCENE_MODE_LANDSCAPE;
break;
- case ia_3a_ae_exposure_program_night:
+ case advci_ae_exposure_program_night:
*expmode = CAM_GENERAL_SCENE_MODE_NIGHT;
break;
- case ia_3a_ae_exposure_program_fireworks:
+ case advci_ae_exposure_program_fireworks:
*expmode = CAM_GENERAL_SCENE_MODE_FIREWORKS;
break;
default:
switch(ci_mode)
{
- case ia_3a_ae_flash_mode_auto:
+ case advci_ae_flash_mode_auto:
*mode = CAM_LIGHT_FLASH_MODE_AUTO;
break;
- case ia_3a_ae_flash_mode_off:
+ case advci_ae_flash_mode_off:
*mode = CAM_LIGHT_FLASH_MODE_OFF;
break;
- case ia_3a_ae_flash_mode_on:
+ case advci_ae_flash_mode_on:
*mode = CAM_LIGHT_FLASH_MODE_ON;
break;
- case ia_3a_ae_flash_mode_day_sync:
+ case advci_ae_flash_mode_day_sync:
*mode = CAM_LIGHT_FLASH_MODE_AUTO;
break;
- case ia_3a_ae_flash_mode_slow_sync:
+ case advci_ae_flash_mode_slow_sync:
*mode = CAM_LIGHT_FLASH_MODE_AUTO;
break;
default:
}
cam_err_t set_ae_flash_mode(int fd, cam_flash_mode_t mode)
{
- ia_3a_ae_flash_mode ia_mode;
+ advci_ae_flash_mode flash_mode;
switch(mode)
{
case CAM_LIGHT_FLASH_MODE_AUTO:
- ia_mode = ia_3a_ae_flash_mode_auto;
+ flash_mode = advci_ae_flash_mode_auto;
break;
case CAM_LIGHT_FLASH_MODE_OFF:
- ia_mode = ia_3a_ae_flash_mode_off;
+ flash_mode = advci_ae_flash_mode_off;
break;
case CAM_LIGHT_FLASH_MODE_ON:
- ia_mode = ia_3a_ae_flash_mode_on;
+ flash_mode = advci_ae_flash_mode_on;
break;
default:
- ia_mode = ia_3a_ae_flash_mode_auto;
+ flash_mode = advci_ae_flash_mode_auto;
break;
}
- mfldadvci->AeSetFlashMode(ia_mode);
+ mfldadvci->AeSetFlashMode(flash_mode);
return CAM_ERR_NONE;
}
$(GST_BASE_CFLAGS) \
$(GST_CONTROLLER_CFLAGS) \
$(GST_BAD_CFLAGS) \
+ $(LIBMFLDADVCI_CFLAGS) \
-DGST_USE_UNSTABLE_API
libgstmfldv4l2cam_la_LIBADD = $(top_builddir)/gst-libs/gst/camera/libgstmfldcamera-$(GST_MAJORMINOR).la \
-lgstphotography-$(GST_MAJORMINOR)
-libgstmfldv4l2cam_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
+libgstmfldv4l2cam_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS) $(LIBMFLDADVCI_LIBS)
libgstmfldv4l2cam_la_LIBTOOLFLAGS = --tag=disable-static
noinst_HEADERS = v4l2camsrc_calls.h gstv4l2camvidorient.h
GST_DEBUG_OBJECT(v4l2camsrc,"wrong ae metering mode. set it to spot mode automaticly.\n");
v4l2camsrc->ae_metering_mode = GST_CAMERA_AE_METERING_SPOT;
v4l2camsrc->mfldadvci->AeSetMeteringMode
- ( (ia_3a_ae_metering_mode) v4l2camsrc->ae_metering_mode);
+ ( (advci_ae_metering_mode) v4l2camsrc->ae_metering_mode);
}
- v4l2camsrc->mfldadvci->AeSetWindow ((ia_3a_window *) (&(v4l2camsrc->ae_window)));
+ v4l2camsrc->mfldadvci->AeSetWindow ((advci_window *) (&(v4l2camsrc->ae_window)));
gst_structure_free (ae_window_param);
g_free (ctmp);
case PROP_AE_METERING_MODE:
{
v4l2camsrc->ae_metering_mode = g_value_get_enum (value);
- v4l2camsrc->mfldadvci->AeSetMeteringMode((ia_3a_ae_metering_mode)v4l2camsrc->ae_metering_mode);
+ v4l2camsrc->mfldadvci->AeSetMeteringMode((advci_ae_metering_mode)v4l2camsrc->ae_metering_mode);
break;
}
case PROP_AF_METERING_MODE:
{
v4l2camsrc->af_metering_mode = g_value_get_enum (value);
- v4l2camsrc->mfldadvci->AfSetMeteringMode((ia_3a_af_metering_mode)v4l2camsrc->af_metering_mode);
+ v4l2camsrc->mfldadvci->AfSetMeteringMode((advci_af_metering_mode)v4l2camsrc->af_metering_mode);
break;
}
case PROP_AF_WINDOW:
v4l2camsrc->af_window.y_top);
- v4l2camsrc->mfldadvci->AfSetWindow ((ia_3a_window *) (&(v4l2camsrc->af_window)));
+ v4l2camsrc->mfldadvci->AfSetWindow ((advci_window *) (&(v4l2camsrc->af_window)));
gst_structure_free (af_window_param);
g_free (ctmp);
if (v4l2camsrc->is_active) {
g_mutex_lock (v4l2camsrc->device_mutex);
- v4l2camsrc->mfldadvci->AfSetWindow ((ia_3a_window *) (&(v4l2camsrc->af_window)));
+ v4l2camsrc->mfldadvci->AfSetWindow ((advci_window *) (&(v4l2camsrc->af_window)));
g_mutex_unlock (v4l2camsrc->device_mutex);
}
if (v4l2camsrc->is_active) {
g_mutex_lock (v4l2camsrc->device_mutex);
v4l2camsrc->ae_metering_mode = *(GstCameraAEMeteringMode *)&mode;
- v4l2camsrc->mfldadvci->AeSetMeteringMode((ia_3a_ae_metering_mode)v4l2camsrc->ae_metering_mode);
+ v4l2camsrc->mfldadvci->AeSetMeteringMode((advci_ae_metering_mode)v4l2camsrc->ae_metering_mode);
g_mutex_unlock (v4l2camsrc->device_mutex);
}
+* Wed Nov 28 2012 Marko Ollonen <marko.ollonen@ixonos.com> submit/trunk/20121126.140213@4962ec2
+- Clean up: remove dependency to 3a lib headers
+
* Tue Nov 27 2012 Marko Ollonen <marko.ollonen@ixonos.com> submit/trunk/20121126.140213@ddbbe46
- clean up: MIPI interrupt debugs
Name: mfldv4l2camsrc
Summary: Camera source component for Intel Medfield ISP
-Version: 0.47
+Version: 0.48
Release: 1
Group: Applications/Multimedia
License: LGPLv2+
%build
ln -sf /usr/src/kernels/*mfld-blackbay/include/ %{_builddir}/kernel_headers
./autogen.sh
-CFLAGS="-DSTDC99 -D__user= -DUSE_STATIC_3A -I/usr/include/libmfldadvci/ -I%{_builddir}/kernel_headers" %configure --disable-static \
+CFLAGS="$CFLAGS -DSTDC99 -D__user= -I%{_builddir}/kernel_headers" %configure --disable-static \
--disable-nls \
--enable-swscale \
--prefix=%{_prefix} \
projects / adaptation / intel_mfld / gst-plugins-atomisp.git / commitdiff