bytestream_hw.c

最新MTK手机软件源码

/*****************************************************************************
*  Copyright Statement:
*  --------------------
*  This software is protected by Copyright and the information contained
*  herein is confidential. The software may not be copied and the information
*  contained herein may not be used or disclosed except with the written
*  permission of MediaTek Inc. (C) 2005
*
*  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
*  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
*  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
*  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
*  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
*  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
*  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
*  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
*  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
*  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
*  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
*  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
*
*  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
*  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
*  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
*  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
*  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. 
*
*  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
*  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
*  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
*  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
*  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
*
*****************************************************************************/

/*******************************************************************************
 * Filename:
 * ---------
 *	 bytestream_hw.c
 *
 * Project:
 * --------
 *  MAUI
 *
 * Description:
 * ------------
 *  Abstract file and memory data source.
 *
 * Author:
 * -------
 * -------
 *
 *==============================================================================
 * 				HISTORY
 * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!! 
 *------------------------------------------------------------------------------
 * removed!
 * removed!
 * removed!
 *
 * removed!
 * removed!
 * removed!
 * removed!
 * removed!
 * removed!
 * removed!
 * removed!
 * removed!
 * removed!
 *------------------------------------------------------------------------------
 * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!! 
 *==============================================================================
 *******************************************************************************/
#include "kal_release.h" 
#include "fat_fs.h"				/* for access file system */
#include "drm_gprot.h"
#include "bytestream_hw.h"
/* Function pointer table */

hw_bytestream_dcb_struct hw_bytestream_dcb[HW_BYTESTREAM_OWNER_NUM];

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

	FUNCTION NAME		: hw_bytestream_free

  	PURPOSE				: free a bytestream

	INPUT PARAMETERS	: void
						  
	OUTPUT PARAMETERS	: nil

	RETURNS				: hw_RESULT

	REMARKS				: nil

***************************************************************/
void hw_bytestream_free(kal_uint32 owner)
{
	/*
	hw_bytestream_dcb_struct *p = &hw_bytestream_dcb[owner];
	
	if(p->hw_bytestream_source_type == HW_BYTESTREAM_TYPE_FILE)
	{
		(void)DRM_close_file(p->file.p->type.file.file_handle);
	}
	else
	{
		ASSERT(p->hw_bytestream_source_type == HW_BYTESTREAM_TYPE_MEM);
	}
	*/

}



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

	FUNCTION NAME		: hw_bytestream_get_byte_mem

  	PURPOSE				: get a byte from memory

	INPUT PARAMETERS	: nil
						  
	OUTPUT PARAMETERS	: nil

	RETURNS				: kal_uint8

	REMARKS				: nil

***************************************************************/
kal_uint8	hw_bytestream_get_byte_mem(kal_uint32 owner)
{
	hw_bytestream_dcb_struct *p = &hw_bytestream_dcb[owner];	
	kal_uint8 v = (kal_uint8)p->type.mem.buffer_ptr[p->type.mem.buffer_offset++];
	
	if(p->type.mem.buffer_offset <= p->type.mem.buffer_size)
	{
		return v;
	}
	else
	{
		BYTESTREAM_RAISE(owner,1);
	}
	return 0;
}


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

	FUNCTION NAME		: hw_bytestream_get_byte_mem

  	PURPOSE				: peek a byte from memory

	INPUT PARAMETERS	: nil
						  
	OUTPUT PARAMETERS	: nil

	RETURNS				: kal_uint8

	REMARKS				: nil

***************************************************************/
kal_uint8	hw_bytestream_peek_byte_mem(kal_uint32 owner)
{
	hw_bytestream_dcb_struct *p = &hw_bytestream_dcb[owner];
	
	if(p->type.mem.buffer_offset+1 <= p->type.mem.buffer_size)
	{
		return (kal_uint8)p->type.mem.buffer_ptr[p->type.mem.buffer_offset];
	}
	else
	{
		BYTESTREAM_RAISE(owner,1);
	}
	return 0;
}

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

	FUNCTION NAME		: hw_bytestream_peek_byte_n_mem

  	PURPOSE				: peek one byte after n bytes

	INPUT PARAMETERS	: int index
						  
	OUTPUT PARAMETERS	: nil

	RETURNS				: kal_uint8

	REMARKS				: nil

