1use std::cmp::max;
2use std::marker::PhantomData;
3use crate::bytes_read::{Mp4Readable, Mp4VersionedReadable, ReadMp4};
4use crate::bytes_write::{FlagTrait, Mp4VersionedWritable, Mp4Writable, WriteMp4};
5use crate::error::MP4Error;
6use async_trait::async_trait;
7use num_traits::{AsPrimitive};
8
9#[derive(Debug, Clone, Eq, PartialEq, Hash, Default)]
10pub struct Mp4Array<I, T>(pub Vec<T>, pub PhantomData<I>)
11 where
12 I: AsPrimitive<usize> + Mp4Readable + Mp4Writable,
13 T: Mp4Readable + Mp4Writable,
14 usize: AsPrimitive<I>;
15
16impl<I, T> From<Vec<T>> for Mp4Array<I, T> where
17 I: AsPrimitive<usize> + Mp4Readable + Mp4Writable,
18 T: Mp4Readable + Mp4Writable,
19 usize: AsPrimitive<I> {
20 fn from(vec: Vec<T>) -> Self {
21 Self(vec, Default::default())
22 }
23}
24
25#[async_trait]
26impl<I, T> Mp4Readable for Mp4Array<I, T>
27 where
28 I: AsPrimitive<usize> + Mp4Readable + Mp4Writable + Send + Sync,
29 T: Mp4Readable + Mp4Writable + Send + Sync,
30 usize: AsPrimitive<I>
31{
32 async fn read<R: ReadMp4>(reader: &mut R) -> Result<Self, MP4Error> {
33 let i: I = reader.read().await?;
34 let mut vec = vec![];
35 for _ in 0..AsPrimitive::<usize>::as_(i) {
36 vec.push(reader.read().await?);
37 }
38 Ok(Self(vec, Default::default()))
39 }
40}
41
42impl<I, T> Mp4Writable for Mp4Array<I, T>
43 where
44 I: AsPrimitive<usize> + Mp4Readable + Mp4Writable + Send + Sync,
45 T: Mp4Readable + Mp4Writable + Send + Sync,
46 usize: AsPrimitive<I>
47{
48 fn byte_size(&self) -> usize {
49 AsPrimitive::<I>::as_(self.0.len()).byte_size() + self.0.iter().map(Mp4Writable::byte_size).sum::<usize>()
50 }
51
52 fn write<W: WriteMp4>(&self, writer: &mut W) -> Result<usize, MP4Error> {
53 let mut count = 0;
54 count += AsPrimitive::<I>::as_(self.0.len()).write(writer)?;
55 for elem in &self.0 {
56 count += elem.write(writer)?;
57 }
58 Ok(count)
59 }
60}
61
62#[derive(Debug, Clone, Eq, PartialEq, Hash, Default)]
63pub struct Mp4OffsetArray<I, O, T>
64 where
65 I: AsPrimitive<usize> + Mp4Readable + Mp4Writable,
66 usize: AsPrimitive<I>
67{
68 pub data: Vec<T>,
69 pub offset: O,
70 pub _p: PhantomData<I>,
71}
72
73impl<I, O, T> Mp4OffsetArray<I, O, T> where
74 I: AsPrimitive<usize> + Mp4Readable + Mp4Writable,
75 usize: AsPrimitive<I> {
76
77 pub fn new(data: Vec<T>, offset: O) -> Self {
78 Self { data, offset, _p: Default::default() }
79 }
80
81}
82
83#[async_trait]
84impl<I, O, T> Mp4Readable for Mp4OffsetArray<I, O, T> where
85 I: AsPrimitive<usize> + Mp4Readable + Mp4Writable + Send + Sync,
86 T: Mp4Readable + Mp4Writable + Send + Sync,
87 O: Mp4Readable + Mp4Writable + Send + Sync,
88 usize: AsPrimitive<I>
89{
90 async fn read<R: ReadMp4>(reader: &mut R) -> Result<Self, MP4Error> {
91 let i: I = reader.read().await?;
92 let offset: O = reader.read().await?;
93 let mut data = vec![];
94 for _ in 0..AsPrimitive::<usize>::as_(i) {
95 data.push(reader.read().await?);
96 }
97 Ok(Self { data, offset, _p: Default::default() })
98 }
99}
100
101impl<I, O, T> Mp4Writable for Mp4OffsetArray<I, O, T> where
102 I: AsPrimitive<usize> + Mp4Readable + Mp4Writable + Send + Sync,
103 T: Mp4Readable + Mp4Writable + Send + Sync,
104 O: Mp4Readable + Mp4Writable + Send + Sync,
105 usize: AsPrimitive<I>
106{
107 fn byte_size(&self) -> usize {
108 AsPrimitive::<I>::as_(self.data.len()).byte_size() + self.data.iter().map(Mp4Writable::byte_size).sum::<usize>() + self.offset.byte_size()
109 }
110
111 fn write<W: WriteMp4>(&self, writer: &mut W) -> Result<usize, MP4Error> {
112 let mut count = 0;
113 count += AsPrimitive::<I>::as_(self.data.len()).write(writer)?;
114 count += self.offset.write(writer)?;
115 for elem in &self.data {
116 count += elem.write(writer)?;
117 }
118 Ok(count)
119 }
120}
121
122#[derive(Default, Debug, Clone, Eq, PartialEq, Hash)]
123pub struct Mp4VersionedOffsetArray<I, O, T>
124 where
125 I: AsPrimitive<usize> + Mp4Readable + Mp4Writable,
126 usize: AsPrimitive<I>
127{
128 pub data: Vec<T>,
129 pub offset: O,
130 pub _p: PhantomData<I>,
131}
132
133impl<I, O, T> Mp4VersionedOffsetArray<I, O, T> where
134 I: AsPrimitive<usize> + Mp4Readable + Mp4Writable,
135 usize: AsPrimitive<I> {
136
137 pub fn new(data: Vec<T>, offset: O) -> Self {
138 Self { data, offset, _p: Default::default() }
139 }
140
141}
142
143#[async_trait]
144impl<I, O, T, F> Mp4VersionedReadable<F> for Mp4VersionedOffsetArray<I, O, T> where
145 I: AsPrimitive<usize> + Mp4Readable + Mp4Writable + Send + Sync,
146 T: Mp4VersionedReadable<F> + Mp4VersionedWritable<F> + Send + Sync,
147 O: Mp4VersionedReadable<F> + Mp4VersionedWritable<F> + Send + Sync,
148 F: FlagTrait,
149 usize: AsPrimitive<I>
150{
151 async fn versioned_read<R: ReadMp4>(version: u8, flags: F, reader: &mut R) -> Result<Self, MP4Error> {
152 let i: I = reader.read().await?;
153 let offset: O = reader.versioned_read(version, flags).await?;
154 let mut data = vec![];
155 for _ in 0..AsPrimitive::<usize>::as_(i) {
156 data.push(reader.versioned_read(version, flags).await?);
157 }
158 Ok(Self { data, offset, _p: Default::default() })
159 }
160}
161
162impl<I, O, T, F> Mp4VersionedWritable<F> for Mp4VersionedOffsetArray<I, O, T> where
163 I: AsPrimitive<usize> + Mp4Readable + Mp4Writable + Send + Sync,
164 T: Mp4VersionedReadable<F> + Mp4VersionedWritable<F> + Send + Sync,
165 O: Mp4VersionedReadable<F> + Mp4VersionedWritable<F> + Send + Sync,
166 F: FlagTrait,
167 usize: AsPrimitive<I>
168{
169 fn required_version(&self) -> u8 {
170 max(self.offset.required_version(), self.data.iter().map(Mp4VersionedWritable::required_version).max().unwrap_or_default())
171 }
172
173 fn required_flags(&self) -> F {
174 self.offset.required_flags() | self.data.iter().map(Mp4VersionedWritable::required_flags).reduce(F::bitor).unwrap_or_default()
175 }
176
177 fn versioned_byte_size(&self, version: u8, flags: F) -> usize {
178 AsPrimitive::<I>::as_(self.data.len()).byte_size() +
179 self.offset.versioned_byte_size(version, flags) +
180 self.data.iter().map(|it|it.versioned_byte_size(version, flags)).sum::<usize>()
181 }
182
183 fn versioned_write<W: WriteMp4>(&self, version: u8, flags: F, writer: &mut W) -> Result<usize, MP4Error> {
184 let mut count = 0;
185 count += AsPrimitive::<I>::as_(self.data.len()).write(writer)?;
186 count += self.offset.versioned_write(version, flags, writer)?;
187 for elem in &self.data {
188 count += elem.versioned_write(version, flags, writer)?;
189 }
190 Ok(count)
191 }
192}