mirror of
https://github.com/korenkonder/ReDIVA.git
synced 2026-10-04 04:37:55 +03:00
1791 lines
70 KiB
C++
1791 lines
70 KiB
C++
/*
|
|
by korenkonder
|
|
GitHub/GitLab: korenkonder
|
|
*/
|
|
|
|
#include <unordered_map>
|
|
#include "aet.hpp"
|
|
#include "f2/struct.hpp"
|
|
#include "io/path.hpp"
|
|
#include "io/memory_stream.hpp"
|
|
|
|
struct aet_layer_header {
|
|
int64_t markers_offset;
|
|
int64_t video_offset;
|
|
int64_t audio_offset;
|
|
};
|
|
|
|
struct aet_scene_header {
|
|
int64_t camera_offset;
|
|
int64_t comp_offset;
|
|
int64_t video_offset;
|
|
int64_t audio_offset;
|
|
};
|
|
|
|
static void aet_move_data_audio(aet_audio* audio_dst, const aet_audio* audio_src,
|
|
prj::shared_ptr<prj::stack_allocator> alloc);
|
|
static aet_camera* aet_move_data_camera(const aet_camera* cam_src,
|
|
prj::shared_ptr<prj::stack_allocator> alloc);
|
|
static void aet_move_data_comp(aet_comp* comp_dst, const aet_comp* comp_src,
|
|
prj::shared_ptr<prj::stack_allocator> alloc, std::unordered_map<void*, const aet_layer*>& layers);
|
|
static void aet_move_data_fcurve(aet_fcurve* fcurve_dst, const aet_fcurve* fcurve_src,
|
|
prj::shared_ptr<prj::stack_allocator> alloc);
|
|
static void aet_move_data_layer(aet_layer* layer_dst, const aet_layer* layer_src,
|
|
prj::shared_ptr<prj::stack_allocator> alloc);
|
|
static aet_layer_audio* aet_move_data_layer_audio(const aet_layer_audio* layer_audio_src,
|
|
prj::shared_ptr<prj::stack_allocator> alloc);
|
|
static aet_layer_video* aet_move_data_layer_video(const aet_layer_video* layer_video_src,
|
|
prj::shared_ptr<prj::stack_allocator> alloc);
|
|
static aet_layer_video_3d* aet_move_data_layer_video_3d(const aet_layer_video_3d* layer_video_3d_src,
|
|
prj::shared_ptr<prj::stack_allocator> alloc);
|
|
static void aet_move_data_marker(aet_marker* marker_dst, const aet_marker* marker_src,
|
|
prj::shared_ptr<prj::stack_allocator> alloc);
|
|
static void aet_move_data_scene(aet_scene* scene_dst, const aet_scene* scene_src,
|
|
prj::shared_ptr<prj::stack_allocator> alloc,
|
|
std::unordered_map<int64_t, const aet_layer*>& layers,
|
|
std::unordered_map<int64_t, aet_item>& items);
|
|
static void aet_move_data_video(aet_video* video_dst, const aet_video* video_src,
|
|
prj::shared_ptr<prj::stack_allocator> alloc);
|
|
static void aet_move_data_video_src(aet_video_src* video_dst, const aet_video_src* video_src,
|
|
prj::shared_ptr<prj::stack_allocator> alloc);
|
|
|
|
static void aet_set_classic_read_inner(aet_set* as, prj::shared_ptr<prj::stack_allocator>& alloc, stream& s);
|
|
static void aet_set_classic_write_inner(aet_set* as, stream& s);
|
|
static void aet_set_modern_read_inner(aet_set* as, prj::shared_ptr<prj::stack_allocator>& alloc, stream& s);
|
|
static void aet_set_modern_write_inner(aet_set* as, stream& s);
|
|
|
|
static void aet_classic_read_audio(aet_audio* audio,
|
|
prj::shared_ptr<prj::stack_allocator> alloc, stream& s,
|
|
std::unordered_map<int64_t, aet_item>& items);
|
|
static void aet_classic_write_audio(const aet_audio* audio, stream& s,
|
|
std::unordered_map<const void*, int64_t>& offsets);
|
|
static aet_camera* aet_classic_read_camera(prj::shared_ptr<prj::stack_allocator> alloc,
|
|
stream& s, int64_t offset);
|
|
static void aet_classic_write_camera(const aet_camera* cam, stream& s,
|
|
std::unordered_map<const void*, int64_t>& offsets);
|
|
static void aet_classic_read_comp(aet_comp* comp,
|
|
prj::shared_ptr<prj::stack_allocator> alloc, stream& s,
|
|
std::unordered_map<int64_t, const aet_layer*>& layers,
|
|
std::unordered_map<int64_t, aet_item>& items);
|
|
static void aet_classic_read_fcurve(aet_fcurve* fcurve,
|
|
prj::shared_ptr<prj::stack_allocator> alloc, stream& s);
|
|
static void aet_classic_write_fcurve(const aet_fcurve* fcurve, stream& s,
|
|
std::unordered_map<const void*, int64_t>& offsets);
|
|
static void aet_classic_write_fcurve_header(const aet_fcurve* fcurve, stream& s,
|
|
std::unordered_map<const void*, int64_t>& offsets, int64_t null_data_pos, uint32_t& null_data_count);
|
|
static void aet_classic_read_layer(aet_layer* layer,
|
|
prj::shared_ptr<prj::stack_allocator> alloc, stream& s);
|
|
static void aet_classic_write_layer(const aet_layer* layer, stream& s,
|
|
std::unordered_map<const void*, int64_t>& offsets);
|
|
static aet_layer_audio* aet_classic_read_layer_audio(prj::shared_ptr<prj::stack_allocator> alloc,
|
|
stream& s, int64_t offset);
|
|
static void aet_classic_write_layer_audio(const aet_layer_audio* layer_audio, stream& s,
|
|
std::unordered_map<const void*, int64_t>& offsets);
|
|
static aet_layer_video* aet_classic_read_layer_video(prj::shared_ptr<prj::stack_allocator> alloc,
|
|
stream& s, int64_t offset);
|
|
static void aet_classic_write_layer_video(const aet_layer_video* layer_video, stream& s,
|
|
std::unordered_map<const void*, int64_t>& offsets);
|
|
static aet_layer_video_3d* aet_classic_read_layer_video_3d(prj::shared_ptr<prj::stack_allocator> alloc,
|
|
stream& s, int64_t offset);
|
|
static void aet_classic_write_layer_video_3d(const aet_layer_video_3d* layer_video_3d, stream& s,
|
|
std::unordered_map<const void*, int64_t>& offsets);
|
|
static aet_scene* aet_classic_read_scene(prj::shared_ptr<prj::stack_allocator> alloc,
|
|
stream& s, int64_t offset, std::unordered_map<int64_t, const aet_layer*>& layers,
|
|
std::unordered_map<int64_t, aet_item>& items);
|
|
static void aet_classic_read_video(aet_video* video,
|
|
prj::shared_ptr<prj::stack_allocator> alloc, stream& s,
|
|
std::unordered_map<int64_t, aet_item>& items);
|
|
|
|
static void aet_modern_read_audio(aet_audio* audio,
|
|
prj::shared_ptr<prj::stack_allocator> alloc, stream& s,
|
|
uint32_t header_length, bool is_x);
|
|
static aet_camera* aet_modern_read_camera(prj::shared_ptr<prj::stack_allocator> alloc,
|
|
stream& s, int64_t offset,
|
|
uint32_t header_length, bool is_x);
|
|
static void aet_modern_read_comp(aet_comp* comp,
|
|
prj::shared_ptr<prj::stack_allocator> alloc, stream& s,
|
|
uint32_t header_length, bool is_x,
|
|
std::unordered_map<int64_t, const aet_layer*>& layers, std::unordered_map<int64_t, aet_item>& items);
|
|
static void aet_modern_read_fcurve(aet_fcurve* fcurve,
|
|
prj::shared_ptr<prj::stack_allocator> alloc, stream& s,
|
|
uint32_t header_length, bool is_x);
|
|
static void aet_modern_read_layer(aet_layer* layer,
|
|
prj::shared_ptr<prj::stack_allocator> alloc, stream& s,
|
|
uint32_t header_length, bool is_x);
|
|
static aet_layer_audio* aet_modern_read_layer_audio(prj::shared_ptr<prj::stack_allocator> alloc,
|
|
stream& s, int64_t offset,
|
|
uint32_t header_length, bool is_x);
|
|
static aet_layer_video* aet_modern_read_layer_video(prj::shared_ptr<prj::stack_allocator> alloc,
|
|
stream& s, int64_t offset,
|
|
uint32_t header_length, bool is_x);
|
|
static aet_layer_video_3d* aet_modern_read_layer_video_3d(prj::shared_ptr<prj::stack_allocator> alloc,
|
|
stream& s, int64_t offset,
|
|
uint32_t header_length, bool is_x);
|
|
static void aet_modern_read_marker(aet_marker* marker,
|
|
prj::shared_ptr<prj::stack_allocator> alloc, stream& s,
|
|
uint32_t header_length, bool is_x);
|
|
static aet_scene* aet_modern_read_scene(prj::shared_ptr<prj::stack_allocator> alloc,
|
|
stream& s, int64_t offset,
|
|
uint32_t header_length, bool is_x,
|
|
std::unordered_map<int64_t, const aet_layer*>& layers, std::unordered_map<int64_t, aet_item>& items);
|
|
static void aet_modern_read_video(aet_video* video,
|
|
prj::shared_ptr<prj::stack_allocator> alloc, stream& s,
|
|
uint32_t header_length, bool is_x,
|
|
std::unordered_map<int64_t, aet_item>& items);
|
|
|
|
static void aet_comp_set_item_parent(const aet_comp* comp,
|
|
std::unordered_map<int64_t, const aet_layer*>& layers,
|
|
std::unordered_map<int64_t, aet_item>& items);
|
|
|
|
static const char* aet_move_data_string(const char* str,
|
|
prj::shared_ptr<prj::stack_allocator>& alloc);
|
|
|
|
static const char* aet_read_utf8_string_null_terminated_offset(
|
|
prj::shared_ptr<prj::stack_allocator>& alloc, stream& s, int64_t offset);
|
|
|
|
static int64_t aet_strings_get_string_offset(
|
|
const std::unordered_map<std::string, int64_t>& vec, const std::string& str);
|
|
static void aet_strings_push_back_check(stream& s,
|
|
std::unordered_map<std::string, int64_t>& vec, const std::string& str);
|
|
|
|
aet_fcurve::aet_fcurve() : keys_count(), keys() {
|
|
|
|
}
|
|
|
|
float_t aet_fcurve::interpolate(float_t frame) const {
|
|
if (!keys_count)
|
|
return 0.0f;
|
|
else if (keys_count == 1)
|
|
return keys[0];
|
|
|
|
size_t keys_count = this->keys_count;
|
|
const float_t* keys = this->keys;
|
|
const float_t* values = &keys[keys_count];
|
|
if (frame <= keys[0])
|
|
return values[0];
|
|
|
|
const float_t* v6 = keys;
|
|
const float_t* v7 = &keys[keys_count];
|
|
if (frame >= keys[keys_count - 1])
|
|
return values[(keys_count - 1) * 2];
|
|
|
|
const float_t* v8 = &keys[keys_count / 2];
|
|
while (v6 < v8) {
|
|
if (frame >= *v8)
|
|
v6 = v8;
|
|
else
|
|
v7 = v8;
|
|
v8 = &v6[(v7 - v6) / 2];
|
|
}
|
|
|
|
if (values - 1 <= v8)
|
|
return values[(keys_count - 1) * 2];
|
|
|
|
size_t v9 = (v8 - keys) * 2;
|
|
|
|
float_t df = v8[1] - v8[0];
|
|
float_t t = (frame - v8[0]) / df;
|
|
float_t t_1 = t - 1.0f;
|
|
return (t_1 * values[v9 + 1] + t * values[v9 + 3]) * t * t_1 * df
|
|
+ t * t * (3.0f - 2.0f * t) * values[v9 + 2]
|
|
+ (1.0f + 2.0f * t) * (t_1 * t_1) * values[v9];
|
|
}
|
|
|
|
aet_layer_video_3d::aet_layer_video_3d() {
|
|
|
|
}
|
|
|
|
aet_transfer_mode::aet_transfer_mode() : mode(), flag(), matte() {
|
|
|
|
}
|
|
|
|
aet_layer_video::aet_layer_video() : _3d() {
|
|
|
|
}
|
|
|
|
aet_layer_audio::aet_layer_audio() {
|
|
|
|
}
|
|
|
|
aet_camera::aet_camera() {
|
|
|
|
}
|
|
|
|
aet_video_src::aet_video_src() : sprite_name() {
|
|
sprite_index = -1;
|
|
}
|
|
|
|
aet_video::aet_video() : color(), width(), height(), fpf(), sources_count(), sources() {
|
|
|
|
}
|
|
|
|
aet_audio::aet_audio() : sound_index() {
|
|
|
|
}
|
|
|
|
aet_marker::aet_marker() : time(), name() {
|
|
|
|
}
|
|
|
|
aet_layer::aet_layer() : name(), start_time(), end_time(), offset_time(), time_scale(),
|
|
flags(), quality(), item_type(), parent(), markers_count(), markers(), video(), audio() {
|
|
|
|
}
|
|
|
|
aet_comp::aet_comp() : layers_count(), layers() {
|
|
|
|
}
|
|
|
|
aet_scene::aet_scene() : name(), start_time(), end_time(), fps(), color(), width(),
|
|
height(), camera(), comp_count(), comp(), video_count(), video(), audio_count(), audio() {
|
|
|
|
}
|
|
|
|
const aet_comp* aet_scene::get_root_comp(const aet_scene* scene) {
|
|
if (scene && scene->comp_count)
|
|
return &scene->comp[scene->comp_count - 1];
|
|
return 0;
|
|
}
|
|
|
|
aet_set::aet_set() : ready(), modern(), big_endian(), is_x(), scenes_count(), scenes() {
|
|
|
|
}
|
|
|
|
void aet_set::move_data(aet_set* set_src, prj::shared_ptr<prj::stack_allocator> alloc) {
|
|
if (!set_src->ready) {
|
|
ready = false;
|
|
modern = false;
|
|
big_endian = false;
|
|
is_x = false;
|
|
return;
|
|
}
|
|
|
|
ready = true;
|
|
modern = set_src->modern;
|
|
big_endian = set_src->big_endian;
|
|
is_x = set_src->is_x;
|
|
|
|
std::unordered_map<int64_t, aet_item> items;
|
|
std::unordered_map<int64_t, const aet_layer*> layers;
|
|
|
|
uint32_t scenes_count = set_src->scenes_count;
|
|
const aet_scene** scenes_src = set_src->scenes;
|
|
aet_scene** scenes_dst = alloc->allocate<aet_scene*>(scenes_count);
|
|
|
|
for (uint32_t i = 0; i < scenes_count; i++) {
|
|
scenes_dst[i] = alloc->allocate<aet_scene>();
|
|
aet_move_data_scene(scenes_dst[i], scenes_src[i], alloc, layers, items);
|
|
}
|
|
|
|
this->scenes = (const aet_scene**)scenes_dst;
|
|
this->scenes_count = scenes_count;
|
|
|
|
for (uint32_t i = 0; i < scenes_count; i++) {
|
|
aet_scene* scene = scenes_dst[i];
|
|
const aet_comp* comp = scene->comp;
|
|
for (uint32_t j = scene->comp_count; j; j--, comp++)
|
|
aet_comp_set_item_parent(comp, layers, items);
|
|
}
|
|
}
|
|
|
|
void aet_set::pack_file(void** data, size_t* size) {
|
|
if (!data || !ready)
|
|
return;
|
|
|
|
memory_stream s;
|
|
s.open();
|
|
if (!modern)
|
|
aet_set_classic_write_inner(this, s);
|
|
else
|
|
aet_set_modern_write_inner(this, s);
|
|
s.align_write(0x10);
|
|
s.copy(data, size);
|
|
}
|
|
|
|
void aet_set::unpack_file(prj::shared_ptr<prj::stack_allocator> alloc, const void* data, size_t size, bool modern) {
|
|
if (!data || !size)
|
|
return;
|
|
|
|
memory_stream s;
|
|
s.open(data, size);
|
|
if (!modern)
|
|
aet_set_classic_read_inner(this, alloc, s);
|
|
else
|
|
aet_set_modern_read_inner(this, alloc, s);
|
|
}
|
|
|
|
static void aet_move_data_audio(aet_audio* audio_dst, const aet_audio* audio_src,
|
|
prj::shared_ptr<prj::stack_allocator> alloc) {
|
|
audio_dst->sound_index = audio_src->sound_index;
|
|
}
|
|
|
|
static aet_camera* aet_move_data_camera(const aet_camera* cam_src,
|
|
prj::shared_ptr<prj::stack_allocator> alloc) {
|
|
if (!cam_src)
|
|
return 0;
|
|
|
|
aet_camera* cam_dst = alloc->allocate<aet_camera>();
|
|
aet_move_data_fcurve(&cam_dst->eye_x, &cam_src->eye_x, alloc);
|
|
aet_move_data_fcurve(&cam_dst->eye_y, &cam_src->eye_y, alloc);
|
|
aet_move_data_fcurve(&cam_dst->eye_z, &cam_src->eye_z, alloc);
|
|
aet_move_data_fcurve(&cam_dst->pos_x, &cam_src->pos_x, alloc);
|
|
aet_move_data_fcurve(&cam_dst->pos_y, &cam_src->pos_y, alloc);
|
|
aet_move_data_fcurve(&cam_dst->pos_z, &cam_src->pos_z, alloc);
|
|
aet_move_data_fcurve(&cam_dst->dir_x, &cam_src->dir_x, alloc);
|
|
aet_move_data_fcurve(&cam_dst->dir_y, &cam_src->dir_y, alloc);
|
|
aet_move_data_fcurve(&cam_dst->dir_z, &cam_src->dir_z, alloc);
|
|
aet_move_data_fcurve(&cam_dst->rot_x, &cam_src->rot_x, alloc);
|
|
aet_move_data_fcurve(&cam_dst->rot_y, &cam_src->rot_y, alloc);
|
|
aet_move_data_fcurve(&cam_dst->rot_z, &cam_src->rot_z, alloc);
|
|
aet_move_data_fcurve(&cam_dst->zoom, &cam_src->zoom, alloc);
|
|
return cam_dst;
|
|
}
|
|
|
|
static void aet_move_data_comp(aet_comp* comp_dst, const aet_comp* comp_src,
|
|
prj::shared_ptr<prj::stack_allocator> alloc, std::unordered_map<int64_t, const aet_layer*>& layers) {
|
|
uint32_t layers_count = comp_src->layers_count;
|
|
const aet_layer* layers_src = comp_src->layers;
|
|
aet_layer* layers_dst = alloc->allocate<aet_layer>(layers_count);
|
|
|
|
for (uint32_t i = 0; i < layers_count; i++) {
|
|
aet_move_data_layer(&layers_dst[i], &layers_src[i], alloc);
|
|
layers[(int64_t)&layers_src[i]] = &layers_dst[i];
|
|
}
|
|
|
|
comp_dst->layers = layers_dst;
|
|
comp_dst->layers_count = layers_count;
|
|
}
|
|
|
|
static void aet_move_data_fcurve(aet_fcurve* fcurve_dst, const aet_fcurve* fcurve_src,
|
|
prj::shared_ptr<prj::stack_allocator> alloc) {
|
|
fcurve_dst->keys_count = fcurve_src->keys_count;
|
|
|
|
if (fcurve_src->keys_count > 1)
|
|
fcurve_dst->keys = alloc->allocate<float_t>(fcurve_src->keys, fcurve_src->keys_count * 3ULL);
|
|
else if (fcurve_src->keys_count)
|
|
fcurve_dst->keys = alloc->allocate<float_t>(fcurve_src->keys);
|
|
else
|
|
fcurve_dst->keys = 0;
|
|
}
|
|
|
|
static void aet_move_data_layer(aet_layer* layer_dst, const aet_layer* layer_src,
|
|
prj::shared_ptr<prj::stack_allocator> alloc) {
|
|
layer_dst->name = aet_move_data_string(layer_src->name, alloc);
|
|
layer_dst->start_time = layer_src->start_time;
|
|
layer_dst->end_time = layer_src->end_time;
|
|
layer_dst->offset_time = layer_src->offset_time;
|
|
layer_dst->time_scale = layer_src->time_scale;
|
|
layer_dst->flags = layer_src->flags;
|
|
layer_dst->quality = layer_src->quality;
|
|
layer_dst->item_type = layer_src->item_type;
|
|
layer_dst->item.none = layer_src->item.none;
|
|
layer_dst->parent = layer_src->parent;
|
|
|
|
uint32_t markers_count = layer_src->markers_count;
|
|
const aet_marker* markers_src = layer_src->markers;
|
|
aet_marker* markers_dst = alloc->allocate<aet_marker>(markers_count);
|
|
|
|
for (uint32_t i = 0; i < markers_count; i++)
|
|
aet_move_data_marker(&markers_dst[i], &markers_src[i], alloc);
|
|
|
|
layer_dst->markers = markers_dst;
|
|
layer_dst->markers_count = markers_count;
|
|
|
|
layer_dst->video = aet_move_data_layer_video(layer_src->video, alloc);
|
|
layer_dst->audio = aet_move_data_layer_audio(layer_src->audio, alloc);
|
|
}
|
|
|
|
static aet_layer_audio* aet_move_data_layer_audio(const aet_layer_audio* layer_audio_src,
|
|
prj::shared_ptr<prj::stack_allocator> alloc) {
|
|
if (!layer_audio_src)
|
|
return 0;
|
|
|
|
aet_layer_audio* layer_audio_dst = alloc->allocate<aet_layer_audio>();
|
|
aet_move_data_fcurve(&layer_audio_dst->volume_l, &layer_audio_src->volume_l, alloc);
|
|
aet_move_data_fcurve(&layer_audio_dst->volume_r, &layer_audio_src->volume_r, alloc);
|
|
aet_move_data_fcurve(&layer_audio_dst->pan_l, &layer_audio_src->pan_l, alloc);
|
|
aet_move_data_fcurve(&layer_audio_dst->pan_r, &layer_audio_src->pan_r, alloc);
|
|
return layer_audio_dst;
|
|
}
|
|
|
|
static aet_layer_video* aet_move_data_layer_video(const aet_layer_video* layer_video_src,
|
|
prj::shared_ptr<prj::stack_allocator> alloc) {
|
|
if (!layer_video_src)
|
|
return 0;
|
|
|
|
aet_layer_video* layer_video_dst = alloc->allocate<aet_layer_video>();
|
|
layer_video_dst->transfer_mode = layer_video_src->transfer_mode;
|
|
aet_move_data_fcurve(&layer_video_dst->anchor_x, &layer_video_src->anchor_x, alloc);
|
|
aet_move_data_fcurve(&layer_video_dst->anchor_y, &layer_video_src->anchor_y, alloc);
|
|
aet_move_data_fcurve(&layer_video_dst->pos_x, &layer_video_src->pos_x, alloc);
|
|
aet_move_data_fcurve(&layer_video_dst->pos_y, &layer_video_src->pos_y, alloc);
|
|
aet_move_data_fcurve(&layer_video_dst->rot_z, &layer_video_src->rot_z, alloc);
|
|
aet_move_data_fcurve(&layer_video_dst->scale_x, &layer_video_src->scale_x, alloc);
|
|
aet_move_data_fcurve(&layer_video_dst->scale_y, &layer_video_src->scale_y, alloc);
|
|
aet_move_data_fcurve(&layer_video_dst->opacity, &layer_video_src->opacity, alloc);
|
|
layer_video_dst->_3d = aet_move_data_layer_video_3d(layer_video_src->_3d, alloc);
|
|
return layer_video_dst;
|
|
}
|
|
|
|
static aet_layer_video_3d* aet_move_data_layer_video_3d(const aet_layer_video_3d* layer_video_3d_src,
|
|
prj::shared_ptr<prj::stack_allocator> alloc) {
|
|
if (!layer_video_3d_src)
|
|
return 0;
|
|
|
|
aet_layer_video_3d* layer_video_3d_dst = alloc->allocate<aet_layer_video_3d>();
|
|
aet_move_data_fcurve(&layer_video_3d_dst->anchor_z, &layer_video_3d_src->anchor_z, alloc);
|
|
aet_move_data_fcurve(&layer_video_3d_dst->pos_z, &layer_video_3d_src->pos_z, alloc);
|
|
aet_move_data_fcurve(&layer_video_3d_dst->dir_x, &layer_video_3d_src->dir_x, alloc);
|
|
aet_move_data_fcurve(&layer_video_3d_dst->dir_y, &layer_video_3d_src->dir_y, alloc);
|
|
aet_move_data_fcurve(&layer_video_3d_dst->dir_z, &layer_video_3d_src->dir_z, alloc);
|
|
aet_move_data_fcurve(&layer_video_3d_dst->rot_x, &layer_video_3d_src->rot_x, alloc);
|
|
aet_move_data_fcurve(&layer_video_3d_dst->rot_y, &layer_video_3d_src->rot_y, alloc);
|
|
aet_move_data_fcurve(&layer_video_3d_dst->scale_z, &layer_video_3d_src->scale_z, alloc);
|
|
return layer_video_3d_dst;
|
|
}
|
|
|
|
static void aet_move_data_marker(aet_marker* marker_dst, const aet_marker* marker_src,
|
|
prj::shared_ptr<prj::stack_allocator> alloc) {
|
|
marker_dst->time = marker_src->time;
|
|
marker_dst->name = aet_move_data_string(marker_src->name, alloc);
|
|
}
|
|
|
|
static void aet_move_data_scene(aet_scene* scene_dst, const aet_scene* scene_src,
|
|
prj::shared_ptr<prj::stack_allocator> alloc,
|
|
std::unordered_map<int64_t, const aet_layer*>& layers,
|
|
std::unordered_map<int64_t, aet_item>& items) {
|
|
scene_dst->name = aet_move_data_string(scene_src->name, alloc);
|
|
scene_dst->start_time = scene_src->start_time;
|
|
scene_dst->end_time = scene_src->end_time;
|
|
scene_dst->fps = scene_src->fps;
|
|
scene_dst->color[0] = scene_src->color[0];
|
|
scene_dst->color[1] = scene_src->color[1];
|
|
scene_dst->color[2] = scene_src->color[2];
|
|
scene_dst->width = scene_src->width;
|
|
scene_dst->height = scene_src->height;
|
|
|
|
scene_dst->camera = aet_move_data_camera(scene_src->camera, alloc);
|
|
|
|
uint32_t video_count = scene_src->video_count;
|
|
const aet_video* video_src = scene_src->video;
|
|
aet_video* video_dst = alloc->allocate<aet_video>(video_count);
|
|
|
|
for (uint32_t i = 0; i < video_count; i++) {
|
|
aet_move_data_video(&video_dst[i], &video_src[i], alloc);
|
|
items[(int64_t)&video_src[i]] = &video_dst[i];
|
|
}
|
|
|
|
scene_dst->video = video_dst;
|
|
scene_dst->video_count = video_count;
|
|
|
|
uint32_t audio_count = scene_src->audio_count;
|
|
const aet_audio* audio_src = scene_src->audio;
|
|
aet_audio* audio_dst = alloc->allocate<aet_audio>(audio_count);
|
|
|
|
for (uint32_t i = 0; i < audio_count; i++)
|
|
aet_move_data_audio(&audio_dst[i], &audio_src[i], alloc);
|
|
|
|
scene_dst->audio = audio_dst;
|
|
scene_dst->audio_count = audio_count;
|
|
|
|
uint32_t comp_count = scene_src->comp_count;
|
|
const aet_comp* comp_src = scene_src->comp;
|
|
aet_comp* comp_dst = alloc->allocate<aet_comp>(comp_count);
|
|
|
|
for (uint32_t i = 0; i < comp_count; i++) {
|
|
aet_move_data_comp(&comp_dst[i], &comp_src[i], alloc, layers);
|
|
items[(int64_t)&comp_src[i]] = &comp_dst[i];
|
|
}
|
|
|
|
scene_dst->comp = comp_dst;
|
|
scene_dst->comp_count = comp_count;
|
|
}
|
|
|
|
static void aet_move_data_video(aet_video* video_dst, const aet_video* video_src,
|
|
prj::shared_ptr<prj::stack_allocator> alloc) {
|
|
video_dst->color[0] = video_src->color[0];
|
|
video_dst->color[1] = video_src->color[1];
|
|
video_dst->color[2] = video_src->color[2];
|
|
video_dst->width = video_src->width;
|
|
video_dst->height = video_src->height;
|
|
video_dst->fpf = video_src->fpf;
|
|
|
|
uint32_t sources_count = video_src->sources_count;
|
|
const aet_video_src* sources_src = video_src->sources;
|
|
aet_video_src* sources_dst = alloc->allocate<aet_video_src>(sources_count);
|
|
|
|
for (uint32_t i = 0; i < sources_count; i++)
|
|
aet_move_data_video_src(&sources_dst[i], &sources_src[i], alloc);
|
|
|
|
video_dst->sources = sources_dst;
|
|
video_dst->sources_count = sources_count;
|
|
}
|
|
|
|
static void aet_move_data_video_src(aet_video_src* video_dst, const aet_video_src* video_src,
|
|
prj::shared_ptr<prj::stack_allocator> alloc) {
|
|
video_dst->sprite_name = aet_move_data_string(video_src->sprite_name, alloc);
|
|
video_dst->sprite_index = video_src->sprite_index;
|
|
}
|
|
|
|
static void aet_set_classic_read_inner(aet_set* as, prj::shared_ptr<prj::stack_allocator>& alloc, stream& s) {
|
|
uint32_t scenes_count = 0;
|
|
while (s.read_uint32_t())
|
|
scenes_count++;
|
|
as->scenes_count = scenes_count;
|
|
|
|
aet_scene** scenes = alloc->allocate<aet_scene*>(scenes_count);
|
|
as->scenes = (const aet_scene**)scenes;
|
|
|
|
uint32_t* data = force_malloc<uint32_t>(scenes_count);
|
|
s.set_position(0, SEEK_SET);
|
|
for (uint32_t i = 0; i < scenes_count; i++)
|
|
data[i] = s.read_uint32_t();
|
|
|
|
std::unordered_map<int64_t, aet_item> items;
|
|
std::unordered_map<int64_t, const aet_layer*> layers;
|
|
|
|
for (uint32_t i = 0; i < scenes_count; i++)
|
|
scenes[i] = aet_classic_read_scene(alloc, s, data[i], layers, items);
|
|
|
|
for (uint32_t i = 0; i < scenes_count; i++) {
|
|
aet_scene* scene = scenes[i];
|
|
const aet_comp* comp = scene->comp;
|
|
for (uint32_t j = scene->comp_count; j; j--, comp++)
|
|
aet_comp_set_item_parent(comp, layers, items);
|
|
}
|
|
|
|
free_def(data);
|
|
|
|
as->ready = true;
|
|
as->modern = false;
|
|
as->big_endian = false;
|
|
as->is_x = false;
|
|
}
|
|
|
|
static void aet_set_classic_write_inner(aet_set* as, stream& s) {
|
|
for (uint32_t i = align_val(as->scenes_count + 1, 8); i; i--)
|
|
s.write_uint32_t(0x90669066);
|
|
|
|
std::unordered_map<std::string, int64_t> strings;
|
|
|
|
std::unordered_map<const void*, int64_t> offsets;
|
|
|
|
uint32_t scenes_count = as->scenes_count;
|
|
const aet_scene** scenes = as->scenes;
|
|
|
|
for (uint32_t i = 0; i < scenes_count; i++) {
|
|
const aet_scene* scene = scenes[i];
|
|
|
|
const aet_video* video = scene->video;
|
|
for (uint32_t j = scene->video_count; j; j--, video++) {
|
|
if (video->sources_count == 0) {
|
|
offsets[video->sources] = 0;
|
|
continue;
|
|
}
|
|
|
|
if (video->sources_count > 1)
|
|
s.align_write(0x20);
|
|
offsets[video->sources] = s.get_position();
|
|
s.write(0x08ULL * video->sources_count);
|
|
}
|
|
|
|
if (scene->video_count > 1)
|
|
s.align_write(0x20);
|
|
offsets[scene->video] = s.get_position();
|
|
video = scene->video;
|
|
for (uint32_t j = scene->video_count; j; j--, video++) {
|
|
offsets[video] = s.get_position();
|
|
|
|
s.write_uint8_t(video->color[0]);
|
|
s.write_uint8_t(video->color[1]);
|
|
s.write_uint8_t(video->color[2]);
|
|
s.write(0x01);
|
|
s.write_uint16_t(video->width);
|
|
s.write_uint16_t(video->height);
|
|
s.write_float_t(video->fpf);
|
|
s.write_uint32_t(video->sources_count);
|
|
s.write_uint32_t(video->sources ? (uint32_t)offsets[video->sources] : 0);
|
|
}
|
|
|
|
if (scene->comp_count > 1)
|
|
s.align_write(0x20);
|
|
|
|
offsets[scene->comp] = s.get_position();
|
|
const aet_comp* comp = scene->comp;
|
|
for (uint32_t j = scene->comp_count; j; j--, comp++) {
|
|
offsets[comp] = s.get_position();
|
|
s.write(0x08);
|
|
}
|
|
|
|
comp = scene->comp;
|
|
for (uint32_t j = scene->comp_count; j; j--, comp++) {
|
|
if (comp->layers_count < 1)
|
|
continue;
|
|
|
|
const aet_layer* layer = comp->layers;
|
|
for (uint32_t k = comp->layers_count; k; k--, layer++) {
|
|
if (layer->markers) {
|
|
if (layer->markers_count > 3)
|
|
s.align_write(0x20);
|
|
offsets[layer->markers] = s.get_position();
|
|
s.write(0x08ULL * layer->markers_count);
|
|
}
|
|
|
|
const aet_layer_video* layer_video = layer->video;
|
|
if (layer_video) {
|
|
const aet_layer_video_3d* layer_video_3d = layer_video->_3d;
|
|
aet_classic_write_layer_video(layer_video, s, offsets);
|
|
|
|
if (layer_video_3d) {
|
|
s.align_write(0x20);
|
|
offsets[layer_video_3d] = s.get_position();
|
|
s.write(0x40);
|
|
}
|
|
}
|
|
|
|
const aet_layer_audio* layer_audio = layer->audio;
|
|
aet_classic_write_layer_audio(layer_audio, s, offsets);
|
|
|
|
if (layer_video) {
|
|
s.align_write(0x20);
|
|
offsets[layer_video] = s.get_position();
|
|
s.write(0x48);
|
|
}
|
|
|
|
if (layer_audio) {
|
|
s.align_write(0x20);
|
|
offsets[layer_audio] = s.get_position();
|
|
s.write(0x20);
|
|
}
|
|
}
|
|
|
|
s.align_write(0x20);
|
|
offsets[comp->layers] = s.get_position();
|
|
layer = comp->layers;
|
|
for (uint32_t k = comp->layers_count; k; k--, layer++) {
|
|
offsets[layer] = s.get_position();
|
|
s.write(0x30);
|
|
}
|
|
}
|
|
|
|
aet_classic_write_camera(scene->camera, s, offsets);
|
|
|
|
s.align_write(0x20);
|
|
offsets[scene] = s.get_position();
|
|
s.write(0x40);
|
|
|
|
s.align_write(0x10);
|
|
}
|
|
|
|
for (uint32_t i = 0; i < scenes_count; i++) {
|
|
const aet_scene* scene = scenes[i];
|
|
|
|
const aet_video* video = scene->video;
|
|
for (uint32_t j = scene->video_count; j; j--, video++)
|
|
for (uint32_t k = 0; k < video->sources_count; k++)
|
|
aet_strings_push_back_check(s, strings, video->sources[k].sprite_name);
|
|
|
|
const aet_comp* comp = scene->comp;
|
|
for (uint32_t j = scene->comp_count; j; j--, comp++) {
|
|
const aet_layer* layer = comp->layers;
|
|
for (uint32_t k = comp->layers_count; k; k--, layer++) {
|
|
const aet_marker* marker = layer->markers;
|
|
for (uint32_t l = layer->markers_count; l; l--, marker++)
|
|
aet_strings_push_back_check(s, strings, marker->name);
|
|
}
|
|
|
|
layer = comp->layers;
|
|
for (uint32_t k = comp->layers_count; k; k--, layer++)
|
|
aet_strings_push_back_check(s, strings, layer->name);
|
|
}
|
|
|
|
aet_strings_push_back_check(s, strings, scene->name);
|
|
s.align_write(0x04);
|
|
}
|
|
|
|
for (uint32_t i = 0; i < scenes_count; i++) {
|
|
const aet_scene* scene = scenes[i];
|
|
|
|
if (scene->audio) {
|
|
offsets[scene->audio] = s.get_position();
|
|
const aet_audio* audio = scene->audio;
|
|
for (uint32_t j = scene->audio_count; j; j--, audio++)
|
|
aet_classic_write_audio(&scene->audio[j], s, offsets);
|
|
}
|
|
}
|
|
|
|
int64_t null_data_pos = s.get_position();
|
|
uint32_t null_data_count = 0;
|
|
for (uint32_t i = 0; i < scenes_count; i++) {
|
|
const aet_scene* scene = scenes[i];
|
|
|
|
const aet_comp* comp = scene->comp;
|
|
for (uint32_t j = scene->comp_count; j; j--, comp++) {
|
|
if (comp->layers_count < 1)
|
|
continue;
|
|
|
|
const aet_layer* layer = comp->layers;
|
|
for (uint32_t k = comp->layers_count; k; k--, layer++) {
|
|
const aet_layer_video* layer_video = layer->video;
|
|
const aet_layer_audio* layer_audio = layer->audio;
|
|
if (layer_video) {
|
|
const aet_layer_video_3d* layer_video_3d = layer_video->_3d;
|
|
if (layer_video_3d) {
|
|
s.position_push(offsets[layer_video_3d], SEEK_SET);
|
|
aet_classic_write_fcurve_header(&layer_video_3d->anchor_z,
|
|
s, offsets, null_data_pos, null_data_count);
|
|
aet_classic_write_fcurve_header(&layer_video_3d->pos_z,
|
|
s, offsets, null_data_pos, null_data_count);
|
|
aet_classic_write_fcurve_header(&layer_video_3d->dir_x,
|
|
s, offsets, null_data_pos, null_data_count);
|
|
aet_classic_write_fcurve_header(&layer_video_3d->dir_y,
|
|
s, offsets, null_data_pos, null_data_count);
|
|
aet_classic_write_fcurve_header(&layer_video_3d->dir_z,
|
|
s, offsets, null_data_pos, null_data_count);
|
|
aet_classic_write_fcurve_header(&layer_video_3d->rot_x,
|
|
s, offsets, null_data_pos, null_data_count);
|
|
aet_classic_write_fcurve_header(&layer_video_3d->rot_y,
|
|
s, offsets, null_data_pos, null_data_count);
|
|
aet_classic_write_fcurve_header(&layer_video_3d->scale_z,
|
|
s, offsets, null_data_pos, null_data_count);
|
|
s.position_pop();
|
|
}
|
|
|
|
s.position_push(offsets[layer_video], SEEK_SET);
|
|
s.write_uint8_t((uint8_t)layer_video->transfer_mode.mode);
|
|
s.write_uint8_t((uint8_t)layer_video->transfer_mode.flag);
|
|
s.write_uint8_t((uint8_t)layer_video->transfer_mode.matte);
|
|
s.write(0x01);
|
|
|
|
aet_classic_write_fcurve_header(&layer_video->anchor_x,
|
|
s, offsets, null_data_pos, null_data_count);
|
|
aet_classic_write_fcurve_header(&layer_video->anchor_y,
|
|
s, offsets, null_data_pos, null_data_count);
|
|
aet_classic_write_fcurve_header(&layer_video->pos_x,
|
|
s, offsets, null_data_pos, null_data_count);
|
|
aet_classic_write_fcurve_header(&layer_video->pos_y,
|
|
s, offsets, null_data_pos, null_data_count);
|
|
aet_classic_write_fcurve_header(&layer_video->rot_z,
|
|
s, offsets, null_data_pos, null_data_count);
|
|
aet_classic_write_fcurve_header(&layer_video->scale_x,
|
|
s, offsets, null_data_pos, null_data_count);
|
|
aet_classic_write_fcurve_header(&layer_video->scale_y,
|
|
s, offsets, null_data_pos, null_data_count);
|
|
aet_classic_write_fcurve_header(&layer_video->opacity,
|
|
s, offsets, null_data_pos, null_data_count);
|
|
s.write_uint32_t(layer_video_3d ? (uint32_t)offsets[layer_video_3d] : 0);
|
|
s.position_pop();
|
|
}
|
|
|
|
if (layer_audio) {
|
|
s.position_push(offsets[layer_audio], SEEK_SET);
|
|
aet_classic_write_fcurve_header(&layer_audio->volume_l,
|
|
s, offsets, null_data_pos, null_data_count);
|
|
aet_classic_write_fcurve_header(&layer_audio->volume_r,
|
|
s, offsets, null_data_pos, null_data_count);
|
|
aet_classic_write_fcurve_header(&layer_audio->pan_l,
|
|
s, offsets, null_data_pos, null_data_count);
|
|
aet_classic_write_fcurve_header(&layer_audio->pan_r,
|
|
s, offsets, null_data_pos, null_data_count);
|
|
s.position_pop();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
s.write(sizeof(uint32_t) * null_data_count);
|
|
s.align_write(0x10);
|
|
|
|
for (uint32_t i = 0; i < scenes_count; i++) {
|
|
const aet_scene* scene = scenes[i];
|
|
const aet_comp* comp = scene->comp;
|
|
for (uint32_t j = scene->comp_count; j; j--, comp++) {
|
|
const aet_layer* layer = comp->layers;
|
|
for (uint32_t k = comp->layers_count; k; k--, layer++) {
|
|
s.set_position(offsets[layer], SEEK_SET);
|
|
s.write_uint32_t((uint32_t)aet_strings_get_string_offset(strings, layer->name));
|
|
s.write_float_t(layer->start_time);
|
|
s.write_float_t(layer->end_time);
|
|
s.write_float_t(layer->offset_time);
|
|
s.write_float_t(layer->time_scale);
|
|
s.write_uint16_t(*(uint16_t*)&layer->flags);
|
|
s.write_uint8_t((uint8_t)layer->quality);
|
|
s.write_uint8_t((uint8_t)layer->item_type);
|
|
if (layer->item_type == AET_ITEM_TYPE_VIDEO
|
|
|| layer->item_type == AET_ITEM_TYPE_COMPOSITION)
|
|
s.write_uint32_t((uint32_t)offsets[layer->item.none]);
|
|
else
|
|
s.write(0x04);
|
|
|
|
s.write_uint32_t(layer->parent ? (uint32_t)offsets[layer->parent] : 0);
|
|
s.write_uint32_t(layer->markers_count);
|
|
s.write_uint32_t(layer->markers ? (uint32_t)offsets[layer->markers] : 0);
|
|
s.write_uint32_t(layer->video ? (uint32_t)offsets[layer->video] : 0);
|
|
s.write_uint32_t(layer->audio ? (uint32_t)offsets[layer->audio] : 0);
|
|
|
|
if (layer->markers) {
|
|
s.set_position(offsets[layer->markers], SEEK_SET);
|
|
const aet_marker* marker = layer->markers;
|
|
for (uint32_t l = layer->markers_count; l; l--, marker++) {
|
|
s.write_float_t(marker->time);
|
|
s.write_uint32_t((uint32_t)aet_strings_get_string_offset(strings, marker->name));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
const aet_video* video = scene->video;
|
|
for (uint32_t j = scene->video_count; j; j--, video++) {
|
|
if (!video->sources)
|
|
continue;
|
|
|
|
s.set_position(offsets[video->sources], SEEK_SET);
|
|
const aet_video_src* source = video->sources;
|
|
for (uint32_t k = video->sources_count; k; k--, source++) {
|
|
s.write_uint32_t((uint32_t)aet_strings_get_string_offset(strings, source->sprite_name));
|
|
s.write_uint32_t(source->sprite_index);
|
|
}
|
|
}
|
|
|
|
s.set_position(offsets[scene->comp], SEEK_SET);
|
|
comp = scene->comp;
|
|
for (uint32_t j = scene->comp_count; j; j--, comp++) {
|
|
if (comp->layers) {
|
|
s.write_uint32_t(comp->layers_count);
|
|
s.write_uint32_t((uint32_t)offsets[comp->layers]);
|
|
}
|
|
else
|
|
s.write(0x08);
|
|
}
|
|
|
|
s.set_position(offsets[scene], SEEK_SET);
|
|
s.write_uint32_t((uint32_t)aet_strings_get_string_offset(strings, scene->name));
|
|
s.write_float_t(scene->start_time);
|
|
s.write_float_t(scene->end_time);
|
|
s.write_float_t(scene->fps);
|
|
s.write_uint8_t(scene->color[0]);
|
|
s.write_uint8_t(scene->color[1]);
|
|
s.write_uint8_t(scene->color[2]);
|
|
s.write_uint8_t(0x00);
|
|
s.write_uint32_t(scene->width);
|
|
s.write_uint32_t(scene->height);
|
|
s.write_uint32_t(scene->camera ? (uint32_t)offsets[scene->camera] : 0);
|
|
s.write_uint32_t(scene->comp_count);
|
|
s.write_uint32_t(scene->comp ? (uint32_t)offsets[scene->comp] : 0);
|
|
s.write_uint32_t(scene->video_count);
|
|
s.write_uint32_t(scene->video ? (uint32_t)offsets[scene->video] : 0);
|
|
s.write_uint32_t(scene->audio_count);
|
|
s.write_uint32_t(scene->audio ? (uint32_t)offsets[scene->audio] : 0);
|
|
s.write(0x08);
|
|
}
|
|
|
|
s.position_push(0x00, SEEK_SET);
|
|
for (uint32_t i = 0; i < scenes_count; i++)
|
|
s.write_uint32_t((uint32_t)offsets[scenes[i]]);
|
|
s.write(0x04);
|
|
s.position_pop();
|
|
}
|
|
|
|
static void aet_set_modern_read_inner(aet_set* as, prj::shared_ptr<prj::stack_allocator>& alloc, stream& s) {
|
|
f2_struct st;
|
|
st.read(s);
|
|
if (st.header.signature != reverse_endianness_uint32_t('AETC') || !st.data.size())
|
|
return;
|
|
|
|
uint32_t header_length = st.header.length;
|
|
bool big_endian = st.header.use_big_endian;
|
|
bool is_x = st.pof.shift_x;
|
|
|
|
memory_stream s_aetc;
|
|
s_aetc.open(st.data);
|
|
s_aetc.big_endian = big_endian;
|
|
|
|
uint32_t scenes_count = 0;
|
|
if (!is_x)
|
|
while (s_aetc.read_uint32_t_reverse_endianness())
|
|
scenes_count++;
|
|
else
|
|
while (s_aetc.read_int64_t_reverse_endianness())
|
|
scenes_count++;
|
|
as->scenes_count = scenes_count;
|
|
|
|
aet_scene** scenes = alloc->allocate<aet_scene*>(scenes_count);
|
|
as->scenes = (const aet_scene**)scenes;
|
|
|
|
int64_t* data = force_malloc<int64_t>(scenes_count);
|
|
s_aetc.set_position(0, SEEK_SET);
|
|
if (!is_x)
|
|
for (uint32_t i = 0; i < scenes_count; i++)
|
|
data[i] = s_aetc.read_uint32_t_reverse_endianness();
|
|
else
|
|
for (uint32_t i = 0; i < scenes_count; i++)
|
|
data[i] = s_aetc.read_int64_t_reverse_endianness();
|
|
|
|
std::unordered_map<int64_t, aet_item> items;
|
|
std::unordered_map<int64_t, const aet_layer*> layers;
|
|
|
|
for (uint32_t i = 0; i < scenes_count; i++)
|
|
scenes[i] = aet_modern_read_scene(alloc, s_aetc, data[i],
|
|
header_length, is_x, layers, items);
|
|
|
|
for (uint32_t i = 0; i < scenes_count; i++) {
|
|
aet_scene* scene = scenes[i];
|
|
const aet_comp* comp = scene->comp;
|
|
for (uint32_t j = scene->comp_count; j; j--, comp++)
|
|
aet_comp_set_item_parent(comp, layers, items);
|
|
}
|
|
|
|
free_def(data);
|
|
|
|
as->ready = true;
|
|
as->modern = true;
|
|
as->big_endian = big_endian;
|
|
as->is_x = is_x;
|
|
}
|
|
|
|
static void aet_set_modern_write_inner(aet_set* as, stream& s) {
|
|
bool big_endian = as->big_endian;
|
|
bool is_x = as->is_x;
|
|
|
|
memory_stream s_aetc;
|
|
s_aetc.open();
|
|
s_aetc.big_endian = big_endian;
|
|
|
|
uint32_t off;
|
|
enrs e;
|
|
enrs_entry ee;
|
|
pof pof;
|
|
|
|
off = align_val(0, 0x10);
|
|
|
|
f2_struct st;
|
|
s_aetc.align_write(0x10);
|
|
s_aetc.copy(st.data);
|
|
s_aetc.close();
|
|
|
|
st.enrs = e;
|
|
st.pof = pof;
|
|
|
|
st.header.signature = reverse_endianness_uint32_t('AETC');
|
|
st.header.length = 0x20;
|
|
st.header.use_big_endian = big_endian;
|
|
st.header.use_section_size = true;
|
|
|
|
st.write(s, true, is_x);
|
|
}
|
|
|
|
static void aet_classic_read_audio(aet_audio* audio,
|
|
prj::shared_ptr<prj::stack_allocator> alloc, stream& s,
|
|
std::unordered_map<int64_t, aet_item>& items) {
|
|
items[s.get_position()] = audio;
|
|
audio->sound_index = s.read_int32_t();
|
|
}
|
|
|
|
static void aet_classic_write_audio(const aet_audio* audio, stream& s,
|
|
std::unordered_map<const void*, int64_t>& offsets) {
|
|
offsets[audio] = s.get_position();
|
|
s.write_int32_t(audio->sound_index);
|
|
}
|
|
|
|
static aet_camera* aet_classic_read_camera(prj::shared_ptr<prj::stack_allocator> alloc,
|
|
stream& s, int64_t offset) {
|
|
if (!offset)
|
|
return 0;
|
|
|
|
aet_camera* cam = alloc->allocate<aet_camera>();
|
|
s.position_push(offset, SEEK_SET);
|
|
aet_classic_read_fcurve(&cam->eye_x, alloc, s);
|
|
aet_classic_read_fcurve(&cam->eye_y, alloc, s);
|
|
aet_classic_read_fcurve(&cam->eye_z, alloc, s);
|
|
aet_classic_read_fcurve(&cam->pos_x, alloc, s);
|
|
aet_classic_read_fcurve(&cam->pos_y, alloc, s);
|
|
aet_classic_read_fcurve(&cam->pos_z, alloc, s);
|
|
aet_classic_read_fcurve(&cam->dir_x, alloc, s);
|
|
aet_classic_read_fcurve(&cam->dir_y, alloc, s);
|
|
aet_classic_read_fcurve(&cam->dir_z, alloc, s);
|
|
aet_classic_read_fcurve(&cam->rot_x, alloc, s);
|
|
aet_classic_read_fcurve(&cam->rot_y, alloc, s);
|
|
aet_classic_read_fcurve(&cam->rot_z, alloc, s);
|
|
aet_classic_read_fcurve(&cam->zoom, alloc, s);
|
|
s.position_pop();
|
|
return cam;
|
|
}
|
|
|
|
static void aet_classic_write_camera(const aet_camera* cam, stream& s,
|
|
std::unordered_map<const void*, int64_t>& offsets) {
|
|
if (!cam)
|
|
return;
|
|
|
|
s.align_write(0x10);
|
|
aet_classic_write_fcurve(&cam->eye_x, s, offsets);
|
|
aet_classic_write_fcurve(&cam->eye_y, s, offsets);
|
|
aet_classic_write_fcurve(&cam->eye_z, s, offsets);
|
|
aet_classic_write_fcurve(&cam->pos_x, s, offsets);
|
|
aet_classic_write_fcurve(&cam->pos_y, s, offsets);
|
|
aet_classic_write_fcurve(&cam->pos_z, s, offsets);
|
|
aet_classic_write_fcurve(&cam->dir_x, s, offsets);
|
|
aet_classic_write_fcurve(&cam->dir_y, s, offsets);
|
|
aet_classic_write_fcurve(&cam->dir_z, s, offsets);
|
|
aet_classic_write_fcurve(&cam->rot_x, s, offsets);
|
|
aet_classic_write_fcurve(&cam->rot_y, s, offsets);
|
|
aet_classic_write_fcurve(&cam->rot_z, s, offsets);
|
|
aet_classic_write_fcurve(&cam->zoom, s, offsets);
|
|
|
|
s.align_write(0x20);
|
|
offsets[cam] = s.get_position();
|
|
s.write(0x34);
|
|
}
|
|
|
|
static void aet_classic_read_comp(aet_comp* comp,
|
|
prj::shared_ptr<prj::stack_allocator> alloc, stream& s,
|
|
std::unordered_map<int64_t, const aet_layer*>& layers,
|
|
std::unordered_map<int64_t, aet_item>& items) {
|
|
items[s.get_position()] = comp;
|
|
|
|
comp->layers_count = s.read_uint32_t();
|
|
uint32_t layers_offset = s.read_uint32_t();
|
|
|
|
if (layers_offset) {
|
|
aet_layer* layer = alloc->allocate<aet_layer>(comp->layers_count);
|
|
comp->layers = layer;
|
|
|
|
s.position_push(layers_offset, SEEK_SET);
|
|
for (uint32_t i = comp->layers_count; i; i--, layer++) {
|
|
layers[s.get_position()] = layer;
|
|
aet_classic_read_layer(layer, alloc, s);
|
|
}
|
|
s.position_pop();
|
|
}
|
|
else
|
|
comp->layers = 0;
|
|
}
|
|
|
|
static void aet_classic_read_fcurve(aet_fcurve* fcurve,
|
|
prj::shared_ptr<prj::stack_allocator> alloc, stream& s) {
|
|
fcurve->keys_count = s.read_uint32_t();
|
|
uint32_t keys_offset = s.read_uint32_t();
|
|
|
|
s.position_push(keys_offset, SEEK_SET);
|
|
if (fcurve->keys_count > 1) {
|
|
float_t* key = alloc->allocate<float_t>(fcurve->keys_count * 3ULL);
|
|
fcurve->keys = key;
|
|
|
|
s.read(key, fcurve->keys_count * 3ULL * sizeof(float_t));
|
|
}
|
|
else if (fcurve->keys_count) {
|
|
float_t* key = alloc->allocate<float_t>();
|
|
fcurve->keys = key;
|
|
|
|
*key = s.read_float_t();
|
|
}
|
|
else
|
|
fcurve->keys = 0;
|
|
s.position_pop();
|
|
}
|
|
|
|
static void aet_classic_write_fcurve(const aet_fcurve* fcurve, stream& s,
|
|
std::unordered_map<const void*, int64_t>& offsets) {
|
|
if (fcurve->keys_count < 1)
|
|
return;
|
|
else if (fcurve->keys_count == 1) {
|
|
const float_t* key = fcurve->keys;
|
|
if (*(const uint32_t*)key) {
|
|
offsets[fcurve] = s.get_position();
|
|
s.write_float_t(*key);
|
|
}
|
|
}
|
|
else {
|
|
if (fcurve->keys_count > 2)
|
|
s.align_write(0x20);
|
|
|
|
offsets[fcurve] = s.get_position();
|
|
s.write(fcurve->keys, fcurve->keys_count * 3ULL * sizeof(float_t));
|
|
}
|
|
}
|
|
|
|
static void aet_classic_write_fcurve_header(const aet_fcurve* fcurve, stream& s,
|
|
std::unordered_map<const void*, int64_t>& offsets, int64_t null_data_pos, uint32_t& null_data_count) {
|
|
if (fcurve->keys_count < 1)
|
|
s.write(0x08);
|
|
else if (fcurve->keys_count == 1 && !*(const uint32_t*)fcurve->keys) {
|
|
int64_t offset = null_data_pos + null_data_count * sizeof(float_t);
|
|
offsets[fcurve] = offset;
|
|
|
|
s.write_uint32_t(fcurve->keys_count);
|
|
s.write_uint32_t((uint32_t)offset);
|
|
null_data_count++;
|
|
}
|
|
else {
|
|
auto elem = offsets.find(fcurve);
|
|
if (elem != offsets.end()) {
|
|
s.write_uint32_t(fcurve->keys_count);
|
|
s.write_uint32_t((uint32_t)elem->second);
|
|
}
|
|
else
|
|
s.write(0x08);
|
|
}
|
|
}
|
|
|
|
static void aet_classic_read_layer(aet_layer* layer,
|
|
prj::shared_ptr<prj::stack_allocator> alloc, stream& s) {
|
|
aet_layer_header alh = {};
|
|
|
|
layer->name = aet_read_utf8_string_null_terminated_offset(
|
|
alloc, s, s.read_uint32_t());
|
|
layer->start_time = s.read_float_t();
|
|
layer->end_time = s.read_float_t();
|
|
layer->offset_time = s.read_float_t();
|
|
layer->time_scale = s.read_float_t();
|
|
*(uint16_t*)&layer->flags = s.read_uint16_t();
|
|
layer->quality = (aet_layer_quality)s.read_uint8_t();
|
|
layer->item_type = (aet_item_type)s.read_uint8_t();
|
|
if (layer->item_type == AET_ITEM_TYPE_VIDEO
|
|
|| layer->item_type == AET_ITEM_TYPE_COMPOSITION)
|
|
layer->item.none = (void*)(size_t)s.read_uint32_t();
|
|
else
|
|
s.read_uint32_t();
|
|
|
|
layer->parent = (const aet_layer*)(size_t)s.read_uint32_t();
|
|
layer->markers_count = s.read_uint32_t();
|
|
alh.markers_offset = s.read_uint32_t();
|
|
alh.video_offset = s.read_uint32_t();
|
|
alh.audio_offset = s.read_uint32_t();
|
|
|
|
if (alh.markers_offset) {
|
|
aet_marker* marker = alloc->allocate<aet_marker>(layer->markers_count);
|
|
layer->markers = marker;
|
|
|
|
s.position_push(alh.markers_offset, SEEK_SET);
|
|
for (uint32_t i = layer->markers_count; i; i--, marker++) {
|
|
marker->time = s.read_float_t();
|
|
marker->name = aet_read_utf8_string_null_terminated_offset(
|
|
alloc, s, s.read_uint32_t());
|
|
}
|
|
s.position_pop();
|
|
}
|
|
else
|
|
layer->markers = 0;
|
|
|
|
layer->video = aet_classic_read_layer_video(alloc, s, alh.video_offset);
|
|
layer->audio = aet_classic_read_layer_audio(alloc, s, alh.audio_offset);
|
|
}
|
|
|
|
static void aet_classic_write_layer(const aet_layer* layer, stream& s,
|
|
std::unordered_map<const void*, int64_t>& offsets) {
|
|
|
|
}
|
|
|
|
static aet_layer_audio* aet_classic_read_layer_audio(prj::shared_ptr<prj::stack_allocator> alloc,
|
|
stream& s, int64_t offset) {
|
|
if (!offset)
|
|
return 0;
|
|
|
|
aet_layer_audio* layer_audio = alloc->allocate<aet_layer_audio>();
|
|
s.position_push(offset, SEEK_SET);
|
|
aet_classic_read_fcurve(&layer_audio->volume_l, alloc, s);
|
|
aet_classic_read_fcurve(&layer_audio->volume_r, alloc, s);
|
|
aet_classic_read_fcurve(&layer_audio->pan_l, alloc, s);
|
|
aet_classic_read_fcurve(&layer_audio->pan_r, alloc, s);
|
|
s.position_pop();
|
|
return layer_audio;
|
|
}
|
|
|
|
static void aet_classic_write_layer_audio(const aet_layer_audio* layer_audio, stream& s,
|
|
std::unordered_map<const void*, int64_t>& offsets) {
|
|
if (!layer_audio)
|
|
return;
|
|
|
|
aet_classic_write_fcurve(&layer_audio->volume_l, s, offsets);
|
|
aet_classic_write_fcurve(&layer_audio->volume_r, s, offsets);
|
|
aet_classic_write_fcurve(&layer_audio->pan_l, s, offsets);
|
|
aet_classic_write_fcurve(&layer_audio->pan_r, s, offsets);
|
|
}
|
|
|
|
static aet_layer_video* aet_classic_read_layer_video(prj::shared_ptr<prj::stack_allocator> alloc,
|
|
stream& s, int64_t offset) {
|
|
if (!offset)
|
|
return 0;
|
|
|
|
aet_layer_video* layer_video = alloc->allocate<aet_layer_video>();
|
|
s.position_push(offset, SEEK_SET);
|
|
layer_video->transfer_mode.mode = (aet_blend_mode)s.read_uint8_t();
|
|
layer_video->transfer_mode.flag = s.read_uint8_t();
|
|
layer_video->transfer_mode.matte = s.read_uint8_t();
|
|
s.read_uint8_t();
|
|
aet_classic_read_fcurve(&layer_video->anchor_x, alloc, s);
|
|
aet_classic_read_fcurve(&layer_video->anchor_y, alloc, s);
|
|
aet_classic_read_fcurve(&layer_video->pos_x, alloc, s);
|
|
aet_classic_read_fcurve(&layer_video->pos_y, alloc, s);
|
|
aet_classic_read_fcurve(&layer_video->rot_z, alloc, s);
|
|
aet_classic_read_fcurve(&layer_video->scale_x, alloc, s);
|
|
aet_classic_read_fcurve(&layer_video->scale_y, alloc, s);
|
|
aet_classic_read_fcurve(&layer_video->opacity, alloc, s);
|
|
layer_video->_3d = aet_classic_read_layer_video_3d(alloc, s, s.read_uint32_t());
|
|
s.position_pop();
|
|
return layer_video;
|
|
}
|
|
|
|
static void aet_classic_write_layer_video(const aet_layer_video* layer_video, stream& s,
|
|
std::unordered_map<const void*, int64_t>& offsets) {
|
|
if (!layer_video)
|
|
return;
|
|
|
|
aet_classic_write_layer_video_3d(layer_video->_3d, s, offsets);
|
|
|
|
aet_classic_write_fcurve(&layer_video->anchor_x, s, offsets);
|
|
aet_classic_write_fcurve(&layer_video->anchor_y, s, offsets);
|
|
aet_classic_write_fcurve(&layer_video->pos_x, s, offsets);
|
|
aet_classic_write_fcurve(&layer_video->pos_y, s, offsets);
|
|
aet_classic_write_fcurve(&layer_video->rot_z, s, offsets);
|
|
aet_classic_write_fcurve(&layer_video->scale_x, s, offsets);
|
|
aet_classic_write_fcurve(&layer_video->scale_y, s, offsets);
|
|
aet_classic_write_fcurve(&layer_video->opacity, s, offsets);
|
|
}
|
|
|
|
static aet_layer_video_3d* aet_classic_read_layer_video_3d(prj::shared_ptr<prj::stack_allocator> alloc,
|
|
stream& s, int64_t offset) {
|
|
if (!offset)
|
|
return 0;
|
|
|
|
aet_layer_video_3d* layer_video_3d = alloc->allocate<aet_layer_video_3d>();
|
|
s.position_push(offset, SEEK_SET);
|
|
aet_classic_read_fcurve(&layer_video_3d->anchor_z, alloc, s);
|
|
aet_classic_read_fcurve(&layer_video_3d->pos_z, alloc, s);
|
|
aet_classic_read_fcurve(&layer_video_3d->dir_x, alloc, s);
|
|
aet_classic_read_fcurve(&layer_video_3d->dir_y, alloc, s);
|
|
aet_classic_read_fcurve(&layer_video_3d->dir_z, alloc, s);
|
|
aet_classic_read_fcurve(&layer_video_3d->rot_x, alloc, s);
|
|
aet_classic_read_fcurve(&layer_video_3d->rot_y, alloc, s);
|
|
aet_classic_read_fcurve(&layer_video_3d->scale_z, alloc, s);
|
|
s.position_pop();
|
|
return layer_video_3d;
|
|
}
|
|
|
|
static void aet_classic_write_layer_video_3d(const aet_layer_video_3d* layer_video_3d, stream& s,
|
|
std::unordered_map<const void*, int64_t>& offsets) {
|
|
if (!layer_video_3d)
|
|
return;
|
|
|
|
aet_classic_write_fcurve(&layer_video_3d->anchor_z, s, offsets);
|
|
aet_classic_write_fcurve(&layer_video_3d->pos_z, s, offsets);
|
|
aet_classic_write_fcurve(&layer_video_3d->dir_x, s, offsets);
|
|
aet_classic_write_fcurve(&layer_video_3d->dir_y, s, offsets);
|
|
aet_classic_write_fcurve(&layer_video_3d->dir_z, s, offsets);
|
|
aet_classic_write_fcurve(&layer_video_3d->rot_x, s, offsets);
|
|
aet_classic_write_fcurve(&layer_video_3d->rot_y, s, offsets);
|
|
aet_classic_write_fcurve(&layer_video_3d->scale_z, s, offsets);
|
|
}
|
|
|
|
static aet_scene* aet_classic_read_scene(prj::shared_ptr<prj::stack_allocator> alloc,
|
|
stream& s, int64_t offset, std::unordered_map<int64_t, const aet_layer*>& layers,
|
|
std::unordered_map<int64_t, aet_item>& items) {
|
|
if (!offset)
|
|
return 0;
|
|
|
|
aet_scene_header ash = {};
|
|
|
|
aet_scene* scene = alloc->allocate<aet_scene>();
|
|
s.position_push(offset, SEEK_SET);
|
|
scene->name = aet_read_utf8_string_null_terminated_offset(
|
|
alloc, s, s.read_uint32_t());
|
|
scene->start_time = s.read_float_t();
|
|
scene->end_time = s.read_float_t();
|
|
scene->fps = s.read_float_t();
|
|
scene->color[0] = s.read_uint8_t();
|
|
scene->color[1] = s.read_uint8_t();
|
|
scene->color[2] = s.read_uint8_t();
|
|
s.read_uint8_t();
|
|
scene->width = s.read_uint32_t();
|
|
scene->height = s.read_uint32_t();
|
|
ash.camera_offset = s.read_uint32_t();
|
|
scene->comp_count = s.read_uint32_t();
|
|
ash.comp_offset = s.read_uint32_t();
|
|
scene->video_count = s.read_uint32_t();
|
|
ash.video_offset = s.read_uint32_t();
|
|
scene->audio_count = s.read_uint32_t();
|
|
ash.audio_offset = s.read_uint32_t();
|
|
s.position_pop();
|
|
|
|
scene->camera = aet_classic_read_camera(alloc, s, ash.camera_offset);
|
|
|
|
if (ash.comp_offset) {
|
|
aet_comp* comp = alloc->allocate<aet_comp>(scene->comp_count);
|
|
scene->comp = comp;
|
|
|
|
s.position_push(ash.comp_offset, SEEK_SET);
|
|
for (uint32_t i = scene->comp_count; i; i--, comp++)
|
|
aet_classic_read_comp(comp, alloc, s, layers, items);
|
|
s.position_pop();
|
|
}
|
|
else
|
|
scene->comp = 0;
|
|
|
|
if (ash.video_offset) {
|
|
aet_video* video = alloc->allocate<aet_video>(scene->video_count);
|
|
scene->video = video;
|
|
|
|
s.position_push(ash.video_offset, SEEK_SET);
|
|
for (uint32_t i = scene->video_count; i; i--, video++)
|
|
aet_classic_read_video(video, alloc, s, items);
|
|
s.position_pop();
|
|
}
|
|
else
|
|
scene->video = 0;
|
|
|
|
if (ash.audio_offset) {
|
|
aet_audio* audio = alloc->allocate<aet_audio>(scene->audio_count);
|
|
scene->audio = audio;
|
|
|
|
s.position_push(ash.audio_offset, SEEK_SET);
|
|
for (uint32_t i = scene->audio_count; i; i--, audio++)
|
|
aet_classic_read_audio(audio, alloc, s, items);
|
|
s.position_pop();
|
|
}
|
|
else
|
|
scene->audio = 0;
|
|
return scene;
|
|
}
|
|
|
|
static void aet_classic_read_video(aet_video* video,
|
|
prj::shared_ptr<prj::stack_allocator> alloc, stream& s,
|
|
std::unordered_map<int64_t, aet_item>& items) {
|
|
items[s.get_position()] = video;
|
|
|
|
video->color[0] = s.read_uint8_t();
|
|
video->color[1] = s.read_uint8_t();
|
|
video->color[2] = s.read_uint8_t();
|
|
s.read_uint8_t();
|
|
video->width = s.read_uint16_t();
|
|
video->height = s.read_uint16_t();
|
|
video->fpf = s.read_float_t();
|
|
video->sources_count = s.read_uint32_t();
|
|
uint32_t sources_offset = s.read_uint32_t();
|
|
|
|
if (sources_offset) {
|
|
aet_video_src* source = alloc->allocate<aet_video_src>(video->sources_count);
|
|
video->sources = source;
|
|
|
|
s.position_push(sources_offset, SEEK_SET);
|
|
for (uint32_t i = video->sources_count; i; i--, source++) {
|
|
source->sprite_name = aet_read_utf8_string_null_terminated_offset(
|
|
alloc, s, s.read_uint32_t());
|
|
source->sprite_index = s.read_int32_t();
|
|
}
|
|
s.position_pop();
|
|
}
|
|
else
|
|
video->sources = 0;
|
|
}
|
|
|
|
static void aet_modern_read_audio(aet_audio* audio,
|
|
prj::shared_ptr<prj::stack_allocator> alloc, stream& s,
|
|
uint32_t header_length, bool is_x) {
|
|
audio->sound_index = s.read_int32_t();
|
|
}
|
|
|
|
static aet_camera* aet_modern_read_camera(prj::shared_ptr<prj::stack_allocator> alloc,
|
|
stream& s, int64_t offset,
|
|
uint32_t header_length, bool is_x) {
|
|
if (!offset)
|
|
return 0;
|
|
|
|
aet_camera* cam = alloc->allocate<aet_camera>();
|
|
s.position_push(offset, SEEK_SET);
|
|
aet_modern_read_fcurve(&cam->eye_x, alloc, s, header_length, is_x);
|
|
aet_modern_read_fcurve(&cam->eye_y, alloc, s, header_length, is_x);
|
|
aet_modern_read_fcurve(&cam->eye_z, alloc, s, header_length, is_x);
|
|
aet_modern_read_fcurve(&cam->pos_x, alloc, s, header_length, is_x);
|
|
aet_modern_read_fcurve(&cam->pos_y, alloc, s, header_length, is_x);
|
|
aet_modern_read_fcurve(&cam->pos_z, alloc, s, header_length, is_x);
|
|
aet_modern_read_fcurve(&cam->dir_x, alloc, s, header_length, is_x);
|
|
aet_modern_read_fcurve(&cam->dir_y, alloc, s, header_length, is_x);
|
|
aet_modern_read_fcurve(&cam->dir_z, alloc, s, header_length, is_x);
|
|
aet_modern_read_fcurve(&cam->rot_x, alloc, s, header_length, is_x);
|
|
aet_modern_read_fcurve(&cam->rot_y, alloc, s, header_length, is_x);
|
|
aet_modern_read_fcurve(&cam->rot_z, alloc, s, header_length, is_x);
|
|
aet_modern_read_fcurve(&cam->zoom, alloc, s, header_length, is_x);
|
|
s.position_pop();
|
|
return cam;
|
|
}
|
|
|
|
static void aet_modern_read_comp(aet_comp* comp,
|
|
prj::shared_ptr<prj::stack_allocator> alloc, stream& s,
|
|
uint32_t header_length, bool is_x,
|
|
std::unordered_map<int64_t, const aet_layer*>& layers, std::unordered_map<int64_t, aet_item>& items) {
|
|
items[s.get_position()] = comp;
|
|
|
|
comp->layers_count = s.read_uint32_t();
|
|
int64_t layers_offset = s.read_offset(header_length, is_x);
|
|
|
|
if (layers_offset) {
|
|
aet_layer* layer = alloc->allocate<aet_layer>(comp->layers_count);
|
|
comp->layers = layer;
|
|
|
|
s.position_push(layers_offset, SEEK_SET);
|
|
for (uint32_t i = comp->layers_count; i; i--, layer++) {
|
|
layers[s.get_position()] = layer;
|
|
aet_modern_read_layer(layer, alloc, s, header_length, is_x);
|
|
}
|
|
s.position_pop();
|
|
}
|
|
else
|
|
comp->layers = 0;
|
|
}
|
|
|
|
static void aet_modern_read_fcurve(aet_fcurve* fcurve,
|
|
prj::shared_ptr<prj::stack_allocator> alloc, stream& s,
|
|
uint32_t header_length, bool is_x) {
|
|
fcurve->keys_count = s.read_uint32_t();
|
|
int64_t keys_offset = s.read_offset(header_length, is_x);
|
|
|
|
s.position_push(keys_offset, SEEK_SET);
|
|
if (fcurve->keys_count > 1) {
|
|
float_t* key = alloc->allocate<float_t>(fcurve->keys_count * 3ULL);
|
|
fcurve->keys = key;
|
|
|
|
s.read(key, fcurve->keys_count * 3ULL * sizeof(float_t));
|
|
}
|
|
else if (fcurve->keys_count) {
|
|
float_t* key = alloc->allocate<float_t>();
|
|
fcurve->keys = key;
|
|
|
|
*key = s.read_float_t_reverse_endianness();
|
|
}
|
|
else
|
|
fcurve->keys = 0;
|
|
s.position_pop();
|
|
}
|
|
|
|
static void aet_modern_read_layer(aet_layer* layer,
|
|
prj::shared_ptr<prj::stack_allocator> alloc, stream& s,
|
|
uint32_t header_length, bool is_x) {
|
|
aet_layer_header alh = {};
|
|
|
|
if (!is_x) {
|
|
layer->name = aet_read_utf8_string_null_terminated_offset(
|
|
alloc, s, s.read_offset_f2(header_length));
|
|
layer->start_time = s.read_float_t_reverse_endianness();
|
|
layer->end_time = s.read_float_t_reverse_endianness();
|
|
layer->offset_time = s.read_float_t_reverse_endianness();
|
|
layer->time_scale = s.read_float_t_reverse_endianness();
|
|
*(uint16_t*)&layer->flags = s.read_uint16_t_reverse_endianness();
|
|
layer->quality = (aet_layer_quality)s.read_uint8_t();
|
|
layer->item_type = (aet_item_type)s.read_uint8_t();
|
|
if (layer->item_type == AET_ITEM_TYPE_VIDEO
|
|
|| layer->item_type == AET_ITEM_TYPE_COMPOSITION)
|
|
layer->item.none = (void*)(size_t)s.read_offset_f2(header_length);
|
|
else
|
|
s.read_offset_f2(header_length);
|
|
|
|
layer->parent = (const aet_layer*)(size_t)s.read_offset_f2(header_length);
|
|
layer->markers_count = s.read_uint32_t_reverse_endianness();
|
|
alh.markers_offset = s.read_offset_f2(header_length);
|
|
alh.video_offset = s.read_offset_f2(header_length);
|
|
alh.audio_offset = s.read_offset_f2(header_length);
|
|
}
|
|
else {
|
|
layer->name = aet_read_utf8_string_null_terminated_offset(
|
|
alloc, s, s.read_offset_x());
|
|
layer->start_time = s.read_float_t_reverse_endianness();
|
|
layer->end_time = s.read_float_t_reverse_endianness();
|
|
layer->offset_time = s.read_float_t_reverse_endianness();
|
|
layer->time_scale = s.read_float_t_reverse_endianness();
|
|
*(uint16_t*)&layer->flags = s.read_uint16_t_reverse_endianness();
|
|
layer->quality = (aet_layer_quality)s.read_uint8_t();
|
|
layer->item_type = (aet_item_type)s.read_uint8_t();
|
|
if (layer->item_type == AET_ITEM_TYPE_VIDEO
|
|
|| layer->item_type == AET_ITEM_TYPE_COMPOSITION)
|
|
layer->item.none = (void*)s.read_offset_x();
|
|
else
|
|
s.read_offset_x();
|
|
|
|
layer->parent = (const aet_layer*)s.read_offset_x();
|
|
layer->markers_count = s.read_uint32_t_reverse_endianness();
|
|
alh.markers_offset = s.read_offset_x();
|
|
alh.video_offset = s.read_offset_x();
|
|
alh.audio_offset = s.read_offset_x();
|
|
}
|
|
|
|
if (alh.markers_offset) {
|
|
aet_marker* marker = alloc->allocate<aet_marker>(layer->markers_count);
|
|
layer->markers = marker;
|
|
|
|
s.position_push(alh.markers_offset, SEEK_SET);
|
|
for (uint32_t i = layer->markers_count; i; i--, marker++)
|
|
aet_modern_read_marker(marker, alloc, s, header_length, is_x);
|
|
s.position_pop();
|
|
}
|
|
else
|
|
layer->audio = 0;
|
|
|
|
layer->video = aet_modern_read_layer_video(alloc, s, alh.video_offset, header_length, is_x);
|
|
layer->audio = aet_modern_read_layer_audio(alloc, s, alh.audio_offset, header_length, is_x);
|
|
}
|
|
|
|
static aet_layer_audio* aet_modern_read_layer_audio(prj::shared_ptr<prj::stack_allocator> alloc,
|
|
stream& s, int64_t offset,
|
|
uint32_t header_length, bool is_x) {
|
|
if (!offset)
|
|
return 0;
|
|
|
|
aet_layer_audio* layer_audio = alloc->allocate<aet_layer_audio>();
|
|
s.position_push(offset, SEEK_SET);
|
|
aet_modern_read_fcurve(&layer_audio->volume_l, alloc, s, header_length, is_x);
|
|
aet_modern_read_fcurve(&layer_audio->volume_r, alloc, s, header_length, is_x);
|
|
aet_modern_read_fcurve(&layer_audio->pan_l, alloc, s, header_length, is_x);
|
|
aet_modern_read_fcurve(&layer_audio->pan_r, alloc, s, header_length, is_x);
|
|
s.position_pop();
|
|
return layer_audio;
|
|
}
|
|
|
|
static aet_layer_video* aet_modern_read_layer_video(prj::shared_ptr<prj::stack_allocator> alloc,
|
|
stream& s, int64_t offset,
|
|
uint32_t header_length, bool is_x) {
|
|
if (!offset)
|
|
return 0;
|
|
|
|
aet_layer_video* layer_video = alloc->allocate<aet_layer_video>();
|
|
s.position_push(offset, SEEK_SET);
|
|
layer_video->transfer_mode.mode = (aet_blend_mode)s.read_uint8_t();
|
|
layer_video->transfer_mode.flag = s.read_uint8_t();
|
|
layer_video->transfer_mode.matte = s.read_uint8_t();
|
|
s.read_uint8_t();
|
|
if (is_x)
|
|
s.read_uint32_t();
|
|
aet_modern_read_fcurve(&layer_video->anchor_x, alloc, s, header_length, is_x);
|
|
aet_modern_read_fcurve(&layer_video->anchor_y, alloc, s, header_length, is_x);
|
|
aet_modern_read_fcurve(&layer_video->pos_x, alloc, s, header_length, is_x);
|
|
aet_modern_read_fcurve(&layer_video->pos_y, alloc, s, header_length, is_x);
|
|
aet_modern_read_fcurve(&layer_video->rot_z, alloc, s, header_length, is_x);
|
|
aet_modern_read_fcurve(&layer_video->scale_x, alloc, s, header_length, is_x);
|
|
aet_modern_read_fcurve(&layer_video->scale_y, alloc, s, header_length, is_x);
|
|
aet_modern_read_fcurve(&layer_video->opacity, alloc, s, header_length, is_x);
|
|
layer_video->_3d = aet_modern_read_layer_video_3d(alloc,
|
|
s, s.read_offset(header_length, is_x), header_length, is_x);
|
|
s.position_pop();
|
|
return layer_video;
|
|
}
|
|
|
|
static aet_layer_video_3d* aet_modern_read_layer_video_3d(prj::shared_ptr<prj::stack_allocator> alloc,
|
|
stream& s, int64_t offset,
|
|
uint32_t header_length, bool is_x) {
|
|
if (!offset)
|
|
return 0;
|
|
|
|
aet_layer_video_3d* layer_video_3d = alloc->allocate<aet_layer_video_3d>();
|
|
s.position_push(offset, SEEK_SET);
|
|
aet_modern_read_fcurve(&layer_video_3d->anchor_z, alloc, s, header_length, is_x);
|
|
aet_modern_read_fcurve(&layer_video_3d->pos_z, alloc, s, header_length, is_x);
|
|
aet_modern_read_fcurve(&layer_video_3d->dir_x, alloc, s, header_length, is_x);
|
|
aet_modern_read_fcurve(&layer_video_3d->dir_y, alloc, s, header_length, is_x);
|
|
aet_modern_read_fcurve(&layer_video_3d->dir_z, alloc, s, header_length, is_x);
|
|
aet_modern_read_fcurve(&layer_video_3d->rot_x, alloc, s, header_length, is_x);
|
|
aet_modern_read_fcurve(&layer_video_3d->rot_y, alloc, s, header_length, is_x);
|
|
aet_modern_read_fcurve(&layer_video_3d->scale_z, alloc, s, header_length, is_x);
|
|
s.position_pop();
|
|
return layer_video_3d;
|
|
}
|
|
|
|
static void aet_modern_read_marker(aet_marker* marker,
|
|
prj::shared_ptr<prj::stack_allocator> alloc, stream& s,
|
|
uint32_t header_length, bool is_x) {
|
|
marker->time = s.read_float_t_reverse_endianness();
|
|
marker->name = aet_read_utf8_string_null_terminated_offset(
|
|
alloc, s, s.read_offset(header_length, is_x));
|
|
}
|
|
|
|
static aet_scene* aet_modern_read_scene(prj::shared_ptr<prj::stack_allocator> alloc,
|
|
stream& s, int64_t offset,
|
|
uint32_t header_length, bool is_x,
|
|
std::unordered_map<int64_t, const aet_layer*>& layers, std::unordered_map<int64_t, aet_item>& items) {
|
|
if (!offset)
|
|
return 0;
|
|
|
|
aet_scene_header ash = {};
|
|
|
|
aet_scene* scene = alloc->allocate<aet_scene>();
|
|
s.position_push(offset, SEEK_SET);
|
|
if (!is_x) {
|
|
scene->name = aet_read_utf8_string_null_terminated_offset(
|
|
alloc, s, s.read_offset_f2(header_length));
|
|
scene->start_time = s.read_float_t_reverse_endianness();
|
|
scene->end_time = s.read_float_t_reverse_endianness();
|
|
scene->fps = s.read_float_t_reverse_endianness();
|
|
scene->color[0] = s.read_uint8_t();
|
|
scene->color[1] = s.read_uint8_t();
|
|
scene->color[2] = s.read_uint8_t();
|
|
s.read_uint8_t();
|
|
scene->width = s.read_uint32_t_reverse_endianness();
|
|
scene->height = s.read_uint32_t_reverse_endianness();
|
|
ash.camera_offset = s.read_offset_f2(header_length);
|
|
scene->comp_count = s.read_uint32_t_reverse_endianness();
|
|
ash.comp_offset = s.read_offset_f2(header_length);
|
|
scene->video_count = s.read_uint32_t_reverse_endianness();
|
|
ash.video_offset = s.read_offset_f2(header_length);
|
|
scene->audio_count = s.read_uint32_t_reverse_endianness();
|
|
ash.audio_offset = s.read_offset_f2(header_length);
|
|
}
|
|
else {
|
|
scene->name = aet_read_utf8_string_null_terminated_offset(
|
|
alloc, s, s.read_offset_x());
|
|
scene->start_time = s.read_float_t_reverse_endianness();
|
|
scene->end_time = s.read_float_t_reverse_endianness();
|
|
scene->fps = s.read_float_t_reverse_endianness();
|
|
scene->color[0] = s.read_uint8_t();
|
|
scene->color[1] = s.read_uint8_t();
|
|
scene->color[2] = s.read_uint8_t();
|
|
s.read_uint8_t();
|
|
scene->width = s.read_uint32_t_reverse_endianness();
|
|
scene->height = s.read_uint32_t_reverse_endianness();
|
|
ash.camera_offset = s.read_offset_x();
|
|
scene->comp_count = s.read_uint32_t_reverse_endianness();
|
|
ash.comp_offset = s.read_offset_x();
|
|
scene->video_count = s.read_uint32_t_reverse_endianness();
|
|
ash.video_offset = s.read_offset_x();
|
|
scene->audio_count = s.read_uint32_t_reverse_endianness();
|
|
ash.audio_offset = s.read_offset_x();
|
|
}
|
|
s.position_pop();
|
|
|
|
scene->camera = aet_modern_read_camera(alloc, s, ash.camera_offset, header_length, is_x);
|
|
|
|
if (ash.comp_offset) {
|
|
aet_comp* comp = alloc->allocate<aet_comp>(scene->comp_count);
|
|
scene->comp = comp;
|
|
|
|
s.position_push(ash.comp_offset, SEEK_SET);
|
|
for (uint32_t i = scene->comp_count; i; i--, comp++)
|
|
aet_modern_read_comp(comp, alloc, s, header_length, is_x, layers, items);
|
|
s.position_pop();
|
|
}
|
|
else
|
|
scene->comp = 0;
|
|
|
|
if (ash.video_offset) {
|
|
aet_video* video = alloc->allocate<aet_video>(scene->video_count);
|
|
scene->video = video;
|
|
|
|
s.position_push(ash.video_offset, SEEK_SET);
|
|
for (uint32_t i = scene->video_count; i; i--, video++)
|
|
aet_modern_read_video(video, alloc, s, header_length, is_x, items);
|
|
s.position_pop();
|
|
}
|
|
else
|
|
scene->video = 0;
|
|
|
|
if (ash.audio_offset) {
|
|
aet_audio* audio = alloc->allocate<aet_audio>(scene->audio_count);
|
|
scene->audio = audio;
|
|
|
|
s.position_push(ash.audio_offset, SEEK_SET);
|
|
for (uint32_t i = scene->audio_count; i; i--, audio++)
|
|
aet_modern_read_audio(audio, alloc, s, header_length, is_x);
|
|
s.position_pop();
|
|
}
|
|
else
|
|
scene->audio = 0;
|
|
return scene;
|
|
}
|
|
|
|
static void aet_modern_read_video(aet_video* video,
|
|
prj::shared_ptr<prj::stack_allocator> alloc, stream& s,
|
|
uint32_t header_length, bool is_x,
|
|
std::unordered_map<int64_t, aet_item>& items) {
|
|
items[s.get_position()] = video;
|
|
|
|
video->color[0] = s.read_uint8_t();
|
|
video->color[1] = s.read_uint8_t();
|
|
video->color[2] = s.read_uint8_t();
|
|
s.read_uint8_t();
|
|
video->width = s.read_uint16_t_reverse_endianness();
|
|
video->height = s.read_uint16_t_reverse_endianness();
|
|
video->fpf = s.read_float_t_reverse_endianness();
|
|
video->sources_count = s.read_uint32_t_reverse_endianness();
|
|
int64_t sources_offset = s.read_offset(header_length, is_x);
|
|
|
|
if (sources_offset) {
|
|
aet_video_src* source = alloc->allocate<aet_video_src>(video->sources_count);
|
|
video->sources = source;
|
|
|
|
s.position_push(sources_offset, SEEK_SET);
|
|
if (!is_x)
|
|
for (uint32_t i = video->sources_count; i; i--, source++) {
|
|
source->sprite_name = aet_read_utf8_string_null_terminated_offset(
|
|
alloc, s, s.read_offset_f2(header_length));
|
|
source->sprite_index = s.read_int32_t();
|
|
}
|
|
else
|
|
for (uint32_t i = video->sources_count; i; i--, source++) {
|
|
source->sprite_name = aet_read_utf8_string_null_terminated_offset(
|
|
alloc, s, s.read_offset_x());
|
|
source->sprite_index = s.read_int32_t();
|
|
}
|
|
s.position_pop();
|
|
}
|
|
else
|
|
video->sources = 0;
|
|
}
|
|
|
|
static void aet_comp_set_item_parent(const aet_comp* comp,
|
|
std::unordered_map<int64_t, const aet_layer*>& layers,
|
|
std::unordered_map<int64_t, aet_item>& items) {
|
|
aet_layer* layer = (aet_layer*)comp->layers;
|
|
for (uint32_t i = comp->layers_count; i; i--, layer++) {
|
|
if (layer->item_type == AET_ITEM_TYPE_VIDEO
|
|
|| layer->item_type == AET_ITEM_TYPE_COMPOSITION) {
|
|
int64_t item_offset = (int64_t)layer->item.none;
|
|
layer->item.none = 0;
|
|
|
|
if (item_offset) {
|
|
auto elem = items.find(item_offset);
|
|
if (elem != items.end())
|
|
layer->item = elem->second;
|
|
}
|
|
}
|
|
|
|
int64_t parent_offset = (int64_t)layer->parent;
|
|
layer->parent = 0;
|
|
|
|
if (parent_offset) {
|
|
auto elem = layers.find(parent_offset);
|
|
if (elem != layers.end())
|
|
layer->parent = elem->second;
|
|
}
|
|
}
|
|
}
|
|
|
|
inline static const char* aet_move_data_string(const char* str,
|
|
prj::shared_ptr<prj::stack_allocator>& alloc) {
|
|
if (str)
|
|
return alloc->allocate<char>(str, utf8_length(str) + 1);
|
|
return 0;
|
|
}
|
|
|
|
inline static const char* aet_read_utf8_string_null_terminated_offset(
|
|
prj::shared_ptr<prj::stack_allocator>& alloc, stream& s, int64_t offset) {
|
|
size_t len = s.read_utf8_string_null_terminated_offset_length(offset);
|
|
char* str = alloc->allocate<char>(len + 1);
|
|
s.position_push(offset, SEEK_SET);
|
|
s.read(str, len);
|
|
s.position_pop();
|
|
str[len] = 0;
|
|
return str;
|
|
}
|
|
|
|
inline static int64_t aet_strings_get_string_offset(
|
|
const std::unordered_map<std::string, int64_t>& vec, const std::string& str) {
|
|
auto elem = vec.find(str);
|
|
if (elem != vec.end())
|
|
return elem->second;
|
|
return 0;
|
|
}
|
|
|
|
inline static void aet_strings_push_back_check(stream& s,
|
|
std::unordered_map<std::string, int64_t>& vec, const std::string& str) {
|
|
if (vec.find(str) != vec.end())
|
|
return;
|
|
|
|
vec[str] = s.get_position();
|
|
s.write_string_null_terminated(str);
|
|
}
|