/*

 * GStreamer

 * Copyright (C) 2008 Nokia Corporation <multimedia@maemo.org>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/**

 * SECTION:gstcamerabin

 * @short_description: camera capture bin

 *

 * <refsect2>

 * <para>

 * GstCameraBin is a high-level camera object that encapsulates the gstreamer

 * internals and provides a task based API for the application. It consists of

 * three main data paths: view-finder, image capture and video capture.

 * </para>

 * <informalfigure>

 *   <mediaobject>

 *     <imageobject><imagedata fileref="camerabin.png"/></imageobject>

 *     <textobject><phrase>CameraBin structure</phrase></textobject>

 *     <caption><para>Structural decomposition of CameraBin object.</para></caption>

 *   </mediaobject>

 * </informalfigure>

 * </refsect2>

 * <refsect2>

 * <title>Example launch line</title>

 * <para>

 * <programlisting>

 * gst-launch -v -m camerabin filename=test.jpeg

 * </programlisting>

 * </para>

 * </refsect2>

 * <refsect2>

 * <title>Image capture</title>

 * <para>

 * Taking still images is initiated with the #GstCameraBin::user-start action

 * signal. Once the image has captured, #GstCameraBin::img-done signal is fired.

 * It allows to decide wheter to take another picture (burst capture, bracketing

 * shot) or stop capturing. The last captured image is shown

 * until one switches back to view finder using #GstCameraBin::user-stop action

 * signal.

 * </para>

 * <para>

 * Available resolutions can be taken from the #GstCameraBin:inputcaps property.

 * Image capture resolution can be set with #GstCameraBin::user-image-res

 * action signal.

 * </para>

 * </refsect2>

 * <refsect2>

 * <title>Video capture</title>

 * <para>

 * Video capture is started with the #GstCameraBin::user-start action signal too.

 * In addition to image capture one can use #GstCameraBin::user-pause to

 * pause recording and #GstCameraBin::user-stop to end recording.

 * </para>

 * <para>

 * Available resolutions and fps can be taken from the #GstCameraBin:inputcaps

 * property. #GstCameraBin::user-res-fps action signal can be used to set frame

 * rate and resolution for the video recording and view finder as well.

 * </para>

 * </refsect2>

 * <refsect2>

 * <title>Photography interface</title>

 * <para>

 * GstCameraBin implements gst photography interface, which can be used to set

 * and get different settings related to digital imaging. Since currently many

 * of these settings require low-level support the photography interface support

 * is dependent on video src element. In practice photography interface settings

 * cannot be used successfully until in PAUSED state when the video src has

 * opened the video device.

 * </para>

 * </refsect2>

 * <refsect2>

 * <title>States</title>

 * <para>

 * Elements within GstCameraBin are created and destroyed when switching

 * between NULL and READY states. Therefore element properties should be set

 * in NULL state. User set elements are not unreffed until GstCameraBin is

 * unreffed or replaced by a new user set element. Initially only elements needed

 * for view finder mode are created to speed up startup. Image bin and video bin

 * elements are created when setting the mode or starting capture.

 * </para>

 * </refsect2>

 * <refsect2>

 * <note>

 * <para>

 * Since the muxers tested so far have problems with discontinous buffers, QoS

 * has been disabled, and then in order to record video, you MUST ensure that

 * there is enough CPU to encode the video. Thus choose smart resolution and

 * frames per second values. It is also highly recommended to avoid color

 * conversions; make sure all the elements involved work with the same colorspace

 * (i.e. rgb or yuv i420 or whatelse).

 * </para>

 * </note>

 * </refsect2>

 */

/*

 * The pipeline in the camerabin is

 *

 *                                   "image bin"

 * videosrc ! crop ! scale ! out-sel <------> in-sel ! scale ! ffmpegcsp ! vfsink

 *                                   "video bin"

 *

 * it is possible to have 'ffmpegcolorspace' and 'capsfilter' just after

 * v4l2camsrc

 *

 * The properties of elements are:

 *

 *   vfsink - "sync", FALSE, "qos", FALSE

 *   output-selector - "resend-latest", FALSE

 *   input-selector - "select-all", TRUE

 */

