--- a/media/libstagefright/binding/mp4parse_capi/src/lib.rs
+++ b/media/libstagefright/binding/mp4parse_capi/src/lib.rs
@@ -20,17 +20,17 @@
//! let mut file = std::fs::File::open("../mp4parse/tests/minimal.mp4").unwrap();
//! let io = mp4parse_capi::mp4parse_io {
//! read: Some(buf_read),
//! userdata: &mut file as *mut _ as *mut std::os::raw::c_void
//! };
//! unsafe {
//! let parser = mp4parse_capi::mp4parse_new(&io);
//! let rv = mp4parse_capi::mp4parse_read(parser);
-//! assert_eq!(rv, mp4parse_capi::mp4parse_error::MP4PARSE_OK);
+//! assert_eq!(rv, mp4parse_capi::mp4parse_status::OK);
//! mp4parse_capi::mp4parse_free(parser);
//! }
//! ```
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.
@@ -54,63 +54,55 @@ use mp4parse::VideoCodecSpecific;
use mp4parse::MediaTimeScale;
use mp4parse::MediaScaledTime;
use mp4parse::TrackTimeScale;
use mp4parse::TrackScaledTime;
use mp4parse::serialize_opus_header;
use mp4parse::CodecType;
use mp4parse::Track;
-// rusty-cheddar's C enum generation doesn't namespace enum members by
-// prefixing them, so we're forced to do it in our member names until
-// https://github.com/Sean1708/rusty-cheddar/pull/35 is fixed. Importing
-// the members into the module namespace avoids doubling up on the
-// namespacing on the Rust side.
-use mp4parse_error::*;
-use mp4parse_track_type::*;
-
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(PartialEq, Debug)]
-pub enum mp4parse_error {
- MP4PARSE_OK = 0,
- MP4PARSE_ERROR_BADARG = 1,
- MP4PARSE_ERROR_INVALID = 2,
- MP4PARSE_ERROR_UNSUPPORTED = 3,
- MP4PARSE_ERROR_EOF = 4,
- MP4PARSE_ERROR_IO = 5,
+pub enum mp4parse_status {
+ OK = 0,
+ BAD_ARG = 1,
+ INVALID = 2,
+ UNSUPPORTED = 3,
+ EOF = 4,
+ IO = 5,
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(PartialEq, Debug)]
pub enum mp4parse_track_type {
- MP4PARSE_TRACK_TYPE_VIDEO = 0,
- MP4PARSE_TRACK_TYPE_AUDIO = 1,
+ VIDEO = 0,
+ AUDIO = 1,
}
impl Default for mp4parse_track_type {
- fn default() -> Self { mp4parse_track_type::MP4PARSE_TRACK_TYPE_VIDEO }
+ fn default() -> Self { mp4parse_track_type::VIDEO }
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(PartialEq, Debug)]
pub enum mp4parse_codec {
- MP4PARSE_CODEC_UNKNOWN,
- MP4PARSE_CODEC_AAC,
- MP4PARSE_CODEC_FLAC,
- MP4PARSE_CODEC_OPUS,
- MP4PARSE_CODEC_AVC,
- MP4PARSE_CODEC_VP9,
- MP4PARSE_CODEC_MP3,
+ UNKNOWN,
+ AAC,
+ FLAC,
+ OPUS,
+ AVC,
+ VP9,
+ MP3,
}
impl Default for mp4parse_codec {
- fn default() -> Self { mp4parse_codec::MP4PARSE_CODEC_UNKNOWN }
+ fn default() -> Self { mp4parse_codec::UNKNOWN }
}
#[repr(C)]
#[derive(Default)]
pub struct mp4parse_track_info {
pub track_type: mp4parse_track_type,
pub codec: mp4parse_codec,
pub track_id: u32,
@@ -312,61 +304,61 @@ pub unsafe extern fn mp4parse_free(parse
/// Enable `mp4_parser` log.
#[no_mangle]
pub unsafe extern fn mp4parse_log(enable: bool) {
mp4parse::set_debug_mode(enable);
}
/// Run the `mp4parse_parser*` allocated by `mp4parse_new()` until EOF or error.
#[no_mangle]
-pub unsafe extern fn mp4parse_read(parser: *mut mp4parse_parser) -> mp4parse_error {
+pub unsafe extern fn mp4parse_read(parser: *mut mp4parse_parser) -> mp4parse_status {
// Validate arguments from C.
if parser.is_null() || (*parser).poisoned() {
- return MP4PARSE_ERROR_BADARG;
+ return mp4parse_status::BAD_ARG;
}
let mut context = (*parser).context_mut();
let mut io = (*parser).io_mut();
let r = read_mp4(io, context);
match r {
- Ok(_) => MP4PARSE_OK,
+ Ok(_) => mp4parse_status::OK,
Err(Error::NoMoov) | Err(Error::InvalidData(_)) => {
// Block further calls. We've probable lost sync.
(*parser).set_poisoned(true);
- MP4PARSE_ERROR_INVALID
+ mp4parse_status::INVALID
}
- Err(Error::Unsupported(_)) => MP4PARSE_ERROR_UNSUPPORTED,
- Err(Error::UnexpectedEOF) => MP4PARSE_ERROR_EOF,
+ Err(Error::Unsupported(_)) => mp4parse_status::UNSUPPORTED,
+ Err(Error::UnexpectedEOF) => mp4parse_status::EOF,
Err(Error::Io(_)) => {
// Block further calls after a read failure.
// Getting std::io::ErrorKind::UnexpectedEof is normal
// but our From trait implementation should have converted
// those to our Error::UnexpectedEOF variant.
(*parser).set_poisoned(true);
- MP4PARSE_ERROR_IO
+ mp4parse_status::IO
}
}
}
/// Return the number of tracks parsed by previous `mp4parse_read()` call.
#[no_mangle]
-pub unsafe extern fn mp4parse_get_track_count(parser: *const mp4parse_parser, count: *mut u32) -> mp4parse_error {
+pub unsafe extern fn mp4parse_get_track_count(parser: *const mp4parse_parser, count: *mut u32) -> mp4parse_status {
// Validate arguments from C.
if parser.is_null() || count.is_null() || (*parser).poisoned() {
- return MP4PARSE_ERROR_BADARG;
+ return mp4parse_status::BAD_ARG;
}
let context = (*parser).context();
// Make sure the track count fits in a u32.
if context.tracks.len() > u32::max_value() as usize {
- return MP4PARSE_ERROR_INVALID;
+ return mp4parse_status::INVALID;
}
*count = context.tracks.len() as u32;
- MP4PARSE_OK
+ mp4parse_status::OK
}
/// Calculate numerator * scale / denominator, if possible.
///
/// Applying the associativity of integer arithmetic, we divide first
/// and add the remainder after multiplying each term separately
/// to preserve precision while leaving more headroom. That is,
/// (n * s) / d is split into floor(n / d) * s + (n % d) * s / d.
@@ -398,143 +390,143 @@ fn track_time_to_us<T>(time: TrackScaled
where T: PrimInt + Zero {
assert_eq!(time.1, scale.1);
let microseconds_per_second = 1000000;
rational_scale::<T, u64>(time.0, scale.0, microseconds_per_second)
}
/// Fill the supplied `mp4parse_track_info` with metadata for `track`.
#[no_mangle]
-pub unsafe extern fn mp4parse_get_track_info(parser: *mut mp4parse_parser, track_index: u32, info: *mut mp4parse_track_info) -> mp4parse_error {
+pub unsafe extern fn mp4parse_get_track_info(parser: *mut mp4parse_parser, track_index: u32, info: *mut mp4parse_track_info) -> mp4parse_status {
if parser.is_null() || info.is_null() || (*parser).poisoned() {
- return MP4PARSE_ERROR_BADARG;
+ return mp4parse_status::BAD_ARG;
}
// Initialize fields to default values to ensure all fields are always valid.
*info = Default::default();
let context = (*parser).context_mut();
let track_index: usize = track_index as usize;
let info: &mut mp4parse_track_info = &mut *info;
if track_index >= context.tracks.len() {
- return MP4PARSE_ERROR_BADARG;
+ return mp4parse_status::BAD_ARG;
}
info.track_type = match context.tracks[track_index].track_type {
- TrackType::Video => MP4PARSE_TRACK_TYPE_VIDEO,
- TrackType::Audio => MP4PARSE_TRACK_TYPE_AUDIO,
- TrackType::Unknown => return MP4PARSE_ERROR_UNSUPPORTED,
+ TrackType::Video => mp4parse_track_type::VIDEO,
+ TrackType::Audio => mp4parse_track_type::AUDIO,
+ TrackType::Unknown => return mp4parse_status::UNSUPPORTED,
};
info.codec = match context.tracks[track_index].data {
Some(SampleEntry::Audio(ref audio)) => match audio.codec_specific {
AudioCodecSpecific::OpusSpecificBox(_) =>
- mp4parse_codec::MP4PARSE_CODEC_OPUS,
+ mp4parse_codec::OPUS,
AudioCodecSpecific::FLACSpecificBox(_) =>
- mp4parse_codec::MP4PARSE_CODEC_FLAC,
+ mp4parse_codec::FLAC,
AudioCodecSpecific::ES_Descriptor(ref esds) if esds.audio_codec == CodecType::AAC =>
- mp4parse_codec::MP4PARSE_CODEC_AAC,
+ mp4parse_codec::AAC,
AudioCodecSpecific::ES_Descriptor(ref esds) if esds.audio_codec == CodecType::MP3 =>
- mp4parse_codec::MP4PARSE_CODEC_MP3,
+ mp4parse_codec::MP3,
AudioCodecSpecific::ES_Descriptor(_) =>
- mp4parse_codec::MP4PARSE_CODEC_UNKNOWN,
+ mp4parse_codec::UNKNOWN,
AudioCodecSpecific::MP3 =>
- mp4parse_codec::MP4PARSE_CODEC_MP3,
+ mp4parse_codec::MP3,
},
Some(SampleEntry::Video(ref video)) => match video.codec_specific {
VideoCodecSpecific::VPxConfig(_) =>
- mp4parse_codec::MP4PARSE_CODEC_VP9,
+ mp4parse_codec::VP9,
VideoCodecSpecific::AVCConfig(_) =>
- mp4parse_codec::MP4PARSE_CODEC_AVC,
+ mp4parse_codec::AVC,
},
- _ => mp4parse_codec::MP4PARSE_CODEC_UNKNOWN,
+ _ => mp4parse_codec::UNKNOWN,
};
let track = &context.tracks[track_index];
if let (Some(track_timescale),
Some(context_timescale)) = (track.timescale,
context.timescale) {
let media_time =
match track.media_time.map_or(Some(0), |media_time| {
track_time_to_us(media_time, track_timescale) }) {
Some(time) => time as i64,
- None => return MP4PARSE_ERROR_INVALID,
+ None => return mp4parse_status::INVALID,
};
let empty_duration =
match track.empty_duration.map_or(Some(0), |empty_duration| {
media_time_to_us(empty_duration, context_timescale) }) {
Some(time) => time as i64,
- None => return MP4PARSE_ERROR_INVALID,
+ None => return mp4parse_status::INVALID,
};
info.media_time = media_time - empty_duration;
if let Some(track_duration) = track.duration {
match track_time_to_us(track_duration, track_timescale) {
Some(duration) => info.duration = duration,
- None => return MP4PARSE_ERROR_INVALID,
+ None => return mp4parse_status::INVALID,
}
} else {
// Duration unknown; stagefright returns 0 for this.
info.duration = 0
}
} else {
- return MP4PARSE_ERROR_INVALID
+ return mp4parse_status::INVALID
}
info.track_id = match track.track_id {
Some(track_id) => track_id,
- None => return MP4PARSE_ERROR_INVALID,
+ None => return mp4parse_status::INVALID,
};
- MP4PARSE_OK
+ mp4parse_status::OK
}
/// Fill the supplied `mp4parse_track_audio_info` with metadata for `track`.
#[no_mangle]
-pub unsafe extern fn mp4parse_get_track_audio_info(parser: *mut mp4parse_parser, track_index: u32, info: *mut mp4parse_track_audio_info) -> mp4parse_error {
+pub unsafe extern fn mp4parse_get_track_audio_info(parser: *mut mp4parse_parser, track_index: u32, info: *mut mp4parse_track_audio_info) -> mp4parse_status {
if parser.is_null() || info.is_null() || (*parser).poisoned() {
- return MP4PARSE_ERROR_BADARG;
+ return mp4parse_status::BAD_ARG;
}
// Initialize fields to default values to ensure all fields are always valid.
*info = Default::default();
let context = (*parser).context_mut();
if track_index as usize >= context.tracks.len() {
- return MP4PARSE_ERROR_BADARG;
+ return mp4parse_status::BAD_ARG;
}
let track = &context.tracks[track_index as usize];
match track.track_type {
TrackType::Audio => {}
- _ => return MP4PARSE_ERROR_INVALID,
+ _ => return mp4parse_status::INVALID,
};
let audio = match track.data {
Some(ref data) => data,
- None => return MP4PARSE_ERROR_INVALID,
+ None => return mp4parse_status::INVALID,
};
let audio = match *audio {
SampleEntry::Audio(ref x) => x,
- _ => return MP4PARSE_ERROR_INVALID,
+ _ => return mp4parse_status::INVALID,
};
(*info).channels = audio.channelcount;
(*info).bit_depth = audio.samplesize;
(*info).sample_rate = audio.samplerate >> 16; // 16.16 fixed point
match audio.codec_specific {
AudioCodecSpecific::ES_Descriptor(ref v) => {
if v.codec_esds.len() > std::u32::MAX as usize {
- return MP4PARSE_ERROR_INVALID;
+ return mp4parse_status::INVALID;
}
(*info).codec_specific_config.length = v.codec_esds.len() as u32;
(*info).codec_specific_config.data = v.codec_esds.as_ptr();
(*info).codec_specific_data.length = v.decoder_specific_data.len() as u32;
(*info).codec_specific_data.data = v.decoder_specific_data.as_ptr();
if let Some(rate) = v.audio_sample_rate {
(*info).sample_rate = rate;
}
@@ -544,33 +536,33 @@ pub unsafe extern fn mp4parse_get_track_
if let Some(profile) = v.audio_object_type {
(*info).profile = profile;
}
}
AudioCodecSpecific::FLACSpecificBox(ref flac) => {
// Return the STREAMINFO metadata block in the codec_specific.
let streaminfo = &flac.blocks[0];
if streaminfo.block_type != 0 || streaminfo.data.len() != 34 {
- return MP4PARSE_ERROR_INVALID;
+ return mp4parse_status::INVALID;
}
(*info).codec_specific_config.length = streaminfo.data.len() as u32;
(*info).codec_specific_config.data = streaminfo.data.as_ptr();
}
AudioCodecSpecific::OpusSpecificBox(ref opus) => {
let mut v = Vec::new();
match serialize_opus_header(opus, &mut v) {
Err(_) => {
- return MP4PARSE_ERROR_INVALID;
+ return mp4parse_status::INVALID;
}
Ok(_) => {
let header = (*parser).opus_header_mut();
header.insert(track_index, v);
if let Some(v) = header.get(&track_index) {
if v.len() > std::u32::MAX as usize {
- return MP4PARSE_ERROR_INVALID;
+ return mp4parse_status::INVALID;
}
(*info).codec_specific_config.length = v.len() as u32;
(*info).codec_specific_config.data = v.as_ptr();
}
}
}
}
AudioCodecSpecific::MP3 => (),
@@ -579,104 +571,104 @@ pub unsafe extern fn mp4parse_get_track_
if let Some(p) = audio.protection_info.iter().find(|sinf| sinf.tenc.is_some()) {
if let Some(ref tenc) = p.tenc {
(*info).protected_data.is_encrypted = tenc.is_encrypted;
(*info).protected_data.iv_size = tenc.iv_size;
(*info).protected_data.kid.set_data(&(tenc.kid));
}
}
- MP4PARSE_OK
+ mp4parse_status::OK
}
/// Fill the supplied `mp4parse_track_video_info` with metadata for `track`.
#[no_mangle]
-pub unsafe extern fn mp4parse_get_track_video_info(parser: *mut mp4parse_parser, track_index: u32, info: *mut mp4parse_track_video_info) -> mp4parse_error {
+pub unsafe extern fn mp4parse_get_track_video_info(parser: *mut mp4parse_parser, track_index: u32, info: *mut mp4parse_track_video_info) -> mp4parse_status {
if parser.is_null() || info.is_null() || (*parser).poisoned() {
- return MP4PARSE_ERROR_BADARG;
+ return mp4parse_status::BAD_ARG;
}
// Initialize fields to default values to ensure all fields are always valid.
*info = Default::default();
let context = (*parser).context_mut();
if track_index as usize >= context.tracks.len() {
- return MP4PARSE_ERROR_BADARG;
+ return mp4parse_status::BAD_ARG;
}
let track = &context.tracks[track_index as usize];
match track.track_type {
TrackType::Video => {}
- _ => return MP4PARSE_ERROR_INVALID,
+ _ => return mp4parse_status::INVALID,
};
let video = match track.data {
Some(ref data) => data,
- None => return MP4PARSE_ERROR_INVALID,
+ None => return mp4parse_status::INVALID,
};
let video = match *video {
SampleEntry::Video(ref x) => x,
- _ => return MP4PARSE_ERROR_INVALID,
+ _ => return mp4parse_status::INVALID,
};
if let Some(ref tkhd) = track.tkhd {
(*info).display_width = tkhd.width >> 16; // 16.16 fixed point
(*info).display_height = tkhd.height >> 16; // 16.16 fixed point
let matrix = (tkhd.matrix.a >> 16, tkhd.matrix.b >> 16,
tkhd.matrix.c >> 16, tkhd.matrix.d >> 16);
(*info).rotation = match matrix {
( 0, 1, -1, 0) => 90, // rotate 90 degrees
(-1, 0, 0, -1) => 180, // rotate 180 degrees
( 0, -1, 1, 0) => 270, // rotate 270 degrees
_ => 0,
};
} else {
- return MP4PARSE_ERROR_INVALID;
+ return mp4parse_status::INVALID;
}
(*info).image_width = video.width;
(*info).image_height = video.height;
if let VideoCodecSpecific::AVCConfig(ref avc) = video.codec_specific {
(*info).extra_data.set_data(avc);
}
if let Some(p) = video.protection_info.iter().find(|sinf| sinf.tenc.is_some()) {
if let Some(ref tenc) = p.tenc {
(*info).protected_data.is_encrypted = tenc.is_encrypted;
(*info).protected_data.iv_size = tenc.iv_size;
(*info).protected_data.kid.set_data(&(tenc.kid));
}
}
- MP4PARSE_OK
+ mp4parse_status::OK
}
#[no_mangle]
-pub unsafe extern fn mp4parse_get_indice_table(parser: *mut mp4parse_parser, track_id: u32, indices: *mut mp4parse_byte_data) -> mp4parse_error {
+pub unsafe extern fn mp4parse_get_indice_table(parser: *mut mp4parse_parser, track_id: u32, indices: *mut mp4parse_byte_data) -> mp4parse_status {
if parser.is_null() || (*parser).poisoned() {
- return MP4PARSE_ERROR_BADARG;
+ return mp4parse_status::BAD_ARG;
}
// Initialize fields to default values to ensure all fields are always valid.
*indices = Default::default();
let context = (*parser).context();
let tracks = &context.tracks;
let track = match tracks.iter().find(|track| track.track_id == Some(track_id)) {
Some(t) => t,
- _ => return MP4PARSE_ERROR_INVALID,
+ _ => return mp4parse_status::INVALID,
};
let index_table = (*parser).sample_table_mut();
if let Some(v) = index_table.get(&track_id) {
(*indices).set_indices(v);
- return MP4PARSE_OK;
+ return mp4parse_status::OK;
}
let media_time = match (&track.media_time, &track.timescale) {
(&Some(t), &Some(s)) => {
track_time_to_us(t, s).map(|v| v as i64)
},
_ => None,
};
@@ -696,20 +688,20 @@ pub unsafe extern fn mp4parse_get_indice
(Some(e), None) => e,
(None, Some(m)) => m,
_ => 0,
};
if let Some(v) = create_sample_table(track, offset_time) {
(*indices).set_indices(&v);
index_table.insert(track_id, v);
- return MP4PARSE_OK;
+ return mp4parse_status::OK;
}
- MP4PARSE_ERROR_INVALID
+ mp4parse_status::INVALID
}
// Convert a 'ctts' compact table to full table by iterator,
// (sample_with_the_same_offset_count, offset) => (offset), (offset), (offset) ...
//
// For example:
// (2, 10), (4, 9) into (10, 10, 9, 9, 9, 9) by calling next_offset_time().
struct TimeOffsetIterator<'a> {
@@ -1007,108 +999,108 @@ fn create_sample_table(track: &Track, tr
}
}
Some(sample_table)
}
/// Fill the supplied `mp4parse_fragment_info` with metadata from fragmented file.
#[no_mangle]
-pub unsafe extern fn mp4parse_get_fragment_info(parser: *mut mp4parse_parser, info: *mut mp4parse_fragment_info) -> mp4parse_error {
+pub unsafe extern fn mp4parse_get_fragment_info(parser: *mut mp4parse_parser, info: *mut mp4parse_fragment_info) -> mp4parse_status {
if parser.is_null() || info.is_null() || (*parser).poisoned() {
- return MP4PARSE_ERROR_BADARG;
+ return mp4parse_status::BAD_ARG;
}
// Initialize fields to default values to ensure all fields are always valid.
*info = Default::default();
let context = (*parser).context();
let info: &mut mp4parse_fragment_info = &mut *info;
info.fragment_duration = 0;
let duration = match context.mvex {
Some(ref mvex) => mvex.fragment_duration,
- None => return MP4PARSE_ERROR_INVALID,
+ None => return mp4parse_status::INVALID,
};
if let (Some(time), Some(scale)) = (duration, context.timescale) {
info.fragment_duration = match media_time_to_us(time, scale) {
Some(time_us) => time_us as u64,
- None => return MP4PARSE_ERROR_INVALID,
+ None => return mp4parse_status::INVALID,
}
}
- MP4PARSE_OK
+ mp4parse_status::OK
}
/// A fragmented file needs mvex table and contains no data in stts, stsc, and stco boxes.
#[no_mangle]
-pub unsafe extern fn mp4parse_is_fragmented(parser: *mut mp4parse_parser, track_id: u32, fragmented: *mut u8) -> mp4parse_error {
+pub unsafe extern fn mp4parse_is_fragmented(parser: *mut mp4parse_parser, track_id: u32, fragmented: *mut u8) -> mp4parse_status {
if parser.is_null() || (*parser).poisoned() {
- return MP4PARSE_ERROR_BADARG;
+ return mp4parse_status::BAD_ARG;
}
let context = (*parser).context_mut();
let tracks = &context.tracks;
(*fragmented) = false as u8;
if context.mvex.is_none() {
- return MP4PARSE_OK;
+ return mp4parse_status::OK;
}
// check sample tables.
let mut iter = tracks.iter();
match iter.find(|track| track.track_id == Some(track_id)) {
Some(track) if track.empty_sample_boxes.all_empty() => (*fragmented) = true as u8,
Some(_) => {},
- None => return MP4PARSE_ERROR_BADARG,
+ None => return mp4parse_status::BAD_ARG,
}
- MP4PARSE_OK
+ mp4parse_status::OK
}
/// Get 'pssh' system id and 'pssh' box content for eme playback.
///
/// The data format of the `info` struct passed to gecko is:
///
/// - system id (16 byte uuid)
/// - pssh box size (32-bit native endian)
/// - pssh box content (including header)
#[no_mangle]
-pub unsafe extern fn mp4parse_get_pssh_info(parser: *mut mp4parse_parser, info: *mut mp4parse_pssh_info) -> mp4parse_error {
+pub unsafe extern fn mp4parse_get_pssh_info(parser: *mut mp4parse_parser, info: *mut mp4parse_pssh_info) -> mp4parse_status {
if parser.is_null() || info.is_null() || (*parser).poisoned() {
- return MP4PARSE_ERROR_BADARG;
+ return mp4parse_status::BAD_ARG;
}
// Initialize fields to default values to ensure all fields are always valid.
*info = Default::default();
let context = (*parser).context_mut();
let pssh_data = (*parser).pssh_data_mut();
let info: &mut mp4parse_pssh_info = &mut *info;
pssh_data.clear();
for pssh in &context.psshs {
let content_len = pssh.box_content.len();
if content_len > std::u32::MAX as usize {
- return MP4PARSE_ERROR_INVALID;
+ return mp4parse_status::INVALID;
}
let mut data_len = Vec::new();
if data_len.write_u32::<byteorder::NativeEndian>(content_len as u32).is_err() {
- return MP4PARSE_ERROR_IO;
+ return mp4parse_status::IO;
}
pssh_data.extend_from_slice(pssh.system_id.as_slice());
pssh_data.extend_from_slice(data_len.as_slice());
pssh_data.extend_from_slice(pssh.box_content.as_slice());
}
info.data.set_data(pssh_data);
- MP4PARSE_OK
+ mp4parse_status::OK
}
#[cfg(test)]
extern fn panic_read(_: *mut u8, _: usize, _: *mut std::os::raw::c_void) -> isize {
panic!("panic_read shouldn't be called in these tests");
}
#[cfg(test)]
@@ -1149,19 +1141,19 @@ fn free_null_parser() {
}
}
#[test]
fn get_track_count_null_parser() {
unsafe {
let mut count: u32 = 0;
let rv = mp4parse_get_track_count(std::ptr::null(), std::ptr::null_mut());
- assert_eq!(rv, MP4PARSE_ERROR_BADARG);
+ assert_eq!(rv, mp4parse_status::BAD_ARG);
let rv = mp4parse_get_track_count(std::ptr::null(), &mut count);
- assert_eq!(rv, MP4PARSE_ERROR_BADARG);
+ assert_eq!(rv, mp4parse_status::BAD_ARG);
}
}
#[test]
fn arg_validation() {
unsafe {
// Passing a null mp4parse_io is an error.
let parser = mp4parse_new(std::ptr::null());
@@ -1184,87 +1176,87 @@ fn arg_validation() {
let io = mp4parse_io {
read: None,
userdata: &mut dummy_value as *mut _ as *mut std::os::raw::c_void,
};
let parser = mp4parse_new(&io);
assert!(parser.is_null());
// Passing a null mp4parse_parser is an error.
- assert_eq!(MP4PARSE_ERROR_BADARG, mp4parse_read(std::ptr::null_mut()));
+ assert_eq!(mp4parse_status::BAD_ARG, mp4parse_read(std::ptr::null_mut()));
let mut dummy_info = mp4parse_track_info {
- track_type: MP4PARSE_TRACK_TYPE_VIDEO,
- codec: mp4parse_codec::MP4PARSE_CODEC_UNKNOWN,
+ track_type: mp4parse_track_type::VIDEO,
+ codec: mp4parse_codec::UNKNOWN,
track_id: 0,
duration: 0,
media_time: 0,
};
- assert_eq!(MP4PARSE_ERROR_BADARG, mp4parse_get_track_info(std::ptr::null_mut(), 0, &mut dummy_info));
+ assert_eq!(mp4parse_status::BAD_ARG, mp4parse_get_track_info(std::ptr::null_mut(), 0, &mut dummy_info));
let mut dummy_video = mp4parse_track_video_info {
display_width: 0,
display_height: 0,
image_width: 0,
image_height: 0,
rotation: 0,
extra_data: mp4parse_byte_data::default(),
protected_data: Default::default(),
};
- assert_eq!(MP4PARSE_ERROR_BADARG, mp4parse_get_track_video_info(std::ptr::null_mut(), 0, &mut dummy_video));
+ assert_eq!(mp4parse_status::BAD_ARG, mp4parse_get_track_video_info(std::ptr::null_mut(), 0, &mut dummy_video));
let mut dummy_audio = Default::default();
- assert_eq!(MP4PARSE_ERROR_BADARG, mp4parse_get_track_audio_info(std::ptr::null_mut(), 0, &mut dummy_audio));
+ assert_eq!(mp4parse_status::BAD_ARG, mp4parse_get_track_audio_info(std::ptr::null_mut(), 0, &mut dummy_audio));
}
}
#[test]
fn arg_validation_with_parser() {
unsafe {
let mut dummy_value = 42;
let io = mp4parse_io {
read: Some(error_read),
userdata: &mut dummy_value as *mut _ as *mut std::os::raw::c_void,
};
let parser = mp4parse_new(&io);
assert!(!parser.is_null());
// Our mp4parse_io read should simply fail with an error.
- assert_eq!(MP4PARSE_ERROR_IO, mp4parse_read(parser));
+ assert_eq!(mp4parse_status::IO, mp4parse_read(parser));
// The parser is now poisoned and unusable.
- assert_eq!(MP4PARSE_ERROR_BADARG, mp4parse_read(parser));
+ assert_eq!(mp4parse_status::BAD_ARG, mp4parse_read(parser));
// Null info pointers are an error.
- assert_eq!(MP4PARSE_ERROR_BADARG, mp4parse_get_track_info(parser, 0, std::ptr::null_mut()));
- assert_eq!(MP4PARSE_ERROR_BADARG, mp4parse_get_track_video_info(parser, 0, std::ptr::null_mut()));
- assert_eq!(MP4PARSE_ERROR_BADARG, mp4parse_get_track_audio_info(parser, 0, std::ptr::null_mut()));
+ assert_eq!(mp4parse_status::BAD_ARG, mp4parse_get_track_info(parser, 0, std::ptr::null_mut()));
+ assert_eq!(mp4parse_status::BAD_ARG, mp4parse_get_track_video_info(parser, 0, std::ptr::null_mut()));
+ assert_eq!(mp4parse_status::BAD_ARG, mp4parse_get_track_audio_info(parser, 0, std::ptr::null_mut()));
let mut dummy_info = mp4parse_track_info {
- track_type: MP4PARSE_TRACK_TYPE_VIDEO,
- codec: mp4parse_codec::MP4PARSE_CODEC_UNKNOWN,
+ track_type: mp4parse_track_type::VIDEO,
+ codec: mp4parse_codec::UNKNOWN,
track_id: 0,
duration: 0,
media_time: 0,
};
- assert_eq!(MP4PARSE_ERROR_BADARG, mp4parse_get_track_info(parser, 0, &mut dummy_info));
+ assert_eq!(mp4parse_status::BAD_ARG, mp4parse_get_track_info(parser, 0, &mut dummy_info));
let mut dummy_video = mp4parse_track_video_info {
display_width: 0,
display_height: 0,
image_width: 0,
image_height: 0,
rotation: 0,
extra_data: mp4parse_byte_data::default(),
protected_data: Default::default(),
};
- assert_eq!(MP4PARSE_ERROR_BADARG, mp4parse_get_track_video_info(parser, 0, &mut dummy_video));
+ assert_eq!(mp4parse_status::BAD_ARG, mp4parse_get_track_video_info(parser, 0, &mut dummy_video));
let mut dummy_audio = Default::default();
- assert_eq!(MP4PARSE_ERROR_BADARG, mp4parse_get_track_audio_info(parser, 0, &mut dummy_audio));
+ assert_eq!(mp4parse_status::BAD_ARG, mp4parse_get_track_audio_info(parser, 0, &mut dummy_audio));
mp4parse_free(parser);
}
}
#[test]
fn get_track_count_poisoned_parser() {
unsafe {
@@ -1272,112 +1264,112 @@ fn get_track_count_poisoned_parser() {
let io = mp4parse_io {
read: Some(error_read),
userdata: &mut dummy_value as *mut _ as *mut std::os::raw::c_void,
};
let parser = mp4parse_new(&io);
assert!(!parser.is_null());
// Our mp4parse_io read should simply fail with an error.
- assert_eq!(MP4PARSE_ERROR_IO, mp4parse_read(parser));
+ assert_eq!(mp4parse_status::IO, mp4parse_read(parser));
let mut count: u32 = 0;
let rv = mp4parse_get_track_count(parser, &mut count);
- assert_eq!(rv, MP4PARSE_ERROR_BADARG);
+ assert_eq!(rv, mp4parse_status::BAD_ARG);
}
}
#[test]
fn arg_validation_with_data() {
unsafe {
let mut file = std::fs::File::open("../mp4parse/tests/minimal.mp4").unwrap();
let io = mp4parse_io { read: Some(valid_read),
userdata: &mut file as *mut _ as *mut std::os::raw::c_void };
let parser = mp4parse_new(&io);
assert!(!parser.is_null());
- assert_eq!(MP4PARSE_OK, mp4parse_read(parser));
+ assert_eq!(mp4parse_status::OK, mp4parse_read(parser));
let mut count: u32 = 0;
- assert_eq!(MP4PARSE_OK, mp4parse_get_track_count(parser, &mut count));
+ assert_eq!(mp4parse_status::OK, mp4parse_get_track_count(parser, &mut count));
assert_eq!(2, count);
let mut info = mp4parse_track_info {
- track_type: MP4PARSE_TRACK_TYPE_VIDEO,
- codec: mp4parse_codec::MP4PARSE_CODEC_UNKNOWN,
+ track_type: mp4parse_track_type::VIDEO,
+ codec: mp4parse_codec::UNKNOWN,
track_id: 0,
duration: 0,
media_time: 0,
};
- assert_eq!(MP4PARSE_OK, mp4parse_get_track_info(parser, 0, &mut info));
- assert_eq!(info.track_type, MP4PARSE_TRACK_TYPE_VIDEO);
- assert_eq!(info.codec, mp4parse_codec::MP4PARSE_CODEC_AVC);
+ assert_eq!(mp4parse_status::OK, mp4parse_get_track_info(parser, 0, &mut info));
+ assert_eq!(info.track_type, mp4parse_track_type::VIDEO);
+ assert_eq!(info.codec, mp4parse_codec::AVC);
assert_eq!(info.track_id, 1);
assert_eq!(info.duration, 40000);
assert_eq!(info.media_time, 0);
- assert_eq!(MP4PARSE_OK, mp4parse_get_track_info(parser, 1, &mut info));
- assert_eq!(info.track_type, MP4PARSE_TRACK_TYPE_AUDIO);
- assert_eq!(info.codec, mp4parse_codec::MP4PARSE_CODEC_AAC);
+ assert_eq!(mp4parse_status::OK, mp4parse_get_track_info(parser, 1, &mut info));
+ assert_eq!(info.track_type, mp4parse_track_type::AUDIO);
+ assert_eq!(info.codec, mp4parse_codec::AAC);
assert_eq!(info.track_id, 2);
assert_eq!(info.duration, 61333);
assert_eq!(info.media_time, 21333);
let mut video = mp4parse_track_video_info {
display_width: 0,
display_height: 0,
image_width: 0,
image_height: 0,
rotation: 0,
extra_data: mp4parse_byte_data::default(),
protected_data: Default::default(),
};
- assert_eq!(MP4PARSE_OK, mp4parse_get_track_video_info(parser, 0, &mut video));
+ assert_eq!(mp4parse_status::OK, mp4parse_get_track_video_info(parser, 0, &mut video));
assert_eq!(video.display_width, 320);
assert_eq!(video.display_height, 240);
assert_eq!(video.image_width, 320);
assert_eq!(video.image_height, 240);
let mut audio = Default::default();
- assert_eq!(MP4PARSE_OK, mp4parse_get_track_audio_info(parser, 1, &mut audio));
+ assert_eq!(mp4parse_status::OK, mp4parse_get_track_audio_info(parser, 1, &mut audio));
assert_eq!(audio.channels, 1);
assert_eq!(audio.bit_depth, 16);
assert_eq!(audio.sample_rate, 48000);
// Test with an invalid track number.
let mut info = mp4parse_track_info {
- track_type: MP4PARSE_TRACK_TYPE_VIDEO,
- codec: mp4parse_codec::MP4PARSE_CODEC_UNKNOWN,
+ track_type: mp4parse_track_type::VIDEO,
+ codec: mp4parse_codec::UNKNOWN,
track_id: 0,
duration: 0,
media_time: 0,
};
- assert_eq!(MP4PARSE_ERROR_BADARG, mp4parse_get_track_info(parser, 3, &mut info));
- assert_eq!(info.track_type, MP4PARSE_TRACK_TYPE_VIDEO);
- assert_eq!(info.codec, mp4parse_codec::MP4PARSE_CODEC_UNKNOWN);
+ assert_eq!(mp4parse_status::BAD_ARG, mp4parse_get_track_info(parser, 3, &mut info));
+ assert_eq!(info.track_type, mp4parse_track_type::VIDEO);
+ assert_eq!(info.codec, mp4parse_codec::UNKNOWN);
assert_eq!(info.track_id, 0);
assert_eq!(info.duration, 0);
assert_eq!(info.media_time, 0);
let mut video = mp4parse_track_video_info { display_width: 0,
display_height: 0,
image_width: 0,
image_height: 0,
rotation: 0,
extra_data: mp4parse_byte_data::default(),
protected_data: Default::default(),
};
- assert_eq!(MP4PARSE_ERROR_BADARG, mp4parse_get_track_video_info(parser, 3, &mut video));
+ assert_eq!(mp4parse_status::BAD_ARG, mp4parse_get_track_video_info(parser, 3, &mut video));
assert_eq!(video.display_width, 0);
assert_eq!(video.display_height, 0);
assert_eq!(video.image_width, 0);
assert_eq!(video.image_height, 0);
let mut audio = Default::default();
- assert_eq!(MP4PARSE_ERROR_BADARG, mp4parse_get_track_audio_info(parser, 3, &mut audio));
+ assert_eq!(mp4parse_status::BAD_ARG, mp4parse_get_track_audio_info(parser, 3, &mut audio));
assert_eq!(audio.channels, 0);
assert_eq!(audio.bit_depth, 0);
assert_eq!(audio.sample_rate, 0);
mp4parse_free(parser);
}
}
