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) { constrained-baseline, 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 *
 214     iface);
 215 #ifdef GST_RPI_CAM_SRC_ENABLE_VIDEO_DIRECTION
 216 static void gst_rpi_cam_src_direction_init (GstVideoDirectionInterface * iface);
 217 #endif
 218
 219 static void gst_rpi_cam_src_set_property (GObject * object, guint prop_id,
 220     const GValue * value, GParamSpec * pspec);
 221 static void gst_rpi_cam_src_get_property (GObject * object, guint prop_id,
 222     GValue * value, GParamSpec * pspec);
 223 static gboolean gst_rpi_cam_src_start (GstBaseSrc * parent);
 224 static gboolean gst_rpi_cam_src_stop (GstBaseSrc * parent);
 225 static gboolean gst_rpi_cam_src_decide_allocation (GstBaseSrc * src,
 226     GstQuery * query);
 227 static GstFlowReturn gst_rpi_cam_src_create (GstPushSrc * parent,
 228     GstBuffer ** buf);
 229 static GstCaps *gst_rpi_cam_src_get_caps (GstBaseSrc * src, GstCaps * filter);
 230 static gboolean gst_rpi_cam_src_set_caps (GstBaseSrc * src, GstCaps * caps);
 231 static GstCaps *gst_rpi_cam_src_fixate (GstBaseSrc * basesrc, GstCaps * caps);
 232 static gboolean gst_rpi_cam_src_event (GstBaseSrc * src, GstEvent * event);
 233 static gboolean gst_rpi_cam_src_send_event (GstElement * element,
 234     GstEvent * event);
 235
 236 #define gst_rpi_cam_src_parent_class parent_class
 237 G_DEFINE_TYPE_WITH_CODE (GstRpiCamSrc, gst_rpi_cam_src,
 238     GST_TYPE_PUSH_SRC,
 239     G_IMPLEMENT_INTERFACE (GST_TYPE_COLOR_BALANCE,
 240         gst_rpi_cam_src_colorbalance_init);
 241 #ifdef GST_RPI_CAM_SRC_ENABLE_VIDEO_DIRECTION
 242     G_IMPLEMENT_INTERFACE (GST_TYPE_VIDEO_DIRECTION,
 243         gst_rpi_cam_src_direction_init);
 244 #endif
 245     G_IMPLEMENT_INTERFACE (GST_TYPE_VIDEO_ORIENTATION,
 246         gst_rpi_cam_src_orientation_init));
 247
 248 #define C_ENUM(v) ((gint) v)
 249
 250 static GType gst_rpi_cam_src_sensor_mode_get_type (void);
 251
 252 static GType
 253 gst_rpi_cam_src_sensor_mode_get_type (void)
 254 {
 255   static const GEnumValue values[] = {
 256     {C_ENUM (GST_RPI_CAM_SRC_SENSOR_MODE_AUTOMATIC), "Automatic", "automatic"},
 257     {C_ENUM (GST_RPI_CAM_SRC_SENSOR_MODE_1920x1080), "1920x1080 16:9 1-30fps",
 258         "1920x1080"},
 259     {C_ENUM (GST_RPI_CAM_SRC_SENSOR_MODE_2592x1944_FAST),
 260           "2592x1944 4:3 1-15fps / 3240x2464 15fps w/ v.2 board",
 261         "2592x1944-fast"},
 262     {C_ENUM (GST_RPI_CAM_SRC_SENSOR_MODE_2592x1944_SLOW),
 263           "2592x1944 4:3 0.1666-1fps / 3240x2464 15fps w/ v.2 board",
 264         "2592x1944-slow"},
 265     {C_ENUM (GST_RPI_CAM_SRC_SENSOR_MODE_1296x972), "1296x972 4:3 1-42fps",
 266         "1296x972"},
 267     {C_ENUM (GST_RPI_CAM_SRC_SENSOR_MODE_1296x730), "1296x730 16:9 1-49fps",
 268         "1296x730"},
 269     {C_ENUM (GST_RPI_CAM_SRC_SENSOR_MODE_640x480_SLOW),
 270         "640x480 4:3 42.1-60fps", "640x480-slow"},
 271     {C_ENUM (GST_RPI_CAM_SRC_SENSOR_MODE_640x480_FAST),
 272         "640x480 4:3 60.1-90fps", "640x480-fast"},
 273     {0, NULL, NULL}
 274   };
 275   static volatile GType id = 0;
 276   if (g_once_init_enter ((gsize *) & id)) {
 277     GType _id;
 278     _id = g_enum_register_static ("GstRpiCamSrcSensorMode", values);
 279     g_once_init_leave ((gsize *) & id, _id);
 280   }
 281
 282   return id;
 283 }
 284
 285
 286 static void
 287 gst_rpi_cam_src_class_init (GstRpiCamSrcClass * klass)
 288 {
 289   GObjectClass *gobject_class;
 290   GstElementClass *gstelement_class;
 291   GstBaseSrcClass *basesrc_class;
 292   GstPushSrcClass *pushsrc_class;
 293   gobject_class = (GObjectClass *) klass;
 294   gstelement_class = (GstElementClass *) klass;
 295   basesrc_class = (GstBaseSrcClass *) klass;
 296   pushsrc_class = (GstPushSrcClass *) klass;
 297
 298   gobject_class->finalize = gst_rpi_cam_src_finalize;
 299   gobject_class->set_property = gst_rpi_cam_src_set_property;
 300   gobject_class->get_property = gst_rpi_cam_src_get_property;
 301   g_object_class_install_property (gobject_class, PROP_CAMERA_NUMBER,
 302       g_param_spec_int ("camera-number", "Camera Number",
 303           "Which camera to use on a multi-camera system - 0 or 1", 0,
 304           1, CAMERA_DEFAULT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 305   g_object_class_install_property (gobject_class, PROP_BITRATE,
 306       g_param_spec_int ("bitrate", "Bitrate",
 307           "Bitrate for encoding. 0 for VBR using quantisation-parameter", 0,
 308           BITRATE_HIGHEST, BITRATE_DEFAULT,
 309           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 310 #ifdef USE_JPEG_CODEC
 311   g_object_class_install_property (gobject_class, PROP_JPEG_QUALITY,
 312       g_param_spec_int ("jpeg-quality", "JPEG Quality",
 313           "Quality setting for JPEG encode", 1, 100, DEFAULT_JPEG_QUALITY,
 314           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 315 #endif
 316   g_object_class_install_property (gobject_class, PROP_KEYFRAME_INTERVAL,
 317       g_param_spec_int ("keyframe-interval", "Keyframe Interface",
 318           "Interval (in frames) between I frames. -1 = automatic, 0 = single-keyframe",
 319           -1, G_MAXINT, KEYFRAME_INTERVAL_DEFAULT,
 320           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 321   g_object_class_install_property (gobject_class, PROP_PREVIEW,
 322       g_param_spec_boolean ("preview", "Preview Window",
 323           "Display preview window overlay", TRUE,
 324           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 325   g_object_class_install_property (gobject_class, PROP_FULLSCREEN,
 326       g_param_spec_boolean ("fullscreen", "Fullscreen Preview",
 327           "Display preview window full screen", TRUE,
 328           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 329   g_object_class_install_property (gobject_class, PROP_PREVIEW_ENCODED,
 330       g_param_spec_boolean ("preview-encoded", "Preview Encoded",
 331           "Display encoder output in the preview", TRUE,
 332           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 333   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_PREVIEW_OPACITY,
 334       g_param_spec_int ("preview-opacity", "Preview Opacity",
 335           "Opacity to use for the preview window", 0, 255, 255,
 336           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 337   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_PREVIEW_X,
 338       g_param_spec_int ("preview-x", "Preview window X position",
 339           "Start X 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_Y,
 342       g_param_spec_int ("preview-y", "Preview window Y position",
 343           "Start Y coordinate of the preview window (in pixels)", 0, 2048, 0,
 344           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 345   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_PREVIEW_W,
 346       g_param_spec_int ("preview-w", "Preview window width",
 347           "Width of the preview window (in pixels)", 0, 2048, 1024,
 348           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 349   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_PREVIEW_H,
 350       g_param_spec_int ("preview-h", "Preview window height",
 351           "Height of the preview window (in pixels)", 0, 2048, 768,
 352           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 353   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_SHARPNESS,
 354       g_param_spec_int ("sharpness", "Sharpness", "Image capture sharpness",
 355           -100, 100, SHARPNESS_DEFAULT,
 356           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 357   g_object_class_install_property (gobject_class, PROP_CONTRAST,
 358       g_param_spec_int ("contrast", "Contrast", "Image capture contrast", -100,
 359           100, CONTRAST_DEFAULT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 360   g_object_class_install_property (gobject_class, PROP_BRIGHTNESS,
 361       g_param_spec_int ("brightness", "Brightness", "Image capture brightness",
 362           0, 100, BRIGHTNESS_DEFAULT,
 363           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 364   g_object_class_install_property (gobject_class, PROP_SATURATION,
 365       g_param_spec_int ("saturation", "Saturation", "Image capture saturation",
 366           -100, 100, SATURATION_DEFAULT,
 367           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 368   g_object_class_install_property (gobject_class, PROP_ISO,
 369       g_param_spec_int ("iso", "ISO", "ISO value to use (0 = Auto)", 0, 3200, 0,
 370           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 371   g_object_class_install_property (gobject_class, PROP_VIDEO_STABILISATION,
 372       g_param_spec_boolean ("video-stabilisation", "Video Stabilisation",
 373           "Enable or disable video stabilisation", FALSE,
 374           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 375   g_object_class_install_property (gobject_class, PROP_EXPOSURE_COMPENSATION,
 376       g_param_spec_int ("exposure-compensation", "EV compensation",
 377           "Exposure Value compensation", -10, 10, 0,
 378           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 379   g_object_class_install_property (gobject_class, PROP_EXPOSURE_MODE,
 380       g_param_spec_enum ("exposure-mode", "Exposure Mode",
 381           "Camera exposure mode to use",
 382           GST_RPI_CAM_SRC_TYPE_EXPOSURE_MODE, EXPOSURE_MODE_DEFAULT,
 383           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 384   g_object_class_install_property (gobject_class, PROP_EXPOSURE_METERING_MODE,
 385       g_param_spec_enum ("metering-mode", "Exposure Metering Mode",
 386           "Camera exposure metering mode to use",
 387           GST_RPI_CAM_SRC_TYPE_EXPOSURE_METERING_MODE,
 388           EXPOSURE_METERING_MODE_DEFAULT,
 389           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 390   g_object_class_install_property (gobject_class, PROP_DRC,
 391       g_param_spec_enum ("drc", "DRC level", "Dynamic Range Control level",
 392           GST_RPI_CAM_SRC_TYPE_DRC_LEVEL, GST_RPI_CAM_SRC_DRC_LEVEL_OFF,
 393           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 394   g_object_class_install_property (gobject_class, PROP_AWB_MODE,
 395       g_param_spec_enum ("awb-mode", "Automatic White Balance Mode",
 396           "White Balance mode", GST_RPI_CAM_SRC_TYPE_AWB_MODE,
 397           GST_RPI_CAM_SRC_AWB_MODE_AUTO,
 398           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 399   g_object_class_install_property (gobject_class, PROP_AWB_GAIN_RED,
 400       g_param_spec_float ("awb-gain-red", "AWB Red Gain",
 401           "Manual AWB Gain for red 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_AWB_GAIN_BLUE,
 404       g_param_spec_float ("awb-gain-blue", "AWB Blue Gain",
 405           "Manual AWB Gain for blue channel when awb-mode=off", 0, 8.0, 0,
 406           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 407   g_object_class_install_property (gobject_class, PROP_IMAGE_EFFECT,
 408       g_param_spec_enum ("image-effect", "Image effect",
 409           "Visual FX to apply to the image",
 410           GST_RPI_CAM_SRC_TYPE_IMAGE_EFFECT,
 411           GST_RPI_CAM_SRC_IMAGEFX_NONE,
 412           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 413 #if 0
 414   PROP_IMAGE_EFFECT_PARAMS, PROP_COLOUR_EFFECTS,
 415 #endif
 416       g_object_class_install_property (gobject_class, PROP_ROTATION,
 417       g_param_spec_int ("rotation", "Rotation",
 418           "Rotate captured image (0, 90, 180, 270 degrees)", 0, 270, 0,
 419           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 420   g_object_class_install_property (gobject_class, PROP_HFLIP,
 421       g_param_spec_boolean ("hflip", "Horizontal Flip",
 422           "Flip capture horizontally", FALSE,
 423           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 424   g_object_class_install_property (gobject_class, PROP_VFLIP,
 425       g_param_spec_boolean ("vflip", "Vertical Flip",
 426           "Flip capture vertically", FALSE,
 427           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 428   g_object_class_install_property (gobject_class, PROP_ROI_X,
 429       g_param_spec_float ("roi-x", "ROI X",
 430           "Normalised region-of-interest X coord", 0, 1.0, 0,
 431           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 432   g_object_class_install_property (gobject_class, PROP_ROI_Y,
 433       g_param_spec_float ("roi-y", "ROI Y",
 434           "Normalised region-of-interest Y coord", 0, 1.0, 0,
 435           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 436   g_object_class_install_property (gobject_class, PROP_ROI_W,
 437       g_param_spec_float ("roi-w", "ROI W",
 438           "Normalised region-of-interest W coord", 0, 1.0, 1.0,
 439           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 440   g_object_class_install_property (gobject_class, PROP_ROI_H,
 441       g_param_spec_float ("roi-h", "ROI H",
 442           "Normalised region-of-interest H coord", 0, 1.0, 1.0,
 443           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 444   g_object_class_install_property (gobject_class,
 445       PROP_QUANTISATION_PARAMETER,
 446       g_param_spec_int ("quantisation-parameter",
 447           "Quantisation Parameter",
 448           "Set a Quantisation Parameter approx 10-40 with bitrate=0 for VBR encoding. 0 = off",
 449           0, G_MAXINT, QUANTISATION_DEFAULT,
 450           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 451   g_object_class_install_property (gobject_class, PROP_INLINE_HEADERS,
 452       g_param_spec_boolean ("inline-headers", "Inline Headers",
 453           "Set to TRUE to insert SPS/PPS before each IDR packet", FALSE,
 454           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 455   g_object_class_install_property (gobject_class, PROP_SHUTTER_SPEED,
 456       g_param_spec_int ("shutter-speed", "Shutter Speed",
 457           "Set a fixed shutter speed, in microseconds. (0 = Auto)", 0,
 458           6000000, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 459   g_object_class_install_property (gobject_class, PROP_SENSOR_MODE,
 460       g_param_spec_enum ("sensor-mode", "Camera Sensor Mode",
 461           "Manually set the camera sensor mode",
 462           gst_rpi_cam_src_sensor_mode_get_type (),
 463           GST_RPI_CAM_SRC_SENSOR_MODE_AUTOMATIC,
 464           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 465   g_object_class_install_property (gobject_class, PROP_ANNOTATION_MODE,
 466       g_param_spec_flags ("annotation-mode", "Annotation Mode",
 467           "Flags to control annotation of the output video",
 468           GST_RPI_CAM_SRC_TYPE_ANNOTATION_MODE, 0,
 469           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 470   g_object_class_install_property (gobject_class, PROP_ANNOTATION_TEXT,
 471       g_param_spec_string ("annotation-text", "Annotation Text",
 472           "Text string to annotate onto video when annotation-mode flags include 'custom-text'",
 473           NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 474   g_object_class_install_property (gobject_class, PROP_INTRA_REFRESH_TYPE,
 475       g_param_spec_enum ("intra-refresh-type", "Intra Refresh Type",
 476           "Type of Intra Refresh to use, -1 to disable intra refresh",
 477           GST_RPI_CAM_SRC_TYPE_INTRA_REFRESH_TYPE,
 478           GST_RPI_CAM_SRC_INTRA_REFRESH_TYPE_NONE,
 479           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 480   g_object_class_install_property (gobject_class, PROP_ANNOTATION_TEXT_SIZE,
 481       g_param_spec_int ("annotation-text-size", "Annotation text size",
 482           "Set the size of annotation text (in pixels) (0 = Auto)", 0,
 483           G_MAXINT, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 484   g_object_class_install_property (gobject_class, PROP_ANNOTATION_TEXT_COLOUR,
 485       g_param_spec_int ("annotation-text-colour",
 486           "Annotation text colour (VUY)",
 487           "Set the annotation text colour, as the integer corresponding to a VUY value eg 0x8080FF = 8421631, -1 for default",
 488           -1, G_MAXINT, -1, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 489   g_object_class_install_property (gobject_class,
 490       PROP_ANNOTATION_TEXT_BG_COLOUR,
 491       g_param_spec_int ("annotation-text-bg-colour",
 492           "Annotation text background colour (VUY)",
 493           "Set the annotation text background colour, as the integer corresponding to a VUY value eg 0x8080FF = 8421631, -1 for default",
 494           -1, G_MAXINT, -1, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 495 #ifdef GST_RPI_CAM_SRC_ENABLE_VIDEO_DIRECTION
 496   g_object_class_override_property (gobject_class, PROP_VIDEO_DIRECTION,
 497       "video-direction");
 498 #endif
 499   g_object_class_install_property (gobject_class, PROP_USE_STC,
 500       g_param_spec_boolean ("use-stc", "Use System Time Clock",
 501           "Use the camera STC for timestamping buffers", TRUE,
 502           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 503
 504   gst_element_class_set_static_metadata (gstelement_class,
 505       "Raspberry Pi Camera Source", "Source/Video",
 506       "Raspberry Pi camera module source", "Jan Schmidt <jan@centricular.com>");
 507   gst_element_class_add_pad_template (gstelement_class,
 508       gst_static_pad_template_get (&video_src_template));
 509   basesrc_class->start = GST_DEBUG_FUNCPTR (gst_rpi_cam_src_start);
 510   basesrc_class->stop = GST_DEBUG_FUNCPTR (gst_rpi_cam_src_stop);
 511   basesrc_class->decide_allocation =
 512       GST_DEBUG_FUNCPTR (gst_rpi_cam_src_decide_allocation);
 513   basesrc_class->get_caps = GST_DEBUG_FUNCPTR (gst_rpi_cam_src_get_caps);
 514   basesrc_class->set_caps = GST_DEBUG_FUNCPTR (gst_rpi_cam_src_set_caps);
 515   basesrc_class->fixate = GST_DEBUG_FUNCPTR (gst_rpi_cam_src_fixate);
 516   basesrc_class->event = GST_DEBUG_FUNCPTR (gst_rpi_cam_src_event);
 517   gstelement_class->send_event = GST_DEBUG_FUNCPTR (gst_rpi_cam_src_send_event);
 518   pushsrc_class->create = GST_DEBUG_FUNCPTR (gst_rpi_cam_src_create);
 519   raspicapture_init ();
 520 }
 521
 522 static void
 523 gst_rpi_cam_src_init (GstRpiCamSrc * src)
 524 {
 525   GstColorBalanceChannel *channel;
 526
 527   gst_base_src_set_format (GST_BASE_SRC (src), GST_FORMAT_TIME);
 528   gst_base_src_set_live (GST_BASE_SRC (src), TRUE);
 529   raspicapture_default_config (&src->capture_config);
 530   src->capture_config.intraperiod = KEYFRAME_INTERVAL_DEFAULT;
 531   src->capture_config.verbose = 1;
 532   src->capture_config.useSTC = TRUE;
 533
 534   g_mutex_init (&src->config_lock);
 535
 536   /* basesrc will generate timestamps if use-stc = false */
 537   gst_base_src_set_do_timestamp (GST_BASE_SRC (src), TRUE);
 538
 539   /* Generate the channels list */
 540   channel = g_object_new (GST_TYPE_COLOR_BALANCE_CHANNEL, NULL);
 541   channel->label = g_strdup ("CONTRAST");
 542   channel->min_value = -100;
 543   channel->max_value = 100;
 544   src->channels = g_list_append (src->channels, channel);
 545
 546   channel = g_object_new (GST_TYPE_COLOR_BALANCE_CHANNEL, NULL);
 547   channel->label = g_strdup ("BRIGHTNESS");
 548   channel->min_value = 0;
 549   channel->max_value = 100;
 550   src->channels = g_list_append (src->channels, channel);
 551
 552   channel = g_object_new (GST_TYPE_COLOR_BALANCE_CHANNEL, NULL);
 553   channel->label = g_strdup ("SATURATION");
 554   channel->min_value = -100;
 555   channel->max_value = 100;
 556   src->channels = g_list_append (src->channels, channel);
 557 }
 558
 559 static void
 560 gst_rpi_cam_src_finalize (GObject * object)
 561 {
 562   GstRpiCamSrc *src = GST_RPICAMSRC (object);
 563   GList *channels = NULL;
 564   g_mutex_clear (&src->config_lock);
 565
 566   channels = src->channels;
 567   while (channels) {
 568     GstColorBalanceChannel *channel = channels->data;
 569
 570     g_object_unref (channel);
 571     channels->data = NULL;
 572     channels = g_list_next (channels);
 573   }
 574
 575   if (src->channels)
 576     g_list_free (src->channels);
 577
 578   G_OBJECT_CLASS (gst_rpi_cam_src_parent_class)->finalize (object);
 579 }
 580
 581 static const GList *
 582 gst_rpi_cam_src_colorbalance_list_channels (GstColorBalance * balance)
 583 {
 584   GstRpiCamSrc *src = GST_RPICAMSRC (balance);
 585
 586   g_return_val_if_fail (src != NULL, NULL);
 587   g_return_val_if_fail (GST_IS_RPICAMSRC (src), NULL);
 588
 589   return src->channels;
 590 }
 591
 592 static void
 593 gst_rpi_cam_src_colorbalance_set_value (GstColorBalance * balance,
 594     GstColorBalanceChannel * channel, gint value)
 595 {
 596   GstRpiCamSrc *src = GST_RPICAMSRC (balance);
 597   gboolean changed = FALSE;
 598
 599   g_return_if_fail (src != NULL);
 600   g_return_if_fail (GST_IS_RPICAMSRC (src));
 601   g_return_if_fail (channel->label != NULL);
 602
 603   g_mutex_lock (&src->config_lock);
 604   if (!g_ascii_strcasecmp (channel->label, "SATURATION")) {
 605     changed = value != src->capture_config.camera_parameters.saturation;
 606     src->capture_config.camera_parameters.saturation = value;
 607   } else if (!g_ascii_strcasecmp (channel->label, "BRIGHTNESS")) {
 608     changed = value != src->capture_config.camera_parameters.brightness;
 609     src->capture_config.camera_parameters.brightness = value;
 610   } else if (!g_ascii_strcasecmp (channel->label, "CONTRAST")) {
 611     changed = value != src->capture_config.camera_parameters.contrast;
 612     src->capture_config.camera_parameters.contrast = value;
 613   }
 614
 615   if (changed)
 616     src->capture_config.change_flags |= PROP_CHANGE_COLOURBALANCE;
 617
 618   g_mutex_unlock (&src->config_lock);
 619
 620   if (changed) {
 621     gst_color_balance_value_changed (balance, channel,
 622         gst_color_balance_get_value (balance, channel));
 623   }
 624 }
 625
 626 static gint
 627 gst_rpi_cam_src_colorbalance_get_value (GstColorBalance * balance,
 628     GstColorBalanceChannel * channel)
 629 {
 630   GstRpiCamSrc *src = GST_RPICAMSRC (balance);
 631   gint value = 0;
 632
 633   g_return_val_if_fail (src != NULL, 0);
 634   g_return_val_if_fail (GST_IS_RPICAMSRC (src), 0);
 635   g_return_val_if_fail (channel->label != NULL, 0);
 636
 637   g_mutex_lock (&src->config_lock);
 638
 639   if (!g_ascii_strcasecmp (channel->label, "SATURATION")) {
 640     value = src->capture_config.camera_parameters.saturation;
 641   } else if (!g_ascii_strcasecmp (channel->label, "BRIGHTNESS")) {
 642     value = src->capture_config.camera_parameters.brightness;
 643   } else if (!g_ascii_strcasecmp (channel->label, "CONTRAST")) {
 644     value = src->capture_config.camera_parameters.contrast;
 645   }
 646
 647   g_mutex_unlock (&src->config_lock);
 648
 649   return value;
 650 }
 651
 652 static GstColorBalanceType
 653 gst_rpi_cam_src_colorbalance_get_balance_type (GstColorBalance * balance)
 654 {
 655   return GST_COLOR_BALANCE_HARDWARE;
 656 }
 657
 658 #ifdef GST_RPI_CAM_SRC_ENABLE_VIDEO_DIRECTION
 659 static void
 660 gst_rpi_cam_src_set_orientation (GstRpiCamSrc * src,
 661     GstVideoOrientationMethod orientation)
 662 {
 663   switch (orientation) {
 664     case GST_VIDEO_ORIENTATION_IDENTITY:
 665       src->capture_config.camera_parameters.rotation = 0;
 666       src->capture_config.camera_parameters.hflip = FALSE;
 667       src->capture_config.camera_parameters.vflip = FALSE;
 668       GST_DEBUG_OBJECT (src, "set orientation identity");
 669       break;
 670     case GST_VIDEO_ORIENTATION_90R:
 671       src->capture_config.camera_parameters.rotation = 90;
 672       src->capture_config.camera_parameters.hflip = FALSE;
 673       src->capture_config.camera_parameters.vflip = FALSE;
 674       GST_DEBUG_OBJECT (src, "set orientation 90R");
 675       break;
 676     case GST_VIDEO_ORIENTATION_180:
 677       src->capture_config.camera_parameters.rotation = 180;
 678       src->capture_config.camera_parameters.hflip = FALSE;
 679       src->capture_config.camera_parameters.vflip = FALSE;
 680       GST_DEBUG_OBJECT (src, "set orientation 180");
 681       break;
 682     case GST_VIDEO_ORIENTATION_90L:
 683       src->capture_config.camera_parameters.rotation = 270;
 684       src->capture_config.camera_parameters.hflip = FALSE;
 685       src->capture_config.camera_parameters.vflip = FALSE;
 686       GST_DEBUG_OBJECT (src, "set orientation 90L");
 687       break;
 688     case GST_VIDEO_ORIENTATION_HORIZ:
 689       src->capture_config.camera_parameters.rotation = 0;
 690       src->capture_config.camera_parameters.hflip = TRUE;
 691       src->capture_config.camera_parameters.vflip = FALSE;
 692       GST_DEBUG_OBJECT (src, "set orientation hflip");
 693       break;
 694     case GST_VIDEO_ORIENTATION_VERT:
 695       src->capture_config.camera_parameters.rotation = 0;
 696       src->capture_config.camera_parameters.hflip = FALSE;
 697       src->capture_config.camera_parameters.vflip = TRUE;
 698       GST_DEBUG_OBJECT (src, "set orientation vflip");
 699       break;
 700     case GST_VIDEO_ORIENTATION_UL_LR:
 701       src->capture_config.camera_parameters.rotation = 90;
 702       src->capture_config.camera_parameters.hflip = FALSE;
 703       src->capture_config.camera_parameters.vflip = TRUE;
 704       GST_DEBUG_OBJECT (src, "set orientation trans");
 705       break;
 706     case GST_VIDEO_ORIENTATION_UR_LL:
 707       src->capture_config.camera_parameters.rotation = 270;
 708       src->capture_config.camera_parameters.hflip = FALSE;
 709       src->capture_config.camera_parameters.vflip = TRUE;
 710       GST_DEBUG_OBJECT (src, "set orientation trans");
 711       break;
 712     case GST_VIDEO_ORIENTATION_CUSTOM:
 713       break;
 714     default:
 715       GST_WARNING_OBJECT (src, "unsupported orientation %d", orientation);
 716       break;
 717   }
 718   src->orientation =
 719       orientation >= GST_VIDEO_ORIENTATION_IDENTITY &&
 720       orientation <= GST_VIDEO_ORIENTATION_CUSTOM ?
 721       orientation : GST_VIDEO_ORIENTATION_CUSTOM;
 722   src->capture_config.change_flags |= PROP_CHANGE_ORIENTATION;
 723 }
 724
 725 static void
 726 gst_rpi_cam_src_direction_init (GstVideoDirectionInterface * iface)
 727 {
 728   /* We implement the video-direction property */
 729 }
 730 #endif
 731
 732 static void
 733 gst_rpi_cam_src_colorbalance_init (GstColorBalanceInterface * iface)
 734 {
 735   iface->list_channels = gst_rpi_cam_src_colorbalance_list_channels;
 736   iface->set_value = gst_rpi_cam_src_colorbalance_set_value;
 737   iface->get_value = gst_rpi_cam_src_colorbalance_get_value;
 738   iface->get_balance_type = gst_rpi_cam_src_colorbalance_get_balance_type;
 739 }
 740
 741 static gboolean
 742 gst_rpi_cam_src_orientation_get_hflip (GstVideoOrientation * orientation,
 743     gboolean * flip)
 744 {
 745   GstRpiCamSrc *src = GST_RPICAMSRC (orientation);
 746
 747   g_return_val_if_fail (src != NULL, FALSE);
 748   g_return_val_if_fail (GST_IS_RPICAMSRC (src), FALSE);
 749
 750   g_mutex_lock (&src->config_lock);
 751   *flip = src->capture_config.camera_parameters.hflip;
 752   g_mutex_unlock (&src->config_lock);
 753
 754   return TRUE;
 755 }
 756
 757 static gboolean
 758 gst_rpi_cam_src_orientation_get_vflip (GstVideoOrientation * orientation,
 759     gboolean * flip)
 760 {
 761   GstRpiCamSrc *src = GST_RPICAMSRC (orientation);
 762
 763   g_return_val_if_fail (src != NULL, FALSE);
 764   g_return_val_if_fail (GST_IS_RPICAMSRC (src), FALSE);
 765
 766   g_mutex_lock (&src->config_lock);
 767   *flip = src->capture_config.camera_parameters.vflip;
 768   g_mutex_unlock (&src->config_lock);
 769
 770   return TRUE;
 771 }
 772
 773 static gboolean
 774 gst_rpi_cam_src_orientation_set_hflip (GstVideoOrientation * orientation,
 775     gboolean flip)
 776 {
 777   GstRpiCamSrc *src = GST_RPICAMSRC (orientation);
 778
 779   g_return_val_if_fail (src != NULL, FALSE);
 780   g_return_val_if_fail (GST_IS_RPICAMSRC (src), FALSE);
 781
 782   g_mutex_lock (&src->config_lock);
 783   gst_rpi_cam_src_reset_custom_orientation (src);
 784   src->capture_config.camera_parameters.hflip = flip;
 785   src->capture_config.change_flags |= PROP_CHANGE_ORIENTATION;
 786   g_mutex_unlock (&src->config_lock);
 787
 788   return TRUE;
 789 }
 790
 791 static gboolean
 792 gst_rpi_cam_src_orientation_set_vflip (GstVideoOrientation * orientation,
 793     gboolean flip)
 794 {
 795   GstRpiCamSrc *src = GST_RPICAMSRC (orientation);
 796
 797   g_return_val_if_fail (src != NULL, FALSE);
 798   g_return_val_if_fail (GST_IS_RPICAMSRC (src), FALSE);
 799
 800   g_mutex_lock (&src->config_lock);
 801   gst_rpi_cam_src_reset_custom_orientation (src);
 802   src->capture_config.camera_parameters.vflip = flip;
 803   src->capture_config.change_flags |= PROP_CHANGE_ORIENTATION;
 804   g_mutex_unlock (&src->config_lock);
 805
 806   return TRUE;
 807 }
 808
 809 static void
 810 gst_rpi_cam_src_orientation_init (GstVideoOrientationInterface * iface)
 811 {
 812   iface->get_hflip = gst_rpi_cam_src_orientation_get_hflip;
 813   iface->set_hflip = gst_rpi_cam_src_orientation_set_hflip;
 814   iface->get_vflip = gst_rpi_cam_src_orientation_get_vflip;
 815   iface->set_vflip = gst_rpi_cam_src_orientation_set_vflip;
 816
 817   /* TODO: hcenter / vcenter support */
 818 }
 819
 820 static void
 821 gst_rpi_cam_src_set_property (GObject * object, guint prop_id,
 822     const GValue * value, GParamSpec * pspec)
 823 {
 824   GstRpiCamSrc *src = GST_RPICAMSRC (object);
 825
 826   g_mutex_lock (&src->config_lock);
 827
 828   switch (prop_id) {
 829     case PROP_CAMERA_NUMBER:
 830       src->capture_config.cameraNum = g_value_get_int (value);
 831       break;
 832     case PROP_BITRATE:
 833       src->capture_config.bitrate = g_value_get_int (value);
 834       src->capture_config.change_flags |= PROP_CHANGE_ENCODING;
 835       break;
 836     case PROP_JPEG_QUALITY:
 837       src->capture_config.jpegQuality = g_value_get_int (value);
 838       src->capture_config.change_flags |= PROP_CHANGE_ENCODING;
 839       break;
 840     case PROP_KEYFRAME_INTERVAL:
 841       src->capture_config.intraperiod = g_value_get_int (value);
 842       src->capture_config.change_flags |= PROP_CHANGE_ENCODING;
 843       break;
 844     case PROP_PREVIEW:
 845       src->capture_config.preview_parameters.wantPreview =
 846           g_value_get_boolean (value);
 847       src->capture_config.change_flags |= PROP_CHANGE_PREVIEW;
 848       break;
 849     case PROP_PREVIEW_ENCODED:
 850       src->capture_config.immutableInput = g_value_get_boolean (value);
 851       src->capture_config.change_flags |= PROP_CHANGE_PREVIEW;
 852       break;
 853     case PROP_FULLSCREEN:
 854       src->capture_config.preview_parameters.wantFullScreenPreview =
 855           g_value_get_boolean (value);
 856       src->capture_config.change_flags |= PROP_CHANGE_PREVIEW;
 857       break;
 858     case PROP_PREVIEW_OPACITY:
 859       src->capture_config.preview_parameters.opacity = g_value_get_int (value);
 860       src->capture_config.change_flags |= PROP_CHANGE_PREVIEW;
 861       break;
 862     case PROP_PREVIEW_X:
 863       src->capture_config.preview_parameters.previewWindow.x =
 864           g_value_get_int (value);
 865       src->capture_config.change_flags |= PROP_CHANGE_PREVIEW;
 866       break;
 867     case PROP_PREVIEW_Y:
 868       src->capture_config.preview_parameters.previewWindow.y =
 869           g_value_get_int (value);
 870       src->capture_config.change_flags |= PROP_CHANGE_PREVIEW;
 871       break;
 872     case PROP_PREVIEW_W:
 873       src->capture_config.preview_parameters.previewWindow.width =
 874           g_value_get_int (value);
 875       src->capture_config.change_flags |= PROP_CHANGE_PREVIEW;
 876       break;
 877     case PROP_PREVIEW_H:
 878       src->capture_config.preview_parameters.previewWindow.height =
 879           g_value_get_int (value);
 880       src->capture_config.change_flags |= PROP_CHANGE_PREVIEW;
 881       break;
 882     case PROP_SHARPNESS:
 883       src->capture_config.camera_parameters.sharpness = g_value_get_int (value);
 884       src->capture_config.change_flags |= PROP_CHANGE_COLOURBALANCE;
 885       break;
 886     case PROP_CONTRAST:
 887       src->capture_config.camera_parameters.contrast = g_value_get_int (value);
 888       src->capture_config.change_flags |= PROP_CHANGE_COLOURBALANCE;
 889       break;
 890     case PROP_BRIGHTNESS:
 891       src->capture_config.camera_parameters.brightness =
 892           g_value_get_int (value);
 893       src->capture_config.change_flags |= PROP_CHANGE_COLOURBALANCE;
 894       break;
 895     case PROP_SATURATION:
 896       src->capture_config.camera_parameters.saturation =
 897           g_value_get_int (value);
 898       src->capture_config.change_flags |= PROP_CHANGE_COLOURBALANCE;
 899       break;
 900     case PROP_ISO:
 901       src->capture_config.camera_parameters.ISO = g_value_get_int (value);
 902       src->capture_config.change_flags |= PROP_CHANGE_SENSOR_SETTINGS;
 903       break;
 904     case PROP_VIDEO_STABILISATION:
 905       src->capture_config.camera_parameters.videoStabilisation =
 906           g_value_get_boolean (value);
 907       src->capture_config.change_flags |= PROP_CHANGE_VIDEO_STABILISATION;
 908       break;
 909     case PROP_EXPOSURE_COMPENSATION:
 910       src->capture_config.camera_parameters.exposureCompensation =
 911           g_value_get_int (value);
 912       src->capture_config.change_flags |= PROP_CHANGE_SENSOR_SETTINGS;
 913       break;
 914     case PROP_EXPOSURE_MODE:
 915       src->capture_config.camera_parameters.exposureMode =
 916           g_value_get_enum (value);
 917       src->capture_config.change_flags |= PROP_CHANGE_SENSOR_SETTINGS;
 918       break;
 919     case PROP_EXPOSURE_METERING_MODE:
 920       src->capture_config.camera_parameters.exposureMeterMode =
 921           g_value_get_enum (value);
 922       src->capture_config.change_flags |= PROP_CHANGE_SENSOR_SETTINGS;
 923       break;
 924     case PROP_ROTATION:
 925       gst_rpi_cam_src_reset_custom_orientation (src);
 926       src->capture_config.camera_parameters.rotation = g_value_get_int (value);
 927       break;
 928     case PROP_AWB_MODE:
 929       src->capture_config.camera_parameters.awbMode = g_value_get_enum (value);
 930       src->capture_config.change_flags |= PROP_CHANGE_AWB;
 931       break;
 932     case PROP_AWB_GAIN_RED:
 933       src->capture_config.camera_parameters.awb_gains_r =
 934           g_value_get_float (value);
 935       src->capture_config.change_flags |= PROP_CHANGE_AWB;
 936       break;
 937     case PROP_AWB_GAIN_BLUE:
 938       src->capture_config.camera_parameters.awb_gains_b =
 939           g_value_get_float (value);
 940       src->capture_config.change_flags |= PROP_CHANGE_AWB;
 941       break;
 942     case PROP_IMAGE_EFFECT:
 943       src->capture_config.camera_parameters.imageEffect =
 944           g_value_get_enum (value);
 945       src->capture_config.change_flags |= PROP_CHANGE_IMAGE_COLOUR_EFFECT;
 946       break;
 947     case PROP_HFLIP:
 948       gst_rpi_cam_src_reset_custom_orientation (src);
 949       src->capture_config.camera_parameters.hflip = g_value_get_boolean (value);
 950       src->capture_config.change_flags |= PROP_CHANGE_ORIENTATION;
 951       break;
 952     case PROP_VFLIP:
 953       gst_rpi_cam_src_reset_custom_orientation (src);
 954       src->capture_config.camera_parameters.vflip = g_value_get_boolean (value);
 955       src->capture_config.change_flags |= PROP_CHANGE_ORIENTATION;
 956       break;
 957     case PROP_ROI_X:
 958       src->capture_config.camera_parameters.roi.x = g_value_get_float (value);
 959       src->capture_config.change_flags |= PROP_CHANGE_ROI;
 960       break;
 961     case PROP_ROI_Y:
 962       src->capture_config.camera_parameters.roi.y = g_value_get_float (value);
 963       src->capture_config.change_flags |= PROP_CHANGE_ROI;
 964       break;
 965     case PROP_ROI_W:
 966       src->capture_config.camera_parameters.roi.w = g_value_get_float (value);
 967       src->capture_config.change_flags |= PROP_CHANGE_ROI;
 968       break;
 969     case PROP_ROI_H:
 970       src->capture_config.camera_parameters.roi.h = g_value_get_float (value);
 971       src->capture_config.change_flags |= PROP_CHANGE_ROI;
 972       break;
 973     case PROP_QUANTISATION_PARAMETER:
 974       src->capture_config.quantisationParameter = g_value_get_int (value);
 975       src->capture_config.change_flags |= PROP_CHANGE_ENCODING;
 976       break;
 977     case PROP_INLINE_HEADERS:
 978       src->capture_config.bInlineHeaders = g_value_get_boolean (value);
 979       break;
 980     case PROP_SHUTTER_SPEED:
 981       src->capture_config.camera_parameters.shutter_speed =
 982           g_value_get_int (value);
 983       src->capture_config.change_flags |= PROP_CHANGE_SENSOR_SETTINGS;
 984       break;
 985     case PROP_DRC:
 986       src->capture_config.camera_parameters.drc_level =
 987           g_value_get_enum (value);
 988       src->capture_config.change_flags |= PROP_CHANGE_SENSOR_SETTINGS;
 989       break;
 990     case PROP_SENSOR_MODE:
 991       src->capture_config.sensor_mode = g_value_get_enum (value);
 992       src->capture_config.change_flags |= PROP_CHANGE_SENSOR_SETTINGS;
 993       break;
 994     case PROP_ANNOTATION_MODE:
 995       src->capture_config.camera_parameters.enable_annotate =
 996           g_value_get_flags (value);
 997       src->capture_config.change_flags |= PROP_CHANGE_ANNOTATION;
 998       break;
 999     case PROP_ANNOTATION_TEXT:
1000       strncpy (src->capture_config.camera_parameters.annotate_string,
1001           g_value_get_string (value), MMAL_CAMERA_ANNOTATE_MAX_TEXT_LEN_V2);
1002       src->capture_config.
1003           camera_parameters.annotate_string[MMAL_CAMERA_ANNOTATE_MAX_TEXT_LEN_V2
1004           - 1] = '\0';
1005       src->capture_config.change_flags |= PROP_CHANGE_ANNOTATION;
1006       break;
1007     case PROP_ANNOTATION_TEXT_SIZE:
1008       src->capture_config.camera_parameters.annotate_text_size =
1009           g_value_get_int (value);
1010       src->capture_config.change_flags |= PROP_CHANGE_ANNOTATION;
1011       break;
1012     case PROP_ANNOTATION_TEXT_COLOUR:
1013       src->capture_config.camera_parameters.annotate_text_colour =
1014           g_value_get_int (value);
1015       src->capture_config.change_flags |= PROP_CHANGE_ANNOTATION;
1016       break;
1017     case PROP_ANNOTATION_TEXT_BG_COLOUR:
1018       src->capture_config.camera_parameters.annotate_bg_colour =
1019           g_value_get_int (value);
1020       src->capture_config.change_flags |= PROP_CHANGE_ANNOTATION;
1021       break;
1022     case PROP_INTRA_REFRESH_TYPE:
1023       src->capture_config.intra_refresh_type = g_value_get_enum (value);
1024       src->capture_config.change_flags |= PROP_CHANGE_ENCODING;
1025       break;
1026 #ifdef GST_RPI_CAM_SRC_ENABLE_VIDEO_DIRECTION
1027     case PROP_VIDEO_DIRECTION:
1028       gst_rpi_cam_src_set_orientation (src, g_value_get_enum (value));
1029       break;
1030 #endif
1031     case PROP_USE_STC:
1032       src->capture_config.useSTC = g_value_get_boolean (value);
1033       break;
1034     default:
1035       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1036       break;
1037   }
1038
1039   g_mutex_unlock (&src->config_lock);
1040 }
1041
1042 static void
1043 gst_rpi_cam_src_get_property (GObject * object, guint prop_id,
1044     GValue * value, GParamSpec * pspec)
1045 {
1046   GstRpiCamSrc *src = GST_RPICAMSRC (object);
1047
1048   g_mutex_lock (&src->config_lock);
1049   switch (prop_id) {
1050     case PROP_CAMERA_NUMBER:
1051       g_value_set_int (value, src->capture_config.cameraNum);
1052       break;
1053     case PROP_BITRATE:
1054       g_value_set_int (value, src->capture_config.bitrate);
1055       break;
1056     case PROP_JPEG_QUALITY:
1057       g_value_set_int (value, src->capture_config.jpegQuality);
1058       break;
1059     case PROP_KEYFRAME_INTERVAL:
1060       g_value_set_int (value, src->capture_config.intraperiod);
1061       break;
1062     case PROP_PREVIEW:
1063       g_value_set_boolean (value,
1064           src->capture_config.preview_parameters.wantPreview);
1065       break;
1066     case PROP_PREVIEW_ENCODED:
1067       g_value_set_boolean (value, src->capture_config.immutableInput);
1068       break;
1069     case PROP_FULLSCREEN:
1070       g_value_set_boolean (value,
1071           src->capture_config.preview_parameters.wantFullScreenPreview);
1072       break;
1073     case PROP_PREVIEW_OPACITY:
1074       g_value_set_int (value, src->capture_config.preview_parameters.opacity);
1075       break;
1076     case PROP_PREVIEW_X:
1077       g_value_set_int (value,
1078           src->capture_config.preview_parameters.previewWindow.x);
1079       break;
1080     case PROP_PREVIEW_Y:
1081       g_value_set_int (value,
1082           src->capture_config.preview_parameters.previewWindow.y);
1083       break;
1084     case PROP_PREVIEW_W:
1085       g_value_set_int (value,
1086           src->capture_config.preview_parameters.previewWindow.width);
1087       break;
1088     case PROP_PREVIEW_H:
1089       g_value_set_int (value,
1090           src->capture_config.preview_parameters.previewWindow.height);
1091       break;
1092     case PROP_SHARPNESS:
1093       g_value_set_int (value, src->capture_config.camera_parameters.sharpness);
1094       break;
1095     case PROP_CONTRAST:
1096       g_value_set_int (value, src->capture_config.camera_parameters.contrast);
1097       break;
1098     case PROP_BRIGHTNESS:
1099       g_value_set_int (value, src->capture_config.camera_parameters.brightness);
1100       break;
1101     case PROP_SATURATION:
1102       g_value_set_int (value, src->capture_config.camera_parameters.saturation);
1103       break;
1104     case PROP_ISO:
1105       g_value_set_int (value, src->capture_config.camera_parameters.ISO);
1106       break;
1107     case PROP_VIDEO_STABILISATION:
1108       g_value_set_boolean (value,
1109           src->capture_config.camera_parameters.videoStabilisation != 0);
1110       break;
1111     case PROP_EXPOSURE_COMPENSATION:
1112       g_value_set_int (value,
1113           src->capture_config.camera_parameters.exposureCompensation);
1114       break;
1115     case PROP_EXPOSURE_MODE:
1116       g_value_set_enum (value,
1117           src->capture_config.camera_parameters.exposureMode);
1118       break;
1119     case PROP_EXPOSURE_METERING_MODE:
1120       g_value_set_enum (value,
1121           src->capture_config.camera_parameters.exposureMeterMode);
1122       break;
1123     case PROP_ROTATION:
1124       g_value_set_int (value, src->capture_config.camera_parameters.rotation);
1125       break;
1126     case PROP_AWB_MODE:
1127       g_value_set_enum (value, src->capture_config.camera_parameters.awbMode);
1128       break;
1129     case PROP_AWB_GAIN_RED:
1130       g_value_set_float (value,
1131           src->capture_config.camera_parameters.awb_gains_r);
1132       break;
1133     case PROP_AWB_GAIN_BLUE:
1134       g_value_set_float (value,
1135           src->capture_config.camera_parameters.awb_gains_b);
1136       break;
1137     case PROP_IMAGE_EFFECT:
1138       g_value_set_enum (value,
1139           src->capture_config.camera_parameters.imageEffect);
1140       break;
1141     case PROP_HFLIP:
1142       g_value_set_boolean (value,
1143           src->capture_config.camera_parameters.hflip != 0);
1144       break;
1145     case PROP_VFLIP:
1146       g_value_set_boolean (value,
1147           src->capture_config.camera_parameters.vflip != 0);
1148       break;
1149     case PROP_ROI_X:
1150       g_value_set_float (value, src->capture_config.camera_parameters.roi.x);
1151       break;
1152     case PROP_ROI_Y:
1153       g_value_set_float (value, src->capture_config.camera_parameters.roi.y);
1154       break;
1155     case PROP_ROI_W:
1156       g_value_set_float (value, src->capture_config.camera_parameters.roi.w);
1157       break;
1158     case PROP_ROI_H:
1159       g_value_set_float (value, src->capture_config.camera_parameters.roi.h);
1160       break;
1161     case PROP_QUANTISATION_PARAMETER:
1162       g_value_set_int (value, src->capture_config.quantisationParameter);
1163       break;
1164     case PROP_INLINE_HEADERS:
1165       g_value_set_boolean (value, src->capture_config.bInlineHeaders);
1166       break;
1167     case PROP_SHUTTER_SPEED:
1168       g_value_set_int (value,
1169           src->capture_config.camera_parameters.shutter_speed);
1170       break;
1171     case PROP_DRC:
1172       g_value_set_enum (value, src->capture_config.camera_parameters.drc_level);
1173       break;
1174     case PROP_SENSOR_MODE:
1175       g_value_set_enum (value, src->capture_config.sensor_mode);
1176       break;
1177     case PROP_ANNOTATION_MODE:
1178       g_value_set_flags (value,
1179           src->capture_config.camera_parameters.enable_annotate);
1180       break;
1181     case PROP_ANNOTATION_TEXT:
1182       g_value_set_string (value,
1183           src->capture_config.camera_parameters.annotate_string);
1184       break;
1185     case PROP_ANNOTATION_TEXT_SIZE:
1186       g_value_set_int (value,
1187           src->capture_config.camera_parameters.annotate_text_size);
1188       break;
1189     case PROP_ANNOTATION_TEXT_COLOUR:
1190       g_value_set_int (value,
1191           src->capture_config.camera_parameters.annotate_text_colour);
1192       break;
1193     case PROP_ANNOTATION_TEXT_BG_COLOUR:
1194       g_value_set_int (value,
1195           src->capture_config.camera_parameters.annotate_bg_colour);
1196       break;
1197     case PROP_INTRA_REFRESH_TYPE:
1198       g_value_set_enum (value, src->capture_config.intra_refresh_type);
1199       break;
1200 #ifdef GST_RPI_CAM_SRC_ENABLE_VIDEO_DIRECTION
1201     case PROP_VIDEO_DIRECTION:
1202       g_value_set_enum (value, src->orientation);
1203       break;
1204 #endif
1205     case PROP_USE_STC:
1206       g_value_set_boolean (value, src->capture_config.useSTC);
1207       break;
1208     default:
1209       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1210       break;
1211   }
1212   g_mutex_unlock (&src->config_lock);
1213 }
1214
1215 static gboolean
1216 gst_rpi_cam_src_start (GstBaseSrc * parent)
1217 {
1218   GstRpiCamSrc *src = GST_RPICAMSRC (parent);
1219   GST_LOG_OBJECT (src, "In src_start()");
1220   /* Ensure basesrc timestamping is off is use-stc is on */
1221   if (src->capture_config.useSTC)
1222     gst_base_src_set_do_timestamp (GST_BASE_SRC (src), FALSE);
1223   g_mutex_lock (&src->config_lock);
1224   src->capture_state = raspi_capture_setup (&src->capture_config);
1225   /* Clear all capture flags */
1226   src->capture_config.change_flags = 0;
1227   g_mutex_unlock (&src->config_lock);
1228   if (src->capture_state == NULL)
1229     return FALSE;
1230   return TRUE;
1231 }
1232
1233 static gboolean
1234 gst_rpi_cam_src_stop (GstBaseSrc * parent)
1235 {
1236   GstRpiCamSrc *src = GST_RPICAMSRC (parent);
1237   if (src->started)
1238     raspi_capture_stop (src->capture_state);
1239   raspi_capture_free (src->capture_state);
1240   src->capture_state = NULL;
1241   return TRUE;
1242 }
1243
1244 static gboolean
1245 gst_rpi_cam_src_send_event (GstElement * parent, GstEvent * event)
1246 {
1247   GstRpiCamSrc *src = GST_RPICAMSRC (parent);
1248   gboolean ret;
1249   switch (GST_EVENT_TYPE (event)) {
1250     case GST_EVENT_CUSTOM_DOWNSTREAM:
1251     case GST_EVENT_CUSTOM_UPSTREAM:
1252       if (gst_video_event_is_force_key_unit (event)) {
1253         if (src->started) {
1254           ret = raspi_capture_request_i_frame (src->capture_state);
1255         } else {
1256           ret = FALSE;
1257         }
1258         gst_event_unref (event);
1259       } else {
1260         ret = GST_ELEMENT_CLASS (parent_class)->send_event (parent, event);
1261       }
1262       break;
1263     default:
1264       ret = GST_ELEMENT_CLASS (parent_class)->send_event (parent, event);
1265       break;
1266   }
1267   return ret;
1268 }
1269
1270 static gboolean
1271 gst_rpi_cam_src_event (GstBaseSrc * parent, GstEvent * event)
1272 {
1273   GstRpiCamSrc *src = GST_RPICAMSRC (parent);
1274   gboolean ret;
1275   switch (GST_EVENT_TYPE (event)) {
1276     case GST_EVENT_CUSTOM_DOWNSTREAM:
1277     case GST_EVENT_CUSTOM_UPSTREAM:
1278       if (gst_video_event_is_force_key_unit (event)) {
1279         if (src->started) {
1280           ret = raspi_capture_request_i_frame (src->capture_state);
1281         } else {
1282           ret = FALSE;
1283         }
1284       } else {
1285         ret = GST_BASE_SRC_CLASS (parent_class)->event (parent, event);
1286       }
1287       break;
1288     default:
1289       ret = GST_BASE_SRC_CLASS (parent_class)->event (parent, event);
1290       break;
1291   }
1292   return ret;
1293 }
1294
1295 static GstCaps *
1296 gst_rpi_cam_src_get_caps (GstBaseSrc * bsrc, GstCaps * filter)
1297 {
1298   GstRpiCamSrc *src = GST_RPICAMSRC (bsrc);
1299   GstCaps *caps;
1300   gint i;
1301
1302   caps = gst_pad_get_pad_template_caps (GST_BASE_SRC_PAD (bsrc));
1303   if (src->capture_state == NULL)
1304     goto done;
1305   /* FIXME: Retrieve limiting parameters from the camera module, max width/height fps-range */
1306   caps = gst_caps_make_writable (caps);
1307   for (i = 0; i < gst_caps_get_size (caps); i++) {
1308     GstStructure *s = gst_caps_get_structure (caps, i);
1309     if (gst_structure_has_name (s, "video/x-h264")) {
1310       gst_caps_set_simple (caps, "width", GST_TYPE_INT_RANGE, 1, 1920, "height",
1311           GST_TYPE_INT_RANGE, 1, 1080, "framerate", GST_TYPE_FRACTION_RANGE, 0,
1312           1, RPICAMSRC_MAX_FPS, 1, NULL);
1313     } else {
1314       gst_caps_set_simple (caps, "width", GST_TYPE_INT_RANGE, 1, 3240, "height",
1315           GST_TYPE_INT_RANGE, 1, 2464, "framerate", GST_TYPE_FRACTION_RANGE, 0,
1316           1, RPICAMSRC_MAX_FPS, 1, NULL);
1317     }
1318   }
1319 done:
1320   GST_DEBUG_OBJECT (src, "get_caps returning %" GST_PTR_FORMAT, caps);
1321   return caps;
1322 }
1323
1324 static gboolean
1325 gst_rpi_cam_src_set_caps (GstBaseSrc * bsrc, GstCaps * caps)
1326 {
1327   GstRpiCamSrc *src = GST_RPICAMSRC (bsrc);
1328   GstVideoInfo info;
1329   GstStructure *structure;
1330   const gchar *profile_str = NULL;
1331
1332   GST_DEBUG_OBJECT (src, "In set_caps %" GST_PTR_FORMAT, caps);
1333   if (!gst_video_info_from_caps (&info, caps))
1334     return FALSE;
1335
1336   structure = gst_caps_get_structure (caps, 0);
1337   if (gst_structure_has_name (structure, "video/x-h264")) {
1338     src->capture_config.encoding = MMAL_ENCODING_H264;
1339     profile_str = gst_structure_get_string (structure, "profile");
1340     if (profile_str) {
1341       if (g_str_equal (profile_str, "baseline"))
1342         src->capture_config.profile = MMAL_VIDEO_PROFILE_H264_BASELINE;
1343       else if (g_str_equal (profile_str, "constrained-baseline"))
1344         src->capture_config.profile =
1345             MMAL_VIDEO_PROFILE_H264_CONSTRAINED_BASELINE;
1346       else if (g_str_equal (profile_str, "main"))
1347         src->capture_config.profile = MMAL_VIDEO_PROFILE_H264_MAIN;
1348       else if (g_str_equal (profile_str, "high"))
1349         src->capture_config.profile = MMAL_VIDEO_PROFILE_H264_HIGH;
1350       else
1351         g_warning ("Unknown profile string in rpicamsrc caps: %s", profile_str);
1352     }
1353   } else if (gst_structure_has_name (structure, "image/jpeg")) {
1354 #ifdef USE_JPEG_CODEC
1355     src->capture_config.encoding = MMAL_ENCODING_JPEG;
1356 #else
1357     src->capture_config.encoding = MMAL_ENCODING_MJPEG;
1358 #endif
1359   } else {
1360     /* Raw caps */
1361     switch (GST_VIDEO_INFO_FORMAT (&info)) {
1362       case GST_VIDEO_FORMAT_I420:
1363         src->capture_config.encoding = MMAL_ENCODING_I420;
1364         break;
1365       case GST_VIDEO_FORMAT_RGB:
1366         src->capture_config.encoding = MMAL_ENCODING_RGB24;
1367         break;
1368       case GST_VIDEO_FORMAT_BGR:
1369         src->capture_config.encoding = MMAL_ENCODING_BGR24;
1370         break;
1371       case GST_VIDEO_FORMAT_RGBA:
1372         src->capture_config.encoding = MMAL_ENCODING_RGBA;
1373         break;
1374       default:
1375         return FALSE;
1376     }
1377   }
1378
1379   src->capture_config.width = info.width;
1380   src->capture_config.height = info.height;
1381   src->capture_config.fps_n = info.fps_n;
1382   src->capture_config.fps_d = info.fps_d;
1383
1384   if (info.fps_n != 0 && info.fps_d != 0)
1385     src->duration = gst_util_uint64_scale_int (GST_SECOND, info.fps_d,
1386         info.fps_n);
1387   else
1388     src->duration = GST_CLOCK_TIME_NONE;
1389
1390   return TRUE;
1391 }
1392
1393 static gboolean
1394 gst_rpi_cam_src_decide_allocation (GstBaseSrc * bsrc, GstQuery * query)
1395 {
1396   GST_LOG_OBJECT (bsrc, "In decide_allocation");
1397   return GST_BASE_SRC_CLASS (parent_class)->decide_allocation (bsrc, query);
1398 }
1399
1400 static GstCaps *
1401 gst_rpi_cam_src_fixate (GstBaseSrc * basesrc, GstCaps * caps)
1402 {
1403   GstStructure *structure;
1404   gint i;
1405   GST_DEBUG_OBJECT (basesrc, "fixating caps %" GST_PTR_FORMAT, caps);
1406   caps = gst_caps_make_writable (caps);
1407   for (i = 0; i < gst_caps_get_size (caps); ++i) {
1408     structure = gst_caps_get_structure (caps, i);
1409     /* Fixate to 1920x1080 resolution if possible */
1410     gst_structure_fixate_field_nearest_int (structure, "width", 1920);
1411     gst_structure_fixate_field_nearest_int (structure, "height", 1080);
1412     gst_structure_fixate_field_nearest_fraction (structure, "framerate", 30, 1);
1413     gst_structure_fixate_field (structure, "format");
1414   }
1415
1416   GST_DEBUG_OBJECT (basesrc, "fixated caps %" GST_PTR_FORMAT, caps);
1417   caps = GST_BASE_SRC_CLASS (parent_class)->fixate (basesrc, caps);
1418   return caps;
1419 }
1420
1421 static GstFlowReturn
1422 gst_rpi_cam_src_create (GstPushSrc * parent, GstBuffer ** buf)
1423 {
1424   GstRpiCamSrc *src = GST_RPICAMSRC (parent);
1425   GstFlowReturn ret;
1426   GstClock *clock = NULL;
1427   GstClockTime base_time;
1428
1429   if (!src->started) {
1430     g_mutex_lock (&src->config_lock);
1431     raspi_capture_update_config (src->capture_state, &src->capture_config,
1432         FALSE);
1433     src->capture_config.change_flags = 0;
1434     g_mutex_unlock (&src->config_lock);
1435
1436     if (!raspi_capture_start (src->capture_state))
1437       return GST_FLOW_ERROR;
1438     src->started = TRUE;
1439   }
1440
1441   GST_OBJECT_LOCK (src);
1442   if ((clock = GST_ELEMENT_CLOCK (src)) != NULL)
1443     gst_object_ref (clock);
1444   base_time = GST_ELEMENT_CAST (src)->base_time;
1445   GST_OBJECT_UNLOCK (src);
1446
1447   g_mutex_lock (&src->config_lock);
1448   if (src->capture_config.change_flags) {
1449     raspi_capture_update_config (src->capture_state, &src->capture_config,
1450         TRUE);
1451     src->capture_config.change_flags = 0;
1452   }
1453   g_mutex_unlock (&src->config_lock);
1454
1455   /* FIXME: Use custom allocator */
1456   ret = raspi_capture_fill_buffer (src->capture_state, buf, clock, base_time);
1457   if (*buf) {
1458     GST_LOG_OBJECT (src, "Made buffer of size %" G_GSIZE_FORMAT,
1459         gst_buffer_get_size (*buf));
1460     /* Only set the duration when we have a PTS update from the rpi encoder.
1461      * not every buffer is a frame */
1462     if (GST_BUFFER_PTS_IS_VALID (*buf))
1463       GST_BUFFER_DURATION (*buf) = src->duration;
1464   }
1465
1466   if (ret == GST_FLOW_ERROR_TIMEOUT) {
1467     GST_ELEMENT_ERROR (src, STREAM, FAILED,
1468         ("Camera capture timed out."),
1469         ("Waiting for a buffer from the camera took too long."));
1470     ret = GST_FLOW_ERROR;
1471   }
1472
1473   if (clock)
1474     gst_object_unref (clock);
1475   return ret;
1476 }
1477
1478 static gboolean
1479 plugin_init (GstPlugin * plugin)
1480 {
1481   gboolean ret;
1482
1483   GST_DEBUG_CATEGORY_INIT (gst_rpi_cam_src_debug, "rpicamsrc",
1484       0, "rpicamsrc debug");
1485
1486   ret = gst_element_register (plugin, "rpicamsrc", GST_RANK_NONE,
1487       GST_TYPE_RPICAMSRC);
1488
1489   ret &= gst_device_provider_register (plugin, "rpicamsrcdeviceprovider",
1490       GST_RANK_PRIMARY, GST_TYPE_RPICAMSRC_DEVICE_PROVIDER);
1491
1492   return ret;
1493 }
1494
1495 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
1496     GST_VERSION_MINOR,
1497     rpicamsrc,
1498     "Raspberry Pi Camera Source",
1499     plugin_init, VERSION, GST_LICENSE, GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)