cam_msg_handler.c

MTK6225 支持的200W像素的代码

        ext_cam_stop_preview();
    #endif /* __MTK_TARGET__ */
        CAM_ENTER_STATE(CAM_READY);
    }

    if (!CAM_IN_STATE(CAM_IDLE))
    {
        CAM_FREE_CAPTURE_BUFFER();
        med_stop_timer(CAM_POWER_UP_TIMER);
#if 0 //modified by ycd for ext dsp 2008.07.01
        if (req_p->delay_time > 0)
        {
            /* cam_context_p->delay_power_down=KAL_TRUE; */
            med_start_timer(CAM_POWER_DOWN_DELAY_TIMER, req_p->delay_time, cam_power_down, 0);
        }
        else
#endif
        {
            cam_power_down(0);
        }
    }
	SIMC_CAM_PRITNF(POWER DOWN REQ COMPLETE);
}


/*****************************************************************************
 * FUNCTION
 *  cam_preview_check
 * DESCRIPTION
 *  This function is to check the preview state.
 * PARAMETERS
 *  arg     [?]
 * RETURNS
 *  void
 *****************************************************************************/
void cam_preview_check(void *arg)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
	//SIMC_CAM_PRITNF(CAM PREVIEW CHECK);
    switch (cam_context_p->state)
    {
        case CAM_START_PREVIEW:
	     //dump_printf("%s, %d", __FILE__, __LINE__);
            if (ext_cam_is_preview_ready())
            {
                /* preview ok */
                CAM_ENTER_STATE(CAM_PREVIEW);
                CAM_SET_EVENT(CAM_EVT_PREVIEW);
            }
            else
            {
                CAM_VALUE_TRACE(cam_context_p->preview_retry_conut, cam_context_p->preview_check_conut, -1);
                /* preview fail, retry */
                cam_context_p->preview_check_conut++;
                if (cam_context_p->preview_check_conut > MAX_PREVIEW_CHECK_COUNT)
                {
                    if (cam_context_p->preview_retry_conut > MAX_PREVIEW_RETRY_COUNT)
                    {
                        /* preview really fail, return to MMI */
                        ext_cam_stop_preview();
                        ext_cam_power_off();
                    #ifdef CAMERA_MODULE_WITH_LCD
			#if (defined(__LCD_UPDATE_BY_LCDCONTROLER__))
                        if (cam_context_p->osd_buffer_p)
                        {
                            med_free_ext_mem((void **)&cam_context_p->osd_buffer_p);
                        }
			#endif//end #if (defined(__LCD_UPDATE_BY_LCDCONTROLER__))
                    #endif /* CAMERA_MODULE_WITH_LCD */
                        /* to release the memory allocated in MED_MODE_BUFFER mode */
                        CAM_FREE_CAPTURE_BUFFER();
                        cam_set_result(MED_RES_FAIL);
                        CAM_ENTER_STATE(CAM_IDLE);
                        CAM_SET_EVENT(CAM_EVT_PREVIEW);
                        break;
                    }
                    else
                    {
                        ext_cam_power_off();
                    #ifdef CAMERA_MODULE_WITH_LCD
			#if (defined(__LCD_UPDATE_BY_LCDCONTROLER__))
                        if (cam_context_p->osd_buffer_p)
                        {
                            med_free_ext_mem((void **)&cam_context_p->osd_buffer_p);
                        }
			#endif//end #if (defined(__LCD_UPDATE_BY_LCDCONTROLER__))
                    #endif /* CAMERA_MODULE_WITH_LCD */
                        ext_cam_power_on();
                        cam_context_p->power_up_check_conut = 0;
                        med_start_timer(CAM_POWER_UP_TIMER, CAM_POWER_UP_INIT_TIME, cam_power_up_check, 0);
                        break;
                    }
                }

            }
            med_start_timer(CAM_READY_POLLING_TIMER, CAM_PREVIEW_POLLING_TIME, cam_preview_check, 0);
            break;

        case CAM_PREVIEW:
            ext_cam_is_preview_ready();
            med_start_timer(CAM_READY_POLLING_TIMER, CAM_PREVIEW_POLLING_TIME, cam_preview_check, 0);
            break;
        default:
            break;

    }
	//SIMC_CAM_PRITNF(CAM PREVIEW CHECK COM);
}


