Branch data Line data Source code
1 : : /* GStreamer Editing Services
2 : : * Copyright (C) 2009 Edward Hervey <edward.hervey@collabora.co.uk>
3 : : * 2009 Nokia Corporation
4 : : *
5 : : * This library is free software; you can redistribute it and/or
6 : : * modify it under the terms of the GNU Library General Public
7 : : * License as published by the Free Software Foundation; either
8 : : * version 2 of the License, or (at your option) any later version.
9 : : *
10 : : * This library is distributed in the hope that it will be useful,
11 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 : : * Library General Public License for more details.
14 : : *
15 : : * You should have received a copy of the GNU Library General Public
16 : : * License along with this library; if not, write to the
17 : : * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 : : * Boston, MA 02111-1307, USA.
19 : : */
20 : :
21 : : /**
22 : : * SECTION:ges-track-object
23 : : * @short_description: Base Class for objects contained in a #GESTrack
24 : : *
25 : : * #GESTrackObject is the Base Class for any object that can be contained in a
26 : : * #GESTrack.
27 : : *
28 : : * It contains the basic information as to the location of the object within
29 : : * its container, like the start position, the in-point, the duration and the
30 : : * priority.
31 : : */
32 : :
33 : : #include "ges-internal.h"
34 : : #include "ges-track-object.h"
35 : : #include "ges-timeline-object.h"
36 : :
37 [ + + ]: 680 : G_DEFINE_ABSTRACT_TYPE (GESTrackObject, ges_track_object,
38 : 680 : G_TYPE_INITIALLY_UNOWNED);
39 : :
40 : : struct _GESTrackObjectPrivate
41 : : {
42 : : /* These fields are only used before the gnlobject is available */
43 : : guint64 pending_start;
44 : : guint64 pending_inpoint;
45 : : guint64 pending_duration;
46 : : guint32 pending_priority;
47 : : gboolean pending_active;
48 : :
49 : : GstElement *gnlobject; /* The GnlObject */
50 : : GstElement *element; /* The element contained in the gnlobject (can be NULL) */
51 : :
52 : : GESTimelineObject *timelineobj;
53 : : GESTrack *track;
54 : :
55 : : gboolean valid;
56 : :
57 : : gboolean locked; /* If TRUE, then moves in sync with its controlling
58 : : * GESTimelineObject */
59 : : };
60 : :
61 : : enum
62 : : {
63 : : PROP_0,
64 : : PROP_START,
65 : : PROP_INPOINT,
66 : : PROP_DURATION,
67 : : PROP_PRIORITY,
68 : : PROP_ACTIVE,
69 : : PROP_LAST
70 : : };
71 : :
72 : : static GParamSpec *properties[PROP_LAST];
73 : :
74 : : static GstElement *ges_track_object_create_gnl_object_func (GESTrackObject *
75 : : object);
76 : :
77 : : static void gnlobject_start_cb (GstElement * gnlobject, GParamSpec * arg
78 : : G_GNUC_UNUSED, GESTrackObject * obj);
79 : :
80 : : static void gnlobject_media_start_cb (GstElement * gnlobject, GParamSpec * arg
81 : : G_GNUC_UNUSED, GESTrackObject * obj);
82 : :
83 : : static void gnlobject_priority_cb (GstElement * gnlobject, GParamSpec * arg
84 : : G_GNUC_UNUSED, GESTrackObject * obj);
85 : :
86 : : static void gnlobject_duration_cb (GstElement * gnlobject, GParamSpec * arg
87 : : G_GNUC_UNUSED, GESTrackObject * obj);
88 : :
89 : : static void gnlobject_active_cb (GstElement * gnlobject, GParamSpec * arg
90 : : G_GNUC_UNUSED, GESTrackObject * obj);
91 : :
92 : : static inline gboolean
93 : : ges_track_object_set_start_internal (GESTrackObject * object, guint64 start);
94 : : static inline gboolean
95 : : ges_track_object_set_inpoint_internal (GESTrackObject * object,
96 : : guint64 inpoint);
97 : : static inline gboolean ges_track_object_set_duration_internal (GESTrackObject *
98 : : object, guint64 duration);
99 : : static inline gboolean ges_track_object_set_priority_internal (GESTrackObject *
100 : : object, guint32 priority);
101 : :
102 : : static void
103 : 0 : ges_track_object_get_property (GObject * object, guint property_id,
104 : : GValue * value, GParamSpec * pspec)
105 : : {
106 : 0 : GESTrackObject *tobj = GES_TRACK_OBJECT (object);
107 : :
108 [ # # # # : 0 : switch (property_id) {
# # ]
109 : : case PROP_START:
110 : 0 : g_value_set_uint64 (value, tobj->start);
111 : 0 : break;
112 : : case PROP_INPOINT:
113 : 0 : g_value_set_uint64 (value, tobj->inpoint);
114 : 0 : break;
115 : : case PROP_DURATION:
116 : 0 : g_value_set_uint64 (value, tobj->duration);
117 : 0 : break;
118 : : case PROP_PRIORITY:
119 : 0 : g_value_set_uint (value, tobj->priority);
120 : 0 : break;
121 : : case PROP_ACTIVE:
122 : 0 : g_value_set_boolean (value, tobj->active);
123 : 0 : break;
124 : : default:
125 : 0 : G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
126 : : }
127 : 0 : }
128 : :
129 : : static void
130 : 2 : ges_track_object_set_property (GObject * object, guint property_id,
131 : : const GValue * value, GParamSpec * pspec)
132 : : {
133 : 2 : GESTrackObject *tobj = GES_TRACK_OBJECT (object);
134 : :
135 [ + - - - : 2 : switch (property_id) {
- - ]
136 : : case PROP_START:
137 : 2 : ges_track_object_set_start_internal (tobj, g_value_get_uint64 (value));
138 : 2 : break;
139 : : case PROP_INPOINT:
140 : 0 : ges_track_object_set_inpoint_internal (tobj, g_value_get_uint64 (value));
141 : 0 : break;
142 : : case PROP_DURATION:
143 : 0 : ges_track_object_set_duration_internal (tobj, g_value_get_uint64 (value));
144 : 0 : break;
145 : : case PROP_PRIORITY:
146 : 0 : ges_track_object_set_priority_internal (tobj, g_value_get_uint (value));
147 : 0 : break;
148 : : case PROP_ACTIVE:
149 : 0 : ges_track_object_set_active (tobj, g_value_get_boolean (value));
150 : 0 : break;
151 : : default:
152 : 0 : G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
153 : : }
154 : 2 : }
155 : :
156 : : static void
157 : 62 : ges_track_object_dispose (GObject * object)
158 : : {
159 : 62 : G_OBJECT_CLASS (ges_track_object_parent_class)->dispose (object);
160 : 62 : }
161 : :
162 : : static void
163 : 62 : ges_track_object_finalize (GObject * object)
164 : : {
165 : 62 : G_OBJECT_CLASS (ges_track_object_parent_class)->finalize (object);
166 : 62 : }
167 : :
168 : : static void
169 : 24 : ges_track_object_class_init (GESTrackObjectClass * klass)
170 : : {
171 : 24 : GObjectClass *object_class = G_OBJECT_CLASS (klass);
172 : :
173 : 24 : g_type_class_add_private (klass, sizeof (GESTrackObjectPrivate));
174 : :
175 : 24 : object_class->get_property = ges_track_object_get_property;
176 : 24 : object_class->set_property = ges_track_object_set_property;
177 : 24 : object_class->dispose = ges_track_object_dispose;
178 : 24 : object_class->finalize = ges_track_object_finalize;
179 : :
180 : : /**
181 : : * GESTrackObject:start
182 : : *
183 : : * The position of the object in the container #GESTrack (in nanoseconds).
184 : : */
185 : 24 : properties[PROP_START] = g_param_spec_uint64 ("start", "Start",
186 : : "The position in the container", 0, G_MAXUINT64, 0, G_PARAM_READWRITE);
187 : 24 : g_object_class_install_property (object_class, PROP_START,
188 : : properties[PROP_START]);
189 : :
190 : : /**
191 : : * GESTrackObject:in-point
192 : : *
193 : : * The in-point at which this #GESTrackObject will start outputting data
194 : : * from its contents (in nanoseconds).
195 : : *
196 : : * Ex : an in-point of 5 seconds means that the first outputted buffer will
197 : : * be the one located 5 seconds in the controlled resource.
198 : : */
199 : 24 : properties[PROP_INPOINT] =
200 : 24 : g_param_spec_uint64 ("in-point", "In-point", "The in-point", 0,
201 : : G_MAXUINT64, 0, G_PARAM_READWRITE);
202 : 24 : g_object_class_install_property (object_class, PROP_INPOINT,
203 : : properties[PROP_INPOINT]);
204 : :
205 : : /**
206 : : * GESTrackObject:duration
207 : : *
208 : : * The duration (in nanoseconds) which will be used in the container #GESTrack
209 : : * starting from 'in-point'.
210 : : *
211 : : */
212 : 24 : properties[PROP_DURATION] =
213 : 24 : g_param_spec_uint64 ("duration", "Duration", "The duration to use", 0,
214 : : G_MAXUINT64, GST_SECOND, G_PARAM_READWRITE);
215 : 24 : g_object_class_install_property (object_class, PROP_DURATION,
216 : : properties[PROP_DURATION]);
217 : :
218 : : /**
219 : : * GESTrackObject:priority
220 : : *
221 : : * The priority of the object within the containing #GESTrack.
222 : : * If two objects intersect over the same region of time, the @priority
223 : : * property is used to decide which one takes precedence.
224 : : *
225 : : * The highest priority (that supercedes everything) is 0, and then lowering
226 : : * priorities go in increasing numerical value (with #G_MAXUINT64 being the
227 : : * lowest priority).
228 : : */
229 : 24 : properties[PROP_PRIORITY] = g_param_spec_uint ("priority", "Priority",
230 : : "The priority of the object", 0, G_MAXUINT, 0, G_PARAM_READWRITE);
231 : 24 : g_object_class_install_property (object_class, PROP_PRIORITY,
232 : : properties[PROP_PRIORITY]);
233 : :
234 : : /**
235 : : * GESTrackObject:active
236 : : *
237 : : * Whether the object should be taken into account in the #GESTrack output.
238 : : * If #FALSE, then its contents will not be used in the resulting track.
239 : : */
240 : 24 : properties[PROP_ACTIVE] =
241 : 24 : g_param_spec_boolean ("active", "Active", "Use object in output", TRUE,
242 : : G_PARAM_READWRITE);
243 : 24 : g_object_class_install_property (object_class, PROP_ACTIVE,
244 : : properties[PROP_ACTIVE]);
245 : :
246 : 24 : klass->create_gnl_object = ges_track_object_create_gnl_object_func;
247 : 24 : }
248 : :
249 : : static void
250 : 74 : ges_track_object_init (GESTrackObject * self)
251 : : {
252 : 74 : self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
253 : : GES_TYPE_TRACK_OBJECT, GESTrackObjectPrivate);
254 : :
255 : : /* Sane default values */
256 : 74 : self->priv->pending_start = 0;
257 : 74 : self->priv->pending_inpoint = 0;
258 : 74 : self->priv->pending_duration = GST_SECOND;
259 : 74 : self->priv->pending_priority = 1;
260 : 74 : self->priv->pending_active = TRUE;
261 : 74 : self->priv->locked = TRUE;
262 : 74 : }
263 : :
264 : : static inline gboolean
265 : 178 : ges_track_object_set_start_internal (GESTrackObject * object, guint64 start)
266 : : {
267 [ - + ][ # # ]: 178 : GST_DEBUG ("object:%p, start:%" GST_TIME_FORMAT,
[ # # ][ # # ]
[ # # ]
268 : : object, GST_TIME_ARGS (start));
269 : :
270 [ + + ]: 178 : if (object->priv->gnlobject != NULL) {
271 [ + + ]: 104 : if (G_UNLIKELY (start == object->start))
272 : 1 : return FALSE;
273 : :
274 : 103 : g_object_set (object->priv->gnlobject, "start", start, NULL);
275 : : } else
276 : 74 : object->priv->pending_start = start;
277 : 178 : return TRUE;
278 : : };
279 : :
280 : : /**
281 : : * ges_track_object_set_start:
282 : : * @object: a #GESTrackObject
283 : : * @start: the start position (in #GstClockTime)
284 : : *
285 : : * Sets the position of the object in the container #GESTrack.
286 : : */
287 : : void
288 : 176 : ges_track_object_set_start (GESTrackObject * object, guint64 start)
289 : : {
290 [ + + ]: 176 : if (ges_track_object_set_start_internal (object, start))
291 : : #if GLIB_CHECK_VERSION(2,26,0)
292 : 175 : g_object_notify_by_pspec (G_OBJECT (object), properties[PROP_START]);
293 : : #else
294 : : g_object_notify (G_OBJECT (object), "start");
295 : : #endif
296 : 176 : }
297 : :
298 : : static inline gboolean
299 : 80 : ges_track_object_set_inpoint_internal (GESTrackObject * object, guint64 inpoint)
300 : : {
301 : :
302 [ - + ][ # # ]: 80 : GST_DEBUG ("object:%p, inpoint:%" GST_TIME_FORMAT,
[ # # ][ # # ]
[ # # ]
303 : : object, GST_TIME_ARGS (inpoint));
304 : :
305 [ + + ]: 80 : if (object->priv->gnlobject != NULL) {
306 [ - + ]: 6 : if (G_UNLIKELY (inpoint == object->inpoint))
307 : 0 : return FALSE;
308 : :
309 : 6 : g_object_set (object->priv->gnlobject, "media-start", inpoint, NULL);
310 : : } else
311 : 74 : object->priv->pending_inpoint = inpoint;
312 : :
313 : 80 : return TRUE;
314 : : }
315 : :
316 : : /**
317 : : * ges_track_object_set_inpoint:
318 : : * @object: a #GESTrackObject
319 : : * @inpoint: the in-point (in #GstClockTime)
320 : : *
321 : : * Set the offset within the contents of this #GESTrackObject
322 : : */
323 : : void
324 : 80 : ges_track_object_set_inpoint (GESTrackObject * object, guint64 inpoint)
325 : : {
326 [ + - ]: 80 : if (ges_track_object_set_inpoint_internal (object, inpoint))
327 : : #if GLIB_CHECK_VERSION(2,26,0)
328 : 80 : g_object_notify_by_pspec (G_OBJECT (object), properties[PROP_INPOINT]);
329 : : #else
330 : : g_object_notify (G_OBJECT (object), "in-point");
331 : : #endif
332 : 80 : }
333 : :
334 : : static inline gboolean
335 : 81 : ges_track_object_set_duration_internal (GESTrackObject * object,
336 : : guint64 duration)
337 : : {
338 [ - + ][ # # ]: 81 : GST_DEBUG ("object:%p, duration:%" GST_TIME_FORMAT,
[ # # ][ # # ]
[ # # ]
339 : : object, GST_TIME_ARGS (duration));
340 : :
341 [ + + ]: 81 : if (object->priv->gnlobject != NULL) {
342 [ - + ]: 7 : if (G_UNLIKELY (duration == object->duration))
343 : 0 : return FALSE;
344 : :
345 : 7 : g_object_set (object->priv->gnlobject, "duration", duration,
346 : : "media-duration", duration, NULL);
347 : : } else
348 : 74 : object->priv->pending_duration = duration;
349 : 81 : return TRUE;
350 : : }
351 : :
352 : : /**
353 : : * ges_track_object_set_duration:
354 : : * @object: a #GESTrackObject
355 : : * @duration: the duration (in #GstClockTime)
356 : : *
357 : : * Set the duration which will be used in the container #GESTrack
358 : : * starting from the 'in-point'
359 : : */
360 : : void
361 : 81 : ges_track_object_set_duration (GESTrackObject * object, guint64 duration)
362 : : {
363 [ + - ]: 81 : if (ges_track_object_set_duration_internal (object, duration))
364 : : #if GLIB_CHECK_VERSION(2,26,0)
365 : 81 : g_object_notify_by_pspec (G_OBJECT (object), properties[PROP_DURATION]);
366 : : #else
367 : : g_object_notify (G_OBJECT (object), "duration");
368 : : #endif
369 : 81 : }
370 : :
371 : : static inline gboolean
372 : 145 : ges_track_object_set_priority_internal (GESTrackObject * object,
373 : : guint32 priority)
374 : : {
375 [ - + ]: 145 : GST_DEBUG ("object:%p, priority:%" G_GUINT32_FORMAT, object, priority);
376 : :
377 [ + + ]: 145 : if (object->priv->gnlobject != NULL) {
378 [ - + ]: 71 : if (G_UNLIKELY (priority == object->priority))
379 : 0 : return FALSE;
380 : :
381 : 71 : g_object_set (object->priv->gnlobject, "priority", priority, NULL);
382 : : } else
383 : 74 : object->priv->pending_priority = priority;
384 : 145 : return TRUE;
385 : : }
386 : :
387 : : /**
388 : : * ges_track_object_set_priority:
389 : : * @object: a #GESTrackObject
390 : : * @priority: the priority
391 : : *
392 : : * Sets the priority of the object withing the containing #GESTrack.
393 : : * If two objects intersect over the same region of time, the priority
394 : : * property is used to decide which one takes precedence.
395 : : *
396 : : * The highest priority (that supercedes everything) is 0, and then
397 : : * lowering priorities go in increasing numerical value (with G_MAXUINT32
398 : : * being the lowest priority).
399 : : */
400 : : void
401 : 145 : ges_track_object_set_priority (GESTrackObject * object, guint32 priority)
402 : : {
403 [ + - ]: 145 : if (ges_track_object_set_priority_internal (object, priority))
404 : : #if GLIB_CHECK_VERSION(2,26,0)
405 : 145 : g_object_notify_by_pspec (G_OBJECT (object), properties[PROP_PRIORITY]);
406 : : #else
407 : : g_object_notify (G_OBJECT (object), "priority");
408 : : #endif
409 : 145 : }
410 : :
411 : :
412 : : /**
413 : : * ges_track_object_set_active:
414 : : * @object: a #GESTrackObject
415 : : * @active: visibility
416 : : *
417 : : * Sets the usage of the @object. If @active is %TRUE, the object will be used for
418 : : * playback and rendering, else it will be ignored.
419 : : *
420 : : * Returns: %TRUE if the property was toggled, else %FALSE
421 : : */
422 : : gboolean
423 : 6 : ges_track_object_set_active (GESTrackObject * object, gboolean active)
424 : : {
425 [ - + ]: 6 : GST_DEBUG ("object:%p, active:%d", object, active);
426 : :
427 [ + - ]: 6 : if (object->priv->gnlobject != NULL) {
428 [ - + ]: 6 : if (G_UNLIKELY (active == object->active))
429 : 0 : return FALSE;
430 : :
431 : 6 : g_object_set (object->priv->gnlobject, "active", active, NULL);
432 : : } else
433 : 0 : object->priv->pending_active = active;
434 : 6 : return TRUE;
435 : : }
436 : :
437 : : /* Callbacks from the GNonLin object */
438 : : static void
439 : 173 : gnlobject_start_cb (GstElement * gnlobject, GParamSpec * arg G_GNUC_UNUSED,
440 : : GESTrackObject * obj)
441 : : {
442 : : guint64 start;
443 : : GESTrackObjectClass *klass;
444 : :
445 : 173 : klass = GES_TRACK_OBJECT_GET_CLASS (obj);
446 : :
447 : 173 : g_object_get (gnlobject, "start", &start, NULL);
448 : :
449 [ - + ][ # # ]: 173 : GST_DEBUG ("gnlobject start : %" GST_TIME_FORMAT " current : %"
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
450 : : GST_TIME_FORMAT, GST_TIME_ARGS (start), GST_TIME_ARGS (obj->start));
451 : :
452 [ + + ]: 173 : if (start != obj->start) {
453 : 147 : obj->start = start;
454 [ - + ]: 147 : if (klass->start_changed)
455 : 0 : klass->start_changed (obj, start);
456 : : }
457 : 173 : }
458 : :
459 : : /* Callbacks from the GNonLin object */
460 : : static void
461 : 76 : gnlobject_media_start_cb (GstElement * gnlobject,
462 : : GParamSpec * arg G_GNUC_UNUSED, GESTrackObject * obj)
463 : : {
464 : : guint64 start;
465 : : GESTrackObjectClass *klass;
466 : :
467 : 76 : klass = GES_TRACK_OBJECT_GET_CLASS (obj);
468 : :
469 : 76 : g_object_get (gnlobject, "media-start", &start, NULL);
470 : :
471 [ - + ][ # # ]: 76 : GST_DEBUG ("gnlobject in-point : %" GST_TIME_FORMAT " current : %"
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
472 : : GST_TIME_FORMAT, GST_TIME_ARGS (start), GST_TIME_ARGS (obj->inpoint));
473 : :
474 [ + + ]: 76 : if (start != obj->inpoint) {
475 : 15 : obj->inpoint = start;
476 [ - + ]: 15 : if (klass->media_start_changed)
477 : 0 : klass->media_start_changed (obj, start);
478 : : }
479 : 76 : }
480 : :
481 : : static void
482 : 141 : gnlobject_priority_cb (GstElement * gnlobject, GParamSpec * arg G_GNUC_UNUSED,
483 : : GESTrackObject * obj)
484 : : {
485 : : guint32 priority;
486 : : GESTrackObjectClass *klass;
487 : :
488 : 141 : klass = GES_TRACK_OBJECT_GET_CLASS (obj);
489 : :
490 : 141 : g_object_get (gnlobject, "priority", &priority, NULL);
491 : :
492 [ - + ]: 141 : GST_DEBUG ("gnlobject priority : %d current : %d", priority, obj->priority);
493 : :
494 [ + + ]: 141 : if (priority != obj->priority) {
495 : 90 : obj->priority = priority;
496 [ - + ]: 90 : if (klass->gnl_priority_changed)
497 : 0 : klass->gnl_priority_changed (obj, priority);
498 : : }
499 : 141 : }
500 : :
501 : : static void
502 : 77 : gnlobject_duration_cb (GstElement * gnlobject, GParamSpec * arg G_GNUC_UNUSED,
503 : : GESTrackObject * obj)
504 : : {
505 : : guint64 duration;
506 : : GESTrackObjectClass *klass;
507 : :
508 : 77 : klass = GES_TRACK_OBJECT_GET_CLASS (obj);
509 : :
510 : 77 : g_object_get (gnlobject, "duration", &duration, NULL);
511 : :
512 [ - + ][ # # ]: 77 : GST_DEBUG ("gnlobject duration : %" GST_TIME_FORMAT " current : %"
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
513 : : GST_TIME_FORMAT, GST_TIME_ARGS (duration), GST_TIME_ARGS (obj->duration));
514 : :
515 [ + + ]: 77 : if (duration != obj->duration) {
516 : 76 : obj->duration = duration;
517 [ + + ]: 76 : if (klass->duration_changed)
518 : 16 : klass->duration_changed (obj, duration);
519 : : }
520 : 77 : }
521 : :
522 : : static void
523 : 76 : gnlobject_active_cb (GstElement * gnlobject, GParamSpec * arg G_GNUC_UNUSED,
524 : : GESTrackObject * obj)
525 : : {
526 : : gboolean active;
527 : : GESTrackObjectClass *klass;
528 : :
529 : 76 : klass = GES_TRACK_OBJECT_GET_CLASS (obj);
530 : :
531 : 76 : g_object_get (gnlobject, "active", &active, NULL);
532 : :
533 [ - + ]: 76 : GST_DEBUG ("gnlobject active : %d current : %d", active, obj->active);
534 : :
535 [ + - ]: 76 : if (active != obj->active) {
536 : 76 : obj->active = active;
537 [ - + ]: 76 : if (klass->active_changed)
538 : 0 : klass->active_changed (obj, active);
539 : : }
540 : 76 : }
541 : :
542 : :
543 : : /* default 'create_gnl_object' virtual method implementation */
544 : : static GstElement *
545 : 69 : ges_track_object_create_gnl_object_func (GESTrackObject * self)
546 : : {
547 : 69 : GESTrackObjectClass *klass = NULL;
548 : 69 : GstElement *child = NULL;
549 : : GstElement *gnlobject;
550 : :
551 : 69 : klass = GES_TRACK_OBJECT_GET_CLASS (self);
552 : :
553 [ - + ]: 69 : if (G_UNLIKELY (self->priv->gnlobject != NULL))
554 : 0 : goto already_have_gnlobject;
555 : :
556 [ - + ]: 69 : if (G_UNLIKELY (klass->gnlobject_factorytype == NULL))
557 : 0 : goto no_gnlfactory;
558 : :
559 [ - + ]: 69 : GST_DEBUG ("Creating a supporting gnlobject of type '%s'",
560 : : klass->gnlobject_factorytype);
561 : :
562 : 69 : gnlobject = gst_element_factory_make (klass->gnlobject_factorytype, NULL);
563 : :
564 [ - + ]: 69 : if (G_UNLIKELY (gnlobject == NULL))
565 : 0 : goto no_gnlobject;
566 : :
567 [ + + ]: 69 : if (klass->create_element) {
568 [ - + ]: 44 : GST_DEBUG ("Calling subclass 'create_element' vmethod");
569 : 44 : child = klass->create_element (self);
570 : :
571 [ - + ]: 44 : if (G_UNLIKELY (!child))
572 : 0 : goto child_failure;
573 : :
574 [ - + ]: 44 : if (!gst_bin_add (GST_BIN (gnlobject), child))
575 : 0 : goto add_failure;
576 : :
577 [ - + ]: 44 : GST_DEBUG ("Succesfully got the element to put in the gnlobject");
578 : 44 : self->priv->element = child;
579 : : }
580 : :
581 [ - + ]: 69 : GST_DEBUG ("done");
582 : 69 : return gnlobject;
583 : :
584 : :
585 : : /* ERROR CASES */
586 : :
587 : : already_have_gnlobject:
588 : : {
589 [ # # ]: 0 : GST_ERROR ("Already controlling a GnlObject %s",
590 : : GST_ELEMENT_NAME (self->priv->gnlobject));
591 : 0 : return NULL;
592 : : }
593 : :
594 : : no_gnlfactory:
595 : : {
596 [ # # ]: 0 : GST_ERROR ("No GESTrackObject::gnlobject_factorytype implementation!");
597 : 0 : return NULL;
598 : : }
599 : :
600 : : no_gnlobject:
601 : : {
602 [ # # ]: 0 : GST_ERROR ("Error creating a gnlobject of type '%s'",
603 : : klass->gnlobject_factorytype);
604 : 0 : return NULL;
605 : : }
606 : :
607 : : child_failure:
608 : : {
609 [ # # ]: 0 : GST_ERROR ("create_element returned NULL");
610 : 0 : gst_object_unref (gnlobject);
611 : 0 : return NULL;
612 : : }
613 : :
614 : : add_failure:
615 : : {
616 [ # # ]: 0 : GST_ERROR ("Error adding the contents to the gnlobject");
617 : 0 : gst_object_unref (child);
618 : 0 : gst_object_unref (gnlobject);
619 : 69 : return NULL;
620 : : }
621 : : }
622 : :
623 : : static gboolean
624 : 70 : ensure_gnl_object (GESTrackObject * object)
625 : : {
626 : : GESTrackObjectClass *class;
627 : : GstElement *gnlobject;
628 : 70 : gboolean res = FALSE;
629 : :
630 [ - + ][ # # ]: 70 : if (object->priv->gnlobject && object->priv->valid)
631 : 0 : return FALSE;
632 : :
633 : : /* 1. Create the GnlObject */
634 [ - + ]: 70 : GST_DEBUG ("Creating GnlObject");
635 : :
636 : 70 : class = GES_TRACK_OBJECT_GET_CLASS (object);
637 : :
638 [ - + ]: 70 : if (G_UNLIKELY (class->create_gnl_object == NULL)) {
639 [ # # ]: 0 : GST_ERROR ("No 'create_gnl_object' implementation !");
640 : 0 : goto done;
641 : : }
642 : :
643 [ - + ]: 70 : GST_DEBUG ("Calling virtual method");
644 : :
645 : : /* call the create_gnl_object virtual method */
646 : 70 : gnlobject = class->create_gnl_object (object);
647 : :
648 [ - + ]: 70 : if (G_UNLIKELY (gnlobject == NULL)) {
649 [ # # ]: 0 : GST_ERROR
650 : : ("'create_gnl_object' implementation returned TRUE but no GnlObject is available");
651 : 0 : goto done;
652 : : }
653 : :
654 : 70 : object->priv->gnlobject = gnlobject;
655 : :
656 : : /* 2. Fill in the GnlObject */
657 [ + - ]: 70 : if (gnlobject) {
658 [ - + ]: 70 : GST_DEBUG ("Got a valid GnlObject, now filling it in");
659 : :
660 : 70 : res =
661 : 70 : ges_timeline_object_fill_track_object (object->priv->timelineobj,
662 : 70 : object, object->priv->gnlobject);
663 [ + - ]: 70 : if (res) {
664 : : /* Connect to property notifications */
665 : : /* FIXME : remember the signalids so we can remove them later on !!! */
666 : 70 : g_signal_connect (G_OBJECT (object->priv->gnlobject), "notify::start",
667 : : G_CALLBACK (gnlobject_start_cb), object);
668 : 70 : g_signal_connect (G_OBJECT (object->priv->gnlobject),
669 : : "notify::media-start", G_CALLBACK (gnlobject_media_start_cb), object);
670 : 70 : g_signal_connect (G_OBJECT (object->priv->gnlobject), "notify::duration",
671 : : G_CALLBACK (gnlobject_duration_cb), object);
672 : 70 : g_signal_connect (G_OBJECT (object->priv->gnlobject), "notify::priority",
673 : : G_CALLBACK (gnlobject_priority_cb), object);
674 : 70 : g_signal_connect (G_OBJECT (object->priv->gnlobject), "notify::active",
675 : : G_CALLBACK (gnlobject_active_cb), object);
676 : :
677 : : /* Set some properties on the GnlObject */
678 : 70 : g_object_set (object->priv->gnlobject,
679 : 70 : "caps", ges_track_get_caps (object->priv->track),
680 : 70 : "duration", object->priv->pending_duration,
681 : 70 : "media-duration", object->priv->pending_duration,
682 : 70 : "start", object->priv->pending_start,
683 : 70 : "media-start", object->priv->pending_inpoint,
684 : 70 : "priority", object->priv->pending_priority,
685 : 70 : "active", object->priv->pending_active, NULL);
686 : :
687 : : }
688 : : }
689 : :
690 : : done:
691 : 70 : object->priv->valid = res;
692 : :
693 [ - + ]: 70 : GST_DEBUG ("Returning res:%d", res);
694 : :
695 : 70 : return res;
696 : : }
697 : :
698 : : /* INTERNAL USAGE */
699 : : gboolean
700 : 132 : ges_track_object_set_track (GESTrackObject * object, GESTrack * track)
701 : : {
702 [ - + ]: 132 : GST_DEBUG ("object:%p, track:%p", object, track);
703 : :
704 : 132 : object->priv->track = track;
705 : :
706 [ + + ]: 132 : if (object->priv->track)
707 : 70 : return ensure_gnl_object (object);
708 : :
709 : 132 : return TRUE;
710 : : }
711 : :
712 : : /**
713 : : * ges_track_object_get_track:
714 : : * @object: a #GESTrackObject
715 : : *
716 : : * Get the #GESTrack to which this object belongs.
717 : : *
718 : : * Returns: (transfer none): The #GESTrack to which this object belongs. Can be %NULL if it
719 : : * is not in any track
720 : : */
721 : : GESTrack *
722 : 261 : ges_track_object_get_track (GESTrackObject * object)
723 : : {
724 [ - + ][ + - ]: 261 : g_return_val_if_fail (GES_IS_TRACK_OBJECT (object), NULL);
[ - + ][ - + ]
725 : :
726 : 261 : return object->priv->track;
727 : : }
728 : :
729 : :
730 : : void
731 : 148 : ges_track_object_set_timeline_object (GESTrackObject * object,
732 : : GESTimelineObject * tlobj)
733 : : {
734 [ - + ]: 148 : GST_DEBUG ("object:%p, timeline-object:%p", object, tlobj);
735 : :
736 : 148 : object->priv->timelineobj = tlobj;
737 : 148 : }
738 : :
739 : : /**
740 : : * ges_track_object_get_timeline_object:
741 : : * @object: a #GESTrackObject
742 : : *
743 : : * Get the #GESTimelineObject which is controlling this track object
744 : : *
745 : : * Returns: (transfer none): the #GESTimelineObject which is controlling
746 : : * this track object
747 : : */
748 : : GESTimelineObject *
749 : 3 : ges_track_object_get_timeline_object (GESTrackObject * object)
750 : : {
751 [ - + ][ + - ]: 3 : g_return_val_if_fail (GES_IS_TRACK_OBJECT (object), NULL);
[ - + ][ - + ]
752 : :
753 : 3 : return object->priv->timelineobj;
754 : : }
755 : :
756 : : /**
757 : : * ges_track_object_get_gnlobject:
758 : : * @object: a #GESTrackObject
759 : : *
760 : : * Get the GNonLin object this object is controlling.
761 : : *
762 : : * Returns: (transfer none): the GNonLin object this object is controlling.
763 : : */
764 : : GstElement *
765 : 228 : ges_track_object_get_gnlobject (GESTrackObject * object)
766 : : {
767 : 228 : return object->priv->gnlobject;
768 : : }
769 : :
770 : : /**
771 : : * ges_track_object_get_element:
772 : : * @object: a #GESTrackObject
773 : : *
774 : : * Get the #GstElement this track object is controlling within GNonLin.
775 : : *
776 : : * Returns: (transfer none): the #GstElement this track object is controlling
777 : : * within GNonLin.
778 : : */
779 : : GstElement *
780 : 32 : ges_track_object_get_element (GESTrackObject * object)
781 : : {
782 : 32 : return object->priv->element;
783 : : }
784 : :
785 : : /**
786 : : * ges_track_object_set_locked:
787 : : * @object: a #GESTrackObject
788 : : * @locked: whether the object is lock to its parent
789 : : *
790 : : * Set the locking status of the @object in relationship to its controlling
791 : : * #GESTimelineObject. If @locked is %TRUE, then this object will move synchronously
792 : : * with its controlling #GESTimelineObject.
793 : : */
794 : : void
795 : 1 : ges_track_object_set_locked (GESTrackObject * object, gboolean locked)
796 : : {
797 : 1 : object->priv->locked = locked;
798 : 1 : }
799 : :
800 : : /**
801 : : * ges_track_object_is_locked:
802 : : * @object: a #GESTrackObject
803 : : *
804 : : * Let you know if object us locked or not (moving synchronously).
805 : : *
806 : : * Returns: %TRUE if the object is moving synchronously to its controlling
807 : : * #GESTimelineObject, else %FALSE.
808 : : */
809 : : gboolean
810 : 191 : ges_track_object_is_locked (GESTrackObject * object)
811 : : {
812 : 191 : return object->priv->locked;
813 : : }
|
