1 /* GStreamer ASF/WMV/WMA demuxer
2 * Copyright (C) 2007 Tim-Philipp Müller <tim centricular net>
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
13 *
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
17 * Boston, MA 02110-1301, USA.
18 */
19
20 /* FIXME:
21 * file:///home/tpm/samples/video/asf//336370-regis-velo862.wmv
22 * file:///home/tpm/samples/video/asf//336370-eichhoer.wmv
23 * throw errors (not always necessarily) in this code path
24 * (looks like they carry broken payloads/packets though) */
25
26 #include "asfpacket.h"
27
28 #include <gst/gstutils.h>
29 #include <gst/gstinfo.h>
30 #include <string.h>
31
32 #define GST_ASF_PAYLOAD_KF_COMPLETE(stream, payload) (stream->is_video && payload->keyframe && payload->buf_filled >= payload->mo_size)
33
34 /* we are unlikely to deal with lengths > 2GB here any time soon, so just
35 * return a signed int and use that for error reporting */
36 static inline gint
asf_packet_read_varlen_int(guint lentype_flags,guint lentype_bit_offset,const guint8 ** p_data,guint * p_size)37 asf_packet_read_varlen_int (guint lentype_flags, guint lentype_bit_offset,
38 const guint8 ** p_data, guint * p_size)
39 {
40 static const guint lens[4] = { 0, 1, 2, 4 };
41 guint len, val;
42
43 len = lens[(lentype_flags >> lentype_bit_offset) & 0x03];
44
45 /* will make caller bail out with a short read if there's not enough data */
46 if (G_UNLIKELY (*p_size < len)) {
47 GST_WARNING ("need %u bytes, but only %u bytes available", len, *p_size);
48 return -1;
49 }
50
51 switch (len) {
52 case 0:
53 val = 0;
54 break;
55 case 1:
56 val = GST_READ_UINT8 (*p_data);
57 break;
58 case 2:
59 val = GST_READ_UINT16_LE (*p_data);
60 break;
61 case 4:
62 val = GST_READ_UINT32_LE (*p_data);
63 break;
64 default:
65 val = 0;
66 g_assert_not_reached ();
67 }
68
69 *p_data += len;
70 *p_size -= len;
71
72 return (gint) val;
73 }
74
75 static GstBuffer *
asf_packet_create_payload_buffer(AsfPacket * packet,const guint8 ** p_data,guint * p_size,guint payload_len)76 asf_packet_create_payload_buffer (AsfPacket * packet, const guint8 ** p_data,
77 guint * p_size, guint payload_len)
78 {
79 guint off;
80
81 g_assert (payload_len <= *p_size);
82
83 off = (guint) (*p_data - packet->bdata);
84 g_assert (off < gst_buffer_get_size (packet->buf));
85
86 *p_data += payload_len;
87 *p_size -= payload_len;
88
89 return gst_buffer_copy_region (packet->buf, GST_BUFFER_COPY_ALL, off,
90 payload_len);
91 }
92
93 static AsfPayload *
asf_payload_search_payloads_queue(AsfPayload * payload,GArray * payload_list)94 asf_payload_search_payloads_queue (AsfPayload * payload, GArray * payload_list)
95 {
96 AsfPayload *ret = NULL;
97 gint idx;
98 for (idx = payload_list->len - 1; idx >= 0; idx--) {
99 ret = &g_array_index (payload_list, AsfPayload, idx);
100
101 if (G_UNLIKELY (ret->mo_size == payload->mo_size &&
102 ret->mo_number == payload->mo_number)) {
103 return ret;
104 }
105 }
106 return NULL;
107 }
108
109 static AsfPayload *
asf_payload_find_previous_fragment(GstASFDemux * demux,AsfPayload * payload,AsfStream * stream)110 asf_payload_find_previous_fragment (GstASFDemux * demux, AsfPayload * payload,
111 AsfStream * stream)
112 {
113 AsfPayload *ret = NULL;
114
115 if (GST_ASF_DEMUX_IS_REVERSE_PLAYBACK (demux->segment)) {
116
117 /* Search in queued payloads list */
118 ret = asf_payload_search_payloads_queue (payload, stream->payloads);
119 if (ret) {
120 GST_DEBUG
121 ("previous fragments found in payloads queue for reverse playback : object ID %d",
122 ret->mo_number);
123 return ret;
124 }
125
126 /* Search in payloads 'to be queued' list */
127 ret = asf_payload_search_payloads_queue (payload, stream->payloads_rev);
128 if (ret) {
129 GST_DEBUG
130 ("previous fragments found in temp payload queue for reverse playback : object ID %d",
131 ret->mo_number);
132 return ret;
133 }
134 } else {
135 if (G_UNLIKELY (stream->payloads->len == 0)) {
136 GST_DEBUG ("No previous fragments to merge with for stream %u",
137 stream->id);
138 return NULL;
139 }
140
141 ret =
142 &g_array_index (stream->payloads, AsfPayload,
143 stream->payloads->len - 1);
144
145 if (G_UNLIKELY (ret->mo_size != payload->mo_size ||
146 ret->mo_number != payload->mo_number || ret->mo_offset != 0)) {
147 if (payload->mo_size != 0) {
148 GST_WARNING ("Previous fragment does not match continued fragment");
149 return NULL;
150 } else {
151 /* Warn about this case, but accept it anyway: files in the wild sometimes
152 * have continued packets where the subsequent fragments say that they're
153 * zero-sized. */
154 GST_WARNING ("Previous fragment found, but current fragment has "
155 "zero size, accepting anyway");
156 }
157 }
158 }
159
160 #if 0
161 if (this_fragment->mo_offset + this_payload_len > first_fragment->mo_size) {
162 GST_WARNING ("Merged fragments would be bigger than the media object");
163 return FALSE;
164 }
165 #endif
166
167 return ret;
168 }
169
170 /* TODO: if we have another payload already queued for this stream and that
171 * payload doesn't have a duration, maybe we can calculate a duration for it
172 * (if the previous timestamp is smaller etc. etc.) */
173 static void
gst_asf_payload_queue_for_stream_forward(GstASFDemux * demux,AsfPayload * payload,AsfStream * stream)174 gst_asf_payload_queue_for_stream_forward (GstASFDemux * demux,
175 AsfPayload * payload, AsfStream * stream)
176 {
177 GST_DEBUG_OBJECT (demux, "Got payload for stream %d ts:%" GST_TIME_FORMAT,
178 stream->id, GST_TIME_ARGS (payload->ts));
179
180 /* make timestamps start from 0; first_ts will be determined during activation (once we have enough data),
181 which will also update ts of all packets queued before we knew first_ts; */
182 if (G_LIKELY (GST_CLOCK_TIME_IS_VALID (demux->first_ts)
183 && GST_CLOCK_TIME_IS_VALID (payload->ts))) {
184 if (payload->ts > demux->first_ts)
185 payload->ts -= demux->first_ts;
186 else
187 payload->ts = 0;
188 }
189
190 /* remove any incomplete payloads that will never be completed */
191 while (stream->payloads->len > 0) {
192 AsfPayload *prev;
193 guint idx_last;
194
195 idx_last = stream->payloads->len - 1;
196 prev = &g_array_index (stream->payloads, AsfPayload, idx_last);
197
198 if (G_UNLIKELY (gst_asf_payload_is_complete (prev)))
199 break;
200
201 GST_DEBUG_OBJECT (demux, "Dropping incomplete fragmented media object "
202 "queued for stream %u", stream->id);
203
204 gst_buffer_replace (&prev->buf, NULL);
205 g_array_remove_index (stream->payloads, idx_last);
206
207 /* there's data missing, so there's a discontinuity now */
208 GST_BUFFER_FLAG_SET (payload->buf, GST_BUFFER_FLAG_DISCONT);
209 }
210
211 /* If we're about to queue a key frame that is before the segment start, we
212 * can ditch any previously queued payloads (which would also be before the
213 * segment start). This makes sure the decoder doesn't decode more than
214 * absolutely necessary after a seek (we don't push out payloads that are
215 * before the segment start until we have at least one that falls within the
216 * segment) */
217 if (G_UNLIKELY (GST_CLOCK_TIME_IS_VALID (payload->ts) &&
218 payload->ts < demux->segment.start && payload->keyframe)) {
219 GST_DEBUG_OBJECT (demux, "Queueing keyframe before segment start, removing"
220 " %u previously-queued payloads, which would be out of segment too and"
221 " hence don't have to be decoded", stream->payloads->len);
222 while (stream->payloads->len > 0) {
223 AsfPayload *last;
224 guint idx_last;
225
226 idx_last = stream->payloads->len - 1;
227 last = &g_array_index (stream->payloads, AsfPayload, idx_last);
228 gst_buffer_replace (&last->buf, NULL);
229 g_array_remove_index (stream->payloads, idx_last);
230 }
231
232 /* Mark discontinuity (should be done via stream->discont anyway though) */
233 GST_BUFFER_FLAG_SET (payload->buf, GST_BUFFER_FLAG_DISCONT);
234 }
235
236 g_array_append_vals (stream->payloads, payload, 1);
237 }
238
239 static void
gst_asf_payload_queue_for_stream_reverse(GstASFDemux * demux,AsfPayload * payload,AsfStream * stream)240 gst_asf_payload_queue_for_stream_reverse (GstASFDemux * demux,
241 AsfPayload * payload, AsfStream * stream)
242 {
243 GST_DEBUG_OBJECT (demux, "Got payload for stream %d ts:%" GST_TIME_FORMAT,
244 stream->id, GST_TIME_ARGS (payload->ts));
245
246 if (demux->multiple_payloads) {
247 /* store the payload in temporary buffer, until we parse all payloads in this packet */
248 g_array_append_vals (stream->payloads_rev, payload, 1);
249 } else {
250 if (G_LIKELY (GST_CLOCK_TIME_IS_VALID (payload->ts))) {
251 g_array_append_vals (stream->payloads, payload, 1);
252 if (GST_ASF_PAYLOAD_KF_COMPLETE (stream, payload)) {
253 stream->kf_pos = stream->payloads->len - 1;
254 }
255 } else {
256 gst_buffer_unref (payload->buf);
257 }
258 }
259 }
260
261
262 static void
gst_asf_payload_queue_for_stream(GstASFDemux * demux,AsfPayload * payload,AsfStream * stream)263 gst_asf_payload_queue_for_stream (GstASFDemux * demux, AsfPayload * payload,
264 AsfStream * stream)
265 {
266 GST_DEBUG_OBJECT (demux, "Got payload for stream %d ts:%" GST_TIME_FORMAT,
267 stream->id, GST_TIME_ARGS (payload->ts));
268
269 if (GST_ASF_DEMUX_IS_REVERSE_PLAYBACK (demux->segment)) {
270 gst_asf_payload_queue_for_stream_reverse (demux, payload, stream);
271 } else {
272 gst_asf_payload_queue_for_stream_forward (demux, payload, stream);
273 }
274
275 }
276
277 static void
asf_payload_parse_replicated_data_extensions(AsfStream * stream,AsfPayload * payload)278 asf_payload_parse_replicated_data_extensions (AsfStream * stream,
279 AsfPayload * payload)
280 {
281 AsfPayloadExtension *ext;
282 guint off;
283 guint16 ext_len;
284
285 if (!stream->ext_props.valid || stream->ext_props.payload_extensions == NULL)
286 return;
287
288 off = 8;
289 for (ext = stream->ext_props.payload_extensions; ext->len > 0; ++ext) {
290 ext_len = ext->len;
291 if (ext_len == 0xFFFF) { /* extension length is determined by first two bytes in replicated data */
292 ext_len = GST_READ_UINT16_LE (payload->rep_data + off);
293 off += 2;
294 }
295 if (G_UNLIKELY (off + ext_len > payload->rep_data_len)) {
296 GST_WARNING ("not enough replicated data for defined extensions");
297 return;
298 }
299 switch (ext->id) {
300 case ASF_PAYLOAD_EXTENSION_DURATION:
301 if (G_LIKELY (ext_len == 2)) {
302 guint16 tdur = GST_READ_UINT16_LE (payload->rep_data + off);
303 /* packet durations of 1ms are mostly invalid */
304 if (tdur != 1)
305 payload->duration = tdur * GST_MSECOND;
306 } else {
307 GST_WARNING ("unexpected DURATION extensions len %u", ext_len);
308 }
309 break;
310 case ASF_PAYLOAD_EXTENSION_SYSTEM_CONTENT:
311 if (G_LIKELY (ext_len == 1)) {
312 guint8 data = payload->rep_data[off];
313
314 payload->interlaced = data & 0x1;
315 payload->rff = data & 0x8;
316 payload->tff = (data & 0x2) || !(data & 0x4);
317 GST_DEBUG ("SYSTEM_CONTENT: interlaced:%d, rff:%d, tff:%d",
318 payload->interlaced, payload->rff, payload->tff);
319 } else {
320 GST_WARNING ("unexpected SYSTEM_CONTE extensions len %u", ext_len);
321 }
322 break;
323 case ASF_PAYLOAD_EXTENSION_SYSTEM_PIXEL_ASPECT_RATIO:
324 if (G_LIKELY (ext_len == 2)) {
325 payload->par_x = payload->rep_data[off];
326 payload->par_y = payload->rep_data[off + 1];
327 GST_DEBUG ("PAR %d / %d", payload->par_x, payload->par_y);
328 } else {
329 GST_WARNING ("unexpected SYSTEM_PIXEL_ASPECT_RATIO extensions len %u",
330 ext_len);
331 }
332 break;
333 case ASF_PAYLOAD_EXTENSION_TIMING:
334 {
335 /* dvr-ms timing - this will override packet timestamp */
336 guint64 time = GST_READ_UINT64_LE (payload->rep_data + off + 8);
337 if (time != 0xFFFFFFFFFFFFFFFF)
338 payload->ts = time * 100;
339 else
340 payload->ts = GST_CLOCK_TIME_NONE;
341 }
342 break;
343 default:
344 GST_LOG ("UNKNOWN PAYLOAD EXTENSION!");
345 break;
346 }
347 off += ext_len;
348 }
349 }
350
351 static gboolean
gst_asf_demux_parse_payload(GstASFDemux * demux,AsfPacket * packet,gint lentype,const guint8 ** p_data,guint * p_size)352 gst_asf_demux_parse_payload (GstASFDemux * demux, AsfPacket * packet,
353 gint lentype, const guint8 ** p_data, guint * p_size)
354 {
355 AsfPayload payload = { 0, };
356 AsfStream *stream;
357 gboolean is_compressed;
358 guint payload_len;
359 guint stream_num;
360
361 if (G_UNLIKELY (*p_size < 1)) {
362 GST_WARNING_OBJECT (demux, "Short packet!");
363 return FALSE;
364 }
365
366 stream_num = GST_READ_UINT8 (*p_data) & 0x7f;
367 payload.keyframe = ((GST_READ_UINT8 (*p_data) & 0x80) != 0);
368
369 *p_data += 1;
370 *p_size -= 1;
371
372 payload.ts = GST_CLOCK_TIME_NONE;
373 payload.duration = GST_CLOCK_TIME_NONE;
374 payload.par_x = 0;
375 payload.par_y = 0;
376 payload.interlaced = FALSE;
377 payload.tff = FALSE;
378 payload.rff = FALSE;
379
380 payload.mo_number =
381 asf_packet_read_varlen_int (packet->prop_flags, 4, p_data, p_size);
382 payload.mo_offset =
383 asf_packet_read_varlen_int (packet->prop_flags, 2, p_data, p_size);
384 payload.rep_data_len =
385 asf_packet_read_varlen_int (packet->prop_flags, 0, p_data, p_size);
386
387 is_compressed = (payload.rep_data_len == 1);
388
389 GST_LOG_OBJECT (demux, "payload for stream %u", stream_num);
390 GST_LOG_OBJECT (demux, "keyframe : %s", (payload.keyframe) ? "yes" : "no");
391 GST_LOG_OBJECT (demux, "compressed : %s", (is_compressed) ? "yes" : "no");
392
393 if (G_UNLIKELY (*p_size < payload.rep_data_len)) {
394 GST_WARNING_OBJECT (demux, "Short packet! rep_data_len=%u, size=%u",
395 payload.rep_data_len, *p_size);
396 return FALSE;
397 }
398
399 memcpy (payload.rep_data, *p_data,
400 MIN (sizeof (payload.rep_data), payload.rep_data_len));
401
402 *p_data += payload.rep_data_len;
403 *p_size -= payload.rep_data_len;
404
405 if (G_UNLIKELY (*p_size == 0)) {
406 GST_WARNING_OBJECT (demux, "payload without data!?");
407 return FALSE;
408 }
409
410 /* we use -1 as lentype for a single payload that's the size of the packet */
411 if (G_UNLIKELY ((lentype >= 0 && lentype <= 3))) {
412 payload_len = asf_packet_read_varlen_int (lentype, 0, p_data, p_size);
413 if (*p_size < payload_len) {
414 GST_WARNING_OBJECT (demux, "Short packet! payload_len=%u, size=%u",
415 payload_len, *p_size);
416 return FALSE;
417 }
418 } else {
419 payload_len = *p_size;
420 }
421
422 GST_LOG_OBJECT (demux, "payload length: %u", payload_len);
423
424 stream = gst_asf_demux_get_stream (demux, stream_num);
425
426 if (G_UNLIKELY (stream == NULL)) {
427 if (gst_asf_demux_is_unknown_stream (demux, stream_num)) {
428 GST_WARNING_OBJECT (demux, "Payload for unknown stream %u, skipping",
429 stream_num);
430 }
431 if (*p_size < payload_len) {
432 *p_data += *p_size;
433 *p_size = 0;
434 } else {
435 *p_data += payload_len;
436 *p_size -= payload_len;
437 }
438 return TRUE;
439 }
440
441 if (!stream->is_video)
442 stream->kf_pos = 0;
443
444 if (G_UNLIKELY (!is_compressed)) {
445 GST_LOG_OBJECT (demux, "replicated data length: %u", payload.rep_data_len);
446
447 if (payload.rep_data_len >= 8) {
448 payload.mo_size = GST_READ_UINT32_LE (payload.rep_data);
449 payload.ts = GST_READ_UINT32_LE (payload.rep_data + 4) * GST_MSECOND;
450 if (G_UNLIKELY (payload.ts < demux->preroll))
451 payload.ts = 0;
452 else
453 payload.ts -= demux->preroll;
454 asf_payload_parse_replicated_data_extensions (stream, &payload);
455
456 GST_LOG_OBJECT (demux, "media object size : %u", payload.mo_size);
457 GST_LOG_OBJECT (demux, "media object ts : %" GST_TIME_FORMAT,
458 GST_TIME_ARGS (payload.ts));
459 GST_LOG_OBJECT (demux, "media object dur : %" GST_TIME_FORMAT,
460 GST_TIME_ARGS (payload.duration));
461 } else if (payload.rep_data_len == 0) {
462 payload.mo_size = 0;
463 } else if (payload.rep_data_len != 0) {
464 GST_WARNING_OBJECT (demux, "invalid replicated data length, very bad");
465 *p_data += payload_len;
466 *p_size -= payload_len;
467 return FALSE;
468 }
469
470 GST_LOG_OBJECT (demux, "media object offset : %u", payload.mo_offset);
471
472 GST_LOG_OBJECT (demux, "payload length: %u", payload_len);
473
474 if (payload_len == 0) {
475 GST_DEBUG_OBJECT (demux, "skipping empty payload");
476 } else if (payload.mo_offset == 0 && payload.mo_size == payload_len) {
477 /* if the media object is not fragmented, just create a sub-buffer */
478 GST_LOG_OBJECT (demux, "unfragmented media object size %u", payload_len);
479 payload.buf = asf_packet_create_payload_buffer (packet, p_data, p_size,
480 payload_len);
481 payload.buf_filled = payload_len;
482 gst_asf_payload_queue_for_stream (demux, &payload, stream);
483 } else if (GST_ASF_DEMUX_IS_REVERSE_PLAYBACK (demux->segment)) {
484 /* Handle fragmented payloads for reverse playback */
485 AsfPayload *prev;
486 const guint8 *payload_data = *p_data;
487 prev = asf_payload_find_previous_fragment (demux, &payload, stream);
488
489 if (prev) {
490 gint idx;
491 AsfPayload *p;
492 gst_buffer_fill (prev->buf, payload.mo_offset,
493 payload_data, payload_len);
494 prev->buf_filled += payload_len;
495 if (payload.keyframe && payload.mo_offset == 0) {
496 stream->reverse_kf_ready = TRUE;
497
498 for (idx = stream->payloads->len - 1; idx >= 0; idx--) {
499 p = &g_array_index (stream->payloads, AsfPayload, idx);
500 if (p->mo_number == payload.mo_number) {
501 /* Mark position of KF for reverse play */
502 stream->kf_pos = idx;
503 }
504 }
505 }
506 } else {
507 payload.buf = gst_buffer_new_allocate (NULL, payload.mo_size, NULL); /* can we use (mo_size - offset) for size? */
508 gst_buffer_fill (payload.buf, payload.mo_offset,
509 payload_data, payload_len);
510 payload.buf_filled = payload.mo_size - (payload.mo_offset);
511 gst_asf_payload_queue_for_stream (demux, &payload, stream);
512 }
513 *p_data += payload_len;
514 *p_size -= payload_len;
515 } else {
516 const guint8 *payload_data = *p_data;
517
518 g_assert (payload_len <= *p_size);
519
520 *p_data += payload_len;
521 *p_size -= payload_len;
522
523 /* n-th fragment of a fragmented media object? */
524 if (payload.mo_offset != 0) {
525 AsfPayload *prev;
526
527 if ((prev =
528 asf_payload_find_previous_fragment (demux, &payload, stream))) {
529 if (prev->buf == NULL || (payload.mo_size > 0
530 && payload.mo_size != prev->mo_size)
531 || payload.mo_offset >= gst_buffer_get_size (prev->buf)
532 || payload.mo_offset + payload_len >
533 gst_buffer_get_size (prev->buf)) {
534 GST_WARNING_OBJECT (demux, "Offset doesn't match previous data?!");
535 } else {
536 /* we assume fragments are payloaded with increasing mo_offset */
537 if (payload.mo_offset != prev->buf_filled) {
538 GST_WARNING_OBJECT (demux, "media object payload discontinuity: "
539 "offset=%u vs buf_filled=%u", payload.mo_offset,
540 prev->buf_filled);
541 }
542 gst_buffer_fill (prev->buf, payload.mo_offset,
543 payload_data, payload_len);
544 prev->buf_filled =
545 MAX (prev->buf_filled, payload.mo_offset + payload_len);
546 GST_LOG_OBJECT (demux, "Merged media object fragments, size now %u",
547 prev->buf_filled);
548 }
549 } else {
550 GST_DEBUG_OBJECT (demux, "n-th payload fragment, but don't have "
551 "any previous fragment, ignoring payload");
552 }
553 } else {
554 GST_LOG_OBJECT (demux, "allocating buffer of size %u for fragmented "
555 "media object", payload.mo_size);
556 payload.buf = gst_buffer_new_allocate (NULL, payload.mo_size, NULL);
557 gst_buffer_fill (payload.buf, 0, payload_data, payload_len);
558 payload.buf_filled = payload_len;
559
560 gst_asf_payload_queue_for_stream (demux, &payload, stream);
561 }
562 }
563 } else {
564 const guint8 *payload_data;
565 GstClockTime ts, ts_delta;
566 guint num;
567
568 GST_LOG_OBJECT (demux, "Compressed payload, length=%u", payload_len);
569
570 payload_data = *p_data;
571
572 *p_data += payload_len;
573 *p_size -= payload_len;
574
575 ts = payload.mo_offset * GST_MSECOND;
576 if (G_UNLIKELY (ts < demux->preroll))
577 ts = 0;
578 else
579 ts -= demux->preroll;
580 ts_delta = payload.rep_data[0] * GST_MSECOND;
581
582 for (num = 0; payload_len > 0; ++num) {
583 guint sub_payload_len;
584
585 sub_payload_len = GST_READ_UINT8 (payload_data);
586
587 GST_LOG_OBJECT (demux, "subpayload #%u: len=%u, ts=%" GST_TIME_FORMAT,
588 num, sub_payload_len, GST_TIME_ARGS (ts));
589
590 ++payload_data;
591 --payload_len;
592
593 if (G_UNLIKELY (payload_len < sub_payload_len)) {
594 GST_WARNING_OBJECT (demux, "Short payload! %u bytes left", payload_len);
595 return FALSE;
596 }
597
598 if (G_LIKELY (sub_payload_len > 0)) {
599 payload.buf = asf_packet_create_payload_buffer (packet,
600 &payload_data, &payload_len, sub_payload_len);
601 payload.buf_filled = sub_payload_len;
602
603 payload.ts = ts;
604 if (G_LIKELY (ts_delta))
605 payload.duration = ts_delta;
606 else
607 payload.duration = GST_CLOCK_TIME_NONE;
608
609 gst_asf_payload_queue_for_stream (demux, &payload, stream);
610 }
611
612 ts += ts_delta;
613 }
614 }
615
616 return TRUE;
617 }
618
619 GstAsfDemuxParsePacketError
gst_asf_demux_parse_packet(GstASFDemux * demux,GstBuffer * buf)620 gst_asf_demux_parse_packet (GstASFDemux * demux, GstBuffer * buf)
621 {
622 AsfPacket packet = { 0, };
623 GstMapInfo map;
624 const guint8 *data;
625 gboolean has_multiple_payloads;
626 GstAsfDemuxParsePacketError ret = GST_ASF_DEMUX_PARSE_PACKET_ERROR_NONE;
627 guint8 ec_flags, flags1;
628 guint size;
629
630 gst_buffer_map (buf, &map, GST_MAP_READ);
631 data = map.data;
632 size = map.size;
633 GST_LOG_OBJECT (demux, "Buffer size: %u", size);
634
635 /* need at least two payload flag bytes, send time, and duration */
636 if (G_UNLIKELY (size < 2 + 4 + 2)) {
637 GST_WARNING_OBJECT (demux, "Packet size is < 8");
638 ret = GST_ASF_DEMUX_PARSE_PACKET_ERROR_RECOVERABLE;
639 goto done;
640 }
641
642 packet.buf = buf;
643 /* evidently transient */
644 packet.bdata = data;
645
646 ec_flags = GST_READ_UINT8 (data);
647
648 /* skip optional error correction stuff */
649 if ((ec_flags & 0x80) != 0) {
650 guint ec_len_type, ec_len;
651
652 ec_len_type = (ec_flags & 0x60) >> 5;
653 if (ec_len_type == 0) {
654 ec_len = ec_flags & 0x0f;
655 } else {
656 GST_WARNING_OBJECT (demux, "unexpected error correction length type %u",
657 ec_len_type);
658 ec_len = 2;
659 }
660 GST_LOG_OBJECT (demux, "packet has error correction (%u bytes)", ec_len);
661
662 /* still need at least two payload flag bytes, send time, and duration */
663 if (size <= (1 + ec_len) + 2 + 4 + 2) {
664 GST_WARNING_OBJECT (demux, "Packet size is < 8 with Error Correction");
665 ret = GST_ASF_DEMUX_PARSE_PACKET_ERROR_FATAL;
666 goto done;
667 }
668
669 data += 1 + ec_len;
670 size -= 1 + ec_len;
671 }
672
673 /* parse payload info */
674 flags1 = GST_READ_UINT8 (data);
675 packet.prop_flags = GST_READ_UINT8 (data + 1);
676
677 data += 2;
678 size -= 2;
679
680 has_multiple_payloads = (flags1 & 0x01) != 0;
681
682 packet.length = asf_packet_read_varlen_int (flags1, 5, &data, &size);
683
684 packet.sequence = asf_packet_read_varlen_int (flags1, 1, &data, &size);
685
686 packet.padding = asf_packet_read_varlen_int (flags1, 3, &data, &size);
687
688 if (G_UNLIKELY (size < 6)) {
689 GST_WARNING_OBJECT (demux, "Packet size is < 6");
690 ret = GST_ASF_DEMUX_PARSE_PACKET_ERROR_FATAL;
691 goto done;
692 }
693
694 packet.send_time = GST_READ_UINT32_LE (data) * GST_MSECOND;
695 packet.duration = GST_READ_UINT16_LE (data + 4) * GST_MSECOND;
696
697 data += 4 + 2;
698 size -= 4 + 2;
699
700 GST_LOG_OBJECT (demux, "flags : 0x%x", flags1);
701 GST_LOG_OBJECT (demux, "multiple payloads: %u", has_multiple_payloads);
702 GST_LOG_OBJECT (demux, "packet length : %u", packet.length);
703 GST_LOG_OBJECT (demux, "sequence : %u", packet.sequence);
704 GST_LOG_OBJECT (demux, "padding : %u", packet.padding);
705 GST_LOG_OBJECT (demux, "send time : %" GST_TIME_FORMAT,
706 GST_TIME_ARGS (packet.send_time));
707
708 GST_LOG_OBJECT (demux, "duration : %" GST_TIME_FORMAT,
709 GST_TIME_ARGS (packet.duration));
710
711 if (GST_ASF_DEMUX_IS_REVERSE_PLAYBACK (demux->segment)
712 && demux->seek_to_cur_pos == TRUE) {
713 /* For reverse playback, initially parse packets forward until we reach packet with 'seek' timestamp */
714 if (packet.send_time - demux->preroll > demux->segment.stop) {
715 demux->seek_to_cur_pos = FALSE;
716 }
717 ret = GST_ASF_DEMUX_PARSE_PACKET_ERROR_NONE;
718 goto done;
719 }
720
721 if (G_UNLIKELY (packet.padding == (guint) - 1 || size < packet.padding)) {
722 GST_WARNING_OBJECT (demux, "No padding, or padding bigger than buffer");
723 ret = GST_ASF_DEMUX_PARSE_PACKET_ERROR_RECOVERABLE;
724 goto done;
725 }
726
727 size -= packet.padding;
728
729 /* adjust available size for parsing if there's less actual packet data for
730 * parsing than there is data in bytes (for sample see bug 431318) */
731 if (G_UNLIKELY (packet.length != 0 && packet.padding == 0
732 && packet.length < demux->packet_size)) {
733 GST_LOG_OBJECT (demux, "shortened packet with implicit padding, "
734 "adjusting available data size");
735 if (size < demux->packet_size - packet.length) {
736 /* the buffer is smaller than the implicit padding */
737 GST_WARNING_OBJECT (demux, "Buffer is smaller than the implicit padding");
738 ret = GST_ASF_DEMUX_PARSE_PACKET_ERROR_RECOVERABLE;
739 goto done;
740 } else {
741 /* subtract the implicit padding */
742 size -= (demux->packet_size - packet.length);
743 }
744 }
745
746 if (has_multiple_payloads) {
747 guint i, num, lentype;
748 demux->multiple_payloads = TRUE;
749
750 if (G_UNLIKELY (size < 1)) {
751 GST_WARNING_OBJECT (demux, "No room more in buffer");
752 ret = GST_ASF_DEMUX_PARSE_PACKET_ERROR_RECOVERABLE;
753 goto done;
754 }
755
756 num = (GST_READ_UINT8 (data) & 0x3F) >> 0;
757 lentype = (GST_READ_UINT8 (data) & 0xC0) >> 6;
758
759 ++data;
760 --size;
761
762 GST_LOG_OBJECT (demux, "num payloads : %u", num);
763
764 for (i = 0; i < num; ++i) {
765 GST_LOG_OBJECT (demux, "Parsing payload %u/%u, size left: %u", i + 1, num,
766 size);
767
768 if (G_UNLIKELY (!gst_asf_demux_parse_payload (demux, &packet, lentype,
769 &data, &size))) {
770 GST_WARNING_OBJECT (demux, "Failed to parse payload %u/%u", i + 1, num);
771 ret = GST_ASF_DEMUX_PARSE_PACKET_ERROR_FATAL;
772 break;
773 }
774 }
775
776 if (GST_ASF_DEMUX_IS_REVERSE_PLAYBACK (demux->segment)) {
777 /* In reverse playback, we parsed the packet (with multiple payloads) and stored the payloads in temporary queue.
778 Now, add them to the stream's payload queue */
779 for (i = 0; i < demux->num_streams; i++) {
780 AsfStream *s = &demux->stream[i];
781 while (s->payloads_rev->len > 0) {
782 AsfPayload *p;
783 p = &g_array_index (s->payloads_rev, AsfPayload,
784 s->payloads_rev->len - 1);
785 g_array_append_vals (s->payloads, p, 1);
786 if (GST_ASF_PAYLOAD_KF_COMPLETE (s, p)) {
787 /* Mark position of KF for reverse play */
788 s->kf_pos = s->payloads->len - 1;
789 }
790 g_array_remove_index (s->payloads_rev, (s->payloads_rev->len - 1));
791 }
792 }
793 }
794
795 } else {
796 GST_LOG_OBJECT (demux, "Parsing single payload");
797 demux->multiple_payloads = FALSE;
798 if (G_UNLIKELY (!gst_asf_demux_parse_payload (demux, &packet, -1, &data,
799 &size))) {
800 GST_WARNING_OBJECT (demux, "Failed to parse payload");
801 ret = GST_ASF_DEMUX_PARSE_PACKET_ERROR_RECOVERABLE;
802 }
803 }
804
805 done:
806 gst_buffer_unmap (buf, &map);
807 return ret;
808 }
809