Debian Codegraph @

lib/aviread/AsfReadStream.cpp

raw
1 #include "AsfReadStream.h"
2 #include "AsfReadHandler.h"
3 #include "asf_guids.h"
4 #include "avm_output.h"
5
6 #include <string.h>
7 #include <stdlib.h>
8 #include <stdio.h>
9 #include <unistd.h>
10
11 #define Debug if (0)
12
13 AVM_BEGIN_NAMESPACE;
14
15 AsfReadStream::AsfReadStream(AsfReadHandler* handler)
16 :m_pSeekInfo(0), m_pScrambleDef(0), m_pHandler(handler), m_pIterator(0),
17 m_pStrPacket(0), m_pAsfPacket(0), m_uiFragId(0),
18 m_uiLastPos(0), m_dLastTime(-1.),
19 m_iMaxBitrate(-1), m_bIsScrambled(false)
20 {
21 }
22
23 AsfReadStream::~AsfReadStream()
24 {
25 if (m_pAsfPacket)
26 m_pAsfPacket->release();
27
28 if (m_pIterator)
29 m_pIterator->release();
30
31 if (m_pStrPacket)
32 m_pStrPacket->Release();
33 }
34
35 double AsfReadStream::CacheSize() const
36 {
37 return m_pHandler->m_pInput->cacheSize();
38 }
39
40 void AsfReadStream::ClearCache()
41 {
42 //return m_pHandler->m_pInput->clear();
43 }
44
45 size_t AsfReadStream::GetFormat(void *format, size_t size) const
46 {
47 const void* fmt;
48 size_t fsize;
49
50 if (m_bIsAudio)
51 {
52 fsize = m_Header.hdr.stream_size;
53 fmt = &m_Header.hdr.aud.wfx;
54 }
55 else
56 {
57 fsize = m_Header.hdr.stream_size - 11;
58 fmt = &m_Header.hdr.vid.bih;
59 }
60
61 if (format)
62 memcpy(format, fmt, (fsize > size) ? size : fsize);
63 return fsize;
64 }
65
66 IStream::StreamType AsfReadStream::GetType() const
67 {
68 switch (guid_get_guidid(&m_Header.hdr.stream_guid))
69 {
70 case GUID_ASF_AUDIO_MEDIA:
71 return IStream::Audio;
72 case GUID_ASF_VIDEO_MEDIA:
73 return IStream::Video;
74 default:
75 return IStream::Other;
76 }
77 }
78
79 double AsfReadStream::GetFrameTime() const
80 {
81 if (!m_pSeekInfo || !m_pSeekInfo->size())
82 return 1./15.;
83
84 return GetLengthTime()/(double)m_pSeekInfo->size();
85 }
86
87 size_t AsfReadStream::GetHeader(void* pheader, size_t size) const
88 {
89 if (pheader && size >= sizeof(AVIStreamHeader))
90 {
91 memset(pheader, 0, size);
92
93 AVIStreamHeader* p = (AVIStreamHeader*) pheader;
94
95 if (!m_pSeekInfo)
96 {
97 p->dwRate = 15;
98 p->dwScale = 1;
99 p->dwLength = 0x7FFFFFFF;
100 }
101 else
102 {
103 p->dwRate = 1000000;
104 if (!m_pSeekInfo->size())
105 p->dwScale = 1000000 / 15;
106 else
107 {
108 double stream_length = (double)m_pHandler->m_Header.play_time / 10000000.;
109 p->dwScale = int(1000000. * stream_length / (double)m_pSeekInfo->size());
110 }
111 p->dwLength = (uint32_t)m_pSeekInfo->size();
112 }
113
114 if (m_bIsAudio)
115 {
116 p->fccType = streamtypeAUDIO;
117 p->fccHandler = m_Header.hdr.aud.wfx.wFormatTag;
118 p->dwSampleSize = m_Header.hdr.aud.wfx.nBlockAlign;
119 }
120 else if (guid_is_guidid(&m_Header.hdr.stream_guid, GUID_ASF_VIDEO_MEDIA))
121 {
122 p->fccType = streamtypeVIDEO;
123 p->fccHandler = m_Header.hdr.vid.bih.biCompression;
124 p->rcFrame.right = (int16_t) m_Header.hdr.vid.bih.biWidth;
125 p->rcFrame.top = (int16_t) m_Header.hdr.vid.bih.biHeight;
126 }
127 }
128 return sizeof(AVIStreamHeader);
129 }
130
131 framepos_t AsfReadStream::GetLength() const
132 {
133 // FIXME - show better value here
134 return (m_pSeekInfo) ? (framepos_t)m_pSeekInfo->size() : 0x7fffffff;
135 }
136
137 double AsfReadStream::GetLengthTime() const
138 {
139 if (m_pSeekInfo && m_pSeekInfo->size() > 0)
140 {
141 return ((*m_pSeekInfo)[m_pSeekInfo->size() - 1].object_start_time) / 1000.;
142 }
143
144 if (m_pHandler->m_Header.play_time <= m_pHandler->m_Header.preroll)
145 return (double) 0x7fffffff; // some large value
146
147 return (double)(m_pHandler->m_Header.play_time - m_pHandler->m_Header.preroll) / 10000000.;
148 }
149
150 framepos_t AsfReadStream::GetNearestKeyFrame(framepos_t lFrame) const
151 {
152 if (!m_pSeekInfo)
153 return ERR;
154
155 framepos_t info_pos;
156
157 if (lFrame != ERR)
158 {
159 if (lFrame >= m_pSeekInfo->size())
160 return 0;
161 info_pos = lFrame;
162 }
163 else
164 info_pos = m_uiLastPos;
165
166 return m_pSeekInfo->nearestKeyFrame(info_pos);
167 }
168
169 framepos_t AsfReadStream::GetNextKeyFrame(framepos_t lFrame) const
170 {
171 if (!m_pSeekInfo)
172 return ERR;// GetPos();
173
174 framepos_t info_pos;
175
176 if (lFrame != ERR)
177 {
178 if (lFrame >= m_pSeekInfo->size())
179 return ERR;
180 info_pos = lFrame;
181 }
182 else
183 info_pos = m_uiLastPos;
184
185 return m_pSeekInfo->nextKeyFrame(info_pos + 1);
186 }
187
188 framepos_t AsfReadStream::GetPrevKeyFrame(framepos_t lFrame) const
189 {
190 if (!m_pSeekInfo)
191 return ERR;
192
193 framepos_t info_pos;
194 if (lFrame != ERR)
195 {
196 if (lFrame >= m_pSeekInfo->size() || lFrame == 0)
197 return 0;
198 info_pos = lFrame - 1;
199 }
200 else
201 info_pos = m_uiLastPos;
202 return m_pSeekInfo->prevKeyFrame(info_pos);
203 }
204
205 double AsfReadStream::GetTime(framepos_t pos) const
206 {
207 //printf("GET TIME %d %f %d\n", pos, m_dLastTime, m_iId);
208 if (pos == ERR)
209 {
210 if (!m_pStrPacket)
211 ReadPacketInternal();
212
213 return m_dLastTime;
214 }
215
216 if (m_pSeekInfo && pos < m_pSeekInfo->size())
217 return (*m_pSeekInfo)[pos].object_start_time / 1000.;
218
219 //AVM_WRITE("ASF reader", "lSample %d %f (%f)\n", pos, t, m_uiLastTimestamp / 1000.0);
220 return -1.;
221 }
222
223 size_t AsfReadStream::GetSampleSize() const
224 {
225 return (m_bIsAudio) ? m_Header.hdr.aud.wfx.nBlockAlign : 0;
226 }
227
228 StreamInfo* AsfReadStream::GetStreamInfo() const
229 {
230 if (!m_pSeekInfo)
231 {
232 AVM_WRITE("ASF reader", "GetStreamInfo() no seek info\n");
233 }
234 if (m_StreamInfo.m_p->m_dLengthTime == 0.0)
235 {
236 size_t kfmax = 0;
237 size_t kfmin = ~0U;
238 uint_t kfchunks = 0;
239 int64_t kfsize = 0;
240 size_t fmax = 0;
241 size_t fmin = ~0U;
242 uint_t chunks = 0;
243 int64_t size = 0;
244
245 if (m_pSeekInfo)
246 for (size_t i = 0; i < m_pSeekInfo->size(); ++i)
247 {
248 size_t l = (*m_pSeekInfo)[i].GetChunkLength();
249 if ((*m_pSeekInfo)[i].IsKeyFrame() || m_bIsAudio)
250 {
251 kfmax = (kfmax > l) ? kfmax : l;
252 kfmin = (kfmin < l) ? kfmin : l;
253 kfsize += l;
254 kfchunks++;
255 }
256 else
257 {
258 fmax = (fmax > l) ? fmax : l;
259 fmin = (fmin < l) ? fmin : l;
260 size += l;
261 chunks++;
262 }
263 }
264 m_StreamInfo.m_p->setKfFrames(kfmax, kfmin, kfchunks, kfsize);
265 m_StreamInfo.m_p->setFrames(fmax, fmin, chunks, size);
266
267 double ft = 0;
268 if (m_pSeekInfo && m_pSeekInfo->size())
269 ft = (*m_pSeekInfo)[0].object_start_time / 1000.;
270 m_StreamInfo.m_p->m_dLengthTime = GetLengthTime() - ft;
271 m_StreamInfo.m_p->m_iQuality = 0;
272
273 if (m_bIsAudio)
274 {
275 const WAVEFORMATEX& wfx = m_Header.hdr.aud.wfx;
276 m_StreamInfo.m_p->setAudio(wfx.nChannels, wfx.nSamplesPerSec,
277 wfx.wBitsPerSample, wfx.nAvgBytesPerSec);
278 m_StreamInfo.m_p->m_Type = StreamInfo::Audio;
279 m_StreamInfo.m_p->m_uiFormat = wfx.wFormatTag;
280 m_StreamInfo.m_p->m_iSampleSize = 1;
281 }
282 else
283 {
284 const BITMAPINFOHEADER& bih = m_Header.hdr.vid.bih;
285 m_StreamInfo.m_p->setVideo(bih.biWidth, bih.biHeight, m_iMaxBitrate/8);
286 m_StreamInfo.m_p->m_Type = StreamInfo::Video;
287 m_StreamInfo.m_p->m_uiFormat = bih.biCompression;
288 m_StreamInfo.m_p->m_iSampleSize = 0;
289 }
290 }
291
292 return new StreamInfo(m_StreamInfo);
293 }
294
295 bool AsfReadStream::IsKeyFrame(framepos_t lFrame) const
296 {
297 if (!m_pSeekInfo || m_bIsAudio)
298 return true;
299
300 framepos_t info_pos;
301
302 if (lFrame != ERR)
303 {
304 if (lFrame >= m_pSeekInfo->size())
305 return true;
306 info_pos = lFrame;
307 }
308 else
309 info_pos = m_uiLastPos;
310
311 //printf("ISKEY %d %d\n", info_pos, (*m_pSeekInfo)[info_pos].IsKeyFrame());
312 return (info_pos != ERR) ? (*m_pSeekInfo)[(int)info_pos].IsKeyFrame() : true;
313 }
314
315 void AsfReadStream::ReadPacketInternal() const
316 {
317 int m_iRealId = m_iId;
318 StreamPacket* spkt = 0;
319 size_t wpos = 0;
320 uint_t seq_num = ~0U;
321 int newpos = -1;
322
323 // loop until packet is completed
324 for (;;)
325 {
326 //printf("READPACKET %p %d id:%d\n", m_pAsfPacket, m_uiFragId, m_iId);
327 if (!m_pAsfPacket || m_uiFragId >= m_pAsfPacket->fragments.size())
328 {
329 newpos = -1;
330 if (!GetNextAsfPacket())
331 {
332 if (spkt)
333 spkt->Release();
334 spkt = 0;
335 break;
336 }
337 }
338
339 // go through all fragments in this packet
340 const AsfPacketFragment& f = m_pAsfPacket->fragments[m_uiFragId++];
341
342 Debug AVM_WRITE("ASF reader", 4, "Pos id:%d == %d (rid: %d) spos: %d off: %d osize: %d dsize: %d seq: %d fsize: %" PRIsz "\n",
343 m_iId, f.stream_id, m_iRealId, m_uiFragId, f.fragment_offset, f.object_length, f.data_length, f.seq_num, m_pAsfPacket->fragments.size());
344
345 if (f.stream_id != m_iRealId)
346 {
347 if (!m_iRealId && !f.fragment_offset && f.stream_id > 1)
348 {
349 m_iRealId = f.stream_id;
350 }
351 else
352 continue;
353 }
354 //printf("S %d\n", f.stream_id);
355 if (spkt && seq_num != f.seq_num)
356 {
357 AVM_WRITE("ASF reader", "WARNING: fragment with different"
358 " sequence number ( expected %d, found %d ), "
359 "packet timestamp %f ignoring ???\n", seq_num,
360 f.seq_num, m_pAsfPacket->send_time / 1000.);
361 // we could check if the current packet doesn't have any
362 // other fragments which would fit our needs
363 unsigned np = 0;
364 for (unsigned i = m_uiFragId + 1; i < m_pAsfPacket->fragments.size(); i++)
365 {
366 const AsfPacketFragment& fn = m_pAsfPacket->fragments[i];
367 // ok skip and check if the next fragment would fit
368 //printf("FRAGS %d: %d\n", i, fn.seq_num);
369 if (fn.seq_num == seq_num && f.stream_id == m_iRealId)
370 {
371 np = i;
372 break;
373 }
374 }
375 if (np)
376 {
377 newpos = m_uiFragId - 1;
378 m_uiFragId = np;
379 }
380 else
381 {
382 if (f.fragment_offset == 0)
383 m_uiFragId--;
384 if (spkt)
385 spkt->Release();
386 spkt = 0;
387 }
388 }
389
390 if (!spkt)
391 {
392 //printf("OBJLEN %d t:%d o:%d\n", f.object_length, f.object_start_time, f.fragment_offset);
393 seq_num = f.seq_num;
394 if (f.object_length > StreamPacket::MAX_PACKET_SIZE) // too large - some bug
395 continue;
396 spkt = new StreamPacket(f.object_length);
397 if (!spkt)
398 break;
399 spkt->SetFlags(f.keyframe ? 0x10 : 0);
400 //printf("Duration %d\n", m_pAsfPacket->duration);
401 uint_t tpos = f.object_start_time - m_pHandler->m_Header.preroll;
402 m_uiLastPos = (m_pSeekInfo) ? m_pSeekInfo->find(tpos) : 0;
403 spkt->SetPos(m_uiLastPos);
404 spkt->SetTimestamp((int64_t)tpos * 1000LL);
405 m_dLastTime = spkt->GetTime() ;
406 //printf("CREATED pkt: %d 0x%x tm:%lld %d id:%d\n", spkt->size, spkt->flags, spkt->timestamp, spkt->position, m_iId);
407 }
408
409 if ((wpos + f.data_length) > spkt->GetSize())
410 {
411 // this fragment won't fit into the buffer
412 AVM_WRITE("ASF reader", "WARNING: fragment too big "
413 "( read bytes %" PRIsz ", fragment data length %d ), "
414 "position %d, offset: %d, packet timestamp %f skipping",
415 wpos, f.data_length, m_uiFragId,
416 f.fragment_offset, m_pAsfPacket->send_time / 1000.);
417 if (spkt)
418 spkt->Release();
419 spkt = 0;
420 continue;
421 }
422
423 if (wpos)
424 {
425 if (wpos != f.fragment_offset)
426 {
427 AVM_WRITE("ASF reader", "WARNING: fragment with unexpected offset while"
428 " reassembling ( expected %" PRIsz ", found %d ), "
429 "packet timestamp %f skipping\n", wpos,
430 f.fragment_offset, m_pAsfPacket->send_time / 1000.);
431 if (spkt)
432 spkt->Release();
433 spkt = 0;
434 continue;
435 }
436 }
437 else if (f.fragment_offset) // !spkt->read
438 {
439 AVM_WRITE("ASF reader", "WARNING: incomplete fragment found ( offset %d, length %d )"
440 ", packet timestamp %f skipping\n", f.fragment_offset,
441 f.object_length, m_pAsfPacket->send_time / 1000.);
442 if (spkt)
443 spkt->Release();
444 spkt = 0;
445 continue;
446 }
447
448 memcpy(spkt->GetData() + wpos, f.pointer, f.data_length);
449 wpos += f.data_length;
450
451 if (wpos == spkt->GetSize())
452 break;
453 }
454 if (newpos >= 0)
455 m_uiFragId = newpos;
456
457 //if (m_iId>0) {int sum = 0; for (int i = 0; i < spkt->size; i++) sum += spkt->memory[i]; printf("PK %d %d\n", spkt->size, sum);}
458 m_pStrPacket = spkt;
459 }
460
461 // buffer one frame ahead
462 // after seek we have to throw out the old 'cached' packet
463 // and prepare new one - this is made via SkipFrame call
464 StreamPacket* AsfReadStream::ReadPacket()
465 {
466 if (!m_pStrPacket)
467 ReadPacketInternal();
468 //printf("_____READPAKET %p id:%d\n", m_pStrPacket, m_iId);
469 StreamPacket* tmp = m_pStrPacket;
470 if (m_pStrPacket)
471 {
472 if (m_bIsScrambled)
473 {
474 // descramble packet
475 uint8_t* oldmem = m_pStrPacket->GetData();
476 StreamPacket* npkt = new StreamPacket(m_pStrPacket->GetSize());
477 if (npkt)
478 {
479 if (npkt->GetData())
480 {
481 for (size_t offset = 0; offset < m_pStrPacket->GetSize();
482 offset += m_pScrambleDef->chunk_length)
483 {
484 size_t off = offset / m_pScrambleDef->chunk_length;
485 size_t row = off / m_pScrambleDef->span;
486 size_t col = off % m_pScrambleDef->span;
487 size_t idx = row + col * m_pScrambleDef->packet_length / m_pScrambleDef->chunk_length;
488 //printf("off:%d samp_count: %d samples: %d\n", m_iScrOffset, samp_count, lSamples);
489 //printf("%d bytes in buffer, block align: %d, lasttime: %d\n", m_pcScrambleBuf.size()-m_iScrOffset, m_pScrambleDef->block_align_1, m_uiLastTimestamp);
490 //printf("%d bytes in buffer, block_size: %d, offset: %d\n", m_pcScrambleBuf.size()-m_iScrOffset, m_pScrambleDef->chunk_size, m_iScrOffset);
491 //printf("%d: writing block %dx%d=%d as %d\n", i, row, col, idx, index);
492 memcpy(npkt->GetData() + offset,
493 m_pStrPacket->GetData() + idx * m_pScrambleDef->chunk_length,
494 m_pScrambleDef->chunk_length);
495 }
496 }
497 m_pStrPacket->SwapData(*npkt);
498 npkt->Release();
499 }
500 }
501 ReadPacketInternal();
502 }
503
504 return tmp;
505 }
506
507 int AsfReadStream::Seek(framepos_t pos)
508 {
509 AVM_WRITE("ASF reader", 1, "AsfReadStream::Seek(%d)\n", pos);
510 chunk_info ch;
511 if (m_pIterator->seek(pos, &ch) != 0)
512 return -1;
513
514 GetNextAsfPacket();
515 m_uiFragId = ch.fragment_id;
516 if (m_pStrPacket)
517 m_pStrPacket->Release();
518 m_pStrPacket = 0;
519 ReadPacketInternal();
520
521 //printf("SEEK NEW POS %d %d (%d f:%d)\n", pos, GetPos(), ch.packet_id, ch.fragment_id);
522 return 0;
523 }
524
525 int AsfReadStream::SeekTime(double timepos)
526 {
527 AVM_WRITE("ASF reader", 1, "AsfReadStream::SeekTime(%f)\n", timepos);
528 chunk_info ch;
529 if (timepos < 0. || m_pIterator->seekTime(timepos, &ch) != 0)
530 return -1;
531
532 GetNextAsfPacket();
533 m_uiFragId = ch.fragment_id;
534 if (m_pStrPacket)
535 m_pStrPacket->Release();
536 m_pStrPacket = 0;
537 ReadPacketInternal();
538 //printf("seektimepos %d (tpos: %f)\n", m_uiFragId, timepos);
539 //AVM_WRITE("ASF reader", "SEEKTIMEB %f %f\n", m_uiLastTimestamp / 1000.0, ch.object_start_time / 1000.0);
540 return 0;
541 }
542
543 int AsfReadStream::SkipFrame()
544 {
545 AVM_WRITE("ASF reader", 1, "Skip frame\n");
546 StreamPacket* p = ReadPacket();
547 if (p)
548 p->Release();
549 //printf("SKIP POS %p %u\n", m_pAsfPacket, m_uiLastTimestamp / 1000);
550 return 0;
551 }
552
553 int AsfReadStream::SkipTo(double pos)
554 {
555 while (m_pStrPacket && m_pStrPacket->GetTime() < pos)
556 SkipFrame();
557 return 0;
558 }
559
560 AVM_END_NAMESPACE;