← Back to branch summary

~ubuntu-branches/ubuntu/raring/gst-plugins-good0.10/raring-proposed

« back to all changes in this revision

Viewing changes to gst-libs/gst/basecamerabinsrc/gstcamerabinpreview.c

  • Committer: Package Import Robot
  • Author(s): Timo Aaltonen
  • Date: 2012-02-09 16:44:53 UTC
  • mfrom: (40.2.38 experimental)
  • Revision ID: package-import@ubuntu.com-20120209164453-6hjokwrvdn42zopb
Tags: 0.10.30.3-1ubuntu1
* Merge from Debian experimental, remaining changes:
  - 04_move_farsight_plugins_to_good.patch
    Import autoconvert, dtmf, liveadder, rptmux from -plugins-bad
  - 05_move_shm_to_good.patch
    Import shm from -plugins-bad.
  - 07_move-camerabin.patch
    Import camerabin, camerabin2, jpegformat and basecamerabinsrc
    from -plugins-bad.
  - control*:
    * Drop dependency from gstreamer0.10-plugins-good on
      gstreamer0.10-gconf. It pulls gconf and gtk3 onto the Kubuntu cd.
    * Use Breaks instead of Conflicts.
    * Add a 'Pre-Depends: ${misc:Pre-Depends}' to the plugin package,
      since we're shipping shared libraries in the package that Debian
      isn't.
* Update the patches by pulling new version of the code from
  -plugins-bad 0.10.22.3.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gst-libs/gst/basecamerabinsrc/gstcamerabinpreview.c
31
31
#include "gstcamerabinpreview.h"
32
32
#include "gstbasecamerasrc.h"
33
33
 
34
 
static GstFlowReturn
35
 
gst_camerabin_preview_pipeline_new_preroll (GstAppSink * appsink,
36
 
    gpointer user_data)
 
34
GST_DEBUG_CATEGORY_EXTERN (base_camera_src_debug);
 
35
#define GST_CAT_DEFAULT base_camera_src_debug
 
36
 
 
37
static void _gst_camerabin_preview_set_caps (GstCameraBinPreviewPipelineData *
 
38
    preview, GstCaps * caps);
 
39
 
 
40
static gboolean
 
41
bus_callback (GstBus * bus, GstMessage * message, gpointer user_data)
37
42
{
38
 
  GstBuffer *buffer;
39
 
 
40
 
  buffer = gst_app_sink_pull_preroll (appsink);
41
 
  gst_buffer_unref (buffer);
42
 
 
43
 
  return GST_FLOW_OK;
 
43
  switch (GST_MESSAGE_TYPE (message)) {
 
44
    case GST_MESSAGE_ERROR:{
 
45
      GError *err;
 
46
      GstCameraBinPreviewPipelineData *data;
 
47
 
 
48
      data = user_data;
 
49
 
 
50
      gst_message_parse_error (message, &err, NULL);
 
51
      GST_WARNING ("Error from preview pipeline: %s", err->message);
 
52
      g_error_free (err);
 
53
 
 
54
      /* TODO Not sure if we should post an Error or Warning here */
 
55
      GST_ELEMENT_ERROR (data, CORE, FAILED,
 
56
          ("fatal error in preview pipeline, disposing the pipeline"), (NULL));
 
57
 
 
58
      /* Possible error situations:
 
59
       * 1) cond_wait pending. prevent deadlock by signalling the cond
 
60
       * 2) preview_pipeline_post called with new buffer to handle. returns
 
61
       *    because data->pipeline is set to null
 
62
       * 3) new preview caps incoming. returns because data->pipeline is null
 
63
       */
 
64
 
 
65
      if (data->pipeline) {
 
66
        gst_element_set_state (data->pipeline, GST_STATE_NULL);
 
67
        gst_object_unref (data->pipeline);
 
68
        data->pipeline = NULL;
 
69
      }
 
70
 
 
71
      g_cond_signal (data->processing_cond);
 
72
 
 
73
      break;
 
74
    }
 
75
    default:
 
76
      break;
 
77
  }
 
78
  return TRUE;
44
79
}
45
80
 
46
81
static GstFlowReturn
66
101
        "This element has no bus, therefore no message sent!");
67
102
  }
68
103
 
 
104
  g_mutex_lock (data->processing_lock);
 
105
 
 
106
  data->processing--;
 
107
  if (data->processing == 0)
 
108
    g_cond_signal (data->processing_cond);
 
109
 
 
110
  g_mutex_unlock (data->processing_lock);
 
111
 
69
112
  return GST_FLOW_OK;