/*****************************************************************************
 * FUNCTION
 *  cam_preview_req_hdlr
 * DESCRIPTION
 *  This function is to handle camera preview request.
 * PARAMETERS
 *  ilm_ptr     [?]
 * RETURNS
 *  void
 *****************************************************************************/
void cam_preview_req_hdlr_dsp(ilm_struct *ilm_ptr)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    media_cam_preview_req_struct *req_p;

	SIMC_CAM_PRITNF(CAM_PREVIEW REQ);
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    cam_context_p->src_mod = ilm_ptr->src_mod_id;

    if (CAM_IN_STATE(CAM_READY))
    {
    #ifdef __MTK_TARGET__

        req_p = (media_cam_preview_req_struct*) ilm_ptr->local_para_ptr;
        cam_param.image_width = req_p->image_width;
        cam_param.image_height = req_p->image_height;

        cam_param.buffer_width = req_p->buffer_width;
        cam_param.buffer_height = req_p->buffer_height;
        cam_param.preview_width = cam_context_p->preview_width = req_p->preview_width;
        cam_param.preview_height = cam_context_p->preview_height = req_p->preview_height;
        cam_param.preview_offset_x = req_p->preview_offset_x;
        cam_param.preview_offset_y = req_p->preview_offset_y;
        cam_param.white_balance_mode1 = (kal_uint8) req_p->WB/*cam_wb_param_map[req_p->WB]*/;  //HuangYi, 2007-08-09
        cam_param.ev_value = (kal_uint8) req_p->exposure/*cam_ev_param_map[req_p->exposure]*/; //HuangYi, 2007-08-09
        cam_param.image_effect1 = (kal_uint8) req_p->effect/*cam_effect_param_map[req_p->effect]*/; //HuangYi, 2007-08-09 
    #ifdef CAMERA_MODULE_WITH_LCD
        cam_param.image_buffer_ptr = (kal_uint16*) cam_context_p->osd_buffer_p;
        cam_param.image_buffer_size = LCD_WIDTH * LCD_HEIGHT * 2;
    #else /* CAMERA_MODULE_WITH_LCD */
        cam_param.image_buffer_ptr = req_p->image_buffer_p;
    #endif /* CAMERA_MODULE_WITH_LCD */
        cam_param.preview_rotate = req_p->rotate;
        cam_param.banding_freq = (kal_uint8) req_p->banding_freq/*cam_banding_param_map[req_p->banding_freq]*/; //HuangYi, 2007-08-09 
        cam_param.snapshot_number = req_p->snapshot_number;
        cam_param.src_key_color = req_p->src_key_color;
        cam_param.zoom_factor = req_p->zoom_factor;
        cam_param.video_rec_mode = KAL_FALSE;   /* camera preview */
		
    #if defined(__CAM_AUTO_FOCUS__)
	 cam_param.cam_focus_cb = cam_focus_callback;
    #else
	 cam_param.cam_focus_cb = NULL;
    #endif

        lcd_param.module_id = LCD_UPDATE_MODULE_MEDIA;
        lcd_param.lcd_id = req_p->lcd_id;
        lcd_param.fb_update_mode = LCD_SW_TRIGGER_MODE;
        lcd_param.lcm_start_x = req_p->lcd_start_x;
        lcd_param.lcm_start_y = req_p->lcd_start_y;
        lcd_param.lcm_end_x = req_p->lcd_end_x;
        lcd_param.lcm_end_y = req_p->lcd_end_y;
        lcd_param.roi_offset_x = req_p->roi_offset_x;
        lcd_param.roi_offset_y = req_p->roi_offset_y;
        lcd_param.update_layer = req_p->update_layer;
        lcd_param.hw_update_layer = 0;

        cam_context_p->preview_check_conut = 0;
        cam_context_p->preview_retry_conut = 0;
        cam_context_p->zoom_factor = req_p->zoom_factor;
        cam_context_p->flash_mode = req_p->flash_mode;
        cam_context_p->night_mode = req_p->night_mode;
 //       cam_set_night_mode((kal_int16) cam_context_p->night_mode);
        ext_cam_start_preview(&cam_param, &lcd_param);
        //cam_set_zoom_factor(cam_context_p->zoom_factor);
 //       cam_set_flash(cam_context_p->flash_mode);
    #if defined(VC0558)
        cam_context_p->image_effect = req_p->effect;
        cam_set_effect(cam_context_p->image_effect);
    #endif /* defined(VC0558) */
	
        med_start_timer(CAM_READY_POLLING_TIMER, CAM_PREVIEW_INIT_TIME, cam_preview_check, 0);
    #endif /* __MTK_TARGET__ */
        CAM_ENTER_STATE(CAM_START_PREVIEW);
        cam_set_result(MED_RES_OK);
    }
    else if (CAM_IN_STATE(CAM_PREVIEW))
    {
        med_start_timer(CAM_READY_POLLING_TIMER, CAM_PREVIEW_POLLING_TIME, cam_preview_check, 0);
        CAM_SET_EVENT(CAM_EVT_PREVIEW);
    }
    else
    {
        cam_set_result(MED_RES_BUSY);
        CAM_SET_EVENT(CAM_EVT_PREVIEW);
    }
	SIMC_CAM_PRITNF(CAM PREVIEW REQ COM);
}


