📄 exif.c

📁 最新MTK手机软件源码
💻 C
📖 第 1 页 / 共 4 页
字号:
上一页 1 2 34
 switch(Exif_entry->type)
 {
   case EXIF_BYTE:
	if(Exif_entry->count<=4)
	{
	 if(exif_seek_buffer(exif_FSAL.uFileOffset-4,FS_FILE_BEGIN)!=FSAL_OK)
	  return 0;
	}
	else
	{
	 if(exif_seek_buffer(Exif_entry->value+exif_TiffOffset,FS_FILE_BEGIN)!=FSAL_OK)
	  return 0;	
	}

	*str=buffer;

	while(count++<Exif_entry->count)
	{
     exif_read_uint8(&value8);

	 if(len+Long_stringSize(value8)>=EXIF_BYTE_SHOW_LEN-2)
		 break;

	 len=sprintf(buffer+len,"%u",value8);
	 buffer[len++]=' ';
	}

	buffer[len++]=0;
	//printf("***len:%d %s***",len,buffer[0]);
  return len;

  case EXIF_SHORT:
	if(Exif_entry->count<=2)
	{
	 if(exif_seek_buffer(exif_FSAL.uFileOffset-4,FS_FILE_BEGIN)!=FSAL_OK)
	  return 0;
	}
	else
	{
	 if(exif_seek_buffer(Exif_entry->value+exif_TiffOffset,FS_FILE_BEGIN)!=FSAL_OK)
	  return 0;	
	}
	*str=buffer;

	while(count++<Exif_entry->count)
	{
     exif_read_uint16(&value16);
	 if(len+Long_stringSize(value16)>=EXIF_SHORT_SHOW_LEN-2)
		 break;

	 len=sprintf(buffer+len,"%u",value16);
	 buffer[len++]=' ';
	}

	buffer[len++]=0;
	//printf("***len:%d %s***\n",len,buffer);
  return len;

  case EXIF_LONG:
	if(Exif_entry->count<=1)
	{
	 if(exif_seek_buffer(exif_FSAL.uFileOffset-4,FS_FILE_BEGIN)!=FSAL_OK)
	  return 0;
	}
	else
	{
	 if(exif_seek_buffer(Exif_entry->value+exif_TiffOffset,FS_FILE_BEGIN)!=FSAL_OK)
	  return 0;	
	}

	//printf("--StringLen:%d \n",Long_stringSize(value));
	*str=buffer;
	while(count++<Exif_entry->count)
	{
	 exif_read_uint32(&value);

	 if((len+Long_stringSize(value) >= EXIF_LONG_SHOW_LEN-2))
		break;

	 len=sprintf(buffer+len,"%u",value);
	 buffer[len++]=' ';
	}

	buffer[len++]=0;
	//printf("***len:%d %s***\n",len,buffer);
  return len;

   case EXIF_SLONG:
	if(Exif_entry->count<=1)
	{
	 if(exif_seek_buffer(exif_FSAL.uFileOffset-4,FS_FILE_BEGIN)!=FSAL_OK)
	  return 0;
	}
	else
	{
	 if(exif_seek_buffer(Exif_entry->value+exif_TiffOffset,FS_FILE_BEGIN)!=FSAL_OK)
	  return 0;	
	}

	//printf("--StringLen:%d \n",stringSize(value));

	*str=buffer;
	while(count++<Exif_entry->count)
	{
	 exif_read_uint32(&value);
	 Svalue=(kal_int32)value;

	 if((len+SLong_stringSize(Svalue) >= EXIF_SLONG_SHOW_LEN-2))
		break;

	 len=sprintf(buffer+len,"%u",Svalue);
	 buffer[len++]=' ';
	}

	buffer[len++]=0;
	//printf("***len:%d %s***",len,buffer[0]);
  return len;

  case EXIF_RATIONAL:
	if(exif_seek_buffer(Exif_entry->value+exif_TiffOffset,FS_FILE_BEGIN)!=FSAL_OK)
	 return 0;

	*str=buffer;
	if(Exif_entry->tag==exif_tag_ExposureTime)
	{
	while(count++<Exif_entry->count)
	{
	 exif_read_uint32(&value);
	 exif_read_uint32(&value1);

	 if(len+Long_stringSize(value)+Long_stringSize(value1)+1 >= EXIF_RATIONAL_SHOW_LEN-2)
		break;

	 len=sprintf(buffer+len,"%u",value);
	 buffer[len++]='/';
	 len+=sprintf(buffer+len,"%u",value1);
	 buffer[len++]=' ';
	}
	}
   else
	{
	 while(count++<Exif_entry->count)
	 {
	  exif_read_uint32(&value);
	  exif_read_uint32(&value1);

	  if(value==0 || value1==0)
      {
	   buffer[len++]='0';
       break;
	  }

	  fp=((float)value)/value1;

	  if(len+Float_stringSize(fp)+1 >= EXIF_RATIONAL_SHOW_LEN-2)
		break;
	  len=sprintf(buffer+len,EXIF_RATIONAL_PRECISION,fp);
	  buffer[len++]=' ';
	 }
   }
	buffer[len++]=0;
   return len;

   case EXIF_SRATIONAL:
	if(exif_seek_buffer(Exif_entry->value+exif_TiffOffset,FS_FILE_BEGIN)!=FSAL_OK)
		return 0;

	*str=buffer;
	if(0)
	{
	while(count++<Exif_entry->count)
	{
	 exif_read_uint32(&value);
	 exif_read_uint32(&value1);

	 if(len+SLong_stringSize(value)+SLong_stringSize(value1)+1 >= EXIF_SRATIONAL_SHOW_LEN-2)
		break;

	 len=sprintf(buffer+len,"%d",value);
	 //printf("*** %d %d",SLong_stringSize(value),SLong_stringSize(value1));
	 buffer[len++]='/';
	 len+=sprintf(buffer+len,"%d",value1);
	 buffer[len++]=' ';
	}
	}
	else
	{
	 while(count++<Exif_entry->count)
	 {
	  exif_read_uint32(&value);
	  exif_read_uint32(&value1);

	  if(value==0 || value1==0)
      {
	   buffer[len++]='0';
       break;
	  }

	  Svalue=(kal_int32)value;
	  Svalue1=(kal_int32)value1;
	  	
	  fp=((float)Svalue)/Svalue1;

	  if(len+Float_stringSize(fp)+1 >= EXIF_RATIONAL_SHOW_LEN-2)
		break;
	  len=sprintf(buffer+len,EXIF_RATIONAL_PRECISION,fp);
	  buffer[len++]=' ';
	 }
   }
	buffer[len++]=0;
   return len;

  case EXIF_ASCII:
	if(Exif_entry->count<=4)
	{
	 if(exif_seek_buffer(exif_FSAL.uFileOffset-4,FS_FILE_BEGIN)!=FSAL_OK)
	  return 0;
	}
	else
	{
	 if(exif_seek_buffer(Exif_entry->value+exif_TiffOffset,FS_FILE_BEGIN)!=FSAL_OK)
	  return 0;	
	}
	
	*str=buffer;

	while(count++<Exif_entry->count && len<EXIF_ASCII_SHOW_LEN-1)
	  {
	   exif_read_uint8(&value8);
	   
	   //Check if the char is ASCII ot not
	   if(value8>=32 && value8<127)
	   buffer[len++]=(kal_char)(value8);
	   else
	    buffer[len++]=' ';
	  }
	buffer[len++]=0;
	return len;

  case EXIF_UNDEFINED:
	if(Exif_entry->count<=4)
	{
	 if(exif_seek_buffer(exif_FSAL.uFileOffset-4,FS_FILE_BEGIN)!=FSAL_OK)
		 return 0;
	}
	else
	{
	 if(exif_seek_buffer(Exif_entry->value+exif_TiffOffset,FS_FILE_BEGIN)!=FSAL_OK)
		 return 0;
	}
	//printf("#### buffer:%d\n",buffer);
	*str=buffer;
	while(count++< Exif_entry->count && (len+3<EXIF_UNDEFINED_SHOW_LEN-2))
	{
	 exif_read_uint8(&value8);

	 valueHex=Byte2Hex(value8);
	 buffer[len++]=valueHex[0];
	 buffer[len++]=valueHex[1];
	 buffer[len++]=' ';
	}
	buffer[len++]=0;
	return len;
  
  default:
    *str=0;
	return 0;
  }
}




