c04f2caccaab881760edbb84f8e5cea2f1c9b7a3
[framework/multimedia/gst-plugins-base0.10.git] / gst-libs / gst / video / convertframe.c
1 /* Small helper element for format conversion
2  * Copyright (C) 2005 Tim-Philipp Müller <tim centricular net>
3  * Copyright (C) 2010 Brandon Lewis <brandon.lewis@collabora.co.uk>
4  * Copyright (C) 2010 Edward Hervey <edward.hervey@collabora.co.uk>
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Library General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Library General Public License for more details.
15  *
16  * You should have received a copy of the GNU Library General Public
17  * License along with this library; if not, write to the
18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19  * Boston, MA 02111-1307, USA.
20  */
21
22 #include <string.h>
23 #include "video.h"
24
25 static gboolean
26 caps_are_raw (const GstCaps * caps)
27 {
28   guint i, len;
29
30   len = gst_caps_get_size (caps);
31
32   for (i = 0; i < len; i++) {
33     GstStructure *st = gst_caps_get_structure (caps, i);
34     if (gst_structure_has_name (st, "video/x-raw-yuv") ||
35         gst_structure_has_name (st, "video/x-raw-rgb"))
36       return TRUE;
37   }
38
39   return FALSE;
40 }
41
42 static gboolean
43 create_element (const gchar * factory_name, GstElement ** element,
44     GError ** err)
45 {
46   *element = gst_element_factory_make (factory_name, NULL);
47   if (*element)
48     return TRUE;
49
50   if (err && *err == NULL) {
51     *err = g_error_new (GST_CORE_ERROR, GST_CORE_ERROR_MISSING_PLUGIN,
52         "cannot create element '%s' - please check your GStreamer installation",
53         factory_name);
54   }
55
56   return FALSE;
57 }
58
59 static GstElement *
60 get_encoder (const GstCaps * caps, GError ** err)
61 {
62   GList *encoders = NULL;
63   GList *filtered = NULL;
64   GstElementFactory *factory = NULL;
65   GstElement *encoder = NULL;
66
67   encoders =
68       gst_element_factory_list_get_elements (GST_ELEMENT_FACTORY_TYPE_ENCODER |
69       GST_ELEMENT_FACTORY_TYPE_MEDIA_IMAGE, GST_RANK_NONE);
70
71   if (encoders == NULL) {
72     *err = g_error_new (GST_CORE_ERROR, GST_CORE_ERROR_MISSING_PLUGIN,
73         "Cannot find any image encoder");
74     goto fail;
75   }
76
77   GST_INFO ("got factory list %p", encoders);
78   gst_plugin_feature_list_debug (encoders);
79
80   filtered =
81       gst_element_factory_list_filter (encoders, caps, GST_PAD_SRC, FALSE);
82   GST_INFO ("got filtered list %p", filtered);
83
84   if (filtered == NULL) {
85     gchar *tmp = gst_caps_to_string (caps);
86     *err = g_error_new (GST_CORE_ERROR, GST_CORE_ERROR_MISSING_PLUGIN,
87         "Cannot find any image encoder for caps %s", tmp);
88     g_free (tmp);
89     goto fail;
90   }
91
92   gst_plugin_feature_list_debug (filtered);
93
94   factory = (GstElementFactory *) filtered->data;
95
96   GST_INFO ("got factory %p", factory);
97   encoder = gst_element_factory_create (factory, NULL);
98
99   GST_INFO ("created encoder element %p, %s", encoder,
100       gst_element_get_name (encoder));
101
102 fail:
103   if (encoders)
104     gst_plugin_feature_list_free (encoders);
105   if (filtered)
106     gst_plugin_feature_list_free (filtered);
107
108   return encoder;
109 }
110
111 static GstElement *
112 build_convert_frame_pipeline (GstElement ** src_element,
113     GstElement ** sink_element, const GstCaps * from_caps,
114     const GstCaps * to_caps, GError ** err)
115 {
116   GstElement *src = NULL, *csp = NULL, *vscale = NULL;
117   GstElement *sink = NULL, *encoder = NULL, *pipeline;
118   GError *error = NULL;
119
120   /* videoscale is here to correct for the pixel-aspect-ratio for us */
121   GST_DEBUG ("creating elements");
122   if (!create_element ("appsrc", &src, &error) ||
123       !create_element ("ffmpegcolorspace", &csp, &error) ||
124       !create_element ("videoscale", &vscale, &error) ||
125       !create_element ("appsink", &sink, &error))
126     goto no_elements;
127
128   pipeline = gst_pipeline_new ("videoconvert-pipeline");
129   if (pipeline == NULL)
130     goto no_pipeline;
131
132   /* Add black borders if necessary to keep the DAR */
133   g_object_set (vscale, "add-borders", TRUE, NULL);
134
135   GST_DEBUG ("adding elements");
136   gst_bin_add_many (GST_BIN (pipeline), src, csp, vscale, sink, NULL);
137
138   /* set caps */
139   g_object_set (src, "caps", from_caps, NULL);
140   g_object_set (sink, "caps", to_caps, NULL);
141
142   /* FIXME: linking is still way too expensive, profile this properly */
143   GST_DEBUG ("linking src->csp");
144   if (!gst_element_link_pads (src, "src", csp, "sink"))
145     goto link_failed;
146
147   GST_DEBUG ("linking csp->vscale");
148   if (!gst_element_link_pads (csp, "src", vscale, "sink"))
149     goto link_failed;
150
151   if (caps_are_raw (to_caps)) {
152     GST_DEBUG ("linking vscale->sink");
153
154     if (!gst_element_link_pads (vscale, "src", sink, "sink"))
155       goto link_failed;
156   } else {
157     encoder = get_encoder (to_caps, &error);
158     if (!encoder)
159       goto no_encoder;
160     gst_bin_add (GST_BIN (pipeline), encoder);
161
162     GST_DEBUG ("linking vscale->encoder");
163     if (!gst_element_link (vscale, encoder))
164       goto link_failed;
165
166     GST_DEBUG ("linking encoder->sink");
167     if (!gst_element_link_pads (encoder, "src", sink, "sink"))
168       goto link_failed;
169   }
170
171   g_object_set (src, "emit-signals", TRUE, NULL);
172   g_object_set (sink, "emit-signals", TRUE, NULL);
173
174   *src_element = src;
175   *sink_element = sink;
176
177   return pipeline;
178   /* ERRORS */
179 no_encoder:
180   {
181     gst_object_unref (pipeline);
182
183     GST_ERROR ("could not find an encoder for provided caps");
184     if (err)
185       *err = error;
186     else
187       g_error_free (error);
188
189     return NULL;
190   }
191 no_elements:
192   {
193     if (src)
194       gst_object_unref (src);
195     if (csp)
196       gst_object_unref (csp);
197     if (vscale)
198       gst_object_unref (vscale);
199     if (sink)
200       gst_object_unref (sink);
201     GST_ERROR ("Could not convert video frame: %s", error->message);
202     if (err)
203       *err = error;
204     else
205       g_error_free (error);
206     return NULL;
207   }
208 no_pipeline:
209   {
210     gst_object_unref (src);
211     gst_object_unref (csp);
212     gst_object_unref (vscale);
213     gst_object_unref (sink);
214
215     GST_ERROR ("Could not convert video frame: no pipeline (unknown error)");
216     if (err)
217       *err = g_error_new (GST_CORE_ERROR, GST_CORE_ERROR_FAILED,
218           "Could not convert video frame: no pipeline (unknown error)");
219     return NULL;
220   }
221 link_failed:
222   {
223     gst_object_unref (pipeline);
224
225     GST_ERROR ("Could not convert video frame: failed to link elements");
226     if (err)
227       *err = g_error_new (GST_CORE_ERROR, GST_CORE_ERROR_NEGOTIATION,
228           "Could not convert video frame: failed to link elements");
229     return NULL;
230   }
231 }
232
233 /**
234  * gst_video_convert_frame:
235  * @buf: a #GstBuffer
236  * @to_caps: the #GstCaps to convert to
237  * @timeout: the maximum amount of time allowed for the processing.
238  * @err: pointer to a #GError. Can be %NULL.
239  *
240  * Converts a raw video buffer into the specified output caps.
241  *
242  * The output caps can be any raw video formats or any image formats (jpeg, png, ...).
243  *
244  * The width, height and pixel-aspect-ratio can also be specified in the output caps.
245  *
246  * Returns: The converted #GstBuffer, or %NULL if an error happened (in which case @err
247  * will point to the #GError).
248  *
249  * Since: 0.10.31
250  *
251  */
252 GstBuffer *
253 gst_video_convert_frame (GstBuffer * buf, const GstCaps * to_caps,
254     GstClockTime timeout, GError ** err)
255 {
256   GstMessage *msg;
257   GstBuffer *result = NULL;
258   GError *error = NULL;
259   GstBus *bus;
260   GstCaps *from_caps, *to_caps_copy = NULL;
261   GstFlowReturn ret;
262   GstElement *pipeline, *src, *sink;
263   guint i, n;
264
265   g_return_val_if_fail (buf != NULL, NULL);
266   g_return_val_if_fail (to_caps != NULL, NULL);
267   g_return_val_if_fail (GST_BUFFER_CAPS (buf) != NULL, NULL);
268
269   from_caps = GST_BUFFER_CAPS (buf);
270
271   to_caps_copy = gst_caps_new_empty ();
272   n = gst_caps_get_size (to_caps);
273   for (i = 0; i < n; i++) {
274     GstStructure *s = gst_caps_get_structure (to_caps, i);
275
276     s = gst_structure_copy (s);
277     gst_structure_remove_field (s, "framerate");
278     gst_caps_append_structure (to_caps_copy, s);
279   }
280
281   pipeline =
282       build_convert_frame_pipeline (&src, &sink, from_caps, to_caps_copy,
283       &error);
284   if (!pipeline)
285     goto no_pipeline;
286
287   /* now set the pipeline to the paused state, after we push the buffer into
288    * appsrc, this should preroll the converted buffer in appsink */
289   GST_DEBUG ("running conversion pipeline to caps %" GST_PTR_FORMAT,
290       to_caps_copy);
291   gst_element_set_state (pipeline, GST_STATE_PAUSED);
292
293   /* feed buffer in appsrc */
294   GST_DEBUG ("feeding buffer %p, size %u, caps %" GST_PTR_FORMAT,
295       buf, GST_BUFFER_SIZE (buf), from_caps);
296   g_signal_emit_by_name (src, "push-buffer", buf, &ret);
297
298   /* now see what happens. We either got an error somewhere or the pipeline
299    * prerolled */
300   bus = gst_element_get_bus (pipeline);
301   msg = gst_bus_timed_pop_filtered (bus,
302       timeout, GST_MESSAGE_ERROR | GST_MESSAGE_ASYNC_DONE);
303
304   if (msg) {
305     switch (GST_MESSAGE_TYPE (msg)) {
306       case GST_MESSAGE_ASYNC_DONE:
307       {
308         /* we're prerolled, get the frame from appsink */
309         g_signal_emit_by_name (sink, "pull-preroll", &result);
310
311         if (result) {
312           GST_DEBUG ("conversion successful: result = %p", result);
313         } else {
314           GST_ERROR ("prerolled but no result frame?!");
315         }
316         break;
317       }
318       case GST_MESSAGE_ERROR:{
319         gchar *dbg = NULL;
320
321         gst_message_parse_error (msg, &error, &dbg);
322         if (error) {
323           GST_ERROR ("Could not convert video frame: %s", error->message);
324           GST_DEBUG ("%s [debug: %s]", error->message, GST_STR_NULL (dbg));
325           if (err)
326             *err = error;
327           else
328             g_error_free (error);
329         }
330         g_free (dbg);
331         break;
332       }
333       default:{
334         g_return_val_if_reached (NULL);
335       }
336     }
337     gst_message_unref (msg);
338   } else {
339     GST_ERROR ("Could not convert video frame: timeout during conversion");
340     if (err)
341       *err = g_error_new (GST_CORE_ERROR, GST_CORE_ERROR_FAILED,
342           "Could not convert video frame: timeout during conversion");
343   }
344
345   gst_element_set_state (pipeline, GST_STATE_NULL);
346   gst_object_unref (bus);
347   gst_object_unref (pipeline);
348   gst_caps_unref (to_caps_copy);
349
350   return result;
351
352   /* ERRORS */
353 no_pipeline:
354   {
355     gst_caps_unref (to_caps_copy);
356
357     if (err)
358       *err = error;
359     else
360       g_error_free (error);
361
362     return NULL;
363   }
364 }
365
366 typedef struct
367 {
368   GMutex *mutex;
369   GstElement *pipeline;
370   GstVideoConvertFrameCallback callback;
371   gpointer user_data;
372   GDestroyNotify destroy_notify;
373   GMainContext *context;
374   GstBuffer *buffer;
375   gulong timeout_id;
376   gboolean finished;
377 } GstVideoConvertFrameContext;
378
379 typedef struct
380 {
381   GstVideoConvertFrameCallback callback;
382   GstBuffer *buffer;
383   GError *error;
384   gpointer user_data;
385   GDestroyNotify destroy_notify;
386
387   GstVideoConvertFrameContext *context;
388 } GstVideoConvertFrameCallbackContext;
389
390 static void
391 gst_video_convert_frame_context_free (GstVideoConvertFrameContext * ctx)
392 {
393   /* Wait until all users of the mutex are done */
394   g_mutex_lock (ctx->mutex);
395   g_mutex_unlock (ctx->mutex);
396   g_mutex_free (ctx->mutex);
397   if (ctx->timeout_id)
398     g_source_remove (ctx->timeout_id);
399   if (ctx->buffer)
400     gst_buffer_unref (ctx->buffer);
401   g_main_context_unref (ctx->context);
402
403   gst_element_set_state (ctx->pipeline, GST_STATE_NULL);
404   gst_object_unref (ctx->pipeline);
405
406   g_slice_free (GstVideoConvertFrameContext, ctx);
407 }
408
409 static void
410     gst_video_convert_frame_callback_context_free
411     (GstVideoConvertFrameCallbackContext * ctx)
412 {
413   if (ctx->context)
414     gst_video_convert_frame_context_free (ctx->context);
415   g_slice_free (GstVideoConvertFrameCallbackContext, ctx);
416 }
417
418 static gboolean
419 convert_frame_dispatch_callback (GstVideoConvertFrameCallbackContext * ctx)
420 {
421   ctx->callback (ctx->buffer, ctx->error, ctx->user_data);
422
423   if (ctx->destroy_notify)
424     ctx->destroy_notify (ctx->user_data);
425
426   return FALSE;
427 }
428
429 static void
430 convert_frame_finish (GstVideoConvertFrameContext * context, GstBuffer * buffer,
431     GError * error)
432 {
433   GSource *source;
434   GstVideoConvertFrameCallbackContext *ctx;
435
436   if (context->timeout_id)
437     g_source_remove (context->timeout_id);
438   context->timeout_id = 0;
439
440   ctx = g_slice_new (GstVideoConvertFrameCallbackContext);
441   ctx->callback = context->callback;
442   ctx->user_data = context->user_data;
443   ctx->destroy_notify = context->destroy_notify;
444   ctx->buffer = buffer;
445   ctx->error = error;
446   ctx->context = context;
447
448   source = g_timeout_source_new (0);
449   g_source_set_callback (source,
450       (GSourceFunc) convert_frame_dispatch_callback, ctx,
451       (GDestroyNotify) gst_video_convert_frame_callback_context_free);
452   g_source_attach (source, context->context);
453   g_source_unref (source);
454
455   context->finished = TRUE;
456 }
457
458 static gboolean
459 convert_frame_timeout_callback (GstVideoConvertFrameContext * context)
460 {
461   GError *error;
462
463   g_mutex_lock (context->mutex);
464
465   if (context->finished)
466     goto done;
467
468   GST_ERROR ("Could not convert video frame: timeout");
469
470   error = g_error_new (GST_CORE_ERROR, GST_CORE_ERROR_FAILED,
471       "Could not convert video frame: timeout");
472
473   convert_frame_finish (context, NULL, error);
474
475 done:
476   g_mutex_unlock (context->mutex);
477   return FALSE;
478 }
479
480 static gboolean
481 convert_frame_bus_callback (GstBus * bus, GstMessage * message,
482     GstVideoConvertFrameContext * context)
483 {
484   g_mutex_lock (context->mutex);
485
486   if (context->finished)
487     goto done;
488
489   switch (GST_MESSAGE_TYPE (message)) {
490     case GST_MESSAGE_ERROR:{
491       GError *error;
492       gchar *dbg = NULL;
493
494       gst_message_parse_error (message, &error, &dbg);
495
496       GST_ERROR ("Could not convert video frame: %s", error->message);
497       GST_DEBUG ("%s [debug: %s]", error->message, GST_STR_NULL (dbg));
498
499       convert_frame_finish (context, NULL, error);
500
501       g_free (dbg);
502       break;
503     }
504     default:
505       break;
506   }
507
508 done:
509   g_mutex_unlock (context->mutex);
510
511   return FALSE;
512 }
513
514 static void
515 convert_frame_need_data_callback (GstElement * src, guint size,
516     GstVideoConvertFrameContext * context)
517 {
518   GstFlowReturn ret = GST_FLOW_ERROR;
519   GError *error;
520
521   g_mutex_lock (context->mutex);
522
523   if (context->finished)
524     goto done;
525
526   g_signal_emit_by_name (src, "push-buffer", context->buffer, &ret);
527   gst_buffer_unref (context->buffer);
528   context->buffer = NULL;
529
530   if (ret != GST_FLOW_OK) {
531     GST_ERROR ("Could not push video frame: %s", gst_flow_get_name (ret));
532
533     error = g_error_new (GST_CORE_ERROR, GST_CORE_ERROR_FAILED,
534         "Could not push video frame: %s", gst_flow_get_name (ret));
535
536     convert_frame_finish (context, NULL, error);
537   }
538
539   g_signal_handlers_disconnect_by_func (src, convert_frame_need_data_callback,
540       context);
541
542 done:
543   g_mutex_unlock (context->mutex);
544 }
545
546 static void
547 convert_frame_new_buffer_callback (GstElement * sink,
548     GstVideoConvertFrameContext * context)
549 {
550   GstBuffer *buf = NULL;
551   GError *error = NULL;
552
553   g_mutex_lock (context->mutex);
554
555   if (context->finished)
556     goto done;
557
558   g_signal_emit_by_name (sink, "pull-preroll", &buf);
559
560   if (!buf) {
561     error = g_error_new (GST_CORE_ERROR, GST_CORE_ERROR_FAILED,
562         "Could not get converted video frame");
563   }
564
565   convert_frame_finish (context, buf, error);
566
567   g_signal_handlers_disconnect_by_func (sink, convert_frame_need_data_callback,
568       context);
569
570 done:
571   g_mutex_unlock (context->mutex);
572 }
573
574 /**
575  * gst_video_convert_frame_async:
576  * @buf: a #GstBuffer
577  * @to_caps: the #GstCaps to convert to
578  * @timeout: the maximum amount of time allowed for the processing.
579  * @callback: %GstVideoConvertFrameCallback that will be called after conversion.
580  * @destroy_notify: %GDestroyNotify to be called after @user_data is not needed anymore
581  *
582  * Converts a raw video buffer into the specified output caps.
583  *
584  * The output caps can be any raw video formats or any image formats (jpeg, png, ...).
585  *
586  * The width, height and pixel-aspect-ratio can also be specified in the output caps.
587  *
588  * @callback will be called after conversion, when an error occured or if conversion didn't
589  * finish after @timeout. @callback will always be called from the thread default
590  * %GMainContext, see g_main_context_get_thread_default(). If GLib before 2.22 is used,
591  * this will always be the global default main context.
592  *
593  * @destroy_notify will be called after the callback was called and @user_data is not needed
594  * anymore.
595  *
596  * Since: 0.10.31
597  *
598  */
599 void
600 gst_video_convert_frame_async (GstBuffer * buf, const GstCaps * to_caps,
601     GstClockTime timeout, GstVideoConvertFrameCallback callback,
602     gpointer user_data, GDestroyNotify destroy_notify)
603 {
604   GMainContext *context = NULL;
605   GError *error = NULL;
606   GstBus *bus;
607   GstCaps *from_caps, *to_caps_copy = NULL;
608   GstElement *pipeline, *src, *sink;
609   guint i, n;
610   GSource *source;
611   GstVideoConvertFrameContext *ctx;
612
613   g_return_if_fail (buf != NULL);
614   g_return_if_fail (to_caps != NULL);
615   g_return_if_fail (GST_BUFFER_CAPS (buf) != NULL);
616   g_return_if_fail (callback != NULL);
617
618   context = g_main_context_get_thread_default ();
619
620   if (!context)
621     context = g_main_context_default ();
622
623   from_caps = GST_BUFFER_CAPS (buf);
624
625   to_caps_copy = gst_caps_new_empty ();
626   n = gst_caps_get_size (to_caps);
627   for (i = 0; i < n; i++) {
628     GstStructure *s = gst_caps_get_structure (to_caps, i);
629
630     s = gst_structure_copy (s);
631     gst_structure_remove_field (s, "framerate");
632     gst_caps_append_structure (to_caps_copy, s);
633   }
634
635   pipeline =
636       build_convert_frame_pipeline (&src, &sink, from_caps, to_caps_copy,
637       &error);
638   if (!pipeline)
639     goto no_pipeline;
640
641   bus = gst_element_get_bus (pipeline);
642
643   ctx = g_slice_new0 (GstVideoConvertFrameContext);
644   ctx->mutex = g_mutex_new ();
645   ctx->buffer = gst_buffer_ref (buf);
646   ctx->callback = callback;
647   ctx->user_data = user_data;
648   ctx->destroy_notify = destroy_notify;
649   ctx->context = g_main_context_ref (context);
650   ctx->finished = FALSE;
651   ctx->pipeline = pipeline;
652
653   if (timeout != GST_CLOCK_TIME_NONE) {
654     source = g_timeout_source_new (timeout / GST_MSECOND);
655     g_source_set_callback (source,
656         (GSourceFunc) convert_frame_timeout_callback, ctx, NULL);
657     ctx->timeout_id = g_source_attach (source, context);
658     g_source_unref (source);
659   }
660
661   g_signal_connect (src, "need-data",
662       G_CALLBACK (convert_frame_need_data_callback), ctx);
663   g_signal_connect (sink, "new-preroll",
664       G_CALLBACK (convert_frame_new_buffer_callback), ctx);
665
666   source = gst_bus_create_watch (bus);
667   g_source_set_callback (source, (GSourceFunc) convert_frame_bus_callback,
668       ctx, NULL);
669   g_source_attach (source, context);
670   g_source_unref (source);
671
672   gst_element_set_state (pipeline, GST_STATE_PLAYING);
673
674   gst_object_unref (bus);
675   gst_caps_unref (to_caps_copy);
676
677   return;
678   /* ERRORS */
679 no_pipeline:
680   {
681     GstVideoConvertFrameCallbackContext *ctx;
682     GSource *source;
683
684     gst_caps_unref (to_caps_copy);
685
686     ctx = g_slice_new0 (GstVideoConvertFrameCallbackContext);
687     ctx->callback = callback;
688     ctx->user_data = user_data;
689     ctx->destroy_notify = destroy_notify;
690     ctx->buffer = NULL;
691     ctx->error = error;
692
693     source = g_timeout_source_new (0);
694     g_source_set_callback (source,
695         (GSourceFunc) convert_frame_dispatch_callback, ctx,
696         (GDestroyNotify) gst_video_convert_frame_callback_context_free);
697     g_source_attach (source, context);
698     g_source_unref (source);
699   }
700 }