Debian Codegraph @

lib/aviread/ReadStream.cpp

raw
1 #include "ReadStream.h"
2 #include "avm_output.h"
3 #include <string.h>
4 #include <stdlib.h>
5 #include <stdio.h>
6
7 #ifdef HAVE_MEMALIGN
8 #include <malloc.h> // memalign
9 #endif // HAVE_MEMALIGN
10
11 AVM_BEGIN_NAMESPACE;
12
13 #define __MODULE__ "reader"
14
15 StreamPacket::StreamPacket(size_t bsize, void* mem)
16 : memory((uint8_t*)mem), size(bsize), read(0), flags(0), timestamp(NO_TIMESTAMP),
17 refcount(1)
18 {
19 if (!memory && size > 0)
20 {
21 #ifdef HAVE_MEMALIGN
22 memory = (uint8_t*) memalign(16, size + 16);
23 #else
24 memory = (uint8_t*) malloc(size + 16);
25 #endif
26 }
27 }
28
29 StreamPacket::~StreamPacket()
30 {
31 //printf("******** Destroy stream packet %d\n", size);
32 assert(refcount == 0);
33 free(memory);
34 }
35
36 size_t StreamPacket::Read(void* to, size_t read_size)
37 {
38 if (read_size > GetSize())
39 read_size = GetSize();
40 if (to)
41 memcpy(to, GetData(), read_size);
42 read += read_size;
43 return read_size;
44 }
45
46 IStream::~IStream() {}
47
48 ReadStream::ReadStream(IMediaReadStream* stream)
49 : m_pStream(stream), m_pPacket(0), m_iEof(0),
50 rem_size(0), rem_local(0), rem_limit(0),
51 m_uiLastPos(0), m_dLastTime(0.)
52 {
53 assert(m_pStream != 0);
54 //assert(m_pStream->GetLength() < 0x7fffffff);
55
56 m_uiFormatSize = m_pStream->GetFormat();
57 m_pFormat = new char[m_uiFormatSize];
58 m_pStream->GetFormat(m_pFormat, m_uiFormatSize);
59
60 const char* tname;
61 switch (GetType())
62 {
63 case Video: tname = "video"; break;
64 case Audio: tname = "audio"; break;
65 default: tname = "unknown"; break;
66 }
67 AVM_WRITE(__MODULE__, "Initialized %s stream (chunk tblsz: %d, fmtsz: %" PRIsz ")\n",
68 tname, m_pStream->GetLength(), m_uiFormatSize);
69 }
70
71 ReadStream::~ReadStream()
72 {
73 delete[] m_pFormat;
74 if (m_pPacket)
75 m_pPacket->Release();
76 }
77
78 bool ReadStream::Eof() const
79 {
80 //printf("EOF %d %d\n", m_iEof, GetType());
81 return (m_iEof > 1);
82 //AVM_WRITE(__MODULE__, "EOF %d Pos: %d Len: %d\n", m_iEof, GetPos(), m_pStream->GetLength());
83 //if (GetType() == IStream::Audio)
84 // AVM_WRITE(__MODULE__, "%p EOF %d Pos: %f Len: %f t:%d\n", this, m_iEof, GetTime(), m_pStream->GetLengthTime(), GetType());
85 // using delta difference as comparing two doubles might have some epsilon problems
86 if (m_iEof > 1 || (m_pStream->GetLengthTime() - GetTime()) < 0.001)
87 {
88 //AVM_WRITE(__MODULE__, "EOF\n");
89 return true;
90 }
91 return false;
92 }
93
94 void ReadStream::Flush()
95 {
96 m_iEof = 0;
97 if (!m_pPacket)
98 {
99 rem_size = rem_local = 0;
100 ReadPacket();
101 }
102 }
103
104 int ReadStream::GetFrameFlags(int* flags) const
105 {
106 int f = (m_pPacket && m_pPacket->GetFlags()) ? KEYFRAME : 0;
107 if (flags)
108 *flags = f;
109 return f;
110 }
111
112 double ReadStream::GetFrameTime() const
113 {
114 return m_pStream->GetFrameTime();
115 }
116
117 size_t ReadStream::GetHeader(void* pheader, size_t s) const
118 {
119 return m_pStream->GetHeader(pheader, s);
120 }
121
122 framepos_t ReadStream::GetLength() const
123 {
124 return m_pStream->GetLength();
125 }
126
127 double ReadStream::GetLengthTime() const
128 {
129 return m_pStream->GetLengthTime();
130 }
131
132 framepos_t ReadStream::GetPos() const
133 {
134 return m_uiLastPos;
135 }
136
137 framepos_t ReadStream::GetNextKeyFrame(framepos_t pos) const
138 {
139 AVM_WRITE(__MODULE__, 3, "GetNextKeyFrame() %d\n", pos);
140 return m_pStream->GetNextKeyFrame((pos == ERR) ? GetPos() : pos);
141 }
142
143 framepos_t ReadStream::GetPrevKeyFrame(framepos_t pos) const
144 {
145 AVM_WRITE(__MODULE__, 3, "GetPrevKeyFrame() %d\n", pos);
146 return m_pStream->GetPrevKeyFrame((pos == ERR) ? GetPos() : pos);
147 }
148
149 StreamInfo* ReadStream::GetStreamInfo() const
150 {
151 return m_pStream->GetStreamInfo();
152 }
153
154 double ReadStream::GetTime(framepos_t pos) const
155 {
156 return (pos == ERR) ? m_dLastTime : m_pStream->GetTime(pos);
157 }
158
159 ReadStream::StreamType ReadStream::GetType() const
160 {
161 return m_pStream->GetType();
162 }
163
164 int ReadStream::ReadDirect(void* buffer, size_t bufsize, size_t samples,
165 size_t& samples_read, size_t& bytes_read,
166 int* flags)
167 {
168 //printf("ReadDirect remsize:%d remlimit:%d bufsize:%d %p\n", (int)rem_size, (int)rem_limit, (int)bufsize, m_pPacket);
169 if (!rem_size)
170 {
171 if (!m_iEof)
172 ReadPacket();
173 if (!m_pPacket)
174 {
175 m_iEof++;
176 return -1;
177 }
178 //printf("ReadDirect IN2 %d, %d\n", m_pPacket->read, m_pPacket->size);
179 if (m_pPacket->GetSize())
180 {
181 if (rem_limit < m_pPacket->GetSize()) {
182 rem_limit = m_pPacket->GetSize();
183 rem_buffer.reserve(rem_limit + PADDING);
184 }
185 rem_flags = m_pPacket->GetFlags();
186 rem_local = 0;
187 rem_size = m_pPacket->Read(&rem_buffer[rem_local], m_pPacket->GetSize());
188 ReadPacket();
189 }
190 }
191 //printf("ReadDirect b:%d r:%d\n", bufsize, rem_size);
192 if (buffer)
193 {
194 bytes_read = (bufsize > rem_size) ? rem_size : bufsize;
195 memcpy(buffer, &rem_buffer[rem_local], bytes_read);
196 rem_local += bytes_read;
197 rem_size -= bytes_read;
198 samples_read = bytes_read;
199 }
200 else
201 {
202 // without buffer return size of available data
203 bytes_read = rem_size;
204 samples_read = rem_size;
205 }
206
207 size_t ssize = m_pStream->GetSampleSize();
208 if (ssize > 1)
209 samples_read /= ssize;
210
211 if (flags)
212 *flags = rem_flags;
213
214 //printf("ReadDirect br:%d sr:%d ssize:%d flg:%d\n", bytes_read, samples_read, ssize, rem_flags);
215 return 0;
216 }
217
218 StreamPacket* ReadStream::ReadPacket()
219 {
220 //printf("READPACKET %d %f\n", GetType(), m_dLastTime);
221 if (m_pPacket && !m_pPacket->GetSize())
222 {
223 m_pPacket->Release();
224 m_pPacket = 0;
225 }
226
227 if (!m_pPacket)
228 m_pPacket = m_pStream->ReadPacket();
229
230 if (m_pPacket)
231 {
232 if (m_pPacket->GetTimestamp() != StreamPacket::NO_TIMESTAMP)
233 {
234 m_uiLastPos = m_pPacket->GetPos();
235 m_dLastTime = m_pPacket->GetTime();
236 }
237 }
238 else
239 {
240 double t = m_pStream->GetTime();
241 AVM_WRITE(__MODULE__, 2, "FailedPacket GetTime %f\n", t);
242 if (t != m_dLastTime)
243 {
244 m_dLastTime = t;
245 m_uiLastPos++;// = ERR;
246 }
247 }
248 //printf("ReadPacket type:%d tm:%f sz:%d\n", GetType(), m_dLastTime, m_pPacket ? m_pPacket->size : 0);
249 return m_pPacket;
250 }
251
252 int ReadStream::Seek(framepos_t pos)
253 {
254 AVM_WRITE(__MODULE__, 2, "Seek(%d)\n", pos);
255 int hr = m_pStream->Seek(pos);
256 if (hr == 0)
257 {
258 if (m_pPacket) //m_pPacket->read = m_pPacket->size;
259 m_pPacket->Release();
260 m_pPacket = 0;
261 Flush();
262 }
263 return hr;
264 }
265
266 int ReadStream::SeekTime(double timepos)
267 {
268 AVM_WRITE(__MODULE__, 2, "SeekTime(%f) (%f)\n", timepos, m_dLastTime);
269 int hr = m_pStream->SeekTime(timepos);
270 if (hr == 0)
271 {
272 if (m_pPacket)
273 m_pPacket->Release();
274 m_pPacket = 0;
275 Flush();
276 }
277 return hr;
278 }
279
280 framepos_t ReadStream::SeekToKeyFrame(framepos_t pos)
281 {
282 return (Seek(pos) == 0) ? GetPos() : ERR;
283 }
284
285 double ReadStream::SeekTimeToKeyFrame(double timepos)
286 {
287 return (SeekTime(timepos) == 0) ? GetTime() : -1.0;
288 }
289
290 int ReadStream::SkipFrame()
291 {
292 AVM_WRITE(__MODULE__, 2, "SkipFrame()\n");
293 if (m_pPacket)
294 m_pPacket->Release();
295 m_pPacket = 0;
296 Flush();
297 return m_pPacket ? 0 : -1;
298 }
299
300 int ReadStream::SkipTo(double pos)
301 {
302 AVM_WRITE(__MODULE__, 2, "SkipTo()\n");
303 int hr = m_pStream->SkipTo(pos);
304 if (hr == 0)
305 {
306 if (m_pPacket)
307 m_pPacket->Release();
308 m_pPacket = 0;
309 Flush();
310 }
311 return hr;
312 }
313
314 framepos_t ReadStream::SeekToNextKeyFrame()
315 {
316 AVM_WRITE(__MODULE__, 3, "SeekToNextKeyFrame()\n");
317 framepos_t newpos = GetNextKeyFrame();
318 if (newpos == ERR)
319 {
320 // try to iterate to next keyframe in this case
321 int kf;
322 while (SkipFrame() == 0 && !GetFrameFlags(&kf))
323 ;
324 }
325 else
326 Seek(newpos);
327
328 return GetPos();
329 }
330
331 framepos_t ReadStream::SeekToPrevKeyFrame()
332 {
333 AVM_WRITE(__MODULE__, 3, "SeekToPrevKeyFrame() (lp:%d)\n", m_uiLastPos);
334 framepos_t newpos = GetPrevKeyFrame();
335 if (newpos == ERR) {
336 double t = GetTime();
337 if (t > 20.) {
338 SeekTimeToKeyFrame(t - 20); // just a wilde guess
339 return GetPos();
340 }
341
342 newpos = 0;
343 }
344 Seek(newpos);
345 return GetPos();
346 }
347
348 size_t ReadStream::GetAudioFormat(void* bi, size_t size) const
349 {
350 AVM_WRITE(__MODULE__, "WARNING: GetAudioFormat() for non-audio stream\n");
351 return 0;
352 }
353
354 size_t ReadStream::GetVideoFormat(void* bi, size_t size) const
355 {
356 AVM_WRITE(__MODULE__, "WARNING: GetVideoFormat() for non-video stream\n");
357 return 0;
358 }
359
360 IAudioDecoder* ReadStream::GetAudioDecoder() const
361 {
362 AVM_WRITE(__MODULE__, "WARNING: Getting audio decoder for non-audio stream\n");
363 return 0;
364 }
365
366 IVideoDecoder* ReadStream::GetVideoDecoder() const
367 {
368 AVM_WRITE(__MODULE__, "WARNING: Getting video decoder for non-video stream\n");
369 return 0;
370 }
371
372 CImage* ReadStream::GetFrame(bool readframe)
373 {
374 AVM_WRITE(__MODULE__, "WARNING: GetFrame() called for non-video stream\n");
375 return 0;
376 }
377
378 size_t ReadStream::GetFrameSize() const
379 {
380 AVM_WRITE(__MODULE__, "WARNING: GetFrameSize() called for non-video stream\n");
381 return 0;
382 }
383
384 int ReadStream::ReadFrame(bool render)
385 {
386 AVM_WRITE(__MODULE__, "WARNING: ReadFrame() called for non-video stream\n");
387 return -1;
388 }
389
390 int ReadStream::ReadFrames(void* buffer, size_t bufsize, size_t samples,
391 size_t& samples_read, size_t& bytes_read)
392 {
393 AVM_WRITE(__MODULE__, "WARNING: ReadFrames() called for non-audio stream\n");
394 return -1;
395 }
396
397 int ReadStream::SetOutputFormat(void* bi, size_t size)
398 {
399 AVM_WRITE(__MODULE__, "WARNING: SetOutputFormat() called\n");
400 return -1;
401 }
402
403 #undef __MODULE__
404
405 AVM_END_NAMESPACE;