isp_device_if.c

最新MTK手机软件源码

		{
			if( (search_pixel[i].pixel_diff>defect_min_diff)&&(search_pixel[i].area_id==DEFECT_AREA_1) ||
			    ((defect_num>0)&&(search_pixel[i].pixel_diff==defect_min_diff)&&(search_pixel[i].area_id==DEFECT_AREA_1)))
			{
				if( defect_mode==DEFECT_MODE_CAPTURE ) 
				memcpy(&(defectpixel_result.pixel_list[defect_idx]), &search_pixel[i], pixel_struct_size);					
				else
				memcpy(&(defectpixel_pv_result.pixel_list[defect_idx]), &search_pixel[i], pixel_struct_size);					
					
				defect_idx++;
			    if(search_pixel[i].pixel_diff==defect_min_diff)
			        defect_num--;
			}
		}
		if( defect_mode==DEFECT_MODE_CAPTURE ) 
		{
			defectpixel_result.defect_num = defect_idx;						
			defectpixel_result.search_num = defect_area1_search_num;			
		}
		else
		{
			defectpixel_pv_result.defect_num = defect_idx;						
			defectpixel_pv_result.search_num = defect_area1_search_num;			
		}
	}
}				

void camera_defect_sort_pixel_by_avg_pri(kal_uint8	defect_mode, kal_uint16 search_mode, kal_uint16 defect_type_select)
{
	kal_uint16	defect_min_diff=255, defect_num, defect_idx=0;
	kal_uint32	i;	    
	kal_uint32  pixel_struct_size = sizeof(defectpixel_pixel_struct);	    
    register kal_uint32 *p_diffValue;
    register kal_uint32 *p_diffArea1Value;
	if( defect_mode==DEFECT_MODE_CAPTURE ) 
    {
        p_diffValue = &diffValue[0];
        p_diffArea1Value = &diffArea1Value[0];
    }
    else
	{
        p_diffValue = &diffValue_pv[0];
        p_diffArea1Value = &diffArea1Value_pv[0];
    }	
	if(defect_curr_search_num < defectpixel_data.max_defect_num)
	{
		if( defect_mode==DEFECT_MODE_CAPTURE ) 
		{
    		memcpy(defectpixel_result.pixel_list, search_pixel, (defect_curr_search_num)*pixel_struct_size);
			defectpixel_result.defect_num = defect_curr_search_num;
			defectpixel_result.search_num = defect_curr_search_num;						
		}
		else
		{
			memcpy(defectpixel_pv_result.pixel_list, search_pixel, (defect_curr_search_num)*pixel_struct_size);
			defectpixel_pv_result.defect_num = defect_curr_search_num;
			defectpixel_pv_result.search_num = defect_curr_search_num;						
		}
	}
	else
	{
		/* Search defect_min_diff */
		defect_num = defect_curr_search_num;
		for(i=defect_curr_min_diff;i<=255;i++)
		{
    	    if(defect_num > *(p_diffValue+i))
    		{
    		    defect_num -= *(p_diffValue+i);
				if(defect_num <= defectpixel_data.max_defect_num)
				{
				    defect_num = defectpixel_data.max_defect_num - defect_num;
					break;				    
				}
            }
            else
            {
                defect_num = 0;
				break;
    		}			
    	}			
		defect_min_diff = i;
		/* Search diff value inside max defect num */
		for(i=0;i<defect_curr_search_num;i++)				
		{
			if( (search_pixel[i].pixel_diff>defect_min_diff) ||
			    ((defect_num>0)&&(search_pixel[i].pixel_diff==defect_min_diff)) )
			{
				if( defect_mode==DEFECT_MODE_CAPTURE ) 
				memcpy(&(defectpixel_result.pixel_list[defect_idx]), &search_pixel[i], pixel_struct_size);						
				else
				memcpy(&(defectpixel_pv_result.pixel_list[defect_idx]), &search_pixel[i], pixel_struct_size);						
				defect_idx++;
			    if(search_pixel[i].pixel_diff==defect_min_diff)
                    defect_num--;				        				    
			}
		}
		if( defect_mode==DEFECT_MODE_CAPTURE ) 
		{
			defectpixel_result.defect_num = defect_idx;			
			defectpixel_result.search_num = defect_curr_search_num;									
		}
		else
		{
			defectpixel_pv_result.defect_num = defect_idx;			
			defectpixel_pv_result.search_num = defect_curr_search_num;									
		}
	}
}		