/*****************************************************************************
 * FUNCTION
 *  cam_stop_req_hdlr
 * DESCRIPTION
 *  This function is to handle camera stop request.
 * PARAMETERS
 *  ilm_ptr     [?]
 * RETURNS
 *  void
 *****************************************************************************/
void cam_stop_req_hdlr_dsp(ilm_struct *ilm_ptr)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
	SIMC_CAM_PRITNF(CAM STOP REQ);
    cam_context_p->src_mod = ilm_ptr->src_mod_id;

    if (CAM_IN_STATE(CAM_PREVIEW))
    {
    #ifdef __MTK_TARGET__
        med_stop_timer(CAM_READY_POLLING_TIMER);
        ext_cam_stop_preview();
    #endif /* __MTK_TARGET__ */
        CAM_ENTER_STATE(CAM_READY);
    }
    CAM_SET_EVENT(CAM_EVT_STOP);
	SIMC_CAM_PRITNF(CAM STOP REQ COM);

}


/*****************************************************************************
 * FUNCTION
 *  cam_capture_check
 * DESCRIPTION
 *  This function is to check the capture state.
 * PARAMETERS
 *  arg     [?]
 * RETURNS
 *  void
 *****************************************************************************/
void cam_capture_check(void *arg)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_uint32 file_size;
    kal_int32 res;

	SIMC_CAM_PRITNF(CAM CAPTURE CHECK);
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (!CAM_IN_STATE(CAM_CAPTURE))
    {
        return;
    }
    if (((file_size = ext_cam_get_capture_size()) != NULL_JPEG_FILE) &&
         (file_size >= MIN_JPG_FILE_SIZE))
    {
        if (cam_context_p->media_mode == MED_MODE_FILE)
        {
            res = cam_close_image_file(file_size);
            cam_set_result(res);
        }
        else if (cam_context_p->media_mode == MED_MODE_BUFFER)
        {
            *(cam_context_p->file_size_p) = file_size;
            *(cam_context_p->capture_buffer_pp) = (void*)cam_context_p->capture_buffer_p;
            cam_set_result(MED_RES_OK);
        }
        else
        {
            *(cam_context_p->file_size_p) = file_size;
            cam_set_result(MED_RES_OK);
        }
        CAM_ENTER_STATE(CAM_READY);
        CAM_SET_EVENT(CAM_EVT_CAPTURE);
    }
    else if (file_size < MIN_JPG_FILE_SIZE || cam_context_p->capture_check_conut > MAX_CAPTURE_CHECK_COUNT)
    {
        ext_cam_power_off();
    #ifdef CAMERA_MODULE_WITH_LCD
	#if (defined(__LCD_UPDATE_BY_LCDCONTROLER__))
        if (cam_context_p->osd_buffer_p)
        {
            med_free_ext_mem((void **)&cam_context_p->osd_buffer_p);
        }
	#endif//end #if (defined(__LCD_UPDATE_BY_LCDCONTROLER__))
    #endif /* CAMERA_MODULE_WITH_LCD */
        /* to release the memory allocated in MED_MODE_BUFFER mode */
        CAM_FREE_CAPTURE_BUFFER();
        if (cam_context_p->media_mode == MED_MODE_FILE)
        {
            cam_close_image_file(0);
        }
	if(ext_cam_get_last_error(ERROR_INFO_MOD_CAMERA_CAPTURE) == SIMC_CAM_RET_CAPTURE_BUFFER_FLOW)
	{
		res = MED_RES_BUFFER_INSUFFICIENT;
	}
	else
	{
	        res = MED_RES_FAIL;
	}
        cam_set_result(MED_RES_FAIL);
        CAM_ENTER_STATE(CAM_IDLE);
        CAM_SET_EVENT(CAM_EVT_CAPTURE);
    }
    else
    {
        cam_context_p->capture_check_conut++;
        med_start_timer(CAM_READY_POLLING_TIMER, CAM_CAPTURE_POLLING_TIME, cam_capture_check, 0);
    }
	SIMC_CAM_PRITNF(CAPTURE CHECK COM);
}


