1 /* GStreamer 2 * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu> 3 * 2000 Wim Taymans <wtay@chello.be> 4 * 5 * gstbasesink.h: 6 * 7 * This library is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Library General Public 9 * License as published by the Free Software Foundation; either 10 * version 2 of the License, or (at your option) any later version. 11 * 12 * This library is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Library General Public License for more details. 16 * 17 * You should have received a copy of the GNU Library General Public 18 * License along with this library; if not, write to the 19 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, 20 * Boston, MA 02110-1301, USA. 21 */ 22 23 #ifndef __GST_BASE_SINK_H__ 24 #define __GST_BASE_SINK_H__ 25 26 #include <gst/gst.h> 27 #include <gst/base/base-prelude.h> 28 29 G_BEGIN_DECLS 30 31 32 #define GST_TYPE_BASE_SINK (gst_base_sink_get_type()) 33 #define GST_BASE_SINK(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_BASE_SINK,GstBaseSink)) 34 #define GST_BASE_SINK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_BASE_SINK,GstBaseSinkClass)) 35 #define GST_BASE_SINK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_BASE_SINK, GstBaseSinkClass)) 36 #define GST_IS_BASE_SINK(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_BASE_SINK)) 37 #define GST_IS_BASE_SINK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_BASE_SINK)) 38 #define GST_BASE_SINK_CAST(obj) ((GstBaseSink *) (obj)) 39 40 /** 41 * GST_BASE_SINK_PAD: 42 * @obj: base sink instance 43 * 44 * Gives the pointer to the #GstPad object of the element. 45 */ 46 #define GST_BASE_SINK_PAD(obj) (GST_BASE_SINK_CAST (obj)->sinkpad) 47 48 #define GST_BASE_SINK_GET_PREROLL_LOCK(obj) (&GST_BASE_SINK_CAST(obj)->preroll_lock) 49 #define GST_BASE_SINK_PREROLL_LOCK(obj) (g_mutex_lock(GST_BASE_SINK_GET_PREROLL_LOCK(obj))) 50 #define GST_BASE_SINK_PREROLL_TRYLOCK(obj) (g_mutex_trylock(GST_BASE_SINK_GET_PREROLL_LOCK(obj))) 51 #define GST_BASE_SINK_PREROLL_UNLOCK(obj) (g_mutex_unlock(GST_BASE_SINK_GET_PREROLL_LOCK(obj))) 52 53 #define GST_BASE_SINK_GET_PREROLL_COND(obj) (&GST_BASE_SINK_CAST(obj)->preroll_cond) 54 #define GST_BASE_SINK_PREROLL_WAIT(obj) \ 55 g_cond_wait (GST_BASE_SINK_GET_PREROLL_COND (obj), GST_BASE_SINK_GET_PREROLL_LOCK (obj)) 56 #define GST_BASE_SINK_PREROLL_WAIT_UNTIL(obj, end_time) \ 57 g_cond_wait_until (GST_BASE_SINK_GET_PREROLL_COND (obj), GST_BASE_SINK_GET_PREROLL_LOCK (obj), end_time) 58 #define GST_BASE_SINK_PREROLL_SIGNAL(obj) g_cond_signal (GST_BASE_SINK_GET_PREROLL_COND (obj)); 59 #define GST_BASE_SINK_PREROLL_BROADCAST(obj) g_cond_broadcast (GST_BASE_SINK_GET_PREROLL_COND (obj)); 60 61 typedef struct _GstBaseSink GstBaseSink; 62 typedef struct _GstBaseSinkClass GstBaseSinkClass; 63 typedef struct _GstBaseSinkPrivate GstBaseSinkPrivate; 64 65 /** 66 * GstBaseSink: 67 * 68 * The opaque #GstBaseSink data structure. 69 */ 70 struct _GstBaseSink { 71 GstElement element; 72 73 /*< protected >*/ 74 GstPad *sinkpad; 75 GstPadMode pad_mode; 76 77 /*< protected >*/ /* with LOCK */ 78 guint64 offset; 79 gboolean can_activate_pull; 80 gboolean can_activate_push; 81 82 /*< protected >*/ /* with PREROLL_LOCK */ 83 GMutex preroll_lock; 84 GCond preroll_cond; 85 gboolean eos; 86 #ifdef OHOS_OPT_COMPAT 87 /* ohos.opt.compat.0054 */ 88 gboolean stream_group_done; 89 #endif 90 gboolean need_preroll; 91 gboolean have_preroll; 92 gboolean playing_async; 93 94 /*< protected >*/ /* with STREAM_LOCK */ 95 gboolean have_newsegment; 96 GstSegment segment; 97 98 /*< private >*/ /* with LOCK */ 99 GstClockID clock_id; 100 gboolean sync; 101 gboolean flushing; 102 gboolean running; 103 104 gint64 max_lateness; 105 106 /*< private >*/ 107 GstBaseSinkPrivate *priv; 108 109 gpointer _gst_reserved[GST_PADDING_LARGE]; 110 }; 111 112 /** 113 * GstBaseSinkClass: 114 * @parent_class: Element parent class 115 * @get_caps: Called to get sink pad caps from the subclass 116 * @set_caps: Notify subclass of changed caps 117 * @fixate: Only useful in pull mode. Implement if you have 118 * ideas about what should be the default values for the caps you support. 119 * @activate_pull: Subclasses should override this when they can provide an 120 * alternate method of spawning a thread to drive the pipeline in pull mode. 121 * Should start or stop the pulling thread, depending on the value of the 122 * "active" argument. Called after actually activating the sink pad in pull 123 * mode. The default implementation starts a task on the sink pad. 124 * @get_times: Called to get the start and end times for synchronising 125 * the passed buffer to the clock 126 * @propose_allocation: configure the allocation query 127 * @start: Start processing. Ideal for opening resources in the subclass 128 * @stop: Stop processing. Subclasses should use this to close resources. 129 * @unlock: Unlock any pending access to the resource. Subclasses should 130 * unblock any blocked function ASAP and call gst_base_sink_wait_preroll() 131 * @unlock_stop: Clear the previous unlock request. Subclasses should clear 132 * any state they set during #GstBaseSinkClass::unlock, and be ready to 133 * continue where they left off after gst_base_sink_wait_preroll(), 134 * gst_base_sink_wait() or gst_wait_sink_wait_clock() return or 135 * #GstBaseSinkClass::render is called again. 136 * @query: perform a #GstQuery on the element. 137 * @event: Override this to handle events arriving on the sink pad 138 * @wait_event: Override this to implement custom logic to wait for the event 139 * time (for events like EOS and GAP). Subclasses should always first 140 * chain up to the default implementation. 141 * @prepare: Called to prepare the buffer for @render and @preroll. This 142 * function is called before synchronisation is performed. 143 * @prepare_list: Called to prepare the buffer list for @render_list. This 144 * function is called before synchronisation is performed. 145 * @preroll: Called to present the preroll buffer if desired. 146 * @render: Called when a buffer should be presented or output, at the 147 * correct moment if the #GstBaseSink has been set to sync to the clock. 148 * @render_list: Same as @render but used with buffer lists instead of 149 * buffers. 150 * 151 * #ifdef OHOS_OPT_PERFORMANCE // comment out this macro to avoid header file differences caused by macros 152 * @update_reach_time: ohos.opt.performance.0002: Called to update the running_time reach time. 153 * #endif 154 * 155 * Subclasses can override any of the available virtual methods or not, as 156 * needed. At the minimum, the @render method should be overridden to 157 * output/present buffers. 158 */ 159 struct _GstBaseSinkClass { 160 GstElementClass parent_class; 161 162 /** 163 * GstBaseSink::get_caps: 164 * @filter: (in) (nullable): 165 * 166 * Called to get sink pad caps from the subclass. 167 */ 168 GstCaps* (*get_caps) (GstBaseSink *sink, GstCaps *filter); 169 /* notify subclass of new caps */ 170 gboolean (*set_caps) (GstBaseSink *sink, GstCaps *caps); 171 172 /* fixate sink caps during pull-mode negotiation */ 173 GstCaps * (*fixate) (GstBaseSink *sink, GstCaps *caps); 174 /* start or stop a pulling thread */ 175 gboolean (*activate_pull)(GstBaseSink *sink, gboolean active); 176 177 /** 178 * GstBaseSink::get_times: 179 * @start: (out): the start #GstClockTime 180 * @end: (out): the end #GstClockTime 181 * 182 * Get the start and end times for syncing on this buffer. 183 */ 184 void (*get_times) (GstBaseSink *sink, GstBuffer *buffer, 185 GstClockTime *start, GstClockTime *end); 186 187 /* propose allocation parameters for upstream */ 188 gboolean (*propose_allocation) (GstBaseSink *sink, GstQuery *query); 189 190 /* start and stop processing, ideal for opening/closing the resource */ 191 gboolean (*start) (GstBaseSink *sink); 192 gboolean (*stop) (GstBaseSink *sink); 193 194 /* unlock any pending access to the resource. subclasses should unlock 195 * any function ASAP. */ 196 gboolean (*unlock) (GstBaseSink *sink); 197 /* Clear a previously indicated unlock request not that unlocking is 198 * complete. Sub-classes should clear any command queue or indicator they 199 * set during unlock */ 200 gboolean (*unlock_stop) (GstBaseSink *sink); 201 202 /* notify subclass of query */ 203 gboolean (*query) (GstBaseSink *sink, GstQuery *query); 204 205 /* notify subclass of event */ 206 gboolean (*event) (GstBaseSink *sink, GstEvent *event); 207 /* wait for eos or gap, subclasses should chain up to parent first */ 208 GstFlowReturn (*wait_event) (GstBaseSink *sink, GstEvent *event); 209 210 /* notify subclass of buffer or list before doing sync */ 211 GstFlowReturn (*prepare) (GstBaseSink *sink, GstBuffer *buffer); 212 GstFlowReturn (*prepare_list) (GstBaseSink *sink, GstBufferList *buffer_list); 213 214 /* notify subclass of preroll buffer or real buffer */ 215 GstFlowReturn (*preroll) (GstBaseSink *sink, GstBuffer *buffer); 216 GstFlowReturn (*render) (GstBaseSink *sink, GstBuffer *buffer); 217 /* Render a BufferList */ 218 GstFlowReturn (*render_list) (GstBaseSink *sink, GstBufferList *buffer_list); 219 220 /* #ifdef OHOS_OPT_PERFORMANCE: comment out this macro to avoid header file differences caused by macros 221 * ohos.opt.performance.0002: update the running_time 222 * @sink: the sink 223 * @reach_time: the running_time to be reached 224 * 225 * This function will update the @reach_time. 226 * Returns: an new reach_time 227 */ 228 GstClockTime (*update_reach_time) (GstBaseSink *sink, GstClockTime reach_time); 229 /* #endif */ 230 231 /*< private >*/ 232 gpointer _gst_reserved[GST_PADDING_LARGE]; 233 }; 234 235 GST_BASE_API 236 GType gst_base_sink_get_type (void); 237 238 GST_BASE_API 239 GstFlowReturn gst_base_sink_do_preroll (GstBaseSink *sink, GstMiniObject *obj); 240 241 GST_BASE_API 242 GstFlowReturn gst_base_sink_wait_preroll (GstBaseSink *sink); 243 244 /* synchronizing against the clock */ 245 246 GST_BASE_API 247 void gst_base_sink_set_sync (GstBaseSink *sink, gboolean sync); 248 249 GST_BASE_API 250 gboolean gst_base_sink_get_sync (GstBaseSink *sink); 251 252 /* Drop buffers which are out of segment */ 253 254 GST_BASE_API 255 void gst_base_sink_set_drop_out_of_segment (GstBaseSink *sink, gboolean drop_out_of_segment); 256 257 GST_BASE_API 258 gboolean gst_base_sink_get_drop_out_of_segment (GstBaseSink *sink); 259 260 /* dropping late buffers */ 261 262 GST_BASE_API 263 void gst_base_sink_set_max_lateness (GstBaseSink *sink, gint64 max_lateness); 264 265 GST_BASE_API 266 gint64 gst_base_sink_get_max_lateness (GstBaseSink *sink); 267 268 /* performing QoS */ 269 270 GST_BASE_API 271 void gst_base_sink_set_qos_enabled (GstBaseSink *sink, gboolean enabled); 272 273 GST_BASE_API 274 gboolean gst_base_sink_is_qos_enabled (GstBaseSink *sink); 275 276 /* doing async state changes */ 277 278 GST_BASE_API 279 void gst_base_sink_set_async_enabled (GstBaseSink *sink, gboolean enabled); 280 281 GST_BASE_API 282 gboolean gst_base_sink_is_async_enabled (GstBaseSink *sink); 283 284 /* tuning synchronisation */ 285 286 GST_BASE_API 287 void gst_base_sink_set_ts_offset (GstBaseSink *sink, GstClockTimeDiff offset); 288 289 GST_BASE_API 290 GstClockTimeDiff gst_base_sink_get_ts_offset (GstBaseSink *sink); 291 292 /* last sample */ 293 294 GST_BASE_API 295 GstSample * gst_base_sink_get_last_sample (GstBaseSink *sink); 296 297 GST_BASE_API 298 void gst_base_sink_set_last_sample_enabled (GstBaseSink *sink, gboolean enabled); 299 300 GST_BASE_API 301 gboolean gst_base_sink_is_last_sample_enabled (GstBaseSink *sink); 302 303 /* latency */ 304 305 GST_BASE_API 306 gboolean gst_base_sink_query_latency (GstBaseSink *sink, gboolean *live, gboolean *upstream_live, 307 GstClockTime *min_latency, GstClockTime *max_latency); 308 GST_BASE_API 309 GstClockTime gst_base_sink_get_latency (GstBaseSink *sink); 310 311 /* render delay */ 312 313 GST_BASE_API 314 void gst_base_sink_set_render_delay (GstBaseSink *sink, GstClockTime delay); 315 316 GST_BASE_API 317 GstClockTime gst_base_sink_get_render_delay (GstBaseSink *sink); 318 319 /* blocksize */ 320 321 GST_BASE_API 322 void gst_base_sink_set_blocksize (GstBaseSink *sink, guint blocksize); 323 324 GST_BASE_API 325 guint gst_base_sink_get_blocksize (GstBaseSink *sink); 326 327 /* throttle-time */ 328 329 GST_BASE_API 330 void gst_base_sink_set_throttle_time (GstBaseSink *sink, guint64 throttle); 331 332 GST_BASE_API 333 guint64 gst_base_sink_get_throttle_time (GstBaseSink *sink); 334 335 /* max-bitrate */ 336 337 GST_BASE_API 338 void gst_base_sink_set_max_bitrate (GstBaseSink *sink, guint64 max_bitrate); 339 340 GST_BASE_API 341 guint64 gst_base_sink_get_max_bitrate (GstBaseSink *sink); 342 343 /* processing deadline */ 344 GST_BASE_API 345 void gst_base_sink_set_processing_deadline (GstBaseSink *sink, GstClockTime processing_deadline); 346 347 GST_BASE_API 348 GstClockTime gst_base_sink_get_processing_deadline (GstBaseSink *sink); 349 350 GST_BASE_API 351 GstClockReturn gst_base_sink_wait_clock (GstBaseSink *sink, GstClockTime time, 352 GstClockTimeDiff * jitter); 353 GST_BASE_API 354 GstFlowReturn gst_base_sink_wait (GstBaseSink *sink, GstClockTime time, 355 GstClockTimeDiff *jitter); 356 357 GST_BASE_API 358 GstStructure *gst_base_sink_get_stats (GstBaseSink * sink); 359 360 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GstBaseSink, gst_object_unref) 361 362 G_END_DECLS 363 364 #endif /* __GST_BASE_SINK_H__ */ 365