From 66f51f642f83ce738392a9ecd6bea00f6f94b27a Mon Sep 17 00:00:00 2001 From: Jordan Yelloz Date: Thu, 3 Aug 2023 17:05:17 -0600 Subject: [PATCH] bad: Added W3C Media Source Extensions library Part-of: --- girs/GstMse-1.0.gir | 1135 +++++++++ .../gst-plugins-bad/docs/libs/mse/index.md | 3 + .../gst-plugins-bad/docs/libs/mse/sitemap.txt | 1 + subprojects/gst-plugins-bad/docs/meson.build | 1 + .../docs/plugins/gst_plugins_cache.json | 120 + .../gst-plugins-bad/gst-libs/gst/meson.build | 1 + .../gst/mse/gstappendpipeline-private.h | 102 + .../gst-libs/gst/mse/gstappendpipeline.c | 978 ++++++++ .../gst-libs/gst/mse/gstmediasource-private.h | 58 + .../gst-libs/gst/mse/gstmediasource.c | 1063 +++++++++ .../gst-libs/gst/mse/gstmediasource.h | 203 ++ .../gst/mse/gstmediasourcesamplemap-private.h | 94 + .../gst/mse/gstmediasourcesamplemap.c | 551 +++++ .../gst/mse/gstmediasourcetrack-private.h | 110 + .../gst-libs/gst/mse/gstmediasourcetrack.c | 458 ++++ .../mse/gstmediasourcetrackbuffer-private.h | 100 + .../gst/mse/gstmediasourcetrackbuffer.c | 377 +++ .../gst/mse/gstmseeventqueue-private.h | 46 + .../gst-libs/gst/mse/gstmseeventqueue.c | 133 ++ .../gst-libs/gst/mse/gstmselogging-private.h | 33 + .../gst-libs/gst/mse/gstmselogging.c | 35 + .../gst/mse/gstmsemediatype-private.h | 60 + .../gst-libs/gst/mse/gstmsemediatype.c | 544 +++++ .../gst-libs/gst/mse/gstmsesrc-private.h | 55 + .../gst-libs/gst/mse/gstmsesrc.c | 1385 +++++++++++ .../gst-libs/gst/mse/gstmsesrc.h | 94 + .../gst/mse/gstsourcebuffer-private.h | 72 + .../gst-libs/gst/mse/gstsourcebuffer.c | 2019 +++++++++++++++++ .../gst-libs/gst/mse/gstsourcebuffer.h | 127 ++ .../gst/mse/gstsourcebufferlist-private.h | 64 + .../gst-libs/gst/mse/gstsourcebufferlist.c | 461 ++++ .../gst-libs/gst/mse/gstsourcebufferlist.h | 44 + .../gst-libs/gst/mse/meson.build | 149 ++ .../gst-libs/gst/mse/mse-prelude.h | 48 + .../gst-plugins-bad/gst-libs/gst/mse/mse.h | 32 + subprojects/gst-plugins-bad/gst/meson.build | 2 +- subprojects/gst-plugins-bad/gst/mse/gstmse.c | 49 + subprojects/gst-plugins-bad/gst/mse/gstmse.h | 33 + .../gst-plugins-bad/gst/mse/meson.build | 12 + subprojects/gst-plugins-bad/meson_options.txt | 1 + .../gst-plugins-bad/tests/check/libs/mse.c | 1119 +++++++++ .../gst-plugins-bad/tests/check/meson.build | 1 + .../gst-plugins-bad/tests/files/mse.mp4 | Bin 0 -> 477134 bytes .../gst-plugins-bad/tests/files/mse.webm | Bin 0 -> 526423 bytes .../gstreamer/libs/gst/check/gstcheck.c | 1 + 45 files changed, 11973 insertions(+), 1 deletion(-) create mode 100644 girs/GstMse-1.0.gir create mode 100644 subprojects/gst-plugins-bad/docs/libs/mse/index.md create mode 100644 subprojects/gst-plugins-bad/docs/libs/mse/sitemap.txt create mode 100644 subprojects/gst-plugins-bad/gst-libs/gst/mse/gstappendpipeline-private.h create mode 100644 subprojects/gst-plugins-bad/gst-libs/gst/mse/gstappendpipeline.c create mode 100644 subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasource-private.h create mode 100644 subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasource.c create mode 100644 subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasource.h create mode 100644 subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasourcesamplemap-private.h create mode 100644 subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasourcesamplemap.c create mode 100644 subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasourcetrack-private.h create mode 100644 subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasourcetrack.c create mode 100644 subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasourcetrackbuffer-private.h create mode 100644 subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasourcetrackbuffer.c create mode 100644 subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmseeventqueue-private.h create mode 100644 subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmseeventqueue.c create mode 100644 subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmselogging-private.h create mode 100644 subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmselogging.c create mode 100644 subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmsemediatype-private.h create mode 100644 subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmsemediatype.c create mode 100644 subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmsesrc-private.h create mode 100644 subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmsesrc.c create mode 100644 subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmsesrc.h create mode 100644 subprojects/gst-plugins-bad/gst-libs/gst/mse/gstsourcebuffer-private.h create mode 100644 subprojects/gst-plugins-bad/gst-libs/gst/mse/gstsourcebuffer.c create mode 100644 subprojects/gst-plugins-bad/gst-libs/gst/mse/gstsourcebuffer.h create mode 100644 subprojects/gst-plugins-bad/gst-libs/gst/mse/gstsourcebufferlist-private.h create mode 100644 subprojects/gst-plugins-bad/gst-libs/gst/mse/gstsourcebufferlist.c create mode 100644 subprojects/gst-plugins-bad/gst-libs/gst/mse/gstsourcebufferlist.h create mode 100644 subprojects/gst-plugins-bad/gst-libs/gst/mse/meson.build create mode 100644 subprojects/gst-plugins-bad/gst-libs/gst/mse/mse-prelude.h create mode 100644 subprojects/gst-plugins-bad/gst-libs/gst/mse/mse.h create mode 100644 subprojects/gst-plugins-bad/gst/mse/gstmse.c create mode 100644 subprojects/gst-plugins-bad/gst/mse/gstmse.h create mode 100644 subprojects/gst-plugins-bad/gst/mse/meson.build create mode 100644 subprojects/gst-plugins-bad/tests/check/libs/mse.c create mode 100644 subprojects/gst-plugins-bad/tests/files/mse.mp4 create mode 100644 subprojects/gst-plugins-bad/tests/files/mse.webm diff --git a/girs/GstMse-1.0.gir b/girs/GstMse-1.0.gir new file mode 100644 index 0000000000..4818df5a86 --- /dev/null +++ b/girs/GstMse-1.0.gir @@ -0,0 +1,1135 @@ + + + + + + + + #GstMediaSource is the entry point into the W3C Media Source API. It offers +functionality similar to #GstAppSrc for client-side web or JavaScript +applications decoupling the source of media from its processing and playback. + +To interact with a Media Source, connect it to a #GstMseSrc that is in some +#GstPipeline using gst_media_source_attach(). Then create at least one +#GstSourceBuffer using gst_media_source_add_source_buffer(). Finally, feed +some media data to the Source Buffer(s) using +gst_source_buffer_append_buffer() and play the pipeline. + + + Creates a new #GstMediaSource instance. The instance is in the +%GST_MEDIA_SOURCE_READY_STATE_CLOSED state and is not associated with any +media player. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-constructor) + + + a new #GstMediaSource instance + + + + + Determines whether the current Media Source configuration can process media +of the supplied @type. + + + `TRUE` when supported, `FALSE` otherwise + + + + + A MIME type value + + + + + + Add a #GstSourceBuffer to this #GstMediaSource of the specified media type. +The Media Source must be in the #GstMediaSourceReadyState %GST_MEDIA_SOURCE_READY_STATE_OPEN. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-addsourcebuffer) + + + a new #GstSourceBuffer instance on success, otherwise `NULL` + + + + + #GstMediaSource instance + + + + A MIME type describing the format of the incoming media + + + + + + Associates @self with @element. +Normally, the Element will be part of a #GstPipeline that plays back the data +submitted to the Media Source's Source Buffers. + +#GstMseSrc is a special source element that is designed to consume media from +a #GstMediaSource. + +[Specification](https://www.w3.org/TR/media-source-2/#dfn-attaching-to-a-media-element) + + + + + + + #GstMediaSource instance + + + + #GstMseSrc source Element + + + + + + Clear the live seekable range for @self. This will inform the component +playing this Media Source that there is no seekable time range. + +If the ready state is not %GST_MEDIA_SOURCE_READY_STATE_OPEN, it will fail +and set an error. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-clearliveseekablerange) + + + `TRUE` on success, `FALSE` otherwise + + + + + #GstMediaSource instance + + + + + + Detaches @self from any #GstMseSrc element that it may be associated with. + + + + + + + #GstMediaSource instance + + + + + + Mark @self as reaching the end of stream, disallowing new data inputs. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-endofstream) + + + `TRUE` on success, `FALSE` otherwise + + + + + #GstMediaSource instance + + + + The error type, if any + + + + + + Gets a #GstSourceBufferList containing all the Source Buffers currently +associated with this Media Source that are considered "active." +For a Source Buffer to be considered active, either its video track is +selected, its audio track is enabled, or its text track is visible or hidden. +This object will reflect any future changes to the parent Media Source as +well. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-activesourcebuffers) + + + a new #GstSourceBufferList instance + + + + + #GstMediaSource instance + + + + + + Gets the current duration of @self. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-duration) + + + the current duration as a #GstClockTime + + + + + #GstMediaSource instance + + + + + + Get the live seekable range of @self. Will fill in the supplied @range with +the current live seekable range. + + + + + + + #GstMediaSource instance + + + + time range + + + + + + Gets the current playback position of the Media Source. + + + the current playback position as a #GstClockTime + + + + + #GstMediaSource instance + + + + + + Gets the current Ready State of the Media Source. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-readystate) + + + the current #GstMediaSourceReadyState value + + + + + #GstMediaSource instance + + + + + + Gets a #GstSourceBufferList containing all the Source Buffers currently +associated with this Media Source. This object will reflect any future +changes to the parent Media Source as well. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-sourcebuffers) + + + a #GstSourceBufferList instance + + + + + #GstMediaSource instance + + + + + + Remove @buffer from @self. + +@buffer must have been created as a child of @self and @self must be in the +#GstMediaSourceReadyState %GST_MEDIA_SOURCE_READY_STATE_OPEN. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-removesourcebuffer) + + + `TRUE` on success, `FALSE` otherwise + + + + + #GstMediaSource instance + + + + #GstSourceBuffer instance + + + + + + Sets the duration of @self. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-duration) + + + `TRUE` on success, `FALSE` otherwise + + + + + #GstMediaSource instance + + + + The new duration to apply to @self. + + + + + + Set the live seekable range for @self. This range informs the component +playing this Media Source what it can allow the user to seek through. + +If the ready state is not %GST_MEDIA_SOURCE_READY_STATE_OPEN, or the supplied +@start time is later than @end it will fail and set an error. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-setliveseekablerange) + + + `TRUE` on success, `FALSE` otherwise + + + + + #GstMediaSource instance + + + + The earliest point in the stream considered seekable + + + + The latest point in the stream considered seekable + + + + + + A #GstSourceBufferList of every #GstSourceBuffer in this Media Source that +is considered active + +[Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-activesourcebuffers) + + + + The Duration of the Media Source as a #GstClockTime + +[Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-duration) + + + + The position of the player consuming from the Media Source + + + + The Ready State of the Media Source + +[Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-readystate) + + + + A #GstSourceBufferList of every #GstSourceBuffer in this Media Source + +[Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-sourcebuffers) + + + + + + + + + Emitted when @self has ended, normally through +gst_media_source_end_of_stream(). + +[Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-onsourceended) + + + + + + Emitted when @self has been opened. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-onsourceopen) + + + + + + + + + + + + + Reasons for ending a #GstMediaSource using gst_media_source_end_of_stream(). + +[Specification](https://www.w3.org/TR/media-source-2/#dom-endofstreamerror) + + End the stream successfully + + + End the stream due to a networking error + + + End the stream due to a decoding error + + + + Any error that can occur within #GstMediaSource or #GstSourceBuffer APIs. +These values correspond directly to those in the Web IDL specification. + +[Specification](https://webidl.spec.whatwg.org/#idl-DOMException-error-names) + + + + + + + + + + + + Any error type that can be reported by the Media Source API. + + + + + + + A structure describing a simplified version of the TimeRanges concept in the +HTML specification, only representing a single @start and @end time. + +[Specification](https://html.spec.whatwg.org/multipage/media.html#timeranges) + + + The start of this range. + + + + The end of this range. + + + + + Describes the possible states of the Media Source. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-readystate) + + The #GstMediaSource is not connected to +any playback element. + + + The #GstMediaSource is connected to a +playback element and ready to append data to its #GstSourceBuffer (s). + + + gst_media_source_end_of_stream() has +been called on the current #GstMediaSource + + + + #GstMseSrc is a source Element that interacts with a #GstMediaSource to +consume #GstSample<!-- -->s processed by the Media Source and supplies them +to the containing #GstPipeline. In the perspective of the Media Source API, +this element fulfills the basis of the Media Element's role relating to +working with a Media Source. The remaining responsibilities are meant to be +fulfilled by the application and #GstPlay can be used to satisfy many of +them. + +Once added to a Pipeline, this element should be attached to a Media Source +using gst_media_source_attach(). + + + + Gets the duration of @self. + +[Specification](https://html.spec.whatwg.org/multipage/media.html#dom-media-duration) + + + The duration of this stream as a #GstClockTime + + + + + #GstMseSrc instance + + + + + + + + the number of audio tracks available from this source + + + + + #GstMseSrc instance + + + + + + + + the number of text tracks available from this source + + + + + #GstMseSrc instance + + + + + + + + the number of video tracks available from this source + + + + + #GstMseSrc instance + + + + + + Gets the current playback position of @self. + +[Specification](https://html.spec.whatwg.org/multipage/media.html#current-playback-position) + + + The playback position of this Element as a #GstClockTime + + + + + #GstMseSrc instance + + + + + + The Ready State of @self, describing to what level it can supply content for +the current #GstMseSrc:position. This is a separate concept from +#GstMediaSource:ready-state: and corresponds to the HTML Media Element's +Ready State. + +[Specification](https://html.spec.whatwg.org/multipage/media.html#ready-states) + + + the current #GstMseSrcReadyState + + + + + #GstMseSrc instance + + + + + + The duration of the stream as a #GstClockTime + +[Specification](https://html.spec.whatwg.org/multipage/media.html#dom-media-duration) + + + + The number of audio tracks in the Media Source + + + + The number of text tracks in the Media Source + + + + The number of video tracks in the Media Source + + + + The playback position as a #GstClockTime + +[Specification](https://html.spec.whatwg.org/multipage/media.html#current-playback-position) + + + + The Ready State of this element, describing to what level it can supply +content for the current #GstMseSrc:position. This is a separate concept +from #GstMediaSource:ready-state: and corresponds to the HTML Media +Element's Ready State. + +[Specification](https://html.spec.whatwg.org/multipage/media.html#ready-states) + + + + + + + + + + + + + + + + + + + + Describes how much information a #GstMseSrc has about the media it is playing +back at the current playback #GstMseSrc:position. This type corresponds +directly to the ready state of a HTML Media Element and is a separate concept +from #GstMediaSourceReadyState. + +[Specification](https://html.spec.whatwg.org/multipage/media.html#ready-states) + + No information is available about the +stream + + + The duration is available and video +dimensions are available if the stream contains video + + + The current playback position can +be presented but future information is not available + + + There is data for the current +position and some amount in the future and any text tracks are ready. + + + Either there is enough data to +play the stream through at the current playback and input rate or the input +buffer is full. + + + + The Source Buffer is the primary means of data flow between an application +and the Media Source API. It represents a single timeline of media, +containing some combination of audio, video, and text tracks. +An application is responsible for feeding raw data into the Source Buffer +using gst_source_buffer_append_buffer() and the Source Buffer will +asynchronously process the data into tracks of time-coded multimedia samples. + +The application as well as the associated playback component can then select +to play media from any subset of tracks across all Source Buffers of a Media +Source. + +A few control points are also provided to customize the behavior. + + - #GstSourceBuffer:append-mode controls how timestamps of processed samples are + interpreted. They are either inserted in the timeline directly where the + decoded media states they should, or inserted directly after the previously + encountered sample. + + - #GstSourceBuffer:append-window-start / #GstSourceBuffer:append-window-end + control the planned time window where media from appended data can be added + to the current timeline. Any samples outside that range may be ignored. + + - #GstSourceBuffer:timestamp-offset is added to the start time of any sample + processed. + + + Attempts to end any processing of the currently pending data and reset the +media parser. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-abort) + + + `TRUE` on success, `FALSE` otherwise + + + + + #GstSourceBuffer instance + + + + + + Schedules the bytes inside @buf to be processed by @self. When it is possible +to accept the supplied data, it will be processed asynchronously and fill in +the track buffers for playback purposes. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-appendbuffer) + + + `TRUE` on success, `FALSE` otherwise + + + + + #GstSourceBuffer instance + + + + The media data to append + + + + + + Attempts to change the content type of @self to @type. Any new data appended +to the Source Buffer must be of the supplied @type afterward. + + + `TRUE` on success, `FALSE` otherwise + + + + + #GstSourceBuffer instance + + + + the desired content type + + + + + + [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-mode) + + + The current #GstSourceBufferAppendMode + + + + + #GstSourceBuffer instance + + + + + + Returns the current append window end time. Any segment processed that starts +after this value will be ignored. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-appendwindowend) + + + The current Append Window end time as a #GstClockTime + + + + + #GstSourceBuffer instance + + + + + + Returns the current append window start time. Any segment processed that ends +earlier than this value will be ignored. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-appendwindowstart) + + + The current Append Window start time as a #GstClockTime + + + + + #GstSourceBuffer instance + + + + + + Returns a sequence of #GstMediaSourceRange values representing which segments +of @self are buffered in memory. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-buffered) + + + a #GArray of #GstMediaSourceRange values. + + + + + + + #GstSourceBuffer instance + + + + + + Returns the current content type of @self. + + + a string representing the content type + + + + + #GstSourceBuffer instance + + + + + + [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-timestampoffset) + + + The current timestamp offset as a #GstClockTime + + + + + #GstSourceBuffer instance + + + + + + [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-updating) + + + Whether @self is currently adding or removing media content. + + + + + #GstSourceBuffer instance + + + + + + Attempts to remove any parsed data between @start and @end from @self. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-remove) + + + `TRUE` on success, `FALSE` otherwise + + + + + #GstSourceBuffer instance + + + + The beginning timestamp of data to remove + + + + The end timestamp of data to remove + + + + + + Changes the Append Mode of @self. This influences what timestamps will be +assigned to media processed by this Source Buffer. In Segment mode, the +timestamps in each segment determine the position of each sample after it +is processed. In Sequence mode, the timestamp of each processed sample is +generated based on the end of the most recently processed segment. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-mode) + + + `TRUE` on success, `FALSE` otherwise + + + + + #GstSourceBuffer instance + + + + #GstSourceBufferAppendMode the desired Append Mode + + + + + + Modifies the current append window end of @self. If successful, samples +processed after setting this value that start after this point will be +ignored. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-appendwindowend) + + + `TRUE` on success, `FALSE` otherwise + + + + + #GstSourceBuffer instance + + + + the append window end + + + + + + Modifies the current append window start of @self. If successful, samples +processed after setting this value that end before this point will be +ignored. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-appendwindowstart) + + + `TRUE` on success, `FALSE` otherwise + + + + + #GstSourceBuffer instance + + + + the append window end + + + + + + Attempt to set the timestamp offset of @self. Any media processed after this +value is set will have this value added to its start time. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-timestampoffset) + + + `TRUE` on success, `FALSE` otherwise + + + + + #GstSourceBuffer instance + + + + The new timestamp offset + + + + + + Affects how timestamps of processed media segments are interpreted. +In %GST_SOURCE_BUFFER_APPEND_MODE_SEGMENTS, the start timestamp of a +processed media segment is used directly along with +#GstSourceBuffer:timestamp-offset . +In %GST_SOURCE_BUFFER_APPEND_MODE_SEQUENCE, the timestamp of a +processed media segment is ignored and replaced with the end time of the +most recently appended segment. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-mode) + + + + Any segments processed which have a start time greater than this value will +be ignored by this Source Buffer. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-appendwindowend) + + + + Any segments processed which end before this value will be ignored by this +Source Buffer. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-appendwindowstart) + + + + The set of Time Intervals that have been loaded into the current Source +Buffer + +[Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-buffered) + + + + + + The MIME content-type of the data stream + + + + The next media segment appended to the current Source Buffer will have its +start timestamp increased by this amount. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-timestampoffset) + + + + Whether the current source buffer is still asynchronously processing +previously issued commands. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-updating) + + + + Emitted when @self was aborted after a call to gst_source_buffer_abort(). + +[Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-onabort) + + + + + + Emitted when @self has encountered an error after a call to +gst_source_buffer_append_buffer(). + +[Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-onerror) + + + + + + Emitted when @self has successfully processed data after a call to +gst_source_buffer_append_buffer(). + +[Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-onupdate) + + + + + + Emitted when @self is no longer in the updating state after a call to +gst_source_buffer_append_buffer(). This can happen after a successful or +unsuccessful append. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-onupdateend) + + + + + + Emitted when @self has begun to process data after a call to +gst_source_buffer_append_buffer(). + +[Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-onupdatestart) + + + + + + + [Specification](https://www.w3.org/TR/media-source-2/#dom-appendmode) + + + + + + + + + + + + + + + + + + + + + + The Source Buffer List is a list of #GstSourceBuffer<!-- -->s that can be +indexed numerically and monitored for changes. The list itself cannot be +modified through this interface, though the Source Buffers it holds can be +modified after retrieval. + +It is used by #GstMediaSource to provide direct access to its child +#GstSourceBuffer<!-- -->s through #GstMediaSource:source-buffers as well as +informing clients which of the Source Buffers are active through +#GstMediaSource:active-source-buffers. + + + [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebufferlist-length) + + + The number of #GstSourceBuffer objects in the list + + + + + #GstSourceBufferList instance + + + + + + Retrieves the #GstSourceBuffer at @index from @self. If @index is greater than +the highest index in the list, it will return `NULL`. + +[Specification](https://www.w3.org/TR/media-source-2/#dfn-sourcebufferlist-getter) + + + The requested #GstSourceBuffer or `NULL` + + + + + #GstSourceBufferList instance + + + + index of requested Source Buffer + + + + + + The number of #GstSourceBuffer<!-- -->s contained by this structure + +[Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebufferlist-length) + + + + Emitted when a #GstSourceBuffer has been added to this list. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebufferlist-onaddsourcebuffer) + + + + + + Emitted when a #GstSourceBuffer has been removed from this list. + +[Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebufferlist-onremovesourcebuffer) + + + + + + + + + + + + + Any error type that can be reported by the Media Source API. + + + + + + diff --git a/subprojects/gst-plugins-bad/docs/libs/mse/index.md b/subprojects/gst-plugins-bad/docs/libs/mse/index.md new file mode 100644 index 0000000000..95f019eca5 --- /dev/null +++ b/subprojects/gst-plugins-bad/docs/libs/mse/index.md @@ -0,0 +1,3 @@ +# W3C Media Source Extensions Library + +> NOTE: This library API is considered *unstable* diff --git a/subprojects/gst-plugins-bad/docs/libs/mse/sitemap.txt b/subprojects/gst-plugins-bad/docs/libs/mse/sitemap.txt new file mode 100644 index 0000000000..4f91fcd8a3 --- /dev/null +++ b/subprojects/gst-plugins-bad/docs/libs/mse/sitemap.txt @@ -0,0 +1 @@ +gi-index diff --git a/subprojects/gst-plugins-bad/docs/meson.build b/subprojects/gst-plugins-bad/docs/meson.build index 582de7d0fd..3b884e6af2 100644 --- a/subprojects/gst-plugins-bad/docs/meson.build +++ b/subprojects/gst-plugins-bad/docs/meson.build @@ -134,6 +134,7 @@ if build_gir {'name': 'codecs', 'gir': codecs_gir, 'lib': gstcodecs_dep}, {'name': 'cuda', 'gir': gst_cuda_gir, 'lib': gstcuda_dep, 'c_source_patterns': ['*.h', '*.cpp']}, {'name': 'dxva', 'gir': dxva_gir, 'lib': gstdxva_dep, 'c_source_patterns': ['*.h', '*.cpp']}, + {'name': 'mse', 'gir': mse_gir, 'lib': gstmse_dep, 'suffix': 'lib'}, ] if gstopencv_dep.found() diff --git a/subprojects/gst-plugins-bad/docs/plugins/gst_plugins_cache.json b/subprojects/gst-plugins-bad/docs/plugins/gst_plugins_cache.json index e5a8fe8c41..80e64a24ba 100644 --- a/subprojects/gst-plugins-bad/docs/plugins/gst_plugins_cache.json +++ b/subprojects/gst-plugins-bad/docs/plugins/gst_plugins_cache.json @@ -220390,6 +220390,126 @@ "tracers": {}, "url": "Unknown package origin" }, + "mse": { + "description": "W3C Media Source Extensions Support", + "elements": { + "msesrc": { + "author": "Collabora", + "description": "Implements a GStreamer Source for the gstreamer-mse API", + "hierarchy": [ + "GstMseSrc", + "GstElement", + "GstObject", + "GInitiallyUnowned", + "GObject" + ], + "interfaces": [ + "GstURIHandler" + ], + "klass": "Generic/Source", + "pad-templates": { + "src_%%s": { + "caps": "ANY", + "direction": "src", + "presence": "sometimes", + "type": "GstMseSrcPad" + } + }, + "properties": { + "duration": { + "blurb": "The duration of the stream as a GstClockTime", + "conditionally-available": false, + "construct": false, + "construct-only": false, + "controllable": false, + "default": "0", + "max": "18446744073709551615", + "min": "0", + "mutable": "null", + "readable": true, + "type": "guint64", + "writable": true + }, + "n-audio": { + "blurb": "The number of audio tracks in the Media Source", + "conditionally-available": false, + "construct": false, + "construct-only": false, + "controllable": false, + "default": "0", + "max": "2147483647", + "min": "0", + "mutable": "null", + "readable": true, + "type": "guint", + "writable": false + }, + "n-text": { + "blurb": "The number of text tracks in the Media Source", + "conditionally-available": false, + "construct": false, + "construct-only": false, + "controllable": false, + "default": "0", + "max": "2147483647", + "min": "0", + "mutable": "null", + "readable": true, + "type": "guint", + "writable": false + }, + "n-video": { + "blurb": "The number of video tracks in the Media Source", + "conditionally-available": false, + "construct": false, + "construct-only": false, + "controllable": false, + "default": "0", + "max": "2147483647", + "min": "0", + "mutable": "null", + "readable": true, + "type": "guint", + "writable": false + }, + "position": { + "blurb": "The playback position as a GstClockTime", + "conditionally-available": false, + "construct": false, + "construct-only": false, + "controllable": false, + "default": "18446744073709551615", + "max": "18446744073709551615", + "min": "0", + "mutable": "null", + "readable": true, + "type": "guint64", + "writable": false + }, + "ready-state": { + "blurb": "The Ready State of this Element", + "conditionally-available": false, + "construct": false, + "construct-only": false, + "controllable": false, + "default": "nothing (0)", + "mutable": "null", + "readable": true, + "type": "GstMseSrcReadyState", + "writable": false + } + }, + "rank": "none" + } + }, + "filename": "gstmse", + "license": "LGPL", + "other-types": {}, + "package": "GStreamer Bad Plug-ins", + "source": "gst-plugins-bad", + "tracers": {}, + "url": "Unknown package origin" + }, "musepack": { "description": "Musepack decoder", "elements": { diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/meson.build b/subprojects/gst-plugins-bad/gst-libs/gst/meson.build index fc4ba6942b..7772d8c2b1 100644 --- a/subprojects/gst-plugins-bad/gst-libs/gst/meson.build +++ b/subprojects/gst-plugins-bad/gst-libs/gst/meson.build @@ -13,6 +13,7 @@ subdir('insertbin') subdir('interfaces') subdir('isoff') subdir('mpegts') +subdir('mse') subdir('opencv') subdir('play') subdir('player') diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstappendpipeline-private.h b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstappendpipeline-private.h new file mode 100644 index 0000000000..c44a3440fb --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstappendpipeline-private.h @@ -0,0 +1,102 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2016, 2017 Metrological Group B.V. + * Copyright (C) 2016, 2017 Igalia S.L + * Copyright (C) 2022, 2023 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#pragma once + +#include +#include +#include +#include + +G_BEGIN_DECLS + +#define GST_TYPE_APPEND_PIPELINE (gst_append_pipeline_get_type()) + +GST_MSE_PRIVATE +G_DECLARE_FINAL_TYPE (GstAppendPipeline, gst_append_pipeline, GST, + APPEND_PIPELINE, GstObject); + +typedef struct +{ + void (*received_init_segment) (GstAppendPipeline * self, + gpointer user_data); + void (*duration_changed) (GstAppendPipeline * self, + gpointer user_data); + void (*new_sample) (GstAppendPipeline * self, + GstMediaSourceTrack * track, + GstSample * sample, + gpointer user_data); + void (*eos) (GstAppendPipeline * self, + GstMediaSourceTrack * track, + gpointer user_data); + void (*error) (GstAppendPipeline * self, + gpointer user_data); +} GstAppendPipelineCallbacks; + +GST_MSE_PRIVATE +GstAppendPipeline * gst_append_pipeline_new ( + GstAppendPipelineCallbacks * callbacks, gpointer user_data, + GError ** error); + +GST_MSE_PRIVATE +GstFlowReturn gst_append_pipeline_append (GstAppendPipeline * self, + GstBuffer * buffer); + +GST_MSE_PRIVATE +GstFlowReturn gst_append_pipeline_eos (GstAppendPipeline * self); + +GST_MSE_PRIVATE +gboolean gst_append_pipeline_stop (GstAppendPipeline * self); + +GST_MSE_PRIVATE +gboolean gst_append_pipeline_reset (GstAppendPipeline * self); + +GST_MSE_PRIVATE +gsize gst_append_pipeline_n_tracks (GstAppendPipeline * self); + +GST_MSE_PRIVATE +gboolean gst_append_pipeline_has_init_segment (GstAppendPipeline * self); + +GST_MSE_PRIVATE +GstClockTime gst_append_pipeline_get_duration (GstAppendPipeline * self); + +GST_MSE_PRIVATE +GPtrArray *gst_append_pipeline_get_audio_tracks (GstAppendPipeline * self); + +GST_MSE_PRIVATE +GPtrArray *gst_append_pipeline_get_text_tracks (GstAppendPipeline * self); + +GST_MSE_PRIVATE +GPtrArray *gst_append_pipeline_get_video_tracks (GstAppendPipeline * self); + +GST_MSE_PRIVATE +gboolean gst_append_pipeline_get_eos (GstAppendPipeline * self); + +GST_MSE_PRIVATE +void gst_append_pipeline_fail (GstAppendPipeline * self); + +GST_MSE_PRIVATE +gboolean gst_append_pipeline_get_failed (GstAppendPipeline * self); + +G_END_DECLS diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstappendpipeline.c b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstappendpipeline.c new file mode 100644 index 0000000000..db9cb25181 --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstappendpipeline.c @@ -0,0 +1,978 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2016, 2017 Metrological Group B.V. + * Copyright (C) 2016, 2017 Igalia S.L + * Copyright (C) 2022, 2023 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gstappendpipeline-private.h" + +#include "mse.h" + +#include "gstmselogging-private.h" +#include "gstmsemediatype-private.h" +#include "gstmediasourcetrack-private.h" + +#include +#include +#include + +typedef enum +{ + PARSE_ERROR, + IGNORED, + ADDED, +} AddTrackResult; + +typedef struct +{ + GstAppendPipeline *pipeline; + GstTask *task; + GRecMutex mutex; + GstBus *bus; +} BackgroundTask; + +typedef struct +{ + GstAppendPipelineCallbacks callbacks; + gpointer user_data; +} Callbacks; + +typedef struct +{ + GstAppendPipeline *parent; + GstPad *src_pad; + GstAppSink *sink; + GstMediaSourceTrack *mse_track; + GstStream *stream; + GstClockTime previous_pts; +} Track; + +typedef struct +{ + GstClockTime duration; + GPtrArray *video_tracks; + GPtrArray *audio_tracks; + GPtrArray *text_tracks; +} InitSegment; + +struct _GstAppendPipeline +{ + GstObject parent_instance; + + GstPipeline *pipeline; + GstAppSrc *src; + GstElement *parsebin; + GstBus *bus; + + GstStreamCollection *streams; + GArray *tracks; + + gboolean received_init_segment; + gboolean have_outstanding_samples; + InitSegment init_segment; + + gboolean encountered_error; + + BackgroundTask *task; + + Callbacks callbacks; +}; + +G_DEFINE_TYPE (GstAppendPipeline, gst_append_pipeline, GST_TYPE_OBJECT); + +#define END_OF_APPEND "end-of-append" +#define ABORT "abort" +#define SHUTDOWN "shutdown" + +static void process_init_segment (GstAppendPipeline *); + +static gboolean +send_abort (GstAppendPipeline * self) +{ + return gst_bus_post (self->bus, gst_message_new_application (NULL, + gst_structure_new_empty (ABORT))); +} + +static gboolean +send_shutdown (GstAppendPipeline * self) +{ + return gst_bus_post (self->bus, gst_message_new_application (NULL, + gst_structure_new_empty (SHUTDOWN))); +} + +static GstEvent * +new_end_of_append_event (void) +{ + GstStructure *structure = gst_structure_new_empty (END_OF_APPEND); + return gst_event_new_custom (GST_EVENT_CUSTOM_DOWNSTREAM, structure); +} + +static gboolean +is_end_of_append_event (GstEvent * event) +{ + return GST_EVENT_TYPE (event) == GST_EVENT_CUSTOM_DOWNSTREAM + && gst_event_has_name (event, END_OF_APPEND); +} + +static inline guint +n_tracks (GstAppendPipeline * self) +{ + return self->tracks->len; +} + +static inline Track * +index_track (GstAppendPipeline * self, guint i) +{ + return &g_array_index (self->tracks, Track, i); +} + +static inline void +call_parse_error (GstAppendPipeline * self) +{ + GstAppendPipelineCallbacks *callbacks = &self->callbacks.callbacks; + gpointer user_data = self->callbacks.user_data; + + if (callbacks->error) { + callbacks->error (self, user_data); + GST_TRACE_OBJECT (self, "done"); + } else { + GST_TRACE_OBJECT (self, "dropping"); + } +} + +static inline void +call_received_init_segment (GstAppendPipeline * self) +{ + GstAppendPipelineCallbacks *callbacks = &self->callbacks.callbacks; + gpointer user_data = self->callbacks.user_data; + + if (callbacks->received_init_segment) { + callbacks->received_init_segment (self, user_data); + GST_TRACE_OBJECT (self, "done"); + } else { + GST_TRACE_OBJECT (self, "dropping"); + } +} + +static inline void +call_new_sample (GstAppendPipeline * self, GstMediaSourceTrack * track, + GstSample * sample) +{ + GstAppendPipelineCallbacks *callbacks = &self->callbacks.callbacks; + gpointer user_data = self->callbacks.user_data; + + if (callbacks->new_sample) { + callbacks->new_sample (self, track, sample, user_data); + GST_TRACE_OBJECT (self, "done"); + } else { + GST_TRACE_OBJECT (self, "dropping"); + } +} + +static inline void +call_duration_changed (GstAppendPipeline * self) +{ + GstAppendPipelineCallbacks *callbacks = &self->callbacks.callbacks; + gpointer user_data = self->callbacks.user_data; + + if (callbacks->duration_changed) { + callbacks->duration_changed (self, user_data); + GST_TRACE_OBJECT (self, "done"); + } else { + GST_TRACE_OBJECT (self, "dropping"); + } +} + +static inline void +call_eos (GstAppendPipeline * self, GstMediaSourceTrack * track) +{ + GstAppendPipelineCallbacks *callbacks = &self->callbacks.callbacks; + gpointer user_data = self->callbacks.user_data; + + if (callbacks->eos) { + callbacks->eos (self, track, user_data); + GST_TRACE_OBJECT (self, "done"); + } else { + GST_TRACE_OBJECT (self, "dropping"); + } +} + +static inline GstSample * +patch_missing_duration (GstAppendPipeline * self, GstSample * sample) +{ + GstBuffer *buffer = gst_sample_get_buffer (sample); + if (!GST_BUFFER_DURATION_IS_VALID (buffer)) { + GST_BUFFER_DURATION (buffer) = GST_SECOND / 60; + GST_TRACE_OBJECT (self, "sample is missing duration, patched to %" + GST_TIMEP_FORMAT, &buffer->duration); + } + return sample; +} + +static inline GstSample * +patch_missing_pts (GstAppendPipeline * self, GstSample * sample, GstClockTime + fallback) +{ + GstBuffer *buffer = gst_sample_get_buffer (sample); + if (!GST_BUFFER_PTS_IS_VALID (buffer) && GST_CLOCK_TIME_IS_VALID (fallback)) { + GST_TRACE_OBJECT (self, "sample is missing pts, patching with %" + GST_TIMEP_FORMAT, &fallback); + GST_BUFFER_PTS (buffer) = fallback; + } + return sample; +} + +static inline GstSample * +patch_missing_dts (GstAppendPipeline * self, GstSample * sample) +{ + GstBuffer *buffer = gst_sample_get_buffer (sample); + if (!GST_BUFFER_DTS_IS_VALID (buffer) && GST_BUFFER_PTS_IS_VALID (buffer)) { + GST_TRACE_OBJECT (self, "sample is missing dts, patching with pts %" + GST_TIMEP_FORMAT, &buffer->pts); + GST_BUFFER_DTS (buffer) = GST_BUFFER_PTS (buffer); + } + return sample; +} + +static gboolean +consume_sample_from_track (GstAppendPipeline * self, Track * track) +{ + GstSample *sample = gst_app_sink_try_pull_sample (track->sink, 0); + if (sample == NULL) { + return FALSE; + } + GstBuffer *buffer = gst_sample_get_buffer (sample); + if (!GST_IS_BUFFER (buffer)) { + GST_WARNING_OBJECT (self, "got null buffer in sample"); + goto done; + } + sample = patch_missing_pts (self, sample, track->previous_pts); + sample = patch_missing_duration (self, sample); + sample = patch_missing_dts (self, sample); + track->previous_pts = GST_BUFFER_PTS (buffer); + call_new_sample (self, track->mse_track, sample); + +done: + gst_clear_sample (&sample); + return TRUE; +} + +static void +consume_all_samples (GstAppendPipeline * self) +{ + if (!self->received_init_segment) { + GST_DEBUG_OBJECT (self, "not all tracks are available, delaying"); + self->have_outstanding_samples = TRUE; + return; + } + guint track_count = n_tracks (self); + while (TRUE) { + gboolean sample_consumed = FALSE; + for (guint i = 0; i < track_count; i++) { + Track *track = index_track (self, i); + sample_consumed |= consume_sample_from_track (self, track); + } + if (!sample_consumed) { + break; + } + } + call_duration_changed (self); + self->have_outstanding_samples = FALSE; +} + +static void +handle_shutdown (BackgroundTask * task) +{ + gst_task_stop (task->task); + GstAppendPipeline *self = task->pipeline; + guint track_count = n_tracks (self); + for (guint i = 0; i < track_count; i++) { + Track *track = index_track (self, i); + call_eos (self, track->mse_track); + } + call_eos (self, NULL); +} + +static void +handle_abort (BackgroundTask * task) +{ + gst_task_stop (task->task); +} + +static void +task_function (gpointer user_data) +{ + BackgroundTask *task = (BackgroundTask *) user_data; + GstAppendPipeline *self = task->pipeline; + GstMessage *message = gst_bus_timed_pop (task->bus, GST_CLOCK_TIME_NONE); + switch (GST_MESSAGE_TYPE (message)) { + case GST_MESSAGE_APPLICATION:{ + if (gst_message_has_name (message, END_OF_APPEND)) { + GST_TRACE_OBJECT (self, "end of append"); + consume_all_samples (self); + goto done; + } + if (gst_message_has_name (message, SHUTDOWN)) { + GST_DEBUG_OBJECT (self, "shutdown"); + handle_shutdown (task); + goto done; + } + if (gst_message_has_name (message, ABORT)) { + GST_DEBUG_OBJECT (self, "abort"); + handle_abort (task); + goto done; + } + g_error ("received unsupported application message"); + } + case GST_MESSAGE_STREAM_COLLECTION:{ + GST_DEBUG_OBJECT (self, "stream collection"); + GstStreamCollection *streams; + gst_message_parse_stream_collection (message, &streams); + gst_clear_object (&self->streams); + self->streams = streams; + process_init_segment (self); + goto done; + } + case GST_MESSAGE_EOS: + GST_DEBUG_OBJECT (self, "end of stream"); + if (self->have_outstanding_samples) { + GST_DEBUG_OBJECT (self, "consuming remaining samples before EOS"); + consume_all_samples (self); + } + handle_shutdown (task); + goto done; + case GST_MESSAGE_ERROR: + GST_DEBUG_OBJECT (self, "error: %" GST_PTR_FORMAT, message); + self->encountered_error = TRUE; + call_parse_error (self); + handle_shutdown (task); + goto done; + default: + GST_TRACE_OBJECT (self, "ignoring message %" GST_PTR_FORMAT, message); + goto done; + } +done: + gst_message_unref (message); +} + +static inline GstAppSink * +new_appsink (GstAppendPipeline * self, GstStreamType type) +{ + const gchar *type_name = gst_stream_type_get_name (type); + gchar *name = g_strdup_printf ("%s-%u", type_name, n_tracks (self)); + GstAppSink *appsink = + GST_APP_SINK (gst_element_factory_make ("appsink", name)); + gst_base_sink_set_sync (GST_BASE_SINK (appsink), FALSE); + gst_base_sink_set_async_enabled (GST_BASE_SINK (appsink), FALSE); + gst_base_sink_set_drop_out_of_segment (GST_BASE_SINK (appsink), FALSE); + gst_base_sink_set_last_sample_enabled (GST_BASE_SINK (appsink), FALSE); + g_free (name); + return appsink; +} + +static GstPadProbeReturn +black_hole_probe (GstPad * pad, GstPadProbeInfo * info, gpointer user_data) +{ + g_return_val_if_fail (GST_PAD_PROBE_INFO_TYPE (info) & + GST_PAD_PROBE_TYPE_BUFFER, GST_PAD_PROBE_DROP); + return GST_PAD_PROBE_DROP; +} + +static GstPadProbeReturn +event_probe (GstPad * pad, GstPadProbeInfo * info, gpointer user_data) +{ + GstAppendPipeline *self = GST_APPEND_PIPELINE (user_data); + GstEvent *event = GST_PAD_PROBE_INFO_EVENT (info); + + if (is_end_of_append_event (event)) { + GST_TRACE_OBJECT (self, "end of append event"); + if (gst_bus_post (self->bus, gst_message_new_application (NULL, + gst_structure_new_empty (END_OF_APPEND)))) { + return GST_PAD_PROBE_DROP; + } else { + GST_ERROR_OBJECT (self, "failed to post end of append"); + goto error; + } + } + + if (GST_EVENT_TYPE (event) == GST_EVENT_EOS) { + GST_DEBUG_OBJECT (self, "eos event"); + if (send_shutdown (self)) { + return GST_PAD_PROBE_OK; + } else { + GST_ERROR_OBJECT (self, "failed to post shutdown"); + goto error; + } + } + + return GST_PAD_PROBE_OK; + +error: + GST_PAD_PROBE_INFO_FLOW_RETURN (info) = GST_FLOW_ERROR; + gst_event_unref (event); + return GST_PAD_PROBE_HANDLED; +} + +static AddTrackResult +add_track (GstAppendPipeline * self, GstPad * pad, GstStream * stream, + GstCaps * caps, Track * added_track) +{ + GstStreamType type = gst_stream_get_stream_type (stream); + GstMediaSourceTrackType track_type = + gst_media_source_track_type_from_stream_type (type); + + switch (type) { + case GST_STREAM_TYPE_AUDIO: + case GST_STREAM_TYPE_TEXT: + case GST_STREAM_TYPE_VIDEO: + break; + default:{ + GST_DEBUG_OBJECT (self, "unexpected caps %" GST_PTR_FORMAT + ", using black hole probe", caps); + gst_pad_add_probe (pad, GST_PAD_PROBE_TYPE_BUFFER, black_hole_probe, self, + NULL); + return IGNORED; + } + } + + if (type != GST_STREAM_TYPE_TEXT && + !gst_media_source_media_type_is_caps_supported (caps)) { + GST_ERROR_OBJECT (self, "unsupported caps: %" GST_PTR_FORMAT, caps); + return PARSE_ERROR; + } + + GstAppSink *appsink = new_appsink (self, type); + gst_bin_add (GST_BIN (self->pipeline), GST_ELEMENT (appsink)); + gst_element_sync_state_with_parent (GST_ELEMENT (appsink)); + + GstPad *appsink_pad = + gst_element_get_static_pad (GST_ELEMENT (appsink), "sink"); + GstPadLinkReturn link_result = gst_pad_link (pad, appsink_pad); + gst_clear_object (&appsink_pad); + if (GST_PAD_LINK_FAILED (link_result)) { + g_error ("failed to link parser to appsink: %s", + gst_pad_link_get_name (link_result)); + } + + Track track_template = { + .parent = self, + .sink = gst_object_ref (appsink), + .src_pad = gst_object_ref (pad), + .stream = gst_object_ref (stream), + .mse_track = gst_media_source_track_new_with_initial_caps (track_type, + GST_OBJECT_NAME (appsink), caps), + .previous_pts = GST_CLOCK_TIME_NONE, + }; + g_array_append_val (self->tracks, track_template); + + GST_TRACE_OBJECT (self, "added appsink %s to pad %s", + GST_OBJECT_NAME (appsink), GST_OBJECT_NAME (pad)); + + *added_track = track_template; + + return ADDED; +} + +static void +clear_track (Track * track) +{ + gst_clear_object (&track->sink); + gst_clear_object (&track->src_pad); + gst_clear_object (&track->mse_track); + gst_clear_object (&track->stream); +} + +static inline GPtrArray * +init_segment_tracks_for (InitSegment * self, GstStreamType type) +{ + switch (type) { + case GST_STREAM_TYPE_AUDIO: + return self->audio_tracks; + case GST_STREAM_TYPE_TEXT: + return self->text_tracks; + case GST_STREAM_TYPE_VIDEO: + return self->video_tracks; + default: + g_assert_not_reached (); + return NULL; + } +} + +static void +process_init_segment_track (GstPad * pad, GstAppendPipeline * self) +{ + GST_OBJECT_LOCK (self); + InitSegment *init_segment = &self->init_segment; + GstStream *stream = gst_pad_get_stream (pad); + GstCaps *caps = gst_stream_get_caps (stream); + GST_DEBUG_OBJECT (self, "%" GST_PTR_FORMAT " got caps %" GST_PTR_FORMAT, pad, + caps); + + if (gst_pad_is_linked (pad)) { + GST_TRACE_OBJECT (self, "%" GST_PTR_FORMAT " is already linked, skipping", + pad); + goto done; + } + + if (!GST_IS_CAPS (caps)) { + GST_ERROR_OBJECT (self, "no caps on %" GST_PTR_FORMAT + " after stream collection", pad); + call_parse_error (self); + goto done; + } + + Track track; + AddTrackResult result = add_track (self, pad, stream, caps, &track); + GstMediaSourceTrack *mse_track = track.mse_track; + switch (result) { + case ADDED:{ + GstStreamType type = gst_stream_get_stream_type (stream); + GPtrArray *tracks = init_segment_tracks_for (init_segment, type); + if (tracks->len < 1) { + gst_media_source_track_set_active (mse_track, TRUE); + } + g_ptr_array_add (tracks, gst_object_ref (mse_track)); + break; + } + case IGNORED: + break; + case PARSE_ERROR: + call_parse_error (self); + break; + } + +done: + gst_clear_object (&stream); + gst_clear_caps (&caps); + GST_OBJECT_UNLOCK (self); +} + +static void +on_pad_added (GstElement * parsebin, GstPad * pad, gpointer user_data) +{ + GstAppendPipeline *self = GST_APPEND_PIPELINE (user_data); + process_init_segment_track (pad, self); + process_init_segment (self); +} + +static gboolean +has_track_for_stream (GstAppendPipeline * self, GstStream * stream) +{ + guint track_count = n_tracks (self); + for (guint i = 0; i < track_count; i++) { + Track *track = index_track (self, i); + if (track->stream == stream) { + return TRUE; + } + } + return FALSE; +} + +static gboolean +has_all_tracks (GstAppendPipeline * self) +{ + if (!GST_IS_STREAM_COLLECTION (self->streams)) { + return FALSE; + } + for (guint i = 0; i < gst_stream_collection_get_size (self->streams); i++) { + GstStream *stream = gst_stream_collection_get_stream (self->streams, i); + switch (gst_stream_get_stream_type (stream)) { + case GST_STREAM_TYPE_AUDIO: + case GST_STREAM_TYPE_VIDEO: + case GST_STREAM_TYPE_TEXT: + break; + default: + continue; + } + if (!has_track_for_stream (self, stream)) { + return FALSE; + } + } + return TRUE; +} + +static void +process_init_segment (GstAppendPipeline * self) +{ + gint64 duration; + InitSegment *init_segment = &self->init_segment; + + GST_OBJECT_LOCK (self); + + if (!has_all_tracks (self)) { + goto done; + } + + if (gst_element_query_duration (self->parsebin, GST_FORMAT_TIME, &duration)) { + init_segment->duration = MAX (0, duration); + } else { + init_segment->duration = GST_CLOCK_TIME_NONE; + } + + GST_DEBUG_OBJECT (self, "init segment says duration=%" GST_TIME_FORMAT, + GST_TIME_ARGS ((GstClockTime) duration)); + + self->received_init_segment = TRUE; + + call_received_init_segment (self); + +done: + GST_OBJECT_UNLOCK (self); +} + +static inline void +init_segment_init (InitSegment * self) +{ + self->audio_tracks = g_ptr_array_new_with_free_func (gst_object_unref); + self->text_tracks = g_ptr_array_new_with_free_func (gst_object_unref); + self->video_tracks = g_ptr_array_new_with_free_func (gst_object_unref); + self->duration = GST_CLOCK_TIME_NONE; +} + +static inline void +init_segment_finalize (InitSegment * self) +{ + g_ptr_array_free (self->audio_tracks, TRUE); + g_ptr_array_free (self->text_tracks, TRUE); + g_ptr_array_free (self->video_tracks, TRUE); +} + +static GArray * +new_tracks_array (void) +{ + GArray *tracks = g_array_new (TRUE, TRUE, sizeof (Track)); + g_array_set_clear_func (tracks, (GDestroyNotify) clear_track); + return tracks; +} + +static BackgroundTask * +background_task_new (GstAppendPipeline * pipeline) +{ + BackgroundTask *task = g_new0 (BackgroundTask, 1); + g_rec_mutex_init (&task->mutex); + task->task = gst_task_new (task_function, task, NULL); + task->pipeline = pipeline; + task->bus = gst_object_ref (pipeline->bus); + gst_task_set_lock (task->task, &task->mutex); + return task; +} + +static gboolean +background_task_start (BackgroundTask * task) +{ + gst_bus_set_flushing (task->bus, FALSE); + return gst_task_start (task->task); +} + +static gboolean +background_task_stop (BackgroundTask * task) +{ + send_abort (task->pipeline); + gst_task_join (task->task); + gst_bus_set_flushing (task->bus, TRUE); + return TRUE; +} + +static void +background_task_cleanup (gpointer ptr) +{ + BackgroundTask *task = (BackgroundTask *) ptr; + background_task_stop (task); + task->pipeline = NULL; + gst_clear_object (&task->task); + gst_clear_object (&task->bus); + g_rec_mutex_clear (&task->mutex); + g_free (task); +} + +static void +gst_append_pipeline_init (GstAppendPipeline * self) +{ + GstElement *appsrc = GST_ELEMENT (gst_element_factory_make ("appsrc", "src")); + GstElement *parsebin = + GST_ELEMENT (gst_element_factory_make ("parsebin", "parse")); + GstElement *pipeline = gst_pipeline_new ("append-pipeline"); + + GstPad *appsrc_pad = GST_PAD (gst_element_get_static_pad (appsrc, "src")); + gst_pad_add_probe (appsrc_pad, GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM, + event_probe, self, NULL); + gst_object_unref (appsrc_pad); + + gst_bin_add_many (GST_BIN (pipeline), appsrc, parsebin, NULL); + if (!gst_element_link (appsrc, parsebin)) { + g_error ("failed to link appsrc to parsebin"); + } + + self->bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline)); + self->pipeline = gst_object_ref_sink (GST_PIPELINE (pipeline)); + self->src = GST_APP_SRC (appsrc); + self->parsebin = parsebin; + + self->task = background_task_new (self); + + g_signal_connect_object (parsebin, "pad-added", G_CALLBACK (on_pad_added), + self, 0); + + self->received_init_segment = FALSE; + self->encountered_error = FALSE; + self->tracks = new_tracks_array (); + init_segment_init (&self->init_segment); +} + +static void +gst_append_pipeline_dispose (GObject * object) +{ + GstAppendPipeline *self = (GstAppendPipeline *) object; + + send_shutdown (self); + g_clear_pointer (&self->task, background_task_cleanup); + + gst_element_set_state (GST_ELEMENT (self->pipeline), GST_STATE_NULL); + + G_OBJECT_CLASS (gst_append_pipeline_parent_class)->dispose (object); +} + +static void +gst_append_pipeline_finalize (GObject * object) +{ + GstAppendPipeline *self = (GstAppendPipeline *) object; + + gst_clear_object (&self->pipeline); + gst_clear_object (&self->bus); + + init_segment_finalize (&self->init_segment); + + g_array_free (self->tracks, TRUE); + gst_clear_object (&self->streams); + + G_OBJECT_CLASS (gst_append_pipeline_parent_class)->finalize (object); +} + +static void +gst_append_pipeline_class_init (GstAppendPipelineClass * klass) +{ + GObjectClass *oclass = G_OBJECT_CLASS (klass); + + oclass->dispose = GST_DEBUG_FUNCPTR (gst_append_pipeline_dispose); + oclass->finalize = GST_DEBUG_FUNCPTR (gst_append_pipeline_finalize); +} + +GstAppendPipeline * +gst_append_pipeline_new (GstAppendPipelineCallbacks * callbacks, + gpointer user_data, GError ** error) +{ + gst_mse_init_logging (); + GstAppendPipeline *self = g_object_new (GST_TYPE_APPEND_PIPELINE, NULL); + GstStateChangeReturn started = + gst_element_set_state (GST_ELEMENT (self->pipeline), GST_STATE_PLAYING); + if (started != GST_STATE_CHANGE_SUCCESS) { + GST_ERROR_OBJECT (self, "failed to start: %s", + gst_element_state_change_return_get_name (started)); + g_set_error (error, + GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_INVALID_STATE, + "failed to start append pipeline"); + goto error; + } + if (callbacks) { + self->callbacks.callbacks = *callbacks; + self->callbacks.user_data = user_data; + } + if (!background_task_start (self->task)) { + GST_ERROR_OBJECT (self, "failed to start background task"); + g_set_error (error, + GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_INVALID_STATE, + "failed to start append pipeline's background task"); + goto error; + } + return gst_object_ref_sink (self); +error: + gst_clear_object (&self); + return NULL; +} + +GstFlowReturn +gst_append_pipeline_append (GstAppendPipeline * self, GstBuffer * buffer) +{ + g_return_val_if_fail (GST_IS_APPEND_PIPELINE (self), GST_FLOW_ERROR); + GstFlowReturn push_result = gst_app_src_push_buffer (self->src, buffer); + if (push_result != GST_FLOW_OK) + return push_result; + + if (!gst_element_send_event (GST_ELEMENT_CAST (self->src), + new_end_of_append_event ())) { + GST_ERROR_OBJECT (self, "failed to push end-of-append event"); + return GST_FLOW_ERROR; + } + return GST_FLOW_OK; +} + +GstFlowReturn +gst_append_pipeline_eos (GstAppendPipeline * self) +{ + g_return_val_if_fail (GST_IS_APPEND_PIPELINE (self), GST_FLOW_ERROR); + return gst_app_src_end_of_stream (self->src); +} + +gboolean +gst_append_pipeline_stop (GstAppendPipeline * self) +{ + g_return_val_if_fail (GST_IS_APPEND_PIPELINE (self), FALSE); + + GstElement *pipeline = GST_ELEMENT (self->pipeline); + + GstStateChangeReturn stopped = + gst_element_set_state (pipeline, GST_STATE_NULL); + if (stopped != GST_STATE_CHANGE_SUCCESS) { + GST_ERROR_OBJECT (self, "failed to stop: %s", + gst_element_state_change_return_get_name (stopped)); + return FALSE; + } + self->received_init_segment = FALSE; + self->encountered_error = FALSE; + + return TRUE; +} + +gboolean +gst_append_pipeline_reset (GstAppendPipeline * self) +{ + g_return_val_if_fail (GST_IS_APPEND_PIPELINE (self), FALSE); + + GstElement *pipeline = GST_ELEMENT (self->pipeline); + + GstStateChangeReturn stopped = + gst_element_set_state (pipeline, GST_STATE_READY); + if (stopped != GST_STATE_CHANGE_SUCCESS) { + GST_ERROR_OBJECT (self, "failed to stop: %s", + gst_element_state_change_return_get_name (stopped)); + return FALSE; + } + + background_task_stop (self->task); + + init_segment_finalize (&self->init_segment); + gst_clear_object (&self->streams); + g_array_free (self->tracks, TRUE); + + self->received_init_segment = FALSE; + self->have_outstanding_samples = FALSE; + self->encountered_error = FALSE; + self->tracks = new_tracks_array (); + init_segment_init (&self->init_segment); + + if (!background_task_start (self->task)) { + GST_ERROR_OBJECT (self, "failed to start background task"); + return FALSE; + } + + GstStateChangeReturn started = + gst_element_set_state (pipeline, GST_STATE_PLAYING); + if (started == GST_STATE_CHANGE_SUCCESS) { + return TRUE; + } else { + GST_ERROR_OBJECT (self, "failed to start: %s", + gst_element_state_change_return_get_name (started)); + return FALSE; + } +} + +gsize +gst_append_pipeline_n_tracks (GstAppendPipeline * self) +{ + g_return_val_if_fail (GST_IS_APPEND_PIPELINE (self), 0); + return n_tracks (self); +} + +gboolean +gst_append_pipeline_has_init_segment (GstAppendPipeline * self) +{ + g_return_val_if_fail (GST_IS_APPEND_PIPELINE (self), FALSE); + return self->received_init_segment; +} + +GstClockTime +gst_append_pipeline_get_duration (GstAppendPipeline * self) +{ + g_return_val_if_fail (GST_IS_APPEND_PIPELINE (self), GST_CLOCK_TIME_NONE); + if (self->received_init_segment) { + return self->init_segment.duration; + } else { + return GST_CLOCK_TIME_NONE; + } +} + +GPtrArray * +gst_append_pipeline_get_audio_tracks (GstAppendPipeline * self) +{ + g_return_val_if_fail (GST_IS_APPEND_PIPELINE (self), NULL); + if (self->received_init_segment) { + return self->init_segment.audio_tracks; + } else { + return NULL; + } +} + +GPtrArray * +gst_append_pipeline_get_text_tracks (GstAppendPipeline * self) +{ + g_return_val_if_fail (GST_IS_APPEND_PIPELINE (self), NULL); + if (self->received_init_segment) { + return self->init_segment.text_tracks; + } else { + return NULL; + } +} + +GPtrArray * +gst_append_pipeline_get_video_tracks (GstAppendPipeline * self) +{ + g_return_val_if_fail (GST_IS_APPEND_PIPELINE (self), NULL); + if (self->received_init_segment) { + return self->init_segment.video_tracks; + } else { + return NULL; + } +} + +gboolean +gst_append_pipeline_get_eos (GstAppendPipeline * self) +{ + g_return_val_if_fail (GST_IS_APPEND_PIPELINE (self), FALSE); + return gst_task_get_state (self->task->task) != GST_TASK_STARTED; +} + +void +gst_append_pipeline_fail (GstAppendPipeline * self) +{ + g_return_if_fail (GST_IS_APPEND_PIPELINE (self)); + gst_bus_post (self->bus, gst_message_new_error (NULL, NULL, NULL)); +} + +gboolean +gst_append_pipeline_get_failed (GstAppendPipeline * self) +{ + g_return_val_if_fail (GST_IS_APPEND_PIPELINE (self), FALSE); + return self->encountered_error; +} diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasource-private.h b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasource-private.h new file mode 100644 index 0000000000..0b4e1d08cf --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasource-private.h @@ -0,0 +1,58 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2022, 2023 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#pragma once + +#include "gstmediasource.h" +#include "gstmseeventqueue-private.h" + +G_BEGIN_DECLS + +GST_MSE_PRIVATE +gboolean gst_media_source_is_attached (GstMediaSource * self); + +GST_MSE_PRIVATE +void gst_media_source_open (GstMediaSource * self); + +GST_MSE_PRIVATE +GstMseSrc * gst_media_source_get_source_element (GstMediaSource * self); + +GST_MSE_PRIVATE +void gst_media_source_seek (GstMediaSource * self, GstClockTime time); + +struct _GstMediaSource +{ + GstObject parent_instance; + + GstMseSrc *element; + GstMseEventQueue *event_queue; + + GstSourceBufferList *buffers; + GstSourceBufferList *active_buffers; + + GstMediaSourceRange live_seekable_range; + + GstClockTime duration; + GstMediaSourceReadyState ready_state; +}; + +G_END_DECLS diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasource.c b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasource.c new file mode 100644 index 0000000000..f499f54f24 --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasource.c @@ -0,0 +1,1063 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2013 Google Inc. All rights reserved. + * Copyright (C) 2013 Orange + * Copyright (C) 2013-2017 Apple Inc. All rights reserved. + * Copyright (C) 2014 Sebastian Dröge + * Copyright (C) 2015, 2016 Igalia, S.L + * Copyright (C) 2015, 2016 Metrological Group B.V. + * Copyright (C) 2022, 2023 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +/** + * SECTION:gstmediasource + * @title: GstMediaSource + * @short_description: Media Source + * @symbols: + * - GstMediaSource + * + * #GstMediaSource is the entry point into the W3C Media Source API. It offers + * functionality similar to #GstAppSrc for client-side web or JavaScript + * applications decoupling the source of media from its processing and playback. + * + * To interact with a Media Source, connect it to a #GstMseSrc that is in some + * #GstPipeline using gst_media_source_attach(). Then create at least one + * #GstSourceBuffer using gst_media_source_add_source_buffer(). Finally, feed + * some media data to the Source Buffer(s) using + * gst_source_buffer_append_buffer() and play the pipeline. + * + * Since: 1.24 + */ + +/** + * GstMediaSource: + * Since: 1.24 + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include +#include "gstmediasource.h" +#include "gstmediasource-private.h" + +#include "gstmselogging-private.h" +#include "gstmsemediatype-private.h" +#include "gstsourcebuffer-private.h" +#include "gstsourcebufferlist-private.h" + +#include "gstmsesrc.h" +#include "gstmsesrc-private.h" + +G_DEFINE_TYPE (GstMediaSource, gst_media_source, GST_TYPE_OBJECT); +G_DEFINE_QUARK (gst_media_source_error_quark, gst_media_source_error); + +enum +{ + PROP_0, + + PROP_SOURCE_BUFFERS, + PROP_ACTIVE_SOURCE_BUFFERS, + PROP_READY_STATE, + PROP_POSITION, + PROP_DURATION, + + N_PROPS, +}; + +typedef enum +{ + ON_SOURCE_OPEN, + ON_SOURCE_ENDED, + ON_SOURCE_CLOSE, + + N_SIGNALS, +} MediaSourceEvent; + +typedef struct +{ + GstDataQueueItem item; + MediaSourceEvent event; +} MediaSourceEventItem; + +static GParamSpec *properties[N_PROPS]; +static guint signals[N_SIGNALS]; + +#define DEFAULT_READY_STATE GST_MEDIA_SOURCE_READY_STATE_CLOSED +#define DEFAULT_POSITION GST_CLOCK_TIME_NONE +#define DEFAULT_DURATION GST_CLOCK_TIME_NONE + +static void rebuild_active_source_buffers (GstMediaSource * self); + +/** + * gst_media_source_is_type_supported: + * @type: (transfer none): A MIME type value + * + * Determines whether the current Media Source configuration can process media + * of the supplied @type. + * + * Returns: `TRUE` when supported, `FALSE` otherwise + * + * Since: 1.24 + */ +gboolean +gst_media_source_is_type_supported (const gchar * type) +{ + gst_mse_init_logging (); + g_return_val_if_fail (type != NULL, FALSE); + + if (g_strcmp0 (type, "") == 0) { + return FALSE; + } + + GstMediaSourceMediaType media_type = GST_MEDIA_SOURCE_MEDIA_TYPE_INIT; + if (!gst_media_source_media_type_parse (&media_type, type)) { + return FALSE; + } + + gboolean supported = gst_media_source_media_type_is_supported (&media_type); + + gst_media_source_media_type_reset (&media_type); + + return supported; +} + +/** + * gst_media_source_new: + * + * Creates a new #GstMediaSource instance. The instance is in the + * %GST_MEDIA_SOURCE_READY_STATE_CLOSED state and is not associated with any + * media player. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-constructor) + * + * Returns: (transfer full): a new #GstMediaSource instance + * Since: 1.24 + */ +GstMediaSource * +gst_media_source_new (void) +{ + gst_mse_init_logging (); + return g_object_ref_sink (g_object_new (GST_TYPE_MEDIA_SOURCE, NULL)); +} + +static inline void +empty_buffers (GstMediaSource * self) +{ + for (guint i = 0;; i++) { + GstSourceBuffer *buf = gst_source_buffer_list_index (self->buffers, i); + if (buf == NULL) { + break; + } + gst_object_unparent (GST_OBJECT_CAST (buf)); + gst_object_unref (buf); + } + gst_source_buffer_list_remove_all (self->buffers); +} + +static void +gst_media_source_dispose (GObject * object) +{ + GstMediaSource *self = (GstMediaSource *) object; + + gst_media_source_detach (self); + + g_clear_object (&self->active_buffers); + + if (self->buffers) { + empty_buffers (self); + } + gst_clear_object (&self->buffers); + + gst_clear_object (&self->event_queue); + + G_OBJECT_CLASS (gst_media_source_parent_class)->dispose (object); +} + +static void +gst_media_source_get_property (GObject * object, guint prop_id, GValue * value, + GParamSpec * pspec) +{ + GstMediaSource *self = GST_MEDIA_SOURCE (object); + + switch (prop_id) { + case PROP_SOURCE_BUFFERS: + g_value_take_object (value, gst_media_source_get_source_buffers (self)); + break; + case PROP_ACTIVE_SOURCE_BUFFERS: + g_value_take_object (value, + gst_media_source_get_active_source_buffers (self)); + break; + case PROP_READY_STATE: + g_value_set_enum (value, gst_media_source_get_ready_state (self)); + break; + case PROP_POSITION: + g_value_set_uint64 (value, gst_media_source_get_position (self)); + break; + case PROP_DURATION: + g_value_set_uint64 (value, gst_media_source_get_duration (self)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + } +} + +static void +gst_media_source_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec) +{ + GstMediaSource *self = GST_MEDIA_SOURCE (object); + + switch (prop_id) { + case PROP_DURATION:{ + GstClockTime duration = (GstClockTime) g_value_get_uint64 (value); + gst_media_source_set_duration (self, duration, NULL); + break; + } + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + } +} + +static void +gst_media_source_class_init (GstMediaSourceClass * klass) +{ + GObjectClass *oclass = G_OBJECT_CLASS (klass); + + oclass->dispose = GST_DEBUG_FUNCPTR (gst_media_source_dispose); + oclass->get_property = GST_DEBUG_FUNCPTR (gst_media_source_get_property); + oclass->set_property = GST_DEBUG_FUNCPTR (gst_media_source_set_property); + + /** + * GstMediaSource:source-buffers: + * + * A #GstSourceBufferList of every #GstSourceBuffer in this Media Source + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-sourcebuffers) + * + * Since: 1.24 + */ + properties[PROP_SOURCE_BUFFERS] = g_param_spec_object ("source-buffers", + "Source Buffers", + "A SourceBufferList of all SourceBuffers in this Media Source", + GST_TYPE_SOURCE_BUFFER_LIST, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); + + /** + * GstMediaSource:active-source-buffers: + * + * A #GstSourceBufferList of every #GstSourceBuffer in this Media Source that + * is considered active + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-activesourcebuffers) + * + * Since: 1.24 + */ + properties[PROP_ACTIVE_SOURCE_BUFFERS] = + g_param_spec_object ("active-source-buffers", "Active Source Buffers", + "A SourceBufferList of all SourceBuffers that are active in this Media Source", + GST_TYPE_SOURCE_BUFFER_LIST, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); + + /** + * GstMediaSource:ready-state: + * + * The Ready State of the Media Source + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-readystate) + * + * Since: 1.24 + */ + properties[PROP_READY_STATE] = g_param_spec_enum ("ready-state", + "Ready State", + "The Ready State of the Media Source", + GST_TYPE_MEDIA_SOURCE_READY_STATE, DEFAULT_READY_STATE, G_PARAM_READABLE | + G_PARAM_STATIC_STRINGS); + + /** + * GstMediaSource:position: + * + * The position of the player consuming from the Media Source + * + * Since: 1.24 + */ + properties[PROP_POSITION] = g_param_spec_uint64 ("position", + "Position", + "The Position of the Media Source as a GstClockTime", + GST_CLOCK_TIME_NONE, G_MAXUINT64, DEFAULT_DURATION, G_PARAM_READWRITE | + G_PARAM_STATIC_STRINGS); + + /** + * GstMediaSource:duration: + * + * The Duration of the Media Source as a #GstClockTime + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-duration) + * + * Since: 1.24 + */ + properties[PROP_DURATION] = g_param_spec_uint64 ("duration", + "Duration", + "The Duration of the Media Source as a GstClockTime", + GST_CLOCK_TIME_NONE, G_MAXUINT64, DEFAULT_DURATION, G_PARAM_READWRITE | + G_PARAM_STATIC_STRINGS); + + g_object_class_install_properties (oclass, N_PROPS, properties); + + /** + * GstMediaSource::on-source-open: + * @self: The #GstMediaSource that has just opened + * + * Emitted when @self has been opened. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-onsourceopen) + * + * Since: 1.24 + */ + signals[ON_SOURCE_OPEN] = g_signal_new ("on-source-open", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0); + + /** + * GstMediaSource::on-source-ended: + * @self: The #GstMediaSource that has just ended + * + * Emitted when @self has ended, normally through + * gst_media_source_end_of_stream(). + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-onsourceended) + * + * Since: 1.24 + */ + signals[ON_SOURCE_ENDED] = g_signal_new ("on-source-ended", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0); + + /** + * GstMediaSource::on-source-closed: + * @self: The #GstMediaSource that has just closed + * + * Emitted when @self has closed, normally when detached from a #GstMseSrc. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-onsourceclose) + * + * Since: 1.24 + */ + signals[ON_SOURCE_CLOSE] = g_signal_new ("on-source-close", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0); + +} + +static inline void +reset_live_seekable_range (GstMediaSource * self) +{ + self->live_seekable_range.start = 0; + self->live_seekable_range.end = 0; +} + +static inline gboolean +is_updating (GstMediaSource * self) +{ + for (guint i = 0;; i++) { + GstSourceBuffer *buf = gst_source_buffer_list_index (self->buffers, i); + if (buf == NULL) + break; + gboolean updating = gst_source_buffer_get_updating (buf); + gst_object_unref (buf); + if (updating) { + return TRUE; + } + } + return FALSE; +} + +static inline gboolean +is_attached (GstMediaSource * self) +{ + return GST_IS_MSE_SRC (self->element); +} + +static inline void +network_error (GstMediaSource * self) +{ + if (is_attached (self)) { + gst_mse_src_network_error (self->element); + } +} + +static inline void +decode_error (GstMediaSource * self) +{ + if (is_attached (self)) { + gst_mse_src_decode_error (self->element); + } +} + +static inline void +update_duration (GstMediaSource * self) +{ + if (is_attached (self)) { + gst_mse_src_set_duration (self->element, self->duration); + } +} + +static void +schedule_event (GstMediaSource * self, MediaSourceEvent event) +{ + MediaSourceEventItem item = { + .item = {.destroy = g_free,.visible = TRUE,.size = 1,.object = NULL}, + .event = event, + }; + + gst_mse_event_queue_push (self->event_queue, g_memdup2 (&item, + sizeof (MediaSourceEventItem))); +} + +static void +dispatch_event (MediaSourceEventItem * item, GstMediaSource * self) +{ + g_signal_emit (self, signals[item->event], 0); +} + +static void +gst_media_source_init (GstMediaSource * self) +{ + self->buffers = gst_source_buffer_list_new (); + self->active_buffers = gst_source_buffer_list_new (); + self->ready_state = DEFAULT_READY_STATE; + self->duration = DEFAULT_DURATION; + reset_live_seekable_range (self); + self->element = NULL; + self->event_queue = + gst_mse_event_queue_new ((GstMseEventQueueCallback) dispatch_event, self); +} + +/** + * gst_media_source_attach: + * @self: #GstMediaSource instance + * @element: (transfer none): #GstMseSrc source Element + * + * Associates @self with @element. + * Normally, the Element will be part of a #GstPipeline that plays back the data + * submitted to the Media Source's Source Buffers. + * + * #GstMseSrc is a special source element that is designed to consume media from + * a #GstMediaSource. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dfn-attaching-to-a-media-element) + * + * Since: 1.24 + */ +void +gst_media_source_attach (GstMediaSource * self, GstMseSrc * element) +{ + g_return_if_fail (GST_IS_MEDIA_SOURCE (self)); + g_return_if_fail (GST_IS_MSE_SRC (element)); + + if (is_attached (self)) + gst_media_source_detach (self); + + self->element = gst_object_ref_sink (element); + gst_mse_src_attach (element, self); + + self->ready_state = GST_MEDIA_SOURCE_READY_STATE_OPEN; + schedule_event (self, ON_SOURCE_OPEN); +} + +/** + * gst_media_source_detach: + * @self: #GstMediaSource instance + * + * Detaches @self from any #GstMseSrc element that it may be associated with. + * + * Since: 1.24 + */ +void +gst_media_source_detach (GstMediaSource * self) +{ + g_return_if_fail (GST_IS_MEDIA_SOURCE (self)); + + self->ready_state = GST_MEDIA_SOURCE_READY_STATE_CLOSED; + gst_media_source_set_duration (self, GST_CLOCK_TIME_NONE, NULL); + + gst_source_buffer_list_remove_all (self->active_buffers); + empty_buffers (self); + + if (is_attached (self)) { + gst_mse_src_detach (self->element); + gst_clear_object (&self->element); + } + + schedule_event (self, ON_SOURCE_CLOSE); +} + +/** + * gst_media_source_get_source_element: + * @self: #GstMediaSource instance + * + * Gets the #GstMseSrc currently attached to @self or `NULL` if there is none. + * + * Returns: (transfer full) (nullable): a #GstMseSrc instance or `NULL` + */ +GstMseSrc * +gst_media_source_get_source_element (GstMediaSource * self) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE (self), NULL); + GST_OBJECT_LOCK (self); + GstMseSrc *element = self->element == NULL ? NULL + : gst_object_ref (self->element); + GST_OBJECT_UNLOCK (self); + return element; +} + +void +gst_media_source_open (GstMediaSource * self) +{ + g_return_if_fail (GST_IS_MEDIA_SOURCE (self)); + if (self->ready_state != GST_MEDIA_SOURCE_READY_STATE_OPEN) { + self->ready_state = GST_MEDIA_SOURCE_READY_STATE_OPEN; + schedule_event (self, ON_SOURCE_OPEN); + } +} + +/** + * gst_media_source_get_source_buffers: + * @self: #GstMediaSource instance + * + * Gets a #GstSourceBufferList containing all the Source Buffers currently + * associated with this Media Source. This object will reflect any future + * changes to the parent Media Source as well. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-sourcebuffers) + * + * Returns: (transfer full): a #GstSourceBufferList instance + * Since: 1.24 + */ +GstSourceBufferList * +gst_media_source_get_source_buffers (GstMediaSource * self) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE (self), NULL); + return g_object_ref (self->buffers); +} + +/** + * gst_media_source_get_active_source_buffers: + * @self: #GstMediaSource instance + * + * Gets a #GstSourceBufferList containing all the Source Buffers currently + * associated with this Media Source that are considered "active." + * For a Source Buffer to be considered active, either its video track is + * selected, its audio track is enabled, or its text track is visible or hidden. + * This object will reflect any future changes to the parent Media Source as + * well. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-activesourcebuffers) + * + * Returns: (transfer full): a new #GstSourceBufferList instance + * Since: 1.24 + */ +GstSourceBufferList * +gst_media_source_get_active_source_buffers (GstMediaSource * self) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE (self), NULL); + return g_object_ref (self->active_buffers); +} + +/** + * gst_media_source_get_ready_state: + * @self: #GstMediaSource instance + * + * Gets the current Ready State of the Media Source. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-readystate) + * + * Returns: the current #GstMediaSourceReadyState value + * Since: 1.24 + */ +GstMediaSourceReadyState +gst_media_source_get_ready_state (GstMediaSource * self) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE (self), DEFAULT_READY_STATE); + return self->ready_state; +} + +/** + * gst_media_source_get_position: + * @self: #GstMediaSource instance + * + * Gets the current playback position of the Media Source. + * + * Returns: the current playback position as a #GstClockTime + * Since: 1.24 + */ +GstClockTime +gst_media_source_get_position (GstMediaSource * self) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE (self), DEFAULT_POSITION); + if (is_attached (self)) + return gst_mse_src_get_position (self->element); + return DEFAULT_POSITION; +} + +/** + * gst_media_source_get_duration: + * @self: #GstMediaSource instance + * + * Gets the current duration of @self. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-duration) + * + * Returns: the current duration as a #GstClockTime + * Since: 1.24 + */ +GstClockTime +gst_media_source_get_duration (GstMediaSource * self) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE (self), DEFAULT_DURATION); + if (self->ready_state == GST_MEDIA_SOURCE_READY_STATE_CLOSED) + return GST_CLOCK_TIME_NONE; + return self->duration; +} + +/** + * gst_media_source_set_duration: + * @self: #GstMediaSource instance + * @duration: The new duration to apply to @self. + * @error: (out) (optional) (nullable) (transfer full): the resulting error or `NULL` + * + * Sets the duration of @self. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-duration) + * + * Returns: `TRUE` on success, `FALSE` otherwise + * Since: 1.24 + */ +gboolean +gst_media_source_set_duration (GstMediaSource * self, GstClockTime duration, + GError ** error) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE (self), FALSE); + self->duration = duration; + update_duration (self); + g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_DURATION]); + return TRUE; +} + +static void +on_received_init_segment (G_GNUC_UNUSED GstSourceBuffer * source_buffer, + gpointer user_data) +{ + GstMediaSource *self = GST_MEDIA_SOURCE (user_data); + if (!is_attached (self)) { + GST_DEBUG_OBJECT (self, "received init segment while detached, ignoring"); + return; + } + + GPtrArray *all_tracks = g_ptr_array_new (); + + for (guint i = 0;; i++) { + GstSourceBuffer *buf = gst_source_buffer_list_index (self->buffers, i); + if (buf == NULL) { + break; + } + GPtrArray *tracks = gst_source_buffer_get_all_tracks (buf); + g_ptr_array_extend (all_tracks, tracks, NULL, NULL); + g_ptr_array_unref (tracks); + gst_object_unref (buf); + } + + gst_mse_src_emit_streams (self->element, + (GstMediaSourceTrack **) all_tracks->pdata, all_tracks->len); + + g_ptr_array_unref (all_tracks); +} + +static void +on_duration_changed (G_GNUC_UNUSED GstSourceBuffer * source_buffer, + gpointer user_data) +{ + GstMediaSource *self = GST_MEDIA_SOURCE (user_data); + GstClockTime current = self->duration; + GstClockTime max = 0; + for (guint i = 0;; i++) { + GstSourceBuffer *buf = gst_source_buffer_list_index (self->buffers, i); + if (buf == NULL) { + break; + } + GstClockTime duration = gst_source_buffer_get_duration (buf); + if (GST_CLOCK_TIME_IS_VALID (duration)) { + max = MAX (max, duration); + } + gst_object_unref (buf); + } + if (current == max) { + return; + } + GST_DEBUG_OBJECT (self, "updating %" GST_TIMEP_FORMAT "=>%" GST_TIMEP_FORMAT, + ¤t, &max); + gst_media_source_set_duration (self, max, NULL); +} + +static GHashTable * +source_buffer_list_as_set (GstSourceBufferList * list) +{ + GHashTable *buffers = g_hash_table_new_full (g_direct_hash, g_direct_equal, + gst_object_unref, NULL); + for (guint i = 0;; i++) { + GstSourceBuffer *buf = gst_source_buffer_list_index (list, i); + if (buf == NULL) { + break; + } + g_hash_table_add (buffers, buf); + } + return buffers; +} + +static void +rebuild_active_source_buffers (GstMediaSource * self) +{ + // TODO: Lock the source buffer lists + GST_DEBUG_OBJECT (self, "rebuilding active source buffers"); + GHashTable *previously_active = + source_buffer_list_as_set (self->active_buffers); + + gst_source_buffer_list_notify_freeze (self->active_buffers); + gst_source_buffer_list_remove_all (self->active_buffers); + + gboolean added = FALSE; + gboolean removed = FALSE; + + for (guint i = 0;; i++) { + GstSourceBuffer *buf = gst_source_buffer_list_index (self->buffers, i); + if (buf == NULL) { + break; + } + if (gst_source_buffer_get_active (buf)) { + gst_source_buffer_list_append (self->active_buffers, buf); + added |= !g_hash_table_contains (previously_active, buf); + } else { + gst_source_buffer_list_append (self->active_buffers, buf); + removed |= g_hash_table_contains (previously_active, buf); + } + gst_object_unref (buf); + } + g_hash_table_unref (previously_active); + + gst_source_buffer_list_notify_cancel (self->active_buffers); + gst_source_buffer_list_notify_thaw (self->active_buffers); + + if (added) { + GST_DEBUG_OBJECT (self, "notifying active source buffer added"); + gst_source_buffer_list_notify_added (self->active_buffers); + } + if (removed) { + GST_DEBUG_OBJECT (self, "notifying active source buffer removed"); + gst_source_buffer_list_notify_removed (self->active_buffers); + } +} + +static void +on_active_state_changed (GstSourceBuffer * source_buffer, gpointer user_data) +{ + GstMediaSource *self = GST_MEDIA_SOURCE (user_data); + rebuild_active_source_buffers (self); +} + +/** + * gst_media_source_add_source_buffer: + * @self: #GstMediaSource instance + * @type: (transfer none): A MIME type describing the format of the incoming media + * @error: (out) (optional) (nullable) (transfer full): the resulting error or `NULL` + * + * Add a #GstSourceBuffer to this #GstMediaSource of the specified media type. + * The Media Source must be in the #GstMediaSourceReadyState %GST_MEDIA_SOURCE_READY_STATE_OPEN. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-addsourcebuffer) + * + * Returns: (transfer full): a new #GstSourceBuffer instance on success, otherwise `NULL` + * Since: 1.24 + */ +GstSourceBuffer * +gst_media_source_add_source_buffer (GstMediaSource * self, const gchar * type, + GError ** error) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE (self), NULL); + g_return_val_if_fail (type != NULL, NULL); + + if (g_strcmp0 (type, "") == 0) { + g_set_error (error, + GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_TYPE, + "supplied content type is empty"); + return NULL; + } + + if (!gst_media_source_is_type_supported (type)) { + g_set_error (error, + GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_NOT_SUPPORTED, + "unsupported content type"); + return NULL; + } + + if (self->ready_state != GST_MEDIA_SOURCE_READY_STATE_OPEN) { + g_set_error (error, + GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_INVALID_STATE, + "media source is not open"); + return NULL; + } + + GstSourceBufferCallbacks callbacks = { + .duration_changed = on_duration_changed, + .received_init_segment = on_received_init_segment, + .active_state_changed = on_active_state_changed, + }; + + GError *source_buffer_error = NULL; + GstSourceBuffer *buf = gst_source_buffer_new_with_callbacks (type, + GST_OBJECT (self), &callbacks, self, &source_buffer_error); + if (source_buffer_error) { + g_propagate_prefixed_error (error, source_buffer_error, + "failed to create source buffer"); + gst_clear_object (&buf); + return NULL; + } + + gst_source_buffer_list_append (self->buffers, buf); + + return buf; +} + +/** + * gst_media_source_remove_source_buffer: + * @self: #GstMediaSource instance + * @buffer: (transfer none): #GstSourceBuffer instance + * @error: (out) (optional) (nullable) (transfer full): the resulting error or `NULL` + * + * Remove @buffer from @self. + * + * @buffer must have been created as a child of @self and @self must be in the + * #GstMediaSourceReadyState %GST_MEDIA_SOURCE_READY_STATE_OPEN. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-removesourcebuffer) + * + * Returns: `TRUE` on success, `FALSE` otherwise + * Since: 1.24 + */ +gboolean +gst_media_source_remove_source_buffer (GstMediaSource * self, + GstSourceBuffer * buffer, GError ** error) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE (self), FALSE); + g_return_val_if_fail (GST_IS_SOURCE_BUFFER (buffer), FALSE); + + if (!gst_source_buffer_list_contains (self->buffers, buffer)) { + g_set_error (error, + GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_NOT_FOUND, + "the supplied source buffer was not found in this media source"); + return FALSE; + } + + if (gst_source_buffer_get_updating (buffer)) + gst_source_buffer_teardown (buffer); + + gst_source_buffer_list_remove (self->active_buffers, buffer); + + gst_object_unparent (GST_OBJECT (buffer)); + gst_source_buffer_list_remove (self->buffers, buffer); + + return TRUE; +} + +static void +abort_all_source_buffers (GstMediaSource * self) +{ + for (guint i = 0;; i++) { + GstSourceBuffer *buf = gst_source_buffer_list_index (self->buffers, i); + if (buf == NULL) { + return; + } + GST_LOG_OBJECT (self, "shutting down %" GST_PTR_FORMAT, buf); + gst_source_buffer_abort (buf, NULL); + gst_object_unref (buf); + } +} + +/** + * gst_media_source_end_of_stream: + * @self: #GstMediaSource instance + * @eos_error: The error type, if any + * @error: (out) (optional) (nullable) (transfer full): the resulting error or `NULL` + * + * Mark @self as reaching the end of stream, disallowing new data inputs. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-endofstream) + * + * Returns: `TRUE` on success, `FALSE` otherwise + * Since: 1.24 + */ +gboolean +gst_media_source_end_of_stream (GstMediaSource * self, + GstMediaSourceEOSError eos_error, GError ** error) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE (self), FALSE); + + if (self->ready_state != GST_MEDIA_SOURCE_READY_STATE_OPEN) { + g_set_error (error, + GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_INVALID_STATE, + "media source is not open"); + return FALSE; + } + + if (is_updating (self)) { + g_set_error (error, + GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_INVALID_STATE, + "some buffers are still updating"); + return FALSE; + } + + self->ready_state = GST_MEDIA_SOURCE_READY_STATE_ENDED; + schedule_event (self, ON_SOURCE_ENDED); + + switch (eos_error) { + case GST_MEDIA_SOURCE_EOS_ERROR_NETWORK: + network_error (self); + break; + case GST_MEDIA_SOURCE_EOS_ERROR_DECODE: + decode_error (self); + break; + default: + update_duration (self); + abort_all_source_buffers (self); + break; + } + + return TRUE; +} + +/** + * gst_media_source_set_live_seekable_range: + * @self: #GstMediaSource instance + * @start: The earliest point in the stream considered seekable + * @end: The latest point in the stream considered seekable + * @error: (out) (optional) (nullable) (transfer full): the resulting error or `NULL` + * + * Set the live seekable range for @self. This range informs the component + * playing this Media Source what it can allow the user to seek through. + * + * If the ready state is not %GST_MEDIA_SOURCE_READY_STATE_OPEN, or the supplied + * @start time is later than @end it will fail and set an error. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-setliveseekablerange) + * + * Returns: `TRUE` on success, `FALSE` otherwise + * Since: 1.24 + */ +gboolean +gst_media_source_set_live_seekable_range (GstMediaSource * self, + GstClockTime start, GstClockTime end, GError ** error) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE (self), FALSE); + if (self->ready_state != GST_MEDIA_SOURCE_READY_STATE_OPEN) { + g_set_error (error, + GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_INVALID_STATE, + "media source is not open"); + return FALSE; + } + + if (start > end) { + g_set_error (error, + GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_TYPE, + "bad time range: start must be earlier than end"); + return FALSE; + } + + self->live_seekable_range.start = start; + self->live_seekable_range.end = end; + + return TRUE; +} + +/** + * gst_media_source_clear_live_seekable_range: + * @self: #GstMediaSource instance + * @error: (out) (optional) (nullable) (transfer full): the resulting error or `NULL` + * + * Clear the live seekable range for @self. This will inform the component + * playing this Media Source that there is no seekable time range. + * + * If the ready state is not %GST_MEDIA_SOURCE_READY_STATE_OPEN, it will fail + * and set an error. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-clearliveseekablerange) + * + * Returns: `TRUE` on success, `FALSE` otherwise + * Since: 1.24 + */ +gboolean +gst_media_source_clear_live_seekable_range (GstMediaSource * self, + GError ** error) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE (self), FALSE); + + if (self->ready_state != GST_MEDIA_SOURCE_READY_STATE_OPEN) { + g_set_error (error, + GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_INVALID_STATE, + "media source is not open"); + return FALSE; + } + + reset_live_seekable_range (self); + + return TRUE; +} + +/** + * gst_media_source_get_live_seekable_range: + * @self: #GstMediaSource instance + * @range: (out) (transfer none): time range + * + * Get the live seekable range of @self. Will fill in the supplied @range with + * the current live seekable range. + * + * Since: 1.24 + */ +void +gst_media_source_get_live_seekable_range (GstMediaSource * self, + GstMediaSourceRange * range) +{ + g_return_if_fail (GST_IS_MEDIA_SOURCE (self)); + g_return_if_fail (range != NULL); + + range->start = self->live_seekable_range.start; + range->end = self->live_seekable_range.end; +} + +void +gst_media_source_seek (GstMediaSource * self, GstClockTime time) +{ + g_return_if_fail (GST_IS_MEDIA_SOURCE (self)); + for (guint i = 0;; i++) { + GstSourceBuffer *buf = gst_source_buffer_list_index (self->buffers, i); + if (buf == NULL) { + return; + } + gst_source_buffer_seek (buf, time); + gst_object_unref (buf); + } +} diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasource.h b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasource.h new file mode 100644 index 0000000000..304da3e624 --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasource.h @@ -0,0 +1,203 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2013 Google Inc. All rights reserved. + * Copyright (C) 2013 Orange + * Copyright (C) 2013-2017 Apple Inc. All rights reserved. + * Copyright (C) 2014 Sebastian Dröge + * Copyright (C) 2015, 2016 Igalia, S.L + * Copyright (C) 2015, 2016 Metrological Group B.V. + * Copyright (C) 2022, 2023 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#pragma once + +#include +#include +#include + +#include "gstsourcebufferlist.h" + +G_BEGIN_DECLS + +/** + * GstMediaSourceReadyState: + * @GST_MEDIA_SOURCE_READY_STATE_CLOSED: The #GstMediaSource is not connected to + * any playback element. + * @GST_MEDIA_SOURCE_READY_STATE_OPEN: The #GstMediaSource is connected to a + * playback element and ready to append data to its #GstSourceBuffer (s). + * @GST_MEDIA_SOURCE_READY_STATE_ENDED: gst_media_source_end_of_stream() has + * been called on the current #GstMediaSource + * + * Describes the possible states of the Media Source. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-readystate) + * + * Since: 1.24 + */ +typedef enum +{ + GST_MEDIA_SOURCE_READY_STATE_CLOSED, + GST_MEDIA_SOURCE_READY_STATE_OPEN, + GST_MEDIA_SOURCE_READY_STATE_ENDED, +} GstMediaSourceReadyState; + +/** + * GstMediaSourceError: + * @GST_MEDIA_SOURCE_ERROR_INVALID_STATE: + * @GST_MEDIA_SOURCE_ERROR_TYPE: + * @GST_MEDIA_SOURCE_ERROR_NOT_SUPPORTED: + * @GST_MEDIA_SOURCE_ERROR_NOT_FOUND: + * @GST_MEDIA_SOURCE_ERROR_QUOTA_EXCEEDED: + * + * Any error that can occur within #GstMediaSource or #GstSourceBuffer APIs. + * These values correspond directly to those in the Web IDL specification. + * + * [Specification](https://webidl.spec.whatwg.org/#idl-DOMException-error-names) + * + * Since: 1.24 + */ +typedef enum +{ + GST_MEDIA_SOURCE_ERROR_INVALID_STATE, + GST_MEDIA_SOURCE_ERROR_TYPE, + GST_MEDIA_SOURCE_ERROR_NOT_SUPPORTED, + GST_MEDIA_SOURCE_ERROR_NOT_FOUND, + GST_MEDIA_SOURCE_ERROR_QUOTA_EXCEEDED, +} GstMediaSourceError; + +/** + * GstMediaSourceEOSError: + * @GST_MEDIA_SOURCE_EOS_ERROR_NONE: End the stream successfully + * @GST_MEDIA_SOURCE_EOS_ERROR_NETWORK: End the stream due to a networking error + * @GST_MEDIA_SOURCE_EOS_ERROR_DECODE: End the stream due to a decoding error + * + * Reasons for ending a #GstMediaSource using gst_media_source_end_of_stream(). + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-endofstreamerror) + * + * Since: 1.24 + */ +typedef enum +{ + GST_MEDIA_SOURCE_EOS_ERROR_NONE, + GST_MEDIA_SOURCE_EOS_ERROR_NETWORK, + GST_MEDIA_SOURCE_EOS_ERROR_DECODE, +} GstMediaSourceEOSError; + +/** + * GstMediaSourceRange: + * @start: The start of this range. + * @end: The end of this range. + * + * A structure describing a simplified version of the TimeRanges concept in the + * HTML specification, only representing a single @start and @end time. + * + * [Specification](https://html.spec.whatwg.org/multipage/media.html#timeranges) + * + * Since: 1.24 + */ +typedef struct +{ + GstClockTime start; + GstClockTime end; +} GstMediaSourceRange; + +GST_MSE_API +gboolean gst_media_source_is_type_supported (const gchar * type); + +#define GST_TYPE_MEDIA_SOURCE (gst_media_source_get_type()) +#define GST_MEDIA_SOURCE_ERROR (gst_media_source_error_quark()) + +/** + * gst_media_source_error_quark: + * + * Any error type that can be reported by the Media Source API. + * + * Since: 1.24 + */ +GST_MSE_API +GQuark gst_media_source_error_quark (void); + +GST_MSE_API +G_DECLARE_FINAL_TYPE (GstMediaSource, gst_media_source, GST, MEDIA_SOURCE, + GstObject); + +GST_MSE_API +GstMediaSource *gst_media_source_new (void); + +GST_MSE_API +void gst_media_source_attach (GstMediaSource * self, GstMseSrc * element); + +GST_MSE_API +void gst_media_source_detach (GstMediaSource * self); + +GST_MSE_API +GstSourceBufferList * gst_media_source_get_source_buffers ( + GstMediaSource * self); + +GST_MSE_API +GstSourceBufferList * gst_media_source_get_active_source_buffers ( + GstMediaSource * self); + +GST_MSE_API +GstMediaSourceReadyState gst_media_source_get_ready_state ( + GstMediaSource * self); + +GST_MSE_API +GstClockTime gst_media_source_get_position (GstMediaSource * self); + +GST_MSE_API +GstClockTime gst_media_source_get_duration (GstMediaSource * self); + +GST_MSE_API +gboolean gst_media_source_set_duration (GstMediaSource * self, + GstClockTime duration, + GError ** error); + +GST_MSE_API +GstSourceBuffer * gst_media_source_add_source_buffer (GstMediaSource * self, + const gchar * type, + GError ** error); + +GST_MSE_API +gboolean gst_media_source_remove_source_buffer (GstMediaSource * self, + GstSourceBuffer * buffer, + GError ** error); + +GST_MSE_API +gboolean gst_media_source_end_of_stream (GstMediaSource * self, + GstMediaSourceEOSError eos_error, + GError ** error); + +GST_MSE_API +gboolean gst_media_source_set_live_seekable_range (GstMediaSource * self, + GstClockTime start, + GstClockTime end, + GError ** error); + +GST_MSE_API +gboolean gst_media_source_clear_live_seekable_range (GstMediaSource * self, + GError ** error); + +GST_MSE_API +void gst_media_source_get_live_seekable_range (GstMediaSource * self, + GstMediaSourceRange * range); + +G_END_DECLS diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasourcesamplemap-private.h b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasourcesamplemap-private.h new file mode 100644 index 0000000000..f22c79bf98 --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasourcesamplemap-private.h @@ -0,0 +1,94 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2022, 2023 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#pragma once + +#include +#include +#include + +G_BEGIN_DECLS + +#define GST_TYPE_MEDIA_SOURCE_SAMPLE_MAP \ + (gst_media_source_sample_map_get_type()) + +GST_MSE_PRIVATE +G_DECLARE_FINAL_TYPE (GstMediaSourceSampleMap, gst_media_source_sample_map, GST, + MEDIA_SOURCE_SAMPLE_MAP, GstObject); + +GST_MSE_PRIVATE +GstMediaSourceSampleMap *gst_media_source_sample_map_new (void); + +GST_MSE_PRIVATE +void gst_media_source_sample_map_add (GstMediaSourceSampleMap * self, + GstSample * sample); + +GST_MSE_PRIVATE +void gst_media_source_sample_map_remove (GstMediaSourceSampleMap * self, + GstSample * sample); + +GST_MSE_PRIVATE +gsize gst_media_source_sample_map_remove_range (GstMediaSourceSampleMap * self, + GstClockTime earliest, GstClockTime latest); + +GST_MSE_PRIVATE +gsize +gst_media_source_sample_map_remove_range_from_start (GstMediaSourceSampleMap + * self, GstClockTime latest_dts); + +GST_MSE_PRIVATE +gsize +gst_media_source_sample_map_remove_range_from_end (GstMediaSourceSampleMap + * self, GstClockTime earliest_dts); + +GST_MSE_PRIVATE +gboolean gst_media_source_sample_map_contains (GstMediaSourceSampleMap * self, + GstSample * sample); + +GST_MSE_PRIVATE +GSequenceIter * gst_media_source_sample_map_get_begin_iter_by_pts ( + GstMediaSourceSampleMap * self); + +GST_MSE_PRIVATE +GstClockTime gst_media_source_sample_map_get_highest_end_time ( + GstMediaSourceSampleMap * self); + +GST_MSE_PRIVATE +guint gst_media_source_sample_map_get_size (GstMediaSourceSampleMap * self); + +GST_MSE_PRIVATE +gsize gst_media_source_sample_map_get_storage_size ( + GstMediaSourceSampleMap * self); + +GST_MSE_PRIVATE +GstIterator * +gst_media_source_sample_map_iter_samples_by_dts (GstMediaSourceSampleMap * map, + GMutex * lock, guint32 * master_cookie, GstClockTime start_dts, + GstSample * start_sample); + +GST_MSE_PRIVATE +GstIterator * +gst_media_source_sample_map_iter_samples_by_pts (GstMediaSourceSampleMap * map, + GMutex * lock, guint32 * master_cookie, GstClockTime start_pts, + GstSample *start_sample); + +G_END_DECLS diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasourcesamplemap.c b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasourcesamplemap.c new file mode 100644 index 0000000000..6728c6c567 --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasourcesamplemap.c @@ -0,0 +1,551 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2022, 2023 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gstmediasourcesamplemap-private.h" +#include "gstmselogging-private.h" + +struct _GstMediaSourceSampleMap +{ + GstObject parent_instance; + + GHashTable *samples; + GSequence *samples_by_dts; + GSequence *samples_by_pts; + + gsize storage_size; +}; + +G_DEFINE_TYPE (GstMediaSourceSampleMap, gst_media_source_sample_map, + GST_TYPE_OBJECT); + +static gint compare_pts (GstSample * a, GstSample * b, gpointer user_data); +static GSequenceIter *find_sample_containing_dts (GstMediaSourceSampleMap * + self, GstClockTime dts); +static GSequenceIter *find_sample_containing_pts (GstMediaSourceSampleMap * + self, GstClockTime pts); +static GSequenceIter *find_sequentially (GSequence * sequence, gpointer item); + +static inline GstClockTime +sample_dts (GstSample * sample) +{ + return GST_BUFFER_DTS (gst_sample_get_buffer (sample)); +} + +static inline GstClockTime +sample_pts (GstSample * sample) +{ + return GST_BUFFER_PTS (gst_sample_get_buffer (sample)); +} + +static gsize +sample_buffer_size (GstSample * sample) +{ + return gst_buffer_get_size (gst_sample_get_buffer (sample)); +} + +static gboolean +iter_is_delta_unit (GSequenceIter * iter) +{ + if (g_sequence_iter_is_end (iter)) { + return TRUE; + } + GstSample *sample = g_sequence_get (iter); + GstBuffer *buffer = gst_sample_get_buffer (sample); + return GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT); +} + +static gint +compare_dts (GstSample * a, GstSample * b, gpointer user_data) +{ + GstClockTime a_dts = sample_dts (a); + GstClockTime b_dts = sample_dts (b); + if (a_dts == b_dts) { + return compare_pts (a, b, user_data); + } + return a_dts > b_dts ? +1 : -1; +} + +static gint +compare_pts (GstSample * a, GstSample * b, gpointer user_data) +{ + GstClockTime a_pts = sample_pts (a); + GstClockTime b_pts = sample_pts (b); + if (a_pts == b_pts) { + return 0; + } + return a_pts > b_pts ? +1 : -1; +} + +static inline void +remove_sample (GSequence * sequence, GCompareDataFunc compare, + GstSample * sample, GstMediaSourceSampleMap * self) +{ + GSequenceIter *match = g_sequence_lookup (sequence, sample, compare, self); + if (match == NULL) { + return; + } + g_sequence_remove (match); +} + +GstMediaSourceSampleMap * +gst_media_source_sample_map_new (void) +{ + return gst_object_ref_sink (g_object_new (GST_TYPE_MEDIA_SOURCE_SAMPLE_MAP, + NULL)); +} + +static void +gst_media_source_sample_map_finalize (GObject * object) +{ + GstMediaSourceSampleMap *self = GST_MEDIA_SOURCE_SAMPLE_MAP (object); + g_sequence_free (self->samples_by_dts); + g_sequence_free (self->samples_by_pts); + g_hash_table_unref (self->samples); + G_OBJECT_CLASS (gst_media_source_sample_map_parent_class)->finalize (object); +} + +static void +gst_media_source_sample_map_class_init (GstMediaSourceSampleMapClass * klass) +{ + GObjectClass *oclass = G_OBJECT_CLASS (klass); + + oclass->finalize = GST_DEBUG_FUNCPTR (gst_media_source_sample_map_finalize); +} + +static void +gst_media_source_sample_map_init (GstMediaSourceSampleMap * self) +{ + self->samples = g_hash_table_new_full (g_direct_hash, g_direct_equal, + (GDestroyNotify) gst_sample_unref, NULL); + self->samples_by_dts = g_sequence_new ((GDestroyNotify) gst_sample_unref); + self->samples_by_pts = g_sequence_new ((GDestroyNotify) gst_sample_unref); +} + +void +gst_media_source_sample_map_add (GstMediaSourceSampleMap * self, + GstSample * sample) +{ + g_return_if_fail (GST_IS_MEDIA_SOURCE_SAMPLE_MAP (self)); + g_return_if_fail (GST_IS_SAMPLE (sample)); + GstBuffer *buffer = gst_sample_get_buffer (sample); + g_return_if_fail (GST_BUFFER_DTS_IS_VALID (buffer)); + g_return_if_fail (GST_BUFFER_PTS_IS_VALID (buffer)); + g_return_if_fail (GST_BUFFER_DURATION_IS_VALID (buffer)); + + if (g_hash_table_contains (self->samples, sample)) { + return; + } + + g_hash_table_add (self->samples, gst_sample_ref (sample)); + g_sequence_insert_sorted (self->samples_by_dts, gst_sample_ref (sample), + (GCompareDataFunc) compare_dts, self); + g_sequence_insert_sorted (self->samples_by_pts, gst_sample_ref (sample), + (GCompareDataFunc) compare_pts, self); + self->storage_size += gst_buffer_get_size (buffer); + GST_TRACE_OBJECT (self, "new storage size=%" G_GSIZE_FORMAT, + self->storage_size); +} + +void +gst_media_source_sample_map_remove (GstMediaSourceSampleMap * self, + GstSample * sample) +{ + g_return_if_fail (GST_IS_MEDIA_SOURCE_SAMPLE_MAP (self)); + g_return_if_fail (GST_IS_SAMPLE (sample)); + + if (!g_hash_table_contains (self->samples, sample)) { + return; + } + + gsize buffer_size = sample_buffer_size (sample); + remove_sample (self->samples_by_dts, (GCompareDataFunc) compare_dts, sample, + self); + remove_sample (self->samples_by_pts, (GCompareDataFunc) compare_pts, sample, + self); + g_hash_table_remove (self->samples, sample); + self->storage_size -= MIN (buffer_size, self->storage_size); +} + +gboolean +gst_media_source_sample_map_contains (GstMediaSourceSampleMap * self, + GstSample * sample) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE_SAMPLE_MAP (self), FALSE); + return g_hash_table_contains (self->samples, sample); +} + +gsize +gst_media_source_sample_map_remove_range (GstMediaSourceSampleMap * self, + GstClockTime earliest, GstClockTime latest) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE_SAMPLE_MAP (self), 0); + g_return_val_if_fail (earliest <= latest, 0); + + GSequenceIter *start_by_dts = find_sample_containing_dts (self, earliest); + GSequenceIter *end_by_dts = find_sample_containing_dts (self, latest); + + GstSample *start = g_sequence_get (start_by_dts); + GstSample *end = g_sequence_get (end_by_dts); + + GstClockTime start_time = + start == NULL ? GST_CLOCK_TIME_NONE : sample_dts (start); + GstClockTime end_time = end == NULL ? start_time : sample_dts (end); + + GST_TRACE_OBJECT (self, "remove range [%" GST_TIMEP_FORMAT ",%" + GST_TIMEP_FORMAT ")", &start_time, &end_time); + + GList *to_remove = NULL; + while (g_sequence_iter_compare (start_by_dts, end_by_dts) < 1) { + GstSample *sample = g_sequence_get (start_by_dts); + to_remove = g_list_prepend (to_remove, sample); + start_by_dts = g_sequence_iter_next (start_by_dts); + } + gsize bytes_removed = 0; + for (GList * iter = to_remove; iter != NULL; iter = g_list_next (iter)) { + GstSample *sample = iter->data; + bytes_removed += sample_buffer_size (sample); + gst_media_source_sample_map_remove (self, sample); + } + + g_list_free (to_remove); + + GST_TRACE_OBJECT (self, "removed=%" G_GSIZE_FORMAT "B, latest=%" + GST_TIMEP_FORMAT, bytes_removed, &latest); + return bytes_removed; +} + +gsize +gst_media_source_sample_map_remove_range_from_start (GstMediaSourceSampleMap + * self, GstClockTime latest_dts) +{ + return gst_media_source_sample_map_remove_range (self, 0, latest_dts); +} + +gsize +gst_media_source_sample_map_remove_range_from_end (GstMediaSourceSampleMap + * self, GstClockTime earliest_dts) +{ + return gst_media_source_sample_map_remove_range (self, earliest_dts, + GST_CLOCK_TIME_NONE); +} + +GstClockTime +gst_media_source_sample_map_get_highest_end_time (GstMediaSourceSampleMap * + self) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE_SAMPLE_MAP (self), + GST_CLOCK_TIME_NONE); + GSequenceIter *iter = g_sequence_get_end_iter (self->samples_by_pts); + iter = g_sequence_iter_prev (iter); + if (g_sequence_iter_is_begin (iter)) { + return GST_CLOCK_TIME_NONE; + } + GstSample *sample = g_sequence_get (iter); + GstBuffer *buffer = gst_sample_get_buffer (sample); + g_return_val_if_fail (GST_BUFFER_PTS_IS_VALID (buffer), GST_CLOCK_TIME_NONE); + g_return_val_if_fail (GST_BUFFER_DURATION_IS_VALID (buffer), + GST_CLOCK_TIME_NONE); + return GST_BUFFER_PTS (buffer) + GST_BUFFER_DURATION (buffer); +} + +guint +gst_media_source_sample_map_get_size (GstMediaSourceSampleMap * self) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE_SAMPLE_MAP (self), 0); + return g_hash_table_size (self->samples); +} + +gsize +gst_media_source_sample_map_get_storage_size (GstMediaSourceSampleMap * self) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE_SAMPLE_MAP (self), 0); + return self->storage_size; +} + +static inline gboolean +sample_contains_dts (GstSample * sample, GstClockTime dts) +{ + GstBuffer *buffer = gst_sample_get_buffer (sample); + g_return_val_if_fail (GST_BUFFER_DURATION_IS_VALID (buffer), FALSE); + g_return_val_if_fail (GST_BUFFER_DTS_IS_VALID (buffer), FALSE); + g_return_val_if_fail (GST_CLOCK_TIME_IS_VALID (dts), FALSE); + GstClockTime end = GST_BUFFER_DTS (buffer) + GST_BUFFER_DURATION (buffer); + return dts <= end; +} + +static inline gboolean +sample_contains_pts (GstSample * sample, GstClockTime pts) +{ + GstBuffer *buffer = gst_sample_get_buffer (sample); + g_return_val_if_fail (GST_BUFFER_DURATION_IS_VALID (buffer), FALSE); + g_return_val_if_fail (GST_BUFFER_PTS_IS_VALID (buffer), FALSE); + g_return_val_if_fail (GST_CLOCK_TIME_IS_VALID (pts), FALSE); + GstClockTime end = GST_BUFFER_PTS (buffer) + GST_BUFFER_DURATION (buffer); + return pts <= end; +} + +static GSequenceIter * +find_sequentially (GSequence * sequence, gpointer item) +{ + GSequenceIter *iter = g_sequence_get_begin_iter (sequence); + for (; !g_sequence_iter_is_end (iter); iter = g_sequence_iter_next (iter)) { + gpointer current = g_sequence_get (iter); + if (current == item) { + return iter; + } + } + return iter; +} + +static GSequenceIter * +find_sample_containing_dts (GstMediaSourceSampleMap * self, GstClockTime dts) +{ + if (dts == 0) { + return g_sequence_get_begin_iter (self->samples_by_dts); + } + if (dts == GST_CLOCK_TIME_NONE) { + return g_sequence_get_end_iter (self->samples_by_dts); + } + GSequenceIter *iter = g_sequence_get_begin_iter (self->samples_by_dts); + while (!g_sequence_iter_is_end (iter)) { + GstSample *sample = g_sequence_get (iter); + if (sample_contains_dts (sample, dts)) { + return iter; + } + iter = g_sequence_iter_next (iter); + } + return iter; +} + +static GSequenceIter * +find_sample_containing_pts (GstMediaSourceSampleMap * self, GstClockTime pts) +{ + if (pts == 0) { + return g_sequence_get_begin_iter (self->samples_by_pts); + } + if (pts == GST_CLOCK_TIME_NONE) { + return g_sequence_get_end_iter (self->samples_by_pts); + } + GSequenceIter *iter = g_sequence_get_begin_iter (self->samples_by_pts); + while (!g_sequence_iter_is_end (iter)) { + GstSample *sample = g_sequence_get (iter); + if (sample_contains_pts (sample, pts)) { + return iter; + } + iter = g_sequence_iter_next (iter); + } + return iter; +} + +static GSequenceIter * +find_previous_non_delta_unit (GstMediaSourceSampleMap * self, + GSequenceIter * iter) +{ + while (!g_sequence_iter_is_begin (iter)) { + if (!iter_is_delta_unit (iter)) { + GST_TRACE_OBJECT (self, "found valid sample"); + return iter; + } + iter = g_sequence_iter_prev (iter); + } + GST_TRACE_OBJECT (self, "rolled back to the first sample"); + return iter; +} + +static GSequenceIter * +gst_media_source_sample_map_iter_starting_dts (GstMediaSourceSampleMap * self, + GstClockTime start_dts) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE_SAMPLE_MAP (self), NULL); + g_return_val_if_fail (GST_CLOCK_TIME_IS_VALID (start_dts), NULL); + GSequenceIter *iter = find_sample_containing_dts (self, start_dts); + return find_previous_non_delta_unit (self, iter); +} + +static GSequenceIter * +gst_media_source_sample_map_iter_starting_pts (GstMediaSourceSampleMap + * self, GstClockTime start_pts) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE_SAMPLE_MAP (self), NULL); + g_return_val_if_fail (GST_CLOCK_TIME_IS_VALID (start_pts), NULL); + GSequenceIter *iter = find_sample_containing_pts (self, start_pts); + return find_previous_non_delta_unit (self, iter); +} + +typedef struct _SampleMapIterator SampleMapIterator; + +struct _SampleMapIterator +{ + GstIterator iterator; + GstMediaSourceSampleMap *map; +/* *INDENT-OFF* */ + GstClockTime (*timestamp_func) (GstSample *); + GSequenceIter *(*resync_locator_func) (SampleMapIterator *); +/* *INDENT-ON* */ + + GstClockTime start_time; + GstClockTime current_time; + GSequenceIter *current_iter; + GstSample *current_sample; +}; + +static void +iter_copy (const SampleMapIterator * it, SampleMapIterator * copy) +{ + copy->map = gst_object_ref (it->map); + copy->timestamp_func = it->timestamp_func; + copy->resync_locator_func = it->resync_locator_func; + + copy->current_time = it->current_time; + copy->start_time = it->start_time; + copy->current_iter = it->current_iter; + copy->current_sample = gst_sample_ref (it->current_sample); +} + +static GSequenceIter * +iter_find_resync_point_dts (SampleMapIterator * it) +{ + if (it->current_sample) { + GSequenceIter *iter = + find_sequentially (it->map->samples_by_dts, it->current_sample); + if (!g_sequence_iter_is_end (iter)) { + return g_sequence_iter_next (iter); + } + } + + return gst_media_source_sample_map_iter_starting_dts (it->map, + it->current_time); +} + +static GSequenceIter * +iter_find_resync_point_pts (SampleMapIterator * it) +{ + if (it->current_sample) { + GSequenceIter *iter = + find_sequentially (it->map->samples_by_pts, it->current_sample); + if (!g_sequence_iter_is_end (iter)) { + return g_sequence_iter_next (iter); + } + } + + return gst_media_source_sample_map_iter_starting_pts (it->map, + it->current_time); +} + +static GstIteratorResult +iter_next (SampleMapIterator * it, GValue * result) +{ + + if (g_sequence_iter_is_end (it->current_iter)) { + return GST_ITERATOR_DONE; + } + + GstSample *sample = g_sequence_get (it->current_iter); + gst_clear_sample (&it->current_sample); + it->current_sample = gst_sample_ref (sample); + + it->current_time = it->timestamp_func (sample); + it->current_iter = g_sequence_iter_next (it->current_iter); + + gst_value_set_sample (result, sample); + + return GST_ITERATOR_OK; +} + +static void +iter_resync (SampleMapIterator * it) +{ + GST_TRACE_OBJECT (it->map, "resync"); + it->current_time = it->start_time; + it->current_iter = it->resync_locator_func (it); +} + +static void +iter_free (SampleMapIterator * it) +{ + gst_clear_object (&it->map); + gst_clear_sample (&it->current_sample); +} + +GstIterator * +gst_media_source_sample_map_iter_samples_by_dts (GstMediaSourceSampleMap * map, + GMutex * lock, guint32 * master_cookie, GstClockTime start_dts, + GstSample * start_sample) +{ +/* *INDENT-OFF* */ + SampleMapIterator *it = (SampleMapIterator *) gst_iterator_new ( + sizeof (SampleMapIterator), + GST_TYPE_SAMPLE, + lock, + master_cookie, + (GstIteratorCopyFunction) iter_copy, + (GstIteratorNextFunction) iter_next, + (GstIteratorItemFunction) NULL, + (GstIteratorResyncFunction) iter_resync, + (GstIteratorFreeFunction) iter_free + ); +/* *INDENT-ON* */ + + it->map = gst_object_ref (map); + it->timestamp_func = sample_dts; + it->resync_locator_func = iter_find_resync_point_dts; + it->start_time = start_dts; + it->current_time = start_dts; + it->current_sample = start_sample ? gst_sample_ref (start_sample) : NULL; + it->current_iter = iter_find_resync_point_dts (it); + + return GST_ITERATOR (it); +} + +GstIterator * +gst_media_source_sample_map_iter_samples_by_pts (GstMediaSourceSampleMap * map, + GMutex * lock, guint32 * master_cookie, GstClockTime start_pts, + GstSample * start_sample) +{ +/* *INDENT-OFF* */ + SampleMapIterator *it = (SampleMapIterator *) gst_iterator_new ( + sizeof (SampleMapIterator), + GST_TYPE_SAMPLE, + lock, + master_cookie, + (GstIteratorCopyFunction) iter_copy, + (GstIteratorNextFunction) iter_next, + (GstIteratorItemFunction) NULL, + (GstIteratorResyncFunction) iter_resync, + (GstIteratorFreeFunction) iter_free + ); +/* *INDENT-ON* */ + + it->map = gst_object_ref (map); + it->timestamp_func = sample_pts; + it->resync_locator_func = iter_find_resync_point_pts; + it->start_time = start_pts; + it->current_time = start_pts; + it->current_sample = start_sample ? gst_sample_ref (start_sample) : NULL; + it->current_iter = iter_find_resync_point_pts (it); + + return GST_ITERATOR (it); +} diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasourcetrack-private.h b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasourcetrack-private.h new file mode 100644 index 0000000000..68c834efbd --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasourcetrack-private.h @@ -0,0 +1,110 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2022, 2023 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#pragma once + +#include +#include + +G_BEGIN_DECLS + +typedef enum +{ + GST_MEDIA_SOURCE_TRACK_TYPE_AUDIO, + GST_MEDIA_SOURCE_TRACK_TYPE_VIDEO, + GST_MEDIA_SOURCE_TRACK_TYPE_TEXT, + GST_MEDIA_SOURCE_TRACK_TYPE_OTHER, +} GstMediaSourceTrackType; + +#define GST_TYPE_MEDIA_SOURCE_TRACK (gst_media_source_track_get_type()) + +GST_MSE_PRIVATE +G_DECLARE_FINAL_TYPE (GstMediaSourceTrack, gst_media_source_track, GST, + MEDIA_SOURCE_TRACK, GstObject); + +GST_MSE_PRIVATE +GstMediaSourceTrackType gst_media_source_track_get_track_type ( + GstMediaSourceTrack * self); + +GST_MSE_PRIVATE +const gchar * +gst_media_source_track_get_id (GstMediaSourceTrack * self); + +GST_MSE_PRIVATE +gboolean gst_media_source_track_get_active (GstMediaSourceTrack * self); + +GST_MSE_PRIVATE +GstMediaSourceTrack *gst_media_source_track_new (GstMediaSourceTrackType type, + const gchar * track_id); + +GST_MSE_PRIVATE +GstMediaSourceTrack * +gst_media_source_track_new_with_initial_caps (GstMediaSourceTrackType type, + const gchar * track_id, GstCaps * initial_caps); + +GST_MSE_PRIVATE +GstMediaSourceTrack * gst_media_source_track_new_with_size ( + GstMediaSourceTrackType type, const gchar * track_id, gsize size); + +GST_MSE_PRIVATE +GstCaps *gst_media_source_track_get_initial_caps (GstMediaSourceTrack * self); + +GST_MSE_PRIVATE +GstStreamType +gst_media_source_track_get_stream_type (GstMediaSourceTrack * self); + +GST_MSE_API +void gst_media_source_track_set_active (GstMediaSourceTrack * self, + gboolean active); + +GST_MSE_PRIVATE +GstMiniObject *gst_media_source_track_pop (GstMediaSourceTrack * self); + +GST_MSE_PRIVATE +gboolean gst_media_source_track_push (GstMediaSourceTrack * self, + GstSample * sample); + +GST_MSE_PRIVATE +gboolean gst_media_source_track_try_push (GstMediaSourceTrack * self, + GstSample * sample); + +GST_MSE_PRIVATE +gboolean gst_media_source_track_push_eos (GstMediaSourceTrack * self); + +GST_MSE_PRIVATE +void gst_media_source_track_flush (GstMediaSourceTrack * self); + +GST_MSE_PRIVATE +void gst_media_source_track_resume (GstMediaSourceTrack * self); + +GST_MSE_PRIVATE +gboolean gst_media_source_track_is_empty (GstMediaSourceTrack * self); + +GST_MSE_PRIVATE +GstStreamType gst_media_source_track_type_to_stream_type ( + GstMediaSourceTrackType type); + +GST_MSE_PRIVATE +GstMediaSourceTrackType gst_media_source_track_type_from_stream_type ( + GstStreamType type); + +G_END_DECLS diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasourcetrack.c b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasourcetrack.c new file mode 100644 index 0000000000..378c5c9cf4 --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasourcetrack.c @@ -0,0 +1,458 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2022, 2023 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include +#include +#include "gstmediasourcetrack-private.h" + +#include "gstmselogging-private.h" + +#include + +struct _GstMediaSourceTrack +{ + GstObject parent_instance; + + GstMediaSourceTrackType track_type; + gchar *track_id; + gboolean active; + GstCaps *initial_caps; + + gsize queue_size; + GstDataQueue *samples; +}; + +G_DEFINE_TYPE (GstMediaSourceTrack, gst_media_source_track, GST_TYPE_OBJECT); + +#define DEFAULT_QUEUE_SIZE (1 << 10) + +enum +{ + PROP_0, + + PROP_TRACK_TYPE, + PROP_TRACK_ID, + PROP_ACTIVE, + PROP_INITIAL_CAPS, + PROP_QUEUE_SIZE, + + N_PROPS, +}; + +enum +{ + ON_NOT_EMPTY, + + N_SIGNALS, +}; + +static GParamSpec *properties[N_PROPS]; +static guint signals[N_SIGNALS]; + +static GstMediaSourceTrack * +_gst_media_source_track_new_full (GstMediaSourceTrackType type, + const gchar * track_id, gsize size, GstCaps * initial_caps) +{ + g_return_val_if_fail (type >= 0, NULL); + g_return_val_if_fail (type <= GST_MEDIA_SOURCE_TRACK_TYPE_OTHER, NULL); + + gst_mse_init_logging (); + + GstMediaSourceTrack *self = g_object_new (GST_TYPE_MEDIA_SOURCE_TRACK, + "track-type", type, "track-id", track_id, "queue-size", size, + "initial-caps", initial_caps, NULL); + + return gst_object_ref_sink (self); +} + +GstMediaSourceTrack * +gst_media_source_track_new_with_size (GstMediaSourceTrackType type, + const gchar * track_id, gsize size) +{ + return _gst_media_source_track_new_full (type, track_id, size, NULL); +} + +GstMediaSourceTrack * +gst_media_source_track_new (GstMediaSourceTrackType type, + const gchar * track_id) +{ + return _gst_media_source_track_new_full (type, track_id, DEFAULT_QUEUE_SIZE, + NULL); +} + +GstMediaSourceTrack * +gst_media_source_track_new_with_initial_caps (GstMediaSourceTrackType type, + const gchar * track_id, GstCaps * initial_caps) +{ + g_return_val_if_fail (GST_IS_CAPS (initial_caps), NULL); + return _gst_media_source_track_new_full (type, track_id, DEFAULT_QUEUE_SIZE, + initial_caps); +} + +static void +gst_media_source_track_finalize (GObject * object) +{ + GstMediaSourceTrack *self = (GstMediaSourceTrack *) object; + + g_free (self->track_id); + gst_clear_caps (&self->initial_caps); + g_object_unref (self->samples); + + G_OBJECT_CLASS (gst_media_source_track_parent_class)->finalize (object); +} + +static void +gst_media_source_track_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec) +{ + GstMediaSourceTrack *self = GST_MEDIA_SOURCE_TRACK (object); + + switch (prop_id) { + case PROP_TRACK_TYPE: + g_value_set_enum (value, gst_media_source_track_get_track_type (self)); + break; + case PROP_TRACK_ID: + g_value_set_static_string (value, gst_media_source_track_get_id (self)); + break; + case PROP_ACTIVE: + g_value_set_boolean (value, gst_media_source_track_get_active (self)); + break; + case PROP_INITIAL_CAPS: + g_value_take_boxed (value, + gst_media_source_track_get_initial_caps (self)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + } +} + +static void +gst_media_source_track_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec) +{ + GstMediaSourceTrack *self = GST_MEDIA_SOURCE_TRACK (object); + + switch (prop_id) { + case PROP_TRACK_TYPE: + self->track_type = g_value_get_enum (value); + break; + case PROP_TRACK_ID: + self->track_id = g_value_dup_string (value); + break; + case PROP_ACTIVE: + gst_media_source_track_set_active (self, g_value_get_boolean (value)); + break; + case PROP_INITIAL_CAPS:{ + const GstCaps *caps = gst_value_get_caps (value); + self->initial_caps = caps == NULL ? NULL : gst_caps_copy (caps); + break; + } + case PROP_QUEUE_SIZE:{ + self->queue_size = g_value_get_ulong (value); + break; + } + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + } +} + +static void +gst_media_source_track_class_init (GstMediaSourceTrackClass * klass) +{ + GObjectClass *oclass = G_OBJECT_CLASS (klass); + + oclass->finalize = GST_DEBUG_FUNCPTR (gst_media_source_track_finalize); + oclass->get_property = + GST_DEBUG_FUNCPTR (gst_media_source_track_get_property); + oclass->set_property = + GST_DEBUG_FUNCPTR (gst_media_source_track_set_property); + + signals[ON_NOT_EMPTY] = g_signal_new ("on-not-empty", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0); + + properties[PROP_TRACK_TYPE] = + g_param_spec_enum ("track-type", "Track Type", + "Type of media in this Track, either Audio, Video, Text, or Other.", + GST_TYPE_MEDIA_SOURCE_TRACK_TYPE, GST_MEDIA_SOURCE_TRACK_TYPE_OTHER, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS); + + properties[PROP_TRACK_ID] = + g_param_spec_string ("track-id", "Track ID", + "Identifier for this Track that must be unique within a Source Buffer.", + "", G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS); + + properties[PROP_ACTIVE] = + g_param_spec_boolean ("active", "Active", + "Whether this Track requires its parent Source Buffer to be in its " + "parent Media Source's Active Source Buffers list", FALSE, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); + + properties[PROP_INITIAL_CAPS] = + g_param_spec_boxed ("initial-caps", "Initial Caps", + "GstCaps discovered in the first Initialization Segment", + GST_TYPE_CAPS, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | + G_PARAM_STATIC_STRINGS); + + properties[PROP_QUEUE_SIZE] = + g_param_spec_ulong ("queue-size", "Queue Size", + "Maximum Track Queue size", + 0, G_MAXULONG, DEFAULT_QUEUE_SIZE, + G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS); + + g_object_class_install_properties (oclass, N_PROPS, properties); +} + +static gboolean +check_queue_depth (GstDataQueue * queue, guint visible, guint bytes, + guint64 time, gpointer checkdata) +{ + GstMediaSourceTrack *self = GST_MEDIA_SOURCE_TRACK (checkdata); + return visible >= self->queue_size; +} + +static void +gst_media_source_track_init (GstMediaSourceTrack * self) +{ + self->samples = gst_data_queue_new (check_queue_depth, NULL, NULL, self); +} + +GstMediaSourceTrackType +gst_media_source_track_get_track_type (GstMediaSourceTrack * self) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE_TRACK (self), + GST_MEDIA_SOURCE_TRACK_TYPE_OTHER); + return self->track_type; +} + +GstStreamType +gst_media_source_track_get_stream_type (GstMediaSourceTrack * self) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE_TRACK (self), + GST_STREAM_TYPE_UNKNOWN); + return gst_media_source_track_type_to_stream_type (self->track_type); +} + +const gchar * +gst_media_source_track_get_id (GstMediaSourceTrack * self) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE_TRACK (self), NULL); + return self->track_id; +} + +GstCaps * +gst_media_source_track_get_initial_caps (GstMediaSourceTrack * self) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE_TRACK (self), NULL); + if (GST_IS_CAPS (self->initial_caps)) { + return self->initial_caps; + } else { + return NULL; + } +} + +gboolean +gst_media_source_track_get_active (GstMediaSourceTrack * self) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE_TRACK (self), FALSE); + return self->active; +} + +void +gst_media_source_track_set_active (GstMediaSourceTrack * self, gboolean active) +{ + g_return_if_fail (GST_IS_MEDIA_SOURCE_TRACK (self)); + self->active = active; + g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_ACTIVE]); +} + +GstMiniObject * +gst_media_source_track_pop (GstMediaSourceTrack * self) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE_TRACK (self), NULL); + GstDataQueueItem *item = NULL; + if (!gst_data_queue_pop (self->samples, &item)) { + return NULL; + } + GstMiniObject *object = item->object; + item->object = NULL; + item->destroy (item); + return object; +} + +static inline gsize +sample_size (GstSample * sample) +{ + GstBuffer *buffer = gst_sample_get_buffer (sample); + return gst_buffer_get_size (buffer); +} + +static inline GstClockTime +sample_duration (GstSample * sample) +{ + GstBuffer *buffer = gst_sample_get_buffer (sample); + return GST_BUFFER_DURATION (buffer); +} + +static void +destroy_item (GstDataQueueItem * item) +{ + gst_clear_mini_object (&item->object); + g_free (item); +} + +static inline GstDataQueueItem * +wrap_sample (GstSample * sample) +{ + GstDataQueueItem item = { + .object = GST_MINI_OBJECT (sample), + .size = sample_size (sample), + .duration = sample_duration (sample), + .destroy = (GDestroyNotify) destroy_item, + .visible = TRUE, + }; + return g_memdup2 (&item, sizeof (GstDataQueueItem)); +} + +gboolean +gst_media_source_track_push (GstMediaSourceTrack * self, GstSample * sample) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE_TRACK (self), FALSE); + g_return_val_if_fail (GST_IS_SAMPLE (sample), FALSE); + + gboolean was_empty = gst_media_source_track_is_empty (self); + + GstDataQueueItem *item = wrap_sample (sample); + + gboolean result = gst_data_queue_push (self->samples, item); + + if (result) { + if (was_empty) { + g_signal_emit (self, signals[ON_NOT_EMPTY], 0); + } + return TRUE; + } else { + item->destroy (item); + return FALSE; + } +} + +static inline GstDataQueueItem * +wrap_eos (void) +{ + GstEvent *event = gst_event_ref (gst_event_new_eos ()); + + GstDataQueueItem item = { + .object = GST_MINI_OBJECT (event), + .size = 0, + .duration = 0, + .destroy = (GDestroyNotify) destroy_item, + .visible = TRUE, + }; + return g_memdup2 (&item, sizeof (GstDataQueueItem)); +} + +gboolean +gst_media_source_track_push_eos (GstMediaSourceTrack * self) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE_TRACK (self), FALSE); + + GstDataQueueItem *item = wrap_eos (); + + gboolean result = gst_data_queue_push (self->samples, item); + + if (result) { + return TRUE; + } else { + item->destroy (item); + return FALSE; + } +} + +void +gst_media_source_track_flush (GstMediaSourceTrack * self) +{ + g_return_if_fail (GST_IS_MEDIA_SOURCE_TRACK (self)); + gst_data_queue_set_flushing (self->samples, TRUE); + gst_data_queue_flush (self->samples); +} + +void +gst_media_source_track_resume (GstMediaSourceTrack * self) +{ + g_return_if_fail (GST_IS_MEDIA_SOURCE_TRACK (self)); + gst_data_queue_set_flushing (self->samples, FALSE); +} + +gboolean +gst_media_source_track_try_push (GstMediaSourceTrack * self, GstSample * sample) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE_TRACK (self), FALSE); + g_return_val_if_fail (GST_IS_SAMPLE (sample), FALSE); + + if (gst_data_queue_is_full (self->samples)) { + return FALSE; + } + + return gst_media_source_track_push (self, sample); +} + +gboolean +gst_media_source_track_is_empty (GstMediaSourceTrack * self) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE_TRACK (self), FALSE); + return gst_data_queue_is_empty (self->samples); +} + +GstStreamType +gst_media_source_track_type_to_stream_type (GstMediaSourceTrackType type) +{ + switch (type) { + case GST_MEDIA_SOURCE_TRACK_TYPE_AUDIO: + return GST_STREAM_TYPE_AUDIO; + case GST_MEDIA_SOURCE_TRACK_TYPE_TEXT: + return GST_STREAM_TYPE_TEXT; + case GST_MEDIA_SOURCE_TRACK_TYPE_VIDEO: + return GST_STREAM_TYPE_VIDEO; + default: + return GST_STREAM_TYPE_UNKNOWN; + } +} + +GstMediaSourceTrackType +gst_media_source_track_type_from_stream_type (GstStreamType type) +{ + switch (type) { + case GST_STREAM_TYPE_AUDIO: + return GST_MEDIA_SOURCE_TRACK_TYPE_AUDIO; + case GST_STREAM_TYPE_TEXT: + return GST_MEDIA_SOURCE_TRACK_TYPE_TEXT; + case GST_STREAM_TYPE_VIDEO: + return GST_MEDIA_SOURCE_TRACK_TYPE_VIDEO; + default: + return GST_MEDIA_SOURCE_TRACK_TYPE_OTHER; + } +} diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasourcetrackbuffer-private.h b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasourcetrackbuffer-private.h new file mode 100644 index 0000000000..8abfa77b61 --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasourcetrackbuffer-private.h @@ -0,0 +1,100 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2022, 2023 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#pragma once + +#include +#include +#include + +G_BEGIN_DECLS + +#define GST_TYPE_MEDIA_SOURCE_TRACK_BUFFER \ + (gst_media_source_track_buffer_get_type()) + +GST_MSE_PRIVATE +G_DECLARE_FINAL_TYPE (GstMediaSourceTrackBuffer, gst_media_source_track_buffer, + GST, MEDIA_SOURCE_TRACK_BUFFER, GstObject); + +GST_MSE_PRIVATE +GstMediaSourceTrackBuffer *gst_media_source_track_buffer_new (void); + +GST_MSE_PRIVATE +gboolean gst_media_source_track_buffer_is_empty ( + GstMediaSourceTrackBuffer * self); + +GST_MSE_PRIVATE +gint gst_media_source_track_buffer_get_size (GstMediaSourceTrackBuffer * self); + +GST_MSE_PRIVATE +GstClockTime gst_media_source_track_buffer_get_highest_end_time ( + GstMediaSourceTrackBuffer * self); + +GST_MSE_PRIVATE +GArray * gst_media_source_track_buffer_get_ranges ( + GstMediaSourceTrackBuffer * self); + +GST_MSE_PRIVATE +void gst_media_source_track_buffer_set_group_start (GstMediaSourceTrackBuffer + * self, GstClockTime group_start); + +GST_MSE_PRIVATE +void gst_media_source_track_buffer_process_init_segment ( + GstMediaSourceTrackBuffer * self, gboolean sequence_mode); + +GST_MSE_PRIVATE +void gst_media_source_track_buffer_add (GstMediaSourceTrackBuffer * self, + GstSample * sample); + +GST_MSE_PRIVATE +void gst_media_source_track_buffer_remove (GstMediaSourceTrackBuffer * self, + GstSample * sample); + +GST_MSE_PRIVATE +gsize +gst_media_source_track_buffer_remove_range (GstMediaSourceTrackBuffer * self, + GstClockTime start, GstClockTime end); + +GST_MSE_PRIVATE +void gst_media_source_track_buffer_clear (GstMediaSourceTrackBuffer * self); + +GST_MSE_PRIVATE +void gst_media_source_track_buffer_eos (GstMediaSourceTrackBuffer * self); + +GST_MSE_PRIVATE +gboolean gst_media_source_track_buffer_is_eos ( + GstMediaSourceTrackBuffer * self); + +GST_MSE_PRIVATE +gboolean gst_media_source_track_buffer_await_eos_until ( + GstMediaSourceTrackBuffer * self, gint64 deadline); + +GST_MSE_PRIVATE +gsize gst_media_source_track_buffer_get_storage_size ( + GstMediaSourceTrackBuffer * self); + +GST_MSE_PRIVATE +GstIterator * gst_media_source_track_buffer_iter_samples ( + GstMediaSourceTrackBuffer * buffer, GstClockTime start_dts, + GstSample * start_sample); + +G_END_DECLS diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasourcetrackbuffer.c b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasourcetrackbuffer.c new file mode 100644 index 0000000000..a73bdc0901 --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasourcetrackbuffer.c @@ -0,0 +1,377 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2022, 2023 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gstmediasourcetrackbuffer-private.h" +#include "gstmediasourcesamplemap-private.h" +#include "gstmediasource.h" +#include "gstmselogging-private.h" + +typedef struct +{ + gboolean enabled; + GstClockTime group_start; + GstClockTime group_end; + GstClockTimeDiff offset; + + GstClockTime last_dts; + GstClockTime last_duration; +} Timestamps; + +struct _GstMediaSourceTrackBuffer +{ + GstObject parent_instance; + + GstMediaSourceSampleMap *samples; + Timestamps timestamps; + guint eos; + + guint32 master_cookie; + + GCond new_data_cond; + GMutex new_data_mutex; +}; + +#define g_array_new_ranges() \ + (g_array_new (TRUE, FALSE, sizeof (GstMediaSourceRange))) + +#define NEW_DATA_LOCK(a) (g_mutex_lock (&a->new_data_mutex)) +#define NEW_DATA_UNLOCK(a) (g_mutex_unlock (&a->new_data_mutex)) +#define NEW_DATA_SIGNAL(a) (g_cond_signal (&a->new_data_cond)) +#define NEW_DATA_WAIT(a) (g_cond_wait (&a->new_data_cond, &a->new_data_mutex)) +#define NEW_DATA_WAIT_UNTIL(a, d) \ + (g_cond_wait_until (&a->new_data_cond, &a->new_data_mutex, d)) + +static void timestamps_init (Timestamps * self, gboolean enabled); +static void timestamps_process (Timestamps * self, GstSample * sample); + +G_DEFINE_TYPE (GstMediaSourceTrackBuffer, gst_media_source_track_buffer, + GST_TYPE_OBJECT); + +static void +invalidate_cookie (GstMediaSourceTrackBuffer * self) +{ + self->master_cookie++; +} + +GstMediaSourceTrackBuffer * +gst_media_source_track_buffer_new (void) +{ + return gst_object_ref_sink (g_object_new (GST_TYPE_MEDIA_SOURCE_TRACK_BUFFER, + NULL)); +} + +static void +gst_media_source_track_buffer_finalize (GObject * object) +{ + GstMediaSourceTrackBuffer *self = GST_MEDIA_SOURCE_TRACK_BUFFER (object); + gst_object_unref (self->samples); + g_cond_clear (&self->new_data_cond); + g_mutex_clear (&self->new_data_mutex); + G_OBJECT_CLASS (gst_media_source_track_buffer_parent_class)->finalize + (object); +} + +static void +gst_media_source_track_buffer_class_init (GstMediaSourceTrackBufferClass * + klass) +{ + GObjectClass *oclass = G_OBJECT_CLASS (klass); + + oclass->finalize = GST_DEBUG_FUNCPTR (gst_media_source_track_buffer_finalize); +} + +static void +gst_media_source_track_buffer_init (GstMediaSourceTrackBuffer * self) +{ + self->samples = gst_media_source_sample_map_new (); + self->eos = FALSE; + self->master_cookie = 0; + timestamps_init (&self->timestamps, FALSE); + g_cond_init (&self->new_data_cond); + g_mutex_init (&self->new_data_mutex); +} + +void +gst_media_source_track_buffer_process_init_segment (GstMediaSourceTrackBuffer + * self, gboolean sequence_mode) +{ + NEW_DATA_LOCK (self); + + timestamps_init (&self->timestamps, sequence_mode); + + NEW_DATA_UNLOCK (self); +} + +void +gst_media_source_track_buffer_set_group_start (GstMediaSourceTrackBuffer + * self, GstClockTime group_start) +{ + g_return_if_fail (GST_IS_MEDIA_SOURCE_TRACK_BUFFER (self)); + if (self->timestamps.enabled) { + self->timestamps.group_start = group_start; + } +} + +void +gst_media_source_track_buffer_add (GstMediaSourceTrackBuffer * self, + GstSample * sample) +{ + g_return_if_fail (GST_IS_MEDIA_SOURCE_TRACK_BUFFER (self)); + g_return_if_fail (GST_IS_SAMPLE (sample)); + + NEW_DATA_LOCK (self); + + timestamps_process (&self->timestamps, sample); + gst_media_source_sample_map_add (self->samples, sample); + invalidate_cookie (self); + + NEW_DATA_SIGNAL (self); + NEW_DATA_UNLOCK (self); +} + +void +gst_media_source_track_buffer_remove (GstMediaSourceTrackBuffer * self, + GstSample * sample) +{ + g_return_if_fail (GST_IS_MEDIA_SOURCE_TRACK_BUFFER (self)); + g_return_if_fail (GST_IS_SAMPLE (sample)); + + NEW_DATA_LOCK (self); + + gst_media_source_sample_map_remove (self->samples, sample); + invalidate_cookie (self); + + NEW_DATA_SIGNAL (self); + NEW_DATA_UNLOCK (self); +} + +gsize +gst_media_source_track_buffer_remove_range (GstMediaSourceTrackBuffer * self, + GstClockTime earliest, GstClockTime latest) +{ + NEW_DATA_LOCK (self); + gsize size = gst_media_source_sample_map_remove_range (self->samples, + earliest, latest); + invalidate_cookie (self); + NEW_DATA_SIGNAL (self); + NEW_DATA_UNLOCK (self); + return size; +} + +void +gst_media_source_track_buffer_clear (GstMediaSourceTrackBuffer * self) +{ + g_return_if_fail (GST_IS_MEDIA_SOURCE_TRACK_BUFFER (self)); + + NEW_DATA_LOCK (self); + + g_set_object (&self->samples, gst_media_source_sample_map_new ()); + + NEW_DATA_SIGNAL (self); + NEW_DATA_UNLOCK (self); +} + +static gboolean +is_eos (GstMediaSourceTrackBuffer * self) +{ + return g_atomic_int_get (&self->eos); +} + +void +gst_media_source_track_buffer_eos (GstMediaSourceTrackBuffer * self) +{ + g_return_if_fail (GST_IS_MEDIA_SOURCE_TRACK_BUFFER (self)); + NEW_DATA_LOCK (self); + g_atomic_int_set (&self->eos, TRUE); + NEW_DATA_SIGNAL (self); + NEW_DATA_UNLOCK (self); +} + +gboolean +gst_media_source_track_buffer_is_eos (GstMediaSourceTrackBuffer * self) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE_TRACK_BUFFER (self), FALSE); + return is_eos (self); +} + +gboolean +gst_media_source_track_buffer_await_eos_until (GstMediaSourceTrackBuffer * self, + gint64 deadline) +{ + NEW_DATA_LOCK (self); + while (!is_eos (self) && NEW_DATA_WAIT_UNTIL (self, deadline)) { + /* wait */ + } + NEW_DATA_UNLOCK (self); + return is_eos (self); +} + +gint +gst_media_source_track_buffer_get_size (GstMediaSourceTrackBuffer * self) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE_TRACK_BUFFER (self), 0); + return gst_media_source_sample_map_get_size (self->samples); +} + +GstClockTime +gst_media_source_track_buffer_get_highest_end_time (GstMediaSourceTrackBuffer + * self) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE_TRACK_BUFFER (self), + GST_CLOCK_TIME_NONE); + return gst_media_source_sample_map_get_highest_end_time (self->samples); +} + +typedef struct +{ + GArray *ranges; + GstMediaSourceRange current_range; +} GetRangesAccumulator; + +static gboolean +get_ranges_fold (const GValue * item, GetRangesAccumulator * acc, + gpointer user_data) +{ + GstSample *sample = gst_value_get_sample (item); + GstBuffer *buffer = gst_sample_get_buffer (sample); + GstClockTime start = GST_BUFFER_PTS (buffer); + GstClockTime end = start + GST_BUFFER_DURATION (buffer); + + GstMediaSourceRange *range = &acc->current_range; + + if (range->end == 0 || start <= (range->end + (GST_SECOND / 100))) { + range->end = end; + return TRUE; + } + g_array_append_val (acc->ranges, *range); + + range->start = start; + range->end = end; + + return TRUE; +} + +GArray * +gst_media_source_track_buffer_get_ranges (GstMediaSourceTrackBuffer * self) +{ + GetRangesAccumulator acc = { + .ranges = g_array_new_ranges (), + .current_range = {.start = 0,.end = 0}, + }; + + /* *INDENT-OFF* */ + GstIterator *iter = gst_media_source_sample_map_iter_samples_by_pts ( + self->samples, + &self->new_data_mutex, + &self->master_cookie, + 0, + NULL + ); + /* *INDENT-ON* */ + while (gst_iterator_fold (iter, (GstIteratorFoldFunction) get_ranges_fold, + (GValue *) & acc, NULL) == GST_ITERATOR_RESYNC) { + gst_iterator_resync (iter); + } + gst_iterator_free (iter); + + if (acc.current_range.end > 0) { + g_array_append_val (acc.ranges, acc.current_range); + } + + return acc.ranges; +} + +static void +timestamps_init (Timestamps * self, gboolean enabled) +{ + self->enabled = enabled; + self->group_start = GST_CLOCK_TIME_NONE; + self->group_end = GST_CLOCK_TIME_NONE; + self->offset = 0; + self->last_dts = 0; + self->last_duration = 0; +} + +static void +timestamps_process (Timestamps * self, GstSample * sample) +{ + if (!self->enabled) { + return; + } + + GstBuffer *buffer = gst_sample_get_buffer (sample); + GstClockTime duration = GST_BUFFER_DURATION (buffer); + + GstClockTime pts = 0; + GstClockTime dts = 0; + + if (GST_CLOCK_TIME_IS_VALID (self->group_start)) { + self->offset = self->group_start - pts; + self->group_end = self->group_start; + self->group_start = GST_CLOCK_TIME_NONE; + } + + if (self->offset != 0) { + pts += self->offset; + dts += self->offset; + } + + GstClockTime end_pts = pts + duration; + + self->last_dts = dts; + self->last_duration = duration; + + if (GST_CLOCK_TIME_IS_VALID (self->group_end)) { + self->group_end = MAX (self->group_end, end_pts); + } + self->offset = end_pts; + + GST_BUFFER_PTS (buffer) = pts; + GST_BUFFER_DTS (buffer) = dts; +} + +gsize +gst_media_source_track_buffer_get_storage_size (GstMediaSourceTrackBuffer * + self) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE_TRACK_BUFFER (self), 0); + return gst_media_source_sample_map_get_storage_size (self->samples); +} + +GstIterator * +gst_media_source_track_buffer_iter_samples (GstMediaSourceTrackBuffer * self, + GstClockTime start_dts, GstSample * start_sample) +{ + /* *INDENT-OFF* */ + return gst_media_source_sample_map_iter_samples_by_dts ( + self->samples, + &self->new_data_mutex, + &self->master_cookie, + start_dts, + start_sample + ); + /* *INDENT-ON* */ +} diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmseeventqueue-private.h b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmseeventqueue-private.h new file mode 100644 index 0000000000..9b0c9bbb23 --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmseeventqueue-private.h @@ -0,0 +1,46 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2023 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#pragma once + +#include +#include +#include + +G_BEGIN_DECLS + +typedef void (*GstMseEventQueueCallback) (GstDataQueueItem *, gpointer); + +#define GST_TYPE_MSE_EVENT_QUEUE (gst_mse_event_queue_get_type()) + +G_DECLARE_FINAL_TYPE (GstMseEventQueue, gst_mse_event_queue, GST, + MSE_EVENT_QUEUE, GstObject); + +GST_MSE_PRIVATE +GstMseEventQueue * gst_mse_event_queue_new (GstMseEventQueueCallback callback, + gpointer user_data); + +GST_MSE_PRIVATE +gboolean gst_mse_event_queue_push (GstMseEventQueue * self, + GstDataQueueItem * item); + +G_END_DECLS diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmseeventqueue.c b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmseeventqueue.c new file mode 100644 index 0000000000..b49e09c793 --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmseeventqueue.c @@ -0,0 +1,133 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2023 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include +#include + +#include "gstmseeventqueue-private.h" + +struct _GstMseEventQueue +{ + GstObject parent_instance; + + GstMseEventQueueCallback callback; + gpointer user_data; + + GstTask *task; + GRecMutex lock; + GstDataQueue *queue; +}; + +G_DEFINE_TYPE (GstMseEventQueue, gst_mse_event_queue, GST_TYPE_OBJECT); + +GstMseEventQueue * +gst_mse_event_queue_new (GstMseEventQueueCallback callback, gpointer user_data) +{ + g_return_val_if_fail (callback != NULL, NULL); + + GstMseEventQueue *self = g_object_new (GST_TYPE_MSE_EVENT_QUEUE, NULL); + + self->callback = callback; + self->user_data = user_data; + + gst_task_start (self->task); + + return g_object_ref_sink (self); +} + +static void +gst_mse_background_event_queue_dispose (GObject * obj) +{ + GstMseEventQueue *self = GST_MSE_EVENT_QUEUE (obj); + + gst_data_queue_set_flushing (self->queue, TRUE); + gst_data_queue_flush (self->queue); + + G_OBJECT_CLASS (gst_mse_event_queue_parent_class)->dispose (obj); +} + +static void +gst_mse_background_event_queue_finalize (GObject * obj) +{ + GstMseEventQueue *self = GST_MSE_EVENT_QUEUE (obj); + + gst_task_join (self->task); + g_rec_mutex_clear (&self->lock); + gst_clear_object (&self->task); + gst_clear_object (&self->queue); + + G_OBJECT_CLASS (gst_mse_event_queue_parent_class)->finalize (obj); +} + +void +gst_mse_event_queue_class_init (GstMseEventQueueClass * klass) +{ + GObjectClass *oclass = G_OBJECT_CLASS (klass); + + oclass->dispose = GST_DEBUG_FUNCPTR (gst_mse_background_event_queue_dispose); + oclass->finalize = + GST_DEBUG_FUNCPTR (gst_mse_background_event_queue_finalize); +} + +static void +task_func (GstMseEventQueue * self) +{ + GstTask *task = self->task; + GstDataQueue *queue = self->queue; + GstDataQueueItem *item = NULL; + if (!gst_data_queue_pop (queue, &item)) { + gst_task_stop (task); + return; + } + self->callback (item, self->user_data); + if (item->destroy) { + item->destroy (item); + } +} + +static gboolean +never_full (GstDataQueue * queue, guint visible, guint bytes, guint64 time, + gpointer user_data) +{ + return FALSE; +} + +void +gst_mse_event_queue_init (GstMseEventQueue * self) +{ + self->queue = gst_data_queue_new (never_full, NULL, NULL, NULL); + self->task = gst_task_new ((GstTaskFunction) task_func, self, NULL); + g_rec_mutex_init (&self->lock); + gst_task_set_lock (self->task, &self->lock); +} + +gboolean +gst_mse_event_queue_push (GstMseEventQueue * self, GstDataQueueItem * item) +{ + g_return_val_if_fail (GST_IS_MSE_EVENT_QUEUE (self), FALSE); + g_return_val_if_fail (item != NULL, FALSE); + return gst_data_queue_push (self->queue, item); +} diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmselogging-private.h b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmselogging-private.h new file mode 100644 index 0000000000..160d1a3606 --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmselogging-private.h @@ -0,0 +1,33 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2022, 2023 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#pragma once + +#include + +#define GST_CAT_DEFAULT gst_mse_debug + +G_GNUC_INTERNAL +GST_DEBUG_CATEGORY_EXTERN (gst_mse_debug); + +G_GNUC_INTERNAL +void gst_mse_init_logging (void); diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmselogging.c b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmselogging.c new file mode 100644 index 0000000000..0664b8a553 --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmselogging.c @@ -0,0 +1,35 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2022, 2023 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gstmselogging-private.h" + +GST_DEBUG_CATEGORY (gst_mse_debug); + +void +gst_mse_init_logging (void) +{ + GST_DEBUG_CATEGORY_INIT (gst_mse_debug, "gst-mse", 0, "GstMse"); +} diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmsemediatype-private.h b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmsemediatype-private.h new file mode 100644 index 0000000000..dfdb537f35 --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmsemediatype-private.h @@ -0,0 +1,60 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2022, 2023 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#pragma once + +#include +#include +#include + +G_BEGIN_DECLS + +typedef struct +{ + gchar *mime_type; + GStrv codecs; +} GstMediaSourceMediaType; + +#define GST_MEDIA_SOURCE_MEDIA_TYPE_INIT { 0 } + +GST_MSE_PRIVATE +gboolean gst_media_source_media_type_parse (GstMediaSourceMediaType * self, + const gchar * type); + +GST_MSE_PRIVATE +gboolean gst_media_source_media_type_is_caps_supported (const GstCaps * caps); + +GST_MSE_PRIVATE +gboolean gst_media_source_media_type_is_supported ( + GstMediaSourceMediaType * self); + +GST_MSE_PRIVATE +gboolean gst_media_source_media_type_generates_timestamp ( + GstMediaSourceMediaType * self); + +GST_MSE_PRIVATE +void gst_media_source_media_type_reset (GstMediaSourceMediaType * self); + +GST_MSE_PRIVATE +void gst_media_source_media_type_free (GstMediaSourceMediaType * self); + +G_END_DECLS diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmsemediatype.c b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmsemediatype.c new file mode 100644 index 0000000000..85c19fa7ab --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmsemediatype.c @@ -0,0 +1,544 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2019 Igalia S.L. + * Copyright (C) 2022, 2023 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include +#include + +#include "gstmsemediatype-private.h" + +static const gchar tspecials[] = { + '(', ')', '<', '>', '@', ',', ';', ':', + '\\', '"', '/', '[', ']', '?', '=', + 0, +}; + +static gboolean +is_tspecial (const gchar c) +{ + for (const gchar * tspecial = tspecials; *tspecial != 0; tspecial++) { + if (*tspecial == c) { + return TRUE; + } + } + return FALSE; +} + +static gboolean +is_token_character (const gchar c) +{ + if (g_ascii_iscntrl (c) || is_tspecial (c)) { + return FALSE; + } + return g_ascii_isgraph (c); +} + +static gboolean +is_ascii (const gchar c) +{ + return c > 0 && c <= G_MAXINT8; +} + +static gboolean +is_eos (const gchar c) +{ + return c == '\0'; +} + +static void +ignore_whitespace (const gchar ** input) +{ + g_return_if_fail (input != NULL); + + const gchar *output; + for (output = *input; g_ascii_isspace (*output); output++) { + } + *input = output; +} + +static gboolean +any_of (const gchar ** input, const gchar ** choices, gchar ** value) +{ + g_return_val_if_fail (input != NULL, FALSE); + g_return_val_if_fail (choices != NULL, FALSE); + g_return_val_if_fail (value != NULL, FALSE); + + for (const gchar ** choice = choices; *choice != NULL; choice++) { + gulong prefix_length = strlen (*choice); + if (g_str_has_prefix (*input, *choice)) { + *value = g_strndup (*input, prefix_length); + *input += prefix_length; + return TRUE; + } + } + return FALSE; +} + +static gboolean +literal (const gchar ** input, const gchar * value) +{ + g_return_val_if_fail (input != NULL, FALSE); + g_return_val_if_fail (value != NULL, FALSE); + + if (!g_str_has_prefix (*input, value)) { + return FALSE; + } + *input += strlen (value); + return TRUE; +} + +static gboolean +token (const gchar ** input, gchar ** value) +{ + g_return_val_if_fail (input != NULL, FALSE); + g_return_val_if_fail (value != NULL, FALSE); + + const gchar *unparsed = *input; + for (; is_token_character (unparsed[0]); unparsed++) { + } + gsize length = unparsed - *input; + if (length < 1) { + return FALSE; + } + *value = g_strndup (*input, length); + *input = unparsed; + return TRUE; +} + +static gboolean +quoted_string_char (const gchar ** input, gchar * value) +{ + g_return_val_if_fail (input != NULL, FALSE); + g_return_val_if_fail (value != NULL, FALSE); + + const gchar *unparsed = *input; + char c = unparsed[0]; + if (!is_ascii (c)) { + return FALSE; + } + + if (c == '"' || c == '\\' || c == '\r') { + return FALSE; + } + + *value = c; + (*input)++; + return TRUE; +} + +static gboolean +escaped_ascii_char (const gchar ** input, gchar * value) +{ + g_return_val_if_fail (input != NULL, FALSE); + g_return_val_if_fail (value != NULL, FALSE); + + if (!literal (input, "\\")) { + return FALSE; + } + + gchar c = (*input)[0]; + if (!is_ascii (c)) { + return FALSE; + } + + *value = c; + (*input)++; + return TRUE; +} + +static gboolean +quoted_string (const gchar ** input, gchar ** value) +{ + g_return_val_if_fail (input != NULL, FALSE); + g_return_val_if_fail (value != NULL, FALSE); + + const gchar *unparsed = *input; + if (!literal (&unparsed, "\"")) { + return FALSE; + } + + GString *string_value = g_string_new (NULL); + for (;;) { + if (literal (&unparsed, "\"")) { + *input = unparsed; + *value = g_string_free (string_value, FALSE); + return TRUE; + } + + if (is_eos (unparsed[0])) { + goto error; + } + + gchar c; + + if (quoted_string_char (&unparsed, &c)) { + g_string_append_c (string_value, c); + continue; + } + + if (escaped_ascii_char (&unparsed, &c)) { + g_string_append_c (string_value, c); + continue; + } + + goto error; + } +error: + g_string_free (string_value, TRUE); + return FALSE; +} + +static const gchar *discrete_media_types[] = { + "text", + "image", + "audio", + "video", + "application", + NULL, +}; + +static gboolean +discrete_media_type (const gchar ** input, gchar ** value) +{ + return any_of (input, discrete_media_types, value); +} + +static gboolean +composite_media_type (const gchar ** input, gchar ** value) +{ + return token (input, value); +} + +static gboolean +media_type_parameter (const gchar ** input, gchar ** param_name, + gchar ** param_value) +{ + g_return_val_if_fail (input != NULL, FALSE); + g_return_val_if_fail (param_name != NULL, FALSE); + g_return_val_if_fail (param_value != NULL, FALSE); + + ignore_whitespace (input); + if (!token (input, param_name)) { + return FALSE; + } + if (!literal (input, "=")) { + return FALSE; + } + if (!token (input, param_value)) { + if (!quoted_string (input, param_value)) { + return FALSE; + } + } + ignore_whitespace (input); + return TRUE; +} + +static gboolean +media_type (const gchar ** input, gchar ** value) +{ + g_return_val_if_fail (input != NULL, FALSE); + g_return_val_if_fail (value != NULL, FALSE); + + gchar *discrete = NULL; + gchar *composite = NULL; + + if (!discrete_media_type (input, &discrete)) { + goto error; + } + if (!literal (input, "/")) { + goto error; + } + if (!composite_media_type (input, &composite)) { + goto error; + } + + *value = g_strdup_printf ("%s/%s", discrete, composite); + g_clear_pointer (&discrete, g_free); + g_clear_pointer (&composite, g_free); + return TRUE; + +error: + g_clear_pointer (&discrete, g_free); + g_clear_pointer (&composite, g_free); + return FALSE; +} + +static gboolean +media_type_codecs (const gchar ** input, gchar *** codecs) +{ + g_return_val_if_fail (input != NULL, FALSE); + g_return_val_if_fail (codecs != NULL, FALSE); + + gchar *param_name = NULL; + gchar *codecs_value = NULL; + while (!is_eos (*input[0]) + && media_type_parameter (input, ¶m_name, &codecs_value)) { + gboolean is_codecs = g_strcmp0 (param_name, "codecs") == 0; + g_clear_pointer (¶m_name, g_free); + if (is_codecs) { + break; + } + g_clear_pointer (&codecs_value, g_free); + } + if (codecs_value == NULL) { + return TRUE; + } + + gchar **codec_names = g_strsplit (codecs_value, ",", 0); + guint n_codecs = g_strv_length (codec_names); + GPtrArray *codecs_array = g_ptr_array_new_full (n_codecs, NULL); + for (guint i = 0; i < n_codecs; i++) { + gchar *codec = g_strstrip (g_strdup (codec_names[i])); + if (g_strcmp0 (codec, "") != 0) { + g_ptr_array_add (codecs_array, g_strdup (codec)); + } + g_clear_pointer (&codec, g_free); + } + g_ptr_array_add (codecs_array, NULL); + *codecs = (gchar **) g_ptr_array_free (codecs_array, FALSE); + + g_clear_pointer (&codecs_value, g_free); + g_strfreev (codec_names); + + return TRUE; +} + +gboolean +gst_media_source_media_type_parse (GstMediaSourceMediaType * self, + const gchar * type) +{ + g_return_val_if_fail (self != NULL, FALSE); + g_return_val_if_fail (type != NULL, FALSE); + + gchar *lowercase = g_ascii_strdown (type, -1); + const gchar *input = lowercase; + + ignore_whitespace (&input); + if (!media_type (&input, &self->mime_type)) { + g_free (lowercase); + return FALSE; + } + self->codecs = NULL; + ignore_whitespace (&input); + if (is_eos (input[0])) { + g_free (lowercase); + return TRUE; + } + if (!literal (&input, ";")) { + g_free (lowercase); + return TRUE; + } + ignore_whitespace (&input); + media_type_codecs (&input, &self->codecs); + g_free (lowercase); + return TRUE; +} + +static inline gboolean +has_any_prefix (const gchar * str, const gchar * prefix, ...) +{ + if (g_str_has_prefix (str, prefix)) { + return TRUE; + } + + va_list varargs; + + va_start (varargs, prefix); + for (const gchar * arg = va_arg (varargs, const gchar *); arg != NULL; + arg = va_arg (varargs, const gchar *)) + { + if (g_str_has_prefix (str, arg)) { + va_end (varargs); + return TRUE; + } + } + va_end (varargs); + return FALSE; +} + +static const gchar * +patch_media_type (const gchar * media_type) +{ + if (g_strcmp0 (media_type, "video/mp4") == 0) { + return "video/quicktime"; + } + if (g_strcmp0 (media_type, "audio/mp4") == 0 || + g_strcmp0 (media_type, "audio/aac") == 0) { + return "audio/x-m4a"; + } + if (!has_any_prefix (media_type, "audio/", "video/", NULL)) { + return NULL; + } + return media_type; +} + +static GstStaticCaps h264_caps = GST_STATIC_CAPS ("video/x-h264"); +static GstStaticCaps h265_caps = GST_STATIC_CAPS ("video/x-h265"); +static GstStaticCaps av1_caps = GST_STATIC_CAPS ("video/x-av1"); +static GstStaticCaps vp8_caps = GST_STATIC_CAPS ("video/x-vp8"); +static GstStaticCaps vp9_caps = GST_STATIC_CAPS ("video/x-vp9"); + +static GstStaticCaps vorbis_caps = GST_STATIC_CAPS ("audio/x-vorbis"); +static GstStaticCaps opus_caps = GST_STATIC_CAPS ("audio/x-opus"); +static GstStaticCaps flac_caps = GST_STATIC_CAPS ("audio/x-flac"); +static GstStaticCaps mp3_caps = +GST_STATIC_CAPS ("audio/mpeg, mpegversion=(int)1, layer=(int)3"); +static GstStaticCaps aac_caps = +GST_STATIC_CAPS ("audio/mpeg, mpegversion=(int)4"); + +static inline GstStaticCaps * +mse_codec_id_to_static_caps (const gchar * codec_id) +{ + if (has_any_prefix (codec_id, "avc", "x-h264", "mp4v", NULL)) { + return &h264_caps; + } + if (has_any_prefix (codec_id, "hvc1", "hev1", "x-h265", NULL)) { + return &h265_caps; + } + if (has_any_prefix (codec_id, "av01", "av1", "x-av1", NULL)) { + return &av1_caps; + } + if (has_any_prefix (codec_id, "vp8", "x-vp8", NULL)) { + return &vp8_caps; + } + if (has_any_prefix (codec_id, "vp9", "vp09", "x-vp9", NULL)) { + return &vp9_caps; + } + + if (has_any_prefix (codec_id, "mpeg", "mp4a", NULL)) { + return &aac_caps; + } + if (has_any_prefix (codec_id, "vorbis", "x-vorbis", NULL)) { + return &vorbis_caps; + } + if (has_any_prefix (codec_id, "opus", "x-opus", NULL)) { + return &opus_caps; + } + if (has_any_prefix (codec_id, "flac", "x-flac", NULL)) { + return &flac_caps; + } + if (has_any_prefix (codec_id, "mp3", "audio/mp3", NULL)) { + return &mp3_caps; + } + + return NULL; +} + +static gboolean +is_supported (const GstCaps * caps, GList * elements) +{ + GList *supporting_elements = gst_element_factory_list_filter (elements, caps, + GST_PAD_SINK, FALSE); + gboolean supported = supporting_elements != NULL; + gst_plugin_feature_list_free (supporting_elements); + return supported; +} + +static gboolean +is_codec_supported (const gchar * codec_id, GList * elements) +{ + GstStaticCaps *static_caps = mse_codec_id_to_static_caps (codec_id); + if (static_caps == NULL) { + return FALSE; + } + GstCaps *codec_caps = gst_static_caps_get (static_caps); + gboolean supported = is_supported (codec_caps, elements); + gst_clear_caps (&codec_caps); + return supported; +} + +static inline GList * +get_srcpad_elements (void) +{ + return gst_element_factory_list_get_elements (GST_ELEMENT_FACTORY_TYPE_DEMUXER + | GST_ELEMENT_FACTORY_TYPE_DECODER | GST_ELEMENT_FACTORY_TYPE_DECRYPTOR | + GST_ELEMENT_FACTORY_TYPE_DEPAYLOADER | GST_ELEMENT_FACTORY_TYPE_SINK | + GST_ELEMENT_FACTORY_TYPE_PARSER, GST_RANK_MARGINAL); +} + +gboolean +gst_media_source_media_type_is_caps_supported (const GstCaps * caps) +{ + GList *elements = get_srcpad_elements (); + gboolean supported = is_supported (caps, elements); + gst_plugin_feature_list_free (elements); + return supported; +} + +gboolean +gst_media_source_media_type_is_supported (GstMediaSourceMediaType * self) +{ + g_return_val_if_fail (self != NULL, FALSE); + g_return_val_if_fail (self->mime_type != NULL, FALSE); + + const gchar *mime_type = patch_media_type (self->mime_type); + if (mime_type == NULL) { + return FALSE; + } + + GList *elements = get_srcpad_elements (); + GstCaps *caps = gst_caps_from_string (mime_type); + + gboolean supported = is_supported (caps, elements); + for (gchar ** codec_id = self->codecs; + supported && codec_id && *codec_id; codec_id++) { + supported &= is_codec_supported (*codec_id, elements); + } + + gst_plugin_feature_list_free (elements); + gst_clear_caps (&caps); + + return supported; +} + +static const gchar *generate_timestamps_formats[] = { + "audio/mpeg", + "audio/aac", + NULL, +}; + +gboolean +gst_media_source_media_type_generates_timestamp (GstMediaSourceMediaType * self) +{ + g_return_val_if_fail (self != NULL, FALSE); + g_return_val_if_fail (self->mime_type != NULL, FALSE); + return g_strv_contains (generate_timestamps_formats, self->mime_type); +} + +void +gst_media_source_media_type_reset (GstMediaSourceMediaType * self) +{ + g_return_if_fail (self != NULL); + g_clear_pointer (&self->mime_type, g_free); + g_clear_pointer (&self->codecs, g_strfreev); +} + +void +gst_media_source_media_type_free (GstMediaSourceMediaType * self) +{ + gst_media_source_media_type_reset (self); + g_free (self); +} diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmsesrc-private.h b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmsesrc-private.h new file mode 100644 index 0000000000..b40b0a6553 --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmsesrc-private.h @@ -0,0 +1,55 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2022, 2023 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#pragma once + +#include +#include +#include "gstmsesrc.h" +#include "gstmediasource.h" +#include "gstmediasourcetrack-private.h" + +G_BEGIN_DECLS + +GST_MSE_PRIVATE +void gst_mse_src_set_duration (GstMseSrc * self, GstClockTime duration); + +GST_MSE_PRIVATE +void gst_mse_src_network_error (GstMseSrc * self); + +GST_MSE_PRIVATE +void gst_mse_src_decode_error (GstMseSrc * self); + +GST_MSE_PRIVATE +void gst_mse_src_emit_streams (GstMseSrc * self, GstMediaSourceTrack ** tracks, + gsize n_tracks); + +GST_MSE_PRIVATE +void gst_mse_src_update_ready_state (GstMseSrc * self); + +GST_MSE_PRIVATE +void gst_mse_src_attach (GstMseSrc * self, GstMediaSource * media_source); + +GST_MSE_PRIVATE +void gst_mse_src_detach (GstMseSrc * self); + +G_END_DECLS diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmsesrc.c b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmsesrc.c new file mode 100644 index 0000000000..96e07062ca --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmsesrc.c @@ -0,0 +1,1385 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2009, 2010 Sebastian Dröge + * Copyright (C) 2013, 2022, 2023 Collabora Ltd. + * Copyright (C) 2013 Orange + * Copyright (C) 2014, 2015 Sebastian Dröge + * Copyright (C) 2015, 2016, 2018, 2019, 2020, 2021 Igalia, S.L + * Copyright (C) 2015, 2016, 2018, 2019, 2020, 2021 Metrological Group B.V. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +/** + * SECTION:gstmsesrc + * @title: GstMseSrc + * @short_description: Source Element for Media Source playback + * + * #GstMseSrc is a source Element that interacts with a #GstMediaSource to + * consume #GstSamples processed by the Media Source and supplies them + * to the containing #GstPipeline. In the perspective of the Media Source API, + * this element fulfills the basis of the Media Element's role relating to + * working with a Media Source. The remaining responsibilities are meant to be + * fulfilled by the application and #GstPlay can be used to satisfy many of + * them. + * + * Once added to a Pipeline, this element should be attached to a Media Source + * using gst_media_source_attach(). + * + * Since: 1.24 + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include +#include + +#include +#include "gstmsesrc.h" +#include "gstmsesrc-private.h" + +#include "gstmselogging-private.h" + +#include "gstmediasource.h" +#include "gstmediasource-private.h" +#include "gstmediasourcetrack-private.h" +#include "gstsourcebuffer.h" +#include "gstsourcebuffer-private.h" + +#define DEFAULT_POSITION GST_CLOCK_TIME_NONE +#define DEFAULT_DURATION GST_CLOCK_TIME_NONE +#define DEFAULT_READY_STATE GST_MSE_SRC_READY_STATE_HAVE_NOTHING +#define DECODE_ERROR "decode error" +#define NETWORK_ERROR "network error" + +enum +{ + PROP_0, + + PROP_POSITION, + PROP_DURATION, + PROP_READY_STATE, + + PROP_N_AUDIO, + PROP_N_TEXT, + PROP_N_VIDEO, + + N_PROPS, +}; + +enum +{ + THRESHOLD_FUTURE_DATA = GST_SECOND * 5, + THRESHOLD_ENOUGH_DATA = GST_SECOND * 50, +}; + +static GParamSpec *properties[N_PROPS]; + +static GstStaticPadTemplate gst_mse_src_template = +GST_STATIC_PAD_TEMPLATE ("src_%s", GST_PAD_SRC, GST_PAD_SOMETIMES, + GST_STATIC_CAPS_ANY); + +/** + * GstMseSrcPad: + * + * Since: 1.24 + */ +struct _GstMseSrcPad +{ + GstPad base; + + GstStream *stream; + GstMediaSourceTrack *track; + GstCaps *most_recent_caps; + GstSegment segment; + + GstClockTime position; + + gboolean sent_stream_collection; + gboolean sent_stream_start; + gboolean sent_initial_caps; + gboolean does_need_segment; + + GCond linked_or_flushing_cond; + GMutex linked_or_flushing_lock; + gboolean flushing; + gboolean eos; +}; + +#define STREAMS_LOCK(a) (g_mutex_lock (&a->streams_lock)) +#define STREAMS_UNLOCK(a) (g_mutex_unlock (&a->streams_lock)) + +#define LINKED_OR_FLUSHING_LOCK(a) (g_mutex_lock (&a->linked_or_flushing_lock)) +#define LINKED_OR_FLUSHING_UNLOCK(a) (g_mutex_unlock (&a->linked_or_flushing_lock)) +#define LINKED_OR_FLUSHING_SIGNAL(a) (g_cond_signal (&a->linked_or_flushing_cond)) +#define LINKED_OR_FLUSHING_WAIT(a) \ + (g_cond_wait (&a->linked_or_flushing_cond, &a->linked_or_flushing_lock)) + +#define FLOW_COMBINER_LOCK(a) (g_mutex_lock (&a->flow_combiner_lock)) +#define FLOW_COMBINER_UNLOCK(a) (g_mutex_unlock (&a->flow_combiner_lock)) + +G_DEFINE_TYPE (GstMseSrcPad, gst_mse_src_pad, GST_TYPE_PAD); + +static gboolean pad_activate_mode (GstMseSrcPad * pad, GstObject * parent, + GstPadMode mode, gboolean active); + +static GstPadLinkReturn pad_linked (GstMseSrcPad * pad, GstMseSrc * parent, + GstPad * sink); +static gboolean pad_event (GstMseSrcPad * pad, GstMseSrc * parent, + GstEvent * event); +static gboolean pad_query (GstMseSrcPad * pad, GstObject * parent, + GstQuery * query); +static void pad_task (GstMseSrcPad * pad); + +static GstPad * +gst_mse_src_pad_new (GstMediaSourceTrack * track, GstStream * stream, + guint id, GstClockTime start, gdouble rate) +{ + gchar *name = g_strdup_printf ("src_%u", id); + GstMseSrcPad *self = g_object_new (GST_TYPE_MSE_SRC_PAD, "name", name, + "direction", GST_PAD_SRC, NULL); + g_free (name); + self->stream = stream; + self->track = track; + self->segment.start = start; + self->segment.rate = rate; + + return GST_PAD (self); +} + +static void +gst_mse_src_pad_init (GstMseSrcPad * self) +{ + gst_segment_init (&self->segment, GST_FORMAT_TIME); + self->sent_stream_collection = FALSE; + self->sent_stream_start = FALSE; + self->sent_initial_caps = FALSE; + self->does_need_segment = TRUE; + self->position = DEFAULT_POSITION; + self->flushing = FALSE; + self->eos = FALSE; + g_mutex_init (&self->linked_or_flushing_lock); + g_cond_init (&self->linked_or_flushing_cond); + + gst_pad_set_activatemode_function (GST_PAD (self), + (GstPadActivateModeFunction) pad_activate_mode); + gst_pad_set_link_function (GST_PAD (self), (GstPadLinkFunction) pad_linked); + gst_pad_set_event_function (GST_PAD (self), (GstPadEventFunction) pad_event); + gst_pad_set_query_function (GST_PAD (self), (GstPadQueryFunction) pad_query); +} + +static void +gst_mse_src_pad_finalize (GObject * object) +{ + GstMseSrcPad *self = GST_MSE_SRC_PAD (object); + + gst_clear_caps (&self->most_recent_caps); + g_mutex_clear (&self->linked_or_flushing_lock); + g_cond_clear (&self->linked_or_flushing_cond); + + G_OBJECT_CLASS (gst_mse_src_pad_parent_class)->finalize (object); +} + +static void +gst_mse_src_pad_class_init (GstMseSrcPadClass * klass) +{ + GObjectClass *oclass = G_OBJECT_CLASS (klass); + oclass->finalize = GST_DEBUG_FUNCPTR (gst_mse_src_pad_finalize); +} + +// TODO: Check if this struct is even necessary. +// The custom pad should be able to keep track of information for each track. +typedef struct +{ + GstMediaSourceTrack *track; + GstPad *pad; + GstStream *info; +} Stream; + +/** + * GstMseSrc: + * + * Since: 1.24 + */ +struct _GstMseSrc +{ + GstElement base; + + GstMediaSource *media_source; + + guint group_id; + GstStreamCollection *collection; + GHashTable *streams; + GMutex streams_lock; + + GstClockTime duration; + GstClockTime start_time; + gdouble rate; + GstMseSrcReadyState ready_state; + + GstFlowCombiner *flow_combiner; + GMutex flow_combiner_lock; + + GCond eos_cond; + GMutex eos_lock; + + gchar *uri; +}; + +static void gst_mse_src_uri_handler_init (gpointer g_iface, + gpointer iface_data); +static GstStateChangeReturn gst_mse_src_change_state (GstElement * element, + GstStateChange transition); +static gboolean gst_mse_src_send_event (GstElement * element, GstEvent * event); +static void update_ready_state_for_init_segment (GstMseSrc * self); +static void update_ready_state_for_sample (GstMseSrc * self); + +G_DEFINE_TYPE_WITH_CODE (GstMseSrc, gst_mse_src, GST_TYPE_ELEMENT, + G_IMPLEMENT_INTERFACE (GST_TYPE_URI_HANDLER, gst_mse_src_uri_handler_init)); + +static void +gst_mse_src_constructed (GObject * object) +{ + GstMseSrc *self = GST_MSE_SRC (object); + GST_OBJECT_FLAG_SET (self, GST_ELEMENT_FLAG_SOURCE); +} + +static void +gst_mse_src_dispose (GObject * object) +{ + GstMseSrc *self = GST_MSE_SRC (object); + gst_clear_object (&self->collection); + g_clear_pointer (&self->streams, g_hash_table_unref); + g_mutex_clear (&self->streams_lock); + g_clear_pointer (&self->flow_combiner, gst_flow_combiner_free); + g_mutex_clear (&self->flow_combiner_lock); + g_cond_clear (&self->eos_cond); + g_mutex_clear (&self->eos_lock); + G_OBJECT_CLASS (gst_mse_src_parent_class)->dispose (object); +} + +static void +gst_mse_src_finalize (GObject * object) +{ + GstMseSrc *self = GST_MSE_SRC (object); + + g_clear_pointer (&self->uri, g_free); + + G_OBJECT_CLASS (gst_mse_src_parent_class)->finalize (object); +} + +static void +gst_mse_src_get_property (GObject * object, guint prop_id, GValue * value, + GParamSpec * pspec) +{ + GstMseSrc *self = GST_MSE_SRC (object); + + switch (prop_id) { + case PROP_DURATION: + g_value_set_uint64 (value, gst_mse_src_get_duration (self)); + break; + case PROP_POSITION: + g_value_set_uint64 (value, gst_mse_src_get_position (self)); + break; + case PROP_READY_STATE: + g_value_set_enum (value, gst_mse_src_get_ready_state (self)); + break; + case PROP_N_AUDIO: + g_value_set_uint (value, gst_mse_src_get_n_audio (self)); + break; + case PROP_N_TEXT: + g_value_set_uint (value, gst_mse_src_get_n_text (self)); + break; + case PROP_N_VIDEO: + g_value_set_uint (value, gst_mse_src_get_n_video (self)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gst_mse_src_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec) +{ + GstMseSrc *self = GST_MSE_SRC (object); + + switch (prop_id) { + case PROP_DURATION: + gst_mse_src_set_duration (self, g_value_get_uint64 (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gst_mse_src_class_init (GstMseSrcClass * klass) +{ + GObjectClass *oclass = (GObjectClass *) klass; + GstElementClass *eclass = (GstElementClass *) klass; + + oclass->constructed = GST_DEBUG_FUNCPTR (gst_mse_src_constructed); + oclass->finalize = GST_DEBUG_FUNCPTR (gst_mse_src_finalize); + oclass->dispose = GST_DEBUG_FUNCPTR (gst_mse_src_dispose); + oclass->get_property = GST_DEBUG_FUNCPTR (gst_mse_src_get_property); + oclass->set_property = GST_DEBUG_FUNCPTR (gst_mse_src_set_property); + + eclass->change_state = GST_DEBUG_FUNCPTR (gst_mse_src_change_state); + eclass->send_event = GST_DEBUG_FUNCPTR (gst_mse_src_send_event); + + /** + * GstMseSrc:position: + * + * The playback position as a #GstClockTime + * + * [Specification](https://html.spec.whatwg.org/multipage/media.html#current-playback-position) + * + * Since: 1.24 + */ + properties[PROP_POSITION] = g_param_spec_uint64 ("position", + "Position", + "The playback position as a GstClockTime", + 0, G_MAXUINT64, DEFAULT_POSITION, G_PARAM_READABLE | + G_PARAM_STATIC_STRINGS); + + /** + * GstMseSrc:duration: + * + * The duration of the stream as a #GstClockTime + * + * [Specification](https://html.spec.whatwg.org/multipage/media.html#dom-media-duration) + * + * Since: 1.24 + */ + properties[PROP_DURATION] = g_param_spec_uint64 ("duration", + "Duration", + "The duration of the stream as a GstClockTime", + 0, G_MAXUINT64, DEFAULT_DURATION, G_PARAM_READWRITE | + G_PARAM_STATIC_STRINGS); + + /** + * GstMseSrc:ready-state: + * + * The Ready State of this element, describing to what level it can supply + * content for the current #GstMseSrc:position. This is a separate concept + * from #GstMediaSource:ready-state: and corresponds to the HTML Media + * Element's Ready State. + * + * [Specification](https://html.spec.whatwg.org/multipage/media.html#ready-states) + * + * Since: 1.24 + */ + properties[PROP_READY_STATE] = g_param_spec_enum ("ready-state", + "Ready State", + "The Ready State of this Element", + GST_TYPE_MSE_SRC_READY_STATE, + DEFAULT_READY_STATE, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); + + /** + * GstMseSrc:n-audio: + * + * The number of audio tracks in the Media Source + * + * Since: 1.24 + */ + properties[PROP_N_AUDIO] = g_param_spec_uint ("n-audio", + "Number of Audio Tracks", + "The number of audio tracks in the Media Source", + 0, G_MAXINT, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); + + /** + * GstMseSrc:n-text: + * + * The number of text tracks in the Media Source + * + * Since: 1.24 + */ + properties[PROP_N_TEXT] = g_param_spec_uint ("n-text", + "Number of Text Tracks", + "The number of text tracks in the Media Source", + 0, G_MAXINT, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); + + /** + * GstMseSrc:n-video: + * + * The number of video tracks in the Media Source + * + * Since: 1.24 + */ + properties[PROP_N_VIDEO] = g_param_spec_uint ("n-video", + "Number of Video Tracks", + "The number of video tracks in the Media Source", + 0, G_MAXINT, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); + + g_object_class_install_properties (oclass, N_PROPS, properties); + + gst_element_class_set_static_metadata (eclass, "MseSrc", + "Generic/Source", + "Implements a GStreamer Source for the gstreamer-mse API", "Collabora"); + gst_element_class_add_static_pad_template (eclass, &gst_mse_src_template); + + gst_mse_init_logging (); +} + +static void +clear_stream (Stream * stream) +{ + gst_clear_object (&stream->track); + gst_clear_object (&stream->info); + g_free (stream); +} + +static GHashTable * +streams_init (const GstMseSrc * self) +{ + return g_hash_table_new_full (g_direct_hash, g_direct_equal, + NULL, (GDestroyNotify) clear_stream); +} + +static GstStreamCollection * +collection_init (const GstMseSrc * self) +{ + return gst_stream_collection_new (G_OBJECT_TYPE_NAME (self)); +} + +static void +gst_mse_src_init (GstMseSrc * self) +{ + self->group_id = gst_util_group_id_next (); + self->streams = streams_init (self); + self->collection = collection_init (self); + self->uri = NULL; + self->start_time = 0; + self->rate = 1; + g_mutex_init (&self->streams_lock); + self->flow_combiner = gst_flow_combiner_new (); + g_mutex_init (&self->flow_combiner_lock); + g_cond_init (&self->eos_cond); + g_mutex_init (&self->eos_lock); +} + +/** + * gst_mse_src_get_position: + * @self: #GstMseSrc instance + * + * Gets the current playback position of @self. + * + * [Specification](https://html.spec.whatwg.org/multipage/media.html#current-playback-position) + * + * Returns: The playback position of this Element as a #GstClockTime + * Since: 1.24 + */ +GstClockTime +gst_mse_src_get_position (GstMseSrc * self) +{ + g_return_val_if_fail (GST_IS_MSE_SRC (self), GST_CLOCK_TIME_NONE); + gint64 position; + gboolean success = gst_element_query_position (GST_ELEMENT (self), + GST_FORMAT_TIME, &position); + if (success) + return (GstClockTime) position; + else + return DEFAULT_POSITION; +} + +static void +update_pad_duration (GstMseSrc * self, GstMseSrcPad * pad) +{ + pad->segment.duration = self->duration; + pad->does_need_segment = TRUE; +} + +void +gst_mse_src_set_duration (GstMseSrc * self, GstClockTime duration) +{ + g_return_if_fail (GST_IS_MSE_SRC (self)); + + self->duration = duration; + + gst_element_foreach_src_pad (GST_ELEMENT (self), + (GstElementForeachPadFunc) update_pad_duration, NULL); + + gst_element_post_message (GST_ELEMENT (self), + gst_message_new_duration_changed (GST_OBJECT (self))); +} + +/** + * gst_mse_src_get_duration: + * @self: #GstMseSrc instance + * + * Gets the duration of @self. + * + * [Specification](https://html.spec.whatwg.org/multipage/media.html#dom-media-duration) + * + * Returns: The duration of this stream as a #GstClockTime + * Since: 1.24 + */ +GstClockTime +gst_mse_src_get_duration (GstMseSrc * self) +{ + g_return_val_if_fail (GST_IS_MSE_SRC (self), DEFAULT_DURATION); + return self->duration; +} + +/** + * gst_mse_src_get_ready_state: + * @self: #GstMseSrc instance + * + * The Ready State of @self, describing to what level it can supply content for + * the current #GstMseSrc:position. This is a separate concept from + * #GstMediaSource:ready-state: and corresponds to the HTML Media Element's + * Ready State. + * + * [Specification](https://html.spec.whatwg.org/multipage/media.html#ready-states) + * + * Returns: the current #GstMseSrcReadyState + * Since: 1.24 + */ +GstMseSrcReadyState +gst_mse_src_get_ready_state (GstMseSrc * self) +{ + g_return_val_if_fail (GST_IS_MSE_SRC (self), DEFAULT_READY_STATE); + return self->ready_state; +} + +static guint +n_streams_by_type (GstMseSrc * self, GstMediaSourceTrackType type) +{ + guint count = 0; + GHashTableIter iter; + g_hash_table_iter_init (&iter, self->streams); + for (gpointer key; g_hash_table_iter_next (&iter, &key, NULL);) { + GstMediaSourceTrack *track = GST_MEDIA_SOURCE_TRACK (key); + GstMediaSourceTrackType stream_type = + gst_media_source_track_get_track_type (track); + if (type == stream_type) { + count++; + } + } + return count; +} + +/** + * gst_mse_src_get_n_audio: + * @self: #GstMseSrc instance + * + * Returns: the number of audio tracks available from this source + * Since: 1.24 + */ +guint +gst_mse_src_get_n_audio (GstMseSrc * self) +{ + g_return_val_if_fail (GST_IS_MSE_SRC (self), 0); + return n_streams_by_type (self, GST_MEDIA_SOURCE_TRACK_TYPE_AUDIO); +} + +/** + * gst_mse_src_get_n_text: + * @self: #GstMseSrc instance + * + * Returns: the number of text tracks available from this source + * Since: 1.24 + */ +guint +gst_mse_src_get_n_text (GstMseSrc * self) +{ + g_return_val_if_fail (GST_IS_MSE_SRC (self), 0); + return n_streams_by_type (self, GST_MEDIA_SOURCE_TRACK_TYPE_TEXT); +} + +/** + * gst_mse_src_get_n_video: + * @self: #GstMseSrc instance + * + * Returns: the number of video tracks available from this source + * Since: 1.24 + */ +guint +gst_mse_src_get_n_video (GstMseSrc * self) +{ + g_return_val_if_fail (GST_IS_MSE_SRC (self), 0); + return n_streams_by_type (self, GST_MEDIA_SOURCE_TRACK_TYPE_VIDEO); +} + +void +gst_mse_src_decode_error (GstMseSrc * self) +{ + g_return_if_fail (GST_IS_MSE_SRC (self)); + GstMseSrcReadyState ready_state = g_atomic_int_get (&self->ready_state); + if (ready_state == GST_MSE_SRC_READY_STATE_HAVE_NOTHING) { + GST_ELEMENT_ERROR (self, STREAM, DECODE, (DECODE_ERROR), + ("the necessary decoder may be missing from this installation")); + } else { + GST_ELEMENT_ERROR (self, STREAM, DECODE, (DECODE_ERROR), + ("the stream may be corrupt")); + } +} + +void +gst_mse_src_network_error (GstMseSrc * self) +{ + g_return_if_fail (GST_IS_MSE_SRC (self)); + GstMseSrcReadyState ready_state = g_atomic_int_get (&self->ready_state); + if (ready_state == GST_MSE_SRC_READY_STATE_HAVE_NOTHING) { + GST_ELEMENT_ERROR (self, RESOURCE, OPEN_READ, (NETWORK_ERROR), + ("an error occurred before any media was read")); + } else { + GST_ELEMENT_ERROR (self, RESOURCE, READ, (NETWORK_ERROR), + ("an error occurred while reading media")); + } +} + +static inline gboolean +is_streamable (GstMediaSourceTrack * track) +{ + switch (gst_media_source_track_get_track_type (track)) { + case GST_MEDIA_SOURCE_TRACK_TYPE_AUDIO: + case GST_MEDIA_SOURCE_TRACK_TYPE_TEXT: + case GST_MEDIA_SOURCE_TRACK_TYPE_VIDEO: + return TRUE; + default: + return FALSE; + } +} + +static GstStream * +create_gst_stream (GstMediaSourceTrack * track) +{ + gchar *stream_id = g_strdup_printf ("%s-%s", + GST_OBJECT_NAME (track), gst_media_source_track_get_id (track)); + GstStream *stream = gst_stream_new (stream_id, + gst_media_source_track_get_initial_caps (track), + gst_media_source_track_get_stream_type (track), GST_STREAM_FLAG_SELECT); + g_free (stream_id); + return stream; +} + +static void +set_flushing_and_signal (GstMseSrcPad * pad) +{ + GST_TRACE_OBJECT (pad, "locking"); + LINKED_OR_FLUSHING_LOCK (pad); + g_atomic_int_set (&pad->flushing, TRUE); + LINKED_OR_FLUSHING_SIGNAL (pad); + LINKED_OR_FLUSHING_UNLOCK (pad); + GST_TRACE_OBJECT (pad, "done"); +} + +static void +clear_flushing (GstMseSrcPad * pad) +{ + GST_TRACE_OBJECT (pad, "locking"); + LINKED_OR_FLUSHING_LOCK (pad); + g_atomic_int_set (&pad->flushing, FALSE); + LINKED_OR_FLUSHING_UNLOCK (pad); + GST_TRACE_OBJECT (pad, "done"); +} + +static void +flush_stream (GstMseSrc * self, Stream * stream, gboolean is_seek) +{ + GstMseSrcPad *pad = GST_MSE_SRC_PAD (stream->pad); + gst_pad_push_event (GST_PAD (pad), gst_event_new_flush_start ()); + + if (is_seek) { + GST_DEBUG_OBJECT (pad, "flushing for seek to %" GST_TIMEP_FORMAT, + &self->start_time); + set_flushing_and_signal (pad); + gst_media_source_track_flush (stream->track); + gst_pad_stop_task (GST_PAD (pad)); + GST_DEBUG_OBJECT (pad, "stopped task"); + GstSegment *segment = &(pad->segment); + segment->base = 0; + segment->start = self->start_time; + segment->time = self->start_time; + segment->rate = self->rate; + } + + gst_media_source_track_flush (stream->track); + g_atomic_int_set (&pad->does_need_segment, TRUE); + + gst_pad_push_event (GST_PAD (pad), gst_event_new_flush_stop (is_seek)); +} + +static void +flush_all_streams (GstMseSrc * self, gboolean is_seek) +{ + GHashTableIter iter; + g_hash_table_iter_init (&iter, self->streams); + for (gpointer value; g_hash_table_iter_next (&iter, NULL, &value);) { + flush_stream (self, (Stream *) value, is_seek); + } +} + +static void +resume_all_streams (GstMseSrc * self) +{ + GstState state; + gst_element_get_state (GST_ELEMENT (self), &state, NULL, 0); + gboolean active = state > GST_STATE_READY; + + GHashTableIter iter; + g_hash_table_iter_init (&iter, self->streams); + for (gpointer value; g_hash_table_iter_next (&iter, NULL, &value);) { + Stream *stream = value; + GstPad *pad = GST_PAD (stream->pad); + if (active) { + clear_flushing (GST_MSE_SRC_PAD (pad)); + gst_pad_start_task (pad, (GstTaskFunction) pad_task, pad, NULL); + } + } +} + +static void +tear_down_stream (GstMseSrc * self, Stream * stream) +{ + GST_DEBUG_OBJECT (self, "tearing down stream %s", + gst_media_source_track_get_id (stream->track)); + + flush_stream (self, stream, FALSE); + gst_pad_set_active (stream->pad, FALSE); + + if (gst_stream_collection_get_size (self->collection) > 0) { + gst_element_remove_pad (GST_ELEMENT (self), stream->pad); + FLOW_COMBINER_LOCK (self); + gst_flow_combiner_remove_pad (self->flow_combiner, stream->pad); + FLOW_COMBINER_UNLOCK (self); + } +} + + +static void +tear_down_all_streams (GstMseSrc * self) +{ + GHashTableIter iter; + g_hash_table_iter_init (&iter, self->streams); + for (gpointer value; g_hash_table_iter_next (&iter, NULL, &value);) { + tear_down_stream (self, (Stream *) value); + g_hash_table_iter_remove (&iter); + } +} + +static GstStateChangeReturn +gst_mse_src_change_state (GstElement * element, GstStateChange transition) +{ + GstMseSrc *self = GST_MSE_SRC (element); + switch (transition) { + case GST_STATE_CHANGE_PAUSED_TO_READY: + tear_down_all_streams (self); + break; + case GST_STATE_CHANGE_READY_TO_NULL: + gst_mse_src_detach (self); + break; + default: + break; + } + return GST_ELEMENT_CLASS (gst_mse_src_parent_class)->change_state (element, + transition); +} + +static void +gst_mse_src_seek (GstMseSrc * self, GstClockTime start_time, gdouble rate) +{ + self->start_time = start_time; + self->rate = rate; + + flush_all_streams (self, TRUE); + if (self->media_source) { + GST_DEBUG_OBJECT (self, "seeking on media source %" GST_PTR_FORMAT, + self->media_source); + gst_media_source_seek (self->media_source, start_time); + } else { + GST_DEBUG_OBJECT (self, "detached, not seeking on media source"); + } + resume_all_streams (self); +} + +static gboolean +gst_mse_src_send_event (GstElement * element, GstEvent * event) +{ + if (GST_EVENT_TYPE (event) != GST_EVENT_SEEK) { + return GST_ELEMENT_CLASS (gst_mse_src_parent_class)->send_event (element, + event); + } + + GstMseSrc *self = GST_MSE_SRC (element); + + gdouble rate; + GstFormat format; + GstSeekType seek_type; + gint64 start; + gst_event_parse_seek (event, &rate, &format, NULL, &seek_type, &start, NULL, + NULL); + + gst_event_unref (event); + + if (format != GST_FORMAT_TIME || seek_type != GST_SEEK_TYPE_SET) { + GST_ERROR_OBJECT (self, + "Rejecting unsupported seek event: %" GST_PTR_FORMAT, event); + return FALSE; + } + + GST_DEBUG_OBJECT (self, "handling %" GST_PTR_FORMAT, event); + gst_mse_src_seek (self, start, rate); + return TRUE; +} + +static inline gboolean +is_flushing (GstMseSrcPad * pad) +{ + return g_atomic_int_get (&pad->flushing) || GST_PAD_IS_FLUSHING (pad); +} + +static void +await_pad_linked_or_flushing (GstMseSrcPad * pad) +{ + GST_TRACE_OBJECT (pad, "waiting for link"); + LINKED_OR_FLUSHING_LOCK (pad); + while (!gst_pad_is_linked (GST_PAD_CAST (pad)) && !is_flushing (pad)) { + LINKED_OR_FLUSHING_WAIT (pad); + } + LINKED_OR_FLUSHING_UNLOCK (pad); + GST_TRACE_OBJECT (pad, "linked"); +} + +static gboolean +all_pads_eos_fold (const GValue * item, gboolean * all_eos, gpointer user_data) +{ + GstMseSrcPad *pad = g_value_get_object (item); + if (pad->eos) { + return TRUE; + } else { + *all_eos = FALSE; + return FALSE; + } +} + +static gboolean +all_pads_eos (GstMseSrc * self) +{ + GstIterator *iter = gst_element_iterate_src_pads (GST_ELEMENT_CAST (self)); + gboolean all_eos = TRUE; + while (gst_iterator_fold (iter, + (GstIteratorFoldFunction) all_pads_eos_fold, (GValue *) & all_eos, + NULL) == GST_ITERATOR_RESYNC) { + gst_iterator_resync (iter); + } + gst_iterator_free (iter); + return all_eos; +} + +static void +pad_task (GstMseSrcPad * pad) +{ + await_pad_linked_or_flushing (pad); + + if (is_flushing (pad)) { + GST_TRACE_OBJECT (pad, "pad is flushing"); + goto pause; + } + + GstMseSrc *self = GST_MSE_SRC (gst_pad_get_parent_element (GST_PAD (pad))); + + GstMediaSourceTrack *track = pad->track; + + GstMiniObject *object = gst_media_source_track_pop (track); + + if (object == NULL) { + GST_DEBUG_OBJECT (pad, "nothing was popped from track, must be flushing"); + gst_media_source_track_flush (track); + goto pause; + } + + if (!g_atomic_int_get (&pad->sent_stream_start)) { + const gchar *track_id = gst_media_source_track_get_id (track); + GstEvent *event = gst_event_new_stream_start (track_id); + gst_event_set_group_id (event, self->group_id); + gst_event_set_stream (event, pad->stream); + if (!gst_pad_push_event (GST_PAD (pad), event)) { + GST_ERROR_OBJECT (pad, "failed to push stream start"); + goto pause; + } + GST_TRACE_OBJECT (pad, "stream start"); + g_atomic_int_set (&pad->sent_stream_start, TRUE); + } + + GstCaps *caps = gst_media_source_track_get_initial_caps (track); + if (!g_atomic_int_get (&pad->sent_initial_caps) && GST_IS_CAPS (caps)) { + GST_DEBUG_OBJECT (pad, "sending initial caps"); + gst_caps_replace (&pad->most_recent_caps, caps); + GstEvent *event = gst_event_new_caps (caps); + if (!gst_pad_push_event (GST_PAD (pad), event)) { + GST_ERROR_OBJECT (pad, "failed to push caps update"); + goto pause; + } + GST_TRACE_OBJECT (pad, "initial caps %" GST_PTR_FORMAT, caps); + g_atomic_int_set (&pad->sent_initial_caps, TRUE); + } + + if (g_atomic_int_get (&pad->does_need_segment)) { + GST_DEBUG_OBJECT (pad, "sending new segment starting@%" GST_TIMEP_FORMAT, + &pad->segment.time); + GstEvent *event = gst_event_new_segment (&pad->segment); + if (!gst_pad_push_event (GST_PAD (pad), event)) { + GST_ERROR_OBJECT (pad, "failed to push new segment"); + goto pause; + } + GST_TRACE_OBJECT (pad, "segment"); + g_atomic_int_set (&pad->does_need_segment, FALSE); + } + + if (!g_atomic_int_get (&pad->sent_stream_collection)) { + GstEvent *event = gst_event_new_stream_collection (self->collection); + if (!gst_pad_push_event (GST_PAD (pad), event)) { + GST_ERROR_OBJECT (pad, "failed to push stream collection"); + goto pause; + } + GST_TRACE_OBJECT (pad, "stream collection"); + g_atomic_int_set (&pad->sent_stream_collection, TRUE); + } + + if (GST_IS_SAMPLE (object)) { + GstSample *sample = GST_SAMPLE (object); + GstCaps *sample_caps = gst_sample_get_caps (sample); + + if (!gst_caps_is_equal (pad->most_recent_caps, sample_caps)) { + gst_caps_replace (&pad->most_recent_caps, sample_caps); + GstEvent *event = gst_event_new_caps (gst_caps_ref (sample_caps)); + if (!gst_pad_push_event (GST_PAD (pad), event)) { + GST_ERROR_OBJECT (pad, "failed to push new caps"); + goto pause; + } + GST_TRACE_OBJECT (pad, "new caps %" GST_PTR_FORMAT, sample_caps); + } + + GstBuffer *buffer = gst_buffer_copy (gst_sample_get_buffer (sample)); + if (GST_BUFFER_DTS_IS_VALID (buffer)) { + pad->position = GST_BUFFER_DTS (buffer); + } + + GstFlowReturn push_result = gst_pad_push (GST_PAD (pad), buffer); + + FLOW_COMBINER_LOCK (self); + GstFlowReturn combined_result = + gst_flow_combiner_update_pad_flow (self->flow_combiner, + GST_PAD_CAST (pad), push_result); + FLOW_COMBINER_UNLOCK (self); + + if (combined_result != GST_FLOW_OK) { + GST_DEBUG_OBJECT (pad, "push result: %s, combined result: %s", + gst_flow_get_name (push_result), gst_flow_get_name (combined_result)); + goto pause; + } + } else if (GST_IS_EVENT (object)) { + if (GST_EVENT_TYPE (object) == GST_EVENT_EOS) { + g_mutex_lock (&self->eos_lock); + pad->eos = TRUE; + g_cond_broadcast (&self->eos_cond); + g_mutex_unlock (&self->eos_lock); + g_mutex_lock (&self->eos_lock); + while (!all_pads_eos (self)) { + GST_DEBUG_OBJECT (pad, "waiting for eos on all tracks"); + g_cond_wait (&self->eos_cond, &self->eos_lock); + } + g_mutex_unlock (&self->eos_lock); + GST_DEBUG_OBJECT (pad, "have eos on all tracks"); + } + if (!gst_pad_push_event (GST_PAD (pad), GST_EVENT (object))) { + GST_ERROR_OBJECT (self, "failed to push enqueued event"); + goto pause; + } + } else { + GST_ERROR_OBJECT (self, "unexpected object on track queue" + ", only samples and events are supported"); + g_assert_not_reached (); + } + + return; + +pause: + if (!g_atomic_int_get (&pad->flushing)) { + gst_pad_pause_task (GST_PAD (pad)); + } +} + +static gboolean +pad_activate_mode (GstMseSrcPad * pad, GstObject * parent, GstPadMode mode, + gboolean active) +{ + if (mode != GST_PAD_MODE_PUSH) { + GST_ERROR_OBJECT (parent, "msesrc only supports push mode"); + return FALSE; + } + + if (active) { + gst_pad_start_task (GST_PAD (pad), (GstTaskFunction) pad_task, pad, NULL); + } else { + set_flushing_and_signal (pad); + gst_media_source_track_flush (pad->track); + gst_pad_stop_task (GST_PAD (pad)); + clear_flushing (pad); + } + + return TRUE; +} + +static GstPadLinkReturn +pad_linked (GstMseSrcPad * pad, GstMseSrc * parent, GstPad * sink) +{ + GST_DEBUG_OBJECT (pad, "pad is linked to %" GST_PTR_FORMAT ", resuming task", + sink); + LINKED_OR_FLUSHING_LOCK (pad); + LINKED_OR_FLUSHING_SIGNAL (pad); + LINKED_OR_FLUSHING_UNLOCK (pad); + return GST_PAD_LINK_OK; +} + +static gboolean +pad_event (GstMseSrcPad * pad, GstMseSrc * parent, GstEvent * event) +{ + switch (GST_EVENT_TYPE (event)) { + case GST_EVENT_SEEK: + return gst_element_send_event (GST_ELEMENT (parent), event); + default: + return gst_pad_event_default (GST_PAD (pad), GST_OBJECT (parent), event); + } +} + +static gboolean +pad_query (GstMseSrcPad * pad, GstObject * parent, GstQuery * query) +{ + GstMseSrc *self = GST_MSE_SRC (parent); + switch (GST_QUERY_TYPE (query)) { + case GST_QUERY_POSITION:{ + GstClockTime position = pad->position; + GstFormat fmt; + gst_query_parse_position (query, &fmt, NULL); + if (fmt == GST_FORMAT_TIME && GST_CLOCK_TIME_IS_VALID (position)) { + GST_TRACE_OBJECT (pad, "position query returning %" GST_TIMEP_FORMAT, + &position); + gst_query_set_position (query, GST_FORMAT_TIME, position); + return TRUE; + } + break; + } + case GST_QUERY_DURATION:{ + GstFormat fmt; + gst_query_parse_duration (query, &fmt, NULL); + if (fmt == GST_FORMAT_TIME) { + gst_query_set_duration (query, GST_FORMAT_TIME, self->duration); + return TRUE; + } else { + return FALSE; + } + } + case GST_QUERY_SEEKING:{ + GstFormat fmt; + gst_query_parse_seeking (query, &fmt, NULL, NULL, NULL); + if (fmt != GST_FORMAT_TIME) { + return FALSE; + } + gst_query_set_seeking (query, GST_FORMAT_TIME, TRUE, 0, self->duration); + return TRUE; + } + default: + break; + } + return gst_pad_query_default (GST_PAD (pad), parent, query); +} + +static void +append_stream (GstMseSrc * self, GstMediaSourceTrack * track) +{ + if (g_hash_table_contains (self->streams, track)) { + GST_DEBUG_OBJECT (self, "skipping processed %" GST_PTR_FORMAT, track); + return; + } + GST_DEBUG_OBJECT (self, "creating stream for %" GST_PTR_FORMAT, track); + guint pad_index = g_hash_table_size (self->streams); + GstStream *info = create_gst_stream (track); + Stream stream = { + .info = gst_object_ref (info), + .track = gst_object_ref (track), + .pad = gst_mse_src_pad_new (track, info, pad_index, + self->start_time, self->rate), + }; + g_hash_table_insert (self->streams, track, + g_memdup2 (&stream, sizeof (Stream))); + gst_stream_collection_add_stream (self->collection, stream.info); +} + +void +gst_mse_src_emit_streams (GstMseSrc * self, GstMediaSourceTrack ** tracks, + gsize n_tracks) +{ + g_return_if_fail (GST_IS_MSE_SRC (self)); + + GstElement *element = GST_ELEMENT (self); + GstObject *object = GST_OBJECT (self); + + update_ready_state_for_init_segment (self); + + STREAMS_LOCK (self); + + for (gsize i = 0; i < n_tracks; i++) { + GstMediaSourceTrack *track = tracks[i]; + if (!is_streamable (track)) { + continue; + } + append_stream (self, track); + } + + GstState state; + gst_element_get_state (element, &state, NULL, 0); + gboolean active = state > GST_STATE_READY; + + GHashTableIter iter; + g_hash_table_iter_init (&iter, self->streams); + for (gpointer value; g_hash_table_iter_next (&iter, NULL, &value);) { + Stream *stream = value; + GstPad *pad = stream->pad; + if (active) { + gst_pad_set_active (pad, TRUE); + } + GstElement *parent = gst_pad_get_parent_element (pad); + if (parent) { + GST_DEBUG_OBJECT (self, "skipping parented pad %" GST_PTR_FORMAT, pad); + gst_object_unref (parent); + continue; + } + gst_element_add_pad (element, pad); + FLOW_COMBINER_LOCK (self); + gst_flow_combiner_add_pad (self->flow_combiner, pad); + FLOW_COMBINER_UNLOCK (self); + } + STREAMS_UNLOCK (self); + + gst_element_no_more_pads (element); + gst_element_post_message (element, gst_message_new_stream_collection (object, + self->collection)); +} + +void +gst_mse_src_update_ready_state (GstMseSrc * self) +{ + g_return_if_fail (GST_IS_MSE_SRC (self)); + update_ready_state_for_sample (self); +} + +static GstURIType +gst_mse_src_uri_get_type (GType type) +{ + return GST_URI_SRC; +} + +static const gchar *const * +gst_mse_src_uri_get_protocols (GType type) +{ + static const gchar *protocols[] = { "mse", NULL }; + return protocols; +} + +static gchar * +gst_mse_src_uri_get_uri (GstURIHandler * handler) +{ + GstMseSrc *self = GST_MSE_SRC (handler); + return g_strdup (self->uri); +} + +static gboolean +gst_mse_src_uri_set_uri (GstURIHandler * handler, const gchar * uri, + GError ** error) +{ + GstMseSrc *self = GST_MSE_SRC (handler); + g_free (self->uri); + self->uri = g_strdup (uri); + return TRUE; +} + +static void +gst_mse_src_uri_handler_init (gpointer g_iface, gpointer iface_data) +{ + GstURIHandlerInterface *iface = (GstURIHandlerInterface *) g_iface; + iface->get_type = gst_mse_src_uri_get_type; + iface->get_protocols = gst_mse_src_uri_get_protocols; + iface->get_uri = gst_mse_src_uri_get_uri; + iface->set_uri = gst_mse_src_uri_set_uri; +} + +void +gst_mse_src_attach (GstMseSrc * self, GstMediaSource * media_source) +{ + g_return_if_fail (GST_IS_MSE_SRC (self)); + g_return_if_fail (GST_IS_MEDIA_SOURCE (media_source)); + g_set_object (&self->media_source, media_source); +} + +void +gst_mse_src_detach (GstMseSrc * self) +{ + g_return_if_fail (GST_IS_MSE_SRC (self)); + gst_clear_object (&self->media_source); +} + +static void +set_ready_state (GstMseSrc * self, GstMseSrcReadyState ready_state) +{ + if (ready_state == self->ready_state) { + return; + } + GST_DEBUG_OBJECT (self, "ready state %d=>%d", self->ready_state, ready_state); + self->ready_state = ready_state; + g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_READY_STATE]); +} + +static void +update_ready_state_for_init_segment (GstMseSrc * self) +{ + g_return_if_fail (GST_IS_MEDIA_SOURCE (self->media_source)); + if (self->ready_state != GST_MSE_SRC_READY_STATE_HAVE_NOTHING) { + return; + } + GstSourceBufferList *buffers = gst_media_source_get_source_buffers + (self->media_source); + gboolean all_received_init_segment = TRUE; + for (guint i = 0; all_received_init_segment; i++) { + GstSourceBuffer *buf = gst_source_buffer_list_index (buffers, i); + if (buf == NULL) { + break; + } + all_received_init_segment &= gst_source_buffer_has_init_segment (buf); + gst_object_unref (buf); + } + if (!all_received_init_segment) { + return; + } + set_ready_state (self, GST_MSE_SRC_READY_STATE_HAVE_METADATA); +} + +static gboolean +has_current_data (GstMseSrc * self) +{ + GstClockTime position = gst_mse_src_get_position (self); + if (!GST_CLOCK_TIME_IS_VALID (position)) { + return FALSE; + } + GstSourceBufferList *active = + gst_media_source_get_active_source_buffers (self->media_source); + gboolean has_data = TRUE; + for (guint i = 0; has_data; i++) { + GstSourceBuffer *buf = gst_source_buffer_list_index (active, i); + if (buf == NULL) { + if (i == 0) { + has_data = FALSE; + GST_DEBUG_OBJECT (self, + "no active source buffers, nothing is buffered"); + } + break; + } + has_data = gst_source_buffer_is_buffered (buf, position); + gst_object_unref (buf); + } + g_object_unref (active); + return has_data; +} + +static gboolean +has_future_data (GstMseSrc * self) +{ + GstClockTime position = gst_mse_src_get_position (self); + GstClockTime duration = self->duration; + if (!GST_CLOCK_TIME_IS_VALID (position) + || !GST_CLOCK_TIME_IS_VALID (duration)) { + return FALSE; + } + GstClockTime target_position = MIN (position + THRESHOLD_FUTURE_DATA, + duration); + GstSourceBufferList *active = + gst_media_source_get_active_source_buffers (self->media_source); + gboolean has_data = TRUE; + for (guint i = 0; has_data; i++) { + GstSourceBuffer *buf = gst_source_buffer_list_index (active, i); + if (buf == NULL) { + if (i == 0) { + has_data = FALSE; + GST_DEBUG_OBJECT (self, + "no active source buffers, nothing is buffered"); + } + break; + } + has_data = gst_source_buffer_is_range_buffered (buf, position, + target_position); + gst_object_unref (buf); + } + g_object_unref (active); + return has_data; +} + +static gboolean +has_enough_data (GstMseSrc * self) +{ + GstClockTime position = gst_mse_src_get_position (self); + GstClockTime duration = self->duration; + if (!GST_CLOCK_TIME_IS_VALID (position) + || !GST_CLOCK_TIME_IS_VALID (duration)) { + return FALSE; + } + GstClockTime target_position = MIN (position + THRESHOLD_ENOUGH_DATA, + duration); + GstSourceBufferList *active = + gst_media_source_get_active_source_buffers (self->media_source); + gboolean has_data = TRUE; + for (guint i = 0; has_data; i++) { + GstSourceBuffer *buf = gst_source_buffer_list_index (active, i); + if (buf == NULL) { + if (i == 0) { + has_data = FALSE; + GST_DEBUG_OBJECT (self, + "no active source buffers, nothing is buffered"); + } + break; + } + has_data = gst_source_buffer_is_range_buffered (buf, position, + target_position); + gst_object_unref (buf); + } + g_object_unref (active); + return has_data; +} + +static void +update_ready_state_for_sample (GstMseSrc * self) +{ + g_return_if_fail (GST_IS_MEDIA_SOURCE (self->media_source)); + g_return_if_fail (self->ready_state >= GST_MSE_SRC_READY_STATE_HAVE_METADATA); + + if (has_enough_data (self)) { + set_ready_state (self, GST_MSE_SRC_READY_STATE_HAVE_ENOUGH_DATA); + } else if (has_future_data (self)) { + set_ready_state (self, GST_MSE_SRC_READY_STATE_HAVE_FUTURE_DATA); + } else if (has_current_data (self)) { + set_ready_state (self, GST_MSE_SRC_READY_STATE_HAVE_CURRENT_DATA); + } else { + set_ready_state (self, GST_MSE_SRC_READY_STATE_HAVE_METADATA); + } +} diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmsesrc.h b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmsesrc.h new file mode 100644 index 0000000000..1a7ff1411f --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmsesrc.h @@ -0,0 +1,94 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2009, 2010 Sebastian Dröge + * Copyright (C) 2013, 2022, 2023 Collabora Ltd. + * Copyright (C) 2013 Orange + * Copyright (C) 2014, 2015 Sebastian Dröge + * Copyright (C) 2015, 2016, 2018, 2019, 2020, 2021 Igalia, S.L + * Copyright (C) 2015, 2016, 2018, 2019, 2020, 2021 Metrological Group B.V. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#pragma once + +#include +#include + +G_BEGIN_DECLS + +/** + * GstMseSrcReadyState: + * @GST_MSE_SRC_READY_STATE_HAVE_NOTHING: No information is available about the + * stream + * @GST_MSE_SRC_READY_STATE_HAVE_METADATA: The duration is available and video + * dimensions are available if the stream contains video + * @GST_MSE_SRC_READY_STATE_HAVE_CURRENT_DATA: The current playback position can + * be presented but future information is not available + * @GST_MSE_SRC_READY_STATE_HAVE_FUTURE_DATA: There is data for the current + * position and some amount in the future and any text tracks are ready. + * @GST_MSE_SRC_READY_STATE_HAVE_ENOUGH_DATA: Either there is enough data to + * play the stream through at the current playback and input rate or the input + * buffer is full. + * + * Describes how much information a #GstMseSrc has about the media it is playing + * back at the current playback #GstMseSrc:position. This type corresponds + * directly to the ready state of a HTML Media Element and is a separate concept + * from #GstMediaSourceReadyState. + * + * [Specification](https://html.spec.whatwg.org/multipage/media.html#ready-states) + * + * Since: 1.24 + */ +typedef enum +{ + GST_MSE_SRC_READY_STATE_HAVE_NOTHING, + GST_MSE_SRC_READY_STATE_HAVE_METADATA, + GST_MSE_SRC_READY_STATE_HAVE_CURRENT_DATA, + GST_MSE_SRC_READY_STATE_HAVE_FUTURE_DATA, + GST_MSE_SRC_READY_STATE_HAVE_ENOUGH_DATA, +} GstMseSrcReadyState; + +#define GST_TYPE_MSE_SRC (gst_mse_src_get_type()) +#define GST_TYPE_MSE_SRC_PAD (gst_mse_src_pad_get_type()) + +GST_MSE_API +G_DECLARE_FINAL_TYPE (GstMseSrc, gst_mse_src, GST, MSE_SRC, GstElement); + +GST_MSE_API +G_DECLARE_FINAL_TYPE (GstMseSrcPad, gst_mse_src_pad, GST, MSE_SRC_PAD, GstPad); + +GST_MSE_API +GstClockTime gst_mse_src_get_position (GstMseSrc * self); + +GST_MSE_API +GstClockTime gst_mse_src_get_duration (GstMseSrc * self); + +GST_MSE_API +GstMseSrcReadyState gst_mse_src_get_ready_state (GstMseSrc * self); + +GST_MSE_API +guint gst_mse_src_get_n_audio (GstMseSrc * self); + +GST_MSE_API +guint gst_mse_src_get_n_text (GstMseSrc * self); + +GST_MSE_API +guint gst_mse_src_get_n_video (GstMseSrc * self); + +G_END_DECLS diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstsourcebuffer-private.h b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstsourcebuffer-private.h new file mode 100644 index 0000000000..17ae1af5c3 --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstsourcebuffer-private.h @@ -0,0 +1,72 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2022, 2023 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#pragma once + +#include +#include "gstsourcebuffer.h" + +G_BEGIN_DECLS + +typedef struct +{ + void (*duration_changed) (GstSourceBuffer * self, gpointer user_data); + void (*received_init_segment) (GstSourceBuffer * self, gpointer user_data); + void (*active_state_changed) (GstSourceBuffer * self, gpointer user_data); +} GstSourceBufferCallbacks; + +GST_MSE_PRIVATE +GstSourceBuffer * gst_source_buffer_new (const gchar * content_type, + GstObject * parent, GError ** error); + +GST_MSE_PRIVATE +GstSourceBuffer * gst_source_buffer_new_with_callbacks ( + const gchar * content_type, GstObject * parent, + GstSourceBufferCallbacks *callbacks, gpointer user_data, GError ** error); + +GST_MSE_PRIVATE +void gst_source_buffer_teardown (GstSourceBuffer * self); + +GST_MSE_PRIVATE +gboolean gst_source_buffer_has_init_segment (GstSourceBuffer * self); + +GST_MSE_PRIVATE +gboolean gst_source_buffer_is_buffered (GstSourceBuffer * self, GstClockTime + time); + +GST_MSE_PRIVATE +gboolean gst_source_buffer_is_range_buffered (GstSourceBuffer * self, + GstClockTime start, GstClockTime end); + +GST_MSE_PRIVATE +GstClockTime gst_source_buffer_get_duration (GstSourceBuffer * self); + +GST_MSE_PRIVATE +GPtrArray * gst_source_buffer_get_all_tracks (GstSourceBuffer * self); + +GST_MSE_PRIVATE +void gst_source_buffer_seek (GstSourceBuffer * self, GstClockTime time); + +GST_MSE_PRIVATE +gboolean gst_source_buffer_get_active (GstSourceBuffer * self); + +G_END_DECLS diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstsourcebuffer.c b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstsourcebuffer.c new file mode 100644 index 0000000000..7695bad373 --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstsourcebuffer.c @@ -0,0 +1,2019 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2013 Google Inc. All rights reserved. + * Copyright (C) 2013 Orange + * Copyright (C) 2013-2020 Apple Inc. All rights reserved. + * Copyright (C) 2014 Sebastian Dröge + * Copyright (C) 2015, 2016, 2017 Igalia, S.L + * Copyright (C) 2015, 2016, 2017 Metrological Group B.V. + * Copyright (C) 2022, 2023 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +/** + * SECTION:gstsourcebuffer + * @title: GstSourceBuffer + * @short_description: Source Buffer + * @include: mse/mse.h + * @symbols: + * - GstSourceBuffer + * + * The Source Buffer is the primary means of data flow between an application + * and the Media Source API. It represents a single timeline of media, + * containing some combination of audio, video, and text tracks. + * An application is responsible for feeding raw data into the Source Buffer + * using gst_source_buffer_append_buffer() and the Source Buffer will + * asynchronously process the data into tracks of time-coded multimedia samples. + * + * The application as well as the associated playback component can then select + * to play media from any subset of tracks across all Source Buffers of a Media + * Source. + * + * A few control points are also provided to customize the behavior. + * + * - #GstSourceBuffer:append-mode controls how timestamps of processed samples are + * interpreted. They are either inserted in the timeline directly where the + * decoded media states they should, or inserted directly after the previously + * encountered sample. + * + * - #GstSourceBuffer:append-window-start / #GstSourceBuffer:append-window-end + * control the planned time window where media from appended data can be added + * to the current timeline. Any samples outside that range may be ignored. + * + * - #GstSourceBuffer:timestamp-offset is added to the start time of any sample + * processed. + * + * Since: 1.24 + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include +#include "gstsourcebuffer.h" +#include "gstsourcebuffer-private.h" + +#include "gstmselogging-private.h" +#include "gstmsemediatype-private.h" +#include "gstmseeventqueue-private.h" + +#include "gstappendpipeline-private.h" +#include "gstmediasource.h" +#include "gstmediasource-private.h" +#include "gstmediasourcetrack-private.h" +#include "gstmediasourcetrackbuffer-private.h" +#include "gstsourcebufferlist-private.h" +#include "gstmsesrc.h" +#include "gstmsesrc-private.h" + +#define g_array_new_ranges() \ + (g_array_new (TRUE, FALSE, sizeof (GstMediaSourceRange))) + +typedef struct +{ + GstSourceBufferCallbacks callbacks; + gpointer user_data; +} Callbacks; + +/** + * GstSourceBuffer: + * Since: 1.24 + */ +typedef struct +{ + GstSourceBuffer *parent; + + GstMediaSourceTrack *track; + GstMediaSourceTrackBuffer *buffer; + + GstTask *task; + GRecMutex lock; + + gboolean cancelled; +} TrackFeedTask; + +typedef struct +{ + gsize n_samples; + GstSample *current_sample; + GstClockTime current_dts; +} TrackFeedAccumulator; + +typedef struct +{ + const GstClockTime time; + gboolean buffered; +} IsBufferedAccumulator; + +typedef struct +{ + const GstClockTime start; + const GstClockTime end; + gboolean start_buffered; + gboolean end_buffered; +} IsRangeBufferedAccumulator; + +struct _GstSourceBuffer +{ + GstObject parent_instance; + + GstSourceBufferAppendMode append_mode; + GstClockTime append_window_start; + GstClockTime append_window_end; + gchar *content_type; + gboolean generate_timestamps; + GstClockTime timestamp_offset; + gboolean updating; + gboolean errored; + gsize size_limit; + gsize size; + GstBuffer *pending_data; + GstTask *append_to_buffer_task; + GRecMutex append_to_buffer_lock; + GstClockTime seek_time; + GstAppendPipeline *append_pipeline; + GstMseEventQueue *event_queue; + + gboolean processed_init_segment; + + GHashTable *track_buffers; + GHashTable *track_feeds; + + Callbacks callbacks; +}; + +G_DEFINE_TYPE (GstSourceBuffer, gst_source_buffer, GST_TYPE_OBJECT); + +enum +{ + PROP_0, + + PROP_APPEND_MODE, + PROP_APPEND_WINDOW_START, + PROP_APPEND_WINDOW_END, + PROP_BUFFERED, + PROP_CONTENT_TYPE, + PROP_TIMESTAMP_OFFSET, + PROP_UDPATING, + + N_PROPS, +}; + +typedef enum +{ + ON_UPDATE_START, + ON_UPDATE, + ON_UPDATE_END, + ON_ERROR, + ON_ABORT, + + N_SIGNALS, +} SourceBufferEvent; + +typedef struct +{ + GstDataQueueItem item; + SourceBufferEvent event; +} SourceBufferEventItem; + +#define DEFAULT_BUFFER_SIZE 1 << 24 +#define DEFAULT_APPEND_MODE GST_SOURCE_BUFFER_APPEND_MODE_SEGMENTS + +static GParamSpec *properties[N_PROPS]; +static guint signals[N_SIGNALS]; + +static void call_received_init_segment (GstSourceBuffer * self); +static void call_duration_changed (GstSourceBuffer * self); +static void call_active_state_changed (GstSourceBuffer * self); + +static inline gboolean is_removed (GstSourceBuffer * self); +static void reset_parser_state (GstSourceBuffer * self); +static void append_error (GstSourceBuffer * self); + +static void seek_track_buffer (GstMediaSourceTrack * track, + GstMediaSourceTrackBuffer * buffer, GstSourceBuffer * self); +static void dispatch_event (SourceBufferEventItem * item, GstSourceBuffer * + self); +static void schedule_event (GstSourceBuffer * self, SourceBufferEvent event); +static void append_to_buffer_task (GstSourceBuffer * self); +static void track_feed_task (TrackFeedTask * feed); +static void clear_track_feed (TrackFeedTask * feed); +static void stop_track_feed (TrackFeedTask * feed); +static void start_track_feed (TrackFeedTask * feed); +static void reset_track_feed (TrackFeedTask * feed); +static TrackFeedTask *get_track_feed (GstSourceBuffer * self, + GstMediaSourceTrack * track); +static GstMediaSourceTrackBuffer *get_track_buffer (GstSourceBuffer * self, + GstMediaSourceTrack * track); +static void add_track_feed (GstMediaSourceTrack * track, + GstMediaSourceTrackBuffer * track_buffer, GstSourceBuffer * self); +static void add_track_buffer (GstMediaSourceTrack * track, GstSourceBuffer * + self); +static void update_msesrc_ready_state (GstSourceBuffer * self); + +static void on_duration_changed (GstAppendPipeline * pipeline, + gpointer user_data); +static void on_eos (GstAppendPipeline * pipeline, GstMediaSourceTrack * track, + gpointer user_data); +static void on_error (GstAppendPipeline * pipeline, gpointer user_data); +static void on_new_sample (GstAppendPipeline * pipeline, + GstMediaSourceTrack * track, GstSample * sample, gpointer user_data); +static void on_received_init_segment (GstAppendPipeline * pipeline, + gpointer user_data); + +static inline GstMediaSource * +get_media_source (GstSourceBuffer * self) +{ + return GST_MEDIA_SOURCE (gst_object_get_parent (GST_OBJECT (self))); +} + +static GstMseSrc * +get_msesrc (GstSourceBuffer * self) +{ + GstMediaSource *media_source = get_media_source (self); + if (media_source == NULL) { + return NULL; + } + return gst_media_source_get_source_element (media_source); +} + +static void +clear_pending_data (GstSourceBuffer * self) +{ + gst_clear_buffer (&self->pending_data); +} + +static GstBuffer * +take_pending_data (GstSourceBuffer * self) +{ + return g_steal_pointer (&self->pending_data); +} + +static void +set_pending_data (GstSourceBuffer * self, GstBuffer * buffer) +{ + clear_pending_data (self); + self->pending_data = buffer; +} + +GstSourceBuffer * +gst_source_buffer_new (const gchar * content_type, GstObject * parent, + GError ** error) +{ + g_return_val_if_fail (GST_IS_MEDIA_SOURCE (parent), NULL); + g_return_val_if_fail (content_type != NULL, NULL); + + gst_mse_init_logging (); + + GstMediaSourceMediaType media_type = GST_MEDIA_SOURCE_MEDIA_TYPE_INIT; + gst_media_source_media_type_parse (&media_type, content_type); + + gboolean generate_timestamps = gst_media_source_media_type_generates_timestamp + (&media_type); + gst_media_source_media_type_reset (&media_type); + + GstSourceBufferAppendMode append_mode = generate_timestamps + ? GST_SOURCE_BUFFER_APPEND_MODE_SEQUENCE + : GST_SOURCE_BUFFER_APPEND_MODE_SEGMENTS; + + GstSourceBuffer *self = g_object_new (GST_TYPE_SOURCE_BUFFER, + "parent", parent, NULL); + + self->generate_timestamps = generate_timestamps; + self->append_mode = append_mode; + self->content_type = g_strdup (content_type); + + GstAppendPipelineCallbacks callbacks = { + .duration_changed = on_duration_changed, + .eos = on_eos, + .error = on_error, + .new_sample = on_new_sample, + .received_init_segment = on_received_init_segment, + }; + GError *append_pipeline_error = NULL; + self->append_pipeline = + gst_append_pipeline_new (&callbacks, self, &append_pipeline_error); + if (append_pipeline_error) { + g_propagate_prefixed_error (error, append_pipeline_error, + "failed to create source buffer"); + goto error; + } + + return gst_object_ref_sink (self); +error: + gst_clear_object (&self); + return NULL; +} + +GstSourceBuffer * +gst_source_buffer_new_with_callbacks (const gchar * content_type, + GstObject * parent, GstSourceBufferCallbacks * callbacks, + gpointer user_data, GError ** error) +{ + g_return_val_if_fail (callbacks, NULL); + + GError *source_buffer_error = NULL; + GstSourceBuffer *self = + gst_source_buffer_new (content_type, parent, &source_buffer_error); + if (source_buffer_error) { + g_propagate_error (error, source_buffer_error); + gst_clear_object (&self); + return NULL; + } + self->callbacks.callbacks = *callbacks; + self->callbacks.user_data = user_data; + + return self; +} + +static void +gst_source_buffer_dispose (GObject * object) +{ + GstSourceBuffer *self = (GstSourceBuffer *) object; + + if (self->append_to_buffer_task) { + gst_task_join (self->append_to_buffer_task); + } + gst_clear_object (&self->append_to_buffer_task); + + gst_clear_object (&self->append_pipeline); + + g_hash_table_remove_all (self->track_feeds); + + if (!is_removed (self)) { + GstMediaSource *parent = get_media_source (self); + gst_media_source_remove_source_buffer (parent, self, NULL); + gst_object_unref (parent); + } + + gst_clear_object (&self->event_queue); + + G_OBJECT_CLASS (gst_source_buffer_parent_class)->dispose (object); +} + +static void +gst_source_buffer_finalize (GObject * object) +{ + GstSourceBuffer *self = (GstSourceBuffer *) object; + + g_clear_pointer (&self->content_type, g_free); + g_rec_mutex_clear (&self->append_to_buffer_lock); + + g_hash_table_unref (self->track_buffers); + g_hash_table_unref (self->track_feeds); + + G_OBJECT_CLASS (gst_source_buffer_parent_class)->finalize (object); +} + +static void +gst_source_buffer_get_property (GObject * object, guint prop_id, GValue * value, + GParamSpec * pspec) +{ + GstSourceBuffer *self = GST_SOURCE_BUFFER (object); + + switch (prop_id) { + case PROP_APPEND_MODE: + g_value_set_enum (value, gst_source_buffer_get_append_mode (self)); + break; + case PROP_APPEND_WINDOW_START: + g_value_set_uint64 (value, + gst_source_buffer_get_append_window_start (self)); + break; + case PROP_APPEND_WINDOW_END: + g_value_set_uint64 (value, + gst_source_buffer_get_append_window_end (self)); + break; + case PROP_BUFFERED: + g_value_take_boxed (value, gst_source_buffer_get_buffered (self, NULL)); + break; + case PROP_CONTENT_TYPE: + g_value_take_string (value, gst_source_buffer_get_content_type (self)); + break; + case PROP_TIMESTAMP_OFFSET: + g_value_set_int64 (value, gst_source_buffer_get_timestamp_offset (self)); + break; + case PROP_UDPATING: + g_value_set_boolean (value, gst_source_buffer_get_updating (self)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + } +} + +static void +gst_source_buffer_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec) +{ + GstSourceBuffer *self = GST_SOURCE_BUFFER (object); + + switch (prop_id) { + case PROP_APPEND_MODE: + gst_source_buffer_set_append_mode (self, g_value_get_enum (value), NULL); + break; + case PROP_CONTENT_TYPE: + gst_source_buffer_change_content_type (self, + g_value_get_string (value), NULL); + break; + case PROP_TIMESTAMP_OFFSET: + gst_source_buffer_set_timestamp_offset (self, + g_value_get_int64 (value), NULL); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + } +} + +static void +gst_source_buffer_class_init (GstSourceBufferClass * klass) +{ + GObjectClass *oclass = G_OBJECT_CLASS (klass); + + oclass->dispose = GST_DEBUG_FUNCPTR (gst_source_buffer_dispose); + oclass->finalize = GST_DEBUG_FUNCPTR (gst_source_buffer_finalize); + oclass->get_property = GST_DEBUG_FUNCPTR (gst_source_buffer_get_property); + oclass->set_property = GST_DEBUG_FUNCPTR (gst_source_buffer_set_property); + + /** + * GstSourceBuffer:append-mode: + * + * Affects how timestamps of processed media segments are interpreted. + * In %GST_SOURCE_BUFFER_APPEND_MODE_SEGMENTS, the start timestamp of a + * processed media segment is used directly along with + * #GstSourceBuffer:timestamp-offset . + * In %GST_SOURCE_BUFFER_APPEND_MODE_SEQUENCE, the timestamp of a + * processed media segment is ignored and replaced with the end time of the + * most recently appended segment. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-mode) + * + * Since: 1.24 + */ + properties[PROP_APPEND_MODE] = g_param_spec_enum ("append-mode", + "Append Mode", + "Either Segments or Sequence", + GST_TYPE_SOURCE_BUFFER_APPEND_MODE, DEFAULT_APPEND_MODE, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); + + /** + * GstSourceBuffer:append-window-start: + * + * Any segments processed which end before this value will be ignored by this + * Source Buffer. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-appendwindowstart) + * + * Since: 1.24 + */ + properties[PROP_APPEND_WINDOW_START] = + g_param_spec_uint64 ("append-window-start", "Append Window Start", + "The timestamp representing the start of the append window", 0, + GST_CLOCK_TIME_NONE, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); + + /** + * GstSourceBuffer:append-window-end: + * + * Any segments processed which have a start time greater than this value will + * be ignored by this Source Buffer. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-appendwindowend) + * + * Since: 1.24 + */ + properties[PROP_APPEND_WINDOW_END] = g_param_spec_uint64 ("append-window-end", + "Append Window End", + "The timestamp representing the end of the append window", + 0, GST_CLOCK_TIME_NONE, GST_CLOCK_TIME_NONE, G_PARAM_READABLE | + G_PARAM_STATIC_STRINGS); + + /** + * GstSourceBuffer:buffered: + * + * The set of Time Intervals that have been loaded into the current Source + * Buffer + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-buffered) + * + * Since: 1.24 + */ + properties[PROP_BUFFERED] = g_param_spec_boxed ("buffered", + "Buffered Time Intervals", + "The set of Time Intervals that have been loaded into" + " the current Source Buffer", G_TYPE_ARRAY, G_PARAM_READABLE | + G_PARAM_STATIC_STRINGS); + + /** + * GstSourceBuffer:content-type: + * + * The MIME content-type of the data stream + * + * Since: 1.24 + */ + properties[PROP_CONTENT_TYPE] = g_param_spec_string ("content-type", + "Content Type", + "The MIME content-type of the data stream", NULL, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS); + + /** + * GstSourceBuffer:timestamp-offset: + * + * The next media segment appended to the current Source Buffer will have its + * start timestamp increased by this amount. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-timestampoffset) + * + * Since: 1.24 + */ + properties[PROP_TIMESTAMP_OFFSET] = g_param_spec_int64 ("timestamp-offset", + "Timestamp Offset", + "The next media segment appended to the current Source Buffer" + " will have its start timestamp increased by this amount", + 0, G_MAXINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); + + /** + * GstSourceBuffer:updating: + * + * Whether the current source buffer is still asynchronously processing + * previously issued commands. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-updating) + * + * Since: 1.24 + */ + properties[PROP_UDPATING] = g_param_spec_boolean ("updating", + "Updating", + "Whether the current Source Buffer is still" + " asynchronously processing previously issued commands", + FALSE, G_PARAM_READABLE); + + g_object_class_install_properties (oclass, N_PROPS, properties); + + /** + * GstSourceBuffer::on-update-start: + * @self: The #GstSourceBuffer that has just started updating + * + * Emitted when @self has begun to process data after a call to + * gst_source_buffer_append_buffer(). + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-onupdatestart) + * + * Since: 1.24 + */ + signals[ON_UPDATE_START] = g_signal_new ("on-update-start", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0); + + /** + * GstSourceBuffer::on-update: + * @self: The #GstSourceBuffer that has just updated + * + * Emitted when @self has successfully processed data after a call to + * gst_source_buffer_append_buffer(). + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-onupdate) + * + * Since: 1.24 + */ + signals[ON_UPDATE] = g_signal_new ("on-update", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0); + + /** + * GstSourceBuffer::on-update-end: + * @self: The #GstSourceBuffer that is no longer updating + * + * Emitted when @self is no longer in the updating state after a call to + * gst_source_buffer_append_buffer(). This can happen after a successful or + * unsuccessful append. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-onupdateend) + * + * Since: 1.24 + */ + signals[ON_UPDATE_END] = g_signal_new ("on-update-end", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0); + + /** + * GstSourceBuffer::on-error: + * @self: The #GstSourceBuffer that has encountered an error + * + * Emitted when @self has encountered an error after a call to + * gst_source_buffer_append_buffer(). + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-onerror) + * + * Since: 1.24 + */ + signals[ON_ERROR] = g_signal_new ("on-error", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0); + + /** + * GstSourceBuffer::on-abort: + * @self: The #GstSourceBuffer that has been aborted. + * + * Emitted when @self was aborted after a call to gst_source_buffer_abort(). + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-onabort) + * + * Since: 1.24 + */ + signals[ON_ABORT] = g_signal_new ("on-abort", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0); +} + +static void +on_duration_changed (GstAppendPipeline * pipeline, gpointer user_data) +{ + GstSourceBuffer *self = GST_SOURCE_BUFFER (user_data); + if (is_removed (self)) { + return; + } + call_duration_changed (self); +} + +static void +on_eos (GstAppendPipeline * pipeline, GstMediaSourceTrack * track, + gpointer user_data) +{ + GstSourceBuffer *self = GST_SOURCE_BUFFER (user_data); + if (GST_IS_MEDIA_SOURCE_TRACK (track)) { + GST_DEBUG_OBJECT (self, "got EOS event on %" GST_PTR_FORMAT, track); + GstMediaSourceTrackBuffer *buffer = get_track_buffer (self, track); + gst_media_source_track_buffer_eos (buffer); + } + update_msesrc_ready_state (self); +} + +static void +on_error (GstAppendPipeline * pipeline, gpointer user_data) +{ + GstSourceBuffer *self = GST_SOURCE_BUFFER (user_data); + append_error (self); +} + +static GstMediaSourceTrackBuffer * +get_track_buffer (GstSourceBuffer * self, GstMediaSourceTrack * track) +{ + g_return_val_if_fail (g_hash_table_contains (self->track_buffers, track), + NULL); + return g_hash_table_lookup (self->track_buffers, track); +} + +static inline TrackFeedTask * +get_track_feed (GstSourceBuffer * self, GstMediaSourceTrack * track) +{ + g_return_val_if_fail (g_hash_table_contains (self->track_feeds, track), NULL); + return g_hash_table_lookup (self->track_feeds, track); +} + +static void +add_track_buffer (GstMediaSourceTrack * track, GstSourceBuffer * self) +{ + const gchar *id = gst_media_source_track_get_id (track); + if (g_hash_table_contains (self->track_buffers, track)) { + GST_DEBUG_OBJECT (self, "already have a track buffer for track %s", id); + return; + } + GstMediaSourceTrackBuffer *buf = gst_media_source_track_buffer_new (); + g_hash_table_insert (self->track_buffers, track, buf); + GST_DEBUG_OBJECT (self, "added track buffer for track %s", id); + + add_track_feed (track, buf, self); +} + +static void +add_track_feed (GstMediaSourceTrack * track, + GstMediaSourceTrackBuffer * track_buffer, GstSourceBuffer * self) +{ + TrackFeedTask *feed = g_new0 (TrackFeedTask, 1); + GstTask *task = gst_task_new ((GstTaskFunction) track_feed_task, feed, NULL); + g_rec_mutex_init (&feed->lock); + gst_task_set_lock (task, &feed->lock); + feed->task = task; + feed->buffer = track_buffer; + feed->track = gst_object_ref (track); + feed->parent = self; + feed->cancelled = FALSE; + g_hash_table_insert (self->track_feeds, track, feed); +} + +static void +clear_track_feed (TrackFeedTask * feed) +{ + gst_object_unref (feed->task); + g_rec_mutex_clear (&feed->lock); + gst_object_unref (feed->track); + g_free (feed); +} + +static void +stop_track_feed (TrackFeedTask * feed) +{ + g_return_if_fail (feed != NULL); + gst_media_source_track_flush (feed->track); + g_atomic_int_set (&feed->cancelled, TRUE); + gst_task_join (feed->task); +} + +static void +start_track_feed (TrackFeedTask * feed) +{ + g_return_if_fail (feed != NULL); + g_atomic_int_set (&feed->cancelled, FALSE); + gst_media_source_track_resume (feed->track); + gst_task_start (feed->task); +} + +static void +reset_track_feed (TrackFeedTask * feed) +{ + stop_track_feed (feed); + start_track_feed (feed); +} + +static gboolean +is_within_append_window (GstSourceBuffer * self, GstSample * sample) +{ + GstBuffer *buffer = gst_sample_get_buffer (sample); + GstClockTime start = GST_BUFFER_PTS (buffer); + GstClockTime end = start + GST_BUFFER_DURATION (buffer); + + if (start < self->append_window_start) { + return FALSE; + } + + if (!GST_CLOCK_TIME_IS_VALID (self->append_window_end)) { + return TRUE; + } + + return end <= self->append_window_end; +} + +static void +on_new_sample (GstAppendPipeline * pipeline, GstMediaSourceTrack * track, + GstSample * sample, gpointer user_data) +{ + GstSourceBuffer *self = GST_SOURCE_BUFFER (user_data); + + g_return_if_fail (self->processed_init_segment); + + GST_OBJECT_LOCK (self); + + if (is_within_append_window (self, sample)) { + GstMediaSourceTrackBuffer *track_buffer = get_track_buffer (self, track); + GST_TRACE_OBJECT (self, "new sample on %s with %" GST_PTR_FORMAT, + gst_media_source_track_get_id (track), gst_sample_get_buffer (sample)); + gst_media_source_track_buffer_add (track_buffer, sample); + TrackFeedTask *feed = get_track_feed (self, track); + start_track_feed (feed); + } + + GST_OBJECT_UNLOCK (self); + + update_msesrc_ready_state (self); +} + +static void +call_received_init_segment (GstSourceBuffer * self) +{ + GstSourceBufferCallbacks *callbacks = &self->callbacks.callbacks; + if (callbacks->received_init_segment) { + callbacks->received_init_segment (self, self->callbacks.user_data); + } +} + +static void +call_duration_changed (GstSourceBuffer * self) +{ + GstSourceBufferCallbacks *callbacks = &self->callbacks.callbacks; + if (callbacks->duration_changed) { + callbacks->duration_changed (self, self->callbacks.user_data); + } +} + +static void +call_active_state_changed (GstSourceBuffer * self) +{ + GstSourceBufferCallbacks *callbacks = &self->callbacks.callbacks; + if (callbacks->active_state_changed) { + callbacks->active_state_changed (self, self->callbacks.user_data); + } +} + +static void +update_track_buffer_modes (GstSourceBuffer * self) +{ + GHashTableIter iter; + g_hash_table_iter_init (&iter, self->track_buffers); + gboolean enabled = + self->append_mode == GST_SOURCE_BUFFER_APPEND_MODE_SEQUENCE; + for (gpointer value; g_hash_table_iter_next (&iter, NULL, &value);) { + GstMediaSourceTrackBuffer *buffer = GST_MEDIA_SOURCE_TRACK_BUFFER (value); + gst_media_source_track_buffer_process_init_segment (buffer, enabled); + gst_media_source_track_buffer_set_group_start (buffer, + self->timestamp_offset); + } +} + +static void +on_received_init_segment (GstAppendPipeline * pipeline, gpointer user_data) +{ + GstSourceBuffer *self = GST_SOURCE_BUFFER (user_data); + GST_DEBUG_OBJECT (self, "got init segment, have duration %" GST_TIME_FORMAT, + GST_TIME_ARGS (gst_append_pipeline_get_duration (pipeline))); + + GST_OBJECT_LOCK (self); + + if (!self->processed_init_segment) { + GST_DEBUG_OBJECT (self, "processing first init segment"); + + GPtrArray *audio_tracks = gst_append_pipeline_get_audio_tracks (pipeline); + GPtrArray *text_tracks = gst_append_pipeline_get_text_tracks (pipeline); + GPtrArray *video_tracks = gst_append_pipeline_get_video_tracks (pipeline); + + g_ptr_array_foreach (audio_tracks, (GFunc) add_track_buffer, self); + g_ptr_array_foreach (text_tracks, (GFunc) add_track_buffer, self); + g_ptr_array_foreach (video_tracks, (GFunc) add_track_buffer, self); + } + + self->processed_init_segment = TRUE; + + update_track_buffer_modes (self); + + GST_OBJECT_UNLOCK (self); + + call_received_init_segment (self); + call_active_state_changed (self); +} + +static guint +track_buffer_hash (GstMediaSourceTrack * track) +{ + return g_str_hash (gst_media_source_track_get_id (track)); +} + +static gboolean +track_buffer_equal (GstMediaSourceTrack * a, GstMediaSourceTrack * b) +{ + return g_str_equal (gst_media_source_track_get_id (a), + gst_media_source_track_get_id (b)); +} + +static void +gst_source_buffer_init (GstSourceBuffer * self) +{ + + self->append_mode = DEFAULT_APPEND_MODE; + self->append_window_start = 0; + self->append_window_end = GST_CLOCK_TIME_NONE; + self->content_type = NULL; + self->timestamp_offset = 0; + self->updating = FALSE; + self->errored = FALSE; + self->size_limit = DEFAULT_BUFFER_SIZE; + self->size = 0; + self->pending_data = NULL; + self->processed_init_segment = FALSE; + self->event_queue = + gst_mse_event_queue_new ((GstMseEventQueueCallback) dispatch_event, self); + + g_rec_mutex_init (&self->append_to_buffer_lock); + self->append_to_buffer_task = gst_task_new ( + (GstTaskFunction) append_to_buffer_task, self, NULL); + gst_task_set_lock (self->append_to_buffer_task, &self->append_to_buffer_lock); + self->track_buffers = g_hash_table_new_full ((GHashFunc) track_buffer_hash, + (GEqualFunc) track_buffer_equal, NULL, gst_object_unref); + + self->track_feeds = g_hash_table_new_full (g_direct_hash, g_direct_equal, + NULL, (GDestroyNotify) clear_track_feed); + self->seek_time = 0; + self->callbacks.callbacks.duration_changed = NULL; + self->callbacks.user_data = NULL; +} + +static inline gboolean +is_removed (GstSourceBuffer * self) +{ + GstObject *parent = gst_object_get_parent (GST_OBJECT (self)); + if (parent == NULL) { + return TRUE; + } + gst_object_unref (parent); + + GstMediaSource *source = get_media_source (self); + GstSourceBufferList *buffers = gst_media_source_get_source_buffers (source); + gboolean removed = !gst_source_buffer_list_contains (buffers, self); + + gst_object_unref (source); + gst_object_unref (buffers); + + return removed; +} + +static inline gboolean +is_updating (GstSourceBuffer * self) +{ + return g_atomic_int_get (&self->updating); +} + +static inline void +set_updating (GstSourceBuffer * self) +{ + g_atomic_int_set (&self->updating, TRUE); +} + +static inline void +clear_updating (GstSourceBuffer * self) +{ + g_atomic_int_set (&self->updating, FALSE); +} + +static inline gboolean +is_errored (GstSourceBuffer * self) +{ + return g_atomic_int_get (&self->errored); +} + +static inline void +set_errored (GstSourceBuffer * self) +{ + g_atomic_int_set (&self->errored, TRUE); +} + +static inline void +clear_errored (GstSourceBuffer * self) +{ + g_atomic_int_set (&self->errored, FALSE); +} + +static inline gboolean +is_ended (GstSourceBuffer * self) +{ + if (is_removed (self)) { + return TRUE; + } + + GstMediaSource *source = get_media_source (self); + gboolean ended = gst_media_source_get_ready_state (source) == + GST_MEDIA_SOURCE_READY_STATE_ENDED; + + gst_object_unref (source); + + return ended; +} + +static void +open_parent (GstSourceBuffer * self) +{ + g_return_if_fail (!is_removed (self)); + GstMediaSource *source = get_media_source (self); + gst_media_source_open (source); + gst_object_unref (source); +} + +/** + * gst_source_buffer_get_append_mode: + * @self: #GstSourceBuffer instance + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-mode) + * + * Returns: The current #GstSourceBufferAppendMode + * Since: 1.24 + */ +GstSourceBufferAppendMode +gst_source_buffer_get_append_mode (GstSourceBuffer * self) +{ + g_return_val_if_fail (GST_IS_SOURCE_BUFFER (self), DEFAULT_APPEND_MODE); + return self->append_mode; +} + +/** + * gst_source_buffer_set_append_mode: + * @self: #GstSourceBuffer instance + * @mode: #GstSourceBufferAppendMode the desired Append Mode + * @error: (out) (optional) (nullable) (transfer full): the resulting error or `NULL` + * + * Changes the Append Mode of @self. This influences what timestamps will be + * assigned to media processed by this Source Buffer. In Segment mode, the + * timestamps in each segment determine the position of each sample after it + * is processed. In Sequence mode, the timestamp of each processed sample is + * generated based on the end of the most recently processed segment. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-mode) + * + * Returns: `TRUE` on success, `FALSE` otherwise + * Since: 1.24 + */ +gboolean +gst_source_buffer_set_append_mode (GstSourceBuffer * self, + GstSourceBufferAppendMode mode, GError ** error) +{ + g_return_val_if_fail (GST_IS_SOURCE_BUFFER (self), FALSE); + + if (is_removed (self)) { + g_set_error (error, + GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_INVALID_STATE, + "buffer is removed"); + return FALSE; + } + + if (is_updating (self)) { + g_set_error (error, + GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_INVALID_STATE, + "buffer is still updating"); + return FALSE; + } + + if (self->generate_timestamps && mode == + GST_SOURCE_BUFFER_APPEND_MODE_SEGMENTS) { + g_set_error (error, + GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_TYPE, + "cannot change to segments mode while generate timestamps is active"); + return FALSE; + } + + if (is_ended (self)) { + open_parent (self); + } + + self->append_mode = mode; + g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_APPEND_MODE]); + return TRUE; +} + +/** + * gst_source_buffer_get_append_window_start: + * @self: #GstSourceBuffer instance + * + * Returns the current append window start time. Any segment processed that ends + * earlier than this value will be ignored. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-appendwindowstart) + * + * Returns: The current Append Window start time as a #GstClockTime + * Since: 1.24 + */ +GstClockTime +gst_source_buffer_get_append_window_start (GstSourceBuffer * self) +{ + g_return_val_if_fail (GST_IS_SOURCE_BUFFER (self), GST_CLOCK_TIME_NONE); + return self->append_window_start; +} + +/** + * gst_source_buffer_set_append_window_start: + * @self: #GstSourceBuffer instance + * @start: the append window end + * @error: (out) (optional) (nullable) (transfer full): the resulting error or `NULL` + * + * Modifies the current append window start of @self. If successful, samples + * processed after setting this value that end before this point will be + * ignored. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-appendwindowstart) + * + * Returns: `TRUE` on success, `FALSE` otherwise + * Since: 1.24 + */ +gboolean +gst_source_buffer_set_append_window_start (GstSourceBuffer * self, + GstClockTime start, GError ** error) +{ + g_return_val_if_fail (GST_IS_SOURCE_BUFFER (self), FALSE); + + if (is_removed (self)) { + g_set_error (error, + GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_INVALID_STATE, + "append window start cannot be set on source buffer " + "with no media source"); + return FALSE; + } + + if (is_updating (self)) { + g_set_error (error, + GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_INVALID_STATE, + "append window start cannot be set on source buffer while updating"); + return FALSE; + } + + if (start < 0 || start <= self->append_window_end) { + g_set_error (error, + GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_TYPE, + "append window start must be between zero and append window end"); + return FALSE; + } + + self->append_window_start = start; + g_object_notify_by_pspec (G_OBJECT (self), + properties[PROP_APPEND_WINDOW_START]); + return TRUE; +} + +/** + * gst_source_buffer_get_append_window_end: + * @self: #GstSourceBuffer instance + * + * Returns the current append window end time. Any segment processed that starts + * after this value will be ignored. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-appendwindowend) + * + * Returns: The current Append Window end time as a #GstClockTime + * Since: 1.24 + */ +GstClockTime +gst_source_buffer_get_append_window_end (GstSourceBuffer * self) +{ + g_return_val_if_fail (GST_IS_SOURCE_BUFFER (self), GST_CLOCK_TIME_NONE); + return self->append_window_end; +} + +/** + * gst_source_buffer_set_append_window_end: + * @self: #GstSourceBuffer instance + * @end: the append window end + * @error: (out) (optional) (nullable) (transfer full): the resulting error or `NULL` + * + * Modifies the current append window end of @self. If successful, samples + * processed after setting this value that start after this point will be + * ignored. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-appendwindowend) + * + * Returns: `TRUE` on success, `FALSE` otherwise + * Since: 1.24 + */ +gboolean +gst_source_buffer_set_append_window_end (GstSourceBuffer * self, + GstClockTime end, GError ** error) +{ + g_return_val_if_fail (GST_IS_SOURCE_BUFFER (self), FALSE); + + if (is_removed (self)) { + g_set_error (error, + GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_INVALID_STATE, + "append window end cannot be set on source buffer " + "with no media source"); + return FALSE; + } + + if (is_updating (self)) { + g_set_error (error, + GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_INVALID_STATE, + "append window end cannot be set on source buffer while updating"); + return FALSE; + } + + if (end <= self->append_window_start) { + g_set_error (error, + GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_TYPE, + "append window end must be after append window start"); + return FALSE; + } + + self->append_window_end = end; + g_object_notify_by_pspec (G_OBJECT (self), + properties[PROP_APPEND_WINDOW_END]); + return TRUE; +} + +static gboolean +get_intersection (GstMediaSourceRange * a, GstMediaSourceRange * b, + GstMediaSourceRange * intersection) +{ + g_return_val_if_fail (a != NULL, FALSE); + g_return_val_if_fail (b != NULL, FALSE); + g_return_val_if_fail (intersection != NULL, FALSE); + GstMediaSourceRange range = { + .start = MAX (a->start, b->start), + .end = MIN (a->end, b->end), + }; + if (range.start >= range.end) { + return FALSE; + } + *intersection = range; + return TRUE; +} + +static GArray * +intersect_ranges (GstMediaSourceRange * a, GstMediaSourceRange * a_end, + GstMediaSourceRange * b, GstMediaSourceRange * b_end) +{ + GArray *intersection = g_array_new_ranges (); + while (a < a_end && b < b_end) { + GstMediaSourceRange range; + if (!get_intersection (a, b, &range)) { + if (a->end < b->end) { + a++; + } else { + b++; + } + continue; + } + + if (a->end < b->end) { + a++; + } else { + b++; + } + + g_array_append_val (intersection, range); + } + return intersection; +} + +static inline gboolean +contributes_to_buffered (GstMediaSourceTrack * track) +{ + switch (gst_media_source_track_get_track_type (track)) { + case GST_MEDIA_SOURCE_TRACK_TYPE_AUDIO: + case GST_MEDIA_SOURCE_TRACK_TYPE_VIDEO: + return TRUE; + default: + return FALSE; + } +} + +/** + * gst_source_buffer_get_buffered: + * @self: #GstSourceBuffer instance + * @error: (out) (optional) (nullable) (transfer full): the resulting error or `NULL` + * + * Returns a sequence of #GstMediaSourceRange values representing which segments + * of @self are buffered in memory. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-buffered) + * + * Returns: (transfer full) (element-type GstMediaSourceRange): a #GArray of #GstMediaSourceRange values. + * Since: 1.24 + */ +GArray * +gst_source_buffer_get_buffered (GstSourceBuffer * self, GError ** error) +{ + g_return_val_if_fail (GST_IS_SOURCE_BUFFER (self), NULL); + GHashTableIter iter; + GArray *buffered = NULL; + g_hash_table_iter_init (&iter, self->track_buffers); + for (gpointer key, value; g_hash_table_iter_next (&iter, &key, &value);) { + GstMediaSourceTrack *track = GST_MEDIA_SOURCE_TRACK (key); + GstMediaSourceTrackBuffer *buffer = GST_MEDIA_SOURCE_TRACK_BUFFER (value); + if (!contributes_to_buffered (track)) { + continue; + } + GArray *current_ranges = gst_media_source_track_buffer_get_ranges (buffer); + if (buffered == NULL) { + buffered = current_ranges; + continue; + } + GArray *intersection = intersect_ranges ( + (GstMediaSourceRange *) buffered->data, + ((GstMediaSourceRange *) buffered->data) + buffered->len, + (GstMediaSourceRange *) current_ranges->data, + ((GstMediaSourceRange *) current_ranges->data) + current_ranges->len); + g_array_unref (buffered); + buffered = intersection; + } + if (buffered == NULL) { + return g_array_new_ranges (); + } else { + return buffered; + } +} + +/** + * gst_source_buffer_get_content_type: + * @self: #GstSourceBuffer instance + * + * Returns the current content type of @self. + * + * Returns: (transfer full): a string representing the content type + * Since: 1.24 + */ +gchar * +gst_source_buffer_get_content_type (GstSourceBuffer * self) +{ + g_return_val_if_fail (GST_IS_SOURCE_BUFFER (self), NULL); + + GST_OBJECT_LOCK (self); + gchar *content_type = g_strdup (self->content_type); + GST_OBJECT_UNLOCK (self); + + return content_type; +} + +/** + * gst_source_buffer_change_content_type: + * @self: #GstSourceBuffer instance + * @type: (transfer none): the desired content type + * @error: (out) (optional) (nullable) (transfer full): the resulting error or `NULL` + * + * Attempts to change the content type of @self to @type. Any new data appended + * to the Source Buffer must be of the supplied @type afterward. + * + * Returns: `TRUE` on success, `FALSE` otherwise + * Since: 1.24 + */ +gboolean +gst_source_buffer_change_content_type (GstSourceBuffer * self, + const gchar * type, GError ** error) +{ + g_return_val_if_fail (GST_IS_SOURCE_BUFFER (self), FALSE); + + if (type == NULL || g_strcmp0 (type, "") == 0) { + g_set_error (error, + GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_TYPE, + "content type must not be empty"); + return FALSE; + } + + if (is_removed (self)) { + g_set_error (error, + GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_INVALID_STATE, + "content type cannot be set on source buffer with no media source"); + return FALSE; + } + + if (is_updating (self)) { + g_set_error (error, + GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_INVALID_STATE, + "content type cannot be set on source buffer that is updating"); + return FALSE; + } + + g_set_error (error, + GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_NOT_SUPPORTED, + "content type cannot be changed"); + return FALSE; +} + +/** + * gst_source_buffer_remove: + * @self: #GstSourceBuffer instance + * @start: The beginning timestamp of data to remove + * @end: The end timestamp of data to remove + * @error: (out) (optional) (nullable) (transfer full): the resulting error or `NULL` + * + * Attempts to remove any parsed data between @start and @end from @self. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-remove) + * + * Returns: `TRUE` on success, `FALSE` otherwise + * Since: 1.24 + */ +gboolean +gst_source_buffer_remove (GstSourceBuffer * self, GstClockTime start, + GstClockTime end, GError ** error) +{ + g_return_val_if_fail (GST_IS_SOURCE_BUFFER (self), FALSE); + return TRUE; +} + +/** + * gst_source_buffer_get_timestamp_offset: + * @self: #GstSourceBuffer instance + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-timestampoffset) + * + * Returns: The current timestamp offset as a #GstClockTime + * Since: 1.24 + */ +GstClockTime +gst_source_buffer_get_timestamp_offset (GstSourceBuffer * self) +{ + return self->timestamp_offset; +} + +/** + * gst_source_buffer_set_timestamp_offset: + * @self: #GstSourceBuffer instance + * @offset: The new timestamp offset + * @error: (out) (optional) (nullable) (transfer full): the resulting error or `NULL` + * + * Attempt to set the timestamp offset of @self. Any media processed after this + * value is set will have this value added to its start time. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-timestampoffset) + * + * Returns: `TRUE` on success, `FALSE` otherwise + * Since: 1.24 + */ +gboolean +gst_source_buffer_set_timestamp_offset (GstSourceBuffer * self, GstClockTime + offset, GError ** error) +{ + g_return_val_if_fail (GST_IS_SOURCE_BUFFER (self), FALSE); + if (is_removed (self)) { + g_set_error (error, + GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_INVALID_STATE, + "source buffer is removed"); + return FALSE; + } + if (is_updating (self)) { + g_set_error (error, + GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_INVALID_STATE, + "source buffer is still updating"); + return FALSE; + } + if (is_ended (self)) { + GstMediaSource *parent = get_media_source (self); + gst_media_source_open (parent); + gst_clear_object (&parent); + } + GST_OBJECT_LOCK (self); + GHashTableIter iter; + g_hash_table_iter_init (&iter, self->track_buffers); + for (gpointer value; g_hash_table_iter_next (&iter, NULL, &value);) { + GstMediaSourceTrackBuffer *buffer = value; + gst_media_source_track_buffer_set_group_start (buffer, offset); + } + self->timestamp_offset = offset; + GST_OBJECT_UNLOCK (self); + g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_TIMESTAMP_OFFSET]); + return TRUE; +} + +/** + * gst_source_buffer_get_updating: + * @self: #GstSourceBuffer instance + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-updating) + * + * Returns: Whether @self is currently adding or removing media content. + * Since: 1.24 + */ +gboolean +gst_source_buffer_get_updating (GstSourceBuffer * self) +{ + g_return_val_if_fail (GST_IS_SOURCE_BUFFER (self), FALSE); + return is_updating (self); +} + +static gsize +compute_total_size_unlocked (GstSourceBuffer * self) +{ + GHashTableIter iter; + g_hash_table_iter_init (&iter, self->track_buffers); + gsize total_size = 0; + for (gpointer value; g_hash_table_iter_next (&iter, NULL, &value);) { + GstMediaSourceTrackBuffer *buffer = value; + total_size += gst_media_source_track_buffer_get_storage_size (buffer); + } + return total_size; +} + +static gboolean +will_overflow (GstSourceBuffer * self, gsize bytes) +{ + GST_OBJECT_LOCK (self); + gsize total = compute_total_size_unlocked (self); + GST_OBJECT_UNLOCK (self); + return total + bytes > self->size_limit; +} + +static void +evict_coded_frames (GstSourceBuffer * self, gsize space_required, + gsize size_limit, GstClockTime position, GstClockTime duration) +{ + if (!will_overflow (self, space_required)) { + return; + } + + if (!GST_CLOCK_TIME_IS_VALID (position)) { + GST_ERROR ("invalid position, cannot delete anything"); + return; + } + + GstClockTime min_distance_from_position = GST_SECOND * 5; + GstClockTime max_dts = position > min_distance_from_position ? + position - min_distance_from_position : 0; + + GST_DEBUG_OBJECT (self, "position=%" GST_TIMEP_FORMAT + ", attempting removal from 0 to %" GST_TIMEP_FORMAT, &position, &max_dts); + + GST_OBJECT_LOCK (self); + GHashTableIter iter; + g_hash_table_iter_init (&iter, self->track_buffers); + for (gpointer value; g_hash_table_iter_next (&iter, NULL, &value);) { + GstMediaSourceTrackBuffer *buffer = value; + gst_media_source_track_buffer_remove_range (buffer, 0, max_dts); + } + self->size = compute_total_size_unlocked (self); + GST_OBJECT_UNLOCK (self); + + GST_DEBUG_OBJECT (self, "capacity=%" G_GSIZE_FORMAT "/%" G_GSIZE_FORMAT + "(%" G_GSIZE_FORMAT "%%)", self->size, self->size_limit, + self->size * 100 / size_limit); +} + +static void +reset_parser_state (GstSourceBuffer * self) +{ + clear_pending_data (self); + if (gst_append_pipeline_reset (self->append_pipeline)) { + clear_errored (self); + } else { + set_errored (self); + } +} + +static void +append_error (GstSourceBuffer * self) +{ + gst_task_stop (self->append_to_buffer_task); + reset_parser_state (self); + clear_updating (self); + + if (is_removed (self)) { + return; + } + + schedule_event (self, ON_ERROR); + schedule_event (self, ON_UPDATE_END); + + GstMediaSource *source = get_media_source (self); + gst_media_source_end_of_stream (source, GST_MEDIA_SOURCE_EOS_ERROR_DECODE, + NULL); + gst_object_unref (source); +} + +static void +append_successful (GstSourceBuffer * self, gboolean ended) +{ + gst_task_stop (self->append_to_buffer_task); + clear_updating (self); + schedule_event (self, ON_UPDATE); + schedule_event (self, ON_UPDATE_END); +} + +static gboolean +encountered_bad_bytes (GstSourceBuffer * self) +{ + return gst_append_pipeline_get_failed (self->append_pipeline); +} + +static void +append_to_buffer_task (GstSourceBuffer * self) +{ + if (is_removed (self)) { + append_successful (self, TRUE); + return; + } + + if (encountered_bad_bytes (self)) { + append_error (self); + return; + } + + GstBuffer *pending_data = take_pending_data (self); + + if (!GST_IS_BUFFER (pending_data)) { + GST_LOG_OBJECT (self, "no pending data"); + append_successful (self, is_ended (self)); + return; + } + + GstFlowReturn result = gst_append_pipeline_append (self->append_pipeline, + pending_data); + + if (result != GST_FLOW_OK) { + GST_ERROR_OBJECT (self, "failed to append: %s", gst_flow_get_name (result)); + append_error (self); + return; + } + + append_successful (self, is_ended (self)); +} + +static gboolean +track_feed_fold (const GValue * item, TrackFeedAccumulator * acc, + TrackFeedTask * feed) +{ + GstSample *sample = gst_sample_ref (gst_value_get_sample (item)); + GstClockTime dts = GST_BUFFER_DTS (gst_sample_get_buffer (sample)); + acc->n_samples++; + acc->current_dts = dts; + gst_clear_sample (&acc->current_sample); + acc->current_sample = gst_sample_ref (sample); + if (gst_media_source_track_push (feed->track, sample)) { + return TRUE; + } else { + gst_sample_unref (sample); + return FALSE; + } +} + +static void +track_feed_task (TrackFeedTask * feed) +{ + GstSourceBuffer *self = feed->parent; + GstMediaSourceTrack *track = feed->track; + GstMediaSourceTrackBuffer *buffer = feed->buffer; + GstClockTime time = feed->parent->seek_time; + const gchar *track_id = gst_media_source_track_get_id (track); + + GST_DEBUG_OBJECT (self, "%s: feed starting@%" GST_TIMEP_FORMAT, track_id, + &time); + + TrackFeedAccumulator acc = { + .n_samples = 0, + .current_dts = time, + .current_sample = NULL, + }; + while (TRUE) { + gboolean eos = gst_media_source_track_buffer_is_eos (buffer); + GstIterator *it = gst_media_source_track_buffer_iter_samples (buffer, + acc.current_dts, acc.current_sample); + while (TRUE) { + GstIteratorResult fold_result = gst_iterator_fold (it, + (GstIteratorFoldFunction) track_feed_fold, (GValue *) & acc, feed); + if (fold_result != GST_ITERATOR_RESYNC) { + break; + } + if (g_atomic_int_get (&feed->cancelled)) { + break; + } + gst_iterator_resync (it); + } + gst_iterator_free (it); + + if (eos) { + GST_DEBUG_OBJECT (self, "%s: enqueued all %" G_GSIZE_FORMAT " samples", + track_id, acc.n_samples); + gst_media_source_track_push_eos (track); + GST_DEBUG_OBJECT (self, "%s: marked EOS", track_id); + gst_task_stop (feed->task); + break; + } + + if (g_atomic_int_get (&feed->cancelled)) { + GST_DEBUG_OBJECT (self, "feed is cancelled, stopping task"); + gst_task_stop (feed->task); + break; + } + + GST_DEBUG_OBJECT (self, "%s: resume after %" G_GSIZE_FORMAT " samples", + track_id, acc.n_samples); + gint64 deadline = g_get_monotonic_time () + G_TIME_SPAN_SECOND; + gst_media_source_track_buffer_await_eos_until (buffer, deadline); + } + + gst_clear_sample (&acc.current_sample); +} + +static void +dispatch_event (SourceBufferEventItem * item, GstSourceBuffer * self) +{ + g_signal_emit (self, signals[item->event], 0); +} + +static void +schedule_event (GstSourceBuffer * self, SourceBufferEvent event) +{ + g_return_if_fail (event < N_SIGNALS); + if (is_removed (self)) { + return; + } + SourceBufferEventItem item = { + .item = {.destroy = g_free,.visible = TRUE,.size = 1,.object = NULL}, + .event = event, + }; + gst_mse_event_queue_push (self->event_queue, g_memdup2 (&item, + sizeof (SourceBufferEventItem))); +} + +static void +schedule_append_to_buffer_task (GstSourceBuffer * self) +{ + GstTask *task = self->append_to_buffer_task; + g_return_if_fail (GST_IS_TASK (task)); + g_return_if_fail (gst_task_get_state (task) != GST_TASK_STARTED); + gst_task_start (task); +} + +static void +update_msesrc_ready_state (GstSourceBuffer * self) +{ + GstMseSrc *element = get_msesrc (self); + if (element == NULL) { + return; + } + gst_mse_src_update_ready_state (element); + gst_object_unref (element); +} + +/** + * gst_source_buffer_append_buffer: + * @self: #GstSourceBuffer instance + * @buf: (transfer full):The media data to append + * @error: (out) (optional) (nullable) (transfer full): the resulting error or `NULL` + * + * Schedules the bytes inside @buf to be processed by @self. When it is possible + * to accept the supplied data, it will be processed asynchronously and fill in + * the track buffers for playback purposes. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-appendbuffer) + * + * Returns: `TRUE` on success, `FALSE` otherwise + * Since: 1.24 + */ +gboolean +gst_source_buffer_append_buffer (GstSourceBuffer * self, GstBuffer * buf, + GError ** error) +{ + g_return_val_if_fail (GST_IS_SOURCE_BUFFER (self), FALSE); + g_return_val_if_fail (GST_IS_BUFFER (buf), FALSE); + + if (is_removed (self) || is_updating (self)) { + g_set_error (error, + GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_INVALID_STATE, + "source buffer is removed or still updating"); + return FALSE; + } + + if (is_errored (self)) { + g_set_error (error, + GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_INVALID_STATE, + "source buffer has encountered error"); + return FALSE; + } + + if (is_ended (self)) { + open_parent (self); + } + + GstMediaSource *source = get_media_source (self); + gsize buffer_size = gst_buffer_get_size (buf); + GstClockTime position = gst_media_source_get_position (source); + GstClockTime duration = gst_media_source_get_duration (source); + + gst_object_unref (source); + + evict_coded_frames (self, buffer_size, self->size_limit, position, duration); + + if (will_overflow (self, buffer_size)) { + g_set_error (error, + GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_QUOTA_EXCEEDED, + "buffer is full"); + return FALSE; + } + + g_return_val_if_fail (self->pending_data == NULL, FALSE); + + set_pending_data (self, buf); + set_updating (self); + + schedule_event (self, ON_UPDATE_START); + schedule_append_to_buffer_task (self); + + return TRUE; +} + +/** + * gst_source_buffer_abort: + * @self: #GstSourceBuffer instance + * @error: (out) (optional) (nullable) (transfer full): the resulting error or `NULL` + * + * Attempts to end any processing of the currently pending data and reset the + * media parser. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebuffer-abort) + * + * Returns: `TRUE` on success, `FALSE` otherwise + * Since: 1.24 + */ +gboolean +gst_source_buffer_abort (GstSourceBuffer * self, GError ** error) +{ + g_return_val_if_fail (GST_IS_SOURCE_BUFFER (self), FALSE); + if (gst_append_pipeline_eos (self->append_pipeline) == GST_FLOW_OK) { + return TRUE; + } else { + g_set_error (error, + GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_INVALID_STATE, + "failed to abort source buffer"); + return FALSE; + } +} + +gboolean +gst_source_buffer_has_init_segment (GstSourceBuffer * self) +{ + g_return_val_if_fail (GST_IS_SOURCE_BUFFER (self), FALSE); + return gst_append_pipeline_has_init_segment (self->append_pipeline); +} + +static gboolean +is_buffered_fold (const GValue * item, IsBufferedAccumulator * acc, + GstSourceBuffer * self) +{ + GstSample *sample = gst_value_get_sample (item); + GstBuffer *buffer = gst_sample_get_buffer (sample); + GstClockTime buffer_start = GST_BUFFER_DTS (buffer); + GstClockTime buffer_end = buffer_start + GST_BUFFER_DURATION (buffer); + if (acc->time < buffer_start) { + GST_TRACE_OBJECT (self, "position precedes buffer start, done"); + acc->buffered = FALSE; + return FALSE; + } + if (acc->time >= buffer_start && acc->time < buffer_end) { + GST_TRACE_OBJECT (self, "position is within buffer, done"); + acc->buffered = TRUE; + return FALSE; + } + return TRUE; +} + +gboolean +gst_source_buffer_is_buffered (GstSourceBuffer * self, GstClockTime time) +{ + GHashTableIter iter; + gboolean buffered = TRUE; + g_hash_table_iter_init (&iter, self->track_buffers); + for (gpointer key, value; + buffered && g_hash_table_iter_next (&iter, &key, &value);) { + GstMediaSourceTrack *track = key; + if (!gst_media_source_track_get_active (track)) { + continue; + } + GstMediaSourceTrackBuffer *track_buffer = value; + IsBufferedAccumulator acc = { + .time = time, + .buffered = FALSE, + }; + GstIterator *iter = + gst_media_source_track_buffer_iter_samples (track_buffer, time, NULL); + while (gst_iterator_fold (iter, (GstIteratorFoldFunction) is_buffered_fold, + (GValue *) & acc, self) == GST_ITERATOR_RESYNC) { + gst_iterator_resync (iter); + } + gst_iterator_free (iter); + buffered = acc.buffered; + } + return buffered; +} + +static gboolean +is_range_buffered_fold (const GValue * item, IsRangeBufferedAccumulator * acc, + GstSourceBuffer * self) +{ + GstSample *sample = gst_value_get_sample (item); + GstBuffer *buffer = gst_sample_get_buffer (sample); + GstClockTime buffer_start = GST_BUFFER_DTS (buffer); + GstClockTime buffer_end = buffer_start + GST_BUFFER_DURATION (buffer); + + GstClockTime start = acc->start; + GstClockTime end = acc->end; + + if (!acc->start_buffered) { + if (start < buffer_start) { + GST_TRACE_OBJECT (self, "start position precedes buffer start, done"); + return FALSE; + } + if (start >= buffer_start && start < buffer_end) { + GST_TRACE_OBJECT (self, "start position is within buffer, checking end"); + acc->start_buffered = TRUE; + return TRUE; + } + } else { + if (end < buffer_start) { + GST_TRACE_OBJECT (self, "end position precedes buffer start, done"); + return FALSE; + } + if (end <= buffer_end) { + GST_TRACE_OBJECT (self, "end position is within buffer, done"); + acc->end_buffered = TRUE; + return FALSE; + } + } + + return TRUE; +} + +gboolean +gst_source_buffer_is_range_buffered (GstSourceBuffer * self, GstClockTime start, + GstClockTime end) +{ + GHashTableIter iter; + gboolean buffered = TRUE; + g_hash_table_iter_init (&iter, self->track_buffers); + for (gpointer key, value; + buffered && g_hash_table_iter_next (&iter, &key, &value);) { + GstMediaSourceTrack *track = key; + if (!gst_media_source_track_get_active (track)) { + continue; + } + GstMediaSourceTrackBuffer *track_buffer = value; + IsRangeBufferedAccumulator acc = { + .start = start, + .end = end, + .start_buffered = FALSE, + .end_buffered = FALSE, + }; + GstIterator *iter = + gst_media_source_track_buffer_iter_samples (track_buffer, start, NULL); + while (gst_iterator_fold (iter, + (GstIteratorFoldFunction) is_range_buffered_fold, (GValue *) & acc, + self) == GST_ITERATOR_RESYNC) { + gst_iterator_resync (iter); + } + buffered = acc.end_buffered; + gst_iterator_free (iter); + } + return buffered; +} + +GstClockTime +gst_source_buffer_get_duration (GstSourceBuffer * self) +{ + g_return_val_if_fail (GST_IS_SOURCE_BUFFER (self), GST_CLOCK_TIME_NONE); + return gst_append_pipeline_get_duration (self->append_pipeline); +} + +void +gst_source_buffer_teardown (GstSourceBuffer * self) +{ + reset_parser_state (self); + clear_updating (self); +} + +GPtrArray * +gst_source_buffer_get_all_tracks (GstSourceBuffer * self) +{ + g_return_val_if_fail (GST_IS_SOURCE_BUFFER (self), NULL); + + GPtrArray *tracks = g_ptr_array_new (); + + GPtrArray *audio_tracks = gst_append_pipeline_get_audio_tracks + (self->append_pipeline); + GPtrArray *text_tracks = gst_append_pipeline_get_text_tracks + (self->append_pipeline); + GPtrArray *video_tracks = gst_append_pipeline_get_video_tracks + (self->append_pipeline); + + if (audio_tracks) { + g_ptr_array_extend (tracks, audio_tracks, NULL, NULL); + } + if (text_tracks) { + g_ptr_array_extend (tracks, text_tracks, NULL, NULL); + } + if (video_tracks) { + g_ptr_array_extend (tracks, video_tracks, NULL, NULL); + } + + return tracks; +} + +static void +seek_track_buffer (GstMediaSourceTrack * track, + GstMediaSourceTrackBuffer * buffer, GstSourceBuffer * self) +{ + TrackFeedTask *feed = get_track_feed (self, track); + + const gchar *track_id = gst_media_source_track_get_id (track); + GST_DEBUG_OBJECT (self, "%s: seeking", track_id); + reset_track_feed (feed); + GST_DEBUG_OBJECT (self, "%s: restarted track feed", track_id); +} + +void +gst_source_buffer_seek (GstSourceBuffer * self, GstClockTime time) +{ + g_return_if_fail (GST_IS_SOURCE_BUFFER (self)); + g_return_if_fail (GST_CLOCK_TIME_IS_VALID (time)); + self->seek_time = time; + g_hash_table_foreach (self->track_buffers, (GHFunc) seek_track_buffer, self); +} + +gboolean +gst_source_buffer_get_active (GstSourceBuffer * self) +{ + gboolean active = FALSE; + GHashTableIter iter; + GST_OBJECT_LOCK (self); + g_hash_table_iter_init (&iter, self->track_buffers); + for (gpointer key; !active && g_hash_table_iter_next (&iter, &key, NULL);) { + GstMediaSourceTrack *track = GST_MEDIA_SOURCE_TRACK (key); + active |= gst_media_source_track_get_active (track); + } + GST_OBJECT_UNLOCK (self); + return active; +} diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstsourcebuffer.h b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstsourcebuffer.h new file mode 100644 index 0000000000..965094ae4c --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstsourcebuffer.h @@ -0,0 +1,127 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2013 Google Inc. All rights reserved. + * Copyright (C) 2013 Orange + * Copyright (C) 2013-2020 Apple Inc. All rights reserved. + * Copyright (C) 2014 Sebastian Dröge + * Copyright (C) 2015, 2016, 2017 Igalia, S.L + * Copyright (C) 2015, 2016, 2017 Metrological Group B.V. + * Copyright (C) 2022, 2023 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#pragma once + +#include +#include +#include + +G_BEGIN_DECLS + +/** + * GstSourceBufferAppendMode: + * @GST_SOURCE_BUFFER_APPEND_MODE_SEGMENTS: + * @GST_SOURCE_BUFFER_APPEND_MODE_SEQUENCE: + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-appendmode) + * + * Since: 1.24 + */ +typedef enum +{ + GST_SOURCE_BUFFER_APPEND_MODE_SEGMENTS, + GST_SOURCE_BUFFER_APPEND_MODE_SEQUENCE, +} GstSourceBufferAppendMode; + +/** + * GstSourceBufferInterval: + * + * Since: 1.24 + */ +typedef struct +{ + GstClockTime start; + GstClockTime end; +} GstSourceBufferInterval; + +#define GST_TYPE_SOURCE_BUFFER (gst_source_buffer_get_type()) + +GST_MSE_API +G_DECLARE_FINAL_TYPE (GstSourceBuffer, gst_source_buffer, GST, SOURCE_BUFFER, + GstObject); + +GST_MSE_API +GstSourceBufferAppendMode gst_source_buffer_get_append_mode ( + GstSourceBuffer * self); + +GST_MSE_API +gboolean gst_source_buffer_set_append_mode (GstSourceBuffer * self, + GstSourceBufferAppendMode mode, GError ** error); + +GST_MSE_API +gchar *gst_source_buffer_get_content_type (GstSourceBuffer * self); + +GST_MSE_API +gboolean gst_source_buffer_get_updating (GstSourceBuffer * self); + +GST_MSE_API +GArray * gst_source_buffer_get_buffered (GstSourceBuffer * self, + GError ** error); + +GST_MSE_API +gboolean gst_source_buffer_set_timestamp_offset (GstSourceBuffer * self, + GstClockTime offset, + GError ** error); + +GST_MSE_API +GstClockTime gst_source_buffer_get_timestamp_offset (GstSourceBuffer * self); + +GST_MSE_API +gboolean gst_source_buffer_set_append_window_start (GstSourceBuffer * self, + GstClockTime start, + GError ** error); + +GST_MSE_API +GstClockTime gst_source_buffer_get_append_window_start (GstSourceBuffer * self); + +GST_MSE_API +gboolean gst_source_buffer_set_append_window_end (GstSourceBuffer * self, + GstClockTime end, + GError ** error); + +GST_MSE_API +GstClockTime gst_source_buffer_get_append_window_end (GstSourceBuffer * self); + +GST_MSE_API +gboolean gst_source_buffer_append_buffer (GstSourceBuffer * self, + GstBuffer * buf, GError ** error); + +GST_MSE_API +gboolean gst_source_buffer_abort (GstSourceBuffer * self, GError ** error); + +GST_MSE_API +gboolean gst_source_buffer_change_content_type (GstSourceBuffer * self, + const gchar * type, + GError ** error); + +GST_MSE_API +gboolean gst_source_buffer_remove (GstSourceBuffer * self, GstClockTime start, + GstClockTime end, GError ** error); + +G_END_DECLS diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstsourcebufferlist-private.h b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstsourcebufferlist-private.h new file mode 100644 index 0000000000..264fb35e6a --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstsourcebufferlist-private.h @@ -0,0 +1,64 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2022, 2023 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#pragma once + +#include +#include "gstsourcebufferlist.h" +#include "gstsourcebuffer.h" + +G_BEGIN_DECLS + +GST_MSE_PRIVATE +GstSourceBufferList *gst_source_buffer_list_new (void); + +GST_MSE_PRIVATE +gboolean gst_source_buffer_list_contains (GstSourceBufferList * self, + GstSourceBuffer * buf); + +GST_MSE_PRIVATE +void gst_source_buffer_list_append (GstSourceBufferList * self, + GstSourceBuffer * buf); + +GST_MSE_PRIVATE +gboolean gst_source_buffer_list_remove (GstSourceBufferList * self, + GstSourceBuffer * buf); + +GST_MSE_PRIVATE +void gst_source_buffer_list_remove_all (GstSourceBufferList * self); + +GST_MSE_PRIVATE +void gst_source_buffer_list_notify_freeze (GstSourceBufferList * self); + +GST_MSE_PRIVATE +void gst_source_buffer_list_notify_cancel (GstSourceBufferList * self); + +GST_MSE_PRIVATE +void gst_source_buffer_list_notify_added (GstSourceBufferList * self); + +GST_MSE_PRIVATE +void gst_source_buffer_list_notify_removed (GstSourceBufferList * self); + +GST_MSE_PRIVATE +void gst_source_buffer_list_notify_thaw (GstSourceBufferList * self); + +G_END_DECLS diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstsourcebufferlist.c b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstsourcebufferlist.c new file mode 100644 index 0000000000..db1f9d038d --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstsourcebufferlist.c @@ -0,0 +1,461 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2022, 2023 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +/** + * SECTION:gstsourcebufferlist + * @title: GstSourceBufferList + * @short_description: Source Buffer List + * @include: mse/mse.h + * @symbols: + * - GstSourceBufferList + * + * The Source Buffer List is a list of #GstSourceBuffers that can be + * indexed numerically and monitored for changes. The list itself cannot be + * modified through this interface, though the Source Buffers it holds can be + * modified after retrieval. + * + * It is used by #GstMediaSource to provide direct access to its child + * #GstSourceBuffers through #GstMediaSource:source-buffers as well as + * informing clients which of the Source Buffers are active through + * #GstMediaSource:active-source-buffers. + * + * Since: 1.24 + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gstsourcebufferlist.h" +#include "gstsourcebufferlist-private.h" + +#include "gstmseeventqueue-private.h" + +typedef struct +{ + gboolean frozen; + gboolean added; + gboolean removed; +} PendingNotifications; + +/** + * GstSourceBufferList: + * + * Since: 1.24 + */ +struct _GstSourceBufferList +{ + GstObject parent_instance; + + GPtrArray *buffers; + + GstMseEventQueue *event_queue; + + PendingNotifications pending_notifications; +}; + +G_DEFINE_TYPE (GstSourceBufferList, gst_source_buffer_list, GST_TYPE_OBJECT); + +enum +{ + PROP_0, + PROP_LENGTH, + N_PROPS, +}; + +typedef enum +{ + ON_SOURCEBUFFER_ADDED, + ON_SOURCEBUFFER_REMOVED, + N_SIGNALS, +} SourceBufferListEvent; + +typedef struct +{ + GstDataQueueItem item; + SourceBufferListEvent event; +} SourceBufferListEventItem; + +static GParamSpec *properties[N_PROPS]; +static guint signals[N_SIGNALS] = { 0 }; + +static gboolean +is_frozen (GstSourceBufferList * self) +{ + return g_atomic_int_get (&self->pending_notifications.frozen); +} + +static void +set_frozen (GstSourceBufferList * self) +{ + g_atomic_int_set (&self->pending_notifications.frozen, TRUE); +} + +static void +clear_frozen (GstSourceBufferList * self) +{ + g_atomic_int_set (&self->pending_notifications.frozen, FALSE); +} + +static void +set_pending_added (GstSourceBufferList * self) +{ + g_atomic_int_set (&self->pending_notifications.added, TRUE); +} + +static void +set_pending_removed (GstSourceBufferList * self) +{ + g_atomic_int_set (&self->pending_notifications.removed, TRUE); +} + +static gboolean +clear_pending_added (GstSourceBufferList * self) +{ + return g_atomic_int_and (&self->pending_notifications.added, FALSE); +} + +static gboolean +clear_pending_removed (GstSourceBufferList * self) +{ + return g_atomic_int_and (&self->pending_notifications.removed, FALSE); +} + +static void +schedule_event (GstSourceBufferList * self, SourceBufferListEvent event) +{ + SourceBufferListEventItem item = { + .item = {.destroy = g_free,.visible = TRUE,.size = 1,.object = NULL}, + .event = event, + }; + + gst_mse_event_queue_push (self->event_queue, g_memdup2 (&item, + sizeof (SourceBufferListEventItem))); +} + +static void +dispatch_event (SourceBufferListEventItem * item, GstSourceBufferList * self) +{ + g_signal_emit (self, signals[item->event], 0); +} + +static void +call_source_buffer_added (GstSourceBufferList * self) +{ + if (is_frozen (self)) { + set_pending_added (self); + } else { + clear_pending_added (self); + schedule_event (self, ON_SOURCEBUFFER_ADDED); + } +} + +static void +call_source_buffer_removed (GstSourceBufferList * self) +{ + if (is_frozen (self)) { + set_pending_removed (self); + } else { + clear_pending_removed (self); + schedule_event (self, ON_SOURCEBUFFER_REMOVED); + } +} + +GstSourceBufferList * +gst_source_buffer_list_new (void) +{ + return gst_object_ref_sink (g_object_new (GST_TYPE_SOURCE_BUFFER_LIST, NULL)); +} + +static void +gst_source_buffer_list_dispose (GObject * object) +{ + GstSourceBufferList *self = (GstSourceBufferList *) object; + gst_clear_object (&self->event_queue); + + G_OBJECT_CLASS (gst_source_buffer_list_parent_class)->dispose (object); +} + +static void +gst_source_buffer_list_finalize (GObject * object) +{ + GstSourceBufferList *self = (GstSourceBufferList *) object; + + g_clear_pointer (&self->buffers, g_ptr_array_unref); + + G_OBJECT_CLASS (gst_source_buffer_list_parent_class)->finalize (object); +} + +static void +gst_source_buffer_list_get_property (GObject * object, guint prop_id, GValue + * value, GParamSpec * pspec) +{ + GstSourceBufferList *self = GST_SOURCE_BUFFER_LIST (object); + + switch (prop_id) { + case PROP_LENGTH: + g_value_set_uint (value, gst_source_buffer_list_get_length (self)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + } +} + +static void +gst_source_buffer_list_class_init (GstSourceBufferListClass * klass) +{ + GObjectClass *oclass = G_OBJECT_CLASS (klass); + + oclass->dispose = GST_DEBUG_FUNCPTR (gst_source_buffer_list_dispose); + oclass->finalize = GST_DEBUG_FUNCPTR (gst_source_buffer_list_finalize); + oclass->get_property = + GST_DEBUG_FUNCPTR (gst_source_buffer_list_get_property); + + /** + * GstSourceBufferList:length: + * + * The number of #GstSourceBuffers contained by this structure + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebufferlist-length) + * + * Since: 1.24 + */ + properties[PROP_LENGTH] = g_param_spec_ulong ("length", + "Length", + "The number of SourceBuffers contained by this structure", + 0, G_MAXULONG, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); + + g_object_class_install_properties (oclass, N_PROPS, properties); + + /** + * GstSourceBufferList::on-sourcebuffer-added: + * @self: The #GstSourceBufferList that has just added a + * #GstSourceBuffer + * + * Emitted when a #GstSourceBuffer has been added to this list. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebufferlist-onaddsourcebuffer) + * + * Since: 1.24 + */ + signals[ON_SOURCEBUFFER_ADDED] = g_signal_new ("on-sourcebuffer-added", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0); + + /** + * GstSourceBufferList::on-sourcebuffer-removed: + * @self: The #GstSourceBufferList that has just removed a + * #GstSourceBuffer + * + * Emitted when a #GstSourceBuffer has been removed from this list. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebufferlist-onremovesourcebuffer) + * + * Since: 1.24 + */ + signals[ON_SOURCEBUFFER_REMOVED] = g_signal_new ("on-sourcebuffer-removed", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0); +} + +static void +gst_source_buffer_list_init (GstSourceBufferList * self) +{ + set_frozen (self); + self->buffers = g_ptr_array_new_with_free_func (gst_object_unref); + self->event_queue = + gst_mse_event_queue_new ((GstMseEventQueueCallback) dispatch_event, self); + clear_pending_added (self); + clear_pending_removed (self); + clear_frozen (self); +} + +/** + * gst_source_buffer_list_index: + * @self: #GstSourceBufferList instance + * @index: index of requested Source Buffer + * + * Retrieves the #GstSourceBuffer at @index from @self. If @index is greater than + * the highest index in the list, it will return `NULL`. + * + * [Specification](https://www.w3.org/TR/media-source-2/#dfn-sourcebufferlist-getter) + * + * Returns: (transfer full) (nullable): The requested #GstSourceBuffer or `NULL` + * Since: 1.24 + */ +GstSourceBuffer * +gst_source_buffer_list_index (GstSourceBufferList * self, guint index) +{ + g_return_val_if_fail (GST_IS_SOURCE_BUFFER_LIST (self), NULL); + if (index >= gst_source_buffer_list_get_length (self)) + return NULL; + return gst_object_ref (g_ptr_array_index (self->buffers, index)); +} + +/** + * gst_source_buffer_list_get_length: + * @self: #GstSourceBufferList instance + * + * [Specification](https://www.w3.org/TR/media-source-2/#dom-sourcebufferlist-length) + * + * Returns: The number of #GstSourceBuffer objects in the list + * Since: 1.24 + */ +guint +gst_source_buffer_list_get_length (GstSourceBufferList * self) +{ + g_return_val_if_fail (GST_IS_SOURCE_BUFFER_LIST (self), 0); + return self->buffers->len; +} + +gboolean +gst_source_buffer_list_contains (GstSourceBufferList * self, + GstSourceBuffer * buf) +{ + g_return_val_if_fail (GST_IS_SOURCE_BUFFER_LIST (self), FALSE); + g_return_val_if_fail (GST_IS_SOURCE_BUFFER (buf), FALSE); + return g_ptr_array_find (self->buffers, buf, NULL); +} + +void +gst_source_buffer_list_append (GstSourceBufferList * self, + GstSourceBuffer * buf) +{ + g_return_if_fail (GST_IS_SOURCE_BUFFER_LIST (self)); + g_ptr_array_add (self->buffers, gst_object_ref (buf)); + call_source_buffer_added (self); +} + +gboolean +gst_source_buffer_list_remove (GstSourceBufferList * self, + GstSourceBuffer * buf) +{ + g_return_val_if_fail (GST_IS_SOURCE_BUFFER_LIST (self), FALSE); + gboolean removed = g_ptr_array_remove (self->buffers, buf); + if (removed) { + call_source_buffer_removed (self); + return TRUE; + } else { + return FALSE; + } +} + +void +gst_source_buffer_list_remove_all (GstSourceBufferList * self) +{ + g_return_if_fail (GST_IS_SOURCE_BUFFER_LIST (self)); + if (self->buffers->len < 1) { + return; + } + g_ptr_array_set_size (self->buffers, 0); + call_source_buffer_removed (self); +} + +/** + * gst_source_buffer_list_notify_freeze: + * @self: #GstSourceBufferList instance + * + * Prevents any notifications from being emitted by @self until the next call to + * gst_source_buffer_list_notify_thaw(). + * + */ +void +gst_source_buffer_list_notify_freeze (GstSourceBufferList * self) +{ + g_return_if_fail (GST_IS_SOURCE_BUFFER_LIST (self)); + clear_pending_added (self); + clear_pending_removed (self); + set_frozen (self); +} + +/** + * gst_source_buffer_list_notify_cancel: + * @self: #GstSourceBufferList instance + * + * Cancels any pending notifications that are waiting between calls to + * gst_source_buffer_list_notify_freeze() and + * gst_source_buffer_list_notify_thaw(). + * + */ +void +gst_source_buffer_list_notify_cancel (GstSourceBufferList * self) +{ + g_return_if_fail (GST_IS_SOURCE_BUFFER_LIST (self)); + clear_pending_added (self); + clear_pending_removed (self); +} + +/** + * gst_source_buffer_list_notify_added: + * @self: #GstSourceBufferList instance + * + * Explicitly notifies subscribers to the ::on-sourcebuffer-added signal that an + * item has been added to @self. + * + */ +void +gst_source_buffer_list_notify_added (GstSourceBufferList * self) +{ + g_return_if_fail (GST_IS_SOURCE_BUFFER_LIST (self)); + g_return_if_fail (!is_frozen (self)); + call_source_buffer_added (self); +} + +/** + * gst_source_buffer_list_notify_removed: + * @self: #GstSourceBufferList instance + * + * Explicitly notifies subscribers to the ::on-sourcebuffer-removed signal that + * an item has been removed from @self. + * + */ +void +gst_source_buffer_list_notify_removed (GstSourceBufferList * self) +{ + g_return_if_fail (GST_IS_SOURCE_BUFFER_LIST (self)); + g_return_if_fail (!is_frozen (self)); + call_source_buffer_removed (self); +} + +/** + * gst_source_buffer_list_notify_thaw: + * @self: #GstSourceBufferList instance + * + * Resumes notifications emitted from @self after a call to + * gst_source_buffer_list_notify_freeze(). If any notifications are pending, + * they will be emitted as a result of this call. To prevent pending + * notifications from being published, use + * gst_source_buffer_list_notify_cancel() before calling this method. + * + */ +void +gst_source_buffer_list_notify_thaw (GstSourceBufferList * self) +{ + g_return_if_fail (GST_IS_SOURCE_BUFFER_LIST (self)); + clear_frozen (self); + if (clear_pending_added (self)) { + g_signal_emit (self, signals[ON_SOURCEBUFFER_ADDED], 0); + } + if (clear_pending_removed (self)) { + g_signal_emit (self, signals[ON_SOURCEBUFFER_REMOVED], 0); + } +} diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstsourcebufferlist.h b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstsourcebufferlist.h new file mode 100644 index 0000000000..d80ee52078 --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstsourcebufferlist.h @@ -0,0 +1,44 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2022, 2023 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#pragma once + +#include +#include + +#include "gstsourcebuffer.h" + +G_BEGIN_DECLS + +#define GST_TYPE_SOURCE_BUFFER_LIST (gst_source_buffer_list_get_type()) + +GST_MSE_API +G_DECLARE_FINAL_TYPE (GstSourceBufferList, gst_source_buffer_list, GST, + SOURCE_BUFFER_LIST, GstObject); + +GST_MSE_API +GstSourceBuffer *gst_source_buffer_list_index (GstSourceBufferList * self, + guint index); +GST_MSE_API +guint gst_source_buffer_list_get_length (GstSourceBufferList * self); + +G_END_DECLS diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/mse/meson.build b/subprojects/gst-plugins-bad/gst-libs/gst/mse/meson.build new file mode 100644 index 0000000000..fba8613ff0 --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/mse/meson.build @@ -0,0 +1,149 @@ +gstmse_headers_private = files( + 'gstappendpipeline-private.h', + 'gstmediasourcesamplemap-private.h', + 'gstmediasourcetrackbuffer-private.h', + 'gstmediasourcetrack-private.h', + 'gstmseeventqueue-private.h', + 'gstmselogging-private.h', + 'gstmsemediatype-private.h', +) + +gstmse_sources_private = files( + 'gstappendpipeline.c', + 'gstmediasourcesamplemap.c', + 'gstmediasourcetrackbuffer.c', + 'gstmediasourcetrack.c', + 'gstmseeventqueue.c', + 'gstmselogging.c', + 'gstmsemediatype.c', +) + +gstmse_headers_public = files( + 'gstmediasource.h', + 'gstsourcebuffer.h', + 'gstsourcebufferlist.h', + 'gstmsesrc.h', + 'mse.h', + 'mse-prelude.h', +) + +gstmse_sources_public = files( + 'gstmediasource.c', + 'gstmsesrc.c', + 'gstsourcebuffer.c', + 'gstsourcebufferlist.c', +) + +gstmse_header_dir = 'gstreamer-' + api_version + '/gst/mse/' + +gstmse_enums_private = gnome.mkenums_simple('mse-enumtypes-private', + sources : gstmse_headers_private, + body_prefix : '#ifdef HAVE_CONFIG_H\n#include "config.h"\n#endif', + header_prefix : '#include ', + decorator: 'GST_MSE_PRIVATE', + install_header: false, +) + +gstmse_enums = gnome.mkenums_simple('mse-enumtypes', + sources : gstmse_headers_public, + body_prefix : '#ifdef HAVE_CONFIG_H\n#include "config.h"\n#endif', + header_prefix : '#include ', + decorator: 'GST_MSE_API', + install_header: true, + install_dir : join_paths(get_option('includedir'), gstmse_header_dir), +) + +gstmse_deps = [gstbase_dep, gstapp_dep] + +gstmse_enums_private_c = gstmse_enums_private[0] +gstmse_enums_private_h = gstmse_enums_private[1] + +gstmse_enums_c = gstmse_enums[0] +gstmse_enums_h = gstmse_enums[1] + +gstmse_c_args = gst_plugins_bad_args + [ + '-DBUILDING_GST_MSE', + '-DGST_USE_UNSTABLE_API', + '-DG_LOG_DOMAIN="GStreamer-MSE"', +] + +gstmse_sources_all = [ + gstmse_sources_private, + gstmse_sources_public, + gstmse_enums_c, + gstmse_enums_h, + gstmse_enums_private_c, + gstmse_enums_private_h, +] + +gstmse_private_test = library('gstmse-private-test', + gstmse_sources_all, + c_args : [gstmse_c_args, '-DBUILDING_GST_MSE_TEST'], + include_directories : [configinc, libsinc], + dependencies : gstmse_deps, +) + +gstmse_private_test_dep = declare_dependency( + compile_args : [gstmse_c_args, '-DBUILDING_GST_MSE_TEST'], + link_with : [gstmse_private_test], + include_directories : [libsinc], +) + +gstmse = library('gstmse-' + api_version, + gstmse_sources_all, + c_args : gstmse_c_args, + include_directories : [configinc, libsinc], + version : libversion, + soversion : soversion, + darwin_versions : osxversion, + install : true, + dependencies : gstmse_deps, +) + +pkg_name = 'gstreamer-mse-' + api_version +gst_libraries += [[pkg_name, {'lib': gstmse}]] +pkgconfig.generate(gstmse, + libraries : [gst_dep], + variables : pkgconfig_variables, + subdirs : pkgconfig_subdirs, + name : pkg_name, + description : 'GStreamer Support for W3C Media Source Extensions', +) + +library_def = {'lib': gstmse} +gen_sources = [] +if build_gir + gir = { + 'sources' : [ + gstmse_sources_public, + gstmse_headers_public, + gstmse_enums_h, + gstmse_enums_c, + ], + 'namespace' : 'GstMse', + 'nsversion' : api_version, + 'identifier_prefix' : 'Gst', + 'symbol_prefix' : 'gst', + 'export_packages' : pkg_name, + 'includes' : ['Gst-1.0'], + 'install' : true, + 'extra_args' : gir_init_section + ['-DGST_USE_UNSTABLE_API'] + ['--c-include=gst/mse/mse.h'], + 'dependencies' : gstmse_deps, + } + library_def += {'gir': [gir]} + if not static_build + mse_gir = gnome.generate_gir(gstmse, kwargs: gir) + library_def += {'gir_targets': library_def.get('gir_targets', []) + [mse_gir]} + gen_sources += mse_gir + endif +endif +gst_libraries += [[pkg_name, library_def]] + +gstmse_dep = declare_dependency( + link_with : [gstmse], + include_directories : [libsinc], + dependencies : gstmse_deps, + sources: [gstmse_enums_h], +) +install_headers(gstmse_headers_public, subdir: gstmse_header_dir) +meson.override_dependency(pkg_name, gstmse_dep) diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/mse/mse-prelude.h b/subprojects/gst-plugins-bad/gst-libs/gst/mse/mse-prelude.h new file mode 100644 index 0000000000..eb807e1874 --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/mse/mse-prelude.h @@ -0,0 +1,48 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2022, 2023 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#pragma once + +#include + +#ifndef GST_MSE_API +# if defined(BUILDING_GST_MSE) && defined(GST_API_EXPORT) +# define GST_MSE_API GST_API_EXPORT +# elif defined(GST_API_IMPORT) +# define GST_MSE_API GST_API_IMPORT +# else +# define GST_MSE_API +# endif +#endif + +#ifndef GST_MSE_PRIVATE +# if defined(BUILDING_GST_MSE_TEST) +# define GST_MSE_PRIVATE GST_MSE_API +# else +# define GST_MSE_PRIVATE G_GNUC_INTERNAL +# endif +#endif + +#ifndef GST_USE_UNSTABLE_API +#warning "The MSE library from gst-plugins-bad is an unstable API and may change in future." +#warning "You can define GST_USE_UNSTABLE_API to avoid this warning." +#endif diff --git a/subprojects/gst-plugins-bad/gst-libs/gst/mse/mse.h b/subprojects/gst-plugins-bad/gst-libs/gst/mse/mse.h new file mode 100644 index 0000000000..343213e17a --- /dev/null +++ b/subprojects/gst-plugins-bad/gst-libs/gst/mse/mse.h @@ -0,0 +1,32 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2022, 2023 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#pragma once + +#include + +#include "mse-prelude.h" +#include +#include "gstmsesrc.h" +#include "gstmediasource.h" +#include "gstsourcebufferlist.h" +#include "gstsourcebuffer.h" diff --git a/subprojects/gst-plugins-bad/gst/meson.build b/subprojects/gst-plugins-bad/gst/meson.build index 81f8f62092..4232a34aef 100644 --- a/subprojects/gst-plugins-bad/gst/meson.build +++ b/subprojects/gst-plugins-bad/gst/meson.build @@ -8,7 +8,7 @@ foreach plugin : ['accurip', 'adpcmdec', 'adpcmenc', 'aiff', 'asfmux', 'geometrictransform', 'id3tag', 'insertbin', 'inter', 'interlace', 'ivfparse', 'ivtc', 'jp2kdecimator', 'jpegformat', 'librfb', 'midi', 'mpegdemux', 'mpegpsmux', 'mpegtsdemux', 'mpegtsmux', - 'mxf', 'netsim', 'onvif', 'pcapparse', 'pnm', 'proxy', + 'mse', 'mxf', 'netsim', 'onvif', 'pcapparse', 'pnm', 'proxy', 'rawparse', 'removesilence', 'rist', 'rtmp2', 'rtp', 'sdp', 'segmentclip', 'siren', 'smooth', 'speed', 'subenc', 'switchbin', 'timecode', 'transcode', 'unixfd', 'videofilters', diff --git a/subprojects/gst-plugins-bad/gst/mse/gstmse.c b/subprojects/gst-plugins-bad/gst/mse/gstmse.c new file mode 100644 index 0000000000..7e8938f42c --- /dev/null +++ b/subprojects/gst-plugins-bad/gst/mse/gstmse.c @@ -0,0 +1,49 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2022, 2023 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +/** + * plugin-mse: + * + * Since: 1.24 + */ + +#include "gstmse.h" + +/** + * SECTION:element-msesrc + * @title: msesrc + * + * Since: 1.24 + */ +GST_ELEMENT_REGISTER_DEFINE (msesrc, "msesrc", GST_RANK_NONE, GST_TYPE_MSE_SRC); + +static gboolean +plugin_init (GstPlugin * plugin) +{ + return GST_ELEMENT_REGISTER (msesrc, plugin); +} + +GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, + GST_VERSION_MINOR, + mse, + "W3C Media Source Extensions Support", + plugin_init, VERSION, GST_LICENSE, GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN) diff --git a/subprojects/gst-plugins-bad/gst/mse/gstmse.h b/subprojects/gst-plugins-bad/gst/mse/gstmse.h new file mode 100644 index 0000000000..0500b65963 --- /dev/null +++ b/subprojects/gst-plugins-bad/gst/mse/gstmse.h @@ -0,0 +1,33 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2022, 2023 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#pragma once + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include +#include +#include + +GST_ELEMENT_REGISTER_DECLARE (msesrc); diff --git a/subprojects/gst-plugins-bad/gst/mse/meson.build b/subprojects/gst-plugins-bad/gst/mse/meson.build new file mode 100644 index 0000000000..e4ac5e72d7 --- /dev/null +++ b/subprojects/gst-plugins-bad/gst/mse/meson.build @@ -0,0 +1,12 @@ +mse_sources = ['gstmse.c'] + +gstmse_plugin = library('gstmse', + mse_sources, + c_args: gst_plugins_bad_args + ['-DGST_USE_UNSTABLE_API'], + include_directories: [configinc], + dependencies : [gstbase_dep, gstmse_dep], + install : true, + install_dir : plugins_install_dir, +) + +plugins += [gstmse_plugin] diff --git a/subprojects/gst-plugins-bad/meson_options.txt b/subprojects/gst-plugins-bad/meson_options.txt index 8fe3b8fc7f..d4f087791c 100644 --- a/subprojects/gst-plugins-bad/meson_options.txt +++ b/subprojects/gst-plugins-bad/meson_options.txt @@ -45,6 +45,7 @@ option('mpegdemux', type : 'feature', value : 'auto') option('mpegpsmux', type : 'feature', value : 'auto') option('mpegtsdemux', type : 'feature', value : 'auto') option('mpegtsmux', type : 'feature', value : 'auto') +option('mse', type : 'feature', value : 'auto') option('mxf', type : 'feature', value : 'auto') option('netsim', type : 'feature', value : 'auto') option('onvif', type : 'feature', value : 'auto') diff --git a/subprojects/gst-plugins-bad/tests/check/libs/mse.c b/subprojects/gst-plugins-bad/tests/check/libs/mse.c new file mode 100644 index 0000000000..f3ae4bed16 --- /dev/null +++ b/subprojects/gst-plugins-bad/tests/check/libs/mse.c @@ -0,0 +1,1119 @@ +/* GStreamer + * + * SPDX-License-Identifier: LGPL-2.1 + * + * Copyright (C) 2022, 2023 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#ifdef HAVE_VALGRIND +# include +#endif + +#include + +#include +#include +#include +#include +#include +#include + +static GstCheckLogFilter * +add_log_filter (GLogLevelFlags level, const gchar * regex) +{ + GRegex *gregex = g_regex_new (regex, 0, 0, NULL); + return gst_check_add_log_filter ("GStreamer-MSE", level, gregex, NULL, NULL, + NULL); +} + +static gchar * +test_mp4_path (void) +{ + return g_build_filename (GST_TEST_FILES_PATH, "mse.mp4", NULL); +} + +static gchar * +test_webm_path (void) +{ + return g_build_filename (GST_TEST_FILES_PATH, "mse.webm", NULL); +} + +static GstMediaSource * +opened_media_source (void) +{ + GstMediaSource *media_source = gst_media_source_new (); + media_source->ready_state = GST_MEDIA_SOURCE_READY_STATE_OPEN; + return media_source; +} + +static GstSample * +new_empty_sample_full (GstClockTime dts, GstClockTime pts, + GstClockTime duration, GstBufferFlags flags, GstCaps * caps, + GstSegment * segment, GstStructure * info) +{ + GstBuffer *buffer = gst_buffer_new (); + GST_BUFFER_DTS (buffer) = dts; + GST_BUFFER_PTS (buffer) = pts; + GST_BUFFER_DURATION (buffer) = duration; + GST_BUFFER_FLAGS (buffer) = flags; + GstSample *sample = gst_sample_new (buffer, caps, segment, info); + gst_buffer_unref (buffer); + return sample; +} + +static GstSample * +new_empty_sample_with_timing (GstClockTime dts, GstClockTime pts, + GstClockTime duration) +{ + return new_empty_sample_full (dts, pts, duration, 0, NULL, NULL, NULL); +} + +static GstSample * +new_sample_with_bytes_and_timing (GBytes * bytes, GstClockTime dts, + GstClockTime pts, GstClockTime duration) +{ + GstBuffer *buffer = gst_buffer_new_wrapped_bytes (bytes); + GST_BUFFER_DTS (buffer) = dts; + GST_BUFFER_PTS (buffer) = pts; + GST_BUFFER_DURATION (buffer) = duration; + GstSample *sample = gst_sample_new (buffer, NULL, NULL, NULL); + gst_buffer_unref (buffer); + g_bytes_unref (bytes); + return sample; +} + +GST_START_TEST (test_create_and_free) +{ + GstMediaSource *media_source = gst_media_source_new (); + fail_unless (GST_IS_MEDIA_SOURCE (media_source)); + gst_check_object_destroyed_on_unref (media_source); +} + +GST_END_TEST; + +GST_START_TEST (test_create_initial_state) +{ + GstMediaSource *media_source = gst_media_source_new (); + + GstSourceBufferList *buffers = + gst_media_source_get_source_buffers (media_source); + GstSourceBufferList *active_buffers = + gst_media_source_get_active_source_buffers (media_source); + + fail_unless (gst_media_source_get_ready_state (media_source) == + GST_MEDIA_SOURCE_READY_STATE_CLOSED); + fail_unless (gst_source_buffer_list_get_length (buffers) == 0); + fail_unless (gst_source_buffer_list_get_length (active_buffers) == 0); + fail_unless (gst_media_source_get_position (media_source) == + GST_CLOCK_TIME_NONE); + + gst_object_unref (media_source); + gst_object_unref (buffers); + gst_object_unref (active_buffers); +} + +GST_END_TEST; + +GST_START_TEST (test_add_source_buffer_with_content_type_null) +{ + add_log_filter (G_LOG_LEVEL_CRITICAL, + "^.*_add_source_buffer: assertion 'type != NULL' failed"); + + GstMediaSource *media_source = gst_media_source_new (); + + g_assert_null (gst_media_source_add_source_buffer (media_source, NULL, NULL)); + + gst_object_unref (media_source); +} + +GST_END_TEST; + +GST_START_TEST (test_add_source_buffer_with_content_type_empty) +{ + GError *error = NULL; + GstMediaSource *media_source = gst_media_source_new (); + GstSourceBuffer *source_buffer = + gst_media_source_add_source_buffer (media_source, "", &error); + + g_assert_null (source_buffer); + g_assert_error (error, GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_TYPE); + + gst_object_unref (media_source); + g_clear_error (&error); +} + +GST_END_TEST; + +GST_START_TEST (test_add_source_buffer_with_content_type_fake) +{ + GError *error = NULL; + GstMediaSource *media_source = gst_media_source_new (); + GstSourceBuffer *source_buffer = + gst_media_source_add_source_buffer (media_source, "fake/type", &error); + + g_assert_null (source_buffer); + g_assert_error (error, GST_MEDIA_SOURCE_ERROR, + GST_MEDIA_SOURCE_ERROR_NOT_SUPPORTED); + + gst_object_unref (media_source); + g_clear_error (&error); +} + +GST_END_TEST; + +GST_START_TEST (test_add_source_buffer_to_unopened_media_source) +{ + GError *error = NULL; + GstMediaSource *media_source = gst_media_source_new (); + GstSourceBuffer *source_buffer = + gst_media_source_add_source_buffer (media_source, "video/webm", &error); + + g_assert_null (source_buffer); + g_assert_error (error, GST_MEDIA_SOURCE_ERROR, + GST_MEDIA_SOURCE_ERROR_INVALID_STATE); + + gst_object_unref (media_source); + g_clear_error (&error); +} + +GST_END_TEST; + +GST_START_TEST (test_add_source_buffer_to_opened_media_source) +{ + GError *error = NULL; + GstMediaSource *media_source = opened_media_source (); + GstSourceBufferList *buffers = + gst_media_source_get_source_buffers (media_source); + guint n_buffers_before = gst_source_buffer_list_get_length (buffers); + GstSourceBuffer *source_buffer = + gst_media_source_add_source_buffer (media_source, "video/webm", &error); + guint n_buffers_after = gst_source_buffer_list_get_length (buffers); + + fail_unless (GST_IS_SOURCE_BUFFER (source_buffer)); + g_assert_no_error (error); + fail_unless (n_buffers_before < n_buffers_after); + + g_object_unref (media_source); + g_object_unref (buffers); + g_object_unref (source_buffer); + g_clear_error (&error); +} + +GST_END_TEST; + +GST_START_TEST (test_remove_source_buffer_from_unrelated_media_source) +{ + GError *error = NULL; + GstMediaSource *a = opened_media_source (); + GstMediaSource *b = opened_media_source (); + GstSourceBuffer *buffer_in_b = + gst_media_source_add_source_buffer (b, "video/webm", &error); + + gst_media_source_remove_source_buffer (a, buffer_in_b, &error); + g_assert_error (error, GST_MEDIA_SOURCE_ERROR, + GST_MEDIA_SOURCE_ERROR_NOT_FOUND); + + gst_object_unref (a); + gst_object_unref (b); + gst_object_unref (buffer_in_b); + g_clear_error (&error); +} + +GST_END_TEST; + +GST_START_TEST (test_remove_source_buffer_from_parent_media_source) +{ + GError *error = NULL; + GstMediaSource *media_source = opened_media_source (); + GstSourceBufferList *buffers = + gst_media_source_get_source_buffers (media_source); + GstSourceBuffer *buffer = + gst_media_source_add_source_buffer (media_source, "video/webm", &error); + + guint n_buffers_before = gst_source_buffer_list_get_length (buffers); + gst_media_source_remove_source_buffer (media_source, buffer, &error); + guint n_buffers_after = gst_source_buffer_list_get_length (buffers); + + g_assert_no_error (error); + fail_unless (n_buffers_before > n_buffers_after); + + gst_object_unref (media_source); + gst_object_unref (buffers); + gst_object_unref (buffer); + g_clear_error (&error); +} + +GST_END_TEST; + +GST_START_TEST (test_set_live_seekable_range_on_unopened_media_source) +{ + GError *error = NULL; + GstMediaSource *media_source = gst_media_source_new (); + + gst_media_source_set_live_seekable_range (media_source, 0, 1, &error); + + g_assert_error (error, GST_MEDIA_SOURCE_ERROR, + GST_MEDIA_SOURCE_ERROR_INVALID_STATE); + + gst_object_unref (media_source); + g_clear_error (&error); +} + +GST_END_TEST; + +GST_START_TEST (test_set_backwards_live_seekable_range_on_opened_media_source) +{ + GError *error = NULL; + GstMediaSource *media_source = opened_media_source (); + + gst_media_source_set_live_seekable_range (media_source, 2, 1, &error); + + GstMediaSourceRange range = { + .start = GST_CLOCK_TIME_NONE, + .end = GST_CLOCK_TIME_NONE, + }; + gst_media_source_get_live_seekable_range (media_source, &range); + + g_assert_error (error, GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_TYPE); + fail_unless (range.start == 0); + fail_unless (range.end == 0); + + gst_object_unref (media_source); + g_clear_error (&error); +} + +GST_END_TEST; + +GST_START_TEST (test_set_live_seekable_range_on_opened_media_source) +{ + GError *error = NULL; + GstClockTime start = 1, end = 2; + GstMediaSource *media_source = opened_media_source (); + + gst_media_source_set_live_seekable_range (media_source, start, end, &error); + + GstMediaSourceRange range = { + .start = GST_CLOCK_TIME_NONE, + .end = GST_CLOCK_TIME_NONE, + }; + gst_media_source_get_live_seekable_range (media_source, &range); + + g_assert_no_error (error); + fail_unless (range.start == start); + fail_unless (range.end == end); + + gst_object_unref (media_source); + g_clear_error (&error); +} + +GST_END_TEST; + +GST_START_TEST (test_clear_live_seekable_range_on_unopened_media_source) +{ + GError *error = NULL; + GstMediaSource *media_source = gst_media_source_new (); + + gst_media_source_clear_live_seekable_range (media_source, &error); + + g_assert_error (error, GST_MEDIA_SOURCE_ERROR, + GST_MEDIA_SOURCE_ERROR_INVALID_STATE); + + gst_object_unref (media_source); + g_clear_error (&error); +} + +GST_END_TEST; + +GST_START_TEST (test_clear_live_seekable_range_on_opened_media_source) +{ + GError *error = NULL; + GstMediaSource *media_source = opened_media_source (); + gst_media_source_set_live_seekable_range (media_source, 1, 2, NULL); + + gst_media_source_clear_live_seekable_range (media_source, &error); + GstMediaSourceRange range = { + .start = GST_CLOCK_TIME_NONE, + .end = GST_CLOCK_TIME_NONE, + }; + gst_media_source_get_live_seekable_range (media_source, &range); + + g_assert_no_error (error); + fail_unless (range.start == 0); + fail_unless (range.end == 0); + + gst_object_unref (media_source); + g_clear_error (&error); +} + +GST_END_TEST; + +GST_START_TEST (test_append_pipeline_create_and_free) +{ + GError *error = NULL; + GstAppendPipeline *pipeline = gst_append_pipeline_new (NULL, NULL, &error); + g_assert_no_error (error); + fail_unless (GST_IS_APPEND_PIPELINE (pipeline)); + gst_check_object_destroyed_on_unref (pipeline); + g_clear_error (&error); +} + +GST_END_TEST; + +typedef struct +{ + GMutex mutex; + GCond eos_cond; + GCond error_cond; +} AppendPipelineTestContext; + +static void +test_append_pipeline_eos (GstAppendPipeline * pipeline, + GstMediaSourceTrack * track, gpointer user_data) +{ + AppendPipelineTestContext *context = user_data; + g_mutex_lock (&context->mutex); + g_cond_signal (&context->eos_cond); + g_mutex_unlock (&context->mutex); + GST_DEBUG_OBJECT (pipeline, "signalled eos"); +} + +static void +test_append_pipeline_error (GstAppendPipeline * pipeline, gpointer user_data) +{ + AppendPipelineTestContext *context = user_data; + g_mutex_lock (&context->mutex); + g_cond_signal (&context->error_cond); + g_mutex_unlock (&context->mutex); + GST_DEBUG_OBJECT (pipeline, "signalled error"); +} + +static void +test_append_pipeline_await_eos (GstAppendPipeline * pipeline, + AppendPipelineTestContext * context) +{ + GST_DEBUG_OBJECT (pipeline, "waiting for eos"); + g_mutex_lock (&context->mutex); + while (!gst_append_pipeline_get_eos (pipeline)) { + g_cond_wait (&context->eos_cond, &context->mutex); + } + g_mutex_unlock (&context->mutex); + GST_DEBUG_OBJECT (pipeline, "received eos"); +} + +static void +test_append_pipeline_await_error (GstAppendPipeline * pipeline, + AppendPipelineTestContext * context) +{ + GST_DEBUG_OBJECT (pipeline, "waiting for error"); + g_mutex_lock (&context->mutex); + while (!gst_append_pipeline_get_failed (pipeline)) { + g_cond_wait (&context->error_cond, &context->mutex); + } + g_mutex_unlock (&context->mutex); + GST_DEBUG_OBJECT (pipeline, "received error"); +} + +static void +test_append_pipeline (const gchar * filename) +{ + AppendPipelineTestContext context = { 0 }; + GstAppendPipelineCallbacks callbacks = { + .eos = test_append_pipeline_eos, + }; + GstAppendPipeline *pipeline = + gst_append_pipeline_new (&callbacks, &context, NULL); + GError *error = NULL; + + gchar *data; + gsize length; + + g_file_get_contents (filename, &data, &length, &error); + g_assert_no_error (error); + + fail_unless (gst_append_pipeline_append (pipeline, + gst_buffer_new_wrapped (data, length)) == GST_FLOW_OK); + + gst_append_pipeline_eos (pipeline); + + test_append_pipeline_await_eos (pipeline, &context); + + fail_if (gst_append_pipeline_get_failed (pipeline)); + + gst_object_unref (pipeline); + g_clear_error (&error); +} + +GST_START_TEST (test_append_pipeline_mp4) +{ + gchar *filename = test_mp4_path (); + test_append_pipeline (filename); + g_free (filename); +} + +GST_END_TEST; + +GST_START_TEST (test_append_pipeline_webm) +{ + gchar *filename = test_webm_path (); + test_append_pipeline (filename); + g_free (filename); +} + +GST_END_TEST; + +static GstAppendPipeline * +failed_append_pipeline (GstAppendPipelineCallbacks * callbacks, + AppendPipelineTestContext * context) +{ + GstAppendPipeline *pipeline = + gst_append_pipeline_new (callbacks, context, NULL); + + gst_append_pipeline_fail (pipeline); + + return pipeline; +} + +GST_START_TEST (test_append_pipeline_invalid_data_triggers_error) +{ + AppendPipelineTestContext context = { 0 }; + GstAppendPipelineCallbacks callbacks = { + .eos = test_append_pipeline_eos, + .error = test_append_pipeline_error, + }; + GstAppendPipeline *pipeline = failed_append_pipeline (&callbacks, &context); + + test_append_pipeline_await_error (pipeline, &context); + + gst_object_unref (pipeline); +} + +GST_END_TEST; + +GST_START_TEST (test_append_pipeline_invalid_data_triggers_eos) +{ + AppendPipelineTestContext context = { 0 }; + GstAppendPipelineCallbacks callbacks = { + .eos = test_append_pipeline_eos, + .error = test_append_pipeline_error, + }; + GstAppendPipeline *pipeline = failed_append_pipeline (&callbacks, &context); + + test_append_pipeline_await_eos (pipeline, &context); + + gst_object_unref (pipeline); +} + +GST_END_TEST; + +GST_START_TEST (test_append_pipeline_reset_recovery) +{ + AppendPipelineTestContext context = { 0 }; + GstAppendPipelineCallbacks callbacks = { + .eos = test_append_pipeline_eos, + .error = test_append_pipeline_error, + }; + GstAppendPipeline *pipeline = failed_append_pipeline (&callbacks, &context); + + test_append_pipeline_await_error (pipeline, &context); + fail_unless (gst_append_pipeline_get_failed (pipeline)); + + fail_unless (gst_append_pipeline_reset (pipeline)); + fail_if (gst_append_pipeline_get_failed (pipeline)); + + gchar *data; + gsize length; + { + GError *error = NULL; + gchar *filename = test_webm_path (); + g_file_get_contents (filename, &data, &length, &error); + g_assert_no_error (error); + g_clear_error (&error); + g_free (filename); + } + + fail_unless (gst_append_pipeline_append (pipeline, + gst_buffer_new_wrapped (data, length)) == GST_FLOW_OK); + + gst_append_pipeline_eos (pipeline); + + test_append_pipeline_await_eos (pipeline, &context); + + fail_if (gst_append_pipeline_get_failed (pipeline)); + + gst_object_unref (pipeline); +} + +GST_END_TEST; + +GST_START_TEST (test_track_create_and_free) +{ + GstMediaSourceTrack *track = + gst_media_source_track_new (GST_MEDIA_SOURCE_TRACK_TYPE_OTHER, ""); + fail_unless (GST_IS_MEDIA_SOURCE_TRACK (track)); + gst_check_object_destroyed_on_unref (track); +} + +GST_END_TEST; + +GST_START_TEST (test_track_create_with_invalid_type) +{ + add_log_filter (G_LOG_LEVEL_CRITICAL, + "^.*track_new_full: assertion .*type .* failed"); + + g_assert_null (gst_media_source_track_new (-1, "")); + g_assert_null (gst_media_source_track_new (GST_MEDIA_SOURCE_TRACK_TYPE_OTHER + + 1, "")); +} + +GST_END_TEST; + +GST_START_TEST (test_track_push_with_adequate_space) +{ + GstMediaSourceTrack *track = + gst_media_source_track_new_with_size (GST_MEDIA_SOURCE_TRACK_TYPE_OTHER, + "", 1); + GstBuffer *buffer = gst_buffer_new (); + GstSample *sample = gst_sample_new (buffer, NULL, NULL, NULL); + gboolean result = gst_media_source_track_push (track, sample); + fail_unless (result); + gst_buffer_unref (buffer); + gst_object_unref (track); +} + +GST_END_TEST; + +GST_START_TEST (test_track_push_with_inadequate_space) +{ + GstMediaSourceTrack *track = + gst_media_source_track_new_with_size (GST_MEDIA_SOURCE_TRACK_TYPE_OTHER, + "", 0); + GstBuffer *buffer = gst_buffer_new (); + GstSample *sample = gst_sample_new (buffer, NULL, NULL, NULL); + gboolean result = gst_media_source_track_try_push (track, sample); + fail_if (result); + gst_sample_unref (sample); + gst_buffer_unref (buffer); + gst_object_unref (track); +} + +GST_END_TEST; + +GST_START_TEST (test_track_buffer_empty) +{ + GstMediaSourceTrackBuffer *buffer = gst_media_source_track_buffer_new (); + + GArray *ranges = gst_media_source_track_buffer_get_ranges (buffer); + fail_unless_equals_uint64 (ranges->len, 0); + + gst_object_unref (buffer); + g_array_unref (ranges); +} + +GST_END_TEST; + +GST_START_TEST (test_track_buffer_single_span) +{ + GstMediaSourceTrackBuffer *buffer = gst_media_source_track_buffer_new (); + + GstSample *sample = new_empty_sample_with_timing (0, 0, 1); + gst_media_source_track_buffer_add (buffer, sample); + + GArray *ranges = gst_media_source_track_buffer_get_ranges (buffer); + fail_unless_equals_uint64 (ranges->len, 1); + + GstMediaSourceRange range = g_array_index (ranges, GstMediaSourceRange, 0); + fail_unless_equals_uint64 (range.start, 0); + fail_unless_equals_uint64 (range.end, 1); + + gst_sample_unref (sample); + gst_object_unref (buffer); + g_array_unref (ranges); +} + +GST_END_TEST; + +GST_START_TEST (test_track_buffer_continuous_span) +{ + GstMediaSourceTrackBuffer *buffer = gst_media_source_track_buffer_new (); + + GstClockTime a_start = 0; + GstClockTime a_duration = GST_SECOND; + GstClockTime b_start = a_start + a_duration; + GstClockTime b_duration = a_duration; + GstSample *a = new_empty_sample_with_timing (a_start, a_start, a_duration); + GstSample *b = new_empty_sample_with_timing (b_start, b_start, b_duration); + gst_media_source_track_buffer_add (buffer, a); + gst_media_source_track_buffer_add (buffer, b); + + GArray *ranges = gst_media_source_track_buffer_get_ranges (buffer); + fail_unless_equals_uint64 (ranges->len, 1); + + GstMediaSourceRange range = g_array_index (ranges, GstMediaSourceRange, 0); + fail_unless_equals_uint64 (range.start, a_start); + fail_unless_equals_uint64 (range.end, a_start + a_duration + b_duration); + + gst_sample_unref (a); + gst_sample_unref (b); + gst_object_unref (buffer); + g_array_unref (ranges); +} + +GST_END_TEST; + +GST_START_TEST (test_track_buffer_discontinuous_span) +{ + GstMediaSourceTrackBuffer *buffer = gst_media_source_track_buffer_new (); + + GstClockTime a_start = 0; + GstClockTime a_duration = GST_SECOND; + GstClockTime b_start = a_start + a_duration + GST_SECOND; + GstClockTime b_duration = a_duration; + GstSample *a = new_empty_sample_with_timing (a_start, a_start, a_duration); + GstSample *b = new_empty_sample_with_timing (b_start, b_start, b_duration); + gst_media_source_track_buffer_add (buffer, a); + gst_media_source_track_buffer_add (buffer, b); + + GArray *ranges = gst_media_source_track_buffer_get_ranges (buffer); + fail_unless_equals_uint64 (ranges->len, 2); + + GstMediaSourceRange range_a = g_array_index (ranges, GstMediaSourceRange, 0); + fail_unless_equals_uint64 (range_a.start, a_start); + fail_unless_equals_uint64 (range_a.end, a_start + a_duration); + + GstMediaSourceRange range_b = g_array_index (ranges, GstMediaSourceRange, 1); + fail_unless_equals_uint64 (range_b.start, b_start); + fail_unless_equals_uint64 (range_b.end, b_start + b_duration); + + gst_sample_unref (a); + gst_sample_unref (b); + gst_object_unref (buffer); + g_array_unref (ranges); +} + +GST_END_TEST; + +GST_START_TEST (test_source_buffer_generate_timestamps_mp4) +{ + GstMediaSource *media_source = opened_media_source (); + GstSourceBuffer *source_buffer = gst_media_source_add_source_buffer + (media_source, "video/mp4", NULL); + + fail_unless_equals_uint64 (gst_source_buffer_get_append_mode (source_buffer), + GST_SOURCE_BUFFER_APPEND_MODE_SEGMENTS); + + gst_object_unref (source_buffer); + gst_object_unref (media_source); +} + +GST_END_TEST; + +GST_START_TEST (test_source_buffer_generate_timestamps_aac) +{ + GstMediaSource *media_source = opened_media_source (); + GstSourceBuffer *source_buffer = gst_media_source_add_source_buffer + (media_source, "audio/aac", NULL); + + fail_unless (GST_IS_SOURCE_BUFFER (source_buffer)); + + fail_unless_equals_uint64 (gst_source_buffer_get_append_mode (source_buffer), + GST_SOURCE_BUFFER_APPEND_MODE_SEQUENCE); + + gst_object_unref (source_buffer); + gst_object_unref (media_source); +} + +GST_END_TEST; + +GST_START_TEST (test_source_buffer_change_content_type_null) +{ + GstMediaSource *media_source = opened_media_source (); + GstSourceBuffer *source_buffer = gst_media_source_add_source_buffer + (media_source, "video/mp4", NULL); + + fail_unless (GST_IS_SOURCE_BUFFER (source_buffer)); + + GError *error = NULL; + gst_source_buffer_change_content_type (source_buffer, NULL, &error); + g_assert_error (error, GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_TYPE); + + g_clear_error (&error); + gst_object_unref (source_buffer); + gst_object_unref (media_source); +} + +GST_END_TEST; + +GST_START_TEST (test_source_buffer_change_content_type_empty) +{ + GstMediaSource *media_source = opened_media_source (); + GstSourceBuffer *source_buffer = gst_media_source_add_source_buffer + (media_source, "video/mp4", NULL); + + fail_unless (GST_IS_SOURCE_BUFFER (source_buffer)); + + GError *error = NULL; + gst_source_buffer_change_content_type (source_buffer, "", &error); + g_assert_error (error, GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_TYPE); + + g_clear_error (&error); + gst_object_unref (source_buffer); + gst_object_unref (media_source); +} + +GST_END_TEST; + +GST_START_TEST (test_source_buffer_change_content_type) +{ + GstMediaSource *media_source = opened_media_source (); + GstSourceBuffer *source_buffer = gst_media_source_add_source_buffer + (media_source, "video/mp4", NULL); + + fail_unless (GST_IS_SOURCE_BUFFER (source_buffer)); + + GError *error = NULL; + gst_source_buffer_change_content_type (source_buffer, "video/webm", &error); + g_assert_error (error, GST_MEDIA_SOURCE_ERROR, + GST_MEDIA_SOURCE_ERROR_NOT_SUPPORTED); + + gst_object_unref (source_buffer); + gst_object_unref (media_source); + g_clear_error (&error); +} + +GST_END_TEST; + +static const gchar *unsupported_content_types[] = { + "xxx", + "text/html", + "image/jpeg", +}; + +GST_START_TEST (test_media_source_unsupported_content_type) +{ + const gchar *content_type = unsupported_content_types[__i__]; + ck_assert_msg (!gst_media_source_is_type_supported (content_type), + "%s should be rejected as an unsupported MIME type", content_type); +} + +GST_END_TEST; + +static const gchar *valid_mp4_content_types[] = { + "video/mp4;codecs=\"avc1.4d001e\"", // H.264 Main Profile level 3.0 + "video/mp4;codecs=\"avc1.42001e\"", // H.264 Baseline Profile level 3.0 + "audio/mp4;codecs=\"mp4a.40.2\"", // MPEG4 AAC-LC + "audio/mp4;codecs=\"mp4a.40.5\"", // MPEG4 HE-AAC + "audio/mp4;codecs=\"mp4a.67\"", // MPEG2 AAC-LC + "video/mp4;codecs=\"mp4a.40.2\"", + "video/mp4;codecs=\"avc1.4d001e,mp4a.40.2\"", + "video/mp4;codecs=\"mp4a.40.2 , avc1.4d001e \"", + "video/mp4;codecs=\"avc1.4d001e,mp4a.40.5\"", + "audio/mp4;codecs=\"Opus\"", + "video/mp4;codecs=\"Opus\"", + "audio/mp4;codecs=\"fLaC\"", + "video/mp4;codecs=\"fLaC\"", +}; + +GST_START_TEST (test_media_source_supported_mp4_content_type) +{ + const gchar *content_type = valid_mp4_content_types[__i__]; + ck_assert_msg (gst_media_source_is_type_supported (content_type), + "%s must be a supported MP4 content type", content_type); +} + +GST_END_TEST; + +static const gchar *valid_webm_content_types[] = { + "video/webm;codecs=\"vp8\"", + "video/webm;codecs=\"vorbis\"", + "video/webm;codecs=\"vp8,vorbis\"", + "video/webm;codecs=\"vorbis, vp8\"", + "audio/webm;codecs=\"vorbis\"", + "AUDIO/WEBM;CODECS=\"vorbis\"", + "audio/webm;codecs=vorbis;test=\"6\"", + "audio/webm;codecs=\"opus\"", + "video/webm;codecs=\"opus\"", +}; + +GST_START_TEST (test_media_source_supported_webm_content_type) +{ + const gchar *content_type = valid_webm_content_types[__i__]; + ck_assert_msg (gst_media_source_is_type_supported (content_type), + "%s must be a supported WebM content type", content_type); +} + +GST_END_TEST; + +GST_START_TEST (test_sample_map_create_and_destroy) +{ + GstMediaSourceSampleMap *map = gst_media_source_sample_map_new (); + gst_check_object_destroyed_on_unref (map); +} + +GST_END_TEST; + +GST_START_TEST (test_sample_map_add_valid_sample) +{ + GstMediaSourceSampleMap *map = gst_media_source_sample_map_new (); + + GstSample *sample = new_empty_sample_with_timing (0, 0, 0); + + fail_if (gst_media_source_sample_map_contains (map, sample)); + + gst_media_source_sample_map_add (map, sample); + + fail_unless (gst_media_source_sample_map_contains (map, sample)); + + gst_object_unref (map); + gst_sample_unref (sample); +} + +GST_END_TEST; + +GST_START_TEST (test_sample_map_add_invalid_sample) +{ + add_log_filter (G_LOG_LEVEL_CRITICAL, + "^.*_sample_map_add: assertion .* failed"); + + GstMediaSourceSampleMap *map = gst_media_source_sample_map_new (); + + GstSample *sample = new_empty_sample_with_timing (GST_CLOCK_TIME_NONE, + GST_CLOCK_STIME_NONE, GST_CLOCK_TIME_NONE); + + gst_media_source_sample_map_add (map, sample); + + fail_if (gst_media_source_sample_map_contains (map, sample)); + + gst_object_unref (map); + gst_sample_unref (sample); +} + +GST_END_TEST; + +GST_START_TEST (test_sample_map_remove_sample) +{ + GstMediaSourceSampleMap *map = gst_media_source_sample_map_new (); + + GstSample *sample = new_empty_sample_with_timing (0, 0, 0); + gst_media_source_sample_map_add (map, sample); + + gst_media_source_sample_map_remove (map, sample); + + fail_if (gst_media_source_sample_map_contains (map, sample)); + + gst_object_unref (map); + gst_sample_unref (sample); +} + +GST_END_TEST; + +GST_START_TEST (test_sample_map_remove_range_from_start) +{ + GstMediaSourceSampleMap *map = gst_media_source_sample_map_new (); + + GstSample *samples_to_remove[100] = { NULL }; + for (guint i = 0; i < G_N_ELEMENTS (samples_to_remove); i++) { + GstClockTime time = i; + GstSample *sample = new_empty_sample_with_timing (time, time, 1); + gst_media_source_sample_map_add (map, sample); + samples_to_remove[i] = sample; + } + GstSample *samples_to_preserve[100] = { NULL }; + for (guint i = 0; i < G_N_ELEMENTS (samples_to_preserve); i++) { + GstClockTime time = i + G_N_ELEMENTS (samples_to_remove); + GstSample *sample = new_empty_sample_with_timing (time, time, 0); + gst_media_source_sample_map_add (map, sample); + samples_to_preserve[i] = sample; + } + + gst_media_source_sample_map_remove_range_from_start (map, 100); + + for (guint i = 0; i < G_N_ELEMENTS (samples_to_remove); i++) { + GstSample *sample = samples_to_remove[i]; + fail_if (gst_media_source_sample_map_contains (map, sample)); + gst_sample_unref (sample); + } + for (guint i = 0; i < G_N_ELEMENTS (samples_to_preserve); i++) { + GstSample *sample = samples_to_preserve[i]; + fail_unless (gst_media_source_sample_map_contains (map, sample)); + gst_sample_unref (sample); + } + + gst_object_unref (map); +} + +GST_END_TEST; + +GST_START_TEST (test_sample_map_remove_range_from_start_byte_count) +{ + GstMediaSourceSampleMap *map = gst_media_source_sample_map_new (); + + GstSample *samples_to_remove[100] = { NULL }; + const guint8 chunk[1000] = { 0 }; + gsize total_bytes_to_remove = 0; + for (guint i = 0; i < G_N_ELEMENTS (samples_to_remove); i++) { + GstClockTime time = i; + gsize buffer_size = g_random_int_range (0, G_N_ELEMENTS (chunk)); + GBytes *bytes = g_bytes_new_static (chunk, buffer_size); + total_bytes_to_remove += buffer_size; + GstSample *sample = new_sample_with_bytes_and_timing (bytes, time, time, 1); + gst_media_source_sample_map_add (map, sample); + samples_to_remove[i] = sample; + } + GstSample *samples_to_preserve[100] = { NULL }; + for (guint i = 0; i < G_N_ELEMENTS (samples_to_preserve); i++) { + GstClockTime time = i + G_N_ELEMENTS (samples_to_remove); + GBytes *bytes = g_bytes_new_static (chunk, 1); + GstSample *sample = new_sample_with_bytes_and_timing (bytes, time, time, 0); + gst_media_source_sample_map_add (map, sample); + samples_to_preserve[i] = sample; + } + + gsize bytes_removed = + gst_media_source_sample_map_remove_range_from_start (map, + G_N_ELEMENTS (samples_to_remove)); + fail_unless_equals_uint64 (bytes_removed, total_bytes_to_remove); + + for (guint i = 0; i < G_N_ELEMENTS (samples_to_remove); i++) { + gst_sample_unref (samples_to_remove[i]); + } + for (guint i = 0; i < G_N_ELEMENTS (samples_to_preserve); i++) { + gst_sample_unref (samples_to_preserve[i]); + } + + gst_object_unref (map); +} + +GST_END_TEST; + +#define DEFAULT_TCASE_TIMEOUT 15 + +#ifdef HAVE_VALGRIND +#define TCASE_TIMEOUT (RUNNING_ON_VALGRIND ? (5 * 60) : DEFAULT_TCASE_TIMEOUT) +#else +#define TCASE_TIMEOUT DEFAULT_TCASE_TIMEOUT +#endif + +static inline TCase * +new_tcase (const gchar * name) +{ + TCase *tcase = tcase_create (name); + tcase_set_timeout (tcase, TCASE_TIMEOUT); + return tcase; +} + +static Suite * +mse_suite (void) +{ + Suite *s = suite_create ("GstMse"); + + TCase *tc_media_source = new_tcase ("GstMediaSource"); + TCase *tc_source_buffer = new_tcase ("GstSourceBuffer"); + TCase *tc_source_buffer_list = new_tcase ("GstSourceBufferList"); + TCase *tc_append_pipeline = new_tcase ("GstAppendPipeline"); + TCase *tc_track = new_tcase ("GstMediaSourceTrack"); + TCase *tc_track_buffer = new_tcase ("GstMediaSourceTrackBuffer"); + TCase *tc_sample_map = new_tcase ("GstMediaSourceSampleMap"); + + tcase_add_test (tc_media_source, test_create_and_free); + tcase_add_test (tc_media_source, test_create_initial_state); + tcase_add_test (tc_media_source, + test_add_source_buffer_with_content_type_null); + tcase_add_test (tc_media_source, + test_add_source_buffer_with_content_type_empty); + tcase_add_test (tc_media_source, + test_add_source_buffer_with_content_type_fake); + tcase_add_test (tc_media_source, + test_add_source_buffer_to_unopened_media_source); + tcase_add_test (tc_media_source, + test_add_source_buffer_to_opened_media_source); + tcase_add_test (tc_media_source, + test_remove_source_buffer_from_unrelated_media_source); + tcase_add_test (tc_media_source, + test_remove_source_buffer_from_parent_media_source); + tcase_add_test (tc_media_source, + test_set_live_seekable_range_on_unopened_media_source); + tcase_add_test (tc_media_source, + test_set_backwards_live_seekable_range_on_opened_media_source); + tcase_add_test (tc_media_source, + test_set_live_seekable_range_on_opened_media_source); + tcase_add_test (tc_media_source, + test_clear_live_seekable_range_on_unopened_media_source); + tcase_add_test (tc_media_source, + test_clear_live_seekable_range_on_opened_media_source); + tcase_add_loop_test (tc_media_source, + test_media_source_unsupported_content_type, + 0, G_N_ELEMENTS (unsupported_content_types)); + tcase_add_loop_test (tc_media_source, + test_media_source_supported_mp4_content_type, + 0, G_N_ELEMENTS (valid_mp4_content_types)); + tcase_add_loop_test (tc_media_source, + test_media_source_supported_webm_content_type, + 0, G_N_ELEMENTS (valid_webm_content_types)); + + tcase_add_test (tc_source_buffer, test_source_buffer_generate_timestamps_mp4); + tcase_add_test (tc_source_buffer, test_source_buffer_generate_timestamps_aac); + + tcase_add_test (tc_source_buffer, + test_source_buffer_change_content_type_null); + tcase_add_test (tc_source_buffer, + test_source_buffer_change_content_type_empty); + tcase_add_test (tc_source_buffer, test_source_buffer_change_content_type); + + tcase_add_test (tc_append_pipeline, test_append_pipeline_create_and_free); + tcase_add_test (tc_append_pipeline, test_append_pipeline_mp4); + tcase_add_test (tc_append_pipeline, test_append_pipeline_webm); + tcase_add_test (tc_append_pipeline, + test_append_pipeline_invalid_data_triggers_eos); + tcase_add_test (tc_append_pipeline, + test_append_pipeline_invalid_data_triggers_error); + tcase_add_test (tc_append_pipeline, test_append_pipeline_reset_recovery); + + tcase_add_test (tc_track, test_track_create_and_free); + tcase_add_test (tc_track, test_track_create_with_invalid_type); + tcase_add_test (tc_track, test_track_push_with_adequate_space); + tcase_add_test (tc_track, test_track_push_with_inadequate_space); + + tcase_add_test (tc_track_buffer, test_track_buffer_empty); + tcase_add_test (tc_track_buffer, test_track_buffer_single_span); + tcase_add_test (tc_track_buffer, test_track_buffer_continuous_span); + tcase_add_test (tc_track_buffer, test_track_buffer_discontinuous_span); + + tcase_add_test (tc_sample_map, test_sample_map_create_and_destroy); + tcase_add_test (tc_sample_map, test_sample_map_add_valid_sample); + tcase_add_test (tc_sample_map, test_sample_map_add_invalid_sample); + tcase_add_test (tc_sample_map, test_sample_map_remove_sample); + tcase_add_test (tc_sample_map, test_sample_map_remove_range_from_start); + tcase_add_test (tc_sample_map, + test_sample_map_remove_range_from_start_byte_count); + + suite_add_tcase (s, tc_media_source); + suite_add_tcase (s, tc_source_buffer); + suite_add_tcase (s, tc_source_buffer_list); + suite_add_tcase (s, tc_append_pipeline); + suite_add_tcase (s, tc_track); + suite_add_tcase (s, tc_track_buffer); + suite_add_tcase (s, tc_sample_map); + + return s; +} + +GST_CHECK_MAIN (mse) diff --git a/subprojects/gst-plugins-bad/tests/check/meson.build b/subprojects/gst-plugins-bad/tests/check/meson.build index 173722f44f..dcdd098d3c 100644 --- a/subprojects/gst-plugins-bad/tests/check/meson.build +++ b/subprojects/gst-plugins-bad/tests/check/meson.build @@ -85,6 +85,7 @@ base_tests = [ [['libs/nalutils.c', '../../gst-libs/gst/codecparsers/nalutils.c'], false, [nalutils_dep]], [['libs/mpegts.c'], false, [gstmpegts_dep]], [['libs/mpegvideoparser.c'], false, [gstcodecparsers_dep]], + [['libs/mse.c'], false, [gstmse_private_test_dep]], [['libs/planaraudioadapter.c'], false, [gstbadaudio_dep]], [['libs/play.c'], not enable_gst_play_tests, [gstplay_dep, libsoup_dep]], [['libs/vc1parser.c'], false, [gstcodecparsers_dep]], diff --git a/subprojects/gst-plugins-bad/tests/files/mse.mp4 b/subprojects/gst-plugins-bad/tests/files/mse.mp4 new file mode 100644 index 0000000000000000000000000000000000000000..41315ca3c7b7e7631a16db6d73fa40f84da9526f GIT binary patch literal 477134 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 w5fv&$kNh$s{z+KMn;0BO#z#4b{X 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
Hh+0$5MBQ0`b|FGIvATRf6ECNEQW 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 z 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

tSQaLHd7CvkeXK@RU;GA%XjFE3v>T2vq>eLLU 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%0AxN#-fO`?4iv0TX* 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

eI$Fiy_rVNb=r4W;xPUQYI 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∾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 z zTuq)6qPjwe+%-8>PI*CW&6UWMCp8@7U&G^`P{{!@Ulc;$#Z32>%uYHSz7ab6 z0Cj1EHM0zGUFazBS&7;PKr3+TA=Cx`+2GVJ#O|ZdIn~O5%L|&i z-E#%pwoXSR=AAO25M2Pl>@Jxo7VVJE60T-FF53^ddt#E0n%E(`#{ua!*jLWHHaoXf^5(TpH^ zWi*b^q3~GZGy%51XWLfLZq4punOM>kF=snbO_7W$BvhMQ2KzXdDvzK2&xnz%Z6{|# zRafI{JbAWryfxNKuCx*HqDS1h<;ta<6u@LJ@|?8CFQYBSR5j2xx+qLk9P9E+oZ@EaMDO^w*~+lt5i5&hjwD8$*zh)=S zLYRqoD0KLkNxpQQt9Q3&w_l1s|8RQ>?)l;*!&@ei4@G|D#W{_nX6X0&%?ygVezKgL%>Q3}Tz^OH6!#R^Iu)aq>fMv}1_Q+fHLu}r} zcCI7bXFEh4m6EA)#ZVNI2nv9sK;(h|QGon177;OYMNSY7i%7%@ca#(X&BOs_R;~UM zMA(o-F6T*rw4ong(_S;r-6qktYj6aEK~7K1Qq0D54U*iB@gc^=fcQe3Y8#t$?vRNB@& zknSvRV`F-*_1{ggR}mgrKq_o?qrq~|;JbGp{b(dpOWyQFgJ1NsBgvyc-hu#Sfc!Q( zBN8@8A#R0ms6%d!xRj)ARs-JnN5a3PFmiah+oEFxk5tnI1@n*`v|TansKl$$u|6=$ zma-dK817OTggb}wl{SlKS%eF^eYDcBP*at{T8+I-pK|e3S4`9dwJ zrm#EaR7o%}{>mnSH!fSb<++rVocd+W%k5`r$4rjLBVR9_cpA8s>NlzfxXIB+vvL#Q z?uvcyM9x-sVKdza9!mq@iU%xITjezn__xkH2T|j_ihOUwD$- zij3ssQSqA_;3W?44pk0*yad52WaBs4>YToLc?tjk0Ir;fR*_EnkQW=pn@r=HsmIFG z;d@c1vx?e!400Wj2y?HgC-vH6b)o4g z_nSaO-Q^s%(LUQ)U*9M=)Y`l3Lo~60-nBcTF)urVH8o-g0XA_?ccW9eFuUMLGnzZ^ zh9CsAvkcnfoP_&Lc}wT%GbaFi0xB9U5#ZlvhW%d~EC3B8xGMNKV0F+tamSSI1R*(A zpi+-tJ8W^uOV9|Ew-qWuuNoKlBlRCkL{cNufY; z$#@Uo(SR#Ca7{C42=^dG^dccn4yBCbZEf#B1ne1)Gyp%i?>ka|-uZEwuVkZTK%+q1 zf&h7d{4gfCP@B`9shlcsw8+WYq92$@A0P=hfNqP}G;i_-C9-@Oe8!~GU9b4uxLja% zGugk>Y$f_udJF@~8SfjxAKl*y& zFY32I^Y$hN0g2epl&a5sE=aZIpL=lBRBQi?@od3Z$YZMAUcdqRHJsJ9DPhwB%rCcM zb?p)-K1*n^S|{(f8+59>=gxhB^bb{jRx4DD_| zQ2wjV+qOIo#4m}Gqd?w*0E~eA{Hn3ziwa!l-*^N4t5y@Ae{nW$fMNMqz<5toT= z8X>1)gS2H9!eBJS9n)JbED-cBwIa#(dAlrf0>%CitE}eQ?^Ro8eo}xy4gC{^F!aEV z!R-wFD@U3SHFwkMdJdCrlozmn&v>XN0>`v-Bc^e+!kjgg9$&Ww+@z=z;1P5eI7MSk zez&2=m)oY=q}NVhN>|5*R{PURQOAgx->)i>CRpta2No$4E?jZH&@nd_6Auty(6W8J zu46}*C0jJO7Dngvy$;(yhXt3q*hg^4Oas(};G;^ZfdGsEh5$g4@Busk0L*uLK9`d) zu&gpTOT+kn=rNed!wKGspXxVa`V1g`$LlV@SK|-K_`fIS0(UHpIs{U{0Dn%mC`gHL z9elPH*X`P#E);M=%*7>-`I2&|px8$V(RDOlm41d;j&F?ZC_)l4wtw> zJJ64~1Ku{|cZy%#HFTGFTf~+#bRh}{$(E5%2OFY@qTb%{*-X%BaK|s=p2PwTUf$T6>d!B((c>L z{^(kP20smey3*I0{=rkMPPt<~YWEk*%dry13NP-x@v3xr!gGykM7#J4;rX>4JjYQO zepAAEn|$bJJ`~(~Y`Tbo-0E2DvI-f2T#M?3@}op!b6YNS(;*6BiP#@(5)QwP)ZHw#^Di z3XRx5lqC%;QaQsO_CDe~+#w-O^%_NM`4DODObtl~c&7VQaF@iu0heS-1%oz1t}b*R zdugfriW2iG73g04OcT`F6WX_&27G4Y~@1dS?Ke zKxDrH0bp8AiNi>jhhpVzO!coBi-aXtwE*58m%3fV{Dr$oY{RWymgzUwRY{qot0MEL0 z61Xu&?yd!K1{xj|tYJ6&&+nX>V|-Q0e+0FsL1Sjd>~(iC_eiNCJjH~Zh%RMJ{}G|Z zx*r(vH4$HSzi5yjE>r~c)mA=&Q(nChiC0()gMvYuGR;k&7zFyiqW@uwRu|{Px)4>vLZSJpAC(N#(q(o z*+cL|Sf7#=L!Xo1b@V_fchkcF0>La;V+XXO>?QaJJ&#t0pa8GYWCCV|fkw zk!SW(trscB9lY6Q+jH%VVu}v_Sw-{-`ITVJ?zRhepA_nM%sXwB?Dj-V8l{}%>@K2~ zzhQ=a#suoJ?%7GWPejnv4^t++ef@WVSJQx;t2(sMtN;LFstmiS|Mm@wXr$~S#|Y3vyH3ghV|)QspE@aqoYZ{kK<0dZg+4XHw;l_wli7lg$crPowr(v$CME5|x%~qw-)gZJ7ZCCx0_uzjGjiC|4(z3#N8Uy-WSBf`ETTC&0)w z!8mdsN^^>b+>Hf>JdpWn-xEUEDpU}K@|wMazg5Yjg5RZK>avDt7pai_s>~!s3LXZt zQzTEUiNr88H4wCX+}Xb$Ag-tApuP)N9^1s#?0SH+V`+N8!1stEHhN>J#~<(f>JIQYJND9!=ptF! zbU*fL&u7yHBO|ZM8hT=rwx!M1ew{C%`lPA4fxyG9^D5|?95cidI@9skYtx8FFy2yR zmiUy)%xev;oh+!yZdki68L@HLiMiX3x@Vw-g$*6ybH9ZB^W@NWqQAQ~(Qt=p zOXx}#Xm5~VfU7NS`hRNdq*{N$(t?6sYx>8Wr=xgt#8xeOc~8P$s>Ee zu%WqlR->ccW>CU~K^iBSWKwh6#S zfMUw+RcH-J_fW!Ya{@bQ#)u1Zt-~e!ibKKJn7yg>eG8h-&UuV;fVeLly4Z>4gPZlh zrYt|)c;-oHo3fq`obOz;H%LEP$OqmjmF(M7JCoiAkvVb_bl-7h=XWH{Fkud4xx5Fy;CLn8fbLn}xg6afLP6^_PBfW00RJt(wU;{!> z8?)F~U}uh8MZ@CY$~3!0xkBpWvxQ}T+ryvLWoO+n7=t70A;@Z8!p~WJqs^cVBaCDi zPI4HlO3DLyaQ6xw$^2dXJ{Y4ZWn&8!%YZCiP`P@st$&`U8KY=zdZcI}c?9eyP)m zISrQ(k)YgPmk`3GG4(U}5y{$t>lK=JvCV!$Vayt1o!&?w`PxJ~xe=^kL@%cyspu-~ z5a73Q?8(&Fafz2?e)8Z=)!^Ze!LllC0b4FuD;U=QN6+Te7!v_tt-D%pN+~br6-wt?;RUB; z@aB`PK(tmP$N-~2-GTt2fc!8hfGBkZ7+VY5=t5t$1Nt6;-?mHk2+br!hqv@Y9a=uR z7FO}nI%dMi5ROqwtR(fL>UkH>dn^)jQS71lSS30BhdZFmnbob}!4m#xN7+~Esml(V zuDXNA97UcJw3+)ReXE^Cl;^E`aeJ8LRBEVO8eUN95VBBZLl^>LnfhqObDo9Z~h z7cj~4Yt~eBrpQUvydNqxb+l4}^f#>$&!wY50)YUn0EPfSlJEgd000zl#ee_+V^2pZ zIpiE&dK|t37_cShE+Fac7f@m`bZXmmo~zM1+lQC z<)62rgCd4dD#K2p;Iish+OH5D*&iPS)c|ZZ4~D^Srhe{W^3G&KKBm-GhGh&2lN>X% zQjW3z&#h)!-ek8&5j5MD4j;dUF9SZhVzn$3(wXfcUwyrBOCDALIN1OPNY{&6GM4YJ zp*7jaaNIDy2rmx=uHuLd7FY;1%mzFMM@k5zK;D7?wSfFEGMl`=?_`sDhC2P~oK|_< zQp4hw83D?J%iiouCe@?QkklQiNBhUSZZ@vl;PHTcVO*U2 zCxyKH)xA3uIDS(aLEjgO^UE4Yl^~ufgg36-u8R!QNKE=mW*7IP>uUud=En?i6Q1yb8ydMGK1Q!z=*&CfJMKOg=8yWW6ghHC_w0~1&@miIcF7`-vm&u=b3 zRjUuV zHhDG2nE<)LhpNUpD;o2KQc$$ZJLDdD@E#Yeu)mWeeLFeFf&P!JaEi%I4vio03SO*= z!`{e`uclX98ct~3qev-%0M7u106>!P0X+Z!EO5k+>eMsmdh7rIe|$=Wa+6lz-hptx ztdVjV5Te+vd_Z~@>N1!(E_U*F80?kwrim_4?W5x(JjG{txP<<;_l`J#{y{ADjRxgU z0p;k^GUnxutrF_#gGqdC>wXrW5QaOYiBrDP;|w&LUKJUx=iw0)PZa15*<;7l|F{dZ zRP3{diRE*;w_ZVA$z0W_2@MkLJhCB7C&SJWw$l&vEcHKf0LixB09YhY)9GnVRX@68qdTK!qKkZjkj^AwECTCv<8fvNT6Z4db2o>i8%KZE zkMT{!Y{(f5ZY#Wpr;s@YaqtK^P^r?X_qRKCw-KA>#FBa;@R;NzkrU{6DQV5^8u3U) z-(W2|dy<(XeEyOpzZfvXA?n2-a1 z-lOw>Ovoz_8>*DEoP87L=5pS7KkZ=lLe-@Tr(^7OJ%~wgj)?1LjouP6TXGHvf;K(K zaq|OGmgcv|EY8DLzqGuz6VcbSWX}!Hw+w*lZ}tLb3ywsmiy$7YJcUXaX#Zn`fBrk! zE4jVw7tw3V~ z&S06nW1{b(^g>?-6lojlox$4gOn`%6C~x=bnI!p<(Ujm~e+>+BwS0w8C5uM;T9UBf zaQ6-`+6(M&;H0A$D&+@(@u2dHhZD_!mHMBZsNteLW-GiZ2O{x+CIkQ;VgQ4d6YRG_ zT9t*TP=4d=HuFAx*8&fitxqEVJ_UF3ObuT%Cd{1kI-=hITm)77CWf+GDW&QUpLg}R zorM=k8M57D&gZf%rsb|JxXzn-YW~0qf`nURo}=N$&~$fqBsp(q=x~^K91Xi!r3>X! zSc9@i%KD_dWY7Qr3*Mm=t}_GCIct94BlpE)Naw$Y&;4X9pd-Fxo1|E}V#L#fhP#nY zJ|B!Z&TbhFIemCHlmHM7z-jQsb4B|WPtL|tG#@<8;MhS0V+5VXGO2LO%w)P%o4Aoa zQ?L~!vLJI(`(}!V{KFYxiRq^Idhd3+f+U^%l7IsFcuCfI_w3+GeK9|IQd z!7$QS#vad5=N7u}38Ysp5A^}k1ovPIDkN4+dAH)yJ;B?XgGqw)Cb$na;!cX01RJ)r)R z+jOn`D7v6l#XeIGV%5%`uZ<_c_A?P@41jBx10&AIvx=Vf@`(EcR#~nCznY?Jg4R~O zLMe`+@e6z=$Jq&JkGjGXsO>q$nHR0jnp*N)GTql6{AbIDHP6;>jA?h_G898ssd8h( zgj_GSO+!qNzvd^Xm8-S@t)IhsFVwh{u?5}3+)Js9B7l+Y{PT;3pSns8A_^C8TT!n& zGflRiF(Kldz9>aK)esz~P7=N}=f?L{)=NQ?uH zGzY$pJ$oRC)rXY>LY7XE}Q;@6(Ud$^0 zbNNS!HM8*?^~R#<#tBndn1^{B&>@p-=@iCXT$#m2Rcl9oLZLwS-U_LjQow``L*Jy< z3;!s+ijPXGuu{;Xo((!@?mrr(l`uq%z=LvrfSovpB=tT6oX88_N!S3B*z$=DFa}H- zCe2$wMagB``+-sod94@AUlGazp^7=i8zJ18z9Bh*;e7RIF)UH%D2V_T-1y?xi1gP8 zaK@CL=qN&Ua*3^td~;T|p#ug-k*HwGNs25ceDrc($v*-9n!1)#X;{Y9x^=~} zK_mb46|^;swisap(A;uForbOH*Yvq(>7$|XaUT=}5)Co3$bL!``YfiSV6 zRqSlS-?Lp1+D@hq@FK!zcMu`kuyH7e_@W|MTgp+1tk&6JU0|I4$A;k`lm}%xQUMW# zfYWzViw-0^-3qRZL6zvI=7L#c$TTH6T&aufvPG&$UnQ5EtBbd<-6V?zA zV7>ic3VgadHC8EI#m5nWM%z9LEq{6$j@6F;VbOf9#d@ELS->RR)VbKw>#P_Kk%D^C z!~rZqKsd1eDyamHZfUY=5`W$S6Gmg(vJ#zab0N(jYf)}4d_#fd*awPe^M!Mmqd??> z0PukPE==J`e37p?6Ba$yfTw9e3Gr0wB@pXVSTfOLxus!*&WJ+mdq}b=4@3+V^$6eE zsm7~WRVHtHE#9>~t6Ykh>%05NV7P*BaC{bDp4edAxZJwg_&xkNZJ?y{LE?%1VKur& zw-{E^R#`m_)03Grij`jj5bM{F0gj>I^?&qA{4waFI=Ifk>CoEcTwP_7c#jkFV*Ahc zugl+54`h-{9#A|HCp;@nMb!6Njq-;|*FUl=hjjF;7?+l!UQ|<23N6w1LOpP=;#LSi zsFUp})gUend~?^LHfG7x=|=*iL4<(-@BoGYK$7qQNB{sBaLFH#004S6wfJ|-v{wY_ z{|-kt3uk=4_F81*!)P)q+YLbpc= z9{diLjzN15hcR23WuWg_AYQmC%(fB_hXURZZP^2r9p z5TGpfQ&2M;9)vhlG2SRN=@R$I>J)7)vxBYiIuR`#4A0>J%+&+(1^Y2kGh4 z#LkZW%SdkPHYa=23#bFj6|ybrfh~j;De7k688{;3<7n3l3%n^Z;704uWQw{l4a>Fh z>Tt`D&pmRVbax+`H1>h2OF~=1J^*EjtqwbmcQ8%@R^B2A&rT>L>OU5nzyPB_;er7K zfc!8epJ&?-D~JhfM`kZi3}Q|%ZMf%17NplCSZ2hK$kY7rUp0oJO_y;q%=p!9-Kk5c ze%ae7*!ANp8h%Yr_-M%^shi}o$=tS>_Fqs!&(ZU>w(4j zkbC1NR-_Oqb6D=nnuv?j0D1aMyEx) z@}@JtDvY+I5yZudM75(v&4B?C0EPfSlJJ2(002CH((%`V#+~^9mv850XaIjz-^@*; zCc-vO0`48Gz(#6!@R3=~mP<>Jg!@-QU0sXUM1Ip<`>{uMeg%5N3YiC2(M2*LfvaS^ z&WJ;ucXkqlQQ!A_DAWm9dOG^*Ma6hWnxqv|1v-Eg3D-%mlMDNAlftuY%_-cec2G7j zR7`3Hgqe1S4FafJky^W>I$?_jF=n>^oJ_!?wlM-1UI{uDB}S}>5TPp*LWwYv5d^uT zFU9(c4khqJ!P-l-eHD*hES$?fb7K(zpK+rIVF=N`V*TUs1(PNwZgKX>+sNvv@m<8`P#o$%Vu)*xtv zOkQ-Ce7XcM9P?ZDjgsfEE~IQthPZ9zQmbS=a>q)q&#yclTqU^`PI2#P^rL?| zK*G$dSt{^^Et#Zg^%=7h6!kITbAQt0g70%=8F5_9c0%h~vNb^7-E&5^l{l+j`t&(x zeTRpEN~oBk+V=zXlYH9j%Jxl;T8_je`OVy-h>gq29&aj~{aHD$`I14} z9_c;%vPEmm#|7t{q9>2J+AP5b6v`z~KuL9INE8a=!S(imG)H%zu0o6;v(NE z*baPYa!hC`wLIt!C3^VuzoCk%+Lt9JQV@xKo)yNy8R8{4FH@;zdQ=3FO1g4Pd)zJ-Qj3*$yf%FsjMrxSi%5UkC-LD zQ#_B7q{$}*umpKFzCFF6KGa+IUqdsLKrS5LX$BkAd-5BcS3y?YEuuW{=$A44o2yI% zLH{8F`f?95b;#QU){cZM*P0SZb#0xPD%A0*4#Rzn@(_Omx|n&!*H_fw=Gu1(3mwV> z;yi5MYv8h&<)^)clQ^2KmNfooZ=sWGEphdpEjsQEX^U+761rS@QRP|IG{^O_!VE4iS4t$8v05A!$1Z1iM-Gn0 zW>?1kP4G6s7S~plTFJ8yiY}z4^M$$DOoo)7K%-ef2m@Y^g@MqR#`eDTe2EMrG`(-F z^i{k=JKW!|S{{e4TGq*td%T}6rIci4n;E63KTv1S9(SzUue_p?kx^(8X@{8JhL>i@$n3Qc*6r zX^%PwiX@R`r&=KrQrqSnspA|gCat?_s;D?NcESMJAe<^s5j0HRse7jccx^ce&>hDN z0o>Bgbv_YemhKA;{gh$Z<6X-V=@J{L%W%FoYhz6nJyT-_^nR5Im90$?8&helot9Vy z=YMewu+hb|lWoy?h0`D5NVF`IuC9hcuKFs&&;ydm^lL^B~C7C+7icx^{~>ze~`uN$P1Q7d6Vkq|Sr{*Qcm`L)dZhR!UR+OPr?K z7bEyi0>Z3**m%i&6JsvFmx)M_N2eRruNj0$bSs+J?BgGlSP5(i+Mm&fOv4S@={sL@ z>y^Zs#npHW2@~TA(fGbx^lRg0=)3_af)Hr;D<{UJ^KYMgoBxtGB|XR_MK>I4pJi>x z@8_jft}1UW;weub@`JT>#X)T+a`e}ZYl0Nss+TouoET=)w3c;7++PCsABlTP7- zq=$aWRnC9d`p@Syg#Z7Gz@8toZSHZ%KCW;UxET_!3|W22>fB_c&;X-A;er7ffcys9 zCX=k$si${{0)b>E(E7^LjUo@z>>SukU{rcR+(JJ^|1>oamvOfq#$FbK;C29;B&}XkLi?%N&dh zk|(rN)IC0qTSucn-+}=xfc!QCelngtHn0wN--LfiNMJn8r_#W?*#lgMvely4Q@b|& z;dvi1!Vrs*F;c%-%Hz;?34lyn;pQX5rB%hwujn_8bP9Eu;Gnj6CmhlQGoQIPrvxoW zHNhbe{nw#OP+--uN){y2LylgRFr4%}9zX7X$)(kp3GijJKBB6{k->_;++jy$nhgyx zB~9)&Y6Yty(*%W`OpmXyRYW;T!)YY62zssFZ$Dd3XMz3VkdzP#%|s@3!i+6d8am=$ z_J7Mh_V=FB_t8Q_`Os{k_sY3tVdvflM#9raqe5bV0W$!G06>!P0Y!iSAaKNw|K{)j z0DYB&37IF;h2q+M^PS7~KSXlzSX`xTFbZSd-(CQ(jdYFjK#Mo!z*5_R9F%na6+Nty z0nxh5AnM*H7F~$#+V-mgjg*}x;vQzCWiUgy(RZb4NRM$Ae5Ye{I?wLj? zLA0~J_vY!uA!!1PL_|YzsXi}gn?Jyhl5c};Z^PL}O@;14Wt>#t5T4&Q07rLYkNrZKiQoB*L#9p8CIM$gA+ zhBJZ8c)U4lFytXOgorxv58?Lo-v7JpRka)YDYFw+$2bBmFqlg-;4Y99EmL230zMx0 znMRq+<*<#}i(WZMUG%&fMCIp=hO)yVYA)CGosHl9o^+BVG$W)~xXFR9S}Ht108gE+ zm7BN_D4lyF-%_Hge(um!HA6ZE;RFL&3u46835d|ZSj*i@jfU3n}!ax!lal&b70*jM_>ZU+qPc&CY^iOg_ospfmP*V zLoPuwhWt?FgF!wt_Fp0-0HZ+Qf&oE*`~UzU;2S>3l4s{E-&u-G zab$@f-$ocVKC{_Tb>8i>bc~sDfy2xdC)wf07=g=3q)X*RL|13cU&GwF=>qGv+S^MU zt~GM1Wgu}opmugHJX4vyJ`CQ^8)ajpz|Mstd!nj2O6HC}>9O}8k2^%<$VVip`=Fe0 zr9~q-n!t5pXai@pQPIId(OjJUdbo6UAj9pfWr-%0I5Ea+qd?q(0aSqe2CCimltea zfo-mlBMcX`@n>47@spfasWo7 zb5DT*Q~-tmz>@G`9e@HHf5h~`zPZ1Duf2Elr>p$WUF78#&d~LLxqma{<9nC-U()}K zeq$To)%5Qn+3!39(XQj9dXKU8ojBh5?xLFioa(jPUel*_q}}QYUhZOZ)tgW458MA* z{nym5_*CQH8ddtWiv2Xd2K}w`@gK+RA3OLwXR7_55_MNyKmR8Byx*qz{>A`*xLbIY zCu-gXSFABkZLdgqD3_kdLw@MoP`Pd!M-kRE&aMQ+>thArky*=wLK^!&eLw7#K;ii%;@< zE1^KtJ*|_gryF~>8J|9%8*GWvVke*8Zf@zE>a3Gy(WBYX~We+CpV6GHx ziex~M57rD`Cdb3DYF2bAj|_)B(aOrV{=;mAH1v8`>!YyW4B zdiMGdVIQaVA19qMtj-~+MT5#kKP3!i7&1KpIqOn@XaFq=!a%MbA1KHqfADdQ98^3R zgwlH5QXdZz1>IgD*p`*>H~)&ybp!RisujzgbNvlh7_Z4xS(ii9Ugln_AB zAaWiKK|5N@gIaksFd#oA@-G6R+4$!s?lK(sVY$}JrQ?QIHZ_1S%GD)-vgkxR21llvFG7kf@7vhXcm;j_>zc2`OLA-fI_~ zwY4ksRFE=v)V&5~uNEh7xy1GXmmshg4#%1e+9FWp+8;H z$$sW=n=wK1(BKi+ud{>1jcpZb>?w1ueupw;)Czt=?$SW(Ay@2l)eW*04t}&C8+SauAN8GBP|Gw3YrUfg)47E;QUa%ue zsjV(!NDypkAf@IKYF|rcEL{#g{DKG9dh2&bhd~Re1Hu5OZ1xejuU?%T!~u%ftv)tz+Kn%$ zJq1Mx-x?ByD$Y6KvX;t_`~wsC|D1p$Rina@`CqVdph+DK2_#=!PJy{PzDE`}2KK;( zA~Txt2m7|Nxkx^MI{rm3ZI}mKj9HP#a2_rp|OMr&K!=U<@djEFFq<`a-HH6%c zEd^L?jC6yV<%ln}2S)kdKTOliHvGD3ildbjIwEmJZpacnRiUIYT6AW7^eo308@*zS zV#eS5C}E3s8Pg&6N%m9A4n`FsE2J_qFCIY!8t@d(P23ZWCg2*Y*N~_64m_?)Y zr*cH}N-KDBJA9jB|U&Pok-@j>t8ly=f@kDdAVyG^56p3?9cLnR{kgDhw zL_&|=HZ=k`UpBZsu-ls$@O~wl0B??<>`gL6?J%XX8pa{2w@;Ew(T}d1{2c6gA|U3ab<``01(zSw90!$h%+8k9ez} zoqRJQP>~42I0j{e^HxeL^5x_%J;d@?_c8Q1wUKuqU(7OLyrZjz%R!s4$vxy{j}+ml z(EC%ALMn{z{Ucb^`?PA?+vXbZJ#)rFdf9ei|Jtk6ta(<$oa!+oGFiDOPqR-E2??IV z)cHr6heaujX6|C@4^=1mxN58uSzK<)HlNj1Hb>}e``X$FZ};NLIGPL-gO}2EVr8wQ z4TAHWHHn1sU7aho8BFJK>_~~*=c9UBp!b2#a3jTl#deok*>}ijLu|^&yf3B|IDtqh zyS@1C%|8dWaMtG&#EW!T6`sLgcid4ko!XwrXf3{tk zMq4VX-k#B$5vdGH31iS{XSzc_^GpoCJP492MG$3hFkHlibCR7!A#ru>j#q6!Ktc=Y%?y2yC7Ve>ZdF!!G zU|IX!|5?DIesHyID{ydp1_<%0QR3hNrwZL~jWax|t02U<@S$ ztOQhXoMm*L z(Gy*HB)GDapvfgubsc3udRnY%O)UQjg@+#DxK3?&PYdWc<56e=R3eb7rx>!nDv566 z313=ds+oP#KtW;-)gG(?LNJvUt=!#jKrf(ShHxpLm~Fs2m`yW{Y!T8_^}xnyI`^IZ z+$1LsPG9tXeo5aTy^)S=TO6dh*G?HzZs<)6=^e+qX1FaiiqlW6m`LW7RQnck9!U?IJ)yXntIf!^E*8xtA#~XkG(i7J`!gZbf=tz>Vu1evcm(1fieW2 z^J3jApupc9FZn!(k959ncEz_+W{^G%=fl3bV<*kW!fu(Seqz@Cx{n zg~6YC!4N59$n4?GyV&!};Lz3Bz4d|6tg@K^lZPG{wFM`DLpz!MtHK08RxZjK!h`kXZ&w zo~_gLLKi!ShH`+Yvqv!cV8LjA&SM!Z1rYl9Q2)u`2w0>xPKxNeQuM zEl`PwT!(yfQeEB(>1{BD#0^3-f@e)Nkj46%%#K%m6*4d@mOAwYq7Uv8MfLuf8dSuq zpI2M09bh}%-9lrlH)Lln%;vS~9VX=zx0pLKimTsD!q&r9%Q6$B=<^RPSMBZ|sx7{t zi&g>XacfbH-+(U;Z*`R;a^5E^O1U6@8-PJy-!bz^<(Mds0s8?qWm+{_M~bMf!XpSt`PB8reli-BcuR-n%l|Ku4UW;}stN<~=is z!qTODhvsj7-Y`Ema!v?7CxK=)%oy^wnU&00o^Y_umB2=x_&tvbc1(9xmTE;efLW*& z0oC4IcbPhcy;n1nHXK%UcoLZsrz+UAFoK#_4R1t(h7r>-`sdo*H4rrU+Kkq(B$uB*{YHG4rC~u1?{K^|z6tJyQ`l6VW(6^9_muY}n3j;V=1N+x|6&2~ zqe}PE^#8UIK>Y+A+|y&c*8)D`t-QoH2M^w>#@W&o`|t?TgjD#R`SgN5K6w0bs_bu3 zN)OW9jz|O0Pus(HNd#9bQM{G#wxEF{lDkg+g$XP@JZ5Mr+iX+9e+xjt;qZIxDXx@rPT98-F>^L|p2qEhy}N-P_|8Q+ol>_YjF6%587q zf_L=eS2H1aVLQ<6kHVaS_yH;XIR5Tz{5P7}0aSvG_K8uD*_7L7{tmBy&~5AA-6T9E4(V}!1n(iqY~pQ1K~ z{qel5zH=8;`xb$`tmUrSdEpFC=zT2Q{r=A{gm1~d3_Wb^m)rf(S(S{<8P23ejOa{6&v%m?X?z&NUD%w*ohK93}Rpp5vh1ww%d5M+S8nH$;FBF0I^V5Oye)7R2H-R*=KkUh$BuDRiJ`T;LElo9?$LK$rfhIl1u2$fpmSx*X@h_(s@DMQt?DSANzK@FTYIn2ligA z`03CY+DWT4xIQ|D9R{MQpxdj3^lJEEIvdaD7QUq!&qTDHn`;MKZ|KU2*gl)OoFBs2 ztv`B}1&lz}wi#`*zHugn$Wqr>`-~CaZh7Qt&X|^si0r6c;ltqN%Y72yS=pORDtzZV z<~Fw4sepJSef)W7-$9fEG-604Ts}Le-v;iWQ}wPxsRcPi!Fnr~O#R+C z1#sa=9)bnB%d=e_tVGeN`tt53;O^(dLnF#Xh3VB@ZsaF#059P^oKeBG`44Fsy1-Ae zU#IsCOvdgZ93WStcRS$qfMtSNr}QI*Oj)a8R5m30d+X7q<^Sf^>ClfiTtR= zJzoyd0Ak47L?Rz`jycv0HS~0lx~!!;Ocm;wcJgT;AM*vb#1zfte~KC= z>DiKvE_jgP@Eb2rtnToGLtbPx=RGgWdu9Pf{_AcD1UfZX;&3&NCww#%Ck<}zlbLR< zD3M3G)c}`yCaGqg;tC^Wz>)uD6wcM@vv! zxmr3hJkf(+J;vG?(WYGJH7<90OMQRLND;VVc@o@Aqf(i%T>@leUln5%OxOW^ghj({ zLi)~7D-rN};Q;zD*aQ!XFlC@+R@7+n zyH+WtN5~Y-`-S#1Y&o*(sFg zyruo?Z-pXUX{ZWBFC)E(NO^|^#th4#1`%k*w%-JYGru=wk^8jhX^}S{uPjwfTp4A? zxw7YJEi6M%CD~*@1Qp;8XsG++@*!O|PB!cs&f6qwK%nyL@3AFBo=@TD;w}~)5M9@` zR{B#LXE~`H6I=V$UW4UIwx| z2fL~&Q-`oK;9m9fnda@6<95N8ft@F9;#zczv_TsbOG|zY?Uh;Dv%IJyDU=7HUcSC< z&`vz!-D&;XEZYs~P=XVqXooOp31&^y9Y4yk5h+{C9I&e=iYL1LS#lu}9dr9-=RO|c zw&E`UEMZ)6I!C%6#*lrzEv-dj9VyPPS>S9&TbU43sBzwj(t#-UE4z7I#H6fPGRIgbIfD2pL`b`J4+xtD8Eri z%1smUl!csaePqi$5$3OxI!-V>D&X{gT2I*{{lJ96g=u64QRn#)?A$J7`x&sU!?BSq zi!TfS4-YcMkS+GFf>MBj zt=!g0`VylgS|B`XnOSmCvc5x+%QGqB=Ul8=ii%!ix^U*D0?EtHPN;=QbkPWJ+FtaH z-4MPVMQ8w>Kw`fQd)UXZCCji}x!oH|xzO#EBA(r;BGl3vf6AEfo?;}kd6PuI$+HwD z<&$4%S6`7j-jNlEs^WLw%Kd=1c`-f@+Yh;JsS~|Xf91p|F6NsmN82f37qj!KH>Lj- zX0lIeT&#MC9DlX)ZM@X-QhQcx;Yd)8HSGYYdZ43s&4s3E-5JZuL(oRk2a<3O_)~@? z1QG)r`<|EPWbX`+ocT?sPwr&#QD~^dB#?rr7&^!xZsJlYFL+ekQXGaiQOIKRX!eib zgBc+R-<7a7G?^gNL2K#4!PtZ0GTc487TC$H7;Kcdq3vVT$7Rp@d84s1_;U4oJ#r;3 zqwAKdC_avX^4)_T7cMCcZtn3sD#xFfg&1Q6HVkSa-8gNqixFwgyXo8Pu|RSjFQ2K- z{k4QpllZ(~fB`$s1h}NM!g|5ciZ)SBvsMk5$eVQ>Q(-hB>PUgoXV2=gcq}@`uu#hY z692RH1>{r7$$MK`U2Tt873~bl{Ez*7#et6>4|n|k#H&|togaiM0^zhkJHP_xCTIh% zLfBEZZFJAo8wI#guGI0on80J9xSTM=Iv)Vxc`4XCjAD1^2P_sSaD|$bU?!!1I|`qo z2(&3~SFjZBYf(yKs~3(wi_CV`V>JaLC8POq+hR8Se=>to zzHCdLh4t(`rT3pd*;adYs^m$QXquxS(BEf(^bcvFGi zxWxAC83TYq@V#cA)o^A?d!mCva8gU6mb*LFbbEpC8YdJUS7NB&*-RvLh6Of!ZJIT?V(jEtFWnTs8_;~t8zFmW}IJbG3dp*R<}@6 z$MO2aU@@M+N0YvvUB}Yhic|f|VXIaFHp&vWqRCpT!(*$vY~syPfZe6LcHCg2!aB|? zeV5>p9^((%ls2|AFTLj1io{%U%v?eVmiV8$*4_(JIw{EC39i;eJir%c?U{i6=AME! z{!b$F2^*vqrIHRH;aN|Ss%OFM?~@B<(ZOTVMA6ZSqSlX~t-IWI;sY$ZJmVjCqANB~ z%i!Wyy>pEc_9!LYh013*fwk(g3?J>yO8jb^hLP3eudE1;&=>?N)E9ay3Bgi~BTZVm z!c?j+T#vXAZHmI>V~ON$>jN+#eY1jD>*I@_R^i_d4hH&PS>cg{g|)?o}er4WDP4dTrOdT1p` z;sjQ~W4{302y)^wMijEI#rVK5MvQU-J5jNxAoO+{zdO^%0Whyh$3UCMGcbyx9o1MG z45u2nE*rQ!&pebwi<|XPhA2On!0vOkR(U2GNFso(%~TLsST8~Gj?w44qMAZnAaUSR zsLW;I0wFF)otg`5wZ)5lD* zTNqA+<#cGix30Pgl3SuQr+%2RBcU%Ab6-)Pw7k$+dlEvHtqngPttx?XOe#f;9eR8$ zQGRsY>an~G>@a_1GYW0^cxpxRe{JESawa+D{M(!x<|HVE^+>1Fykys?wRcWlGBF?m zUu3^dX-PLrrk6PbbxwLggNL9!im4rZKEJoF7|8HvoDw;`7xc1KjgPG3`7MnUD(~m* zteV|6&rEj^y7VT#9_ZIGuO~bc8gwOI6o?+tkqE#bajhy^Kv#T*h&^Lv=Jo0NMe46~ROAPo0j!cD+$B`(x$RZ>&2*F|@4|x8ioG@~e=G;L+kDPZ zEdz&p$ zJ>Vck@mUG+e8<^nMlaNL%ZX7J#TER;7`kU?s-}(gC zf6NVuXG(qY{80~^c2a-WAtZJB1SwSKcdH9~0b_RQCx)$RpU1H#Q8Oa!Z4|Aq84ljCOu%=p`x@(^sD;rjurIah27I2t66|&cW5wriDh<; zgCdn~`)vapc8i~oc`sA4v$^nuhqB6DX6*nPmkIoD_NV+%!n246L0(vyoV_9?gU+qB zQTZF-aM_H-v_*lBAR^9Qk5%zMm*wOI@|y&2|mh?3kr+nY8Zf%7wg^oKN_sbQfC z!YDO{yUWke^=mF}#JyOMmoIyxhXz{~;B)*c9nf%TIXQVNa_ryok&f#gs_Ey;Pzg*T z7q1#|V09}O{l}@eG=Z)fg3SemW|N!DWiW6yYDvVWvmlM+`MLYwxrwz4gM%Xmm8kk6 zzdpU|kh4O(N=A_vm>haXuWz{`rqY{3deWXs7q(EkiZ&hs!`J-NE-%ax87IBg+M?wID_x-z`7JjC%l4r|?HN8#*CV_5gO0~w zbQR8)O=R$5E4jSiZ@mi}9GS*lfVHqOs2g6A#Wf=3bK`|t;|znruR$eyNGBhx{hy@@ zZ{d)z9#q@}gEHwc0J#vjou_ZMD-~xn|HzZ5&&uN{!O@EH%S3n?M zJ%RkTPM!>-iVb)-0AM%7bJ~xKwIu%@vfd!055=?<58y&bE*)z)hW;_Zy)&uF(q>3) zvv(tvG2pSTzU*1U_6(Xx_;+zjGsArQ`5A6!oJ)eQ{S})0BSaF){edtBMksO#4tmuy zIz0x80Hz-Tn>}bd!GTbqWQU-ymq3t~cfFK@!+{=0DfA&%ANjDZhd2yAcb94_GmMTC zKjg4A$OZ>4x=Re^u7!1LoIv+)V!^}H4(VO@Z{^RKz(-|2TXr>eEdz^7{cDDM%2*(2 zYW#+PQbghRAQFT^nzNq>Y8)22iSLdN+P-)Dt_ikQ>7W5@0^S`tc=L?1DjkwowV}_j ziPqf&zBK9ebuWCMf3qDA@)8=DZoorY=#xoajJ~uuhbscpz>*W50Wd%7or#~I_ELgI zZ$uS?E63r|+4>?Q0)l?kk?|DJK+h^0Y4iY%C3dA%t1n-gzba43Nr1(Z&%1>j=)9_;o3J={uOB+VBqy8S{&r8kDlP)W5cb8~ zGPFf9XW1oD?g1J(`T-y~KH?kVZbjb4I8S;SX7>UUbx$uQYW;YDRZ;R2GyZxsOxMub zY7BX{e25$^e_@~4x(aFpe)jW%{HK5h7d1w0D#W|F47c&=;G)*5;r3AFvH=ajA=j8o4C1aRYT7<3|6`yw*# zhF|2JhC6{buOP+G5qU}?{NL!yF3&9ZJ?WD1g-kJBBEcqueSMJGk5GLU#xnN^F!W6n z;FcP9HUmqT##T7302?q=n2)|c^h#NS?XWo4LgxsofhDCMPTi!O?0ITJID_`uuU2 zS6;bZ67W<#NsU$rgH%TJGNG+qSw!=hj0V)|vgwUR9)O4t9OmR08ETJE>wT{9GW&ALi+?0nxvH z+|FUs-;Zh2JJ=e+=DrdzRy84~J4#$^fQ$G!oAVorHUj_vRszgH6dLP|F=4(FyV*ve z6R#p=Ik(5v$c*c+O*i;D4FB(VbiD$gAnHp=-jgJKUWOYo^2P!kFYkS1F1A(zH1YfW z63l~G>+kAOY_zWvoNhsflxHS1-T8TVaem~u$4>zZJ~deh*o&ta?`*v)%Yx^_TsBwg z1=%7z@-@7ZxhenNEX@sdI_YJ#^lsFR^;>z1mTU5BGC8cHk%F zwX^5+{Hef7cX`{l68M1FRA5RxCTDwTvf@CdoHUi-xuPLmjkH*@%RR?u4^0>eGG>ZD zdv2gniYP-h`t8x__NFQ0<_o54v~tW6)L{WVzBVX*8ulZ?F9`- zAS~A-cbN6n{~8yP3sbJfTQ>j6rempx`1LBl-7T;bmYiC?ar%32A^VF0!abH+-vSoi z^9?C%OQt2=Rlbk;nNBeX7a>G>A&XV1Dt1?rM^IM%Mc2iIro98Lw?z;f{68!MDiPv> zmvw3#m4!m!=iB|S(8Nda3`d0$;@YgLvV$4NSUPt>Rw1Ni*Qwudu8@?cY8rr~PPo&` z?zhsZ&OeI4w^NMt1;9F9f~%axys3S?{mv%Uy1m)ila|iqmnMrg1g^ z5o+p}#nB#`WC$(l#9iqC;S$E9Vr{=^%&w!SU3i6%~}v9TI)M*qQ3-fZ5GK_-l@(XRlp^^{eGz4Bi1gH5w1CTN@PL{5!GP zFTLzcOI|jNpX2VcXsXArQFTvQ6?g4N)rl?fLUv6-)}}&hZtpxt-_(;m=i9HT z_4@8II(LgDz1{BAHL1Btnq(*PCvg6ddZ>r)-WA-IrrxW-U;OHmmK$ZGF_g{cwf1Fyj?_R`ZVWtQu*-dVONZ% zO?oco3BVtiRbEj#2f>{T5pUfzQ3(&>y6MWM6;y zHZe%QQEUS`rmkbUKuUFiFxsEzT|SL{IKgbJ#YhuI!)-Z*wWX;ylLUs;DDuIm4V8E} z?uf0&PW7dx(Mm^zthfnx#Fgg0BI=tGO|tc)Obtc;kfOaq*a^RCqbwMnaBOCmjL)r) zX@b}q7wLfLv3j;Vw1q{+u_M(WR&S04hpl^6-HN&m{E#c$yDaEFItf?gBgP9Jz|#b! z@$fZdOG!&w=d6FVt>F^%fw_>oS$5Y*+Rxqf zOpt%vMn6@D{J2Q^JUEZ01e8iwN|(O!eMK=WrhBXk^wYZtX=;Do63|>eOPtxyRu6Fi zWTNd{Z7hlTVQ@wMx+Ejr*vwG3Y<~kK@tFz0{6Yf<2iV%62bb=Xv*+T+u^6)1}Kh3$R1-AcA8Kr z=yzUeLB*pFp#=lc)g9ohb!K%sfhrjjI!#Whf+#KMmxg3 zaz;Fg)q=Nd&H-llt5D>eo}3fXPwgR387B5|+{cVC5RHwDQe#X!tZAN-V|%v&s8a@}9Nj7;OJiQ2Cz z?glyhB2@=g1W3@!HlB85+qYY0G-6GA9Bc;B<>G`E!AZKryksAq(YT{DmhG(p9bwMp z;9KrEXt4m9_;&%7_!In?;GzI2gkmU%i)~dU_>$tbJ!&C|RD+yv`T;U(QhVR#1>i5xnOTdQ?A+g8 zol2|_g(4x#QoPd3M@DW(baV^t4a)x=BDJad|MmuPmR6Wtp6@4dl-4>r0gQbN8eiKI z`g^?keGF1(JIjaEAtryiTVJzkH?)Ok;>&rhp}|C->`?5_@&Kbi-hu&Xfc!8e2|w;U zyF>xNspnx5GHdo>?s;K5{Bt8TR9C#37vWZKLUiIM5HYEa9W$-kC=vv4@6U>mOxq_e0NAA-fI-4O<-rc)K)i&4R2<1> zqK+O-Pc8>_z>~@!psUP{%(_sgYelYh+8OfQYN-IiKi>zSgS^^qc@FQ%BTUZ9B6Zvg zpbXukLJxrfbpVC{K$7qQKL7wgcJGU=p5PS#_)KY%I^BQ(dIAV9By&-+zr4u#=LQ4) z1-UOxcN8HZe$f2Zk$lqj$hX^Z+3)>Y0(%|L^s;DI|1T;f*d zQnx+Rme+M28HHuL-|L}oSoHvbwO`(@F$G7Vfw3(jBT4b{qqoGLFTOw-m42 z^9RAbJZb8m+$kBNCEUm~jO*BJE8;H1bp$G(RQTE?S})n~AijK3#w^@zlR;dMXUclV zS~IOrKEyC;sOQkKTH`1vu$_Dss+J{i_6awtkJC^Bcn@(+-c1$I!Vj@$7TxCdDX8I8 z?%-c#Ehn@{T_Lhg%k^ZycQqZ=1m#W9b%l*+(KlMW;alrE|9W^T?mP)pjDrAt6hUE3 zjS=(e|HuOG?>e(sK~}UO3ihI!d+~qMDL2CZ3v`-suKlKta%C#RTRqH}eD$4Ax+wu` z?sW)*=B*D4lzGX7mgHOOGs;hZ>tVx@;E-N)lCBLSXmF=CupYS*`1=w)-pT1_??&a) z&9j(sFt@-d7vO=iq;ZXkso)5(#;&3^m%a@cQIdr&AO-q80cC*-x$*@7q7DGrP5!?27d4UqP`5K=HKbB+1Sc{exY>bfSd0LIm|Rm}x-v@L z$08vh<{f%TZ<4qczISK?lb7XYnB892eOQVVhq@QxU+WI~9_kRQHM- z>J~6-cFphoR1-;j>2F$}oX4Rb?L0_{2f;mw>^<$HK;(h}k%0U#GGYx0k(}o%Y-7tO z{)6MY_ou^taNB5`+~&IjpxTect1Iv{WQM9~*J1mogm&~rby5_w60br08cZI_S$Bxa zTe;$iO<{BH<{sSqyu1m%x`hO2p9hcek_Dv@FFp`zt=Pi)9Z(}bJM(m5=A5d|8LPit zr8lr!k~k-Y*m839L&CSbuQ?mWGmL#{#~ow}Y~5q}=Eshr3(G0LsBm`d6^}qxcqEr? z2o@;&mD%%p|D+PRAKCt*++Ql;>mi|? zK{KOFpMe3F0EPfSlJJo?fBaU9LSZ%LtIj<%qqOWnDP)pRqR`r7+%>d?Po26EPWkZfdGB{$A3Modo1=fAx zJu;@}@W$f>_NBYS?gP3lxRAxNO0SZf$2J?_87s(VYZczim7yhIoRrSFHKduZ0bChs zt9LeR`-I|4CPdg(8_4}?CWuXyy~sLPs=9h*BctUxeX9kF6lyCU0lAO6PD<$-%V?>@ zP~r7KuH=x20Pie8Gi3yzmx@ub`9GZ%0{;JSfF|uNZ2$ZkE=yNbGdesWd!4UaKAN4(FZ><6#vM+pIXd37xZ0$&)xO&A%`)66*32PHna}+nIVAQVe ze2V^azHrUJ9J8q}*WC*KXwn;6(x;sflxvcMW5!V=4E9Rr{Jg%h(={xO$3Mj!wB?w$ z(|6cYV6_GE`pKC%q(ZxByG-3Q-*~stw&0NH_f+D@Xr>khiQXiSj>kDtX2_EW+qvkW zBgIiR!^XV&cCF+4XIm;A5$%)d`k{KC6~_Al45oM|Xio|kinx|Vd6>xW z>jm@Mu5W~PVOCNr=0i_~$22YwhxfOr^0whpGjuPg8C1rZptF@w2qYW&-}MhkC?*WG zXPnu7ya9fL&6B;$uY~$9!7$`Y5|^ z2NHvK;Ffr1;^xgK@kV{yFMOZC!goaL#oXT(Yvt6ZCd9T!sZsuoKbqz`yze-@liWG2 z5V6;{`pToYyd^eSB#ZN=@dsg1_* z^s*giNomK~KY#bM(%%Y&UL#NvEG@-Y2~7XuSfQN~+6@53kqpn&nRIDJZmaWXaFpuv zFbg$HV42#9tM9o8>SOVM0-yDiaZLqk7nyh?PGH4F6;%)$^HG{tIoI`@$;y zYZ##$Hd!tb$@X$d^>Ir2lngB|@)x$*?%=sXF{?aFsm9`U5&HH8epA1kFc$*!ZKe<6wk#kUw zdYWjDuK@2`n832s0OklX?0b5jH_U`sGMKO8NK-q*Ku(3EaV;2(V#Iz`aXkHeaF20| zwtwMFqE-5=3?LeXetEwP_F;-KTDBBKia?t#q|$sK@+lELq~1UdSYK$3j&>Xnn_+;@4=m&H%8_tYd2b=8m#Dfzpikj}oSVh0PHKXxLEnx|CmsRdCpAk3@zoVc7-l zjlr~K)Zi6hJTC0iV6*Hkih?QRTKruLC%(Nb()KJGkM%qXsls5rxUT*33{JilZ@{Q! zKv(nwG3f*)I77WBmsM)21mYy>n*y!;XTa;t0SXW4+adkV3}<0ql5sP%;0P_nu6%`=kk5 zgQBNoGy}k5B%EOC~R9MN(MbrFELmV}`=nrDcUi#SP-^KFONj(fgVj8}xxJfVN0G2N)} zhwLS7vynb+B{H`oA^BZ`Iq6-{R!z>cuChGE(Nk`i5dpAtBY}XBE>4J<7K`eFQc4Wq*7?6=mj->CATjSU1G9l0EA}R zy8PrCM8k(@kp!Nerz2Tec3;RPEm=8sw;=X8-!wqPZOl+9>zTt#Ie9~u_&1uo;XH1pKZ8AAW*A++CW7VY z0}^+=|A4%TSJzLXcw*^_nScH>0=&Rp<;oKuTMGEO$9KI5RB3P!KZzVNZJrP#O$Ks($01$`$VCoxJ>OWh2n_+t;CHNUuE9J#U;UNg zEGxr;o|9HOi|2z80Dmz~s9}@1GlsPtsAZu}??GbB6alga9q%@ibonp5)E8;QL#-Oy z3%;0yO%4eicfY~&iE>iUp1C_-B#0)eykK(XlyUnzGT%T#kn*VefenQJGZn zDJj&wx3swZQJn<~LdFv*BH1IY3^hgP@ET@(-vWqaIba?hdrk?iH7E>m|96G5NXuj)t@<+urn3(gyEw=+=2nPfc*Nj=27&~i3-VL&Jw(&Q;9Qg z7;Qc!C9qVk0|kd@0RMZ6Yu&{eqTmP#iG(u zl)ZQsIcgY9zD^NNa2E6+nj2p89wO#F^(qPFyL_6KRM}bEGuRqLv!g*|fdRMxh5$g4 z@BvK#07Q3x-A6;NjI`fi6mwwXxBviufoYlDim~#hy;1`Ng?}twVnuwu15Gd=KLxrH zETaz^Lfs?>h8k=(NazH<3M%ri??_|UINCzn5IZr^k_viNGWq2j0MdqEcq)>n2n95K zvi)eJ)dw75v8D@D6syO;1ka8KOMo*a3&)M=yFlj=VB9JgOOU9;I?I|shz~60bV)m- z{@QhGx5ULi670&+MsR6|Ml883|qd?k%0nC8>Fe>G@dq(i* zA3%D+lbAvO-;@Z#7uy7U8|8Cc!{7dW?$br{N)6a^b#zVy)aSEwy<{{(>z%w)&`lb^ z1alZ91+Ti9UhGGMW9vwiIi*c0xfb@f%v+sjyN=Cqg)VF++kEnmt*eG|sD=r>;tQ{R zB@|zcg|feG-Q^3(^wU+JPRXC0atd-~aGV~ijER_Up-eF z!hVtSEHU=TP&E4y=gMFddC=t)jzTJuEfhA|8TI4OQFlR%7h_KszuT@9)M^~w^`k{a zfdSb7h5$g4@Nq!^09bc&wHn|BAg6-|?brZS>cDnWv8{jrf2I!@_6j)5QUP{KkmQTE zzPE<2f8VL|tZz`tLl?n(OR|Wm?2G*{OZQ_m1#`fvanQUwIsxGpKbv%Pk+?yS?hATd z4_Tt+hQ$jC|HV;opvPN_}CqX0e;bJR+jz=Re{L)L$AQD0(ko=|KZd=PogtQi4X!ju_$wr7unR5ud%DQ z$f*b&I*C97VB>t*gr)!U{LLR|Ti`{rNveG5tN}N>MQbfIgUf9?0lw9P;(|S7^}8~I z5Nt9s;GwW|!NpsxTx2xKn8o5GB5n8944e_4nRo?{7MXdFi(=GNdMa6imV25VdHiV6 zDgmzeQB5JGdmU3gK1jK_(S}6og4~=GLda2hw{HNS^!o4eLv!1Ec1&$-RG&t|04^-g z-_Y=KkVtAjGa8xnpsla-Paig%#sD1ymwyv|9*y{FdbK-sw&J?zgWp6Mxb|}hO0+5U z41KpOdEPxJLrCIff9@VEdyE9Kb+Ebo%h-HQ?P8$EpdMM9+2GW~3I(sM6h&n{2@V4+ zd59t37$6^8c;`q!uXESNcmfDu66Z>O`914G#k0}E@RrA-C5E~5puP}<)rFX7(Z zZEmp~Km>}E9$gk?P6+7DgIn&eRbkr=sdLxQm}L~%<9Jq6atTPm#UdCf;JOS{n>Z*N zMV;>K_u4siaQ``}`uF03QC-%))+VUv8ewYlXKIg#F(~#oUS9QLis4V=vd-{gi&tJ( zDw5;dU2a2@a^rCA{gD&_D_fD(*6%3&Nq7tFr*KviAT~X{TRH>_6ZoF?oLg-;`A|v> zZFdi4Uay-75PBeWn!o~h%Ow*Y$s@KGiB)U9u{gL{{nyJ$@h{TOSF{(X z@%rB_-xx}IG|S_FIM$@Me>vh1hzhzoSzxP`%CJWp1SSvjg@s)S2AF;Tw{3?Wrefg_*0)aq;CGsjXrQVh&KJ@&Jbt$8 zG+fEk$5n{$4Q#QV2Te}Q#Cl3K`Jzeq?4Uk-T(YTm!@E|lRo^w8fI4MVao%hRT!lYZ*82oqH?ymj|K2{6A&{Q?Fl+ zA@J>Tq4|epG8&axL!CY*7Lc{|&VreBqeEDM0s8=k06>!PK|_E5ByrpL1B=F_004i$ zjqAHMg$X2^H%HGQF{41}Jg+AZ<1^k1NAE3YS4OP4Ic~CkPn0p|?3+!EG`yj@(0Gy8 z(lwC-WMv5bc9#F3Jw0^Ro&hD4E{EOXN`smZ0yu25-V5D_%}xx=k&rWaViF-p{}`j0 zElM+GjxHY+eTI}$c&`&%JaeV}Ut{ehYQ8Ch^T*a-$eypzBPWOos97VzG^gyJWVpu) zkw!^WrR~B>$+u>V`^Rmq#jtwZaa%8~>eVtnS4B?yvnqiN;SbrZrrCjcF%fgat2-+i zCtwh5X5o;epll(o0qlf0q=#^}q2YcdW5Q3U6Qn@H$RQ=6ea4HYHL>w8enVvegGlEG>TqKkckUjbU>l@sv{{3@s&JUW3rMCS5n3xxZ;-bWGz^G8gX)qJgl>? zASH5Oh8_ot7+id7Pt)&XlUtygI9+DZDHoEv>VHv`Wfo4URv9u1iN7$Dz~gJ<5rbwk zQhOsf%r8B{*G8fPXqTt+uZCY_UwMD#lN`#l$l})sbZKG*-n;v3%c8(^lZfg`x|(0K zASb<)o%kj^so9g*J}K~8LLz)Zfi-vHyg{ww-addJd;`1pdfvL#$Wh2&kcd&y^?`tt z0O0qP+mXdCeOEJo^=s0vh3SM0%6|o=Z8-yl%LAT|+>KMHg_~c1O$?cS@5KBOLfhW) z0uMiN<$N(cFr^B2#SCm}=(rAfezE(A@_p}q8^k;3bXIe(`n@3Fkt^6?cEY~X^Yml# zG`uZqbS_b%ZW%o=YsW=>C5)SARji_h#z368bXB4y*8L8>3j#92bx_ybZl8D4Jz1cm zK;41@34r`E3QQ<~J}cG>dUC?)ss|?#nq!Wa`kvCpR2rTr^cAm;Hey5>`AKzHXCWMM z^+g#p-AX*>GCg|Y3Xh1p+;5UlbXn4(;sg%Bbz9OHh_5hIoi zdGYwCnz{Adr2%#S!q&EI{O__)Ks^e?V9;|^(ky@!Yu?uKNzU)nFK(L}FXo-jPf9%{ z*GL2p&cjoP0ojh5dzZm1;SB1D12LV)=SR%~v)B};`8BSW1bHi7RnO+50BhM~1dOO@ zELsB7XB@mWDU9plShw|~K-z)=9f15UkvI3wtayOee~_;3sO?#gq1zBl$q#NSH4pRf zot=)DW738p@$y-8;=Ml2qi+*5s`BlHuA^i-cVPrS>tXR+oOM3j{2rR2nd7EQ)aW$S zZ1a&D!?`25n^h2wBa%Lq_UejDu%5+;2kOQyxG9i;qM5iL%N{Ekm#arMVwj^2q>Ku* z=*%G(+~pK+dz7=r%pEKV1x8GNWFhQPFhheiG+MHb>MrmeU8IoQ$B2vj3>O;#pkw4t zu9a;_<$PjMgs4xUF}Kpn8S+8>ub4O4!V>n!PVL^ZZaCc_l6--K7 zB%mw3ce9Flm-c}p6~XYtb@lYX0Ds?Mg2^W+Q7X|di#EGQe~fMuom7b<2{~W-c(c}S zH{a7scQ4WRMa7COr=%Sy0hy32C1dEQm)m9uRo9K<00;zJ8` z1Ia(d&Qq$mRR}mU3Px54%I-DNDi>6RqpFp`md^#ad zmWmrx;+77%1v%M`4kw8NQ8zP{9L3Uf(VWN+>1t4 zXgzOB89%HT-41Go^6faV#ee_+1Q8UhZS0zYUrWpno>e#pXyW7C z3fi`~$Ek}uUhXW0xH6+%pa1||Rw3a#3amX5m*CCI^JXYjNMsqrb&8s_G)paZ-bp&8 zJqA>4OyyG$0BPVufT7Y|og?buBx*Z4=*eYUsv=O9!a8AJ9f8`XV*o<(Oik;B16?mX z#-U)rJ}uXo$`~wLKAgiM)i{#AW$xLvoBh;&tMgK*_C20@GGs~x|3+)C)q7v5t}V34 zWu=m0NGBlWk>C#1n1B%jQ>2vBRfG(5tpIVm>=o3<0x&2Fp$ct(^O12-y5*@w^FROq z6t(!4AE#FG&402cr$cO;i&>>D7GmBHlu_JMUtlu^us7h_+{y))2hOuoOq1~_*cV+- zPDqCTY^`I#{%$*k`Z0?L|8)9ctx5ak*@tVZxp5|63SR{gbv#Ef;muuJ$WFkZTJ2Gs zo4%RCEa9wsp`EEs#-a6cn+~2MQ^kCk*a+m8vT+!hgCfERj~D~ zmiP)^pk-C3>j_}YbGxPUQ!?rx@N>*OQXABS(6+JX(O)sJSAu0=hfQ+Py7I)@OQ zyTksc0vKN1_Dw8ltpW)PnG~`u`jZU?cE8FQKi*dz2DhynqSG6PZDNf){KGWCoD9J+-IS*4sF%ZeE*DPdIA+e7HN%DrFGvSm^LKK}inUBeV zb;;wHy{*l4!fq3DJ8h#(0~Er^dBxmc*MO?hpikinYa;K`iC|JG;EGoaBN9zRZz`eJ zFC6!ZkB{4s{k83^rd69@|Iw4dzY#qjB^ug=>}b!64hR#LTtj9{#*RQ zbW#(yR`VHdn)Lfx6fja}bqdg>x;t(-`X{WS7>{3ssCViGxsJ-<(;-^(lRT&qZd_3t zhbQH=BR{!vC`Hg6a0<7?&V#5Yw2{CU{SFUy-pGa7f@Y7&yS~2B&owpUh)< zm`ud=)rDVAB9&f#-<>g!f*&Afr5J^yZ4%$-qJk~{P+c#SHIa~=kZ>15>ZgPk*!s)wI~t2+#P zRZeVdORU3)kri!R7Fgl^0FFR$zgn6dk*Z)VqeC5m0zCkR06>!PVMc%e7;s!0?SKG# z6*DHVq$ed^NnHd`KIgY@8^Khx0=pjQ^JsBp&07x1H7z9GxpPmHHFf{W6DMrKn-voe z;|fccT+YmcFY&_kum@uOq^0b;lEY(5uUeut19Z@23!Hihp~9x)sCS@6=)=cj0n8dA z&U#o`^oNfA7s)A~*|kvVaiJcpv!(*h!qJxb@Q+y>9J=v4AoVK0?UFq z9YAIRZdU^S`#dX3`|5wiQl8w5rsJ}&fhoz>e|a-Si=9ef>~eNe#ILB@yYBx7@M;?0 z2HC#KoYeo(a=_ElEHGHAnGvir(EyTi`da5nIL1Wc`|*xQ>Xl|S4+MX!?BlewP>?Nf z9q4ww2Ag=xd#$un{=zG6pzk4mTLVLWvFJ{t#hF-d^hDWiB%qcEND7xw6*b(RiVr-Z zqIw8v^ZRF~nL{YnK|7~;<`pGZ>L3L8H*VaZYwd-r2#DF4Jg?9?L3h60T12ISiCOy? zXwFwYksf*_JVcu|Z`9*5c(`AQwFt32DWaX?oZS$rXin1yY?I6Ja`HiyDI(VA3;D^N zo}O|v(*PFSoINxMp8ER5B$T+bvu){9XS9|7H;La8&~A2bGSdWu9vQG{HM5RogH*W;~O9(ye>8 z+7L`j{z?__?fYJ- z0{CP*@me)^B}(;J?npbizn0rgd`_f&m*}v95$5kQcg9$(zZNA+0Z&iV*j%sxqd?h$ z0!4uQ2lNB2PYbA~Q)FIIZ;~E7$0Xb=X3#>~K$4Lf9*lidqQC*`NpZ|k*T!F+zd+%x zdykpD#|0Ma!MFxH#SMx&j|iG0*$w4q`dp=c%Zr&(cf&hFYC4v#{fs|X<~V#*>Z}i; zaBZV%xW@t&=^KtsK;PuyCjdJk-bzc2;q>FIxd_`ne^R{|Qu*bF44 z^o>>=q5VW(I9Zpu>lO{E!^sY-L*q@o5c-d6FQ4imr%=l>J{7 zFp0X}0 zJx19aZt3H-lg%&b%Z}_futfS1Eb+EziibX}3M@O?`4MqZHR7cRuoA$SpEUVB{tYx* z+p>s`JQN=jkKmP)QOm(m?P;b}!{=Y4vVQnGSzf+YWvR(yM5(^ceiL(pUTg#*m3y*w zU7rq`os?h;?uq**1wK%_^oyR$<1e{lOVLrke@0_9z(W0v2}d4h(xCLt`m;yOk@X;e zCo{Yryt9M`0}+7yX!fI+TkV#2=gzv2BpMF(+B|`z2lyBrOn`p9$HB|96lroUa$q&b zNe6|Jyf_{@3$$7GT=+wBrH11h&>H;@Te%p)i)#9dhSU4ttttj}BTeoHx=q+8W&)I= zSKn~C6DGa4P~pF}6+iRe5c)LE6z^Eu_P!~TCZ|dt?TQ2^A`sddSXo;OuK_tC5`tg@C(*uxt6 z+MR9;$DL0PPaU!!X(E@Voa$DGm2r_*dyoBzQ`>14TEzwfAb=-D6&KuxGazV*it7Ch z^eprpg`_E5^`Z|Y8ldElIx2C1ZH7Zmd(0MERmHF29J&Rhd)1Ld0{zl;w||m8c&C#&51BE(h+)LSlz!wjRmH(10PIn^Y-( zObC&#C+UxpenkT{Xv!}T-U~%V_vPDAkbJV*40(^i-Sps~r=R(EaH+)x8y*Nt-L-Wg zur(NC#Wi1HxA-Zt$a2pp-f4%~BEg;Z{;*`g35mH@hIK*i2$P5L`J|5PLsq=-LiXbb zXZjnlM@X<7jMoH&ZwJHrWHLw4%X|WaB`#%(IEb~&bV_w!1HS}~ za@Y#wT@b9O2+9^CjRfiZ(MkiA)>>Dsc z7<=S=xhxtfGvL7&)1%ZrN$WrJ7g|;Gd7JV7OU+~2Ovo{2#1Xo3}DT_PVi3N}83qsf;mQ zt>bUnF0p`%+j;oxq@av4HdbL*ULZ1UtQo>8pb6QDY}9D3-v?Gy@Hc z$%2%nnyr~$u3eq;Xg>JP4wrdI;!+skQ?=ypgFcd10#w1R2PKt5fv*bRe{rogvhyvP zXl~IT;faBAcdk~zw(L!sjJGN%Qp&Foe%Nvj_ezH4iX3+kjxfo6HLq@BA-(VBO&ke4 zx$9SLwUU=>{UU+5f&DD2LplETxQ6<3$^n3U4VgY$(l=N#B?GC{aNcTW^ACEclX0O} zjY^|}`c(R8P0UYJ2Y@}+7fDg>8VCPPVdR$og-6Qm>N79oB7M4|pd&fhsBX0=ee2ll zfKxgv?}3rJX1F5yQ~7#5eaX6L(?Tlk+%8`-=+IwaX{sO0_IuQZ+xHas4akFpCkk4} z6HJiPsj^)PnLvddd>;>Zi9bjBo%NQ7?Sc7clsyDbb>#D&;G;m=f&y)T{7sY**6CCj z_;f!lgmh@>#m0*S-LK6hGFt;c1?>V zBS8oEoMqi;dYzANG}lXVRB1RPqx{I~MagIh>4&GAmk8A=$}Hx)++IYD%HJD-r)gt! zVL5NZL|Wgx7?Bws2-$bhHfv=begsR|Z3bha#1>yr96&wwXdWKxn_j~mf3A)5hH z34PI1!-Z{&?cd&*mZgV@6-F)M1@mc|R!a~*m;TG5+HKgFQy~HEIqrWJvTPw~oc=65 zDsO|>uY6j`@>SoNN0)x>Wk9igo4*Hw`?sGGyP9yIye8#tlE}y#!o#;|Mi-$?onu!J z!MDocYzDp2CvpcQ^Y!Pfk%J<6mZ0V004gnK;m@$F4?d-q63kR z-ye_)`Nee6Mu2=|f}0{5>P{Z?&kSe0USVa@ES=)U2F)^hDKR=_3&fXgVSU;V8IC?e zG!G>v-DZ;>m+=eRZk4c|!B*c;ZJ|-_cs&k-yDS0T%B|iTkeuRAR*LJr1Y7q_35d

QnSqnK-OztB&_ZomwkV%1#jL{D*+O5|rw|evF*oTWjK<&O6tH5w*;u*>U8SR_Tk5hp*YMcQ7w50j$3F zB)4r#4sg;l=vvr*K1fB?1H%!In9RAw4L$fcxBMW;+L6&>cWWIyY!AZodU$u#zjsYW zd~E;TA&-DY9Km}2^}k-ICNza$z2t%57xN4J8aNWE8iJ)Kz*>av7xjH5V7$^{-k^aS zO0rNL0pH25-*>5t4CasP6Hf91S2W^;h9{~rxp)2*w7Y5+AN7g)ma>}@`k}xmekV7* zer)_HO${2PKWGKRMf)~Pj%n*0dAqV@K$Ok%JxMM;fw($eC!pZEP`I;!j!^q@Xr|*y zb9B3SUC5aJa>Y(q6;~QmJ}w=L>cFJx?=na=BP5Vb@J#xksr9N4rgNSV`@yul{q=9g$qXq=hvalk+!*L#8C@OF>(zH zJAW&67Sc`vo9w=5O+TRcvf6S;Q~lX)Lg4dVG;4w6Pa?aKN%vf;mUo|I-T8Ii2=wOU z-)dA{62|PT`p{tn+k&vw7`3I(ZtA@2TiEQ)ql+08&9qQ7*= z72hIi48pQVSEuI={c+YBdP@D9%}9gfl?tG4wonwb22#M=~@6E59GvO*Vp*G zA)~qks9KldZv`{&4B1W2#CK*D8dcVZCsL$EW0UPsp0b{+T@b!lV;MNEWgDz-gqa8` zy-TRoos_Hpo1|4`BRsg?qCRop^Do^)VX6a(lk}z-xW>cZy zRe6R$83Z7F*ltx8a;aH(YaW_Co_?;QS5-EY`2+3q!#!adUrb4*ym_^jqmHe1dTtoe`_nPd|Lgp_b*V+w{i>eA$2jCL-Zx8 zlKa|I!#;;{x-avaxwkLkzij+(90C~yud)~6_@9Uh8hgc!Dh|P{H~ON!0DZSlr(Mla z7H8H$&cR${dAGgL-&;lF=z={wnUn@^;v{js_%?%HrQ!m-ZSx~M>Czzc1pN~0obU$1 z^A7z}*`^@JOj(UAS=pUgdxGT4_sYD`8=DObQ0m+zQtCn=n{CNTm_-+1 zrli;r6R=Gz^9yD!9L(ZCCof@9nHvvFje#dWSwt)dF~BqYy`v{{YtyfE74L_YnLBN* z*Ks;>@l(%sSWRI=p4iGoxP~*J&L!ZKW=EBlr9d&_C(N*wfx^6~9HTw7ZM#P1b&@B1 zA3wiy?Lw!eTNpwGR=z_YDZ2{6XOwup8GJqtbAcp`iUNaG5eRUMPue}NJ5Op6*H6+mzv?UNl1 z-;4QMK`sE~;p6Zg~gBQ`TqJi>40-9yU_;{I7)%Lgd?Zn(Xe{g2$#XN$SuWwEm) zb;SY8e^yofjc&@m`wqQ>mcOP$n*i5ez%&Gz~zhvLi$n6hd{$^9nmMMZsVB$lRr;y?!hc(WL`;&x9c;wTn%+h zm6eQm$OtGO_XXAHGLxI~*gOiZLA+B*E_?By9+DDfd|p&%Ht7?4xb{uh;vY#%sriNo zVEZrjw`$S4o7g&JL^8z;d7V(GqBAdfU$;yQb77reM?3jit z(Nf7Wk0Dvc3^GWITm2#Ev*%*@C#hlKd4DcldLyd1__X3(jZ;2k9?aHb>q0(HV;#qz zIckcLyf7H2!0o`aq$)bng{bqK6N^vHNH6T_;4(i#paHov*JkbkDvTB|MIs6-n-0(AOC3kQ%UtV3L<&U&tg<_Qi;NVQ zWM~Arr2}F}VRCq`-_;eSZ<~h?&4opg9}Rr1Lz85I?(O29?H$&5-Q@4HH4A#qrFKbp ze?pv>V*ZhrjiyVzSyb)VB}wKA)y%lu0Tx_eVXvKRV6cgCl)F+o_zS%>jLagrR9kS= z!Z0kgdAdWxz-*>`D^QqufhbT(O-FGX?tL(!(6Gp}y4j#lz3yy0y$t((B@q}D`FKI6 zl^OL5+Tx*Y8h%y|=pJNYBgr6T7@2&xym7Zz0vNm}z6)UMaj@F$^t>;5M}fIOqoBC5 z^Z{%(0`$vlyDiaPdS>uXbA?q6@P@jKaO;4q5#P!RnsbY)zZ?7hP3u9kVce7O@RPPz zwh6KK3e%zSlG=Pn3^=(Lqt>QOPiZFSK!dP$=d!&5a!PB}ttcvF8e|47CXwF!;30j$ z0x3Zi`Ht_C;@i2eus8Tv#kc&%(%tm8xokMwG77VQt||ywp9Jr(fyS9X+1{& zf>BsGq-UA9m-xHqhpsks*2i^Sx&m}t(M^P_uRg9ugCRCc${W0*$c3#>kI2#WpaDEGdChNe$8;Ec&$tIN1r`eSjj|;UOd# z+SZPt_AyPbl9zRgGL2`?^vcEkX-U-#jA8kn0zbUkhYGf9?ds)J)Nn5GgVCs&7N9s9EyXdkZ@h`zGAdg)4D?%xRkr!M7qxE;z$#D_s}{flIk$PQlKP{SoFb`sC30b-|rDjH{N;pnG%%`Lp{xW?^h zkL~+|$hPp?rjz{3&mwjt5`itzbLv>w-I_rOvP%jPod1wy3<9f4mjS4}XBfh5l0}w` zx3yyUMhWglqG2*ff0Wejv@9gkoYPquf`5UyU1 z`eDdwOxszz{ciI`-B>zi3$Ze;aXJlkIBU`v<9K@mUm!rY>|G4_o#ZxM0KDcb-7(^Mo zim>&EO39#P@Q64Qikuy)G`N-^7K@j*kJc<^p#Lnn&5N9TI*u^o32XOC6LDL+>0yD2x5+_vv=Tw~b`&rX zcB;3Yh@sUg4iWyF= ztx_SvHVjWKb#GKdVB6@S(%C^TAJ8kX(gWAJq^w7ADuQw69gQWUHgNT5gFej+3lgyL z5L=Z6_}D4RR^yq|<||tupE{F2Vm>U~xygI&A~vgcjbWN&hTKh=1zkzCf~HC=REIH( zk*~XWN-A?Gf0~6SHTNYNTqrq$s%D!Y z6?XU3$;TP}kw)_ShHrHb>-SuWJSxYlTY6q(GW*hZYqAyB-SWL2D2^_3VF4pG^qq>1 zV?HT{HA57ZA7ExdN_3prrpvD{p=;P*0dT9zZA*^!Co|FRBK@9?vFM$?Py?NWveH0o z6ACa^TS3VL_;4F2(mB`TTFctNOwk(M5d} z!Bz;45x8gMB&`Ozi9@5t8l>0D(b>o+AT&1RtG%rr6GA~Na5Uwy(&MduJAW24F}{oI zR7(z634T?B<>60+z2`fIVa$NXCKpmPgip~b^>82Kg=*+8dBiP%=vpbgj3 zIB5Jr0V|o$xaqjQe@+Gr1Nw(u=WAxZa(j~A?F8d|)T4e^=RO1R218}@Ag(J79E-cP}6pc4L)1#XvFD!lW9VRS9)c>mrEUXm zjFs|Y3S{nOKDrVLrq&*GjT#;MbxkYtuV>ZJ(cAs3^&}zl$oe2DE}1~$x?gG3aaN{} zk6u2@4$G;#@Yuu*ST6|itrY~W&9z|=lIg@TZ%vtPa&7lLMz3Jky?rcAbnPGf4n2S6 z-5Ozy5YtunUsUP`NQUww1B>iJXvliEh`6*)0Pm=u%uWv2I|Z6=yz6Z}mlLcMgugHC z_>35jeHA7}k3gR`J5Z0QsB?{L)&$<_v40toWm z<-8p-Z#qg(Pk~`qa{HYvcJ!b;*87EpE35VsiHN8d+wX0=o4o~rG!^eDpL7Q@$pA3g ztQNbDYQbu%oEv}dl=6Sgn_PpK#F}D_{K|`h&P)l_;qlJkCwrQTj;F+yOhVEW4RRsu zbHs7C*XX_xqXEu%8U@7P*{wjAvA(_vOjMn35xGoB@loM`)20;o)-=K)0 z@bUNp7$qcz``Y+BHEqdU=-8~{_=FIH6i9T$ROU+qqv$@Z?;1k;we0)!NVU{Uc#VSQ z0)g$-*{ENNTMf^$q@>l@gh-~bd>S(Nj&HOcGHBm7evhM1z)^R{7CMW;bNvU5PM1E; zESiY^)aA2MgwXuJ4tBOBk|l>1!(4;XeH#M9h>!|3x;=&H>V~*i{3A>-tNnomLWX*G zJhNLBXRs!s3H5P*N#0Z)_kkyJdUfw#^9zzEk^V_+WUwGa;lr)aYD()BqpGCSUEvDB zJk8~WKCgA%>S;^+TP}_+RXx(q>l2l?!0hk0?DFR#{&nH#^6{WzCh*I_JY;8{f4o0^ z4{G=)crk^;{D~{%q%lm)!KcPiThhFUoD$?Qisyd3>{z+z zHfXI>Kh(E}cQ2UomUkL#k6AX1xaa>K%yNFmrjc?nj#>Dq^CXFNCk0V;W);Rg40wZ# z8e_j>e*|;t43DROCQ_r+X_LC8O8#H{8dSjs$p}We@K5ac9#al`7vm;A4}G^liF%!g z8$HI+;TMDO-*#Yw>5xqReBvm8tln~Bm2V;ysbb!|NCHaVpzzYF1L~r}sh*1B+-)qe zB{Y`A5Nc*m*Wd&nCao*zb7hdU&%a8ND75<1AurKYjJz6CWL)FU_#fCvyq$@*hQ03o z#=^l}_RE#YADG;!03*h0nM3-TqG)*af_!v^=)79cF(rr8>Bh|FN=*AGXz!u?hM+kl zs^!H;(NsbAQwe)~%dWdFfV4WSp__#Q~$0>;w%`p!fj0Dke?L7#DsK_MZ97JA0DR4C^IAD z2yW#Q)Tl5zZaY9JXKbF_WU$HZ4$&QvrnGC)bw}JF1jcx28|-zy#o!YC`!ZveowbP8 z9s*>H796h6E*=T3qn9b)5oVSKo-k*;>+BeYW0*K$f;KjAbI^P2&*vhaIO3_3+c$PiHAoId<13WgY$m&*=JibF8xR24io zMZ01=EEcz~Rmvz$!uDw8mk%x%KaUq8CWGEg>YL}v3yK|&c--@&U>HG%($s~q|HuAcJBqE@EZ9ZY|{~AA1U{B+sH8j+20O*W+0>qiz8lBXRw%UqW z6~Xl99~)w!+PEB9c5Sv4E=dgk1`J3C)9pSc|CM{RMb_T?aEb)k=7h14J6Kce85pp3 z_kh&-a^jeXT8{=zh2ral{*-330FV7C{tyUq34JsPsNHDlsz!I3IQ|?{l96P%8AV1f znW0kX1xo3j5iFk2B{rgwoD-XkfW{D9zJ4?udG^a~1BvV)_X=XY!1SEP@Uf@4Q~Vuz zf(6;cp&rC&ZjY#a4*IuKbbd*aaHY|Sp|EJwPm4wOIlxJcA}KIk@=Hc*1$-rFvP5?O z(i9xdy5nJtw}6o$VZ1OStl6`D-C`PGTyzq3^#y`+Rba`Fl4L( z(A_Dxynz%mMRa#=6`-XAt3HbBNz%F)nj=E_{sZoTlU+3Ks<{o7AbrU)YKFGqiS$^5 z&uTj4r2J#a3XQfo z((ubF^;1G${gLw7OJQZ$L-2t}r|?!CU}_8WiD-5j#|dr}WSmK#C_zI0Hxdpy->Z+& zU9;LGln&L-0fjv`wE-Ix`+X2X=oh>vzgZ4cw#)c~mlB{?cvq=}wYE_sfN#E9=-XPm za8HW+lHy$^)%5o>wtmsv>}qG@zzA4U$-L4tcLM#ZP{MXDD@8tOUn&2XXyO5dZehL6YsahQe! zjDvedX#fy!hktU^*=Wg0VY1JKzg2n*78~&hG;8gs^ zuhi>4;bSX9uqraEx`P$y^(PK07XUTSlvBW#7LY~Vf&W86j67y4Xxq`@w3R~sbNYX09rE#hi817<7SgR)0ut%*FzX)Y$=D@K%Eu$ ztsbO_Pt*_aE;$yMhuM9?J_iK?jM9S>_4>qmMI-nlItc&e!&d7hEL_HLu25~O4S11Y zCxE$~HQ6@rQil-E>49&5x8JMfJ&iTh*7=CIX%kz zIw=0qs5g-#hc|DKpl~0b6!%2(h@R|VA>WzHFB^9@$<6~t^79>#wzbqlCyfYVBJ5gy z<@qHKS=RS$ye<~H7alB}VQ4c{$ZsK3l+_|x11BLlfbf27SW$X`(w=C<%rtWaXleY&^>eQbWj5jT z$H@hiSdru|#YF17oNU-PTDI!gp0+7XEtxxyyY5WRD{Xp7Z>eq-H8_J93JiAfOvWm~ zS4(>+c2m(edwvU9MZgUaz#!9$jfs_a+LUTv6l~5|^$PI;m$sa})^usku=hU!kQHwo0 z;zpds33XekzzBs%Fl?wE2p)H-4(6#(LD+`VdNM5;cKsENMAdOx2K7J zxs6sCLG;`6i@+D3fv5N+F9|{gxZWGIlB&ax*9Kzq7{%Qi{#RAr`yRP2HQssbo+K$> zRQg*L-ph>m50iVMECYO8xPWWT2WP)sg_FpJd_Y3O{@~7OD}qhjr;+4cH^-m4AID!# zx}mff(}aHeTOQJ;MX~&5lH_FKA%G%l%J__D7PDEb0P{N_zwJJzAgvLz&8DIw6$WDs zZ3-?l83auRp)&XhDdr;1&kkD~qrE!NZ>t$Z`~oikHOPAb-HfVh(oM`x>S9XSyCSl4 z3K9s`o%9cmiLduDzSLY7=^y~4c_CMM(A~26n2AYrVM$)bR{`I)1Jiv-jF;$O67!)1 zqozQt7)~T;q99L29HiW4QEhaELvB3qK%dbjQR-p47+a#w;y^j9&i3$g$<1!6hJDmb z{bnRlxBtxkb$MD_m9c42CGpaaoOoE6J^!!AkzSONFYzgqz40TU_%yd>8kJ4^I4CQy zGzxm!ki%w1R^_HYJ>MR(!37My3-Q=^f7z&4v=n->O&#LogIYu8>3&M~5HWP!A|o#x zsoMn+kHwJ(NuJ>?tPaS*?;fOI$1t89EG&;%m_X&ue7I4nWmsyND^KuT$}_BU^u2}7 zi*I1K{*Pw%H*exOX5Uc+?Q&{EH>l(3$X-wxwvFzY4vi*;Pbm3`v_ z`=VF>N)f=M*oqeD2_WrVLHn`fl|?C4PXBA;C{$gx^H5Wz(x^QHEprkc^$a>sTA!U2 zj%l+`9Ll3>T4-n~57}~O{jB%72=wyUfh8iQtC37sEt|oi09geA?mBsdg`JQDu0qod z;)82vh_!~%JT4D#)Eo*TkKHpv*d^tmVbf+8P+a8KFL3fj;)*Rf;N@c*%~{GfJx7@d z(;QyAQ8Th$M7708*h8b27lif@hfAlfk& ziEM$G6BJ@WbK=|t`7MPi^o&vnNvuE zgc0o0%r;o>zJ0G`l?l;qx-R|SgfJST2CkXSX$+L%1%(?+@zxlB`ll}k8OFPBAXE7f zS)Mz!(OBec;Vv|)BlxH~$ZeI{Lq<*%BcB?kYNoJbiebtxPGFT>uO>SfQR5Sqc8BAM8CJ?Oa)kuhwm{6mDX6=qi{I7 z8N##6h$-5M3~8g$f8~2cSV79ew@P8bZlwN6@l^?4)tcI9Dm=&-nrUi;BnRjSkgETw z;ZhFxXfUZGqn@V~^zeg2h@S1rQIx+s^VW=sETy)owyS!n?l*Q8KmX@w7%kFfY;(xa z)%OtXJ^8D(G_m>(4I@~65ZTyt7Cj?ahZI19HJmU5gF#lSHq2)(c?n5H%cTyQ-g%gR z0JgRNTX+)@FL3nt!G`SFu$6dlu$IBbstc&)B^o5)-k&tEsMV=YBTddRCiATAe$K9& z_4jC%1nrz+>+Q#jyY$#UK*UWwP;1q0Q*+}a6F>&x*?(qKEO!yN_9=}LOupSQi1&}g z2Nx#9b%q)GZDu5jm1{8zHaLwRo#CCSEyZ?40Dt52Igfoy+Am!r7A3h2Mfoa@`*o2z z0C+|>#`O|;O;SZLb8j>5$Q)A7CfjB4a%-J%@Que)aze7OzY5*MutcCW`F@R`qh4j6g z$=3zl@O$ax<96BQ|B`9wY}YW*rFOksDhNHF7~6N~Rv256KDU$s5AMzzBbu~3TYVMqC{_B} z+>vt2&RnHA`ypqhAS);IAk6xK9^f0Dw*()_gcCS;&@=lpa^e2U*xB_RQ-d^c|X!KI~jptG) z_HjeHUtGMoOd%qhr`O{ldc1ZTAk&J35nT^|`coG6nHqRN%i(4FsYCxcYuo07Wu@1k zF80;`nKBAY$y`+Pqd?n&0=HlXG zB+w?E)jC7OW$r zhM|CDQ4|qK)A}qiI0lPpxo%0y`ahI_aTcAp$87z{n*V^}UTju$k!Ygyo^U*q@Cvb+pM8Ts$|A7L-0EPfSlJEgQfB-0VhE@eV{o?rm z0D7H0>q2C=%^DT=Q}_B!R4XiPXfXcS;OR{#@@1w(_B*Rw4YIT9sb5)JeDYUR9ZrMa zNIsGff#x1(+6Mc==RnFdhAA&n0)8J)AP*XFVF$V~oqXTp+^E8@Cg|nJhZNl8^y8L2 zr($dut)z-x!m*87fIJS5x4?JDjAC=#f*}({)5ZlECNwL6LEBhNfRo~BsRH5HlKG4! zdEa)J7uK+-oDmDc=^$-fo660-*0{dYT-%a19##(xYvS#nhpKQ_d6Pz1N*wq~QV7{1 zyeRox$}8%HG=UglnY|(&k9z{=Q9F?6U@nA*FEBi05&+rbjCrIl3lf&lX3mgPbIUIH zi$~!Wv?wswplmzH*?d8Wb%Ap^_YVaq`@p7Z9_|YniZz)Ws0Poi zQ8R$XQWc$fQN+}0Y?sdHf$_|x67V&Sble{1d76WfcyNbkB-TyR+^}W9Tt+G^>Tf1Z zDEAUx84oOw%X$T49EtXRFPqy(B|}(HNfh6kwMom@N-lHHD@23zPU`>w=O1n&%tDib zJKS_**RG45h=|^VAsHz+)j?0(N{(B_MuQR7k*@nN7ofNvDDa8oxUnp<${)6+%b9!h zI^rqa`N?FkK^#Y!GN{r4(^{m)#o*0S;PSI!ZBAFfu3}nDGQjB z#XN`F<#|l0N)=pvD`lqt4shpdr{4q{jeQsfVIZFC9fKOZtb2lj(maCBk>Tr~VoFZ;bQm0AJ*9qa&01epiY zI$Gk7f2s;R!b)c3%L?e^#t&)zxm;}I4YFWu0q`s4!pLL~V(&*>78J>fNaFvaPNIPV z_tZV7&<7T=lGSX@%<8L_->cc3nWA4?UL`wZUekHiJ=P4-aDj{;~ zG|X#nCoGGA<~L9ib$L0C-t;L&Drw>iw%=n@e_>jc{wBH4ZX6)eX_>j!#$qZKJ%BLs zSXP9U+l6M=*JQ8U%ES995h9uN+k}uC!W$*iy@shY?P4Xd+FHgv^ZUD10s6>SDQ9VD z)=kP-Gc)%zha$ZO*jN@qG|^Qr7ZH=-W*ja+ZNa1CG9Li6u|J{$UZor|k6l1z>MmDB z{EBYUx`(V2vH``h-}Y!D#9BS?2ok;A5bT5lE|DCG9JcY|Y!VF&bl>AL)<0uKf%iDQ_QqdY^V87d*^M&D)gDLrA;_$?22g zQZQw!mnUO9u0lGT*vcKl=AL4pOg3;#P{29IWC3VQ=R49bHKT^}R5)lQDs_iiGPs@& zv$Z5ds8nx!lDD~-3&UGlS;h29g{U&Cd6TcFNfl5fBMMkZjIuT_)|iYvdnxrhq-?br zf9zUJgn&S^KFaxIb87RJ@e_D%W>&5dQ@k3$8-$qG&$`_gbM{eIx)ryO{Xs)^*P94z z#j;?1hT#UaNp_2qK$f-h$c8iPMtm$fU8iMlr&&*F7IDo?-KFkso^VozVC|IGl${kgHbvC7$Do5Bg{&q{o zHT%@6CSjzms1vbRs@5oJZC-do1he&{nmfn#&2Ccj2o?e7uTFj_g}FEC4pFz-`gALY z(R4&}cnPJIl&~_`h@CCpY~S)qBoE~pAk-}%?a(`gs5oP9*anD3PXEUw2K*oIWUfTW z>-KrK*A+J{o!LxtwxN^WWK|l^#F!t@Mcx%sjj2HD%=}+pfH;Qyo&c=BGc`gJxHjM3 zG_-a{nR^Jf1gqrp&y%=c+2o#iZ)}eP%mDjFo}yYBV8UOSRQNc8aJx7=VOs2T;M;dYM`dTgGy8$sigvXP1N#A& ztqfv;Yj&Vzi^gg?ev~jcuxfC-LB=K4?^`UDETjgw+(R;wFfcH(OsV|7omY16g5S+$#2{cpUal zBtf{(#I|@b7h!61;+!g0{Ab|7LK-SK`vmk=BS!kvJD@JL`fd_`_khbs;iaK$+8BNe zbO>ckjKg@Dr}fzqyiL!`UGaTwFN;UN_H){Li}q%{yHn3ADC7KpQF=(qeF456*2>bk z%=+3$;qW%{DJy&=6^_tZe??kS3DNLJ{{?9HfcI$Oo~{{P!^-o$qI4+XyPch0d4o4i zirqg>vAy3W>W?Mt^R+rL)Y$y6aauwi*{TFSFbY9uG)`J&}R2$l`X4K$k9R>1sbf}4}gG|+1Jy17k6x~Hh8(->WVKjNsKB16+muay<_@kd*>}_Pn+(ud0?ABV zyz2z#BkyLo!d4+sQ|RBU&R=XI!MQ`AG@ARbZ7>>g4an+wvL`3BBr!>mJV@{2G91<} zZ!Et&Tyc|0yB&DEL~NX_J8L1Gv|MQUnGUL>_g)CWG`NO>y3SvO`*GE ztFB8$j?cF;i!v@oZL*X@!K&2;CEl+too4O>_;Zgf2yxB35AN?eF$+prLhNO8;tZbW zCGJ`7q6Q8)!rtlz^CrO*(cRKlZh062V*NPPf$mj@Q-0cy6ohLt^K1g6>+iK9(DOr1 z-p1Wz^Y_8IAmiiaO7X7!NyA(1!Q;QN!3x`tiK%ww42=F59g{&XDnGS25(br!Ck&;v ziI6#rKWWsAMTU9YEDL^s_k)YIURQgb0hC89P^o{L0)XnA|B?kb7{D51z9!uKd3`Uf zcyI>ZsyIS+C7oTp6#3lx^<7wXf<=V$e+ZzKr*Bqlo-qWCe@4vKiamE7(w-?Z0CM|o z(UARIRrIt`@;jpoXg(X?-hHA((k_66vaQ~1o7go;q2$lf`E$SXIA*Y7BwMk{e3c{z&M|jOw$`9e$Z;1| zT;btlj;XQnG0=s+JsJOHZjm;wEq~zU)p5k`Za^Rh6#xkISFeN#misnqe5G5F=g=&A zsuQwi|5p$VmnfqB`&Bi8#mj3$L(=BGo&mC^k}WJlx1;+(L&|xjQIg5ghv8s@7J>LF zO@+#XE(f^>R(!#hbr#A}de(3E9;Z}r)Q%gS!rcFJ)=73p$bc~W7a5>D+vff+!t)4m zQ2si>S;o9B;ff63QX$thd(Gme<&B)-s>RMXf^W@Z05TN%PS~4L|(N$RKhyt&C7s-zd4ZKpWSL zsKb|7!>Yup+g}{_h4qJ|M&7B(6Kos=LrI&{{^S%am{R+g87|ObGNAh@b*#7bO5PFH zi75Dzb2nldf<9aTsz6o0mD3}CgzLB`@=G?HlEZfsow7s)Hp&114(bG%D$ITE4qjW@ zdv!NaMIvnJnbbU|wx~lTv4`FozMCbwhC!A&#?w%LFK~1L_ns^Gm>1?QM}@TF&10!f zs683kxI-u+Ftm{)cAEHrVrk_O{?$ZwkkP}bb-HyjBaMED%X1>8k}0@QH%EV8N3itT zS@7+JRhkq+KPyXvps8)OAEdgeF6Ji!1LWP*=>Dybc~+P!ROzIY8;P?&^$A2aq9h7Z zKvP-SMD{}eRd9IuYk-W>mksyn%ZH1hT?!yQrusU%BcHNetzFMR&3u}z8dR9KY8M46 z6e#oFeo6!T6X^3chuP*A+Z+a3X~if^h?d)b-ve5@-KDgQf_==rtrsGDQwG+7z-XDi zkj5yC7c|x{A%^BE*o?x3P4&;rn^U^dIhCsD|8)#S1uLA?mDYaD;3Bbt9<|#iF1>^0 zczsp;uYhO{d%%l1yNC=zf;qZ@!&vKB(O;otaG~06J?cS%L0=R**ZO|yi3iTL5165F zfq7BLUr$_}geOsqFs)L9_JI=C-Oa*(2yA>As3`4i@XGiAH{lK>6@B5EDCABhz$A-iF1%|h3qOLdIymW!0OXTE=?ypttb-S6vsR|fi=!;9i@4p)i$cLLasQScdwH?+0WbM}r6 zCY9`@`D)tKkoZZLbocdK=zPn`&G)LO_p@7xv{}=DP!72`ubZ$67S9aBr^D8{9Bfh8 z=~mEQz})ny)g_VCruGpQy*MY+YTdQJ^xP1qEgSAYjX&dSFg@Z>)-wM}kjz><;-Z`} zthE`#vmU}UWxKGP{7I(*C&5Q8T0fjh-}5V5+`pc|RgXYJ8ZviM7L{Q9tRfVIgn2_m zJMPsF-4HeUWl^ck{{N*2p3s?8&6f-UK0qY5I6Hi>L6XAQI;L>3R1e5gQj5`}OGYeE z%}V5GC+D_W$=(-1YZ`#`E;;cs!KvEo4)%mHp>^Zq7>PsBZ{I5rCK##A(rbZdsV%3) z`H{PblbG9hRP9s)OC=XW(v`yIQFEXY*MeEIsd5$XZW1d(k_+E@JMUa zY;W(3rtdYe3EbtAdkO=?5`xavvZ|KCbY3F_SpnlSL8Vcy^>~c2L_m zBAUnRt0Ad!mSIRo*J5h5xh?gY5_o@+#YX(dad}}J-j2;(g^afP$xd_?obLKgg`mpF zjT-aW0HZ+Jf&%$~{4h9K9pB9cUf_K-<9bW_(QuGVq|Dr0#Wi@;xWLfc``^qEY|fY|JCaBu9ogvlEl@l$9GGU@Tuw|9TD*@#$lFN z{j#1P2Dvvq@tt~%Lk=U&07QP5uDPHXp!25EZJBqR#GfliN(mbI7(MZZo9N{epDa%R zy`bw4ucvr-5~%dWDm6aM=bdu$I7(JgoISzd@Pqw++N86O!KDRrqksrW+8lyoIfdd5qh5$g4@BvH!02FY|-~a%4+5lX>rON`XXVmvo zrd}Uxw%^Xs#{_x#WqR$uly|{P7uW`z!#boY-9PE4hqIP{DqO|BbzA@Yds-GEG zkBo7x%hc)c$PPNXa*%SCvX6eDLSExDo(nX;@NGh17Q2+OWnK-`P919a9`Gkj?1Dgv zEi>b|?B#gT$<{7TnM>MWcNqmyuP{oc28i=pQh~{n{9%e;NJU%&2+zLe`R26m&HL|6 zb*9xRoTPDIxKaM`VD*EA8`l~0G8lDssW;gjUwNLZ@>pV{K-+=?4S@VGtJ4?#JGFTh zL7y9QG5!Q~fY6)HU5p#usWLtvZ8lr(E1^79IWjg!%*^;4@oWq8v;`XV&Y@)xYjHNea$mGZ*2X{Usl~FNI5J>io z0yRu>r9#ev?VGb4Z~2mmi%`jxdqE6daxOU25)6?y08~5ab=ue)0zkmlv-dY{=<1~; z^d>Oq&5};2FYAks_!sUtS}4>MzoPOIj?l(f^mf>(FFH02E)c4cuA=e3x&%>_oE`oQ z!o+04m!=X;AHKjs=a8dK(18Od0EPfSlJJo^004A%dpn8+0J$?QMCsNBEzCP{MqZRW z_r-r-2xb@nf8;RuLS(fV1NY z<*ZQX@yOZ9`f75Q2tWir*BR~e9C!1^5g3(E3$2~mGYu93X2UqLLy)CxAieP z1|lUaudid|k&jxfKynFJ6Ej06Ho|;x=56tu=w!Y$al5hb1?~$hi|Vfv604L7e~j#5PoumXxiV zOUZ1{K!nD9q{Ocq%;(}IFENOS^?WTEe<|*3NQ9 znYkH_N@lF&)h6HTSrsxCM+9U}p%D1`GS5nd_(Ji)iu?g?tHZ4sTy)bfocp7Vogk6C zBaymVGl7NbRZIc7zY2NU%w*N?I$Ax|b!|%KyX5R;T zJ@82$NO9WHkxf>oFAIUs!gCE1zcV*XqfXy9n;P`I^+yU3XY)Ey`M%gy(Kgr|T#@5V z`05c}=pLn)kKqv3k$9n7as*xC+x5(h41E$?w7~-uS}=dqT%hhg_$2ywrDG43T3kPF(*xN?kTA0*sa5QTv0EPR_S^p}6Z6X{HENj|8vPE({ibc+*4i zP3i8n{}gd;uOCze8h^+5MQG)J6qfg@#N}=QvS{&V-3lk3%^PWP0q8b+ZjgXX94NAx z(~}oagSN1WxeZQ~jB%Cy@=sJJ`93GJ$H8iNRs9=`^PQ^R2u4fHMm7}Iy(+AXg<(r{ z4(G+^mLdbTR15;3;R2K(z-;jxO$V!5HRPEaJFB^tPHNbBug{yKnbO-=aK7K;=MpVM zFLm4{Jh8+r?^Wp9>GY-^cwg*GlIAEd-ffM^wG_|g`KWqa7prW-y*#Q6;m2?9Mmnr= zt08stvA$+7ak$o`vt#sxVl?mDoSi!wRBTUD2&kb2QQ}8b|H_(#8b=0h zKCqoNmolt3RV`fl$zU}Y9D+j>V0Ts1mf}M7b%g(U`EG}5JVcw&qxM7@bf%i**8jcW zI&^VD>OIx%?{KrWb_gRNl6?Q*U;mk9s9(>2UkTaE@p#y-hKp(Fe-hf|LxRC(5v7gV zF>{^@lmTCODWROz-Ir=rXG=XRvzlyqLpp0Iu>qIR92&mBqz~H8Y=uZlK(1n?ywCyd zEa~72YmEsYH717;a{0s(#(lemlI>OO?&v4+l`fnO2=r(tN$F)~ED4qEH3?E74o?gH z-hI;NjnRPfGj;(sI1YE?bN>6s%q6|YP~rV-6`O#l_X%iGYxTsqkZu2@+VW0Hg8`9WLf6}` zkz9}!=VWVyo)5gRQ?f7AtE1IAf9Jz3=NpIGi_`3IGQrq~A)>*cb}g#RipWPmK9X9P z5j9#k&vdpQ&bJ{LaZ}yd!1R>ae*(_gz3#28GjQl}Nf3>kw{7j)nqQEw2bIZ0-aOt) z+b#dpxr)5kG8C?w8frq@Huo1Z+-zq}Yl8)5l$+>S87W}-`x#8_&O4P!E}A|g{<>0E z^#8AJk(pX#&-_Psv++`VroM7wR`T7Q_nVyZh~oWxbM2B4K?g|}gZ5}p$_Xhg1s~Mkp+`aW51bx&qG0vwr(pn4en1Q<%_C*M z6y$|#7d#F=VRIV%Z}`7{Zp48zrJP#e=y@L>5qq4l^03DJ38u89_}O_qSnZz&SHx_- zHPfW8N}x1A0|~WML8abhL$Y>~?t16}U=&2U2M9s}wDh102d^~0(}FxLwVbmwr|420)3%-+UT2Evm}h2k?x_NmOXfyQl+E=g~(QZB?FdZ4xCYsY(RZ1qPyr*02YCl1yyG!VcYM_`QeeP;*%X~)WFzWiqdE* z1FK2%U^S&6SMz1cME>h{&eaaO)+=~aK%Ju#VxNtf>7Y}OSg;&gjqB1yc3+>TA93`B zGun$Ze?D$!wK^RsEKiLX2r?r_!!K!1czJU zWr>(;0zUByzn<*IX9^GX3t$v{Gk61U3&0XEqN;0X;As-fJ!DG8!(^aDi!gya}*M?(F1;xJv|GOuU#QB+5^ufd~G&aPcL6=gdU@ zVopX*L;@)8RL+)z(+$v#tcSE9W91&jsLx2sGYyNd$Lx(twjQtdb@sEkCsZ6K&dSH; z(aD03R9}@6;DWcsGPt+eNB=AS?!eTI1V5psi z#=lFjO5N|pKUt4p0jD61G!(h`J|$nAeu($GOq9Ra(ob9T`XV=yn)}{=%my z<_w1~r)!puS>9!@k3WAxx<`5^RDXgOkEe#Q#CC@jKseYDARwjH?@z%sT91uw!VL730p`LxYBeYSJ?1#|MI~8>;~e;qnJ{06;0X?F4}xA zefrOn%eX7yH&_G%kB>16@M;oAY_RNM9aM?5E^^`xdf2`UTiPsgO6CDK*TL zi3{l%`qkhWheb{WbsNp3CfLfpTvG#SihO(us!zu z7biEJUnE?_Z-I7>?Gif=K8@SelBgCDGR&oGIpLahK!*@UeH8|Z{;4YkWsUNR_$J8` z2W^QVkzCadg@$ak2(uptEll*$j!uhg!WS6nKbS@H47nt{tP#lCc8>wz@8n1`QlKd& zg2F}(XB*LJ0iQy-@S*eygx+J$1zTbbJ=SY$$;JK5x^dijRx8N8#Yf#?z{gI_Br3}W z>e^2AZybzxDL-a>q1ZRN3AgXqXppBBu7}nOB@%Tn4n8E}G4GI^T#(|W3gvY(o?)rp zRI>{qjb3=&SC;h1OIYH04ZCVUE9;ylouS5q1+>mOcE;A`3ACx{iKfr_jzEeC5j(5f z4F6GV2s{hIwmFjmbAg+~th-NhXC>=X`1)BLVc`yCpo?FC&TSH*ZXaLqtP$cF3F|0M z=f3iZG#5|{9A1FK&nC+E`-J+6p!Eo@Kj|*1m=meAGbn#XSemO8dIxTT^mmm@!g~&Q zbhylGfuzXqkuy_!3-~ssN?|2>3(XyP1%hCHxMC@AzJ=rV2J@RCT|^c;O@gd1I<@(e znI?#>UuX-H>Il(L4BO?{0HZ+Jf&(>x`~VG_h)E_x-X$Atk(rRv@N8Mmk#&#jGzXvW zQGC$L#{g@ps%9k3v#t}+u53JKD){;^W!oaI z=e(%&AnxtL>bq_pjTV1|fSIdYWFKawkWme1(Tq^2&V^YSw)ZMRq^isjyT3`m)d3*TsO=`Ti$;)%(x21M2 zkvcbNjwgL=j8LVE-oJT5gvs~ejXV(p=-s3hexpF$f&)o_{4g^s(}=D44g3Q?UqDrk zc7E9;ax}nqTsF3ZVzNHoHw^jiGUXZb9>+ea_zfb5677X!6&h6QcJTu(99hdOI3gh= z0z)J!Ucr2cGA>cOjI-i$=^nguw5lU|;fu7QayR@t+-Vm-xy?dcF%uZ4!9IB{%Mnk&gcXSbXV&dxbG%X-Dgu{pG2M5U^qI zx^J|p0BbiM7ymQ?T=CpH8XhYee#{mP0Y^c%5~xvm>tgyN*IZfpL096G7e>Ou8-pzC z9y=Wl%|j%OjYgB2!nE8!uqfJzC{ltUhZgNLn0ykPoD;~S9gc*J1hqQ zan!cbM?s=e#qTD#1y-`i$RCb|iwCU|aG6~sF;lM8BRkX;{KVDJ5PK%LX!Mp=O#toG++xgtZQpTeDtocc1rVb^ z-GT#Mfcybf+bwm=LNNMG_bcP={+q;SxLTRQ{Y9=TmVEH{?R<&xDw zW^~b$b$yD&iG)5ER}^4?rRZt3?VN(IbG57B)sJMCSE=}X80`}|FF=S-#E)0R*EJ-> z_{uUVRfD=3ks~DrotUFYIDrFc0EPfSlJIdnfB-ah?^o9WO0+O9kqejrf4Z(tu7&S0 zG^+d)p1jh5BwHYp zi=hzKaZW<(LN3IO1?(@Q-;ENn_NYFfjRA|tVs0o=mPRkXYeOEfB|D)2v-P;SBQW8eNETVRQUs0HeunKo~RoDdo~m0*^?^K6!Q z(te1p^XHi^LEt$$Sg&eRMqRofT#1OvZ;Kljq%!e;n|1N4{^MI;tMR59Yal4PaC$@9 zvPKZd(a9O4D{lHBYA?&_aI&_WI9x*dy^sFXaF~kds>KSE0$Els(p!LUd>nFd9Z`;t z#Ze-vz30AK2vHNxQ-t^dH!s}9x(orr`xdK0GlFM%lnjCV!rU#$#N?zd1 zbje9Z(7KGwOh0BDTGtS=m#-SDd|s38SARLLi-Ojd6$_l5eACBxc_q%JPzog6>7n zOX(lIiwXy|GPEXPCADj|Kpr$L8BhbqtRI33x%t?R2swvgeX4PxAa_?|IbR}&4pnNO zaFsHOy8^5zqPwsQlDTc5+#^jsq8es=No5J41Upo^$|@%vFyKB++#5?jiN}RLOQ}F6G@JYuEZDujEvds zWtR*GG$?MbNZh3=>og>4g7N+nRPkR3%TSdrcyg-~gQ`?1BVMwPCGiwfuH~=00;aQ$ zk!qP&+ZipwCOVz)4Avl@5l&%=)K0}AO1)=ebcz*vhSTW9MC`*7j&=q`zEW9N9EDx& zLVvjRsiRJdg!N0q9xlL@*Bw37=KE645qXW#rrC54r6Z1TnzkDU#7I>brWolBSVN7@ ztalo<$1XBiV*L4>4ayV1DuQqTN;LkrJev&&-hP+??KeHzi4C{56 z_>LTed1y?k+&gz=!L;0Rk4LgSvsu1^09T_e@IyC}c7uFL}_e?&eJK4u-9#HU& z-lSQ<%2=2%&&u?+ve2;N44{!I3{vv=_em>8Lpq`GUM7VT`!A=v>D*@oj}b z@E&pm2i%wGa*JZBa-iOHD^V$lxUl!7Q3E~`_X7K9|4{{z4oUl`HzEqJr^VYXW~jms%)CPO6Eo zcPf~pxZy8-2Rv5~umoxyTIs`b+2w4|pHW@1Gqm@vqI%{q5ue3AH1Qy3S^6&WgFhf& zoLRoG-eM@xg2Zf`u^NB)>lAd;9g#?cPzXdiCP8K#*ci)~Yo|=m^A%2{DOEjsN}=Ww z8_ez{v8O@z;C4cS#P(p-QTyeoyIhrOpobQLFN0Q5855b3`Z#uzAWk<#SAxo^r6HV- znf$MY0iM=J&|9_0s@VyR46Q25u0Kj?kIXKk{Ev%BKE1t#gBdb~@c+@;v`WxnJi2D5A&lf6^G7&oA3*~);%sx0M zAY9V1yH$Hy-p>wXtcW_a{~$zv*d7sgd2T98jN|ty_h9SCaSgCD8N@kzy zPh`H}jZM^a?0^)aL$$SCH0SiKWMr>TB9@J4pAj?8&+Hdve*j)pUjmHpM}a9iBmYg? zNq5vpaW!v&aWd+XL3g>htIy?Ba)a z`aN(8Cgpy2sM$XvLydcARL0Nqji>gc^={g>7wWbf6g)SdYs4eLfTKX$f&+1Y{4PxK zJf)>FUhS7fU)x7pc6YnK^)KE@QdMSMu^ z_pV>(zX#eMxfu+5=z<7MszLush_|_w%SQlzMn|qR_o4W;;Pw777ETH43^0E?vXE-e7`2 zUjwHRI_kQ@AXp8MsCgSiT8XV*P2vRX>C`4w@ZSm~9fl1lfP1i*s2;T`w#&L~h0N#Q zbl|Bun<=TH2A`R`aR8HUPD5<@V*+EUbU|`=I8Fy`F8}>_9_F@^xJ?--Rpx)YH0OLi zc5Ry3Uc_V>qCT`tc*DOW4y~1+HGI_nxDAcNN(BdpSgr|;>8)nn8%MdYJCT`KR8;(i zTD8J!9W1@H9Zn9m%^#biLa2cQivWfIK$7s$LjV8_Z~y>*2qnW+TJBZqzETeZ_h+tF zHaBLh-h+iix7+Qt*lxD>fK65%OD4Hy`Os$dVFF*5%21G_p3(#(v|(6a0ToVlL7!}Yx0yH-TJ9No}(ObF5o`>r(fB6tP>K+(B9-C-N zQk$ygjmNV$iwvF&5z3AuTtI(XPkdHIQkA8Gqy@I(qUm1Z)qY=S&k>wX&ui@T$DBm^ zh+z=k*!c}V61EPrU?RX9=r%zj;kHLBW@E5b!72q1R||9=8H6mlCFYzO>woO0c0x+% zKn>T*mxbbGN?)cf<*H>m=WmZc{xS;}8W4e{mmyk^+IR+j%T1Gjg;-JOFW9k4?657o z6%@^cL&pqquiMHV7^1v9>Vo@IJ{x}~bPl#*Yh>i}5}A8`V(ZBicZ23zW>E1uQUC!k zw5cV#CWSMfg`K?|FSfHY=>&41X(V;PcfFVMO;DgH)=hM`_}8+Q z#uyk3{8SKIOcqu${x$C6FL#8NUew3K_BQ6+&aHTwVCSipnmR<7d94LBN zrIq#FPM8-_`GHDj%V?9mWt1l|3R_#%f*!}5O(8WIbEDUoMVY-+E4@agf-7#HN1Fsg z$S%OWJRt()qo6*@KrQkUms25EDHoAiX9bHP5RUUZb`+@?(vsYHSTIa46AGIoWII@7 zFI2UGs(n<=->6oSor_d5cFPr1bM07F+Jr$g89{P`owXTANLd{|SH9|>mUe7c-}uJS zi0^Si`4@WXI&u;IK%?P;6!g2irC=usP%6+UxDppzSJ(dZ@Q5>L0u0W$e*@6R^fc!99@H(OrnT0OrHX=qE53yomw%>mc z{Ek-q2KX|gzQlW|{J6AaRqU)7NKx%_zq{LQXJC`L&knR47mI8gV*PWaeG9%GyC@V` zdcPoiSi6jd1DYJG=p)6bkc#Y1Z9pb=GtsOIi`HsfC0Uwy)@J!a!Z(s6m9b9c5+c25H<8>=YD6)FR5MD z*anSYfOm5^fX8m>G9u+3fM5*Hhfn+MJ?hwN*c5Wu0Bxf{*@6SCfc!8enwcJp58Ydx zlMp(Lg*D(#jfb@v)Kb;315Qu2qOoUmU8rOe_J;wmWzRohNRM{Y>Wth%VLL(%J8zQp z{ST3Ia8rYtui@ZEM@t47G>O?3_6buX_y*tUBq|v?@daA5W%!hNH1=Kiety{fb2^PpmRy15XgZjjN+bWPt;$ z0EPfSlJJ2&000zl#9#mbf9V*<(5x@6&>L!1s>{@)Bvp=cv4HU%*aMksa6n6tJTshv zK`d_do^CVhFrTp3nN#nl^38M!Tgm;YzE8w$DP}B@R31(s*d{pp87{^u_ZG zh~U`c}L@fGOAopXcl;ld6Pr4j$d;Qx}9L{5<#b!xNb7?uN@V!td zH8)yPorr2c+oAM%Sph_Z^m=m;48rdHvWz$3=_7T=gGpxe(=gHBu?I__z`&r(N?JZy z9mYvt1dolDe*Bb1FwOEpRiYr=OMie)7es|$roJpbs-KeqJ=I(RHg$6spw#hQXn}X* z$mVBXSp)8H)10?Jge2c%=D!A1#JRt6MR{w+l&(2V1g$v+?gufyJA|v;EtGue<)$K2WFf*)p1l;3|PNfKf8+c#> zJ-pjjj(7}6T08vhVAD?QviO;FQD6Y&es;DEb4AiCB>9lZW0u1^`^;vJr+)WU{zuhz zm3Uo*!j%Yg20l`Xj>W&)OoZ*1m+ymOo30jJiieMHU^S@L0KzR5V2E%$Of+rR4DkP~ z#59yLlu7AZio7nmqoqUi#@f-q1ZbgobMbYW|k}sTR_GdH^5VkP%yRrc@K_Ia^ zG!~Wwxlz-yAnnV}X>R2njUun5?r9U_otQ%ctNtlo!DE6!_65;e&G-%#2mUEeQ~t&k z^I%B|#`7jX^vNVPIDNB_TML6C!RDQNFvg{(%Hoq2ivqzw5=?&jKA!8MCCYvaYz97N zKc!RrAq!r3;W+7D8|{>F%5pF4C{)ADj8;jP?1861JDOXbRJLI5(rzTIXBJ>11-vzo zqZ4sRfG@Tz2J&J4Pd6H`X%Ze>`Zmn07A0v*x!_#t6{K{kv?PqQkk+hpUY@#|rATFH zB+`NQ3x>bJGN!3B4);zl#WrT_u#r4-A}Fr{=`Y4*{f>^bbuTPiq?Nhj)CU zHzC3FO0NNhLQLHD-_=ypYYg#L-vLGM zl%UyCM-AQWcUI64;vCvb_{j@oQ!4>Mh#=jA8nOo5H`*I~=3KjpRY)bKFM}{i$pktf zEa8~F$vB?yFl7iYrXG-^Zo*1l#&knJ)Bu}JXLI#TgH5ZSTkv}~6b4PY4`s3yV&Ac@ zS;>?0W={Fpn2Cvf1hgg&MIS`MYC5l`rbw8p3X&C0A}pg@yUDYKR_`7kf4zD5Gs3uo z(uMrUd)1{?h8BRn?CL7TGYqejm$Sm`E5;b8W`$WS{pJ$1BeNz7StPj>H)p5gVP3QH ztu!X!wT7}~Rg2HCHAud~c6-pifEJ$C^JjeU*M_5R)Zr3;1k5uL&q*T!WWH}$ zHK+P$q*4VttMg!i_Q#H$t(x@#zY`Q8kjEFJh(~i!Uao0NmF1!F_{-quVUY zCZl!>3p41&=$bPUI9j7`jDehHG#ILM07g=DGiNpl+Wk@4jeP8HZH>dYnN1~YqYSR& zIw=c2%aEHwk_pzZhlEcE14FV?06lAMR!3v987PIA>|Bh3dQ=x*=2$kTtDH+l^;xem z2aNzW^$L*R%_oQ`+Qg0BWKl2$VSN0NSAMO9fw+?fyvwHtv$p3)vH7hcga4hrCtZzb zJg2KC`;=%g5Ep5zhqJInwMCZ@nk{Ffm#H?krX>w8 z{wGyxwxSi-xg*tcGA~jFG-`s$$v?11MA_4_(27GyvX?A64}E|CH*kAh5oR9n;Xn`d zJdje;RBD#FHp*mCvVkD1wgEv^&f?IDUd|r54q~e2074CRBm=B0%nzUW0~y39dp!6n zwW>Q=HQ6l0#8DI#G4CVAn;m8Vp7EqthOsBQs624tq{SsN&h9v~|EuR3JahgLNP~V- z-UvAhTE5nbunvhND@Kgn7z&;>aeP|)LdRfu1$U8$8PWT)Bk?>XUCT9?-ynmVPGHZG z1O?-Os(VF>*2)9>HD4A$OM^O{7F5G@V?$tJFIdWTB35BACveCR@rOaDG9R3z$IMWZ z++74hC%=B`0w(KT#~gL2cn~s(7wm}x#$3p~C|f0bjRBrS6)QDMc7f)DaQi9I+A`Iu zK6_nh#_!i)jbl610HZ+Of&;*S{Q9c<6g4keBqYi49?v=T(QBkA;yqNPTIqEvsNM9F zK6NoSI^~k_*5T2m$~^um6Om#X&`|9D$*KY>CY?5b)MK>4`F?WmwBW%MLDgMg8BBQ-4&A7xo#*!sw!S5w9~E z?So;U0xXqG?!VX%%G3&xi3^Kccgv3J_S`Fb(|3OyAE)nm%pa zF=KXoxE7SzyHkjSz~Thh*$pe{k1|JohXK&73KWG+nPXV z7N7QejiJ18RseWaXv@c?6zm_+Jn+(8rxo3J7t^zno#i$g#^vTIPPVQeDoV5*-;NE?im0y9i9 zc-gRLLZNA=${RxiGUNa}Fr?{&HbBCW408X8CjXYEDh!2^3B(SnGKDNupT^W3zzU^D z-(l{>FZ%zZ3`*^c4E2ZT93xvzrg=Ig-L>DO(!wlD3|Itg!&^~ExlR*|;=mr}T7Y1v z29pW_D`M|CIHMZUWt`+tG|L4;;;E%|U13me+E3bi(I>1?Lk-TNJG&c%JP5f52BmLN zWN=7zG1ACOx^h5^m*ScWR@aJYYL~MGR^7Sx%D+fYZ*s0$h#O1Wo}mY&A)Juc8Nxl9 zY^4aCo$VGL$be4xxC`s5LO4k9gqPB^`dW}QBkQj3ET?P6Bz{ZiwkWzG!_orm#>%G;&Ze7DX^j6aMA|_m+Qer1a=|XG|k#h?CcIvhqI@(NrYSZjkS@ zM((Bspz>)QBG&4GyAa*5I#(iL9SSWE6V3fe1JxSR9=w0(TIH5NJLL%M~U%tlicBAF78edMGIID2zlp3-#qUdBJ?V`yiHT54~b zAqFzgJn0EaToX&l+O*H!ab{~!;<$n|NJ_&?Zu;xP;>bWL^aC52FA*@oJk}s^=?D7T z#gg`>S=T;?o$2eN$TYWtmvK5CgN*>`gMa0~TN|nobxXcYHhZZ|wQP71Sb$<=Hra&y zBu4_?QlhiSN3IpU4S>e^X8!~#y{kfzlzaC6p(^4KFw zU;v{)+kyksfc!A4#6~|1jn1Op=nmf>kI7Rq77mqo&__{6Lm@Z+i~Ennj4X;F^`>5L zC3(8wYnr@JSuz?hv^+)waGcdjlU}-nFpD%H#<5>xmEo2wDCwC_&l+MMPW+XYeWl#M z!>6)Bsla)pGs8v*9IEO1{g{ZvB@9`X&5cJrF%>eI1gk$c8qVvXVxp*!E$z5;^s8nz zVuQh<7Bh}3!f~g%>l{cQh|j)HkuMJ9c=?r*^hLCe(7thm&pG zOkQIZNx8faCg6laBjui>qd?k%1L=VL7f@_aJq-3w2vdPJ(M$Q}!1t+hnM%7@%AW`J zM*~0iz#{heH@+F6pK1~Wkw~Qe%3llTCuU;;-6n|HMG_)jBAJ{5j$Ek(?KxI2qIc3~ zv_itIo2MLE1v9|g8o+6t4*2R|#iO@fqIF>sl0N_6qB$mF1sjV(Eiz9G>QKjXo8RB6 ziP+)^%TnB$S(IOnCAemG^wnf>dA(2HjmRKC`JvnhK-epJ!SmmLlX*FH6VaqA56@QO z^i~=}q{3DtzI)tR^hkmzN2j9fdlUVh5*2l@L?Z-0YHDq^3&d1 z@%mr$|H}VIqVc!?DfoZG>{}!J|Hb|Ii}3s}!}zl=*M5Jp$M;tq5$sS=AE8~jeQA}H zz2dAtF-$Xm3DP}ZqXWj{^y_LlAOL@~yjTgNwv|G(LA!2!=!kb2Ly30lPk;UalY-uf z_i|p_xny(6haT<08>?3r5mUI>aPpQb{`eGe+Dya$2uD4xvB{~*vwDQpbY-w=;sEv5 z$0rl|{M1L0t4QqAO3;b(wA&JWu?6mzo%AQi)DOyyu6HmAA)%SR4^Uf)IsLie4w?Ru z+<|dszvAOFKHY!?CCy)iuN7-4@XZIX4m%s7vJ<~w-2mf7KQDB}M{=nVPDWW^s>ejS z33|g@H;-fkM31Uyx2$uIY`ThYV82#e&j{Qv8H3RhdP=pX;4%$S0mX1x%vX)GO?u4d zq^G6jC96}9sA~@fJX5@^6G>~ZOb}UyjA(eSqqt{%6=b-28Z_HmsX8XcWSC;5KVUWL z{V9XO*(V1lljbFNpUS;D zm!%)2or4gPdZi7a0U4hTXn-Bz&fl!vA6Kj%y^QXdP+{f`V~UT}xt7yHhfDr#U!Tz% z{mdep%VqM&0-YNd)JKVsw;snJc_TRZhi$^|BNJB~X``^m>zf zgysUnT?dGhF4H!6PYUtd9pc$QupPC0`xPFs`;ar7ZHiNW#iyiu2h|SH!d%JCR+@gM z_PS53DO^=~zvt&9UdS&RDz~8NTijX_;s|>}l4@5R5xiG=Qw#iySSKpXJPGvm*mUv1 zplSRHT;Q7x)3wtM?sZ|36sGFZ$-jg8Za=zUJ|LSqQuNbA@5SeJCbETaI>o~++re*n zFfMH^yExLUlRiucSa{PYtUCGmvzT<@#0iFhWdm-gV}+{Xr`s8Ge(A7Kd+z5e#u7QS z>#6!oI7U7jBV!Bzik#h1$VEM9yo&j^Bo)B^)^o*{122eiR=M2fvvlV{6I^a+)0&G> zQ%Wts8a5_E+>(nKiUasMy;%*rgNNM|mNe6kF%M>GjoDRse0aHb9k9E=*d{I?{{{kp zMFoeAWCi?meyY6hA8`R)l5O=TbwfcRdM3|^MMvNWYyGLWUFy*Yn~mvHW8z$Qw8wYg zf!Jvo3>tZMibnWh#QXx*-|M^fY4aX*j(uQGxgxzk?Wzc8@@jEWm_O=E=_u2S7=p7} zVfHKoW(<#LJmgP$h?+45`tjudCQC;jAd!SfV4ssR{z%LN%lIk_nrp33BO;B~Y~BOq zAWJvd8;5FoEw_{ULizvNr!6qfoo{QdjLssi12U-~_5OnA!eI32*qLrk8pWsPoH}x$ReBsdZp#WK982 zZ<#0;4{ZBNqXQ`bK1Iglgk6QYKrW=v^QM%~6>|etyyr@|%+Rd@8Rh^sMJ!Gr+Sy;y zGOZW4ySM<}$v}~pZ#}Bje6s!P@e-__I7V zN*E<&W7r}Tv@FIq5DT>`qH+{IgXHn@_+yfpo+s+CR##U><&BOWaig>`G_*IGs zn2NF7@W$mVC*a{p`-Yz=^4VxAe-1Ykx#{Z`(z%kzKi}Wck!v||1g6w6FZD4RXpBDq z0r!)+O`GWCg+q5pZ7$=3`#94iP&v6jmhCbL*spPU8n0e99`M%CNU{bV?N0&_`q8%x zBOYRLFY=LX^yJG3=v-ND7r;fe#qGm*;qD{ri$s8e;bmVn2{DA$-m6x25Tb(POQa>= zU_HjI8}-PIjCIXTsV7Vnfp!09#@$)Ec`?gZ#J%Y9loTq5VKL_SwT6|gaO)&_G5tH; zHjFQDJJ%A6G&M6Pa zWic4+(l)hYdbjhlX)qU5C3juXm??}5AA}AYxgqIM5V8PhK$pJ;rGGm;?b}OdZm zw^DKlbGIeVRHc}MAbrl_sqn|<~Yq*w=BaR$IuM3L0PswnWtkg&Dlp_Zqx4)3+~Bz{gK+7;V_O`klL>|ge^o~Z(JtgY&1IxX9GI_tV-r4We0JLh7p z7!WA_|9SnM5kFLmF3O*IHh5b(Kast zj$A9a|B`qunABn~n$SX;SiHS3Jd8Qlp?NBq|{62Nk$MYS1Q^EF;DwS_b;XS#}f((1O$PIa7; zlpN2Ldk{RqmIq!0&Kkxtj{y)Bzk~DxDPO8g{*fgsfkE6Le!*7eYqFgPDz0bY~&m6Y!hNjH+FZL`m z#hi@vtsR0atd@~J@us9rt1I(m-At5u?L{ChzT1&LF;GTigS|=oG651N3h}~UD-<+q zZr_Jtp5fN0`?(VkbCl-y!1Bnr>V=ZKFJ;3P?m`a}Z+?;hF zHkm$h!Rt-GqbOR>LKfz3gysc;a1x|Cag*nBgb%aa$N!}5+<yDbAlDhJ2g}*04NBQJE#=2%iFrE!+=h+XdOurpj z!HMYeR+9KK)g8Lv7mm}`s6gzw`!4SrAx)<1BQkEmZG;Scr5z;^f3CoOdV~1Xo%&p) zBwu>2W)^3k4!^X$sgmn*OAYHGe8xex4v>T5bZE-c5U@@PPnNAB=Tp-m4DxIJC%vDN zGf!?eJHRJ~zW|;r-SETV8+NJ-4K!u4v-QUo>Gr&g_^|;CC_YT2X2IL)p$qd9`#ZgW zSOlCa^6>U^4h5?V9n2bTIa=SuPH8(KZned#cz1V9wyL?;?4QZ_n3g-c;Ww5c0KiV+ z5nv|B^SN4AbnAz3trO)G|Agq2>ktaf^2Hm8|8S@W^PcN8v$#_oOUh~#HX#zZY6%6%R!w%_u-n0 z3lejtrS|}=e19F{!4eK;9ThYQ7)Q~PmSRIpN+XEEbW}ow{`Tynb$XWRDhg`pi}Z80 z?m)CYR&k6k16JH{#%+3*(c;G}qjA!GxGLm*h^%x_`-D=n=}n9WzkZH^Qw?7Mfl>>W z;0R0HyTze)h8i=4|Lu98cKKQ+h`)Mvg>g-yWsMJn%Q`-2XU38CYvwX|{sE-N*E?}x z;ZT85!nOzh^Ppyb>=59P%^YLvQpiA;|V;zcBXpvr=k~-C`dtUDIjZ<>!K)6 zkb%ta1ZWsVBKQBq6Z!q|It5*p8oU;BJFtI2rV8vV~18(O1Weu8N8x1w24U(^__bG zmpWNT^Ss>M3IfAV1+`?LA-Z`=ms;5yZhn+{ms~!mbP>I+?|vBtozfri?78U2azbYu zz16f}wkmf1KbH)mvUeod68rxh3@lJm0FAhcO8kL>zgpPP7bV27{wj*-9>(4U;O~F_ zTJX3;xi`Mzv5&`(Flgh3hRj!SAjZiqig=umncXIn%n%9Y4MfX*LypCnTYG7|Rm9F{Wn z_8$YTAbdAx-t<)RU{!;t`+a=UFdBARvqD>=wgVMK=3eskP}+v&+aHM_cF*z^{X<=2 zd7HRk1$dpR+qzK5b(Bv9@`%-CHV1>VyRA1ufffYq#irp}*QG}c0EBN7fm+DBsc9O! z;kA|n3OTXrYALiMM8jb>B?YsRya2%&13nkC4kP<5)vpTY7tFmg5GiJ%3w%U`k^~tb z^stDcbKy)=D(ON3%QwRMUnY|Rup7I}-kEE`wm7GfA0#lf6)`^Kil_ci4{T{$k2j0) zYt!bq;@Tic@pfI}@I*BporNH_5 z&xR4K{~3xv!8?M4=&@H0D^w61bk zLMq!vSLb#Q7F*(x2T6j|FIg0#er^<}V%7*hyUF;xhI^0YT`f)LsZgdF44~5%m&2+9 zNG)30a<5ls!DtBVnqmg6%&KsZqY=jAs1W=uN`yh_Hs6u7bQ zw1~#t*)Xb|9z_0DqMTvUYJ=v@bW`txg~5cfstV!}#0H$aXmV{oM+EY}^0@t*-$(2B zJxeTo+?i9l>qF{^jFMY5HkIsZTm>ISmxg*Mu=S9VAs^A9a^G^Vfr%)S5M9=ccG6kM z@mm+?Q8R#Bz$yks0;i=7fk<@4Y!}qI`WEwE0`pU|TC}QsqC``rnHU1l~XdO)zcfc$Iz=Aw6Y-Ls|JB=$NqcA23BcYKe9^CzXr_ zr^0GsYSz97$jZW>Oo!%z4dMYhk+GdctR|s5g)Cq%Y%W;AA@W5=e zqA{&xK%uiPZLDbI4FyX3CFGj0tUb zTr1=%&`&2`L8y`~_^Yy#+Oqt&j-bpY5JfctIlI6&g6cQuPN%fM zm3n|_90g)D$z>7wdnh|<431%V7A#ia1VFq9v>e9-nKpqo|5Fx<5ssnbT%i(}-qk>K zZf)}*Y<0Q;kTKjJB7Fo!eINvDZ7i^K^;22X8FvrYEluT<6?ItJE`=F_gpX|$Dx_fz`A1*kYfh|Z$IlqHEN4%PKYDkQtD_=$UDs=3 zB@&tZ*t!?!#B*G|BE{*a%$qDLiiZSi=U21-6>OMt56asNC~uOf+k;^`>Nq!@Z*OcX zF=o25!B?)Q+&l7xYaF8s7gSP{ghOdP!xs3S>#Od2gSh)V(h?vEIQ>%u7{%Y4%$D(- zSVF?wmNpT##l6)etwvp*Z|hxS=O@IOsl>jr&E!kqNMtEZG)TsH0lDK#ws z&hJ?QZp63wqrfRoYFH}m`z7h*V{)Ky{^hQRjoZJ|H&Z@`c2}$LR_qfV1K*lYCD{N_ zIMez6WX392Ys+9vH$;oC~;zDV|)4O+IL*d*Q5Ci7;lxD2>q#j<1B%l2oo z6(KHuZb*OGMmnBNvU#^3Wjb%D>l?f!%3tRf4aGI>8^$u2vfd(!i1DGyg+NvS8X(_Y zA&7FlfegK8D2Sv3;u0*_=U$)}O$TXY#y@H;!n27y*%I*}k$ty4T-IgBX-%r)71|y4 zIV&pmBJL0{`4E&-9DP0u9Wn5AQ3mR|#-@VVq`ij0H$ZmMum?}Prz{RCd}FpT1LDbK z#T;iAeB>%u{6;7W8SsyS%mxQNYa3W{M9+DW93_5BtI2MxH9oH^$q39O73kk_rAi~j zFSPuLi(=`C%c`dY7`uAnjVWX7F$J%Gr61L;x@D35jYEc{NiND+({tMbllubSSC)R0 z+m;x-bSB@!PdR%pPv8HDCs4q;kMN~9vLlc$W$c2P(!pY6gQj4H)p2t=tJjYrE1Ohy zZBjPn+p)apny5sw+3t!l-?fG*GT-)4$3NRo3lZspU$l{Z3 zqyUjlH(wFmd(JKO=yU=8iG(o-#<{(!>HPA1a+MK(98&W>%^@6U%?sVfKA4E;l$Fgo-bH;ppK%|nqn4NiVro+_ zJ%a10P5GAmP8%-hrZSI`7I9d4MXK(bza+{(*~X%309naHV+jvb+H{SsCyDe(R%)=P zgD_Lt-1z>i%4}O`Seglfw4aJCr$DZB%cGGFF)&PbrFn(}e`948y%<3GT2PwPv|9x? ztW`qrk7^EAb;A@B>zD93*=bXUGPT8<~b~Jjw@IjEg`Dcos`OSa@}U=Iw)^n@gfQmZFR zmr65?T;8gUD+04&HQfI``$RaJ2C5&jK(KZ*DYXaQSO2G3JOV2rgk(n+L8DL-mzQmr zYd!%B9Hh3!9aIpJpNqNjRY;7iO6^3QgQGvou^K^_)+yD}Nmg4z=9kEPf!yy@lza)7 z^IGa^%GvG!=_cPc*&&aF5mT)%K^ag<;uh3k()90FBZ3UxMs`aY<~Ii)!oBTI%^Jsd~VZ`f7o~77?%CB-95R_vh)rnm4y+BMwQ{#((YG zarYREe6k@$BVEtXkocIkdhI@9O2pi{NxR>mfS*Po>TcT#$-vd(8I!}+Wqh4>!)+pC z5vrAKgA~wZk{*G#^{p9nN1 ze*km7M@|DOwcHS@yA1)2NSYpB7w|JU81-q`a58&{k2AjP6$E3J-LR0ld(K;baojrQ z%#;vA$h{2TV}FyP`UMYwz~70WX^PYpWVjpI^N4Y~4AzH%||O#Vf18SZ8NaAYcbv^G11-pcip zIe(=#ri&#(=axZaZmb5LWme!+iY%V^69Hk@zEU|!8)M4jtEW00FnM(#ocDEeb-mPY zDCbZ+rft?=_ud$uDs^@OuebfnIH_AG?lOXHVKs_ODgO;mO7k~5GsWYDZq{CYT&ZH9 zD|Kx?`hEKf6QApbQ$e9n9JjfQpS&pQdm{8YpjwAjUF8h@f_e|upgy^45zjIl2zLPB zLGH*E{l*JyW45sc(+Mj%EF~a!F~f8d1;k3tEkYmd$FezqzfTVq(iJxz@zrUqXxhG! zhSX!5*GE_mPUrf3gbBA&rcGQ1>ZzKiVs>0pGroAq2d~A48_8*SQ%A)L6T=mzt?nf7 zB9J+M&v4TsgwDqT?vpMEVYmZW4_zPKS@Y6KULb@4sN5plNm8Y~oM*OKb0(H`-%}R* zx!XYCq)U?o;MXuE?dGSM)i3xc!|Qrw)mjbwOAL+q7E;OiG!t-;6&-O%=aG}!fx|U_ z?0y_pgCR!oe#Lv|;uR0JkQdr=HQiQ|O|B*Zarxh1E+#&t2-NG*I2Y^BAKHpi+R9IS}D z6$et@fBaOekM{j3{Lcfkp!(z>K+{T?X(D!9Occ2TV({ua$CcXBmTIQFYy=o&pFM{T z6>g@bK}(L&9dTZ}lMCc0E#l7zR@8qqTF7klVLVQ z|2ec<*eoi-3P5)|+9X39H+FCKcR1f`1!G=ShOKO#>|Q7!Ezhoy2?#f<`#zPZ z4FDH827pwrBnB5IMbVtkL+fayDFY2o7jIYG#9%V^bzr1)&%kssmyp!g{S_1BR|VP> z2W{yAh$~-y31qUOmwW#wPBG3=LGf~Lhs5#Xb}u;T5{ZU!Wr!Q%%Iu|ZX2;1zp6PT% zN##UOCPjNx&M0B+lE&Nihbev@D01#3wl~*gMevrA`Da!%v`?g;N7XASk?-E-hJp3< zI|RigGU@jbkc;NWR3Y({l5xhthVUa5ntTYmsl3S}gl1G4avn-8E9JDoVJ`7!#IrR%E97-?jyUdvDgBZtjRGv1#53<-aF; zZdXO$^_>*o=;8}XR;NImdn--=SJyd6miO+8NFI`y!KHT+ymx*ja3mfN|P_rKgJpStwsD+yE~eA3XZwX4K*wQXAJF4xi8gn z!ep;jvbPKan71pZh`UEa@yM&Y*6BqAWS+t7eSi9&U%HRVRf)8YQ*4ZRNp(k~*Wi^6 zE;0H@tb`HBuGgRhbvka~3>^@}V3C9(3A~o=KUIo2bnjrnd9|>7NYIFkmi+FlF_Dp) z?6ld_3G0&B7~PY#I#-iRQK{0Pn<1E8-Xi;4kfimo1|$C*7$Y~kdd}@OyCi=XEkCv&c zx?;Tv@|1E_>vtf#FC#q%C-}nQO7n5gYm)YkO}X~0U#5{7*?Po>mM{X=I7CG%^}jit z+(RYGK;-!KpXoHDWPZ1skKLH!J!wPe&9@b&eh9l0N?J|llE>|_9J2!7Nj+T~M=8$M zs2$5ED@3bLY;ODhdLPIPDa*hs+`wY=p>Z%zu{x>YM5A_-hjUWhm;G}Y{peHJ04aca zZWZ1QMt&DNi_3K&-lG62AwRzVW0pg8j54;;IdVcyo>G1y#3DJ1Axw1^9i)j>G1U__ z%n9ge;?eV>F5@+aRY`gmjHw!h7pvlnh9L#GsAwS(U* za-Jw4XqJ;&mZHdzQmRG7yvqO|b;fgSvtbsT_5Qp|FW zO@n>V$T06d@X<6k*a0h?JgV+)Xsdr-xQW-mX-_~4RjPx*=u*Avz5ojtpBaH#haAgZJ2DK(z`03s7?@O! zFZO)lwA3JTxiOv*iVxr@UBZIressuwOz_xU3j@-YmYJA{*jLI|XS`lyH>Bt$X^vq? z2Kx(52z4gm`&nytVjCAHYmjJ0d4s{p-Ly&}6X|1jvW zT4n&e$~5bn2l@R&Ti0n>dd*Lr7KV^EOB2fN-kB8*8n1w#GKa@mUgsG0=Rex?IR7|5 z#o)x!uDHis!{bi_T=)DKr=_{RU0F&n6Wcbo1V<0tA?Y{Zf=8vM^6r zHr4jDPn)#Vwf%72Wc{g0mx{kC2=%EYtYn9?s|gY8Cy!0l)oBeZkxv9vAI>G0~@Aq3ubBG77B(hJX4@Ep*a~&}90AA;ixH zh;N10L-S&C0}{^Zn}oh3EZiJ#POb1RDgv`Sd?y$526?d zqwHw;Xs;y${nVbZ^RG;$5F{M&rd^D5!Ci%2QRi>n-VVxM%xF~)I}*@80*0*00WXo! zd9_Y|s`_>cln+~e-! zL)VO^2l~bSLNCZ&nC=Ag;1%htraM>rnF4FpnI-%sxr5_gXLXohX;hRr12I+Lc*82gyJZu3W%_~Z29z1;i>p%ATl0Xkh_T#pE z+R>~+|9dgsTL3}B3AmTmE%4dX33s4809RyqI-&sI_v?X&hbxuq4N=I3F_U2oEbq_? z@}fYJ2teGG)%R@`$NRj)Rsa)f`GNR$N2x`#fJ{`%hPg`lZEAq*I|KVOr#t9#p^cul z2;Ny5CNejsa^=P1-GiBl{yYZd7f|UIA(y$NAjv--WkCBS&&==G?zg%EgG4hBD^1$) zJZm&uq^T8C*7gwIS~}{vH3D@l+MdD_`J={yhkQ&C+gRq0jlp^;TV4k$HR9un5t@m6}BlG*ag79Yv%8g zSf972H_`y`6C3HT*c@73Qt;S;BWiV#`#Hca=HZ%phw!tlu%kfPf&=`3{4gu0d&PRL zbJ(W49I`^47L-_p@-#fDd1%vHrS5r~ZYGv;!rX?>C=F@-3bHrLAr3jH#gz>=ANeV) z0*w~#F-l4HbWOKEy=}V{_pa;PCRGV-82%G!6cJcn`7$z^u}KF}4zr^aYcg_}$l-8thfYPC9ITTq zsf{ILk*4V1aOJ5-6$Y8nd%m+kFolZpx>*N&G<3YUhLZi%v5{{rzNtN{5A(^r_qtieg5$Pq~7_i2Uao^T}u5)nsiE98IOSBLhR0WMkKz_v0dNWt~R@` z)hNd^!QP9X2Eav(JLCI~-vHp)ph0|vq_JqJmn?`Bjcv36CZ^-N^09MiKHXbBO|7N# zUVs5OJtchC^A zZ~SdPt~F(fqwt?g8HS@lN`V9r0EPfSlJH?g001y{hFAqa{u3FpN&o@#H*T5e6y)TWt=0fuFqTGn$l@4mI#!TuOTJB zhBg=g00HR**=@-bmI{UZ1CwC!FKI;&*HTk<$8KK{x3xgp1C;dvWaXpTAl#0e(ODtgVX>K2U=_`z% zFONM^5ebKIUwilg6RIyJs-8crx`A~Zv`({_uA-KO!0OA#W;!~Ftndqu!(Go;Oe8Ta zMlsSsA_^5_xh&7z{~z~;P8|Fot8yg%0=>ICMY8!`s7?c+>Cpc}z`l5(AE7x7FdAIm zQt1B6E~8L!fdnxCh5$g4@PRe}0Pug)`Ci%lKM8tYU89*_sObsccXWnhy+Rj7?fU>I z;0n$ZgHil%NcA4DB3(A72VeZZpK{X1f)V%}pa6eYAUp9-e@&?dj-78lIHu|(5l)f^ z)v8ZoP1tngl^Yuj@}Ci3-cC z8Q2TZEYIGWJIpJajl)h;w*B^qxSb(TmJNl<_&WcYf66QD5#nC)kYjMcMO!$aX0DCa zW4obab}fNJ-Zoz{j}kY$fAmDQbhhS0rIWF|q!g&yxKi+Jab?#(9!OUUZs>>|Q=x(S z@xY`Cz4-Pv4U+HIXZGk3vqj)BRm^aztdNsaRhvZl3BCT1QR(2PuU#b=Ik&NqlA>!m zO~x-1*z!I!_ReeCyHU8RI)3kgBw$(QXH+RYm?(FU*^K3eHP)W(x9IK1v?mQKy2&?BDi32flS-l^#M;)zqJrI@g^`0O5a(YAJKIP{mC1Ew|^DWjjsSt!3bdsr9(907`{5z3>;&)=aDbfy1+|3_-*L zj|)WfRXWxk^)wxOEqtsGP~g})52|+cUtUhb0dR>QAiV!X9mC*D0+RI**u|31L_dvW zM5L!%oGb8jIcX5?vs%N(ZqIg-PY%sq=V5oIoIjd7NXWma%K`vajvsW4xAVL6%jM*H z7+|(=)&8yj3F;>A0nrb(N2V%g7FbDJam^)mUsf=JB5bt~dW8G`UF{}DK<2lI@-&;G zVnvGFcf5Rv^mhBhE#liid?`?nKL}k!NH(rR;3KIfSM(%reKntaE0u>An)QfTU4pXm z6$)xdazcq|M>3r8MxdpqUmAxt8!(EEj&59IElt(YII#{nI{~WUL|GOB&YgZher5d( z-%3K9k;ycysM(VLrN;?4(*SvIG4b790tDEQS>O}kb+Q#cT12>Oq}fqv!s@Hf8O!TO ziq%@DcRi#jDqJfLLKkht7@8KF;1)U(O=0Upe~F=hY?AEP6+_SPekWD}sNUX&lPc;T zG2M{rcN_5YcUwB@s}OqO`1%VwCt`dzp?!R zb&R#zJm+w$HB2ISmZx_&ZzVQ;PyJF#vL}-;)jc)x4ICsFrKiN&vt!7?FjU&drdgmj z8s*470k2IZTTheHP%i-xQ)XNFj}ymtPVn@BNfdvra#%4!-`EvE*OmV3@#Jzoviqvh z>_xaUbx(ylV+CNleL;qdPO-wy#!XLa?>1{NLx zO|ie~AuqX2m>3=r4N;lY$F@?On`8o8^>7h1gVDV_JyQV$xTF5Rnj6Qg-wm4Xp`=wA)Y5=+tC>+PyJv~ai8q7+= z-tvhHd|MGN#%LbphkF`?EoWHE2A!#- z30W^^p|S`20Oi%b(NXb%9%OBAi+VX^|JpNprwBj*(2TzNK(ofV4sLQ1foSqVPXel_ z%bp>hv1?#er{o=k6e;U){(>dkL#B%RKgc5?|9Ng=m3$Z9p)-aaVh(})lotmE-wuXF z#VQ!TnzC^B z7_kP37(hZiEQw8KBUheRo4*p&Q%mB9@qF3){ZFcmy}dt~ONdsDBs}%RgS`kDukRU3 zD-*Gu%urMm9;8;|eR)UD46|oPg!4VND8f<* zj7%rNdZg0&sk$!?hELMwXA3&^tAzPTV9I}Bx% z6QROFLL-0GgT=M+k(M$KxJWc}(P1Im?EyHLU5F6A2?oX&!y1WLBdWVH{{HR1Ju>g# ztMOJ4(LMiK;noaAu*C71bo12Yd0L4Elo>y;H?+m;293Ame8|#zv~f);y_27NqgTiA zO!zLB5#>}P9$lTdfrd`-zqzJ?_cGP&)5c1^j1me$>kt2QB)mB=U$9Nzf9=dM(*6eY zCENqKPi+iNn$Nnp2$0qp9ShU8CUz*0_<^T8>4Xg}N7NO1p?k4``%qI13vvc3CzR#b zoT+Z-%Aay!G7Sxxn{&aYmv=Fk@auDQyzbN3DLVDv%6FnP(2efrA2Ng|rWO*HVB4qS zjyuo?$?c7vU@Dmw;4&2A+)W0bzP3>PHFV|v5~f<3|4^!UJ8PYzij~xF>pEjI1TwKeLsH|qB~jPzz#j%U##{_j}XM%*8~Cj32-CVf`74~6-ije zX@u6l5S(4_->n2o-pbAP^RVvS#nP?$=KGO?+)J<~wn{LpE|H?}|C}!a{jBA>4X}F}h5H2>HCwKAtgiSqLL>-Y-_Gmdiifr%Da-VUwC3o; zSxTbqQ@Rjk-8E9$v4ToyWN)nEGgSu-2dpKNKeF^ynPvsj`j zxS?TPSQ$zWmfCjOOh#sUjq=PTI-<(lJfuSTXkb^i5Ij~$+e0!a(}VZElaNP6X?uAv z`=n)&0rzRPSp(`+Bqd@Av7mcLg6x{h-m7Gi~K@$wsf6;Y4xXSY{Pa*V1t2g5x z!AR_sMAM6V3m7_SWJ+;rEwVpI@T#gV6CVjOPT648zNxYd6O!Z+4p}0PjIl8EEFD?JaNi4(Ndrfo)Bn=};7 zw{8CWeA6N^e#UklfGsLmVp_7!%?%uOBkn4P843!`spfJ(<+ix{CpPh|%mnu9=yy;M z<1;InekA<5U`uqZ@{)C&UUVL7k^>ce@8y)2oonCB=Q^MwY#{< zLtGc&0=2(oQXl0>N{(=P0!72b+iL##&p9>hTRW}UZ%|pe2&#dy+A`FqH2hME zA0S9r+uE>-ph2e*PRv`{|&=k=4I1lxFfD(ZVM)0${r*86W2r z+qCB6Tfy9vI8qQ;WF$0e%}yV^yQMcClQ+S~p;<2iA*u=&Kr)q~o5s!*MHi5!HF|we zS0jfvu`i6d=UrS!_Y^(#8@(EULrQEE2W_)m#_ji3(c{0YV|;`7d!ka~?BL?gI=TT| z)*#KdL?5bClPhHN)Cf-EF+LA5_#sW2GY{Mr#1dPTu5V?tZXV($^iBXE>D!FjP1NpD z9@2HhpGPa>X+2pEj1!6cY=IsGVp@I&#`Od`A0@=oYq{IfrwxUMJd!vRq)lbVyjW4F zTg~!e1IR7)PX_kgUjo8C)5+rryDKVkq6MB-v_MXVuu6q3+Z9rlk_Zu68`OGd5OYPk zqi`@fRz3$CVN-e84b&$tTr5~*+x?OLdE7PsAJxwL1&JiV$hanPw2$fPH*Fa#69wnV zDR@|owrYaV#Lms!~G}@{TNc9%(CdY75d0t}pXOc93-J3juPwr&Sx{^}C zpAg3jnjIW0hjgvro#$Ib-PC%{_Jg8!`IM(j9z_?mZqJnv3%{TNFZPJ?p`@)G@R^Ol z4B7z9A3wVAI4w2KXDT2K&L|ga9O&F8vn-{G%9Zqgj29Z- z*qp|A6{q&WllkD(IdX32pq}DJp<>GvoqgTF*hUevk0(SG>)3>ObgB!~ws6mU?7}ZI zaVS^-0HZ+Tf&@5#{4gZn-W9it#_uAnBupaLBh@@pA|ozv#!ObRN{o+CUkM8AjLXDh zPU{_|f|YagpTPzYRN&i@t%}2_2~sa{qlc5+^-6S%kEiFnA=q3Kd*XO99(DUs>jv&y z?1Hb2{ja8ym%Ho9ec$UI>K>&dSQvikl zK$7qQP=Ej^cNDsZ0NcNq004g?#ocWcWEN<5QF-ha88ZG1IttQ`1I_qfW92ZMX;35@i2%LGx?5iw!UKIPPr6Fx9Sq9H{t zvEiuhK69zMl$WD*^vuHD2;~qE_>S4L+hW67b<7=wXT;Wu+SiRxyMs&Q+|$=mXtFa^ z9_I=FbVefa1UE17J@j@~3n=i6FT)DGV9M$A*fiXf*b$<&LGKeZ~&t~+kymPfcyXe z$_E{T3#!P}pw$wWvQd8LuD_*6-}9;{QftOnOht`pi`!1mNBRo%nH~XM#Zxx%{Mbc5 zZ7iWga0kQQCa%v@mixfbj{LdL)zjv6{eSCIGn-$woN2OU$nZm4Y2Tl;s79s-!-M1^ zfaegechf#;*c=N)%wiGqCVRTbd=BQ;aA22?e+dnnY#{V4t?eX0AuMg|S#pq)J2#r} zq52zf9?8?dLn1oT=kuuP>(yfS*Lzd9Dr2Hep_y-;(PGv!VO`#K*d?S)lIhz!-_XwM zeKs_cqd?|@1a*M?FaKx&v!wz))Vmp>QnE-y*Ifc*%OPnpX3j6qndfcuTYaS)Okfjc za}np{?B9*+a-SYm95-J}6FNO^?dVd{$hg4j5R*}!OITee)9;Ssz`V5ixn6Z1G|Oe10Kl(l{U}MOch#H$ zWhFuXs0AK%R~Cyx?nh8g-4_85`ir+DM zH=WvdZ!i4nB496!SbXd84F>>^K-2p;h10SGb=>6cXy{r3H?WmE(nH!XH(9D2Dku}ZZU-$J)^C7tNKP=4940QVmAHiLF=?C*Bb zAd+3N6~(XJIU9|KtZdfU%~~B-xJu}n{p*SPHeJBTOzG@wABzj zs7Oehga$?Lk&I({H2M+;}*aNegz=h{>_mR}yTg@-YRt^+o4i@8@OG zZQ0#=Hu>htUsNa24fd0cb9L10gJk$o!uzqrH=2{H%K^x`qLSZsK31hqd0fZ#O*F3W z4)8=epCT%t(%wW)<;_Z{KU5n2vymCCLj`cmrN?@u*Wtv?{u;>ZmWXhSU1O6bL6?2n z_Oxxgr)}GIPusR_+qP}nwrz8!wf*jH#D3k3`~y{4Q8(|o2Ubfbz53%X>+_oN!@$Je z0LA3m<;5s)V*4Q4UO^7ha3=;>!|UJP36}OS4wMnk3&b9Uno{DF*J}ArdWf{C*{_`S zlDN1?mmn(-oVgn*V`$XkwLy(WzQHcN#bt-iMt+s`;1wPTeO`j@@Tus}sn; zxW-4Nun$n>sfrXWekA((QJOiyWJp*t7@(dt*yO*myR4p+IbYv@8*|vl-zJNNc79un z@FIQu>1!fXF)51etx zbfhvzU1`L`PpV(D$UTGQxQrjhbk1sJFbi8wGEDDz!aZ(duF|IJO0nRjZmS5 zitqqf+%Pdk9D=Ov+hs}9v4Tewh)_5}oOWBc4ae%}hOUbgRH?RJNne+IDBNY$<)B8H zPxJY*A;p^g?4})vYusna9Ua=OGyaVuTGcMMq%r_UBz0Cu8?0I4i21mz);^O2^$<>} z(v2$VT%DObShc(ser-Q24dU|~X%;;rM1iaPjl#=!b#>V-{&%U=6!`FtgeU(Q_nDLt z*_u}ZZX=k`?l#OhQIqT*tRYXzdl5VCmt4IW*>p!M%y=C>F0v`FCK!Y(z(RyXl9tj? zYBJjx!c<{d!RfI%?KVLQ_>YGEuRKrha(4LeL5`(@`v4iOMEkS0W#EOxyr3O0{mE|`*?Ah_v& zp8?e(l)tjdZ@tR?5x$~3zZWjma;DiK^$uAPp=^eYVaHp4OSa07c(+AvQ7fEu=^eNv zH{gANtY;hnKW3Cv%=wdhGcR&^ezQe1#8F#7;+Ls%!Iz)(-oGqd@Q)@C!J*lc{n_%u zxIL2W&GqNllPG7Vz0c4p%}pt zSzVhYZ@x8qFR&RdA_V3AM7$iDkl~pIZs;!YYC=qf6_Jw@({Q)URc}PtUmE5y3=!xs ztFv^2u~b5?&@gXOXa#!<5<@ozW%g9PPxm{ zj6ad9R$%kkM@>>g(675ddZ1(RvwU5+{}zh2>p7@JIyAFm@I}%#4BLL1H*qF3qSHS< zgR(IB_Orri`fKD@l$UaQXeF~t(n!AFY@ZCOdq>!fk1l$fVqttslKEQ`rfCqF6!BK_ z>>{<@?NpC1Mv z$$YD$0@-@!+QBd*Q=Ylr1TdNh%@wvi|5+5Ad+1SB`mE8F+~J6q&!C}YX|>I{kbD>E zVi&bmQ;OAtyJyB^G>=8HLD!po1eGhDP!!Ldlj7t6<=p{R^50a7R}#&ujFCEs*E?dS zO*c2tqM@eC@K_Hu$ldPEAHklkE!z{dXrme!LLe#yzHxNTsn=QQl8e!`BS(P^S;sHL zEf%5C!xyjU8y{8QnrA4k->w@Goe58S*1u#1|lFKRHHLeC|`xARupnJ>oK#t{Sb95-dukq zJ(Ompg#Er&F*ryI1YDgXB0JglgzAV{ot1qJA1$!in2a^e8&H%EI&wn6+|utR-TYa{ zBgQ-)oh?ISeQ-?%P;eS&Bo;fc7QK-P>x47Vo740vw1Uwpwi)- zH;o5O7?KlAHNm9#zYaH9bRkF(_MwoNWOgbwKL~!_G`w_(3xc%vhPur($7})9$Jkvz zl=16uiHx*#C(o}7k-!+y@`7WRRoB_uQMU3m*ZLv2IA9sH*p^9e5EzY{mN{C>;p$O6 zXWgVzS$|@o`&hNb2i6&vEd*s{DD*z;@UlpaQG*2^2NI6aTQRySl+mvY1B+34_u9ps zD(4)gHgv7Qh6s*1%HLOO)M1(^TDig)MLCMz-8yY(y|@^kJG=LmkxNMj>jLCWsTU#YOe zbexPjRy4kplEZ_fWQyvjVI_bQmi}4&ChcRH3sa;V#mB&%42EH6$mHUusXGb)4g1L- zwTVS~Mno$L0&` zpB8Lpq7+bcIQOyP#DR`mFqkR(OTUq$7M6Ce{YuF! zLsy$O#8f7>IT<|~B47!t6-!M>2O^)h<$c&5_vHX z<%CY2?=m9!HiwbTF?;nxhVlnZ{@XicIS@hN+Y8AAmd`j}C<>s~{ZS4K^-YT{gUGU>2Uq(Inrd|i z@t|jUS#fxAXr#pJ`E9u6#_t$^zqXf6r=*Mw%{6gYLqyUxd{ zh1?Mu{1i=)pp==n9Epkp4mo^XGmrBMOtst_Fr|vy1xZpv!u&@3L;mO%A`ked3pH4gLly{ofaZuJv}>X$`$iK&GQ_%f;m+Lyv2OHXIgpSaHHKXGtd%pJtvA&N9b0dD zqhT9QWN>pr1#~1<36+9%2Q3!OuYv~mxDUQ?m}Y>Y&eOW`-p*I;WqJwMVRv(Zaq^73 zm_5$p$#x{L(@5#L42QVsZ{3`(yc0aoVT4$9A@$H)RIeioTvxCL|7lM()yCok-QZ*! z^ya+K!e8MYTbl&qE8xA$tyNyQ@vYWp)0lMRe_7mY`kqqT#@1iJ;Lz~h`;P35soR*Hz(y+;%dvDTkBE`Ow#6M ziu0;VJpN3BGPDZ8X$i|tHaWBxzWDaeG0>vAwA42ao_oKLE45Ieu-{*Y$Up=yUMVt2 z%wBm5?TP9q?RSjYr!J9;xiga^%)f4 zygmEXP+FpPPy8T~ZV&T>_g^-lbAF#F(J*|qb+dGUs>4)8cCph8fP#!?q*R z*<(B8b-6VN(bTr&9*d|n<$IpucDdpu^1n5-qPm1UROrCzl{3A8d3~{yMLuPUm+GMq zAQa|Fl7rau#KMZkg}0fxQK+deo*;1%5FI@2{QLMy(9=qi(TG3 zoJ*EuzYTrdiDzmpWUrU-%u&IdLOU_cEv;Bvu07%|D_fxhg^mjUR&Vj!d83b(nH9L3 zM4539Kbz6ENyI#GFR^#29(C|qY@;$Q;k$B#;a7CJQ??T1RCjJ@1qkX0wtj4T2D~HX zK{PG8(*FjdpTn4$M5o)^NM{O-8Be)r=-pW%60g|!xY>h4FjholQ(>grORSfL><@sB&{(ux(@XLI9-f1@hbit3A?+4clKheSlM zu&b=B;DEDG>It}?7Lq)P1q~Dh;)S(n!Vy)g;36I&2T}8W!BxV{;J}B35klRCKx){4 zF2$W}rD?EnmhXtif|K6LY>rl)?8RqlXmC@`SKyYOY#Pam?KTo2a(R3{=|KJtx|}Yt zBF<4M=F?Q)K>Bf9-?F+>B?5{OqjKS}g zo3y|`Gf=x(7MDV?$Py!yFeRQ5b%z#Q)F=DTi zHZWB6*@Jd~P^raT7Ee4*MY~`E={*z#o++$+g;jI5=SFA7o4piJrRqKjBc)qv@1@I> zG2%?g`93fcU7w5V3*pg43MV~;k;a^S0o1~Ise^b&w#Rw)-=dsA;f~XFh)#buZY+Z7 zjt7j<_3ZCk1!ojasdS-JuMD5sexMU|x!xf)^t}y8_uCivZ{D0H?#d$V_vi71(+b3^ z;pTgI0QXBo9e!mQ6l5YuUUG|6Cw{#jli-a54R|Gv$XAmZJwIDoNGRFtGtqafD%XUf zTm9YmSj?G@!QbIDBkE|53`pJmb59<9OrV#9x>f$neUz)R{((Hv(M3O&3kw|y_@lnnkQrPMzC;kh zJuib%naokv9GY6VOg-iUixEq7t1KH-6B)vp=Aa^)i|BCP|5?1jgQ!`gOd;$uh6qMk ziubX&@#Y}bqr6RN|6?`k%|Xee2)bu3iG=zgAVO9JgHW%dlYp0Bp4kkKl@fK`SAthw z-OAG^VO3qY68YixYra>|&|!-XfkreM#r@+0QHcM`ofphT$Auy|EAgvcK2^DaxH@}o zyCyUOmrr#RtNs2gLmO-p(v-GO>TIqYx|#TwXj2!jAC!_0FKM_oBw&RnV10>4w!O%S z{l$-2a!1pxfu|5Dx2P4@cl^Gw?Sh-9w5<1$L;81k+&~1 zDjKJVaZAAd6`gURQlcKl{vf=9mBG;eprZmAivX;{{c0heMa!S&#YnH6h7kXzzpMQl zMDLmoM<+BuiKv#0^pxqM?mCmH1_gn5=<2EP#9+my+~nVFQiPO$e=)RxKE;_3cCr;J zMv`)I^hs|XNl^f+0a7ar4-|ZAieoxy58khwZA$>w^xtfL5dR1%%55+0&Z3pWt(Hv7I`nK8^R)XDj?`AHiYCtVp`MQ+=c zQJN9(L{tyL?ZdM&2N;r~bJl^TJ>9dfIHhg%0%G1n8q7!o9Nu!)#SIa1NAb6%7klOm znDBA)yTBg9$mb<|W- z-5nb)LAUVIz3T6AB$dH@#!VjKVHYh-x;Rilq`PgxAPH4{AZTP1dM#(2X~z?nfU-=j zi(tcI0U92NC`a%%1^zQt3ry5kay4x*agKl@@E5qgRc;SF5znzG<_a}Nr z0%KH-eSzEUi8A#k9gw9`L?512SF}?|3MXEIb>)t-yq351k6e^w9(D(j{+`Tc`-`FH zXNqpbetL^R%&*Q^kZfns5&vKH@r~8a(nT(1>ptpOeO=t5%DjOyuz}5t#L>z0E8S%8 zAx*^I+iN|uuyX_Le77Bw%;>p3V30itGOUGsioNRCied*V{1ROBomH+DAEP-a zXPLFkDqUO|7>$jMcZwEAptrBP@)=3;{x+6Th|;L)(UMyjVQ9(gLdfHCg<Cdm0i%}alglGkB<-+zYOluKiW!zDD{oJQWB@73#Jdm8$r6m&Prvf9Rw(5d|2J}VD z4(LH{6*z?m6W+Y`P4*F^b*tKtbIc4oikP7mvl^5=U_)Te{n(|FmchFQf1y;J^KD++ zbJv%9K_i@tY2kg29Hlj|%(z!STFz_kXWQ;vn7vvH*Mgy6$LeH$6VQ+`bl%gW8q|eB zQ9QN{96BJdo>LEn2fGY8bLpk2nw_BFmdt3gsHT#O-q={->tO^zx;4%b8}=7BBY+M-iJU4EjB?ypW!dtngUVI4@mHB<(O3OT*StKvCU&NL+9sauap-+Ld z4kTwWnp}8(>n!i4i=Hc_wfM)_U&o(CuIH*B6UL><{jKB z?}f$G&5Fh3?UmdUC$LM|3>@xc<77#Nb?`>^`ZS|A5ayfnobvQUwKzQwXg`Sc!L)s) zdH`2O$UG2(olONv-c17e)vv8H@(VkJqEj=RY8o$FrPFra`Q>a0zsFD>5w}s1NHGv+ zx~B!QHbGM7o+X}0Ctmehl#2+3p!m$lWx?NaqsK^Z(Du7|4oo>(=J#9G97n`T1?`T21~E%_#=6m zzu!J6GO4SOmnr&<+%&IjWCwV)`@&|kQus{x{8H>lGa&8X>N|Dl6Oqz>M~6v$tS6f*8;c1N@gZE_Af%#9)h~xr=K?qn^HgPx@Z3<9U7yv*m1;Mh zYUb`_>Fw7VNl={D`&2=)J)q{QDXvI&@9U2RA)g80Z*6N%9&w#U8 zn$h3?))c)neGyB~p`6N63Gb%@nrq{g0_7ZADY96vgw`coO4iBTcBzH%h(;C@3ygbc zT{kx`oN~_qNY`y|veLgS`UHj3WfTqx|223K{=zUA`etP_jb-Lcsg*EU>bFhcCL`N} zFyq?g1)QQ5Hi|0_pn@-WWvS02BWF8q~QD6kL!y6*Sk69`fek>U)* zA)T3Y5v!Y)JIfx#gJGVKb@W>U7&p1rAZDYY?aS)kwru9DP#O|z_XQXB>5D%y&}zhIC-*FR8A2xyJTzDQw}Ybfp%| ztYDX~k%Ov2(@aJ@!=(>+)|ezp69oTrm*C-6-I1Mb-*tsT&?VeVzdHZNL(w|oqCcd` zzhf+zo$OQlZj1^%QD5eEXjE5^fEDFqY>$d@5`n;(sjFxK0BAbXcHwuzpA8TL{{aVt z-#u^co7B8BQ`F!50006|RH}>H!ErnEkZl=le=WJAcki#Lt4M8wyATW;Z5X^tNBJI7 zKCE@_iw_y?89LX)8r--7v@Xi9V$Flg+}iL8I4CPEwHHsj_2IrV$?lT!KC0osd|Pfe z=khJD;Kl-tDYxO+--xtdFS={qexxq5sBgJ?k+p~*ApHxlY=m)9rThRRparh+(k_vf zp1}8A8w#ay7l_my8p1yPZKu{dEh|G~PO+GF3UZY80%YSt{!o9=wf{jo>VJ?q47>5& zG5|m?Gx4h_@32J`luwa+i@#m)BBeGAyMP#Z z9Q#M&0KnXPo?=DwYy6t@mm4RHDVEl<$SFP%wJI#cC#;LkwS-U2TJAMlptuv~x|TwV zZJL*U(bbd7n88k%Q}IxO-OM6rgQh}7c5VD~t-~h9UAiwYS-!n~HJFdq0L4^@uK*n$ zz6H#kT*WxFW4g!?f<{ET;=@)5lP~K>hC1MM5(9Ja*`*3znh%U;M-7}xqDC#3WW#!LI3_Af<1L^lmZxV(DD_8Bn2(U=kalY2AAMAOT(#{n}QntYR= zscizRzRv8x2u+6w_@2%mKqS>vE!~}+F!0N^zx}ZJgy0VzyHLy>lsfP-%#d+!)#IH- zoi!l~Hx2&Iwge!coi{UK$$LT}2u2gX-=OHGsK`zA4g`ma4#re;Ptk9GW7Is5mt7iS zi$kL|4+}63=T)T!I7t5{E>dsJh%N9*6WO*&6gifo7ZPo~ARf~J9VpW@VYe^(-jJOX zRmA7*$*X7QPzcb}gq(AA2Pg1KUbVqm+x_70wv$4(`5J-WiqS%o-cYziPTohBRCbFf zM7p!Xnh{y4=`IUF$f;`V_he3%H0i(HceC;HyT(GWV%I6QZH=@6krrvh*zzY zs+?jh@}3g28C_kb(GbrWBwN0plq;|jHWRQu!bTXHrd`%)1x#s>4fW-}f)+517?ztx z!ilzIDU4$D2f(oDcRE&z_m;kItTyN3CRWj~5@!IQZv;SjD^XK6wJ% znUfe$0J!R-(_zBimHk4Xez;AQ0H`byhprv;nb*lG>N1*V(Ia8W?Dfm~8aX{|TYuz= zNOdSU&=G{tK^{R{kFRXPKAY6lmFk(zW{Noe*oT3ax&&*-YH{I$nWRBfCsz1y5SZt8k;L1l9cDyPO(H zSk`y;zITwE{SKvASdK^I9cQbF^OpK3K1B*0F5eHD35SqtP~foKO$%jC;ld+wK42_y zA|WV_)zPl$gcc!^jj*E7e=^F~P5dw-)#Ug_qA@a3KM ztJ8$*gomBg&nTdO5MY_T{J`p)gC0A%>(1HNvADC#jDPgJs0fi{3Kda-oT&o z@C(cn1W`=FzXAuC3<(xp>Y9^262Od1zO;WHFZC1je6I%u3J#mu3rm;>OAW#Jm|=RN z1_Hl>GjwO3ya_UzDxW#heW~;tk_U)60^7UB42s3m1TuVOTMyiWre?;Zpu20Rf(tu} z^|tnb+<<6a&jIlNT8%}>9o4WEPS)}cfDis)*NH1gH)N=*XX`sRT1j|NAv09!C{V5) zRdI@LDEwH%_CI;(w&Q4vjtTR{btf*vn>jcdu(~_Q?yEcrP3H2r2P7~;u8}CV$>{8; z44H07A?Hg^+#CykQIm2b`0M^IU~Vr}qz=|$l%7*K%Cylq)ctc&=cJ7)MZlC8))({X zbi?TVFh?cq_?LhlAM0~G@71{{f6XcSmBo>pHaBlX#R@e5i*mbnB8I5!FoZNXYS(+2 zrO$E+Wl|{69{~2t@1u9o_1$M_H)-PX8saQj8ug^^=-p(^I7IztYvu-bs9w?@9b*a- zyhE}rsa$pOEQcgUrHY{On;Ej_6k%WHf%#Gl5m>A6m}|yMY#+i4$HrlfjZv?1|1F4o zaZ-FinQ|=(j<;+%`5yPbS|DOp3K(8>W(S5}UD{ME0Fj~pS3D_=rDQM5Zj`{%dYzGx z(l}AX3xzmj@mcerrHr8wRk2@1<#eDwuD}<>fghZwosW>P5&l9A&_hIr&WIpPQ$r>y zLtJpqi=oE7y9Qbh(F~DQw3c%%J%tgiYTgA_{VIXa_~k0T5TIc*(5yr&aN#-d=xn4Q z25Zw~PLJ zgO~wWGwK8h9Hk`;evyQe58kfy)5E2nH2lil+p?KY9=JQ`Ns) zPQiV6KuiTK_}|~}-*4aHy@`Dm$+52+L%b{P5Z|tj@;nm|-)F5Mg`!mcVA%hCqsStV z(FY(n_O9d_1%!aX?Ycw>>;QZlf$dgMhrrwte-l@9&BZi$P|detIeUUAEO6UgC~1Hj z5(M@S)j^b=2@F9Ry~q4k$j%6Jl@j!=-D9W(Fb@i@M*YQMtJ(m4Pli-o>cb2hj|VHT zY;dkcaAzKN`>PqR!;oLhmz8B&f zNdPNmT_>z{d&lx48e9-(LyUI_29h6A{p^wY!|(K3&1dm%hJjJy_eNg{zsmW-gRC;) zF>ZBnWA5CwJlvDCmF0AWVzt#a_bSRUL-;pFS`mT0y61#Gd{^Y%s(zC9&wPxm`51Lv zl$3h?{aY#iT409Eum1uju-)j5ONg)vl&t~wZV5Fz+~Ce3Q(jF<-a6;fr7_Zn zWp0Ne85%_|c}PFxH8|KN<^U^WuCHPU`VdSE_ArU0+m`2)@0fC{gGPl{^=GmBfPN>* zQN|M$10~_MTLyZH9n7<+9oEk5B^Llj1Ye!R0f4qQC}A(GDQPkz z)+F{yFnQO0=O@$RK3KLa3XL1vf)1r1MqqfptXsIviz)_G9vXu44c=3i*;Iq+v=%0P^ z6CH+1QGZ#`4czDl)r)kDfJkdi5eY?Mahr$iGx=b+hbUbgy2?3j2LbgW9*W_Z9_-H4 zd{Q7-7fpRT73|6bfr8KM~O3eWp^%8} zb9%IjsAEaWoTEdBiSgoag#s0cOeOq)$J2IUUQr*Qp3J*Srv*;}FAvh@yIk`=C}Zn( z@wRtCQtv|)2R*{WF>Z~TA7ynU$}yxkTGuiS5-#Wi82u&hoO9|dcV8uS1!mM~;|lL{ zTGkMOAMiKeFUFGZjIRsO_P!9+SD;o3I>u$u83%dEkm*Fy!;TL4 zW5VXwef|42mpGJh+lMxaT}>-9yk35PQfyfP4Rl~utDR$@g(3!$3-_Mr6D;{lE%0{_ zbL5O#DdTiou!XvtNU2V_bE(d*{`u_M`@mLjiPUtKNjpvs+>nA~k}Nt`?hR8?T9h7y z=tiWRXyQCDw&=}6rhL{tY{;qe=-P@`bu8>E?l<}!Ljs?12z>b9tW_hIcndN{byZoT`GFsZ4}oF-2xAn ztQavs3+;j-;EhcfM8CSU<<^3H-Ko9GbcwSn;)Q&Nk6{%TyE8HgDVabhvj3r7-^=zJ zryMb#yH(+8TjZSvrK`aTU+!>&XF2bGnf<1$C_To^c4F-6}ODsB4=yGW~ZCRG3-8^%gSQ^GyNHBJGhD z)Js04?;nw>-g*+S1`TjcCC`-wpEYbpt)KE!!&Y5NOm~?fBTgUJFH2c2ialGwh)(AL zK^&@Th)W%&<1ZA*2>_$`Pr>(1TrJHOVh!Btoj$!e{B}c<3d+MF9Ka#$PsO@#$WQqz zrNj>Kfz%;=9o;QX%QD*zP65CAORg(JJf+W&BcKYubm@7wYZ zfo)a)hE|^**YQ-f5B-bzZG#RUH6UGL$NL{Y4yj+zqQ>w~Owv(`&2{b9P*}mayyTcL zSQ)umxb_`zp$_=p=?%WJ^Z9P{gfe}{`}*P;`$CzJ{+Y>N95z2%_dp*rTQ^xj(kA?> zD|cL>Cf^={Fp!b25})n)ak~oJf7CL}YWqX6nI_!gHU)gz=GI$O8UtHf+C?k5 z<_(l2z$Ld$4Dg^NmOMxw0wqH^gC7C_fiQ7au1|y3gJc8`l&iV0S=x#5QlG<{arNJS z*ZRs&9)c7Al^>vjB|sOe%nwKz046UdO~%%P!2kOFv+h8hp7|IbtqFLi{Xe4{k~{|2 z7&=Aq6MvkWTm!&(ehz3CYmWdz(1^b~Jb0XEc+R(zd${6j#oaW;o#ihn5jC2FVd@%y zgi*vIN#nws9^?jbln8-b(t9#E+n{oQkNNuHh16Cv83~R3816Y&NEI%25ngG};UpaA70JuDW3VbV_X4zBh1vqAR zY+CB=PI6b`Yb-gp@`(ej&;9Z5b6?ENM;AKcj;9#LXS{Yby6nqjhwZV@Y5K`?Uh?Ci zo>)5K`+rt$wqmK&-}raE`+W+Jxv?4ui(mRb`k`7bAJP(}IjDJMd;bJ}0#hU1$&cqiyW{dD6t zb?4|6?N?K^{8>w&lFbQV22je4><*|N-1sduG&T}LYa<6+D<{32fTFSXNNomk7^$U) zTfci0o@nSaf`kiz@}m6AS+r9x0j+rFS-?lVR?By_O5@hGBl`NXg?O-U6DBsa=lCyC zQ}nW!K96Z;?tBBTxOm6GnNtXjD+`UgF= z`_b^6C_bIWBrAlJT6972RMu^U#{@8r91+nPB#LMHVu`<`3jHtmws~46CV9TI``(-Q51}MC&y^i1<9ixN@9ou@1lE1&*;B+-2M)bBO&_$#}dQN zycb`Xhhfd;tM;np|K4sIfO>F;FaCCaWPHf94cVU;+iLjp+&47qorrn29o@aOz` zvfRCDi=g?rO0U}vdxTCvLFg;Z@!etdbNNeIfF3cCFjlsXT~}1nrqkFBL$pcBOL^Y|)2K$>ROuU-vH(<9(K0yBdCr8V;kU`&}1Mx`h}uJ-gO6I~gL* zg8@W3WZU$QfEjx;^wN474-ykf4spe9+s?jDT@Ioc*Ei+h6gOS9rPIfT_3Dq%qB3P! zN>x_;TB!R)re|;&`=WmpBP_3hOeo$6OS3Mx!U>Z(dJB|P3E7~TRh=YcBaQ@_135+7 zqA(Z8Mr(BKR`Yuex7@`*Yv%ql)36MgkFhva9~83ny9g}ll;V~-am(i5tV&K#H285T zE_Q~pXt~)$FlRVnI;CgMnSHz;ArWyHGv6b?X3sf1$Zhe7R5(pk8dt+vr+ew68g|66 zin>3OW15_yBR$+CWwuit(EX-OZDh_SSGvk@<1*9&Y%`7_f$p2ob88+;ufH_26l_HF zArV(`-ivSWNNv=SiNkgsPf&4r+Kg~QyihWql3`a;@iZ7#9ExNFu50y087R(q`{?T< zIc>1u?=tX@2hosF+LGH~z;f+muKkjk;G21`Y@OR?_T4N> zx3#pshTw=!Lz6OD-%{(Qv`E+8X7-hctJuimlcad*J_RJC5$>eKrWQ0tZHK0L2K&V?L4$f* z@jP?G=Tdi|8CJnrJm+VET!M0QL+g(Mz1i6$T~DBGomDO7La&M`vtd>lvhCIG2CG3Q3y3UcHKwN)siDd6(82 zRjSISEHl7Fj5Jr%uZSN7idY$;co}T7H)O8ZyL^Wt>e$T7o9qmKXzxHmI^c zBCf?B@>;-MLp&Xq10@P}4GmGh~dOzWb# zbuMS>f37q`Xi)5s0AXPEixdfR4Jpd>=w80-<>fSIl|S;o#@Ff`Umu>30o@q+%xb7z zWD7PFzeK5w@8tXVah^js<0IpYLYGIr)_^LO1@=FH$?(Ya$^Ns`Wc+hOggEkNWskqK+JOBwMcC{qFk@IQO&_Lt z^S}=$6j*D$%ZV7nftASUT~BO^=B3h7b8r7@YRxpDO(owoby~w@(D~2(mo6f@j+A1n zxzK9|6l^4aCH-PDQpM{cz)*cd3IN);k*r)L9o5uSBY|W`-jOlg3kkB;va?>TB2xHV z4+|#EMKCT}_lP&~LYQ*5h73zuFKdq(%_(<&vm^e-qn+mtWGSY-#xGRuq zL{SmGw2l3^3$3nxyDm?Ik&x2BQT<82s0Ca(IRNstQTbVZ69Qtp65K^);#I5hJr03< znp!3^UbKXv3+ZiIb?F7@SB(UHi~Vb#S*f{L)8_U!+nz1rKz1dG+-@~Gv`r?O)uQ+w zV$yt7#$~CYc&`?=!M!Tn+$-52#q7*5C^yRGF^D5K>EP_WkZHVt%RNz#$xlk^@SY82 zRp=wYpyR7M^UOL^Gk@ZaHtutKU%&$75Sc6sP2?gBbCH)@__tCiCzTR&Ip$OuaX~=J z!RP4WIcOUA)~N6%G~L)NClif)UC1=`0>M;(sz5F zAVn~m;F2UZOZ1VznZTVdSAn?L_30)Xtumx5flPl7x+X^KkA3k5!^W2`+8g-=j)rI5 zPxSj#9q82o?);56ulc!=V;#=?{Pms;01Av5quWFYU$<}0fo?p3Di|Ytebu8}8W`S%NsmZjHKWo7;!WThJD&_Z88v}Z$-K}`Njnnmh z2#lbqiOr9^Xg~UH%Dl2}g(Lq&+SPynJB_6$hZe0xvPWdK56Pcs9r#~fTEA592d9&p60x~bufVRhFi0v$P> z+0GA^9c@VyC4NfUla*3t#3NoPVsS*Dl+aNOUyXvyk-L4y0c7lIUD3D<{6Z8r zD4#j+)olbH8XN}FHvT|%)vsX^`y+y=g8B-k}r!b(yn1P=X3WqAuDxk_*$QKwPJpwg{v9 zn>SV2rIo6?3b5SQi_H~d;u0VZvL8TDDJGXpCDD+~i)hrX-e%Svf&Rc_k$2!gG|S^zrK4g|nxaZC z1~8v4wI!ceS_5-|RXHznV1;WGSLU&Alkx1JO`8xSV4=Oj$OiX1d36PXGe{d-ncoRB zj@GB4I>Gf29k|xeK?p_Fh7Ia#7ijtKYN6&qXR$sbP!g?w#gB?QDM_HS=~Bni}%ZP#@p>tC>~`)4m333D-uT zpa<_MPBeUG?@IKwE7#lOMR5J_-vFEi zOl?y-xuBc!XkBu=I~h)kRP)~4jMPozZXt+7e8XovXX$mueK>+4gyT(U=>R5q@0vi^ ze(wdBE3f|gYAW_(?t5E*WFECLy{ME#0^cvEo4mTy zTr1Z_+^o5o)R;}Z86fN)ZNrMetDFfHOt^uK@dmI=c){au*u(l3X+;!5#GUiS95qO4v8+!_? z#cE1xj$~s<>i7FM1EeyRTL9N(oG1j-{a_%&Cw~31TU*SV(eoDXafG_DcD|z6(x^+T zGyhsg!^c*-mjOKY=5zMhcMpVK_2t3MC&Bw9aoxdeJW$NpKlA!PBYO_S)Jw@)s=lGn zAgdtRGXd=>UeuEJcs#1J1Ckm`()cqQgEE*+{k7-78#{kr zv;lt%Tiw-_qiRL=r|_?^uu$2|Ay~X$v*H5=wd&TS0M)o+%D8M4U=1U74WiGNB142y zoo>FA#=KHvE>tn2#+V&pdT&z<`jPz>nEHM2n+;qd%_S&eFvtE2KLU-FM?TH3WK4iK zsgxM$!~wn;(3nOOTWKM9VqOTe;d|5~-r+RO}3e>L?@!I=f^*6$nJnAo;4u_v}|+qNdQZB1<3n%K_7 zwobn9|LfGb>+0RLFP`e|+Uwa1n%ORnvBvHSOt1Ml-c(tEbn;(cfBYaO=GxkWJp5NR zw2AI{YP}G-z~X9DN?GgSQ7#<$0$epT%0bOh7<=PzGzRA!H$ryx;YP&qfxyy`&Qpv0KOJtS!*Dv5qXcb zGlcE1rS?s)FK9*%v9+*uKzsAIczCKQ?~_|t+2a==cW3CXtzeZ2CeZ*SK(51 zC7Cg+UADq^OXbK zzBGSSb9-?=8$iLVp{m>xKkLR)R4P?mprbLOTsI9*RQYmsG-hCE z`v?UN)^zvPm6_*)rt40X{suA`N!dC znN5KLm#pimc(n71&swGz%E~((#R3ZoO4GS7lInF(3>uNZDdWOhr)hB$FnnW%nUG;- z$o42&MExw`Xo%06W$R>1qHImWt%l(-I}AkY(G^!j?h>?1JsX2M9*yP%1&mK-S0p?^ zsRDn6YZTzfL$z*n$^-3=Wa+h4r!Ye+-dB^i7EpTKk(EIA#Rw^_RTx(>vo&m4M9ug^ zF+LS!7^g^wE{Od_U0NdZz-ccf#?Z#`$H&m8c2^O$z6eF-_+oJ=sF|Im9CQ{6JzQuJPwfnB@~It=Rn@C&%;yz11SakrT|I7u?*1Y#mj)A8G<27QPB;YbJqyC|g)@&h z!=K$uqSLRBpA+BkPp@F42BxPP8h`m6P!0SDV~dlgM~;!F9_*8IJI5ks+*j%xOs4$A z21r*3Vq!u6+blpp&rg=Bp$2Zy&Xe}Hp+2vnoM2<~4zS@1cVFf@h&2h7)YJlF696Dz zzIn2cLc-i!&V#0NnGkX-%zwJaKZ{#lU^~iWs;)(y9Q|9!bFz!pKtcbZVFWM0I59PE zB$wHRH7ay5=qjP2aZOm8!V~srQzo5sv->SO8Zjx|kXbWhSd)Axa>0OtyqxSG4hn^q z8QoN~rv8?Tv!^+?jirDBqIf`;(41FVm1CZ91nHbOcvTHo1n-H;-ndE7un}xLy zN?heJPPN^e+a|SBvfiX*-AUx=mUpmfZxymDUMj}p5k{7caHeu+-DRCJFX59b-&PUx zSAqkMbX6BIvv#*q%BkV(^V3l;=F2jcBnHl;je~}8aSvG;>rtMnVJ&-&fc|v>@jJ%; zO%P--Xx29tFMQ{3=-nnjl8&4@Th(SHsFi&MEaAuVl$otJ2=rYt{e@qf++cLS9i~>@ ze1j6@YP&d1nwbe6YYKV?Bl=#+ys;c$d*nD}qzQ*~o+R zF?*j*sVbQUeyJRO(SCQ)blo~zUr<=2^nt2w`P+Np9KUP7D~0wXw8u;0HLMHOZ`qqy z8FrHwfA_1DeFT61VxpB8bOwut*SfrguD*ANZsd=kJsL9+fkJ%z*1vxBC3feqINA_6 zOTXVZIn%-0o7+E*c?l#+o?pgGL6b7J@buD;oU62+UTexvjeER^t^m}Du-vc?Hj6hq8~M#>bONrT>sd%g8y3beHTU4%S2S!L;IByYGn@t(CE<8y5BN zP*^gVDl5TPh1phM4$EDg?_@TcKUVz`YvVJhjpb7mb*Y$Q))C^|#-}j}wAj#*_dP3o z!nszEKnvluTsr&QMfx50y^2`_NB@Aj%kE`y@?pE*%$S*PV%9FiTy{I8=Tx(B@7=f8 z#y#A`XhFb)wI18h&&`%3CGz9WC_bmQ_ zUTVWS8`p%XOWR6k5SE9u)!%CYLTod-1=5=)fZ>QyktaKt($}xo0kvj?Jc?L5Uh|Wj z>>Z!&_J^N{UT-u=b4M(#u8tzYN5ySka+(HKr~wErf?G-%S|7_*Q?N-I|3;nWnt6St z|H2IPJm>7>Tglmh|hqKTI@D#-;O7 z!Ti;=u_*Xn4kJ_$ZzS%XkeB^oy7pc)X_oShbuW|&=d^8)QErL6NN?2oMG++jKJ84W zp9JB!HyEDd&LMo^96(sR-2W>6SsSovW#sYafWuH9D%QW6Yxt;c^oX+mDcGbD3gMF# za%;A94Mq{7hQEvKy1yR5(j(AMIk(MJLfK)D;HUb?~2Ctv8*K4$K9Wa;U~i$}CT zb3moKA<#2=j3;||3|EFLDZ!ov7m0S+S&{_Xz0Cd^6@jS85!RI=7A*Ydl;iWs6@DBv ztO_Y@r(vl<>M(45a$4L_+Kot~k190^sYxnDJtM_;9>oqf1`S!j4W50oZVz4u%Y+<$ z*1>t*C)W6uoimo@O=yS^(ejr8>^fN=THyNE!uj^-i2*xlMH^1-@TM>{R0V-+_Mwev zVFWVrDpBns(6K1!DGfp7Jec6jIryw&+%QJ%))`YM_`FzEeTJ@t>rI&)$f=K2Aj9%I z9s>enRLg-Eo&Zvjga};MgPrjOtjMt+Kh{Eq`p90j!RIIAX>CLxG1U0xj%HgAkV=SL z)IYqhD>hst5Ipm@puS_yGRB+Yu_^2dMbfR=DS1hNXT8+Dv`|o98UoyPM6U+@gGyeA^jCSw1s1b+S=a(g;f z2R>c?a0ah=><>pv**{GZe&SWw@XLRV1sW)|PkOWE+|YYOS9(HM;PcDHqvQ5Z9K#Mm`GlreAt)dy&~4uVaC6(WE|oaiAA|PS ziKHMRLTxX0uV}(T;3x3dn2;ej9kG3-lY1l|zZtG!*#QZ`sc)q*(;3yqr=bOn$^+t(e^IZqd%}~>}w#KZ(i#J1}%Z~HNT9$>k?zh&|7pz`Jq%JaqcUH8l9>PCDi}<|= z)dxt6Slulu;C@Ob;GQ}m0f**oZ}H?(bcX<1cxlaCM}6^xGs|d$w=oFObqHw~=Ex;p zcdG(eh!UxAwA$Z>P-rsOB7p-iS*Pc?4@f!*h84I)oqdL?KiB+$tEuX6de11c0nJ9? zT4w()Qj`TimtVrr0rHMX9pxR^(9}0f`tPcf=f9&3QT%3)a&p4+H&9m?37}aJtUR1Z zOE>6_v<0;4II;{AR6ZitqV93L-QHjG^Vwm(e&EDv{~|Gtnvp$lZ;yhPC2@B-8)E&1 zT0=}`3GvBJ5e5d6FYsgsv6EowP}?LkVHuiJ?U=2kaP7~rxbc?EaZ3~; zo`)d3eahlN)L($11c@nmy=!F5e+!hR>UTgC*|A)syTKEbfzib#V(sQ38FsRySK;sI z5z?dH*KS@7lBh38stlm@JHs&_K?&TpU*`<$a%ZCSJm1LW*$g=jX%yji3NE2-($fq~ zq1)9?=#(*4gMkx&++Kl=Z~eWaerA`Pa#{)9T*vVu1;AuuLR9N|zXLN~ey@mf6~Wmk z@ba`uhD1d2E@|Pa&AVs{?u6Y^neZ8v(V()d`4ZGpR@(kxw>)t=dpdJ0@waAx5`^q@!jcP6wk#}X!Ue?nu|BFp2wN*_>`+BX_H(G%ALE9IfC%Hr`rE#EfxNPa8 z-TK3V*Z+|Gmo&J$jqGyYs^+q=`9b&%0d406ra8P-54^(5nwq*(?=%= z6$GOHShnB_aSH)E{UbXL_jJA=Yi%$mBbQ=?h;il0$TAqRy4LlU$;$qv~iOMU-(SHbV<`4s0W+#(Ac#>1W?whY2dtK=Qmb+*6!d+r!jhXx16n>;jgF zq1OYcY>vCG$PW~!NjU^SlP;FM5+z0XY&4C;u-~l?fwIb?uj_LAv4}=h1roCKTpLo)zkdVWiuXwqxOSaUb@@}|rpkSYON?3FNhJEz73RbO zf4#h!sV(3SzP6o9vn6oaw5sg#{nlU{B&C7E6ETc|)wktu*!{Vy5!37s#_%e~qZ95N zuiioWl`89w%%D)ufiIU%5qY?F6uV&xWt05Bz$(7hCC39D3wnYrd1!!0wQL2 zum-v5l9tVZbj1Oh4U5)beIZi@`;TDaPoe@WEYU31iCan@ABHs$Quc6z%ZHoDpndgx zyB11aoMRhIm{4pdk>$LvWgJ{qYF`fi8=Szgo)LWs)C1`g0Po6roq9~vuXMIpJ4m0# z(~pgQ;qtY=Z2Gjh4cE=?&$B4SRM({we>)mr&^MdfrPvwUw&P*#GYze|8 zz0rqp3CFA`l;9BC@sg65M}a54DYI))BbHAN9T9lSbHg}r1w?n`rsznUnl+8g#)bwK z+`Z&sTzvLKxztLdZv#xb1vVqij%rAxQ$>2EQHgrTtOj4%1?%E)7g8b_c5o8g6}d9| z;RP!xXa@1co+>uGq{VAE3B{p7TQ-a&C-K)I9Cya;w-RoPsUd4ec1*WG`)-ZL`5BGN zU`YfEm-A1~pOnfye6U0%DCpjOCcvBwmOLM*5W1?01zn);z?#mtBJVkM@=99@ z`Ybtx*_mac0srQeVJe(?GRYa{ldho)W!N@jvrRopzb&l6y2~I-a|bXRZb>mg2(k5F zhsM{0!j8jTg-X;cibe0=j^ATMtk|#LR`Vwoy8`(Y3)~o3xAHq%W#YIyub4&Q5igIg zi#%vt?SFVw#R_#T-B_n^>vuV=!RR%5JacR07x#(U zS6d$QG;1=p7b=p+;nGT2bCOMb7rbF6$vAuMC9l!jYFx=9*zFdL#QJ3;!&>8Dz^T=BK?c zv7%MB44}}dL*^sVz>MbU9mWZM9?=>7(v1NzWei`?n5oukCh<=%@6htf++F;XA6*eL zPd>5~A&1K2ZfOsnoab=mK}KH?(58*(L|}KmaWFqAwS$fb+u>W>{8AH9-f-^Gdk6Fg zpx(+cmjUjt{4Q$h>x!L7Q&)cB5$^Kla;B>j^q`;$guX$=wOv_0E9%7ozdCa$3W-|r z)ZBB`G+3lY8IkPvzwhv)jm7eS_)h4%mexBLDwi)~O6oaHq8WMohZu0KzxkT7_qHPj z;`2qnk%R`cnmP=SRUI>^ox(`f&8dgfy}#h3)>JW5*-qi*X8fj)H)_b1M7FOQ=_Ys- z`44>?fmg>d>Q``@aYqoX_bQfo`osSK2p(Yii>T7KU^*NXy6ej2(UI3^WdRsx@#3l0 z>|}-{y%v}#F0(3_A8^=sho=u#X>;pnVq<0LIvsmsy(B@*j=8WEv6}T7SE1w>6qV9s zQh2kDM%-Oy1TVvVLF*|})H95Y205G3Ka`tg6{qva4E2Rx&-tQbcw!#qkbEO~*Eq*8 zO8%^34=eeLouS5csP4&p$zeppB<{=k1S(nrxC5=n{~n}Fw<(??EM0eImq7lc^2fsn zSyZILV?&yc2@{Z?r=IELWC^xnwJMSmMizTJebvg(VBHLWt;OKQd0t_d{>rZ#w*NM% zE!gIe&iEzvM&8S+WOzZ^c{|0^mS1S8K#WwJ$bS)du<{z*p0QeOKeDHzqfh#h6vf^- zPPxBp4S%8E9$00VxK#3P~jZ<`O~83`8J znIh^_5H%;duczQjl=_K9KscS(u4grO2{x(B_)iEgKFyLw1Q-ME1*IO z3DLK4!*{Z>&#wQPf-j(64BCZ*Q$MMS=rR+xBH+Dy#F#+D}Y*F@LIp~g7Lwly)Vz#u+{8L+I zJ6A|gaTX|IQo+lswV?JUKXXA@sV5CY0iH1X5Lvl~7xT}p#{6kNqGMp4cev}e46G>7g8yKmcwjC)~TW5GXL!uw19w6@@Tt;MD^%`Hg2KZvMhmaU#{WgZaM zy?;SLCa!ey4TdasTsVVKtUwD6hRS?_02D5n(S7bRJych(8boyPtf2ZyY$f)f?XiRn z#^dBEuqPX>D}F7$Q|3bM6{}H(FqW3_7$iS-b-56glL&e=os*z8sKzG=R5j0=h+R;# z;zDgWuoVx_?=#Wyik?PqRN4a2&Rt|L;*Sqph*2?m>sTqbM#x{}*Adv#VcuwqFj(#Au~NOWrmQ;9I;%AuJHGuB6hM zW%JiS6zj!Gu6$qeg%^#2+-({opdIppZAV%O8WdsFWw1{eP3}Yy7z2MC$)V{DEj`YL z71RIXqL5AKaOmcDs(W`5Q@>1p6}QkJEZ|k!&LKJLqrExb48?_BTE;jQi+q5RZ2i{` z3%?W_uC0!$TGjZ|SPf-4;GMA-}7&tMX+SFF_fwTgqdche^}FpY2c%<=uSz zbXyAaNDA+gx;?{>DcXhDuqircf&joX-J>i}HU60t)&ssy8iYuB2~H0TdFXxj5<~X! zK#KOQj&?owG*X4kjmMz8utc$U(uA_3Ka<>;R8qjRL6v?`W$q=&_G#{~3QVB3M?l+| zeZ&O}FG``rVLs#$1?O>wSY1rtB#Fm3pl3sOw$Ru2aGvd!x+fWTAKuTrreGiA2ClNs zjw`mkgNxa>P!FT6!udfbdx93QWPqyh%!S7Kqq7*ymY;obVP-y76JE}M4V-^ zo$y_PWaHs_zGDJP?GIV6wRt)qPf}J%Ip$1PxmD@oA`a7};nld_Uan3@C??~EhH$U@ z;KkHV$M~Mn&|>a^ys%LWfN{e-E{n9oRUah!?_`8qd^4@z{PmoyuoELn+KhcwP2rHpXRY$R7bgF!2ptLq?75KFoQE1!d;T!4mn%th7p2#l#T}^$T=3e?+*B zN)Rr-z5HWtQj&V~FU$etV*;%UOc@==qx8!#w_W6(QOzH{`$cN&i-f7M zYqD}FMG?`m%5tS!uegeZq*RqUB1yKT&!~0ni={kLz#9{9Cx1i=t=Vhx|Sjhw?rfbcc$txJ+OJud>M**Jvx$wE4&2ui?j}+ z&$UycIh9SbjCrcbv`SjQcn;gRy1alUg)~8mcqAXs=N)3+^E=#c zON0W)Y0iGkq5MI|0^Rx`{1-WGAhCc1<)Q_8d)`i+8lV!Kvg8bf_{TdK9|GOl3p;Cb zMe=9b2H0{b?xEl7va)*TtKGuiFbg%NiSo{Y8UPiSiny)qA~3E?6=hiEcuX*QNQ~sq zb>)zFF-T1V1??Nxeqa?};k-MW>oyU_a!v#J0cLeJipW9exO=kFQfbAKdiw30=!5OK zMWaD>3a7({n1)6dp}rLZdqUX#u!Q8c+X5Fa$gY_Pf51;ki~Fm8RI(VM{%Dagw6ZYX zwXl$j;PIc%-m_n({7`ROih1ASSe-y{g>MG`d$REZi_xxEkRCXSf0dc)h%7+Ltt1{U7ZmlrZH0n53;t&W^*{*gN<2Zm&A8DRvU@T8~(> zQC~dmp|C@Wl$2jA_0shQ+z#@;*BWUI5N;@M{OKMUX5ls5j7!n@v9b!f;y`GR-u#vd zRTS&i+i_2R!~ZGa{*ngR0ALE?m1WCm{lBG<(!;@i-#mSP@?TQ_nm(I{Me9Q6*$wUJ zIC;WaVZRj;I|1N2|4;AuLrx!n;O0h9;WM`Fis_3;3jp{or~Yh~V1F_RD-HL>IeTT~ zpa>BFfbB2$9w|&zw~8`G!-+2tyc@?_F7Us|yC^EomrpO^AzEB?+ax$TE2J|5KqBdv zSxpyHS{83HVN}e2sS)8AvO{?UEX*CmKA?1%s65q-Swa+9K2xJdv5DR!EYiq}O3Cbg zG}!3%;4kyq#x+2~$t@$Xqg{@R)q^$gC?w+B>&Nu8w7$I|Mv*l8lAUH?Bq@ahn90vm!X!fJn317j#`IR zQ5wvsFIs3r28%e4;m$Wi*#aDqtog;|MZ&uS+B#pI~ zs66_q_XY|*o@A&|d2LuQp0U?rD^MC-byDpzN30+sG@c?rWkl!}e$g^NiEXO+l zLI8B*@~l1p3IOjLME_48AmtCFKaIzX4n_m?g3IM^`oub<3tHp)#E8~4i%-Sh$A!I# zh26))@%4!n3Tg&|yMNdCgWAiE?(|zaBQ%3sjjY58{}=b+DaQRc#@UDJbOb%4GXu+b z7}7XL+u7hZrK1DukO+9az9KH3D4x(wS8iQ1IhYqt zk|Vs*{JEe^T-GFXEY%@}vS|k*btt@AZ^XZKnp&c}p>?9f#a>wa=0iy;CbT7Os8N7F zArv6{W!wLMFQ|qbWmo|uExlB&n;?HE)<3!5**^gCzmkFi-!%q%h5NG&_#Q}$Qqb=k zfPd2p0O12+#Sf2oBSnSZP2+EaLLYqsdB3Jp$D@DjdpLd&g_6?&;C}zTqppG9Vd~y) zrhWu_I-Er~n_HGY4mGJmI7`5g|3q@ybfl5XeCK3QMP#r!)#y;4D1QP`>R-DHUfGL@?nk{ZpnHdRO zP*SUXgF;{A48FAK9gh#pa6*R*=$9V^pO!%`_*li3|IU{R9cN9g7V2^iifl2`CI$novJf{22tjZxNf7mexWo<-hpo&5 zgbrgo$@>e7yTl;Kw$>`iRiucsfb5@tmC8y7B!S$IV8Rw?u~5DJPOzStjP9FVJRP~e zA?eOaFt!@yWbg}e9N7dhBznE5G-SmTjT$AM0!4Xx&<0Qs6HA8yGe~OTX=UV@t&8UmweGOvsMwM6*OIjOP;JVn@{l;-L8}$UQbt`>%M*Bcj&2%%BTvKWvD5vyDFinO7~2&Wm%-*a z{?X)Bx@sX0a(Y30TR=&_ZTbd4;@>O;Bpc49Z9;OeGs;{eA7EfFSCt(kC_#KYp+XRK z1xoYEO$FnVn3wbXn$RaTdJ7KL#Y>|z=Th_V*bs_#E9;&;HqVH6n@Gj)yPAtr$f5_e z@ECT}`{2lpSW;;Bz|=x4QJnoHANdMB{Q^J==Fu+eyWx;(V!)Tnx=TNFLshSV1qg8`Xnwopk`iX0n#Bo2qT`U?X9&z6~eyrAv{Oip0-i<=W z8CL0@Sy}k`X9g8|)4P#Jf%2eS*!F!`!D~YpWZz{bTlt!jV?fjCN?I$7M%kN~)3Ko6 zdESc;ej^uZ9Q8~pzBVmTIrr}{Y^dt5Gp}IG1M7EH*cO<_%5j0%LB8n8#izI@%!v@4M#P zrc)Xezxflg_bPgOC}RG>_}k>-wCAu6bcMl^Enuw?emKsaP3b`;5o7gTaiuq>h3-+Y z((+39=JEveSD*A6FI5&}x$pT8vH0Je7yAt?u@-n0lqWVUgkP2EJ3c-&Q6&;o8cVQq z@|ZetQ&-eU&th<;7&K=`VubJfGi!$rP|&4n3b$ zi4OBV%9O!6?@DdvM357TEuG$;1heZ~yn5N17RSM;q^&LRT<9DL@+{@AT`UY&h&Roh z%p}6g>3M!}YjPGoqUvYiF6MV$pXi`;9;6=NawoVy(?A+rz@HsjqFRUkI|C&uB*`e= z8L9oDg_j6BkK)9|i|D+6b=RLSUU41G1$Z-J^F9m+5k<4VTBR0%hyz;^tOYE|Xde|KB|FC4qjqyc>`#Q_(_@q-iH+;8nqHt!sDKeeQ@q6s_Su~E@P{jFEf=Uw~i%pu!QECZtRu>ewA7xdL42!9c+}+Dr9cXq~hV z9cN2OpOq!_>zug4>IE%u@k3ylxs5jW>Usu})$SxUA}rRTk}N-XFtcDyre%CC?(Qp$lkYHZBRBlTl3$FIrc#~4>3#S-_hH|TdF(omiDNb?Sx z;A=Lq3HE!h%IFG2sf$nX&DfF_A6#?=szricNJ;9?tOrFZ(}k^^U*LQu`_;Zo(1irV za1>J-nYRMP6!9%BUy#(AhnI?Fp#v=R$uiZ84H(>C#faFve%gsWenGuAKy)W_c#Lrw z)4A(&7Ef^!U+^TJ!+2m$oF>wk!C4ek+lMu94fAv?Qho}`J>~7)o)U$KUzU-rJW_&@RnDc< z{1us1%_}HJe=%b=N(l4UNYyu7EvUL{yzk?Vg{)35&Yk?D9GN$O?~?A$)y>ARX>$mM z`$iFer*og^2fU)OaH=0u(KeG*Vn1!|lC4P1 zn~nJD(DFpYgT#ziB+dUh)T2qD5u;WKmZxHiHmQ$UN$u&WfNT#hF;{r4jSo$+}Y(f<$ zgmXRB7&)SVZc?#Zw8}=tD(Nw*XOrStP9ycBUa5v`sp-_C?F;z=#zOO4(7ZT-laM+$ ztnBG6I0qzze6U8{QZYfe&3dv6zR6 zWBiPLW@ZxvSlFxENdYbS{%U=qvkW+9JB;=BZ_=(WG-R@|^k$Q(bP`^;Lo2Pv&~~E+ zXBt0X8stLP#?6Gy9y*WkA{N|k;@aFarADZbl2?9KIctZZ9y3Xg=$@7uay;Wu@c%Db zi2lE5LHMaGMIb;&0@5m?wP`}TY2@Q+vnnb#slX8=K{nXM3JiEJi=K04)nO!Qq|K|T zPYxO?%$*W?uPiBWF%f*ZqN6qA01Z5F1e445)m9goxcUnB+q{v7E6fB{g41Xckd$7Vcb*e6Bs#&wdJ zfFQ}2=WhUpeZg9U2Eg_Q)hinRy#5{l78HGb*^%Ty0a)sGtK@2WMjOh#(U1fV=iy(c z%dfLGHl%`@!5A6|+TR@w*+B68{}$IDj0~GFnq-aoygrl?o;w z^DOclWEpu76=Pk8T^tJ1(o{b>3ri!u8j%+1sm&!TA`T5_#Mc+lwKSB^MU5DTr81JB zJ;LUi`ssmL+Wik$t;PDlMmnZ@|EjoK?Rkld_zb4RQD46qg<*S`v?iX4tR`lA<^}8T zoZ$Zx@24A$K%S1{Aag^94GQ5;v2En^)f(^TCw#BSE6|@xw(55auQN&AJ45_ZV@Qr> z-2uv>F`)a16zIYb6>~pC7`^%(`P>&kyB(u&{Vtbn0D=(`C9SFg0*r6~fp7G>(F^JS z?d9+vTK;o-~F~>RZekhIINch zD7sDUFvXfZX6ks3r@i;)Pbzy99RycmJdq+~=r4xGSkKz-G4|QYa29EV^lMP!vqRHD zs^7mnf`joU)=Zaeb{N$%FkwWzphv{23ev)V^qENtKh4oCzqF#Oo ziP+%3^p*>3ozs~&S5g1vdOc#vY2|OfvnQHOH~srcn7>(4-%(3dov`hb42Ks_PwK`_ zjHE{`64zl!{qpPJv$wwyFho|LF_8`cAb|k@p#QPT_};A3ckBX09;?-+l>%^DdX2C) zvhE;W>37$F1pwR2%YE8^wyWmn?PVwcSO!2jBm#e45fp#}7)O@)e8j$8c*g2KC?3V` zklG+W82iP2Wf*piatf}^<_SvW3kn5-j{@HP{*?};_3Pl?#e*L|Ioa_A;@gCWJkYL| zucZ2yb3_aeN&~@x6;)%8x?w6C^B=hT){p%@tMxp=SlC=odC_om@@gJE{Kr#0PNkF{ zb@jvT`Ew*Ly)jp!naPRHXZAn*CUw+#6nT2bNkVQDeaa$87;qgLxcN|U!A$F0hCWMw zah^*Jam1}#)HvdN4n8^A7B~9k1~7o*UfK}s24xJn&X3mvfy0f3gsrvTthAQ=30 z09;2(Lm=qCmbj+?(ErW^0cY>(17TbLGmn_}f9Ao{B

Gf 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�{8U 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