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. All Rights Reserved.
|
|
17 *
|
|
18 * Contributor(s):
|
|
19 * Dave Mackie dmackie@cisco.com
|
|
20 */
|
|
21
|
|
22 #ifndef __RTPHINT_INCLUDED__
|
|
23 #define __RTPHINT_INCLUDED__
|
|
24
|
|
25 // forward declarations
|
|
26 class MP4RtpHintTrack;
|
|
27 class MP4RtpHint;
|
|
28 class MP4RtpPacket;
|
|
29
|
|
30 class MP4RtpData : public MP4Container {
|
|
31 public:
|
|
32 MP4RtpData(MP4RtpPacket* pPacket);
|
|
33
|
|
34 MP4RtpPacket* GetPacket() {
|
|
35 return m_pPacket;
|
|
36 }
|
|
37
|
|
38 virtual u_int16_t GetDataSize() = 0;
|
|
39 virtual void GetData(u_int8_t* pDest) = 0;
|
|
40
|
|
41 MP4Track* FindTrackFromRefIndex(u_int8_t refIndex);
|
|
42
|
|
43 virtual void WriteEmbeddedData(MP4File* pFile, u_int64_t startPos) {
|
|
44 // default is no-op
|
|
45 }
|
|
46
|
|
47 protected:
|
|
48 MP4RtpPacket* m_pPacket;
|
|
49 };
|
|
50
|
|
51 MP4ARRAY_DECL(MP4RtpData, MP4RtpData*)
|
|
52
|
|
53 class MP4RtpNullData : public MP4RtpData {
|
|
54 public:
|
|
55 MP4RtpNullData(MP4RtpPacket* pPacket);
|
|
56
|
|
57 u_int16_t GetDataSize() {
|
|
58 return 0;
|
|
59 }
|
|
60
|
|
61 void GetData(u_int8_t* pDest) {
|
|
62 // no-op
|
|
63 }
|
|
64 };
|
|
65
|
|
66 class MP4RtpImmediateData : public MP4RtpData {
|
|
67 public:
|
|
68 MP4RtpImmediateData(MP4RtpPacket* pPacket);
|
|
69
|
|
70 void Set(const u_int8_t* pBytes, u_int8_t numBytes);
|
|
71
|
|
72 u_int16_t GetDataSize();
|
|
73
|
|
74 void GetData(u_int8_t* pDest);
|
|
75 };
|
|
76
|
|
77 class MP4RtpSampleData : public MP4RtpData {
|
|
78 public:
|
|
79 MP4RtpSampleData(MP4RtpPacket* pPacket);
|
|
80
|
|
81 ~MP4RtpSampleData(void) {
|
|
82 CHECK_AND_FREE(m_pRefData);
|
|
83 };
|
|
84
|
|
85 void SetEmbeddedImmediate(
|
|
86 MP4SampleId sampleId,
|
|
87 u_int8_t* pData, u_int16_t dataLength);
|
|
88
|
|
89 void SetReferenceSample(
|
|
90 MP4SampleId refSampleId, u_int32_t refSampleOffset,
|
|
91 u_int16_t sampleLength);
|
|
92
|
|
93 void SetEmbeddedSample(
|
|
94 MP4SampleId sampleId, MP4Track* pRefTrack,
|
|
95 MP4SampleId refSampleId, u_int32_t refSampleOffset,
|
|
96 u_int16_t sampleLength);
|
|
97
|
|
98 u_int16_t GetDataSize();
|
|
99
|
|
100 void GetData(u_int8_t* pDest);
|
|
101
|
|
102 void WriteEmbeddedData(MP4File* pFile, u_int64_t startPos);
|
|
103
|
|
104 protected:
|
|
105 u_int8_t* m_pRefData;
|
|
106
|
|
107 MP4Track* m_pRefTrack;
|
|
108 MP4SampleId m_refSampleId;
|
|
109 u_int32_t m_refSampleOffset;
|
|
110 };
|
|
111
|
|
112 class MP4RtpSampleDescriptionData : public MP4RtpData {
|
|
113 public:
|
|
114 MP4RtpSampleDescriptionData(MP4RtpPacket* pPacket);
|
|
115
|
|
116 void Set(u_int32_t sampleDescrIndex,
|
|
117 u_int32_t offset, u_int16_t length);
|
|
118
|
|
119 u_int16_t GetDataSize();
|
|
120
|
|
121 void GetData(u_int8_t* pDest);
|
|
122 };
|
|
123
|
|
124 class MP4RtpPacket : public MP4Container {
|
|
125 public:
|
|
126 MP4RtpPacket(MP4RtpHint* pHint);
|
|
127
|
|
128 ~MP4RtpPacket();
|
|
129
|
|
130 void AddExtraProperties();
|
|
131
|
|
132 MP4RtpHint* GetHint() {
|
|
133 return m_pHint;
|
|
134 }
|
|
135
|
|
136 void Set(u_int8_t payloadNumber, u_int32_t packetId, bool setMbit);
|
|
137
|
|
138 int32_t GetTransmitOffset();
|
|
139
|
|
140 bool GetPBit();
|
|
141
|
|
142 bool GetXBit();
|
|
143
|
|
144 bool GetMBit();
|
|
145
|
|
146 u_int8_t GetPayload();
|
|
147
|
|
148 u_int16_t GetSequenceNumber();
|
|
149
|
|
150 void SetTransmitOffset(int32_t transmitOffset);
|
|
151
|
|
152 bool IsBFrame();
|
|
153
|
|
154 void SetBFrame(bool isBFrame);
|
|
155
|
|
156 void SetTimestampOffset(u_int32_t timestampOffset);
|
|
157
|
|
158 void AddData(MP4RtpData* pData);
|
|
159
|
|
160 u_int32_t GetDataSize();
|
|
161
|
|
162 void GetData(u_int8_t* pDest);
|
|
163
|
|
164 void Read(MP4File* pFile);
|
|
165
|
|
166 void ReadExtra(MP4File* pFile);
|
|
167
|
|
168 void Write(MP4File* pFile);
|
|
169
|
|
170 void WriteEmbeddedData(MP4File* pFile, u_int64_t startPos);
|
|
171
|
|
172 void Dump(FILE* pFile, u_int8_t indent, bool dumpImplicits);
|
|
173
|
|
174 protected:
|
|
175 MP4RtpHint* m_pHint;
|
|
176 MP4RtpDataArray m_rtpData;
|
|
177 };
|
|
178
|
|
179 MP4ARRAY_DECL(MP4RtpPacket, MP4RtpPacket*)
|
|
180
|
|
181 class MP4RtpHint : public MP4Container {
|
|
182 public:
|
|
183 MP4RtpHint(MP4RtpHintTrack* pTrack);
|
|
184
|
|
185 ~MP4RtpHint();
|
|
186
|
|
187 MP4RtpHintTrack* GetTrack() {
|
|
188 return m_pTrack;
|
|
189 }
|
|
190
|
|
191 u_int16_t GetNumberOfPackets() {
|
|
192 return m_rtpPackets.Size();
|
|
193 }
|
|
194
|
|
195 bool IsBFrame() {
|
|
196 return m_isBFrame;
|
|
197 }
|
|
198 void SetBFrame(bool isBFrame) {
|
|
199 m_isBFrame = isBFrame;
|
|
200 }
|
|
201
|
|
202 u_int32_t GetTimestampOffset() {
|
|
203 return m_timestampOffset;
|
|
204 }
|
|
205 void SetTimestampOffset(u_int32_t timestampOffset) {
|
|
206 m_timestampOffset = timestampOffset;
|
|
207 }
|
|
208
|
|
209 MP4RtpPacket* AddPacket();
|
|
210
|
|
211 MP4RtpPacket* GetPacket(u_int16_t index) {
|
|
212 return m_rtpPackets[index];
|
|
213 }
|
|
214
|
|
215 MP4RtpPacket* GetCurrentPacket() {
|
|
216 if (m_rtpPackets.Size() == 0) {
|
|
217 return NULL;
|
|
218 }
|
|
219 return m_rtpPackets[m_rtpPackets.Size() - 1];
|
|
220 }
|
|
221
|
|
222 void Read(MP4File* pFile);
|
|
223
|
|
224 void Write(MP4File* pFile);
|
|
225
|
|
226 void Dump(FILE* pFile, u_int8_t indent, bool dumpImplicits);
|
|
227
|
|
228 protected:
|
|
229 MP4RtpHintTrack* m_pTrack;
|
|
230 MP4RtpPacketArray m_rtpPackets;
|
|
231
|
|
232 // values when adding packets to a hint (write mode)
|
|
233 bool m_isBFrame;
|
|
234 u_int32_t m_timestampOffset;
|
|
235 };
|
|
236
|
|
237 class MP4RtpHintTrack : public MP4Track {
|
|
238 public:
|
|
239 MP4RtpHintTrack(MP4File* pFile, MP4Atom* pTrakAtom);
|
|
240
|
|
241 ~MP4RtpHintTrack();
|
|
242
|
|
243 void InitRefTrack();
|
|
244
|
|
245 void InitPayload();
|
|
246
|
|
247 void InitRtpStart();
|
|
248
|
|
249 void InitStats();
|
|
250
|
|
251 MP4Track* GetRefTrack() {
|
|
252 InitRefTrack();
|
|
253 return m_pRefTrack;
|
|
254 }
|
|
255
|
|
256 void GetPayload(
|
|
257 char** ppPayloadName = NULL,
|
|
258 u_int8_t* pPayloadNumber = NULL,
|
|
259 u_int16_t* pMaxPayloadSize = NULL,
|
|
260 char **ppEncodingParams = NULL);
|
|
261
|
|
262 void SetPayload(
|
|
263 const char* payloadName,
|
|
264 u_int8_t payloadNumber,
|
|
265 u_int16_t maxPayloadSize,
|
|
266 const char *encoding_parms,
|
|
267 bool add_rtpmap,
|
|
268 bool add_mpeg4_esid);
|
|
269
|
|
270 void ReadHint(
|
|
271 MP4SampleId hintSampleId,
|
|
272 u_int16_t* pNumPackets = NULL);
|
|
273
|
|
274 u_int16_t GetHintNumberOfPackets();
|
|
275
|
|
276 bool GetPacketBFrame(u_int16_t packetIndex);
|
|
277
|
|
278 u_int16_t GetPacketTransmitOffset(u_int16_t packetIndex);
|
|
279
|
|
280 void ReadPacket(
|
|
281 u_int16_t packetIndex,
|
|
282 u_int8_t** ppBytes,
|
|
283 u_int32_t* pNumBytes,
|
|
284 u_int32_t ssrc,
|
|
285 bool includeHeader = true,
|
|
286 bool includePayload = true);
|
|
287
|
|
288 MP4Timestamp GetRtpTimestampStart();
|
|
289
|
|
290 void SetRtpTimestampStart(MP4Timestamp start);
|
|
291
|
|
292 void AddHint(bool isBFrame, u_int32_t timestampOffset);
|
|
293
|
|
294 void AddPacket(bool setMbit, int32_t transmitOffset = 0);
|
|
295
|
|
296 void AddImmediateData(const u_int8_t* pBytes, u_int32_t numBytes);
|
|
297
|
|
298 void AddSampleData(MP4SampleId sampleId,
|
|
299 u_int32_t dataOffset, u_int32_t dataLength);
|
|
300
|
|
301 void AddESConfigurationPacket();
|
|
302
|
|
303 void WriteHint(MP4Duration duration, bool isSyncSample);
|
|
304
|
|
305 void FinishWrite();
|
|
306
|
|
307 protected:
|
|
308 MP4Track* m_pRefTrack;
|
|
309
|
|
310 MP4StringProperty* m_pRtpMapProperty;
|
|
311 MP4Integer32Property* m_pPayloadNumberProperty;
|
|
312 MP4Integer32Property* m_pMaxPacketSizeProperty;
|
|
313 MP4Integer32Property* m_pSnroProperty;
|
|
314 MP4Integer32Property* m_pTsroProperty;
|
|
315 u_int32_t m_rtpSequenceStart;
|
|
316 u_int32_t m_rtpTimestampStart;
|
|
317
|
|
318 // reading
|
|
319 MP4RtpHint* m_pReadHint;
|
|
320 u_int8_t* m_pReadHintSample;
|
|
321 u_int32_t m_readHintSampleSize;
|
|
322 MP4Timestamp m_readHintTimestamp;
|
|
323
|
|
324 // writing
|
|
325 MP4RtpHint* m_pWriteHint;
|
|
326 MP4SampleId m_writeHintId;
|
|
327 u_int32_t m_writePacketId;
|
|
328
|
|
329 // statistics
|
|
330 // in trak.udta.hinf
|
|
331 MP4Integer64Property* m_pTrpy;
|
|
332 MP4Integer64Property* m_pNump;
|
|
333 MP4Integer64Property* m_pTpyl;
|
|
334 MP4Integer32Property* m_pMaxr;
|
|
335 MP4Integer64Property* m_pDmed;
|
|
336 MP4Integer64Property* m_pDimm;
|
|
337 MP4Integer32Property* m_pPmax;
|
|
338 MP4Integer32Property* m_pDmax;
|
|
339
|
|
340 // in trak.mdia.minf.hmhd
|
|
341 MP4Integer16Property* m_pMaxPdu;
|
|
342 MP4Integer16Property* m_pAvgPdu;
|
|
343 MP4Integer32Property* m_pMaxBitRate;
|
|
344 MP4Integer32Property* m_pAvgBitRate;
|
|
345
|
|
346 MP4Timestamp m_thisSec;
|
|
347 u_int32_t m_bytesThisSec;
|
|
348 u_int32_t m_bytesThisHint;
|
|
349 u_int32_t m_bytesThisPacket;
|
|
350 };
|
|
351
|
|
352 #endif /* __RTPHINT_INCLUDED__ */
|