Debian Codegraph @

gst-libs/gst/adaptivedemux/gstadaptivedemux.h

raw
1 /* GStreamer
2 *
3 * Copyright (C) 2014 Samsung Electronics. All rights reserved.
4 * Author: Thiago Santos <[email protected]>
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Library General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Library General Public License for more details.
15 *
16 * You should have received a copy of the GNU Library General Public
17 * License along with this library; if not, write to the
18 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
19 * Boston, MA 02110-1301, USA.
20 */
21
22 #ifndef _GST_ADAPTIVE_DEMUX_H_
23 #define _GST_ADAPTIVE_DEMUX_H_
24
25 #include <gst/gst.h>
26 #include <gst/base/gstadapter.h>
27 #include <gst/uridownloader/gsturidownloader.h>
28 #include <gst/adaptivedemux/adaptive-demux-prelude.h>
29
30 G_BEGIN_DECLS
31
32 #define GST_TYPE_ADAPTIVE_DEMUX \
33 (gst_adaptive_demux_get_type())
34 #define GST_ADAPTIVE_DEMUX(obj) \
35 (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_ADAPTIVE_DEMUX,GstAdaptiveDemux))
36 #define GST_ADAPTIVE_DEMUX_CLASS(klass) \
37 (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_ADAPTIVE_DEMUX,GstAdaptiveDemuxClass))
38 #define GST_ADAPTIVE_DEMUX_GET_CLASS(obj) \
39 (G_TYPE_INSTANCE_GET_CLASS((obj),GST_TYPE_ADAPTIVE_DEMUX,GstAdaptiveDemuxClass))
40 #define GST_IS_ADAPTIVE_DEMUX(obj) \
41 (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_ADAPTIVE_DEMUX))
42 #define GST_IS_ADAPTIVE_DEMUX_CLASS(obj) \
43 (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_ADAPTIVE_DEMUX))
44 #define GST_ADAPTIVE_DEMUX_CAST(obj) ((GstAdaptiveDemux *)obj)
45
46 #define GST_ADAPTIVE_DEMUX_STREAM_CAST(obj) ((GstAdaptiveDemuxStream *)obj)
47
48 /**
49 * GST_ADAPTIVE_DEMUX_SINK_NAME:
50 *
51 * The name of the templates for the sink pad.
52 */
53 #define GST_ADAPTIVE_DEMUX_SINK_NAME "sink"
54
55 /**
56 * GST_ADAPTIVE_DEMUX_SINK_PAD:
57 * @obj: a #GstAdaptiveDemux
58 *
59 * Gives the pointer to the sink #GstPad object of the element.
60 */
61 #define GST_ADAPTIVE_DEMUX_SINK_PAD(obj) (((GstAdaptiveDemux *) (obj))->sinkpad)
62
63 #define GST_ADAPTIVE_DEMUX_IN_TRICKMODE_KEY_UNITS(obj) ((((GstAdaptiveDemux*)(obj))->segment.flags & GST_SEGMENT_FLAG_TRICKMODE_KEY_UNITS) == GST_SEGMENT_FLAG_TRICKMODE_KEY_UNITS)
64
65 #define GST_ADAPTIVE_DEMUX_STREAM_PAD(obj) (((GstAdaptiveDemuxStream *) (obj))->pad)
66
67 #define GST_ADAPTIVE_DEMUX_STREAM_NEED_HEADER(obj) (((GstAdaptiveDemuxStream *) (obj))->need_header)
68
69 /**
70 * GST_ADAPTIVE_DEMUX_STATISTICS_MESSAGE_NAME:
71 *
72 * Name of the ELEMENT type messages posted by dashdemux with statistics.
73 *
74 * Since: 1.6
75 */
76 #define GST_ADAPTIVE_DEMUX_STATISTICS_MESSAGE_NAME "adaptive-streaming-statistics"
77
78 #define GST_ELEMENT_ERROR_FROM_ERROR(el, msg, err) G_STMT_START { \
79 gchar *__dbg = g_strdup_printf ("%s: %s", msg, err->message); \
80 GST_WARNING_OBJECT (el, "error: %s", __dbg); \
81 gst_element_message_full (GST_ELEMENT(el), GST_MESSAGE_ERROR, \
82 err->domain, err->code, \
83 NULL, __dbg, __FILE__, GST_FUNCTION, __LINE__); \
84 g_clear_error (&err); \
85 } G_STMT_END
86
87 /* DEPRECATED */
88 #define GST_ADAPTIVE_DEMUX_FLOW_END_OF_FRAGMENT GST_FLOW_CUSTOM_SUCCESS_1
89
90 typedef struct _GstAdaptiveDemuxStreamFragment GstAdaptiveDemuxStreamFragment;
91 typedef struct _GstAdaptiveDemuxStream GstAdaptiveDemuxStream;
92 typedef struct _GstAdaptiveDemux GstAdaptiveDemux;
93 typedef struct _GstAdaptiveDemuxClass GstAdaptiveDemuxClass;
94 typedef struct _GstAdaptiveDemuxPrivate GstAdaptiveDemuxPrivate;
95
96 struct _GstAdaptiveDemuxStreamFragment
97 {
98 GstClockTime timestamp;
99 GstClockTime duration;
100
101 gchar *uri;
102 gint64 range_start;
103 gint64 range_end;
104
105 /* when chunked downloading is used, may be be updated need_another_chunk() */
106 guint chunk_size;
107
108 /* when headers are needed */
109 gchar *header_uri;
110 gint64 header_range_start;
111 gint64 header_range_end;
112
113 /* when index is needed */
114 gchar *index_uri;
115 gint64 index_range_start;
116 gint64 index_range_end;
117
118 /* Nominal bitrate as provided by
119 * sub-class or calculated by base-class */
120 guint bitrate;
121
122 gboolean finished;
123 };
124
125 struct _GstAdaptiveDemuxStream
126 {
127 GstPad *pad;
128 GstPad *internal_pad;
129
130 GstAdaptiveDemux *demux;
131
132 GstSegment segment;
133
134 GstCaps *pending_caps;
135 GstEvent *pending_segment;
136 GstTagList *pending_tags;
137 gboolean need_header;
138 GList *pending_events;
139
140 GstFlowReturn last_ret;
141 GError *last_error;
142
143 GstTask *download_task;
144 GRecMutex download_lock;
145
146 gboolean restart_download;
147 gboolean discont;
148
149 gboolean downloading_first_buffer;
150 gboolean downloading_header;
151 gboolean downloading_index;
152
153 gboolean bitrate_changed;
154
155 /* download tooling */
156 GstElement *src;
157 guint last_status_code;
158 GstPad *src_srcpad;
159 GstElement *uri_handler;
160 GstElement *queue;
161 GMutex fragment_download_lock;
162 GCond fragment_download_cond;
163 gboolean download_finished; /* protected by fragment_download_lock */
164 gboolean cancelled; /* protected by fragment_download_lock */
165 gboolean replaced; /* replaced in a bitrate switch (used with cancelled) */
166 gboolean src_at_ready; /* protected by fragment_download_lock */
167 gboolean starting_fragment;
168 gboolean first_fragment_buffer;
169 gint64 download_start_time;
170 gint64 download_total_bytes;
171 guint64 current_download_rate;
172
173 /* amount of data downloaded in current fragment (pre-queue2) */
174 guint64 fragment_bytes_downloaded;
175 /* bitrate of the previous fragment (pre-queue2) */
176 guint64 last_bitrate;
177 /* latency (request to first byte) and full download time (request to EOS)
178 * of previous fragment (pre-queue2) */
179 GstClockTime last_latency;
180 GstClockTime last_download_time;
181
182 /* Average for the last fragments */
183 guint64 moving_bitrate;
184 guint moving_index;
185 guint64 *fragment_bitrates;
186
187 /* QoS data : UNUSED !!! */
188 GstClockTime qos_earliest_time;
189
190 GstAdaptiveDemuxStreamFragment fragment;
191
192 guint download_error_count;
193
194 /* TODO check if used */
195 gboolean eos;
196
197 gboolean do_block; /* TRUE if stream should block on preroll */
198 };
199
200 /**
201 * GstAdaptiveDemux:
202 *
203 * The opaque #GstAdaptiveDemux data structure.
204 */
205 struct _GstAdaptiveDemux
206 {
207 /*< private >*/
208 GstBin bin;
209
210 gint running;
211
212 gsize stream_struct_size;
213
214 /*< protected >*/
215 GstPad *sinkpad;
216
217 GstUriDownloader *downloader;
218
219 GList *streams;
220 GList *prepared_streams;
221 GList *next_streams;
222
223 GstSegment segment;
224
225 gchar *manifest_uri;
226 gchar *manifest_base_uri;
227
228 /* Properties */
229 gfloat bitrate_limit; /* limit of the available bitrate to use */
230 guint connection_speed;
231
232 gboolean have_group_id;
233 guint group_id;
234
235 /* Realtime clock */
236 GstClock *realtime_clock;
237 gint64 clock_offset; /* offset between realtime_clock and UTC (in usec) */
238
239 /* < private > */
240 GstAdaptiveDemuxPrivate *priv;
241 };
242
243 /**
244 * GstAdaptiveDemuxClass:
245 *
246 */
247 struct _GstAdaptiveDemuxClass
248 {
249 /*< private >*/
250 GstBinClass bin_class;
251
252 /*< public >*/
253
254 /**
255 * process_manifest: Parse the manifest
256 * @demux: #GstAdaptiveDemux
257 * @manifest: the manifest to be parsed
258 *
259 * Parse the manifest and add the created streams using
260 * gst_adaptive_demux_stream_new()
261 *
262 * Returns: %TRUE if successful
263 */
264 gboolean (*process_manifest) (GstAdaptiveDemux * demux, GstBuffer * manifest);
265
266 /**
267 * get_manifest_update_interval:
268 * @demux: #GstAdaptiveDemux
269 *
270 * Used during live streaming, the subclass should return the interval
271 * between successive manifest updates
272 *
273 * Returns: the update interval in microseconds
274 */
275 gint64 (*get_manifest_update_interval) (GstAdaptiveDemux * demux);
276
277 /**
278 * update_manifest:
279 * @demux: #GstAdaptiveDemux
280 *
281 * During live streaming, this will be called for the subclass to update its
282 * manifest with the new version. By default it fetches the manifest URI
283 * and passes it to GstAdaptiveDemux::update_manifest_data().
284 *
285 * Returns: #GST_FLOW_OK is all succeeded, #GST_FLOW_EOS if the stream ended
286 * or #GST_FLOW_ERROR if an error happened
287 */
288 GstFlowReturn (*update_manifest) (GstAdaptiveDemux * demux);
289
290 /**
291 * update_manifest_data:
292 * @demux: #GstAdaptiveDemux
293 * @buf: Downloaded manifest data
294 *
295 * During live streaming, this will be called for the subclass to update its
296 * manifest with the new version
297 *
298 * Returns: #GST_FLOW_OK is all succeeded, #GST_FLOW_EOS if the stream ended
299 * or #GST_FLOW_ERROR if an error happened
300 */
301 GstFlowReturn (*update_manifest_data) (GstAdaptiveDemux * demux, GstBuffer * buf);
302
303 gboolean (*is_live) (GstAdaptiveDemux * demux);
304 GstClockTime (*get_duration) (GstAdaptiveDemux * demux);
305
306 /**
307 * reset:
308 * @demux: #GstAdaptiveDemux
309 *
310 * Reset the internal state of the subclass, getting ready to restart with
311 * a new stream afterwards
312 */
313 void (*reset) (GstAdaptiveDemux * demux);
314
315 /**
316 * seek:
317 * @demux: #GstAdaptiveDemux
318 * @seek: a seek #GstEvent
319 *
320 * The demuxer should seek on all its streams to the specified position
321 * in the seek event
322 *
323 * Returns: %TRUE if successful
324 */
325 gboolean (*seek) (GstAdaptiveDemux * demux, GstEvent * seek);
326
327 /**
328 * has_next_period:
329 * @demux: #GstAdaptiveDemux
330 *
331 * Checks if there is a next period following the current one.
332 * DASH can have multiple medias chained in its manifest, when one finishes
333 * this function is called to verify if there is a new period to be played
334 * in sequence.
335 *
336 * Returns: %TRUE if there is another period
337 */
338 gboolean (*has_next_period) (GstAdaptiveDemux * demux);
339 /**
340 * advance_period:
341 * @demux: #GstAdaptiveDemux
342 *
343 * Advances the manifest to the next period. New streams should be created
344 * using gst_adaptive_demux_stream_new().
345 */
346 void (*advance_period) (GstAdaptiveDemux * demux);
347
348 void (*stream_free) (GstAdaptiveDemuxStream * stream);
349 GstFlowReturn (*stream_seek) (GstAdaptiveDemuxStream * stream, gboolean forward, GstSeekFlags flags, GstClockTime target_ts, GstClockTime * final_ts);
350 gboolean (*stream_has_next_fragment) (GstAdaptiveDemuxStream * stream);
351 GstFlowReturn (*stream_advance_fragment) (GstAdaptiveDemuxStream * stream);
352
353 /**
354 * need_another_chunk:
355 * @stream: #GstAdaptiveDemuxStream
356 *
357 * If chunked downloading is used (chunk_size != 0) this is called once a
358 * chunk is finished to decide whether more has to be downloaded or not.
359 * May update chunk_size to a different value
360 */
361 gboolean (*need_another_chunk) (GstAdaptiveDemuxStream * stream);
362
363 /**
364 * stream_update_fragment_info:
365 * @stream: #GstAdaptiveDemuxStream
366 *
367 * Requests the stream to set the information about the current fragment to its
368 * current fragment struct
369 *
370 * Returns: #GST_FLOW_OK in success, #GST_FLOW_ERROR on error and #GST_FLOW_EOS
371 * if there is no fragment.
372 */
373 GstFlowReturn (*stream_update_fragment_info) (GstAdaptiveDemuxStream * stream);
374 /**
375 * stream_select_bitrate:
376 * @stream: #GstAdaptiveDemuxStream
377 * @bitrate: the bitrate to select (in bytes per second)
378 *
379 * The stream should try to select the bitrate that is the greater, but not
380 * greater than the requested bitrate. If it needs a codec change it should
381 * create the new stream using gst_adaptive_demux_stream_new(). If it only
382 * needs a caps change it should set the new caps using
383 * gst_adaptive_demux_stream_set_caps().
384 *
385 * Returns: %TRUE if the stream changed bitrate, %FALSE otherwise
386 */
387 gboolean (*stream_select_bitrate) (GstAdaptiveDemuxStream * stream, guint64 bitrate);
388 /**
389 * stream_get_fragment_waiting_time:
390 * @stream: #GstAdaptiveDemuxStream
391 *
392 * For live streams, requests how much time should be waited before starting
393 * to download the fragment. This is useful to avoid downloading a fragment that
394 * isn't available yet.
395 *
396 * Returns: The waiting time in microseconds
397 */
398 gint64 (*stream_get_fragment_waiting_time) (GstAdaptiveDemuxStream * stream);
399
400 /**
401 * start_fragment:
402 * @demux: #GstAdaptiveDemux
403 * @stream: #GstAdaptiveDemuxStream
404 *
405 * Notifies the subclass that the given stream is starting the download
406 * of a new fragment. Can be used to reset/init internal state that is
407 * needed before each fragment, like decryption engines.
408 *
409 * Returns: %TRUE if successful.
410 */
411 gboolean (*start_fragment) (GstAdaptiveDemux * demux, GstAdaptiveDemuxStream * stream);
412 /**
413 * finish_fragment:
414 * @demux: #GstAdaptiveDemux
415 * @stream: #GstAdaptiveDemuxStream
416 *
417 * Notifies the subclass that a fragment download was finished.
418 * It can be used to cleanup internal state after a fragment and
419 * also push any pending data before moving to the next fragment.
420 */
421 GstFlowReturn (*finish_fragment) (GstAdaptiveDemux * demux, GstAdaptiveDemuxStream * stream);
422 /**
423 * data_received:
424 * @demux: #GstAdaptiveDemux
425 * @stream: #GstAdaptiveDemuxStream
426 * @buffer: #GstBuffer
427 *
428 * Notifies the subclass that a fragment chunk was downloaded. The subclass
429 * can look at the data and modify/push data as desired.
430 *
431 * Returns: #GST_FLOW_OK if successful, #GST_FLOW_ERROR in case of error.
432 */
433 GstFlowReturn (*data_received) (GstAdaptiveDemux * demux, GstAdaptiveDemuxStream * stream, GstBuffer * buffer);
434
435 /**
436 * get_live_seek_range:
437 * @demux: #GstAdaptiveDemux
438 * @start: pointer to put the start position allowed to seek to
439 * @stop: pointer to put the stop position allowed to seek to
440 *
441 * Gets the allowed seek start and stop positions for the current live stream
442 *
443 * Return: %TRUE if successful
444 */
445 gboolean (*get_live_seek_range) (GstAdaptiveDemux * demux, gint64 * start, gint64 * stop);
446
447 /**
448 * get_presentation_offset:
449 * @demux: #GstAdaptiveDemux
450 * @stream: #GstAdaptiveDemuxStream
451 *
452 * Gets the delay to apply to @stream.
453 *
454 * Return: a #GstClockTime representing the (positive) time offset to apply to
455 * @stream.
456 */
457 GstClockTime (*get_presentation_offset) (GstAdaptiveDemux *demux, GstAdaptiveDemuxStream *stream);
458
459 /**
460 * get_period_start_time:
461 * @demux: #GstAdaptiveDemux
462 *
463 * Gets the start time of the current period. Timestamps are resetting to 0
464 * after each period but we have to maintain a continuous stream and running
465 * time so need to know the start time of the current period.
466 *
467 * Return: a #GstClockTime representing the start time of the currently
468 * selected period.
469 */
470 GstClockTime (*get_period_start_time) (GstAdaptiveDemux *demux);
471
472 /**
473 * requires_periodical_playlist_update:
474 * @demux: #GstAdaptiveDemux
475 *
476 * Some adaptive streaming protocols allow the client to download
477 * the playlist once and build up the fragment list based on the
478 * current fragment metadata. For those protocols the demuxer
479 * doesn't need to periodically refresh the playlist. This vfunc
480 * is relevant only for live playback scenarios.
481 *
482 * Return: %TRUE if the playlist needs to be refreshed periodically by the demuxer.
483 */
484 gboolean (*requires_periodical_playlist_update) (GstAdaptiveDemux * demux);
485 };
486
487 GST_ADAPTIVE_DEMUX_API
488 GType gst_adaptive_demux_get_type (void);
489
490 GST_ADAPTIVE_DEMUX_API
491 void gst_adaptive_demux_set_stream_struct_size (GstAdaptiveDemux * demux,
492 gsize struct_size);
493
494
495 GST_ADAPTIVE_DEMUX_API
496 GstAdaptiveDemuxStream *gst_adaptive_demux_stream_new (GstAdaptiveDemux * demux,
497 GstPad * pad);
498
499 GST_ADAPTIVE_DEMUX_API
500 GstAdaptiveDemuxStream *gst_adaptive_demux_find_stream_for_pad (GstAdaptiveDemux * demux,
501 GstPad * pad);
502
503 GST_ADAPTIVE_DEMUX_API
504 void gst_adaptive_demux_stream_set_caps (GstAdaptiveDemuxStream * stream,
505 GstCaps * caps);
506
507 GST_ADAPTIVE_DEMUX_API
508 void gst_adaptive_demux_stream_set_tags (GstAdaptiveDemuxStream * stream,
509 GstTagList * tags);
510
511 GST_ADAPTIVE_DEMUX_API
512 void gst_adaptive_demux_stream_fragment_clear (GstAdaptiveDemuxStreamFragment * f);
513
514 GST_ADAPTIVE_DEMUX_API
515 GstFlowReturn gst_adaptive_demux_stream_push_buffer (GstAdaptiveDemuxStream * stream, GstBuffer * buffer);
516
517 GST_ADAPTIVE_DEMUX_API
518 GstFlowReturn
519 gst_adaptive_demux_stream_advance_fragment (GstAdaptiveDemux * demux,
520 GstAdaptiveDemuxStream * stream, GstClockTime duration);
521
522 GST_ADAPTIVE_DEMUX_API
523 void gst_adaptive_demux_stream_queue_event (GstAdaptiveDemuxStream * stream,
524 GstEvent * event);
525
526 GST_ADAPTIVE_DEMUX_API
527 GstClockTime gst_adaptive_demux_get_monotonic_time (GstAdaptiveDemux * demux);
528
529 GST_ADAPTIVE_DEMUX_API
530 GDateTime *gst_adaptive_demux_get_client_now_utc (GstAdaptiveDemux * demux);
531
532 GST_ADAPTIVE_DEMUX_API
533 gboolean gst_adaptive_demux_is_running (GstAdaptiveDemux * demux);
534
535 GST_ADAPTIVE_DEMUX_API
536 GstClockTime gst_adaptive_demux_get_qos_earliest_time (GstAdaptiveDemux *demux);
537
538 G_END_DECLS
539
540 #endif
541