bytestream_hw.c

最新MTK手机软件源码

{
	hw_bytestream_dcb_struct *p = &hw_bytestream_dcb[owner];	
	int offset;
	offset = p->type.file.buffer_content_size;
	if(offset)
		memcpy(p->type.file.buffer_ptr,p->type.file.buffer_reader,p->type.file.buffer_content_size);
	
	if((DRM_read_file(p->type.file.file_handle,
				p->type.file.buffer_ptr+offset,p->type.file.buffer_size-offset,
				(UINT*)&p->type.file.buffer_content_size) == FS_NO_ERROR)
	&& p->type.file.buffer_content_size>0)
	{
		p->type.file.buffer_reader = p->type.file.buffer_ptr;
		p->type.file.buffer_content_size += offset;

		if(p->type.file.buffer_content_size >= at_least)
			return KAL_TRUE;
	}
	return KAL_FALSE;
}
/**************************************************************

	FUNCTION NAME		: hw_bytestream_get_byte_file 

  	PURPOSE				: get a byte from file 

	INPUT PARAMETERS	: nil
						  
	OUTPUT PARAMETERS	: nil

	RETURNS				: kal_uint8

	REMARKS				: nil

***************************************************************/
kal_uint8	hw_bytestream_get_byte_file(kal_uint32 owner)
{
	hw_bytestream_dcb_struct *p = &hw_bytestream_dcb[owner];	
	
	if(!(p->type.file.buffer_content_size))
		hw_bytestream_buffer_load_file(owner, 1);

	p->type.file.buffer_content_size--;

	p->type.file.file_offset++;

	return *p->type.file.buffer_reader++;
}

/**************************************************************

	FUNCTION NAME		: hw_bytestream_get_byte_file 

  	PURPOSE				: peek a byte from file 

	INPUT PARAMETERS	: nil
						  
	OUTPUT PARAMETERS	: nil

	RETURNS				: kal_uint8

	REMARKS				: nil

***************************************************************/
kal_uint8	hw_bytestream_peek_byte_file(kal_uint32 owner)
{
	hw_bytestream_dcb_struct *p = &hw_bytestream_dcb[owner];	
	
	if(!p->type.file.buffer_content_size)
		hw_bytestream_buffer_load_file(owner, 1);

	return *p->type.file.buffer_reader;
}
/**************************************************************

	FUNCTION NAME		: hw_bytestream_peek_byte_n_file 

  	PURPOSE				: peek n byte from file 

	INPUT PARAMETERS	: int index
						  
	OUTPUT PARAMETERS	: nil

	RETURNS				: kal_uint8

	REMARKS				: nil

***************************************************************/
kal_uint8	hw_bytestream_peek_byte_n_file(kal_uint32 owner, kal_uint32 index)
{
	hw_bytestream_dcb_struct *p = &hw_bytestream_dcb[owner];	
	
	if(p->type.file.buffer_content_size<index)
		hw_bytestream_buffer_load_file(owner, index);
	
	return p->type.file.buffer_reader[index];
}


/**************************************************************

	FUNCTION NAME		: hw_bytestream_get_word_file 

  	PURPOSE				: peek a word from file (16 bit)

	INPUT PARAMETERS	: void 
						  
	OUTPUT PARAMETERS	: nil

	RETURNS				: kal_uint16

	REMARKS				: nil

***************************************************************/
kal_uint16 hw_bytestream_get_word_file(kal_uint32 owner,hw_bytestream_endian_enum endian)
{
	hw_bytestream_dcb_struct *p = &hw_bytestream_dcb[owner];	
	kal_uint16 result;
	
	if(p->type.file.buffer_content_size<2)
		hw_bytestream_buffer_load_file(owner, 2);
	
	p->type.file.buffer_content_size-=2;
	p->type.file.file_offset+=2;

	if(endian == LITTLE_ENDIAN)
	{
		result = *p->type.file.buffer_reader++;
		result |= (*p->type.file.buffer_reader++) << 8;
	}
	else
	{
		result = *p->type.file.buffer_reader++ << 8;
		result |= (*p->type.file.buffer_reader++);
	}
	return result;
}




/**************************************************************

	FUNCTION NAME		: hw_bytestream_get_word_file 

  	PURPOSE				: peek a word from file (16 bit)

	INPUT PARAMETERS	: void 
						  
	OUTPUT PARAMETERS	: nil

	RETURNS				: kal_uint16

	REMARKS				: nil

***************************************************************/
kal_uint32 hw_bytestream_get_3bytes_file(kal_uint32 owner)
{
	hw_bytestream_dcb_struct *p = &hw_bytestream_dcb[owner];	
	kal_uint32 result;
	
	if(p->type.file.buffer_content_size<3)
		hw_bytestream_buffer_load_file(owner, 3);
	
	p->type.file.buffer_content_size-=3;
	p->type.file.file_offset+=3;

	result = *p->type.file.buffer_reader++;
	result |= (*p->type.file.buffer_reader++) << 8;
	result |= (*p->type.file.buffer_reader++) << 16;
	return result;
}


