sys/rpicamsrc/gstrpicamsrc.c

   1 /*
   2  * GStreamer
   3  * Copyright (C) 2013-2015 Jan Schmidt <jan@centricular.com>
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  *
  23  * Alternatively, the contents of this file may be used under the
  24  * GNU Lesser General Public License Version 2.1 (the "LGPL"), in
  25  * which case the following provisions apply instead of the ones
  26  * mentioned above:
  27  *
  28  * This library is free software; you can redistribute it and/or
  29  * modify it under the terms of the GNU Library General Public
  30  * License as published by the Free Software Foundation; either
  31  * version 2 of the License, or (at your option) any later version.
  32  *
  33  * This library is distributed in the hope that it will be useful,
  34  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  35  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  36  * Library General Public License for more details.
  37  *
  38  * You should have received a copy of the GNU Library General Public
  39  * License along with this library; if not, write to the
  40  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  41  * Boston, MA 02111-1307, USA.
  42  */
  43
  44 /**
  45  * SECTION:element-rpicamsrc
  46  *
  47  * Source element for capturing from the Raspberry Pi camera module
  48  *
  49  * <refsect2>
  50  * <title>Example launch line</title>
  51  * |[
  52  * gst-launch -v -m rpicamsrc ! fakesink
  53  * ]|
  54  * </refsect2>
  55  */
  56
  57 #ifdef HAVE_CONFIG_H
  58 #  include <config.h>
  59 #endif
  60 #include <gst/video/video.h>
  61
  62 #include "gstrpicamsrc.h"
  63 #include "gstrpicam_types.h"
  64 #include "gstrpicam-enum-types.h"
  65 #include "gstrpicamsrcdeviceprovider.h"
  66 #include "RaspiCapture.h"
  67
  68 #include "bcm_host.h"
  69 #include "interface/vcos/vcos.h"
  70
  71 #include "interface/mmal/mmal.h"
  72 #include "interface/mmal/mmal_logging.h"
  73 #include "interface/mmal/mmal_buffer.h"
  74 #include "interface/mmal/util/mmal_util.h"
  75 #include "interface/mmal/util/mmal_util_params.h"
  76 #include "interface/mmal/util/mmal_default_components.h"
  77 #include "interface/mmal/util/mmal_connection.h"
  78
  79 GST_DEBUG_CATEGORY (gst_rpi_cam_src_debug);
  80
  81 /* comment out to use JPEG codec instead of MJPEG */
  82 // #define USE_JPEG_CODEC
  83
  84 /* Filter signals and args */
  85 enum
  86 {
  87   /* FILL ME */
  88   LAST_SIGNAL
  89 };
  90
  91 enum
  92 {
  93   PROP_0,
  94   PROP_CAMERA_NUMBER,
  95   PROP_BITRATE,
  96   PROP_KEYFRAME_INTERVAL,
  97   PROP_PREVIEW,
  98   PROP_PREVIEW_ENCODED,
  99   PROP_PREVIEW_OPACITY,
 100   PROP_PREVIEW_X,
 101   PROP_PREVIEW_Y,
 102   PROP_PREVIEW_W,
 103   PROP_PREVIEW_H,
 104   PROP_FULLSCREEN,
 105   PROP_SHARPNESS,
 106   PROP_CONTRAST,
 107   PROP_BRIGHTNESS,
 108   PROP_SATURATION,
 109   PROP_ISO,
 110   PROP_VIDEO_STABILISATION,
 111   PROP_EXPOSURE_COMPENSATION,
 112   PROP_EXPOSURE_MODE,
 113   PROP_EXPOSURE_METERING_MODE,
 114   PROP_AWB_MODE,
 115   PROP_AWB_GAIN_RED,
 116   PROP_AWB_GAIN_BLUE,
 117   PROP_IMAGE_EFFECT,
 118   PROP_IMAGE_EFFECT_PARAMS,
 119   PROP_COLOUR_EFFECTS,
 120   PROP_ROTATION,
 121   PROP_HFLIP,
 122   PROP_VFLIP,
 123   PROP_ROI_X,
 124   PROP_ROI_Y,
 125   PROP_ROI_W,
 126   PROP_ROI_H,
 127   PROP_QUANTISATION_PARAMETER,
 128   PROP_INLINE_HEADERS,
 129   PROP_SHUTTER_SPEED,
 130   PROP_SENSOR_MODE,
 131   PROP_DRC,
 132   PROP_ANNOTATION_MODE,
 133   PROP_ANNOTATION_TEXT,
 134   PROP_ANNOTATION_TEXT_SIZE,
 135   PROP_ANNOTATION_TEXT_COLOUR,
 136   PROP_ANNOTATION_TEXT_BG_COLOUR,
 137   PROP_INTRA_REFRESH_TYPE,
 138 #ifdef GST_RPI_CAM_SRC_ENABLE_VIDEO_DIRECTION
 139   PROP_VIDEO_DIRECTION,
 140 #endif
 141   PROP_JPEG_QUALITY,
 142   PROP_USE_STC
 143 };
 144
 145 #define CAMERA_DEFAULT 0
 146
 147 #define BITRATE_DEFAULT 17000000        /* 17Mbit/s default for 1080p */
 148 #define BITRATE_HIGHEST 25000000
 149
 150 #define QUANTISATION_DEFAULT 0
 151
 152 #define SHARPNESS_DEFAULT 0
 153 #define CONTRAST_DEFAULT 0
 154 #define BRIGHTNESS_DEFAULT 50
 155 #define SATURATION_DEFAULT 0
 156 #define ISO_DEFAULT 0
 157 #define VIDEO_STABILISATION_DEFAULT FALSE
 158 #define EXPOSURE_COMPENSATION_DEFAULT 0
 159 #define KEYFRAME_INTERVAL_DEFAULT -1
 160
 161 #define EXPOSURE_MODE_DEFAULT GST_RPI_CAM_SRC_EXPOSURE_MODE_AUTO
 162 #define EXPOSURE_METERING_MODE_DEFAULT GST_RPI_CAM_SRC_EXPOSURE_METERING_MODE_AVERAGE
 163
 164 #define DEFAULT_JPEG_QUALITY 50
 165
 166 /*
 167    params->exposureMode = MMAL_PARAM_EXPOSUREMODE_AUTO;
 168    params->exposureMeterMode = MMAL_PARAM_EXPOSUREMETERINGMODE_AVERAGE;
 169    params->awbMode = MMAL_PARAM_AWBMODE_AUTO;
 170    params->imageEffect = MMAL_PARAM_IMAGEFX_NONE;
 171    params->colourEffects.enable = 0;
 172    params->colourEffects.u = 128;
 173    params->colourEffects.v = 128;
 174    params->rotation = 0;
 175    params->hflip = params->vflip = 0;
 176    params->roi.x = params->roi.y = 0.0;
 177    params->roi.w = params->roi.h = 1.0;
 178 */
 179
 180 #define JPEG_CAPS \
 181   "image/jpeg,"                                   \
 182   "width = " GST_VIDEO_SIZE_RANGE ","             \
 183   "height = " GST_VIDEO_SIZE_RANGE ","            \
 184   "framerate = " GST_VIDEO_FPS_RANGE
 185 #define H264_CAPS               \
 186   "video/x-h264, "                              \
 187   "width = " GST_VIDEO_SIZE_RANGE ", "          \
 188   "height = " GST_VIDEO_SIZE_RANGE ", "         \
 189   "framerate = " GST_VIDEO_FPS_RANGE ", "       \
 190   "stream-format = (string) byte-stream, "  \
 191   "alignment = (string) nal, "               \
 192   "profile = (string) { baseline, main, high }"
 193 #define RAW_CAPS \
 194   GST_VIDEO_CAPS_MAKE ("{ I420, RGB, BGR, RGBA }") /* FIXME: Map more raw formats */
 195
 196 #ifdef GST_RPI_CAM_SRC_ENABLE_VIDEO_DIRECTION
 197 #define gst_rpi_cam_src_reset_custom_orientation(src) { src->orientation = GST_VIDEO_ORIENTATION_CUSTOM; }
 198 #else
 199 #define gst_rpi_cam_src_reset_custom_orientation(src) { }
 200 #endif
 201
 202 static GstStaticPadTemplate video_src_template = GST_STATIC_PAD_TEMPLATE ("src",
 203     GST_PAD_SRC,
 204     GST_PAD_ALWAYS,
 205     GST_STATIC_CAPS ( H264_CAPS "; " JPEG_CAPS "; " RAW_CAPS)
 206     );
 207
 208
 209 static void gst_rpi_cam_src_finalize (GObject *object);
 210
 211 static void gst_rpi_cam_src_colorbalance_init (GstColorBalanceInterface *
 212     iface);
 213 static void gst_rpi_cam_src_orientation_init (GstVideoOrientationInterface * iface);
 214 #ifdef GST_RPI_CAM_SRC_ENABLE_VIDEO_DIRECTION
 215 static void gst_rpi_cam_src_direction_init (GstVideoDirectionInterface * iface);
 216 #endif
 217
 218 static void gst_rpi_cam_src_set_property (GObject * object, guint prop_id,
 219     const GValue * value, GParamSpec * pspec);
 220 static void gst_rpi_cam_src_get_property (GObject * object, guint prop_id,
 221     GValue * value, GParamSpec * pspec);
 222 static gboolean gst_rpi_cam_src_start (GstBaseSrc * parent);
 223 static gboolean gst_rpi_cam_src_stop (GstBaseSrc * parent);
 224 static gboolean gst_rpi_cam_src_decide_allocation (GstBaseSrc * src,
 225     GstQuery * query);
 226 static GstFlowReturn gst_rpi_cam_src_create (GstPushSrc * parent,
 227     GstBuffer ** buf);
 228 static GstCaps *gst_rpi_cam_src_get_caps (GstBaseSrc * src, GstCaps * filter);
 229 static gboolean gst_rpi_cam_src_set_caps (GstBaseSrc * src, GstCaps * caps);
 230 static GstCaps *gst_rpi_cam_src_fixate (GstBaseSrc * basesrc, GstCaps * caps);
 231 static gboolean gst_rpi_cam_src_event (GstBaseSrc * src, GstEvent * event);
 232 static gboolean gst_rpi_cam_src_send_event (GstElement * element,
 233     GstEvent * event);
 234
 235 #define gst_rpi_cam_src_parent_class parent_class
 236 G_DEFINE_TYPE_WITH_CODE (GstRpiCamSrc, gst_rpi_cam_src,
 237     GST_TYPE_PUSH_SRC,
 238     G_IMPLEMENT_INTERFACE (GST_TYPE_COLOR_BALANCE,
 239         gst_rpi_cam_src_colorbalance_init);
 240 #ifdef GST_RPI_CAM_SRC_ENABLE_VIDEO_DIRECTION
 241     G_IMPLEMENT_INTERFACE (GST_TYPE_VIDEO_DIRECTION,
 242         gst_rpi_cam_src_direction_init);
 243 #endif
 244     G_IMPLEMENT_INTERFACE (GST_TYPE_VIDEO_ORIENTATION,
 245         gst_rpi_cam_src_orientation_init));
 246
 247 #define C_ENUM(v) ((gint) v)
 248
 249 GType
 250 gst_rpi_cam_src_sensor_mode_get_type (void)
 251 {
 252   static const GEnumValue values[] = {
 253     {C_ENUM (GST_RPI_CAM_SRC_SENSOR_MODE_AUTOMATIC), "Automatic", "automatic"},
 254     {C_ENUM (GST_RPI_CAM_SRC_SENSOR_MODE_1920x1080), "1920x1080 16:9 1-30fps",
 255         "1920x1080"},
 256     {C_ENUM (GST_RPI_CAM_SRC_SENSOR_MODE_2592x1944_FAST),
 257           "2592x1944 4:3 1-15fps / 3240x2464 15fps w/ v.2 board",
 258         "2592x1944-fast"},
 259     {C_ENUM (GST_RPI_CAM_SRC_SENSOR_MODE_2592x1944_SLOW),
 260         "2592x1944 4:3 0.1666-1fps / 3240x2464 15fps w/ v.2 board", "2592x1944-slow"},
 261     {C_ENUM (GST_RPI_CAM_SRC_SENSOR_MODE_1296x972), "1296x972 4:3 1-42fps",
 262         "1296x972"},
 263     {C_ENUM (GST_RPI_CAM_SRC_SENSOR_MODE_1296x730), "1296x730 16:9 1-49fps",
 264         "1296x730"},
 265     {C_ENUM (GST_RPI_CAM_SRC_SENSOR_MODE_640x480_SLOW),
 266         "640x480 4:3 42.1-60fps", "640x480-slow"},
 267     {C_ENUM (GST_RPI_CAM_SRC_SENSOR_MODE_640x480_FAST),
 268         "640x480 4:3 60.1-90fps", "640x480-fast"},
 269     {0, NULL, NULL}
 270   };
 271   static volatile GType id = 0;
 272   if (g_once_init_enter ((gsize *) & id)) {
 273     GType _id;
 274     _id = g_enum_register_static ("GstRpiCamSrcSensorMode", values);
 275     g_once_init_leave ((gsize *) & id, _id);
 276   }
 277
 278   return id;
 279 }
 280
 281
 282 static void
 283 gst_rpi_cam_src_class_init (GstRpiCamSrcClass * klass)
 284 {
 285   GObjectClass *gobject_class;
 286   GstElementClass *gstelement_class;
 287   GstBaseSrcClass *basesrc_class;
 288   GstPushSrcClass *pushsrc_class;
 289   gobject_class = (GObjectClass *) klass;
 290   gstelement_class = (GstElementClass *) klass;
 291   basesrc_class = (GstBaseSrcClass *) klass;
 292   pushsrc_class = (GstPushSrcClass *) klass;
 293
 294   gobject_class->finalize = gst_rpi_cam_src_finalize;
 295   gobject_class->set_property = gst_rpi_cam_src_set_property;
 296   gobject_class->get_property = gst_rpi_cam_src_get_property;
 297   g_object_class_install_property (gobject_class, PROP_CAMERA_NUMBER,
 298       g_param_spec_int ("camera-number", "Camera Number",
 299           "Which camera to use on a multi-camera system - 0 or 1", 0,
 300           1, CAMERA_DEFAULT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 301   g_object_class_install_property (gobject_class, PROP_BITRATE,
 302       g_param_spec_int ("bitrate", "Bitrate",
 303           "Bitrate for encoding. 0 for VBR using quantisation-parameter", 0,
 304           BITRATE_HIGHEST, BITRATE_DEFAULT,
 305           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 306 #ifdef USE_JPEG_CODEC
 307   g_object_class_install_property (gobject_class, PROP_JPEG_QUALITY,
 308       g_param_spec_int ("jpeg-quality", "JPEG Quality",
 309           "Quality setting for JPEG encode", 1, 100, DEFAULT_JPEG_QUALITY,
 310           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 311 #endif
 312   g_object_class_install_property (gobject_class, PROP_KEYFRAME_INTERVAL,
 313       g_param_spec_int ("keyframe-interval", "Keyframe Interface",
 314           "Interval (in frames) between I frames. -1 = automatic, 0 = single-keyframe",
 315           -1, G_MAXINT, KEYFRAME_INTERVAL_DEFAULT,
 316           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 317   g_object_class_install_property (gobject_class, PROP_PREVIEW,
 318       g_param_spec_boolean ("preview", "Preview Window",
 319           "Display preview window overlay", TRUE,
 320           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 321   g_object_class_install_property (gobject_class, PROP_FULLSCREEN,
 322       g_param_spec_boolean ("fullscreen", "Fullscreen Preview",
 323           "Display preview window full screen", TRUE,
 324           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 325   g_object_class_install_property (gobject_class, PROP_PREVIEW_ENCODED,
 326       g_param_spec_boolean ("preview-encoded", "Preview Encoded",
 327           "Display encoder output in the preview", TRUE,
 328           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 329   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_PREVIEW_OPACITY,
 330       g_param_spec_int ("preview-opacity", "Preview Opacity",
 331           "Opacity to use for the preview window", 0, 255, 255,
 332           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 333   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_PREVIEW_X,
 334       g_param_spec_int ("preview-x", "Preview window X position",
 335           "Start X coordinate of the preview window (in pixels)", 0, 2048, 0,
 336           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 337   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_PREVIEW_Y,
 338       g_param_spec_int ("preview-y", "Preview window Y position",
 339           "Start Y coordinate of the preview window (in pixels)", 0, 2048, 0,
 340           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 341   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_PREVIEW_W,
 342       g_param_spec_int ("preview-w", "Preview window width",
 343           "Width of the preview window (in pixels)", 0, 2048, 1024,
 344           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 345   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_PREVIEW_H,
 346       g_param_spec_int ("preview-h", "Preview window height",
 347           "Height of the preview window (in pixels)", 0, 2048, 768,
 348           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 349   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_SHARPNESS,
 350       g_param_spec_int ("sharpness", "Sharpness", "Image capture sharpness",
 351           -100, 100, SHARPNESS_DEFAULT,
 352           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 353   g_object_class_install_property (gobject_class, PROP_CONTRAST,
 354       g_param_spec_int ("contrast", "Contrast", "Image capture contrast", -100,
 355           100, CONTRAST_DEFAULT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 356   g_object_class_install_property (gobject_class, PROP_BRIGHTNESS,
 357       g_param_spec_int ("brightness", "Brightness", "Image capture brightness",
 358           0, 100, BRIGHTNESS_DEFAULT,
 359           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 360   g_object_class_install_property (gobject_class, PROP_SATURATION,
 361       g_param_spec_int ("saturation", "Saturation", "Image capture saturation",
 362           -100, 100, SATURATION_DEFAULT,
 363           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 364   g_object_class_install_property (gobject_class, PROP_ISO,
 365       g_param_spec_int ("iso", "ISO", "ISO value to use (0 = Auto)", 0, 3200, 0,
 366           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 367   g_object_class_install_property (gobject_class, PROP_VIDEO_STABILISATION,
 368       g_param_spec_boolean ("video-stabilisation", "Video Stabilisation",
 369           "Enable or disable video stabilisation", FALSE,
 370           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 371   g_object_class_install_property (gobject_class, PROP_EXPOSURE_COMPENSATION,
 372       g_param_spec_int ("exposure-compensation", "EV compensation",
 373           "Exposure Value compensation", -10, 10, 0,
 374           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 375   g_object_class_install_property (gobject_class, PROP_EXPOSURE_MODE,
 376       g_param_spec_enum ("exposure-mode", "Exposure Mode",
 377           "Camera exposure mode to use",
 378           GST_RPI_CAM_TYPE_RPI_CAM_SRC_EXPOSURE_MODE, EXPOSURE_MODE_DEFAULT,
 379           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 380   g_object_class_install_property (gobject_class, PROP_EXPOSURE_METERING_MODE,
 381       g_param_spec_enum ("metering-mode", "Exposure Metering Mode",
 382           "Camera exposure metering mode to use",
 383           GST_RPI_CAM_TYPE_RPI_CAM_SRC_EXPOSURE_METERING_MODE,
 384           EXPOSURE_METERING_MODE_DEFAULT,
 385           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 386   g_object_class_install_property (gobject_class, PROP_DRC,
 387       g_param_spec_enum ("drc", "DRC level", "Dynamic Range Control level",
 388           GST_RPI_CAM_TYPE_RPI_CAM_SRC_DRC_LEVEL, GST_RPI_CAM_SRC_DRC_LEVEL_OFF,
 389           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 390   g_object_class_install_property (gobject_class, PROP_AWB_MODE,
 391       g_param_spec_enum ("awb-mode", "Automatic White Balance Mode",
 392           "White Balance mode", GST_RPI_CAM_TYPE_RPI_CAM_SRC_AWB_MODE,
 393           GST_RPI_CAM_SRC_AWB_MODE_AUTO,
 394           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 395   g_object_class_install_property (gobject_class, PROP_AWB_GAIN_RED,
 396       g_param_spec_float ("awb-gain-red", "AWB Red Gain",
 397           "Manual AWB Gain for red channel when awb-mode=off", 0, 8.0, 0,
 398           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 399   g_object_class_install_property (gobject_class, PROP_AWB_GAIN_BLUE,
 400       g_param_spec_float ("awb-gain-blue", "AWB Blue Gain",
 401           "Manual AWB Gain for blue channel when awb-mode=off", 0, 8.0, 0,
 402           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 403   g_object_class_install_property (gobject_class, PROP_IMAGE_EFFECT,
 404       g_param_spec_enum ("image-effect", "Image effect",
 405           "Visual FX to apply to the image",
 406           GST_RPI_CAM_TYPE_RPI_CAM_SRC_IMAGE_EFFECT,
 407           GST_RPI_CAM_SRC_IMAGEFX_NONE,
 408           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 409 #if 0
 410   PROP_IMAGE_EFFECT_PARAMS, PROP_COLOUR_EFFECTS,
 411 #endif
 412       g_object_class_install_property (gobject_class, PROP_ROTATION,
 413       g_param_spec_int ("rotation", "Rotation",
 414           "Rotate captured image (0, 90, 180, 270 degrees)", 0, 270, 0,
 415           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 416   g_object_class_install_property (gobject_class, PROP_HFLIP,
 417       g_param_spec_boolean ("hflip", "Horizontal Flip",
 418           "Flip capture horizontally", FALSE,
 419           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 420   g_object_class_install_property (gobject_class, PROP_VFLIP,
 421       g_param_spec_boolean ("vflip", "Vertical Flip",
 422           "Flip capture vertically", FALSE,
 423           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 424   g_object_class_install_property (gobject_class, PROP_ROI_X,
 425       g_param_spec_float ("roi-x", "ROI X",
 426           "Normalised region-of-interest X coord", 0, 1.0, 0,
 427           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 428   g_object_class_install_property (gobject_class, PROP_ROI_Y,
 429       g_param_spec_float ("roi-y", "ROI Y",
 430           "Normalised region-of-interest Y coord", 0, 1.0, 0,
 431           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 432   g_object_class_install_property (gobject_class, PROP_ROI_W,
 433       g_param_spec_float ("roi-w", "ROI W",
 434           "Normalised region-of-interest W coord", 0, 1.0, 1.0,
 435           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 436   g_object_class_install_property (gobject_class, PROP_ROI_H,
 437       g_param_spec_float ("roi-h", "ROI H",
 438           "Normalised region-of-interest H coord", 0, 1.0, 1.0,
 439           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 440   g_object_class_install_property (gobject_class,
 441       PROP_QUANTISATION_PARAMETER,
 442       g_param_spec_int ("quantisation-parameter",
 443           "Quantisation Parameter",
 444           "Set a Quantisation Parameter approx 10-40 with bitrate=0 for VBR encoding. 0 = off",
 445           0, G_MAXINT, QUANTISATION_DEFAULT,
 446           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 447   g_object_class_install_property (gobject_class, PROP_INLINE_HEADERS,
 448       g_param_spec_boolean ("inline-headers", "Inline Headers",
 449           "Set to TRUE to insert SPS/PPS before each IDR packet", FALSE,
 450           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 451   g_object_class_install_property (gobject_class, PROP_SHUTTER_SPEED,
 452       g_param_spec_int ("shutter-speed", "Shutter Speed",
 453           "Set a fixed shutter speed, in microseconds. (0 = Auto)", 0,
 454           6000000, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 455   g_object_class_install_property (gobject_class, PROP_SENSOR_MODE,
 456       g_param_spec_enum ("sensor-mode", "Camera Sensor Mode",
 457           "Manually set the camera sensor mode",
 458           gst_rpi_cam_src_sensor_mode_get_type (),
 459           GST_RPI_CAM_SRC_SENSOR_MODE_AUTOMATIC,
 460           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 461   g_object_class_install_property (gobject_class, PROP_ANNOTATION_MODE,
 462       g_param_spec_flags ("annotation-mode", "Annotation Mode",
 463           "Flags to control annotation of the output video",
 464           GST_RPI_CAM_TYPE_RPI_CAM_SRC_ANNOTATION_MODE, 0,
 465           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 466   g_object_class_install_property (gobject_class, PROP_ANNOTATION_TEXT,
 467       g_param_spec_string ("annotation-text", "Annotation Text",
 468           "Text string to annotate onto video when annotation-mode flags include 'custom-text'",
 469           NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 470   g_object_class_install_property (gobject_class, PROP_INTRA_REFRESH_TYPE,
 471       g_param_spec_enum ("intra-refresh-type", "Intra Refresh Type",
 472           "Type of Intra Refresh to use, -1 to disable intra refresh",
 473           GST_RPI_CAM_TYPE_RPI_CAM_SRC_INTRA_REFRESH_TYPE,
 474           GST_RPI_CAM_SRC_INTRA_REFRESH_TYPE_NONE,
 475           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 476   g_object_class_install_property (gobject_class, PROP_ANNOTATION_TEXT_SIZE,
 477       g_param_spec_int ("annotation-text-size", "Annotation text size",
 478           "Set the size of annotation text (in pixels) (0 = Auto)", 0,
 479           G_MAXINT, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 480   g_object_class_install_property (gobject_class, PROP_ANNOTATION_TEXT_COLOUR,
 481       g_param_spec_int ("annotation-text-colour", "Annotation text colour (VUY)",
 482           "Set the annotation text colour, as the integer corresponding to a VUY value eg 0x8080FF = 8421631, -1 for default", -1,
 483           G_MAXINT, -1, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 484   g_object_class_install_property (gobject_class, PROP_ANNOTATION_TEXT_BG_COLOUR,
 485       g_param_spec_int ("annotation-text-bg-colour", "Annotation text background colour (VUY)",
 486           "Set the annotation text background colour, as the integer corresponding to a VUY value eg 0x8080FF = 8421631, -1 for default", -1,
 487           G_MAXINT, -1, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 488 #ifdef GST_RPI_CAM_SRC_ENABLE_VIDEO_DIRECTION
 489   g_object_class_override_property (gobject_class, PROP_VIDEO_DIRECTION,
 490       "video-direction");
 491 #endif
 492   g_object_class_install_property (gobject_class, PROP_USE_STC,
 493       g_param_spec_boolean ("use-stc", "Use System Time Clock",
 494           "Use the camera STC for timestamping buffers", TRUE,
 495           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 496
 497   gst_element_class_set_static_metadata (gstelement_class,
 498       "Raspberry Pi Camera Source", "Source/Video",
 499       "Raspberry Pi camera module source", "Jan Schmidt <jan@centricular.com>");
 500   gst_element_class_add_pad_template (gstelement_class,
 501       gst_static_pad_template_get (&video_src_template));
 502   basesrc_class->start = GST_DEBUG_FUNCPTR (gst_rpi_cam_src_start);
 503   basesrc_class->stop = GST_DEBUG_FUNCPTR (gst_rpi_cam_src_stop);
 504   basesrc_class->decide_allocation =
 505       GST_DEBUG_FUNCPTR (gst_rpi_cam_src_decide_allocation);
 506   basesrc_class->get_caps = GST_DEBUG_FUNCPTR (gst_rpi_cam_src_get_caps);
 507   basesrc_class->set_caps = GST_DEBUG_FUNCPTR (gst_rpi_cam_src_set_caps);
 508   basesrc_class->fixate = GST_DEBUG_FUNCPTR (gst_rpi_cam_src_fixate);
 509   basesrc_class->event = GST_DEBUG_FUNCPTR (gst_rpi_cam_src_event);
 510   gstelement_class->send_event = GST_DEBUG_FUNCPTR (gst_rpi_cam_src_send_event);
 511   pushsrc_class->create = GST_DEBUG_FUNCPTR (gst_rpi_cam_src_create);
 512   raspicapture_init ();
 513 }
 514
 515 static void
 516 gst_rpi_cam_src_init (GstRpiCamSrc * src)
 517 {
 518   GstColorBalanceChannel *channel;
 519
 520   gst_base_src_set_format (GST_BASE_SRC (src), GST_FORMAT_TIME);
 521   gst_base_src_set_live (GST_BASE_SRC (src), TRUE);
 522   raspicapture_default_config (&src->capture_config);
 523   src->capture_config.intraperiod = KEYFRAME_INTERVAL_DEFAULT;
 524   src->capture_config.verbose = 1;
 525   src->capture_config.useSTC = TRUE;
 526
 527   g_mutex_init (&src->config_lock);
 528
 529   /* basesrc will generate timestamps if use-stc = false */
 530   gst_base_src_set_do_timestamp (GST_BASE_SRC (src), TRUE);
 531
 532   /* Generate the channels list */
 533   channel = g_object_new (GST_TYPE_COLOR_BALANCE_CHANNEL, NULL);
 534   channel->label = g_strdup ("CONTRAST");
 535   channel->min_value = -100;
 536   channel->max_value = 100;
 537   src->channels = g_list_append (src->channels, channel);
 538
 539   channel = g_object_new (GST_TYPE_COLOR_BALANCE_CHANNEL, NULL);
 540   channel->label = g_strdup ("BRIGHTNESS");
 541   channel->min_value = 0;
 542   channel->max_value = 100;
 543   src->channels = g_list_append (src->channels, channel);
 544
 545   channel = g_object_new (GST_TYPE_COLOR_BALANCE_CHANNEL, NULL);
 546   channel->label = g_strdup ("SATURATION");
 547   channel->min_value = -100;
 548   channel->max_value = 100;
 549   src->channels = g_list_append (src->channels, channel);
 550 }
 551
 552 static void
 553 gst_rpi_cam_src_finalize (GObject *object)
 554 {
 555   GstRpiCamSrc *src = GST_RPICAMSRC (object);
 556   GList *channels = NULL;
 557   g_mutex_clear (&src->config_lock);
 558
 559   channels = src->channels;
 560   while (channels) {
 561     GstColorBalanceChannel *channel = channels->data;
 562
 563     g_object_unref (channel);
 564     channels->data = NULL;
 565     channels = g_list_next (channels);
 566   }
 567
 568   if (src->channels)
 569     g_list_free (src->channels);
 570
 571   G_OBJECT_CLASS (gst_rpi_cam_src_parent_class)->finalize (object);
 572 }
 573
 574 static const GList *
 575 gst_rpi_cam_src_colorbalance_list_channels (GstColorBalance * balance)
 576 {
 577   GstRpiCamSrc *src = GST_RPICAMSRC (balance);
 578
 579   g_return_val_if_fail (src != NULL, NULL);
 580   g_return_val_if_fail (GST_IS_RPICAMSRC (src), NULL);
 581
 582   return src->channels;
 583 }
 584
 585 static void
 586 gst_rpi_cam_src_colorbalance_set_value (GstColorBalance * balance,
 587     GstColorBalanceChannel * channel, gint value)
 588 {
 589   GstRpiCamSrc *src = GST_RPICAMSRC (balance);
 590   gboolean changed = FALSE;
 591
 592   g_return_if_fail (src != NULL);
 593   g_return_if_fail (GST_IS_RPICAMSRC (src));
 594   g_return_if_fail (channel->label != NULL);
 595
 596   g_mutex_lock (&src->config_lock);
 597   if (!g_ascii_strcasecmp (channel->label, "SATURATION")) {
 598     changed = value != src->capture_config.camera_parameters.saturation;
 599     src->capture_config.camera_parameters.saturation = value;
 600   } else if (!g_ascii_strcasecmp (channel->label, "BRIGHTNESS")) {
 601     changed = value != src->capture_config.camera_parameters.brightness;
 602     src->capture_config.camera_parameters.brightness = value;
 603   } else if (!g_ascii_strcasecmp (channel->label, "CONTRAST")) {
 604     changed = value != src->capture_config.camera_parameters.contrast;
 605     src->capture_config.camera_parameters.contrast = value;
 606   }
 607
 608   if (changed)
 609     src->capture_config.change_flags |= PROP_CHANGE_COLOURBALANCE;
 610
 611   g_mutex_unlock (&src->config_lock);
 612
 613   if (changed) {
 614     gst_color_balance_value_changed (balance, channel,
 615         gst_color_balance_get_value (balance, channel));
 616   }
 617 }
 618
 619 static gint
 620 gst_rpi_cam_src_colorbalance_get_value (GstColorBalance * balance,
 621     GstColorBalanceChannel * channel)
 622 {
 623   GstRpiCamSrc *src = GST_RPICAMSRC (balance);
 624   gint value = 0;
 625
 626   g_return_val_if_fail (src != NULL, 0);
 627   g_return_val_if_fail (GST_IS_RPICAMSRC (src), 0);
 628   g_return_val_if_fail (channel->label != NULL, 0);
 629
 630   g_mutex_lock (&src->config_lock);
 631
 632   if (!g_ascii_strcasecmp (channel->label, "SATURATION")) {
 633     value = src->capture_config.camera_parameters.saturation;
 634   } else if (!g_ascii_strcasecmp (channel->label, "BRIGHTNESS")) {
 635     value = src->capture_config.camera_parameters.brightness;
 636   } else if (!g_ascii_strcasecmp (channel->label, "CONTRAST")) {
 637     value = src->capture_config.camera_parameters.contrast;
 638   }
 639
 640   g_mutex_unlock (&src->config_lock);
 641
 642   return value;
 643 }
 644
 645 static GstColorBalanceType
 646 gst_rpi_cam_src_colorbalance_get_balance_type (GstColorBalance * balance)
 647 {
 648   return GST_COLOR_BALANCE_HARDWARE;
 649 }
 650
 651 #ifdef GST_RPI_CAM_SRC_ENABLE_VIDEO_DIRECTION
 652 static void gst_rpi_cam_src_set_orientation (GstRpiCamSrc * src, GstVideoOrientationMethod orientation)
 653 {
 654   switch (orientation) {
 655     case GST_VIDEO_ORIENTATION_IDENTITY:
 656       src->capture_config.camera_parameters.rotation = 0;
 657       src->capture_config.camera_parameters.hflip = FALSE;
 658       src->capture_config.camera_parameters.vflip = FALSE;
 659       GST_DEBUG_OBJECT (src, "set orientation identity");
 660       break;
 661     case GST_VIDEO_ORIENTATION_90R:
 662       src->capture_config.camera_parameters.rotation = 90;
 663       src->capture_config.camera_parameters.hflip = FALSE;
 664       src->capture_config.camera_parameters.vflip = FALSE;
 665       GST_DEBUG_OBJECT (src, "set orientation 90R");
 666       break;
 667     case GST_VIDEO_ORIENTATION_180:
 668       src->capture_config.camera_parameters.rotation = 180;
 669       src->capture_config.camera_parameters.hflip = FALSE;
 670       src->capture_config.camera_parameters.vflip = FALSE;
 671       GST_DEBUG_OBJECT (src, "set orientation 180");
 672       break;
 673     case GST_VIDEO_ORIENTATION_90L:
 674       src->capture_config.camera_parameters.rotation = 270;
 675       src->capture_config.camera_parameters.hflip = FALSE;
 676       src->capture_config.camera_parameters.vflip = FALSE;
 677       GST_DEBUG_OBJECT (src, "set orientation 90L");
 678       break;
 679     case GST_VIDEO_ORIENTATION_HORIZ:
 680       src->capture_config.camera_parameters.rotation = 0;
 681       src->capture_config.camera_parameters.hflip = TRUE;
 682       src->capture_config.camera_parameters.vflip = FALSE;
 683       GST_DEBUG_OBJECT (src, "set orientation hflip");
 684       break;
 685     case GST_VIDEO_ORIENTATION_VERT:
 686       src->capture_config.camera_parameters.rotation = 0;
 687       src->capture_config.camera_parameters.hflip = FALSE;
 688       src->capture_config.camera_parameters.vflip = TRUE;
 689       GST_DEBUG_OBJECT (src, "set orientation vflip");
 690       break;
 691     case GST_VIDEO_ORIENTATION_UL_LR:
 692       src->capture_config.camera_parameters.rotation = 90;
 693       src->capture_config.camera_parameters.hflip = FALSE;
 694       src->capture_config.camera_parameters.vflip = TRUE;
 695       GST_DEBUG_OBJECT (src, "set orientation trans");
 696       break;
 697     case GST_VIDEO_ORIENTATION_UR_LL:
 698       src->capture_config.camera_parameters.rotation = 270;
 699       src->capture_config.camera_parameters.hflip = FALSE;
 700       src->capture_config.camera_parameters.vflip = TRUE;
 701       GST_DEBUG_OBJECT (src, "set orientation trans");
 702       break;
 703     case GST_VIDEO_ORIENTATION_CUSTOM:
 704       break;
 705     default:
 706       GST_WARNING_OBJECT (src, "unsupported orientation %d", orientation);
 707       break;
 708   }
 709   src->orientation =
 710     orientation >= GST_VIDEO_ORIENTATION_IDENTITY &&
 711     orientation <= GST_VIDEO_ORIENTATION_CUSTOM ?
 712       orientation : GST_VIDEO_ORIENTATION_CUSTOM;
 713   src->capture_config.change_flags |= PROP_CHANGE_ORIENTATION;
 714 }
 715
 716 static void
 717 gst_rpi_cam_src_direction_init (GstVideoDirectionInterface * iface)
 718 {
 719   /* We implement the video-direction property */
 720 }
 721 #endif
 722
 723 static void
 724 gst_rpi_cam_src_colorbalance_init (GstColorBalanceInterface * iface)
 725 {
 726   iface->list_channels = gst_rpi_cam_src_colorbalance_list_channels;
 727   iface->set_value = gst_rpi_cam_src_colorbalance_set_value;
 728   iface->get_value = gst_rpi_cam_src_colorbalance_get_value;
 729   iface->get_balance_type = gst_rpi_cam_src_colorbalance_get_balance_type;
 730 }
 731
 732 static gboolean
 733 gst_rpi_cam_src_orientation_get_hflip (GstVideoOrientation * orientation, gboolean * flip)
 734 {
 735   GstRpiCamSrc *src = GST_RPICAMSRC (orientation);
 736
 737   g_return_val_if_fail (src != NULL, FALSE);
 738   g_return_val_if_fail (GST_IS_RPICAMSRC (src), FALSE);
 739
 740   g_mutex_lock (&src->config_lock);
 741   *flip = src->capture_config.camera_parameters.hflip;
 742   g_mutex_unlock (&src->config_lock);
 743
 744   return TRUE;
 745 }
 746
 747 static gboolean
 748 gst_rpi_cam_src_orientation_get_vflip (GstVideoOrientation * orientation, gboolean * flip)
 749 {
 750   GstRpiCamSrc *src = GST_RPICAMSRC (orientation);
 751
 752   g_return_val_if_fail (src != NULL, FALSE);
 753   g_return_val_if_fail (GST_IS_RPICAMSRC (src), FALSE);
 754
 755   g_mutex_lock (&src->config_lock);
 756   *flip = src->capture_config.camera_parameters.vflip;
 757   g_mutex_unlock (&src->config_lock);
 758
 759   return TRUE;
 760 }
 761
 762 static gboolean
 763 gst_rpi_cam_src_orientation_set_hflip (GstVideoOrientation * orientation, gboolean flip)
 764 {
 765   GstRpiCamSrc *src = GST_RPICAMSRC (orientation);
 766
 767   g_return_val_if_fail (src != NULL, FALSE);
 768   g_return_val_if_fail (GST_IS_RPICAMSRC (src), FALSE);
 769
 770   g_mutex_lock (&src->config_lock);
 771   gst_rpi_cam_src_reset_custom_orientation(src);
 772   src->capture_config.camera_parameters.hflip = flip;
 773   src->capture_config.change_flags |= PROP_CHANGE_ORIENTATION;
 774   g_mutex_unlock (&src->config_lock);
 775
 776   return TRUE;
 777 }
 778
 779 static gboolean
 780 gst_rpi_cam_src_orientation_set_vflip (GstVideoOrientation * orientation, gboolean flip)
 781 {
 782   GstRpiCamSrc *src = GST_RPICAMSRC (orientation);
 783
 784   g_return_val_if_fail (src != NULL, FALSE);
 785   g_return_val_if_fail (GST_IS_RPICAMSRC (src), FALSE);
 786
 787   g_mutex_lock (&src->config_lock);
 788   gst_rpi_cam_src_reset_custom_orientation(src);
 789   src->capture_config.camera_parameters.vflip = flip;
 790   src->capture_config.change_flags |= PROP_CHANGE_ORIENTATION;
 791   g_mutex_unlock (&src->config_lock);
 792
 793   return TRUE;
 794 }
 795
 796 static void
 797 gst_rpi_cam_src_orientation_init (GstVideoOrientationInterface * iface)
 798 {
 799   iface->get_hflip = gst_rpi_cam_src_orientation_get_hflip;
 800   iface->set_hflip = gst_rpi_cam_src_orientation_set_hflip;
 801   iface->get_vflip = gst_rpi_cam_src_orientation_get_vflip;
 802   iface->set_vflip = gst_rpi_cam_src_orientation_set_vflip;
 803
 804   /* TODO: hcenter / vcenter support */
 805 }
 806
 807 static void
 808 gst_rpi_cam_src_set_property (GObject * object, guint prop_id,
 809     const GValue * value, GParamSpec * pspec)
 810 {
 811   GstRpiCamSrc *src = GST_RPICAMSRC (object);
 812
 813   g_mutex_lock (&src->config_lock);
 814
 815   switch (prop_id) {
 816     case PROP_CAMERA_NUMBER:
 817       src->capture_config.cameraNum = g_value_get_int (value);
 818       break;
 819     case PROP_BITRATE:
 820       src->capture_config.bitrate = g_value_get_int (value);
 821       src->capture_config.change_flags |= PROP_CHANGE_ENCODING;
 822       break;
 823     case PROP_JPEG_QUALITY:
 824       src->capture_config.jpegQuality = g_value_get_int (value);
 825       src->capture_config.change_flags |= PROP_CHANGE_ENCODING;
 826       break;
 827     case PROP_KEYFRAME_INTERVAL:
 828       src->capture_config.intraperiod = g_value_get_int (value);
 829       src->capture_config.change_flags |= PROP_CHANGE_ENCODING;
 830       break;
 831     case PROP_PREVIEW:
 832       src->capture_config.preview_parameters.wantPreview =
 833           g_value_get_boolean (value);
 834       src->capture_config.change_flags |= PROP_CHANGE_PREVIEW;
 835       break;
 836     case PROP_PREVIEW_ENCODED:
 837       src->capture_config.immutableInput = g_value_get_boolean (value);
 838       src->capture_config.change_flags |= PROP_CHANGE_PREVIEW;
 839       break;
 840     case PROP_FULLSCREEN:
 841       src->capture_config.preview_parameters.wantFullScreenPreview =
 842           g_value_get_boolean (value);
 843       src->capture_config.change_flags |= PROP_CHANGE_PREVIEW;
 844       break;
 845     case PROP_PREVIEW_OPACITY:
 846       src->capture_config.preview_parameters.opacity = g_value_get_int (value);
 847       src->capture_config.change_flags |= PROP_CHANGE_PREVIEW;
 848       break;
 849     case PROP_PREVIEW_X:
 850       src->capture_config.preview_parameters.previewWindow.x = g_value_get_int (value);
 851       src->capture_config.change_flags |= PROP_CHANGE_PREVIEW;
 852       break;
 853     case PROP_PREVIEW_Y:
 854       src->capture_config.preview_parameters.previewWindow.y = g_value_get_int (value);
 855       src->capture_config.change_flags |= PROP_CHANGE_PREVIEW;
 856       break;
 857     case PROP_PREVIEW_W:
 858       src->capture_config.preview_parameters.previewWindow.width = g_value_get_int (value);
 859       src->capture_config.change_flags |= PROP_CHANGE_PREVIEW;
 860       break;
 861     case PROP_PREVIEW_H:
 862       src->capture_config.preview_parameters.previewWindow.height = g_value_get_int (value);
 863       src->capture_config.change_flags |= PROP_CHANGE_PREVIEW;
 864       break;
 865     case PROP_SHARPNESS:
 866       src->capture_config.camera_parameters.sharpness = g_value_get_int (value);
 867       src->capture_config.change_flags |= PROP_CHANGE_COLOURBALANCE;
 868       break;
 869     case PROP_CONTRAST:
 870       src->capture_config.camera_parameters.contrast = g_value_get_int (value);
 871       src->capture_config.change_flags |= PROP_CHANGE_COLOURBALANCE;
 872       break;
 873     case PROP_BRIGHTNESS:
 874       src->capture_config.camera_parameters.brightness =
 875           g_value_get_int (value);
 876       src->capture_config.change_flags |= PROP_CHANGE_COLOURBALANCE;
 877       break;
 878     case PROP_SATURATION:
 879       src->capture_config.camera_parameters.saturation =
 880           g_value_get_int (value);
 881       src->capture_config.change_flags |= PROP_CHANGE_COLOURBALANCE;
 882       break;
 883     case PROP_ISO:
 884       src->capture_config.camera_parameters.ISO = g_value_get_int (value);
 885       src->capture_config.change_flags |= PROP_CHANGE_SENSOR_SETTINGS;
 886       break;
 887     case PROP_VIDEO_STABILISATION:
 888       src->capture_config.camera_parameters.videoStabilisation =
 889           g_value_get_boolean (value);
 890       src->capture_config.change_flags |= PROP_CHANGE_VIDEO_STABILISATION;
 891       break;
 892     case PROP_EXPOSURE_COMPENSATION:
 893       src->capture_config.camera_parameters.exposureCompensation =
 894           g_value_get_int (value);
 895       src->capture_config.change_flags |= PROP_CHANGE_SENSOR_SETTINGS;
 896       break;
 897     case PROP_EXPOSURE_MODE:
 898       src->capture_config.camera_parameters.exposureMode =
 899           g_value_get_enum (value);
 900       src->capture_config.change_flags |= PROP_CHANGE_SENSOR_SETTINGS;
 901       break;
 902     case PROP_EXPOSURE_METERING_MODE:
 903       src->capture_config.camera_parameters.exposureMeterMode =
 904           g_value_get_enum (value);
 905       src->capture_config.change_flags |= PROP_CHANGE_SENSOR_SETTINGS;
 906       break;
 907     case PROP_ROTATION:
 908       gst_rpi_cam_src_reset_custom_orientation(src);
 909       src->capture_config.camera_parameters.rotation = g_value_get_int (value);
 910       break;
 911     case PROP_AWB_MODE:
 912       src->capture_config.camera_parameters.awbMode = g_value_get_enum (value);
 913       src->capture_config.change_flags |= PROP_CHANGE_AWB;
 914       break;
 915     case PROP_AWB_GAIN_RED:
 916       src->capture_config.camera_parameters.awb_gains_r =
 917           g_value_get_float (value);
 918       src->capture_config.change_flags |= PROP_CHANGE_AWB;
 919       break;
 920     case PROP_AWB_GAIN_BLUE:
 921       src->capture_config.camera_parameters.awb_gains_b =
 922           g_value_get_float (value);
 923       src->capture_config.change_flags |= PROP_CHANGE_AWB;
 924       break;
 925     case PROP_IMAGE_EFFECT:
 926       src->capture_config.camera_parameters.imageEffect =
 927           g_value_get_enum (value);
 928       src->capture_config.change_flags |= PROP_CHANGE_IMAGE_COLOUR_EFFECT;
 929       break;
 930     case PROP_HFLIP:
 931       gst_rpi_cam_src_reset_custom_orientation(src);
 932       src->capture_config.camera_parameters.hflip = g_value_get_boolean (value);
 933       src->capture_config.change_flags |= PROP_CHANGE_ORIENTATION;
 934       break;
 935     case PROP_VFLIP:
 936       gst_rpi_cam_src_reset_custom_orientation(src);
 937       src->capture_config.camera_parameters.vflip = g_value_get_boolean (value);
 938       src->capture_config.change_flags |= PROP_CHANGE_ORIENTATION;
 939       break;
 940     case PROP_ROI_X:
 941       src->capture_config.camera_parameters.roi.x = g_value_get_float (value);
 942       src->capture_config.change_flags |= PROP_CHANGE_ROI;
 943       break;
 944     case PROP_ROI_Y:
 945       src->capture_config.camera_parameters.roi.y = g_value_get_float (value);
 946       src->capture_config.change_flags |= PROP_CHANGE_ROI;
 947       break;
 948     case PROP_ROI_W:
 949       src->capture_config.camera_parameters.roi.w = g_value_get_float (value);
 950       src->capture_config.change_flags |= PROP_CHANGE_ROI;
 951       break;
 952     case PROP_ROI_H:
 953       src->capture_config.camera_parameters.roi.h = g_value_get_float (value);
 954       src->capture_config.change_flags |= PROP_CHANGE_ROI;
 955       break;
 956     case PROP_QUANTISATION_PARAMETER:
 957       src->capture_config.quantisationParameter = g_value_get_int (value);
 958       src->capture_config.change_flags |= PROP_CHANGE_ENCODING;
 959       break;
 960     case PROP_INLINE_HEADERS:
 961       src->capture_config.bInlineHeaders = g_value_get_boolean (value);
 962       break;
 963     case PROP_SHUTTER_SPEED:
 964       src->capture_config.camera_parameters.shutter_speed =
 965           g_value_get_int (value);
 966       src->capture_config.change_flags |= PROP_CHANGE_SENSOR_SETTINGS;
 967       break;
 968     case PROP_DRC:
 969       src->capture_config.camera_parameters.drc_level =
 970           g_value_get_enum (value);
 971       src->capture_config.change_flags |= PROP_CHANGE_SENSOR_SETTINGS;
 972       break;
 973     case PROP_SENSOR_MODE:
 974       src->capture_config.sensor_mode = g_value_get_enum (value);
 975       src->capture_config.change_flags |= PROP_CHANGE_SENSOR_SETTINGS;
 976       break;
 977     case PROP_ANNOTATION_MODE:
 978       src->capture_config.camera_parameters.enable_annotate =
 979           g_value_get_flags (value);
 980       src->capture_config.change_flags |= PROP_CHANGE_ANNOTATION;
 981       break;
 982     case PROP_ANNOTATION_TEXT:
 983       strncpy (src->capture_config.camera_parameters.annotate_string,
 984           g_value_get_string (value), MMAL_CAMERA_ANNOTATE_MAX_TEXT_LEN_V2);
 985       src->capture_config.
 986           camera_parameters.annotate_string[MMAL_CAMERA_ANNOTATE_MAX_TEXT_LEN_V2
 987           - 1] = '\0';
 988       src->capture_config.change_flags |= PROP_CHANGE_ANNOTATION;
 989       break;
 990     case PROP_ANNOTATION_TEXT_SIZE:
 991       src->capture_config.
 992           camera_parameters.annotate_text_size = g_value_get_int (value);
 993       src->capture_config.change_flags |= PROP_CHANGE_ANNOTATION;
 994       break;
 995     case PROP_ANNOTATION_TEXT_COLOUR:
 996       src->capture_config.
 997           camera_parameters.annotate_text_colour = g_value_get_int (value);
 998       src->capture_config.change_flags |= PROP_CHANGE_ANNOTATION;
 999       break;
1000     case PROP_ANNOTATION_TEXT_BG_COLOUR:
1001       src->capture_config.
1002           camera_parameters.annotate_bg_colour = g_value_get_int (value);
1003       src->capture_config.change_flags |= PROP_CHANGE_ANNOTATION;
1004       break;
1005     case PROP_INTRA_REFRESH_TYPE:
1006       src->capture_config.intra_refresh_type = g_value_get_enum (value);
1007       src->capture_config.change_flags |= PROP_CHANGE_ENCODING;
1008       break;
1009 #ifdef GST_RPI_CAM_SRC_ENABLE_VIDEO_DIRECTION
1010     case PROP_VIDEO_DIRECTION:
1011       gst_rpi_cam_src_set_orientation (src, g_value_get_enum (value));
1012       break;
1013 #endif
1014     case PROP_USE_STC:
1015       src->capture_config.useSTC = g_value_get_boolean (value);
1016       break;
1017     default:
1018       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1019       break;
1020   }
1021
1022   g_mutex_unlock (&src->config_lock);
1023 }
1024
1025 static void
1026 gst_rpi_cam_src_get_property (GObject * object, guint prop_id,
1027     GValue * value, GParamSpec * pspec)
1028 {
1029   GstRpiCamSrc *src = GST_RPICAMSRC (object);
1030
1031   g_mutex_lock (&src->config_lock);
1032   switch (prop_id) {
1033     case PROP_CAMERA_NUMBER:
1034       g_value_set_int (value, src->capture_config.cameraNum);
1035       break;
1036     case PROP_BITRATE:
1037       g_value_set_int (value, src->capture_config.bitrate);
1038       break;
1039     case PROP_JPEG_QUALITY:
1040       g_value_set_int (value, src->capture_config.jpegQuality);
1041       break;
1042     case PROP_KEYFRAME_INTERVAL:
1043       g_value_set_int (value, src->capture_config.intraperiod);
1044       break;
1045     case PROP_PREVIEW:
1046       g_value_set_boolean (value,
1047           src->capture_config.preview_parameters.wantPreview);
1048       break;
1049     case PROP_PREVIEW_ENCODED:
1050       g_value_set_boolean (value, src->capture_config.immutableInput);
1051       break;
1052     case PROP_FULLSCREEN:
1053       g_value_set_boolean (value,
1054           src->capture_config.preview_parameters.wantFullScreenPreview);
1055       break;
1056     case PROP_PREVIEW_OPACITY:
1057       g_value_set_int (value, src->capture_config.preview_parameters.opacity);
1058       break;
1059     case PROP_PREVIEW_X:
1060       g_value_set_int (value, src->capture_config.preview_parameters.previewWindow.x);
1061       break;
1062     case PROP_PREVIEW_Y:
1063       g_value_set_int (value, src->capture_config.preview_parameters.previewWindow.y);
1064       break;
1065     case PROP_PREVIEW_W:
1066       g_value_set_int (value, src->capture_config.preview_parameters.previewWindow.width);
1067       break;
1068     case PROP_PREVIEW_H:
1069       g_value_set_int (value, src->capture_config.preview_parameters.previewWindow.height);
1070       break;
1071     case PROP_SHARPNESS:
1072       g_value_set_int (value, src->capture_config.camera_parameters.sharpness);
1073       break;
1074     case PROP_CONTRAST:
1075       g_value_set_int (value, src->capture_config.camera_parameters.contrast);
1076       break;
1077     case PROP_BRIGHTNESS:
1078       g_value_set_int (value, src->capture_config.camera_parameters.brightness);
1079       break;
1080     case PROP_SATURATION:
1081       g_value_set_int (value, src->capture_config.camera_parameters.saturation);
1082       break;
1083     case PROP_ISO:
1084       g_value_set_int (value, src->capture_config.camera_parameters.ISO);
1085       break;
1086     case PROP_VIDEO_STABILISATION:
1087       g_value_set_boolean (value,
1088           ! !(src->capture_config.camera_parameters.videoStabilisation));
1089       break;
1090     case PROP_EXPOSURE_COMPENSATION:
1091       g_value_set_int (value,
1092           src->capture_config.camera_parameters.exposureCompensation);
1093       break;
1094     case PROP_EXPOSURE_MODE:
1095       g_value_set_enum (value,
1096           src->capture_config.camera_parameters.exposureMode);
1097       break;
1098     case PROP_EXPOSURE_METERING_MODE:
1099       g_value_set_enum (value,
1100           src->capture_config.camera_parameters.exposureMeterMode);
1101       break;
1102     case PROP_ROTATION:
1103       g_value_set_int (value, src->capture_config.camera_parameters.rotation);
1104       break;
1105     case PROP_AWB_MODE:
1106       g_value_set_enum (value, src->capture_config.camera_parameters.awbMode);
1107       break;
1108     case PROP_AWB_GAIN_RED:
1109       g_value_set_float (value,
1110           src->capture_config.camera_parameters.awb_gains_r);
1111       break;
1112     case PROP_AWB_GAIN_BLUE:
1113       g_value_set_float (value,
1114           src->capture_config.camera_parameters.awb_gains_b);
1115       break;
1116     case PROP_IMAGE_EFFECT:
1117       g_value_set_enum (value,
1118           src->capture_config.camera_parameters.imageEffect);
1119       break;
1120     case PROP_HFLIP:
1121       g_value_set_boolean (value,
1122           ! !(src->capture_config.camera_parameters.hflip));
1123       break;
1124     case PROP_VFLIP:
1125       g_value_set_boolean (value,
1126           ! !(src->capture_config.camera_parameters.vflip));
1127       break;
1128     case PROP_ROI_X:
1129       g_value_set_float (value, src->capture_config.camera_parameters.roi.x);
1130       break;
1131     case PROP_ROI_Y:
1132       g_value_set_float (value, src->capture_config.camera_parameters.roi.y);
1133       break;
1134     case PROP_ROI_W:
1135       g_value_set_float (value, src->capture_config.camera_parameters.roi.w);
1136       break;
1137     case PROP_ROI_H:
1138       g_value_set_float (value, src->capture_config.camera_parameters.roi.h);
1139       break;
1140     case PROP_QUANTISATION_PARAMETER:
1141       g_value_set_int (value, src->capture_config.quantisationParameter);
1142       break;
1143     case PROP_INLINE_HEADERS:
1144       g_value_set_boolean (value, src->capture_config.bInlineHeaders);
1145       break;
1146     case PROP_SHUTTER_SPEED:
1147       g_value_set_int (value,
1148           src->capture_config.camera_parameters.shutter_speed);
1149       break;
1150     case PROP_DRC:
1151       g_value_set_enum (value, src->capture_config.camera_parameters.drc_level);
1152       break;
1153     case PROP_SENSOR_MODE:
1154       g_value_set_enum (value, src->capture_config.sensor_mode);
1155       break;
1156     case PROP_ANNOTATION_MODE:
1157       g_value_set_flags (value,
1158           src->capture_config.camera_parameters.enable_annotate);
1159       break;
1160     case PROP_ANNOTATION_TEXT:
1161       g_value_set_string (value,
1162           src->capture_config.camera_parameters.annotate_string);
1163       break;
1164     case PROP_ANNOTATION_TEXT_SIZE:
1165       g_value_set_int (value, src->capture_config.camera_parameters.annotate_text_size);
1166       break;
1167     case PROP_ANNOTATION_TEXT_COLOUR:
1168       g_value_set_int (value, src->capture_config.camera_parameters.annotate_text_colour);
1169       break;
1170     case PROP_ANNOTATION_TEXT_BG_COLOUR:
1171       g_value_set_int (value, src->capture_config.camera_parameters.annotate_bg_colour);
1172       break;
1173     case PROP_INTRA_REFRESH_TYPE:
1174       g_value_set_enum (value, src->capture_config.intra_refresh_type);
1175       break;
1176 #ifdef GST_RPI_CAM_SRC_ENABLE_VIDEO_DIRECTION
1177     case PROP_VIDEO_DIRECTION:
1178       g_value_set_enum (value, src->orientation);
1179       break;
1180 #endif
1181     case PROP_USE_STC:
1182       g_value_set_boolean (value, src->capture_config.useSTC);
1183       break;
1184     default:
1185       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1186       break;
1187   }
1188   g_mutex_unlock (&src->config_lock);
1189 }
1190
1191 static gboolean
1192 gst_rpi_cam_src_start (GstBaseSrc * parent)
1193 {
1194   GstRpiCamSrc *src = GST_RPICAMSRC (parent);
1195   GST_LOG_OBJECT (src, "In src_start()");
1196   /* Ensure basesrc timestamping is off is use-stc is on */
1197   if (src->capture_config.useSTC)
1198     gst_base_src_set_do_timestamp (GST_BASE_SRC (src), FALSE);
1199   g_mutex_lock (&src->config_lock);
1200   src->capture_state = raspi_capture_setup (&src->capture_config);
1201   /* Clear all capture flags */
1202   src->capture_config.change_flags = 0;
1203   g_mutex_unlock (&src->config_lock);
1204   if (src->capture_state == NULL)
1205     return FALSE;
1206   return TRUE;
1207 }
1208
1209 static gboolean
1210 gst_rpi_cam_src_stop (GstBaseSrc * parent)
1211 {
1212   GstRpiCamSrc *src = GST_RPICAMSRC (parent);
1213   if (src->started)
1214     raspi_capture_stop (src->capture_state);
1215   raspi_capture_free (src->capture_state);
1216   src->capture_state = NULL;
1217   return TRUE;
1218 }
1219
1220 static gboolean
1221 gst_rpi_cam_src_send_event (GstElement * parent, GstEvent * event)
1222 {
1223   GstRpiCamSrc *src = GST_RPICAMSRC (parent);
1224   gboolean ret;
1225   switch (GST_EVENT_TYPE (event)) {
1226     case GST_EVENT_CUSTOM_DOWNSTREAM:
1227     case GST_EVENT_CUSTOM_UPSTREAM:
1228       if (gst_video_event_is_force_key_unit (event)) {
1229         if (src->started) {
1230           ret = raspi_capture_request_i_frame (src->capture_state);
1231         } else {
1232           ret = FALSE;
1233         }
1234         gst_event_unref (event);
1235       } else {
1236         ret = GST_ELEMENT_CLASS (parent_class)->send_event (parent, event);
1237       }
1238       break;
1239     default:
1240       ret = GST_ELEMENT_CLASS (parent_class)->send_event (parent, event);
1241       break;
1242   }
1243   return ret;
1244 }
1245
1246 static gboolean
1247 gst_rpi_cam_src_event (GstBaseSrc * parent, GstEvent * event)
1248 {
1249   GstRpiCamSrc *src = GST_RPICAMSRC (parent);
1250   gboolean ret;
1251   switch (GST_EVENT_TYPE (event)) {
1252     case GST_EVENT_CUSTOM_DOWNSTREAM:
1253     case GST_EVENT_CUSTOM_UPSTREAM:
1254       if (gst_video_event_is_force_key_unit (event)) {
1255         if (src->started) {
1256           ret = raspi_capture_request_i_frame (src->capture_state);
1257         } else {
1258           ret = FALSE;
1259         }
1260       } else {
1261         ret = GST_BASE_SRC_CLASS (parent_class)->event (parent, event);
1262       }
1263       break;
1264     default:
1265       ret = GST_BASE_SRC_CLASS (parent_class)->event (parent, event);
1266       break;
1267   }
1268   return ret;
1269 }
1270
1271 static GstCaps *
1272 gst_rpi_cam_src_get_caps (GstBaseSrc * bsrc, GstCaps * filter)
1273 {
1274   GstRpiCamSrc *src = GST_RPICAMSRC (bsrc);
1275   GstCaps *caps;
1276   gint i;
1277
1278   caps = gst_pad_get_pad_template_caps (GST_BASE_SRC_PAD (bsrc));
1279   if (src->capture_state == NULL)
1280     goto done;
1281   /* FIXME: Retrieve limiting parameters from the camera module, max width/height fps-range */
1282   caps = gst_caps_make_writable (caps);
1283   for (i = 0; i < gst_caps_get_size (caps); i++) {
1284     GstStructure *s = gst_caps_get_structure (caps, i);
1285     if (gst_structure_has_name (s, "video/x-h264")) {
1286        gst_caps_set_simple (caps, "width", GST_TYPE_INT_RANGE, 1, 1920, "height",
1287            GST_TYPE_INT_RANGE, 1, 1080, "framerate", GST_TYPE_FRACTION_RANGE, 0, 1,
1288            90, 1, NULL);
1289     }
1290     else {
1291        gst_caps_set_simple (caps, "width", GST_TYPE_INT_RANGE, 1, 3240, "height",
1292            GST_TYPE_INT_RANGE, 1, 2464, "framerate", GST_TYPE_FRACTION_RANGE, 0, 1,
1293            90, 1, NULL);
1294     }
1295   }
1296 done:
1297   GST_DEBUG_OBJECT (src, "get_caps returning %" GST_PTR_FORMAT, caps);
1298   return caps;
1299 }
1300
1301 static gboolean
1302 gst_rpi_cam_src_set_caps (GstBaseSrc * bsrc, GstCaps * caps)
1303 {
1304   GstRpiCamSrc *src = GST_RPICAMSRC (bsrc);
1305   GstVideoInfo info;
1306   GstStructure *structure;
1307   const gchar *profile_str = NULL;
1308
1309   GST_DEBUG_OBJECT (src, "In set_caps %" GST_PTR_FORMAT, caps);
1310   if (!gst_video_info_from_caps (&info, caps))
1311     return FALSE;
1312
1313   structure = gst_caps_get_structure (caps, 0);
1314   if (gst_structure_has_name (structure, "video/x-h264")) {
1315     src->capture_config.encoding = MMAL_ENCODING_H264;
1316     profile_str = gst_structure_get_string (structure, "profile");
1317     if (profile_str) {
1318       if (g_str_equal (profile_str, "baseline"))
1319         src->capture_config.profile = MMAL_VIDEO_PROFILE_H264_BASELINE;
1320       else if (g_str_equal (profile_str, "main"))
1321         src->capture_config.profile = MMAL_VIDEO_PROFILE_H264_MAIN;
1322       else if (g_str_equal (profile_str, "high"))
1323         src->capture_config.profile = MMAL_VIDEO_PROFILE_H264_HIGH;
1324       else
1325         g_warning ("Unknown profile string in rpicamsrc caps: %s", profile_str);
1326     }
1327   }
1328   else if (gst_structure_has_name (structure, "image/jpeg")) {
1329 #ifdef USE_JPEG_CODEC
1330     src->capture_config.encoding = MMAL_ENCODING_JPEG;
1331 #else
1332     src->capture_config.encoding = MMAL_ENCODING_MJPEG;
1333 #endif
1334   }
1335   else {
1336     /* Raw caps */
1337     switch (GST_VIDEO_INFO_FORMAT(&info)) {
1338     case GST_VIDEO_FORMAT_I420:
1339       src->capture_config.encoding = MMAL_ENCODING_I420;
1340       break;
1341     case GST_VIDEO_FORMAT_RGB:
1342       src->capture_config.encoding = MMAL_ENCODING_RGB24;
1343       break;
1344     case GST_VIDEO_FORMAT_BGR:
1345       src->capture_config.encoding = MMAL_ENCODING_BGR24;
1346       break;
1347     case GST_VIDEO_FORMAT_RGBA:
1348       src->capture_config.encoding = MMAL_ENCODING_RGBA;
1349       break;
1350     default:
1351       return FALSE;
1352     }
1353   }
1354
1355   src->capture_config.width = info.width;
1356   src->capture_config.height = info.height;
1357   src->capture_config.fps_n = info.fps_n;
1358   src->capture_config.fps_d = info.fps_d;
1359
1360   if (info.fps_n != 0 && info.fps_d != 0)
1361     src->duration = gst_util_uint64_scale_int (GST_SECOND, info.fps_d,
1362                         info.fps_n);
1363   else
1364     src->duration = GST_CLOCK_TIME_NONE;
1365
1366   return TRUE;
1367 }
1368
1369 static gboolean
1370 gst_rpi_cam_src_decide_allocation (GstBaseSrc * bsrc, GstQuery * query)
1371 {
1372   GST_LOG_OBJECT (bsrc, "In decide_allocation");
1373   return GST_BASE_SRC_CLASS (parent_class)->decide_allocation (bsrc, query);
1374 }
1375
1376 static GstCaps *
1377 gst_rpi_cam_src_fixate (GstBaseSrc * basesrc, GstCaps * caps)
1378 {
1379   GstStructure *structure;
1380   gint i;
1381   GST_DEBUG_OBJECT (basesrc, "fixating caps %" GST_PTR_FORMAT, caps);
1382   caps = gst_caps_make_writable (caps);
1383   for (i = 0; i < gst_caps_get_size (caps); ++i) {
1384     structure = gst_caps_get_structure (caps, i);
1385     /* Fixate to 1920x1080 resolution if possible */
1386     gst_structure_fixate_field_nearest_int (structure, "width", 1920);
1387     gst_structure_fixate_field_nearest_int (structure, "height", 1080);
1388     gst_structure_fixate_field_nearest_fraction (structure, "framerate", 30, 1);
1389     gst_structure_fixate_field (structure, "format");
1390   }
1391
1392   GST_DEBUG_OBJECT (basesrc, "fixated caps %" GST_PTR_FORMAT, caps);
1393   caps = GST_BASE_SRC_CLASS (parent_class)->fixate (basesrc, caps);
1394   return caps;
1395 }
1396
1397 static GstFlowReturn
1398 gst_rpi_cam_src_create (GstPushSrc * parent, GstBuffer ** buf)
1399 {
1400   GstRpiCamSrc *src = GST_RPICAMSRC (parent);
1401   GstFlowReturn ret;
1402   GstClock *clock = NULL;
1403   GstClockTime base_time;
1404
1405   if (!src->started) {
1406     g_mutex_lock (&src->config_lock);
1407     raspi_capture_update_config (src->capture_state, &src->capture_config, FALSE);
1408     src->capture_config.change_flags = 0;
1409     g_mutex_unlock (&src->config_lock);
1410
1411     if (!raspi_capture_start (src->capture_state))
1412       return GST_FLOW_ERROR;
1413     src->started = TRUE;
1414   }
1415
1416   GST_OBJECT_LOCK (src);
1417   if ((clock = GST_ELEMENT_CLOCK (src)) != NULL)
1418     gst_object_ref (clock);
1419   base_time = GST_ELEMENT_CAST (src)->base_time;
1420   GST_OBJECT_UNLOCK (src);
1421
1422   g_mutex_lock (&src->config_lock);
1423   if (src->capture_config.change_flags) {
1424     raspi_capture_update_config (src->capture_state, &src->capture_config, TRUE);
1425     src->capture_config.change_flags = 0;
1426   }
1427   g_mutex_unlock (&src->config_lock);
1428
1429   /* FIXME: Use custom allocator */
1430   ret = raspi_capture_fill_buffer (src->capture_state, buf, clock, base_time);
1431   if (*buf) {
1432     GST_LOG_OBJECT (src, "Made buffer of size %" G_GSIZE_FORMAT,
1433         gst_buffer_get_size (*buf));
1434     /* Only set the duration when we have a PTS update from the rpi encoder.
1435      * not every buffer is a frame */
1436     if (GST_BUFFER_PTS_IS_VALID (*buf))
1437       GST_BUFFER_DURATION (*buf) = src->duration;
1438   }
1439
1440   if (clock)
1441     gst_object_unref (clock);
1442   return ret;
1443 }
1444
1445 static gboolean
1446 plugin_init (GstPlugin * plugin)
1447 {
1448   gboolean ret;
1449   GST_DEBUG_CATEGORY_INIT (gst_rpi_cam_src_debug, "rpicamsrc",
1450       0, "rpicamsrc debug");
1451   ret = gst_element_register (plugin, "rpicamsrc", GST_RANK_NONE,
1452       GST_TYPE_RPICAMSRC);
1453 #if GST_CHECK_VERSION (1,4,0)
1454   ret &= gst_device_provider_register (plugin, "rpicamsrcdeviceprovider",
1455       GST_RANK_PRIMARY, GST_TYPE_RPICAMSRC_DEVICE_PROVIDER);
1456 #endif
1457   return ret;
1458 }
1459
1460 #ifndef PACKAGE
1461 #define PACKAGE "gstrpicamsrc"
1462 #endif
1463
1464 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
1465     GST_VERSION_MINOR,
1466     rpicamsrc,
1467     "Raspberry Pi Camera Source",
1468     plugin_init, VERSION, "LGPL", "GStreamer", "http://gstreamer.net/")