static inline int read_SMARW() { return read_dword(1, 23,1); }
static inline int read_SMARR() { return read_dword(1, 21,1); }
static inline int read_SMALW() { return read_dword(1, 22,1); }
GLubyte * /* O - Bitmap data */
LoadDIBitmap(const char *filename, /* I - File to load */
BITMAPINFO **info) /* O - Bitmap information */
{
FILE *fp; /* Open file pointer */
GLubyte *bits; /* Bitmap pixel bits */
GLubyte *ptr; /* Pointer into bitmap */
GLubyte temp; /* Temporary variable to swap red and blue */
int x, y; /* X and Y position in image */
int length; /* Line length */
int bitsize; /* Size of bitmap */
int infosize; /* Size of header information */
BITMAPFILEHEADER header; /* File header */
/* Try opening the file; use "rb" mode to read this *binary* file. */
if ((fp = fopen(filename, "rb")) == NULL)
return (NULL);
/* Read the file header and any following bitmap information... */
header.bfType = read_word(fp);
header.bfSize = read_dword(fp);
header.bfReserved1 = read_word(fp);
header.bfReserved2 = read_word(fp);
header.bfOffBits = read_dword(fp);
if (header.bfType != BF_TYPE) /* Check for BM reversed... */
{
/* Not a bitmap file - return NULL... */
fclose(fp);
return (NULL);
}
infosize = header.bfOffBits - 18;
if ((*info = (BITMAPINFO *)malloc(sizeof(BITMAPINFO))) == NULL)
{
/* Couldn't allocate memory for bitmap info - return NULL... */
fclose(fp);
return (NULL);
}
(*info)->bmiHeader.biSize = read_dword(fp);
(*info)->bmiHeader.biWidth = read_long(fp);
(*info)->bmiHeader.biHeight = read_long(fp);
(*info)->bmiHeader.biPlanes = read_word(fp);
(*info)->bmiHeader.biBitCount = read_word(fp);
(*info)->bmiHeader.biCompression = read_dword(fp);
(*info)->bmiHeader.biSizeImage = read_dword(fp);
(*info)->bmiHeader.biXPelsPerMeter = read_long(fp);
(*info)->bmiHeader.biYPelsPerMeter = read_long(fp);
(*info)->bmiHeader.biClrUsed = read_dword(fp);
(*info)->bmiHeader.biClrImportant = read_dword(fp);
if (infosize > 40)
if (fread((*info)->bmiColors, infosize - 40, 1, fp) < 1)
{
/* Couldn't read the bitmap header - return NULL... */
free(*info);
fclose(fp);
return (NULL);
}
/* Now that we have all the header info read in, allocate memory for *
* the bitmap and read *it* in... */
if ((bitsize = (*info)->bmiHeader.biSizeImage) == 0)
bitsize = ((*info)->bmiHeader.biWidth *
(*info)->bmiHeader.biBitCount + 7) / 8 *
abs((*info)->bmiHeader.biHeight);
if ((bits = malloc(bitsize)) == NULL)
{
/* Couldn't allocate memory - return NULL! */
free(*info);
fclose(fp);
return (NULL);
}
if (fread(bits, 1, bitsize, fp) < bitsize)
{
/* Couldn't read bitmap - free memory and return NULL! */
free(*info);
free(bits);
fclose(fp);
return (NULL);
}
/* Swap red and blue */
length = ((*info)->bmiHeader.biWidth * 3 + 3) & ~3;
for (y = 0; y < (*info)->bmiHeader.biHeight; y ++)
for (ptr = bits + y * length, x = (*info)->bmiHeader.biWidth;
x > 0;
x --, ptr += 3)
{
temp = ptr[0];
ptr[0] = ptr[2];
ptr[2] = temp;
}
/* OK, everything went fine - return the allocated bitmap... */
fclose(fp);
return (bits);
}
HRESULT parse_dxbc(const char *data, SIZE_T data_size,
HRESULT (*chunk_handler)(const char *data, DWORD data_size, DWORD tag, void *ctx), void *ctx)
{
const char *ptr = data;
HRESULT hr = S_OK;
DWORD chunk_count;
DWORD total_size;
unsigned int i;
DWORD tag;
if (!data)
{
WARN("No data supplied.\n");
return E_FAIL;
}
read_dword(&ptr, &tag);
TRACE("tag: %s.\n", debugstr_an((const char *)&tag, 4));
if (tag != TAG_DXBC)
{
WARN("Wrong tag.\n");
return E_FAIL;
}
/* checksum? */
skip_dword_unknown("DXBC header", &ptr, 4);
skip_dword_unknown("DXBC header", &ptr, 1);
read_dword(&ptr, &total_size);
TRACE("total size: %#x\n", total_size);
if (data_size != total_size)
{
WARN("Wrong size supplied.\n");
return E_FAIL;
}
read_dword(&ptr, &chunk_count);
TRACE("chunk count: %#x\n", chunk_count);
for (i = 0; i < chunk_count; ++i)
{
DWORD chunk_tag, chunk_size;
const char *chunk_ptr;
DWORD chunk_offset;
read_dword(&ptr, &chunk_offset);
TRACE("chunk %u at offset %#x\n", i, chunk_offset);
chunk_ptr = data + chunk_offset;
read_dword(&chunk_ptr, &chunk_tag);
read_dword(&chunk_ptr, &chunk_size);
hr = chunk_handler(chunk_ptr, chunk_size, chunk_tag, ctx);
if (FAILED(hr)) break;
}
return hr;
}
void d2_client::mcp_thread_function(void * unused)
{
game_request_id = 0x02;
std::cout << "Connecting to realm server " << mcp_ip << ":" << mcp_port << std::endl;
if(mcp_socket.connect(mcp_ip, mcp_port))
std::cout << "Successfully connected to realm server" << std::endl;
else
std::cout << "Failed to connect to the realm server" << std::endl;
mcp_socket.send("\x01");
std::string packet = construct_mcp_packet(0x01, mcp_data);
mcp_socket.send(packet);
std::string mcp_buffer;
while(true)
{
std::string data;
if(!get_mcp_packet(mcp_socket, mcp_buffer, data))
break;
ulong identifier = read_byte(data, 2);
//std::cout << "MCP data:" << std::endl;
//std::cout << data << std::endl;
//print_data(data);
if(identifier == 0x01)
{
ulong result = read_dword(data, 3);
switch(result)
{
case 0x00:
std::cout << "Successfully logged on to realm server" << std::endl;
break;
case 0x7e:
std::cout << "Your CD key has been banned from playing on this realm!" << std::endl;
break;
case 0x7f:
std::cout << "Your IP has been banned temporarily!" << std::endl;
break;
default:
std::cout << "Unknown realm server logon error occured (" << std::hex << result << ")" << std::endl;
break;
}
if(result != 0)
return;
std::cout << "Requesting character list" << std::endl;
mcp_socket.send(construct_mcp_packet(0x19, dword_to_string(8)));
}
else if(identifier == 0x19)
{
ulong count = read_word(data, 9);
if(count == 0)
{
std::cout << "There are no characters on this account." << std::endl;
return;
}
else
{
bool found_character = false;
bool selected_first_character = false;
std::cout << "List of characters on this account:" << std::endl;
std::size_t offset = 11;
for(ulong i = 1; i <= count; i++)
{
offset += 4;
std::string character_name = read_string(data, offset);
std::string stats = read_string(data, offset);
ulong character_class = read_byte(stats, 13);
ulong level = read_byte(stats, 25);
ulong flags = read_byte(stats, 26);
bool hardcore = (flags & 0x04) != 0;
bool dead = (flags & 0x08) != 0;
bool expansion = (flags & 0x20) != 0;
std::string character_class_string = get_character_class_string(character_class);
std::string core_string = hardcore ? "Hardcore" : "Softcore";
std::string expansion_string = expansion ? "Expansion" : "Classic";
std::cout << i << ". " << character_name << ", Level " << level << " " << character_class_string << " (" << expansion_string << ", " << core_string;
if(hardcore && dead)
std::cout << ", Dead";
std::cout << ")" << std::endl;
//print_data(stats);
if(character.empty() && i == 1)
{
selected_first_character = true;
character = character_name;
}
if(character == character_name)
{
found_character = true;
class_byte = character_class - 1;
character_level = level;
}
}
if(selected_first_character)
std::cout << "No character was specified in the ini file so the first character is being used" << std::endl;
if(!found_character)
{
std::cout << "Unable to locate character specified in the ini file";
return;
}
std::cout << "Logging into character " << character << std::endl;
mcp_socket.send(construct_mcp_packet(0x07, character + zero));
}
}
else if(identifier == 0x07)
{
ulong result = read_dword(data, 3);
if(result != 0)
{
std::cout << "Failed to log into character (" << std::hex << result << ")" << std::endl;
return;
}
std::cout << "Successfully logged into character" << std::endl;
std::cout << "Requesting channel list" << std::endl;
bncs_socket.send(construct_bncs_packet(0x0b, lod_id));
std::cout << "Entering the chat server" << std::endl;
bncs_socket.send(construct_bncs_packet(0x0a, character + zero + realm + "," + character + zero));
std::cout << "Requesting MOTD" << std::endl;
mcp_socket.send(construct_mcp_packet(0x12, ""));
}
else if(identifier == 0x12)
{
std::cout << "Received MOTD" << std::endl;
}
else if(identifier == 0x03)
{
//print_data(data);
ulong result = read_dword(data, 9);
switch(result)
{
case 0x00:
std::cout << "Game has been created successfully" << std::endl;
break;
case 0x1e:
std::cout << "Invalid game name specified" << std::endl;
break;
case 0x1f:
std::cout << "This game already exists" << std::endl;
break;
case 0x20:
std::cout << "Game server down (it is probable that you tried to create a nightmare/hell game with a character who doesn't have access to that difficulty yet, or gamename/password were invalid)" << std::endl;
break;
case 0x6e:
std::cout << "Your character can't create a game because it's dead!" << std::endl;
break;
}
if(result == 0)
{
std::cout << "Joining the game we just created" << std::endl;
join_game(game_name, game_password);
}
}
else if(identifier == 0x04)
{
//print_data(data);
ulong result = read_word(data, 17);
switch(result)
{
case 0x00:
std::cout << "Successfully joined the game" << std::endl;
break;
case 0x29:
std::cout << "Password is incorrect" << std::endl;
break;
case 0x2A:
std::cout << "Game does not exist" << std::endl;
break;
case 0x2B:
std::cout << "Game is full" << std::endl;
break;
case 0x2C:
std::cout << "You do not meet the level requirements for this game" << std::endl;
break;
case 0x71:
std::cout << "A non-hardcore character cannot join a game created by a Hardcore character." << std::endl;
break;
case 0x73:
std::cout << "Unable to join a Nightmare game." << std::endl;
break;
case 0x74:
std::cout << "Unable to join a Hell game." << std::endl;
break;
case 0x78:
std::cout << "A non-expansion character cannot join a game created by an Expansion character." << std::endl;
break;
case 0x79:
std::cout << "A Expansion character cannot join a game created by a non-expansion character." << std::endl;
break;
case 0x7D:
std::cout << "A non-ladder character cannot join a game created by a Ladder character." << std::endl;
break;
}
if(result == 0)
{
ulong ip = read_dword(data, 9);
gs_ip = nil::net::ip_to_string(ip);
gs_hash = data.substr(13, 4);
gs_token = data.substr(5, 2);
bncs_socket.send(construct_bncs_packet(0x22, lod_id + dword_to_string(0xc) + game_name + zero + game_password + zero));
bncs_socket.send(construct_bncs_packet(0x10, ""));
gs_thread.start(nil::thread::function_type(*this, &d2_client::gs_thread_function));
}
}
}
std::cout << "Disconnected from MCP server" << std::endl;
}
unsigned long InternalEEPROMClass::IMCheck_read()
{
return read_dword(IMPointer);
}
static inline int read_CSL(int channel) { return read_dword(7,channel,0); }
static inline int read_CCCA(int channel) { return read_dword(0,channel,1); }
static inline int read_VTFT(int channel) { return read_dword(3,channel,0); }
static inline int read_PSST(int channel) { return read_dword(6,channel,0); }
static inline int read_CVCF(int channel) { return read_dword(2,channel,0); }
static inline int read_PTRX(int channel) { return read_dword(1,channel,0); }
/* read_*:
* Functions to read information from the AWE32's registers
* (abbreviated as in the AEPG).
*/
static inline int read_CPF(int channel) { return read_dword(0,channel,0); }
static zip_error read_ecd(zip_file *zip)
{
UINT32 buflen = 1024;
UINT8 *buffer;
/* we may need multiple tries */
while (buflen < 65536)
{
file_error error;
UINT32 read_length;
INT32 offset;
/* max out the buffer length at the size of the file */
if (buflen > zip->length)
buflen = zip->length;
/* allocate buffer */
buffer = (UINT8 *)malloc(buflen + 1);
if (buffer == nullptr)
return ZIPERR_OUT_OF_MEMORY;
/* read in one buffers' worth of data */
error = osd_read(zip->file, buffer, zip->length - buflen, buflen, &read_length);
if (error != FILERR_NONE || read_length != buflen)
{
free(buffer);
return ZIPERR_FILE_ERROR;
}
/* find the ECD signature */
for (offset = buflen - 22; offset >= 0; offset--)
if (buffer[offset + 0] == 'P' && buffer[offset + 1] == 'K' && buffer[offset + 2] == 0x05 && buffer[offset + 3] == 0x06)
break;
/* if we found it, fill out the data */
if (offset >= 0)
{
/* reuse the buffer as our ECD buffer */
zip->ecd.raw = buffer;
zip->ecd.rawlength = buflen - offset;
/* append a NULL terminator to the comment */
memmove(&buffer[0], &buffer[offset], zip->ecd.rawlength);
zip->ecd.raw[zip->ecd.rawlength] = 0;
/* extract ecd info */
zip->ecd.signature = read_dword(zip->ecd.raw + ZIPESIG);
zip->ecd.disk_number = read_word (zip->ecd.raw + ZIPEDSK);
zip->ecd.cd_start_disk_number = read_word (zip->ecd.raw + ZIPECEN);
zip->ecd.cd_disk_entries = read_word (zip->ecd.raw + ZIPENUM);
zip->ecd.cd_total_entries = read_word (zip->ecd.raw + ZIPECENN);
zip->ecd.cd_size = read_dword(zip->ecd.raw + ZIPECSZ);
zip->ecd.cd_start_disk_offset = read_dword(zip->ecd.raw + ZIPEOFST);
zip->ecd.comment_length = read_word (zip->ecd.raw + ZIPECOML);
zip->ecd.comment = (const char *)(zip->ecd.raw + ZIPECOM);
return ZIPERR_NONE;
}
/* didn't find it; free this buffer and expand our search */
free(buffer);
if (buflen < zip->length)
buflen *= 2;
else
return ZIPERR_BAD_SIGNATURE;
}
return ZIPERR_OUT_OF_MEMORY;
}
static inline int read_HWCF4() { return read_dword(1, 9,1); }
void slurp_pe_header(pe_header *header, FILE *fh, int *bytes_read) {
int btotal = 0;
header->Signature = read_dword(fh); btotal += 4;
header->Machine = read_word(fh); btotal += 2;
header->NumberOfSections = read_word(fh); btotal += 2;
header->TimeDateStamp = read_dword(fh); btotal += 4;
header->PointerToSymbolTable = read_dword(fh); btotal += 4;
header->NumberOfSymbols = read_dword(fh); btotal += 4;
header->SizeOfOptionalHeader = read_word(fh); btotal += 2;
header->Characteristics = read_word(fh); btotal += 2;
if (header->SizeOfOptionalHeader > 0) {
int j;
/* Standard fields */
header->Magic = read_word(fh); btotal += 2;
header->MajorLinkerVersion = read_byte(fh); btotal += 1;
header->MinorLinkerVersion = read_byte(fh); btotal += 1;
header->SizeOfCode = read_dword(fh); btotal += 4;
header->SizeOfInitializedData = read_dword(fh); btotal += 4;
header->SizeOfUninitializedData = read_dword(fh); btotal += 4;
header->AddressOfEntryPoint = read_dword(fh); btotal += 4;
header->BaseOfCode = read_dword(fh); btotal += 4;
header->BaseOfData = read_dword(fh); btotal += 4;
/* NT additional fields */
header->ImageBase = read_dword(fh); btotal += 4;
header->SectionAlignment = read_dword(fh); btotal += 4;
header->FileAlignment = read_dword(fh); btotal += 4;
header->MajorOperatingSystemVersion = read_word(fh); btotal += 2;
header->MinorOperatingSystemVersion = read_word(fh); btotal += 2;
header->MajorImageVersion = read_word(fh); btotal += 2;
header->MinorImageVersion = read_word(fh); btotal += 2;
header->MajorSubsystemVersion = read_word(fh); btotal += 2;
header->MinorSubsystemVersion = read_word(fh); btotal += 2;
header->Win32VersionValue = read_dword(fh); btotal += 4;
header->SizeOfImage = read_dword(fh); btotal += 4;
header->SizeOfHeaders = read_dword(fh); btotal += 4;
header->CheckSum = read_dword(fh); btotal += 4;
header->Subsystem = read_word(fh); btotal += 2;
header->DllCharacteristics = read_word(fh); btotal += 2;
header->SizeOfStackReserve = read_dword(fh); btotal += 4;
header->SizeOfStackCommit = read_dword(fh); btotal += 4;
header->SizeOfHeapReserve = read_dword(fh); btotal += 4;
header->SizeOfHeapCommit = read_dword(fh); btotal += 4;
header->LoaderFlags = read_dword(fh); btotal += 4;
header->NumberOfRvaAndSizes = read_dword(fh); btotal += 4;
header->DataDirectories = (pe_data_directory *)
malloc(sizeof(pe_data_directory) * header->NumberOfRvaAndSizes);
for (j = 0; j < header->NumberOfRvaAndSizes; ++j) {
header->DataDirectories[j].VirtualAddress = read_dword(fh); btotal += 4;
header->DataDirectories[j].Size = read_dword(fh); btotal += 4;
}
}
*bytes_read = btotal;
}
static inline int read_HWCF5() { return read_dword(1, 10,1); }
HRESULT parse_dxbc(const char *data, SIZE_T data_size,
HRESULT (*chunk_handler)(const char *data, DWORD data_size, DWORD tag, void *ctx), void *ctx)
{
const char *ptr = data;
HRESULT hr = S_OK;
DWORD chunk_count;
DWORD total_size;
unsigned int i;
DWORD tag;
read_dword(&ptr, &tag);
TRACE("tag: %s.\n", debugstr_an((const char *)&tag, 4));
if (tag != TAG_DXBC)
{
WARN("Wrong tag.\n");
return E_INVALIDARG;
}
/* checksum? */
skip_dword_unknown(&ptr, 4);
skip_dword_unknown(&ptr, 1);
read_dword(&ptr, &total_size);
TRACE("total size: %#x\n", total_size);
read_dword(&ptr, &chunk_count);
TRACE("chunk count: %#x\n", chunk_count);
for (i = 0; i < chunk_count; ++i)
{
DWORD chunk_tag, chunk_size;
const char *chunk_ptr;
DWORD chunk_offset;
read_dword(&ptr, &chunk_offset);
TRACE("chunk %u at offset %#x\n", i, chunk_offset);
if (chunk_offset >= data_size || !require_space(chunk_offset, 2, sizeof(DWORD), data_size))
{
WARN("Invalid chunk offset %#x (data size %#lx).\n", chunk_offset, data_size);
return E_FAIL;
}
chunk_ptr = data + chunk_offset;
read_dword(&chunk_ptr, &chunk_tag);
read_dword(&chunk_ptr, &chunk_size);
if (!require_space(chunk_ptr - data, 1, chunk_size, data_size))
{
WARN("Invalid chunk size %#x (data size %#lx, chunk offset %#x).\n", chunk_size, data_size, chunk_offset);
return E_FAIL;
}
hr = chunk_handler(chunk_ptr, chunk_size, chunk_tag, ctx);
if (FAILED(hr)) break;
}
return hr;
}
static inline int read_HWCF6() { return read_dword(1, 13,1); }
static int authenticate_to_floppyd(char fullauth, int sock, char *display,
int protoversion)
{
off_t filelen=0;
Byte buf[16];
const char *command[] = { "xauth", "xauth", "extract", "-", 0, 0 };
char *xcookie = NULL;
Dword errcode;
int bytesRead;
if (fullauth) {
command[4] = display;
filelen=strlen(display);
filelen += 100;
xcookie = (char *) safe_malloc(filelen+4);
filelen = safePopenOut(command, xcookie+4, filelen);
if(filelen < 1)
return AUTH_AUTHFAILED;
}
dword2byte(4,buf);
dword2byte(protoversion,buf+4);
if(write(sock, buf, 8) < 8)
return AUTH_IO_ERROR;
bytesRead = read_dword(sock);
if (bytesRead != 4 && bytesRead != 12) {
return AUTH_WRONGVERSION;
}
errcode = read_dword(sock);
if (errcode != AUTH_SUCCESS) {
return errcode;
}
if(bytesRead == 8) {
protoversion = read_dword(sock);
read_dword(sock);
}
fprintf(stderr, "Protocol Version=%d\n", protoversion);
if (fullauth) {
dword2byte(filelen, (Byte *) xcookie);
if(write(sock, xcookie, filelen+4) < filelen+4)
return AUTH_IO_ERROR;
if (read_dword(sock) != 4) {
return AUTH_PACKETOVERSIZE;
}
errcode = read_dword(sock);
}
return errcode;
}
static inline int read_SMALR() { return read_dword(1, 20,1); }
void lschunks(FILE *f,int level,unsigned int endpos){
unsigned int atom_size;
unsigned int atom_type;
int pos;
while(endpos==0 || ftell(f)<endpos){
pos=ftell(f);
atom_size=read_dword(f);// if(fread(&atom_size_b,4,1,f)<=0) break;
if(fread(&atom_type,4,1,f)<=0) break;
if(atom_size<8) break; // error
printf("%08X: %*s %.4s (%08X) %05d [%s] (begin: %08X)\n",pos,level*2,"",&atom_type,atom_type,atom_size,
atom2human_type(atom_type), pos+8); // 8: atom_size fields (4) + atom_type fields (4)
#ifndef NO_SPECIAL
// if (atom_type == 0x61746475)
// userdata_info(f, atom_size, pos, level);
if (atom_type == 0x6468646D)
{
char data[4];
fread(&data, 1, 1, f); // char
printf("mdhd version %d\n", data[0]);
fread(&data, 3, 1, f); // int24
fread(&data, 4, 1, f); // int32
fread(&data, 4, 1, f); // int32
fread(&data, 4, 1, f); // int32
time_scale = (data[0] << 24) | (data[1] << 16) | (data[2] << 8) | data[3];
printf("timescale: %d\n", time_scale);
fread(&data, 4, 1, f); // int32
fread(&data, 2, 1, f); // int16
fread(&data, 2, 1, f); // int16
}
if (atom_type == 0x64686D76)
{
stream = S_VIDEO;
printf(" Found VIDEO Stream #%d\n", v_stream++);
}
if (atom_type == 0x64686D73)
{
stream = S_AUDIO;
printf(" Found AUDIO Stream #%d\n", a_stream++);
}
if (atom_type == 0x64686B74) // tkhd - track header
{
int i;
unsigned char data[atom_size];
int x, y;
for (i=0; i<atom_size; i++)
fread(&data[i], 1, 1, f);
x = data[77];
y = data[81];
printf(" Flags: %d\n", data[3]);
printf(" Picture size: %dx%d\n", x, y);
if (x == 0 && y == 0)
printf(" Possible audio stream!\n");
}
if(atom_type==0x64737473) { // stsd
unsigned int tmp;
unsigned int count;
int i;
fread(&tmp,4,1,f);
count=read_dword(f);// fread(&count,4,1,f);
printf("desc count = %d\n",count);
for(i=0;i<count;i++){
unsigned int len;
unsigned int format;
len=read_dword(f); // fread(&len,4,1,f);
fread(&format,4,1,f);
printf(" desc #%d: %.4s (%d)\n",i+1,&format,len);
if (stream == S_VIDEO)
video_stream_info(f, len);
if (stream == S_AUDIO)
audio_stream_info(f, len);
fseek(f,len-8,SEEK_CUR);
}
}
if(atom_type==0x6F637473) { // stco
int len,i;
read_dword(f);
len=read_dword(f);
printf("Chunk table size :%d\n",len);
for(i=0;i<len;i++) printf(" chunk #%d: 0x%X\n",i+1,read_dword(f));
}
if(atom_type==0x73747473) { // stts
int len,i;
read_dword(f);
len=read_dword(f);
printf("T->S table size :%d\n",len);
for(i=0;i<len;i++){
int num=read_dword(f);
int dur=read_dword(f);
printf("%5d samples: %d duration", num, dur);
if (stream == S_AUDIO)
printf("(rate: %f Hz)\n", (float)time_scale/dur);
else
printf("(fps: %f)\n", (float)time_scale/dur);
}
}
if(atom_type==0x63737473) { // stsc
int len,i;
read_dword(f);
len=read_dword(f);
printf("S->C table size :%d\n",len);
for(i=0;i<len;i++){
int first=read_dword(f);
int spc=read_dword(f);
int sdid=read_dword(f);
printf(" chunk %d... %d s/c desc: %d\n",first,spc,sdid);
}
}
if(atom_type==0x7A737473) { // stsz
int len,i,ss;
read_dword(f);
ss=read_dword(f);
len=read_dword(f);
printf("Sample size table len: %d\n",len);
if(ss){
printf(" common sample size: %d bytes\n",ss);
} else {
for(i=0;i<len;i++) printf(" sample #%d: %d bytes\n",i+1,read_dword(f));
}
}
#endif
#if 1
switch(atom_type){
case 0x7461646D: // mdat Movie data
case 0x75716D72: // rmqu
case 0x65657266: // free JUNK
case 0x64686B74: // tkhd Track header
case 0x61746475: // udta User data
case 0x64737473: // stsd Sample description
case 0x6F637473: // stco Chunk offset table
case 0x73747473: // stts Sample time table
case 0x63737473: // stsc Sample->Chunk mapping table
case 0x7A737473: // stsz Sample size table
case 0x746f6e70: // pnot
case 0x54434950: // PICT
case 0x70797466:
break;
default: lschunks(f,level+1,pos+atom_size);
}
#else
switch(atom_type){
case 0x766F6F6D: // moov
case 0x61726D72: // rmra
case 0x61646D72: // rmda
lschunks(f,level+1,pos+atom_size);
}
#endif
fseek(f,pos+atom_size,SEEK_SET);
}
}
check_revision_result_type check_revision(std::string const & formula, std::string const & mpq, std::string const & directory, ulong & output)
{
/*
Examples:
std::string const formula = "A=4095648652 B=3744856545 C=4182215876 4 A=A^S B=B+C C=C+A A=A^B";
std::string const mpq = "ver-IX86-4.mpq";
*/
typedef unsigned (*operator_type)(unsigned, unsigned);
//thanks to Zoxc for noticing the operator count bug
std::size_t const variable_count = 3;
std::size_t const operator_count = 4;
unsigned values[variable_count];
operator_type operators[operator_count];
std::vector<std::string> tokens = nil::string::tokenise(formula, " ");
std::size_t offset;
for(offset = 0; offset < tokens.size(); offset++)
{
std::string const & token = tokens[offset];
if(token == "4")
{
offset++;
break;
}
else if(token.size() < 3)
return check_revision_result_formula_error;
char variable_letter = token[0];
std::string number_string = token.substr(2);
unsigned number;
if(!nil::string::string_to_number<unsigned>(number_string, number))
return check_revision_result_formula_error;
std::size_t variable_index;
if(!get_variable_index(variable_letter, variable_index))
return check_revision_result_formula_error;
values[variable_index] = number;
}
for(std::size_t i = 0; offset < tokens.size(); i++, offset++)
{
std::string const & token = tokens[offset];
if(token.size() != 5)
return check_revision_result_formula_error;
operator_type current_operator;
switch(token[3])
{
case '+':
current_operator = &operator_add;
break;
case '-':
current_operator = &operator_sub;
break;
case '^':
current_operator = &operator_xor;
break;
default:
return check_revision_result_formula_error;
}
operators[i] = current_operator;
}
std::size_t mpq_index;
if(!get_mpq_index(mpq, mpq_index))
return check_revision_result_mpq_error;
unsigned mpq_hash = mpq_hash_codes[mpq_index];
unsigned a = values[0];
unsigned b = values[1];
unsigned c = values[2];
a ^= mpq_hash;
for(std::size_t i = 0; i < CountOf(d2_files); i++)
{
std::string content;
std::string file = directory + d2_files[i];
//std::cout << "Loading Diablo II binary " << file << " for hashing" << std::endl;
if(!nil::read_file(file, content))
return check_revision_result_file_error;
for(std::size_t j = 0; j < content.length(); j += 4)
{
unsigned s = read_dword(content, j);
//A=A^S B=B+C C=C+A A=A^B
//the variable positions are fixed
a = operators[0](a, s);
b = operators[1](b, c);
c = operators[2](c, a);
a = operators[3](a, b);
}
}
output = c;
return check_revision_result_success;
}