/**************************************************************

	FUNCTION NAME		: hw_bytestream_get_dword_file 

  	PURPOSE				: get a dword from file (32 bit)

	INPUT PARAMETERS	: int index
						  
	OUTPUT PARAMETERS	: nil

	RETURNS				: kal_uint32

	REMARKS				: nil

***************************************************************/
kal_uint32 hw_bytestream_get_dword_file(kal_uint32 owner, hw_bytestream_endian_enum endian)
{
	hw_bytestream_dcb_struct *p = &hw_bytestream_dcb[owner];	
	kal_uint32 result;
	
	if(p->type.file.buffer_content_size<4)
		hw_bytestream_buffer_load_file(owner, 4);

	p->type.file.buffer_content_size-=4;
	p->type.file.file_offset+=4;	

	if(endian == LITTLE_ENDIAN)
	{
		result = *p->type.file.buffer_reader++;
		result |= (*p->type.file.buffer_reader++) << 8;
		result |= (*p->type.file.buffer_reader++) << 16;
		result |= (*p->type.file.buffer_reader++) << 24;
	}
	else
	{
		result  = (*p->type.file.buffer_reader++) << 24;
		result |= (*p->type.file.buffer_reader++) << 16;
		result |= (*p->type.file.buffer_reader++) << 8;
		result |= (*p->type.file.buffer_reader++);
		
	}
	return result;
}

/**************************************************************

	FUNCTION NAME		: hw_bytestream_get_array_file 

  	PURPOSE				: get a dword from file (32 bit)

	INPUT PARAMETERS	: int index
						  
	OUTPUT PARAMETERS	: nil

	RETURNS				: kal_uint32

	REMARKS				: nil

***************************************************************/
void hw_bytestream_get_array_file(kal_uint32 owner, kal_uint8 * array,kal_uint32 size)
{
	hw_bytestream_dcb_struct *p = &hw_bytestream_dcb[owner];	
	while(size>0)
	{
		int n;
		if(p->type.file.buffer_content_size == 0)
			hw_bytestream_buffer_load_file(owner, 1);
		
		n= MIN(size,p->type.file.buffer_content_size);
		memcpy(array,p->type.file.buffer_reader,n);
		array+=n;
		p->type.file.buffer_content_size -=n;
		size -= n;
		p->type.file.file_offset+=n;
		p->type.file.buffer_reader+=n;
	}
}

/**************************************************************

	FUNCTION NAME		: hw_bytestream_is_eof_file 

  	PURPOSE				: check is eof 

	INPUT PARAMETERS	: nil
						  
	OUTPUT PARAMETERS	: nil

	RETURNS				: kal_bool

	REMARKS				: nil

***************************************************************/
kal_bool hw_bytestream_is_eof_file(kal_uint32 owner)
{
	hw_bytestream_dcb_struct *p = &hw_bytestream_dcb[owner];	
	if(p->type.file.buffer_content_size)
		return KAL_FALSE;

	if(hw_bytestream_buffer_load_file_widthout_exception(owner, 1))
		return KAL_FALSE;
	
	return KAL_TRUE;
}


/**************************************************************

	FUNCTION NAME		: hw_bytestream_seek_file 

  	PURPOSE				: seek file bytestream 

	INPUT PARAMETERS	: kal_int32 offset
						  
	OUTPUT PARAMETERS	: nil

	RETURNS				: void

	REMARKS				: nil

***************************************************************/
void hw_bytestream_seek_file(kal_uint32 owner, kal_int32 offset)
{
	hw_bytestream_dcb_struct *p = &hw_bytestream_dcb[owner];	
	int ret;
	
	ret = DRM_seek_file(p->type.file.file_handle,offset,FS_FILE_BEGIN);
	p->type.file.buffer_content_size = 0;
	p->type.file.file_offset = offset;

	if ((ret<0) || (ret!=(int)offset))
	{
		BYTESTREAM_RAISE(owner,1);
	}
}

/**************************************************************

	FUNCTION NAME		: hw_bytestream_flush_file 

  	PURPOSE				: flush file bytestream 

	INPUT PARAMETERS	: kal_uint32 count
						  
	OUTPUT PARAMETERS	: nil

	RETURNS				: void

	REMARKS				: nil

***************************************************************/
/* Note: FSAL does not check the availability of data until issuing read/write operations */
void hw_bytestream_flush_file(kal_uint32 owner, kal_uint32 count)
{
	hw_bytestream_dcb_struct *p = &hw_bytestream_dcb[owner];	
	p->type.file.file_offset+=count;
	if(count >= p->type.file.buffer_size)
	{
		hw_bytestream_seek_file(owner, p->type.file.file_offset);
		return;
	}
	while(count)
	{
		if(p->type.file.buffer_content_size < (int)count)
		{
			count -= p->type.file.buffer_content_size;
			p->type.file.buffer_content_size=0;
			hw_bytestream_buffer_load_file(owner, 1);
		}
		else
		{
			p->type.file.buffer_content_size-=count;
			p->type.file.buffer_reader +=count;
			count=0;
		}
	}
}





