DCADEC_API int dcadec_frame_parse_header(const uint8_t *data, size_t *size)
{
struct bitstream bits;
uint8_t header[DCADEC_FRAME_HEADER_SIZE];
size_t header_size, frame_size;
int ret;
if (!data || !size)
return -DCADEC_EINVAL;
if ((ret = dcadec_frame_convert_bitstream(header, &header_size,
data, DCADEC_FRAME_HEADER_SIZE)) < 0)
return ret;
bits_init(&bits, header, header_size);
switch (bits_get(&bits, 32)) {
case SYNC_WORD_CORE: {
bool normal_frame = bits_get1(&bits);
int deficit_samples = bits_get(&bits, 5) + 1;
int npcmblocks;
if (normal_frame && deficit_samples != 32)
return -DCADEC_ENOSYNC;
bits_skip1(&bits);
npcmblocks = bits_get(&bits, 7) + 1;
if ((npcmblocks & 7) && (npcmblocks < 6 || normal_frame))
return -DCADEC_ENOSYNC;
frame_size = bits_get(&bits, 14) + 1;
if (frame_size < 96)
return -DCADEC_ENOSYNC;
if (ret & DCADEC_BITSTREAM_BE14)
*size = frame_size * 8 / 14 * 2;
else
*size = frame_size;
return DCADEC_FRAME_TYPE_CORE;
}
case SYNC_WORD_EXSS: {
bool wide_hdr;
bits_skip(&bits, 10);
wide_hdr = bits_get1(&bits);
header_size = bits_get(&bits, 8 + 4 * wide_hdr) + 1;
if ((header_size & 3) || header_size < DCADEC_FRAME_HEADER_SIZE)
return -DCADEC_ENOSYNC;
frame_size = bits_get(&bits, 16 + 4 * wide_hdr) + 1;
if ((frame_size & 3) || frame_size < header_size)
return -DCADEC_ENOSYNC;
*size = frame_size;
return DCADEC_FRAME_TYPE_EXSS;
}
default:
return -DCADEC_ENOSYNC;
}
}
int main(int argc, char *argv[])
{
long id;
char name[NAME_LEN];
char rasdial[RAS_LEN];
memset(name,'\0',NAME_LEN);
memset(rasdial,'\0',RAS_LEN);
Bits bits;
int ret = bits_init(&bits,LEN);
if(-1 == ret){
fprintf(stderr,"bits_init error %s %d\n",__FILE__,__LINE__);
}
FILE *save;
save = fopen("random_save.txt","a+");
if(NULL == save){
fprintf(stderr,"open random_save.text failed\n");
exit(1);
}
long times=0;
long count=0;
srand((int)time(0));
do{
id = rand();
id = ((id<<4) + rand()) % LEN;
if(!bits_get(&bits,id))
{
bits_set(&bits,id);
}
else
{
printf("Repeat times %ld\n",++count);
continue;
}
if (LEN-1 == times){
printf("Have try all size=%ld\n",times);
goto EXIT;
}
sprintf(name,"TYT010%03ld",id);
sprintf(rasdial,"rasdial pppoe %s 8888\n",name);
printf("times=%ld %s",++times,rasdial);
ret = system(rasdial);
}while(0 != ret);
EXIT:
bits_destroy(&bits);
fprintf(save,"times=%ld %s",times,rasdial);
printf("Final Rpeat times %ld\n",count);
return 0;
}
static void lzss_decompress(unsigned char *uncompr, DWORD uncomprlen,
unsigned char *compr, DWORD comprlen)
{
unsigned int act_uncomprlen = 0;
/* compr中的当前字节中的下一个扫描位的位置 */
unsigned int curbit = 0;
/* compr中的当前扫描字节 */
unsigned int curbyte = 0;
unsigned int nCurWindowByte = 0x7ef;
BYTE win[2048];
struct bits bits;
memset(win, 0x20, nCurWindowByte);
bits_init(&bits, compr, comprlen);
while (1) {
/* 如果为0, 表示接下来的1个字节原样输出 */
unsigned int flag;
if (bits_get_high(&bits, 1, &flag))
break;
if (flag) {
unsigned int data;
if (bits_get_high(&bits, 8, &data))
break;
uncompr[act_uncomprlen++] = data;
/* 输出的1字节放入滑动窗口 */
win[nCurWindowByte++] = data;
nCurWindowByte &= sizeof(win) - 1;
} else {
unsigned int copy_bytes, win_offset;
unsigned int i;
if (bits_get_high(&bits, 11, &win_offset))
break;
if (bits_get_high(&bits, 4, ©_bytes))
break;
copy_bytes += 2;
for (i = 0; i < copy_bytes; i++) {
unsigned char data;
data = win[(win_offset + i) & (sizeof(win) - 1)];
uncompr[act_uncomprlen++] = data;
/* 输出的1字节放入滑动窗口 */
win[nCurWindowByte++] = data;
nCurWindowByte &= sizeof(win) - 1;
}
}
}
}
static DWORD Touhou11_uncompress(BYTE *uncompr, DWORD uncomprlen,
BYTE *compr, DWORD comprlen)
{
struct bits bits;
bits_init(&bits, compr, comprlen);
BYTE window[8192];
DWORD win_pos = 1;
DWORD act_uncomprlen = 0;
while (1) {
unsigned int flag;
bit_get_high(&bits, &flag);
if (flag) {
unsigned int data;
bits_get_high(&bits, 8, &data);
uncompr[act_uncomprlen++] = data;
window[win_pos] = data;
win_pos = (win_pos + 1) & 0x1fff;
} else {
unsigned int offset = 0;
bits_get_high(&bits, 13, &offset);
if (!offset)
return act_uncomprlen;
unsigned int count;
bits_get_high(&bits, 4, &count);
count += 3;
for (DWORD i = 0; i < count; ++i) {
BYTE data = window[(i + offset) & 0x1fff];
uncompr[act_uncomprlen++] = data;
window[win_pos] = data;
win_pos = (win_pos + 1) & 0x1fff;
}
}
}
return act_uncomprlen;
}
int exss_parse(struct exss_parser *exss, uint8_t *data, int size)
{
int i, j, ret;
bits_init(&exss->bits, data, size);
// Extension substream sync word
bits_skip(&exss->bits, 32);
// User defined bits
bits_skip(&exss->bits, 8);
// Extension substream index
exss->exss_index = bits_get(&exss->bits, 2);
// Flag indicating short or long header size
bool wide_hdr = bits_get1(&exss->bits);
// Extension substream header length
int header_size = bits_get(&exss->bits, 8 + 4 * wide_hdr) + 1;
// Check CRC
if ((ret = bits_check_crc(&exss->bits, 32 + 8, header_size * 8)) < 0) {
exss_err("Invalid EXSS header checksum");
return ret;
}
exss->exss_size_nbits = 16 + 4 * wide_hdr;
// Number of bytes of extension substream
exss->exss_size = bits_get(&exss->bits, exss->exss_size_nbits) + 1;
if (exss->exss_size > size) {
exss_err("Packet too short for EXSS frame");
return -DCADEC_EBADDATA;
}
// Per stream static fields presence flag
exss->static_fields_present = bits_get1(&exss->bits);
if (exss->static_fields_present) {
// Reference clock code
bits_skip(&exss->bits, 2);
// Extension substream frame duration
bits_skip(&exss->bits, 3);
// Timecode presence flag
if (bits_get1(&exss->bits)) {
// Timecode data
bits_skip(&exss->bits, 32);
bits_skip(&exss->bits, 4);
}
// Number of defined audio presentations
exss->npresents = bits_get(&exss->bits, 3) + 1;
// Number of audio assets in extension substream
exss->nassets = bits_get(&exss->bits, 3) + 1;
// Reject unsupported features for now
if (exss->npresents > 1 || exss->nassets > 1) {
exss_err_once("Multiple audio presentations "
"and/or assets are not supported");
return -DCADEC_ENOSUP;
}
// Active extension substream mask for audio presentation
int active_exss_mask[8];
for (i = 0; i < exss->npresents; i++)
active_exss_mask[i] = bits_get(&exss->bits, exss->exss_index + 1);
// Active audio asset mask
for (i = 0; i < exss->npresents; i++)
for (j = 0; j <= exss->exss_index; j++)
if (active_exss_mask[i] & (1 << j))
bits_skip(&exss->bits, 8);
// Mixing metadata enable flag
exss->mix_metadata_enabled = bits_get1(&exss->bits);
if (exss->mix_metadata_enabled) {
// Mixing metadata adjustment level
bits_skip(&exss->bits, 2);
// Number of bits for mixer output speaker activity mask
int spkr_mask_nbits = (bits_get(&exss->bits, 2) + 1) << 2;
// Number of mixing configurations
exss->nmixoutconfigs = bits_get(&exss->bits, 2) + 1;
// Speaker layout mask for mixer output channels
for (i = 0; i < exss->nmixoutconfigs; i++)
exss->nmixoutchs[i] = count_chs_for_mask(bits_get(&exss->bits, spkr_mask_nbits));
}
} else {
exss->npresents = 1;
exss->nassets = 1;
}
// Reallocate assets
if (ta_zalloc_fast(exss, &exss->assets, exss->nassets, sizeof(struct exss_asset)) < 0)
return -DCADEC_ENOMEM;
// Size of encoded asset data in bytes
int offset = header_size;
for (i = 0; i < exss->nassets; i++) {
exss->assets[i].asset_offset = offset;
exss->assets[i].asset_size = bits_get(&exss->bits, exss->exss_size_nbits) + 1;
offset += exss->assets[i].asset_size;
if (offset > exss->exss_size) {
exss_err("Asset out of bounds");
return -DCADEC_EBADDATA;
}
}
// Audio asset descriptor
for (i = 0; i < exss->nassets; i++) {
exss->assets[i].parser = exss;
if ((ret = parse_descriptor(&exss->assets[i])) < 0)
return ret;
if ((ret = set_exss_offsets(&exss->assets[i])) < 0) {
exss_err("Invalid extension size in asset descriptor");
return ret;
}
}
// Backward compatible core present
// Backward compatible core substream index
// Backward compatible core asset index
// Reserved
// Byte align
// CRC16 of extension substream header
if ((ret = bits_seek(&exss->bits, header_size * 8)) < 0)
exss_err("Read past end of EXSS header");
return ret;
}
/* 封包资源提取函数 */
static int CatSystem2_hg2_extract_resource(struct package *pkg,
struct package_resource *pkg_res)
{
u32 hg2_size;
if (pkg->pio->length_of(pkg, &hg2_size))
return CUI_ELEN;
BYTE *hg2 = new BYTE[hg2_size];
if (!hg2)
return -CUI_EMEM;
if (pkg->pio->readvec(pkg, hg2, hg2_size, 0, IO_SEEK_SET)) {
delete [] hg2;
return -CUI_EREADVEC;
}
hg2_header_t *hg2_header = (hg2_header_t *)hg2;
hg2_info_t *hg2_info = (hg2_info_t *)(hg2_header + 1);
hg2_info2_t *hg2_info2 = (hg2_info2_t *)(hg2_info + 1);
BYTE *compr;
switch (hg2_header->mode) {
case 0x25:
compr = (BYTE *)hg2_info2 + hg2_info2->sizeof_info2;
break;
case 0x10:
break;
case 0x20:
break;
}
BYTE *uncompr = new BYTE[hg2_info->rgb_uncomprlen + 16];
if (!uncompr) {
delete [] hg2;
return -CUI_EMEM;
}
DWORD act_uncomprlen = hg2_info->rgb_uncomprlen + 16;
if (uncompress(uncompr, &act_uncomprlen, compr, hg2_info->rgb_comprlen) != Z_OK) {
delete [] uncompr;
delete [] hg2;
return -CUI_EUNCOMPR;
}
if (act_uncomprlen != hg2_info->rgb_uncomprlen) {
delete [] uncompr;
delete [] hg2;
return -CUI_EUNCOMPR;
}
BYTE *uncompr2 = new BYTE[hg2_info->uncomprlen2 + 16];
if (!uncompr2) {
delete [] uncompr;
delete [] hg2;
return -CUI_EMEM;
}
act_uncomprlen = hg2_info->uncomprlen2 + 16;
compr += hg2_info->rgb_comprlen;
if (uncompress(uncompr2, &act_uncomprlen, compr, hg2_info->alpha_comprlen) != Z_OK) {
delete [] uncompr2;
delete [] uncompr;
delete [] hg2;
return -CUI_EUNCOMPR;
}
if (act_uncomprlen != hg2_info->uncomprlen2) {
delete [] uncompr2;
delete [] uncompr;
delete [] hg2;
return -CUI_EUNCOMPR;
}
DWORD table[4][256];
for (DWORD i = 0; i < 256; i++) {
int dat = (i & 3) | (((i & 0xc) | (((i & 0x30) | ((BYTE)(p & 0xc0) << 6)) << 6)) << 6);
table[0][i] = dat << 6;
table[1][i] = dat << 4;
table[2][i] = dat << 2;
table[3][i] = dat;
}
DWORD bpp = hg2_info->bpp / 8;
DWORD line_len = hg2_info->width * bpp;
DWORD dib_size = hg2_info->height * line_len;
struct bits bits;
bits_init(&bits, uncompr2, hg2_info->uncomprlen2);
DWORD flag = bit_get_high(&bits);
if (!flag) {
delete [] uncompr2;
delete [] uncompr;
delete [] hg2;
return -CUI_EMATCH;
}
DWORD len = get_lenth(&bits);
BYTE *buffer2 = new BYTE[len](0);
if (!buffer2) {
delete [] uncompr2;
delete [] uncompr;
delete [] hg2;
return -CUI_EUNCOMPR;
}
for (DWORD i = 0; i < len; i++)
buffer2[i] = uncompr[i];
if (len & 3) {
delete [] buffer2;
delete [] uncompr2;
delete [] uncompr;
delete [] hg2;
return -CUI_EMATCH;
}
DWORD *buffer1 = new DWORD[len / 4];
if (!buffer1) {
delete [] buffer2;
delete [] uncompr2;
delete [] uncompr;
delete [] hg2;
return -CUI_EMEM;
}
BYTE *src1 = buffer2;
BYTE *src2 = buffer2 + len / 2;
for (i = 0; i < len / 4; i++) {
buffer1[i] = table[0][*src1] | table[1][src1[len / 4]] | table[2][*src2] | table[3][src2[len / 4]];
src1++;
src2++;
}
delete [] buffer2;
BYTE *dib = new BYTE[dib_size];
if (!dib) {
delete [] buffer1;
delete [] uncompr2;
delete [] uncompr;
delete [] hg2;
return -CUI_EMEM;
}
BYTE cross_table[256];
for (i = 0; i < 128; i++) {
cross_table[i * 2 + 0] = i;
cross_table[i * 2 + 1] = 255 - i;
}
// 输出一行第一个象素
BYTE *dst = dib + (hg2_info->height - 1) * line_len;
BYTE *pre = dst;
BYTE *src = buffer1;
for (i = 0; i < bpp; i++)
*dst++ = cross_table[*src++];
// 输出余下行
for (DWORD y = 1; y < hg2_info->height; y++) {
cur = pre - line_len;
for (DWORD x = 0; x < line_len; x++)
cur[x] = pre[x] + cross_table[*src++];
pre -= line_len;
}
delete [] buffer1;
if (hg2_info->key) {
for (y = 0; y < hg2_info->height; y++) {
}
}
printf("ok\n");exit(0);
delete [] hg2;
return 0;
}
