962 lines
27 KiB
C
962 lines
27 KiB
C
/*
|
||
* * Copyright 2000-2009
|
||
* * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
|
||
* *
|
||
* * SPDX-License-Identifier: GPL-2.0+
|
||
* */
|
||
#include <config.h>
|
||
#include <common.h>
|
||
#include <malloc.h>
|
||
#include <sunxi_flash.h>
|
||
#include "imgdecode.h"
|
||
#include "imagefile_new.h"
|
||
#include "../sprite_card.h"
|
||
#include "../sprite_auto_update.h"
|
||
|
||
#define HEAD_ID 0 //头加密接口索引
|
||
#define TABLE_ID 1 //表加密接口索引
|
||
#define DATA_ID 2 //数据加密接口索引
|
||
#define IF_CNT 3 //加密接口个数 现在只有头加密，表加密，数据加密3种
|
||
#define MAX_KEY_SIZE 32 //密码长度
|
||
|
||
#pragma pack(push, 1)
|
||
typedef struct tag_IMAGE_HANDLE {
|
||
// HANDLE fp; //
|
||
|
||
ImageHead_t ImageHead; //img头信息
|
||
|
||
ImageItem_t *ItemTable; //item信息表
|
||
|
||
// RC_ENDECODE_IF_t rc_if_decode[IF_CNT];//解密接口
|
||
|
||
// BOOL bWithEncpy; // 是否加密
|
||
} IMAGE_HANDLE;
|
||
|
||
#define INVALID_INDEX 0xFFFFFFFF
|
||
|
||
typedef struct tag_ITEM_HANDLE {
|
||
uint index; //在ItemTable中的索引
|
||
uint reserved[3];
|
||
// long long pos;
|
||
} ITEM_HANDLE;
|
||
|
||
#define ITEM_PHOENIX_TOOLS "PXTOOLS "
|
||
|
||
uint img_file_start; //固件的起始位置
|
||
//------------------------------------------------------------------------------------------------------------
|
||
//image解析插件的接口
|
||
//------------------------------------------------------------------------------------------------------------
|
||
|
||
//------------------------------------------------------------------------------------------------------------
|
||
//
|
||
// 函数说明
|
||
//
|
||
//
|
||
// 参数说明
|
||
//
|
||
//
|
||
// 返回值
|
||
//
|
||
//
|
||
// 其他
|
||
// 无
|
||
//
|
||
//------------------------------------------------------------------------------------------------------------
|
||
HIMAGE Img_Open(char *ImageFile)
|
||
{
|
||
IMAGE_HANDLE *pImage = NULL;
|
||
uint ItemTableSize; //固件索引表的大小
|
||
debug("%d:sprite_card_firmware_start\n", __LINE__);
|
||
img_file_start = (uint)sprite_card_firmware_start();
|
||
if (!img_file_start) {
|
||
printf("sunxi sprite error: unable to get firmware start position\n");
|
||
|
||
return NULL;
|
||
}
|
||
printf("img start = 0x%x\n", img_file_start);
|
||
pImage = (IMAGE_HANDLE *)memalign(CONFIG_SYS_CACHELINE_SIZE,
|
||
ALIGN(sizeof(IMAGE_HANDLE),
|
||
CONFIG_SYS_CACHELINE_SIZE));
|
||
if (NULL == pImage) {
|
||
printf("sunxi sprite error: fail to malloc memory for img head\n");
|
||
|
||
return NULL;
|
||
}
|
||
memset(pImage, 0, sizeof(IMAGE_HANDLE));
|
||
//------------------------------------------------
|
||
//读img头
|
||
//------------------------------------------------
|
||
printf("try to read mmc start %d\n", img_file_start);
|
||
if (!sunxi_flash_read(img_file_start, IMAGE_HEAD_SIZE / 512,
|
||
&pImage->ImageHead)) {
|
||
printf("sunxi sprite error: read iamge head fail\n");
|
||
|
||
goto _img_open_fail_;
|
||
}
|
||
printf("read mmc ok\n");
|
||
//------------------------------------------------
|
||
//比较magic
|
||
//------------------------------------------------
|
||
if (memcmp(pImage->ImageHead.magic, IMAGE_MAGIC, 8) != 0) {
|
||
printf("sunxi sprite error: iamge magic is bad\n");
|
||
|
||
goto _img_open_fail_;
|
||
}
|
||
//------------------------------------------------
|
||
//为索引表开辟空间
|
||
//------------------------------------------------
|
||
ItemTableSize = pImage->ImageHead.itemcount * sizeof(ImageItem_t);
|
||
pImage->ItemTable = (ImageItem_t *)memalign(
|
||
CONFIG_SYS_CACHELINE_SIZE,
|
||
ALIGN(ItemTableSize, CONFIG_SYS_CACHELINE_SIZE));
|
||
if (NULL == pImage->ItemTable) {
|
||
printf("sunxi sprite error: fail to malloc memory for item table\n");
|
||
|
||
goto _img_open_fail_;
|
||
}
|
||
//------------------------------------------------
|
||
//读出索引表
|
||
//------------------------------------------------
|
||
if (!sunxi_flash_read(img_file_start + (IMAGE_HEAD_SIZE / 512),
|
||
ItemTableSize / 512, pImage->ItemTable)) {
|
||
printf("sunxi sprite error: read iamge item table fail\n");
|
||
|
||
goto _img_open_fail_;
|
||
}
|
||
|
||
return pImage;
|
||
|
||
_img_open_fail_:
|
||
if (pImage->ItemTable) {
|
||
free(pImage->ItemTable);
|
||
}
|
||
if (pImage) {
|
||
free(pImage);
|
||
}
|
||
|
||
return NULL;
|
||
}
|
||
|
||
HIMAGE Img_Fat_Open(char *ImageFile)
|
||
{
|
||
IMAGE_HANDLE *pImage = NULL;
|
||
uint ItemTableSize = 0;
|
||
|
||
pImage = (IMAGE_HANDLE *)memalign(ARCH_DMA_MINALIGN, sizeof(IMAGE_HANDLE));
|
||
if (NULL == pImage) {
|
||
printf("sunxi sprite error: fail to malloc memory for img head\n");
|
||
|
||
return NULL;
|
||
}
|
||
memset(pImage, 0, sizeof(IMAGE_HANDLE));
|
||
|
||
/* read img head*/
|
||
if (fat_fs_read(ImageFile, (void *)&pImage->ImageHead, 0,
|
||
IMAGE_HEAD_SIZE) <= 0) {
|
||
printf("sunxi sprite error: read iamge head fail\n");
|
||
|
||
goto _img_fs_open_fail_;
|
||
}
|
||
|
||
/* check magic*/
|
||
if (memcmp(pImage->ImageHead.magic, IMAGE_MAGIC, 8) != 0) {
|
||
printf("sunxi sprite error: iamge magic is bad\n");
|
||
|
||
goto _img_fs_open_fail_;
|
||
}
|
||
|
||
ItemTableSize = pImage->ImageHead.itemcount * sizeof(ImageItem_t);
|
||
pImage->ItemTable =
|
||
(ImageItem_t *)memalign(ARCH_DMA_MINALIGN, ItemTableSize);
|
||
if (NULL == pImage->ItemTable) {
|
||
printf("sunxi sprite error: fail to malloc memory for item table\n");
|
||
|
||
goto _img_fs_open_fail_;
|
||
}
|
||
|
||
/* read itemtable*/
|
||
if (fat_fs_read(ImageFile, (void *)pImage->ItemTable, IMAGE_HEAD_SIZE,
|
||
ItemTableSize) <= 0) {
|
||
printf("sunxi sprite error: read iamge item table fail\n");
|
||
|
||
goto _img_fs_open_fail_;
|
||
}
|
||
|
||
return pImage;
|
||
|
||
_img_fs_open_fail_:
|
||
if (pImage->ItemTable) {
|
||
free(pImage->ItemTable);
|
||
}
|
||
if (pImage) {
|
||
free(pImage);
|
||
}
|
||
|
||
return NULL;
|
||
}
|
||
|
||
//------------------------------------------------------------------------------------------------------------
|
||
//
|
||
// 函数说明
|
||
//
|
||
//
|
||
// 参数说明
|
||
//
|
||
//
|
||
// 返回值
|
||
//
|
||
//
|
||
// 其他
|
||
// 无
|
||
//
|
||
//------------------------------------------------------------------------------------------------------------
|
||
long long Img_GetSize(HIMAGE hImage)
|
||
{
|
||
IMAGE_HANDLE *pImage = (IMAGE_HANDLE *)hImage;
|
||
long long size;
|
||
|
||
if (NULL == hImage) {
|
||
printf("sunxi sprite error : hImage is NULL\n");
|
||
|
||
return 0;
|
||
}
|
||
|
||
size = pImage->ImageHead.lenHi;
|
||
size <<= 32;
|
||
size |= pImage->ImageHead.lenLo;
|
||
|
||
return size;
|
||
}
|
||
//------------------------------------------------------------------------------------------------------------
|
||
//
|
||
// 函数说明
|
||
//
|
||
//
|
||
// 参数说明
|
||
//
|
||
//
|
||
// 返回值
|
||
//
|
||
//
|
||
// 其他
|
||
// 无
|
||
//
|
||
//------------------------------------------------------------------------------------------------------------
|
||
HIMAGEITEM Img_OpenItem(HIMAGE hImage, char *MainType, char *subType)
|
||
{
|
||
IMAGE_HANDLE *pImage = (IMAGE_HANDLE *)hImage;
|
||
ITEM_HANDLE *pItem = NULL;
|
||
uint i;
|
||
|
||
if (NULL == pImage || NULL == MainType || NULL == subType) {
|
||
return NULL;
|
||
}
|
||
|
||
pItem = (ITEM_HANDLE *)memalign(CONFIG_SYS_CACHELINE_SIZE,
|
||
ALIGN(sizeof(ITEM_HANDLE),
|
||
CONFIG_SYS_CACHELINE_SIZE));
|
||
if (NULL == pItem) {
|
||
printf("sunxi sprite error : cannot malloc memory for item\n");
|
||
|
||
return NULL;
|
||
}
|
||
pItem->index = INVALID_INDEX;
|
||
|
||
for (i = 0; i < pImage->ImageHead.itemcount; i++) {
|
||
// int nCmp = memcmp(ITEM_PHOENIX_TOOLS, MainType, MAINTYPE_LEN);
|
||
//
|
||
// if (nCmp == 0)//
|
||
// {
|
||
// if (memcmp(MainType, pImage->ItemTable[i].mainType, MAINTYPE_LEN) == 0 )
|
||
// {
|
||
// pItem->index = i;
|
||
//
|
||
// return pItem;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// nCmp = memcmp(MainType, pImage->ItemTable[i].mainType, MAINTYPE_LEN);
|
||
// if(nCmp == 0)
|
||
// {
|
||
// nCmp = memcmp(subType, pImage->ItemTable[i].subType, SUBTYPE_LEN);
|
||
// if( nCmp == 0)
|
||
// {
|
||
// pItem->index = i;
|
||
//
|
||
// return pItem;
|
||
// }
|
||
// }
|
||
// }
|
||
if (!memcmp(subType, pImage->ItemTable[i].subType,
|
||
SUBTYPE_LEN)) {
|
||
pItem->index = i;
|
||
//debug("try to malloc %x\n", (uint)pItem);
|
||
|
||
return pItem;
|
||
}
|
||
}
|
||
|
||
printf("sunxi sprite error : cannot find item %s %s\n", MainType,
|
||
subType);
|
||
|
||
free(pItem);
|
||
pItem = NULL;
|
||
|
||
return NULL;
|
||
}
|
||
|
||
//------------------------------------------------------------------------------------------------------------
|
||
//
|
||
// 函数说明
|
||
//
|
||
//
|
||
// 参数说明
|
||
//
|
||
//
|
||
// 返回值
|
||
//
|
||
//
|
||
// 其他
|
||
// 无
|
||
//
|
||
//------------------------------------------------------------------------------------------------------------
|
||
long long Img_GetItemSize(HIMAGE hImage, HIMAGEITEM hItem)
|
||
{
|
||
IMAGE_HANDLE *pImage = (IMAGE_HANDLE *)hImage;
|
||
ITEM_HANDLE *pItem = (ITEM_HANDLE *)hItem;
|
||
long long size;
|
||
|
||
if (NULL == pItem) {
|
||
printf("sunxi sprite error : item is NULL\n");
|
||
|
||
return 0;
|
||
}
|
||
|
||
size = pImage->ItemTable[pItem->index].filelenHi;
|
||
size <<= 32;
|
||
size |= pImage->ItemTable[pItem->index].filelenLo;
|
||
|
||
return size;
|
||
}
|
||
|
||
//------------------------------------------------------------------------------------------------------------
|
||
//
|
||
// 函数说明
|
||
//
|
||
//
|
||
// 参数说明
|
||
//
|
||
//
|
||
// 返回值
|
||
//
|
||
//
|
||
// 其他
|
||
// 无
|
||
//
|
||
//------------------------------------------------------------------------------------------------------------
|
||
uint Img_GetItemStart(HIMAGE hImage, HIMAGEITEM hItem)
|
||
{
|
||
IMAGE_HANDLE *pImage = (IMAGE_HANDLE *)hImage;
|
||
ITEM_HANDLE *pItem = (ITEM_HANDLE *)hItem;
|
||
long long start;
|
||
long long offset;
|
||
|
||
if (NULL == pItem) {
|
||
printf("sunxi sprite error : item is NULL\n");
|
||
|
||
return 0;
|
||
}
|
||
offset = pImage->ItemTable[pItem->index].offsetHi;
|
||
offset <<= 32;
|
||
offset |= pImage->ItemTable[pItem->index].offsetLo;
|
||
start = offset / 512;
|
||
|
||
return ((uint)start + img_file_start);
|
||
}
|
||
|
||
uint Img_GetItemOffset(HIMAGE hImage, HIMAGEITEM hItem)
|
||
{
|
||
IMAGE_HANDLE *pImage = (IMAGE_HANDLE *)hImage;
|
||
ITEM_HANDLE *pItem = (ITEM_HANDLE *)hItem;
|
||
long long offset;
|
||
|
||
if (NULL == pItem) {
|
||
printf("sunxi sprite error : item is NULL\n");
|
||
|
||
return 0;
|
||
}
|
||
|
||
offset = pImage->ItemTable[pItem->index].offsetHi;
|
||
offset <<= 32;
|
||
offset |= pImage->ItemTable[pItem->index].offsetLo;
|
||
|
||
return (uint)offset;
|
||
}
|
||
|
||
//------------------------------------------------------------------------------------------------------------
|
||
//
|
||
// 函数说明
|
||
//
|
||
//
|
||
// 参数说明
|
||
//
|
||
//
|
||
// 返回值
|
||
// 返回实际读取数据的长度
|
||
//
|
||
// 其他
|
||
// 无
|
||
//
|
||
//------------------------------------------------------------------------------------------------------------
|
||
#if 0
|
||
uint Img_ReadItem(HIMAGE hImage, HIMAGEITEM hItem, void *buffer,
|
||
uint buffer_size)
|
||
{
|
||
IMAGE_HANDLE *pImage = (IMAGE_HANDLE *)hImage;
|
||
ITEM_HANDLE *pItem = (ITEM_HANDLE *)hItem;
|
||
long long start;
|
||
long long offset;
|
||
uint file_size;
|
||
void *tmp;
|
||
|
||
if (NULL == pItem) {
|
||
printf("sunxi sprite error : item is NULL\n");
|
||
|
||
return 0;
|
||
}
|
||
if (pImage->ItemTable[pItem->index].filelenHi) {
|
||
printf("sunxi sprite error : the item too big\n");
|
||
|
||
return 0;
|
||
}
|
||
file_size = pImage->ItemTable[pItem->index].filelenLo;
|
||
debug("file size=%d, buffer size=%d\n", file_size, buffer_size);
|
||
if (file_size > buffer_size) {
|
||
printf("sunxi sprite error : buffer is smaller than data size\n");
|
||
|
||
return 0;
|
||
}
|
||
if (file_size > 2 * 1024 * 1024) {
|
||
printf("sunxi sprite error : this function cant be used to read data over 2M bytes\n");
|
||
|
||
return 0;
|
||
}
|
||
file_size = (file_size + 1023) & (~(1024 - 1));
|
||
offset = pImage->ItemTable[pItem->index].offsetHi;
|
||
offset <<= 32;
|
||
offset |= pImage->ItemTable[pItem->index].offsetLo;
|
||
start = offset / 512;
|
||
|
||
debug("malloc size = %d\n", file_size);
|
||
tmp = malloc(file_size);
|
||
if (!tmp) {
|
||
printf("sunxi sprite error : fail to get memory for temp data\n");
|
||
|
||
return 0;
|
||
}
|
||
if (!sunxi_flash_read((uint)start + img_file_start, file_size / 512,
|
||
tmp)) {
|
||
printf("sunxi sprite error : read item data failed\n");
|
||
free(tmp);
|
||
|
||
return 0;
|
||
}
|
||
memcpy(buffer, tmp, buffer_size);
|
||
free(tmp);
|
||
|
||
return buffer_size;
|
||
}
|
||
#else
|
||
uint Img_ReadItem(HIMAGE hImage, HIMAGEITEM hItem, void *buffer,
|
||
uint buffer_size)
|
||
{
|
||
IMAGE_HANDLE *pImage = (IMAGE_HANDLE *)hImage;
|
||
ITEM_HANDLE *pItem = (ITEM_HANDLE *)hItem;
|
||
long long start;
|
||
long long offset;
|
||
uint file_size;
|
||
|
||
if (NULL == pItem) {
|
||
printf("sunxi sprite error : item is NULL\n");
|
||
|
||
return 0;
|
||
}
|
||
if (pImage->ItemTable[pItem->index].filelenHi) {
|
||
printf("sunxi sprite error : the item too big\n");
|
||
|
||
return 0;
|
||
}
|
||
file_size = pImage->ItemTable[pItem->index].filelenLo;
|
||
file_size = (file_size + 1023) & (~(1024 - 1));
|
||
debug("file size=%d, buffer size=%d\n", file_size, buffer_size);
|
||
if (file_size > buffer_size) {
|
||
printf("sunxi sprite error : buffer is smaller than data size\n");
|
||
|
||
return 0;
|
||
}
|
||
offset = pImage->ItemTable[pItem->index].offsetHi;
|
||
offset <<= 32;
|
||
offset |= pImage->ItemTable[pItem->index].offsetLo;
|
||
start = offset / 512;
|
||
//read partition info from the SDcard
|
||
if (!sunxi_flash_read((uint)start + img_file_start, file_size / 512,
|
||
buffer)) {
|
||
printf("sunxi sprite error : read item data failed\n");
|
||
|
||
return 0;
|
||
}
|
||
|
||
return file_size;
|
||
}
|
||
#endif
|
||
|
||
uint Img_Fat_ReadItem(HIMAGE hImage, HIMAGEITEM hItem, char *ImageFile,
|
||
void *buffer, uint buffer_size)
|
||
{
|
||
IMAGE_HANDLE *pImage = (IMAGE_HANDLE *)hImage;
|
||
ITEM_HANDLE *pItem = (ITEM_HANDLE *)hItem;
|
||
long long offset;
|
||
uint file_size;
|
||
|
||
if (NULL == pItem) {
|
||
printf("sunxi sprite error : item is NULL\n");
|
||
|
||
return 0;
|
||
}
|
||
if (pImage->ItemTable[pItem->index].filelenHi) {
|
||
printf("sunxi sprite error : the item too big\n");
|
||
|
||
return 0;
|
||
}
|
||
file_size = pImage->ItemTable[pItem->index].filelenLo;
|
||
file_size = (file_size + 1023) & (~(1024 - 1));
|
||
debug("file size=%d, buffer size=%d\n", file_size, buffer_size);
|
||
if (file_size > buffer_size) {
|
||
printf("sunxi sprite error : buffer is smaller than data size\n");
|
||
|
||
return 0;
|
||
}
|
||
offset = pImage->ItemTable[pItem->index].offsetHi;
|
||
offset <<= 32;
|
||
offset |= pImage->ItemTable[pItem->index].offsetLo;
|
||
|
||
if (fat_fs_read(ImageFile, buffer, offset, file_size) <= 0) {
|
||
printf("sunxi sprite error : read item data failed\n");
|
||
|
||
return 0;
|
||
}
|
||
|
||
return file_size;
|
||
}
|
||
|
||
//------------------------------------------------------------------------------------------------------------
|
||
//
|
||
// 函数说明
|
||
//
|
||
//
|
||
// 参数说明
|
||
//
|
||
//
|
||
// 返回值
|
||
// 返回实际读取数据的长度
|
||
//
|
||
// 其他
|
||
// 无
|
||
//
|
||
//------------------------------------------------------------------------------------------------------------
|
||
|
||
//static __int64 __Img_ReadItemData(HIMAGE hImage, HIMAGEITEM hItem, void * buffer, __int64 Length);
|
||
//
|
||
//// 根据分组进行加速处理的版本 scott 2009-06-22 10:37:17
|
||
////////////////////////////////////////////////////////////////////////////
|
||
////每次读取的大小扩展到10M
|
||
//
|
||
//__int64 Img_ReadItemData(HIMAGE hImage, HIMAGEITEM hItem, void * buffer, __int64 Length)
|
||
//{
|
||
// __int64 readlen = 0;
|
||
// __int64 nRet = 0;
|
||
// IMAGE_HANDLE* pImage = (IMAGE_HANDLE *)hImage;
|
||
// ITEM_HANDLE * pItem = (ITEM_HANDLE *)hItem;
|
||
// DWORD dwLen;
|
||
// //u8 buffer_encode[SIZE_32K];
|
||
// u8* buffer_encode = (u8*)malloc(SIZE_10M);
|
||
// __int64 this_read;
|
||
// __int64 pos = 0;
|
||
// pEnDecode pfDecode = pImage->rc_if_decode[DATA_ID].EnDecode;
|
||
//
|
||
// //为了速度不进行参数的检测工作 scott 2009-06-22
|
||
// //Msg("Img_ReadItemData:Length=%x datalen=%x pos=%x",
|
||
// // Length, pImage->ItemTable[pItem->index].datalen, pItem->pos); //debug
|
||
//
|
||
// __int64 nLenTmp = Get64bitLen(pImage->ItemTable[pItem->index].filelenLo, pImage->ItemTable[pItem->index].filelenHi);
|
||
// __int64 nFileLen = nLenTmp;
|
||
// if (pItem->pos >= nLenTmp) //filelen <= datalen
|
||
// {
|
||
// Err("Img_ReadItemData", __FILE__, __LINE__,
|
||
// "pos(%x) >= pItem->filelen(%x)",nLenTmp);
|
||
// goto readEnd;
|
||
// }
|
||
// //------------------------------------------------
|
||
// //约束数据不会超出加密数据的范围
|
||
// //------------------------------------------------
|
||
// nLenTmp = Get64bitLen(pImage->ItemTable[pItem->index].datalenLo, pImage->ItemTable[pItem->index].datalenHi);
|
||
// Length = min(Length, nLenTmp - pItem->pos);
|
||
// //Msg("Length_min=%x", Length);
|
||
// //------------------------------------------------
|
||
// //加密后的数据以16byte进行分组，需要处理跨边界的情况
|
||
// //------------------------------------------------
|
||
// if ((pItem->pos % ENCODE_LEN) == 0) //pos正好是分组的边界的情况
|
||
// {
|
||
// nLenTmp = Get64bitLen(pImage->ItemTable[pItem->index].offsetLo , pImage->ItemTable[pItem->index].offsetHi);
|
||
// pos = nLenTmp + pItem->pos;
|
||
// //fseek(pImage->fp, pos, SEEK_SET);
|
||
// FsSeek(pImage->fp, pos, SEEK_SET);
|
||
// readlen = 0;
|
||
// while(readlen < Length)
|
||
// {
|
||
// //------------------------------------------------
|
||
// //每次读取n个分组
|
||
// //------------------------------------------------
|
||
// this_read = min(SIZE_10M, (Length - readlen));
|
||
// u32 n = (this_read + ENCODE_LEN - 1) / ENCODE_LEN; //
|
||
// memset(buffer_encode, 0, n * ENCODE_LEN);
|
||
// //fread(buffer_encode, this_read, 1, pImage->fp); //一次读n个分组,速度更快 note has bug
|
||
// //fread(buffer_encode, n * ENCODE_LEN, 1, pImage->fp); //OK 测试通过，必须读取整个的分组
|
||
// u32 nReadAlian = n * ENCODE_LEN;
|
||
// if(pImage->bWithEncpy == FALSE)
|
||
// {
|
||
// ReadFile(pImage->fp, buffer, nReadAlian/*n * ENCODE_LEN*/, &dwLen, NULL);
|
||
// }
|
||
//// else
|
||
//// {
|
||
//// ReadFile(pImage->fp, buffer_encode, nReadAlian/*n * ENCODE_LEN*/, &dwLen, NULL); //OK 测试通过，必须读取整个的分组
|
||
////
|
||
//// //fseek(pImage->fp, 0, SEEK_CUR);
|
||
//// //Msg("this_read=%x", this_read);
|
||
//// //------------------------------------------------
|
||
//// //分组数据解密
|
||
//// //------------------------------------------------
|
||
//// u8 * pin = buffer_encode;
|
||
//// u8 * pout= (u8 *)buffer;
|
||
//// pout = pout + readlen; //实际输出数据的偏移量
|
||
////
|
||
//// for (u32 i = 0; i < n; i++) //逐个分组进行解密
|
||
//// {
|
||
//// //------------------------------------------------
|
||
//// //每次解密一个分组
|
||
//// //------------------------------------------------
|
||
//// if (OK != pfDecode(pImage->rc_if_decode[DATA_ID].handle, pin , pout))
|
||
//// return 0;
|
||
//// /*
|
||
//// //debug start
|
||
//// if (i == (n-1))
|
||
//// {
|
||
//// Msg("last:%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x ",
|
||
//// pout[0], pout[1], pout[2], pout[3], pout[4], pout[5], pout[6], pout[7],
|
||
//// pout[8], pout[9], pout[10], pout[11], pout[12], pout[13], pout[14],pout[15]);
|
||
//// }
|
||
//// //debug end
|
||
//// */
|
||
//// pin += ENCODE_LEN;
|
||
//// pout+= ENCODE_LEN;
|
||
//// }
|
||
////
|
||
//// }
|
||
// //------------------------------------------------
|
||
// //计算实际有效数据长度
|
||
// //------------------------------------------------
|
||
// readlen += this_read;
|
||
// }
|
||
// if((pItem->pos + readlen) >= nFileLen )
|
||
// {
|
||
// readlen = nFileLen - pItem->pos;
|
||
// }
|
||
//
|
||
// pItem->pos += readlen;
|
||
// //Msg("Img_ReadItemData: pos_new =%x", pItem->pos);
|
||
// // Msg("Read %d\ nFileLen = %x\n", readlen, nFileLen);
|
||
// nRet = readlen;
|
||
// goto readEnd;
|
||
//
|
||
// }
|
||
// else
|
||
// {
|
||
// //------------------------------------------------
|
||
// //这里强制只处理分组对齐的情况，对于以前的一些固件包可能会引起不兼容的问题，
|
||
// //那种情况下只好启用原始版本来处理了
|
||
// //------------------------------------------------
|
||
//
|
||
// //MessageBox(NULL, "请按照对齐规则来处理！", "警告", MB_OK);
|
||
// //return 0;
|
||
//
|
||
// Msg("请按照对齐规则来处理！");
|
||
// nRet = __Img_ReadItemData(hImage, hItem, buffer, Length);
|
||
// }
|
||
//
|
||
//
|
||
//
|
||
//readEnd:
|
||
// free(buffer_encode);
|
||
// return nRet;
|
||
//}
|
||
//
|
||
//
|
||
////原始的版本，可以运行，不过每次读img文件是16byte，速度不高，需要进行提速
|
||
//__int64 __Img_ReadItemData(HIMAGE hImage, HIMAGEITEM hItem, void * buffer, __int64 Length)
|
||
//{
|
||
// __int64 readlen = 0;
|
||
// IMAGE_HANDLE* pImage = (IMAGE_HANDLE *)hImage;
|
||
// ITEM_HANDLE * pItem = (ITEM_HANDLE *)hItem;
|
||
// u8 buffer_encode[ENCODE_LEN];
|
||
// __int64 pos = 0;
|
||
// DWORD dwLen;
|
||
// pEnDecode pfDecode = pImage->rc_if_decode[DATA_ID].EnDecode;
|
||
// if (NULL == pImage || NULL == pItem || NULL == buffer || 0 == Length)
|
||
// {
|
||
// return 0;
|
||
// }
|
||
//
|
||
//
|
||
// if (pItem->pos >= pImage->ItemTable[pItem->index].filelenLo) //filelen <= datalen
|
||
// {
|
||
// Err("Img_ReadItemData", __FILE__, __LINE__, "pos >= pItem->filelen");
|
||
// return 0;
|
||
// }
|
||
// //------------------------------------------------
|
||
// //约束数据不会超出加密数据的范围
|
||
// //------------------------------------------------
|
||
// __int64 nTmp = Get64bitLen(pImage->ItemTable[pItem->index].datalenLo, pImage->ItemTable[pItem->index].datalenHi);
|
||
// Length = min(Length, nTmp - pItem->pos);
|
||
//
|
||
// if(pImage->bWithEncpy == FALSE)
|
||
// {
|
||
// nTmp = Get64bitLen(pImage->ItemTable[pItem->index].offsetLo, pImage->ItemTable[pItem->index].offsetHi);
|
||
// pos = nTmp + pItem->pos;
|
||
// //fseek(pImage->fp, pos, SEEK_SET);
|
||
// FsSeek(pImage->fp, pos, SEEK_SET);
|
||
// ReadFile(pImage->fp, buffer, Length, &dwLen, NULL);
|
||
// pItem->pos += Length;
|
||
// return Length;
|
||
// }
|
||
//
|
||
// //------------------------------------------------
|
||
// //加密后的数据以16byte进行分组，需要处理跨边界的情况
|
||
// //------------------------------------------------
|
||
// if ((pItem->pos % ENCODE_LEN) == 0) //pos正好是分组的边界的情况
|
||
// {
|
||
// nTmp = Get64bitLen(pImage->ItemTable[pItem->index].offsetLo, pImage->ItemTable[pItem->index].offsetHi);
|
||
// pos = nTmp + pItem->pos;
|
||
// //fseek(pImage->fp, pos, SEEK_SET);
|
||
// FsSeek(pImage->fp, pos, SEEK_SET);
|
||
//
|
||
// while(readlen < Length)
|
||
// {
|
||
// //每次读取一个分组
|
||
// memset(buffer_encode, 0, ENCODE_LEN);
|
||
// // fread(buffer_encode, ENCODE_LEN, 1, pImage->fp);
|
||
// // fseek(pImage->fp, 0, SEEK_CUR);
|
||
// ReadFile(pImage->fp, buffer_encode, ENCODE_LEN, &dwLen, NULL);
|
||
// //分组数据解密
|
||
// u8 * pin = buffer_encode;
|
||
// u8 * pout= (u8 *)buffer;
|
||
// pout = pout + readlen;
|
||
// if (OK != pfDecode(pImage->rc_if_decode[DATA_ID].handle, pin , pout))
|
||
// return 0;
|
||
// //计算实际有效数据长度
|
||
// readlen += min(Length- readlen, ENCODE_LEN);
|
||
// }
|
||
// pItem->pos += readlen;
|
||
// return readlen;
|
||
// }
|
||
// else //pos不在边界
|
||
// {
|
||
// //pos不在边界，向头方向seek
|
||
// pos = pImage->ItemTable[pItem->index].offsetLo +
|
||
// pItem->pos - (pItem->pos % ENCODE_LEN);
|
||
// //fseek(pImage->fp, pos, SEEK_SET);
|
||
// FsSeek(pImage->fp, pos, SEEK_SET);
|
||
//
|
||
// //-----------------------------------
|
||
// //**********************OOOOOOOOOOOOO *表示已经读取得数据 O表示未读取得数据
|
||
// //-----------------------------------
|
||
// if ((0 < Length) && (Length < ENCODE_LEN)) //读取的数据不足一个分组长度
|
||
// {
|
||
// u32 read = ENCODE_LEN - (pItem->pos % ENCODE_LEN); //分组中未读取的数据长度
|
||
// if (Length <= read) //需要读取得数据小于等于分组中未读取的数据长度 只用读一个分组即可
|
||
// {
|
||
// //-----------------------------------
|
||
// //**********************OOOOOOOOOOOOO *表示已经读取得数据 O表示未读取得数据
|
||
// //-----------------------------------
|
||
// u32 read = ENCODE_LEN - pItem->pos % ENCODE_LEN;
|
||
// memset(buffer_encode, 0, ENCODE_LEN);
|
||
// //fread(buffer_encode, ENCODE_LEN, 1, pImage->fp);
|
||
// ReadFile(pImage->fp, buffer_encode, ENCODE_LEN, &dwLen, NULL);
|
||
//
|
||
// //分组数据解密
|
||
// u8 * pin = buffer_encode;
|
||
// u8 * pout= (u8 *)buffer;
|
||
// pout = pout + readlen;
|
||
// if (OK != pfDecode(pImage->rc_if_decode[DATA_ID].handle, pin , pout))
|
||
// return 0;
|
||
//
|
||
// readlen = Length;
|
||
// pItem->pos += readlen;
|
||
// return readlen;
|
||
// }
|
||
// else //需要读两个分组的数据
|
||
// {
|
||
// //----------------------------------- //-----------------------------------
|
||
// //**********************OOOOOOOOOOOOO //OOOOOOOOOO
|
||
// //----------------------------------- //-----------------------------------
|
||
// //第一个分组
|
||
// u32 read = ENCODE_LEN - pItem->pos % ENCODE_LEN;
|
||
// memset(buffer_encode, 0, ENCODE_LEN);
|
||
// //fread(buffer_encode, ENCODE_LEN, 1, pImage->fp);
|
||
// ReadFile(pImage->fp, buffer_encode, ENCODE_LEN, &dwLen, NULL);
|
||
// //分组数据解密
|
||
// u8 * pin = buffer_encode;
|
||
// u8 * pout= (u8 *)buffer;
|
||
// pout = pout + readlen;
|
||
// if (OK != pfDecode(pImage->rc_if_decode[DATA_ID].handle, pin , pout))
|
||
// return 0;
|
||
//
|
||
// readlen += read;
|
||
//
|
||
// //第二个分组
|
||
// __int64 Left_Length = Length - read; //剩余的数据
|
||
// memset(buffer_encode, 0, ENCODE_LEN);
|
||
// //fread(buffer_encode, ENCODE_LEN, 1, pImage->fp);
|
||
// //fseek(pImage->fp, 0, SEEK_CUR);
|
||
// ReadFile(pImage->fp, buffer_encode, ENCODE_LEN, &dwLen, NULL);
|
||
// //分组数据解密
|
||
// pin = buffer_encode;
|
||
// pout= (u8 *)buffer;
|
||
// pout = pout + readlen;
|
||
// if (OK != pfDecode(pImage->rc_if_decode[DATA_ID].handle, pin , pout))
|
||
// return 0;
|
||
// readlen += Left_Length;
|
||
//
|
||
// pItem->pos += readlen;
|
||
// return readlen;
|
||
// }
|
||
// }
|
||
// else if (Length >= ENCODE_LEN) //读取的数据不少于一个分组长度
|
||
// {
|
||
// //-----------------------------------
|
||
// //**********************OOOOOOOOOOOOO *表示已经读取得数据 O表示未读取得数据
|
||
// //-----------------------------------
|
||
// u32 read = ENCODE_LEN - pItem->pos % ENCODE_LEN;
|
||
// memset(buffer_encode, 0, ENCODE_LEN);
|
||
// //fread(buffer_encode, ENCODE_LEN, 1, pImage->fp);
|
||
// // fread(pImage->fp, buffer_encode, ENCODE_LEN, &dwLen,NULL);
|
||
// ReadFile(pImage->fp, buffer_encode, ENCODE_LEN, &dwLen,NULL);
|
||
//
|
||
// //分组数据解密
|
||
// u8 * pin = buffer_encode;
|
||
// u8 * pout= (u8 *)buffer;
|
||
// pout = pout + readlen;
|
||
// if (OK != pfDecode(pImage->rc_if_decode[DATA_ID].handle, pin , pout))
|
||
// return 0;
|
||
//
|
||
// readlen += read;
|
||
//
|
||
// //------------------------------------------------
|
||
// //剩余的数据按照分组进行处理
|
||
// //------------------------------------------------
|
||
// u32 Left_Length = Length - read;
|
||
// u32 Left_readlen= 0;
|
||
// while(Left_readlen < Left_Length)
|
||
// {
|
||
// //每次读取一个分组
|
||
// memset(buffer_encode, 0, ENCODE_LEN);
|
||
// // fread(buffer_encode, ENCODE_LEN, 1, pImage->fp);
|
||
// // fseek(pImage->fp, 0, SEEK_CUR);
|
||
// ReadFile(pImage->fp, buffer_encode, ENCODE_LEN, &dwLen, NULL);
|
||
// //分组数据解密
|
||
// u8 * pin = buffer_encode;
|
||
// u8 * pout= (u8 *)buffer;
|
||
// pout = pout + readlen;
|
||
// if (OK != pfDecode(pImage->rc_if_decode[DATA_ID].handle, pin , pout))
|
||
// return 0;
|
||
// //计算实际有效数据长度
|
||
// Left_readlen += min(Left_Length - Left_readlen, ENCODE_LEN);
|
||
// }
|
||
//
|
||
// readlen += Left_readlen;
|
||
// }
|
||
//
|
||
// pItem->pos += readlen;
|
||
// return readlen;
|
||
// }
|
||
//
|
||
// return 0;
|
||
//}
|
||
|
||
//------------------------------------------------------------------------------------------------------------
|
||
//
|
||
// 函数说明
|
||
//
|
||
//
|
||
// 参数说明
|
||
//
|
||
//
|
||
// 返回值
|
||
//
|
||
//
|
||
// 其他
|
||
// 无
|
||
//
|
||
//------------------------------------------------------------------------------------------------------------
|
||
int Img_CloseItem(HIMAGE hImage, HIMAGEITEM hItem)
|
||
{
|
||
ITEM_HANDLE *pItem = (ITEM_HANDLE *)hItem;
|
||
if (NULL == pItem) {
|
||
printf("sunxi sprite error : item is null when close it\n");
|
||
|
||
return -1;
|
||
}
|
||
//debug("try to free %x\n", (uint)pItem);
|
||
free(pItem);
|
||
pItem = NULL;
|
||
|
||
return 0;
|
||
}
|
||
|
||
//------------------------------------------------------------------------------------------------------------
|
||
//
|
||
// 函数说明
|
||
//
|
||
//
|
||
// 参数说明
|
||
//
|
||
//
|
||
// 返回值
|
||
//
|
||
//
|
||
// 其他
|
||
// 无
|
||
//
|
||
//------------------------------------------------------------------------------------------------------------
|
||
void Img_Close(HIMAGE hImage)
|
||
{
|
||
IMAGE_HANDLE *pImage = (IMAGE_HANDLE *)hImage;
|
||
|
||
if (NULL == pImage) {
|
||
printf("sunxi sprite error : imghead is null when close it\n");
|
||
|
||
return;
|
||
}
|
||
|
||
if (NULL != pImage->ItemTable) {
|
||
free(pImage->ItemTable);
|
||
pImage->ItemTable = NULL;
|
||
}
|
||
|
||
memset(pImage, 0, sizeof(IMAGE_HANDLE));
|
||
free(pImage);
|
||
pImage = NULL;
|
||
|
||
return;
|
||
}
|