Archive/TRX
0
0
Fork 0
mirror of https://github.com/LostArtefacts/TRX.git synced 2025-04-28 20:58:07 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

libtrx: use new file read/write api

Browse source
This commit is contained in:
Marcin Kurczewski 2024-08-07 21:20:58 +02:00
parent 83b1f4a4a2
commit 330a57d2b9
No known key found for this signature in database
GPG key ID: CC65E6FD28CAE42A
7 changed files with 532 additions and 642 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/config.c
View file

@ -460,7 +460,7 @@ bool Config_Write(void)
char *data = json_write_pretty(root, " ", "\n", &size);
json_value_free(root);
File_Write(data, sizeof(char), size - 1, fp);
File_WriteData(fp, data, size - 1);
File_Close(fp);
Memory_FreePointer(&data);

676
src/game/inject.c
View file

File diff suppressed because it is too large Load diff

467
src/game/level.c
View file

@ -60,9 +60,6 @@ static size_t Level_CalculateMaxVertices(void);
static bool Level_LoadFromFile(
const char *filename, int32_t level_num, bool is_demo)
{
int32_t version;
int32_t file_level_num;
GameBuf_Shutdown();
GameBuf_Init();
@ -73,7 +70,7 @@ static bool Level_LoadFromFile(
return false;
}
File_Read(&version, sizeof(int32_t), 1, fp);
const int32_t version = File_ReadS32(fp);
if (version != 32) {
Shell_ExitSystemFmt(
"Level %d (%s) is version %d (this game code is version %d)",
@ -85,7 +82,7 @@ static bool Level_LoadFromFile(
return false;
}
File_Read(&file_level_num, sizeof(int32_t), 1, fp);
const int32_t file_level_num = File_ReadS32(fp);
LOG_INFO("file level num: %d", file_level_num);
if (!Level_LoadRooms(fp)) {
@ -156,11 +153,7 @@ static bool Level_LoadFromFile(
static bool Level_LoadRooms(MYFILE *fp)
{
uint16_t count2;
uint32_t count4;
uint32_t inj_mesh_size;
File_Read(&g_RoomCount, sizeof(uint16_t), 1, fp);
g_RoomCount = File_ReadU16(fp);
LOG_INFO("%d rooms", g_RoomCount);
g_RoomInfo =
@ -169,67 +162,68 @@ static bool Level_LoadRooms(MYFILE *fp)
for (ROOM_INFO *current_room_info = g_RoomInfo; i < g_RoomCount;
i++, current_room_info++) {
// Room position
File_Read(&current_room_info->x, sizeof(uint32_t), 1, fp);
current_room_info->x = File_ReadS32(fp);
current_room_info->y = 0;
File_Read(&current_room_info->z, sizeof(uint32_t), 1, fp);
current_room_info->z = File_ReadS32(fp);
// Room floor/ceiling
File_Read(&current_room_info->min_floor, sizeof(uint32_t), 1, fp);
File_Read(&current_room_info->max_ceiling, sizeof(uint32_t), 1, fp);
current_room_info->min_floor = File_ReadS32(fp);
current_room_info->max_ceiling = File_ReadS32(fp);
// Room mesh
File_Read(&count4, sizeof(uint32_t), 1, fp);
inj_mesh_size = Inject_GetExtraRoomMeshSize(i);
const uint32_t num_meshes = File_ReadS32(fp);
const uint32_t inj_mesh_size = Inject_GetExtraRoomMeshSize(i);
current_room_info->data = GameBuf_Alloc(
sizeof(uint16_t) * (count4 + inj_mesh_size), GBUF_ROOM_MESH);
File_Read(current_room_info->data, sizeof(uint16_t), count4, fp);
sizeof(uint16_t) * (num_meshes + inj_mesh_size), GBUF_ROOM_MESH);
File_ReadItems(
fp, current_room_info->data, sizeof(uint16_t), num_meshes);
// Doors
File_Read(&count2, sizeof(uint16_t), 1, fp);
if (!count2) {
const uint16_t num_doors = File_ReadS16(fp);
if (!num_doors) {
current_room_info->doors = NULL;
} else {
current_room_info->doors = GameBuf_Alloc(
sizeof(uint16_t) + sizeof(DOOR_INFO) * count2, GBUF_ROOM_DOOR);
current_room_info->doors->count = count2;
for (int32_t j = 0; j < count2; j++) {
sizeof(uint16_t) + sizeof(DOOR_INFO) * num_doors,
GBUF_ROOM_DOOR);
current_room_info->doors->count = num_doors;
for (int32_t j = 0; j < num_doors; j++) {
DOOR_INFO *door = &current_room_info->doors->door[j];
File_Read(&door->room_num, sizeof(int16_t), 1, fp);
File_Read(&door->normal.x, sizeof(int16_t), 1, fp);
File_Read(&door->normal.y, sizeof(int16_t), 1, fp);
File_Read(&door->normal.z, sizeof(int16_t), 1, fp);
door->room_num = File_ReadS16(fp);
door->normal.x = File_ReadS16(fp);
door->normal.y = File_ReadS16(fp);
door->normal.z = File_ReadS16(fp);
for (int32_t k = 0; k < 4; k++) {
File_Read(&door->vertex[k].x, sizeof(int16_t), 1, fp);
File_Read(&door->vertex[k].y, sizeof(int16_t), 1, fp);
File_Read(&door->vertex[k].z, sizeof(int16_t), 1, fp);
door->vertex[k].x = File_ReadS16(fp);
door->vertex[k].y = File_ReadS16(fp);
door->vertex[k].z = File_ReadS16(fp);
}
}
}
// Room floor
File_Read(&current_room_info->z_size, sizeof(uint16_t), 1, fp);
File_Read(&current_room_info->x_size, sizeof(uint16_t), 1, fp);
count4 = current_room_info->x_size * current_room_info->z_size;
current_room_info->z_size = File_ReadS16(fp);
current_room_info->x_size = File_ReadS16(fp);
const int32_t sector_count =
current_room_info->x_size * current_room_info->z_size;
current_room_info->sectors =
GameBuf_Alloc(sizeof(SECTOR_INFO) * count4, GBUF_ROOM_SECTOR);
for (int32_t j = 0; j < (signed)count4; j++) {
GameBuf_Alloc(sizeof(SECTOR_INFO) * sector_count, GBUF_ROOM_SECTOR);
for (int32_t j = 0; j < sector_count; j++) {
SECTOR_INFO *const sector = &current_room_info->sectors[j];
int8_t floor_clicks;
int8_t ceiling_clicks;
File_Read(&sector->index, sizeof(uint16_t), 1, fp);
File_Read(&sector->box, sizeof(int16_t), 1, fp);
File_Read(&sector->pit_room, sizeof(uint8_t), 1, fp);
File_Read(&floor_clicks, sizeof(int8_t), 1, fp);
File_Read(&sector->sky_room, sizeof(uint8_t), 1, fp);
File_Read(&ceiling_clicks, sizeof(int8_t), 1, fp);
sector->index = File_ReadU16(fp);
sector->box = File_ReadS16(fp);
sector->pit_room = File_ReadU8(fp);
const int8_t floor_clicks = File_ReadS8(fp);
sector->sky_room = File_ReadU8(fp);
const int8_t ceiling_clicks = File_ReadS8(fp);
sector->floor.height = floor_clicks * STEP_L;
sector->ceiling.height = ceiling_clicks * STEP_L;
}
// Room lights
File_Read(&current_room_info->ambient, sizeof(uint16_t), 1, fp);
File_Read(&current_room_info->num_lights, sizeof(uint16_t), 1, fp);
current_room_info->ambient = File_ReadS16(fp);
current_room_info->num_lights = File_ReadS16(fp);
if (!current_room_info->num_lights) {
current_room_info->light = NULL;
} else {
@ -238,16 +232,16 @@ static bool Level_LoadRooms(MYFILE *fp)
GBUF_ROOM_LIGHTS);
for (int32_t j = 0; j < current_room_info->num_lights; j++) {
LIGHT_INFO *light = &current_room_info->light[j];
File_Read(&light->pos.x, sizeof(int32_t), 1, fp);
File_Read(&light->pos.y, sizeof(int32_t), 1, fp);
File_Read(&light->pos.z, sizeof(int32_t), 1, fp);
File_Read(&light->intensity, sizeof(int16_t), 1, fp);
File_Read(&light->falloff, sizeof(int32_t), 1, fp);
light->pos.x = File_ReadS32(fp);
light->pos.y = File_ReadS32(fp);
light->pos.z = File_ReadS32(fp);
light->intensity = File_ReadS16(fp);
light->falloff = File_ReadS32(fp);
}
}
// Static mesh infos
File_Read(&current_room_info->num_meshes, sizeof(uint16_t), 1, fp);
current_room_info->num_meshes = File_ReadS16(fp);
if (!current_room_info->num_meshes) {
current_room_info->mesh = NULL;
} else {
@ -256,20 +250,20 @@ static bool Level_LoadRooms(MYFILE *fp)
GBUF_ROOM_STATIC_MESH_INFOS);
for (int32_t j = 0; j < current_room_info->num_meshes; j++) {
MESH_INFO *mesh = &current_room_info->mesh[j];
File_Read(&mesh->pos.x, sizeof(int32_t), 1, fp);
File_Read(&mesh->pos.y, sizeof(int32_t), 1, fp);
File_Read(&mesh->pos.z, sizeof(int32_t), 1, fp);
File_Read(&mesh->rot.y, sizeof(PHD_ANGLE), 1, fp);
File_Read(&mesh->shade, sizeof(uint16_t), 1, fp);
File_Read(&mesh->static_number, sizeof(uint16_t), 1, fp);
mesh->pos.x = File_ReadS32(fp);
mesh->pos.y = File_ReadS32(fp);
mesh->pos.z = File_ReadS32(fp);
mesh->rot.y = File_ReadS16(fp);
mesh->shade = File_ReadU16(fp);
mesh->static_number = File_ReadU16(fp);
}
}
// Flipped (alternative) room
File_Read(&current_room_info->flipped_room, sizeof(uint16_t), 1, fp);
current_room_info->flipped_room = File_ReadS16(fp);
// Room flags
File_Read(&current_room_info->flags, sizeof(uint16_t), 1, fp);
current_room_info->flags = File_ReadU16(fp);
// Initialise some variables
current_room_info->bound_active = 0;
@ -277,34 +271,36 @@ static bool Level_LoadRooms(MYFILE *fp)
current_room_info->top = Viewport_GetMaxY();
current_room_info->bottom = 0;
current_room_info->right = 0;
current_room_info->item_number = -1;
current_room_info->fx_number = -1;
current_room_info->item_number = NO_ITEM;
current_room_info->fx_number = NO_ITEM;
}
File_Read(&m_LevelInfo.floor_data_size, sizeof(uint32_t), 1, fp);
m_LevelInfo.floor_data_size = File_ReadS32(fp);
g_FloorData = GameBuf_Alloc(
sizeof(uint16_t)
sizeof(int16_t)
* (m_LevelInfo.floor_data_size + m_InjectionInfo->floor_data_size),
GBUF_FLOOR_DATA);
File_Read(g_FloorData, sizeof(uint16_t), m_LevelInfo.floor_data_size, fp);
File_ReadItems(
fp, g_FloorData, sizeof(int16_t), m_LevelInfo.floor_data_size);
return true;
}
static bool Level_LoadObjects(MYFILE *fp)
{
File_Read(&m_LevelInfo.mesh_count, sizeof(int32_t), 1, fp);
m_LevelInfo.mesh_count = File_ReadS32(fp);
LOG_INFO("%d meshes", m_LevelInfo.mesh_count);
g_MeshBase = GameBuf_Alloc(
sizeof(int16_t)
* (m_LevelInfo.mesh_count + m_InjectionInfo->mesh_count),
GBUF_MESHES);
File_Read(g_MeshBase, sizeof(int16_t), m_LevelInfo.mesh_count, fp);
File_ReadItems(fp, g_MeshBase, sizeof(int16_t), m_LevelInfo.mesh_count);
File_Read(&m_LevelInfo.mesh_ptr_count, sizeof(int32_t), 1, fp);
uint32_t *mesh_indices = GameBuf_Alloc(
sizeof(uint32_t) * m_LevelInfo.mesh_ptr_count, GBUF_MESH_POINTERS);
File_Read(mesh_indices, sizeof(uint32_t), m_LevelInfo.mesh_ptr_count, fp);
m_LevelInfo.mesh_ptr_count = File_ReadS32(fp);
int32_t *mesh_indices = GameBuf_Alloc(
sizeof(int32_t) * m_LevelInfo.mesh_ptr_count, GBUF_MESH_POINTERS);
File_ReadItems(
fp, mesh_indices, sizeof(int32_t), m_LevelInfo.mesh_ptr_count);
g_Meshes = GameBuf_Alloc(
sizeof(int16_t *)
@ -314,7 +310,7 @@ static bool Level_LoadObjects(MYFILE *fp)
g_Meshes[i] = &g_MeshBase[mesh_indices[i] / 2];
}
File_Read(&m_LevelInfo.anim_count, sizeof(int32_t), 1, fp);
m_LevelInfo.anim_count = File_ReadS32(fp);
LOG_INFO("%d anims", m_LevelInfo.anim_count);
g_Anims = GameBuf_Alloc(
sizeof(ANIM_STRUCT)
@ -323,22 +319,22 @@ static bool Level_LoadObjects(MYFILE *fp)
for (int i = 0; i < m_LevelInfo.anim_count; i++) {
ANIM_STRUCT *anim = g_Anims + i;
File_Read(&anim->frame_ofs, sizeof(uint32_t), 1, fp);
File_Read(&anim->interpolation, sizeof(int16_t), 1, fp);
File_Read(&anim->current_anim_state, sizeof(int16_t), 1, fp);
File_Read(&anim->velocity, sizeof(int32_t), 1, fp);
File_Read(&anim->acceleration, sizeof(int32_t), 1, fp);
File_Read(&anim->frame_base, sizeof(int16_t), 1, fp);
File_Read(&anim->frame_end, sizeof(int16_t), 1, fp);
File_Read(&anim->jump_anim_num, sizeof(int16_t), 1, fp);
File_Read(&anim->jump_frame_num, sizeof(int16_t), 1, fp);
File_Read(&anim->number_changes, sizeof(int16_t), 1, fp);
File_Read(&anim->change_index, sizeof(int16_t), 1, fp);
File_Read(&anim->number_commands, sizeof(int16_t), 1, fp);
File_Read(&anim->command_index, sizeof(int16_t), 1, fp);
anim->frame_ofs = File_ReadU32(fp);
anim->interpolation = File_ReadS16(fp);
anim->current_anim_state = File_ReadS16(fp);
anim->velocity = File_ReadS32(fp);
anim->acceleration = File_ReadS32(fp);
anim->frame_base = File_ReadS16(fp);
anim->frame_end = File_ReadS16(fp);
anim->jump_anim_num = File_ReadS16(fp);
anim->jump_frame_num = File_ReadS16(fp);
anim->number_changes = File_ReadS16(fp);
anim->change_index = File_ReadS16(fp);
anim->number_commands = File_ReadS16(fp);
anim->command_index = File_ReadS16(fp);
}
File_Read(&m_LevelInfo.anim_change_count, sizeof(int32_t), 1, fp);
m_LevelInfo.anim_change_count = File_ReadS32(fp);
LOG_INFO("%d anim changes", m_LevelInfo.anim_change_count);
g_AnimChanges = GameBuf_Alloc(
sizeof(ANIM_CHANGE_STRUCT)
@ -347,12 +343,12 @@ static bool Level_LoadObjects(MYFILE *fp)
GBUF_ANIM_CHANGES);
for (int32_t i = 0; i < m_LevelInfo.anim_change_count; i++) {
ANIM_CHANGE_STRUCT *anim_change = &g_AnimChanges[i];
File_Read(&anim_change->goal_anim_state, sizeof(int16_t), 1, fp);
File_Read(&anim_change->number_ranges, sizeof(int16_t), 1, fp);
File_Read(&anim_change->range_index, sizeof(int16_t), 1, fp);
anim_change->goal_anim_state = File_ReadS16(fp);
anim_change->number_ranges = File_ReadS16(fp);
anim_change->range_index = File_ReadS16(fp);
}
File_Read(&m_LevelInfo.anim_range_count, sizeof(int32_t), 1, fp);
m_LevelInfo.anim_range_count = File_ReadS32(fp);
LOG_INFO("%d anim ranges", m_LevelInfo.anim_range_count);
g_AnimRanges = GameBuf_Alloc(
sizeof(ANIM_RANGE_STRUCT)
@ -361,31 +357,32 @@ static bool Level_LoadObjects(MYFILE *fp)
GBUF_ANIM_RANGES);
for (int32_t i = 0; i < m_LevelInfo.anim_range_count; i++) {
ANIM_RANGE_STRUCT *anim_range = &g_AnimRanges[i];
File_Read(&anim_range->start_frame, sizeof(int16_t), 1, fp);
File_Read(&anim_range->end_frame, sizeof(int16_t), 1, fp);
File_Read(&anim_range->link_anim_num, sizeof(int16_t), 1, fp);
File_Read(&anim_range->link_frame_num, sizeof(int16_t), 1, fp);
anim_range->start_frame = File_ReadS16(fp);
anim_range->end_frame = File_ReadS16(fp);
anim_range->link_anim_num = File_ReadS16(fp);
anim_range->link_frame_num = File_ReadS16(fp);
}
File_Read(&m_LevelInfo.anim_command_count, sizeof(int32_t), 1, fp);
m_LevelInfo.anim_command_count = File_ReadS32(fp);
LOG_INFO("%d anim commands", m_LevelInfo.anim_command_count);
g_AnimCommands = GameBuf_Alloc(
sizeof(int16_t)
* (m_LevelInfo.anim_command_count
+ m_InjectionInfo->anim_cmd_count),
GBUF_ANIM_COMMANDS);
File_Read(
g_AnimCommands, sizeof(int16_t), m_LevelInfo.anim_command_count, fp);
File_ReadItems(
fp, g_AnimCommands, sizeof(int16_t), m_LevelInfo.anim_command_count);
File_Read(&m_LevelInfo.anim_bone_count, sizeof(int32_t), 1, fp);
m_LevelInfo.anim_bone_count = File_ReadS32(fp);
LOG_INFO("%d anim bones", m_LevelInfo.anim_bone_count);
g_AnimBones = GameBuf_Alloc(
sizeof(int32_t)
* (m_LevelInfo.anim_bone_count + m_InjectionInfo->anim_bone_count),
GBUF_ANIM_BONES);
File_Read(g_AnimBones, sizeof(int32_t), m_LevelInfo.anim_bone_count, fp);
File_ReadItems(
fp, g_AnimBones, sizeof(int32_t), m_LevelInfo.anim_bone_count);
File_Read(&m_LevelInfo.anim_frame_data_count, sizeof(int32_t), 1, fp);
m_LevelInfo.anim_frame_data_count = File_ReadS32(fp);
LOG_INFO("%d anim frames data", m_LevelInfo.anim_frame_data_count);
const size_t frame_data_start = File_Pos(fp);
@ -397,8 +394,7 @@ static bool Level_LoadObjects(MYFILE *fp)
File_Seek(fp, frame_data_start, SEEK_SET);
while (File_Pos(fp) < frame_data_end) {
File_Skip(fp, 9 * sizeof(int16_t));
int16_t num_meshes;
File_Read(&num_meshes, sizeof(int16_t), 1, fp);
const int16_t num_meshes = File_ReadS16(fp);
File_Skip(fp, num_meshes * sizeof(int32_t));
m_LevelInfo.anim_frame_count++;
m_LevelInfo.anim_frame_mesh_rot_count += num_meshes;
@ -426,18 +422,18 @@ static bool Level_LoadObjects(MYFILE *fp)
for (int32_t i = 0; i < m_LevelInfo.anim_frame_count; i++) {
m_LevelInfo.anim_frame_offsets[i] = File_Pos(fp) - frame_data_start;
FRAME_INFO *const frame = &g_AnimFrames[i];
File_Read(&frame->bounds.min.x, sizeof(int16_t), 1, fp);
File_Read(&frame->bounds.max.x, sizeof(int16_t), 1, fp);
File_Read(&frame->bounds.min.y, sizeof(int16_t), 1, fp);
File_Read(&frame->bounds.max.y, sizeof(int16_t), 1, fp);
File_Read(&frame->bounds.min.z, sizeof(int16_t), 1, fp);
File_Read(&frame->bounds.max.z, sizeof(int16_t), 1, fp);
File_Read(&frame->offset.x, sizeof(int16_t), 1, fp);
File_Read(&frame->offset.y, sizeof(int16_t), 1, fp);
File_Read(&frame->offset.z, sizeof(int16_t), 1, fp);
File_Read(&frame->nmeshes, sizeof(int16_t), 1, fp);
frame->bounds.min.x = File_ReadS16(fp);
frame->bounds.max.x = File_ReadS16(fp);
frame->bounds.min.y = File_ReadS16(fp);
frame->bounds.max.y = File_ReadS16(fp);
frame->bounds.min.z = File_ReadS16(fp);
frame->bounds.max.z = File_ReadS16(fp);
frame->offset.x = File_ReadS16(fp);
frame->offset.y = File_ReadS16(fp);
frame->offset.z = File_ReadS16(fp);
frame->nmeshes = File_ReadS16(fp);
frame->mesh_rots = mesh_rots;
File_Read(mesh_rots, sizeof(int32_t), frame->nmeshes, fp);
File_ReadItems(fp, mesh_rots, sizeof(int32_t), frame->nmeshes);
mesh_rots += frame->nmeshes;
}
assert(File_Pos(fp) == frame_data_end);
@ -456,20 +452,18 @@ static bool Level_LoadObjects(MYFILE *fp)
}
File_Seek(fp, frame_data_end, SEEK_SET);
File_Read(&m_LevelInfo.object_count, sizeof(int32_t), 1, fp);
m_LevelInfo.object_count = File_ReadS32(fp);
LOG_INFO("%d objects", m_LevelInfo.object_count);
for (int i = 0; i < m_LevelInfo.object_count; i++) {
int32_t object_num;
File_Read(&object_num, sizeof(int32_t), 1, fp);
const int32_t object_num = File_ReadS32(fp);
OBJECT_INFO *object = &g_Objects[object_num];
File_Read(&object->nmeshes, sizeof(int16_t), 1, fp);
File_Read(&object->mesh_index, sizeof(int16_t), 1, fp);
File_Read(&object->bone_index, sizeof(int32_t), 1, fp);
object->nmeshes = File_ReadS16(fp);
object->mesh_index = File_ReadS16(fp);
object->bone_index = File_ReadS32(fp);
int32_t frame_offset;
File_Read(&frame_offset, sizeof(int32_t), 1, fp);
File_Read(&object->anim_index, sizeof(int16_t), 1, fp);
const int32_t frame_offset = File_ReadS32(fp);
object->anim_index = File_ReadS16(fp);
bool found = false;
for (int j = 0; j < m_LevelInfo.anim_frame_count; j++) {
@ -482,31 +476,30 @@ static bool Level_LoadObjects(MYFILE *fp)
object->loaded = found;
}
File_Read(&m_LevelInfo.static_count, sizeof(int32_t), 1, fp);
m_LevelInfo.static_count = File_ReadS32(fp);
LOG_INFO("%d statics", m_LevelInfo.static_count);
for (int i = 0; i < m_LevelInfo.static_count; i++) {
int32_t tmp;
File_Read(&tmp, sizeof(int32_t), 1, fp);
const int32_t tmp = File_ReadS32(fp);
STATIC_INFO *object = &g_StaticObjects[tmp];
File_Read(&object->mesh_number, sizeof(int16_t), 1, fp);
File_Read(&object->p.min.x, sizeof(int16_t), 1, fp);
File_Read(&object->p.max.x, sizeof(int16_t), 1, fp);
File_Read(&object->p.min.y, sizeof(int16_t), 1, fp);
File_Read(&object->p.max.y, sizeof(int16_t), 1, fp);
File_Read(&object->p.min.z, sizeof(int16_t), 1, fp);
File_Read(&object->p.max.z, sizeof(int16_t), 1, fp);
File_Read(&object->c.min.x, sizeof(int16_t), 1, fp);
File_Read(&object->c.max.x, sizeof(int16_t), 1, fp);
File_Read(&object->c.min.y, sizeof(int16_t), 1, fp);
File_Read(&object->c.max.y, sizeof(int16_t), 1, fp);
File_Read(&object->c.min.z, sizeof(int16_t), 1, fp);
File_Read(&object->c.max.z, sizeof(int16_t), 1, fp);
File_Read(&object->flags, sizeof(int16_t), 1, fp);
object->mesh_number = File_ReadS16(fp);
object->p.min.x = File_ReadS16(fp);
object->p.max.x = File_ReadS16(fp);
object->p.min.y = File_ReadS16(fp);
object->p.max.y = File_ReadS16(fp);
object->p.min.z = File_ReadS16(fp);
object->p.max.z = File_ReadS16(fp);
object->c.min.x = File_ReadS16(fp);
object->c.max.x = File_ReadS16(fp);
object->c.min.y = File_ReadS16(fp);
object->c.max.y = File_ReadS16(fp);
object->c.min.z = File_ReadS16(fp);
object->c.max.z = File_ReadS16(fp);
object->flags = File_ReadS16(fp);
object->loaded = true;
}
File_Read(&m_LevelInfo.texture_count, sizeof(int32_t), 1, fp);
m_LevelInfo.texture_count = File_ReadS32(fp);
LOG_INFO("%d textures", m_LevelInfo.texture_count);
if ((m_LevelInfo.texture_count + m_InjectionInfo->texture_count)
> MAX_TEXTURES) {
@ -514,11 +507,11 @@ static bool Level_LoadObjects(MYFILE *fp)
}
for (int32_t i = 0; i < m_LevelInfo.texture_count; i++) {
PHD_TEXTURE *texture = &g_PhdTextureInfo[i];
File_Read(&texture->drawtype, sizeof(uint16_t), 1, fp);
File_Read(&texture->tpage, sizeof(uint16_t), 1, fp);
texture->drawtype = File_ReadU16(fp);
texture->tpage = File_ReadU16(fp);
for (int32_t j = 0; j < 4; j++) {
File_Read(&texture->uv[j].u, sizeof(uint16_t), 1, fp);
File_Read(&texture->uv[j].v, sizeof(uint16_t), 1, fp);
texture->uv[j].u = File_ReadU16(fp);
texture->uv[j].v = File_ReadU16(fp);
}
}
@ -527,7 +520,7 @@ static bool Level_LoadObjects(MYFILE *fp)
static bool Level_LoadSprites(MYFILE *fp)
{
File_Read(&m_LevelInfo.sprite_info_count, sizeof(int32_t), 1, fp);
m_LevelInfo.sprite_info_count = File_ReadS32(fp);
if (m_LevelInfo.sprite_info_count + m_InjectionInfo->sprite_info_count
> MAX_SPRITES) {
Shell_ExitSystem("Too many sprites in level");
@ -535,24 +528,22 @@ static bool Level_LoadSprites(MYFILE *fp)
}
for (int32_t i = 0; i < m_LevelInfo.sprite_info_count; i++) {
PHD_SPRITE *sprite = &g_PhdSpriteInfo[i];
File_Read(&sprite->tpage, sizeof(uint16_t), 1, fp);
File_Read(&sprite->offset, sizeof(uint16_t), 1, fp);
File_Read(&sprite->width, sizeof(uint16_t), 1, fp);
File_Read(&sprite->height, sizeof(uint16_t), 1, fp);
File_Read(&sprite->x1, sizeof(int16_t), 1, fp);
File_Read(&sprite->y1, sizeof(int16_t), 1, fp);
File_Read(&sprite->x2, sizeof(int16_t), 1, fp);
File_Read(&sprite->y2, sizeof(int16_t), 1, fp);
sprite->tpage = File_ReadU16(fp);
sprite->offset = File_ReadU16(fp);
sprite->width = File_ReadU16(fp);
sprite->height = File_ReadU16(fp);
sprite->x1 = File_ReadS16(fp);
sprite->y1 = File_ReadS16(fp);
sprite->x2 = File_ReadS16(fp);
sprite->y2 = File_ReadS16(fp);
}
File_Read(&m_LevelInfo.sprite_count, sizeof(int32_t), 1, fp);
m_LevelInfo.sprite_count = File_ReadS32(fp);
for (int i = 0; i < m_LevelInfo.sprite_count; i++) {
GAME_OBJECT_ID object_num;
int16_t num_meshes;
int16_t mesh_index;
File_Read(&object_num, sizeof(int32_t), 1, fp);
File_Read(&num_meshes, sizeof(int16_t), 1, fp);
File_Read(&mesh_index, sizeof(int16_t), 1, fp);
object_num = File_ReadS32(fp);
const int16_t num_meshes = File_ReadS16(fp);
const int16_t mesh_index = File_ReadS16(fp);
if (object_num < O_NUMBER_OF) {
OBJECT_INFO *object = &g_Objects[object_num];
@ -571,7 +562,7 @@ static bool Level_LoadSprites(MYFILE *fp)
static bool Level_LoadItems(MYFILE *fp)
{
File_Read(&m_LevelInfo.item_count, sizeof(int32_t), 1, fp);
m_LevelInfo.item_count = File_ReadS32(fp);
LOG_INFO("%d items", m_LevelInfo.item_count);
@ -588,14 +579,14 @@ static bool Level_LoadItems(MYFILE *fp)
for (int i = 0; i < m_LevelInfo.item_count; i++) {
ITEM_INFO *item = &g_Items[i];
File_Read(&item->object_number, sizeof(int16_t), 1, fp);
File_Read(&item->room_number, sizeof(int16_t), 1, fp);
File_Read(&item->pos.x, sizeof(int32_t), 1, fp);
File_Read(&item->pos.y, sizeof(int32_t), 1, fp);
File_Read(&item->pos.z, sizeof(int32_t), 1, fp);
File_Read(&item->rot.y, sizeof(int16_t), 1, fp);
File_Read(&item->shade, sizeof(int16_t), 1, fp);
File_Read(&item->flags, sizeof(uint16_t), 1, fp);
item->object_number = File_ReadS16(fp);
item->room_number = File_ReadS16(fp);
item->pos.x = File_ReadS32(fp);
item->pos.y = File_ReadS32(fp);
item->pos.z = File_ReadS32(fp);
item->rot.y = File_ReadS16(fp);
item->shade = File_ReadS16(fp);
item->flags = File_ReadU16(fp);
if (item->object_number < 0 || item->object_number >= O_NUMBER_OF) {
Shell_ExitSystemFmt(
@ -620,9 +611,9 @@ static bool Level_LoadPalette(MYFILE *fp)
LOG_INFO("");
RGB_888 palette[256];
for (int32_t i = 0; i < 256; i++) {
File_Read(&palette[i].r, sizeof(uint8_t), 1, fp);
File_Read(&palette[i].g, sizeof(uint8_t), 1, fp);
File_Read(&palette[i].b, sizeof(uint8_t), 1, fp);
palette[i].r = File_ReadU8(fp);
palette[i].g = File_ReadU8(fp);
palette[i].b = File_ReadU8(fp);
}
palette[0].r = 0;
palette[0].g = 0;
@ -638,7 +629,7 @@ static bool Level_LoadPalette(MYFILE *fp)
static bool Level_LoadCameras(MYFILE *fp)
{
File_Read(&g_NumberCameras, sizeof(int32_t), 1, fp);
g_NumberCameras = File_ReadS32(fp);
LOG_INFO("%d cameras", g_NumberCameras);
if (!g_NumberCameras) {
return true;
@ -650,18 +641,18 @@ static bool Level_LoadCameras(MYFILE *fp)
}
for (int32_t i = 0; i < g_NumberCameras; i++) {
OBJECT_VECTOR *camera = &g_Camera.fixed[i];
File_Read(&camera->x, sizeof(int32_t), 1, fp);
File_Read(&camera->y, sizeof(int32_t), 1, fp);
File_Read(&camera->z, sizeof(int32_t), 1, fp);
File_Read(&camera->data, sizeof(int16_t), 1, fp);
File_Read(&camera->flags, sizeof(int16_t), 1, fp);
camera->x = File_ReadS32(fp);
camera->y = File_ReadS32(fp);
camera->z = File_ReadS32(fp);
camera->data = File_ReadS16(fp);
camera->flags = File_ReadS16(fp);
}
return true;
}
static bool Level_LoadSoundEffects(MYFILE *fp)
{
File_Read(&g_NumberSoundEffects, sizeof(int32_t), 1, fp);
g_NumberSoundEffects = File_ReadS32(fp);
LOG_INFO("%d sound effects", g_NumberSoundEffects);
if (!g_NumberSoundEffects) {
return true;
@ -673,65 +664,46 @@ static bool Level_LoadSoundEffects(MYFILE *fp)
}
for (int32_t i = 0; i < g_NumberSoundEffects; i++) {
OBJECT_VECTOR *sound = &g_SoundEffectsTable[i];
File_Read(&sound->x, sizeof(int32_t), 1, fp);
File_Read(&sound->y, sizeof(int32_t), 1, fp);
File_Read(&sound->z, sizeof(int32_t), 1, fp);
File_Read(&sound->data, sizeof(int16_t), 1, fp);
File_Read(&sound->flags, sizeof(int16_t), 1, fp);
sound->x = File_ReadS32(fp);
sound->y = File_ReadS32(fp);
sound->z = File_ReadS32(fp);
sound->data = File_ReadS16(fp);
sound->flags = File_ReadS16(fp);
}
return true;
}
static bool Level_LoadBoxes(MYFILE *fp)
{
File_Read(&g_NumberBoxes, sizeof(int32_t), 1, fp);
g_NumberBoxes = File_ReadS32(fp);
g_Boxes = GameBuf_Alloc(sizeof(BOX_INFO) * g_NumberBoxes, GBUF_BOXES);
for (int32_t i = 0; i < g_NumberBoxes; i++) {
BOX_INFO *box = &g_Boxes[i];
File_Read(&box->left, sizeof(int32_t), 1, fp);
File_Read(&box->right, sizeof(int32_t), 1, fp);
File_Read(&box->top, sizeof(int32_t), 1, fp);
File_Read(&box->bottom, sizeof(int32_t), 1, fp);
File_Read(&box->height, sizeof(int16_t), 1, fp);
File_Read(&box->overlap_index, sizeof(int16_t), 1, fp);
box->left = File_ReadS32(fp);
box->right = File_ReadS32(fp);
box->top = File_ReadS32(fp);
box->bottom = File_ReadS32(fp);
box->height = File_ReadS16(fp);
box->overlap_index = File_ReadS16(fp);
}
File_Read(&m_LevelInfo.overlap_count, sizeof(int32_t), 1, fp);
m_LevelInfo.overlap_count = File_ReadS32(fp);
g_Overlap = GameBuf_Alloc(
sizeof(uint16_t) * m_LevelInfo.overlap_count, GBUF_OVERLAPS);
if (!File_Read(
g_Overlap, sizeof(uint16_t), m_LevelInfo.overlap_count, fp)) {
Shell_ExitSystem("Level_LoadBoxes(): Unable to load box overlaps");
return false;
}
File_ReadItems(fp, g_Overlap, sizeof(uint16_t), m_LevelInfo.overlap_count);
for (int i = 0; i < 2; i++) {
g_GroundZone[i] =
GameBuf_Alloc(sizeof(int16_t) * g_NumberBoxes, GBUF_GROUNDZONE);
if (!g_GroundZone[i]
|| !File_Read(
g_GroundZone[i], sizeof(int16_t), g_NumberBoxes, fp)) {
Shell_ExitSystem("Level_LoadBoxes(): Unable to load 'ground_zone'");
return false;
}
File_ReadItems(fp, g_GroundZone[i], sizeof(int16_t), g_NumberBoxes);
g_GroundZone2[i] =
GameBuf_Alloc(sizeof(int16_t) * g_NumberBoxes, GBUF_GROUNDZONE);
if (!g_GroundZone2[i]
|| !File_Read(
g_GroundZone2[i], sizeof(int16_t), g_NumberBoxes, fp)) {
Shell_ExitSystem(
"Level_LoadBoxes(): Unable to load 'ground2_zone'");
return false;
}
File_ReadItems(fp, g_GroundZone2[i], sizeof(int16_t), g_NumberBoxes);
g_FlyZone[i] =
GameBuf_Alloc(sizeof(int16_t) * g_NumberBoxes, GBUF_FLYZONE);
if (!g_FlyZone[i]
|| !File_Read(g_FlyZone[i], sizeof(int16_t), g_NumberBoxes, fp)) {
Shell_ExitSystem("Level_LoadBoxes(): Unable to load 'fly_zone'");
return false;
}
File_ReadItems(fp, g_FlyZone[i], sizeof(int16_t), g_NumberBoxes);
}
return true;
@ -739,12 +711,11 @@ static bool Level_LoadBoxes(MYFILE *fp)
static bool Level_LoadAnimatedTextures(MYFILE *fp)
{
File_Read(&m_LevelInfo.anim_texture_range_count, sizeof(int32_t), 1, fp);
m_LevelInfo.anim_texture_range_count = File_ReadS32(fp);
size_t end_position =
File_Pos(fp) + m_LevelInfo.anim_texture_range_count * sizeof(int16_t);
int16_t num_ranges;
File_Read(&num_ranges, sizeof(int16_t), 1, fp);
const int16_t num_ranges = File_ReadS16(fp);
LOG_INFO("%d animated texture ranges", num_ranges);
if (!num_ranges) {
g_AnimTextureRanges = NULL;
@ -760,13 +731,14 @@ static bool Level_LoadAnimatedTextures(MYFILE *fp)
// Level data is tied to the original logic in Output_AnimateTextures
// and hence stores one less than the actual count here.
File_Read(&range->num_textures, sizeof(int16_t), 1, fp);
range->num_textures = File_ReadS16(fp);
range->num_textures++;
range->textures = GameBuf_Alloc(
sizeof(int16_t) * range->num_textures,
GBUF_ANIMATING_TEXTURE_RANGES);
File_Read(range->textures, sizeof(int16_t), range->num_textures, fp);
File_ReadItems(
fp, range->textures, sizeof(int16_t), range->num_textures);
}
cleanup:
@ -778,7 +750,7 @@ cleanup:
static bool Level_LoadCinematic(MYFILE *fp)
{
File_Read(&g_NumCineFrames, sizeof(int16_t), 1, fp);
g_NumCineFrames = File_ReadS16(fp);
LOG_INFO("%d cinematic frames", g_NumCineFrames);
if (!g_NumCineFrames) {
return true;
@ -787,14 +759,14 @@ static bool Level_LoadCinematic(MYFILE *fp)
sizeof(CINE_CAMERA) * g_NumCineFrames, GBUF_CINEMATIC_FRAMES);
for (int32_t i = 0; i < g_NumCineFrames; i++) {
CINE_CAMERA *camera = &g_CineCamera[i];
File_Read(&camera->tx, sizeof(int16_t), 1, fp);
File_Read(&camera->ty, sizeof(int16_t), 1, fp);
File_Read(&camera->tz, sizeof(int16_t), 1, fp);
File_Read(&camera->cx, sizeof(int16_t), 1, fp);
File_Read(&camera->cy, sizeof(int16_t), 1, fp);
File_Read(&camera->cz, sizeof(int16_t), 1, fp);
File_Read(&camera->fov, sizeof(int16_t), 1, fp);
File_Read(&camera->roll, sizeof(int16_t), 1, fp);
camera->tx = File_ReadS16(fp);
camera->ty = File_ReadS16(fp);
camera->tz = File_ReadS16(fp);
camera->cx = File_ReadS16(fp);
camera->cy = File_ReadS16(fp);
camera->cz = File_ReadS16(fp);
camera->fov = File_ReadS16(fp);
camera->roll = File_ReadS16(fp);
}
return true;
}
@ -803,20 +775,19 @@ static bool Level_LoadDemo(MYFILE *fp)
{
g_DemoData =
GameBuf_Alloc(sizeof(uint32_t) * DEMO_COUNT_MAX, GBUF_LOADDEMO_BUFFER);
uint16_t size = 0;
File_Read(&size, sizeof(int16_t), 1, fp);
const uint16_t size = File_ReadS16(fp);
LOG_INFO("%d demo buffer size", size);
if (!size) {
return true;
}
File_Read(g_DemoData, 1, size, fp);
File_ReadData(fp, g_DemoData, size);
return true;
}
static bool Level_LoadSamples(MYFILE *fp)
{
File_Read(g_SampleLUT, sizeof(int16_t), MAX_SAMPLES, fp);
File_Read(&m_LevelInfo.sample_info_count, sizeof(int32_t), 1, fp);
File_ReadItems(fp, g_SampleLUT, sizeof(int16_t), MAX_SAMPLES);
m_LevelInfo.sample_info_count = File_ReadS32(fp);
LOG_INFO("%d sample infos", m_LevelInfo.sample_info_count);
if (!m_LevelInfo.sample_info_count) {
Shell_ExitSystem("No Sample Infos");
@ -829,13 +800,13 @@ static bool Level_LoadSamples(MYFILE *fp)
GBUF_SAMPLE_INFOS);
for (int32_t i = 0; i < m_LevelInfo.sample_info_count; i++) {
SAMPLE_INFO *sample_info = &g_SampleInfos[i];
File_Read(&sample_info->number, sizeof(int16_t), 1, fp);
File_Read(&sample_info->volume, sizeof(int16_t), 1, fp);
File_Read(&sample_info->randomness, sizeof(int16_t), 1, fp);
File_Read(&sample_info->flags, sizeof(int16_t), 1, fp);
sample_info->number = File_ReadS16(fp);
sample_info->volume = File_ReadS16(fp);
sample_info->randomness = File_ReadS16(fp);
sample_info->flags = File_ReadS16(fp);
}
File_Read(&m_LevelInfo.sample_data_size, sizeof(int32_t), 1, fp);
m_LevelInfo.sample_data_size = File_ReadS32(fp);
LOG_INFO("%d sample data size", m_LevelInfo.sample_data_size);
if (!m_LevelInfo.sample_data_size) {
Shell_ExitSystem("No Sample Data");
@ -845,11 +816,11 @@ static bool Level_LoadSamples(MYFILE *fp)
m_LevelInfo.sample_data = GameBuf_Alloc(
m_LevelInfo.sample_data_size + m_InjectionInfo->sfx_data_size,
GBUF_SAMPLES);
File_Read(
m_LevelInfo.sample_data, sizeof(char), m_LevelInfo.sample_data_size,
fp);
File_ReadItems(
fp, m_LevelInfo.sample_data, sizeof(char),
m_LevelInfo.sample_data_size);
File_Read(&m_LevelInfo.sample_count, sizeof(int32_t), 1, fp);
m_LevelInfo.sample_count = File_ReadS32(fp);
LOG_INFO("%d samples", m_LevelInfo.sample_count);
if (!m_LevelInfo.sample_count) {
Shell_ExitSystem("No Samples");
@ -859,22 +830,22 @@ static bool Level_LoadSamples(MYFILE *fp)
m_LevelInfo.sample_offsets = Memory_Alloc(
sizeof(int32_t)
* (m_LevelInfo.sample_count + m_InjectionInfo->sample_count));
File_Read(
m_LevelInfo.sample_offsets, sizeof(int32_t), m_LevelInfo.sample_count,
fp);
File_ReadItems(
fp, m_LevelInfo.sample_offsets, sizeof(int32_t),
m_LevelInfo.sample_count);
return true;
}
static bool Level_LoadTexturePages(MYFILE *fp)
{
File_Read(&m_LevelInfo.texture_page_count, sizeof(int32_t), 1, fp);
m_LevelInfo.texture_page_count = File_ReadS32(fp);
LOG_INFO("%d texture pages", m_LevelInfo.texture_page_count);
m_LevelInfo.texture_page_ptrs =
Memory_Alloc(m_LevelInfo.texture_page_count * PAGE_SIZE);
File_Read(
m_LevelInfo.texture_page_ptrs, PAGE_SIZE,
m_LevelInfo.texture_page_count, fp);
File_ReadItems(
fp, m_LevelInfo.texture_page_ptrs, PAGE_SIZE,
m_LevelInfo.texture_page_count);
return true;
}

12
src/game/savegame/savegame_bson.c
View file

@ -117,8 +117,8 @@ static void SaveGame_BSON_SaveRaw(
.uncompressed_size = uncompressed_size,
};
File_Write(&header, sizeof(header), 1, fp);
File_Write(compressed, sizeof(char), compressed_size, fp);
File_WriteData(fp, &header, sizeof(header));
File_WriteData(fp, compressed, compressed_size);
Memory_FreePointer(&compressed);
}
@ -201,10 +201,10 @@ static struct json_value_s *Savegame_BSON_ParseFromBuffer(
static struct json_value_s *Savegame_BSON_ParseFromFile(
MYFILE *fp, int32_t *version_out)
{
size_t buffer_size = File_Size(fp);
const size_t buffer_size = File_Size(fp);
char *buffer = Memory_Alloc(buffer_size);
File_Seek(fp, 0, FILE_SEEK_SET);
File_Read(buffer, sizeof(char), buffer_size, fp);
File_ReadData(fp, buffer, buffer_size);
struct json_value_s *ret =
Savegame_BSON_ParseFromBuffer(buffer, buffer_size, version_out);
@ -1298,7 +1298,7 @@ bool Savegame_BSON_FillInfo(MYFILE *fp, SAVEGAME_INFO *info)
SAVEGAME_BSON_HEADER header;
File_Seek(fp, 0, FILE_SEEK_SET);
File_Read(&header, sizeof(SAVEGAME_BSON_HEADER), 1, fp);
File_ReadData(fp, &header, sizeof(SAVEGAME_BSON_HEADER));
info->initial_version = header.initial_version;
info->features.restart = header.initial_version >= VERSION_LEGACY;
info->features.select_level = header.initial_version >= VERSION_1;
@ -1315,7 +1315,7 @@ bool Savegame_BSON_LoadFromFile(MYFILE *fp, GAME_INFO *game_info)
// Read savegame version
SAVEGAME_BSON_HEADER header;
File_Seek(fp, 0, FILE_SEEK_SET);
File_Read(&header, sizeof(SAVEGAME_BSON_HEADER), 1, fp);
File_ReadData(fp, &header, sizeof(SAVEGAME_BSON_HEADER));
File_Seek(fp, 0, FILE_SEEK_SET);
struct json_value_s *root = Savegame_BSON_ParseFromFile(fp, NULL);

13
src/game/savegame/savegame_legacy.c
View file

@ -475,11 +475,11 @@ bool Savegame_Legacy_FillInfo(MYFILE *fp, SAVEGAME_INFO *info)
File_Seek(fp, 0, SEEK_SET);
char title[SAVEGAME_LEGACY_TITLE_SIZE];
File_Read(title, sizeof(char), SAVEGAME_LEGACY_TITLE_SIZE, fp);
File_ReadItems(fp, title, sizeof(char), SAVEGAME_LEGACY_TITLE_SIZE);
info->level_title = Memory_DupStr(title);
int32_t counter;
File_Read(&counter, sizeof(int32_t), 1, fp);
counter = File_ReadS32(fp);
info->counter = counter;
for (int i = 0; i < g_GameFlow.level_count; i++) {
@ -498,8 +498,7 @@ bool Savegame_Legacy_FillInfo(MYFILE *fp, SAVEGAME_INFO *info)
File_Skip(fp, sizeof(uint32_t)); // kills
File_Skip(fp, sizeof(uint16_t)); // secrets
uint16_t level_num;
File_Read(&level_num, sizeof(int16_t), 1, fp);
const uint16_t level_num = File_ReadS16(fp);
info->level_num = level_num;
info->initial_version = VERSION_LEGACY;
@ -519,7 +518,7 @@ bool Savegame_Legacy_LoadFromFile(MYFILE *fp, GAME_INFO *game_info)
char *buffer = Memory_Alloc(File_Size(fp));
File_Seek(fp, 0, FILE_SEEK_SET);
File_Read(buffer, sizeof(char), File_Size(fp), fp);
File_ReadData(fp, buffer, File_Size(fp));
bool skip_reading_bacon_lara = Savegame_Legacy_NeedsBaconLaraFix(buffer);
if (skip_reading_bacon_lara) {
@ -652,7 +651,7 @@ bool Savegame_Legacy_LoadOnlyResumeInfo(MYFILE *fp, GAME_INFO *game_info)
char *buffer = Memory_Alloc(File_Size(fp));
File_Seek(fp, 0, FILE_SEEK_SET);
File_Read(buffer, sizeof(char), File_Size(fp), fp);
File_ReadData(fp, buffer, File_Size(fp));
Savegame_Legacy_Skip(SAVEGAME_LEGACY_TITLE_SIZE); // level title
Savegame_Legacy_Skip(sizeof(int32_t)); // save counter
@ -796,7 +795,7 @@ void Savegame_Legacy_SaveToFile(MYFILE *fp, GAME_INFO *game_info)
Savegame_Legacy_Write(&g_FlipEffect, sizeof(int32_t));
Savegame_Legacy_Write(&g_FlipTimer, sizeof(int32_t));
File_Write(buffer, sizeof(char), m_SGBufPos, fp);
File_WriteData(fp, buffer, m_SGBufPos);
Memory_FreePointer(&buffer);
}

2
src/specific/s_picture.c
View file

@ -300,7 +300,7 @@ bool S_Picture_SaveToFile(const PICTURE *pic, const char *path)
goto cleanup;
}
File_Write(packet->data, 1, packet->size, fp);
File_WriteData(fp, packet->data, packet->size);
av_packet_unref(packet);
}

2
subprojects/libtrx

@ -1 +1 @@
Subproject commit 43cfa6da50d669a5fcdb2a47e6919fbab9223553
Subproject commit 54d123770199501975d87eb63b40c405c4d651b4