//--Read uint16 as big endian--
FSAL_Status exif_direct_read_uint16(kal_uint16 *pwValue)
{
 kal_uint8 data[2];
 FSAL_Status ret;

 if(exif_FSAL.uFileOffset+2>exif_FileSize) return FSAL_READ_ERROR;

 if((ret=FSAL_Read_Bytes(&exif_FSAL, data, 2))!=FSAL_OK)
   return ret;

 *pwValue = (kal_uint16)((data[0]<<8) + (data[1]));
 
 return FSAL_OK;
}

FSAL_Status exif_read_uint8(kal_uint8 *pwValue)
{
 if(exif_FSAL.uFileOffset+1>exif_FileSize) return FSAL_READ_ERROR;

 return FSAL_Read_Bytes(&exif_FSAL,pwValue, 1);
}

FSAL_Status exif_read_uint16(kal_uint16 *pwValue)
{
 kal_uint8 data[2];
 FSAL_Status ret;

  FSAL_CHECK_ARG(pwValue!=NULL);

 if(exif_FSAL.uFileOffset+2>exif_FileSize) return FSAL_READ_ERROR;

 if((ret=FSAL_Read_Bytes(&exif_FSAL, data, 2))!=FSAL_OK)
  return ret;

 if(exif_ByteOrder==EXIF_BIG_ENDIAN)
  *pwValue = (kal_uint16)((data[0]<<8) + (data[1]));
 else if(exif_ByteOrder==EXIF_LITTLE_ENDIAN)
  *pwValue = (kal_uint16)((data[1]<<8) + (data[0]));
 else
  return FSAL_FATAL_ERROR;
 
 return FSAL_OK;
}

