1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #ifndef MEDIA_MP4_BOX_READER_H_
6 #define MEDIA_MP4_BOX_READER_H_
7
8 #include <map>
9 #include <vector>
10
11 #include "base/compiler_specific.h"
12 #include "base/logging.h"
13 #include "media/base/media_export.h"
14 #include "media/base/media_log.h"
15 #include "media/mp4/fourccs.h"
16 #include "media/mp4/rcheck.h"
17
18 namespace media {
19 namespace mp4 {
20
21 class BoxReader;
22
23 struct MEDIA_EXPORT Box {
24 virtual ~Box();
25 virtual bool Parse(BoxReader* reader) = 0;
26 virtual FourCC BoxType() const = 0;
27 };
28
29 class MEDIA_EXPORT BufferReader {
30 public:
BufferReader(const uint8 * buf,const int size)31 BufferReader(const uint8* buf, const int size)
32 : buf_(buf), size_(size), pos_(0) {}
33
HasBytes(int count)34 bool HasBytes(int count) { return (pos() + count <= size()); }
35
36 // Read a value from the stream, perfoming endian correction, and advance the
37 // stream pointer.
38 bool Read1(uint8* v) WARN_UNUSED_RESULT;
39 bool Read2(uint16* v) WARN_UNUSED_RESULT;
40 bool Read2s(int16* v) WARN_UNUSED_RESULT;
41 bool Read4(uint32* v) WARN_UNUSED_RESULT;
42 bool Read4s(int32* v) WARN_UNUSED_RESULT;
43 bool Read8(uint64* v) WARN_UNUSED_RESULT;
44 bool Read8s(int64* v) WARN_UNUSED_RESULT;
45
46 bool ReadFourCC(FourCC* v) WARN_UNUSED_RESULT;
47
48 bool ReadVec(std::vector<uint8>* t, int count) WARN_UNUSED_RESULT;
49
50 // These variants read a 4-byte integer of the corresponding signedness and
51 // store it in the 8-byte return type.
52 bool Read4Into8(uint64* v) WARN_UNUSED_RESULT;
53 bool Read4sInto8s(int64* v) WARN_UNUSED_RESULT;
54
55 // Advance the stream by this many bytes.
56 bool SkipBytes(int nbytes) WARN_UNUSED_RESULT;
57
data()58 const uint8* data() const { return buf_; }
size()59 int size() const { return size_; }
pos()60 int pos() const { return pos_; }
61
62 protected:
63 const uint8* buf_;
64 int size_;
65 int pos_;
66
67 template<typename T> bool Read(T* t) WARN_UNUSED_RESULT;
68 };
69
70 class MEDIA_EXPORT BoxReader : public BufferReader {
71 public:
72 ~BoxReader();
73
74 // Create a BoxReader from a buffer. Note that this function may return NULL
75 // if an intact, complete box was not available in the buffer. If |*err| is
76 // set, there was a stream-level error when creating the box; otherwise, NULL
77 // values are only expected when insufficient data is available.
78 //
79 // |buf| is retained but not owned, and must outlive the BoxReader instance.
80 static BoxReader* ReadTopLevelBox(const uint8* buf,
81 const int buf_size,
82 const LogCB& log_cb,
83 bool* err);
84
85 // Read the box header from the current buffer. This function returns true if
86 // there is enough data to read the header and the header is sane; that is, it
87 // does not check to ensure the entire box is in the buffer before returning
88 // true. The semantics of |*err| are the same as above.
89 //
90 // |buf| is not retained.
91 static bool StartTopLevelBox(const uint8* buf,
92 const int buf_size,
93 const LogCB& log_cb,
94 FourCC* type,
95 int* box_size,
96 bool* err) WARN_UNUSED_RESULT;
97
98 // Returns true if |type| is recognized to be a top-level box, false
99 // otherwise. This returns true for some boxes which we do not parse.
100 // Helpful in debugging misaligned appends.
101 static bool IsValidTopLevelBox(const FourCC& type,
102 const LogCB& log_cb);
103
104 // Scan through all boxes within the current box, starting at the current
105 // buffer position. Must be called before any of the *Child functions work.
106 bool ScanChildren() WARN_UNUSED_RESULT;
107
108 // Read exactly one child box from the set of children. The type of the child
109 // will be determined by the BoxType() method of |child|.
110 bool ReadChild(Box* child) WARN_UNUSED_RESULT;
111
112 // Read one child if available. Returns false on error, true on successful
113 // read or on child absent.
114 bool MaybeReadChild(Box* child) WARN_UNUSED_RESULT;
115
116 // Read at least one child. False means error or no such child present.
117 template<typename T> bool ReadChildren(
118 std::vector<T>* children) WARN_UNUSED_RESULT;
119
120 // Read any number of children. False means error.
121 template<typename T> bool MaybeReadChildren(
122 std::vector<T>* children) WARN_UNUSED_RESULT;
123
124 // Read all children, regardless of FourCC. This is used from exactly one box,
125 // corresponding to a rather significant inconsistency in the BMFF spec.
126 // Note that this method is mutually exclusive with ScanChildren().
127 template<typename T> bool ReadAllChildren(
128 std::vector<T>* children) WARN_UNUSED_RESULT;
129
130 // Populate the values of 'version()' and 'flags()' from a full box header.
131 // Many boxes, but not all, use these values. This call should happen after
132 // the box has been initialized, and does not re-read the main box header.
133 bool ReadFullBoxHeader() WARN_UNUSED_RESULT;
134
type()135 FourCC type() const { return type_; }
version()136 uint8 version() const { return version_; }
flags()137 uint32 flags() const { return flags_; }
138
139 private:
140 BoxReader(const uint8* buf, const int size, const LogCB& log_cb);
141
142 // Must be called immediately after init. If the return is false, this
143 // indicates that the box header and its contents were not available in the
144 // stream or were nonsensical, and that the box must not be used further. In
145 // this case, if |*err| is false, the problem was simply a lack of data, and
146 // should only be an error condition if some higher-level component knows that
147 // no more data is coming (i.e. EOS or end of containing box). If |*err| is
148 // true, the error is unrecoverable and the stream should be aborted.
149 bool ReadHeader(bool* err);
150
151 LogCB log_cb_;
152 FourCC type_;
153 uint8 version_;
154 uint32 flags_;
155
156 typedef std::multimap<FourCC, BoxReader> ChildMap;
157
158 // The set of child box FourCCs and their corresponding buffer readers. Only
159 // valid if scanned_ is true.
160 ChildMap children_;
161 bool scanned_;
162 };
163
164 // Template definitions
ReadChildren(std::vector<T> * children)165 template<typename T> bool BoxReader::ReadChildren(std::vector<T>* children) {
166 RCHECK(MaybeReadChildren(children) && !children->empty());
167 return true;
168 }
169
170 template<typename T>
MaybeReadChildren(std::vector<T> * children)171 bool BoxReader::MaybeReadChildren(std::vector<T>* children) {
172 DCHECK(scanned_);
173 DCHECK(children->empty());
174
175 children->resize(1);
176 FourCC child_type = (*children)[0].BoxType();
177
178 ChildMap::iterator start_itr = children_.lower_bound(child_type);
179 ChildMap::iterator end_itr = children_.upper_bound(child_type);
180 children->resize(std::distance(start_itr, end_itr));
181 typename std::vector<T>::iterator child_itr = children->begin();
182 for (ChildMap::iterator itr = start_itr; itr != end_itr; ++itr) {
183 RCHECK(child_itr->Parse(&itr->second));
184 ++child_itr;
185 }
186 children_.erase(start_itr, end_itr);
187
188 DVLOG(2) << "Found " << children->size() << " "
189 << FourCCToString(child_type) << " boxes.";
190 return true;
191 }
192
193 template<typename T>
ReadAllChildren(std::vector<T> * children)194 bool BoxReader::ReadAllChildren(std::vector<T>* children) {
195 DCHECK(!scanned_);
196 scanned_ = true;
197
198 bool err = false;
199 while (pos() < size()) {
200 BoxReader child_reader(&buf_[pos_], size_ - pos_, log_cb_);
201 if (!child_reader.ReadHeader(&err)) break;
202 T child;
203 RCHECK(child.Parse(&child_reader));
204 children->push_back(child);
205 pos_ += child_reader.size();
206 }
207
208 return !err;
209 }
210
211 } // namespace mp4
212 } // namespace media
213
214 #endif // MEDIA_MP4_BOX_READER_H_
215