kal_uint8 camera_defect_sort_pixel(kal_uint8	defect_mode, kal_uint16 search_mode, kal_uint16 defect_type_select)
{
	if( defect_mode==DEFECT_MODE_CAPTURE ) 	    
	{
	    camera_defect_merge_cap_pixellist(defect_type_select, search_mode);	    
	    defect_curr_search_num = defect_curr_cap_search_num;
	    defect_area1_search_num = defect_area1_cap_search_num;
	    defect_curr_min_diff = defect_curr_cap_min_diff;
	}
	else 
	{
	    camera_defect_merge_pv_pixellist(defect_type_select, search_mode);	    
	    defect_curr_search_num = defect_curr_pv_search_num;	    
	    defect_area1_search_num = defect_area1_pv_search_num;	    
	    defect_curr_min_diff = defect_curr_pv_min_diff;	    
    }	    
	if(search_mode == DEFECT_AREA_CENTER_PRI)
	    camera_defect_sort_pixel_by_center_pri(defect_mode, search_mode, defect_type_select);
	else	//DEFECT_AREA_AVG
	    camera_defect_sort_pixel_by_avg_pri(defect_mode, search_mode, defect_type_select);
	clear_defect_para(defect_mode);	
	return KAL_TRUE;					
}

/* camera_defect_find_white_pixel (capture in dark zoom) */
kal_int32 camera_defect_find_white_pixel( kal_uint16 block_width, kal_uint16 block_height, kal_uint16 pos_y_base,
												kal_uint32 isp_debug_buffer)
{
	kal_uint32	value;
	kal_uint32	pos_x, pos_y;
	kal_uint32  y_base=pos_y_base, full_width=grap_width, height=block_height+y_base;
	kal_uint32	pos_block_offset = isp_debug_buffer; 	
	kal_int32	ret = 1;
	area_id = DEFECT_AREA_1;
	// All block avg sould be 0, search Each Pixel
	for(pos_y=y_base;pos_y<height;pos_y++)
	{	
		for(pos_x=0;pos_x<full_width;pos_x+=4)	    
		{				
			value = (*(volatile unsigned int *) (pos_block_offset+pos_x));			
			if(value>0)
			{
    			// Add Pixel into Search List
        		if((value&0x00000000FF)>0)
    			{
    				if( (ret = camera_defect_add_pixel((value&0x00000000FF)+DEFECT_WHITEPIXEL_OFFSET, pos_x, pos_y)) <0 )
    				break;
    			}
        		if((value&0x0000FF00)>0)
    			{
    				if( (ret = camera_defect_add_pixel(((value&0x0000FF00)>>8)+DEFECT_WHITEPIXEL_OFFSET, (pos_x+1), pos_y)) <0 )
    				break;
    			}
       			if((value&0x00FF0000)>0)
    			{
    				if( (ret = camera_defect_add_pixel(((value&0x00FF0000)>>16)+DEFECT_WHITEPIXEL_OFFSET, (pos_x+2), pos_y)) <0 )
    				break;
    			}
        		if((value&0xFF000000)>0)
    			{
    				if( (ret = camera_defect_add_pixel(((value&0xFF000000)>>24)+DEFECT_WHITEPIXEL_OFFSET, (pos_x+3), pos_y)) <0 )
    				break;
    			}
    		}
    	}		
    	pos_block_offset += full_width;		
	}		
	return ret;
}

