static void
LoadGroupQueue (DECODE_REF fh, QUEUE *pQueue)
{
COUNT num_links;
cread_16 (fh, &num_links);
while (num_links--)
{
HIPGROUP hGroup;
IP_GROUP *GroupPtr;
BYTE tmpb;
cread_16 (fh, NULL); /* unused; was race_id */
hGroup = BuildGroup (pQueue, 0);
GroupPtr = LockIpGroup (pQueue, hGroup);
cread_16 (fh, NULL); /* unused; was which_side */
cread_8 (fh, NULL); /* unused; was captains_name_index */
cread_8 (fh, NULL); /* padding; for savegame compat */
cread_16 (fh, &GroupPtr->group_counter);
cread_8 (fh, &GroupPtr->race_id);
cread_8 (fh, &tmpb); /* was var2 */
GroupPtr->sys_loc = LONIBBLE (tmpb);
GroupPtr->task = HINIBBLE (tmpb);
cread_8 (fh, &GroupPtr->in_system); /* was crew_level */
cread_8 (fh, NULL); /* unused; was max_crew */
cread_8 (fh, &tmpb); /* was energy_level */
GroupPtr->dest_loc = LONIBBLE (tmpb);
GroupPtr->orbit_pos = HINIBBLE (tmpb);
cread_8 (fh, &GroupPtr->group_id); /* was max_energy */
cread_16s(fh, &GroupPtr->loc.x);
cread_16s(fh, &GroupPtr->loc.y);
UnlockIpGroup (pQueue, hGroup);
}
}
static void
bubble_preprocess (ELEMENT *ElementPtr)
{
BYTE thrust_wait, turn_wait;
thrust_wait = HINIBBLE (ElementPtr->turn_wait);
turn_wait = LONIBBLE (ElementPtr->turn_wait);
if (thrust_wait > 0)
--thrust_wait;
else
{
ElementPtr->next.image.frame =
IncFrameIndex (ElementPtr->current.image.frame);
ElementPtr->state_flags |= CHANGING;
thrust_wait = (BYTE)((COUNT)TFB_Random () & 3);
}
if (turn_wait > 0)
--turn_wait;
else
{
COUNT facing;
SIZE delta_facing;
facing = NORMALIZE_FACING (ANGLE_TO_FACING (
GetVelocityTravelAngle (&ElementPtr->velocity)));
if ((delta_facing = TrackShip (ElementPtr, &facing)) == -1)
facing = (COUNT)TFB_Random ();
else if (delta_facing <= ANGLE_TO_FACING (HALF_CIRCLE))
facing += (COUNT)TFB_Random () & (ANGLE_TO_FACING (HALF_CIRCLE) - 1);
else
facing -= (COUNT)TFB_Random () & (ANGLE_TO_FACING (HALF_CIRCLE) - 1);
SetVelocityVector (&ElementPtr->velocity,
MISSILE_SPEED, facing);
#define TRACK_WAIT 2
turn_wait = TRACK_WAIT;
}
ElementPtr->turn_wait = MAKE_BYTE (turn_wait, thrust_wait);
}
GString *
eo_massage_str(const gchar *in_str, gsize maxlen, int dupn)
{
gchar *tmp_ptr;
/* The characters in "reject" come from:
* http://msdn.microsoft.com/en-us/library/aa365247%28VS.85%29.aspx.
* Add to the list as necessary for other OS's.
*/
const gchar *reject = "<>:\"/\\|?*"
"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a"
"\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14"
"\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f";
GString *out_str;
GString *ext_str;
out_str = g_string_new("");
/* Find all disallowed characters/bytes and replace them with %xx */
while ( (tmp_ptr = strpbrk(in_str, reject)) != NULL ) {
out_str = g_string_append_len(out_str, in_str, tmp_ptr - in_str);
out_str = g_string_append_c(out_str, '%');
out_str = g_string_append_c(out_str, HEXTOASCII(HINIBBLE(*tmp_ptr)));
out_str = g_string_append_c(out_str, HEXTOASCII(LONIBBLE(*tmp_ptr)));
in_str = tmp_ptr + 1;
}
out_str = g_string_append(out_str, in_str);
if ( out_str->len > maxlen ) {
if ( (tmp_ptr = strrchr(out_str->str, '.')) != NULL ) {
/* Retain the extension */
ext_str = g_string_new(tmp_ptr);
out_str = g_string_truncate(out_str, maxlen - ext_str->len);
out_str = g_string_append(out_str, ext_str->str);
g_string_free(ext_str, TRUE);
}
else
out_str = g_string_truncate(out_str, maxlen);
}
if ( dupn != 0 )
out_str = eo_rename(out_str, dupn);
return out_str;
}
static void
blaster_preprocess (ELEMENT *ElementPtr)
{
BYTE wait;
switch (ElementPtr->mass_points)
{
case BLASTER_DAMAGE * 1:
if (GetFrameIndex (ElementPtr->current.image.frame) < 8)
{
ElementPtr->next.image.frame =
IncFrameIndex (ElementPtr->current.image.frame);
ElementPtr->state_flags |= CHANGING;
}
break;
case BLASTER_DAMAGE * 3:
if (GetFrameIndex (ElementPtr->current.image.frame) < 19)
ElementPtr->next.image.frame =
IncFrameIndex (ElementPtr->current.image.frame);
else
ElementPtr->next.image.frame =
SetAbsFrameIndex (ElementPtr->current.image.frame, 16);
ElementPtr->state_flags |= CHANGING;
break;
}
if (LONIBBLE (ElementPtr->turn_wait))
--ElementPtr->turn_wait;
else if ((wait = HINIBBLE (ElementPtr->turn_wait)))
{
COUNT facing;
facing = NORMALIZE_FACING (ANGLE_TO_FACING (
GetVelocityTravelAngle (&ElementPtr->velocity)));
if (TrackShip (ElementPtr, &facing) > 0)
SetVelocityVector (&ElementPtr->velocity, BLASTER_SPEED, facing);
ElementPtr->turn_wait = MAKE_BYTE (wait, wait);
}
}
void
dumpPlanetType (FILE *out, int index, const PlanetFrame *planetType)
{
int i;
fprintf (out,
"%s\n"
"\tType: %s\n"
"\tColor: %s\n"
"\tSurface generation algoritm: %s\n"
"\tTectonics: %s\n"
"\tAtmosphere: %s\n"
"\tDensity: %s\n"
"\tElements:\n",
planetTypeString (index),
worldSizeString (PLANSIZE (planetType->Type)),
bodyColorString (PLANCOLOR (planetType->Type)),
worldGenAlgoString (PLANALGO (planetType->Type)),
tectonicsString (planetType->BaseTectonics),
atmosphereString (HINIBBLE (planetType->AtmoAndDensity)),
densityString (LONIBBLE (planetType->AtmoAndDensity))
);
for (i = 0; i < NUM_USEFUL_ELEMENTS; i++)
{
const ELEMENT_ENTRY *entry;
entry = &planetType->UsefulElements[i];
if (entry->Density == 0)
continue;
fprintf(out, "\t\t0 to %d %s-quality (+%d) deposits of %s (%s)\n",
DEPOSIT_QUANTITY (entry->Density),
depositQualityString (DEPOSIT_QUALITY (entry->Density)),
DEPOSIT_QUALITY (entry->Density) * 5,
GAME_STRING (ELEMENTS_STRING_BASE + entry->ElementType),
GAME_STRING (CARGO_STRING_BASE + 2 + ElementCategory (
entry->ElementType))
);
}
fprintf (out, "\n");
}
static FIBITMAP *
LoadOS22XBMP(FreeImageIO *io, fi_handle handle, int flags, unsigned bitmap_bits_offset) {
FIBITMAP *dib = NULL;
try {
// load the info header
BITMAPINFOHEADER bih;
io->read_proc(&bih, sizeof(BITMAPINFOHEADER), 1, handle);
#ifdef FREEIMAGE_BIGENDIAN
SwapInfoHeader(&bih);
#endif
// keep some general information about the bitmap
int used_colors = bih.biClrUsed;
int width = bih.biWidth;
int height = bih.biHeight;
int bit_count = bih.biBitCount;
int compression = bih.biCompression;
int pitch = CalculatePitch(CalculateLine(width, bit_count));
switch (bit_count) {
case 1 :
case 4 :
case 8 :
{
if ((used_colors <= 0) || (used_colors > CalculateUsedPaletteEntries(bit_count)))
used_colors = CalculateUsedPaletteEntries(bit_count);
// allocate enough memory to hold the bitmap (header, palette, pixels) and read the palette
dib = FreeImage_Allocate(width, height, bit_count);
if (dib == NULL)
throw "DIB allocation failed";
BITMAPINFOHEADER *pInfoHeader = FreeImage_GetInfoHeader(dib);
pInfoHeader->biXPelsPerMeter = bih.biXPelsPerMeter;
pInfoHeader->biYPelsPerMeter = bih.biYPelsPerMeter;
// load the palette
io->seek_proc(handle, sizeof(BITMAPFILEHEADER) + bih.biSize, SEEK_SET);
RGBQUAD *pal = FreeImage_GetPalette(dib);
for (int count = 0; count < used_colors; count++) {
FILE_BGR bgr;
io->read_proc(&bgr, sizeof(FILE_BGR), 1, handle);
pal[count].rgbRed = bgr.r;
pal[count].rgbGreen = bgr.g;
pal[count].rgbBlue = bgr.b;
}
// seek to the actual pixel data.
// this is needed because sometimes the palette is larger than the entries it contains predicts
if (bitmap_bits_offset > (sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + (used_colors * 3)))
io->seek_proc(handle, bitmap_bits_offset, SEEK_SET);
// read the pixel data
switch (compression) {
case BI_RGB :
if (height > 0) {
io->read_proc((void *)FreeImage_GetBits(dib), height * pitch, 1, handle);
} else {
for (int c = 0; c < abs(height); ++c) {
io->read_proc((void *)FreeImage_GetScanLine(dib, height - c - 1), pitch, 1, handle);
}
}
return dib;
case BI_RLE4 :
{
BYTE status_byte = 0;
BYTE second_byte = 0;
int scanline = 0;
int bits = 0;
BOOL low_nibble = FALSE;
for (;;) {
io->read_proc(&status_byte, sizeof(BYTE), 1, handle);
switch (status_byte) {
case RLE_COMMAND :
io->read_proc(&status_byte, sizeof(BYTE), 1, handle);
switch (status_byte) {
case RLE_ENDOFLINE :
bits = 0;
scanline++;
low_nibble = FALSE;
break;
case RLE_ENDOFBITMAP :
return (FIBITMAP *)dib;
case RLE_DELTA :
{
// read the delta values
BYTE delta_x;
BYTE delta_y;
io->read_proc(&delta_x, sizeof(BYTE), 1, handle);
io->read_proc(&delta_y, sizeof(BYTE), 1, handle);
// apply them
bits += delta_x / 2;
scanline += delta_y;
break;
}
default :
io->read_proc(&second_byte, sizeof(BYTE), 1, handle);
BYTE *sline = FreeImage_GetScanLine(dib, scanline);
for (int i = 0; i < status_byte; i++) {
if (low_nibble) {
*(sline + bits) |= LOWNIBBLE(second_byte);
if (i != status_byte - 1)
io->read_proc(&second_byte, sizeof(BYTE), 1, handle);
bits++;
} else {
*(sline + bits) |= HINIBBLE(second_byte);
}
low_nibble = !low_nibble;
}
if (((status_byte / 2) & 1 ) == 1)
io->read_proc(&second_byte, sizeof(BYTE), 1, handle);
break;
};
break;
default :
{
BYTE *sline = FreeImage_GetScanLine(dib, scanline);
io->read_proc(&second_byte, sizeof(BYTE), 1, handle);
for (unsigned i = 0; i < status_byte; i++) {
if (low_nibble) {
*(sline + bits) |= LOWNIBBLE(second_byte);
bits++;
} else {
*(sline + bits) |= HINIBBLE(second_byte);
}
low_nibble = !low_nibble;
}
}
break;
};
}
break;
}
case BI_RLE8 :
{
BYTE status_byte = 0;
BYTE second_byte = 0;
int scanline = 0;
int bits = 0;
for (;;) {
io->read_proc(&status_byte, sizeof(BYTE), 1, handle);
switch (status_byte) {
case RLE_COMMAND :
io->read_proc(&status_byte, sizeof(BYTE), 1, handle);
switch (status_byte) {
case RLE_ENDOFLINE :
bits = 0;
scanline++;
break;
case RLE_ENDOFBITMAP :
return (FIBITMAP *)dib;
case RLE_DELTA :
{
// read the delta values
BYTE delta_x;
BYTE delta_y;
io->read_proc(&delta_x, sizeof(BYTE), 1, handle);
io->read_proc(&delta_y, sizeof(BYTE), 1, handle);
// apply them
bits += delta_x;
scanline += delta_y;
break;
}
default :
io->read_proc((void *)(FreeImage_GetScanLine(dib, scanline) + bits), sizeof(BYTE) * status_byte, 1, handle);
// align run length to even number of bytes
if ((status_byte & 1) == 1)
io->read_proc(&second_byte, sizeof(BYTE), 1, handle);
bits += status_byte;
break;
};
break;
default :
BYTE *sline = FreeImage_GetScanLine(dib, scanline);
io->read_proc(&second_byte, sizeof(BYTE), 1, handle);
for (unsigned i = 0; i < status_byte; i++) {
*(sline + bits) = second_byte;
bits++;
}
break;
};
}
break;
}
default :
throw "compression type not supported";
}
break;
}
case 16 :
{
if (bih.biCompression == 3) {
DWORD bitfields[3];
io->read_proc(bitfields, 3 * sizeof(DWORD), 1, handle);
dib = FreeImage_Allocate(width, height, bit_count, bitfields[0], bitfields[1], bitfields[2]);
} else {
dib = FreeImage_Allocate(width, height, bit_count, FI16_555_RED_MASK, FI16_555_GREEN_MASK, FI16_555_BLUE_MASK);
}
if (dib == NULL)
throw "DIB allocation failed";
BITMAPINFOHEADER *pInfoHeader = FreeImage_GetInfoHeader(dib);
pInfoHeader->biXPelsPerMeter = bih.biXPelsPerMeter;
pInfoHeader->biYPelsPerMeter = bih.biYPelsPerMeter;
if (bitmap_bits_offset > (sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + (used_colors * 3)))
io->seek_proc(handle, bitmap_bits_offset, SEEK_SET);
io->read_proc(FreeImage_GetBits(dib), height * pitch, 1, handle);
#ifdef FREEIMAGE_BIGENDIAN
for(int y = 0; y < FreeImage_GetHeight(dib); y++) {
WORD *pixel = (WORD *)FreeImage_GetScanLine(dib, y);
for(int x = 0; x < FreeImage_GetWidth(dib); x++) {
SwapShort(pixel);
pixel++;
}
}
#endif
return dib;
}
case 24 :
case 32 :
{
if( bit_count == 32 ) {
dib = FreeImage_Allocate(width, height, bit_count, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
} else {
dib = FreeImage_Allocate(width, height, bit_count, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
}
if (dib == NULL)
throw "DIB allocation failed";
BITMAPINFOHEADER *pInfoHeader = FreeImage_GetInfoHeader(dib);
pInfoHeader->biXPelsPerMeter = bih.biXPelsPerMeter;
pInfoHeader->biYPelsPerMeter = bih.biYPelsPerMeter;
// Skip over the optional palette
// A 24 or 32 bit DIB may contain a palette for faster color reduction
if (bitmap_bits_offset > (sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + (used_colors * 3)))
io->seek_proc(handle, bitmap_bits_offset, SEEK_SET);
// read in the bitmap bits
io->read_proc(FreeImage_GetBits(dib), height * pitch, 1, handle);
#ifdef FREEIMAGE_BIGENDIAN
for(int y = 0; y < FreeImage_GetHeight(dib); y++) {
BYTE *pixel = FreeImage_GetScanLine(dib, y);
for(int x = 0; x < FreeImage_GetWidth(dib); x++) {
INPLACESWAP(pixel[0], pixel[2]);
pixel += (bit_count>>3);
}
}
#endif
// check if the bitmap contains transparency, if so enable it in the header
FreeImage_SetTransparent(dib, (FreeImage_GetColorType(dib) == FIC_RGBALPHA));
return dib;
}
}
} catch(const char *message) {
if(dib)
FreeImage_Unload(dib);
FreeImage_OutputMessageProc(s_format_id, message);
}
return NULL;
}
enum video_content classify_video_by_payload(tcp_pair *ptp, void *pdata,
int data_length, int offset)
{
struct video_metadata *meta;
meta = &(ptp->streaming.metadata);
char *base = (char *) (pdata + offset);
int available_data = data_length - offset;
switch (*((u_int32_t *) base))
{
case VL7_FLV: /* parse header of an FLV video */
case VL7_FLV2: /* parse header of an FLV video */
if (available_data >= 27)
{
parse_flv_metadata(meta, base, available_data);
if (meta->duration > 0 && meta->bytelength > 0
&& meta->videodatarate == 0)
{
meta->videodatarate = (double) 8 * meta->bytelength
/ meta->duration / 1000;
}
else if (meta->videodatarate != 0 && meta->audiodatarate != 0)
{
meta->videodatarate += meta->audiodatarate;
}
if (debug > 0)
{
fprintf(fp_stdout,"FLV - Duration[min]: %.2f Res: %dx%d Bitrate: %.2f\n",
meta->duration / 60, meta->width, meta->height,
meta->videodatarate);
}
return VIDEO_FLV;
}
break;
case AVI: /* parse header of an AVI container */
if ((available_data >= 16) && memcmp(base + 8, "AVI LIST", 8) == 0)
{
parse_avi_metadata(meta, base, available_data);
if (debug > 0)
fprintf(fp_stdout,"AVI - Duration[min]: %.2f Res: %dx%d Bitrate: %.2f\n",
meta->duration / 60, meta->width, meta->height,
meta->videodatarate / 1000);
return VIDEO_AVI;
}
break;
case WMV_1: /* parse header of an ASF container */
case WMV_2:
if ((available_data >= 8) &&
(memcmp(base + 4, "\x8E\x66\xCF\x11", 4) == 0 ||
memcmp(base + 4, "\x00\x62\xCE\x6C", 4) == 0))
{
return VIDEO_WMV;
}
break;
case WEBM: /* parse header of an WEBM container */
if (((available_data >= 28) && memcmp(base + 24, "webm", 4) == 0) ||
((available_data >= 36) && memcmp(base + 31, "webm", 4) == 0))
{
return VIDEO_WEBM;
}
break;
case OGG: /* parse header of an OGG container
Obs. can also match OGG audio files*/
if (((available_data >= 8) && memcmp(base + 4, "\x00\x02\x00\x00", 4) == 0))
{
return VIDEO_OGG;
}
break;
default:
/* parse header of an MP4 container
* As suggested in http://www.garykessler.net/library/file_sigs.html
* MP4 container is matched as 00 00 00 XX 66 74 79 70*/
if ((available_data >= 12) &&
memcmp(base, "\x00\x00\x00", 3) == 0 &&
memcmp(base + 4, "ftyp", 4) == 0)
{
if ((*(base +3 ) == 0x14) //3GPP v1
|| (*(base ) == 0x20) //3GPP v2
|| (*(base ) == 0x1C)) //3GPP Release 4
{
return VIDEO_3GPP;
}
else
{
parse_mp4_metadata(meta, base, available_data);
if (debug > 0)
{
fprintf(fp_stdout,"MP4 - Duration[min]: %.2f Res: %dx%d Bitrate: %.2f\n",
meta->duration / 60, meta->width, meta->height,
meta->videodatarate / 1000);
}
return VIDEO_MP4;
}
}
else if ((available_data >= 8) && memcmp(base + 4, "moof", 4) == 0)
{
return VIDEO_MP4;
}
else if ((available_data >= 4) &&
memcmp(base, "\x00\x00\x01", 3) == 0 &&
HINIBBLE(*(base+3)) == 0xB)
{
return VIDEO_MPEG;
}
else if ((available_data >= 16) &&
memcmp(base, "\x24\x4D", 2) == 0 &&
memcmp(base + 12, "play", 4) == 0)
{
return VIDEO_WMV;
}
else if ((available_data >= 400) &&
(*(base) == 0x47) &&
(*(base+188) == 0x47) &&
(*(base+376) == 0x47)
)
{ /* MPEG TS framing used in HLS */
/* Since NDS is also using MPEG TS framing, it will also patch partial
NDS flows */
// printf(" video mpegts \n");
return VIDEO_HLS;
}
else if ((available_data >= 16) &&
memcmp(base, "\x47\x1F\xFF\x10", 4) == 0 &&
memcmp(base + 4, "NDS File", 8) == 0)
{ /* NDS File Format - Cisco Videoscape - Sky+ VOD stream */
/* Actually a NULL MPEG TS frame */
return VIDEO_NFF;
}
return VIDEO_NOT_DEFINED;
}
return VIDEO_NOT_DEFINED;
}
