camerabin2: Add a timer to measure shot-to-save delay.
[gstreamer-omap:gst-plugins-bad.git] / gst / camerabin2 / gstcamerabin2.c
1 /* GStreamer
2  * Copyright (C) 2010 Thiago Santos <thiago.sousa.santos@collabora.co.uk>
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Library General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Library General Public License for more details.
13  *
14  * You should have received a copy of the GNU Library General Public
15  * License along with this library; if not, write to the
16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17  * Boston, MA 02111-1307, USA.
18  */
19 /**
20  * SECTION:element-camerabin2
21  *
22  * CameraBin2 is a high-level camera object that encapsulates gstreamer
23  * elements, providing an API for controlling a digital camera.
24  *
25  * <note>
26  * Note that camerabin2 is still UNSTABLE and under
27  * development.
28  * </note>
29  *
30  * CameraBin2 has the following main features:
31  * <itemizedlist>
32  * <listitem>
33  * Record videos
34  * </listitem>
35  * <listitem>
36  * Capture pictures
37  * </listitem>
38  * <listitem>
39  * Display a viewfinder
40  * </listitem>
41  * <listitem>
42  * Post preview images for each capture (video and image)
43  * </listitem>
44  * </itemizedlist>
45  *
46  * <refsect2>
47  * <title>Usage</title>
48  * <para>
49  * Camerabin2 can be created using gst_element_factory_make() just like
50  * any other element. Video or image capture mode can be selected using
51  * the #GstCameraBin2:mode property and the file to save the capture is
52  * selected using #GstCameraBin2:location property.
53  *
54  * After creating camerabin2, applications might want to do some
55  * customization (there's a section about this below), then select
56  * the desired mode and start capturing.
57  *
58  * In image capture mode, just send a #GstCameraBin:start-capture and a
59  * picture will be captured. When the picture is stored on the selected
60  * location, a %GST_MESSAGE_ELEMENT named 'image-done' will be posted on
61  * the #GstBus.
62  *
63  * In video capture mode, send a #GstCameraBin2:start-capture to start
64  * recording, then send a #GstCameraBin2:stop-capture to stop recording.
65  * Note that both signals are asynchronous, so, calling
66  * #GstCameraBin2:stop-capture doesn't guarantee that the video has been
67  * properly finished yet. Applications should wait for the 'video-done'
68  * message to be posted on the bus.
69  *
70  * In both modes, if #GstCameraBin2:post-previews is %TRUE, a #GstBuffer
71  * will be post to the #GstBus in a field named 'buffer', in a
72  * 'preview-image' message of type %GST_MESSAGE_ELEMENT.
73  * </para>
74  * </refsect2>
75
76  * <refsect2>
77  * <title>Customization</title>
78  * <para>
79  * Camerabin2 provides various customization properties, allowing the user
80  * to set custom filters, selecting the viewfinder sink and formats to
81  * use to encode the captured images/videos.
82  *
83  * #GstEncodingProfile<!-- -->s are used to tell camerabin2 which formats it
84  * should encode the captures to, those should be set to
85  * #GstCameraBin2:image-profile and #GstCameraBin2:video-profile. Default is
86  * jpeg for images, and ogg (theora and vorbis) for video. If a profile without
87  * an audio stream is set for video, audio will be disabled on recordings.
88  *
89  * #GstCameraBin2:preview-caps can be used to select which format preview
90  * images should be posted on the #GstBus. It has to be a raw video format.
91  *
92  * Camerabin2 has a #GstCameraBin2:camera-source property so applications can
93  * set their source that will provide buffers for the viewfinder and for
94  * captures. This camera source is a special type of source that has 3 pads.
95  * To use a 'regular' source with a single pad you should use
96  * #GstWrapperCameraBinSource, it will adapt your source and provide 3 pads.
97  *
98  * Applications can also select the desired viewfinder sink using
99  * #GstCameraBin2:viewfinder-sink, it is also possible to select the audio
100  * source using #GstCameraBin2:audio-source.
101  *
102  * The viewfinder resolution can be configured using
103  * #GstCameraBin2:viewfinder-caps, these #GstCaps should be a subset of
104  * #GstCameraBin2:viewfinder-supported-caps.
105  *
106  * To select the desired resolution for captures, camerabin2 provides
107  * #GstCameraBin2:image-capture-caps and #GstCameraBin2:video-capture-caps,
108  * these caps must be a subset of what the source can produce. The allowed
109  * caps can be probed using #GstCameraBin2:image-capture-supported-caps and
110  * #GstCameraBin2:video-capture-supported-caps. In an analogous way, there
111  * are #GstCameraBin2:audio-capture-caps and
112  * #GstCameraBin2:audio-capture-supported-caps.
113  *
114  * Camerabin2 also allows applications to insert custom #GstElements on any
115  * of its branches: video capture, image capture, viewfinder and preview.
116  * Check #GstCameraBin2:video-filter, #GstCameraBin2:image-filter,
117  * #GstCameraBin2:viewfinder-filter and #GstCameraBin2:preview-filter.
118  * </para>
119  * </refsect2>
120  *
121  * <refsect2>
122  * <title>Example launch line</title>
123  * <para>
124  * Unfortunatelly, camerabin2 can't be really used from gst-launch, as you need
125  * to send signals to control it. The following pipeline might be able
126  * to show the viewfinder using all the default elements.
127  * |[
128  * gst-launch -v -m camerabin2
129  * ]|
130  * </para>
131  * </refsect2>
132
133  */
134
135 /*
136  * Detail Topics:
137  *
138  * videorecordingbin state management (for now on called 'videobin')
139  * - The problem: keeping videobin state in sync with camerabin will make it
140  *                go to playing when it might not be used, causing its internal
141  *                filesink to open a file that might be left blank.
142  * - The solution: videobin state is set to locked upon its creation and camerabin
143  *                 registers itself on the notify::ready-for-capture of the src.
144  *                 Whenever the src readyness goes to FALSE it means a new
145  *                 capture is starting. If we are on video mode, the videobin's
146  *                 state is set to NULL and then PLAYING (in between this we
147  *                 have room to set the destination filename).
148  *                 There is no problem to leave it on playing after an EOS, so
149  *                 no action is taken on stop-capture.
150  *
151  * - TODO: What happens when an error pops?
152  * - TODO: Should we split properties in image/video variants? We already do so
153  *         for some of them
154  *
155  *
156  */
157
158 #ifdef HAVE_CONFIG_H
159 #include "config.h"
160 #endif
161
162 #include <string.h>
163
164 #include <gst/basecamerabinsrc/gstbasecamerasrc.h>
165 #include "gstcamerabin2.h"
166 #include <gst/gst-i18n-plugin.h>
167 #include <gst/pbutils/pbutils.h>
168
169 #if GLIB_CHECK_VERSION(2,29,6)
170 #define gst_camerabin2_atomic_int_add g_atomic_int_add
171 #else
172 #define gst_camerabin2_atomic_int_add g_atomic_int_exchange_and_add
173 #endif
174
175 #define GST_CAMERA_BIN2_PROCESSING_INC(c)                                \
176 {                                                                       \
177   gint bef = gst_camerabin2_atomic_int_add (&c->processing_counter, 1); \
178   if (bef == 0)                                                         \
179     g_object_notify (G_OBJECT (c), "idle");                             \
180   GST_DEBUG_OBJECT ((c), "Processing counter incremented to: %d",       \
181       bef + 1);                                                         \
182 }
183
184 #define GST_CAMERA_BIN2_PROCESSING_DEC(c)                                \
185 {                                                                       \
186   if (g_atomic_int_dec_and_test (&c->processing_counter)) {             \
187     g_object_notify (G_OBJECT (c), "idle");                             \
188     GST_DEBUG_OBJECT ((c), "Camerabin now idle");                       \
189   }                                                                     \
190   GST_DEBUG_OBJECT ((c), "Processing counter decremented");             \
191 }
192
193 #define GST_CAMERA_BIN2_RESET_PROCESSING_COUNTER(c)                      \
194 {                                                                       \
195   g_atomic_int_set (&c->processing_counter, 0);                         \
196   GST_DEBUG_OBJECT ((c), "Processing counter reset");                   \
197 }
198
199 GST_DEBUG_CATEGORY_STATIC (gst_camera_bin_debug);
200 #define GST_CAT_DEFAULT gst_camera_bin_debug
201
202 /* prototypes */
203
204 enum
205 {
206   PROP_0,
207   PROP_MODE,
208   PROP_LOCATION,
209   PROP_CAMERA_SRC,
210   PROP_IMAGE_CAPTURE_SUPPORTED_CAPS,
211   PROP_VIDEO_CAPTURE_SUPPORTED_CAPS,
212   PROP_IMAGE_CAPTURE_CAPS,
213   PROP_VIDEO_CAPTURE_CAPS,
214   PROP_POST_PREVIEWS,
215   PROP_PREVIEW_CAPS,
216   PROP_VIDEO_ENCODING_PROFILE,
217   PROP_IMAGE_FILTER,
218   PROP_VIDEO_FILTER,
219   PROP_VIEWFINDER_FILTER,
220   PROP_PREVIEW_FILTER,
221   PROP_VIEWFINDER_SINK,
222   PROP_VIEWFINDER_SUPPORTED_CAPS,
223   PROP_VIEWFINDER_CAPS,
224   PROP_AUDIO_SRC,
225   PROP_MUTE_AUDIO,
226   PROP_AUDIO_CAPTURE_SUPPORTED_CAPS,
227   PROP_AUDIO_CAPTURE_CAPS,
228   PROP_ZOOM,
229   PROP_MAX_ZOOM,
230   PROP_IMAGE_ENCODING_PROFILE,
231   PROP_IDLE,
232   PROP_FLAGS,
233   PROP_AUDIO_FILTER
234 };
235
236 enum
237 {
238   /* action signals */
239   START_CAPTURE_SIGNAL,
240   STOP_CAPTURE_SIGNAL,
241   /* emit signals */
242   LAST_SIGNAL
243 };
244 static guint camerabin_signals[LAST_SIGNAL];
245
246 #define DEFAULT_MODE MODE_IMAGE
247 #define DEFAULT_LOCATION "cap_%d"
248 #define DEFAULT_POST_PREVIEWS FALSE
249 #define DEFAULT_MUTE_AUDIO FALSE
250 #define DEFAULT_IDLE TRUE
251 #define DEFAULT_FLAGS 0
252
253 #define DEFAULT_AUDIO_SRC "autoaudiosrc"
254
255 /********************************
256  * Standard GObject boilerplate *
257  * and GObject types            *
258  ********************************/
259
260 static GstPipelineClass *parent_class;
261 static void gst_camera_bin_class_init (GstCameraBin2Class * klass);
262 static void gst_camera_bin_base_init (gpointer klass);
263 static void gst_camera_bin_init (GstCameraBin2 * camera);
264 static void gst_camera_bin_dispose (GObject * object);
265 static void gst_camera_bin_finalize (GObject * object);
266
267 static void gst_camera_bin_handle_message (GstBin * bin, GstMessage * message);
268 static gboolean gst_camera_bin_send_event (GstElement * element,
269     GstEvent * event);
270
271 #define C_FLAGS(v) ((guint) v)
272 #define GST_TYPE_CAM_FLAGS (gst_cam_flags_get_type())
273 static GType
274 gst_cam_flags_get_type (void)
275 {
276   static const GFlagsValue values[] = {
277     {C_FLAGS (GST_CAM_FLAG_NO_AUDIO_CONVERSION), "Do not use audio conversion "
278           "elements", "no-audio-conversion"},
279     {C_FLAGS (GST_CAM_FLAG_NO_VIDEO_CONVERSION), "Do not use video conversion "
280           "elements", "no-video-conversion"},
281     {C_FLAGS (GST_CAM_FLAG_NO_VIEWFINDER_CONVERSION),
282           "Do not use viewfinder conversion " "elements",
283         "no-viewfinder-conversion"},
284     {C_FLAGS (GST_CAM_FLAG_NO_IMAGE_CONVERSION), "Do not use image conversion "
285           "elements", "no-image-conversion"},
286     {0, NULL, NULL}
287   };
288   static volatile GType id = 0;
289
290   if (g_once_init_enter ((gsize *) & id)) {
291     GType _id;
292
293     _id = g_flags_register_static ("GstCamFlags", values);
294
295     g_once_init_leave ((gsize *) & id, _id);
296   }
297
298   return id;
299 }
300
301 GType
302 gst_camera_bin2_get_type (void)
303 {
304   static GType gst_camera_bin_type = 0;
305   static const GInterfaceInfo camerabin_tagsetter_info = {
306     NULL,
307     NULL,
308     NULL,
309   };
310
311   if (!gst_camera_bin_type) {
312     static const GTypeInfo gst_camera_bin_info = {
313       sizeof (GstCameraBin2Class),
314       (GBaseInitFunc) gst_camera_bin_base_init,
315       NULL,
316       (GClassInitFunc) gst_camera_bin_class_init,
317       NULL,
318       NULL,
319       sizeof (GstCameraBin2),
320       0,
321       (GInstanceInitFunc) gst_camera_bin_init,
322       NULL
323     };
324
325     gst_camera_bin_type =
326         g_type_register_static (GST_TYPE_PIPELINE, "GstCameraBin2",
327         &gst_camera_bin_info, 0);
328
329     g_type_add_interface_static (gst_camera_bin_type, GST_TYPE_TAG_SETTER,
330         &camerabin_tagsetter_info);
331   }
332
333   return gst_camera_bin_type;
334 }
335
336 /* GObject class functions */
337 static void gst_camera_bin_set_property (GObject * object, guint prop_id,
338     const GValue * value, GParamSpec * pspec);
339 static void gst_camera_bin_get_property (GObject * object, guint prop_id,
340     GValue * value, GParamSpec * pspec);
341
342 /* Element class functions */
343 static GstStateChangeReturn
344 gst_camera_bin_change_state (GstElement * element, GstStateChange trans);
345
346
347 /* Camerabin functions */
348
349 static GstEvent *
350 gst_camera_bin_new_event_renegotiate (void)
351 {
352   return gst_event_new_custom (GST_EVENT_CUSTOM_BOTH,
353       gst_structure_new ("renegotiate", NULL));
354 }
355
356 static GstEvent *
357 gst_camera_bin_new_event_file_location (const gchar * location)
358 {
359   return gst_event_new_custom (GST_EVENT_CUSTOM_DOWNSTREAM,
360       gst_structure_new ("new-location", "location", G_TYPE_STRING, location,
361           NULL));
362 }
363
364 static void
365 gst_camera_bin_start_capture (GstCameraBin2 * camerabin)
366 {
367   const GstTagList *taglist;
368   gint capture_index = camerabin->capture_index;
369   gchar *location = NULL;
370   GST_DEBUG_OBJECT (camerabin, "Received start-capture");
371
372   if (camerabin->mode == MODE_IMAGE) {
373     g_timer_start (camerabin->shot_to_save_timer);
374   }
375
376   /* check that we have a valid location */
377   if (camerabin->mode == MODE_VIDEO) {
378     if (camerabin->location == NULL) {
379       GST_ELEMENT_ERROR (camerabin, RESOURCE, OPEN_WRITE,
380           (_("File location is set to NULL, please set it to a valid filename")), (NULL));
381       return;
382     }
383
384     g_mutex_lock (camerabin->video_capture_mutex);
385     while (camerabin->video_state == GST_CAMERA_BIN_VIDEO_FINISHING) {
386       g_cond_wait (camerabin->video_state_cond, camerabin->video_capture_mutex);
387     }
388     if (camerabin->video_state != GST_CAMERA_BIN_VIDEO_IDLE) {
389       GST_WARNING_OBJECT (camerabin, "Another video recording is ongoing"
390           " (state %d), cannot start a new one", camerabin->video_state);
391       g_mutex_unlock (camerabin->video_capture_mutex);
392       return;
393     }
394     camerabin->video_state = GST_CAMERA_BIN_VIDEO_STARTING;
395   }
396
397   GST_CAMERA_BIN2_PROCESSING_INC (camerabin);
398
399   if (camerabin->location)
400     location = g_strdup_printf (camerabin->location, capture_index);
401
402   if (camerabin->mode == MODE_VIDEO) {
403     if (camerabin->audio_src) {
404       GstClock *clock = gst_pipeline_get_clock (GST_PIPELINE_CAST (camerabin));
405
406       gst_element_set_state (camerabin->audio_src, GST_STATE_PAUSED);
407
408       gst_element_set_base_time (camerabin->audio_src,
409           gst_element_get_base_time (GST_ELEMENT_CAST (camerabin)));
410       if (clock) {
411         gst_element_set_clock (camerabin->audio_src, clock);
412         gst_object_unref (clock);
413       }
414     }
415   } else {
416     /* store the next capture buffer filename */
417     g_mutex_lock (camerabin->image_capture_mutex);
418     camerabin->image_location_list =
419         g_slist_append (camerabin->image_location_list, g_strdup (location));
420     g_mutex_unlock (camerabin->image_capture_mutex);
421   }
422
423   if (camerabin->post_previews) {
424     /* Count processing of preview images too */
425     GST_CAMERA_BIN2_PROCESSING_INC (camerabin);
426     /* store the next preview filename */
427     g_mutex_lock (camerabin->preview_list_mutex);
428     camerabin->preview_location_list =
429         g_slist_append (camerabin->preview_location_list, location);
430     g_mutex_unlock (camerabin->preview_list_mutex);
431   } else {
432     g_free (location);
433   }
434
435   g_signal_emit_by_name (camerabin->src, "start-capture", NULL);
436   if (camerabin->mode == MODE_VIDEO) {
437     camerabin->audio_send_newseg = TRUE;
438     if (camerabin->audio_src)
439       gst_element_set_state (camerabin->audio_src, GST_STATE_PLAYING);
440
441     camerabin->video_state = GST_CAMERA_BIN_VIDEO_RECORDING;
442     g_mutex_unlock (camerabin->video_capture_mutex);
443   }
444
445   /*
446    * We have to push tags after start capture because the video elements
447    * might be flushing from the previous capture and are reset only on the
448    * notify from ready for capture going to FALSE
449    */
450   taglist = gst_tag_setter_get_tag_list (GST_TAG_SETTER (camerabin));
451   GST_DEBUG_OBJECT (camerabin, "Have tags from application: %"
452       GST_PTR_FORMAT, taglist);
453
454   if (camerabin->mode == MODE_IMAGE) {
455     /* Store image tags in a list and push them later, this prevents
456        start_capture() from blocking in pad_push_event call */
457     g_mutex_lock (camerabin->image_capture_mutex);
458     camerabin->image_tags_list =
459         g_slist_append (camerabin->image_tags_list,
460         taglist ? gst_tag_list_copy (taglist) : NULL);
461     g_mutex_unlock (camerabin->image_capture_mutex);
462   } else if (taglist) {
463     GstPad *active_pad;
464
465     active_pad = gst_element_get_static_pad (camerabin->src,
466         GST_BASE_CAMERA_SRC_VIDEO_PAD_NAME);
467     gst_pad_push_event (active_pad,
468         gst_event_new_tag (gst_tag_list_copy (taglist)));
469
470     gst_object_unref (active_pad);
471   }
472
473   GST_DEBUG_OBJECT (camerabin, "Start-capture end");
474 }
475
476 static void
477 gst_camera_bin_stop_capture (GstCameraBin2 * camerabin)
478 {
479   GST_DEBUG_OBJECT (camerabin, "Received stop-capture");
480   if (camerabin->mode == MODE_VIDEO) {
481     g_mutex_lock (camerabin->video_capture_mutex);
482     if (camerabin->video_state == GST_CAMERA_BIN_VIDEO_RECORDING) {
483       if (camerabin->src)
484         g_signal_emit_by_name (camerabin->src, "stop-capture", NULL);
485
486       camerabin->video_state = GST_CAMERA_BIN_VIDEO_FINISHING;
487       if (camerabin->audio_src) {
488         camerabin->audio_drop_eos = FALSE;
489         gst_element_send_event (camerabin->audio_src, gst_event_new_eos ());
490       }
491     }
492     g_mutex_unlock (camerabin->video_capture_mutex);
493   }
494 }
495
496 static void
497 gst_camera_bin_change_mode (GstCameraBin2 * camerabin, gint mode)
498 {
499   if (mode == camerabin->mode)
500     return;
501
502   GST_DEBUG_OBJECT (camerabin, "Changing mode to %d", mode);
503
504   /* stop any ongoing capture */
505   gst_camera_bin_stop_capture (camerabin);
506   camerabin->mode = mode;
507   if (camerabin->src)
508     g_object_set (camerabin->src, "mode", mode, NULL);
509 }
510
511 static void
512 gst_camera_bin_src_notify_readyforcapture (GObject * obj, GParamSpec * pspec,
513     gpointer user_data)
514 {
515   GstCameraBin2 *camera = GST_CAMERA_BIN2_CAST (user_data);
516   gboolean ready;
517
518   g_object_get (camera->src, "ready-for-capture", &ready, NULL);
519   if (!ready) {
520     gchar *location = NULL;
521
522     if (camera->mode == MODE_VIDEO) {
523       /* a video recording is about to start, we reset the videobin to clear eos/flushing state
524        * also need to clean the queue ! capsfilter before it */
525       gst_element_set_state (camera->video_encodebin, GST_STATE_NULL);
526       gst_element_set_state (camera->videosink, GST_STATE_NULL);
527       location = g_strdup_printf (camera->location, camera->capture_index);
528       GST_DEBUG_OBJECT (camera, "Switching videobin location to %s", location);
529       g_object_set (camera->videosink, "location", location, NULL);
530       g_free (location);
531       gst_element_set_state (camera->video_encodebin, GST_STATE_PLAYING);
532       gst_element_set_state (camera->videosink, GST_STATE_PLAYING);
533       gst_element_set_state (camera->videobin_capsfilter, GST_STATE_PLAYING);
534     } else if (camera->mode == MODE_IMAGE) {
535       gst_element_set_state (camera->image_encodebin, GST_STATE_NULL);
536       gst_element_set_state (camera->imagesink, GST_STATE_NULL);
537       gst_element_set_state (camera->imagebin_capsfilter, GST_STATE_NULL);
538       GST_DEBUG_OBJECT (camera, "Switching imagebin location to %s", location);
539       g_object_set (camera->imagesink, "location", camera->location, NULL);
540       gst_element_set_state (camera->image_encodebin, GST_STATE_PLAYING);
541       gst_element_set_state (camera->imagesink, GST_STATE_PLAYING);
542       gst_element_set_state (camera->imagebin_capsfilter, GST_STATE_PLAYING);
543     }
544     camera->capture_index++;
545   }
546 }
547
548 static void
549 gst_camera_bin_dispose (GObject * object)
550 {
551   GstCameraBin2 *camerabin = GST_CAMERA_BIN2_CAST (object);
552
553   g_free (camerabin->location);
554   g_mutex_free (camerabin->preview_list_mutex);
555   g_mutex_free (camerabin->image_capture_mutex);
556   g_mutex_free (camerabin->video_capture_mutex);
557   g_cond_free (camerabin->video_state_cond);
558
559   if (camerabin->src_capture_notify_id)
560     g_signal_handler_disconnect (camerabin->src,
561         camerabin->src_capture_notify_id);
562   if (camerabin->src)
563     gst_object_unref (camerabin->src);
564   if (camerabin->user_src)
565     gst_object_unref (camerabin->user_src);
566
567   if (camerabin->audio_src)
568     gst_object_unref (camerabin->audio_src);
569   if (camerabin->user_audio_src)
570     gst_object_unref (camerabin->user_audio_src);
571
572   if (camerabin->audio_capsfilter)
573     gst_object_unref (camerabin->audio_capsfilter);
574   if (camerabin->audio_volume)
575     gst_object_unref (camerabin->audio_volume);
576
577   if (camerabin->viewfinderbin)
578     gst_object_unref (camerabin->viewfinderbin);
579   if (camerabin->viewfinderbin_queue)
580     gst_object_unref (camerabin->viewfinderbin_queue);
581   if (camerabin->viewfinderbin_capsfilter)
582     gst_object_unref (camerabin->viewfinderbin_capsfilter);
583
584   if (camerabin->video_encodebin_signal_id)
585     g_signal_handler_disconnect (camerabin->video_encodebin,
586         camerabin->video_encodebin_signal_id);
587
588   if (camerabin->videosink)
589     gst_object_unref (camerabin->videosink);
590   if (camerabin->video_encodebin)
591     gst_object_unref (camerabin->video_encodebin);
592   if (camerabin->videobin_capsfilter)
593     gst_object_unref (camerabin->videobin_capsfilter);
594
595   if (camerabin->image_encodebin_signal_id)
596     g_signal_handler_disconnect (camerabin->image_encodebin,
597         camerabin->image_encodebin_signal_id);
598   if (camerabin->imagesink)
599     gst_object_unref (camerabin->imagesink);
600   if (camerabin->image_encodebin)
601     gst_object_unref (camerabin->image_encodebin);
602   if (camerabin->imagebin_capsfilter)
603     gst_object_unref (camerabin->imagebin_capsfilter);
604
605   if (camerabin->video_filter)
606     gst_object_unref (camerabin->video_filter);
607   if (camerabin->image_filter)
608     gst_object_unref (camerabin->image_filter);
609   if (camerabin->viewfinder_filter)
610     gst_object_unref (camerabin->viewfinder_filter);
611   if (camerabin->audio_filter)
612     gst_object_unref (camerabin->audio_filter);
613
614   if (camerabin->user_video_filter)
615     gst_object_unref (camerabin->user_video_filter);
616   if (camerabin->user_audio_filter)
617     gst_object_unref (camerabin->user_audio_filter);
618   if (camerabin->user_image_filter)
619     gst_object_unref (camerabin->user_image_filter);
620   if (camerabin->user_viewfinder_filter)
621     gst_object_unref (camerabin->user_viewfinder_filter);
622
623   if (camerabin->video_profile)
624     gst_encoding_profile_unref (camerabin->video_profile);
625   if (camerabin->image_profile)
626     gst_encoding_profile_unref (camerabin->image_profile);
627
628   if (camerabin->preview_caps)
629     gst_caps_replace (&camerabin->preview_caps, NULL);
630   if (camerabin->preview_filter) {
631     gst_object_unref (camerabin->preview_filter);
632     camerabin->preview_filter = NULL;
633   }
634
635   g_timer_destroy (camerabin->shot_to_save_timer);
636
637   G_OBJECT_CLASS (parent_class)->dispose (object);
638 }
639
640 static void
641 gst_camera_bin_finalize (GObject * object)
642 {
643   G_OBJECT_CLASS (parent_class)->finalize (object);
644 }
645
646 static void
647 gst_camera_bin_base_init (gpointer g_class)
648 {
649   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
650
651   gst_element_class_set_details_simple (element_class, "CameraBin2",
652       "Generic/Bin/Camera", "CameraBin2",
653       "Thiago Santos <thiago.sousa.santos@collabora.co.uk>");
654 }
655
656 static void
657 gst_camera_bin_class_init (GstCameraBin2Class * klass)
658 {
659   GObjectClass *object_class;
660   GstElementClass *element_class;
661   GstBinClass *bin_class;
662
663   parent_class = g_type_class_peek_parent (klass);
664   object_class = G_OBJECT_CLASS (klass);
665   element_class = GST_ELEMENT_CLASS (klass);
666   bin_class = GST_BIN_CLASS (klass);
667
668   object_class->dispose = gst_camera_bin_dispose;
669   object_class->finalize = gst_camera_bin_finalize;
670   object_class->set_property = gst_camera_bin_set_property;
671   object_class->get_property = gst_camera_bin_get_property;
672
673   element_class->change_state = GST_DEBUG_FUNCPTR (gst_camera_bin_change_state);
674   element_class->send_event = GST_DEBUG_FUNCPTR (gst_camera_bin_send_event);
675
676   bin_class->handle_message = gst_camera_bin_handle_message;
677
678   klass->start_capture = gst_camera_bin_start_capture;
679   klass->stop_capture = gst_camera_bin_stop_capture;
680
681   /**
682    * GstCameraBin2:mode:
683    *
684    * Set the mode of operation: still image capturing or video recording.
685    */
686   g_object_class_install_property (object_class, PROP_MODE,
687       g_param_spec_enum ("mode", "Mode",
688           "The capture mode (still image capture or video recording)",
689           GST_TYPE_CAMERABIN_MODE, DEFAULT_MODE,
690           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
691
692   g_object_class_install_property (object_class, PROP_LOCATION,
693       g_param_spec_string ("location", "Location",
694           "Location to save the captured files. A %d might be used on the"
695           "filename as a placeholder for a numeric index of the capture."
696           "Default is cap_%d",
697           DEFAULT_LOCATION, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
698
699   g_object_class_install_property (object_class, PROP_CAMERA_SRC,
700       g_param_spec_object ("camera-source", "Camera source",
701           "The camera source element to be used. It is only taken into use on"
702           " the next null to ready transition",
703           GST_TYPE_ELEMENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
704
705   g_object_class_install_property (object_class, PROP_AUDIO_SRC,
706       g_param_spec_object ("audio-source", "Audio source",
707           "The audio source element to be used on video recordings. It is only"
708           " taken into use on the next null to ready transition",
709           GST_TYPE_ELEMENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
710
711   g_object_class_install_property (object_class, PROP_MUTE_AUDIO,
712       g_param_spec_boolean ("mute", "Mute",
713           "If the audio recording should be muted. Note that this still "
714           "saves audio data to the resulting file, but they are silent. Use "
715           "a video-profile without audio to disable audio completely",
716           DEFAULT_MUTE_AUDIO, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
717
718   g_object_class_install_property (object_class,
719       PROP_AUDIO_CAPTURE_SUPPORTED_CAPS,
720       g_param_spec_boxed ("audio-capture-supported-caps",
721           "Audio capture supported caps",
722           "Formats supported for capturing audio represented as GstCaps",
723           GST_TYPE_CAPS, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
724
725   g_object_class_install_property (object_class,
726       PROP_AUDIO_CAPTURE_CAPS,
727       g_param_spec_boxed ("audio-capture-caps",
728           "Audio capture caps",
729           "Format to capture audio for video recording represented as GstCaps",
730           GST_TYPE_CAPS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
731
732   g_object_class_install_property (object_class,
733       PROP_IMAGE_CAPTURE_SUPPORTED_CAPS,
734       g_param_spec_boxed ("image-capture-supported-caps",
735           "Image capture supported caps",
736           "Formats supported for capturing images represented as GstCaps",
737           GST_TYPE_CAPS, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
738
739   g_object_class_install_property (object_class,
740       PROP_VIDEO_CAPTURE_SUPPORTED_CAPS,
741       g_param_spec_boxed ("video-capture-supported-caps",
742           "Video capture supported caps",
743           "Formats supported for capturing videos represented as GstCaps",
744           GST_TYPE_CAPS, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
745
746   g_object_class_install_property (object_class,
747       PROP_IMAGE_CAPTURE_CAPS,
748       g_param_spec_boxed ("image-capture-caps",
749           "Image capture caps",
750           "Caps for image capture",
751           GST_TYPE_CAPS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
752
753   g_object_class_install_property (object_class,
754       PROP_VIDEO_CAPTURE_CAPS,
755       g_param_spec_boxed ("video-capture-caps",
756           "Video capture caps",
757           "Caps for video capture",
758           GST_TYPE_CAPS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
759
760   g_object_class_install_property (object_class, PROP_POST_PREVIEWS,
761       g_param_spec_boolean ("post-previews", "Post Previews",
762           "If capture preview images should be posted to the bus",
763           DEFAULT_POST_PREVIEWS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
764
765   g_object_class_install_property (object_class, PROP_PREVIEW_CAPS,
766       g_param_spec_boxed ("preview-caps", "Preview caps",
767           "The caps of the preview image to be posted",
768           GST_TYPE_CAPS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
769
770   g_object_class_install_property (object_class, PROP_VIDEO_ENCODING_PROFILE,
771       gst_param_spec_mini_object ("video-profile", "Video Profile",
772           "The GstEncodingProfile to use for video recording. Audio is enabled "
773           "when this profile supports audio.", GST_TYPE_ENCODING_PROFILE,
774           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
775
776   g_object_class_install_property (object_class, PROP_IMAGE_FILTER,
777       g_param_spec_object ("image-filter", "Image filter",
778           "The element that will process captured image frames. (Should be"
779           " set on NULL state)",
780           GST_TYPE_ELEMENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
781
782   g_object_class_install_property (object_class, PROP_VIDEO_FILTER,
783       g_param_spec_object ("video-filter", "Video filter",
784           "The element that will process captured video frames. (Should be"
785           " set on NULL state)",
786           GST_TYPE_ELEMENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
787
788   g_object_class_install_property (object_class, PROP_VIEWFINDER_FILTER,
789       g_param_spec_object ("viewfinder-filter", "Viewfinder filter",
790           "The element that will process frames going to the viewfinder."
791           " (Should be set on NULL state)",
792           GST_TYPE_ELEMENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
793
794   g_object_class_install_property (object_class, PROP_AUDIO_FILTER,
795       g_param_spec_object ("audio-filter", "Audio filter",
796           "The element that will process captured audio buffers when recording"
797           ". (Should be set on NULL state)",
798           GST_TYPE_ELEMENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
799
800   g_object_class_install_property (object_class, PROP_PREVIEW_FILTER,
801       g_param_spec_object ("preview-filter", "Preview filter",
802           "The element that will process preview buffers."
803           " (Should be set on NULL state)",
804           GST_TYPE_ELEMENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
805
806   g_object_class_install_property (object_class, PROP_VIEWFINDER_SINK,
807       g_param_spec_object ("viewfinder-sink", "Viewfinder sink",
808           "The video sink of the viewfinder. It is only taken into use"
809           " on the next null to ready transition",
810           GST_TYPE_ELEMENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
811
812   g_object_class_install_property (object_class,
813       PROP_VIEWFINDER_CAPS,
814       g_param_spec_boxed ("viewfinder-caps",
815           "Viewfinder caps",
816           "Restricts the caps that can be used on the viewfinder",
817           GST_TYPE_CAPS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
818
819   g_object_class_install_property (object_class, PROP_ZOOM,
820       g_param_spec_float ("zoom", "Zoom",
821           "Digital zoom factor (e.g. 1.5 means 1.5x)", MIN_ZOOM, MAX_ZOOM,
822           DEFAULT_ZOOM, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
823
824   g_object_class_install_property (object_class, PROP_MAX_ZOOM,
825       g_param_spec_float ("max-zoom", "Maximum zoom level (note: may change "
826           "depending on resolution/implementation)",
827           "Digital zoom factor (e.g. 1.5 means 1.5x)", MIN_ZOOM, G_MAXFLOAT,
828           MAX_ZOOM, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
829
830   /* TODO
831    * Review before stable
832    * - One problem with using encodebin for images here is how jifmux
833    *   autoplugging works. We need to give it a higher rank and fix its
834    *   caps (it has image/jpeg on sink and src pads). Preliminary tests
835    *   show that jifmux is picked if image/jpeg is the caps of a container
836    *   profile. So this could work.
837    * - There seems to be a problem with encodebin for images currently as
838    *   it autoplugs a videorate that only starts outputing buffers after
839    *   getting the 2nd buffer.
840    */
841   g_object_class_install_property (object_class, PROP_IMAGE_ENCODING_PROFILE,
842       gst_param_spec_mini_object ("image-profile", "Image Profile",
843           "The GstEncodingProfile to use for image captures.",
844           GST_TYPE_ENCODING_PROFILE,
845           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
846
847   g_object_class_install_property (object_class, PROP_IDLE,
848       g_param_spec_boolean ("idle", "Idle",
849           "If camerabin2 is idle (not doing captures).", DEFAULT_IDLE,
850           G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
851
852   /* TODO review before going stable
853    * We have viewfinder-supported-caps that returns the caps that the
854    * camerasrc can produce on its viewfinder pad, this could easily be
855    * confused with what the viewfinder-sink accepts.
856    *
857    * Do we want to add a 'viewfinder-sink-supported-caps' or maybe change
858    * the name of this property?
859    */
860   g_object_class_install_property (object_class,
861       PROP_VIEWFINDER_SUPPORTED_CAPS,
862       g_param_spec_boxed ("viewfinder-supported-caps",
863           "Camera source Viewfinder pad supported caps",
864           "The caps that the camera source can produce on the viewfinder pad",
865           GST_TYPE_CAPS, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
866
867    /**
868     * GstCameraBin:flags
869     *
870     * Control the behaviour of encodebin.
871     */
872   g_object_class_install_property (object_class, PROP_FLAGS,
873       g_param_spec_flags ("flags", "Flags", "Flags to control behaviour",
874           GST_TYPE_CAM_FLAGS, DEFAULT_FLAGS,
875           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
876
877   /**
878    * GstCameraBin2::capture-start:
879    * @camera: the camera bin element
880    *
881    * Starts image capture or video recording depending on the Mode.
882    */
883   camerabin_signals[START_CAPTURE_SIGNAL] =
884       g_signal_new ("start-capture",
885       G_TYPE_FROM_CLASS (klass),
886       G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
887       G_STRUCT_OFFSET (GstCameraBin2Class, start_capture),
888       NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
889
890   /**
891    * GstCameraBin2::capture-stop:
892    * @camera: the camera bin element
893    */
894   camerabin_signals[STOP_CAPTURE_SIGNAL] =
895       g_signal_new ("stop-capture",
896       G_TYPE_FROM_CLASS (klass),
897       G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
898       G_STRUCT_OFFSET (GstCameraBin2Class, stop_capture),
899       NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
900 }
901
902 static void
903 gst_camera_bin_init (GstCameraBin2 * camera)
904 {
905   camera->post_previews = DEFAULT_POST_PREVIEWS;
906   camera->mode = DEFAULT_MODE;
907   camera->location = g_strdup (DEFAULT_LOCATION);
908   camera->viewfinderbin = gst_element_factory_make ("viewfinderbin", "vf-bin");
909   camera->zoom = DEFAULT_ZOOM;
910   camera->max_zoom = MAX_ZOOM;
911   camera->flags = DEFAULT_FLAGS;
912   camera->preview_list_mutex = g_mutex_new ();
913   camera->image_capture_mutex = g_mutex_new ();
914   camera->video_capture_mutex = g_mutex_new ();
915   camera->video_state_cond = g_cond_new ();
916
917   /* capsfilters are created here as we proxy their caps properties and
918    * this way we avoid having to store the caps while on NULL state to 
919    * set them later */
920   camera->videobin_capsfilter = gst_element_factory_make ("capsfilter",
921       "videobin-capsfilter");
922   camera->imagebin_capsfilter = gst_element_factory_make ("capsfilter",
923       "imagebin-capsfilter");
924   camera->viewfinderbin_capsfilter = gst_element_factory_make ("capsfilter",
925       "viewfinderbin-capsfilter");
926
927   gst_bin_add_many (GST_BIN (camera),
928       gst_object_ref (camera->viewfinderbin),
929       gst_object_ref (camera->videobin_capsfilter),
930       gst_object_ref (camera->imagebin_capsfilter),
931       gst_object_ref (camera->viewfinderbin_capsfilter), NULL);
932
933   /* these elements are only added if they are going to be used */
934   camera->audio_capsfilter = gst_element_factory_make ("capsfilter",
935       "audio-capsfilter");
936   camera->audio_volume = gst_element_factory_make ("volume", "audio-volume");
937
938   camera->shot_to_save_timer = g_timer_new ();
939 }
940
941 static void
942 gst_image_capture_bin_post_image_done (GstCameraBin2 * camera,
943     const gchar * filename)
944 {
945   GstMessage *msg;
946
947   g_return_if_fail (filename != NULL);
948
949   printf ("*** Shot-to-save delay: %lf\n",
950       g_timer_elapsed (camera->shot_to_save_timer, NULL));
951
952   msg = gst_message_new_element (GST_OBJECT_CAST (camera),
953       gst_structure_new ("image-done", "filename", G_TYPE_STRING,
954           filename, NULL));
955
956   if (!gst_element_post_message (GST_ELEMENT_CAST (camera), msg))
957     GST_WARNING_OBJECT (camera, "Failed to post image-done message");
958 }
959
960 static void
961 gst_video_capture_bin_post_video_done (GstCameraBin2 * camera)
962 {
963   GstMessage *msg;
964
965   msg = gst_message_new_element (GST_OBJECT_CAST (camera),
966       gst_structure_new ("video-done", NULL));
967
968   if (!gst_element_post_message (GST_ELEMENT_CAST (camera), msg))
969     GST_WARNING_OBJECT (camera, "Failed to post video-done message");
970 }
971
972 static void
973 gst_camera_bin_skip_next_preview (GstCameraBin2 * camerabin)
974 {
975   gchar *location;
976
977   g_mutex_lock (camerabin->preview_list_mutex);
978   if (camerabin->preview_location_list) {
979     location = camerabin->preview_location_list->data;
980     GST_DEBUG_OBJECT (camerabin, "Skipping preview for %s", location);
981     g_free (location);
982     camerabin->preview_location_list =
983         g_slist_delete_link (camerabin->preview_location_list,
984         camerabin->preview_location_list);
985     GST_CAMERA_BIN2_PROCESSING_DEC (camerabin);
986   } else {
987     GST_WARNING_OBJECT (camerabin, "No previews to skip");
988   }
989   g_mutex_unlock (camerabin->preview_list_mutex);
990 }
991
992 static gpointer
993 gst_camera_bin_video_reset_elements (gpointer u_data)
994 {
995   GstCameraBin2 *camerabin = GST_CAMERA_BIN2_CAST (u_data);
996
997   GST_DEBUG_OBJECT (camerabin, "Resetting video elements state");
998   g_mutex_lock (camerabin->video_capture_mutex);
999
1000   /* reset element states to clear eos/flushing pads */
1001   gst_element_set_state (camerabin->video_encodebin, GST_STATE_READY);
1002   gst_element_set_state (camerabin->videobin_capsfilter, GST_STATE_READY);
1003   if (camerabin->video_filter) {
1004     gst_element_set_state (camerabin->video_filter, GST_STATE_READY);
1005     gst_element_sync_state_with_parent (camerabin->video_filter);
1006   }
1007   gst_element_sync_state_with_parent (camerabin->videobin_capsfilter);
1008   gst_element_sync_state_with_parent (camerabin->video_encodebin);
1009
1010   if (camerabin->audio_src) {
1011     gst_element_set_state (camerabin->audio_capsfilter, GST_STATE_READY);
1012     gst_element_set_state (camerabin->audio_volume, GST_STATE_READY);
1013
1014     /* FIXME We need to set audiosrc to null to make it resync the ringbuffer
1015      * while bug https://bugzilla.gnome.org/show_bug.cgi?id=648359 isn't
1016      * fixed.
1017      *
1018      * Also, we don't reinit the audiosrc to keep audio devices from being open
1019      * and running until we really need them */
1020     gst_element_set_state (camerabin->audio_src, GST_STATE_NULL);
1021
1022     if (camerabin->audio_filter) {
1023       gst_element_set_state (camerabin->audio_filter, GST_STATE_READY);
1024       gst_element_sync_state_with_parent (camerabin->audio_filter);
1025     }
1026
1027     gst_element_sync_state_with_parent (camerabin->audio_capsfilter);
1028     gst_element_sync_state_with_parent (camerabin->audio_volume);
1029
1030   }
1031
1032   GST_DEBUG_OBJECT (camerabin, "Setting video state to idle");
1033   camerabin->video_state = GST_CAMERA_BIN_VIDEO_IDLE;
1034   g_cond_signal (camerabin->video_state_cond);
1035   g_mutex_unlock (camerabin->video_capture_mutex);
1036
1037   gst_object_unref (camerabin);
1038   return NULL;
1039 }
1040
1041 static void
1042 gst_camera_bin_handle_message (GstBin * bin, GstMessage * message)
1043 {
1044   GstCameraBin2 *camerabin = GST_CAMERA_BIN2_CAST (bin);
1045   gboolean dec_counter = FALSE;
1046
1047   switch (GST_MESSAGE_TYPE (message)) {
1048     case GST_MESSAGE_ELEMENT:{
1049       const GstStructure *structure = gst_message_get_structure (message);
1050       const gchar *filename;
1051
1052       if (gst_structure_has_name (structure, "GstMultiFileSink")) {
1053         filename = gst_structure_get_string (structure, "filename");
1054         GST_DEBUG_OBJECT (bin, "Got file save message from multifilesink, "
1055             "image %s has been saved", filename);
1056         if (filename) {
1057           gst_image_capture_bin_post_image_done (GST_CAMERA_BIN2_CAST (bin),
1058               filename);
1059         }
1060         dec_counter = TRUE;
1061       } else if (gst_structure_has_name (structure, "preview-image")) {
1062         gchar *location = NULL;
1063
1064         g_mutex_lock (camerabin->preview_list_mutex);
1065         if (camerabin->preview_location_list) {
1066           location = camerabin->preview_location_list->data;
1067           camerabin->preview_location_list =
1068               g_slist_delete_link (camerabin->preview_location_list,
1069               camerabin->preview_location_list);
1070           GST_DEBUG_OBJECT (camerabin, "Adding preview location to preview "
1071               "message '%s'", location);
1072         } else {
1073           GST_WARNING_OBJECT (camerabin, "Unexpected preview message received, "
1074               "won't be able to put location field into the message. This can "
1075               "happen if the source is posting previews while camerabin2 is "
1076               "shutting down");
1077         }
1078         g_mutex_unlock (camerabin->preview_list_mutex);
1079
1080         if (location) {
1081           GValue value = { 0 };
1082           g_value_init (&value, G_TYPE_STRING);
1083           g_value_take_string (&value, location);
1084           gst_structure_take_value ((GstStructure *) structure, "location",
1085               &value);
1086         }
1087
1088         GST_LOG_OBJECT (bin, "received preview-image message");
1089         dec_counter = TRUE;
1090       }
1091     }
1092       break;
1093     case GST_MESSAGE_WARNING:{
1094       GError *err = NULL;
1095       gchar *debug = NULL;
1096
1097       gst_message_parse_warning (message, &err, &debug);
1098       if (err->domain == GST_RESOURCE_ERROR) {
1099         /* some capturing failed */
1100         GST_WARNING_OBJECT (bin, "Capture failed, reason: %s - %s",
1101             err->message, debug);
1102         if (camerabin->post_previews) {
1103           gst_camera_bin_skip_next_preview (camerabin);
1104         }
1105         dec_counter = TRUE;
1106       }
1107       g_error_free (err);
1108       g_free (debug);
1109     }
1110       break;
1111     case GST_MESSAGE_EOS:{
1112       GstElement *src = GST_ELEMENT (GST_MESSAGE_SRC (message));
1113       if (src == GST_CAMERA_BIN2_CAST (bin)->videosink) {
1114
1115         g_mutex_lock (camerabin->video_capture_mutex);
1116         GST_DEBUG_OBJECT (bin, "EOS from video branch");
1117         g_assert (camerabin->video_state == GST_CAMERA_BIN_VIDEO_FINISHING);
1118
1119         gst_video_capture_bin_post_video_done (GST_CAMERA_BIN2_CAST (bin));
1120         dec_counter = TRUE;
1121
1122         if (!g_thread_create (gst_camera_bin_video_reset_elements,
1123                 gst_object_ref (camerabin), FALSE, NULL)) {
1124           GST_WARNING_OBJECT (camerabin, "Failed to create thread to "
1125               "reset video elements' state, video recordings may not work "
1126               "anymore");
1127           gst_object_unref (camerabin);
1128           camerabin->video_state = GST_CAMERA_BIN_VIDEO_IDLE;
1129         }
1130
1131         g_mutex_unlock (camerabin->video_capture_mutex);
1132       }
1133     }
1134       break;
1135     default:
1136       break;
1137   }
1138   if (message)
1139     GST_BIN_CLASS (parent_class)->handle_message (bin, message);
1140
1141   if (dec_counter)
1142     GST_CAMERA_BIN2_PROCESSING_DEC (camerabin);
1143 }
1144
1145 /*
1146  * Transforms:
1147  * ... ! previous_element [ ! current_filter ] ! next_element ! ...
1148  *
1149  * into:
1150  * ... ! previous_element [ ! new_filter ] ! next_element ! ...
1151  *
1152  * Where current_filter and new_filter might or might not be NULL
1153  */
1154 static void
1155 gst_camera_bin_check_and_replace_filter (GstCameraBin2 * camera,
1156     GstElement ** current_filter, GstElement * new_filter,
1157     GstElement * previous_element, GstElement * next_element,
1158     const gchar * prev_elem_pad)
1159 {
1160   if (*current_filter == new_filter) {
1161     GST_DEBUG_OBJECT (camera, "Current filter is the same as the previous, "
1162         "no switch needed.");
1163     return;
1164   }
1165
1166   GST_DEBUG_OBJECT (camera, "Replacing current filter (%s) with new filter "
1167       "(%s)", *current_filter ? GST_ELEMENT_NAME (*current_filter) : "null",
1168       new_filter ? GST_ELEMENT_NAME (new_filter) : "null");
1169
1170   if (*current_filter) {
1171     gst_bin_remove (GST_BIN_CAST (camera), *current_filter);
1172     gst_object_unref (*current_filter);
1173     *current_filter = NULL;
1174   } else {
1175     /* unlink the pads */
1176     gst_element_unlink (previous_element, next_element);
1177   }
1178
1179   if (new_filter) {
1180     *current_filter = gst_object_ref (new_filter);
1181     gst_bin_add (GST_BIN_CAST (camera), gst_object_ref (new_filter));
1182   }
1183
1184   if (prev_elem_pad) {
1185     if (new_filter) {
1186       gst_element_link_pads (previous_element, prev_elem_pad, new_filter, NULL);
1187       gst_element_link (new_filter, next_element);
1188     } else {
1189       gst_element_link_pads (previous_element, prev_elem_pad, next_element,
1190           NULL);
1191     }
1192   } else {
1193     if (new_filter)
1194       gst_element_link_many (previous_element, new_filter, next_element, NULL);
1195     else
1196       gst_element_link (previous_element, next_element);
1197   }
1198 }
1199
1200 static void
1201 encodebin_element_added (GstElement * encodebin, GstElement * new_element,
1202     GstCameraBin2 * camera)
1203 {
1204   GstElementFactory *factory = gst_element_get_factory (new_element);
1205
1206   if (factory != NULL) {
1207     if (strcmp (GST_PLUGIN_FEATURE_NAME (factory), "audiorate") == 0 ||
1208         strcmp (GST_PLUGIN_FEATURE_NAME (factory), "videorate") == 0) {
1209       g_object_set (new_element, "skip-to-first", TRUE, NULL);
1210     }
1211   }
1212
1213   if (gst_element_implements_interface (new_element, GST_TYPE_TAG_SETTER)) {
1214     GstTagSetter *tagsetter = GST_TAG_SETTER (new_element);
1215
1216     gst_tag_setter_set_tag_merge_mode (tagsetter, GST_TAG_MERGE_REPLACE);
1217   }
1218 }
1219
1220 #define VIDEO_PAD 1
1221 #define AUDIO_PAD 2
1222 static GstPad *
1223 encodebin_find_pad (GstCameraBin2 * camera, GstElement * encodebin,
1224     gint pad_type)
1225 {
1226   GstPad *pad = NULL;
1227   GstIterator *iter;
1228   gboolean done;
1229
1230   GST_DEBUG_OBJECT (camera, "Looking at encodebin pads, searching for %s pad",
1231       pad_type == VIDEO_PAD ? "video" : "audio");
1232
1233   iter = gst_element_iterate_sink_pads (encodebin);
1234   done = FALSE;
1235   while (!done) {
1236     switch (gst_iterator_next (iter, (gpointer *) & pad)) {
1237       case GST_ITERATOR_OK:
1238         if (pad_type == VIDEO_PAD) {
1239           if (strstr (GST_PAD_NAME (pad), "video") != NULL) {
1240             GST_DEBUG_OBJECT (camera, "Found video pad %s", GST_PAD_NAME (pad));
1241             done = TRUE;
1242             break;
1243           }
1244         } else if (pad_type == AUDIO_PAD) {
1245           if (strstr (GST_PAD_NAME (pad), "audio") != NULL) {
1246             GST_DEBUG_OBJECT (camera, "Found audio pad %s", GST_PAD_NAME (pad));
1247             done = TRUE;
1248             break;
1249           }
1250         }
1251         gst_object_unref (pad);
1252         pad = NULL;
1253         break;
1254       case GST_ITERATOR_RESYNC:
1255         gst_iterator_resync (iter);
1256         break;
1257       case GST_ITERATOR_ERROR:
1258         pad = NULL;
1259         done = TRUE;
1260         break;
1261       case GST_ITERATOR_DONE:
1262         pad = NULL;
1263         done = TRUE;
1264         break;
1265     }
1266   }
1267   gst_iterator_free (iter);
1268
1269   /* no static pad, try requesting one */
1270   if (pad == NULL) {
1271     GstElementClass *klass;
1272     GstPadTemplate *tmpl;
1273
1274     GST_DEBUG_OBJECT (camera, "No pads found, trying to request one");
1275
1276     klass = GST_ELEMENT_GET_CLASS (encodebin);
1277     tmpl = gst_element_class_get_pad_template (klass, pad_type == VIDEO_PAD ?
1278         "video_%d" : "audio_%d");
1279
1280     pad = gst_element_request_pad (encodebin, tmpl, NULL, NULL);
1281     GST_DEBUG_OBJECT (camera, "Got pad: %s", pad ? GST_PAD_NAME (pad) : "null");
1282   }
1283
1284   return pad;
1285 }
1286
1287 static gboolean
1288 gst_camera_bin_video_profile_has_audio (GstCameraBin2 * camera)
1289 {
1290   const GList *list;
1291
1292   g_return_val_if_fail (camera->video_profile != NULL, FALSE);
1293
1294   if (GST_IS_ENCODING_VIDEO_PROFILE (camera->video_profile))
1295     return FALSE;
1296
1297   for (list =
1298       gst_encoding_container_profile_get_profiles ((GstEncodingContainerProfile
1299               *) camera->video_profile); list; list = g_list_next (list)) {
1300     GstEncodingProfile *profile = (GstEncodingProfile *) list->data;
1301
1302     if (GST_IS_ENCODING_AUDIO_PROFILE (profile))
1303       return TRUE;
1304   }
1305
1306   return FALSE;
1307 }
1308
1309 static GstPadLinkReturn
1310 gst_camera_bin_link_encodebin (GstCameraBin2 * camera, GstElement * encodebin,
1311     GstElement * element, gint padtype)
1312 {
1313   GstPadLinkReturn ret;
1314   GstPad *srcpad;
1315   GstPad *sinkpad = NULL;
1316
1317   srcpad = gst_element_get_static_pad (element, "src");
1318   sinkpad = encodebin_find_pad (camera, encodebin, padtype);
1319
1320   g_assert (srcpad != NULL);
1321
1322   sinkpad = encodebin_find_pad (camera, encodebin, padtype);
1323
1324   /* there may be no available sink pad for encodebin in some situations:
1325    * e.g. missing elements or incompatible padtype */
1326   if (sinkpad == NULL) {
1327     gst_object_unref (srcpad);
1328     return GST_PAD_LINK_REFUSED;
1329   }
1330
1331   ret = gst_pad_link_full (srcpad, sinkpad, GST_PAD_LINK_CHECK_CAPS);
1332   gst_object_unref (sinkpad);
1333   gst_object_unref (srcpad);
1334
1335   return ret;
1336 }
1337
1338 static void
1339 gst_camera_bin_src_notify_max_zoom_cb (GObject * self, GParamSpec * pspec,
1340     gpointer user_data)
1341 {
1342   GstCameraBin2 *camera = (GstCameraBin2 *) user_data;
1343
1344   g_object_get (self, "max-zoom", &camera->max_zoom, NULL);
1345   GST_DEBUG_OBJECT (camera, "Max zoom updated to %f", camera->max_zoom);
1346   g_object_notify (G_OBJECT (camera), "max-zoom");
1347 }
1348
1349 static void
1350 gst_camera_bin_src_notify_zoom_cb (GObject * self, GParamSpec * pspec,
1351     gpointer user_data)
1352 {
1353   GstCameraBin2 *camera = (GstCameraBin2 *) user_data;
1354
1355   g_object_get (self, "zoom", &camera->zoom, NULL);
1356   GST_DEBUG_OBJECT (camera, "Zoom updated to %f", camera->zoom);
1357   g_object_notify (G_OBJECT (camera), "zoom");
1358 }
1359
1360 static gboolean
1361 gst_camera_bin_image_src_buffer_probe (GstPad * pad, GstBuffer * buf,
1362     gpointer data)
1363 {
1364   gboolean ret = TRUE;
1365   GstCameraBin2 *camerabin = data;
1366   GstEvent *evt;
1367   gchar *location = NULL;
1368   GstPad *peer;
1369   GstTagList *tags;
1370
1371   g_mutex_lock (camerabin->image_capture_mutex);
1372
1373   /* Push pending image tags */
1374   if (camerabin->image_tags_list) {
1375     tags = camerabin->image_tags_list->data;
1376     camerabin->image_tags_list =
1377         g_slist_delete_link (camerabin->image_tags_list,
1378         camerabin->image_tags_list);
1379     GST_DEBUG_OBJECT (camerabin, "Pushing tags from application: %"
1380         GST_PTR_FORMAT, tags);
1381     if (tags) {
1382       peer = gst_pad_get_peer (pad);
1383       gst_pad_send_event (peer, gst_event_new_tag (tags));
1384       gst_object_unref (peer);
1385     }
1386   } else {
1387     GST_DEBUG_OBJECT (camerabin, "No tags from application to send");
1388   }
1389
1390   /* Push image location event */
1391   if (camerabin->image_location_list) {
1392     location = camerabin->image_location_list->data;
1393     camerabin->image_location_list =
1394         g_slist_delete_link (camerabin->image_location_list,
1395         camerabin->image_location_list);
1396     GST_DEBUG_OBJECT (camerabin, "Sending image location change to '%s'",
1397         location);
1398   } else {
1399     GST_DEBUG_OBJECT (camerabin, "No filename location change to send");
1400     g_mutex_unlock (camerabin->image_capture_mutex);
1401     return ret;
1402   }
1403   g_mutex_unlock (camerabin->image_capture_mutex);
1404
1405   if (location) {
1406     evt = gst_camera_bin_new_event_file_location (location);
1407     peer = gst_pad_get_peer (pad);
1408     gst_pad_send_event (peer, evt);
1409     gst_object_unref (peer);
1410     g_free (location);
1411   } else {
1412     /* This means we don't have to encode the capture, it is used for
1413      * signaling the application just wants the preview */
1414     ret = FALSE;
1415     GST_CAMERA_BIN2_PROCESSING_DEC (camerabin);
1416   }
1417
1418   return ret;
1419 }
1420
1421
1422 static gboolean
1423 gst_camera_bin_image_sink_event_probe (GstPad * pad, GstEvent * event,
1424     gpointer data)
1425 {
1426   GstCameraBin2 *camerabin = data;
1427
1428   switch (GST_EVENT_TYPE (event)) {
1429     case GST_EVENT_CUSTOM_DOWNSTREAM:{
1430       if (gst_event_has_name (event, "new-location")) {
1431         const GstStructure *structure = gst_event_get_structure (event);
1432         const gchar *filename = gst_structure_get_string (structure,
1433             "location");
1434
1435         gst_element_set_state (camerabin->imagesink, GST_STATE_NULL);
1436         GST_DEBUG_OBJECT (camerabin, "Setting filename to imagesink: %s",
1437             filename);
1438         g_object_set (camerabin->imagesink, "location", filename, NULL);
1439         if (gst_element_set_state (camerabin->imagesink, GST_STATE_PLAYING) ==
1440             GST_STATE_CHANGE_FAILURE) {
1441           /* Resets the latest state change return, that would be a failure
1442            * and could cause problems in a camerabin2 state change */
1443           gst_element_set_state (camerabin->imagesink, GST_STATE_NULL);
1444         }
1445       }
1446     }
1447       break;
1448     default:
1449       break;
1450   }
1451
1452   return TRUE;
1453 }
1454
1455 static gboolean
1456 gst_camera_bin_audio_src_data_probe (GstPad * pad, GstMiniObject * obj,
1457     gpointer data)
1458 {
1459   GstCameraBin2 *camera = data;
1460   gboolean ret = TRUE;
1461
1462   if (GST_IS_BUFFER (obj)) {
1463     if (G_UNLIKELY (camera->audio_send_newseg)) {
1464       GstBuffer *buf = GST_BUFFER_CAST (obj);
1465       GstClockTime ts = GST_BUFFER_TIMESTAMP (buf);
1466       GstPad *peer;
1467
1468       if (!GST_CLOCK_TIME_IS_VALID (ts)) {
1469         ts = 0;
1470       }
1471
1472       peer = gst_pad_get_peer (pad);
1473       g_return_val_if_fail (peer != NULL, TRUE);
1474
1475       gst_pad_send_event (peer, gst_event_new_new_segment (FALSE, 1.0,
1476               GST_FORMAT_TIME, ts, -1, 0));
1477
1478       gst_object_unref (peer);
1479
1480       camera->audio_send_newseg = FALSE;
1481     }
1482   } else {
1483     GstEvent *event = GST_EVENT_CAST (obj);
1484     if (GST_EVENT_TYPE (event) == GST_EVENT_EOS) {
1485       /* we only let an EOS pass when the user is stopping a capture */
1486       if (camera->audio_drop_eos) {
1487         ret = FALSE;
1488       } else {
1489         camera->audio_drop_eos = TRUE;
1490         /* should already be false, but reinforce in case no buffers get
1491          * pushed */
1492         camera->audio_send_newseg = FALSE;
1493       }
1494     } else if (GST_EVENT_TYPE (event) == GST_EVENT_NEWSEGMENT) {
1495       ret = FALSE;
1496     }
1497   }
1498
1499   return ret;
1500 }
1501
1502 /**
1503  * gst_camera_bin_create_elements:
1504  * @param camera: the #GstCameraBin2
1505  *
1506  * Creates all elements inside #GstCameraBin2
1507  *
1508  * Each of the pads on the camera source is linked as follows:
1509  * .pad ! queue ! capsfilter ! correspondingbin
1510  *
1511  * Where 'correspondingbin' is the bin appropriate for
1512  * the camera source pad.
1513  */
1514 static gboolean
1515 gst_camera_bin_create_elements (GstCameraBin2 * camera)
1516 {
1517   gboolean new_src = FALSE;
1518   gboolean new_audio_src = FALSE;
1519   gboolean has_audio;
1520   gboolean profile_switched = FALSE;
1521   const gchar *missing_element_name;
1522   gint encbin_flags = 0;
1523
1524   if (!camera->elements_created) {
1525     /* Check that elements created in _init were really created */
1526     if (!(camera->audio_capsfilter && camera->videobin_capsfilter &&
1527             camera->imagebin_capsfilter && camera->viewfinderbin_capsfilter)) {
1528       missing_element_name = "capsfilter";
1529       goto missing_element;
1530     }
1531
1532     camera->video_encodebin =
1533         gst_element_factory_make ("encodebin", "video-encodebin");
1534     if (!camera->video_encodebin) {
1535       missing_element_name = "encodebin";
1536       goto missing_element;
1537     }
1538     camera->video_encodebin_signal_id =
1539         g_signal_connect (camera->video_encodebin, "element-added",
1540         (GCallback) encodebin_element_added, camera);
1541
1542     camera->videosink =
1543         gst_element_factory_make ("filesink", "videobin-filesink");
1544     if (!camera->videosink) {
1545       missing_element_name = "filesink";
1546       goto missing_element;
1547     }
1548     g_object_set (camera->videosink, "async", FALSE, NULL);
1549
1550     /* audio elements */
1551     if (!camera->audio_volume) {
1552       missing_element_name = "volume";
1553       goto missing_element;
1554     }
1555
1556     if (camera->video_profile == NULL) {
1557       GstEncodingContainerProfile *prof;
1558       GstEncodingVideoProfile *video_prof;
1559       GstCaps *caps;
1560
1561       caps = gst_caps_new_simple ("video/x-msvideo", NULL);
1562       prof = gst_encoding_container_profile_new ("avi", "mpeg4+avi",
1563           caps, NULL);
1564       gst_caps_unref (caps);
1565
1566       caps = gst_caps_new_simple ("video/mpeg",
1567           "mpegversion", G_TYPE_INT, 4,
1568           "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
1569       video_prof = gst_encoding_video_profile_new (caps, NULL, NULL, 1);
1570       gst_encoding_video_profile_set_variableframerate (video_prof, TRUE);
1571       if (!gst_encoding_container_profile_add_profile (prof,
1572               (GstEncodingProfile *) video_prof)) {
1573         GST_WARNING_OBJECT (camera, "Failed to create encoding profiles");
1574       }
1575       gst_caps_unref (caps);
1576
1577       camera->video_profile = (GstEncodingProfile *) prof;
1578       camera->video_profile_switch = TRUE;
1579     }
1580
1581     camera->image_encodebin =
1582         gst_element_factory_make ("encodebin", "image-encodebin");
1583     if (!camera->image_encodebin) {
1584       missing_element_name = "encodebin";
1585       goto missing_element;
1586     }
1587
1588     /* durations have no meaning for image captures */
1589     g_object_set (camera->image_encodebin, "queue-time-max", (guint64) 0, NULL);
1590
1591     camera->image_encodebin_signal_id =
1592         g_signal_connect (camera->image_encodebin, "element-added",
1593         (GCallback) encodebin_element_added, camera);
1594
1595     camera->imagesink =
1596         gst_element_factory_make ("multifilesink", "imagebin-filesink");
1597     if (!camera->imagesink) {
1598       missing_element_name = "multifilesink";
1599       goto missing_element;
1600     }
1601     g_object_set (camera->imagesink, "async", FALSE, "post-messages", TRUE,
1602         NULL);
1603
1604     if (camera->image_profile == NULL) {
1605       GstEncodingVideoProfile *prof;
1606       GstEncodingVideoProfile *vprof;
1607       GstCaps *caps;
1608
1609       caps = gst_caps_new_simple ("image/jpeg", NULL);
1610       vprof = gst_encoding_video_profile_new (caps, NULL, NULL, 1);
1611       gst_encoding_video_profile_set_variableframerate (vprof, TRUE);
1612       prof = gst_encoding_container_profile_new ("jpeg", "jpeg container", caps,
1613           NULL);
1614       gst_encoding_container_profile_add_profile (prof,
1615           (GstEncodingProfile *) vprof);
1616
1617       gst_caps_unref (caps);
1618       camera->image_profile = (GstEncodingProfile *) prof;
1619       camera->image_profile_switch = TRUE;
1620     }
1621
1622     camera->viewfinderbin_queue =
1623         gst_element_factory_make ("queue", "viewfinderbin-queue");
1624     if (!camera->viewfinderbin_queue) {
1625       missing_element_name = "queue";
1626       goto missing_element;
1627     }
1628
1629     g_object_set (camera->viewfinderbin_queue, "leaky", 2, "silent", TRUE,
1630         "max-size-time", (guint64) 0, "max-size-bytes", (guint) 0,
1631         "max-size-buffers", (guint) 1, NULL);
1632
1633     gst_bin_add_many (GST_BIN_CAST (camera),
1634         gst_object_ref (camera->video_encodebin),
1635         gst_object_ref (camera->videosink),
1636         gst_object_ref (camera->image_encodebin),
1637         gst_object_ref (camera->imagesink),
1638         gst_object_ref (camera->viewfinderbin_queue), NULL);
1639
1640     gst_element_link_pads_full (camera->video_encodebin, "src",
1641         camera->videosink, "sink", GST_PAD_LINK_CHECK_NOTHING);
1642     gst_element_link_pads_full (camera->image_encodebin, "src",
1643         camera->imagesink, "sink", GST_PAD_LINK_CHECK_NOTHING);
1644     gst_element_link_pads_full (camera->viewfinderbin_queue, "src",
1645         camera->viewfinderbin_capsfilter, "sink", GST_PAD_LINK_CHECK_CAPS);
1646     gst_element_link_pads_full (camera->viewfinderbin_capsfilter, "src",
1647         camera->viewfinderbin, "sink", GST_PAD_LINK_CHECK_CAPS);
1648
1649     {
1650       /* set an event probe to watch for custom location changes */
1651       GstPad *srcpad;
1652
1653       srcpad = gst_element_get_static_pad (camera->image_encodebin, "src");
1654
1655       gst_pad_add_event_probe (srcpad,
1656           (GCallback) gst_camera_bin_image_sink_event_probe, camera);
1657
1658       gst_object_unref (srcpad);
1659     }
1660
1661     /*
1662      * Video can't get into playing as its internal filesink will open
1663      * a file for writing and leave it empty if unused.
1664      *
1665      * Its state is managed using the current mode and the source's
1666      * ready-for-capture notify callback. When we are at video mode and
1667      * the source's ready-for-capture goes to FALSE it means it is
1668      * starting recording, so we should prepare the video bin.
1669      */
1670     gst_element_set_locked_state (camera->videosink, TRUE);
1671     gst_element_set_locked_state (camera->imagesink, TRUE);
1672     g_object_set (camera->videosink, "location", camera->location, NULL);
1673     g_object_set (camera->imagesink, "location", camera->location, NULL);
1674   }
1675
1676   /* propagate the flags property by translating appropriate values
1677    * to GstEncFlags values */
1678   if (camera->flags & GST_CAM_FLAG_NO_AUDIO_CONVERSION)
1679     encbin_flags |= (1 << 0);
1680   if (camera->flags & GST_CAM_FLAG_NO_VIDEO_CONVERSION)
1681     encbin_flags |= (1 << 1);
1682   g_object_set (camera->video_encodebin, "flags", encbin_flags, NULL);
1683
1684   /* image encodebin has only video branch so disable its conversion elements
1685    * appropriately */
1686   if (camera->flags & GST_CAM_FLAG_NO_IMAGE_CONVERSION)
1687     g_object_set (camera->image_encodebin, "flags", (1 << 1), NULL);
1688
1689   g_object_set (camera->viewfinderbin, "disable-converters",
1690       camera->flags & GST_CAM_FLAG_NO_VIEWFINDER_CONVERSION ? TRUE : FALSE,
1691       NULL);
1692
1693   if (camera->video_profile_switch) {
1694     GST_DEBUG_OBJECT (camera, "Switching video-encodebin's profile");
1695     g_object_set (camera->video_encodebin, "profile", camera->video_profile,
1696         NULL);
1697     if (GST_PAD_LINK_FAILED (gst_camera_bin_link_encodebin (camera,
1698                 camera->video_encodebin, camera->videobin_capsfilter,
1699                 VIDEO_PAD))) {
1700       goto fail;
1701     }
1702     camera->video_profile_switch = FALSE;
1703
1704     /* used to trigger relinking further down */
1705     profile_switched = TRUE;
1706   }
1707
1708   if (camera->image_profile_switch) {
1709     GST_DEBUG_OBJECT (camera, "Switching image-encodebin's profile");
1710     g_object_set (camera->image_encodebin, "profile", camera->image_profile,
1711         NULL);
1712     if (GST_PAD_LINK_FAILED (gst_camera_bin_link_encodebin (camera,
1713                 camera->image_encodebin, camera->imagebin_capsfilter,
1714                 VIDEO_PAD))) {
1715       goto fail;
1716     }
1717     camera->image_profile_switch = FALSE;
1718   }
1719
1720   /* check if we need to replace the camera src */
1721   if (camera->src) {
1722     if (camera->user_src && camera->user_src != camera->src) {
1723
1724       if (camera->src_capture_notify_id)
1725         g_signal_handler_disconnect (camera->src,
1726             camera->src_capture_notify_id);
1727
1728       gst_bin_remove (GST_BIN_CAST (camera), camera->src);
1729       gst_object_unref (camera->src);
1730       camera->src = NULL;
1731     }
1732   }
1733
1734   if (!camera->src) {
1735     if (camera->user_src) {
1736       camera->src = gst_object_ref (camera->user_src);
1737     } else {
1738       camera->src = gst_element_factory_make ("omxcamerabinsrc", "camerasrc");
1739     }
1740
1741     new_src = TRUE;
1742   }
1743
1744   g_assert (camera->src != NULL);
1745   g_object_set (camera->src, "mode", camera->mode, NULL);
1746   if (camera->src) {
1747     if (g_object_class_find_property (G_OBJECT_GET_CLASS (camera->src),
1748             "preview-caps")) {
1749       g_object_set (camera->src, "post-previews", camera->post_previews,
1750           "preview-caps", camera->preview_caps, "preview-filter",
1751           camera->preview_filter, NULL);
1752     }
1753     g_signal_connect (G_OBJECT (camera->src), "notify::zoom",
1754         (GCallback) gst_camera_bin_src_notify_zoom_cb, camera);
1755     g_object_set (camera->src, "zoom", camera->zoom, NULL);
1756     g_signal_connect (G_OBJECT (camera->src), "notify::max-zoom",
1757         (GCallback) gst_camera_bin_src_notify_max_zoom_cb, camera);
1758   }
1759   if (new_src) {
1760     GstPad *imgsrc = gst_element_get_static_pad (camera->src, "imgsrc");
1761
1762     gst_bin_add (GST_BIN_CAST (camera), gst_object_ref (camera->src));
1763     camera->src_capture_notify_id = g_signal_connect (G_OBJECT (camera->src),
1764         "notify::ready-for-capture",
1765         G_CALLBACK (gst_camera_bin_src_notify_readyforcapture), camera);
1766     gst_element_link_pads (camera->src, "vfsrc", camera->viewfinderbin_queue,
1767         "sink");
1768
1769     if (!gst_element_link_pads (camera->src, "imgsrc",
1770             camera->imagebin_capsfilter, "sink")) {
1771       GST_ERROR_OBJECT (camera,
1772           "Failed to link camera source's imgsrc pad to image bin capsfilter");
1773       goto fail;
1774     }
1775     if (!gst_element_link_pads (camera->src, "vidsrc",
1776             camera->videobin_capsfilter, "sink")) {
1777       GST_ERROR_OBJECT (camera,
1778           "Failed to link camera source's vidsrc pad to video bin capsfilter");
1779       goto fail;
1780     }
1781
1782     gst_pad_add_buffer_probe (imgsrc,
1783         (GCallback) gst_camera_bin_image_src_buffer_probe, camera);
1784     gst_object_unref (imgsrc);
1785   }
1786
1787   gst_camera_bin_check_and_replace_filter (camera, &camera->image_filter,
1788       camera->user_image_filter, camera->imagebin_capsfilter,
1789       camera->image_encodebin, NULL);
1790   gst_camera_bin_check_and_replace_filter (camera, &camera->video_filter,
1791       camera->user_video_filter, camera->src, camera->videobin_capsfilter,
1792       "vidsrc");
1793   gst_camera_bin_check_and_replace_filter (camera, &camera->viewfinder_filter,
1794       camera->user_viewfinder_filter, camera->viewfinderbin_queue,
1795       camera->viewfinderbin_capsfilter, NULL);
1796
1797   /* check if we need to replace the camera audio src */
1798   has_audio = gst_camera_bin_video_profile_has_audio (camera);
1799   if (camera->audio_src) {
1800     if ((camera->user_audio_src && camera->user_audio_src != camera->audio_src)
1801         || !has_audio) {
1802       gst_bin_remove (GST_BIN_CAST (camera), camera->audio_src);
1803       gst_bin_remove (GST_BIN_CAST (camera), camera->audio_volume);
1804       gst_bin_remove (GST_BIN_CAST (camera), camera->audio_capsfilter);
1805       gst_object_unref (camera->audio_src);
1806       camera->audio_src = NULL;
1807     }
1808   }
1809
1810   if (!camera->audio_src && has_audio) {
1811     if (camera->user_audio_src) {
1812       camera->audio_src = gst_object_ref (camera->user_audio_src);
1813     } else {
1814       camera->audio_src =
1815           gst_element_factory_make (DEFAULT_AUDIO_SRC, "audiosrc");
1816       if (!camera->audio_src) {
1817         missing_element_name = DEFAULT_AUDIO_SRC;
1818         goto missing_element;
1819       }
1820     }
1821
1822     gst_element_set_locked_state (camera->audio_src, TRUE);
1823     new_audio_src = TRUE;
1824   }
1825
1826   if (new_audio_src) {
1827     GstPad *srcpad;
1828
1829     if (g_object_class_find_property (G_OBJECT_GET_CLASS (camera->audio_src),
1830             "provide-clock")) {
1831       g_object_set (camera->audio_src, "provide-clock", FALSE, NULL);
1832     }
1833     gst_bin_add (GST_BIN_CAST (camera), gst_object_ref (camera->audio_src));
1834     gst_bin_add (GST_BIN_CAST (camera), gst_object_ref (camera->audio_volume));
1835     gst_bin_add (GST_BIN_CAST (camera),
1836         gst_object_ref (camera->audio_capsfilter));
1837
1838     gst_element_link_pads_full (camera->audio_src, "src",
1839         camera->audio_volume, "sink", GST_PAD_LINK_CHECK_CAPS);
1840     gst_element_link_pads_full (camera->audio_volume, "src",
1841         camera->audio_capsfilter, "sink", GST_PAD_LINK_CHECK_CAPS);
1842
1843     srcpad = gst_element_get_static_pad (camera->audio_src, "src");
1844
1845     /* 1) drop EOS for audiosrc elements that push them on state_changes
1846      * (basesrc does this) 
1847      * 2) Fix newsegment events to have start time = first buffer ts */
1848     gst_pad_add_data_probe (srcpad,
1849         (GCallback) gst_camera_bin_audio_src_data_probe, camera);
1850
1851     gst_object_unref (srcpad);
1852   }
1853   if (has_audio) {
1854     gst_camera_bin_check_and_replace_filter (camera, &camera->audio_filter,
1855         camera->user_audio_filter, camera->audio_src, camera->audio_volume,
1856         "src");
1857   }
1858
1859   if ((profile_switched && has_audio) || new_audio_src) {
1860     if (GST_PAD_LINK_FAILED (gst_camera_bin_link_encodebin (camera,
1861                 camera->video_encodebin, camera->audio_capsfilter,
1862                 AUDIO_PAD))) {
1863       goto fail;
1864     }
1865   }
1866
1867   camera->elements_created = TRUE;
1868   return TRUE;
1869
1870 missing_element:
1871   gst_element_post_message (GST_ELEMENT_CAST (camera),
1872       gst_missing_element_message_new (GST_ELEMENT_CAST (camera),
1873           missing_element_name));
1874   GST_ELEMENT_ERROR (camera, CORE, MISSING_PLUGIN,
1875       (_("Missing element '%s' - check your GStreamer installation."),
1876           missing_element_name), (NULL));
1877   goto fail;
1878
1879 fail:
1880   /* FIXME properly clean up */
1881   return FALSE;
1882 }
1883
1884 static void
1885 _gst_tag_list_free_maybe (GstTagList * taglist)
1886 {
1887   if (taglist)
1888     gst_tag_list_free (taglist);
1889 }
1890
1891 static GstStateChangeReturn
1892 gst_camera_bin_change_state (GstElement * element, GstStateChange trans)
1893 {
1894   GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
1895   GstCameraBin2 *camera = GST_CAMERA_BIN2_CAST (element);
1896
1897
1898   switch (trans) {
1899     case GST_STATE_CHANGE_NULL_TO_READY:
1900       if (!gst_camera_bin_create_elements (camera)) {
1901         return GST_STATE_CHANGE_FAILURE;
1902       }
1903       break;
1904     case GST_STATE_CHANGE_READY_TO_PAUSED:
1905       GST_CAMERA_BIN2_RESET_PROCESSING_COUNTER (camera);
1906       camera->audio_drop_eos = TRUE;
1907       camera->audio_send_newseg = FALSE;
1908       break;
1909     case GST_STATE_CHANGE_PAUSED_TO_READY:
1910       if (GST_STATE (camera->videosink) >= GST_STATE_PAUSED)
1911         gst_element_set_state (camera->videosink, GST_STATE_READY);
1912       if (GST_STATE (camera->imagesink) >= GST_STATE_PAUSED)
1913         gst_element_set_state (camera->imagesink, GST_STATE_READY);
1914       break;
1915     case GST_STATE_CHANGE_READY_TO_NULL:
1916       gst_element_set_state (camera->videosink, GST_STATE_NULL);
1917       gst_element_set_state (camera->imagesink, GST_STATE_NULL);
1918       break;
1919     default:
1920       break;
1921   }
1922
1923   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, trans);
1924
1925   switch (trans) {
1926     case GST_STATE_CHANGE_PAUSED_TO_READY:
1927       if (GST_STATE (camera->videosink) >= GST_STATE_PAUSED)
1928         gst_element_set_state (camera->videosink, GST_STATE_READY);
1929       if (GST_STATE (camera->imagesink) >= GST_STATE_PAUSED)
1930         gst_element_set_state (camera->imagesink, GST_STATE_READY);
1931       if (camera->audio_src && GST_STATE (camera->audio_src) >= GST_STATE_READY)
1932         gst_element_set_state (camera->audio_src, GST_STATE_READY);
1933
1934       gst_tag_setter_reset_tags (GST_TAG_SETTER (camera));
1935       GST_CAMERA_BIN2_RESET_PROCESSING_COUNTER (camera);
1936       camera->video_state = GST_CAMERA_BIN_VIDEO_IDLE;
1937
1938       g_mutex_lock (camera->image_capture_mutex);
1939       g_slist_foreach (camera->image_location_list, (GFunc) g_free, NULL);
1940       g_slist_free (camera->image_location_list);
1941       camera->image_location_list = NULL;
1942
1943       g_slist_foreach (camera->image_tags_list,
1944           (GFunc) _gst_tag_list_free_maybe, NULL);
1945       g_slist_free (camera->image_tags_list);
1946       camera->image_tags_list = NULL;
1947       g_mutex_unlock (camera->image_capture_mutex);
1948
1949       g_mutex_lock (camera->preview_list_mutex);
1950       g_slist_foreach (camera->preview_location_list, (GFunc) g_free, NULL);
1951       g_slist_free (camera->preview_location_list);
1952       camera->preview_location_list = NULL;
1953       g_mutex_unlock (camera->preview_list_mutex);
1954
1955       /* explicitly set to READY as they might be outside of the bin */
1956       gst_element_set_state (camera->audio_volume, GST_STATE_READY);
1957       gst_element_set_state (camera->audio_capsfilter, GST_STATE_READY);
1958       break;
1959     case GST_STATE_CHANGE_READY_TO_NULL:
1960       gst_element_set_state (camera->videosink, GST_STATE_NULL);
1961       gst_element_set_state (camera->imagesink, GST_STATE_NULL);
1962       if (camera->audio_src)
1963         gst_element_set_state (camera->audio_src, GST_STATE_NULL);
1964
1965       /* explicitly set to NULL as they might be outside of the bin */
1966       gst_element_set_state (camera->audio_volume, GST_STATE_NULL);
1967       gst_element_set_state (camera->audio_capsfilter, GST_STATE_NULL);
1968
1969       break;
1970     default:
1971       break;
1972   }
1973
1974   return ret;
1975 }
1976
1977 static gboolean
1978 gst_camera_bin_send_event (GstElement * element, GstEvent * event)
1979 {
1980   GstCameraBin2 *camera = GST_CAMERA_BIN2_CAST (element);
1981   gboolean res;
1982
1983   /* avoid losing our ref to send_event */
1984   gst_event_ref (event);
1985
1986   res = GST_ELEMENT_CLASS (parent_class)->send_event (element, event);
1987   switch (GST_EVENT_TYPE (event)) {
1988     case GST_EVENT_EOS:
1989     {
1990       GstState current;
1991
1992       if (camera->videosink) {
1993         gst_element_get_state (camera->videosink, &current, NULL, 0);
1994         if (current <= GST_STATE_READY)
1995           gst_element_post_message (camera->videosink,
1996               gst_message_new_eos (GST_OBJECT (camera->videosink)));
1997       }
1998       if (camera->imagesink) {
1999         gst_element_get_state (camera->imagesink, &current, NULL, 0);
2000         if (current <= GST_STATE_READY)
2001           gst_element_post_message (camera->imagesink,
2002               gst_message_new_eos (GST_OBJECT (camera->imagesink)));
2003       }
2004       break;
2005     }
2006
2007     default:
2008       break;
2009   }
2010
2011   gst_event_unref (event);
2012   return res;
2013 }
2014
2015 static void
2016 gst_camera_bin_set_location (GstCameraBin2 * camera, const gchar * location)
2017 {
2018   GST_DEBUG_OBJECT (camera, "Setting mode %d location to %s", camera->mode,
2019       location);
2020   g_free (camera->location);
2021   camera->location = g_strdup (location);
2022 }
2023
2024 static void
2025 gst_camera_bin_set_audio_src (GstCameraBin2 * camera, GstElement * src)
2026 {
2027   GST_DEBUG_OBJECT (GST_OBJECT (camera),
2028       "Setting audio source %" GST_PTR_FORMAT, src);
2029
2030   if (camera->user_audio_src)
2031     g_object_unref (camera->user_audio_src);
2032
2033   if (src)
2034     g_object_ref (src);
2035   camera->user_audio_src = src;
2036 }
2037
2038 static void
2039 gst_camera_bin_set_camera_src (GstCameraBin2 * camera, GstElement * src)
2040 {
2041   GST_DEBUG_OBJECT (GST_OBJECT (camera),
2042       "Setting camera source %" GST_PTR_FORMAT, src);
2043
2044   if (camera->user_src)
2045     g_object_unref (camera->user_src);
2046
2047   if (src)
2048     g_object_ref (src);
2049   camera->user_src = src;
2050 }
2051
2052 static void
2053 gst_camera_bin_set_property (GObject * object, guint prop_id,
2054     const GValue * value, GParamSpec * pspec)
2055 {
2056   GstCameraBin2 *camera = GST_CAMERA_BIN2_CAST (object);
2057
2058   switch (prop_id) {
2059     case PROP_MODE:
2060       gst_camera_bin_change_mode (camera, g_value_get_enum (value));
2061       break;
2062     case PROP_LOCATION:
2063       gst_camera_bin_set_location (camera, g_value_get_string (value));
2064       break;
2065     case PROP_CAMERA_SRC:
2066       gst_camera_bin_set_camera_src (camera, g_value_get_object (value));
2067       break;
2068     case PROP_AUDIO_SRC:
2069       gst_camera_bin_set_audio_src (camera, g_value_get_object (value));
2070       break;
2071     case PROP_MUTE_AUDIO:
2072       g_object_set (camera->audio_volume, "mute", g_value_get_boolean (value),
2073           NULL);
2074       break;
2075     case PROP_AUDIO_CAPTURE_CAPS:{
2076       GST_DEBUG_OBJECT (camera,
2077           "Setting audio capture caps to %" GST_PTR_FORMAT,
2078           gst_value_get_caps (value));
2079
2080       if (G_LIKELY (camera->audio_capsfilter)) {
2081         g_object_set (camera->audio_capsfilter, "caps",
2082             gst_value_get_caps (value), NULL);
2083       } else {
2084         GST_WARNING_OBJECT (camera, "Audio capsfilter missing");
2085       }
2086     }
2087       break;
2088     case PROP_IMAGE_CAPTURE_CAPS:{
2089       GstPad *pad = NULL;
2090
2091       if (camera->src)
2092         pad =
2093             gst_element_get_static_pad (camera->src,
2094             GST_BASE_CAMERA_SRC_IMAGE_PAD_NAME);
2095
2096       GST_DEBUG_OBJECT (camera,
2097           "Setting image capture caps to %" GST_PTR_FORMAT,
2098           gst_value_get_caps (value));
2099
2100       if (G_LIKELY (camera->imagebin_capsfilter)) {
2101         g_object_set (camera->imagebin_capsfilter, "caps",
2102             gst_value_get_caps (value), NULL);
2103       } else {
2104         GST_WARNING_OBJECT (camera, "Image capsfilter missing");
2105       }
2106
2107       /* set the capsfilter caps and notify the src to renegotiate */
2108       if (pad) {
2109         GST_DEBUG_OBJECT (camera, "Pushing renegotiate on %s",
2110             GST_PAD_NAME (pad));
2111         gst_pad_send_event (pad, gst_camera_bin_new_event_renegotiate ());
2112         gst_object_unref (pad);
2113       }
2114     }
2115       break;
2116     case PROP_VIDEO_CAPTURE_CAPS:{
2117       GstPad *pad = NULL;
2118
2119       if (camera->src)
2120         pad =
2121             gst_element_get_static_pad (camera->src,
2122             GST_BASE_CAMERA_SRC_VIDEO_PAD_NAME);
2123
2124       GST_DEBUG_OBJECT (camera,
2125           "Setting video capture caps to %" GST_PTR_FORMAT,
2126           gst_value_get_caps (value));
2127
2128       /* set the capsfilter caps and notify the src to renegotiate */
2129       if (G_LIKELY (camera->videobin_capsfilter)) {
2130         g_object_set (camera->videobin_capsfilter, "caps",
2131             gst_value_get_caps (value), NULL);
2132       } else {
2133         GST_WARNING_OBJECT (camera, "Video capsfilter missing");
2134       }
2135
2136       if (pad) {
2137         GST_DEBUG_OBJECT (camera, "Pushing renegotiate on %s",
2138             GST_PAD_NAME (pad));
2139         gst_pad_send_event (pad, gst_camera_bin_new_event_renegotiate ());
2140         gst_object_unref (pad);
2141       }
2142     }
2143       break;
2144     case PROP_VIEWFINDER_CAPS:{
2145       GstPad *pad = NULL;
2146
2147       if (camera->src)
2148         pad =
2149             gst_element_get_static_pad (camera->src,
2150             GST_BASE_CAMERA_SRC_VIEWFINDER_PAD_NAME);
2151
2152       GST_DEBUG_OBJECT (camera,
2153           "Setting viewfinder capture caps to %" GST_PTR_FORMAT,
2154           gst_value_get_caps (value));
2155
2156       /* set the capsfilter caps and notify the src to renegotiate */
2157       if (G_LIKELY (camera->viewfinderbin_capsfilter)) {
2158         g_object_set (camera->viewfinderbin_capsfilter, "caps",
2159             gst_value_get_caps (value), NULL);
2160       } else {
2161         GST_WARNING_OBJECT (camera, "Viewfinder capsfilter missing");
2162       }
2163
2164       if (pad) {
2165         GST_DEBUG_OBJECT (camera, "Pushing renegotiate on %s",
2166             GST_PAD_NAME (pad));
2167         gst_pad_send_event (pad, gst_camera_bin_new_event_renegotiate ());
2168         gst_object_unref (pad);
2169       }
2170     }
2171       break;
2172     case PROP_POST_PREVIEWS:
2173       camera->post_previews = g_value_get_boolean (value);
2174       if (camera->src
2175           && g_object_class_find_property (G_OBJECT_GET_CLASS (camera->src),
2176               "post-previews"))
2177         g_object_set (camera->src, "post-previews", camera->post_previews,
2178             NULL);
2179       break;
2180     case PROP_PREVIEW_CAPS:
2181       gst_caps_replace (&camera->preview_caps,
2182           (GstCaps *) gst_value_get_caps (value));
2183       if (camera->src
2184           && g_object_class_find_property (G_OBJECT_GET_CLASS (camera->src),
2185               "preview-caps"))
2186         g_object_set (camera->src, "preview-caps", camera->preview_caps, NULL);
2187       break;
2188     case PROP_VIDEO_ENCODING_PROFILE:
2189       if (camera->video_profile)
2190         gst_encoding_profile_unref (camera->video_profile);
2191       camera->video_profile =
2192           (GstEncodingProfile *) gst_value_dup_mini_object (value);
2193       camera->video_profile_switch = TRUE;
2194       break;
2195     case PROP_IMAGE_FILTER:
2196       if (camera->user_image_filter)
2197         g_object_unref (camera->user_image_filter);
2198
2199       camera->user_image_filter = g_value_dup_object (value);
2200       break;
2201     case PROP_VIDEO_FILTER:
2202       if (camera->user_video_filter)
2203         g_object_unref (camera->user_video_filter);
2204
2205       camera->user_video_filter = g_value_dup_object (value);
2206       break;
2207     case PROP_VIEWFINDER_FILTER:
2208       if (camera->user_viewfinder_filter)
2209         g_object_unref (camera->user_viewfinder_filter);
2210
2211       camera->user_viewfinder_filter = g_value_dup_object (value);
2212       break;
2213     case PROP_PREVIEW_FILTER:
2214       if (camera->preview_filter)
2215         g_object_unref (camera->preview_filter);
2216
2217       camera->preview_filter = g_value_dup_object (value);
2218       if (camera->src
2219           && g_object_class_find_property (G_OBJECT_GET_CLASS (camera->src),
2220               "preview-filter"))
2221         g_object_set (camera->src, "preview-filter", camera->preview_filter,
2222             NULL);
2223       break;
2224     case PROP_AUDIO_FILTER:
2225       if (camera->user_audio_filter)
2226         g_object_unref (camera->user_audio_filter);
2227
2228       camera->user_audio_filter = g_value_dup_object (value);
2229       break;
2230     case PROP_VIEWFINDER_SINK:
2231       g_object_set (camera->viewfinderbin, "video-sink",
2232           g_value_get_object (value), NULL);
2233       break;
2234     case PROP_ZOOM:
2235       camera->zoom = g_value_get_float (value);
2236       /* limit to max-zoom */
2237       if (camera->zoom > camera->max_zoom) {
2238         GST_DEBUG_OBJECT (camera, "Clipping zoom %f to max-zoom %f",
2239             camera->zoom, camera->max_zoom);
2240         camera->zoom = camera->max_zoom;
2241       }
2242       if (camera->src)
2243         g_object_set (camera->src, "zoom", camera->zoom, NULL);
2244       break;
2245     case PROP_IMAGE_ENCODING_PROFILE:
2246       if (camera->image_profile)
2247         gst_encoding_profile_unref (camera->image_profile);
2248       camera->image_profile =
2249           (GstEncodingProfile *) gst_value_dup_mini_object (value);
2250       camera->image_profile_switch = TRUE;
2251       break;
2252     case PROP_FLAGS:
2253       camera->flags = g_value_get_flags (value);
2254       break;
2255     default:
2256       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
2257       break;
2258   }
2259 }
2260
2261 static void
2262 gst_camera_bin_get_property (GObject * object, guint prop_id,
2263     GValue * value, GParamSpec * pspec)
2264 {
2265   GstCameraBin2 *camera = GST_CAMERA_BIN2_CAST (object);
2266
2267   switch (prop_id) {
2268     case PROP_MODE:
2269       g_value_set_enum (value, camera->mode);
2270       break;
2271     case PROP_LOCATION:
2272       g_value_set_string (value, camera->location);
2273       break;
2274     case PROP_CAMERA_SRC:
2275       g_value_set_object (value, camera->user_src);
2276       break;
2277     case PROP_AUDIO_SRC:
2278       g_value_set_object (value, camera->user_audio_src);
2279       break;
2280     case PROP_MUTE_AUDIO:{
2281       gboolean mute;
2282
2283       g_object_get (camera->audio_volume, "mute", &mute, NULL);
2284       g_value_set_boolean (value, mute);
2285       break;
2286     }
2287     case PROP_AUDIO_CAPTURE_SUPPORTED_CAPS:
2288     case PROP_VIDEO_CAPTURE_SUPPORTED_CAPS:
2289     case PROP_VIEWFINDER_SUPPORTED_CAPS:
2290     case PROP_IMAGE_CAPTURE_SUPPORTED_CAPS:{
2291       GstPad *pad;
2292       GstElement *element;
2293       GstCaps *caps;
2294       const gchar *padname;
2295
2296       if (prop_id == PROP_VIDEO_CAPTURE_SUPPORTED_CAPS) {
2297         element = camera->src;
2298         padname = GST_BASE_CAMERA_SRC_VIDEO_PAD_NAME;
2299       } else if (prop_id == PROP_IMAGE_CAPTURE_SUPPORTED_CAPS) {
2300         element = camera->src;
2301         padname = GST_BASE_CAMERA_SRC_IMAGE_PAD_NAME;
2302       } else if (prop_id == PROP_VIEWFINDER_SUPPORTED_CAPS) {
2303         element = camera->src;
2304         padname = GST_BASE_CAMERA_SRC_VIEWFINDER_PAD_NAME;
2305       } else {
2306         element = camera->audio_src;
2307         padname = "src";
2308       }
2309
2310       if (element) {
2311         pad = gst_element_get_static_pad (element, padname);
2312
2313         g_assert (pad != NULL);
2314
2315         /* TODO not sure if we want get_caps or get_allowed_caps to already
2316          * consider the full pipeline scenario and avoid picking a caps that
2317          * won't negotiate. Need to take care on the special case of the
2318          * pad being unlinked.
2319          */
2320         caps = gst_pad_get_caps_reffed (pad);
2321         if (caps) {
2322           gst_value_set_caps (value, caps);
2323           gst_caps_unref (caps);
2324         }
2325
2326         gst_object_unref (pad);
2327       } else {
2328         GST_DEBUG_OBJECT (camera, "Source not created, can't get "
2329             "supported caps");
2330       }
2331     }
2332       break;
2333     case PROP_AUDIO_CAPTURE_CAPS:{
2334       GstCaps *caps = NULL;
2335       if (G_LIKELY (camera->audio_capsfilter)) {
2336         g_object_get (camera->audio_capsfilter, "caps", &caps, NULL);
2337       } else {
2338         GST_WARNING ("Missing audio capsfilter");
2339       }
2340       gst_value_set_caps (value, caps);
2341       gst_caps_unref (caps);
2342     }
2343       break;
2344     case PROP_IMAGE_CAPTURE_CAPS:{
2345       GstCaps *caps = NULL;
2346       if (G_LIKELY (camera->imagebin_capsfilter)) {
2347         g_object_get (camera->imagebin_capsfilter, "caps", &caps, NULL);
2348       } else {
2349         GST_WARNING ("Missing imagebin capsfilter");
2350       }
2351       gst_value_set_caps (value, caps);
2352       gst_caps_unref (caps);
2353     }
2354       break;
2355     case PROP_VIDEO_CAPTURE_CAPS:{
2356       GstCaps *caps = NULL;
2357       if (G_LIKELY (camera->videobin_capsfilter)) {
2358         g_object_get (camera->videobin_capsfilter, "caps", &caps, NULL);
2359       } else {
2360         GST_WARNING ("Missing imagebin capsfilter");
2361       }
2362       gst_value_set_caps (value, caps);
2363       gst_caps_unref (caps);
2364     }
2365       break;
2366     case PROP_VIEWFINDER_CAPS:{
2367       GstCaps *caps = NULL;
2368       if (G_LIKELY (camera->viewfinderbin_capsfilter)) {
2369         g_object_get (camera->viewfinderbin_capsfilter, "caps", &caps, NULL);
2370       } else {
2371         GST_WARNING ("Missing imagebin capsfilter");
2372       }
2373       gst_value_set_caps (value, caps);
2374       gst_caps_unref (caps);
2375     }
2376       break;
2377     case PROP_POST_PREVIEWS:
2378       g_value_set_boolean (value, camera->post_previews);
2379       break;
2380     case PROP_PREVIEW_CAPS:
2381       if (camera->preview_caps)
2382         gst_value_set_caps (value, camera->preview_caps);
2383       break;
2384     case PROP_VIDEO_ENCODING_PROFILE:
2385       if (camera->video_profile) {
2386         gst_value_set_mini_object (value,
2387             (GstMiniObject *) camera->video_profile);
2388       }
2389       break;
2390     case PROP_VIDEO_FILTER:
2391       if (camera->user_video_filter)
2392         g_value_set_object (value, camera->user_video_filter);
2393       break;
2394     case PROP_IMAGE_FILTER:
2395       if (camera->user_image_filter)
2396         g_value_set_object (value, camera->user_image_filter);
2397       break;
2398     case PROP_VIEWFINDER_FILTER:
2399       if (camera->user_viewfinder_filter)
2400         g_value_set_object (value, camera->user_viewfinder_filter);
2401       break;
2402     case PROP_AUDIO_FILTER:
2403       if (camera->user_audio_filter)
2404         g_value_set_object (value, camera->user_audio_filter);
2405       break;
2406     case PROP_PREVIEW_FILTER:
2407       if (camera->preview_filter)
2408         g_value_set_object (value, camera->preview_filter);
2409       break;
2410     case PROP_VIEWFINDER_SINK:{
2411       GstElement *sink;
2412
2413       g_object_get (camera->viewfinderbin, "video-sink", &sink, NULL);
2414       g_value_take_object (value, sink);
2415       break;
2416     }
2417     case PROP_ZOOM:
2418       g_value_set_float (value, camera->zoom);
2419       break;
2420     case PROP_MAX_ZOOM:
2421       g_value_set_float (value, camera->max_zoom);
2422       break;
2423     case PROP_IMAGE_ENCODING_PROFILE:
2424       if (camera->image_profile) {
2425         gst_value_set_mini_object (value,
2426             (GstMiniObject *) camera->image_profile);
2427       }
2428       break;
2429     case PROP_IDLE:
2430       g_value_set_boolean (value,
2431           g_atomic_int_get (&camera->processing_counter) == 0);
2432       break;
2433     case PROP_FLAGS:
2434       g_value_set_flags (value, camera->flags);
2435       break;
2436     default:
2437       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
2438       break;
2439   }
2440 }
2441
2442 gboolean
2443 gst_camera_bin2_plugin_init (GstPlugin * plugin)
2444 {
2445   GST_DEBUG_CATEGORY_INIT (gst_camera_bin_debug, "camerabin2", 0, "CameraBin2");
2446
2447   return gst_element_register (plugin, "camerabin2", GST_RANK_NONE,
2448       gst_camera_bin2_get_type ());
2449 }