FSAL_Status exif_read_uint32(kal_uint32 *puValue)
{
   kal_uint8 data[4];
   FSAL_Status ret;

   FSAL_CHECK_ARG(puValue!=NULL);

   if(exif_FSAL.uFileOffset+4>exif_FileSize) return FSAL_READ_ERROR;

   if((ret=FSAL_Read_Bytes(&exif_FSAL, data, 4))!=FSAL_OK)
      return ret;

   if(exif_ByteOrder==EXIF_BIG_ENDIAN)
	*puValue = (kal_uint32)((data[0]<<24) + (data[1]<<16) + (data[2]<<8) + (data[3]));
   else if(exif_ByteOrder==EXIF_LITTLE_ENDIAN)
	*puValue = (kal_uint32)((data[3]<<24) + (data[2]<<16) + (data[1]<<8) + (data[0]));
   else
    return FSAL_FATAL_ERROR;

   return FSAL_OK;
}

FSAL_Status exif_direct_read_uint32(kal_uint32 *puValue)
{
   kal_uint8 data[4];
   FSAL_Status ret;

   FSAL_CHECK_ARG(puValue!=NULL);

  if(exif_FSAL.uFileOffset+4>exif_FileSize) return FSAL_READ_ERROR;

   if((ret=FSAL_Read_Bytes(&exif_FSAL, data, 4))!=FSAL_OK)
      return ret;

   *puValue = (kal_uint32)((data[3]<<24) + (data[2]<<16) + (data[1]<<8) + (data[0]));

   return FSAL_OK;
}