/* camera_defect_find_black_pixel (capture in uniform light source) */
kal_int32 camera_defect_find_black_pixel( kal_uint16 block_width, kal_uint16 block_height, kal_uint16 pos_y_base,
												kal_uint32 isp_debug_buffer)
{
	kal_uint32	value, value1;
	kal_uint32  block_avg0, block_avg1, block_avg2, block_avg3, limit0, limit1;		
	kal_uint32	x_idx, x_idx_count;
	kal_uint32	pixel_value, pixel_diff, pos_x, pos_y = pos_y_base; 
	kal_uint32	pos_x_block_offset = isp_debug_buffer, pos_block_offset;
	kal_int32	ret = 1, x, y; 
	kal_uint32	area_flag, channel_id;
	kal_uint32	block[DEFECT_MAX_BLOACK_PER_ROW][4];			
	kal_uint32  blockWidth=block_width, blockHeight=block_height, full_width = grap_width;
    kal_uint32  cal_width = grap_width<<2, pixel_count = block_pixel_count>>2;	
    kal_uint32	defect_width_num=defectpixel_data.block_width_factor;	
    kal_uint32  threshold_area1 = defectpixel_data.threshold_area1, threshold_area2=defectpixel_data.threshold_area2;
    kal_uint32	area1MinX=area1_min_x, area1MaxX=area1_max_x;		
	// Found all block avg.		
	for(x_idx=0;x_idx<defect_width_num;x_idx++)
	{
        block_avg0=block_avg1=block_avg2=block_avg3=0;	    
		pos_block_offset = pos_x_block_offset;
		// 00 01	=> (B Gb)	02 03	=>	(Gr R)
		for(y=0;y<blockHeight;y+=4)  
		{   // only cal 0/1;4/5;8/9..lines to speed up				
			for(x=0;x<blockWidth;x+=4)
			{   // only cal odd pixels to speed up
				value = (*(volatile unsigned int *) (pos_block_offset+x));
			    value1 = (*(volatile unsigned int *) (pos_block_offset+full_width+x));			    
				block_avg0 += ((value>>8)&0xFF);
				block_avg1 += (value&0xFF);
				block_avg2 += ((value1>>8)&0xFF);
				block_avg3 += (value1&0xFF);								
			}
			pos_block_offset += cal_width;			
		}
		block[x_idx][0] = (block_avg0/pixel_count);
		block[x_idx][1] = (block_avg1/pixel_count);
		block[x_idx][2] = (block_avg2/pixel_count);
		block[x_idx][3] = (block_avg3/pixel_count);												
		pos_x_block_offset += blockWidth;				
	}		
	
	// Search Each Pixel
    pos_block_offset = isp_debug_buffer;	
    channel_id = 0;    
    if((pos_y<area1_min_y)||(pos_y>area1_max_y))
        area_flag = DEFECT_AREA_2;
    else                        
        area_flag = DEFECT_AREA_1;            
    y = blockHeight;
    while (--y>=0)
	{	
        x_idx = 0;
        x_idx_count = 0;            
        block_avg0 = block[0][(channel_id<<1)];
        block_avg1 = block[0][1+(channel_id<<1)];
        limit0 = limit1 = threshold_area2;
		for(pos_x=0;pos_x<full_width;pos_x+=4)
		{				
			value = (*(volatile unsigned int *) (pos_block_offset+pos_x));
			// Check threshold				
			if(x_idx_count<blockWidth)
			    x_idx_count+=4;
            else
			{
                x_idx_count = 0;    // reset count
                x_idx++;
                block_avg0 = block[0][(channel_id<<1)];
                block_avg1 = block[0][1+(channel_id<<1)];                
				if((pos_x<area1MinX)||(pos_x>area1MaxX)||(area_flag==DEFECT_AREA_2))
				{
                    limit0 = limit1 = threshold_area2;
					area_id = DEFECT_AREA_2;										    
				}
				else
				{
                    limit0 = limit1 = threshold_area1;
					area_id = DEFECT_AREA_1;				    
				}
			}			
			// Add Pixel into Search List
			pixel_value = (value&0xFF);
			if(pixel_value<block_avg1)
			{
				pixel_diff = block_avg1-pixel_value;
    			if(pixel_diff>limit1)
			    {
    				if( (ret=camera_defect_add_pixel(pixel_diff, pos_x, pos_y)) <0)	
					break;
			    }
            }
			pixel_value = ((value>>8)&0xFF);
			if(pixel_value<block_avg0)
			{
				pixel_diff = block_avg0-pixel_value;
    			if(pixel_diff>limit0)
			    {
    				if( (ret=camera_defect_add_pixel(pixel_diff, (pos_x+1), pos_y)) <0)	
					break;
			    }
            }			
			pixel_value = ((value>>16)&0xFF);
			if(pixel_value<block_avg1)
			{
				pixel_diff = block_avg1-pixel_value;
    			if(pixel_diff>limit1)
			    {
    				if( (ret=camera_defect_add_pixel(pixel_diff, (pos_x+2), pos_y)) <0)	
					break;
			    }
            }    			
			pixel_value = ((value>>24)&0xFF);
			if(pixel_value<block_avg0)
			{
				pixel_diff = block_avg0-pixel_value;
    			if(pixel_diff>limit0)
			    {
    				if( (ret=camera_defect_add_pixel(pixel_diff, (pos_x+3), pos_y)) <0)	
					break;
    			}
    		}
    	}		
		pos_block_offset += full_width;		
        channel_id = 1 - channel_id;
        pos_y++;
	}		
	return ret;
}

void reset_camera_defectpixel(kal_uint8	defect_mode)
{
	/* Clean previous defect data*/
	clear_defect_para(defect_mode);	
	if(defect_mode==DEFECT_MODE_CAPTURE)
		defect_operation_state = DEFECT_INIT_STATE;	
	else if(defect_mode==DEFECT_MODE_PREVIEW)		
		defect_operation_pv_state = DEFECT_INIT_STATE;
	else if(defect_mode==DEFECT_MODE_BOTH)		
	{
		defect_operation_state = DEFECT_INIT_STATE;			
		defect_operation_pv_state = DEFECT_INIT_STATE;		
	}
}

kal_int32 camera_defectpixel_verify_block_factor(const kal_uint32  isp_debug_buffer_size, defectpixel_para_struct *defect_data) 
{
	kal_uint16	max_width, max_height, block_width, block_height;
	kal_uint16	cap_col_count, i;
	
	/* Check Image WXH */
	max_width = (defect_data->image_width)-(defect_data->boarder_len<<1);
	max_height = (defect_data->image_height)-(defect_data->boarder_len<<1);	
	i = (max_width&0x03);
	if(i==2)	// i==1||3 drop these pixels
	{
		defect_data->boarder_len += 1;
		max_width = (defect_data->image_width)-(defect_data->boarder_len<<1);
	}
	/* Check Block WXH */
	block_width = max_width / defect_data->block_width_factor;		
	block_height = max_height / defect_data->block_height_factor;			
	if((block_height<4)||(block_width<4))	
		return ERR_PARA_SIZE_OVER_MEM;		
	/* Check MEM Size */
	cap_col_count = (isp_debug_buffer_size/max_width)/block_height;		
	if(cap_col_count<1)