/*

 * includes

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <string.h>

#include <stdlib.h>

#include <gst/gst.h>

/* FIXME: include #include <gst/gst-i18n-plugin.h> and use _(" ") */

#ifndef __SYMBIAN32__

#include <gst/gst-i18n-plugin.h>

#else

#include <gst/gst-i18n-plugin.h>

#endif

#ifdef __SYMBIAN32__

#include <gst/gstinfo.h>

#endif

#include "gstcamerabin.h"

#include "gstcamerabinxoverlay.h"

#include "gstcamerabincolorbalance.h"

#include "gstcamerabinphotography.h"

#include "camerabingeneral.h"

#include "gstcamerabin-marshal.h"

#ifdef __SYMBIAN32__

#include <glib_global.h>

#endif

/*

 * enum and types

 */

enum

{

  /* action signals */

  USER_START_SIGNAL,

  USER_STOP_SIGNAL,

  USER_PAUSE_SIGNAL,

  USER_RES_FPS_SIGNAL,

  USER_IMAGE_RES_SIGNAL,

  /* emit signals */

  IMG_DONE_SIGNAL,

  LAST_SIGNAL

};

enum

{

  ARG_0,

  ARG_FILENAME,

  ARG_MODE,

  ARG_MUTE,

  ARG_ZOOM,

  ARG_IMAGE_POST,

  ARG_IMAGE_ENC,

  ARG_VIDEO_POST,

  ARG_VIDEO_ENC,

  ARG_AUDIO_ENC,

  ARG_VIDEO_MUX,

  ARG_VF_SINK,

  ARG_VIDEO_SRC,

  ARG_AUDIO_SRC,

  ARG_INPUT_CAPS,

  ARG_FILTER_CAPS

};

/*

 * defines and static global vars

 */

static guint camerabin_signals[LAST_SIGNAL];

#define GST_TYPE_CAMERABIN_MODE (gst_camerabin_mode_get_type ())

/* default and range values for args */

#define DEFAULT_MODE MODE_IMAGE

#define DEFAULT_ZOOM 100

#define DEFAULT_WIDTH 640

#define DEFAULT_HEIGHT 480

#define DEFAULT_CAPTURE_WIDTH 800

#define DEFAULT_CAPTURE_HEIGHT 600

#define DEFAULT_FPS_N 0         /* makes it use the default */

#define DEFAULT_FPS_D 1

#define CAMERABIN_DEFAULT_VF_CAPS "video/x-raw-yuv,format=(fourcc)I420"

/* Using "bilinear" as default zoom method */

#define CAMERABIN_DEFAULT_ZOOM_METHOD 1

#define MIN_ZOOM 100

#define MAX_ZOOM 1000

#define ZOOM_1X MIN_ZOOM

#define DEFAULT_V4L2CAMSRC_DRIVER_NAME "omap3cam"

/* internal element names */

#define USE_COLOR_CONVERTER 1

/* FIXME: Make sure this can work with autovideosrc and use that. */

#define DEFAULT_SRC_VID_SRC "v4l2src"

#define DEFAULT_VIEW_SINK "autovideosink"

/*

 * static helper functions declaration

 */

static void camerabin_setup_src_elements (GstCameraBin * camera);

static gboolean camerabin_create_src_elements (GstCameraBin * camera);

static void camerabin_setup_view_elements (GstCameraBin * camera);

static gboolean camerabin_create_view_elements (GstCameraBin * camera);

static gboolean camerabin_create_elements (GstCameraBin * camera);

static void camerabin_destroy_elements (GstCameraBin * camera);

static void camerabin_dispose_elements (GstCameraBin * camera);

static void gst_camerabin_change_mode (GstCameraBin * camera, gint mode);

static void

gst_camerabin_change_filename (GstCameraBin * camera, const gchar * name);

static void gst_camerabin_setup_zoom (GstCameraBin * camera);