/**************************************************************

	FUNCTION NAME		: hw_bytestream_tell_file 

  	PURPOSE				: tell file bytestream 

	INPUT PARAMETERS	: void
						  
	OUTPUT PARAMETERS	: nil

	RETURNS				: kal_int32

	REMARKS				: nil

***************************************************************/
kal_int32 hw_bytestream_tell_file(kal_uint32 owner, hw_bytestream_dcb_struct **info )
{
	hw_bytestream_dcb_struct *p = &hw_bytestream_dcb[owner];	
	
	if(info != NULL)
		*info = p;
	return p->type.file.file_offset;
}


/**************************************************************

	FUNCTION NAME		: hw_bytestream_get_size_file 

  	PURPOSE				: get size of file bytestream 

	INPUT PARAMETERS	: void
						  
	OUTPUT PARAMETERS	: nil

	RETURNS				: kal_uint32

	REMARKS				: nil

***************************************************************/
kal_uint32 hw_bytestream_get_size_file(kal_uint32 owner)
{
	hw_bytestream_dcb_struct *p = &hw_bytestream_dcb[owner];	
	return p->type.file.file_size;
}

/**************************************************************

	FUNCTION NAME		: hw_bytestream_refill_file 

  	PURPOSE				: refill the buffer with valid data
	INPUT PARAMETERS	: void
						  
	OUTPUT PARAMETERS	: nil

	RETURNS				: nil

	REMARKS				: nil

***************************************************************/
void hw_bytestream_refill_file(kal_uint32 owner)
{
	hw_bytestream_buffer_load_file(owner,1);
}

/**************************************************************

	FUNCTION NAME		: hw_bytestream_create

  	PURPOSE				: create a memory bytestream

	INPUT PARAMETERS	: kal_uint8 *buf_ptr
							  kal_uint32 buf_size
						  
	OUTPUT PARAMETERS	: nil

	RETURNS				: hw_RESULT

	REMARKS				: nil

***************************************************************/
void hw_bytestream_create(kal_uint32 owner, kal_uint8 *buf_ptr, kal_uint32 buf_size)
{
	hw_bytestream_dcb_struct *p = &hw_bytestream_dcb[owner];	

	p->t = HW_BYTESTREAM_TYPE_MEM;
	p->type.mem.buffer_size		= buf_size;
	p->type.mem.buffer_offset		= 0;
	p->type.mem.buffer_ptr	= buf_ptr;
}

/**************************************************************

	FUNCTION NAME		: hw_bytestream_create_file

  	PURPOSE				: create a file bytestream

	INPUT PARAMETERS	: const S8 *file_name
						  
	OUTPUT PARAMETERS	: nil

	RETURNS				: hw_RESULT

	REMARKS				: nil

***************************************************************/
kal_uint32 hw_bytestream_create_file(kal_uint32 owner, FS_HANDLE handle, kal_uint8* buf, kal_uint32 buf_size)
{
	hw_bytestream_dcb_struct *p = &hw_bytestream_dcb[owner];	

	p->t = HW_BYTESTREAM_TYPE_FILE;
	p->type.file.file_handle = handle;
	p->type.file.buffer_ptr = buf;
	p->type.file.buffer_size = buf_size;
	p->type.file.buffer_reader = p->type.file.buffer_ptr;
	p->type.file.buffer_content_size = 0;
	p->type.file.file_offset = 0;
	DRM_seek_file((FS_HANDLE) p->type.file.file_handle, 0, FS_FILE_BEGIN);
	if(DRM_file_size(p->type.file.file_handle, (kal_uint32*)&p->type.file.file_size)<0)
		p->type.file.file_size = 0;	

	return p->type.file.file_size;
}

hw_bytestream_func_struct hw_bytestream_func[HW_BYTESTREAM_TYPE_NUM]=
{
	{
		hw_bytestream_get_byte_mem ,
		//hw_bytestream_peek_byte_mem,
		hw_bytestream_peek_byte_n_mem,
		hw_bytestream_get_word_mem,
		//hw_bytestream_get_3bytes_mem,
		hw_bytestream_get_dword_mem, 
		hw_bytestream_get_array_mem,
		hw_bytestream_flush_mem,
		hw_bytestream_seek_mem,
		hw_bytestream_tell_mem,
		//hw_bytestream_get_size_mem,		
		hw_bytestream_is_eof_mem,		
		hw_bytestream_refill_mem
	},
	{
		hw_bytestream_get_byte_file ,
		//hw_bytestream_peek_byte_file,
		hw_bytestream_peek_byte_n_file,
		hw_bytestream_get_word_file,
		//hw_bytestream_get_3bytes_file,
		hw_bytestream_get_dword_file, 
		hw_bytestream_get_array_file,
		hw_bytestream_flush_file,
		hw_bytestream_seek_file,
		hw_bytestream_tell_file,
		//hw_bytestream_get_size_file,
		hw_bytestream_is_eof_file,		
		hw_bytestream_refill_file,	
	}
};