tsdemux: Remove useless code
[vjaquez-gstreamer:gst-plugins-bad.git] / gst / mpegtsdemux / tsdemux.c
1 /*
2  * tsdemux.c
3  * Copyright (C) 2009 Zaheer Abbas Merali
4  *               2010 Edward Hervey
5  * Copyright (C) 2011, Hewlett-Packard Development Company, L.P.
6  *  Author: Youness Alaoui <youness.alaoui@collabora.co.uk>, Collabora Ltd.
7  *  Author: Sebastian Dröge <sebastian.droege@collabora.co.uk>, Collabora Ltd.
8  *  Author: Edward Hervey <bilboed@bilboed.com>, Collabora Ltd.
9  *
10  * Authors:
11  *   Zaheer Abbas Merali <zaheerabbas at merali dot org>
12  *   Edward Hervey <edward.hervey@collabora.co.uk>
13  *
14  * This library is free software; you can redistribute it and/or
15  * modify it under the terms of the GNU Library General Public
16  * License as published by the Free Software Foundation; either
17  * version 2 of the License, or (at your option) any later version.
18  *
19  * This library is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
22  * Library General Public License for more details.
23  *
24  * You should have received a copy of the GNU Library General Public
25  * License along with this library; if not, write to the
26  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
27  * Boston, MA 02111-1307, USA.
28  */
29
30 #ifdef HAVE_CONFIG_H
31 #include "config.h"
32 #endif
33
34 #include <stdlib.h>
35 #include <string.h>
36
37 #include <glib.h>
38 #include <gst/tag/tag.h>
39
40 #include "mpegtsbase.h"
41 #include "tsdemux.h"
42 #include "gstmpegdesc.h"
43 #include "gstmpegdefs.h"
44 #include "mpegtspacketizer.h"
45 #include "pesparse.h"
46
47 /*
48  * tsdemux
49  *
50  * See TODO for explanations on improvements needed
51  */
52
53 /* latency in mseconds */
54 #define TS_LATENCY 700
55
56 #define TABLE_ID_UNSET 0xFF
57
58 #define PCR_WRAP_SIZE_128KBPS (((gint64)1490)*(1024*1024))
59 /* small PCR for wrap detection */
60 #define PCR_SMALL 17775000
61 /* maximal PCR time */
62 #define PCR_MAX_VALUE (((((guint64)1)<<33) * 300) + 298)
63 #define PTS_DTS_MAX_VALUE (((guint64)1) << 33)
64
65 /* Seeking/Scanning related variables */
66
67 /* seek to SEEK_TIMESTAMP_OFFSET before the desired offset and search then
68  * either accurately or for the next timestamp
69  */
70 #define SEEK_TIMESTAMP_OFFSET (500 * GST_MSECOND)
71
72 #define SEGMENT_FORMAT "[format:%s, rate:%f, start:%"                   \
73   GST_TIME_FORMAT", stop:%"GST_TIME_FORMAT", time:%"GST_TIME_FORMAT     \
74   ", base:%"GST_TIME_FORMAT", position:%"GST_TIME_FORMAT                \
75   ", duration:%"GST_TIME_FORMAT"]"
76
77 #define SEGMENT_ARGS(a) gst_format_get_name((a).format), (a).rate,      \
78     GST_TIME_ARGS((a).start), GST_TIME_ARGS((a).stop),                  \
79     GST_TIME_ARGS((a).time), GST_TIME_ARGS((a).base),                   \
80     GST_TIME_ARGS((a).position), GST_TIME_ARGS((a).duration)
81
82
83 GST_DEBUG_CATEGORY_STATIC (ts_demux_debug);
84 #define GST_CAT_DEFAULT ts_demux_debug
85
86 #define ABSDIFF(a,b) (((a) > (b)) ? ((a) - (b)) : ((b) - (a)))
87
88 static GQuark QUARK_TSDEMUX;
89 static GQuark QUARK_PID;
90 static GQuark QUARK_PCR;
91 static GQuark QUARK_OPCR;
92 static GQuark QUARK_PTS;
93 static GQuark QUARK_DTS;
94 static GQuark QUARK_OFFSET;
95
96 typedef enum
97 {
98   PENDING_PACKET_EMPTY = 0,     /* No pending packet/buffer
99                                  * Push incoming buffers to the array */
100   PENDING_PACKET_HEADER,        /* PES header needs to be parsed
101                                  * Push incoming buffers to the array */
102   PENDING_PACKET_BUFFER,        /* Currently filling up output buffer
103                                  * Push incoming buffers to the bufferlist */
104   PENDING_PACKET_DISCONT        /* Discontinuity in incoming packets
105                                  * Drop all incoming buffers */
106 } PendingPacketState;
107
108 typedef struct _TSDemuxStream TSDemuxStream;
109
110 struct _TSDemuxStream
111 {
112   MpegTSBaseStream stream;
113
114   GstPad *pad;
115   /* Whether the pad was added or not */
116   gboolean active;
117
118   /* the return of the latest push */
119   GstFlowReturn flow_return;
120
121   /* Output data */
122   PendingPacketState state;
123
124   /* Data to push (allocated) */
125   guint8 *data;
126
127   /* Size of data to push (if known) */
128   guint expected_size;
129
130   /* Size of currently queued data */
131   guint current_size;
132   guint allocated_size;
133
134   /* Current PTS/DTS for this stream */
135   GstClockTime pts;
136   GstClockTime dts;
137   /* Raw value of current PTS/DTS */
138   guint64 raw_pts;
139   guint64 raw_dts;
140   /* PTS/DTS with rollover fixed */
141   guint64 fixed_pts;
142   guint64 fixed_dts;
143   /* Number of rollover seen for PTS/DTS (default:0) */
144   guint nb_pts_rollover;
145   guint nb_dts_rollover;
146
147   /* Whether this stream needs to send a newsegment */
148   gboolean need_newsegment;
149
150   GstTagList *taglist;
151 };
152
153 #define VIDEO_CAPS \
154   GST_STATIC_CAPS (\
155     "video/mpeg, " \
156       "mpegversion = (int) { 1, 2, 4 }, " \
157       "systemstream = (boolean) FALSE; " \
158     "video/x-h264,stream-format=(string)byte-stream," \
159       "alignment=(string)nal;" \
160     "video/x-dirac;" \
161     "video/x-wmv," \
162       "wmvversion = (int) 3, " \
163       "format = (string) WVC1" \
164   )
165
166 #define AUDIO_CAPS \
167   GST_STATIC_CAPS ( \
168     "audio/mpeg, " \
169       "mpegversion = (int) 1;" \
170     "audio/mpeg, " \
171       "mpegversion = (int) 2, " \
172       "stream-format = (string) adts; " \
173     "audio/mpeg, " \
174       "mpegversion = (int) 4, " \
175       "stream-format = (string) loas; " \
176     "audio/x-lpcm, " \
177       "width = (int) { 16, 20, 24 }, " \
178       "rate = (int) { 48000, 96000 }, " \
179       "channels = (int) [ 1, 8 ], " \
180       "dynamic_range = (int) [ 0, 255 ], " \
181       "emphasis = (boolean) { FALSE, TRUE }, " \
182       "mute = (boolean) { FALSE, TRUE }; " \
183     "audio/x-ac3; audio/x-eac3;" \
184     "audio/x-dts;" \
185     "audio/x-private-ts-lpcm" \
186   )
187
188 /* Can also use the subpicture pads for text subtitles? */
189 #define SUBPICTURE_CAPS \
190     GST_STATIC_CAPS ("subpicture/x-pgs; video/x-dvd-subpicture")
191
192 static GstStaticPadTemplate video_template =
193 GST_STATIC_PAD_TEMPLATE ("video_%04x", GST_PAD_SRC,
194     GST_PAD_SOMETIMES,
195     VIDEO_CAPS);
196
197 static GstStaticPadTemplate audio_template =
198 GST_STATIC_PAD_TEMPLATE ("audio_%04x",
199     GST_PAD_SRC,
200     GST_PAD_SOMETIMES,
201     AUDIO_CAPS);
202
203 static GstStaticPadTemplate subpicture_template =
204 GST_STATIC_PAD_TEMPLATE ("subpicture_%04x",
205     GST_PAD_SRC,
206     GST_PAD_SOMETIMES,
207     SUBPICTURE_CAPS);
208
209 static GstStaticPadTemplate private_template =
210 GST_STATIC_PAD_TEMPLATE ("private_%04x",
211     GST_PAD_SRC,
212     GST_PAD_SOMETIMES,
213     GST_STATIC_CAPS_ANY);
214
215 enum
216 {
217   ARG_0,
218   PROP_PROGRAM_NUMBER,
219   PROP_EMIT_STATS,
220   /* FILL ME */
221 };
222
223 /* Pad functions */
224
225
226 /* mpegtsbase methods */
227 static void
228 gst_ts_demux_program_started (MpegTSBase * base, MpegTSBaseProgram * program);
229 static void gst_ts_demux_reset (MpegTSBase * base);
230 static GstFlowReturn
231 gst_ts_demux_push (MpegTSBase * base, MpegTSPacketizerPacket * packet,
232     MpegTSPacketizerSection * section);
233 static void gst_ts_demux_flush (MpegTSBase * base);
234 static void
235 gst_ts_demux_stream_added (MpegTSBase * base, MpegTSBaseStream * stream,
236     MpegTSBaseProgram * program);
237 static void
238 gst_ts_demux_stream_removed (MpegTSBase * base, MpegTSBaseStream * stream);
239 static GstFlowReturn gst_ts_demux_do_seek (MpegTSBase * base, GstEvent * event);
240 static void gst_ts_demux_set_property (GObject * object, guint prop_id,
241     const GValue * value, GParamSpec * pspec);
242 static void gst_ts_demux_get_property (GObject * object, guint prop_id,
243     GValue * value, GParamSpec * pspec);
244 static void gst_ts_demux_flush_streams (GstTSDemux * tsdemux);
245 static GstFlowReturn
246 gst_ts_demux_push_pending_data (GstTSDemux * demux, TSDemuxStream * stream);
247 static void gst_ts_demux_stream_flush (TSDemuxStream * stream);
248
249 static gboolean push_event (MpegTSBase * base, GstEvent * event);
250
251 static void
252 _extra_init (void)
253 {
254   QUARK_TSDEMUX = g_quark_from_string ("tsdemux");
255   QUARK_PID = g_quark_from_string ("pid");
256   QUARK_PCR = g_quark_from_string ("pcr");
257   QUARK_OPCR = g_quark_from_string ("opcr");
258   QUARK_PTS = g_quark_from_string ("pts");
259   QUARK_DTS = g_quark_from_string ("dts");
260   QUARK_OFFSET = g_quark_from_string ("offset");
261 }
262
263 #define gst_ts_demux_parent_class parent_class
264 G_DEFINE_TYPE_WITH_CODE (GstTSDemux, gst_ts_demux, GST_TYPE_MPEGTS_BASE,
265     _extra_init ());
266
267 static void
268 gst_ts_demux_class_init (GstTSDemuxClass * klass)
269 {
270   GObjectClass *gobject_class;
271   GstElementClass *element_class;
272   MpegTSBaseClass *ts_class;
273
274   gobject_class = G_OBJECT_CLASS (klass);
275   gobject_class->set_property = gst_ts_demux_set_property;
276   gobject_class->get_property = gst_ts_demux_get_property;
277
278   g_object_class_install_property (gobject_class, PROP_PROGRAM_NUMBER,
279       g_param_spec_int ("program-number", "Program number",
280           "Program Number to demux for (-1 to ignore)", -1, G_MAXINT,
281           -1, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
282
283   g_object_class_install_property (gobject_class, PROP_EMIT_STATS,
284       g_param_spec_boolean ("emit-stats", "Emit statistics",
285           "Emit messages for every pcr/opcr/pts/dts", FALSE,
286           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
287
288   element_class = GST_ELEMENT_CLASS (klass);
289   gst_element_class_add_pad_template (element_class,
290       gst_static_pad_template_get (&video_template));
291   gst_element_class_add_pad_template (element_class,
292       gst_static_pad_template_get (&audio_template));
293   gst_element_class_add_pad_template (element_class,
294       gst_static_pad_template_get (&subpicture_template));
295   gst_element_class_add_pad_template (element_class,
296       gst_static_pad_template_get (&private_template));
297
298   gst_element_class_set_details_simple (element_class,
299       "MPEG transport stream demuxer",
300       "Codec/Demuxer",
301       "Demuxes MPEG2 transport streams",
302       "Zaheer Abbas Merali <zaheerabbas at merali dot org>\n"
303       "Edward Hervey <edward.hervey@collabora.co.uk>");
304
305   ts_class = GST_MPEGTS_BASE_CLASS (klass);
306   ts_class->reset = GST_DEBUG_FUNCPTR (gst_ts_demux_reset);
307   ts_class->push = GST_DEBUG_FUNCPTR (gst_ts_demux_push);
308   ts_class->push_event = GST_DEBUG_FUNCPTR (push_event);
309   ts_class->program_started = GST_DEBUG_FUNCPTR (gst_ts_demux_program_started);
310   ts_class->stream_added = gst_ts_demux_stream_added;
311   ts_class->stream_removed = gst_ts_demux_stream_removed;
312   ts_class->seek = GST_DEBUG_FUNCPTR (gst_ts_demux_do_seek);
313   ts_class->flush = GST_DEBUG_FUNCPTR (gst_ts_demux_flush);
314 }
315
316 static void
317 gst_ts_demux_reset (MpegTSBase * base)
318 {
319   GstTSDemux *demux = (GstTSDemux *) base;
320
321   demux->program_number = -1;
322   demux->calculate_update_segment = FALSE;
323
324   gst_segment_init (&demux->segment, GST_FORMAT_TIME);
325   if (demux->segment_event) {
326     gst_event_unref (demux->segment_event);
327     demux->segment_event = NULL;
328   }
329
330   if (demux->update_segment) {
331     gst_event_unref (demux->update_segment);
332     demux->update_segment = NULL;
333   }
334 }
335
336 static void
337 gst_ts_demux_init (GstTSDemux * demux)
338 {
339   GST_MPEGTS_BASE (demux)->stream_size = sizeof (TSDemuxStream);
340
341   gst_ts_demux_reset ((MpegTSBase *) demux);
342 }
343
344
345 static void
346 gst_ts_demux_set_property (GObject * object, guint prop_id,
347     const GValue * value, GParamSpec * pspec)
348 {
349   GstTSDemux *demux = GST_TS_DEMUX (object);
350
351   switch (prop_id) {
352     case PROP_PROGRAM_NUMBER:
353       /* FIXME: do something if program is switched as opposed to set at
354        * beginning */
355       demux->program_number = g_value_get_int (value);
356       break;
357     case PROP_EMIT_STATS:
358       demux->emit_statistics = g_value_get_boolean (value);
359       break;
360     default:
361       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
362   }
363 }
364
365 static void
366 gst_ts_demux_get_property (GObject * object, guint prop_id,
367     GValue * value, GParamSpec * pspec)
368 {
369   GstTSDemux *demux = GST_TS_DEMUX (object);
370
371   switch (prop_id) {
372     case PROP_PROGRAM_NUMBER:
373       g_value_set_int (value, demux->program_number);
374       break;
375     case PROP_EMIT_STATS:
376       g_value_set_boolean (value, demux->emit_statistics);
377       break;
378     default:
379       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
380   }
381 }
382
383 static gboolean
384 gst_ts_demux_srcpad_query (GstPad * pad, GstObject * parent, GstQuery * query)
385 {
386   gboolean res = TRUE;
387   GstFormat format;
388   GstTSDemux *demux;
389   MpegTSBase *base;
390
391   demux = GST_TS_DEMUX (parent);
392   base = GST_MPEGTS_BASE (demux);
393
394   switch (GST_QUERY_TYPE (query)) {
395     case GST_QUERY_DURATION:
396     {
397       GST_DEBUG ("query duration");
398       gst_query_parse_duration (query, &format, NULL);
399       if (format == GST_FORMAT_TIME) {
400         if (!gst_pad_peer_query (base->sinkpad, query)) {
401           gint64 val;
402
403           format = GST_FORMAT_BYTES;
404           if (!gst_pad_peer_query_duration (base->sinkpad, format, &val))
405             res = FALSE;
406           else {
407             GstClockTime dur =
408                 mpegts_packetizer_offset_to_ts (base->packetizer, val,
409                 demux->program->pcr_pid);
410             if (GST_CLOCK_TIME_IS_VALID (dur))
411               gst_query_set_duration (query, GST_FORMAT_TIME, dur);
412             else
413               res = FALSE;
414           }
415         }
416       } else {
417         GST_DEBUG_OBJECT (demux, "only query duration on TIME is supported");
418         res = FALSE;
419       }
420       break;
421     }
422     case GST_QUERY_LATENCY:
423     {
424       GST_DEBUG ("query latency");
425       res = gst_pad_peer_query (base->sinkpad, query);
426       if (res && base->upstream_live) {
427         GstClockTime min_lat, max_lat;
428         gboolean live;
429
430         /* According to H.222.0
431            Annex D.0.3 (System Time Clock recovery in the decoder)
432            and D.0.2 (Audio and video presentation synchronization)
433
434            We can end up with an interval of up to 700ms between valid
435            PCR/SCR. We therefore allow a latency of 700ms for that.
436          */
437         gst_query_parse_latency (query, &live, &min_lat, &max_lat);
438         if (min_lat != -1)
439           min_lat += 700 * GST_MSECOND;
440         if (max_lat != -1)
441           max_lat += 700 * GST_MSECOND;
442         gst_query_set_latency (query, live, min_lat, max_lat);
443       }
444       break;
445     }
446     case GST_QUERY_SEEKING:
447     {
448       GST_DEBUG ("query seeking");
449       gst_query_parse_seeking (query, &format, NULL, NULL, NULL);
450       if (format == GST_FORMAT_TIME) {
451         gboolean seekable = FALSE;
452
453         if (gst_pad_peer_query (base->sinkpad, query))
454           gst_query_parse_seeking (query, NULL, &seekable, NULL, NULL);
455
456         /* If upstream is not seekable in TIME format we use
457          * our own values here */
458         if (!seekable)
459           gst_query_set_seeking (query, GST_FORMAT_TIME,
460               demux->parent.mode != BASE_MODE_PUSHING, 0,
461               demux->segment.duration);
462       } else {
463         GST_DEBUG_OBJECT (demux, "only TIME is supported for query seeking");
464         res = FALSE;
465       }
466       break;
467     }
468     default:
469       res = gst_pad_query_default (pad, parent, query);
470   }
471
472   return res;
473
474 }
475
476 static GstFlowReturn
477 gst_ts_demux_do_seek (MpegTSBase * base, GstEvent * event)
478 {
479   GstTSDemux *demux = (GstTSDemux *) base;
480   GstFlowReturn res = GST_FLOW_ERROR;
481   gdouble rate;
482   GstFormat format;
483   GstSeekFlags flags;
484   GstSeekType start_type, stop_type;
485   gint64 start, stop;
486   GstSegment seeksegment;
487   gboolean update;
488   guint64 start_offset;
489
490   gst_event_parse_seek (event, &rate, &format, &flags, &start_type, &start,
491       &stop_type, &stop);
492
493   if (format != GST_FORMAT_TIME) {
494     goto done;
495   }
496
497   GST_DEBUG ("seek event, rate: %f start: %" GST_TIME_FORMAT
498       " stop: %" GST_TIME_FORMAT, rate, GST_TIME_ARGS (start),
499       GST_TIME_ARGS (stop));
500
501   if (flags & (GST_SEEK_FLAG_SEGMENT | GST_SEEK_FLAG_SKIP)) {
502     GST_WARNING ("seek flags 0x%x are not supported", (int) flags);
503     goto done;
504   }
505
506   /* copy segment, we need this because we still need the old
507    * segment when we close the current segment. */
508   memcpy (&seeksegment, &demux->segment, sizeof (GstSegment));
509   if (demux->segment_event) {
510     gst_event_unref (demux->segment_event);
511     demux->segment_event = NULL;
512   }
513   /* configure the segment with the seek variables */
514   GST_DEBUG_OBJECT (demux, "configuring seek");
515   GST_DEBUG ("seeksegment before set_seek " SEGMENT_FORMAT,
516       SEGMENT_ARGS (seeksegment));
517
518   gst_segment_do_seek (&seeksegment, rate, format, flags, start_type, start,
519       stop_type, stop, &update);
520
521   GST_DEBUG ("seeksegment after set_seek " SEGMENT_FORMAT,
522       SEGMENT_ARGS (seeksegment));
523
524   /* Convert start/stop to offset */
525   start_offset =
526       mpegts_packetizer_ts_to_offset (base->packetizer, MAX (0,
527           start - SEEK_TIMESTAMP_OFFSET), demux->program->pcr_pid);
528
529   if (G_UNLIKELY (start_offset == -1)) {
530     GST_WARNING ("Couldn't convert start position to an offset");
531     goto done;
532   }
533
534   /* record offset */
535   base->seek_offset = start_offset;
536   res = GST_FLOW_OK;
537
538   /* commit the new segment */
539   memcpy (&demux->segment, &seeksegment, sizeof (GstSegment));
540
541   if (demux->segment.flags & GST_SEEK_FLAG_SEGMENT) {
542     gst_element_post_message (GST_ELEMENT_CAST (demux),
543         gst_message_new_segment_start (GST_OBJECT_CAST (demux),
544             demux->segment.format, demux->segment.stop));
545   }
546
547 done:
548   return res;
549 }
550
551 static gboolean
552 gst_ts_demux_srcpad_event (GstPad * pad, GstObject * parent, GstEvent * event)
553 {
554   gboolean res = TRUE;
555   GstTSDemux *demux = GST_TS_DEMUX (parent);
556
557   GST_DEBUG_OBJECT (pad, "Got event %s",
558       gst_event_type_get_name (GST_EVENT_TYPE (event)));
559
560   switch (GST_EVENT_TYPE (event)) {
561     case GST_EVENT_SEEK:
562       res = mpegts_base_handle_seek_event ((MpegTSBase *) demux, pad, event);
563       if (!res)
564         GST_WARNING ("seeking failed");
565       gst_event_unref (event);
566       break;
567     default:
568       res = gst_pad_event_default (pad, parent, event);
569   }
570
571   return res;
572 }
573
574 static gboolean
575 push_event (MpegTSBase * base, GstEvent * event)
576 {
577   GstTSDemux *demux = (GstTSDemux *) base;
578   GList *tmp;
579
580   if (G_UNLIKELY (demux->program == NULL)) {
581     gst_event_unref (event);
582     return FALSE;
583   }
584
585   for (tmp = demux->program->stream_list; tmp; tmp = tmp->next) {
586     TSDemuxStream *stream = (TSDemuxStream *) tmp->data;
587     if (stream->pad) {
588       gst_event_ref (event);
589       gst_pad_push_event (stream->pad, event);
590     }
591   }
592
593   gst_event_unref (event);
594
595   return TRUE;
596 }
597
598 static GstFlowReturn
599 tsdemux_combine_flows (GstTSDemux * demux, TSDemuxStream * stream,
600     GstFlowReturn ret)
601 {
602   GList *tmp;
603
604   /* Store the value */
605   stream->flow_return = ret;
606
607   /* any other error that is not-linked can be returned right away */
608   if (ret != GST_FLOW_NOT_LINKED)
609     goto done;
610
611   /* Only return NOT_LINKED if all other pads returned NOT_LINKED */
612   for (tmp = demux->program->stream_list; tmp; tmp = tmp->next) {
613     stream = (TSDemuxStream *) tmp->data;
614     if (stream->pad) {
615       ret = stream->flow_return;
616       /* some other return value (must be SUCCESS but we can return
617        * other values as well) */
618       if (ret != GST_FLOW_NOT_LINKED)
619         goto done;
620     }
621     /* if we get here, all other pads were unlinked and we return
622      * NOT_LINKED then */
623   }
624
625 done:
626   return ret;
627 }
628
629 static void
630 gst_ts_demux_create_tags (TSDemuxStream * stream)
631 {
632   guint8 *desc = NULL;
633   int i;
634
635   desc = mpegts_get_descriptor_from_stream ((MpegTSBaseStream *) stream,
636       DESC_ISO_639_LANGUAGE);
637   if (desc) {
638     if (!stream->taglist)
639       stream->taglist = gst_tag_list_new_empty ();
640
641     for (i = 0; i < DESC_ISO_639_LANGUAGE_codes_n (desc); i++) {
642       const gchar *lc;
643       gchar lang_code[4];
644       gchar *language_n;
645
646       language_n = (gchar *)
647           DESC_ISO_639_LANGUAGE_language_code_nth (desc, i);
648
649       /* Language codes should be 3 character long, we allow
650        * a bit more flexibility by allowing 2 characters. */
651       if (!language_n[0] || !language_n[1])
652         continue;
653
654       GST_LOG ("Add language code for stream: %s", language_n);
655
656       lang_code[0] = language_n[0];
657       lang_code[1] = language_n[1];
658       lang_code[2] = language_n[2];
659       lang_code[3] = 0;
660
661       /* descriptor contains ISO 639-2 code, we want the ISO 639-1 code */
662       lc = gst_tag_get_language_code (lang_code);
663       gst_tag_list_add (stream->taglist, GST_TAG_MERGE_REPLACE,
664           GST_TAG_LANGUAGE_CODE, (lc) ? lc : lang_code, NULL);
665     }
666
667     g_free (desc);
668   }
669 }
670
671 static GstPad *
672 create_pad_for_stream (MpegTSBase * base, MpegTSBaseStream * bstream,
673     MpegTSBaseProgram * program)
674 {
675   TSDemuxStream *stream = (TSDemuxStream *) bstream;
676   gchar *name = NULL;
677   GstCaps *caps = NULL;
678   GstPadTemplate *template = NULL;
679   guint8 *desc = NULL;
680   GstPad *pad = NULL;
681
682   gst_ts_demux_create_tags (stream);
683
684   GST_LOG ("Attempting to create pad for stream 0x%04x with stream_type %d",
685       bstream->pid, bstream->stream_type);
686
687   switch (bstream->stream_type) {
688     case ST_VIDEO_MPEG1:
689     case ST_VIDEO_MPEG2:
690       GST_LOG ("mpeg video");
691       template = gst_static_pad_template_get (&video_template);
692       name = g_strdup_printf ("video_%04x", bstream->pid);
693       caps = gst_caps_new_simple ("video/mpeg",
694           "mpegversion", G_TYPE_INT,
695           bstream->stream_type == ST_VIDEO_MPEG1 ? 1 : 2, "systemstream",
696           G_TYPE_BOOLEAN, FALSE, NULL);
697
698       break;
699     case ST_AUDIO_MPEG1:
700     case ST_AUDIO_MPEG2:
701       GST_LOG ("mpeg audio");
702       template = gst_static_pad_template_get (&audio_template);
703       name = g_strdup_printf ("audio_%04x", bstream->pid);
704       caps =
705           gst_caps_new_simple ("audio/mpeg", "mpegversion", G_TYPE_INT, 1,
706           NULL);
707       break;
708     case ST_PRIVATE_DATA:
709       GST_LOG ("private data");
710       desc = mpegts_get_descriptor_from_stream ((MpegTSBaseStream *) stream,
711           DESC_DVB_AC3);
712       if (desc) {
713         GST_LOG ("ac3 audio");
714         template = gst_static_pad_template_get (&audio_template);
715         name = g_strdup_printf ("audio_%04x", bstream->pid);
716         caps = gst_caps_new_empty_simple ("audio/x-ac3");
717         g_free (desc);
718         break;
719       }
720
721       desc = mpegts_get_descriptor_from_stream ((MpegTSBaseStream *) stream,
722           DESC_DVB_ENHANCED_AC3);
723       if (desc) {
724         GST_LOG ("ac3 audio");
725         template = gst_static_pad_template_get (&audio_template);
726         name = g_strdup_printf ("audio_%04x", bstream->pid);
727         caps = gst_caps_new_empty_simple ("audio/x-eac3");
728         g_free (desc);
729         break;
730       }
731       desc = mpegts_get_descriptor_from_stream ((MpegTSBaseStream *) stream,
732           DESC_DVB_TELETEXT);
733       if (desc) {
734         GST_LOG ("teletext");
735         template = gst_static_pad_template_get (&private_template);
736         name = g_strdup_printf ("private_%04x", bstream->pid);
737         caps = gst_caps_new_empty_simple ("private/teletext");
738         g_free (desc);
739         break;
740       }
741       desc =
742           mpegts_get_descriptor_from_stream ((MpegTSBaseStream *) stream,
743           DESC_DVB_SUBTITLING);
744       if (desc) {
745         GST_LOG ("subtitling");
746         template = gst_static_pad_template_get (&private_template);
747         name = g_strdup_printf ("private_%04x", bstream->pid);
748         caps = gst_caps_new_empty_simple ("subpicture/x-dvb");
749         g_free (desc);
750         break;
751       }
752
753       desc = mpegts_get_descriptor_from_stream ((MpegTSBaseStream *) stream,
754           DESC_REGISTRATION);
755       if (desc) {
756         switch (DESC_REGISTRATION_format_identifier (desc)) {
757           case DRF_ID_DTS1:
758           case DRF_ID_DTS2:
759           case DRF_ID_DTS3:
760             /* SMPTE registered DTS */
761             GST_LOG ("subtitling");
762             template = gst_static_pad_template_get (&private_template);
763             name = g_strdup_printf ("private_%04x", bstream->pid);
764             caps = gst_caps_new_empty_simple ("audio/x-dts");
765             break;
766         }
767         g_free (desc);
768       }
769       if (template)
770         break;
771
772       /* hack for itv hd (sid 10510, video pid 3401 */
773       if (program->program_number == 10510 && bstream->pid == 3401) {
774         template = gst_static_pad_template_get (&video_template);
775         name = g_strdup_printf ("video_%04x", bstream->pid);
776         caps = gst_caps_new_simple ("video/x-h264",
777             "stream-format", G_TYPE_STRING, "byte-stream",
778             "alignment", G_TYPE_STRING, "nal", NULL);
779       }
780       break;
781     case ST_HDV_AUX_V:
782       /* We don't expose those streams since they're only helper streams */
783       /* template = gst_static_pad_template_get (&private_template); */
784       /* name = g_strdup_printf ("private_%04x", bstream->pid); */
785       /* caps = gst_caps_new_simple ("hdv/aux-v", NULL); */
786       break;
787     case ST_HDV_AUX_A:
788       /* We don't expose those streams since they're only helper streams */
789       /* template = gst_static_pad_template_get (&private_template); */
790       /* name = g_strdup_printf ("private_%04x", bstream->pid); */
791       /* caps = gst_caps_new_simple ("hdv/aux-a", NULL); */
792       break;
793     case ST_PRIVATE_SECTIONS:
794     case ST_MHEG:
795     case ST_DSMCC:
796     case ST_DSMCC_A:
797     case ST_DSMCC_B:
798     case ST_DSMCC_C:
799     case ST_DSMCC_D:
800       MPEGTS_BIT_UNSET (base->is_pes, bstream->pid);
801       break;
802     case ST_AUDIO_AAC_ADTS:
803       template = gst_static_pad_template_get (&audio_template);
804       name = g_strdup_printf ("audio_%04x", bstream->pid);
805       caps = gst_caps_new_simple ("audio/mpeg",
806           "mpegversion", G_TYPE_INT, 2,
807           "stream-format", G_TYPE_STRING, "adts", NULL);
808       break;
809     case ST_AUDIO_AAC_LATM:
810       template = gst_static_pad_template_get (&audio_template);
811       name = g_strdup_printf ("audio_%04x", bstream->pid);
812       caps = gst_caps_new_simple ("audio/mpeg",
813           "mpegversion", G_TYPE_INT, 4,
814           "stream-format", G_TYPE_STRING, "loas", NULL);
815       break;
816     case ST_VIDEO_MPEG4:
817       template = gst_static_pad_template_get (&video_template);
818       name = g_strdup_printf ("video_%04x", bstream->pid);
819       caps = gst_caps_new_simple ("video/mpeg",
820           "mpegversion", G_TYPE_INT, 4,
821           "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
822       break;
823     case ST_VIDEO_H264:
824       template = gst_static_pad_template_get (&video_template);
825       name = g_strdup_printf ("video_%04x", bstream->pid);
826       caps = gst_caps_new_simple ("video/x-h264",
827           "stream-format", G_TYPE_STRING, "byte-stream",
828           "alignment", G_TYPE_STRING, "nal", NULL);
829       break;
830     case ST_VIDEO_DIRAC:
831       desc =
832           mpegts_get_descriptor_from_stream ((MpegTSBaseStream *) stream,
833           DESC_REGISTRATION);
834       if (desc) {
835         if (DESC_LENGTH (desc) >= 4) {
836           if (DESC_REGISTRATION_format_identifier (desc) == 0x64726163) {
837             GST_LOG ("dirac");
838             /* dirac in hex */
839             template = gst_static_pad_template_get (&video_template);
840             name = g_strdup_printf ("video_%04x", bstream->pid);
841             caps = gst_caps_new_empty_simple ("video/x-dirac");
842           }
843         }
844         g_free (desc);
845       }
846       break;
847     case ST_PRIVATE_EA:        /* Try to detect a VC1 stream */
848     {
849       desc =
850           mpegts_get_descriptor_from_stream ((MpegTSBaseStream *) stream,
851           DESC_REGISTRATION);
852       if (desc) {
853         if (DESC_LENGTH (desc) >= 4) {
854           if (DESC_REGISTRATION_format_identifier (desc) == DRF_ID_VC1) {
855             GST_WARNING ("0xea private stream type found but no descriptor "
856                 "for VC1. Assuming plain VC1.");
857             template = gst_static_pad_template_get (&video_template);
858             name = g_strdup_printf ("video_%04x", bstream->pid);
859             caps = gst_caps_new_simple ("video/x-wmv",
860                 "wmvversion", G_TYPE_INT, 3,
861                 "format", G_TYPE_STRING, "WVC1", NULL);
862           }
863         }
864         g_free (desc);
865       }
866       break;
867     }
868     case ST_BD_AUDIO_AC3:
869     {
870       /* REGISTRATION DRF_ID_HDMV */
871       desc = mpegts_get_descriptor_from_program (program, DESC_REGISTRATION);
872       if (desc) {
873         if (DESC_REGISTRATION_format_identifier (desc) == DRF_ID_HDMV) {
874           guint8 *ac3_desc;
875
876           /* ATSC ac3 audio descriptor */
877           ac3_desc =
878               mpegts_get_descriptor_from_stream ((MpegTSBaseStream *) stream,
879               DESC_AC3_AUDIO_STREAM);
880           if (ac3_desc && DESC_AC_AUDIO_STREAM_bsid (ac3_desc) != 16) {
881             GST_LOG ("ac3 audio");
882             template = gst_static_pad_template_get (&audio_template);
883             name = g_strdup_printf ("audio_%04x", bstream->pid);
884             caps = gst_caps_new_empty_simple ("audio/x-ac3");
885
886             g_free (ac3_desc);
887           } else {
888             template = gst_static_pad_template_get (&audio_template);
889             name = g_strdup_printf ("audio_%04x", bstream->pid);
890             caps = gst_caps_new_empty_simple ("audio/x-eac3");
891           }
892
893         }
894
895         g_free (desc);
896       }
897       if (template)
898         break;
899
900
901       /* DVB_ENHANCED_AC3 */
902       desc = mpegts_get_descriptor_from_stream ((MpegTSBaseStream *) stream,
903           DESC_DVB_ENHANCED_AC3);
904       if (desc) {
905         template = gst_static_pad_template_get (&audio_template);
906         name = g_strdup_printf ("audio_%04x", bstream->pid);
907         caps = gst_caps_new_empty_simple ("audio/x-eac3");
908         g_free (desc);
909         break;
910       }
911
912       /* DVB_AC3 */
913       desc =
914           mpegts_get_descriptor_from_stream ((MpegTSBaseStream *) stream,
915           DESC_DVB_AC3);
916       if (!desc)
917         GST_WARNING ("AC3 stream type found but no corresponding "
918             "descriptor to differentiate between AC3 and EAC3. "
919             "Assuming plain AC3.");
920       else
921         g_free (desc);
922       template = gst_static_pad_template_get (&audio_template);
923       name = g_strdup_printf ("audio_%04x", bstream->pid);
924       caps = gst_caps_new_empty_simple ("audio/x-ac3");
925       break;
926     }
927     case ST_BD_AUDIO_EAC3:
928       template = gst_static_pad_template_get (&audio_template);
929       name = g_strdup_printf ("audio_%04x", bstream->pid);
930       caps = gst_caps_new_empty_simple ("audio/x-eac3");
931       break;
932     case ST_PS_AUDIO_DTS:
933       template = gst_static_pad_template_get (&audio_template);
934       name = g_strdup_printf ("audio_%04x", bstream->pid);
935       caps = gst_caps_new_empty_simple ("audio/x-dts");
936       break;
937     case ST_PS_AUDIO_LPCM:
938       template = gst_static_pad_template_get (&audio_template);
939       name = g_strdup_printf ("audio_%04x", bstream->pid);
940       caps = gst_caps_new_empty_simple ("audio/x-lpcm");
941       break;
942     case ST_BD_AUDIO_LPCM:
943       template = gst_static_pad_template_get (&audio_template);
944       name = g_strdup_printf ("audio_%04x", bstream->pid);
945       caps = gst_caps_new_empty_simple ("audio/x-private-ts-lpcm");
946       break;
947     case ST_PS_DVD_SUBPICTURE:
948       template = gst_static_pad_template_get (&subpicture_template);
949       name = g_strdup_printf ("subpicture_%04x", bstream->pid);
950       caps = gst_caps_new_empty_simple ("video/x-dvd-subpicture");
951       break;
952     case ST_BD_PGS_SUBPICTURE:
953       template = gst_static_pad_template_get (&subpicture_template);
954       name = g_strdup_printf ("subpicture_%04x", bstream->pid);
955       caps = gst_caps_new_empty_simple ("subpicture/x-pgs");
956       break;
957     default:
958       GST_WARNING ("Non-media stream (stream_type:0x%x). Not creating pad",
959           bstream->stream_type);
960       break;
961   }
962   if (template && name && caps) {
963     gchar *stream_id;
964
965     GST_LOG ("stream:%p creating pad with name %s and caps %s", stream, name,
966         gst_caps_to_string (caps));
967     pad = gst_pad_new_from_template (template, name);
968     gst_pad_set_active (pad, TRUE);
969     gst_pad_use_fixed_caps (pad);
970     stream_id =
971         gst_pad_create_stream_id_printf (pad, GST_ELEMENT_CAST (base), "%08x",
972         bstream->pid);
973     gst_pad_push_event (pad, gst_event_new_stream_start (stream_id));
974     g_free (stream_id);
975     gst_pad_set_caps (pad, caps);
976     gst_pad_set_query_function (pad, gst_ts_demux_srcpad_query);
977     gst_pad_set_event_function (pad, gst_ts_demux_srcpad_event);
978   }
979
980   if (name)
981     g_free (name);
982   if (template)
983     gst_object_unref (template);
984   if (caps)
985     gst_caps_unref (caps);
986
987   return pad;
988 }
989
990 static void
991 gst_ts_demux_stream_added (MpegTSBase * base, MpegTSBaseStream * bstream,
992     MpegTSBaseProgram * program)
993 {
994   TSDemuxStream *stream = (TSDemuxStream *) bstream;
995
996   if (!stream->pad) {
997     /* Create the pad */
998     if (bstream->stream_type != 0xff)
999       stream->pad = create_pad_for_stream (base, bstream, program);
1000     stream->active = FALSE;
1001
1002     stream->need_newsegment = TRUE;
1003     stream->pts = GST_CLOCK_TIME_NONE;
1004     stream->dts = GST_CLOCK_TIME_NONE;
1005     stream->raw_pts = 0;
1006     stream->raw_dts = 0;
1007     stream->fixed_pts = 0;
1008     stream->fixed_dts = 0;
1009     stream->nb_pts_rollover = 0;
1010     stream->nb_dts_rollover = 0;
1011   }
1012   stream->flow_return = GST_FLOW_OK;
1013 }
1014
1015 static void
1016 gst_ts_demux_stream_removed (MpegTSBase * base, MpegTSBaseStream * bstream)
1017 {
1018   TSDemuxStream *stream = (TSDemuxStream *) bstream;
1019
1020   if (stream->pad) {
1021     if (stream->active && gst_pad_is_active (stream->pad)) {
1022       /* Flush out all data */
1023       GST_DEBUG_OBJECT (stream->pad, "Flushing out pending data");
1024       gst_ts_demux_push_pending_data ((GstTSDemux *) base, stream);
1025
1026       GST_DEBUG_OBJECT (stream->pad, "Pushing out EOS");
1027       gst_pad_push_event (stream->pad, gst_event_new_eos ());
1028       GST_DEBUG_OBJECT (stream->pad, "Deactivating and removing pad");
1029       gst_pad_set_active (stream->pad, FALSE);
1030       gst_element_remove_pad (GST_ELEMENT_CAST (base), stream->pad);
1031       stream->active = FALSE;
1032     }
1033     stream->pad = NULL;
1034   }
1035   gst_ts_demux_stream_flush (stream);
1036   stream->flow_return = GST_FLOW_NOT_LINKED;
1037 }
1038
1039 static void
1040 activate_pad_for_stream (GstTSDemux * tsdemux, TSDemuxStream * stream)
1041 {
1042   GList *tmp;
1043   gboolean alldone = TRUE;
1044
1045   if (stream->pad) {
1046     GST_DEBUG_OBJECT (tsdemux, "Activating pad %s:%s for stream %p",
1047         GST_DEBUG_PAD_NAME (stream->pad), stream);
1048     gst_element_add_pad ((GstElement *) tsdemux, stream->pad);
1049     stream->active = TRUE;
1050     GST_DEBUG_OBJECT (stream->pad, "done adding pad");
1051
1052     /* Check if all pads were activated, and if so emit no-more-pads */
1053     for (tmp = tsdemux->program->stream_list; tmp; tmp = tmp->next) {
1054       stream = (TSDemuxStream *) tmp->data;
1055       if (stream->pad && !stream->active)
1056         alldone = FALSE;
1057     }
1058     if (alldone) {
1059       GST_DEBUG_OBJECT (tsdemux, "All pads were activated, emit no-more-pads");
1060       gst_element_no_more_pads ((GstElement *) tsdemux);
1061     }
1062   } else
1063     GST_WARNING_OBJECT (tsdemux,
1064         "stream %p (pid 0x%04x, type:0x%03x) has no pad", stream,
1065         ((MpegTSBaseStream *) stream)->pid,
1066         ((MpegTSBaseStream *) stream)->stream_type);
1067 }
1068
1069 static void
1070 gst_ts_demux_stream_flush (TSDemuxStream * stream)
1071 {
1072   stream->pts = GST_CLOCK_TIME_NONE;
1073
1074   GST_DEBUG ("flushing stream %p", stream);
1075
1076   if (stream->data)
1077     g_free (stream->data);
1078   stream->data = NULL;
1079   stream->state = PENDING_PACKET_EMPTY;
1080   stream->expected_size = 0;
1081   stream->allocated_size = 0;
1082   stream->current_size = 0;
1083   stream->need_newsegment = TRUE;
1084   stream->pts = GST_CLOCK_TIME_NONE;
1085   stream->dts = GST_CLOCK_TIME_NONE;
1086   stream->raw_pts = 0;
1087   stream->raw_dts = 0;
1088   stream->fixed_pts = 0;
1089   stream->fixed_dts = 0;
1090   stream->nb_pts_rollover = 0;
1091   stream->nb_dts_rollover = 0;
1092 }
1093
1094 static void
1095 gst_ts_demux_flush_streams (GstTSDemux * demux)
1096 {
1097   g_list_foreach (demux->program->stream_list,
1098       (GFunc) gst_ts_demux_stream_flush, NULL);
1099 }
1100
1101 static void
1102 gst_ts_demux_program_started (MpegTSBase * base, MpegTSBaseProgram * program)
1103 {
1104   GstTSDemux *demux = GST_TS_DEMUX (base);
1105
1106   GST_DEBUG ("Current program %d, new program %d",
1107       demux->program_number, program->program_number);
1108
1109   if (demux->program_number == -1 ||
1110       demux->program_number == program->program_number) {
1111
1112     GST_LOG ("program %d started", program->program_number);
1113     demux->program_number = program->program_number;
1114     demux->program = program;
1115
1116     /* If this is not the initial program, we need to calculate
1117      * an update newsegment */
1118     demux->calculate_update_segment = !program->initial_program;
1119
1120     /* If we have an upstream time segment and it's the initial program, just use that */
1121     if (program->initial_program && base->segment.format == GST_FORMAT_TIME) {
1122       demux->segment = base->segment;
1123       demux->segment_event = gst_event_new_segment (&demux->segment);
1124     }
1125
1126     /* FIXME : When do we emit no_more_pads ? */
1127
1128     /* Inform scanner we have got our program */
1129     demux->current_program_number = program->program_number;
1130   }
1131 }
1132
1133
1134
1135
1136 static inline void
1137 gst_ts_demux_record_pts (GstTSDemux * demux, TSDemuxStream * stream,
1138     guint64 pts, guint64 offset)
1139 {
1140   MpegTSBaseStream *bs = (MpegTSBaseStream *) stream;
1141
1142   GST_LOG ("pid 0x%04x pts:%" G_GUINT64_FORMAT " at offset %"
1143       G_GUINT64_FORMAT, bs->pid, pts, offset);
1144
1145   if (G_UNLIKELY (GST_CLOCK_TIME_IS_VALID (stream->pts) &&
1146           ABSDIFF (stream->raw_pts, pts) > 900000)) {
1147     /* Detect rollover if diff > 10s */
1148     GST_LOG ("Detected rollover (previous:%" G_GUINT64_FORMAT " new:%"
1149         G_GUINT64_FORMAT ")", stream->raw_pts, pts);
1150     if (pts < stream->raw_pts) {
1151       /* Forward rollover */
1152       GST_LOG ("Forward rollover, incrementing nb_pts_rollover");
1153       stream->nb_pts_rollover++;
1154     } else {
1155       /* Reverse rollover */
1156       GST_LOG ("Reverse rollover, decrementing nb_pts_rollover");
1157       stream->nb_pts_rollover--;
1158     }
1159   }
1160
1161   /* Compute PTS in GstClockTime */
1162   stream->raw_pts = pts;
1163   stream->fixed_pts = pts + stream->nb_pts_rollover * PTS_DTS_MAX_VALUE;
1164   stream->pts = MPEGTIME_TO_GSTTIME (stream->fixed_pts);
1165
1166   GST_LOG ("pid 0x%04x Stored PTS %" G_GUINT64_FORMAT " (%" GST_TIME_FORMAT ")",
1167       bs->pid, stream->raw_pts, GST_TIME_ARGS (stream->pts));
1168
1169
1170   if (G_UNLIKELY (demux->emit_statistics)) {
1171     GstStructure *st;
1172     st = gst_structure_new_id_empty (QUARK_TSDEMUX);
1173     gst_structure_id_set (st,
1174         QUARK_PID, G_TYPE_UINT, bs->pid,
1175         QUARK_OFFSET, G_TYPE_UINT64, offset, QUARK_PTS, G_TYPE_UINT64, pts,
1176         NULL);
1177     gst_element_post_message (GST_ELEMENT_CAST (demux),
1178         gst_message_new_element (GST_OBJECT (demux), st));
1179   }
1180 }
1181
1182 static inline void
1183 gst_ts_demux_record_dts (GstTSDemux * demux, TSDemuxStream * stream,
1184     guint64 dts, guint64 offset)
1185 {
1186   MpegTSBaseStream *bs = (MpegTSBaseStream *) stream;
1187
1188   GST_LOG ("pid 0x%04x dts:%" G_GUINT64_FORMAT " at offset %"
1189       G_GUINT64_FORMAT, bs->pid, dts, offset);
1190
1191   if (G_UNLIKELY (GST_CLOCK_TIME_IS_VALID (stream->dts) &&
1192           ABSDIFF (stream->raw_dts, dts) > 900000)) {
1193     /* Detect rollover if diff > 10s */
1194     GST_LOG ("Detected rollover (previous:%" G_GUINT64_FORMAT " new:%"
1195         G_GUINT64_FORMAT ")", stream->raw_dts, dts);
1196     if (dts < stream->raw_dts) {
1197       /* Forward rollover */
1198       GST_LOG ("Forward rollover, incrementing nb_dts_rollover");
1199       stream->nb_dts_rollover++;
1200     } else {
1201       /* Reverse rollover */
1202       GST_LOG ("Reverse rollover, decrementing nb_dts_rollover");
1203       stream->nb_dts_rollover--;
1204     }
1205   }
1206
1207   /* Compute DTS in GstClockTime */
1208   stream->raw_dts = dts;
1209   stream->fixed_dts = dts + stream->nb_dts_rollover * PTS_DTS_MAX_VALUE;
1210   stream->dts = MPEGTIME_TO_GSTTIME (stream->fixed_dts);
1211
1212   GST_LOG ("pid 0x%04x Stored DTS %" G_GUINT64_FORMAT " (%" GST_TIME_FORMAT ")",
1213       bs->pid, stream->raw_dts, GST_TIME_ARGS (stream->dts));
1214
1215   if (G_UNLIKELY (demux->emit_statistics)) {
1216     GstStructure *st;
1217     st = gst_structure_new_id_empty (QUARK_TSDEMUX);
1218     gst_structure_id_set (st,
1219         QUARK_PID, G_TYPE_UINT, bs->pid,
1220         QUARK_OFFSET, G_TYPE_UINT64, offset, QUARK_DTS, G_TYPE_UINT64, dts,
1221         NULL);
1222     gst_element_post_message (GST_ELEMENT_CAST (demux),
1223         gst_message_new_element (GST_OBJECT (demux), st));
1224   }
1225 }
1226
1227 static void
1228 gst_ts_demux_parse_pes_header (GstTSDemux * demux, TSDemuxStream * stream,
1229     guint8 * data, guint32 length, guint64 bufferoffset)
1230 {
1231   MpegTSBase *base = (MpegTSBase *) demux;
1232   PESHeader header;
1233   gint offset = 0;
1234   PESParsingResult parseres;
1235
1236   GST_MEMDUMP ("Header buffer", data, MIN (length, 32));
1237
1238   parseres = mpegts_parse_pes_header (data, length, &header, &offset);
1239   if (G_UNLIKELY (parseres == PES_PARSING_NEED_MORE))
1240     goto discont;
1241   if (G_UNLIKELY (parseres == PES_PARSING_BAD)) {
1242     GST_WARNING ("Error parsing PES header. pid: 0x%x stream_type: 0x%x",
1243         stream->stream.pid, stream->stream.stream_type);
1244     goto discont;
1245   }
1246
1247   if (header.DTS != -1)
1248     gst_ts_demux_record_dts (demux, stream, header.DTS, bufferoffset);
1249
1250   if (header.PTS != -1) {
1251     gst_ts_demux_record_pts (demux, stream, header.PTS, bufferoffset);
1252
1253     GST_DEBUG_OBJECT (base,
1254         "stream PTS %" GST_TIME_FORMAT " DTS %" GST_TIME_FORMAT,
1255         GST_TIME_ARGS (stream->pts),
1256         GST_TIME_ARGS (MPEGTIME_TO_GSTTIME (header.DTS)));
1257
1258   }
1259
1260   /* Remove PES headers */
1261   GST_DEBUG ("Moving data forward by %d bytes (packet_size:%d, have:%d)",
1262       header.header_size, header.packet_length, length);
1263   stream->expected_size = header.packet_length;
1264   if (stream->expected_size) {
1265     if (G_LIKELY (stream->expected_size > header.header_size)) {
1266       stream->expected_size -= header.header_size;
1267     } else {
1268       /* next packet will have to complete this one */
1269       GST_ERROR ("invalid header and packet size combination");
1270       stream->expected_size = 0;
1271     }
1272   }
1273   data += header.header_size;
1274   length -= header.header_size;
1275
1276   /* Create the output buffer */
1277   if (stream->expected_size)
1278     stream->allocated_size = stream->expected_size;
1279   else
1280     stream->allocated_size = 8192;
1281   g_assert (stream->data == NULL);
1282   stream->data = g_malloc (stream->allocated_size);
1283   memcpy (stream->data, data, length);
1284   stream->current_size = length;
1285
1286   stream->state = PENDING_PACKET_BUFFER;
1287
1288   return;
1289
1290 discont:
1291   stream->state = PENDING_PACKET_DISCONT;
1292   return;
1293 }
1294
1295  /* ONLY CALL THIS:
1296   * * WITH packet->payload != NULL
1297   * * WITH pending/current flushed out if beginning of new PES packet
1298   */
1299 static inline void
1300 gst_ts_demux_queue_data (GstTSDemux * demux, TSDemuxStream * stream,
1301     MpegTSPacketizerPacket * packet)
1302 {
1303   guint8 *data;
1304   guint size;
1305
1306   GST_DEBUG ("state:%d", stream->state);
1307
1308   size = packet->data_end - packet->payload;
1309   data = packet->payload;
1310
1311   if (stream->state == PENDING_PACKET_EMPTY) {
1312     if (G_UNLIKELY (!packet->payload_unit_start_indicator)) {
1313       stream->state = PENDING_PACKET_DISCONT;
1314       GST_WARNING ("Didn't get the first packet of this PES");
1315     } else {
1316       GST_LOG ("EMPTY=>HEADER");
1317       stream->state = PENDING_PACKET_HEADER;
1318     }
1319   }
1320
1321   switch (stream->state) {
1322     case PENDING_PACKET_HEADER:
1323     {
1324       GST_LOG ("HEADER: Parsing PES header");
1325
1326       /* parse the header */
1327       gst_ts_demux_parse_pes_header (demux, stream, data, size, packet->offset);
1328       break;
1329     }
1330     case PENDING_PACKET_BUFFER:
1331     {
1332       GST_LOG ("BUFFER: appending data");
1333       if (G_UNLIKELY (stream->current_size + size > stream->allocated_size)) {
1334         GST_LOG ("resizing buffer");
1335         stream->allocated_size = stream->allocated_size * 2;
1336         stream->data = g_realloc (stream->data, stream->allocated_size);
1337       }
1338       memcpy (stream->data + stream->current_size, data, size);
1339       stream->current_size += size;
1340       break;
1341     }
1342     case PENDING_PACKET_DISCONT:
1343     {
1344       GST_LOG ("DISCONT: not storing/pushing");
1345       if (G_UNLIKELY (stream->data)) {
1346         g_free (stream->data);
1347         stream->data = NULL;
1348       }
1349       break;
1350     }
1351     default:
1352       break;
1353   }
1354
1355   return;
1356 }
1357
1358 static void
1359 calculate_and_push_newsegment (GstTSDemux * demux, TSDemuxStream * stream)
1360 {
1361   MpegTSBase *base = (MpegTSBase *) demux;
1362   GstClockTime lowest_pts = GST_CLOCK_TIME_NONE;
1363   GstClockTime firstts = 0;
1364   GList *tmp;
1365
1366   GST_DEBUG ("Creating new newsegment for stream %p", stream);
1367
1368   /* 1) If we need to calculate an update newsegment, do it
1369    * 2) If we need to calculate a new newsegment, do it
1370    * 3) If an update_segment is valid, push it
1371    * 4) If a newsegment is valid, push it */
1372
1373   /* Speedup : if we don't need to calculate anything, go straight to pushing */
1374   if (!demux->calculate_update_segment && demux->segment_event)
1375     goto push_new_segment;
1376
1377   /* Calculate the 'new_start' value, used for both updates and newsegment */
1378   for (tmp = demux->program->stream_list; tmp; tmp = tmp->next) {
1379     TSDemuxStream *pstream = (TSDemuxStream *) tmp->data;
1380
1381     if (GST_CLOCK_TIME_IS_VALID (pstream->pts)) {
1382       if (!GST_CLOCK_TIME_IS_VALID (lowest_pts) || pstream->pts < lowest_pts)
1383         lowest_pts = pstream->pts;
1384     }
1385     if (GST_CLOCK_TIME_IS_VALID (pstream->dts)) {
1386       if (!GST_CLOCK_TIME_IS_VALID (lowest_pts) || pstream->dts < lowest_pts)
1387         lowest_pts = pstream->dts;
1388     }
1389   }
1390   if (GST_CLOCK_TIME_IS_VALID (lowest_pts))
1391     firstts =
1392         mpegts_packetizer_pts_to_ts (base->packetizer, lowest_pts,
1393         demux->program->pcr_pid);
1394   GST_DEBUG ("lowest_pts %" G_GUINT64_FORMAT " => clocktime %" GST_TIME_FORMAT,
1395       lowest_pts, GST_TIME_ARGS (firstts));
1396
1397   if (demux->calculate_update_segment) {
1398     GST_DEBUG ("Calculating update segment");
1399     /* If we have a valid segment, create an update of that */
1400     if (demux->segment.format == GST_FORMAT_TIME) {
1401       GstSegment update_segment;
1402       GST_DEBUG ("Re-using segment " SEGMENT_FORMAT,
1403           SEGMENT_ARGS (demux->segment));
1404       gst_segment_copy_into (&demux->segment, &update_segment);
1405       update_segment.stop = firstts;
1406       demux->update_segment = gst_event_new_segment (&update_segment);
1407     }
1408     demux->calculate_update_segment = FALSE;
1409   }
1410
1411   if (!demux->segment_event) {
1412     GstSegment new_segment;
1413
1414     GST_DEBUG ("Calculating actual segment");
1415
1416     gst_segment_copy_into (&demux->segment, &new_segment);
1417     if (new_segment.format != GST_FORMAT_TIME) {
1418       /* Start from the first ts/pts */
1419       new_segment.start = firstts;
1420       new_segment.stop = GST_CLOCK_TIME_NONE;
1421       new_segment.position = firstts;
1422     }
1423
1424     demux->segment_event = gst_event_new_segment (&new_segment);
1425   }
1426
1427 push_new_segment:
1428   if (demux->update_segment) {
1429     GST_DEBUG_OBJECT (stream->pad, "Pushing update segment");
1430     gst_event_ref (demux->update_segment);
1431     gst_pad_push_event (stream->pad, demux->update_segment);
1432   }
1433
1434   if (demux->segment_event) {
1435     GST_DEBUG_OBJECT (stream->pad, "Pushing newsegment event");
1436     gst_event_ref (demux->segment_event);
1437     gst_pad_push_event (stream->pad, demux->segment_event);
1438   }
1439
1440   /* Push pending tags */
1441   if (stream->taglist) {
1442     GST_DEBUG_OBJECT (stream->pad, "Sending tags %" GST_PTR_FORMAT,
1443         stream->taglist);
1444     gst_pad_push_event (stream->pad, gst_event_new_tag (stream->taglist));
1445     stream->taglist = NULL;
1446   }
1447
1448   stream->need_newsegment = FALSE;
1449 }
1450
1451 static GstFlowReturn
1452 gst_ts_demux_push_pending_data (GstTSDemux * demux, TSDemuxStream * stream)
1453 {
1454   GstFlowReturn res = GST_FLOW_OK;
1455   MpegTSBaseStream *bs = (MpegTSBaseStream *) stream;
1456   GstBuffer *buffer = NULL;
1457   MpegTSPacketizer2 *packetizer = MPEG_TS_BASE_PACKETIZER (demux);
1458
1459   GST_DEBUG_OBJECT (stream->pad,
1460       "stream:%p, pid:0x%04x stream_type:%d state:%d", stream, bs->pid,
1461       bs->stream_type, stream->state);
1462
1463   if (G_UNLIKELY (stream->data == NULL)) {
1464     GST_LOG ("stream->data == NULL");
1465     goto beach;
1466   }
1467
1468   if (G_UNLIKELY (stream->state == PENDING_PACKET_EMPTY)) {
1469     GST_LOG ("EMPTY: returning");
1470     goto beach;
1471   }
1472
1473   if (G_UNLIKELY (stream->state != PENDING_PACKET_BUFFER)) {
1474     GST_LOG ("state:%d, returning", stream->state);
1475     goto beach;
1476   }
1477
1478   if (G_UNLIKELY (!stream->active))
1479     activate_pad_for_stream (demux, stream);
1480
1481   if (G_UNLIKELY (stream->pad == NULL)) {
1482     g_free (stream->data);
1483     goto beach;
1484   }
1485
1486   if (G_UNLIKELY (stream->need_newsegment))
1487     calculate_and_push_newsegment (demux, stream);
1488
1489   buffer = gst_buffer_new_wrapped (stream->data, stream->current_size);
1490
1491   GST_DEBUG_OBJECT (stream->pad, "stream->pts %" GST_TIME_FORMAT,
1492       GST_TIME_ARGS (stream->pts));
1493   if (GST_CLOCK_TIME_IS_VALID (stream->pts))
1494     GST_BUFFER_PTS (buffer) =
1495         mpegts_packetizer_pts_to_ts (packetizer, stream->pts,
1496         demux->program->pcr_pid);
1497   if (GST_CLOCK_TIME_IS_VALID (stream->dts))
1498     GST_BUFFER_DTS (buffer) =
1499         mpegts_packetizer_pts_to_ts (packetizer, stream->dts,
1500         demux->program->pcr_pid);
1501
1502   GST_DEBUG_OBJECT (stream->pad,
1503       "Pushing buffer with timestamp: %" GST_TIME_FORMAT,
1504       GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buffer)));
1505
1506   res = gst_pad_push (stream->pad, buffer);
1507   GST_DEBUG_OBJECT (stream->pad, "Returned %s", gst_flow_get_name (res));
1508   res = tsdemux_combine_flows (demux, stream, res);
1509   GST_DEBUG_OBJECT (stream->pad, "combined %s", gst_flow_get_name (res));
1510
1511 beach:
1512   /* Reset everything */
1513   GST_LOG ("Resetting to EMPTY, returning %s", gst_flow_get_name (res));
1514   stream->state = PENDING_PACKET_EMPTY;
1515   stream->data = NULL;
1516   stream->expected_size = 0;
1517   stream->current_size = 0;
1518
1519   return res;
1520 }
1521
1522 static GstFlowReturn
1523 gst_ts_demux_handle_packet (GstTSDemux * demux, TSDemuxStream * stream,
1524     MpegTSPacketizerPacket * packet, MpegTSPacketizerSection * section)
1525 {
1526   GstFlowReturn res = GST_FLOW_OK;
1527
1528   GST_DEBUG ("data:%p", packet->data);
1529   GST_LOG ("pid 0x%04x pusi:%d, afc:%d, cont:%d, payload:%p", packet->pid,
1530       packet->payload_unit_start_indicator, packet->adaptation_field_control,
1531       packet->continuity_counter, packet->payload);
1532
1533   if (section) {
1534     GST_DEBUG ("section complete:%d, buffer size %d",
1535         section->complete, section->section_length);
1536     return res;
1537   }
1538
1539   if (G_UNLIKELY (packet->payload_unit_start_indicator) &&
1540       packet->adaptation_field_control & 0x1)
1541     /* Flush previous data */
1542     res = gst_ts_demux_push_pending_data (demux, stream);
1543
1544   if (packet->payload && (res == GST_FLOW_OK || res == GST_FLOW_NOT_LINKED)
1545       && stream->pad) {
1546     gst_ts_demux_queue_data (demux, stream, packet);
1547     GST_DEBUG ("current_size:%d, expected_size:%d",
1548         stream->current_size, stream->expected_size);
1549     /* Finally check if the data we queued completes a packet */
1550     if (stream->expected_size && stream->current_size == stream->expected_size) {
1551       GST_LOG ("pushing complete packet");
1552       res = gst_ts_demux_push_pending_data (demux, stream);
1553     }
1554   }
1555
1556   return res;
1557 }
1558
1559 static void
1560 gst_ts_demux_flush (MpegTSBase * base)
1561 {
1562   GstTSDemux *demux = GST_TS_DEMUX_CAST (base);
1563
1564   gst_ts_demux_flush_streams (demux);
1565 }
1566
1567 static GstFlowReturn
1568 gst_ts_demux_push (MpegTSBase * base, MpegTSPacketizerPacket * packet,
1569     MpegTSPacketizerSection * section)
1570 {
1571   GstTSDemux *demux = GST_TS_DEMUX_CAST (base);
1572   TSDemuxStream *stream = NULL;
1573   GstFlowReturn res = GST_FLOW_OK;
1574
1575   if (G_LIKELY (demux->program)) {
1576     stream = (TSDemuxStream *) demux->program->streams[packet->pid];
1577
1578     if (stream) {
1579       res = gst_ts_demux_handle_packet (demux, stream, packet, section);
1580     }
1581   }
1582   return res;
1583 }
1584
1585 gboolean
1586 gst_ts_demux_plugin_init (GstPlugin * plugin)
1587 {
1588   GST_DEBUG_CATEGORY_INIT (ts_demux_debug, "tsdemux", 0,
1589       "MPEG transport stream demuxer");
1590   init_pes_parser ();
1591
1592   return gst_element_register (plugin, "tsdemux",
1593       GST_RANK_PRIMARY, GST_TYPE_TS_DEMUX);
1594 }