static GstCaps *gst_camerabin_get_allowed_input_caps (GstCameraBin * camera);

static void gst_camerabin_rewrite_tags (GstCameraBin * camera);

static void

gst_camerabin_set_capsfilter_caps (GstCameraBin * camera, GstCaps * new_caps);

static void gst_camerabin_start_image_capture (GstCameraBin * camera);

static void gst_camerabin_start_video_recording (GstCameraBin * camera);

static gboolean

gst_camerabin_have_img_buffer (GstPad * pad, GstBuffer * buffer,

    gpointer u_data);

static gboolean

gst_camerabin_have_vid_buffer (GstPad * pad, GstBuffer * buffer,

    gpointer u_data);

static void gst_camerabin_reset_to_view_finder (GstCameraBin * camera);

static void gst_camerabin_do_stop (GstCameraBin * camera);

static void

gst_camerabin_set_allowed_framerate (GstCameraBin * camera,

    GstCaps * filter_caps);

/*

 * GObject callback functions declaration

 */

static void gst_camerabin_base_init (gpointer gclass);

static void gst_camerabin_class_init (GstCameraBinClass * klass);

static void

gst_camerabin_init (GstCameraBin * camera, GstCameraBinClass * gclass);

static void gst_camerabin_dispose (GObject * object);

static void gst_camerabin_finalize (GObject * object);

static void gst_camerabin_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec);

static void gst_camerabin_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * pspec);

static const GValue *gst_camerabin_find_better_framerate (GstCameraBin * camera,

    GstStructure * st, const GValue * orig_framerate);

/*

 * GstElement function declarations

 */

static GstStateChangeReturn

gst_camerabin_change_state (GstElement * element, GstStateChange transition);

/*

 * GstBin function declarations

 */

static void

gst_camerabin_handle_message_func (GstBin * bin, GstMessage * message);

/*

 * Action signal function declarations

 */

static void gst_camerabin_user_start (GstCameraBin * camera);

static void gst_camerabin_user_stop (GstCameraBin * camera);

static void gst_camerabin_user_pause (GstCameraBin * camera);

static void

gst_camerabin_user_res_fps (GstCameraBin * camera, gint width, gint height,

    gint fps_n, gint fps_d);

static void

gst_camerabin_user_image_res (GstCameraBin * camera, gint width, gint height);

/*

 * GST BOILERPLATE and GObject types

 */

static GType

gst_camerabin_mode_get_type (void)

{

  static GType gtype = 0;

  if (gtype == 0) {

    static const GEnumValue values[] = {

      {MODE_IMAGE, "Still image capture (default)", "mode-image"},

      {MODE_VIDEO, "Video recording", "mode-video"},

      {0, NULL, NULL}

    };

    gtype = g_enum_register_static ("GstCameraBinMode", values);

  }

  return gtype;

}

static gboolean

gst_camerabin_iface_supported (GstImplementsInterface * iface, GType iface_type)

{

  GstCameraBin *camera = GST_CAMERABIN (iface);

  if (iface_type == GST_TYPE_X_OVERLAY) {

    if (camera->view_sink) {

      return GST_IS_X_OVERLAY (camera->view_sink);

    }

  } else if (iface_type == GST_TYPE_COLOR_BALANCE) {

    if (camera->src_vid_src) {

      return GST_IS_COLOR_BALANCE (camera->src_vid_src);

    }

  } else if (iface_type == GST_TYPE_TAG_SETTER) {

    /* Note: Tag setter elements aren't

       present when image and video bin in NULL */

    GstElement *setter;

    setter = gst_bin_get_by_interface (GST_BIN (camera), iface_type);

    if (setter) {

      gst_object_unref (setter);

      return TRUE;

    } else {

      return FALSE;

    }

  } else if (iface_type == GST_TYPE_PHOTOGRAPHY) {

    if (camera->src_vid_src) {

      return GST_IS_PHOTOGRAPHY (camera->src_vid_src);

    }

  }

  return FALSE;

}

static void