70
113
}
71
114
 
85
128
{
86
129
  GstCameraBinPreviewPipelineData *data;
87
130
  GstElement *csp;
88
 
  GstElement *csp2;
89
131
  GstElement *vscale;
90
132
  gboolean added = FALSE;
 
133
  gboolean linkfail = FALSE;
 
134
  GstBus *bus;
91
135
  GstAppSinkCallbacks callbacks = { 0, };
92
136
 
93
 
  data = g_new (GstCameraBinPreviewPipelineData, 1);
 
137
  data = g_new0 (GstCameraBinPreviewPipelineData, 1);
94
138
 
95
139
  data->pipeline = gst_pipeline_new ("preview-pipeline");
96
140
  data->appsrc = gst_element_factory_make ("appsrc", "preview-appsrc");
97
 
  data->capsfilter = gst_element_factory_make ("capsfilter",
98
 
      "preview-capsfilter");
99
141
  data->appsink = gst_element_factory_make ("appsink", "preview-appsink");
100
 
  csp = gst_element_factory_make ("ffmpegcolorspace", "preview-csp0");
101
 
  csp2 = gst_element_factory_make ("ffmpegcolorspace", "preview-csp1");
 
142
  csp = gst_element_factory_make ("ffmpegcolorspace", "preview-csp");
102
143
  vscale = gst_element_factory_make ("videoscale", "preview-vscale");
103
144
 
104
 
  if (!data->appsrc || !data->capsfilter || !data->appsink || !csp ||
105
 
      !csp2 || !vscale) {
 
145
  if (!data->appsrc || !data->appsink || !csp || !vscale) {
106
146
    goto error;
107
147
  }
108
148
 
109
 
  gst_bin_add_many (GST_BIN (data->pipeline), data->appsrc, data->capsfilter,
110
 
      data->appsink, csp, csp2, vscale, NULL);
 
149
  g_object_set (data->appsrc, "emit-signals", FALSE, NULL);
 
150
  g_object_set (data->appsink, "sync", FALSE, "enable-last-buffer",
 
151
      FALSE, NULL);
 
152
 
 
153
  gst_bin_add_many (GST_BIN (data->pipeline), data->appsrc,
 
154
      data->appsink, csp, vscale, NULL);
111
155
  if (filter)
112
156
    gst_bin_add (GST_BIN (data->pipeline), gst_object_ref (filter));
113
157
  added = TRUE;
114
158
 
115
159
  if (filter) {
116
 
    if (!gst_element_link_many (data->appsrc, filter, csp, vscale, csp2,
117
 
            data->capsfilter, data->appsink, NULL))
118
 
      goto error;
 
160
    linkfail |=
 
161
        GST_PAD_LINK_FAILED (gst_element_link_pads_full (data->appsrc, "src",
 
162
            filter, NULL, GST_PAD_LINK_CHECK_NOTHING));
 
163
    linkfail |=
 
164
        GST_PAD_LINK_FAILED (gst_element_link_pads_full (filter, NULL,
 
165
            vscale, "sink", GST_PAD_LINK_CHECK_CAPS));
119
166
  } else {
120
 
    if (!gst_element_link_many (data->appsrc, csp, vscale, csp2,
121
 
            data->capsfilter, data->appsink, NULL))
122
 
      goto error;
123
 
  }
124
 
 
125
 
  callbacks.new_preroll = gst_camerabin_preview_pipeline_new_preroll;
 
167
    linkfail |=
 
168
        GST_PAD_LINK_FAILED (gst_element_link_pads_full (data->appsrc, "src",
 
169
            vscale, "sink", GST_PAD_LINK_CHECK_NOTHING));
 
170
  }
 
171
 
 
172
  linkfail |=
 
173
      GST_PAD_LINK_FAILED (gst_element_link_pads_full (vscale, "src", csp,
 
174
          "sink", GST_PAD_LINK_CHECK_NOTHING));
 
175
  linkfail |=
 
176
      GST_PAD_LINK_FAILED (gst_element_link_pads_full (csp, "src",
 
177
          data->appsink, "sink", GST_PAD_LINK_CHECK_NOTHING));
 
178
 
 
179
  if (linkfail) {
 
180
    GST_WARNING ("Failed to link preview pipeline elements");
 
181
    goto error;
 
182
  }
 
183
 
126
184
  callbacks.new_buffer = gst_camerabin_preview_pipeline_new_buffer;
127
185
  gst_app_sink_set_callbacks ((GstAppSink *) data->appsink, &callbacks, data,
128
186
      NULL);
129
187
 
 
188
  bus = gst_pipeline_get_bus (GST_PIPELINE (data->pipeline));
 
189
  gst_bus_add_watch (bus, bus_callback, data);
 
190
  gst_object_unref (bus);
 
191
 
130
192
  g_object_set (data->appsink, "sync", FALSE, NULL);
131
193
 
132
194
  data->element = element;
133
195
  data->filter = filter;
 
196
  data->vscale = vscale;
 
197
 
 
198
  data->processing_lock = g_mutex_new ();
 
199
  data->processing_cond = g_cond_new ();
 
200
 
 
201
  data->pending_preview_caps = NULL;
 
202
  data->processing = 0;
134
203
 
135
204
  return data;
136
205
error:
138
207
  if (!added) {
139
208
    if (csp)
140
209
      gst_object_unref (csp);
141
 
    if (csp2)
142
 
      gst_object_unref (csp2);
143
210
    if (vscale)
144
211
      gst_object_unref (vscale);
145
212
    if (data->appsrc)
146
213
      gst_object_unref (data->appsrc);
147
 
    if (data->capsfilter)
148
 
      gst_object_unref (data->capsfilter);
149
214
    if (data->appsink)
150
215
      gst_object_unref (data->appsink);
151
216
  }
163
228
gst_camerabin_destroy_preview_pipeline (GstCameraBinPreviewPipelineData *
164
229
    preview)
165
230
{
 
231
  g_return_if_fail (preview != NULL);
 
232
 
 
233
  if (preview->processing_lock) {
 
234
    g_mutex_free (preview->processing_lock);
 
235
    preview->processing_lock = NULL;
 
236
  }
 
237
  if (preview->processing_cond) {
 
238
    g_cond_free (preview->processing_cond);
 
239
    preview->processing_cond = NULL;
 
240
  }
166
241
  if (preview->pipeline) {
167
242
    gst_element_set_state (preview->pipeline, GST_STATE_NULL);
168
243
    gst_object_unref (preview->pipeline);
188
263
  g_return_val_if_fail (preview->pipeline != NULL, FALSE);
189
264
  g_return_val_if_fail (buffer, FALSE);
190
265
 
 
266
  g_mutex_lock (preview->processing_lock);
 
267
  g_return_val_if_fail (preview->pipeline != NULL, FALSE);
 
268
 
 
269
  if (preview->pending_preview_caps) {
 
270
    if (preview->processing > 0) {
 
271
      g_cond_wait (preview->processing_cond, preview->processing_lock);
 
272
    }
 
273
    _gst_camerabin_preview_set_caps (preview, preview->pending_preview_caps);
 
274
    gst_caps_replace (&preview->pending_preview_caps, NULL);
 
275
  }
 
276
 
 
277
  preview->processing++;
 
278
 
191
279
  gst_app_src_push_buffer ((GstAppSrc *) preview->appsrc,
192
280
      gst_buffer_ref (buffer));
193
281
 
 
282
  g_mutex_unlock (preview->processing_lock);
 
283
 
194
284
  return TRUE;
195
285
}
196
286
 
197
 
/**
198
 
 * gst_camerabin_preview_set_caps:
199
 
 * @preview: the #GstCameraBinPreviewPipelineData
200
 
 * @caps: the #GstCaps to be set
201
 
 *
202
 
 * The caps that preview buffers should have when posted
203
 
 * on the bus 
204
 
 */
205
 
void
206
 
gst_camerabin_preview_set_caps (GstCameraBinPreviewPipelineData * preview,
 
287
static void
 
288
_gst_camerabin_preview_set_caps (GstCameraBinPreviewPipelineData * preview,
207
289
    GstCaps * caps)
208
290
{
209
291
  GstState state, pending;
210
292
  GstStateChangeReturn ret;
211
293
 
212
294
  g_return_if_fail (preview != NULL);
 
295
  g_return_if_fail (preview->pipeline != NULL);
213
296
 
214
297
  ret = gst_element_get_state (preview->pipeline, &state, &pending, 0);
215
298
  if (ret == GST_STATE_CHANGE_FAILURE) {
217
300
    state = GST_STATE_PLAYING;
218
301
    pending = GST_STATE_VOID_PENDING;
219
302
  }
220
 
 
221
303
  gst_element_set_state (preview->pipeline, GST_STATE_NULL);
222
 
  g_object_set (preview->capsfilter, "caps", caps, NULL);
 
304
  g_object_set (preview->appsink, "caps", caps, NULL);
223
305
  if (pending != GST_STATE_VOID_PENDING)
224
306
    state = pending;
225
307
  gst_element_set_state (preview->pipeline, state);
226
308
}
 
309
 
 
310
/**
 
311
 * gst_camerabin_preview_set_caps:
 
312
 * @preview: the #GstCameraBinPreviewPipelineData
 
313
 * @caps: the #GstCaps to be set (a new ref will be taken)
 
314
 *
 
315
 * The caps that preview buffers should have when posted
 
316
 * on the bus
 
317
 */
 
318
void
 
319
gst_camerabin_preview_set_caps (GstCameraBinPreviewPipelineData * preview,
 
320
    GstCaps * caps)
 
321
{
 
322
  g_return_if_fail (preview != NULL);
 
323
 
 
324
  g_mutex_lock (preview->processing_lock);
 
325
 
 
326
  if (preview->processing == 0) {
 
327
    _gst_camerabin_preview_set_caps (preview, caps);
 
328
  } else {
 
329
    GST_DEBUG ("Preview pipeline busy, storing new caps as pending");
 
330
    gst_caps_replace (&preview->pending_preview_caps, caps);
 
331
  }
 
332
  g_mutex_unlock (preview->processing_lock);
 
333
}
 
334
 
 
335
/**
 
336
 * gst_camerabin_preview_set_filter:
 
337
 * @preview: the #GstCameraBinPreviewPipelineData
 
338
 * @filter: Custom filter to process preview data (an extra ref is taken)
 
339
 *
 
340
 * Set the filter element into preview pipeline.
 
341
 *
 
342
 * Returns: %TRUE on success
 
343
 */
 
344
gboolean
 
345
gst_camerabin_preview_set_filter (GstCameraBinPreviewPipelineData * preview,
 
346
    GstElement * filter)
 
347
{
 
348
  gboolean ret = TRUE;
 
349
  GstState current;
 
350
 
 
351
  g_return_val_if_fail (preview != NULL, FALSE);
 
352
 
 
353
  GST_DEBUG ("Preview pipeline setting new filter %p", filter);
 
354
 
 
355
  g_mutex_lock (preview->processing_lock);
 
356
 
 
357
  gst_element_get_state (preview->pipeline, &current, NULL, 0);
 
358
 
 
359
  if (preview->processing == 0 && current == GST_STATE_NULL) {
 
360
    gboolean linkfail = FALSE;
 
361
 
 
362
    if (preview->filter) {
 
363
      /* Unlink and remove old filter */
 
364
      gst_element_unlink (preview->appsrc, preview->filter);
 
365
      gst_element_unlink (preview->filter, preview->vscale);
 
366
      gst_bin_remove (GST_BIN (preview->pipeline), preview->filter);
 
367
    } else {
 
368
      /* Make room for filter by breaking the link between appsrc and vcale */
 
369
      gst_element_unlink (preview->appsrc, preview->vscale);
 
370
    }
 
371
 
 
372
    if (filter) {
 
373
      /* Add and link the new filter between appsrc and vscale */
 
374
      gst_bin_add (GST_BIN (preview->pipeline), gst_object_ref (filter));
 
375
 
 
376
      linkfail |=
 
377
          GST_PAD_LINK_FAILED (gst_element_link_pads_full (preview->appsrc,
 
378
              "src", filter, NULL, GST_PAD_LINK_CHECK_NOTHING));
 
379
 
 
380
      linkfail |=
 
381
          GST_PAD_LINK_FAILED (gst_element_link_pads_full (filter, NULL,
 
382
              preview->vscale, "sink", GST_PAD_LINK_CHECK_CAPS));
 
383
    } else {
 
384
      /* No filter was given. Just link the appsrc to vscale directly */
 
385
      linkfail |=
 
386
          GST_PAD_LINK_FAILED (gst_element_link_pads_full (preview->appsrc,
 
387
              "src", preview->vscale, "sink", GST_PAD_LINK_CHECK_NOTHING));
 
388
    }
 
389
 
 
390
    if (linkfail) {
 
391
      GST_WARNING ("Linking the filter to pipeline failed");
 
392
      ret = FALSE;
 
393
    } else {
 
394
      GST_DEBUG ("Linking the filter to pipeline successful");
 
395
      preview->filter = filter;
 
396
    }
 
397
  } else {
 
398
    GST_WARNING ("Cannot change filter when pipeline is running");
 
399
    ret = FALSE;
 
400
  }
 
401
  g_mutex_unlock (preview->processing_lock);
 
402
 
 
403
  return ret;
 
404
}