cam_msg_handler.c

最新MTK手机软件源码

            cam_context_p->power_up_check_conut++;
            if (cam_context_p->power_up_check_conut > MAX_POWER_UP_CHECK_COUNT)
            {
                /* to release the memory allocated in MED_MODE_BUFFER mode */
                CAM_FREE_CAPTURE_BUFFER();
                /* preview really fail, return to MMI */
                cam_set_result(MED_RES_FAIL);
                CAM_ENTER_STATE(CAM_IDLE);
                CAM_SET_EVENT(CAM_EVT_PREVIEW);
            }
            else
            {
            #ifdef CAMERA_MODULE_WITH_LCD
                cam_context_p->osd_buffer_p = (kal_uint32) med_alloc_ext_mem(LCD_WIDTH * LCD_HEIGHT * 2);
                if (cam_context_p->osd_buffer_p)
                {
                    ext_camera_set_osd_buffer(cam_context_p->osd_buffer_p, LCD_WIDTH * LCD_HEIGHT * 2);
                }
            #endif /* CAMERA_MODULE_WITH_LCD */ 
                ext_camera_power_on();
                med_start_timer(CAM_POWER_UP_TIMER, CAM_POWER_UP_INIT_TIME, cam_power_up_check, 0);
            }
        }
    }
#ifdef __MED_MJPG_MOD__
    else if (VID_IN_STATE(VID_START_PREVIEW))
    {
        if (ext_camera_reset_status())
        {
            cam_context_p->preview_check_conut = 0;
            cam_context_p->preview_retry_conut++;
            cam_set_night_mode((kal_int16) cam_context_p->night_mode);
            ext_camera_preview(&cam_param, &lcd_param);
            cam_set_zoom_factor(cam_context_p->zoom_factor);
            cam_set_flash(cam_context_p->flash_mode);
            med_start_timer(CAM_READY_POLLING_TIMER, CAM_PREVIEW_POLLING_TIME, vid_preview_check, 0);
        }
        else
        {
            ext_camera_power_off();
        #ifdef CAMERA_MODULE_WITH_LCD
            if (cam_context_p->osd_buffer_p)
            {
                med_free_ext_mem((void **)&cam_context_p->osd_buffer_p);
            }
        #endif /* CAMERA_MODULE_WITH_LCD */ 
            cam_context_p->power_up_check_conut++;
            if (cam_context_p->power_up_check_conut > MAX_POWER_UP_CHECK_COUNT)
            {
                /* preview really fail, return to MMI */
                vid_set_result(MED_RES_FAIL);
                VID_ENTER_STATE(VID_IDLE);
                CAM_ENTER_STATE(CAM_IDLE);
                VID_SET_EVENT(VID_EVT_PREVIEW);
            }
            else
            {
            #ifdef CAMERA_MODULE_WITH_LCD
                cam_context_p->osd_buffer_p = (kal_uint32) med_alloc_ext_mem(LCD_WIDTH * LCD_HEIGHT * 2);
                if (cam_context_p->osd_buffer_p)
                {
                    ext_camera_set_osd_buffer(cam_context_p->osd_buffer_p, LCD_WIDTH * LCD_HEIGHT * 2);
                }
            #endif /* CAMERA_MODULE_WITH_LCD */ 
                ext_camera_power_on();
                med_start_timer(CAM_POWER_UP_TIMER, CAM_POWER_UP_INIT_TIME, cam_power_up_check, 0);
            }
        }
    }

#endif /* __MED_MJPG_MOD__ */ 

}