gst_camerabin_interface_init (GstImplementsInterfaceClass * klass)

{

  /*

   * default virtual functions

   */

  klass->supported = gst_camerabin_iface_supported;

}

static void

camerabin_init_interfaces (GType type)

{

  static const GInterfaceInfo camerabin_info = {

    (GInterfaceInitFunc) gst_camerabin_interface_init,

    NULL,

    NULL,

  };

  static const GInterfaceInfo camerabin_xoverlay_info = {

    (GInterfaceInitFunc) gst_camerabin_xoverlay_init,

    NULL,

    NULL,

  };

  static const GInterfaceInfo camerabin_color_balance_info = {

    (GInterfaceInitFunc) gst_camerabin_color_balance_init,

    NULL,

    NULL,

  };

  static const GInterfaceInfo camerabin_tagsetter_info = {

    NULL,

    NULL,

    NULL,

  };

  static const GInterfaceInfo camerabin_photography_info = {

    (GInterfaceInitFunc) gst_camerabin_photography_init,

    NULL,

    NULL,

  };

  g_type_add_interface_static (type,

      GST_TYPE_IMPLEMENTS_INTERFACE, &camerabin_info);

  g_type_add_interface_static (type, GST_TYPE_X_OVERLAY,

      &camerabin_xoverlay_info);

  g_type_add_interface_static (type, GST_TYPE_COLOR_BALANCE,

      &camerabin_color_balance_info);

  g_type_add_interface_static (type, GST_TYPE_TAG_SETTER,

      &camerabin_tagsetter_info);

  g_type_add_interface_static (type, GST_TYPE_PHOTOGRAPHY,

      &camerabin_photography_info);

}

GST_BOILERPLATE_FULL (GstCameraBin, gst_camerabin, GstPipeline,

    GST_TYPE_PIPELINE, camerabin_init_interfaces);

/*

 * static helper functions implementation

 */

/*

 * camerabin_setup_src_elements:

 * @camera: camerabin object

 *

 * This function updates camerabin capsfilters according

 * to fps, resolution and zoom that have been configured

 * to camerabin.

 */

static void

camerabin_setup_src_elements (GstCameraBin * camera)

{

  GstStructure *st;

  GstCaps *new_caps;

  gboolean detect_framerate = FALSE;

  if (!camera->view_finder_caps) {

    st = gst_structure_from_string (CAMERABIN_DEFAULT_VF_CAPS, NULL);

  } else {

    st = gst_structure_copy (gst_caps_get_structure (camera->view_finder_caps,

            0));

  }

  if (camera->width > 0 && camera->height > 0) {

    gst_structure_set (st,

        "width", G_TYPE_INT, camera->width,

        "height", G_TYPE_INT, camera->height, NULL);

  }

  if (camera->fps_n > 0 && camera->fps_d > 0) {

    if (camera->night_mode) {

      GST_WARNING_OBJECT (camera,

          "night mode, lowest allowed fps will be forced");

      camera->pre_night_fps_n = camera->fps_n;

      camera->pre_night_fps_d = camera->fps_d;

      detect_framerate = TRUE;

    } else {

      gst_structure_set (st,

          "framerate", GST_TYPE_FRACTION, camera->fps_n, camera->fps_d, NULL);

      new_caps = gst_caps_new_full (st, NULL);

    }

  } else {

    GST_DEBUG_OBJECT (camera, "no framerate specified");

    detect_framerate = TRUE;

  }

  if (detect_framerate) {

    GST_DEBUG_OBJECT (camera, "detecting allowed framerate");

    /* Remove old framerate if any */

    if (gst_structure_has_field (st, "framerate")) {

      gst_structure_remove_field (st, "framerate");

    }

    new_caps = gst_caps_new_full (st, NULL);

    /* Set allowed framerate for the resolution */

    gst_camerabin_set_allowed_framerate (camera, new_caps);

  }

  /* Set default zoom method */

  g_object_set (camera->src_zoom_scale, "method",

      CAMERABIN_DEFAULT_ZOOM_METHOD, NULL);