/*****************************************************************************
 * FUNCTION
 *  cam_capture_req_hdlr
 * DESCRIPTION
 *  This function is to handle camera capture request.
 * PARAMETERS
 *  ilm_ptr     [?]
 * RETURNS
 *  void
 *****************************************************************************/
void cam_capture_req_hdlr_dsp(ilm_struct *ilm_ptr)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    media_cam_capture_req_struct *req_p;
    ext_camera_para_struct cam_param;
    kal_int32 result = MED_RES_OK;

	SIMC_CAM_PRITNF(CAM CAPTURE REQ);
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    cam_context_p->src_mod = ilm_ptr->src_mod_id;

    req_p = (media_cam_capture_req_struct*) ilm_ptr->local_para_ptr;

    if (CAM_IN_STATE(CAM_PREVIEW))
    {
        cam_context_p->media_mode = req_p->media_mode;
        if (req_p->media_mode == MED_MODE_FILE)
        {
            kal_uint32 file_buffer_size;

            if (req_p->source_device == CAM_SRC_ISP)
            {
            #if (defined(__BAR_HI03__) || defined(__BAR_HI06__) || defined(__BAR_G35__))
		file_buffer_size=600*1024;
	     #else
              file_buffer_size = MAX_CAM_FILE_BUFFER_LEN;
	     #endif
            }
            else
            {
                file_buffer_size = 600*1024;   /* MAX_IMG_ENC_FILE_BUFFER_LEN; */
            }

            cam_param.image_width = img_context_p->image_width = req_p->image_width;
            cam_param.image_height = img_context_p->image_height = req_p->image_height;
            cam_param.jpeg_compression_ratio = cam_context_p->image_quality =
                req_p->image_quality;//(kal_uint8) cam_jpg_qty_param_map[req_p->image_quality];
            cam_param.image_buffer_size = file_buffer_size;
            cam_param.snapshot_number = req_p->snapshot_number;
            cam_param.continue_capture = req_p->continue_capture;
            if (cam_param.snapshot_number > 1 && req_p->jpegs_p != NULL)
            {
                ASSERT(cam_param.snapshot_number > 1 && req_p->jpegs_p != NULL)
                    cam_param.burst_capture_ptr = (ext_camera_burst_struct*) req_p->jpegs_p;
            }

            /* stop preview timer */
            med_stop_timer(CAM_READY_POLLING_TIMER);
            if ((result = cam_open_image_file((kal_wchar*) req_p->data, file_buffer_size)) == MED_RES_OK)
            {
                if (req_p->source_device == CAM_SRC_ISP)