61
|
1 /*
|
|
2 * The contents of this file are subject to the Mozilla Public
|
|
3 * License Version 1.1 (the "License"); you may not use this file
|
|
4 * except in compliance with the License. You may obtain a copy of
|
|
5 * the License at http://www.mozilla.org/MPL/
|
|
6 *
|
|
7 * Software distributed under the License is distributed on an "AS
|
|
8 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
9 * implied. See the License for the specific language governing
|
|
10 * rights and limitations under the License.
|
|
11 *
|
|
12 * The Original Code is MPEG4IP.
|
|
13 *
|
|
14 * The Initial Developer of the Original Code is Cisco Systems Inc.
|
|
15 * Portions created by Cisco Systems Inc. are
|
|
16 * Copyright (C) Cisco Systems Inc. 2001 - 2004. All Rights Reserved.
|
|
17 *
|
|
18 * 3GPP features implementation is based on 3GPP's TS26.234-v5.60,
|
|
19 * and was contributed by Ximpo Group Ltd.
|
|
20 *
|
|
21 * Portions created by Ximpo Group Ltd. are
|
|
22 * Copyright (C) Ximpo Group Ltd. 2003, 2004. All Rights Reserved.
|
|
23 *
|
|
24 * Contributor(s):
|
|
25 * Dave Mackie dmackie@cisco.com
|
|
26 * Ximpo Group Ltd. mp4v2@ximpo.com
|
|
27 */
|
|
28
|
|
29 #ifndef __MP4_ATOM_INCLUDED__
|
|
30 #define __MP4_ATOM_INCLUDED__
|
|
31
|
|
32 class MP4Atom;
|
|
33 MP4ARRAY_DECL(MP4Atom, MP4Atom*);
|
|
34
|
|
35 #define Required true
|
|
36 #define Optional false
|
|
37 #define OnlyOne true
|
|
38 #define Many false
|
|
39 #define Counted true
|
|
40
|
|
41 /* helper class */
|
|
42 class MP4AtomInfo {
|
|
43 public:
|
|
44 MP4AtomInfo() {
|
|
45 m_name = NULL;
|
|
46 }
|
|
47 MP4AtomInfo(const char* name, bool mandatory, bool onlyOne);
|
|
48
|
|
49 const char* m_name;
|
|
50 bool m_mandatory;
|
|
51 bool m_onlyOne;
|
|
52 u_int32_t m_count;
|
|
53 };
|
|
54
|
|
55 MP4ARRAY_DECL(MP4AtomInfo, MP4AtomInfo*);
|
|
56
|
|
57 class MP4Atom {
|
|
58 public:
|
|
59 MP4Atom(const char* type = NULL);
|
|
60 virtual ~MP4Atom();
|
|
61
|
|
62 static MP4Atom* ReadAtom(MP4File* pFile, MP4Atom* pParentAtom);
|
|
63 static MP4Atom* CreateAtom(const char* type);
|
|
64 static bool IsReasonableType(const char* type);
|
|
65
|
|
66 MP4File* GetFile() {
|
|
67 return m_pFile;
|
|
68 };
|
|
69 void SetFile(MP4File* pFile) {
|
|
70 m_pFile = pFile;
|
|
71 };
|
|
72
|
|
73 u_int64_t GetStart() {
|
|
74 return m_start;
|
|
75 };
|
|
76 void SetStart(u_int64_t pos) {
|
|
77 m_start = pos;
|
|
78 };
|
|
79
|
|
80 u_int64_t GetEnd() {
|
|
81 return m_end;
|
|
82 };
|
|
83 void SetEnd(u_int64_t pos) {
|
|
84 m_end = pos;
|
|
85 };
|
|
86
|
|
87 u_int64_t GetSize() {
|
|
88 return m_size;
|
|
89 }
|
|
90 void SetSize(u_int64_t size) {
|
|
91 m_size = size;
|
|
92 }
|
|
93
|
|
94 const char* GetType() {
|
|
95 return m_type;
|
|
96 };
|
|
97 void SetType(const char* type) {
|
|
98 if (type && *type != '\0') {
|
|
99 // not needed ASSERT(strlen(type) == 4);
|
|
100 memcpy(m_type, type, 4);
|
|
101 m_type[4] = '\0';
|
|
102 } else {
|
|
103 memset(m_type, 0, 5);
|
|
104 }
|
|
105 }
|
|
106
|
|
107 void GetExtendedType(u_int8_t* pExtendedType) {
|
|
108 memcpy(pExtendedType, m_extendedType, sizeof(m_extendedType));
|
|
109 };
|
|
110 void SetExtendedType(u_int8_t* pExtendedType) {
|
|
111 memcpy(m_extendedType, pExtendedType, sizeof(m_extendedType));
|
|
112 };
|
|
113
|
|
114 bool IsUnknownType() {
|
|
115 return m_unknownType;
|
|
116 }
|
|
117 void SetUnknownType(bool unknownType = true) {
|
|
118 m_unknownType = unknownType;
|
|
119 }
|
|
120
|
|
121 bool IsRootAtom() {
|
|
122 return m_type[0] == '\0';
|
|
123 }
|
|
124
|
|
125 MP4Atom* GetParentAtom() {
|
|
126 return m_pParentAtom;
|
|
127 }
|
|
128 void SetParentAtom(MP4Atom* pParentAtom) {
|
|
129 m_pParentAtom = pParentAtom;
|
|
130 }
|
|
131
|
|
132 void AddChildAtom(MP4Atom* pChildAtom) {
|
|
133 pChildAtom->SetFile(m_pFile);
|
|
134 pChildAtom->SetParentAtom(this);
|
|
135 m_pChildAtoms.Add(pChildAtom);
|
|
136 }
|
|
137
|
|
138 void InsertChildAtom(MP4Atom* pChildAtom, u_int32_t index) {
|
|
139 pChildAtom->SetFile(m_pFile);
|
|
140 pChildAtom->SetParentAtom(this);
|
|
141 m_pChildAtoms.Insert(pChildAtom, index);
|
|
142 }
|
|
143
|
|
144 void DeleteChildAtom(MP4Atom* pChildAtom) {
|
|
145 for (MP4ArrayIndex i = 0; i < m_pChildAtoms.Size(); i++) {
|
|
146 if (m_pChildAtoms[i] == pChildAtom) {
|
|
147 m_pChildAtoms.Delete(i);
|
|
148 return;
|
|
149 }
|
|
150 }
|
|
151 }
|
|
152
|
|
153 u_int32_t GetNumberOfChildAtoms() {
|
|
154 return m_pChildAtoms.Size();
|
|
155 }
|
|
156
|
|
157 MP4Atom* GetChildAtom(u_int32_t index) {
|
|
158 return m_pChildAtoms[index];
|
|
159 }
|
|
160
|
|
161 MP4Property* GetProperty(u_int32_t index) {
|
|
162 return m_pProperties[index];
|
|
163 }
|
|
164
|
|
165 MP4Atom* FindAtom(const char* name);
|
|
166
|
|
167 MP4Atom* FindChildAtom(const char* name);
|
|
168
|
|
169 bool FindProperty(const char* name,
|
|
170 MP4Property** ppProperty, u_int32_t* pIndex = NULL);
|
|
171
|
|
172 u_int32_t GetFlags();
|
|
173 void SetFlags(u_int32_t flags);
|
|
174
|
|
175 u_int8_t GetDepth();
|
|
176
|
|
177 void Skip();
|
|
178
|
|
179 virtual void Generate();
|
|
180 virtual void Read();
|
|
181 virtual void BeginWrite(bool use64 = false);
|
|
182 virtual void Write();
|
|
183 virtual void Rewrite();
|
|
184 virtual void FinishWrite(bool use64 = false);
|
|
185 virtual void Dump(FILE* pFile, u_int8_t indent, bool dumpImplicits);
|
|
186
|
|
187 protected:
|
|
188 void AddProperty(MP4Property* pProperty);
|
|
189
|
|
190 void AddVersionAndFlags();
|
|
191
|
|
192 void AddReserved(char* name, u_int32_t size);
|
|
193
|
|
194 void ExpectChildAtom(const char* name,
|
|
195 bool mandatory, bool onlyOne = true);
|
|
196
|
|
197 MP4AtomInfo* FindAtomInfo(const char* name);
|
|
198
|
|
199 bool IsMe(const char* name);
|
|
200
|
|
201 bool FindContainedProperty(const char* name,
|
|
202 MP4Property** ppProperty, u_int32_t* pIndex);
|
|
203
|
|
204 void ReadProperties(
|
|
205 u_int32_t startIndex = 0, u_int32_t count = 0xFFFFFFFF);
|
|
206 void ReadChildAtoms();
|
|
207
|
|
208 void WriteProperties(
|
|
209 u_int32_t startIndex = 0, u_int32_t count = 0xFFFFFFFF);
|
|
210 void WriteChildAtoms();
|
|
211
|
|
212 u_int8_t GetVersion();
|
|
213 void SetVersion(u_int8_t version);
|
|
214
|
|
215 /* debugging aid */
|
|
216 u_int32_t GetVerbosity();
|
|
217
|
|
218 protected:
|
|
219 MP4File* m_pFile;
|
|
220 u_int64_t m_start;
|
|
221 u_int64_t m_end;
|
|
222 u_int64_t m_size;
|
|
223 char m_type[5];
|
|
224 bool m_unknownType;
|
|
225 u_int8_t m_extendedType[16];
|
|
226
|
|
227 MP4Atom* m_pParentAtom;
|
|
228 u_int8_t m_depth;
|
|
229
|
|
230 MP4PropertyArray m_pProperties;
|
|
231 MP4AtomInfoArray m_pChildAtomInfos;
|
|
232 MP4AtomArray m_pChildAtoms;
|
|
233 };
|
|
234
|
|
235 inline u_int32_t ATOMID(const char* type) {
|
|
236 return STRTOINT32(type);
|
|
237 }
|
|
238
|
|
239 #endif /* __MP4_ATOM_INCLUDED__ */
|