***************************************************************/
kal_uint8	hw_bytestream_peek_byte_n_mem(kal_uint32 owner, kal_uint32 index) 
{
	hw_bytestream_dcb_struct *p = &hw_bytestream_dcb[owner];	
	kal_uint32 offset = p->type.mem.buffer_offset+index;
	
	if(offset+1 <= p->type.mem.buffer_size)
	{
		return (kal_uint8)p->type.mem.buffer_ptr[offset];
	}
	else
	{
		BYTESTREAM_RAISE(owner,1);
		return 0; /* Unreached */
	}
}



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

	FUNCTION NAME		: hw_bytestream_get_word_mem

  	PURPOSE				: peek a word from memory

	INPUT PARAMETERS	: nil
						  
	OUTPUT PARAMETERS	: nil

	RETURNS				: kal_uint16

	REMARKS				: nil

***************************************************************/
kal_uint16 hw_bytestream_get_word_mem(kal_uint32 owner,hw_bytestream_endian_enum endian)
{
	hw_bytestream_dcb_struct *p = &hw_bytestream_dcb[owner];	
	kal_uint32 byte0;
	kal_uint32 byte1;
	
	byte0 = p->type.mem.buffer_ptr[p->type.mem.buffer_offset++];
	byte1 = p->type.mem.buffer_ptr[p->type.mem.buffer_offset++];

	if(p->type.mem.buffer_offset <= p->type.mem.buffer_size)
	{
		if(endian == LITTLE_ENDIAN)
			return ((kal_uint16)((byte1<<8)|byte0));
		else
			return ((kal_uint16)((byte0<<8)|byte1));
	}
	else
	{
		BYTESTREAM_RAISE(owner,1);
		return 0; // Unreached
	}
}


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

	FUNCTION NAME		: hw_bytestream_get_word_mem

  	PURPOSE				: peek a word from memory

	INPUT PARAMETERS	: nil
						  
	OUTPUT PARAMETERS	: nil

	RETURNS				: kal_uint16

	REMARKS				: nil

***************************************************************/
kal_uint32 hw_bytestream_get_3bytes_mem(kal_uint32 owner)
{
	hw_bytestream_dcb_struct *p = &hw_bytestream_dcb[owner];		
	kal_uint32 byte0;
	kal_uint32 byte1;
	kal_uint32 byte2;

	byte0 = p->type.mem.buffer_ptr[p->type.mem.buffer_offset++];
	byte1 = p->type.mem.buffer_ptr[p->type.mem.buffer_offset++];
	byte2 = p->type.mem.buffer_ptr[p->type.mem.buffer_offset++];

	if(p->type.mem.buffer_offset <= p->type.mem.buffer_size)
	{
		return ((kal_uint32)((byte2<<16)|(byte1<<8)|byte0));
	}
	else
	{
		BYTESTREAM_RAISE(owner,1);
		return 0; // Unreached
	}
}


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

	FUNCTION NAME		: hw_bytestream_get_dword_mem

  	PURPOSE				: peek a dword from memory

	INPUT PARAMETERS	: nil
						  
	OUTPUT PARAMETERS	: nil

	RETURNS				: kal_uint32

	REMARKS				: nil

