xcore/x3a_result_factory.cpp - platform/external/libxcam - Gitiles

 /*
  * x3a_result_factory.cpp - 3A result factory
  *
  *  Copyright (c) 2015 Intel Corporation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
  * Author: Wind Yuan <feng.yuan@intel.com>
  */

 #include "x3a_result_factory.h"

 namespace XCam {

 #define XCAM_3A_RESULT_FACTORY(DataType, res_type, from)            \
     DataType *ret =                                                 \
         new DataType (res_type);                                    \
     if (from) {                                                     \
         uint32_t type = xcam_3a_result_type (from);                 \
         if (type != XCAM_3A_RESULT_NULL && type != res_type) {      \
             XCAM_ASSERT (false);                                    \
             XCAM_LOG_WARNING ("create result from wrong type:%d to type:%d", type, res_type);    \
         }                                                           \
         ret->set_standard_result (*from);                           \
     }                                                               \
     return ret;


 Mutex X3aResultFactory::_mutex;
 SmartPtr<X3aResultFactory> X3aResultFactory::_instance (NULL);

 SmartPtr<X3aResultFactory>
 X3aResultFactory::instance ()
 {
     SmartLock locker (_mutex);
     if (_instance.ptr ())
         return _instance;

     _instance = new X3aResultFactory;
     return _instance;
 }

 X3aResultFactory::X3aResultFactory ()
 {
 }

 X3aResultFactory::~X3aResultFactory ()
 {
 }

 SmartPtr<X3aResult>
 X3aResultFactory::create_3a_result (XCam3aResultHead *from)
 {
     SmartPtr<X3aResult> result (NULL);

     XCAM_ASSERT (from);
     if (!from)
         return result;

     uint32_t type = xcam_3a_result_type (from);

     switch (type) {
     case XCAM_3A_RESULT_WHITE_BALANCE:
         result = create_whitebalance ((XCam3aResultWhiteBalance*)from);
         break;
     case XCAM_3A_RESULT_BLACK_LEVEL:
         result = create_blacklevel ((XCam3aResultBlackLevel*)from);
         break;
     case XCAM_3A_RESULT_YUV2RGB_MATRIX:
         result = create_yuv2rgb_colormatrix ((XCam3aResultColorMatrix*)from);
         break;
     case XCAM_3A_RESULT_RGB2YUV_MATRIX:
         result = create_rgb2yuv_colormatrix ((XCam3aResultColorMatrix*)from);
         break;
     case XCAM_3A_RESULT_EXPOSURE:
         result = create_exposure ((XCam3aResultExposure*)from);
         break;
     case XCAM_3A_RESULT_FOCUS:
         result = create_focus ((XCam3aResultFocus*)from);
         break;
     case XCAM_3A_RESULT_DEMOSAIC:
         result = create_demosaicing ((XCam3aResultDemosaic*)from);
         break;
     case XCAM_3A_RESULT_DEFECT_PIXEL_CORRECTION:
         result = create_defectpixel ((XCam3aResultDefectPixel*)from);
         break;
     case XCAM_3A_RESULT_NOISE_REDUCTION:
         result = create_noise_reduction ((XCam3aResultNoiseReduction*)from);
         break;
     case XCAM_3A_RESULT_3D_NOISE_REDUCTION:
         result = create_3d_noise_reduction ((XCam3aResultTemporalNoiseReduction*)from);
         break;
     case XCAM_3A_RESULT_TEMPORAL_NOISE_REDUCTION_YUV:
         result = create_yuv_temp_noise_reduction ((XCam3aResultTemporalNoiseReduction*)from);
         break;
     case XCAM_3A_RESULT_EDGE_ENHANCEMENT:
         result = create_edge_enhancement ((XCam3aResultEdgeEnhancement*)from);
         break;
     case XCAM_3A_RESULT_MACC:
         result = create_macc ((XCam3aResultMaccMatrix*)from);
         break;
     case XCAM_3A_RESULT_CHROMA_TONE_CONTROL:
         result = create_chroma_tone_control ((XCam3aResultChromaToneControl*)from);
         break;
     case XCAM_3A_RESULT_Y_GAMMA:
         result = create_y_gamma_table ((XCam3aResultGammaTable*)from);
         break;
     case XCAM_3A_RESULT_R_GAMMA:
         result = create_r_gamma_table ((XCam3aResultGammaTable*)from);
         break;
     case XCAM_3A_RESULT_G_GAMMA:
         result = create_g_gamma_table ((XCam3aResultGammaTable*)from);
         break;
     case XCAM_3A_RESULT_B_GAMMA:
         result = create_b_gamma_table ((XCam3aResultGammaTable*)from);
         break;
     case XCAM_3A_RESULT_BAYER_NOISE_REDUCTION:
         result = create_bayer_noise_reduction ((XCam3aResultBayerNoiseReduction*)from);
         break;
     case XCAM_3A_RESULT_BRIGHTNESS:
         result = create_brightness ((XCam3aResultBrightness*)from);
         break;
     case XCAM_3A_RESULT_WAVELET_NOISE_REDUCTION:
         result = create_wavelet_noise_reduction ((XCam3aResultWaveletNoiseReduction*)from);
         break;
     case XCAM_3A_RESULT_FACE_DETECTION:
         result = create_face_detection ((XCamFDResult*)from);
         break;
     case XCAM_3A_RESULT_DVS:
         result = create_digital_video_stabilizer ((XCamDVSResult*)from);
         break;
     default:
         XCAM_LOG_WARNING ("create 3a result with unknown result type:%d", type);
         break;
     }

     return result;
 }

 SmartPtr<X3aWhiteBalanceResult>
 X3aResultFactory::create_whitebalance (XCam3aResultWhiteBalance *from)
 {
     XCAM_3A_RESULT_FACTORY (X3aWhiteBalanceResult, XCAM_3A_RESULT_WHITE_BALANCE, from);
 }

 SmartPtr<X3aBlackLevelResult>
 X3aResultFactory::create_blacklevel (XCam3aResultBlackLevel *from)
 {
     XCAM_3A_RESULT_FACTORY (X3aBlackLevelResult, XCAM_3A_RESULT_BLACK_LEVEL, from);
 }

 SmartPtr<X3aColorMatrixResult>
 X3aResultFactory::create_rgb2yuv_colormatrix (XCam3aResultColorMatrix *from)
 {
     XCAM_3A_RESULT_FACTORY (X3aColorMatrixResult, XCAM_3A_RESULT_RGB2YUV_MATRIX, from);
 }

 SmartPtr<X3aColorMatrixResult>
 X3aResultFactory::create_yuv2rgb_colormatrix (XCam3aResultColorMatrix *from)
 {
     XCAM_3A_RESULT_FACTORY (X3aColorMatrixResult, XCAM_3A_RESULT_YUV2RGB_MATRIX, from);
 }

 SmartPtr<X3aExposureResult>
 X3aResultFactory::create_exposure (XCam3aResultExposure *from)
 {
     XCAM_3A_RESULT_FACTORY (X3aExposureResult, XCAM_3A_RESULT_EXPOSURE, from);
 }

 SmartPtr<X3aFocusResult>
 X3aResultFactory::create_focus (XCam3aResultFocus *from)
 {
     XCAM_3A_RESULT_FACTORY (X3aFocusResult, XCAM_3A_RESULT_FOCUS, from);
 }

 SmartPtr<X3aDemosaicResult>
 X3aResultFactory::create_demosaicing (XCam3aResultDemosaic *from)
 {
     XCAM_3A_RESULT_FACTORY (X3aDemosaicResult, XCAM_3A_RESULT_DEMOSAIC, from);
 }

 SmartPtr<X3aDefectPixelResult>
 X3aResultFactory::create_defectpixel (XCam3aResultDefectPixel *from)
 {
     XCAM_3A_RESULT_FACTORY (X3aDefectPixelResult, XCAM_3A_RESULT_DEFECT_PIXEL_CORRECTION, from);
 }

 SmartPtr<X3aNoiseReductionResult>
 X3aResultFactory::create_noise_reduction (XCam3aResultNoiseReduction *from)
 {
     XCAM_3A_RESULT_FACTORY (X3aNoiseReductionResult, XCAM_3A_RESULT_NOISE_REDUCTION, from);
 }

 SmartPtr<X3aTemporalNoiseReduction>
 X3aResultFactory::create_3d_noise_reduction (XCam3aResultTemporalNoiseReduction *from)
 {
     XCAM_3A_RESULT_FACTORY (X3aTemporalNoiseReduction, XCAM_3A_RESULT_3D_NOISE_REDUCTION, from);
 }

 SmartPtr<X3aTemporalNoiseReduction>
 X3aResultFactory::create_yuv_temp_noise_reduction (XCam3aResultTemporalNoiseReduction *from)
 {
     XCAM_3A_RESULT_FACTORY (X3aTemporalNoiseReduction, XCAM_3A_RESULT_TEMPORAL_NOISE_REDUCTION_YUV, from);
 }

 SmartPtr<X3aEdgeEnhancementResult>
 X3aResultFactory::create_edge_enhancement (XCam3aResultEdgeEnhancement *from)
 {
     XCAM_3A_RESULT_FACTORY (X3aEdgeEnhancementResult, XCAM_3A_RESULT_EDGE_ENHANCEMENT, from);
 }

 SmartPtr<X3aGammaTableResult>
 X3aResultFactory::create_y_gamma_table (XCam3aResultGammaTable *from)
 {
     XCAM_3A_RESULT_FACTORY (X3aGammaTableResult, XCAM_3A_RESULT_Y_GAMMA, from);
 }

 SmartPtr<X3aGammaTableResult>
 X3aResultFactory::create_r_gamma_table (XCam3aResultGammaTable *from)
 {
     XCAM_3A_RESULT_FACTORY (X3aGammaTableResult, XCAM_3A_RESULT_R_GAMMA, from);
 }

 SmartPtr<X3aGammaTableResult>
 X3aResultFactory::create_g_gamma_table (XCam3aResultGammaTable *from)
 {
     XCAM_3A_RESULT_FACTORY (X3aGammaTableResult, XCAM_3A_RESULT_G_GAMMA, from);
 }

 SmartPtr<X3aGammaTableResult>
 X3aResultFactory::create_b_gamma_table (XCam3aResultGammaTable *from)
 {
     XCAM_3A_RESULT_FACTORY (X3aGammaTableResult, XCAM_3A_RESULT_B_GAMMA, from);
 }

 SmartPtr<X3aMaccMatrixResult>
 X3aResultFactory::create_macc (XCam3aResultMaccMatrix *from)
 {
     XCAM_3A_RESULT_FACTORY (X3aMaccMatrixResult, XCAM_3A_RESULT_MACC, from);
 }

 SmartPtr<X3aChromaToneControlResult>
 X3aResultFactory::create_chroma_tone_control (XCam3aResultChromaToneControl *from)
 {
     XCAM_3A_RESULT_FACTORY (X3aChromaToneControlResult, XCAM_3A_RESULT_CHROMA_TONE_CONTROL, from);
 }

 SmartPtr<X3aBayerNoiseReduction>
 X3aResultFactory::create_bayer_noise_reduction (XCam3aResultBayerNoiseReduction *from)
 {
     XCAM_3A_RESULT_FACTORY (X3aBayerNoiseReduction, XCAM_3A_RESULT_BAYER_NOISE_REDUCTION, from);
 }

 SmartPtr<X3aBrightnessResult>
 X3aResultFactory::create_brightness (XCam3aResultBrightness *from)
 {
     XCAM_3A_RESULT_FACTORY (X3aBrightnessResult, XCAM_3A_RESULT_BRIGHTNESS, from);
 }

 SmartPtr<X3aWaveletNoiseReduction>
 X3aResultFactory::create_wavelet_noise_reduction (XCam3aResultWaveletNoiseReduction *from)
 {
     XCAM_3A_RESULT_FACTORY (X3aWaveletNoiseReduction, XCAM_3A_RESULT_WAVELET_NOISE_REDUCTION, from);
 }

 SmartPtr<X3aFaceDetectionResult>
 X3aResultFactory::create_face_detection (XCamFDResult *from)
 {
     uint32_t type = xcam_3a_result_type (from);
     if (type != XCAM_3A_RESULT_FACE_DETECTION) {
         XCAM_ASSERT (false);
         XCAM_LOG_WARNING ("X3aResultFactory create face detection failed with wrong type");
     }

     X3aFaceDetectionResult *fd_res = new X3aFaceDetectionResult (
         XCAM_3A_RESULT_FACE_DETECTION,
         from->head.process_type,
         from->face_num * sizeof (XCamFaceInfo));
     fd_res->set_standard_result (*from);

     return fd_res;
 }

 SmartPtr<X3aDVSResult>
 X3aResultFactory::create_digital_video_stabilizer (XCamDVSResult *from)
 {
     XCAM_3A_RESULT_FACTORY (X3aDVSResult, XCAM_3A_RESULT_DVS, from);
 }
 };
	/*
	* x3a_result_factory.cpp - 3A result factory
	*
	* Copyright (c) 2015 Intel Corporation
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	* Author: Wind Yuan <feng.yuan@intel.com>
	*/

	#include "x3a_result_factory.h"

	namespace XCam {

	#define XCAM_3A_RESULT_FACTORY(DataType, res_type, from) \
	DataType *ret = \
	new DataType (res_type); \
	if (from) { \
	uint32_t type = xcam_3a_result_type (from); \
	if (type != XCAM_3A_RESULT_NULL && type != res_type) { \
	XCAM_ASSERT (false); \
	XCAM_LOG_WARNING ("create result from wrong type:%d to type:%d", type, res_type); \
	} \
	ret->set_standard_result (*from); \
	} \
	return ret;


	Mutex X3aResultFactory::_mutex;
	SmartPtr<X3aResultFactory> X3aResultFactory::_instance (NULL);

	SmartPtr<X3aResultFactory>
	X3aResultFactory::instance ()
	{
	SmartLock locker (_mutex);
	if (_instance.ptr ())
	return _instance;

	_instance = new X3aResultFactory;
	return _instance;
	}

	X3aResultFactory::X3aResultFactory ()
	{
	}

	X3aResultFactory::~X3aResultFactory ()
	{
	}

	SmartPtr<X3aResult>
	X3aResultFactory::create_3a_result (XCam3aResultHead *from)
	{
	SmartPtr<X3aResult> result (NULL);

	XCAM_ASSERT (from);
	if (!from)
	return result;

	uint32_t type = xcam_3a_result_type (from);

	switch (type) {
	case XCAM_3A_RESULT_WHITE_BALANCE:
	result = create_whitebalance ((XCam3aResultWhiteBalance*)from);
	break;
	case XCAM_3A_RESULT_BLACK_LEVEL:
	result = create_blacklevel ((XCam3aResultBlackLevel*)from);
	break;
	case XCAM_3A_RESULT_YUV2RGB_MATRIX:
	result = create_yuv2rgb_colormatrix ((XCam3aResultColorMatrix*)from);
	break;
	case XCAM_3A_RESULT_RGB2YUV_MATRIX:
	result = create_rgb2yuv_colormatrix ((XCam3aResultColorMatrix*)from);
	break;
	case XCAM_3A_RESULT_EXPOSURE:
	result = create_exposure ((XCam3aResultExposure*)from);
	break;
	case XCAM_3A_RESULT_FOCUS:
	result = create_focus ((XCam3aResultFocus*)from);
	break;
	case XCAM_3A_RESULT_DEMOSAIC:
	result = create_demosaicing ((XCam3aResultDemosaic*)from);
	break;
	case XCAM_3A_RESULT_DEFECT_PIXEL_CORRECTION:
	result = create_defectpixel ((XCam3aResultDefectPixel*)from);
	break;
	case XCAM_3A_RESULT_NOISE_REDUCTION:
	result = create_noise_reduction ((XCam3aResultNoiseReduction*)from);
	break;
	case XCAM_3A_RESULT_3D_NOISE_REDUCTION:
	result = create_3d_noise_reduction ((XCam3aResultTemporalNoiseReduction*)from);
	break;
	case XCAM_3A_RESULT_TEMPORAL_NOISE_REDUCTION_YUV:
	result = create_yuv_temp_noise_reduction ((XCam3aResultTemporalNoiseReduction*)from);
	break;
	case XCAM_3A_RESULT_EDGE_ENHANCEMENT:
	result = create_edge_enhancement ((XCam3aResultEdgeEnhancement*)from);
	break;
	case XCAM_3A_RESULT_MACC:
	result = create_macc ((XCam3aResultMaccMatrix*)from);
	break;
	case XCAM_3A_RESULT_CHROMA_TONE_CONTROL:
	result = create_chroma_tone_control ((XCam3aResultChromaToneControl*)from);
	break;
	case XCAM_3A_RESULT_Y_GAMMA:
	result = create_y_gamma_table ((XCam3aResultGammaTable*)from);
	break;
	case XCAM_3A_RESULT_R_GAMMA:
	result = create_r_gamma_table ((XCam3aResultGammaTable*)from);
	break;
	case XCAM_3A_RESULT_G_GAMMA:
	result = create_g_gamma_table ((XCam3aResultGammaTable*)from);
	break;
	case XCAM_3A_RESULT_B_GAMMA:
	result = create_b_gamma_table ((XCam3aResultGammaTable*)from);
	break;
	case XCAM_3A_RESULT_BAYER_NOISE_REDUCTION:
	result = create_bayer_noise_reduction ((XCam3aResultBayerNoiseReduction*)from);
	break;
	case XCAM_3A_RESULT_BRIGHTNESS:
	result = create_brightness ((XCam3aResultBrightness*)from);
	break;
	case XCAM_3A_RESULT_WAVELET_NOISE_REDUCTION:
	result = create_wavelet_noise_reduction ((XCam3aResultWaveletNoiseReduction*)from);
	break;
	case XCAM_3A_RESULT_FACE_DETECTION:
	result = create_face_detection ((XCamFDResult*)from);
	break;
	case XCAM_3A_RESULT_DVS:
	result = create_digital_video_stabilizer ((XCamDVSResult*)from);
	break;
	default:
	XCAM_LOG_WARNING ("create 3a result with unknown result type:%d", type);
	break;
	}

	return result;
	}

	SmartPtr<X3aWhiteBalanceResult>
	X3aResultFactory::create_whitebalance (XCam3aResultWhiteBalance *from)
	{
	XCAM_3A_RESULT_FACTORY (X3aWhiteBalanceResult, XCAM_3A_RESULT_WHITE_BALANCE, from);
	}

	SmartPtr<X3aBlackLevelResult>
	X3aResultFactory::create_blacklevel (XCam3aResultBlackLevel *from)
	{
	XCAM_3A_RESULT_FACTORY (X3aBlackLevelResult, XCAM_3A_RESULT_BLACK_LEVEL, from);
	}

	SmartPtr<X3aColorMatrixResult>
	X3aResultFactory::create_rgb2yuv_colormatrix (XCam3aResultColorMatrix *from)
	{
	XCAM_3A_RESULT_FACTORY (X3aColorMatrixResult, XCAM_3A_RESULT_RGB2YUV_MATRIX, from);
	}

	SmartPtr<X3aColorMatrixResult>
	X3aResultFactory::create_yuv2rgb_colormatrix (XCam3aResultColorMatrix *from)
	{
	XCAM_3A_RESULT_FACTORY (X3aColorMatrixResult, XCAM_3A_RESULT_YUV2RGB_MATRIX, from);
	}

	SmartPtr<X3aExposureResult>
	X3aResultFactory::create_exposure (XCam3aResultExposure *from)
	{
	XCAM_3A_RESULT_FACTORY (X3aExposureResult, XCAM_3A_RESULT_EXPOSURE, from);
	}

	SmartPtr<X3aFocusResult>
	X3aResultFactory::create_focus (XCam3aResultFocus *from)
	{
	XCAM_3A_RESULT_FACTORY (X3aFocusResult, XCAM_3A_RESULT_FOCUS, from);
	}

	SmartPtr<X3aDemosaicResult>
	X3aResultFactory::create_demosaicing (XCam3aResultDemosaic *from)
	{
	XCAM_3A_RESULT_FACTORY (X3aDemosaicResult, XCAM_3A_RESULT_DEMOSAIC, from);
	}

	SmartPtr<X3aDefectPixelResult>
	X3aResultFactory::create_defectpixel (XCam3aResultDefectPixel *from)
	{
	XCAM_3A_RESULT_FACTORY (X3aDefectPixelResult, XCAM_3A_RESULT_DEFECT_PIXEL_CORRECTION, from);
	}

	SmartPtr<X3aNoiseReductionResult>
	X3aResultFactory::create_noise_reduction (XCam3aResultNoiseReduction *from)
	{
	XCAM_3A_RESULT_FACTORY (X3aNoiseReductionResult, XCAM_3A_RESULT_NOISE_REDUCTION, from);
	}

	SmartPtr<X3aTemporalNoiseReduction>
	X3aResultFactory::create_3d_noise_reduction (XCam3aResultTemporalNoiseReduction *from)
	{
	XCAM_3A_RESULT_FACTORY (X3aTemporalNoiseReduction, XCAM_3A_RESULT_3D_NOISE_REDUCTION, from);
	}

	SmartPtr<X3aTemporalNoiseReduction>
	X3aResultFactory::create_yuv_temp_noise_reduction (XCam3aResultTemporalNoiseReduction *from)
	{
	XCAM_3A_RESULT_FACTORY (X3aTemporalNoiseReduction, XCAM_3A_RESULT_TEMPORAL_NOISE_REDUCTION_YUV, from);
	}

	SmartPtr<X3aEdgeEnhancementResult>
	X3aResultFactory::create_edge_enhancement (XCam3aResultEdgeEnhancement *from)
	{
	XCAM_3A_RESULT_FACTORY (X3aEdgeEnhancementResult, XCAM_3A_RESULT_EDGE_ENHANCEMENT, from);
	}

	SmartPtr<X3aGammaTableResult>
	X3aResultFactory::create_y_gamma_table (XCam3aResultGammaTable *from)
	{
	XCAM_3A_RESULT_FACTORY (X3aGammaTableResult, XCAM_3A_RESULT_Y_GAMMA, from);
	}

	SmartPtr<X3aGammaTableResult>
	X3aResultFactory::create_r_gamma_table (XCam3aResultGammaTable *from)
	{
	XCAM_3A_RESULT_FACTORY (X3aGammaTableResult, XCAM_3A_RESULT_R_GAMMA, from);
	}

	SmartPtr<X3aGammaTableResult>
	X3aResultFactory::create_g_gamma_table (XCam3aResultGammaTable *from)
	{
	XCAM_3A_RESULT_FACTORY (X3aGammaTableResult, XCAM_3A_RESULT_G_GAMMA, from);
	}

	SmartPtr<X3aGammaTableResult>
	X3aResultFactory::create_b_gamma_table (XCam3aResultGammaTable *from)
	{
	XCAM_3A_RESULT_FACTORY (X3aGammaTableResult, XCAM_3A_RESULT_B_GAMMA, from);
	}

	SmartPtr<X3aMaccMatrixResult>
	X3aResultFactory::create_macc (XCam3aResultMaccMatrix *from)
	{
	XCAM_3A_RESULT_FACTORY (X3aMaccMatrixResult, XCAM_3A_RESULT_MACC, from);
	}

	SmartPtr<X3aChromaToneControlResult>
	X3aResultFactory::create_chroma_tone_control (XCam3aResultChromaToneControl *from)
	{
	XCAM_3A_RESULT_FACTORY (X3aChromaToneControlResult, XCAM_3A_RESULT_CHROMA_TONE_CONTROL, from);
	}

	SmartPtr<X3aBayerNoiseReduction>
	X3aResultFactory::create_bayer_noise_reduction (XCam3aResultBayerNoiseReduction *from)
	{
	XCAM_3A_RESULT_FACTORY (X3aBayerNoiseReduction, XCAM_3A_RESULT_BAYER_NOISE_REDUCTION, from);
	}

	SmartPtr<X3aBrightnessResult>
	X3aResultFactory::create_brightness (XCam3aResultBrightness *from)
	{
	XCAM_3A_RESULT_FACTORY (X3aBrightnessResult, XCAM_3A_RESULT_BRIGHTNESS, from);
	}

	SmartPtr<X3aWaveletNoiseReduction>
	X3aResultFactory::create_wavelet_noise_reduction (XCam3aResultWaveletNoiseReduction *from)
	{
	XCAM_3A_RESULT_FACTORY (X3aWaveletNoiseReduction, XCAM_3A_RESULT_WAVELET_NOISE_REDUCTION, from);
	}

	SmartPtr<X3aFaceDetectionResult>
	X3aResultFactory::create_face_detection (XCamFDResult *from)
	{
	uint32_t type = xcam_3a_result_type (from);
	if (type != XCAM_3A_RESULT_FACE_DETECTION) {
	XCAM_ASSERT (false);
	XCAM_LOG_WARNING ("X3aResultFactory create face detection failed with wrong type");
	}

	X3aFaceDetectionResult *fd_res = new X3aFaceDetectionResult (
	XCAM_3A_RESULT_FACE_DETECTION,
	from->head.process_type,
	from->face_num * sizeof (XCamFaceInfo));
	fd_res->set_standard_result (*from);

	return fd_res;
	}

	SmartPtr<X3aDVSResult>
	X3aResultFactory::create_digital_video_stabilizer (XCamDVSResult *from)
	{
	XCAM_3A_RESULT_FACTORY (X3aDVSResult, XCAM_3A_RESULT_DVS, from);
	}
	};