/*****************************************************************************
 * FUNCTION
 *  cam_power_up_req_hdlr
 * DESCRIPTION
 *  This function is to handle power up request.
 * PARAMETERS
 *  ilm_ptr     [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void cam_power_up_req_hdlr(ilm_struct *ilm_ptr)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    media_cam_power_up_req_struct *req_p;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    cam_context_p->src_mod = ilm_ptr->src_mod_id;

    req_p = (media_cam_power_up_req_struct*) ilm_ptr->local_para_ptr;

    cam_context_p->seq_num = req_p->seq_num;

    if (CAM_IN_STATE(CAM_IDLE))
    {
        cam_context_p->power_up_check_conut = 0;
    #ifdef __MTK_TARGET__
    #ifdef CAMERA_MODULE_WITH_LCD
        cam_context_p->osd_buffer_p = (kal_uint32) med_alloc_ext_mem(LCD_WIDTH * LCD_HEIGHT * 2);
        if (cam_context_p->osd_buffer_p)
        {
            ext_camera_set_osd_buffer(cam_context_p->osd_buffer_p, LCD_WIDTH * LCD_HEIGHT * 2);
        }
    #endif /* CAMERA_MODULE_WITH_LCD */ 
        ext_camera_power_on();
        med_start_timer(CAM_POWER_UP_TIMER, CAM_POWER_UP_INIT_TIME, cam_power_up_check, 0);
    #endif /* __MTK_TARGET__ */ 

        CAM_ENTER_STATE(CAM_POWER_UP);
    }
    else if (CAM_IN_STATE(CAM_READY))
    {
        med_stop_timer(CAM_POWER_DOWN_DELAY_TIMER);
        cam_send_ready_ind(MED_RES_OK);
        CAM_SET_EVENT(CAM_EVT_POWER_UP);
    }
    cam_context_p->delay_power_down = KAL_FALSE;
    /* CAM_SET_EVENT(CAM_EVT_POWER_UP); */
}


/*****************************************************************************
 * FUNCTION
 *  cam_power_down
 * DESCRIPTION
 *  This function is to power down extern camera module.
 * PARAMETERS
 *  arg     [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void cam_power_down(void *arg)
{
#ifdef __MTK_TARGET__
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (CAM_IN_STATE(CAM_READY) || CAM_IN_STATE(CAM_POWER_UP))
    {
        ext_camera_power_off();
    #ifdef CAMERA_MODULE_WITH_LCD
        if (cam_context_p->osd_buffer_p)
        {
            med_free_ext_mem((void **)&cam_context_p->osd_buffer_p);
        }
    #endif /* CAMERA_MODULE_WITH_LCD */ 
        /* to release the memory allocated in MED_MODE_BUFFER mode */
        CAM_FREE_CAPTURE_BUFFER();
        CAM_ENTER_STATE(CAM_IDLE);
        cam_context_p->delay_power_down = KAL_FALSE;
    }
#endif /* __MTK_TARGET__ */ 
}


/*****************************************************************************
 * FUNCTION
 *  cam_power_down_req_hdlr
 * DESCRIPTION
 *  This function is to handle power down request.
 * PARAMETERS
 *  ilm_ptr     [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void cam_power_down_req_hdlr(ilm_struct *ilm_ptr)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    media_cam_power_down_req_struct *req_p;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    cam_context_p->src_mod = ilm_ptr->src_mod_id;

    req_p = (media_cam_power_down_req_struct*) ilm_ptr->local_para_ptr;

    if (CAM_IN_STATE(CAM_PREVIEW) || CAM_IN_STATE(CAM_START_PREVIEW))
    {
    #ifdef __MTK_TARGET__
        med_stop_timer(CAM_READY_POLLING_TIMER);
        exit_ext_camera_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 (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
        {
            cam_power_down(0);
        }
    }
}


/*****************************************************************************
 * 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                                                      */
    /*----------------------------------------------------------------*/
    switch (cam_context_p->state)
    {
        case CAM_START_PREVIEW:
            if (ext_camera_ready_check() != 0xffffffff)
            {
                /* 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 */
                        exit_ext_camera_preview();
                        ext_camera_power_off();
                    #ifdef CAMERA_MODULE_WITH_LCD
                        if (cam_context_p->osd_buffer_p)
                        {
                            med_free_ext_mem((void **)&cam_context_p->osd_buffer_p);
                        }
                    #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_camera_power_off();
                    #ifdef CAMERA_MODULE_WITH_LCD
                        if (cam_context_p->osd_buffer_p)
                        {
                            med_free_ext_mem((void **)&cam_context_p->osd_buffer_p);
                        }
                    #endif /* CAMERA_MODULE_WITH_LCD */ 
                        ext_camera_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_camera_ready_check();
            med_start_timer(CAM_READY_POLLING_TIMER, CAM_PREVIEW_POLLING_TIME, cam_preview_check, 0);
            break;
        default:
            break;

    }
}


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

    /*----------------------------------------------------------------*/
    /* 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) cam_wb_param_map[req_p->WB];
        cam_param.ev_value = (kal_uint8) cam_ev_param_map[req_p->exposure];
        cam_param.image_effect1 = (kal_uint8) cam_effect_param_map[req_p->effect];
    #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) cam_banding_param_map[req_p->banding_freq];
        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_mode = KAL_FALSE;   /* camera preview */

        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_camera_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))
    {