***************************************************************/
kal_uint32 hw_bytestream_get_dword_mem(kal_uint32 owner,hw_bytestream_endian_enum endian)
{
	hw_bytestream_dcb_struct *p = &hw_bytestream_dcb[owner];		
	kal_uint32 byte0;
	kal_uint32 byte1;
	kal_uint32 byte2;
	kal_uint32 byte3;
	
	byte0 = p->type.mem.buffer_ptr[p->type.mem.buffer_offset++];
	byte1 = p->type.mem.buffer_ptr[p->type.mem.buffer_offset++];
	byte2 = p->type.mem.buffer_ptr[p->type.mem.buffer_offset++];
	byte3 = p->type.mem.buffer_ptr[p->type.mem.buffer_offset++];	
	if(p->type.mem.buffer_offset <= p->type.mem.buffer_size)
	{
		if(endian == LITTLE_ENDIAN)
			return  ((kal_uint32)(byte3<<24))|((kal_uint32)(byte2<<16))|((kal_uint32)(byte1<<8))|(kal_uint32)(byte0);
		else
			return  ((kal_uint32)(byte0<<24))|((kal_uint32)(byte1<<16))|((kal_uint32)(byte2<<8))|(kal_uint32)(byte3);			
	}
	else
	{
		BYTESTREAM_RAISE(owner,1);
		return 0; // Unreached code
	}
}
void hw_bytestream_get_array_mem(kal_uint32 owner, kal_uint8 * array,kal_uint32 size)
{
	hw_bytestream_dcb_struct *p = &hw_bytestream_dcb[owner];	
	
	if( p->type.mem.buffer_offset + size <= p->type.mem.buffer_size)
	{
		memcpy(array,p->type.mem.buffer_ptr+p->type.mem.buffer_offset,size);
		p->type.mem.buffer_offset += size;
	}
	else
	{
		BYTESTREAM_RAISE(owner,1);
		return; // Unreached code
	}
}

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

	FUNCTION NAME		: hw_bytestream_is_eof_mem

  	PURPOSE				: chcek if is eof

	INPUT PARAMETERS	: nil
						  
	OUTPUT PARAMETERS	: nil

	RETURNS				: kal_bool

	REMARKS				: nil

***************************************************************/
kal_bool hw_bytestream_is_eof_mem(kal_uint32 owner)
{
	hw_bytestream_dcb_struct *p = &hw_bytestream_dcb[owner];	
	
	return  (kal_bool)(p->type.mem.buffer_offset >= p->type.mem.buffer_size);
}

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

	FUNCTION NAME		: hw_bytestream_flush_mem 

  	PURPOSE				: flush memory

	INPUT PARAMETERS	: kal_uint32 count
						  
	OUTPUT PARAMETERS	: nil

	RETURNS				: void

	REMARKS				: nil

***************************************************************/
void hw_bytestream_flush_mem(kal_uint32 owner, kal_uint32 count)
{
	hw_bytestream_dcb_struct *p = &hw_bytestream_dcb[owner];	
	
	// It allows to stop at the end of stream plus one byte
	if( (p->type.mem.buffer_offset += count) > p->type.mem.buffer_size)
		BYTESTREAM_RAISE(owner,1);
	}


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

	FUNCTION NAME		: hw_bytestream_seek_mem 

  	PURPOSE				: seek memory

	INPUT PARAMETERS	: kal_int32 offset
						  
	OUTPUT PARAMETERS	: nil

	RETURNS				: void

	REMARKS				: nil

***************************************************************/
void hw_bytestream_seek_mem(kal_uint32 owner, kal_int32 offset)
{
	hw_bytestream_dcb_struct *p = &hw_bytestream_dcb[owner];	
	
	// It allows to stop at the end of stream plus one byte
	if (offset <= (kal_int32)p->type.mem.buffer_size)
	{
		p->type.mem.buffer_offset = offset;
	}
	else
	{
		BYTESTREAM_RAISE(owner,1);
	}
}


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

	FUNCTION NAME		: hw_bytestream_tell_mem 

  	PURPOSE				: tell memory

	INPUT PARAMETERS	: kal_int32 offset
						  
	OUTPUT PARAMETERS	: nil

	RETURNS				: kal_int32

	REMARKS				: nil

***************************************************************/
kal_int32 hw_bytestream_tell_mem(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.mem.buffer_offset;
}


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

	FUNCTION NAME		: hw_bytestream_get_size_mem 

  	PURPOSE				: get size of memory

	INPUT PARAMETERS	: kal_int32 offset
						  
	OUTPUT PARAMETERS	: nil

	RETURNS				: kal_uint32

	REMARKS				: nil

***************************************************************/
kal_uint32 hw_bytestream_get_size_mem(kal_uint32 owner)
{
	hw_bytestream_dcb_struct *p = &hw_bytestream_dcb[owner];	
	return p->type.mem.buffer_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_mem(kal_uint32 owner)
{
}


//--------------------------------------------------------------//
// bytestream of file type start here
//--------------------------------------------------------------//
void hw_bytestream_buffer_load_file(kal_uint32 owner, int at_least)
{
	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,offset);
	
	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;
	}
	else
	{
		BYTESTREAM_RAISE(owner,1);
	}
}

kal_bool hw_bytestream_buffer_load_file_widthout_exception(kal_uint32 owner, int at_least)