Debian Codegraph @

lib/aviread/AviReadStream.cpp

raw
1 #include "AviReadStream.h"
2 #include "AviReadHandler.h"
3 #include "formats.h"
4 #include "avm_output.h"
5 #include "avm_cpuinfo.h"
6 #include "utils.h"
7
8 #include <string.h>
9 #include <stdio.h>
10
11 AVM_BEGIN_NAMESPACE;
12
13 AviReadStream::AviReadStream(AviReadHandler* handler,
14 const AVIStreamHeader& hdr,
15 uint_t id, const void* format, size_t fsize)
16 :m_pHandler(handler), m_iId(id), m_uiChunk(0), m_uiPosition(0),
17 m_Header(hdr), m_uiFormatSize(fsize),
18 m_uiStart(0), m_uiStreamSize(0), m_uiAlignedSize(0),
19 m_uiKeyChunks(0), m_uiKeySize(0), m_uiKeyMaxSize(0), m_uiKeyMinSize(~0U),
20 m_uiDeltaSize(0), m_uiDeltaMaxSize(0), m_uiDeltaMinSize(~0U)
21 {
22 if ((m_pcFormat = new char[m_uiFormatSize]))
23 memcpy(m_pcFormat, format, m_uiFormatSize);
24
25 if (GetType() == IStream::Audio && m_Header.dwSampleSize)
26 {
27 m_dFrameRate = m_WAVEFORMATEX->nAvgBytesPerSec / m_Header.dwSampleSize;
28 m_Positions.reserve(16384);
29 m_Positions.push_back(0);
30 }
31 else
32 {
33 m_dFrameRate = (m_Header.dwScale) ? m_Header.dwRate / (double) m_Header.dwScale : 1.;
34 if (GetType() == IStream::Audio) {
35 // VBR audio has dwSampleSize == 0
36 // use tranlation table for time - see note in addChunk().
37 m_Positions.reserve(16384);
38 m_Positions.push_back(0);
39 if (m_WAVEFORMATEX->nBlockAlign < 32)
40 AVM_WRITE("AVI reader", "WARNING: WaveFormat::BlockAlign=%d is too small for VBR audio stream!\n", m_WAVEFORMATEX->nBlockAlign);
41 }
42 }
43 m_Offsets.reserve(16384);
44 }
45
46 AviReadStream::~AviReadStream()
47 {
48 delete[] m_pcFormat;
49 }
50
51 double AviReadStream::CacheSize() const
52 {
53 return m_pHandler->m_Input.cacheSize();
54 }
55
56 void AviReadStream::ClearCache()
57 {
58 m_pHandler->m_Input.clear();
59 }
60
61 size_t AviReadStream::GetHeader(void* header, size_t size) const
62 {
63
64 if (header && size >= sizeof(m_Header))
65 {
66 memset(header, 0, size);
67 memcpy(header, &m_Header, sizeof(m_Header));
68 }
69 return sizeof(m_Header);
70 }
71
72 size_t AviReadStream::GetFormat(void *format, size_t size) const
73 {
74 if (format)
75 memcpy(format, m_pcFormat, (size < m_uiFormatSize) ? size : m_uiFormatSize);
76
77 return m_uiFormatSize;
78 }
79
80 framepos_t AviReadStream::GetLength() const
81 {
82 return m_Header.dwStart + m_Header.dwLength;
83 }
84
85 double AviReadStream::GetLengthTime() const
86 {
87 return GetTime(GetLength());
88 }
89
90 framepos_t AviReadStream::GetNearestKeyFrame(framepos_t pos) const
91 {
92 pos = getFramePos(pos);
93
94 framepos_t rpos = m_Header.dwStart + pos;
95
96 if (m_Header.dwSampleSize
97 || (pos < m_Offsets.size() && (m_Offsets[pos] & 1)))
98 return rpos; // already keyframe
99
100 framepos_t prev = GetPrevKeyFrame(rpos);
101 framepos_t next = GetNextKeyFrame(rpos);
102
103 return ((rpos - prev) < (next - rpos)) ? prev : next;
104 }
105
106 framepos_t AviReadStream::GetNextKeyFrame(framepos_t pos) const
107 {
108 //printf("GETNEXT %d %d %d\n", m_iId, pos, m_uiPosition);
109 pos = getFramePos(pos);
110
111 if (m_Header.dwSampleSize == 0)
112 {
113 do
114 {
115 if (pos >= m_Offsets.size())
116 return ERR;
117
118 } while (!(m_Offsets[pos] & 1) && ++pos);
119 }
120
121 //printf("GETNEXT return %d\n", pos + m_Header.dwStart);
122 return m_Header.dwStart + pos;
123 }
124
125 framepos_t AviReadStream::GetPrevKeyFrame(framepos_t pos) const
126 {
127 //printf("GETPREV %d %d %d\n", m_iId, pos, m_uiPosition);
128 pos = getFramePos(pos);
129
130 if (pos > 0)
131 pos--; // go at least one frame back
132
133 if (m_Header.dwSampleSize == 0) {
134 if (pos >= m_Offsets.size())
135 pos = (framepos_t)m_Offsets.size() - 1;
136
137 while (pos > 0 && !(m_Offsets[--pos] & 1))
138 ;
139 }
140
141 //printf("GETPREV return %d\n", pos + m_Header.dwStart);
142 return m_Header.dwStart + pos;
143 }
144
145 StreamInfo* AviReadStream::GetStreamInfo() const
146 {
147 if (m_StreamInfo.m_p->m_dLengthTime == 0.)
148 {
149 m_StreamInfo.m_p->setKfFrames(m_uiKeyMaxSize,
150 (m_uiKeyMinSize > m_uiKeyMaxSize)
151 ? m_uiKeyMaxSize : m_uiKeyMinSize,
152 m_uiKeyChunks, m_uiKeySize);
153
154 m_StreamInfo.m_p->setFrames(m_uiDeltaMaxSize,
155 (m_uiDeltaMinSize > m_uiDeltaMaxSize)
156 // usually no delta frames
157 ? m_uiDeltaMaxSize : m_uiDeltaMinSize,
158 (uint_t)(m_Offsets.size() - m_uiKeyChunks),
159 m_uiStreamSize - m_uiKeySize);
160
161 m_StreamInfo.m_p->m_dLengthTime = GetLengthTime();
162 m_StreamInfo.m_p->m_iQuality = m_Header.dwQuality;
163 m_StreamInfo.m_p->m_iSampleSize = m_Header.dwSampleSize;
164
165 if (m_pcFormat)
166 switch (GetType())
167 {
168 case IStream::Video:
169 m_StreamInfo.m_p->m_Type = StreamInfo::Video;
170 m_StreamInfo.m_p->m_uiFormat = m_BITMAPINFOHEADER->biCompression;
171 m_StreamInfo.m_p->setVideo(m_BITMAPINFOHEADER->biWidth,
172 m_BITMAPINFOHEADER->biHeight);
173 break;
174 case IStream::Audio:
175 m_StreamInfo.m_p->m_Type = StreamInfo::Audio;
176 m_StreamInfo.m_p->m_uiFormat = m_WAVEFORMATEX->wFormatTag;
177 m_StreamInfo.m_p->setAudio(m_WAVEFORMATEX->nChannels,
178 m_WAVEFORMATEX->nSamplesPerSec,
179 m_WAVEFORMATEX->wBitsPerSample);
180 break;
181 default:
182 ; // FIXME
183 }
184 }
185
186 return new StreamInfo(m_StreamInfo);
187 }
188
189 double AviReadStream::GetTime(framepos_t pos) const
190 {
191 pos = getFramePos(pos);
192
193 if (m_Header.dwSampleSize || !m_Positions.size()) {
194 pos += m_Header.dwStart;
195 framepos_t l = GetLength();
196 if (pos > l)
197 pos = l;
198 } else
199 pos = m_Header.dwStart + ((pos < m_Positions.size()) ? m_Positions[pos] : m_Positions.back());
200
201 //printf("AviGetTime: %d %f (%f, %d, %.4s s: %d/%" PRIsz ") ss:%d\n",
202 // pos, pos / m_dFrameRate, m_dFrameRate, m_Header.dwStart,
203 // (const char*)&m_Header.fccType, m_uiPosition, m_Positions.size(), m_Header.dwSampleSize);
204 return pos / m_dFrameRate;
205 }
206
207 IStream::StreamType AviReadStream::GetType() const
208 {
209 switch (m_Header.fccType)
210 {
211 case streamtypeAUDIO: return IStream::Audio;
212 case streamtypeIAVS:
213 case streamtypeVIDEO: return IStream::Video;
214 default: return IStream::Other;
215 }
216 }
217
218 bool AviReadStream::IsKeyFrame(framepos_t pos) const
219 {
220 if (m_Header.dwSampleSize || pos < m_Header.dwStart)
221 return true; //audio
222
223 pos = getFramePos(pos);
224 return (pos < m_Offsets.size()) ? m_Offsets[pos] & 1 : true;
225 }
226
227 StreamPacket* AviReadStream::ReadPacket()
228 {
229 StreamPacket* p = m_pHandler->m_Input.readPacket(m_iId, m_uiChunk);
230 //printf("ReadPacket: %p id:%d chunk:%d pos:%d %f ss:%d\n", p, m_iId, m_uiChunk, m_uiPosition, GetTime(), m_Header.dwSampleSize);
231 if (p)
232 {
233 p->SetPos(m_uiPosition);
234 p->SetTime(GetTime(m_uiPosition));
235
236 //if (m_Header.dwSampleSize) printf("readpacketpos %d %d id:%d %lld %p pos:%lld\n", m_uiPosition, p->size, m_iId, p->timestamp, p, m_pHandler->m_Input.pos());
237 m_uiChunk++;
238 m_uiPosition = m_Header.dwStart;
239 if (m_Header.dwSampleSize)
240 m_uiPosition += (m_uiChunk < m_Positions.size())
241 ? m_Positions[m_uiChunk] : m_Positions.back();
242 else
243 m_uiPosition += m_uiChunk;
244
245 //printf("SETNEW RP %d/%d ck:%d/%d ss:%d ts: %" PRId64 "\n", m_uiPosition, p->position, m_uiChunk, (int)m_Positions.size(), m_Header.dwSampleSize, p->timestamp);
246 }
247 return p;
248 }
249
250 int AviReadStream::Seek(framepos_t framepos)
251 {
252 if ((m_uiChunk = find(framepos)) == ERR)
253 m_uiPosition = m_uiChunk = 0;
254 else
255 m_uiPosition = m_Header.dwStart + ((m_Header.dwSampleSize) ? m_Positions[m_uiChunk] : m_uiChunk);
256
257 AVM_WRITE("AVI reader", 3, "AviReadStream::Seek(%u) -> %d (%d)\n", framepos, m_uiChunk, m_iId);
258 return 0;
259 }
260
261 int AviReadStream::SeekTime(double timepos)
262 {
263 AVM_WRITE("AVI reader", 3, "AviReadStream::SeekTime(%f)\n", timepos);
264 return Seek((framepos_t)(timepos * m_dFrameRate));
265 }
266
267 // takes normal pos
268 // returns chunk or pos without dwStart!
269 framepos_t AviReadStream::find(framepos_t pos) const
270 {
271 if (pos < m_Header.dwStart)
272 return ERR;
273
274 framepos_t len = GetLength();
275 //printf("FIND %d %d %d\n", pos, len, (int)m_Positions.size());
276 if (pos > len)
277 pos = len;
278
279 pos -= m_Header.dwStart;
280 // when we don't have translation table -> position is found
281 if (!m_Positions.size())
282 return pos;
283
284 framepos_t low_limit = 0;
285 framepos_t high_limit = (framepos_t)m_Positions.size() - 1;
286 while (low_limit < high_limit)
287 {
288 // http://googleresearch.blogspot.com/2006/06/extra-extra-read-all-about-it-nearly.html
289 framepos_t middle = low_limit + (high_limit - low_limit) / 2;
290 if (pos >= m_Positions[middle])
291 {
292 // this fix is necessary to avoid deadlock
293 if (middle == low_limit)
294 break;
295
296 low_limit = middle;
297 if (pos < m_Positions[middle + 1])
298 break;
299 }
300 else
301 high_limit = middle;
302 }
303
304 //printf("FOUNDPOS %d %d \n", low_limit, m_Positions[low_limit]);
305 return low_limit;
306 }
307
308 void AviReadStream::addChunk(off_t coffset, size_t clen, bool iskf)
309 {
310 if (iskf)
311 {
312 m_uiKeyChunks++;
313 m_uiKeySize += clen;
314 if (clen > m_uiKeyMaxSize)
315 m_uiKeyMaxSize = clen;
316 if (clen < m_uiKeyMinSize)
317 m_uiKeyMinSize = clen;
318 // AVI chunks begins on 'even' stream position
319 // so use this the lowest bit as the keyframe flag
320 // saving space
321 coffset |= 1;
322 }
323 else
324 {
325 m_uiDeltaSize += clen;
326 if (clen > m_uiDeltaMaxSize)
327 m_uiDeltaMaxSize = clen;
328 if (clen < m_uiDeltaMinSize)
329 m_uiDeltaMinSize = clen;
330 }
331
332 m_uiStreamSize += clen;
333 m_Offsets.push_back((uint32_t)coffset);
334
335 if (m_Header.dwSampleSize)
336 {
337 // position in bytes for chunk stream is not need, it is always 1
338 // - so use them only for wave audio frame position
339 m_Positions.push_back((framepos_t)(m_uiStreamSize / m_Header.dwSampleSize));
340 }
341 else if (GetType() == IStream::Audio && m_Header.dwScale)
342 {
343 // VBR audio magic - we have to recalculate chunk position
344 // if the chunk is bigger then nBlockAlign - it represents
345 // more then one chunk in that case - rounding applies here!
346 // http://www.virtualdub.org/blog/pivot/entry.php?id=27
347
348 // mencoder produces nonstandard VBR files with nBlockAlign == 1
349 // probably take it as one block per VBR audio chunk
350 framepos_t balign = m_WAVEFORMATEX->nBlockAlign;
351 m_uiAlignedSize += (balign < 32) ? 1 : (framepos_t)(clen + balign - 1) / balign;
352 m_Positions.push_back(m_uiAlignedSize);
353 }
354
355 #if 0
356 if (m_iId > 0) printf("Id:%d/%5d offset:%10d sp:%10d len:%6d p:%5d (%d) -> %.3f\n",
357 m_iId, (int)m_Offsets.size(), (int)coffset & ~1U, (int)m_uiStreamSize,
358 (int)clen, (int)m_Positions.back(), (int)m_Positions.size(),
359 m_Positions.back() * m_Header.dwScale / (double)m_Header.dwRate);
360 else printf("Id:%d/%5d offset:%10d sp:%10d len:%6d p:%5d -> %.3f\n", m_iId, (int)m_Offsets.size(),
361 (int)coffset & ~1U, (int)m_uiStreamSize, (int)clen, (int)m_Offsets.size(),
362 (double)m_Offsets.size() * m_Header.dwScale / (double)m_Header.dwRate);
363 #endif
364 }
365
366 void AviReadStream::fixHeader()
367 {
368 uint32_t n = (m_Header.dwSampleSize) ? (uint32_t)(m_uiStreamSize / m_Header.dwSampleSize) : (uint32_t)m_Offsets.size();
369 if (n != m_Header.dwLength)
370 {
371 AVM_WRITE("AVI reader", "WARNING: stream header has incorrect dwLength (%d -> %d)\n", m_Header.dwLength, n);
372 m_Header.dwLength = n;
373 }
374 }
375
376 int AviReadStream::FixAvgBytes(uint_t bps)
377 {
378 if (bps > 8000)
379 {
380 m_dFrameRate = bps;
381 return 0;
382 }
383 // ok some broken files with vbr stream and nonvbr headers
384 // are weird and we can't easily recognize them - they usually
385 // have 32kbps blocks at the beginning
386 // also this is hack to make playable several broken
387 // sample files I have, thus it might fail for others...
388 return -1;
389 }
390
391 AVM_END_NAMESPACE;