FSAL_Status exif_seek_buffer(kal_uint32 offset, kal_uint8 ref)
{
	if(ref==FS_FILE_BEGIN)
	{
	 if(offset<exif_FileSize)
	  return FSAL_Seek(&exif_FSAL,offset);	 
	 else
	  return FSAL_SEEK_ERROR;
	}
	else if(ref==FS_FILE_CURRENT)
	{
	   if(exif_FSAL.uFileOffset+offset<exif_FileSize) 
		return FSAL_Seek(&exif_FSAL,exif_FSAL.uFileOffset+offset);
	   else
	    return FSAL_SEEK_ERROR;
	}
	else
	 return FSAL_SEEK_ERROR;
}

 const kal_uint32 exif_sizeTable[] = { 9, 99, 999, 9999, 99999, 999999, 9999999,
                           99999999, 999999999, 0xffffffff};

 kal_uint32 Float_stringSize(float fp)
 {
  kal_uint32 len;
  len=sprintf((kal_char*)exif_parser_buffer,EXIF_RATIONAL_PRECISION,fp);
  ASSERT(len<EXIF_PARSER_BUFFER_SIZE);
  return len;
 }

 kal_uint32 Long_stringSize(kal_uint32 x)
 {
  kal_uint16 i;
  for (i=0; ; i++)
   if (x <= exif_sizeTable[i])
     return i+1;
 }

 kal_uint32 SLong_stringSize(kal_int32 x)
 {
  kal_uint16 i,p=0;
  if(x<0) 
  {
	x=-x;
	p++;
  }

  for (i=0; ; i++)
   if (x <= exif_sizeTable[i])
     return i+p+1;
 }

 const kal_uint8 exif_DigitTable[]={'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
 kal_uint8 exif_temp_byte[2];

 kal_uint8* Byte2Hex(kal_uint8 x)
 {
   exif_temp_byte[0]=exif_DigitTable[x/16];
   exif_temp_byte[1]=exif_DigitTable[x%16];
  return exif_temp_byte;
 }

/*************************************************************************
* FUNCTION
*   exif_get_tag_list()
*
* DESCRIPTION
*   This function is to retrive tag description string from a jpeg file.
*	Before calling this function, one should move the decoder state to
*	EXIF_DECODER_PARSE_DONE_STATE by calling exif_parse_jpeg_file().
*
* PARAMETERS
*   tagList			The tag list 	
*   IFD0_Size		Record how many tags are there in IFD0
*   ExifIFD_Size	Record how many tags are there in ExifIFD
*
* RETURNS
*   
*
* GLOBALS AFFECTED
*
*************************************************************************/
void exif_get_tag_list(kal_uint16** tagList,kal_uint32* IFD0_Size,kal_uint32* ExifIFD_Size)
{
 if(exif_decoder_state!=EXIF_DECODER_PARSE_DONE_STATE)
 {
  *IFD0_Size=0;
  *ExifIFD_Size=0;
  *tagList=0;
 }
  *IFD0_Size=IFD0_entry_num;
  //printf("IFD0_Size: %d\n",*IFD0_Size);
  *ExifIFD_Size=ExifIFD_entry_num;
 //printf("ExifIFD_Size: %d\n",*ExifIFD_Size);
 *tagList=exif_tagArr;
}

/*************************************************************************
* FUNCTION
*   exif_get_tag_value()
*
* DESCRIPTION
*   This function is to retrive tag description string from a jpeg file.
*	Before calling this function, one should move the decoder state to
*	EXIF_DECODER_PARSE_DONE_STATE by calling exif_parse_jpeg_file().
*
* PARAMETERS
*   kal_uint16 tag
*
* RETURNS
*   kal_char* description, the conetnt of the tag.
*
* GLOBALS AFFECTED
*
*************************************************************************/
kal_char* exif_get_tag_value(kal_uint16 tag)
{
 kal_uint16 i;

 if(exif_decoder_state!=EXIF_DECODER_PARSE_DONE_STATE)
	 return 0;

 for(i=0;i<IFD0_entry_num+ExifIFD_entry_num;i++)
 {
  if(tag==exif_tagArr[i])
	return exif_valueArr[i];
 }

 return 0;
}

/*************************************************************************
* FUNCTION
*   exif_close_jpeg_file()
*
* DESCRIPTION
*   This function is to close a jpeg file and clear the internal variables
*
* PARAMETERS
*   
*
* RETURNS
*   
*
* GLOBALS AFFECTED
*
*************************************************************************/
void exif_close_jpeg_file(void)
{
	exif_tagArr=0;
	exif_valueArr=0;
	FSAL_Close(&exif_FSAL);
	exif_decoder_state=EXIF_DECODER_IDLE_STATE;

	exif_ByteOrder=0;
	exif_TiffOffset=0;
	exif_ReqBufferSize=0;
	exif_FileSize=0;
	exif_app1_boundary=0;

	//--IFD0 para--
	IFD0_entry_pos=0;
	IFD0_entry_num=0;

	//--ExifIFD para--
	ExifIFD_entry_pos=0;
	ExifIFD_entry_num=0;
	exif_MakerNote_pos=0;
	exif_MakerNote_size=0;
}

#endif
上一页 1 2 34
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -