pub(crate) mod callbacks;
pub(crate) mod controller;
pub(crate) mod decompression;
mod toolbox;
pub(crate) use toolbox::{
ppc_qt_display_clip_contains, ppc_qt_mark_drawing_complete, ppc_qt_reset_movie_toolbox_state,
};
use super::{
ppc_local_point_in_port_regions, ppc_port_clip_storage, ppc_region_storage,
PPC_CGRAF_PORT_VIS_RGN_OFFSET,
};
use std::collections::HashMap;
use std::rc::Rc;
use super::{
format_ppc_fourcc, ppc_decode_aiff_samples, ppc_decoded_sound_data, ppc_draw_pict_bytes_to_16bpp,
ppc_existing_path_for_fsspec, ppc_i16_result, ppc_live_quickdraw_surface,
ppc_memory_can_write_bytes, ppc_parse_aiff_metadata, ppc_process_alloc_handle_with_bytes,
ppc_quickdraw_surface_color_pixel, ppc_quickdraw_write_raw_pixel, ppc_read_be_u32_from_slice,
ppc_read_rect, ppc_sound_codec, ppc_write_rect, qt_trace_enabled, PpcCpu, PpcDecodedAiffData,
PpcDecodedAiffPlaybackRecord, PpcFileRecord, PpcFrontBuffer, PpcGWorldRecord, PpcHandleRecord,
PpcImportAction, PpcProcessAllocatorView, PpcQuickDrawSurface, PpcRgbColor, PpcSectionMem,
PpcSoundFilePlaybackRecord, PpcSoundState, PpcVfsDirectory, PpcVfsFileRecord,
PpcVfsResourceFileRecord, PpcVfsResourceRecord, PPC_FIRST_FILE_REF_NUM,
PPC_INVALID_COMPONENT_ID, PPC_MEM_FULL_ERR, PPC_NO_ERR, PPC_PARAM_ERR,
PPC_QT_GRAPHICS_IMPORTER, PPC_QT_MOVIE, PPC_QT_MOVIE_TASKS_PER_SECOND, PPC_RES_NOT_FOUND_ERR,
};
use crate::managers::resource::ResourceFork;
use crate::process_context::{ProcessForkBytes, ProcessNativeMemoryManager};
use crate::trap::TrapDispatcher;
use ppc::PpcMemory;
pub const PPC_QT_FALLBACK_MOVIE_TASKS_UNTIL_DONE: u32 = 3;
pub fn ppc_main_screen_width() -> u32 {
u32::from(crate::machine_profile::reference_machine_profile().screen_width)
}
pub fn ppc_main_screen_height() -> u32 {
u32::from(crate::machine_profile::reference_machine_profile().screen_height)
}
const PPC_QT_TIME_BASE: u32 = PPC_QT_MOVIE + 0x10;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PpcQuickTimeCompatibilityOperation {
GetMovieTime,
SetMovieTime,
SetMovieTimeValue,
GetMovieActiveSegment,
SetMovieActiveSegment,
NewCallBack,
DisposeCallBack,
CancelCallBack,
CallMeWhen,
GetCallBackType,
GetCallBackTimeBase,
GetMovieActive,
GetMovieTimeBase,
GetMovieColorTable,
GetMovieTimeScale,
GetMoviePreferredRate,
GetMoviePreferredVolume,
GetMovieIndTrackType,
GetMovieUserData,
GetUserData,
GetTrackMedia,
GetMediaSampleDescription,
MCDoAction,
NewMovieController,
DisposeMovieController,
MCSetMovie,
MCGetControllerBoundsRect,
MCSetActionFilterWithRefCon,
MCSetControllerBoundsRect,
MCSetControllerPort,
MCGetControllerPort,
MCIdle,
MCGetCurrentTime,
GetMovieVolume,
NewMovieFromDataFork,
PrerollMovie,
SetMovieActive,
SetMovieVolume,
SetTimeBaseFlags,
UpdateMovie,
GetMovieTrackCount,
GetMovieIndTrack,
GetMovieRate,
SetMovieRate,
SetMoviePreferredRate,
SetMovieTimeScale,
GetMovieSelection,
GetMoviePosterTime,
GetMovieDataSize,
GetMovieNextInterestingTime,
GetMovieGWorld,
GetMovieMatrix,
SetMovieMatrix,
GetMovieDisplayBoundsRgn,
SetMovieDisplayClipRgn,
SetMovieDrawingCompleteProc,
GetMoviePict,
ConvertTimeScale,
GetTrackDuration,
GetTrackOffset,
GetTrackLayer,
GetTrackVolume,
GetTrackEnabled,
SetTrackEnabled,
SetTrackLayer,
SetTrackOffset,
SetTrackVolume,
GetTrackDisplayBoundsRgn,
GetTrackMovieBoundsRgn,
PtInTrack,
GetTrackUserData,
CountUserDataType,
GetMediaHandler,
GetMediaHandlerDescription,
MediaGetSoundBalance,
MediaSetSoundBalance,
MediaHasCharacteristic,
MediaSetGraphicsMode,
SetIdentityMatrix,
InverseMatrix,
RectMatrix,
TransformRect,
MCClick,
MCDraw,
MCGetClip,
MCSetClip,
MCGetControllerBoundsRgn,
MCGetControllerInfo,
MCGetVisible,
MCSetVisible,
MCIsControllerAttached,
MCSetControllerAttached,
MCMovieChanged,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct PpcQuickTimeCinepakStripState {
pub(crate) v4_codebook: [[u8; 12]; 256],
pub(crate) v1_codebook: [[u8; 12]; 256],
}
impl Default for PpcQuickTimeCinepakStripState {
fn default() -> Self {
Self {
v4_codebook: [[0; 12]; 256],
v1_codebook: [[0; 12]; 256],
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PpcQuickTimeVideoTrackRecord {
pub media_time_scale: u32,
pub media_duration: u64,
pub sample_count: u32,
pub first_sample_duration: u32,
pub first_sample_size: u32,
pub first_chunk_offset: u64,
pub first_sample_data_len: u32,
pub first_sample_checksum: u32,
pub first_sample_preview_len: u8,
pub first_sample_preview: [u8; 16],
pub first_samples_per_chunk: u32,
pub sample_description_id: u32,
pub codec: u32,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PpcQuickTimeVideoSampleRecord {
pub offset: u64,
pub size: u32,
pub media_start_time: u64,
pub duration: u32,
pub data_len: u32,
pub checksum: u32,
pub preview_len: u8,
pub preview: [u8; 16],
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PpcQuickTimeVideoSampleTableRecord {
pub media_time_scale: u32,
pub media_duration: u64,
pub sample_count: u32,
pub codec: u32,
pub samples: Vec<PpcQuickTimeVideoSampleRecord>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PpcQuickTimeVideoDecodeCacheRecord {
pub(crate) codec: u32,
pub(crate) width: usize,
pub(crate) height: usize,
pub(crate) sample_index: usize,
pub(crate) rgb: Vec<u8>,
pub(crate) cinepak_strips: Vec<PpcQuickTimeCinepakStripState>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PpcQtGraphicsImage {
pub width: u32,
pub height: u32,
pub rgba: Vec<u8>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PpcQuickTimeAudioTrackRecord {
pub media_time_scale: u32,
pub media_duration: u64,
pub sample_count: u32,
pub first_sample_duration: u32,
pub first_sample_size: u32,
pub first_chunk_offset: u64,
pub first_sample_data_len: u32,
pub first_sample_checksum: u32,
pub first_sample_preview_len: u8,
pub first_sample_preview: [u8; 16],
pub first_samples_per_chunk: u32,
pub sample_description_id: u32,
pub codec: u32,
pub channel_count: u16,
pub sample_size_bits: u16,
pub sample_rate_fixed: u32,
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct PpcQuickTimeTrackRecord {
pub handle: u32,
pub id: u32,
pub media_type: u32,
pub enabled: bool,
pub duration: u64,
pub offset: u64,
pub layer: i16,
pub volume: i16,
pub matrix: [u32; 9],
pub width: u32,
pub height: u32,
pub balance: i16,
pub graphics_mode: u32,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PpcQuickTimeControllerRecord {
pub handle: u32,
pub movie: u32,
pub rect: (i16, i16, i16, i16),
pub flags: u32,
pub window: u32,
pub origin: u32,
pub action_filter: u32,
pub action_ref_con: u32,
pub action_filter_rtoc: u32,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PpcQuickTimeState {
pub(crate) decompression_sequences: decompression::Sequences,
pub(crate) callbacks: callbacks::Callbacks,
pub(crate) callback_frames: Vec<callbacks::ContinuationFrame>,
pub movie_toolbox_enter_count: u32,
pub movie_toolbox_exit_count: u32,
pub movie_toolbox_init_depth: u32,
pub movie_error: i16,
pub movie_sticky_error: i16,
pub movie_file_open_count: u32,
pub movie_file_close_count: u32,
pub movie_file_ref_num: i16,
pub movie_file_last_closed_ref_num: i16,
pub movie_file_path: String,
pub movie_file_data: Vec<u8>,
pub movie_file_sample_fork: Option<Rc<ProcessForkBytes>>,
pub movie_file_bounds: Option<(i16, i16, i16, i16)>,
pub movie_file_time_scale: u32,
pub movie_file_duration: u64,
pub movie_file_preferred_rate: i32,
pub movie_file_preferred_volume: i16,
pub movie_file_tasks_until_done: u32,
pub movie_file_video_track: Option<PpcQuickTimeVideoTrackRecord>,
pub movie_file_video_samples: Option<PpcQuickTimeVideoSampleTableRecord>,
pub movie_file_audio_track: Option<PpcQuickTimeAudioTrackRecord>,
pub movie_file_tracks: Vec<PpcQuickTimeTrackRecord>,
pub graphics_importer_gworld: u32,
pub graphics_importer_gdevice: u32,
pub graphics_importer_open: bool,
pub graphics_import_draw_count: u32,
pub graphics_import_source_draw_count: u32,
pub graphics_importer_path: String,
pub graphics_importer_subtype: u32,
pub graphics_importer_depth: u16,
pub graphics_importer_data: Vec<u8>,
pub graphics_importer_bounds: Option<(i16, i16, i16, i16)>,
pub graphics_importer_image: Option<PpcQtGraphicsImage>,
pub movie_gworld: u32,
pub movie_gdevice: u32,
pub movie_box: (i16, i16, i16, i16),
pub movie_set_box_count: u32,
pub movie_beginning_count: u32,
pub movie_at_beginning: bool,
pub movie_started: bool,
pub movie_active: bool,
pub movie_time_scale: u32,
pub movie_active_segment: Option<(u32, u32)>,
pub movie_preferred_rate: i32,
pub movie_playback_rate: i32,
pub movie_preferred_volume: i16,
pub movie_task_count: u32,
pub movie_task_fraction: u16,
pub movie_clock_subtick: Option<u64>,
pub movie_clock_remainder: i128,
pub movie_tasks_until_done: u32,
pub movie_video_track: Option<PpcQuickTimeVideoTrackRecord>,
pub movie_video_samples: Option<PpcQuickTimeVideoSampleTableRecord>,
pub movie_video_decode_cache: Option<PpcQuickTimeVideoDecodeCacheRecord>,
pub movie_audio_track: Option<PpcQuickTimeAudioTrackRecord>,
pub movie_tracks: Vec<PpcQuickTimeTrackRecord>,
pub movie_controllers: Vec<PpcQuickTimeControllerRecord>,
pub next_movie_controller_handle: u32,
pub movie_disposed: bool,
pub movie_volume: i16,
pub movie_time_base_flags: u32,
pub movie_creation_time_scale: u32,
pub movie_matrix: Option<[u32; 9]>,
pub movie_display_clip: Option<Vec<u8>>,
pub(crate) movie_drawing_complete: Option<(u32, callbacks::Registration)>,
pub movie_controller_clips: Vec<(u32, Option<Vec<u8>>, Option<Vec<u8>>)>,
pub detached_movie_controllers: Vec<u32>,
}
impl Default for PpcQuickTimeState {
fn default() -> Self {
Self {
decompression_sequences: decompression::Sequences::default(),
callbacks: callbacks::Callbacks::default(),
callback_frames: Vec::new(),
movie_toolbox_enter_count: 0,
movie_toolbox_exit_count: 0,
movie_toolbox_init_depth: 0,
movie_error: PPC_NO_ERR,
movie_sticky_error: PPC_NO_ERR,
movie_file_open_count: 0,
movie_file_close_count: 0,
movie_file_ref_num: 0,
movie_file_last_closed_ref_num: 0,
movie_file_path: String::new(),
movie_file_data: Vec::new(),
movie_file_sample_fork: None,
movie_file_bounds: None,
movie_file_time_scale: 0,
movie_file_duration: 0,
movie_file_preferred_rate: 0x0001_0000,
movie_file_preferred_volume: 0x0100,
movie_file_tasks_until_done: PPC_QT_FALLBACK_MOVIE_TASKS_UNTIL_DONE,
movie_file_video_track: None,
movie_file_video_samples: None,
movie_file_audio_track: None,
movie_file_tracks: Vec::new(),
graphics_importer_gworld: 0,
graphics_importer_gdevice: 0,
graphics_importer_open: false,
graphics_import_draw_count: 0,
graphics_import_source_draw_count: 0,
graphics_importer_path: String::new(),
graphics_importer_subtype: 0,
graphics_importer_depth: 0,
graphics_importer_data: Vec::new(),
graphics_importer_bounds: None,
graphics_importer_image: None,
movie_gworld: 0,
movie_gdevice: 0,
movie_box: (
0,
0,
ppc_main_screen_height() as i16,
ppc_main_screen_width() as i16,
),
movie_set_box_count: 0,
movie_beginning_count: 0,
movie_at_beginning: true,
movie_started: false,
movie_active: false,
movie_time_scale: 600,
movie_active_segment: None,
movie_preferred_rate: 0x0001_0000,
movie_playback_rate: 0x0001_0000,
movie_preferred_volume: 0x0100,
movie_task_count: 0,
movie_task_fraction: 0,
movie_clock_subtick: None,
movie_clock_remainder: 0,
movie_tasks_until_done: PPC_QT_FALLBACK_MOVIE_TASKS_UNTIL_DONE,
movie_video_track: None,
movie_video_samples: None,
movie_video_decode_cache: None,
movie_audio_track: None,
movie_tracks: Vec::new(),
movie_controllers: Vec::new(),
next_movie_controller_handle: PPC_QT_MOVIE + 0x1_0000,
movie_disposed: false,
movie_volume: 0x0100,
movie_time_base_flags: 0,
movie_creation_time_scale: 600,
movie_matrix: None,
movie_display_clip: None,
movie_drawing_complete: None,
movie_controller_clips: Vec::new(),
detached_movie_controllers: Vec::new(),
}
}
}
fn compatibility_valid_movie(quicktime: &PpcQuickTimeState, movie: u32) -> bool {
movie == PPC_QT_MOVIE && !quicktime.movie_disposed
}
fn ppc_qt_track_matches(track: &PpcQuickTimeTrackRecord, kind: u32, flags: u32) -> bool {
if flags & 4 != 0 && !track.enabled {
return false;
}
if flags & 1 != 0 {
return track.media_type == kind;
}
if kind == u32::from_be_bytes(*b"eyes") {
matches!(
track.media_type.to_be_bytes(),
[b'v', b'i', b'd', b'e']
| [b't', b'e', b'x', b't']
| [b's', b'p', b'r', b't']
| [b'M', b'P', b'E', b'G']
| [b't', b'm', b'c', b'd']
| [b'q', b'd', b'3', b'd']
)
} else if kind == u32::from_be_bytes(*b"ears") {
matches!(
track.media_type.to_be_bytes(),
[b's', b'o', b'u', b'n'] | [b'm', b'u', b's', b'i'] | [b'M', b'P', b'E', b'G']
)
} else {
false
}
}
pub(super) fn dispatch_quicktime_compatibility(
operation: PpcQuickTimeCompatibilityOperation,
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
process_memory_manager: &mut ProcessNativeMemoryManager,
heap_cursor: &mut u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
quicktime: &mut PpcQuickTimeState,
sound: &mut PpcSoundState,
files: &[PpcFileRecord],
vfs_files: &[PpcVfsFileRecord],
) -> PpcImportAction {
match operation {
PpcQuickTimeCompatibilityOperation::NewCallBack => {
let time_base = cpu.gpr[3];
let kind = cpu.gpr[4] as u16;
if time_base != PPC_QT_TIME_BASE || quicktime.movie_disposed
|| !(1..=5).contains(&(kind & 0x3fff)) {
ppc_qt_record_error(quicktime, PPC_PARAM_ERR);
return PpcImportAction::Return(0);
}
let address = process_memory_manager.new_native_ptr(memory, 4, true);
super::ppc_apply_process_native_allocator(process_memory_manager, memory, heap_cursor, last_mem_error);
if address == 0 {
ppc_qt_record_error(quicktime, PPC_MEM_FULL_ERR);
return PpcImportAction::Return(0);
}
assert!(quicktime.callbacks.create(address, time_base, kind));
ppc_qt_record_error(quicktime, PPC_NO_ERR);
PpcImportAction::Return(address)
}
PpcQuickTimeCompatibilityOperation::DisposeCallBack => {
if quicktime.callbacks.dispose(cpu.gpr[3]) {
process_memory_manager.dispose_native_ptr(cpu.gpr[3]);
super::ppc_apply_process_native_allocator(process_memory_manager, memory, heap_cursor, last_mem_error);
}
PpcImportAction::ReturnPreserve
}
PpcQuickTimeCompatibilityOperation::CancelCallBack => {
quicktime.callbacks.cancel(cpu.gpr[3]);
PpcImportAction::ReturnPreserve
}
PpcQuickTimeCompatibilityOperation::CallMeWhen => {
let Some(record) = quicktime.callbacks.get(cpu.gpr[3]) else {
return PpcImportAction::Return(ppc_i16_result(PPC_PARAM_ERR));
};
if record.kind & 0x3fff == 1 && (cpu.gpr[8] as i32 <= 0 || !(1..=3).contains(&cpu.gpr[6])) {
return PpcImportAction::Return(ppc_i16_result(PPC_PARAM_ERR));
}
if super::ppc_resolve_callback_target(memory, cpu.gpr[4], cpu.gpr[2], None).is_none() {
return PpcImportAction::Return(ppc_i16_result(PPC_PARAM_ERR));
}
let registration = callbacks::Registration {
procedure: cpu.gpr[4], rtoc: cpu.gpr[2], refcon: cpu.gpr[5],
parameters: [cpu.gpr[6] as i32, cpu.gpr[7] as i32, cpu.gpr[8] as i32],
};
let armed = quicktime.callbacks.arm(cpu.gpr[3], registration);
PpcImportAction::Return(ppc_i16_result(if armed { PPC_NO_ERR } else { PPC_PARAM_ERR }))
}
PpcQuickTimeCompatibilityOperation::GetCallBackType => {
PpcImportAction::Return(quicktime.callbacks.get(cpu.gpr[3]).map_or(0, |record| ppc_i16_result(record.kind as i16)))
}
PpcQuickTimeCompatibilityOperation::GetCallBackTimeBase => {
PpcImportAction::Return(quicktime.callbacks.get(cpu.gpr[3]).map_or(0, |record| record.time_base))
}
PpcQuickTimeCompatibilityOperation::GetMovieActive => {
PpcImportAction::Return(u32::from(
compatibility_valid_movie(quicktime, cpu.gpr[3]) && quicktime.movie_active,
))
}
PpcQuickTimeCompatibilityOperation::GetMovieTimeBase => {
PpcImportAction::Return(if compatibility_valid_movie(quicktime, cpu.gpr[3]) {
PPC_QT_TIME_BASE
} else {
0
})
}
PpcQuickTimeCompatibilityOperation::GetMovieTime => {
if !compatibility_valid_movie(quicktime, cpu.gpr[3]) {
let _ = ppc_qt_record_error(quicktime, -2010); return PpcImportAction::Return(0);
}
let time = super::dispatch_quicktime::quicktime_callback_time(quicktime).max(0) as u64;
let record = cpu.gpr[4];
if record != 0 && ppc_memory_can_write_bytes(memory, record, 16) {
let _ = memory.write_u64_be(record, time);
let _ = memory.write_u32_be(record + 8, quicktime.movie_time_scale);
let _ = memory.write_u32_be(record + 12, PPC_QT_TIME_BASE);
}
let _ = ppc_qt_record_error(quicktime, PPC_NO_ERR);
PpcImportAction::Return(time.min(u64::from(u32::MAX)) as u32)
}
PpcQuickTimeCompatibilityOperation::SetMovieTime => {
let error = if !compatibility_valid_movie(quicktime, cpu.gpr[3]) {
-2010
} else {
let record = cpu.gpr[4];
let time = memory.read_u64_be(record);
let scale = record.checked_add(8).and_then(|p| memory.read_u32_be(p));
let base = record.checked_add(12).and_then(|p| memory.read_u32_be(p));
if let (Some(time), Some(scale), Some(base)) = (time, scale, base) {
if record != 0 && scale as i32 > 0 && (base == 0 || base == PPC_QT_TIME_BASE) {
let time = (i128::from(time as i64).max(0)
* i128::from(quicktime.movie_time_scale)
/ i128::from(scale))
.min(i128::from(u64::MAX)) as u64;
ppc_qt_seek_movie(quicktime, sound, time);
PPC_NO_ERR
} else {
PPC_PARAM_ERR
}
} else {
PPC_PARAM_ERR
}
};
let _ = ppc_qt_record_error(quicktime, error);
PpcImportAction::ReturnPreserve
}
PpcQuickTimeCompatibilityOperation::GetMovieActiveSegment => {
if compatibility_valid_movie(quicktime, cpu.gpr[3]) {
if cpu.gpr[4] != 0 {
let start = quicktime
.movie_active_segment
.map_or(u32::MAX, |segment| segment.0);
let _ = memory.write_u32_be(cpu.gpr[4], start);
}
if let Some((_, duration)) = quicktime.movie_active_segment {
if cpu.gpr[5] != 0 {
let _ = memory.write_u32_be(cpu.gpr[5], duration);
}
}
let _ = ppc_qt_record_error(quicktime, PPC_NO_ERR);
} else {
let _ = ppc_qt_record_error(quicktime, -2010);
}
PpcImportAction::ReturnPreserve
}
PpcQuickTimeCompatibilityOperation::SetMovieActiveSegment => {
let start = cpu.gpr[4] as i32;
let duration = cpu.gpr[5] as i32;
let error = if !compatibility_valid_movie(quicktime, cpu.gpr[3]) {
-2010
} else if start == -1 {
quicktime.movie_active_segment = None;
PPC_NO_ERR
} else if start < 0 || u64::from(start as u32) > ppc_qt_movie_duration_value(quicktime)
{
-2015
} else if duration < 0
|| u64::from(start as u32) + u64::from(duration as u32)
> ppc_qt_movie_duration_value(quicktime)
{
-2014
} else {
quicktime.movie_active_segment = Some((start as u32, duration as u32));
PPC_NO_ERR
};
let _ = ppc_qt_record_error(quicktime, error);
PpcImportAction::ReturnPreserve
}
PpcQuickTimeCompatibilityOperation::SetMovieTimeValue => {
if !compatibility_valid_movie(quicktime, cpu.gpr[3]) {
let _ = ppc_qt_record_error(quicktime, -2010); return PpcImportAction::ReturnPreserve;
}
ppc_qt_seek_movie(quicktime, sound, (cpu.gpr[4] as i32).max(0) as u64);
let _ = ppc_qt_record_error(quicktime, PPC_NO_ERR);
PpcImportAction::ReturnPreserve
}
PpcQuickTimeCompatibilityOperation::GetMovieColorTable => {
if !compatibility_valid_movie(quicktime, cpu.gpr[3]) {
return PpcImportAction::Return(ppc_i16_result(ppc_qt_record_error(
quicktime, -2010, )));
}
if cpu.gpr[4] != 0 {
let _ = memory.write_u32_be(cpu.gpr[4], 0);
}
PpcImportAction::Return(ppc_i16_result(ppc_qt_record_error(quicktime, PPC_NO_ERR)))
}
PpcQuickTimeCompatibilityOperation::GetMovieTimeScale => {
if compatibility_valid_movie(quicktime, cpu.gpr[3]) {
let _ = ppc_qt_record_error(quicktime, PPC_NO_ERR);
PpcImportAction::Return(quicktime.movie_time_scale)
} else {
let _ = ppc_qt_record_error(quicktime, -2010); PpcImportAction::Return(0)
}
}
PpcQuickTimeCompatibilityOperation::GetMoviePreferredRate => {
if compatibility_valid_movie(quicktime, cpu.gpr[3]) {
let _ = ppc_qt_record_error(quicktime, PPC_NO_ERR);
PpcImportAction::Return(quicktime.movie_preferred_rate as u32)
} else {
let _ = ppc_qt_record_error(quicktime, -2010); PpcImportAction::Return(0)
}
}
PpcQuickTimeCompatibilityOperation::GetMoviePreferredVolume => {
if compatibility_valid_movie(quicktime, cpu.gpr[3]) {
let _ = ppc_qt_record_error(quicktime, PPC_NO_ERR);
PpcImportAction::Return(quicktime.movie_preferred_volume as u16 as u32)
} else {
let _ = ppc_qt_record_error(quicktime, -2010); PpcImportAction::Return(0)
}
}
PpcQuickTimeCompatibilityOperation::GetMovieIndTrackType => {
if !compatibility_valid_movie(quicktime, cpu.gpr[3]) {
let _ = ppc_qt_record_error(quicktime, -2010); return PpcImportAction::Return(0);
}
let index = cpu.gpr[4];
let flags = cpu.gpr[6];
if index == 0 || flags & !7 != 0 || (flags & 3).count_ones() != 1 {
let _ = ppc_qt_record_error(quicktime, PPC_PARAM_ERR);
return PpcImportAction::Return(0);
}
let track = quicktime
.movie_tracks
.iter()
.filter(|track| ppc_qt_track_matches(track, cpu.gpr[5], flags))
.nth((index - 1) as usize)
.map(|track| track.handle)
.unwrap_or(0);
let _ = ppc_qt_record_error(quicktime, PPC_NO_ERR);
PpcImportAction::Return(track)
}
PpcQuickTimeCompatibilityOperation::GetMovieUserData => {
if !compatibility_valid_movie(quicktime, cpu.gpr[3]) {
let _ = ppc_qt_record_error(quicktime, -2010); return PpcImportAction::Return(0);
}
let user_data = if ppc_qt_movie_has_user_data(&quicktime.movie_file_data) {
toolbox::PPC_QT_MOVIE_USER_DATA
} else {
0
};
let _ = ppc_qt_record_error(quicktime, PPC_NO_ERR);
PpcImportAction::Return(user_data)
}
PpcQuickTimeCompatibilityOperation::GetUserData => {
let Some(range) = toolbox::ppc_qt_user_data_range(quicktime, cpu.gpr[3]) else {
return PpcImportAction::Return(ppc_i16_result(PPC_PARAM_ERR));
};
let index = cpu.gpr[6];
if index == 0 {
return PpcImportAction::Return(ppc_i16_result(PPC_PARAM_ERR));
}
let Some(item) =
toolbox::ppc_qt_user_data_item(&quicktime.movie_file_data, range, cpu.gpr[5], index)
else {
return PpcImportAction::Return(ppc_i16_result(-2026)); };
let handle = cpu.gpr[4];
if handle != 0 {
let Ok(size) = u32::try_from(item.len()) else {
return PpcImportAction::Return(ppc_i16_result(PPC_MEM_FULL_ERR));
};
let mut allocator = PpcProcessAllocatorView {
memory_manager: process_memory_manager,
};
let error = allocator.resize_handle(
memory,
heap_cursor,
last_mem_error,
handles,
handle,
size,
);
if error != PPC_NO_ERR {
return PpcImportAction::Return(ppc_i16_result(error));
}
let Some(ptr) = handles
.iter()
.find(|record| record.handle == handle)
.map(|record| record.ptr)
else {
return PpcImportAction::Return(ppc_i16_result(PPC_PARAM_ERR));
};
for (offset, byte) in item.iter().enumerate() {
if memory.write_u8(ptr + offset as u32, *byte).is_none() {
return PpcImportAction::Return(ppc_i16_result(PPC_PARAM_ERR));
}
}
}
PpcImportAction::Return(ppc_i16_result(PPC_NO_ERR))
}
PpcQuickTimeCompatibilityOperation::GetTrackMedia => {
let media = if quicktime.movie_disposed {
None
} else {
quicktime
.movie_tracks
.iter()
.find(|track| track.handle == cpu.gpr[3])
.map(|track| track.handle + 1)
};
let _ =
ppc_qt_record_error(quicktime, if media.is_some() { PPC_NO_ERR } else { -2009 }); PpcImportAction::Return(media.unwrap_or(0))
}
PpcQuickTimeCompatibilityOperation::GetMediaSampleDescription => {
let Some((ordinal, _)) = quicktime
.movie_tracks
.iter()
.enumerate()
.find(|(_, track)| track.handle + 1 == cpu.gpr[3] && !quicktime.movie_disposed)
else {
let _ = ppc_qt_record_error(quicktime, -2008); return PpcImportAction::ReturnPreserve;
};
let Some(description) = ppc_qt_movie_sample_description(
&quicktime.movie_file_data,
ordinal + 1,
cpu.gpr[4],
) else {
return PpcImportAction::ReturnPreserve; };
let handle = cpu.gpr[5];
let Ok(size) = u32::try_from(description.len()) else {
let _ = ppc_qt_record_error(quicktime, PPC_MEM_FULL_ERR);
return PpcImportAction::ReturnPreserve;
};
let mut allocator = PpcProcessAllocatorView {
memory_manager: process_memory_manager,
};
let error =
allocator.resize_handle(memory, heap_cursor, last_mem_error, handles, handle, size);
if error != PPC_NO_ERR {
let _ = ppc_qt_record_error(quicktime, error);
return PpcImportAction::ReturnPreserve;
}
let Some(ptr) = handles
.iter()
.find(|record| record.handle == handle)
.map(|record| record.ptr)
else {
let _ = ppc_qt_record_error(quicktime, PPC_PARAM_ERR);
return PpcImportAction::ReturnPreserve;
};
for (offset, byte) in description.iter().enumerate() {
if memory.write_u8(ptr + offset as u32, *byte).is_none() {
let _ = ppc_qt_record_error(quicktime, PPC_PARAM_ERR);
return PpcImportAction::ReturnPreserve;
}
}
let _ = ppc_qt_record_error(quicktime, PPC_NO_ERR);
PpcImportAction::ReturnPreserve
}
PpcQuickTimeCompatibilityOperation::SetMovieRate => {
let rate = cpu.gpr[4] as i32;
let error = if compatibility_valid_movie(quicktime, cpu.gpr[3]) {
ppc_qt_set_movie_rate(cpu, memory, gworlds, current_gworld, quicktime, sound, rate)
} else {
-2010 };
ppc_qt_record_error(quicktime, error);
PpcImportAction::ReturnPreserve
}
PpcQuickTimeCompatibilityOperation::MCDoAction => {
let Some(movie) = quicktime
.movie_controllers
.iter()
.find(|controller| controller.handle == cpu.gpr[3])
.map(|controller| controller.movie)
else {
return PpcImportAction::Return(ppc_i16_result(PPC_INVALID_COMPONENT_ID));
};
match cpu.gpr[4] as i16 {
1 => {
if movie == 0 {
return PpcImportAction::Return(0);
}
let controller = cpu.gpr[3];
cpu.gpr[3] = movie;
let error =
ppc_qt_movies_task(cpu, memory, gworlds, current_gworld, quicktime, sound);
cpu.gpr[3] = controller;
PpcImportAction::Return(ppc_i16_result(error))
}
8 => {
if movie != PPC_QT_MOVIE || quicktime.movie_disposed {
return PpcImportAction::Return(ppc_i16_result(-2010)); }
let controller = cpu.gpr[3];
cpu.gpr[3] = movie;
let rate = cpu.gpr[5] as i32;
let error = ppc_qt_set_movie_rate(
cpu, memory, gworlds, current_gworld, quicktime, sound, rate,
);
cpu.gpr[3] = controller;
PpcImportAction::Return(ppc_i16_result(error))
}
12 => {
if !compatibility_valid_movie(quicktime, movie) {
return PpcImportAction::Return(ppc_i16_result(-2010));
}
let record = cpu.gpr[5];
if record == 0 {
return PpcImportAction::Return(ppc_i16_result(PPC_PARAM_ERR));
}
let time = memory.read_u64_be(record);
let scale = record.checked_add(8).and_then(|p| memory.read_u32_be(p));
let base = record.checked_add(12).and_then(|p| memory.read_u32_be(p));
let (Some(time), Some(scale), Some(base)) = (time, scale, base) else {
return PpcImportAction::Return(ppc_i16_result(PPC_PARAM_ERR));
};
if scale as i32 <= 0 || (base != 0 && base != PPC_QT_TIME_BASE) {
return PpcImportAction::Return(ppc_i16_result(PPC_PARAM_ERR));
}
let time = (i128::from(time as i64).max(0)
* i128::from(quicktime.movie_time_scale)
/ i128::from(scale))
.min(i128::from(u64::MAX)) as u64;
ppc_qt_seek_movie(quicktime, sound, time);
PpcImportAction::Return(0)
}
42 => {
if !compatibility_valid_movie(quicktime, movie) {
return PpcImportAction::Return(ppc_i16_result(-2010));
}
let out = cpu.gpr[5];
if out == 0 || !ppc_memory_can_write_bytes(memory, out, 4) {
return PpcImportAction::Return(ppc_i16_result(PPC_PARAM_ERR));
}
let rate = if quicktime.movie_started {
quicktime.movie_playback_rate
} else {
0
};
let _ = memory.write_u32_be(out, rate as u32);
PpcImportAction::Return(0)
}
_ => PpcImportAction::Return(ppc_i16_result(PPC_INVALID_COMPONENT_ID)),
}
}
PpcQuickTimeCompatibilityOperation::NewMovieController => {
if !compatibility_valid_movie(quicktime, cpu.gpr[3]) || cpu.gpr[4] == 0 {
return PpcImportAction::Return(0);
}
let Some(rect) = ppc_read_rect(memory, cpu.gpr[4]) else {
return PpcImportAction::Return(0);
};
let handle = quicktime.next_movie_controller_handle;
let Some(next) = handle.checked_add(0x10) else {
return PpcImportAction::Return(0);
};
quicktime.next_movie_controller_handle = next;
quicktime
.movie_controllers
.push(PpcQuickTimeControllerRecord {
handle,
movie: cpu.gpr[3],
rect,
flags: cpu.gpr[5],
window: 0,
origin: 0,
action_filter: 0,
action_ref_con: 0,
action_filter_rtoc: 0,
});
PpcImportAction::Return(handle)
}
PpcQuickTimeCompatibilityOperation::DisposeMovieController => {
quicktime
.movie_controllers
.retain(|controller| controller.handle != cpu.gpr[3]);
PpcImportAction::ReturnPreserve
}
PpcQuickTimeCompatibilityOperation::MCSetMovie => {
let Some(index) = quicktime
.movie_controllers
.iter()
.position(|controller| controller.handle == cpu.gpr[3])
else {
return PpcImportAction::Return(ppc_i16_result(PPC_INVALID_COMPONENT_ID));
};
let movie = cpu.gpr[4];
if movie == 0 {
quicktime.movie_controllers[index].movie = 0;
return PpcImportAction::Return(0);
}
if movie != PPC_QT_MOVIE || quicktime.movie_disposed {
return PpcImportAction::Return(ppc_i16_result(-2010)); }
let port = if cpu.gpr[5] == 0 {
current_gworld
} else {
cpu.gpr[5]
};
let top = (cpu.gpr[6] >> 16) as u16 as i16;
let left = cpu.gpr[6] as u16 as i16;
let old = quicktime.movie_box;
let bottom = i32::from(top) + i32::from(old.2) - i32::from(old.0);
let right = i32::from(left) + i32::from(old.3) - i32::from(old.1);
let (Ok(bottom), Ok(right)) = (i16::try_from(bottom), i16::try_from(right)) else {
return PpcImportAction::Return(ppc_i16_result(PPC_PARAM_ERR));
};
let rect = (top, left, bottom, right);
if !toolbox::ppc_qt_resize_movie_matrix(quicktime, rect) {
return PpcImportAction::Return(ppc_i16_result(PPC_PARAM_ERR));
}
quicktime.movie_box = rect;
quicktime.movie_gworld = port;
quicktime.movie_gdevice = 0;
let controller = &mut quicktime.movie_controllers[index];
controller.movie = movie;
controller.origin = cpu.gpr[6];
if !quicktime
.detached_movie_controllers
.contains(&controller.handle)
{
controller.window = port;
controller.rect = rect;
}
PpcImportAction::Return(0)
}
PpcQuickTimeCompatibilityOperation::MCGetControllerBoundsRect => {
let Some(controller) = quicktime
.movie_controllers
.iter()
.find(|controller| controller.handle == cpu.gpr[3])
else {
return PpcImportAction::Return(ppc_i16_result(PPC_INVALID_COMPONENT_ID));
};
let out = cpu.gpr[4];
if out == 0 || !ppc_memory_can_write_bytes(memory, out, 8) {
return PpcImportAction::Return(ppc_i16_result(PPC_PARAM_ERR));
}
let (top, left, bottom, right) = controller.rect;
let result = if ppc_write_rect(memory, out, top, left, bottom, right).is_some() {
PPC_NO_ERR
} else {
PPC_PARAM_ERR
};
PpcImportAction::Return(ppc_i16_result(result))
}
PpcQuickTimeCompatibilityOperation::MCSetActionFilterWithRefCon => {
let Some(controller) = quicktime
.movie_controllers
.iter_mut()
.find(|controller| controller.handle == cpu.gpr[3])
else {
return PpcImportAction::Return(ppc_i16_result(PPC_INVALID_COMPONENT_ID));
};
controller.action_filter = cpu.gpr[4];
controller.action_filter_rtoc = if cpu.gpr[4] == 0 { 0 } else { cpu.gpr[2] };
controller.action_ref_con = if cpu.gpr[4] == 0 { 0 } else { cpu.gpr[5] };
PpcImportAction::Return(ppc_i16_result(PPC_NO_ERR))
}
PpcQuickTimeCompatibilityOperation::MCSetControllerBoundsRect => {
let Some(controller) = quicktime
.movie_controllers
.iter_mut()
.find(|controller| controller.handle == cpu.gpr[3])
else {
return PpcImportAction::Return(ppc_i16_result(PPC_INVALID_COMPONENT_ID));
};
if cpu.gpr[4] == 0 {
return PpcImportAction::Return(ppc_i16_result(PPC_PARAM_ERR));
}
let Some(rect) = ppc_read_rect(memory, cpu.gpr[4]) else {
return PpcImportAction::Return(ppc_i16_result(PPC_PARAM_ERR));
};
controller.rect = rect;
PpcImportAction::Return(ppc_i16_result(PPC_NO_ERR))
}
PpcQuickTimeCompatibilityOperation::MCSetControllerPort
| PpcQuickTimeCompatibilityOperation::MCGetControllerPort => {
let Some(controller) = quicktime
.movie_controllers
.iter_mut()
.find(|controller| controller.handle == cpu.gpr[3])
else {
return PpcImportAction::Return(
if operation == PpcQuickTimeCompatibilityOperation::MCGetControllerPort {
0
} else {
ppc_i16_result(PPC_INVALID_COMPONENT_ID)
},
);
};
if operation == PpcQuickTimeCompatibilityOperation::MCGetControllerPort {
return PpcImportAction::Return(controller.window);
}
controller.window = cpu.gpr[4];
PpcImportAction::Return(ppc_i16_result(PPC_NO_ERR))
}
PpcQuickTimeCompatibilityOperation::MCIdle => {
let Some(movie) = quicktime
.movie_controllers
.iter()
.find(|controller| controller.handle == cpu.gpr[3])
.map(|controller| controller.movie)
else {
return PpcImportAction::Return(ppc_i16_result(PPC_INVALID_COMPONENT_ID));
};
if movie != 0 {
let original = cpu.gpr[3];
cpu.gpr[3] = movie;
let error =
ppc_qt_movies_task(cpu, memory, gworlds, current_gworld, quicktime, sound);
cpu.gpr[3] = original;
if error != PPC_NO_ERR {
return PpcImportAction::Return(ppc_i16_result(error));
}
}
PpcImportAction::Return(0)
}
PpcQuickTimeCompatibilityOperation::MCGetCurrentTime => {
let valid_movie = quicktime.movie_controllers.iter().any(|controller| {
controller.handle == cpu.gpr[3]
&& controller.movie == PPC_QT_MOVIE
&& !quicktime.movie_disposed
});
if !valid_movie {
return PpcImportAction::Return(0);
}
let scale = quicktime.movie_time_scale.max(1);
let out = cpu.gpr[4];
if out != 0
&& (!ppc_memory_can_write_bytes(memory, out, 4)
|| memory.write_u32_be(out, scale).is_none())
{
return PpcImportAction::Return(0);
}
let time = super::dispatch_quicktime::quicktime_callback_time(quicktime).max(0) as u64;
PpcImportAction::Return(time.min(i32::MAX as u64) as u32)
}
PpcQuickTimeCompatibilityOperation::GetMovieVolume => {
PpcImportAction::Return(if compatibility_valid_movie(quicktime, cpu.gpr[3]) {
quicktime.movie_volume as u16 as u32
} else {
0
})
}
PpcQuickTimeCompatibilityOperation::SetMovieVolume => {
if compatibility_valid_movie(quicktime, cpu.gpr[3]) {
quicktime.movie_volume = cpu.gpr[4] as u16 as i16;
}
PpcImportAction::ReturnPreserve
}
PpcQuickTimeCompatibilityOperation::SetMovieActive => {
if compatibility_valid_movie(quicktime, cpu.gpr[3]) {
quicktime.movie_active = cpu.gpr[4] != 0;
if quicktime.movie_active && quicktime.movie_started {
let _ = ppc_qt_start_movie_audio(quicktime, sound);
} else if !quicktime.movie_active {
ppc_qt_stop_movie_audio(sound);
}
let _ = ppc_qt_record_error(quicktime, PPC_NO_ERR);
} else {
let _ = ppc_qt_record_error(quicktime, -2010); }
PpcImportAction::ReturnPreserve
}
PpcQuickTimeCompatibilityOperation::SetTimeBaseFlags => {
if cpu.gpr[3] == PPC_QT_TIME_BASE {
quicktime.movie_time_base_flags = cpu.gpr[4];
}
PpcImportAction::ReturnPreserve
}
PpcQuickTimeCompatibilityOperation::PrerollMovie => {
let result = if compatibility_valid_movie(quicktime, cpu.gpr[3]) {
PPC_NO_ERR
} else {
PPC_PARAM_ERR
};
PpcImportAction::Return(ppc_i16_result(ppc_qt_record_error(quicktime, result)))
}
PpcQuickTimeCompatibilityOperation::UpdateMovie => {
let result = if compatibility_valid_movie(quicktime, cpu.gpr[3]) {
PPC_NO_ERR
} else {
PPC_PARAM_ERR
};
let _ = ppc_qt_record_error(quicktime, result);
PpcImportAction::ReturnPreserve
}
PpcQuickTimeCompatibilityOperation::NewMovieFromDataFork => {
let movie_out = cpu.gpr[3];
let changed_out = cpu.gpr[7];
if movie_out == 0
|| memory.write_u32_be(movie_out, PPC_QT_MOVIE).is_none()
|| (changed_out != 0 && memory.write_u8(changed_out, 0).is_none())
{
return PpcImportAction::Return(ppc_i16_result(ppc_qt_record_error(
quicktime,
PPC_PARAM_ERR,
)));
}
if let Some((path, data, sample_fork)) = ppc_qt_movie_data_from_open_fork(
files,
vfs_files,
cpu.gpr[4] as u16 as i16,
cpu.gpr[5],
) {
quicktime.movie_file_path = path;
quicktime.movie_file_data = data;
quicktime.movie_file_sample_fork = Some(sample_fork);
quicktime.movie_file_ref_num = cpu.gpr[4] as u16 as i16;
ppc_qt_refresh_open_movie_metadata(quicktime);
}
if qt_trace_enabled() {
eprintln!(
"[QT-TRACE] NewMovieFromDataFork ref={} offset={} path='{}' atom_bytes={} tracks={}",
cpu.gpr[4] as u16 as i16,
cpu.gpr[5],
quicktime.movie_file_path,
quicktime.movie_file_data.len(),
quicktime.movie_file_tracks.len(),
);
}
if cpu.gpr[4] as u16 as i16 == quicktime.movie_file_ref_num {
if let Some(bounds) = quicktime.movie_file_bounds {
quicktime.movie_box = bounds;
}
quicktime.movie_tasks_until_done = quicktime.movie_file_tasks_until_done;
quicktime.movie_video_track = quicktime.movie_file_video_track;
quicktime.movie_video_samples = quicktime.movie_file_video_samples.clone();
quicktime.movie_audio_track = quicktime.movie_file_audio_track;
quicktime.movie_tracks = quicktime.movie_file_tracks.clone();
quicktime.movie_time_scale = if quicktime.movie_file_time_scale == 0 {
600
} else {
quicktime.movie_file_time_scale
};
quicktime.movie_preferred_rate = quicktime.movie_file_preferred_rate;
quicktime.movie_preferred_volume = quicktime.movie_file_preferred_volume;
quicktime.movie_volume = quicktime.movie_preferred_volume;
} else {
quicktime.movie_tasks_until_done = PPC_QT_FALLBACK_MOVIE_TASKS_UNTIL_DONE;
quicktime.movie_video_track = None;
quicktime.movie_video_samples = None;
quicktime.movie_audio_track = None;
quicktime.movie_tracks.clear();
quicktime.movie_time_scale = 600;
quicktime.movie_preferred_rate = 0x0001_0000;
quicktime.movie_preferred_volume = 0x0100;
quicktime.movie_volume = 0x0100;
}
quicktime.movie_started = false;
quicktime.movie_active = cpu.gpr[6] & 1 != 0;
quicktime.movie_task_count = 0;
quicktime.movie_active_segment = None;
quicktime.movie_task_fraction = 0;
quicktime.movie_clock_remainder = 0;
quicktime.movie_disposed = false;
quicktime.movie_controllers.clear();
quicktime.movie_at_beginning = true;
ppc_qt_reset_movie_video_decode_cache(quicktime);
ppc_qt_reset_movie_toolbox_state(quicktime);
PpcImportAction::Return(ppc_i16_result(ppc_qt_record_error(quicktime, PPC_NO_ERR)))
}
_ => toolbox::dispatch_movie_toolbox(
operation,
cpu,
memory,
process_memory_manager,
heap_cursor,
last_mem_error,
handles,
gworlds,
current_gworld,
quicktime,
),
}
}
pub(crate) fn ppc_qt_movie_duration_value(quicktime: &PpcQuickTimeState) -> u64 {
let duration = if quicktime.movie_file_duration == 0 {
600
} else {
quicktime.movie_file_duration
};
toolbox::ppc_qt_to_movie_scale(quicktime, duration.min(i64::MAX as u64) as i64).max(0) as u64
}
pub(crate) fn ppc_qt_record_error(quicktime: &mut PpcQuickTimeState, error: i16) -> i16 {
quicktime.movie_error = error;
if error != PPC_NO_ERR && quicktime.movie_sticky_error == PPC_NO_ERR {
quicktime.movie_sticky_error = error;
}
error
}
pub(crate) fn ppc_qt_enter_movies(quicktime: &mut PpcQuickTimeState) -> i16 {
quicktime.movie_toolbox_enter_count = quicktime.movie_toolbox_enter_count.saturating_add(1);
quicktime.movie_toolbox_init_depth = quicktime.movie_toolbox_init_depth.saturating_add(1);
ppc_qt_record_error(quicktime, PPC_NO_ERR)
}
pub(crate) fn ppc_qt_exit_movies(quicktime: &mut PpcQuickTimeState) {
quicktime.movie_toolbox_exit_count = quicktime.movie_toolbox_exit_count.saturating_add(1);
quicktime.movie_toolbox_init_depth = quicktime.movie_toolbox_init_depth.saturating_sub(1);
let _ = ppc_qt_record_error(quicktime, PPC_NO_ERR);
}
pub(crate) fn ppc_qt_get_movies_error(quicktime: &mut PpcQuickTimeState) -> i16 {
let error = quicktime.movie_error;
quicktime.movie_error = PPC_NO_ERR;
error
}
pub(crate) fn ppc_qt_get_movies_sticky_error(quicktime: &mut PpcQuickTimeState) -> i16 {
let error = quicktime.movie_sticky_error;
let _ = ppc_qt_record_error(quicktime, PPC_NO_ERR);
error
}
pub(crate) fn ppc_qt_clear_movies_sticky_error(quicktime: &mut PpcQuickTimeState) {
quicktime.movie_sticky_error = PPC_NO_ERR;
let _ = ppc_qt_record_error(quicktime, PPC_NO_ERR);
}
fn ppc_qt_clear_graphics_importer(quicktime: &mut PpcQuickTimeState) {
quicktime.graphics_importer_open = false;
quicktime.graphics_importer_gworld = 0;
quicktime.graphics_importer_gdevice = 0;
quicktime.graphics_importer_path.clear();
quicktime.graphics_importer_subtype = 0;
quicktime.graphics_importer_depth = 0;
quicktime.graphics_importer_data.clear();
quicktime.graphics_importer_bounds = None;
quicktime.graphics_importer_image = None;
}
pub(crate) fn ppc_qt_open_default_component(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
quicktime: &mut PpcQuickTimeState,
) -> i16 {
const GRAPHICS_IMPORTER: u32 = u32::from_be_bytes(*b"grip");
let out = cpu.gpr[5];
match (cpu.gpr[3], cpu.gpr[4]) {
(GRAPHICS_IMPORTER, subtype) if ppc_qt_graphics_image_format(subtype).is_some() => {}
(component_type, component_subtype) => {
eprintln!(
"[PPC-QT] OpenADefaultComponent unsupported type={} subtype={}",
format_ppc_fourcc(component_type),
format_ppc_fourcc(component_subtype),
);
return PPC_INVALID_COMPONENT_ID;
}
}
if out == 0 || !ppc_memory_can_write_bytes(memory, out, 4) {
return PPC_PARAM_ERR;
}
if memory.write_u32_be(out, PPC_QT_GRAPHICS_IMPORTER).is_none() {
return PPC_PARAM_ERR;
}
ppc_qt_clear_graphics_importer(quicktime);
quicktime.graphics_importer_open = true;
quicktime.graphics_importer_subtype = cpu.gpr[4];
quicktime.graphics_importer_path =
format!("<synthetic {} importer>", format_ppc_fourcc(cpu.gpr[4]));
PPC_NO_ERR
}
const PPC_QT_GRAPHICS_IMPORTER_MAX_DATA: u32 = 16 * 1024 * 1024;
const PPC_QT_GRAPHICS_IMPORTER_MAX_DIMENSION: u32 = 8192;
const PPC_QT_GRAPHICS_IMPORTER_MAX_PIXELS: u32 = 16 * 1024 * 1024;
fn ppc_qt_graphics_image_format(subtype: u32) -> Option<image::ImageFormat> {
match subtype.to_be_bytes() {
[b'G', b'I', b'F', b' '] => Some(image::ImageFormat::Gif),
[b'T', b'G', b'A', b' '] => Some(image::ImageFormat::Tga),
[b'j', b'p', b'e', b'g'] | [b'J', b'P', b'E', b'G'] => Some(image::ImageFormat::Jpeg),
[b'p', b'n', b'g', b' '] | [b'P', b'N', b'G', b'f'] => Some(image::ImageFormat::Png),
_ => None,
}
}
fn ppc_qt_decode_graphics_image(subtype: u32, data: &[u8]) -> Option<PpcQtGraphicsImage> {
let format = ppc_qt_graphics_image_format(subtype)?;
if data.len() > PPC_QT_GRAPHICS_IMPORTER_MAX_DATA as usize {
return None;
}
if format == image::ImageFormat::Tga && ppc_qt_tga_is_truecolor_16(data) {
return ppc_qt_decode_tga_truecolor_16(data);
}
let mut reader = image::ImageReader::with_format(std::io::Cursor::new(data), format);
let mut limits = image::Limits::default();
limits.max_image_width = Some(PPC_QT_GRAPHICS_IMPORTER_MAX_DIMENSION);
limits.max_image_height = Some(PPC_QT_GRAPHICS_IMPORTER_MAX_DIMENSION);
limits.max_alloc = Some(128 * 1024 * 1024);
reader.limits(limits);
let decoded = reader.decode().ok()?;
let width = decoded.width();
let height = decoded.height();
if width == 0
|| height == 0
|| width > PPC_QT_GRAPHICS_IMPORTER_MAX_DIMENSION
|| height > PPC_QT_GRAPHICS_IMPORTER_MAX_DIMENSION
|| width.checked_mul(height)? > PPC_QT_GRAPHICS_IMPORTER_MAX_PIXELS
{
return None;
}
Some(PpcQtGraphicsImage {
width,
height,
rgba: decoded.to_rgba8().into_raw(),
})
}
fn ppc_qt_tga_is_truecolor_16(data: &[u8]) -> bool {
let Some(header) = data.get(..18) else {
return false;
};
matches!(header[2], 2 | 10) && header[16] == 16
}
fn ppc_qt_decode_tga_truecolor_16(data: &[u8]) -> Option<PpcQtGraphicsImage> {
let header = data.get(..18)?;
let id_length = usize::from(header[0]);
if header[1] != 0 {
return None;
}
let image_type = header[2];
if !matches!(image_type, 2 | 10) || header[16] != 16 {
return None;
}
let width = u32::from(u16::from_le_bytes([header[12], header[13]]));
let height = u32::from(u16::from_le_bytes([header[14], header[15]]));
if width == 0
|| height == 0
|| width > PPC_QT_GRAPHICS_IMPORTER_MAX_DIMENSION
|| height > PPC_QT_GRAPHICS_IMPORTER_MAX_DIMENSION
|| width.checked_mul(height)? > PPC_QT_GRAPHICS_IMPORTER_MAX_PIXELS
{
return None;
}
let top_left = header[17] & 0x20 != 0;
let pixel_count = (width as usize).checked_mul(height as usize)?;
let payload = data.get(18 + id_length..)?;
let pixels = if image_type == 2 {
let payload = payload.get(..pixel_count.checked_mul(2)?)?;
payload
.chunks_exact(2)
.map(|bytes| u16::from_le_bytes([bytes[0], bytes[1]]))
.collect::<Vec<_>>()
} else {
let mut pixels = Vec::with_capacity(pixel_count);
let mut offset = 0usize;
while pixels.len() < pixel_count {
let control = *payload.get(offset)?;
offset += 1;
let count = usize::from(control & 0x7f) + 1;
if control & 0x80 != 0 {
let bytes = payload.get(offset..offset.checked_add(2)?)?;
offset += 2;
let value = u16::from_le_bytes([bytes[0], bytes[1]]);
if pixels.len().checked_add(count)? > pixel_count {
return None;
}
pixels.extend(std::iter::repeat_n(value, count));
} else {
let bytes = payload.get(offset..offset.checked_add(count.checked_mul(2)?)?)?;
offset += count.checked_mul(2)?;
if pixels.len().checked_add(count)? > pixel_count {
return None;
}
pixels.extend(
bytes
.chunks_exact(2)
.map(|chunk| u16::from_le_bytes([chunk[0], chunk[1]])),
);
}
}
pixels
};
debug_assert_eq!(pixels.len(), pixel_count);
let mut rgba = vec![0u8; pixel_count.checked_mul(4)?];
for source_row in 0..height as usize {
let destination_row = if top_left {
source_row
} else {
height as usize - 1 - source_row
};
for x in 0..width as usize {
let value = pixels[source_row * width as usize + x];
let red = ((value >> 10) & 0x1f) as u8;
let green = ((value >> 5) & 0x1f) as u8;
let blue = (value & 0x1f) as u8;
let destination = (destination_row * width as usize + x) * 4;
rgba[destination] = (red << 3) | (red >> 2);
rgba[destination + 1] = (green << 3) | (green >> 2);
rgba[destination + 2] = (blue << 3) | (blue >> 2);
rgba[destination + 3] = 0xff;
}
}
Some(PpcQtGraphicsImage {
width,
height,
rgba,
})
}
pub(crate) fn ppc_qt_graphics_import_set_data_handle(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
handles: &[PpcHandleRecord],
quicktime: &mut PpcQuickTimeState,
) -> i16 {
if cpu.gpr[3] != PPC_QT_GRAPHICS_IMPORTER || !quicktime.graphics_importer_open {
return PPC_PARAM_ERR;
}
const TGA_SUBTYPE: u32 = u32::from_be_bytes(*b"TGA ");
let subtype = quicktime.graphics_importer_subtype;
if ppc_qt_graphics_image_format(subtype).is_none() {
return PPC_PARAM_ERR;
}
let Some(source) = handles.iter().find(|record| record.handle == cpu.gpr[4]) else {
return PPC_PARAM_ERR;
};
if source.size == 0 || source.size > PPC_QT_GRAPHICS_IMPORTER_MAX_DATA {
return PPC_PARAM_ERR;
}
let mut data = vec![0u8; source.size as usize];
if memory.read_bytes_into(source.ptr, &mut data).is_none() {
return PPC_PARAM_ERR;
}
let declared_depth = if subtype == TGA_SUBTYPE {
let Some(header) = data.get(..18) else {
return PPC_PARAM_ERR;
};
if !matches!(header[2], 1 | 2 | 3 | 9 | 10 | 11) {
return PPC_PARAM_ERR;
}
header[16]
} else {
match ppc_qt_graphics_image_format(subtype) {
Some(image::ImageFormat::Jpeg) => 24,
Some(image::ImageFormat::Png) => 32,
_ => 8,
}
};
if !matches!(declared_depth, 8 | 15 | 16 | 24 | 32) {
return PPC_PARAM_ERR;
}
let Some(image) = ppc_qt_decode_graphics_image(subtype, &data) else {
return PPC_PARAM_ERR;
};
if image.width > i16::MAX as u32 || image.height > i16::MAX as u32 {
return PPC_PARAM_ERR;
}
quicktime.graphics_importer_depth = declared_depth as u16;
quicktime.graphics_importer_data = data;
quicktime.graphics_importer_bounds = Some((0, 0, image.height as i16, image.width as i16));
quicktime.graphics_importer_image = Some(image);
PPC_NO_ERR
}
fn ppc_qt_image_description_bytes(
subtype: u32,
width: i16,
height: i16,
source_depth: u16,
encoded_size: usize,
) -> [u8; 86] {
let mut description = [0u8; 86];
description[..4].copy_from_slice(&86u32.to_be_bytes());
let codec = match ppc_qt_graphics_image_format(subtype) {
Some(image::ImageFormat::Jpeg) => u32::from_be_bytes(*b"jpeg"),
Some(image::ImageFormat::Png) => u32::from_be_bytes(*b"png "),
_ => subtype,
};
description[4..8].copy_from_slice(&codec.to_be_bytes());
description[32..34].copy_from_slice(&width.to_be_bytes());
description[34..36].copy_from_slice(&height.to_be_bytes());
description[36..40].copy_from_slice(&(72i32 << 16).to_be_bytes());
description[40..44].copy_from_slice(&(72i32 << 16).to_be_bytes());
let depth = match source_depth {
8 => 8i16,
15 | 16 => 16,
24 if codec == u32::from_be_bytes(*b"jpeg") => 24,
24 | 32 => 32,
_ => 32,
};
let data_size = i32::try_from(encoded_size).unwrap_or(i32::MAX);
description[44..48].copy_from_slice(&data_size.to_be_bytes());
description[48..50].copy_from_slice(&1i16.to_be_bytes());
let name: &[u8] = match ppc_qt_graphics_image_format(subtype) {
Some(image::ImageFormat::Jpeg) => b"JPEG",
Some(image::ImageFormat::Png) => b"PNG",
Some(image::ImageFormat::Gif) => b"GIF",
_ => b"TGA",
};
description[50] = name.len() as u8;
description[51..51 + name.len()].copy_from_slice(name);
description[82..84].copy_from_slice(&depth.to_be_bytes());
description[84..86].copy_from_slice(&(-1i16).to_be_bytes());
description
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn ppc_qt_graphics_import_get_image_description(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
process_memory_manager: &mut ProcessNativeMemoryManager,
heap_cursor: &mut u32,
last_mem_error: &mut i16,
handles: &mut Vec<PpcHandleRecord>,
quicktime: &mut PpcQuickTimeState,
) -> i16 {
let out = cpu.gpr[4];
if cpu.gpr[3] != PPC_QT_GRAPHICS_IMPORTER
|| !quicktime.graphics_importer_open
|| ppc_qt_graphics_image_format(quicktime.graphics_importer_subtype).is_none()
|| out == 0
|| !ppc_memory_can_write_bytes(memory, out, 4)
{
return PPC_PARAM_ERR;
}
let (top, left, bottom, right) = quicktime.graphics_importer_bounds.unwrap_or((0, 0, 1, 1));
let description = ppc_qt_image_description_bytes(
quicktime.graphics_importer_subtype,
right - left,
bottom - top,
quicktime.graphics_importer_depth,
quicktime.graphics_importer_data.len(),
);
let handle = ppc_process_alloc_handle_with_bytes(
process_memory_manager,
memory,
heap_cursor,
last_mem_error,
handles,
&description,
);
if handle == 0 || memory.write_u32_be(out, handle).is_none() {
*last_mem_error = PPC_MEM_FULL_ERR;
return PPC_MEM_FULL_ERR;
}
PPC_NO_ERR
}
pub(crate) fn ppc_close_component(cpu: &mut PpcCpu, quicktime: &mut PpcQuickTimeState) -> i16 {
if cpu.gpr[3] == PPC_QT_GRAPHICS_IMPORTER && quicktime.graphics_importer_open {
ppc_qt_clear_graphics_importer(quicktime);
PPC_NO_ERR
} else {
PPC_INVALID_COMPONENT_ID
}
}
pub(crate) fn ppc_qt_get_graphics_importer_for_file(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &[PpcVfsFileRecord],
quicktime: &mut PpcQuickTimeState,
) -> i16 {
let spec_ptr = cpu.gpr[3];
let importer_out_ptr = cpu.gpr[4];
if importer_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, importer_out_ptr, 4) {
return PPC_PARAM_ERR;
}
if memory
.write_u32_be(importer_out_ptr, PPC_QT_GRAPHICS_IMPORTER)
.is_none()
{
return PPC_PARAM_ERR;
}
ppc_qt_clear_graphics_importer(quicktime);
quicktime.graphics_importer_open = true;
if spec_ptr == 0 {
return PPC_NO_ERR;
}
let Ok(path) = ppc_existing_path_for_fsspec(memory, vfs_directories, vfs_files, &[], spec_ptr)
else {
return PPC_NO_ERR;
};
let Some(file) = vfs_files
.iter()
.find(|record| record.path.eq_ignore_ascii_case(&path))
else {
if qt_trace_enabled() {
eprintln!(
"[QT-TRACE] GetGraphicsImporterForFile path='{}' missing",
path
);
}
return PPC_NO_ERR;
};
let subtype = match image::guess_format(&file.data) {
Ok(image::ImageFormat::Jpeg) => Some(u32::from_be_bytes(*b"jpeg")),
Ok(image::ImageFormat::Png) => Some(u32::from_be_bytes(*b"png ")),
Ok(image::ImageFormat::Gif) => Some(u32::from_be_bytes(*b"GIF ")),
Ok(image::ImageFormat::Tga) => Some(u32::from_be_bytes(*b"TGA ")),
Ok(_) => {
ppc_qt_clear_graphics_importer(quicktime);
let _ = memory.write_u32_be(importer_out_ptr, 0);
return -8961; }
Err(_)
if file.file_type == u32::from_be_bytes(*b"TPIC")
|| file.file_type == u32::from_be_bytes(*b"TGA ")
|| path.to_ascii_lowercase().ends_with(".tga") =>
{
Some(u32::from_be_bytes(*b"TGA "))
}
_ => None,
};
if let Some(subtype) = subtype {
let Some(image) = ppc_qt_decode_graphics_image(subtype, &file.data) else {
ppc_qt_clear_graphics_importer(quicktime);
let _ = memory.write_u32_be(importer_out_ptr, 0);
return -8969; };
quicktime.graphics_importer_subtype = subtype;
quicktime.graphics_importer_depth = match ppc_qt_graphics_image_format(subtype) {
Some(image::ImageFormat::Jpeg) => 24,
Some(image::ImageFormat::Gif) => 8,
Some(image::ImageFormat::Tga) => u16::from(file.data[16]),
_ => 32,
};
quicktime.graphics_importer_bounds = Some((0, 0, image.height as i16, image.width as i16));
quicktime.graphics_importer_image = Some(image);
} else {
quicktime.graphics_importer_bounds = ppc_qt_pict_bounds(&file.data);
if quicktime.graphics_importer_bounds.is_none() {
ppc_qt_clear_graphics_importer(quicktime);
let _ = memory.write_u32_be(importer_out_ptr, 0);
return -8961; }
}
quicktime.graphics_importer_path = path;
quicktime.graphics_importer_data = file.data.to_vec();
if qt_trace_enabled() {
eprintln!(
"[QT-TRACE] GetGraphicsImporterForFile path='{}' data_len={} bounds={:?}",
quicktime.graphics_importer_path,
quicktime.graphics_importer_data.len(),
quicktime.graphics_importer_bounds
);
}
PPC_NO_ERR
}
pub(crate) fn ppc_qt_graphics_import_get_bounds_rect(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
quicktime: &PpcQuickTimeState,
) -> i16 {
let bounds_ptr = cpu.gpr[4];
if cpu.gpr[3] != PPC_QT_GRAPHICS_IMPORTER
|| !quicktime.graphics_importer_open
|| bounds_ptr == 0
{
return PPC_PARAM_ERR;
}
if !ppc_memory_can_write_bytes(memory, bounds_ptr, 8) {
return PPC_PARAM_ERR;
}
let (top, left, bottom, right) = quicktime.graphics_importer_bounds.unwrap_or((
0,
0,
ppc_main_screen_height() as i16,
ppc_main_screen_width() as i16,
));
if ppc_write_rect(memory, bounds_ptr, top, left, bottom, right).is_none() {
PPC_PARAM_ERR
} else {
PPC_NO_ERR
}
}
pub(crate) fn ppc_qt_graphics_import_set_gworld(
cpu: &mut PpcCpu,
quicktime: &mut PpcQuickTimeState,
) -> i16 {
if cpu.gpr[3] != PPC_QT_GRAPHICS_IMPORTER || !quicktime.graphics_importer_open {
return PPC_PARAM_ERR;
}
quicktime.graphics_importer_gworld = cpu.gpr[4];
quicktime.graphics_importer_gdevice = cpu.gpr[5];
PPC_NO_ERR
}
pub(crate) fn ppc_qt_graphics_import_draw(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
quicktime: &mut PpcQuickTimeState,
) -> i16 {
if cpu.gpr[3] != PPC_QT_GRAPHICS_IMPORTER || !quicktime.graphics_importer_open {
return PPC_PARAM_ERR;
}
let gworld = if quicktime.graphics_importer_gworld != 0 {
quicktime.graphics_importer_gworld
} else {
current_gworld
};
let Some(surface) = ppc_live_quickdraw_surface(memory, gworlds, gworld) else {
if qt_trace_enabled() {
eprintln!(
"[QT-TRACE] GraphicsImportDraw path='{}' gworld=${:08X} result=paramErr no-front-buffer",
quicktime.graphics_importer_path, gworld
);
}
return PPC_PARAM_ERR;
};
let front_buffer = surface.front_buffer;
quicktime.graphics_import_draw_count = quicktime.graphics_import_draw_count.saturating_add(1);
let source_drawn = if quicktime.graphics_importer_subtype == 0 {
ppc_qt_draw_pict_source_to_16bpp(memory, front_buffer, &quicktime.graphics_importer_data)
} else {
ppc_qt_draw_graphics_image(memory, surface, gworld, quicktime)
};
if source_drawn {
quicktime.graphics_import_source_draw_count = quicktime
.graphics_import_source_draw_count
.saturating_add(1);
if qt_trace_enabled() {
eprintln!(
"[QT-TRACE] GraphicsImportDraw path='{}' gworld=${:08X} data_len={} source=true fallback=false draw_count={} source_count={}",
quicktime.graphics_importer_path,
gworld,
quicktime.graphics_importer_data.len(),
quicktime.graphics_import_draw_count,
quicktime.graphics_import_source_draw_count
);
}
return PPC_NO_ERR;
}
let fallback_drawn = quicktime.graphics_importer_subtype == 0
&& ppc_qt_draw_placeholder_frame(
memory,
front_buffer,
quicktime.graphics_importer_bounds,
0x10u32.saturating_add(quicktime.graphics_import_draw_count),
);
if qt_trace_enabled() {
eprintln!(
"[QT-TRACE] GraphicsImportDraw path='{}' gworld=${:08X} data_len={} source=false fallback={} draw_count={} source_count={}",
quicktime.graphics_importer_path,
gworld,
quicktime.graphics_importer_data.len(),
fallback_drawn,
quicktime.graphics_import_draw_count,
quicktime.graphics_import_source_draw_count
);
}
if fallback_drawn {
PPC_NO_ERR
} else {
PPC_PARAM_ERR
}
}
fn ppc_qt_graphics_pixel_value(
memory: &mut PpcSectionMem,
surface: PpcQuickDrawSurface,
color: PpcRgbColor,
) -> Option<u32> {
match surface.front_buffer.depth {
32 => {
Some(
(u32::from(color.red >> 8) << 16)
| (u32::from(color.green >> 8) << 8)
| u32::from(color.blue >> 8),
)
}
_ => {
ppc_quickdraw_surface_color_pixel(memory, surface, color).map(u32::from)
}
}
}
fn ppc_qt_write_graphics_pixel(
memory: &mut PpcSectionMem,
front_buffer: PpcFrontBuffer,
point: (i32, i32),
value: u32,
) -> bool {
match front_buffer.depth {
32 => {
let (x, y) = point;
let (Ok(x), Ok(y)) = (u32::try_from(x), u32::try_from(y)) else {
return false;
};
let Some(row_offset) = y.checked_mul(front_buffer.row_bytes) else {
return false;
};
let Some(pixel_offset) = x.checked_mul(4) else {
return false;
};
if x >= front_buffer.width
|| y >= front_buffer.height
|| pixel_offset
.checked_add(4)
.map_or(true, |end| end > front_buffer.row_bytes)
{
return false;
}
let Some(addr) = front_buffer
.base_addr
.checked_add(row_offset)
.and_then(|row| row.checked_add(pixel_offset))
else {
return false;
};
memory.write_u32_be(addr, value).is_some()
}
_ => ppc_quickdraw_write_raw_pixel(memory, front_buffer, point, value as u16),
}
}
fn ppc_qt_draw_graphics_image(
memory: &mut PpcSectionMem,
surface: PpcQuickDrawSurface,
gworld: u32,
quicktime: &PpcQuickTimeState,
) -> bool {
let Some(image) = quicktime.graphics_importer_image.as_ref() else {
return false;
};
let front_buffer = surface.front_buffer;
if front_buffer.base_addr == 0 || front_buffer.width == 0 || front_buffer.height == 0 {
return false;
}
let x0 = i32::from(surface.left).max(0) as u32;
let y0 = i32::from(surface.top).max(0) as u32;
let x1 = image
.width
.min((i64::from(surface.left) + i64::from(front_buffer.width)).max(0) as u32);
let y1 = image
.height
.min((i64::from(surface.top) + i64::from(front_buffer.height)).max(0) as u32);
let clip = ppc_port_clip_storage(memory, gworld, None);
let vis = memory
.read_u32_be(gworld.wrapping_add(PPC_CGRAF_PORT_VIS_RGN_OFFSET))
.and_then(|handle| ppc_region_storage(memory, handle));
let mut color_cache: HashMap<[u8; 3], Option<u32>> = HashMap::new();
for y in y0..y1 {
for x in x0..x1 {
let point = surface.local_point((x as i32, y as i32));
if !ppc_local_point_in_port_regions(surface, point, vis.as_deref(), clip.as_deref()) {
continue;
}
let Some(offset) = (y as usize)
.checked_mul(image.width as usize)
.and_then(|base| base.checked_add(x as usize))
.and_then(|pixel| pixel.checked_mul(4))
else {
continue;
};
let Some(rgba) = image.rgba.get(offset..offset.saturating_add(4)) else {
continue;
};
if rgba[3] == 0 {
continue;
}
let key = [rgba[0], rgba[1], rgba[2]];
let value = match color_cache.get(&key) {
Some(value) => *value,
None => {
let color = PpcRgbColor {
red: u16::from(rgba[0]) * 0x0101,
green: u16::from(rgba[1]) * 0x0101,
blue: u16::from(rgba[2]) * 0x0101,
};
let value = ppc_qt_graphics_pixel_value(memory, surface, color);
color_cache.insert(key, value);
value
}
};
let Some(value) = value else {
continue;
};
if !ppc_qt_write_graphics_pixel(memory, front_buffer, point, value) {
return false;
}
}
}
true
}
pub(crate) fn ppc_qt_pict_record_offset_and_bounds(
data: &[u8],
) -> Option<(usize, (i16, i16, i16, i16))> {
[0usize, 512usize].into_iter().find_map(|offset| {
let header = data.get(offset..offset.checked_add(10)?)?;
let top = i16::from_be_bytes(header.get(2..4)?.try_into().ok()?);
let left = i16::from_be_bytes(header.get(4..6)?.try_into().ok()?);
let bottom = i16::from_be_bytes(header.get(6..8)?.try_into().ok()?);
let right = i16::from_be_bytes(header.get(8..10)?.try_into().ok()?);
let width = i32::from(right) - i32::from(left);
let height = i32::from(bottom) - i32::from(top);
(width > 0 && height > 0 && width <= 8192 && height <= 8192)
.then_some((offset, (top, left, bottom, right)))
})
}
pub(crate) fn ppc_qt_pict_bounds(data: &[u8]) -> Option<(i16, i16, i16, i16)> {
ppc_qt_pict_record_offset_and_bounds(data).map(|(_, bounds)| bounds)
}
pub(crate) fn ppc_qt_movie_bounds(data: &[u8]) -> Option<(i16, i16, i16, i16)> {
ppc_qt_scan_movie_bounds(data, 0, data.len(), 0)
}
pub(crate) fn ppc_qt_movie_duration(data: &[u8]) -> Option<(u32, u64)> {
ppc_qt_aiff_audio_track(data)
.map(|track| (track.media_time_scale, track.media_duration))
.or_else(|| ppc_qt_scan_movie_header(data, 0, data.len(), 0, ppc_qt_mvhd_duration))
}
pub(crate) fn ppc_qt_movie_preferred_rate(data: &[u8]) -> Option<i32> {
ppc_qt_scan_movie_header(data, 0, data.len(), 0, ppc_qt_mvhd_preferred_rate)
}
pub(crate) fn ppc_qt_movie_preferred_volume(data: &[u8]) -> Option<i16> {
ppc_qt_scan_movie_header(data, 0, data.len(), 0, ppc_qt_mvhd_preferred_volume)
}
fn ppc_qt_movie_user_data_range(data: &[u8]) -> Option<(usize, usize)> {
let mut offset = 0;
while offset + 8 <= data.len() {
let Some((kind, content_start, atom_end)) = ppc_qt_atom_range(data, offset, data.len())
else {
break;
};
if kind == b"moov" {
let mut child = content_start;
while child + 8 <= atom_end {
let Some((child_kind, child_start, child_end)) =
ppc_qt_atom_range(data, child, atom_end)
else {
break;
};
if child_kind == b"udta" {
return Some((child_start, child_end));
}
child = child_end;
}
}
offset = atom_end;
}
None
}
fn ppc_qt_movie_has_user_data(data: &[u8]) -> bool {
ppc_qt_movie_user_data_range(data).is_some()
}
pub(crate) fn ppc_qt_movie_tracks(data: &[u8]) -> Vec<PpcQuickTimeTrackRecord> {
if let Some(audio) = ppc_qt_aiff_audio_track(data) {
return vec![PpcQuickTimeTrackRecord {
handle: PPC_QT_MOVIE + 0x110,
id: 1,
media_type: u32::from_be_bytes(*b"soun"),
enabled: true,
duration: audio.media_duration,
volume: 0x0100,
matrix: [0x10000, 0, 0, 0, 0x10000, 0, 0, 0, 0x40000000],
..PpcQuickTimeTrackRecord::default()
}];
}
let mut offset = 0;
while offset + 8 <= data.len() {
let Some((kind, content_start, atom_end)) = ppc_qt_atom_range(data, offset, data.len())
else {
break;
};
if kind == b"moov" {
let mut tracks = Vec::new();
let mut track_offset = content_start;
while track_offset + 8 <= atom_end && tracks.len() < 1024 {
let Some((track_kind, track_start, track_end)) =
ppc_qt_atom_range(data, track_offset, atom_end)
else {
break;
};
if track_kind == b"trak" {
if let Some((id, media_type, enabled)) =
ppc_qt_track_metadata(data, track_start, track_end)
{
let ordinal = tracks.len() as u32 + 1;
let details = toolbox::ppc_qt_track_details(data, track_start, track_end);
tracks.push(PpcQuickTimeTrackRecord {
handle: PPC_QT_MOVIE + 0x100 + ordinal * 0x10,
id,
media_type,
enabled,
duration: details.duration,
offset: details.offset,
layer: details.layer,
volume: details.volume,
matrix: details.matrix,
width: details.width,
height: details.height,
balance: 0,
graphics_mode: 0x40, });
}
}
track_offset = track_end;
}
return tracks;
}
offset = atom_end;
}
Vec::new()
}
fn ppc_qt_child_atom_range(
data: &[u8],
start: usize,
end: usize,
wanted: &[u8],
) -> Option<(usize, usize)> {
let mut offset = start;
while offset.checked_add(8)? <= end {
let (kind, content_start, atom_end) = ppc_qt_atom_range(data, offset, end)?;
if kind == wanted {
return Some((content_start, atom_end));
}
offset = atom_end;
}
None
}
fn ppc_qt_movie_sample_description(data: &[u8], track_index: usize, index: u32) -> Option<&[u8]> {
if index == 0 || track_index == 0 {
return None;
}
let (moov_start, moov_end) = ppc_qt_child_atom_range(data, 0, data.len(), b"moov")?;
let mut offset = moov_start;
let mut track_number = 0;
while offset.checked_add(8)? <= moov_end {
let (kind, track_start, track_end) = ppc_qt_atom_range(data, offset, moov_end)?;
if kind == b"trak" && ppc_qt_track_metadata(data, track_start, track_end).is_some() {
track_number += 1;
if track_number == track_index {
let (media_start, media_end) =
ppc_qt_child_atom_range(data, track_start, track_end, b"mdia")?;
let (minf_start, minf_end) =
ppc_qt_child_atom_range(data, media_start, media_end, b"minf")?;
let (stbl_start, stbl_end) =
ppc_qt_child_atom_range(data, minf_start, minf_end, b"stbl")?;
let (stsd_start, stsd_end) =
ppc_qt_child_atom_range(data, stbl_start, stbl_end, b"stsd")?;
let count =
u32::from_be_bytes(data.get(stsd_start + 4..stsd_start + 8)?.try_into().ok()?);
if index > count {
return None;
}
let mut entry = stsd_start.checked_add(8)?;
for _ in 1..index {
let (_, _, entry_end) = ppc_qt_atom_range(data, entry, stsd_end)?;
entry = entry_end;
}
let (_, _, entry_end) = ppc_qt_atom_range(data, entry, stsd_end)?;
return data.get(entry..entry_end);
}
}
offset = track_end;
}
None
}
fn ppc_qt_movie_data_from_open_fork(
files: &[PpcFileRecord],
vfs_files: &[PpcVfsFileRecord],
ref_num: i16,
offset: u32,
) -> Option<(String, Vec<u8>, Rc<ProcessForkBytes>)> {
let open_file = files.iter().find(|file| file.ref_num == ref_num)?;
let file = vfs_files
.iter()
.find(|file| file.path.eq_ignore_ascii_case(&open_file.path))?;
let bytes = file.data.as_ref();
let offset = usize::try_from(offset).ok()?;
let (kind, _, atom_end) = ppc_qt_atom_range(bytes, offset, bytes.len())?;
if kind != b"moov" {
return None;
}
Some((
file.path.clone(),
bytes.get(offset..atom_end)?.to_vec(),
Rc::new(file.data.shared_handle()),
))
}
fn ppc_qt_track_metadata(data: &[u8], start: usize, end: usize) -> Option<(u32, u32, bool)> {
let mut header = None;
let mut media_type = None;
let mut offset = start;
while offset.checked_add(8)? <= end {
let (kind, content_start, atom_end) = ppc_qt_atom_range(data, offset, end)?;
if kind == b"tkhd" {
let version = *data.get(content_start)?;
let id_offset = match version {
0 => content_start.checked_add(12)?,
1 => content_start.checked_add(20)?,
_ => return None,
};
if id_offset.checked_add(4)? > atom_end {
return None;
}
let id = u32::from_be_bytes(data.get(id_offset..id_offset + 4)?.try_into().ok()?);
let flags = u32::from_be_bytes(
data.get(content_start..content_start + 4)?
.try_into()
.ok()?,
);
header = Some((id, flags & 1 != 0));
} else if kind == b"mdia" {
let mut media_offset = content_start;
while media_offset.checked_add(8)? <= atom_end {
let (media_kind, handler_start, media_end) =
ppc_qt_atom_range(data, media_offset, atom_end)?;
if media_kind == b"hdlr"
&& handler_start.checked_add(12)? <= media_end
&& data.get(handler_start + 4..handler_start + 8)? == b"mhlr"
{
media_type = Some(u32::from_be_bytes(
data.get(handler_start + 8..handler_start + 12)?
.try_into()
.ok()?,
));
break;
}
media_offset = media_end;
}
}
offset = atom_end;
}
let (id, enabled) = header?;
Some((id, media_type?, enabled))
}
pub(crate) fn ppc_qt_movie_first_video_track(data: &[u8]) -> Option<PpcQuickTimeVideoTrackRecord> {
ppc_qt_scan_movie_video_track(data, 0, data.len(), 0)
}
pub(crate) fn ppc_qt_movie_video_samples(
data: &[u8],
) -> Option<PpcQuickTimeVideoSampleTableRecord> {
ppc_qt_scan_movie_video_samples(data, 0, data.len(), 0)
}
pub(crate) fn ppc_qt_movie_first_audio_track(data: &[u8]) -> Option<PpcQuickTimeAudioTrackRecord> {
ppc_qt_aiff_audio_track(data)
.or_else(|| ppc_qt_scan_movie_audio_track(data, 0, data.len(), 0))
}
fn ppc_qt_aiff_audio_track(data: &[u8]) -> Option<PpcQuickTimeAudioTrackRecord> {
let metadata = ppc_parse_aiff_metadata(data)?;
let form_size = usize::try_from(ppc_read_be_u32_from_slice(data, 4)?).ok()?;
if form_size.checked_add(8)? > data.len() {
return None;
}
let decoded = ppc_decode_aiff_samples(data)?;
let codec = ppc_sound_codec(-1, metadata.compression_type, metadata.sample_size)?;
let (frames_per_packet, bytes_per_channel, _) = codec.packet_geometry();
let packet_size =
u32::from(bytes_per_channel).checked_mul(u32::from(metadata.channel_count))?;
let packet_count = decoded
.summary
.sample_count
.checked_div(u32::from(frames_per_packet))?;
let start = usize::try_from(metadata.sound_data_offset).ok()?;
let packet = data.get(start..start.checked_add(packet_size as usize)?)?;
let mut preview = [0; 16];
let preview_len = packet.len().min(preview.len());
preview[..preview_len].copy_from_slice(&packet[..preview_len]);
Some(PpcQuickTimeAudioTrackRecord {
media_time_scale: decoded.summary.sample_rate_fixed >> 16,
media_duration: u64::from(decoded.summary.sample_count),
sample_count: packet_count,
first_sample_duration: u32::from(frames_per_packet),
first_sample_size: packet_size,
first_chunk_offset: u64::from(metadata.sound_data_offset),
first_sample_data_len: packet_size,
first_sample_checksum: packet
.iter()
.fold(0u32, |sum, byte| sum.wrapping_add(u32::from(*byte))),
first_sample_preview_len: preview_len as u8,
first_sample_preview: preview,
first_samples_per_chunk: packet_count,
sample_description_id: 1,
codec: metadata.compression_type,
channel_count: metadata.channel_count,
sample_size_bits: metadata.sample_size,
sample_rate_fixed: decoded.summary.sample_rate_fixed,
})
}
fn ppc_qt_atom_range(data: &[u8], offset: usize, end: usize) -> Option<(&[u8], usize, usize)> {
if offset.checked_add(8)? > end || end > data.len() {
return None;
}
let size = u32::from_be_bytes(data.get(offset..offset + 4)?.try_into().ok()?);
let atom_type = data.get(offset + 4..offset + 8)?;
let (content_start, atom_end) = if size == 1 {
let extended_size = u64::from_be_bytes(data.get(offset + 8..offset + 16)?.try_into().ok()?);
let extended_size = usize::try_from(extended_size).ok()?;
if extended_size < 16 {
return None;
}
(offset + 16, offset.checked_add(extended_size)?)
} else if size == 0 {
(offset + 8, end)
} else {
let size = usize::try_from(size).ok()?;
if size < 8 {
return None;
}
(offset + 8, offset.checked_add(size)?)
};
if atom_end > end || content_start > atom_end {
return None;
}
Some((atom_type, content_start, atom_end))
}
fn ppc_qt_scan_movie_bounds(
data: &[u8],
start: usize,
end: usize,
depth: u8,
) -> Option<(i16, i16, i16, i16)> {
if depth > 8 || start >= end || end > data.len() {
return None;
}
let mut offset = start;
let mut bounds = None;
while offset.checked_add(8)? <= end {
let size = u32::from_be_bytes(data.get(offset..offset + 4)?.try_into().ok()?);
let atom_type = data.get(offset + 4..offset + 8)?;
let (content_start, atom_end) = if size == 1 {
let extended_size =
u64::from_be_bytes(data.get(offset + 8..offset + 16)?.try_into().ok()?);
let extended_size = usize::try_from(extended_size).ok()?;
if extended_size < 16 {
return bounds;
}
(offset + 16, offset.checked_add(extended_size)?)
} else if size == 0 {
(offset + 8, end)
} else {
let size = usize::try_from(size).ok()?;
if size < 8 {
return bounds;
}
(offset + 8, offset.checked_add(size)?)
};
if atom_end > end || content_start > atom_end {
return bounds;
}
if atom_type == b"tkhd" {
bounds = ppc_qt_union_bounds(bounds, ppc_qt_tkhd_bounds(data, content_start, atom_end));
} else if ppc_qt_is_container_atom(atom_type) {
bounds = ppc_qt_union_bounds(
bounds,
ppc_qt_scan_movie_bounds(data, content_start, atom_end, depth + 1),
);
}
if atom_end == end {
break;
}
offset = atom_end;
}
bounds
}
fn ppc_qt_scan_movie_header<T>(
data: &[u8],
start: usize,
end: usize,
depth: u8,
read_header: fn(&[u8], usize, usize) -> Option<T>,
) -> Option<T> {
if depth > 8 || start >= end || end > data.len() {
return None;
}
let mut offset = start;
while offset.checked_add(8)? <= end {
let size = u32::from_be_bytes(data.get(offset..offset + 4)?.try_into().ok()?);
let atom_type = data.get(offset + 4..offset + 8)?;
let (content_start, atom_end) = if size == 1 {
let extended_size =
u64::from_be_bytes(data.get(offset + 8..offset + 16)?.try_into().ok()?);
let extended_size = usize::try_from(extended_size).ok()?;
if extended_size < 16 {
return None;
}
(offset + 16, offset.checked_add(extended_size)?)
} else if size == 0 {
(offset + 8, end)
} else {
let size = usize::try_from(size).ok()?;
if size < 8 {
return None;
}
(offset + 8, offset.checked_add(size)?)
};
if atom_end > end || content_start > atom_end {
return None;
}
if atom_type == b"mvhd" {
if let Some(value) = read_header(data, content_start, atom_end) {
return Some(value);
}
} else if ppc_qt_is_container_atom(atom_type) {
if let Some(value) =
ppc_qt_scan_movie_header(data, content_start, atom_end, depth + 1, read_header)
{
return Some(value);
}
}
if atom_end == end {
break;
}
offset = atom_end;
}
None
}
#[derive(Default)]
struct PpcQuickTimeTrackSampleInfo {
handler_subtype: u32,
media_time_scale: u32,
media_duration: u64,
sample_count: u32,
first_sample_duration: u32,
first_sample_size: u32,
first_chunk_offset: u64,
first_samples_per_chunk: u32,
sample_description_id: u32,
codec: u32,
audio_channel_count: u16,
audio_sample_size_bits: u16,
audio_sample_rate_fixed: u32,
}
impl PpcQuickTimeTrackSampleInfo {
fn is_complete_for(&self, handler_subtype: u32) -> bool {
self.handler_subtype == handler_subtype
&& self.media_time_scale != 0
&& self.media_duration != 0
&& self.sample_count != 0
&& self.first_sample_duration != 0
&& self.first_sample_size != 0
&& self.first_samples_per_chunk != 0
&& self.sample_description_id != 0
&& self.codec != 0
}
fn into_video_track(self, data: &[u8]) -> Option<PpcQuickTimeVideoTrackRecord> {
if !self.is_complete_for(u32::from_be_bytes(*b"vide")) {
return None;
}
let (
first_sample_data_len,
first_sample_checksum,
first_sample_preview_len,
first_sample_preview,
) = ppc_qt_sample_payload_summary(data, self.first_chunk_offset, self.first_sample_size);
Some(PpcQuickTimeVideoTrackRecord {
media_time_scale: self.media_time_scale,
media_duration: self.media_duration,
sample_count: self.sample_count,
first_sample_duration: self.first_sample_duration,
first_sample_size: self.first_sample_size,
first_chunk_offset: self.first_chunk_offset,
first_sample_data_len,
first_sample_checksum,
first_sample_preview_len,
first_sample_preview,
first_samples_per_chunk: self.first_samples_per_chunk,
sample_description_id: self.sample_description_id,
codec: self.codec,
})
}
fn into_audio_track(self, data: &[u8]) -> Option<PpcQuickTimeAudioTrackRecord> {
if !self.is_complete_for(u32::from_be_bytes(*b"soun"))
|| self.audio_channel_count == 0
|| self.audio_sample_size_bits == 0
|| self.audio_sample_rate_fixed == 0
{
return None;
}
let (
first_sample_data_len,
first_sample_checksum,
first_sample_preview_len,
first_sample_preview,
) = ppc_qt_sample_payload_summary(data, self.first_chunk_offset, self.first_sample_size);
Some(PpcQuickTimeAudioTrackRecord {
media_time_scale: self.media_time_scale,
media_duration: self.media_duration,
sample_count: self.sample_count,
first_sample_duration: self.first_sample_duration,
first_sample_size: self.first_sample_size,
first_chunk_offset: self.first_chunk_offset,
first_sample_data_len,
first_sample_checksum,
first_sample_preview_len,
first_sample_preview,
first_samples_per_chunk: self.first_samples_per_chunk,
sample_description_id: self.sample_description_id,
codec: self.codec,
channel_count: self.audio_channel_count,
sample_size_bits: self.audio_sample_size_bits,
sample_rate_fixed: self.audio_sample_rate_fixed,
})
}
}
#[derive(Default)]
struct PpcQuickTimeAudioDecodeInfo {
handler_subtype: u32,
sample_count: u32,
codec: u32,
channel_count: u16,
sample_size_bits: u16,
sample_rate_fixed: u32,
stsc_entries: Vec<PpcQuickTimeStscEntry>,
chunk_offsets: Vec<u64>,
}
#[derive(Default)]
pub(crate) struct PpcQuickTimeMusicDecodeInfo {
pub(crate) handler_subtype: u32,
pub(crate) media_time_scale: u32,
pub(crate) media_duration: u64,
pub(crate) sample_durations: Vec<u32>,
pub(crate) sample_sizes: Vec<u32>,
pub(crate) stsc_entries: Vec<PpcQuickTimeStscEntry>,
pub(crate) chunk_offsets: Vec<u64>,
pub(crate) sample_descriptions: Vec<Vec<PpcQuickTimeMusicPart>>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct PpcQuickTimeMusicPart {
pub(crate) part: u16,
pub(crate) instrument_number: u32,
pub(crate) gm_number: u32,
}
#[derive(Default)]
struct PpcQuickTimeVideoSampleTableInfo {
handler_subtype: u32,
media_time_scale: u32,
media_duration: u64,
codec: u32,
sample_durations: Vec<u32>,
sample_sizes: Vec<u32>,
stsc_entries: Vec<PpcQuickTimeStscEntry>,
chunk_offsets: Vec<u64>,
}
impl PpcQuickTimeVideoSampleTableInfo {
fn is_complete(&self) -> bool {
self.handler_subtype == u32::from_be_bytes(*b"vide")
&& self.media_time_scale != 0
&& self.media_duration != 0
&& self.codec != 0
&& !self.sample_sizes.is_empty()
&& !self.stsc_entries.is_empty()
&& !self.chunk_offsets.is_empty()
}
}
impl PpcQuickTimeAudioDecodeInfo {
fn is_complete(&self) -> bool {
self.handler_subtype == u32::from_be_bytes(*b"soun")
&& self.sample_count != 0
&& self.codec != 0
&& self.channel_count != 0
&& self.sample_rate_fixed != 0
&& !self.stsc_entries.is_empty()
&& !self.chunk_offsets.is_empty()
}
}
impl PpcQuickTimeMusicDecodeInfo {
fn is_complete(&self) -> bool {
self.handler_subtype == u32::from_be_bytes(*b"musi")
&& self.media_time_scale != 0
&& self.media_duration != 0
&& self.sample_durations.len() == self.sample_sizes.len()
&& !self.sample_sizes.is_empty()
&& !self.stsc_entries.is_empty()
&& !self.chunk_offsets.is_empty()
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct PpcQuickTimeStscEntry {
pub(crate) first_chunk: u32,
pub(crate) samples_per_chunk: u32,
pub(crate) sample_description_id: u32,
}
fn ppc_qt_scan_movie_video_track(
data: &[u8],
start: usize,
end: usize,
depth: u8,
) -> Option<PpcQuickTimeVideoTrackRecord> {
if depth > 8 || start >= end || end > data.len() {
return None;
}
let mut offset = start;
while offset.checked_add(8)? <= end {
let (atom_type, content_start, atom_end) = ppc_qt_atom_range(data, offset, end)?;
if atom_type == b"trak" {
if let Some(track) = ppc_qt_parse_video_track(data, content_start, atom_end, depth + 1)
{
return Some(track);
}
} else if ppc_qt_is_container_atom(atom_type) {
if let Some(track) =
ppc_qt_scan_movie_video_track(data, content_start, atom_end, depth + 1)
{
return Some(track);
}
}
if atom_end == end {
break;
}
offset = atom_end;
}
None
}
fn ppc_qt_parse_video_track(
data: &[u8],
start: usize,
end: usize,
depth: u8,
) -> Option<PpcQuickTimeVideoTrackRecord> {
let mut info = PpcQuickTimeTrackSampleInfo::default();
ppc_qt_collect_track_sample_info(data, start, end, depth, &mut info)?;
info.into_video_track(data)
}
fn ppc_qt_scan_movie_video_samples(
data: &[u8],
start: usize,
end: usize,
depth: u8,
) -> Option<PpcQuickTimeVideoSampleTableRecord> {
if depth > 8 || start >= end || end > data.len() {
return None;
}
let mut offset = start;
while offset.checked_add(8)? <= end {
let (atom_type, content_start, atom_end) = ppc_qt_atom_range(data, offset, end)?;
if atom_type == b"trak" {
if let Some(samples) =
ppc_qt_parse_video_track_samples(data, content_start, atom_end, depth + 1)
{
return Some(samples);
}
} else if ppc_qt_is_container_atom(atom_type) {
if let Some(samples) =
ppc_qt_scan_movie_video_samples(data, content_start, atom_end, depth + 1)
{
return Some(samples);
}
}
if atom_end == end {
break;
}
offset = atom_end;
}
None
}
fn ppc_qt_parse_video_track_samples(
data: &[u8],
start: usize,
end: usize,
depth: u8,
) -> Option<PpcQuickTimeVideoSampleTableRecord> {
let mut info = PpcQuickTimeVideoSampleTableInfo::default();
ppc_qt_collect_video_sample_table_info(data, start, end, depth, &mut info)?;
if !info.is_complete() {
return None;
}
ppc_qt_build_video_sample_table(data, &info)
}
fn ppc_qt_scan_movie_audio_track(
data: &[u8],
start: usize,
end: usize,
depth: u8,
) -> Option<PpcQuickTimeAudioTrackRecord> {
if depth > 8 || start >= end || end > data.len() {
return None;
}
let mut offset = start;
while offset.checked_add(8)? <= end {
let (atom_type, content_start, atom_end) = ppc_qt_atom_range(data, offset, end)?;
if atom_type == b"trak" {
if let Some(track) = ppc_qt_parse_audio_track(data, content_start, atom_end, depth + 1)
{
return Some(track);
}
} else if ppc_qt_is_container_atom(atom_type) {
if let Some(track) =
ppc_qt_scan_movie_audio_track(data, content_start, atom_end, depth + 1)
{
return Some(track);
}
}
if atom_end == end {
break;
}
offset = atom_end;
}
None
}
fn ppc_qt_parse_audio_track(
data: &[u8],
start: usize,
end: usize,
depth: u8,
) -> Option<PpcQuickTimeAudioTrackRecord> {
let mut info = PpcQuickTimeTrackSampleInfo::default();
ppc_qt_collect_track_sample_info(data, start, end, depth, &mut info)?;
info.into_audio_track(data)
}
pub(crate) fn ppc_qt_movie_audio_samples(data: &[u8]) -> Option<PpcDecodedAiffData> {
ppc_decode_aiff_samples(data)
.or_else(|| ppc_qt_scan_movie_audio_samples(data, 0, data.len(), 0))
.or_else(|| ppc_qt_scan_movie_music_samples(data, 0, data.len(), 0))
}
fn ppc_qt_scan_movie_music_samples(
data: &[u8],
start: usize,
end: usize,
depth: u8,
) -> Option<PpcDecodedAiffData> {
if depth > 8 || start >= end || end > data.len() {
return None;
}
let mut offset = start;
while offset.checked_add(8)? <= end {
let (atom_type, content_start, atom_end) = ppc_qt_atom_range(data, offset, end)?;
if atom_type == b"trak" {
let mut info = PpcQuickTimeMusicDecodeInfo::default();
ppc_qt_collect_music_decode_info(data, content_start, atom_end, depth + 1, &mut info)?;
if info.is_complete() {
return ppc_qt_synthesize_music_track(data, &info);
}
} else if ppc_qt_is_container_atom(atom_type) {
if let Some(samples) =
ppc_qt_scan_movie_music_samples(data, content_start, atom_end, depth + 1)
{
return Some(samples);
}
}
if atom_end == end {
break;
}
offset = atom_end;
}
None
}
fn ppc_qt_scan_movie_audio_samples(
data: &[u8],
start: usize,
end: usize,
depth: u8,
) -> Option<PpcDecodedAiffData> {
if depth > 8 || start >= end || end > data.len() {
return None;
}
let mut offset = start;
while offset.checked_add(8)? <= end {
let (atom_type, content_start, atom_end) = ppc_qt_atom_range(data, offset, end)?;
if atom_type == b"trak" {
if let Some(samples) =
ppc_qt_parse_audio_track_samples(data, content_start, atom_end, depth + 1)
{
return Some(samples);
}
} else if ppc_qt_is_container_atom(atom_type) {
if let Some(samples) =
ppc_qt_scan_movie_audio_samples(data, content_start, atom_end, depth + 1)
{
return Some(samples);
}
}
if atom_end == end {
break;
}
offset = atom_end;
}
None
}
fn ppc_qt_parse_audio_track_samples(
data: &[u8],
start: usize,
end: usize,
depth: u8,
) -> Option<PpcDecodedAiffData> {
let mut info = PpcQuickTimeAudioDecodeInfo::default();
ppc_qt_collect_audio_decode_info(data, start, end, depth, &mut info)?;
if !info.is_complete() {
return None;
}
ppc_qt_decode_audio_chunks(data, &info)
}
fn ppc_qt_sample_payload_summary(data: &[u8], offset: u64, size: u32) -> (u32, u32, u8, [u8; 16]) {
let mut preview = [0; 16];
let Ok(offset) = usize::try_from(offset) else {
return (0, 0, 0, preview);
};
let Ok(size) = usize::try_from(size) else {
return (0, 0, 0, preview);
};
let Some(end) = offset.checked_add(size) else {
return (0, 0, 0, preview);
};
let Some(sample) = data.get(offset..end) else {
return (0, 0, 0, preview);
};
let preview_len = sample.len().min(preview.len());
preview[..preview_len].copy_from_slice(&sample[..preview_len]);
let checksum = sample
.iter()
.fold(0u32, |acc, byte| acc.wrapping_add(u32::from(*byte)));
(
u32::try_from(sample.len()).unwrap_or(u32::MAX),
checksum,
u8::try_from(preview_len).unwrap_or(u8::MAX),
preview,
)
}
fn ppc_qt_collect_track_sample_info(
data: &[u8],
start: usize,
end: usize,
depth: u8,
info: &mut PpcQuickTimeTrackSampleInfo,
) -> Option<()> {
if depth > 8 || start >= end || end > data.len() {
return Some(());
}
let mut offset = start;
while offset.checked_add(8)? <= end {
let (atom_type, content_start, atom_end) = ppc_qt_atom_range(data, offset, end)?;
if atom_type == b"hdlr" {
if let Some(subtype) = ppc_qt_hdlr_subtype(data, content_start, atom_end) {
if subtype == u32::from_be_bytes(*b"vide")
|| subtype == u32::from_be_bytes(*b"soun")
{
info.handler_subtype = subtype;
}
}
} else if atom_type == b"mdhd" {
if let Some((time_scale, duration)) =
ppc_qt_mvhd_duration(data, content_start, atom_end)
{
info.media_time_scale = time_scale;
info.media_duration = duration;
}
} else if atom_type == b"stsd" {
if let Some(codec) = ppc_qt_stsd_first_codec(data, content_start, atom_end) {
info.codec = codec;
}
if let Some((channel_count, sample_size_bits, sample_rate_fixed)) =
ppc_qt_stsd_first_sound_description(data, content_start, atom_end)
{
info.audio_channel_count = channel_count;
info.audio_sample_size_bits = sample_size_bits;
info.audio_sample_rate_fixed = sample_rate_fixed;
}
} else if atom_type == b"stts" {
if let Some((sample_count, first_sample_duration)) =
ppc_qt_stts_sample_summary(data, content_start, atom_end)
{
info.sample_count = sample_count;
info.first_sample_duration = first_sample_duration;
}
} else if atom_type == b"stsc" {
if let Some((samples_per_chunk, sample_description_id)) =
ppc_qt_stsc_first_chunk(data, content_start, atom_end)
{
info.first_samples_per_chunk = samples_per_chunk;
info.sample_description_id = sample_description_id;
}
} else if atom_type == b"stsz" {
if let Some((sample_count, first_sample_size)) =
ppc_qt_stsz_sample_summary(data, content_start, atom_end)
{
if info.sample_count == 0 {
info.sample_count = sample_count;
}
info.first_sample_size = first_sample_size;
}
} else if atom_type == b"stco" {
if let Some(first_chunk_offset) =
ppc_qt_stco_first_offset(data, content_start, atom_end)
{
info.first_chunk_offset = first_chunk_offset;
}
} else if atom_type == b"co64" {
if let Some(first_chunk_offset) =
ppc_qt_co64_first_offset(data, content_start, atom_end)
{
info.first_chunk_offset = first_chunk_offset;
}
} else if ppc_qt_is_container_atom(atom_type) {
ppc_qt_collect_track_sample_info(data, content_start, atom_end, depth + 1, info)?;
}
if atom_end == end {
break;
}
offset = atom_end;
}
Some(())
}
fn ppc_qt_collect_video_sample_table_info(
data: &[u8],
start: usize,
end: usize,
depth: u8,
info: &mut PpcQuickTimeVideoSampleTableInfo,
) -> Option<()> {
if depth > 8 || start >= end || end > data.len() {
return Some(());
}
let mut offset = start;
while offset.checked_add(8)? <= end {
let (atom_type, content_start, atom_end) = ppc_qt_atom_range(data, offset, end)?;
if atom_type == b"hdlr" {
if let Some(subtype) = ppc_qt_hdlr_subtype(data, content_start, atom_end) {
if subtype == u32::from_be_bytes(*b"vide") {
info.handler_subtype = subtype;
}
}
} else if atom_type == b"mdhd" {
if let Some((time_scale, duration)) =
ppc_qt_mvhd_duration(data, content_start, atom_end)
{
info.media_time_scale = time_scale;
info.media_duration = duration;
}
} else if atom_type == b"stsd" {
if let Some(codec) = ppc_qt_stsd_first_codec(data, content_start, atom_end) {
info.codec = codec;
}
} else if atom_type == b"stts" {
if let Some(sample_durations) =
ppc_qt_stts_sample_durations(data, content_start, atom_end)
{
info.sample_durations = sample_durations;
}
} else if atom_type == b"stsc" {
if let Some(entries) = ppc_qt_stsc_entries(data, content_start, atom_end) {
info.stsc_entries = entries;
}
} else if atom_type == b"stsz" {
if let Some(sample_sizes) = ppc_qt_stsz_sample_sizes(data, content_start, atom_end) {
info.sample_sizes = sample_sizes;
}
} else if atom_type == b"stco" {
if let Some(offsets) = ppc_qt_stco_offsets(data, content_start, atom_end) {
info.chunk_offsets = offsets;
}
} else if atom_type == b"co64" {
if let Some(offsets) = ppc_qt_co64_offsets(data, content_start, atom_end) {
info.chunk_offsets = offsets;
}
} else if ppc_qt_is_container_atom(atom_type) {
ppc_qt_collect_video_sample_table_info(data, content_start, atom_end, depth + 1, info)?;
}
if atom_end == end {
break;
}
offset = atom_end;
}
Some(())
}
fn ppc_qt_collect_audio_decode_info(
data: &[u8],
start: usize,
end: usize,
depth: u8,
info: &mut PpcQuickTimeAudioDecodeInfo,
) -> Option<()> {
if depth > 8 || start >= end || end > data.len() {
return Some(());
}
let mut offset = start;
while offset.checked_add(8)? <= end {
let (atom_type, content_start, atom_end) = ppc_qt_atom_range(data, offset, end)?;
if atom_type == b"hdlr" {
if let Some(subtype) = ppc_qt_hdlr_subtype(data, content_start, atom_end) {
if subtype == u32::from_be_bytes(*b"soun") {
info.handler_subtype = subtype;
}
}
} else if atom_type == b"stsd" {
if let Some(codec) = ppc_qt_stsd_first_codec(data, content_start, atom_end) {
info.codec = codec;
}
if let Some((channel_count, sample_size_bits, sample_rate_fixed)) =
ppc_qt_stsd_first_sound_description(data, content_start, atom_end)
{
info.channel_count = channel_count;
info.sample_size_bits = sample_size_bits;
info.sample_rate_fixed = sample_rate_fixed;
}
} else if atom_type == b"stts" {
if let Some((sample_count, _first_sample_duration)) =
ppc_qt_stts_sample_summary(data, content_start, atom_end)
{
info.sample_count = sample_count;
}
} else if atom_type == b"stsz" {
if let Some((sample_count, _first_sample_size)) =
ppc_qt_stsz_sample_summary(data, content_start, atom_end)
{
if info.sample_count == 0 {
info.sample_count = sample_count;
}
}
} else if atom_type == b"stsc" {
if let Some(entries) = ppc_qt_stsc_entries(data, content_start, atom_end) {
info.stsc_entries = entries;
}
} else if atom_type == b"stco" {
if let Some(offsets) = ppc_qt_stco_offsets(data, content_start, atom_end) {
info.chunk_offsets = offsets;
}
} else if atom_type == b"co64" {
if let Some(offsets) = ppc_qt_co64_offsets(data, content_start, atom_end) {
info.chunk_offsets = offsets;
}
} else if ppc_qt_is_container_atom(atom_type) {
ppc_qt_collect_audio_decode_info(data, content_start, atom_end, depth + 1, info)?;
}
if atom_end == end {
break;
}
offset = atom_end;
}
Some(())
}
fn ppc_qt_collect_music_decode_info(
data: &[u8],
start: usize,
end: usize,
depth: u8,
info: &mut PpcQuickTimeMusicDecodeInfo,
) -> Option<()> {
if depth > 8 || start >= end || end > data.len() {
return Some(());
}
let mut offset = start;
while offset.checked_add(8)? <= end {
let (atom_type, content_start, atom_end) = ppc_qt_atom_range(data, offset, end)?;
if atom_type == b"hdlr" {
if let Some(subtype) = ppc_qt_hdlr_subtype(data, content_start, atom_end) {
if subtype == u32::from_be_bytes(*b"musi") {
info.handler_subtype = subtype;
}
}
} else if atom_type == b"mdhd" {
if let Some((time_scale, duration)) =
ppc_qt_mvhd_duration(data, content_start, atom_end)
{
info.media_time_scale = time_scale;
info.media_duration = duration;
}
} else if atom_type == b"stsd" {
if let Some(sample_descriptions) =
ppc_qt_music_sample_descriptions(data, content_start, atom_end)
{
info.sample_descriptions = sample_descriptions;
}
} else if atom_type == b"stts" {
if let Some(sample_durations) =
ppc_qt_stts_sample_durations(data, content_start, atom_end)
{
info.sample_durations = sample_durations;
}
} else if atom_type == b"stsz" {
if let Some(sample_sizes) = ppc_qt_stsz_sample_sizes(data, content_start, atom_end) {
info.sample_sizes = sample_sizes;
}
} else if atom_type == b"stsc" {
if let Some(entries) = ppc_qt_stsc_entries(data, content_start, atom_end) {
info.stsc_entries = entries;
}
} else if atom_type == b"stco" {
if let Some(offsets) = ppc_qt_stco_offsets(data, content_start, atom_end) {
info.chunk_offsets = offsets;
}
} else if atom_type == b"co64" {
if let Some(offsets) = ppc_qt_co64_offsets(data, content_start, atom_end) {
info.chunk_offsets = offsets;
}
} else if ppc_qt_is_container_atom(atom_type) {
ppc_qt_collect_music_decode_info(data, content_start, atom_end, depth + 1, info)?;
}
if atom_end == end {
break;
}
offset = atom_end;
}
Some(())
}
pub(crate) fn ppc_qt_music_sample_descriptions(
data: &[u8],
content_start: usize,
atom_end: usize,
) -> Option<Vec<Vec<PpcQuickTimeMusicPart>>> {
let entry_count = usize::try_from(ppc_read_be_u32_from_slice(data, content_start + 4)?).ok()?;
let maximum_entries = atom_end.checked_sub(content_start.checked_add(8)?)? / 16;
if entry_count > maximum_entries {
return None;
}
let mut entry_offset = content_start.checked_add(8)?;
let mut sample_descriptions = Vec::with_capacity(entry_count);
for _ in 0..entry_count {
let entry_size = usize::try_from(ppc_read_be_u32_from_slice(data, entry_offset)?).ok()?;
let entry_end = entry_offset.checked_add(entry_size)?;
if entry_size < 20 || entry_end > atom_end {
return None;
}
if data.get(entry_offset + 4..entry_offset + 8)? != b"musi" {
return None;
}
let mut parts = Vec::new();
let mut event_offset = entry_offset + 20;
while event_offset.checked_add(8)? <= entry_end {
let head = ppc_read_be_u32_from_slice(data, event_offset)?;
if head == 0 {
event_offset += 4;
continue;
}
if head >> 28 != 15 {
break;
}
let word_count = usize::try_from(head & 0xffff).ok()?;
let byte_count = word_count.checked_mul(4)?;
let event_end = event_offset.checked_add(byte_count)?;
if word_count < 2 || event_end > entry_end {
return None;
}
let tail = ppc_read_be_u32_from_slice(data, event_end - 4)?;
if tail >> 30 != 3 || tail & 0xffff != head & 0xffff {
return None;
}
let subtype = (tail >> 16) & 0x0fff;
if subtype == 1 && word_count >= 23 {
let request = event_offset + 4;
parts.push(PpcQuickTimeMusicPart {
part: ((head >> 16) & 0x0fff) as u16,
instrument_number: ppc_read_be_u32_from_slice(data, request + 76)?,
gm_number: ppc_read_be_u32_from_slice(data, request + 80)?,
});
}
event_offset = event_end;
}
sample_descriptions.push(parts);
entry_offset = entry_end;
}
Some(sample_descriptions)
}
fn ppc_qt_is_container_atom(atom_type: &[u8]) -> bool {
atom_type == b"moov"
|| atom_type == b"trak"
|| atom_type == b"mdia"
|| atom_type == b"minf"
|| atom_type == b"stbl"
|| atom_type == b"edts"
}
fn ppc_qt_hdlr_subtype(data: &[u8], content_start: usize, atom_end: usize) -> Option<u32> {
let subtype_offset = content_start.checked_add(8)?;
if subtype_offset.checked_add(4)? > atom_end {
return None;
}
Some(u32::from_be_bytes(
data.get(subtype_offset..subtype_offset + 4)?
.try_into()
.ok()?,
))
}
fn ppc_qt_stsd_first_codec(data: &[u8], content_start: usize, atom_end: usize) -> Option<u32> {
if content_start.checked_add(16)? > atom_end {
return None;
}
let entry_count = u32::from_be_bytes(
data.get(content_start + 4..content_start + 8)?
.try_into()
.ok()?,
);
if entry_count == 0 {
return None;
}
let entry_start = content_start + 8;
let entry_size = usize::try_from(u32::from_be_bytes(
data.get(entry_start..entry_start + 4)?.try_into().ok()?,
))
.ok()?;
if entry_size < 8 || entry_start.checked_add(entry_size)? > atom_end {
return None;
}
Some(u32::from_be_bytes(
data.get(entry_start + 4..entry_start + 8)?
.try_into()
.ok()?,
))
}
fn ppc_qt_stsd_first_sound_description(
data: &[u8],
content_start: usize,
atom_end: usize,
) -> Option<(u16, u16, u32)> {
if content_start.checked_add(16)? > atom_end {
return None;
}
let entry_count = u32::from_be_bytes(
data.get(content_start + 4..content_start + 8)?
.try_into()
.ok()?,
);
if entry_count == 0 {
return None;
}
let entry_start = content_start + 8;
let entry_size = usize::try_from(u32::from_be_bytes(
data.get(entry_start..entry_start + 4)?.try_into().ok()?,
))
.ok()?;
if entry_size < 36 || entry_start.checked_add(entry_size)? > atom_end {
return None;
}
let channel_count = u16::from_be_bytes(
data.get(entry_start + 24..entry_start + 26)?
.try_into()
.ok()?,
);
let sample_size_bits = u16::from_be_bytes(
data.get(entry_start + 26..entry_start + 28)?
.try_into()
.ok()?,
);
let sample_rate_fixed = u32::from_be_bytes(
data.get(entry_start + 32..entry_start + 36)?
.try_into()
.ok()?,
);
(channel_count != 0 && sample_size_bits != 0 && sample_rate_fixed != 0).then_some((
channel_count,
sample_size_bits,
sample_rate_fixed,
))
}
fn ppc_qt_stts_sample_summary(
data: &[u8],
content_start: usize,
atom_end: usize,
) -> Option<(u32, u32)> {
let entry_count = usize::try_from(u32::from_be_bytes(
data.get(content_start + 4..content_start + 8)?
.try_into()
.ok()?,
))
.ok()?;
if entry_count == 0 || entry_count > 1_000_000 {
return None;
}
let table_start = content_start.checked_add(8)?;
if table_start.checked_add(entry_count.checked_mul(8)?)? > atom_end {
return None;
}
let mut sample_count = 0u32;
let mut first_sample_duration = 0u32;
for entry in 0..entry_count {
let entry_start = table_start + entry * 8;
let count = u32::from_be_bytes(data.get(entry_start..entry_start + 4)?.try_into().ok()?);
let duration = u32::from_be_bytes(
data.get(entry_start + 4..entry_start + 8)?
.try_into()
.ok()?,
);
if count != 0 && duration != 0 && first_sample_duration == 0 {
first_sample_duration = duration;
}
sample_count = sample_count.saturating_add(count);
}
(sample_count != 0 && first_sample_duration != 0)
.then_some((sample_count, first_sample_duration))
}
fn ppc_qt_stsc_first_chunk(
data: &[u8],
content_start: usize,
atom_end: usize,
) -> Option<(u32, u32)> {
let entry_count = u32::from_be_bytes(
data.get(content_start + 4..content_start + 8)?
.try_into()
.ok()?,
);
if entry_count == 0 || content_start.checked_add(20)? > atom_end {
return None;
}
let first_chunk = u32::from_be_bytes(
data.get(content_start + 8..content_start + 12)?
.try_into()
.ok()?,
);
let samples_per_chunk = u32::from_be_bytes(
data.get(content_start + 12..content_start + 16)?
.try_into()
.ok()?,
);
let sample_description_id = u32::from_be_bytes(
data.get(content_start + 16..content_start + 20)?
.try_into()
.ok()?,
);
(first_chunk != 0 && samples_per_chunk != 0 && sample_description_id != 0)
.then_some((samples_per_chunk, sample_description_id))
}
pub(crate) fn ppc_qt_stsc_entries(
data: &[u8],
content_start: usize,
atom_end: usize,
) -> Option<Vec<PpcQuickTimeStscEntry>> {
let entry_count = usize::try_from(u32::from_be_bytes(
data.get(content_start + 4..content_start + 8)?
.try_into()
.ok()?,
))
.ok()?;
if entry_count == 0 || entry_count > 100_000 {
return None;
}
let table_start = content_start.checked_add(8)?;
if table_start.checked_add(entry_count.checked_mul(12)?)? > atom_end {
return None;
}
let mut entries: Vec<PpcQuickTimeStscEntry> = Vec::with_capacity(entry_count);
for entry in 0..entry_count {
let entry_start = table_start + entry * 12;
let first_chunk =
u32::from_be_bytes(data.get(entry_start..entry_start + 4)?.try_into().ok()?);
let samples_per_chunk = u32::from_be_bytes(
data.get(entry_start + 4..entry_start + 8)?
.try_into()
.ok()?,
);
let sample_description_id = u32::from_be_bytes(
data.get(entry_start + 8..entry_start + 12)?
.try_into()
.ok()?,
);
if first_chunk == 0
|| samples_per_chunk == 0
|| sample_description_id == 0
|| entries
.last()
.is_some_and(|previous| previous.first_chunk >= first_chunk)
{
return None;
}
entries.push(PpcQuickTimeStscEntry {
first_chunk,
samples_per_chunk,
sample_description_id,
});
}
Some(entries)
}
fn ppc_qt_stsz_sample_summary(
data: &[u8],
content_start: usize,
atom_end: usize,
) -> Option<(u32, u32)> {
if content_start.checked_add(12)? > atom_end {
return None;
}
let sample_size = u32::from_be_bytes(
data.get(content_start + 4..content_start + 8)?
.try_into()
.ok()?,
);
let sample_count = u32::from_be_bytes(
data.get(content_start + 8..content_start + 12)?
.try_into()
.ok()?,
);
if sample_count == 0 {
return None;
}
if sample_size != 0 {
return Some((sample_count, sample_size));
}
if content_start.checked_add(16)? > atom_end {
return None;
}
let first_size = u32::from_be_bytes(
data.get(content_start + 12..content_start + 16)?
.try_into()
.ok()?,
);
(first_size != 0).then_some((sample_count, first_size))
}
fn ppc_qt_stsz_sample_sizes(
data: &[u8],
content_start: usize,
atom_end: usize,
) -> Option<Vec<u32>> {
if content_start.checked_add(12)? > atom_end {
return None;
}
let sample_size = u32::from_be_bytes(
data.get(content_start + 4..content_start + 8)?
.try_into()
.ok()?,
);
let sample_count = usize::try_from(u32::from_be_bytes(
data.get(content_start + 8..content_start + 12)?
.try_into()
.ok()?,
))
.ok()?;
if sample_count == 0 || sample_count > 1_000_000 {
return None;
}
if sample_size != 0 {
return Some(vec![sample_size; sample_count]);
}
let table_start = content_start.checked_add(12)?;
if table_start.checked_add(sample_count.checked_mul(4)?)? > atom_end {
return None;
}
let mut sizes = Vec::with_capacity(sample_count);
for index in 0..sample_count {
let offset = table_start + index * 4;
let size = u32::from_be_bytes(data.get(offset..offset + 4)?.try_into().ok()?);
if size == 0 {
return None;
}
sizes.push(size);
}
Some(sizes)
}
pub(crate) fn ppc_qt_stts_sample_durations(
data: &[u8],
content_start: usize,
atom_end: usize,
) -> Option<Vec<u32>> {
if content_start.checked_add(8)? > atom_end {
return None;
}
let entry_count = usize::try_from(u32::from_be_bytes(
data.get(content_start + 4..content_start + 8)?
.try_into()
.ok()?,
))
.ok()?;
if entry_count == 0 || entry_count > 1_000_000 {
return None;
}
let table_start = content_start.checked_add(8)?;
if table_start.checked_add(entry_count.checked_mul(8)?)? > atom_end {
return None;
}
let mut durations = Vec::new();
for index in 0..entry_count {
let offset = table_start + index * 8;
let sample_count = usize::try_from(u32::from_be_bytes(
data.get(offset..offset + 4)?.try_into().ok()?,
))
.ok()?;
let sample_duration =
u32::from_be_bytes(data.get(offset + 4..offset + 8)?.try_into().ok()?);
if sample_count == 0 || sample_duration == 0 {
return None;
}
let new_len = durations.len().checked_add(sample_count)?;
if new_len > 1_000_000 {
return None;
}
durations.resize(new_len, sample_duration);
}
(!durations.is_empty()).then_some(durations)
}
fn ppc_qt_stco_first_offset(data: &[u8], content_start: usize, atom_end: usize) -> Option<u64> {
if content_start.checked_add(12)? > atom_end {
return None;
}
let entry_count = u32::from_be_bytes(
data.get(content_start + 4..content_start + 8)?
.try_into()
.ok()?,
);
if entry_count == 0 {
return None;
}
Some(u64::from(u32::from_be_bytes(
data.get(content_start + 8..content_start + 12)?
.try_into()
.ok()?,
)))
}
fn ppc_qt_stco_offsets(data: &[u8], content_start: usize, atom_end: usize) -> Option<Vec<u64>> {
let entry_count = usize::try_from(u32::from_be_bytes(
data.get(content_start + 4..content_start + 8)?
.try_into()
.ok()?,
))
.ok()?;
if entry_count == 0 || entry_count > 1_000_000 {
return None;
}
let table_start = content_start.checked_add(8)?;
if table_start.checked_add(entry_count.checked_mul(4)?)? > atom_end {
return None;
}
let mut offsets = Vec::with_capacity(entry_count);
for entry in 0..entry_count {
let entry_start = table_start + entry * 4;
offsets.push(u64::from(u32::from_be_bytes(
data.get(entry_start..entry_start + 4)?.try_into().ok()?,
)));
}
Some(offsets)
}
fn ppc_qt_co64_first_offset(data: &[u8], content_start: usize, atom_end: usize) -> Option<u64> {
if content_start.checked_add(16)? > atom_end {
return None;
}
let entry_count = u32::from_be_bytes(
data.get(content_start + 4..content_start + 8)?
.try_into()
.ok()?,
);
if entry_count == 0 {
return None;
}
Some(u64::from_be_bytes(
data.get(content_start + 8..content_start + 16)?
.try_into()
.ok()?,
))
}
fn ppc_qt_co64_offsets(data: &[u8], content_start: usize, atom_end: usize) -> Option<Vec<u64>> {
let entry_count = usize::try_from(u32::from_be_bytes(
data.get(content_start + 4..content_start + 8)?
.try_into()
.ok()?,
))
.ok()?;
if entry_count == 0 || entry_count > 1_000_000 {
return None;
}
let table_start = content_start.checked_add(8)?;
if table_start.checked_add(entry_count.checked_mul(8)?)? > atom_end {
return None;
}
let mut offsets = Vec::with_capacity(entry_count);
for entry in 0..entry_count {
let entry_start = table_start + entry * 8;
offsets.push(u64::from_be_bytes(
data.get(entry_start..entry_start + 8)?.try_into().ok()?,
));
}
Some(offsets)
}
fn ppc_qt_union_bounds(
lhs: Option<(i16, i16, i16, i16)>,
rhs: Option<(i16, i16, i16, i16)>,
) -> Option<(i16, i16, i16, i16)> {
match (lhs, rhs) {
(Some((top, left, bottom, right)), Some((rhs_top, rhs_left, rhs_bottom, rhs_right))) => {
Some((
top.min(rhs_top),
left.min(rhs_left),
bottom.max(rhs_bottom),
right.max(rhs_right),
))
}
(Some(bounds), None) | (None, Some(bounds)) => Some(bounds),
(None, None) => None,
}
}
fn ppc_qt_tkhd_bounds(
data: &[u8],
content_start: usize,
atom_end: usize,
) -> Option<(i16, i16, i16, i16)> {
let version = *data.get(content_start)?;
let dimensions_offset = match version {
0 => content_start.checked_add(76)?,
1 => content_start.checked_add(88)?,
_ => return None,
};
if dimensions_offset.checked_add(8)? > atom_end {
return None;
}
let width_fixed = u32::from_be_bytes(
data.get(dimensions_offset..dimensions_offset + 4)?
.try_into()
.ok()?,
);
let height_fixed = u32::from_be_bytes(
data.get(dimensions_offset + 4..dimensions_offset + 8)?
.try_into()
.ok()?,
);
let width = width_fixed >> 16;
let height = height_fixed >> 16;
if width == 0 || height == 0 || width > 8192 || height > 8192 {
return None;
}
Some((
0,
0,
i16::try_from(height).ok()?,
i16::try_from(width).ok()?,
))
}
fn ppc_qt_mvhd_duration(data: &[u8], content_start: usize, atom_end: usize) -> Option<(u32, u64)> {
let version = *data.get(content_start)?;
let (time_scale_offset, duration_offset, duration_size) = match version {
0 => (
content_start.checked_add(12)?,
content_start.checked_add(16)?,
4usize,
),
1 => (
content_start.checked_add(20)?,
content_start.checked_add(24)?,
8usize,
),
_ => return None,
};
if time_scale_offset.checked_add(4)? > atom_end
|| duration_offset.checked_add(duration_size)? > atom_end
{
return None;
}
let time_scale = u32::from_be_bytes(
data.get(time_scale_offset..time_scale_offset + 4)?
.try_into()
.ok()?,
);
let duration = if duration_size == 4 {
u64::from(u32::from_be_bytes(
data.get(duration_offset..duration_offset + 4)?
.try_into()
.ok()?,
))
} else {
u64::from_be_bytes(
data.get(duration_offset..duration_offset + 8)?
.try_into()
.ok()?,
)
};
if time_scale == 0 || duration == 0 {
return None;
}
Some((time_scale, duration))
}
fn ppc_qt_mvhd_preferred_rate(data: &[u8], content_start: usize, atom_end: usize) -> Option<i32> {
let offset = match *data.get(content_start)? {
0 => content_start.checked_add(20)?,
1 => content_start.checked_add(32)?,
_ => return None,
};
if offset.checked_add(4)? > atom_end {
return None;
}
Some(i32::from_be_bytes(
data.get(offset..offset + 4)?.try_into().ok()?,
))
}
fn ppc_qt_mvhd_preferred_volume(data: &[u8], content_start: usize, atom_end: usize) -> Option<i16> {
let offset = match *data.get(content_start)? {
0 => content_start.checked_add(24)?,
1 => content_start.checked_add(36)?,
_ => return None,
};
if offset.checked_add(2)? > atom_end {
return None;
}
Some(i16::from_be_bytes(
data.get(offset..offset + 2)?.try_into().ok()?,
))
}
fn ppc_qt_movie_tasks_until_done(time_scale: u32, duration: u64) -> u32 {
if time_scale == 0 || duration == 0 {
return PPC_QT_FALLBACK_MOVIE_TASKS_UNTIL_DONE;
}
let numerator = duration
.saturating_mul(PPC_QT_MOVIE_TASKS_PER_SECOND)
.saturating_add(u64::from(time_scale).saturating_sub(1));
let tasks = numerator / u64::from(time_scale);
u32::try_from(tasks.max(1)).unwrap_or(u32::MAX)
}
pub(crate) fn ppc_qt_draw_pict_source_to_16bpp(
memory: &mut PpcSectionMem,
front_buffer: PpcFrontBuffer,
data: &[u8],
) -> bool {
let Some((_pict_offset, (top, left, bottom, right))) =
ppc_qt_pict_record_offset_and_bounds(data)
else {
return false;
};
let natural_width = u32::try_from(i32::from(right) - i32::from(left)).unwrap_or(0);
let natural_height = u32::try_from(i32::from(bottom) - i32::from(top)).unwrap_or(0);
if natural_width == 0 || natural_height == 0 {
return false;
}
let dst_bottom = i16::try_from(natural_height.min(front_buffer.height)).unwrap_or(i16::MAX);
let dst_right = i16::try_from(natural_width.min(front_buffer.width)).unwrap_or(i16::MAX);
ppc_draw_pict_bytes_to_16bpp(
memory,
front_buffer,
data,
(0, 0, dst_bottom, dst_right),
&TrapDispatcher::standard_mac_8bpp_clut(),
0,
false,
)
}
pub(crate) fn ppc_qt_new_movie_from_file(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
vfs_files: &[PpcVfsFileRecord],
vfs_resource_files: &[PpcVfsResourceFileRecord],
vfs_resources: &[PpcVfsResourceRecord],
quicktime: &mut PpcQuickTimeState,
sound: &mut PpcSoundState,
) -> i16 {
let movie_out_ptr = cpu.gpr[3];
let res_id_ptr = cpu.gpr[5];
let data_ref_was_changed_ptr = cpu.gpr[8];
if movie_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, movie_out_ptr, 4) {
return PPC_PARAM_ERR;
}
if res_id_ptr != 0 && !ppc_memory_can_write_bytes(memory, res_id_ptr, 2) {
return PPC_PARAM_ERR;
}
if data_ref_was_changed_ptr != 0
&& !ppc_memory_can_write_bytes(memory, data_ref_was_changed_ptr, 1)
{
return PPC_PARAM_ERR;
}
if memory.write_u32_be(movie_out_ptr, 0).is_none() {
return PPC_PARAM_ERR;
}
let requested_res_id = if res_id_ptr == 0 {
None
} else {
Some(memory.read_u16_be(res_id_ptr).unwrap_or(0) as i16)
};
if res_id_ptr != 0 && memory.write_u16_be(res_id_ptr, 0).is_none() {
return PPC_PARAM_ERR;
}
ppc_qt_stop_movie_audio(sound);
let ref_num = cpu.gpr[4] as i16;
if ref_num != 0 && ref_num == quicktime.movie_file_ref_num {
let mut selected_data = vfs_files
.iter()
.find(|file| file.path.eq_ignore_ascii_case(&quicktime.movie_file_path))
.map(|file| file.data.to_vec())
.unwrap_or_else(|| quicktime.movie_file_data.clone());
let Some(selected_res_id) = ppc_qt_append_movie_resource(
&mut selected_data,
vfs_resource_files,
vfs_resources,
&quicktime.movie_file_path,
requested_res_id,
) else {
return PPC_RES_NOT_FOUND_ERR;
};
quicktime.movie_file_data = selected_data;
quicktime.movie_file_sample_fork = None;
ppc_qt_refresh_open_movie_metadata(quicktime);
if res_id_ptr != 0
&& memory
.write_u16_be(res_id_ptr, selected_res_id as u16)
.is_none()
{
return PPC_PARAM_ERR;
}
if let Some(bounds) = quicktime.movie_file_bounds {
quicktime.movie_box = bounds;
}
quicktime.movie_tasks_until_done = quicktime.movie_file_tasks_until_done;
quicktime.movie_video_track = quicktime.movie_file_video_track;
quicktime.movie_video_samples = quicktime.movie_file_video_samples.clone();
quicktime.movie_audio_track = quicktime.movie_file_audio_track;
quicktime.movie_tracks = quicktime.movie_file_tracks.clone();
quicktime.movie_time_scale = if quicktime.movie_file_time_scale == 0 {
600
} else {
quicktime.movie_file_time_scale
};
quicktime.movie_preferred_rate = quicktime.movie_file_preferred_rate;
quicktime.movie_preferred_volume = quicktime.movie_file_preferred_volume;
quicktime.movie_volume = quicktime.movie_preferred_volume;
} else {
quicktime.movie_tasks_until_done = PPC_QT_FALLBACK_MOVIE_TASKS_UNTIL_DONE;
quicktime.movie_video_track = None;
quicktime.movie_video_samples = None;
quicktime.movie_audio_track = None;
quicktime.movie_tracks.clear();
quicktime.movie_time_scale = 600;
quicktime.movie_preferred_rate = 0x0001_0000;
quicktime.movie_preferred_volume = 0x0100;
quicktime.movie_volume = 0x0100;
}
if memory.write_u32_be(movie_out_ptr, PPC_QT_MOVIE).is_none() {
return PPC_PARAM_ERR;
}
if data_ref_was_changed_ptr != 0 && memory.write_u8(data_ref_was_changed_ptr, 0).is_none() {
return PPC_PARAM_ERR;
}
quicktime.movie_started = false;
quicktime.movie_active = cpu.gpr[7] & 1 != 0;
quicktime.movie_task_count = 0;
quicktime.movie_active_segment = None;
quicktime.movie_task_fraction = 0;
quicktime.movie_clock_remainder = 0;
quicktime.movie_disposed = false;
quicktime.movie_controllers.clear();
quicktime.movie_at_beginning = true;
ppc_qt_reset_movie_video_decode_cache(quicktime);
ppc_qt_reset_movie_toolbox_state(quicktime);
PPC_NO_ERR
}
pub(crate) fn ppc_qt_open_movie_file(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
vfs_directories: &[PpcVfsDirectory],
vfs_files: &[PpcVfsFileRecord],
quicktime: &mut PpcQuickTimeState,
) -> i16 {
let spec_ptr = cpu.gpr[3];
let ref_num_out_ptr = cpu.gpr[4];
if ref_num_out_ptr == 0 || !ppc_memory_can_write_bytes(memory, ref_num_out_ptr, 2) {
return PPC_PARAM_ERR;
}
let mut movie_file_path = String::new();
let mut movie_file_data = Vec::new();
let mut movie_file_bounds = None;
let mut movie_file_time_scale = 0;
let mut movie_file_duration = 0;
let mut movie_file_preferred_rate = 0x0001_0000;
let mut movie_file_preferred_volume = 0x0100;
let mut movie_file_tasks_until_done = PPC_QT_FALLBACK_MOVIE_TASKS_UNTIL_DONE;
let mut movie_file_video_track = None;
let mut movie_file_video_samples = None;
let mut movie_file_audio_track = None;
let mut movie_file_tracks = Vec::new();
if spec_ptr != 0 {
if let Ok(path) =
ppc_existing_path_for_fsspec(memory, vfs_directories, vfs_files, &[], spec_ptr)
{
if let Some(file) = vfs_files
.iter()
.find(|record| record.path.eq_ignore_ascii_case(&path))
{
movie_file_path = path;
movie_file_data = file.data.to_vec();
movie_file_bounds = ppc_qt_movie_bounds(&movie_file_data);
movie_file_video_track = ppc_qt_movie_first_video_track(&movie_file_data);
movie_file_video_samples = ppc_qt_movie_video_samples(&movie_file_data);
movie_file_audio_track = ppc_qt_movie_first_audio_track(&movie_file_data);
movie_file_tracks = ppc_qt_movie_tracks(&movie_file_data);
movie_file_preferred_rate =
ppc_qt_movie_preferred_rate(&movie_file_data).unwrap_or(0x0001_0000);
movie_file_preferred_volume =
ppc_qt_movie_preferred_volume(&movie_file_data).unwrap_or(0x0100);
if let Some((time_scale, duration)) = ppc_qt_movie_duration(&movie_file_data) {
movie_file_time_scale = time_scale;
movie_file_duration = duration;
movie_file_tasks_until_done =
ppc_qt_movie_tasks_until_done(time_scale, duration);
}
}
}
}
if memory
.write_u16_be(ref_num_out_ptr, PPC_FIRST_FILE_REF_NUM as u16)
.is_none()
{
return PPC_PARAM_ERR;
}
quicktime.movie_file_open_count = quicktime.movie_file_open_count.saturating_add(1);
quicktime.movie_file_ref_num = PPC_FIRST_FILE_REF_NUM;
quicktime.movie_file_path = movie_file_path;
quicktime.movie_file_data = movie_file_data;
quicktime.movie_file_sample_fork = None;
quicktime.movie_file_bounds = movie_file_bounds;
quicktime.movie_file_time_scale = movie_file_time_scale;
quicktime.movie_file_duration = movie_file_duration;
quicktime.movie_file_preferred_rate = movie_file_preferred_rate;
quicktime.movie_file_preferred_volume = movie_file_preferred_volume;
quicktime.movie_file_tasks_until_done = movie_file_tasks_until_done;
quicktime.movie_file_video_track = movie_file_video_track;
quicktime.movie_file_video_samples = movie_file_video_samples;
quicktime.movie_file_audio_track = movie_file_audio_track;
quicktime.movie_file_tracks = movie_file_tracks;
if qt_trace_enabled() {
let video = quicktime
.movie_file_video_samples
.as_ref()
.map(|samples| {
format!(
"{} samples={} duration={}",
format_ppc_fourcc(samples.codec),
samples.sample_count,
samples.media_duration
)
})
.unwrap_or_else(|| "none".to_string());
eprintln!(
"[QT-TRACE] OpenMovieFile path='{}' data_len={} bounds={:?} time_scale={} duration={} tasks_until_done={} video={}",
quicktime.movie_file_path,
quicktime.movie_file_data.len(),
quicktime.movie_file_bounds,
quicktime.movie_file_time_scale,
quicktime.movie_file_duration,
quicktime.movie_file_tasks_until_done,
video
);
}
PPC_NO_ERR
}
pub(crate) fn ppc_qt_append_movie_resource(
movie_file_data: &mut Vec<u8>,
vfs_resource_files: &[PpcVfsResourceFileRecord],
vfs_resources: &[PpcVfsResourceRecord],
path: &str,
requested_res_id: Option<i16>,
) -> Option<i16> {
if matches!(requested_res_id, None | Some(0) | Some(-1))
&& ppc_qt_aiff_audio_track(movie_file_data).is_some()
{
return Some(-1);
}
let data_movie_range = ppc_qt_top_level_atom_offsets(movie_file_data, b"moov");
if data_movie_range.is_some() && !matches!(requested_res_id, Some(1..=i16::MAX)) {
return requested_res_id
.map_or(true, |res_id| res_id == 0 || res_id == -1)
.then_some(-1);
}
if requested_res_id == Some(-1) {
return None;
}
let moov_type = u32::from_be_bytes(*b"moov");
let resource = vfs_resources
.iter()
.filter(|resource| {
resource.path.eq_ignore_ascii_case(path) && resource.res_type == moov_type
})
.find(|resource| requested_res_id.map_or(true, |id| id == 0 || resource.res_id == id))
.map(|resource| (resource.res_id, resource.data.clone()))
.or_else(|| {
let raw_data = vfs_resource_files
.iter()
.find(|file| file.path.eq_ignore_ascii_case(path))?
.raw_data
.as_ref()?;
let fork = ResourceFork::parse(raw_data)?;
fork.resources()
.values()
.filter(|resource| resource.res_type == *b"moov")
.filter(|resource| requested_res_id.map_or(true, |id| id == 0 || resource.id == id))
.min_by_key(|resource| resource.id)
.map(|resource| (resource.id, resource.data.clone().into()))
});
let Some((res_id, resource_data)) = resource else {
return None;
};
if let Some((atom_type, _, atom_end)) =
ppc_qt_atom_range(&resource_data, 0, resource_data.len())
{
if atom_type == b"moov" && atom_end == resource_data.len() {
if let Some((start, end)) = data_movie_range {
movie_file_data.drain(start..end);
}
movie_file_data.extend_from_slice(&resource_data);
return Some(res_id);
}
}
None
}
fn ppc_qt_top_level_atom_offsets(data: &[u8], expected_type: &[u8; 4]) -> Option<(usize, usize)> {
let mut offset = 0usize;
while offset.checked_add(8)? <= data.len() {
let (atom_type, _, atom_end) = ppc_qt_atom_range(data, offset, data.len())?;
if atom_type == expected_type {
return Some((offset, atom_end));
}
if atom_end == data.len() {
break;
}
offset = atom_end;
}
None
}
fn ppc_qt_refresh_open_movie_metadata(quicktime: &mut PpcQuickTimeState) {
quicktime.movie_file_bounds = None;
quicktime.movie_file_time_scale = 0;
quicktime.movie_file_duration = 0;
quicktime.movie_file_preferred_rate = 0x0001_0000;
quicktime.movie_file_preferred_volume = 0x0100;
quicktime.movie_file_tasks_until_done = PPC_QT_FALLBACK_MOVIE_TASKS_UNTIL_DONE;
quicktime.movie_file_video_track = None;
quicktime.movie_file_video_samples = None;
quicktime.movie_file_audio_track = None;
quicktime.movie_file_tracks.clear();
quicktime.movie_file_bounds = ppc_qt_movie_bounds(&quicktime.movie_file_data);
quicktime.movie_file_video_track = ppc_qt_movie_first_video_track(&quicktime.movie_file_data);
quicktime.movie_file_video_samples = ppc_qt_movie_video_samples(&quicktime.movie_file_data);
quicktime.movie_file_audio_track = ppc_qt_movie_first_audio_track(&quicktime.movie_file_data);
quicktime.movie_file_tracks = ppc_qt_movie_tracks(&quicktime.movie_file_data);
quicktime.movie_file_preferred_rate =
ppc_qt_movie_preferred_rate(&quicktime.movie_file_data).unwrap_or(0x0001_0000);
quicktime.movie_file_preferred_volume =
ppc_qt_movie_preferred_volume(&quicktime.movie_file_data).unwrap_or(0x0100);
if let Some((time_scale, duration)) = ppc_qt_movie_duration(&quicktime.movie_file_data) {
quicktime.movie_file_time_scale = time_scale;
quicktime.movie_file_duration = duration;
quicktime.movie_file_tasks_until_done = ppc_qt_movie_tasks_until_done(time_scale, duration);
}
}
#[cfg(test)]
pub(crate) fn ppc_qt_top_level_atom<'a>(
data: &'a [u8],
expected_type: &[u8; 4],
) -> Option<&'a [u8]> {
let mut offset = 0usize;
while offset.checked_add(8)? <= data.len() {
let (atom_type, _, atom_end) = ppc_qt_atom_range(data, offset, data.len())?;
if atom_type == expected_type {
return data.get(offset..atom_end);
}
if atom_end == data.len() {
break;
}
offset = atom_end;
}
None
}
pub(crate) fn ppc_qt_close_movie_file(cpu: &mut PpcCpu, quicktime: &mut PpcQuickTimeState) -> i16 {
let ref_num = cpu.gpr[3] as i16;
if ref_num == 0 {
return PPC_PARAM_ERR;
}
quicktime.movie_file_close_count = quicktime.movie_file_close_count.saturating_add(1);
quicktime.movie_file_last_closed_ref_num = ref_num;
if quicktime.movie_file_ref_num == ref_num {
quicktime.movie_file_ref_num = 0;
}
PPC_NO_ERR
}
pub(crate) fn ppc_qt_set_movie_gworld(cpu: &mut PpcCpu, quicktime: &mut PpcQuickTimeState) -> i16 {
if cpu.gpr[3] != PPC_QT_MOVIE || quicktime.movie_disposed {
return PPC_PARAM_ERR;
}
quicktime.movie_gworld = cpu.gpr[4];
quicktime.movie_gdevice = cpu.gpr[5];
PPC_NO_ERR
}
pub(crate) fn ppc_qt_set_movie_box(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
quicktime: &mut PpcQuickTimeState,
) -> i16 {
if cpu.gpr[3] != PPC_QT_MOVIE || quicktime.movie_disposed {
return PPC_PARAM_ERR;
}
let box_ptr = cpu.gpr[4];
let Some(rect) = ppc_read_rect(memory, box_ptr) else {
return PPC_PARAM_ERR;
};
if !toolbox::ppc_qt_resize_movie_matrix(quicktime, rect) {
return PPC_PARAM_ERR;
}
quicktime.movie_box = rect;
quicktime.movie_set_box_count = quicktime.movie_set_box_count.saturating_add(1);
PPC_NO_ERR
}
pub(crate) fn ppc_qt_get_movie_box(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
quicktime: &PpcQuickTimeState,
) -> i16 {
if cpu.gpr[3] != PPC_QT_MOVIE || quicktime.movie_disposed {
return PPC_PARAM_ERR;
}
if cpu.gpr[4] == 0 || !ppc_memory_can_write_bytes(memory, cpu.gpr[4], 8) {
return PPC_PARAM_ERR;
}
let (top, left, bottom, right) = quicktime.movie_box;
if ppc_write_rect(memory, cpu.gpr[4], top, left, bottom, right).is_none() {
return PPC_PARAM_ERR;
}
PPC_NO_ERR
}
pub(crate) fn ppc_qt_go_to_beginning_of_movie(
cpu: &mut PpcCpu,
quicktime: &mut PpcQuickTimeState,
sound: &mut PpcSoundState,
) -> i16 {
if cpu.gpr[3] != PPC_QT_MOVIE || quicktime.movie_disposed {
return PPC_PARAM_ERR;
}
quicktime.movie_beginning_count = quicktime.movie_beginning_count.saturating_add(1);
quicktime.movie_started = false;
let start = quicktime
.movie_active_segment
.map_or(0, |segment| u64::from(segment.0));
ppc_qt_seek_movie(quicktime, sound, start);
quicktime.movie_at_beginning = true;
PPC_NO_ERR
}
pub(crate) fn ppc_qt_go_to_end_of_movie(
cpu: &mut PpcCpu,
quicktime: &mut PpcQuickTimeState,
sound: &mut PpcSoundState,
) -> i16 {
if cpu.gpr[3] != PPC_QT_MOVIE || quicktime.movie_disposed {
return PPC_PARAM_ERR;
}
quicktime.movie_started = false;
let end = quicktime.movie_active_segment.map_or_else(
|| ppc_qt_movie_duration_value(quicktime),
|segment| u64::from(segment.0) + u64::from(segment.1),
);
ppc_qt_seek_movie(quicktime, sound, end);
quicktime.movie_at_beginning = false;
PPC_NO_ERR
}
pub(crate) fn ppc_qt_get_movie_duration(
cpu: &mut PpcCpu,
quicktime: &PpcQuickTimeState,
) -> (i16, u32) {
if cpu.gpr[3] != PPC_QT_MOVIE || quicktime.movie_disposed {
return (PPC_PARAM_ERR, 0);
}
let duration = ppc_qt_movie_duration_value(quicktime).min(u64::from(u32::MAX)) as u32;
(PPC_NO_ERR, duration)
}
pub(crate) fn ppc_qt_load_movie_into_ram(cpu: &mut PpcCpu, quicktime: &PpcQuickTimeState) -> i16 {
if cpu.gpr[3] != PPC_QT_MOVIE || quicktime.movie_disposed {
return PPC_PARAM_ERR;
}
PPC_NO_ERR
}
pub(crate) fn ppc_qt_start_movie(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
quicktime: &mut PpcQuickTimeState,
sound: &mut PpcSoundState,
) -> i16 {
let rate = quicktime.movie_preferred_rate;
ppc_qt_set_movie_rate(cpu, memory, gworlds, current_gworld, quicktime, sound, rate)
}
fn ppc_qt_seek_movie(quicktime: &mut PpcQuickTimeState, sound: &mut PpcSoundState, time: u64) {
let duration = ppc_qt_movie_duration_value(quicktime);
let tasks = u64::from(quicktime.movie_tasks_until_done.max(1));
let time = time.min(duration);
let before = super::dispatch_quicktime::quicktime_callback_time(quicktime);
let position =
(u128::from(time) * u128::from(tasks) * 65536 / u128::from(duration.max(1))) as u64;
quicktime.movie_task_count = (position >> 16) as u32;
quicktime.movie_task_fraction = position as u16;
quicktime.movie_clock_remainder = 0;
quicktime.movie_at_beginning = time == 0;
ppc_qt_reset_movie_video_decode_cache(quicktime);
ppc_qt_stop_movie_audio(sound);
if quicktime.movie_started && quicktime.movie_active {
let _ = ppc_qt_start_movie_audio(quicktime, sound);
}
if before != super::dispatch_quicktime::quicktime_callback_time(quicktime) {
quicktime
.callbacks
.mark_event(PPC_QT_TIME_BASE, callbacks::Event::Jump);
}
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn ppc_qt_set_movie_rate(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
quicktime: &mut PpcQuickTimeState,
sound: &mut PpcSoundState,
rate: i32,
) -> i16 {
if cpu.gpr[3] != PPC_QT_MOVIE || quicktime.movie_disposed {
return PPC_PARAM_ERR;
}
quicktime.movie_playback_rate = rate;
if rate == 0 {
return ppc_qt_stop_movie(cpu, quicktime, sound);
}
if let Some((start, length)) = quicktime.movie_active_segment {
let time = super::dispatch_quicktime::quicktime_callback_time(quicktime).max(0) as u64;
let start = u64::from(start);
let stop = start + u64::from(length);
if time < start || time > stop {
ppc_qt_seek_movie(quicktime, sound, time.clamp(start, stop));
}
}
quicktime.movie_started = true;
quicktime.movie_at_beginning = false;
if !quicktime.movie_active {
return PPC_NO_ERR;
}
let audio_started = ppc_qt_start_movie_audio(quicktime, sound);
let cache_before = quicktime
.movie_video_decode_cache
.as_ref()
.map(|cache| cache.sample_index);
let drawn = ppc_qt_draw_movie_frame(memory, gworlds, current_gworld, quicktime, 0x21);
if qt_trace_enabled() {
let cache_after = quicktime
.movie_video_decode_cache
.as_ref()
.map(|cache| cache.sample_index);
eprintln!(
"[QT-TRACE] StartMovie path='{}' task_count={} drawn={} decoded={} audio={} cache_before={:?} cache_after={:?}",
quicktime.movie_file_path,
quicktime.movie_task_count,
drawn,
cache_after.is_some() && cache_after != cache_before,
audio_started,
cache_before,
cache_after
);
}
PPC_NO_ERR
}
pub(crate) fn ppc_qt_stop_movie(
cpu: &mut PpcCpu,
quicktime: &mut PpcQuickTimeState,
sound: &mut PpcSoundState,
) -> i16 {
if cpu.gpr[3] != PPC_QT_MOVIE || quicktime.movie_disposed {
return PPC_PARAM_ERR;
}
quicktime.movie_started = false;
ppc_qt_stop_movie_audio(sound);
PPC_NO_ERR
}
pub(crate) fn ppc_qt_service_clock(
quicktime: &mut PpcQuickTimeState,
sound: &mut PpcSoundState,
now: u64,
) {
let Some(previous) = quicktime.movie_clock_subtick.replace(now) else {
return;
};
quicktime.movie_clock_subtick = Some(now.max(previous));
if !quicktime.movie_started || !quicktime.movie_active || quicktime.movie_disposed {
return;
}
let elapsed = now.saturating_sub(previous);
if elapsed == 0 {
return;
}
let before = super::dispatch_quicktime::quicktime_callback_time(quicktime);
let rate = quicktime.movie_playback_rate;
let duration = i128::from(ppc_qt_movie_duration_value(quicktime).max(1));
let tasks = i128::from(quicktime.movie_tasks_until_done.max(1));
let denominator = 60 * i128::from(crate::time_manager::SUBTICKS_PER_TICK) * duration;
let numerator = i128::from(elapsed)
.saturating_mul(i128::from(quicktime.movie_time_scale.max(1)))
.saturating_mul(tasks)
.saturating_mul(i128::from(rate))
.saturating_add(quicktime.movie_clock_remainder);
let delta = numerator / denominator;
quicktime.movie_clock_remainder = numerator % denominator;
let limit = tasks << 16;
let (start, stop) = quicktime
.movie_active_segment
.map_or((0, limit), |(start, length)| {
let stop = i128::from(u64::from(start) + u64::from(length)) * limit / duration;
let start = i128::from(start) * limit / duration;
(start.clamp(0, limit), stop.clamp(0, limit))
});
let position = ((i128::from(quicktime.movie_task_count) << 16)
+ i128::from(quicktime.movie_task_fraction))
.saturating_add(delta)
.clamp(start, stop);
quicktime.movie_task_count = (position >> 16) as u32;
quicktime.movie_task_fraction = position as u16;
quicktime.movie_at_beginning = position == start;
let after = super::dispatch_quicktime::quicktime_callback_time(quicktime);
quicktime
.callbacks
.mark_time_due(PPC_QT_TIME_BASE, before, after, quicktime.movie_time_scale);
if (rate > 0 && position == stop) || (rate < 0 && position == start) {
quicktime.movie_started = false;
quicktime.movie_clock_remainder = 0;
ppc_qt_stop_movie_audio(sound);
quicktime.callbacks.mark_event(
PPC_QT_TIME_BASE,
callbacks::Event::Rate {
before: rate,
after: 0,
},
);
quicktime.callbacks.mark_event(
PPC_QT_TIME_BASE,
callbacks::Event::Extremes {
start: position == start,
stop: position == stop,
},
);
}
}
pub(crate) fn ppc_qt_movie_position_in_scale(quicktime: &PpcQuickTimeState, duration: u64) -> u64 {
let limit = u128::from(quicktime.movie_tasks_until_done.max(1)) << 16;
let position = ((u128::from(quicktime.movie_task_count) << 16)
+ u128::from(quicktime.movie_task_fraction))
.min(limit);
(position * u128::from(duration) / limit) as u64
}
pub(crate) fn ppc_qt_movies_task(
cpu: &mut PpcCpu,
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
quicktime: &mut PpcQuickTimeState,
_sound: &mut PpcSoundState,
) -> i16 {
if cpu.gpr[3] != PPC_QT_MOVIE || quicktime.movie_disposed {
return PPC_PARAM_ERR;
}
if !quicktime.movie_active {
return PPC_NO_ERR;
}
{
quicktime.movie_at_beginning =
quicktime.movie_task_count == 0 && quicktime.movie_task_fraction == 0;
let cache_before = quicktime
.movie_video_decode_cache
.as_ref()
.map(|cache| cache.sample_index);
let drawn = ppc_qt_draw_movie_frame(
memory,
gworlds,
current_gworld,
quicktime,
0x30u32.saturating_add(quicktime.movie_task_count),
);
if qt_trace_enabled() {
let cache_after = quicktime
.movie_video_decode_cache
.as_ref()
.map(|cache| cache.sample_index);
eprintln!(
"[QT-TRACE] MoviesTask path='{}' task_count={} drawn={} decoded={} cache_before={:?} cache_after={:?}",
quicktime.movie_file_path,
quicktime.movie_task_count,
drawn,
cache_after.is_some() && cache_after != cache_before,
cache_before,
cache_after
);
}
}
PPC_NO_ERR
}
pub(crate) fn ppc_qt_is_movie_done(cpu: &mut PpcCpu, quicktime: &PpcQuickTimeState) -> (i16, bool) {
if cpu.gpr[3] != PPC_QT_MOVIE || quicktime.movie_disposed {
return (PPC_PARAM_ERR, true);
}
(
PPC_NO_ERR,
!quicktime.movie_started
|| quicktime.movie_task_count >= quicktime.movie_tasks_until_done.max(1),
)
}
pub(crate) fn ppc_qt_dispose_movie(
cpu: &mut PpcCpu,
quicktime: &mut PpcQuickTimeState,
sound: &mut PpcSoundState,
) -> i16 {
if cpu.gpr[3] != PPC_QT_MOVIE {
return PPC_PARAM_ERR;
}
quicktime.movie_started = false;
quicktime.movie_disposed = true;
quicktime.movie_controllers.clear();
quicktime.movie_active = false;
quicktime.movie_video_track = None;
quicktime.movie_video_samples = None;
quicktime.movie_video_decode_cache = None;
quicktime.movie_audio_track = None;
quicktime.movie_tracks.clear();
ppc_qt_stop_movie_audio(sound);
PPC_NO_ERR
}
pub(crate) fn ppc_qt_reset_movie_video_decode_cache(quicktime: &mut PpcQuickTimeState) {
quicktime.movie_video_decode_cache = None;
}
pub(crate) fn ppc_qt_start_movie_audio(
quicktime: &PpcQuickTimeState,
sound: &mut PpcSoundState,
) -> bool {
ppc_qt_stop_movie_audio(sound);
let Some(decoded_sound) = ppc_qt_decode_movie_audio_samples(quicktime) else {
return false;
};
let Some(file_playback_index) = u32::try_from(sound.file_playbacks.len()).ok() else {
return false;
};
let source_rate = decoded_sound.summary.sample_rate_fixed;
let time = super::dispatch_quicktime::quicktime_callback_time(quicktime).max(0) as u64;
let offset = ((u128::from(time) * u128::from(source_rate))
/ (u128::from(quicktime.movie_time_scale.max(1)) << 16))
.min(decoded_sound.samples.len() as u128) as usize;
let mut samples = decoded_sound.samples;
if quicktime.movie_playback_rate < 0 {
samples.truncate(offset);
samples.reverse();
} else {
samples.drain(..offset);
}
let rate = ((u64::from(source_rate) * u64::from(quicktime.movie_playback_rate.unsigned_abs()))
>> 16)
.min(u64::from(u32::MAX)) as u32;
if rate == 0 || samples.is_empty() {
return false;
}
let Some(decoded_sound) = ppc_decoded_sound_data(samples, rate) else {
return false;
};
let summary = decoded_sound.summary;
let samples = decoded_sound.samples;
if qt_trace_enabled() {
let non_silent = samples.iter().filter(|sample| **sample != 0x80).count();
let first_non_silent = samples.iter().position(|sample| *sample != 0x80);
let last_non_silent = samples.iter().rposition(|sample| *sample != 0x80);
eprintln!(
"[QT-TRACE] MovieAudio samples={} non_silent={} first={:?} last={:?} rate={}",
samples.len(),
non_silent,
first_non_silent,
last_non_silent,
summary.sample_rate_fixed
);
}
sound.manager.play_file_buffer(
PPC_QT_MOVIE,
samples.clone(),
summary.sample_rate_fixed,
None,
);
sound
.decoded_file_playbacks
.push(PpcDecodedAiffPlaybackRecord {
file_playback_index,
channel: PPC_QT_MOVIE,
sample_rate_fixed: summary.sample_rate_fixed,
samples,
});
sound.file_playbacks.push(PpcSoundFilePlaybackRecord {
channel: PPC_QT_MOVIE,
ref_num: quicktime.movie_file_ref_num,
resource_id: 0,
buffer_size: 0,
buffer: 0,
selection: 0,
completion: 0,
completion_command: None,
async_play: false,
aiff: None,
decoded_aiff: Some(summary),
});
true
}
fn ppc_qt_stop_movie_audio(sound: &mut PpcSoundState) {
sound.manager.quiet_channel(PPC_QT_MOVIE);
}
pub(crate) fn ppc_qt_decode_movie_audio_samples(
quicktime: &PpcQuickTimeState,
) -> Option<PpcDecodedAiffData> {
let sample_data = quicktime
.movie_file_sample_fork
.as_ref()
.map(|fork| fork.as_slice())
.unwrap_or(&quicktime.movie_file_data);
if let Some(decoded) = ppc_qt_movie_audio_samples(sample_data) {
return Some(decoded);
}
let track = quicktime.movie_audio_track?;
let sample_count = track.sample_count.min(track.first_samples_per_chunk);
let offset = usize::try_from(track.first_chunk_offset).ok()?;
let frames = usize::try_from(sample_count).ok()?;
let channels = usize::from(track.channel_count);
let samples = match track.codec {
codec if codec == u32::from_be_bytes(*b"ima4") => {
ppc_qt_decode_ima4_movie_audio_samples(sample_data, offset, frames, channels)?
}
_ => ppc_qt_decode_pcm_movie_audio_samples(
sample_data,
offset,
frames,
channels,
usize::from(track.sample_size_bits),
track.codec,
)?,
};
ppc_decoded_sound_data(samples, track.sample_rate_fixed)
}
fn ppc_qt_build_video_sample_table(
data: &[u8],
info: &PpcQuickTimeVideoSampleTableInfo,
) -> Option<PpcQuickTimeVideoSampleTableRecord> {
let mut sample_index = 0usize;
let mut media_start_time = 0u64;
let mut samples = Vec::with_capacity(info.sample_sizes.len());
for (chunk_index, chunk_offset) in info.chunk_offsets.iter().copied().enumerate() {
if sample_index >= info.sample_sizes.len() {
break;
}
let chunk_number = u32::try_from(chunk_index).ok()?.saturating_add(1);
let samples_per_chunk = usize::try_from(ppc_qt_samples_per_chunk_for_chunk(
&info.stsc_entries,
chunk_number,
)?)
.ok()?;
let mut sample_offset = chunk_offset;
for _ in 0..samples_per_chunk {
if sample_index >= info.sample_sizes.len() {
break;
}
let size = info.sample_sizes[sample_index];
let duration = ppc_qt_video_sample_duration(info, sample_index)?;
let (data_len, checksum, preview_len, preview) =
ppc_qt_sample_payload_summary(data, sample_offset, size);
samples.push(PpcQuickTimeVideoSampleRecord {
offset: sample_offset,
size,
media_start_time,
duration,
data_len,
checksum,
preview_len,
preview,
});
sample_offset = sample_offset.checked_add(u64::from(size))?;
media_start_time = media_start_time.checked_add(u64::from(duration))?;
sample_index += 1;
}
}
if samples.len() != info.sample_sizes.len() {
return None;
}
Some(PpcQuickTimeVideoSampleTableRecord {
media_time_scale: info.media_time_scale,
media_duration: info.media_duration,
sample_count: u32::try_from(samples.len()).ok()?,
codec: info.codec,
samples,
})
}
fn ppc_qt_video_sample_duration(
info: &PpcQuickTimeVideoSampleTableInfo,
sample_index: usize,
) -> Option<u32> {
if let Some(duration) = info.sample_durations.get(sample_index).copied() {
if duration != 0 {
return Some(duration);
}
}
let sample_count = u64::try_from(info.sample_sizes.len()).ok()?;
if sample_count == 0 || info.media_duration == 0 {
return None;
}
u32::try_from((info.media_duration / sample_count).max(1)).ok()
}
fn ppc_qt_decode_audio_chunks(
data: &[u8],
info: &PpcQuickTimeAudioDecodeInfo,
) -> Option<PpcDecodedAiffData> {
let mut remaining_frames = usize::try_from(info.sample_count).ok()?;
let mut samples = Vec::with_capacity(remaining_frames);
for (chunk_index, chunk_offset) in info.chunk_offsets.iter().copied().enumerate() {
if remaining_frames == 0 {
break;
}
let chunk_number = u32::try_from(chunk_index).ok()?.saturating_add(1);
let samples_per_chunk = usize::try_from(ppc_qt_samples_per_chunk_for_chunk(
&info.stsc_entries,
chunk_number,
)?)
.ok()?;
let frames = remaining_frames.min(samples_per_chunk);
let offset = usize::try_from(chunk_offset).ok()?;
let mut chunk_samples = match info.codec {
codec if codec == u32::from_be_bytes(*b"ima4") => {
ppc_qt_decode_ima4_movie_audio_samples(
data,
offset,
frames,
usize::from(info.channel_count),
)?
}
_ => ppc_qt_decode_pcm_movie_audio_samples(
data,
offset,
frames,
usize::from(info.channel_count),
usize::from(info.sample_size_bits),
info.codec,
)?,
};
remaining_frames -= chunk_samples.len();
samples.append(&mut chunk_samples);
}
if samples.is_empty() {
return None;
}
ppc_decoded_sound_data(samples, info.sample_rate_fixed)
}
pub(crate) fn ppc_qt_synthesize_music_track(
data: &[u8],
info: &PpcQuickTimeMusicDecodeInfo,
) -> Option<PpcDecodedAiffData> {
const SAMPLE_RATE: u32 = 22_050;
const MAX_MUSIC_SECONDS: u64 = 600;
let total_samples = info
.media_duration
.checked_mul(u64::from(SAMPLE_RATE))?
.checked_div(u64::from(info.media_time_scale))?
.min(u64::from(SAMPLE_RATE) * MAX_MUSIC_SECONDS);
let mut mixed = vec![0i32; usize::try_from(total_samples).ok()?];
let mut sample_index = 0usize;
let mut sample_start_time = 0u64;
let mut parts = Vec::<PpcQuickTimeMusicPartState>::new();
for (chunk_index, chunk_offset) in info.chunk_offsets.iter().copied().enumerate() {
if sample_index >= info.sample_sizes.len() {
break;
}
let chunk_number = u32::try_from(chunk_index).ok()?.saturating_add(1);
let chunk_description = ppc_qt_stsc_entry_for_chunk(&info.stsc_entries, chunk_number)?;
let samples_per_chunk = usize::try_from(chunk_description.samples_per_chunk).ok()?;
if let Some(description_index) = usize::try_from(chunk_description.sample_description_id)
.ok()?
.checked_sub(1)
{
let description = info.sample_descriptions.get(description_index)?;
for requested in description {
ppc_qt_music_part_state(&mut parts, requested.part).instrument =
ppc_qt_music_instrument(*requested);
}
}
let mut sample_offset = usize::try_from(chunk_offset).ok()?;
for _ in 0..samples_per_chunk {
let sample_size = usize::try_from(*info.sample_sizes.get(sample_index)?).ok()?;
let sample_end = sample_offset.checked_add(sample_size)?;
let sample = data.get(sample_offset..sample_end)?;
ppc_qt_synthesize_music_events(
sample,
info.media_time_scale,
sample_start_time,
&mut mixed,
SAMPLE_RATE,
&mut parts,
)?;
sample_offset = sample_end;
sample_start_time = sample_start_time
.checked_add(u64::from(*info.sample_durations.get(sample_index)?))?;
sample_index += 1;
if sample_index >= info.sample_sizes.len() {
break;
}
}
}
if sample_index != info.sample_sizes.len() {
return None;
}
if !mixed.iter().any(|sample| *sample != 0) {
return None;
}
let samples = mixed
.into_iter()
.map(|sample| (sample + 128).clamp(0, 255) as u8)
.collect::<Vec<_>>();
ppc_decoded_sound_data(samples, SAMPLE_RATE << 16)
}
pub(crate) fn ppc_qt_synthesize_music_events(
data: &[u8],
media_time_scale: u32,
sample_start_time: u64,
mixed: &mut [i32],
sample_rate: u32,
parts: &mut Vec<PpcQuickTimeMusicPartState>,
) -> Option<()> {
let mut offset = 0usize;
let mut local_time = 0u64;
let mut reserved_end_marker_seen = false;
while offset.checked_add(4)? <= data.len() {
let word = u32::from_be_bytes(data.get(offset..offset + 4)?.try_into().ok()?);
let short_type = (word >> 29) & 0x7;
match short_type {
0 => {
local_time = local_time.checked_add(u64::from(word & 0x00ff_ffff))?;
offset += 4;
}
1 => {
let part = (word >> 24) & 0x1f;
let pitch = ((word >> 18) & 0x3f) + 32;
let velocity = (word >> 11) & 0x7f;
let duration = word & 0x7ff;
let state = *ppc_qt_music_part_state(parts, part as u16);
ppc_qt_mix_music_note(
mixed,
sample_start_time.checked_add(local_time)?,
duration,
pitch as f64,
velocity,
state,
media_time_scale,
sample_rate,
)?;
offset += 4;
}
2 => {
let part = ((word >> 24) & 0x1f) as u16;
let controller = ((word >> 16) & 0xff) as u16;
let value = word as u16 as i16;
ppc_qt_apply_music_controller(
ppc_qt_music_part_state(parts, part),
controller,
value,
);
offset += 4;
}
3 => {
if ((word >> 16) & 0xff) == 0 {
if word & 0xffff == 0 {
return (offset + 4 == data.len()).then_some(());
}
reserved_end_marker_seen = true;
}
offset += 4;
}
_ => {
let extended_type = word >> 28;
if extended_type == 9 {
let tail =
u32::from_be_bytes(data.get(offset + 4..offset + 8)?.try_into().ok()?);
if tail >> 30 != 2 {
return None;
}
let part = (word >> 16) & 0x0fff;
let pitch_bits = word & 0xffff;
let pitch = if pitch_bits < 128 {
f64::from(pitch_bits)
} else {
f64::from(pitch_bits) / 256.0
};
let velocity = (tail >> 22) & 0x7f;
let duration = tail & 0x003f_ffff;
let state = *ppc_qt_music_part_state(parts, part as u16);
ppc_qt_mix_music_note(
mixed,
sample_start_time.checked_add(local_time)?,
duration,
pitch,
velocity,
state,
media_time_scale,
sample_rate,
)?;
offset += 8;
} else if extended_type == 10 {
let tail =
u32::from_be_bytes(data.get(offset + 4..offset + 8)?.try_into().ok()?);
if tail >> 30 != 2 {
return None;
}
let part = ((word >> 16) & 0x0fff) as u16;
ppc_qt_apply_music_controller(
ppc_qt_music_part_state(parts, part),
(word & 0xffff) as u16,
tail as u16 as i16,
);
offset += 8;
} else if extended_type == 15 {
let word_count = usize::try_from(word & 0xffff).ok()?;
if word_count < 2 {
return None;
}
let event_end = offset.checked_add(word_count.checked_mul(4)?)?;
let tail = u32::from_be_bytes(
data.get(event_end.checked_sub(4)?..event_end)?
.try_into()
.ok()?,
);
if tail >> 30 != 3 || tail & 0xffff != word & 0xffff {
return None;
}
offset = event_end;
} else {
let tail =
u32::from_be_bytes(data.get(offset + 4..offset + 8)?.try_into().ok()?);
if tail >> 30 != 2 {
return None;
}
offset += 8;
}
}
}
}
(offset == data.len() && !reserved_end_marker_seen).then_some(())
}
#[derive(Debug, Clone, Copy)]
pub(crate) struct PpcQuickTimeMusicPartState {
pub(crate) part: u16,
pub(crate) instrument: u32,
pub(crate) volume: i16,
pub(crate) pitch_bend: i16,
pub(crate) sustain: bool,
}
fn ppc_qt_music_part_state(
parts: &mut Vec<PpcQuickTimeMusicPartState>,
part: u16,
) -> &mut PpcQuickTimeMusicPartState {
if let Some(index) = parts.iter().position(|state| state.part == part) {
return &mut parts[index];
}
parts.push(PpcQuickTimeMusicPartState {
part,
instrument: 1,
volume: i16::MAX,
pitch_bend: 0,
sustain: false,
});
parts.last_mut().unwrap()
}
fn ppc_qt_music_instrument(part: PpcQuickTimeMusicPart) -> u32 {
if (1..=128).contains(&part.instrument_number)
|| (16_384..=16_512).contains(&part.instrument_number)
{
part.instrument_number
} else if (1..=128).contains(&part.gm_number) || (16_384..=16_512).contains(&part.gm_number) {
part.gm_number
} else {
1
}
}
fn ppc_qt_apply_music_controller(
state: &mut PpcQuickTimeMusicPartState,
controller: u16,
value: i16,
) {
match controller {
7 => state.volume = value.max(0),
32 => state.pitch_bend = value,
64 => state.sustain = value > 0,
_ => {}
}
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn ppc_qt_mix_music_note(
mixed: &mut [i32],
start_time: u64,
duration: u32,
pitch: f64,
velocity: u32,
state: PpcQuickTimeMusicPartState,
media_time_scale: u32,
sample_rate: u32,
) -> Option<()> {
const OUTPUT_GAIN: i32 = 6;
if duration == 0 || velocity == 0 || media_time_scale == 0 {
return Some(());
}
let start = start_time
.checked_mul(u64::from(sample_rate))?
.checked_div(u64::from(media_time_scale))?;
let length = u64::from(duration)
.checked_mul(u64::from(sample_rate))?
.checked_div(u64::from(media_time_scale))?
.max(1);
let start = usize::try_from(start).ok()?.min(mixed.len());
let end = usize::try_from(u64::try_from(start).ok()?.checked_add(length)?)
.ok()?
.min(mixed.len());
if !pitch.is_finite() {
return Some(());
}
let pitch_fixed = (pitch * 256.0) as i32 + i32::from(state.pitch_bend);
let phase_step = ppc_qt_music_phase_step(pitch_fixed, sample_rate)?;
let note_len = end.saturating_sub(start);
let mut phase = 0u32;
let instrument = state.instrument;
let drum = (16_384..=16_512).contains(&instrument);
let family = instrument.saturating_sub(1).min(127) / 8;
let mut noise = (start_time as u32)
.wrapping_mul(0x9e37_79b9)
.wrapping_add((pitch_fixed as u32).rotate_left(13))
.wrapping_add(instrument);
for (index, destination) in mixed[start..end].iter_mut().enumerate() {
let position = (phase >> 16) as i32;
noise ^= noise << 13;
noise ^= noise >> 17;
noise ^= noise << 5;
let triangle = if position < 32_768 {
position * 2 - 32_768
} else {
98_303 - position * 2
};
let saw = position - 32_768;
let square = if position < 32_768 { 24_576 } else { -24_576 };
let random = (noise >> 16) as i16 as i32;
let waveform = if drum {
match pitch.round() as i32 {
35 | 36 => triangle * 3 / 4 + square / 4,
38 | 40 => random * 3 / 4 + triangle / 4,
42 | 44 | 46 | 49 | 51 | 52 | 55 | 57 | 59 => random,
_ => random / 2 + triangle / 2,
}
} else {
match family {
0 => triangle * 3 / 4 + saw / 4,
1 => triangle / 2 + square / 2,
2 => square * 3 / 4 + triangle / 4,
3 => saw / 2 + triangle / 2,
4 => square / 2 + saw / 2,
5 | 6 => triangle * 3 / 4 + square / 4,
7 | 8 => saw * 3 / 4 + square / 4,
9 => triangle,
10 => saw,
11 => triangle * 3 / 4 + saw / 4,
12 => saw / 2 + random / 2,
13 => triangle / 2 + saw / 2,
14 => random / 2 + square / 2,
_ => random,
}
};
let edge_envelope = index.min(note_len.saturating_sub(index + 1)).min(63) as i32 + 1;
let decay_envelope = match family {
0 | 1 | 3 | 14 => i32::try_from(note_len.saturating_sub(index)).unwrap_or(i32::MAX),
_ => i32::try_from(note_len).unwrap_or(i32::MAX),
}
.max(1);
let volume = i32::from(state.volume).clamp(0, i32::from(i16::MAX));
let amplitude = waveform * velocity as i32 * edge_envelope / (127 * 64 * 4096) * volume
/ i32::from(i16::MAX)
* decay_envelope
/ i32::try_from(note_len.max(1)).unwrap_or(i32::MAX)
* OUTPUT_GAIN;
*destination = destination.saturating_add(amplitude);
phase = phase.wrapping_add(phase_step);
}
Some(())
}
fn ppc_qt_music_phase_step(pitch_fixed: i32, sample_rate: u32) -> Option<u32> {
const STEPS_22_050: [u32; 128] = [
1592507, 1687203, 1787529, 1893821, 2006434, 2125742, 2252146, 2386065, 2527948, 2678268,
2837526, 3006254, 3185015, 3374406, 3575058, 3787642, 4012867, 4251485, 4504291, 4772130,
5055896, 5356535, 5675051, 6012507, 6370030, 6748811, 7150117, 7575285, 8025735, 8502970,
9008582, 9544261, 10111792, 10713070, 11350103, 12025015, 12740059, 13497623, 14300233,
15150569, 16051469, 17005939, 18017165, 19088521, 20223584, 21426141, 22700205, 24050030,
25480119, 26995246, 28600467, 30301139, 32102938, 34011878, 36034330, 38177043, 40447168,
42852281, 45400411, 48100060, 50960238, 53990491, 57200933, 60602278, 64205876, 68023757,
72068660, 76354085, 80894335, 85704563, 90800821, 96200119, 101920476, 107980983,
114401866, 121204555, 128411753, 136047513, 144137319, 152708170, 161788671, 171409126,
181601643, 192400238, 203840952, 215961966, 228803732, 242409110, 256823506, 272095026,
288274639, 305416341, 323577341, 342818251, 363203285, 384800477, 407681904, 431923931,
457607465, 484818220, 513647012, 544190053, 576549277, 610832681, 647154683, 685636503,
726406571, 769600953, 815363807, 863847862, 915214929, 969636441, 1027294024, 1088380105,
1153098554, 1221665363, 1294309365, 1371273005, 1452813141, 1539201906, 1630727614,
1727695724, 1830429858, 1939272882, 2054588048, 2176760211, 2306197109, 2443330725,
];
if sample_rate == 0 {
return None;
}
let pitch_fixed = pitch_fixed.clamp(0, 127 * 256);
let note = usize::try_from(pitch_fixed / 256).ok()?;
let fraction = u64::try_from(pitch_fixed % 256).ok()?;
let first = u64::from(STEPS_22_050[note]);
let second = u64::from(*STEPS_22_050.get(note + 1).unwrap_or(&STEPS_22_050[note]));
let interpolated = first.checked_add(second.saturating_sub(first) * fraction / 256)?;
u32::try_from(
interpolated
.checked_mul(22_050)?
.checked_div(u64::from(sample_rate))?,
)
.ok()
}
fn ppc_qt_stsc_entry_for_chunk(
entries: &[PpcQuickTimeStscEntry],
chunk_number: u32,
) -> Option<PpcQuickTimeStscEntry> {
for (index, entry) in entries.iter().copied().enumerate() {
let next_first_chunk = entries
.get(index + 1)
.map(|next| next.first_chunk)
.unwrap_or(u32::MAX);
if chunk_number >= entry.first_chunk && chunk_number < next_first_chunk {
return Some(entry);
}
}
None
}
fn ppc_qt_samples_per_chunk_for_chunk(
entries: &[PpcQuickTimeStscEntry],
chunk_number: u32,
) -> Option<u32> {
let mut result = None;
for (index, entry) in entries.iter().enumerate() {
let next_first_chunk = entries
.get(index + 1)
.map(|next| next.first_chunk)
.unwrap_or(u32::MAX);
if chunk_number >= entry.first_chunk && chunk_number < next_first_chunk {
result = Some(entry.samples_per_chunk);
break;
}
}
result
}
fn ppc_qt_decode_pcm_movie_audio_samples(
data: &[u8],
data_start: usize,
frames: usize,
channels: usize,
sample_size_bits: usize,
codec: u32,
) -> Option<Vec<u8>> {
if frames == 0 || channels == 0 {
return None;
}
let bytes_per_sample = match sample_size_bits {
8 => 1usize,
16 => 2usize,
_ => return None,
};
let frame_bytes = channels.checked_mul(bytes_per_sample)?;
let byte_count = frames.checked_mul(frame_bytes)?;
let raw = data.get(data_start..data_start.checked_add(byte_count)?)?;
let mut samples = Vec::with_capacity(frames);
for frame in 0..frames {
let mut accum = 0i32;
let frame_start = frame.checked_mul(frame_bytes)?;
for channel in 0..channels {
let offset = frame_start.checked_add(channel.checked_mul(bytes_per_sample)?)?;
let sample = match (codec, sample_size_bits) {
(codec, 8) if codec == u32::from_be_bytes(*b"raw ") => raw[offset] as i32 - 128,
(codec, 8) if codec == u32::from_be_bytes(*b"twos") => raw[offset] as i8 as i32,
(codec, 16) if codec == u32::from_be_bytes(*b"twos") => {
i16::from_be_bytes([raw[offset], raw[offset + 1]]) as i32 >> 8
}
_ => return None,
};
accum += sample;
}
samples.push((accum / channels as i32 + 128).clamp(0, 255) as u8);
}
Some(samples)
}
fn ppc_qt_decode_ima4_movie_audio_samples(
data: &[u8],
data_start: usize,
frames: usize,
channels: usize,
) -> Option<Vec<u8>> {
const FRAMES_PER_PACKET: usize = 64;
const BYTES_PER_CHANNEL_PACKET: usize = 34;
if frames == 0 || channels == 0 {
return None;
}
let packets = frames
.checked_add(FRAMES_PER_PACKET - 1)?
.checked_div(FRAMES_PER_PACKET)?;
let packet_bytes = channels.checked_mul(BYTES_PER_CHANNEL_PACKET)?;
let byte_count = packets.checked_mul(packet_bytes)?;
let raw = data.get(data_start..data_start.checked_add(byte_count)?)?;
let mut samples = Vec::with_capacity(frames);
for packet in 0..packets {
let packet_start = packet.checked_mul(packet_bytes)?;
let mut decoded_channels = Vec::with_capacity(channels);
for channel in 0..channels {
let block_start =
packet_start.checked_add(channel.checked_mul(BYTES_PER_CHANNEL_PACKET)?)?;
decoded_channels.push(ppc_qt_decode_ima4_channel_packet(
raw.get(block_start..block_start + BYTES_PER_CHANNEL_PACKET)?,
)?);
}
let frames_this_packet = (frames - samples.len()).min(FRAMES_PER_PACKET);
for frame in 0..frames_this_packet {
let mut accum = 0i32;
for channel_samples in &decoded_channels {
accum += i32::from(channel_samples[frame]);
}
let mono = (((accum / channels as i32) >> 8) + 128).clamp(0, 255) as u8;
samples.push(mono);
}
}
Some(samples)
}
pub(super) fn ppc_qt_decode_ima4_channel_packet(packet: &[u8]) -> Option<[i16; 64]> {
const STEP_TABLE: [i32; 89] = [
7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 21, 23, 25, 28, 31, 34, 37, 41, 45, 50, 55, 60,
66, 73, 80, 88, 97, 107, 118, 130, 143, 157, 173, 190, 209, 230, 253, 279, 307, 337, 371,
408, 449, 494, 544, 598, 658, 724, 796, 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878,
2066, 2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845,
8630, 9493, 10442, 11487, 12635, 13899, 15289, 16818, 18500, 20350, 22385, 24623, 27086,
29794, 32767,
];
const INDEX_TABLE: [i32; 16] = [-1, -1, -1, -1, 2, 4, 6, 8, -1, -1, -1, -1, 2, 4, 6, 8];
if packet.len() != 34 {
return None;
}
let header = u16::from_be_bytes([packet[0], packet[1]]);
let mut predictor = i32::from((header & 0xff80) as i16);
let mut step_index = usize::from(header & 0x007f).min(STEP_TABLE.len() - 1);
let mut decoded = [0i16; 64];
let mut output_index = 0usize;
for byte in packet.iter().copied().skip(2) {
for nibble in [byte & 0x0f, byte >> 4] {
let step = STEP_TABLE[step_index];
let mut diff = step >> 3;
if (nibble & 0x01) != 0 {
diff += step >> 2;
}
if (nibble & 0x02) != 0 {
diff += step >> 1;
}
if (nibble & 0x04) != 0 {
diff += step;
}
if (nibble & 0x08) != 0 {
predictor -= diff;
} else {
predictor += diff;
}
predictor = predictor.clamp(i32::from(i16::MIN), i32::from(i16::MAX));
let next_index = step_index as i32 + INDEX_TABLE[usize::from(nibble)];
step_index = next_index.clamp(0, (STEP_TABLE.len() - 1) as i32) as usize;
decoded[output_index] = predictor as i16;
output_index += 1;
}
}
Some(decoded)
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct PpcQuickTimeCinepakDecoder {
pub(crate) width: usize,
pub(crate) height: usize,
pub(crate) frame: Vec<u8>,
pub(crate) strips: Vec<PpcQuickTimeCinepakStripState>,
}
pub(crate) struct PpcQuickTimeDecodedVideoFrame {
pub(crate) width: usize,
pub(crate) height: usize,
pub(crate) rgb: Vec<u8>,
}
impl PpcQuickTimeCinepakDecoder {
pub(crate) const MAX_STRIPS: usize = 32;
pub(crate) fn new(width: usize, height: usize) -> Option<Self> {
if width == 0 || height == 0 || width > 4096 || height > 4096 {
return None;
}
let pixel_bytes = width.checked_mul(height)?.checked_mul(3)?;
Some(Self {
width,
height,
frame: vec![0; pixel_bytes],
strips: vec![PpcQuickTimeCinepakStripState::default(); Self::MAX_STRIPS],
})
}
pub(crate) fn decode_sample(&mut self, sample: &[u8]) -> Option<()> {
if sample.len() < 10 {
return None;
}
let frame_flags = sample[0];
let encoded_size = ppc_qt_read_u24(sample, 1)?;
if encoded_size < 10 || encoded_size > sample.len() {
return None;
}
let width = usize::from(u16::from_be_bytes([sample[4], sample[5]]));
let height = usize::from(u16::from_be_bytes([sample[6], sample[7]]));
if width != self.width || height != self.height {
return None;
}
let strip_count =
usize::from(u16::from_be_bytes([sample[8], sample[9]])).min(Self::MAX_STRIPS);
let mut offset = 10usize;
let end = encoded_size;
let mut y_cursor = 0usize;
for strip_index in 0..strip_count {
if offset.checked_add(12)? > end {
return None;
}
let strip_id = sample[offset];
if strip_id != 0x10 && strip_id != 0x11 {
return None;
}
let strip_size = ppc_qt_read_u24(sample, offset + 1)?;
if strip_size < 12 {
return None;
}
let raw_y1 = usize::from(u16::from_be_bytes([sample[offset + 4], sample[offset + 5]]));
let x1 = usize::from(u16::from_be_bytes([sample[offset + 6], sample[offset + 7]]));
let raw_y2 = usize::from(u16::from_be_bytes([sample[offset + 8], sample[offset + 9]]));
let x2 = usize::from(u16::from_be_bytes([
sample[offset + 10],
sample[offset + 11],
]));
let (y1, y2) = if raw_y1 == 0 {
(y_cursor, y_cursor.checked_add(raw_y2)?)
} else {
(raw_y1, raw_y2)
};
if x1 >= x2 || y1 >= y2 || x1 >= self.width || y1 >= self.height {
return None;
}
offset += 12;
let strip_payload_size = strip_size - 12;
let strip_end = offset.checked_add(strip_payload_size)?;
if strip_end > end {
return None;
}
if strip_index > 0 && (frame_flags & 0x01) == 0 {
self.strips[strip_index] = self.strips[strip_index - 1].clone();
}
ppc_qt_decode_cinepak_strip(
&mut self.frame,
self.width,
self.height,
&mut self.strips[strip_index],
sample.get(offset..strip_end)?,
(x1, y1, x2.min(self.width), y2.min(self.height)),
)?;
offset = strip_end;
y_cursor = y2;
}
Some(())
}
pub(crate) fn decoded_frame(&self) -> PpcQuickTimeDecodedVideoFrame {
PpcQuickTimeDecodedVideoFrame {
width: self.width,
height: self.height,
rgb: self.frame.clone(),
}
}
fn from_cache(cache: &PpcQuickTimeVideoDecodeCacheRecord) -> Option<Self> {
if cache.width == 0
|| cache.height == 0
|| cache.rgb.len() != cache.width.checked_mul(cache.height)?.checked_mul(3)?
|| cache.cinepak_strips.len() != Self::MAX_STRIPS
{
return None;
}
Some(Self {
width: cache.width,
height: cache.height,
frame: cache.rgb.clone(),
strips: cache.cinepak_strips.clone(),
})
}
fn cache_record(&self, codec: u32, sample_index: usize) -> PpcQuickTimeVideoDecodeCacheRecord {
PpcQuickTimeVideoDecodeCacheRecord {
codec,
width: self.width,
height: self.height,
sample_index,
rgb: self.frame.clone(),
cinepak_strips: self.strips.clone(),
}
}
}
fn ppc_qt_read_u24(data: &[u8], offset: usize) -> Option<usize> {
let bytes = data.get(offset..offset.checked_add(3)?)?;
Some((usize::from(bytes[0]) << 16) | (usize::from(bytes[1]) << 8) | usize::from(bytes[2]))
}
pub(crate) fn ppc_qt_decode_current_movie_video_frame(
quicktime: &mut PpcQuickTimeState,
) -> Option<PpcQuickTimeDecodedVideoFrame> {
let samples = quicktime.movie_video_samples.clone()?;
if samples.codec != u32::from_be_bytes(*b"cvid") || samples.samples.is_empty() {
return None;
}
let sample_index = ppc_qt_movie_timed_sample_index(quicktime, &samples)?;
let sample_data = quicktime
.movie_file_sample_fork
.as_ref()
.map(|fork| fork.as_slice())
.unwrap_or(&quicktime.movie_file_data);
let first_sample = ppc_qt_movie_video_sample_bytes(sample_data, &samples, 0)?;
if first_sample.len() < 10 {
return None;
}
let width = usize::from(u16::from_be_bytes([first_sample[4], first_sample[5]]));
let height = usize::from(u16::from_be_bytes([first_sample[6], first_sample[7]]));
let mut start_index = 0usize;
let mut decoder = if let Some(cache) = quicktime
.movie_video_decode_cache
.as_ref()
.filter(|cache| {
cache.codec == samples.codec
&& cache.width == width
&& cache.height == height
&& cache.sample_index <= sample_index
})
.and_then(PpcQuickTimeCinepakDecoder::from_cache)
{
start_index = quicktime
.movie_video_decode_cache
.as_ref()?
.sample_index
.saturating_add(1);
cache
} else {
PpcQuickTimeCinepakDecoder::new(width, height)?
};
for index in start_index..=sample_index {
let sample = ppc_qt_movie_video_sample_bytes(sample_data, &samples, index)?;
decoder.decode_sample(sample)?;
}
let frame = decoder.decoded_frame();
quicktime.movie_video_decode_cache = Some(decoder.cache_record(samples.codec, sample_index));
Some(frame)
}
pub(crate) fn ppc_qt_movie_video_sample_bytes<'a>(
data: &'a [u8],
samples: &PpcQuickTimeVideoSampleTableRecord,
index: usize,
) -> Option<&'a [u8]> {
let sample = samples.samples.get(index)?;
let offset = usize::try_from(sample.offset).ok()?;
let size = usize::try_from(sample.size).ok()?;
data.get(offset..offset.checked_add(size)?)
}
fn ppc_qt_decode_cinepak_strip(
frame: &mut [u8],
width: usize,
height: usize,
strip: &mut PpcQuickTimeCinepakStripState,
data: &[u8],
bounds: (usize, usize, usize, usize),
) -> Option<()> {
let mut offset = 0usize;
while offset.checked_add(4)? <= data.len() {
let chunk_id = data[offset];
let chunk_size = ppc_qt_read_u24(data, offset + 1)?;
if chunk_size < 4 {
return None;
}
offset += 4;
let payload_size = chunk_size - 4;
let payload_end = offset.checked_add(payload_size)?;
let payload = data.get(offset..payload_end)?;
match chunk_id {
0x20 | 0x21 | 0x24 | 0x25 => {
ppc_qt_decode_cinepak_codebook(&mut strip.v4_codebook, chunk_id, payload);
}
0x22 | 0x23 | 0x26 | 0x27 => {
ppc_qt_decode_cinepak_codebook(&mut strip.v1_codebook, chunk_id, payload);
}
0x30 | 0x31 | 0x32 => {
ppc_qt_decode_cinepak_vectors(
frame, width, height, strip, chunk_id, payload, bounds,
)?;
return Some(());
}
_ => {}
}
offset = payload_end;
}
None
}
fn ppc_qt_decode_cinepak_codebook(codebook: &mut [[u8; 12]; 256], chunk_id: u8, data: &[u8]) {
let entry_len = if (chunk_id & 0x04) != 0 { 4 } else { 6 };
let flagged = (chunk_id & 0x01) != 0;
let mut offset = 0usize;
let mut flags = 0u32;
let mut mask = 0u32;
for entry in codebook.iter_mut() {
if flagged {
mask >>= 1;
if mask == 0 {
let Some(flag_bytes) = data.get(offset..offset.saturating_add(4)) else {
break;
};
flags = u32::from_be_bytes([
flag_bytes[0],
flag_bytes[1],
flag_bytes[2],
flag_bytes[3],
]);
offset += 4;
mask = 0x8000_0000;
}
if (flags & mask) == 0 {
continue;
}
}
let Some(raw) = data.get(offset..offset.saturating_add(entry_len)) else {
break;
};
offset += entry_len;
let y = [raw[0], raw[1], raw[2], raw[3]];
if entry_len == 4 {
for (index, luma) in y.iter().copied().enumerate() {
let base = index * 3;
entry[base] = luma;
entry[base + 1] = luma;
entry[base + 2] = luma;
}
} else {
let u = raw[4] as i8 as i32;
let v = raw[5] as i8 as i32;
for (index, luma) in y.iter().copied().enumerate() {
let luma = i32::from(luma);
let base = index * 3;
entry[base] = luma.saturating_add(v.saturating_mul(2)).clamp(0, 255) as u8;
entry[base + 1] = luma.saturating_sub(u / 2).saturating_sub(v).clamp(0, 255) as u8;
entry[base + 2] = luma.saturating_add(u.saturating_mul(2)).clamp(0, 255) as u8;
}
}
}
}
fn ppc_qt_decode_cinepak_vectors(
frame: &mut [u8],
width: usize,
height: usize,
strip: &PpcQuickTimeCinepakStripState,
chunk_id: u8,
data: &[u8],
(x1, y1, x2, y2): (usize, usize, usize, usize),
) -> Option<()> {
let mut offset = 0usize;
let mut flags = 0u32;
let mut mask = 0u32;
for y in (y1..y2).step_by(4) {
for x in (x1..x2).step_by(4) {
let should_decode = if (chunk_id & 0x01) != 0 {
ppc_qt_next_cinepak_flag(data, &mut offset, &mut flags, &mut mask)?
} else {
true
};
if !should_decode {
continue;
}
let use_v1 = if (chunk_id & 0x02) != 0 {
true
} else {
!ppc_qt_next_cinepak_flag(data, &mut offset, &mut flags, &mut mask)?
};
if use_v1 {
let index = usize::from(*data.get(offset)?);
offset += 1;
ppc_qt_put_cinepak_v1_block(frame, width, height, x, y, &strip.v1_codebook[index])?;
} else {
let indices = data.get(offset..offset.checked_add(4)?)?;
offset += 4;
ppc_qt_put_cinepak_v4_block(
frame,
width,
height,
x,
y,
[
&strip.v4_codebook[usize::from(indices[0])],
&strip.v4_codebook[usize::from(indices[1])],
&strip.v4_codebook[usize::from(indices[2])],
&strip.v4_codebook[usize::from(indices[3])],
],
)?;
}
}
}
Some(())
}
fn ppc_qt_next_cinepak_flag(
data: &[u8],
offset: &mut usize,
flags: &mut u32,
mask: &mut u32,
) -> Option<bool> {
*mask >>= 1;
if *mask == 0 {
let flag_bytes = data.get(*offset..(*offset).checked_add(4)?)?;
*flags = u32::from_be_bytes([flag_bytes[0], flag_bytes[1], flag_bytes[2], flag_bytes[3]]);
*offset = (*offset).checked_add(4)?;
*mask = 0x8000_0000;
}
Some((*flags & *mask) != 0)
}
fn ppc_qt_put_cinepak_v1_block(
frame: &mut [u8],
width: usize,
height: usize,
x: usize,
y: usize,
codebook: &[u8; 12],
) -> Option<()> {
for dy in 0..4usize {
for dx in 0..4usize {
let codebook_index = ((dy / 2) * 2) + (dx / 2);
let color_offset = codebook_index.checked_mul(3)?;
ppc_qt_write_cinepak_rgb(
frame,
width,
height,
x.checked_add(dx)?,
y.checked_add(dy)?,
[
codebook[color_offset],
codebook[color_offset + 1],
codebook[color_offset + 2],
],
)?;
}
}
Some(())
}
fn ppc_qt_put_cinepak_v4_block(
frame: &mut [u8],
width: usize,
height: usize,
x: usize,
y: usize,
codebooks: [&[u8; 12]; 4],
) -> Option<()> {
for dy in 0..4usize {
for dx in 0..4usize {
let codebook_index = if dy >= 2 { 2 } else { 0 } + if dx >= 2 { 1 } else { 0 };
let pixel_index = ((dy % 2) * 2) + (dx % 2);
let color_offset = pixel_index.checked_mul(3)?;
let codebook = codebooks[codebook_index];
ppc_qt_write_cinepak_rgb(
frame,
width,
height,
x.checked_add(dx)?,
y.checked_add(dy)?,
[
codebook[color_offset],
codebook[color_offset + 1],
codebook[color_offset + 2],
],
)?;
}
}
Some(())
}
fn ppc_qt_write_cinepak_rgb(
frame: &mut [u8],
width: usize,
height: usize,
x: usize,
y: usize,
rgb: [u8; 3],
) -> Option<()> {
if x >= width || y >= height {
return Some(());
}
let offset = y.checked_mul(width)?.checked_add(x)?.checked_mul(3)?;
let pixel = frame.get_mut(offset..offset.checked_add(3)?)?;
pixel.copy_from_slice(&rgb);
Some(())
}
pub(crate) fn ppc_qt_draw_movie_frame(
memory: &mut PpcSectionMem,
gworlds: &[PpcGWorldRecord],
current_gworld: u32,
quicktime: &mut PpcQuickTimeState,
salt: u32,
) -> bool {
if quicktime.movie_audio_track.is_some() && quicktime.movie_video_track.is_none() {
return false;
}
let gworld = if quicktime.movie_gworld != 0 {
quicktime.movie_gworld
} else {
current_gworld
};
let Some(surface) = ppc_live_quickdraw_surface(memory, gworlds, gworld) else {
return false;
};
let front_buffer = surface.front_buffer;
let draw_rect = quicktime
.movie_controllers
.iter()
.rev()
.find(|controller| {
controller.movie == PPC_QT_MOVIE
&& controller.window == gworld
&& !quicktime
.detached_movie_controllers
.contains(&controller.handle)
})
.map_or(quicktime.movie_box, |controller| controller.rect);
if let Some(drawn) = ppc_qt_draw_decoded_movie_frame(memory, surface, quicktime, draw_rect) {
return drawn;
}
if front_buffer.depth != 16 {
return false;
}
ppc_qt_draw_placeholder_frame(
memory,
front_buffer,
None,
ppc_qt_movie_frame_salt(quicktime, salt),
)
}
fn ppc_qt_draw_decoded_movie_frame(
memory: &mut PpcSectionMem,
surface: PpcQuickDrawSurface,
quicktime: &mut PpcQuickTimeState,
draw_rect: (i16, i16, i16, i16),
) -> Option<bool> {
let front_buffer = surface.front_buffer;
if !matches!(front_buffer.depth, 1 | 2 | 4 | 8 | 16 | 32)
|| front_buffer.base_addr == 0
|| front_buffer.width == 0
|| front_buffer.height == 0
|| front_buffer.row_bytes
< front_buffer
.width
.saturating_mul(front_buffer.depth)
.saturating_add(7)
/ 8
{
return Some(false);
}
let frame = ppc_qt_decode_current_movie_video_frame(quicktime)?;
let Some((inverse, natural)) = toolbox::movie_sampling_transform(quicktime, draw_rect) else {
return Some(false);
};
let natural_width = f64::from(natural.3) - f64::from(natural.1);
let natural_height = f64::from(natural.2) - f64::from(natural.0);
if natural_width <= 0.0 || natural_height <= 0.0 {
return Some(false);
}
let (top, left, bottom, right) = draw_rect;
let box_width = i32::from(right) - i32::from(left);
let box_height = i32::from(bottom) - i32::from(top);
if box_width <= 0 || box_height <= 0 {
return Some(false);
}
let surface_left = i32::from(surface.left);
let surface_top = i32::from(surface.top);
let surface_right = surface_left.saturating_add(front_buffer.width as i32);
let surface_bottom = surface_top.saturating_add(front_buffer.height as i32);
let dst_left = i32::from(left).clamp(surface_left, surface_right);
let dst_top = i32::from(top).clamp(surface_top, surface_bottom);
let dst_right = i32::from(right).clamp(surface_left, surface_right);
let dst_bottom = i32::from(bottom).clamp(surface_top, surface_bottom);
if dst_left >= dst_right || dst_top >= dst_bottom {
return Some(false);
}
let mut wrote_any = false;
for dst_y in dst_top..dst_bottom {
for dst_x in dst_left..dst_right {
let Some((x, y)) = toolbox::movie_sample_point(
&inverse,
f64::from(dst_x) + 0.5,
f64::from(dst_y) + 0.5,
) else {
continue;
};
let x = (x - f64::from(natural.1)) / natural_width;
let y = (y - f64::from(natural.0)) / natural_height;
if !(0.0..1.0).contains(&x) || !(0.0..1.0).contains(&y) {
continue;
}
let src_x = (x * frame.width as f64).floor() as usize;
let src_y = (y * frame.height as f64).floor() as usize;
let Some(rgb_offset) = src_y
.checked_mul(frame.width)
.and_then(|base| base.checked_add(src_x))
.and_then(|pixel| pixel.checked_mul(3))
else {
continue;
};
let Some(rgb) = frame.rgb.get(rgb_offset..rgb_offset.saturating_add(3)) else {
continue;
};
if !ppc_qt_display_clip_contains(quicktime, dst_x, dst_y) {
continue;
}
let color = PpcRgbColor {
red: u16::from(rgb[0]) * 257,
green: u16::from(rgb[1]) * 257,
blue: u16::from(rgb[2]) * 257,
};
let Some(pixel) = ppc_qt_graphics_pixel_value(memory, surface, color) else {
continue;
};
if ppc_qt_write_graphics_pixel(
memory,
front_buffer,
surface.local_point((dst_x, dst_y)),
pixel,
) {
wrote_any = true;
}
}
}
Some(wrote_any)
}
pub(crate) fn ppc_qt_rgb555_from_u8(red: u8, green: u8, blue: u8) -> u16 {
fn component(value: u8) -> u16 {
((u16::from(value) * 31) + 127) / 255
}
(component(red) << 10) | (component(green) << 5) | component(blue)
}
pub(crate) fn ppc_qt_movie_frame_salt(quicktime: &PpcQuickTimeState, fallback_salt: u32) -> u32 {
if let Some(samples) = &quicktime.movie_video_samples {
if !samples.samples.is_empty() {
let sample_index = ppc_qt_movie_timed_sample_index(quicktime, samples).unwrap_or(0);
let sample = &samples.samples[sample_index];
return 0x70u32
.saturating_add(u32::try_from(sample_index).unwrap_or(u32::MAX))
.saturating_add(sample.size & 0x0f)
.saturating_add((sample.offset as u32) & 0x0f)
.saturating_add(sample.checksum & 0x0f)
.saturating_add(u32::from(sample.preview[0] & 0x0f))
.saturating_add(samples.codec.rotate_left(7) & 0x0f);
}
}
let Some(track) = quicktime.movie_video_track else {
return fallback_salt;
};
let sample_index = ppc_qt_movie_sample_index(
quicktime,
usize::try_from(track.sample_count.max(1)).unwrap_or(usize::MAX),
)
.and_then(|index| u32::try_from(index).ok())
.unwrap_or(u32::MAX);
0x70u32
.saturating_add(sample_index)
.saturating_add(track.first_sample_size & 0x0f)
.saturating_add((track.first_chunk_offset as u32) & 0x0f)
.saturating_add(track.first_sample_checksum & 0x0f)
.saturating_add(u32::from(track.first_sample_preview[0] & 0x0f))
.saturating_add(track.codec.rotate_left(7) & 0x0f)
}
fn ppc_qt_movie_sample_index(quicktime: &PpcQuickTimeState, sample_count: usize) -> Option<usize> {
if sample_count == 0 {
return None;
}
let sample_count_u64 = u64::try_from(sample_count).ok()?;
usize::try_from(
ppc_qt_movie_position_in_scale(quicktime, sample_count_u64)
.min(sample_count_u64.saturating_sub(1)),
)
.ok()
}
pub(crate) fn ppc_qt_movie_timed_sample_index(
quicktime: &PpcQuickTimeState,
samples: &PpcQuickTimeVideoSampleTableRecord,
) -> Option<usize> {
if samples.samples.is_empty() {
return None;
}
let media_duration = samples.media_duration.max(1);
let movie_time = ppc_qt_movie_position_in_scale(quicktime, media_duration)
.min(media_duration.saturating_sub(1));
samples
.samples
.iter()
.position(|sample| {
let sample_end = sample
.media_start_time
.saturating_add(u64::from(sample.duration));
movie_time >= sample.media_start_time && movie_time < sample_end
})
.or_else(|| samples.samples.len().checked_sub(1))
}
fn ppc_qt_draw_placeholder_frame(
memory: &mut PpcSectionMem,
front_buffer: PpcFrontBuffer,
bounds: Option<(i16, i16, i16, i16)>,
salt: u32,
) -> bool {
let minimum_row_bytes = match front_buffer.depth {
8 => front_buffer.width,
16 => front_buffer.width.saturating_mul(2),
_ => return false,
};
if front_buffer.base_addr == 0
|| front_buffer.width == 0
|| front_buffer.height == 0
|| front_buffer.row_bytes < minimum_row_bytes
{
return false;
}
let (top, left, bottom, right) = bounds.unwrap_or((
0,
0,
i16::try_from(front_buffer.height).unwrap_or(i16::MAX),
i16::try_from(front_buffer.width).unwrap_or(i16::MAX),
));
let left = i32::from(left).max(0).min(front_buffer.width as i32);
let top = i32::from(top).max(0).min(front_buffer.height as i32);
let right = i32::from(right).max(left).min(front_buffer.width as i32);
let bottom = i32::from(bottom).max(top).min(front_buffer.height as i32);
let width = (right - left) as u32;
let height = (bottom - top) as u32;
if width == 0 || height == 0 {
return false;
}
let x_denom = width.saturating_sub(1).max(1);
let y_denom = height.saturating_sub(1).max(1);
let mut wrote_any = false;
for y in 0..height {
for x in 0..width {
let px = left + x as i32;
let py = top + y as i32;
let pixel = if front_buffer.depth == 8 {
0
} else {
let red = ((x.saturating_mul(31)) / x_denom) as u16;
let green = ((y.saturating_mul(31)) / y_denom) as u16;
let blue = ((x ^ y ^ salt) & 0x1f) as u16;
(red << 10) | (green << 5) | blue
};
if ppc_quickdraw_write_raw_pixel(memory, front_buffer, (px, py), pixel) {
wrote_any = true;
}
}
}
wrote_any
}