camerabin2: change profile to h264
[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/quicktime", NULL);
1562       prof = gst_encoding_container_profile_new ("mp4", "h264+isomp4",
1563           caps, NULL);
1564       gst_caps_unref (caps);
1565
1566       caps = gst_caps_new_simple ("video/x-h264", NULL);
1567       video_prof = gst_encoding_video_profile_new (caps, NULL, NULL, 1);
1568       gst_encoding_video_profile_set_variableframerate (video_prof, TRUE);
1569       if (!gst_encoding_container_profile_add_profile (prof,
1570               (GstEncodingProfile *) video_prof)) {
1571         GST_WARNING_OBJECT (camera, "Failed to create encoding profiles");
1572       }
1573       gst_caps_unref (caps);
1574
1575       camera->video_profile = (GstEncodingProfile *) prof;
1576       camera->video_profile_switch = TRUE;
1577     }
1578
1579     camera->image_encodebin =
1580         gst_element_factory_make ("encodebin", "image-encodebin");
1581     if (!camera->image_encodebin) {
1582       missing_element_name = "encodebin";
1583       goto missing_element;
1584     }
1585
1586     /* durations have no meaning for image captures */
1587     g_object_set (camera->image_encodebin, "queue-time-max", (guint64) 0, NULL);
1588
1589     camera->image_encodebin_signal_id =
1590         g_signal_connect (camera->image_encodebin, "element-added",
1591         (GCallback) encodebin_element_added, camera);
1592
1593     camera->imagesink =
1594         gst_element_factory_make ("multifilesink", "imagebin-filesink");
1595     if (!camera->imagesink) {
1596       missing_element_name = "multifilesink";
1597       goto missing_element;
1598     }
1599     g_object_set (camera->imagesink, "async", FALSE, "post-messages", TRUE,
1600         NULL);
1601
1602     if (camera->image_profile == NULL) {
1603       GstEncodingVideoProfile *prof;
1604       GstEncodingVideoProfile *vprof;
1605       GstCaps *caps;
1606
1607       caps = gst_caps_new_simple ("image/jpeg", NULL);
1608       vprof = gst_encoding_video_profile_new (caps, NULL, NULL, 1);
1609       gst_encoding_video_profile_set_variableframerate (vprof, TRUE);
1610       prof = gst_encoding_container_profile_new ("jpeg", "jpeg container", caps,
1611           NULL);
1612       gst_encoding_container_profile_add_profile (prof,
1613           (GstEncodingProfile *) vprof);
1614
1615       gst_caps_unref (caps);
1616       camera->image_profile = (GstEncodingProfile *) prof;
1617       camera->image_profile_switch = TRUE;
1618     }
1619
1620     camera->viewfinderbin_queue =
1621         gst_element_factory_make ("queue", "viewfinderbin-queue");
1622     if (!camera->viewfinderbin_queue) {
1623       missing_element_name = "queue";
1624       goto missing_element;
1625     }
1626
1627     g_object_set (camera->viewfinderbin_queue, "leaky", 2, "silent", TRUE,
1628         "max-size-time", (guint64) 0, "max-size-bytes", (guint) 0,
1629         "max-size-buffers", (guint) 1, NULL);
1630
1631     gst_bin_add_many (GST_BIN_CAST (camera),
1632         gst_object_ref (camera->video_encodebin),
1633         gst_object_ref (camera->videosink),
1634         gst_object_ref (camera->image_encodebin),
1635         gst_object_ref (camera->imagesink),
1636         gst_object_ref (camera->viewfinderbin_queue), NULL);
1637
1638     gst_element_link_pads_full (camera->video_encodebin, "src",
1639         camera->videosink, "sink", GST_PAD_LINK_CHECK_NOTHING);
1640     gst_element_link_pads_full (camera->image_encodebin, "src",
1641         camera->imagesink, "sink", GST_PAD_LINK_CHECK_NOTHING);
1642     gst_element_link_pads_full (camera->viewfinderbin_queue, "src",
1643         camera->viewfinderbin_capsfilter, "sink", GST_PAD_LINK_CHECK_CAPS);
1644     gst_element_link_pads_full (camera->viewfinderbin_capsfilter, "src",
1645         camera->viewfinderbin, "sink", GST_PAD_LINK_CHECK_CAPS);
1646
1647     {
1648       /* set an event probe to watch for custom location changes */
1649       GstPad *srcpad;
1650
1651       srcpad = gst_element_get_static_pad (camera->image_encodebin, "src");
1652
1653       gst_pad_add_event_probe (srcpad,
1654           (GCallback) gst_camera_bin_image_sink_event_probe, camera);
1655
1656       gst_object_unref (srcpad);
1657     }
1658
1659     /*
1660      * Video can't get into playing as its internal filesink will open
1661      * a file for writing and leave it empty if unused.
1662      *
1663      * Its state is managed using the current mode and the source's
1664      * ready-for-capture notify callback. When we are at video mode and
1665      * the source's ready-for-capture goes to FALSE it means it is
1666      * starting recording, so we should prepare the video bin.
1667      */
1668     gst_element_set_locked_state (camera->videosink, TRUE);
1669     gst_element_set_locked_state (camera->imagesink, TRUE);
1670     g_object_set (camera->videosink, "location", camera->location, NULL);
1671     g_object_set (camera->imagesink, "location", camera->location, NULL);
1672   }
1673
1674   /* propagate the flags property by translating appropriate values
1675    * to GstEncFlags values */
1676   if (camera->flags & GST_CAM_FLAG_NO_AUDIO_CONVERSION)
1677     encbin_flags |= (1 << 0);
1678   if (camera->flags & GST_CAM_FLAG_NO_VIDEO_CONVERSION)
1679     encbin_flags |= (1 << 1);
1680   g_object_set (camera->video_encodebin, "flags", encbin_flags, NULL);
1681
1682   /* image encodebin has only video branch so disable its conversion elements
1683    * appropriately */
1684   if (camera->flags & GST_CAM_FLAG_NO_IMAGE_CONVERSION)
1685     g_object_set (camera->image_encodebin, "flags", (1 << 1), NULL);
1686
1687   g_object_set (camera->viewfinderbin, "disable-converters",
1688       camera->flags & GST_CAM_FLAG_NO_VIEWFINDER_CONVERSION ? TRUE : FALSE,
1689       NULL);
1690
1691   if (camera->video_profile_switch) {
1692     GST_DEBUG_OBJECT (camera, "Switching video-encodebin's profile");
1693     g_object_set (camera->video_encodebin, "profile", camera->video_profile,
1694         NULL);
1695     if (GST_PAD_LINK_FAILED (gst_camera_bin_link_encodebin (camera,
1696                 camera->video_encodebin, camera->videobin_capsfilter,
1697                 VIDEO_PAD))) {
1698       goto fail;
1699     }
1700     camera->video_profile_switch = FALSE;
1701
1702     /* used to trigger relinking further down */
1703     profile_switched = TRUE;
1704   }
1705
1706   if (camera->image_profile_switch) {
1707     GST_DEBUG_OBJECT (camera, "Switching image-encodebin's profile");
1708     g_object_set (camera->image_encodebin, "profile", camera->image_profile,
1709         NULL);
1710     if (GST_PAD_LINK_FAILED (gst_camera_bin_link_encodebin (camera,
1711                 camera->image_encodebin, camera->imagebin_capsfilter,
1712                 VIDEO_PAD))) {
1713       goto fail;
1714     }
1715     camera->image_profile_switch = FALSE;
1716   }
1717
1718   /* check if we need to replace the camera src */
1719   if (camera->src) {
1720     if (camera->user_src && camera->user_src != camera->src) {
1721
1722       if (camera->src_capture_notify_id)
1723         g_signal_handler_disconnect (camera->src,
1724             camera->src_capture_notify_id);
1725
1726       gst_bin_remove (GST_BIN_CAST (camera), camera->src);
1727       gst_object_unref (camera->src);
1728       camera->src = NULL;
1729     }
1730   }
1731
1732   if (!camera->src) {
1733     if (camera->user_src) {
1734       camera->src = gst_object_ref (camera->user_src);
1735     } else {
1736       camera->src = gst_element_factory_make ("omxcamerabinsrc", "camerasrc");
1737     }
1738
1739     new_src = TRUE;
1740   }
1741
1742   g_assert (camera->src != NULL);
1743   g_object_set (camera->src, "mode", camera->mode, NULL);
1744   if (camera->src) {
1745     if (g_object_class_find_property (G_OBJECT_GET_CLASS (camera->src),
1746             "preview-caps")) {
1747       g_object_set (camera->src, "post-previews", camera->post_previews,
1748           "preview-caps", camera->preview_caps, "preview-filter",
1749           camera->preview_filter, NULL);
1750     }
1751     g_signal_connect (G_OBJECT (camera->src), "notify::zoom",
1752         (GCallback) gst_camera_bin_src_notify_zoom_cb, camera);
1753     g_object_set (camera->src, "zoom", camera->zoom, NULL);
1754     g_signal_connect (G_OBJECT (camera->src), "notify::max-zoom",
1755         (GCallback) gst_camera_bin_src_notify_max_zoom_cb, camera);
1756   }
1757   if (new_src) {
1758     GstPad *imgsrc = gst_element_get_static_pad (camera->src, "imgsrc");
1759
1760     gst_bin_add (GST_BIN_CAST (camera), gst_object_ref (camera->src));
1761     camera->src_capture_notify_id = g_signal_connect (G_OBJECT (camera->src),
1762         "notify::ready-for-capture",
1763         G_CALLBACK (gst_camera_bin_src_notify_readyforcapture), camera);
1764     gst_element_link_pads (camera->src, "vfsrc", camera->viewfinderbin_queue,
1765         "sink");
1766
1767     if (!gst_element_link_pads (camera->src, "imgsrc",
1768             camera->imagebin_capsfilter, "sink")) {
1769       GST_ERROR_OBJECT (camera,
1770           "Failed to link camera source's imgsrc pad to image bin capsfilter");
1771       goto fail;
1772     }
1773     if (!gst_element_link_pads (camera->src, "vidsrc",
1774             camera->videobin_capsfilter, "sink")) {
1775       GST_ERROR_OBJECT (camera,
1776           "Failed to link camera source's vidsrc pad to video bin capsfilter");
1777       goto fail;
1778     }
1779
1780     gst_pad_add_buffer_probe (imgsrc,
1781         (GCallback) gst_camera_bin_image_src_buffer_probe, camera);
1782     gst_object_unref (imgsrc);
1783   }
1784
1785   gst_camera_bin_check_and_replace_filter (camera, &camera->image_filter,
1786       camera->user_image_filter, camera->imagebin_capsfilter,
1787       camera->image_encodebin, NULL);
1788   gst_camera_bin_check_and_replace_filter (camera, &camera->video_filter,
1789       camera->user_video_filter, camera->src, camera->videobin_capsfilter,
1790       "vidsrc");
1791   gst_camera_bin_check_and_replace_filter (camera, &camera->viewfinder_filter,
1792       camera->user_viewfinder_filter, camera->viewfinderbin_queue,
1793       camera->viewfinderbin_capsfilter, NULL);
1794
1795   /* check if we need to replace the camera audio src */
1796   has_audio = gst_camera_bin_video_profile_has_audio (camera);
1797   if (camera->audio_src) {
1798     if ((camera->user_audio_src && camera->user_audio_src != camera->audio_src)
1799         || !has_audio) {
1800       gst_bin_remove (GST_BIN_CAST (camera), camera->audio_src);
1801       gst_bin_remove (GST_BIN_CAST (camera), camera->audio_volume);
1802       gst_bin_remove (GST_BIN_CAST (camera), camera->audio_capsfilter);
1803       gst_object_unref (camera->audio_src);
1804       camera->audio_src = NULL;
1805     }
1806   }
1807
1808   if (!camera->audio_src && has_audio) {
1809     if (camera->user_audio_src) {
1810       camera->audio_src = gst_object_ref (camera->user_audio_src);
1811     } else {
1812       camera->audio_src =
1813           gst_element_factory_make (DEFAULT_AUDIO_SRC, "audiosrc");
1814       if (!camera->audio_src) {
1815         missing_element_name = DEFAULT_AUDIO_SRC;
1816         goto missing_element;
1817       }
1818     }
1819
1820     gst_element_set_locked_state (camera->audio_src, TRUE);
1821     new_audio_src = TRUE;
1822   }
1823
1824   if (new_audio_src) {
1825     GstPad *srcpad;
1826
1827     if (g_object_class_find_property (G_OBJECT_GET_CLASS (camera->audio_src),
1828             "provide-clock")) {
1829       g_object_set (camera->audio_src, "provide-clock", FALSE, NULL);
1830     }
1831     gst_bin_add (GST_BIN_CAST (camera), gst_object_ref (camera->audio_src));
1832     gst_bin_add (GST_BIN_CAST (camera), gst_object_ref (camera->audio_volume));
1833     gst_bin_add (GST_BIN_CAST (camera),
1834         gst_object_ref (camera->audio_capsfilter));
1835
1836     gst_element_link_pads_full (camera->audio_src, "src",
1837         camera->audio_volume, "sink", GST_PAD_LINK_CHECK_CAPS);
1838     gst_element_link_pads_full (camera->audio_volume, "src",
1839         camera->audio_capsfilter, "sink", GST_PAD_LINK_CHECK_CAPS);
1840
1841     srcpad = gst_element_get_static_pad (camera->audio_src, "src");
1842
1843     /* 1) drop EOS for audiosrc elements that push them on state_changes
1844      * (basesrc does this) 
1845      * 2) Fix newsegment events to have start time = first buffer ts */
1846     gst_pad_add_data_probe (srcpad,
1847         (GCallback) gst_camera_bin_audio_src_data_probe, camera);
1848
1849     gst_object_unref (srcpad);
1850   }
1851   if (has_audio) {
1852     gst_camera_bin_check_and_replace_filter (camera, &camera->audio_filter,
1853         camera->user_audio_filter, camera->audio_src, camera->audio_volume,
1854         "src");
1855   }
1856
1857   if ((profile_switched && has_audio) || new_audio_src) {
1858     if (GST_PAD_LINK_FAILED (gst_camera_bin_link_encodebin (camera,
1859                 camera->video_encodebin, camera->audio_capsfilter,
1860                 AUDIO_PAD))) {
1861       goto fail;
1862     }
1863   }
1864
1865   camera->elements_created = TRUE;
1866   return TRUE;
1867
1868 missing_element:
1869   gst_element_post_message (GST_ELEMENT_CAST (camera),
1870       gst_missing_element_message_new (GST_ELEMENT_CAST (camera),
1871           missing_element_name));
1872   GST_ELEMENT_ERROR (camera, CORE, MISSING_PLUGIN,
1873       (_("Missing element '%s' - check your GStreamer installation."),
1874           missing_element_name), (NULL));
1875   goto fail;
1876
1877 fail:
1878   /* FIXME properly clean up */
1879   return FALSE;
1880 }
1881
1882 static void
1883 _gst_tag_list_free_maybe (GstTagList * taglist)
1884 {
1885   if (taglist)
1886     gst_tag_list_free (taglist);
1887 }
1888
1889 static GstStateChangeReturn
1890 gst_camera_bin_change_state (GstElement * element, GstStateChange trans)
1891 {
1892   GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
1893   GstCameraBin2 *camera = GST_CAMERA_BIN2_CAST (element);
1894
1895
1896   switch (trans) {
1897     case GST_STATE_CHANGE_NULL_TO_READY:
1898       if (!gst_camera_bin_create_elements (camera)) {
1899         return GST_STATE_CHANGE_FAILURE;
1900       }
1901       break;
1902     case GST_STATE_CHANGE_READY_TO_PAUSED:
1903       GST_CAMERA_BIN2_RESET_PROCESSING_COUNTER (camera);
1904       camera->audio_drop_eos = TRUE;
1905       camera->audio_send_newseg = FALSE;
1906       break;
1907     case GST_STATE_CHANGE_PAUSED_TO_READY:
1908       if (GST_STATE (camera->videosink) >= GST_STATE_PAUSED)
1909         gst_element_set_state (camera->videosink, GST_STATE_READY);
1910       if (GST_STATE (camera->imagesink) >= GST_STATE_PAUSED)
1911         gst_element_set_state (camera->imagesink, GST_STATE_READY);
1912       break;
1913     case GST_STATE_CHANGE_READY_TO_NULL:
1914       gst_element_set_state (camera->videosink, GST_STATE_NULL);
1915       gst_element_set_state (camera->imagesink, GST_STATE_NULL);
1916       break;
1917     default:
1918       break;
1919   }
1920
1921   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, trans);
1922
1923   switch (trans) {
1924     case GST_STATE_CHANGE_PAUSED_TO_READY:
1925       if (GST_STATE (camera->videosink) >= GST_STATE_PAUSED)
1926         gst_element_set_state (camera->videosink, GST_STATE_READY);
1927       if (GST_STATE (camera->imagesink) >= GST_STATE_PAUSED)
1928         gst_element_set_state (camera->imagesink, GST_STATE_READY);
1929       if (camera->audio_src && GST_STATE (camera->audio_src) >= GST_STATE_READY)
1930         gst_element_set_state (camera->audio_src, GST_STATE_READY);
1931
1932       gst_tag_setter_reset_tags (GST_TAG_SETTER (camera));
1933       GST_CAMERA_BIN2_RESET_PROCESSING_COUNTER (camera);
1934       camera->video_state = GST_CAMERA_BIN_VIDEO_IDLE;
1935
1936       g_mutex_lock (camera->image_capture_mutex);
1937       g_slist_foreach (camera->image_location_list, (GFunc) g_free, NULL);
1938       g_slist_free (camera->image_location_list);
1939       camera->image_location_list = NULL;
1940
1941       g_slist_foreach (camera->image_tags_list,
1942           (GFunc) _gst_tag_list_free_maybe, NULL);
1943       g_slist_free (camera->image_tags_list);
1944       camera->image_tags_list = NULL;
1945       g_mutex_unlock (camera->image_capture_mutex);
1946
1947       g_mutex_lock (camera->preview_list_mutex);
1948       g_slist_foreach (camera->preview_location_list, (GFunc) g_free, NULL);
1949       g_slist_free (camera->preview_location_list);
1950       camera->preview_location_list = NULL;
1951       g_mutex_unlock (camera->preview_list_mutex);
1952
1953       /* explicitly set to READY as they might be outside of the bin */
1954       gst_element_set_state (camera->audio_volume, GST_STATE_READY);
1955       gst_element_set_state (camera->audio_capsfilter, GST_STATE_READY);
1956       break;
1957     case GST_STATE_CHANGE_READY_TO_NULL:
1958       gst_element_set_state (camera->videosink, GST_STATE_NULL);
1959       gst_element_set_state (camera->imagesink, GST_STATE_NULL);
1960       if (camera->audio_src)
1961         gst_element_set_state (camera->audio_src, GST_STATE_NULL);
1962
1963       /* explicitly set to NULL as they might be outside of the bin */
1964       gst_element_set_state (camera->audio_volume, GST_STATE_NULL);
1965       gst_element_set_state (camera->audio_capsfilter, GST_STATE_NULL);
1966
1967       break;
1968     default:
1969       break;
1970   }
1971
1972   return ret;
1973 }
1974
1975 static gboolean
1976 gst_camera_bin_send_event (GstElement * element, GstEvent * event)
1977 {
1978   GstCameraBin2 *camera = GST_CAMERA_BIN2_CAST (element);
1979   gboolean res;
1980
1981   /* avoid losing our ref to send_event */
1982   gst_event_ref (event);
1983
1984   res = GST_ELEMENT_CLASS (parent_class)->send_event (element, event);
1985   switch (GST_EVENT_TYPE (event)) {
1986     case GST_EVENT_EOS:
1987     {
1988       GstState current;
1989
1990       if (camera->videosink) {
1991         gst_element_get_state (camera->videosink, &current, NULL, 0);
1992         if (current <= GST_STATE_READY)
1993           gst_element_post_message (camera->videosink,
1994               gst_message_new_eos (GST_OBJECT (camera->videosink)));
1995       }
1996       if (camera->imagesink) {
1997         gst_element_get_state (camera->imagesink, &current, NULL, 0);
1998         if (current <= GST_STATE_READY)
1999           gst_element_post_message (camera->imagesink,
2000               gst_message_new_eos (GST_OBJECT (camera->imagesink)));
2001       }
2002       break;
2003     }
2004
2005     default:
2006       break;
2007   }
2008
2009   gst_event_unref (event);
2010   return res;
2011 }
2012
2013 static void
2014 gst_camera_bin_set_location (GstCameraBin2 * camera, const gchar * location)
2015 {
2016   GST_DEBUG_OBJECT (camera, "Setting mode %d location to %s", camera->mode,
2017       location);
2018   g_free (camera->location);
2019   camera->location = g_strdup (location);
2020 }
2021
2022 static void
2023 gst_camera_bin_set_audio_src (GstCameraBin2 * camera, GstElement * src)
2024 {
2025   GST_DEBUG_OBJECT (GST_OBJECT (camera),
2026       "Setting audio source %" GST_PTR_FORMAT, src);
2027
2028   if (camera->user_audio_src)
2029     g_object_unref (camera->user_audio_src);
2030
2031   if (src)
2032     g_object_ref (src);
2033   camera->user_audio_src = src;
2034 }
2035
2036 static void
2037 gst_camera_bin_set_camera_src (GstCameraBin2 * camera, GstElement * src)
2038 {
2039   GST_DEBUG_OBJECT (GST_OBJECT (camera),
2040       "Setting camera source %" GST_PTR_FORMAT, src);
2041
2042   if (camera->user_src)
2043     g_object_unref (camera->user_src);
2044
2045   if (src)
2046     g_object_ref (src);
2047   camera->user_src = src;
2048 }
2049
2050 static void
2051 gst_camera_bin_set_property (GObject * object, guint prop_id,
2052     const GValue * value, GParamSpec * pspec)
2053 {
2054   GstCameraBin2 *camera = GST_CAMERA_BIN2_CAST (object);
2055
2056   switch (prop_id) {
2057     case PROP_MODE:
2058       gst_camera_bin_change_mode (camera, g_value_get_enum (value));
2059       break;
2060     case PROP_LOCATION:
2061       gst_camera_bin_set_location (camera, g_value_get_string (value));
2062       break;
2063     case PROP_CAMERA_SRC:
2064       gst_camera_bin_set_camera_src (camera, g_value_get_object (value));
2065       break;
2066     case PROP_AUDIO_SRC:
2067       gst_camera_bin_set_audio_src (camera, g_value_get_object (value));
2068       break;
2069     case PROP_MUTE_AUDIO:
2070       g_object_set (camera->audio_volume, "mute", g_value_get_boolean (value),
2071           NULL);
2072       break;
2073     case PROP_AUDIO_CAPTURE_CAPS:{
2074       GST_DEBUG_OBJECT (camera,
2075           "Setting audio capture caps to %" GST_PTR_FORMAT,
2076           gst_value_get_caps (value));
2077
2078       if (G_LIKELY (camera->audio_capsfilter)) {
2079         g_object_set (camera->audio_capsfilter, "caps",
2080             gst_value_get_caps (value), NULL);
2081       } else {
2082         GST_WARNING_OBJECT (camera, "Audio capsfilter missing");
2083       }
2084     }
2085       break;
2086     case PROP_IMAGE_CAPTURE_CAPS:{
2087       GstPad *pad = NULL;
2088
2089       if (camera->src)
2090         pad =
2091             gst_element_get_static_pad (camera->src,
2092             GST_BASE_CAMERA_SRC_IMAGE_PAD_NAME);
2093
2094       GST_DEBUG_OBJECT (camera,
2095           "Setting image capture caps to %" GST_PTR_FORMAT,
2096           gst_value_get_caps (value));
2097
2098       if (G_LIKELY (camera->imagebin_capsfilter)) {
2099         g_object_set (camera->imagebin_capsfilter, "caps",
2100             gst_value_get_caps (value), NULL);
2101       } else {
2102         GST_WARNING_OBJECT (camera, "Image capsfilter missing");
2103       }
2104
2105       /* set the capsfilter caps and notify the src to renegotiate */
2106       if (pad) {
2107         GST_DEBUG_OBJECT (camera, "Pushing renegotiate on %s",
2108             GST_PAD_NAME (pad));
2109         gst_pad_send_event (pad, gst_camera_bin_new_event_renegotiate ());
2110         gst_object_unref (pad);
2111       }
2112     }
2113       break;
2114     case PROP_VIDEO_CAPTURE_CAPS:{
2115       GstPad *pad = NULL;
2116
2117       if (camera->src)
2118         pad =
2119             gst_element_get_static_pad (camera->src,
2120             GST_BASE_CAMERA_SRC_VIDEO_PAD_NAME);
2121
2122       GST_DEBUG_OBJECT (camera,
2123           "Setting video capture caps to %" GST_PTR_FORMAT,
2124           gst_value_get_caps (value));
2125
2126       /* set the capsfilter caps and notify the src to renegotiate */
2127       if (G_LIKELY (camera->videobin_capsfilter)) {
2128         g_object_set (camera->videobin_capsfilter, "caps",
2129             gst_value_get_caps (value), NULL);
2130       } else {
2131         GST_WARNING_OBJECT (camera, "Video capsfilter missing");
2132       }
2133
2134       if (pad) {
2135         GST_DEBUG_OBJECT (camera, "Pushing renegotiate on %s",
2136             GST_PAD_NAME (pad));
2137         gst_pad_send_event (pad, gst_camera_bin_new_event_renegotiate ());
2138         gst_object_unref (pad);
2139       }
2140     }
2141       break;
2142     case PROP_VIEWFINDER_CAPS:{
2143       GstPad *pad = NULL;
2144
2145       if (camera->src)
2146         pad =
2147             gst_element_get_static_pad (camera->src,
2148             GST_BASE_CAMERA_SRC_VIEWFINDER_PAD_NAME);
2149
2150       GST_DEBUG_OBJECT (camera,
2151           "Setting viewfinder capture caps to %" GST_PTR_FORMAT,
2152           gst_value_get_caps (value));
2153
2154       /* set the capsfilter caps and notify the src to renegotiate */
2155       if (G_LIKELY (camera->viewfinderbin_capsfilter)) {
2156         g_object_set (camera->viewfinderbin_capsfilter, "caps",
2157             gst_value_get_caps (value), NULL);
2158       } else {
2159         GST_WARNING_OBJECT (camera, "Viewfinder capsfilter missing");
2160       }
2161
2162       if (pad) {
2163         GST_DEBUG_OBJECT (camera, "Pushing renegotiate on %s",
2164             GST_PAD_NAME (pad));
2165         gst_pad_send_event (pad, gst_camera_bin_new_event_renegotiate ());
2166         gst_object_unref (pad);
2167       }
2168     }
2169       break;
2170     case PROP_POST_PREVIEWS:
2171       camera->post_previews = g_value_get_boolean (value);
2172       if (camera->src
2173           && g_object_class_find_property (G_OBJECT_GET_CLASS (camera->src),
2174               "post-previews"))
2175         g_object_set (camera->src, "post-previews", camera->post_previews,
2176             NULL);
2177       break;
2178     case PROP_PREVIEW_CAPS:
2179       gst_caps_replace (&camera->preview_caps,
2180           (GstCaps *) gst_value_get_caps (value));
2181       if (camera->src
2182           && g_object_class_find_property (G_OBJECT_GET_CLASS (camera->src),
2183               "preview-caps"))
2184         g_object_set (camera->src, "preview-caps", camera->preview_caps, NULL);
2185       break;
2186     case PROP_VIDEO_ENCODING_PROFILE:
2187       if (camera->video_profile)
2188         gst_encoding_profile_unref (camera->video_profile);
2189       camera->video_profile =
2190           (GstEncodingProfile *) gst_value_dup_mini_object (value);
2191       camera->video_profile_switch = TRUE;
2192       break;
2193     case PROP_IMAGE_FILTER:
2194       if (camera->user_image_filter)
2195         g_object_unref (camera->user_image_filter);
2196
2197       camera->user_image_filter = g_value_dup_object (value);
2198       break;
2199     case PROP_VIDEO_FILTER:
2200       if (camera->user_video_filter)
2201         g_object_unref (camera->user_video_filter);
2202
2203       camera->user_video_filter = g_value_dup_object (value);
2204       break;
2205     case PROP_VIEWFINDER_FILTER:
2206       if (camera->user_viewfinder_filter)
2207         g_object_unref (camera->user_viewfinder_filter);
2208
2209       camera->user_viewfinder_filter = g_value_dup_object (value);
2210       break;
2211     case PROP_PREVIEW_FILTER:
2212       if (camera->preview_filter)
2213         g_object_unref (camera->preview_filter);
2214
2215       camera->preview_filter = g_value_dup_object (value);
2216       if (camera->src
2217           && g_object_class_find_property (G_OBJECT_GET_CLASS (camera->src),
2218               "preview-filter"))
2219         g_object_set (camera->src, "preview-filter", camera->preview_filter,
2220             NULL);
2221       break;
2222     case PROP_AUDIO_FILTER:
2223       if (camera->user_audio_filter)
2224         g_object_unref (camera->user_audio_filter);
2225
2226       camera->user_audio_filter = g_value_dup_object (value);
2227       break;
2228     case PROP_VIEWFINDER_SINK:
2229       g_object_set (camera->viewfinderbin, "video-sink",
2230           g_value_get_object (value), NULL);
2231       break;
2232     case PROP_ZOOM:
2233       camera->zoom = g_value_get_float (value);
2234       /* limit to max-zoom */
2235       if (camera->zoom > camera->max_zoom) {
2236         GST_DEBUG_OBJECT (camera, "Clipping zoom %f to max-zoom %f",
2237             camera->zoom, camera->max_zoom);
2238         camera->zoom = camera->max_zoom;
2239       }
2240       if (camera->src)
2241         g_object_set (camera->src, "zoom", camera->zoom, NULL);
2242       break;
2243     case PROP_IMAGE_ENCODING_PROFILE:
2244       if (camera->image_profile)
2245         gst_encoding_profile_unref (camera->image_profile);
2246       camera->image_profile =
2247           (GstEncodingProfile *) gst_value_dup_mini_object (value);
2248       camera->image_profile_switch = TRUE;
2249       break;
2250     case PROP_FLAGS:
2251       camera->flags = g_value_get_flags (value);
2252       break;
2253     default:
2254       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
2255       break;
2256   }
2257 }
2258
2259 static void
2260 gst_camera_bin_get_property (GObject * object, guint prop_id,
2261     GValue * value, GParamSpec * pspec)
2262 {
2263   GstCameraBin2 *camera = GST_CAMERA_BIN2_CAST (object);
2264
2265   switch (prop_id) {
2266     case PROP_MODE:
2267       g_value_set_enum (value, camera->mode);
2268       break;
2269     case PROP_LOCATION:
2270       g_value_set_string (value, camera->location);
2271       break;
2272     case PROP_CAMERA_SRC:
2273       g_value_set_object (value, camera->user_src);
2274       break;
2275     case PROP_AUDIO_SRC:
2276       g_value_set_object (value, camera->user_audio_src);
2277       break;
2278     case PROP_MUTE_AUDIO:{
2279       gboolean mute;
2280
2281       g_object_get (camera->audio_volume, "mute", &mute, NULL);
2282       g_value_set_boolean (value, mute);
2283       break;
2284     }
2285     case PROP_AUDIO_CAPTURE_SUPPORTED_CAPS:
2286     case PROP_VIDEO_CAPTURE_SUPPORTED_CAPS:
2287     case PROP_VIEWFINDER_SUPPORTED_CAPS:
2288     case PROP_IMAGE_CAPTURE_SUPPORTED_CAPS:{
2289       GstPad *pad;
2290       GstElement *element;
2291       GstCaps *caps;
2292       const gchar *padname;
2293
2294       if (prop_id == PROP_VIDEO_CAPTURE_SUPPORTED_CAPS) {
2295         element = camera->src;
2296         padname = GST_BASE_CAMERA_SRC_VIDEO_PAD_NAME;
2297       } else if (prop_id == PROP_IMAGE_CAPTURE_SUPPORTED_CAPS) {
2298         element = camera->src;
2299         padname = GST_BASE_CAMERA_SRC_IMAGE_PAD_NAME;
2300       } else if (prop_id == PROP_VIEWFINDER_SUPPORTED_CAPS) {
2301         element = camera->src;
2302         padname = GST_BASE_CAMERA_SRC_VIEWFINDER_PAD_NAME;
2303       } else {
2304         element = camera->audio_src;
2305         padname = "src";
2306       }
2307
2308       if (element) {
2309         pad = gst_element_get_static_pad (element, padname);
2310
2311         g_assert (pad != NULL);
2312
2313         /* TODO not sure if we want get_caps or get_allowed_caps to already
2314          * consider the full pipeline scenario and avoid picking a caps that
2315          * won't negotiate. Need to take care on the special case of the
2316          * pad being unlinked.
2317          */
2318         caps = gst_pad_get_caps_reffed (pad);
2319         if (caps) {
2320           gst_value_set_caps (value, caps);
2321           gst_caps_unref (caps);
2322         }
2323
2324         gst_object_unref (pad);
2325       } else {
2326         GST_DEBUG_OBJECT (camera, "Source not created, can't get "
2327             "supported caps");
2328       }
2329     }
2330       break;
2331     case PROP_AUDIO_CAPTURE_CAPS:{
2332       GstCaps *caps = NULL;
2333       if (G_LIKELY (camera->audio_capsfilter)) {
2334         g_object_get (camera->audio_capsfilter, "caps", &caps, NULL);
2335       } else {
2336         GST_WARNING ("Missing audio capsfilter");
2337       }
2338       gst_value_set_caps (value, caps);
2339       gst_caps_unref (caps);
2340     }
2341       break;
2342     case PROP_IMAGE_CAPTURE_CAPS:{
2343       GstCaps *caps = NULL;
2344       if (G_LIKELY (camera->imagebin_capsfilter)) {
2345         g_object_get (camera->imagebin_capsfilter, "caps", &caps, NULL);
2346       } else {
2347         GST_WARNING ("Missing imagebin capsfilter");
2348       }
2349       gst_value_set_caps (value, caps);
2350       gst_caps_unref (caps);
2351     }
2352       break;
2353     case PROP_VIDEO_CAPTURE_CAPS:{
2354       GstCaps *caps = NULL;
2355       if (G_LIKELY (camera->videobin_capsfilter)) {
2356         g_object_get (camera->videobin_capsfilter, "caps", &caps, NULL);
2357       } else {
2358         GST_WARNING ("Missing imagebin capsfilter");
2359       }
2360       gst_value_set_caps (value, caps);
2361       gst_caps_unref (caps);
2362     }
2363       break;
2364     case PROP_VIEWFINDER_CAPS:{
2365       GstCaps *caps = NULL;
2366       if (G_LIKELY (camera->viewfinderbin_capsfilter)) {
2367         g_object_get (camera->viewfinderbin_capsfilter, "caps", &caps, NULL);
2368       } else {
2369         GST_WARNING ("Missing imagebin capsfilter");
2370       }
2371       gst_value_set_caps (value, caps);
2372       gst_caps_unref (caps);
2373     }
2374       break;
2375     case PROP_POST_PREVIEWS:
2376       g_value_set_boolean (value, camera->post_previews);
2377       break;
2378     case PROP_PREVIEW_CAPS:
2379       if (camera->preview_caps)
2380         gst_value_set_caps (value, camera->preview_caps);
2381       break;
2382     case PROP_VIDEO_ENCODING_PROFILE:
2383       if (camera->video_profile) {
2384         gst_value_set_mini_object (value,
2385             (GstMiniObject *) camera->video_profile);
2386       }
2387       break;
2388     case PROP_VIDEO_FILTER:
2389       if (camera->user_video_filter)
2390         g_value_set_object (value, camera->user_video_filter);
2391       break;
2392     case PROP_IMAGE_FILTER:
2393       if (camera->user_image_filter)
2394         g_value_set_object (value, camera->user_image_filter);
2395       break;
2396     case PROP_VIEWFINDER_FILTER:
2397       if (camera->user_viewfinder_filter)
2398         g_value_set_object (value, camera->user_viewfinder_filter);
2399       break;
2400     case PROP_AUDIO_FILTER:
2401       if (camera->user_audio_filter)
2402         g_value_set_object (value, camera->user_audio_filter);
2403       break;
2404     case PROP_PREVIEW_FILTER:
2405       if (camera->preview_filter)
2406         g_value_set_object (value, camera->preview_filter);
2407       break;
2408     case PROP_VIEWFINDER_SINK:{
2409       GstElement *sink;
2410
2411       g_object_get (camera->viewfinderbin, "video-sink", &sink, NULL);
2412       g_value_take_object (value, sink);
2413       break;
2414     }
2415     case PROP_ZOOM:
2416       g_value_set_float (value, camera->zoom);
2417       break;
2418     case PROP_MAX_ZOOM:
2419       g_value_set_float (value, camera->max_zoom);
2420       break;
2421     case PROP_IMAGE_ENCODING_PROFILE:
2422       if (camera->image_profile) {
2423         gst_value_set_mini_object (value,
2424             (GstMiniObject *) camera->image_profile);
2425       }
2426       break;
2427     case PROP_IDLE:
2428       g_value_set_boolean (value,
2429           g_atomic_int_get (&camera->processing_counter) == 0);
2430       break;
2431     case PROP_FLAGS:
2432       g_value_set_flags (value, camera->flags);
2433       break;
2434     default:
2435       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
2436       break;
2437   }
2438 }
2439
2440 gboolean
2441 gst_camera_bin2_plugin_init (GstPlugin * plugin)
2442 {
2443   GST_DEBUG_CATEGORY_INIT (gst_camera_bin_debug, "camerabin2", 0, "CameraBin2");
2444
2445   return gst_element_register (plugin, "camerabin2", GST_RANK_NONE,
2446       gst_camera_bin2_get_type ());
2447 }