Debian Codegraph @

lib/aviread/AsfReadHandler.cpp

raw
1 #include "AsfReadHandler.h"
2 #include "AsfReadStream.h"
3 #include "asf_guids.h"
4
5 #include "AsfFileInputStream.h"
6 #include "AsfRedirectInputStream.h"
7 #include "AsfNetworkInputStream.h"
8 #include "avm_output.h"
9
10 #include <time.h>
11 #include <string.h>
12 #include <stdio.h>
13
14 #define Debug if (0)
15
16 AVM_BEGIN_NAMESPACE;
17
18 #define __MODULE__ "AsfReaderHandler"
19
20 AsfReadHandler::AsfReadHandler()
21 : m_pInput(0)
22 {
23 }
24
25 int AsfReadHandler::init(const char* pszFile)
26 {
27 bool isurl = strstr(pszFile, "://");
28 if (!isurl)
29 {
30 AsfFileInputStream* af = new AsfFileInputStream();
31 if (af && af->init(pszFile) == 0)
32 m_pInput = af;
33 else
34 delete af;
35 }
36 if (!isurl && !m_pInput)
37 {
38 AsfRedirectInputStream* ar = new AsfRedirectInputStream();
39 if (ar && ar->init(pszFile) == 0)
40 m_pInput = ar;
41 else
42 delete ar;
43 }
44 if (!m_pInput)
45 {
46 AsfNetworkInputStream* ai = new AsfNetworkInputStream();
47 if (ai && ai->init(pszFile) == 0)
48 m_pInput = ai;
49 else
50 delete ai;
51 }
52
53 if (!m_pInput)
54 return -1;
55
56 IsValid();
57 return 0;
58 }
59
60 AsfReadHandler::~AsfReadHandler()
61 {
62 for (size_t i = 0; i < m_SeekInfo.size(); ++i)
63 delete m_SeekInfo[i];
64
65 for (size_t i = 0; i < m_Streams.size(); ++i)
66 delete m_Streams[i];
67
68 delete m_pInput;
69 }
70
71 size_t AsfReadHandler::GetHeader(void* header, size_t size)
72 {
73 if (header && (size >= sizeof(AVIStreamHeader)))
74 {
75 memset(header, 0, size);
76
77 AVIStreamHeader* p = (AVIStreamHeader*) header;
78
79 if (!m_Streams.size())
80 {
81 p->dwRate=15;
82 p->dwScale=1;
83 p->dwLength=0x7FFFFFFF;
84 }
85 else
86 {
87 double stream_length = (double)m_Header.play_time / 10000000.;
88 p->dwRate = 1000000;
89 if (!m_SeekInfo.size())
90 p->dwScale = 1000000/15;
91 else
92 p->dwScale = uint_t(1000000.*stream_length/(double)m_SeekInfo.size());
93 p->dwLength = (uint32_t)m_SeekInfo.size();
94 }
95 /*
96 if (m_bIsAudio)
97 {
98 p->fccType=mmioFOURCC('a', 'u', 'd', 's');
99 p->fccHandler=m_Header.hdr.aud.wfex.wFormatTag;
100 p->dwSampleSize=m_Header.hdr.aud.wfex.nBlockAlign;
101 }
102 else if (m_Header.hdr.uid_type == guid_video_stream)
103 {
104 p->fccType=mmioFOURCC('v', 'i', 'd', 's');
105 p->fccHandler=m_Header.hdr.vid.biCompression;
106 p->rcFrame.right=m_Header.hdr.vid.biWidth;
107 p->rcFrame.top=m_Header.hdr.vid.biHeight;
108 }
109 */
110 }
111 return sizeof(AVIStreamHeader);
112 }
113
114 IMediaReadStream* AsfReadHandler::GetStream(uint_t stream_id,
115 IStream::StreamType type)
116 {
117 guidid_t guidid;
118 switch (type)
119 {
120 case IStream::Audio: guidid = GUID_ASF_AUDIO_MEDIA; break;
121 case IStream::Video: guidid = GUID_ASF_VIDEO_MEDIA; break;
122 default: return 0;
123 }
124
125 //
126 // Selecting from the last available stream - as usualy this
127 // stream contains the best quality video.
128 // yet it's a little bit problematic
129 // so some more advanced selection mechanism is necessary...
130 // FIXME FIXME FIXME
131 uint_t match = 0;
132 for (
133 #if 1
134 int i = (int)m_Streams.size() - 1; i >= 0; i--
135 #else
136 uint_t i = 0; i < m_Streams.size(); i++
137 #endif
138 )
139 {
140 if (guid_is_guidid(&m_Streams[i]->m_Header.hdr.stream_guid, guidid))
141 {
142 if (match == stream_id)
143 {
144 if (!m_Streams[i]->m_pIterator)
145 {
146 m_Streams[i]->m_pIterator = m_pInput->getIterator(i);
147 if (!m_Streams[i]->m_pIterator)
148 continue;
149 m_Streams[i]->m_pSeekInfo = m_Streams[i]->m_pIterator->getSeekInfo();
150 m_Streams[i]->m_iMaxBitrate = m_pInput->getMaxBitrate(m_Streams[i]->m_pIterator->getId());
151 //printf("STREAM %d %d BITRATE %d %d\n", stream_id, i, m_Streams[i]->m_iMaxBitrate, m_Streams[i]->m_pIterator->getId());
152 }
153 return m_Streams[i];
154 }
155 match++;
156 }
157 }
158
159 return 0;
160 }
161
162 size_t AsfReadHandler::GetStreamCount(IStream::StreamType type)
163 {
164 guidid_t guidid;
165
166 switch (type)
167 {
168 case IStream::Audio: guidid = GUID_ASF_AUDIO_MEDIA; break;
169 case IStream::Video: guidid = GUID_ASF_VIDEO_MEDIA; break;
170 default: guidid = GUID_ERROR;
171 }
172
173 size_t cnt = 0;
174 for (size_t i = 0; i < m_Streams.size(); ++i)
175 if (guid_is_guidid(&m_Streams[i]->m_Header.hdr.stream_guid, guidid))
176 cnt++;
177
178 return cnt;
179 }
180
181 bool AsfReadHandler::GetURLs(avm::vector<avm::string>& urls)
182 {
183 return m_pInput->getURLs(urls);
184 }
185
186 void AsfReadHandler::Interrupt()
187 {
188 return m_pInput->interrupt();
189 }
190
191 bool AsfReadHandler::IsOpened()
192 {
193 return m_pInput->isOpened();
194 }
195
196 bool AsfReadHandler::IsRedirector()
197 {
198 return m_pInput->isRedirector();
199 }
200
201 bool AsfReadHandler::IsValid()
202 {
203 //printf("ISVALIDE %d %d %d\n", IsOpened(), m_pInput->isValid(), IsRedirector());
204 if (!IsOpened() || !m_pInput->isValid())
205 return false;
206 if (IsRedirector())
207 return true;
208
209 if (!m_Streams.size())
210 {
211 m_Header = m_pInput->getHeader();
212 const avm::vector<ASFStreamHeader>& str = m_pInput->getStreams();
213 for (size_t i = 0; i < str.size(); ++i)
214 {
215 AsfReadStream* stream = new AsfReadStream(this);
216 if (!stream)
217 return false;
218 m_Streams.push_back(stream);
219 stream->m_Header = str[i];
220 // stream id could be <1, 127>
221 stream->m_iId = stream->m_Header.hdr.stream & 0x7f;
222 stream->m_bIsAudio = guid_is_guidid(&stream->m_Header.hdr.stream_guid, GUID_ASF_AUDIO_MEDIA);
223 if (stream->m_bIsAudio
224 && guid_is_guidid(&stream->m_Header.hdr.error_guid, GUID_ASF_AUDIO_SPREAD)
225 && stream->m_Header.hdr.aud.wfx.cbSize < 200 //FIXME
226 )
227 {
228 // read/calculate descrambling parameters
229 char* ctmp = (char*) &stream->m_Header.hdr.aud.wfx
230 + sizeof(WAVEFORMATEX) + stream->m_Header.hdr.aud.wfx.cbSize;
231 stream->m_pScrambleDef = (const ASFSpreadAudio*) ctmp;
232
233 //printf("Scrambling check %d\n", stream.m_Header.hdr.aud.wfex.cbSize);
234 AVM_WRITE("ASF reader", "Interleave info: blocksize=%d packetlen=%d chunklen=%d\n",
235 (int)stream->m_pScrambleDef->span,
236 stream->m_pScrambleDef->packet_length,
237 stream->m_pScrambleDef->chunk_length);
238 if ((stream->m_pScrambleDef->span != 1)
239 && (stream->m_pScrambleDef->chunk_length > 0)
240 && (stream->m_pScrambleDef->packet_length/stream->m_pScrambleDef->chunk_length!=1))
241 {
242 stream->m_bIsScrambled = true;
243 int msize = stream->m_pScrambleDef->packet_length * stream->m_pScrambleDef->span;
244 AVM_WRITE("ASF reader", "Scrambling scrsize: %d\n", msize);
245 }
246 }
247 if (stream->m_Header.hdr.stream & 0x8000)
248 {
249 AVM_WRITE("ASF reader", "The content of the stream: %d is ENCRYPTED (and for now unplayable!)\n", stream->m_iId);
250 }
251 }
252 }
253
254 return true;
255 }
256
257
258 bool AsfInputStream::parseHeader(uint8_t* ptr, size_t size, int level)
259 {
260 ASFStreamHeader strhdr;
261 bool bResult = false;
262 uint32_t a = avm_get_le32(ptr);
263 ptr += 4 + 2 /* reserved */;
264 AVM_WRITE("ASF reader", 1, "header objects: %d (%" PRIsz ")\n", a, size);
265 for (unsigned i = 0; i <= ASF_STREAMS; ++i)
266 m_MaxBitrates[i] = ~0U;
267
268 while (size >= 24)
269 {
270 uint64_t ch_size;
271 GUID* guid = avm_get_leGUID(ptr);
272 guidid_t gid = guid_get_guidid(guid);
273 ptr += 16;
274 ch_size = avm_get_le64(ptr);
275 ptr += 8;
276
277 if (ch_size > size) ch_size = size; // some error
278 if (ch_size < 24) break;
279 ch_size -= 24;
280 size -= 24;
281
282 AVM_WRITE("ASF reader", 1, "chunk_size %d, size: %" PRIsz " GUID: %s\n", (uint_t)ch_size, size, guidid_to_text(gid));
283 switch (gid)
284 {
285 case GUID_ASF_FILE_PROPERTIES:
286 if ((uint_t)ch_size < sizeof(ASFMainHeader))
287 {
288 AVM_WRITE("ASF reader", "Wrong ASF header size");
289 return false;
290 }
291 if ((uint_t)ch_size > sizeof(ASFMainHeader))
292 AVM_WRITE("ASF reader", "Warning: unexpected size of ASF header %" PRIsz "!\n", size);
293 m_Header = *avm_get_leASFMainHeader(ptr);
294 m_Streams.clear();
295 if (level == 0)
296 AsfReadHandler::PrintASFMainHeader(&m_Header);
297 bResult = true;
298 break;
299 case GUID_ASF_STREAM_PROPERTIES:
300 memset(&strhdr, 0, sizeof(strhdr));
301 // FIXME
302 if ((uint_t)ch_size > sizeof(strhdr))
303 AVM_WRITE("ASF reader", "FIXME: unexpected size of ASF stream header %" PRIsz "\n", size);
304 memcpy(&strhdr, ptr, ((uint_t)ch_size < sizeof(strhdr)) ? ch_size : sizeof(strhdr));
305 avm_get_leASFStreamHeader(&strhdr);
306 if (level == 0)
307 AsfReadHandler::PrintASFStreamHeader(&strhdr);
308 m_Streams.push_back(strhdr);
309 break;
310 case GUID_ASF_CONTENT_DESCRIPTION:
311 {
312 static const char comment_txt[][14] = {
313 "Title ",
314 "Author ",
315 "Copyright ",
316 "Description ",
317 "Rating "
318 };
319 size_t ps = 5 * 2;
320 for (uint_t i = 0; i < 5; i++)
321 {
322 size_t sz = avm_get_le16(ptr + i * 2);
323 if (sz > 0)
324 {
325 char* cs = avm_convert_asfstring(ptr + ps, sz);
326 m_Description.push_back(cs);
327 AVM_WRITE("ASF reader", level, " %s: %s\n",
328 comment_txt[i], cs);
329 ps += sz;
330 }
331 }
332 }
333 break;
334 case GUID_ASF_EXTENDED_CONTENT_DESCRIPTION:
335 {
336 size_t off = 0;
337 while (off < ch_size)
338 {
339 size_t sz = avm_get_le16(ptr + 2 + off);
340 off += 4;
341 if (off + sz < ch_size)
342 {
343 AVM_WRITE("ASF reader", level, "VersionInfo: %s\n",
344 avm_convert_asfstring(ptr + off, sz));
345 }
346 off += sz;
347 }
348 }
349 break;
350 case GUID_ASF_CODEC_LIST:
351 {
352 uint8_t* b = ptr + 16; // skip reserved GUID
353 size_t ccount = avm_get_le32(b);
354 b += 4;
355 for (size_t i = 0; i < ccount; ++i)
356 {
357 static const char cstr[][19] = {
358 "Codec Name",
359 "Codec Description",
360 "Information"
361 // wide, wide, byte -
362 };
363 uint16_t ctype = avm_get_le16(b);
364 b += 2;
365 AVM_WRITE("ASF reader", level, "Codec Type: %s\n", (ctype == 1) ? "Video" : ((ctype == 2) ? "Audio" : "Unknown"));
366
367 for (uint_t j = 0; j < 3; ++j)
368 {
369 size_t csize = avm_get_le16(b);
370 b += 2;
371 if (j < 2)
372 {
373 csize = (uint16_t) (csize * 2); // *2 WCHAR
374 avm_convert_asfstring(b, csize);
375 AVM_WRITE("ASF reader", level, "%s: %s\n", cstr[j], b);
376 }
377 b += csize;
378 }
379 }
380 }
381 break;
382 case GUID_ERROR:
383 {
384 char guidstr[64];
385 AVM_WRITE("ASF reader", "Unknown guid \"%s\"!\n",
386 guid_to_string(guidstr, guid));
387 }
388 break;
389 case GUID_ASF_STREAM_BITRATE_PROPERTIES:
390 {
391 const uint8_t* b = ptr;
392 avm::string t;
393 unsigned sc = avm_get_le16(b); b += 2;
394 for (unsigned i = 0; i < sc; i++)
395 {
396 char tl[50];
397 unsigned sid = avm_get_le16(b); b += 2;
398 unsigned mbit = avm_get_le32(b); b += 4;
399 m_MaxBitrates[sid & ASF_STREAMS] = mbit;
400 sprintf(tl, " %d-%d", sid, mbit);
401 t += tl;
402 }
403 AVM_WRITE("ASF reader", level, "Stream-MaxBitrate:%s\n", t.c_str());
404 }
405 break;
406 default:
407 // some known but not parsed GUIDs at this moment
408 AVM_WRITE("ASF reader", level, "header contains \"%s\" (%" PRId64 "b)\n",
409 guidid_to_text(gid), ch_size);
410 break;
411 }
412 size -= (uint_t) ch_size;
413 ptr += (uint_t) ch_size;
414 }
415
416 return bResult;
417 }
418
419
420
421 /* 1601 to 1970 is 369 years plus 89 leap days */
422 #define SECS_1601_TO_1970 ((369 * 365 + 89) * 86400ULL)
423
424 void AsfReadHandler::PrintASFMainHeader(const ASFMainHeader* h)
425 {
426 char b[64];
427 char sec1970str[128];
428 struct tm result;
429
430 time_t sec1970 = (int64_t) (h->create_time / 10000000) - SECS_1601_TO_1970;
431 #ifdef HAVE_LOCALTIME_R
432 localtime_r(&sec1970, &result);
433 #else
434 struct tm* r = localtime(&sec1970);
435 memcpy(&result, r, sizeof(result));
436 #endif
437
438 #ifdef HAVE_ASCTIME_R
439 #ifdef HAVE_ASCTIME_R_LONG
440 asctime_r(&result, sec1970str, sizeof(sec1970str) - 1);
441 #else
442 asctime_r(&result, sec1970str);
443 #endif // HAVE_ASCTIME_R_LONG
444 #else // HAVE_ASCTIME_R
445 char* bb = asctime(&result);
446 strcpy(sec1970str, bb);
447 #endif // HAVE_ASCTIME_R
448 char* d = strchr(sec1970str, '\n'); if (d) *d = 0;
449 AVM_WRITE("ASF reader", "MainHeader: %s\n"
450 " Created: %s File size=%.0f Packets=%.0f\n"
451 " Total time=%.1f sec Play time=%.1f sec Preroll=%.1f sec\n"
452 " Flags=0x%x Packet size=%d (=%d) MaxBandwidth=%d bps\n",
453 guid_to_string(b, &h->guid),
454 sec1970str,
455 (double)h->file_size,
456 (double)h->pkts_count,
457 (double)h->play_time / 10000000.,
458 (double)h->send_time / 10000000.,
459 (double)h->preroll / 1000., h->flags,
460 h->min_pktsize, h->max_pktsize,
461 h->max_bitrate);
462 }
463
464 void AsfReadHandler::PrintASFStreamHeader(const ASFStreamHeader* h)
465 {
466 char b[64], c[64];
467
468 AVM_WRITE("ASF reader", "StreamHeader: %s Error correction: %s\n"
469 " Time offset=%.0f Stream size=%d Error size=%d Stream=%d Reserved=0x%x\n",
470 guidid_to_text(guid_get_guidid(&h->hdr.stream_guid)),
471 guidid_to_text(guid_get_guidid(&h->hdr.error_guid)),
472 (double)h->hdr.time_offset,
473 h->hdr.stream_size,
474 h->hdr.error_size,
475 h->hdr.stream,
476 h->hdr.reserved);
477 }
478
479
480 IMediaReadHandler* CreateAsfReadHandler(const char* pszFile)
481 {
482 AsfReadHandler* r = new AsfReadHandler();
483 if (r && r->init(pszFile) == 0)
484 return r;
485
486 delete r;
487 return 0;
488 }
489
490 #undef __MODULE__
491
492 AVM_END_NAMESPACE;