/* GStreamer encoding bin

 * Copyright (C) 2009 Edward Hervey <edward.hervey@collabora.co.uk>

 *           (C) 2009 Nokia Corporation

 *

 * 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., 51 Franklin St, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <string.h>

#include "gstencodebin.h"

#include "gstsmartencoder.h"

#include "gststreamsplitter.h"

#include "gststreamcombiner.h"

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

/**

 * SECTION:element-encodebin

 * @title: encodebin

 *

 * EncodeBin provides a bin for encoding/muxing various streams according to

 * a specified #GstEncodingProfile.

 *

 * Based on the profile that was set (via the #GstEncodeBin:profile property),

 * EncodeBin will internally select and configure the required elements

 * (encoders, muxers, but also audio and video converters) so that you can

 * provide it raw or pre-encoded streams of data in input and have your

 * encoded/muxed/converted stream in output.

 *

 * ## Features

 *

 * * Automatic encoder and muxer selection based on elements available on the

 * system.

 *

 * * Conversion of raw audio/video streams (scaling, framerate conversion,

 * colorspace conversion, samplerate conversion) to conform to the profile

 * output format.

 *

 * * Variable number of streams. If the presence property for a stream encoding

 * profile is 0, you can request any number of sink pads for it via the

 * standard request pad gstreamer API or the #GstEncodeBin::request-pad action

 * signal.

 *

 * * Avoid reencoding (passthrough). If the input stream is already encoded and is

 * compatible with what the #GstEncodingProfile expects, then the stream won't

 * be re-encoded but just passed through downstream to the muxer or the output.

 *

 * * Mix pre-encoded and raw streams as input. In addition to the passthrough

 * feature above, you can feed both raw audio/video *AND* already-encoded data

 * to a pad. #GstEncodeBin will take care of passing through the compatible

 * segments and re-encoding the segments of media that need encoding.

 *

 * * Standard behaviour is to use a #GstEncodingContainerProfile to have both

 * encoding and muxing performed. But you can also provide a single stream

 * profile (like #GstEncodingAudioProfile) to only have the encoding done and

 * handle the encoded output yourself.

 *

 * * Audio imperfection corrections. Incoming audio streams can have non perfect

 * timestamps (jitter), like the streams coming from ASF files. #GstEncodeBin

 * will automatically fix those imperfections for you. See

 * #GstEncodeBin:audio-jitter-tolerance for more details.

 *

 * * Variable or Constant video framerate. If your #GstEncodingVideoProfile has

 * the variableframerate property deactivated (default), then the incoming

 * raw video stream will be retimestampped in order to produce a constant

 * framerate.

 *

 * * Cross-boundary re-encoding. When feeding compatible pre-encoded streams that

 * fall on segment boundaries, and for supported formats (right now only H263),

 * the GOP will be decoded/reencoded when needed to produce an encoded output

 * that fits exactly within the request GstSegment.

 *

 * * Missing plugin support. If a #GstElement is missing to encode/mux to the

 * request profile formats, a missing-plugin #GstMessage will be posted on the

 * #GstBus, allowing systems that support the missing-plugin system to offer the

 * user a way to install the missing element.

 *

 */

/* TODO/FIXME

 *

 * Handling mp3!xing!idv3 and theora!ogg tagsetting scenarios:

 *  Once we have chosen a muxer:

 *   When a new stream is requested:

 *    If muxer isn't 'Formatter' OR doesn't have a TagSetter interface:

 *      Find a Formatter for the given stream (preferably with TagSetter)

 *       Insert that before muxer

 **/

#define fast_pad_link(a,b) gst_pad_link_full((a),(b),GST_PAD_LINK_CHECK_NOTHING)

#define fast_element_link(a,b) gst_element_link_pads_full((a),"src",(b),"sink",GST_PAD_LINK_CHECK_NOTHING)

typedef enum

{

  GST_ENCODEBIN_FLAG_NO_AUDIO_CONVERSION = (1 << 0),

  GST_ENCODEBIN_FLAG_NO_VIDEO_CONVERSION = (1 << 1)

} GstEncodeBinFlags;

#define GST_TYPE_ENCODEBIN_FLAGS (gst_encodebin_flags_get_type())

GType gst_encodebin_flags_get_type (void);

/* generic templates */

static GstStaticPadTemplate muxer_src_template =

GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC, GST_PAD_ALWAYS,

    GST_STATIC_CAPS_ANY);

static GstStaticPadTemplate video_sink_template =

GST_STATIC_PAD_TEMPLATE ("video_%u",

    GST_PAD_SINK,

    GST_PAD_REQUEST,

    GST_STATIC_CAPS_ANY);

static GstStaticPadTemplate audio_sink_template =

GST_STATIC_PAD_TEMPLATE ("audio_%u",

    GST_PAD_SINK,

    GST_PAD_REQUEST,

    GST_STATIC_CAPS_ANY);

/* static GstStaticPadTemplate text_sink_template = */

/* GST_STATIC_PAD_TEMPLATE ("text_%u", */

/*     GST_PAD_SINK, */

/*     GST_PAD_REQUEST, */

/*     GST_STATIC_CAPS_ANY); */

static GstStaticPadTemplate private_sink_template =

GST_STATIC_PAD_TEMPLATE ("private_%u",

    GST_PAD_SINK,

    GST_PAD_REQUEST,

    GST_STATIC_CAPS_ANY);

struct _GstEncodeBin

{

  GstBin parent;

  /* the profile field is only valid if it could be entirely setup */

  GstEncodingProfile *profile;

  GList *streams;               /* List of StreamGroup, not sorted */

  GstElement *muxer;

  /* Ghostpad with changing target */

  GstPad *srcpad;

  /* TRUE if in PAUSED/PLAYING */

  gboolean active;

  /* available muxers, encoders and parsers */

  GList *muxers;

  GList *formatters;

  GList *encoders;

  GList *parsers;

  /* Increasing counter for unique pad name */

  guint last_pad_id;

  /* Cached caps for identification */

  GstCaps *raw_video_caps;

  GstCaps *raw_audio_caps;

  /* GstCaps *raw_text_caps; */

  guint queue_buffers_max;

  guint queue_bytes_max;

  guint64 queue_time_max;

  guint64 tolerance;

  gboolean avoid_reencoding;

  GstEncodeBinFlags flags;

};

struct _GstEncodeBinClass

{

  GstBinClass parent;

  /* Action Signals */

  GstPad *(*request_pad) (GstEncodeBin * encodebin, GstCaps * caps);

  GstPad *(*request_profile_pad) (GstEncodeBin * encodebin,

      const gchar * profilename);

};

typedef struct _StreamGroup StreamGroup;

struct _StreamGroup

{

  GstEncodeBin *ebin;

  GstEncodingProfile *profile;

  GstPad *ghostpad;             /* Sink ghostpad */

  GstElement *inqueue;          /* Queue just after the ghostpad */

  GstElement *splitter;

  GList *converters;            /* List of conversion GstElement */

  GstElement *capsfilter;       /* profile->restriction (if non-NULL/ANY) */

  gulong inputfilter_caps_sid;

  GstElement *encoder;          /* Encoder (can be NULL) */

  GstElement *fakesink;         /* Fakesink (can be NULL) */

  GstElement *combiner;

  GstElement *parser;

  GstElement *smartencoder;

  GstElement *outfilter;        /* Output capsfilter (streamprofile.format) */

  gulong outputfilter_caps_sid;

  GstElement *formatter;

  GstElement *outqueue;         /* Queue just before the muxer */

  gulong restriction_sid;

};

/* Default for queues (same defaults as queue element) */

#define DEFAULT_QUEUE_BUFFERS_MAX  200

#define DEFAULT_QUEUE_BYTES_MAX    10 * 1024 * 1024

#define DEFAULT_QUEUE_TIME_MAX     GST_SECOND

#define DEFAULT_AUDIO_JITTER_TOLERANCE 20 * GST_MSECOND

#define DEFAULT_AVOID_REENCODING   FALSE

#define DEFAULT_FLAGS              0

#define DEFAULT_RAW_CAPS			\

  "video/x-raw; "				\

  "audio/x-raw; "				\

  "text/x-raw; "				\

  "subpicture/x-dvd; "			\

  "subpicture/x-pgs"

/* Properties */

enum

{

  PROP_0,

  PROP_PROFILE,

  PROP_QUEUE_BUFFERS_MAX,

  PROP_QUEUE_BYTES_MAX,

  PROP_QUEUE_TIME_MAX,

  PROP_AUDIO_JITTER_TOLERANCE,

  PROP_AVOID_REENCODING,

  PROP_FLAGS

};

/* Signals */

enum

{

  SIGNAL_REQUEST_PAD,

  SIGNAL_REQUEST_PROFILE_PAD,

  LAST_SIGNAL

};

#define C_FLAGS(v) ((guint) v)

GType

gst_encodebin_flags_get_type (void)

{

  static const GFlagsValue values[] = {

    {C_FLAGS (GST_ENCODEBIN_FLAG_NO_AUDIO_CONVERSION), "Do not use audio "

          "conversion elements", "no-audio-conversion"},

    {C_FLAGS (GST_ENCODEBIN_FLAG_NO_VIDEO_CONVERSION), "Do not use video "

          "conversion elements", "no-video-conversion"},

    {0, NULL, NULL}

  };

  static volatile GType id = 0;

  if (g_once_init_enter ((gsize *) & id)) {

    GType _id;

    _id = g_flags_register_static ("GstEncodeBinFlags", values);

    g_once_init_leave ((gsize *) & id, _id);

  }

  return id;

}

static guint gst_encode_bin_signals[LAST_SIGNAL] = { 0 };

static GstStaticCaps default_raw_caps = GST_STATIC_CAPS (DEFAULT_RAW_CAPS);

GST_DEBUG_CATEGORY_STATIC (gst_encode_bin_debug);

#define GST_CAT_DEFAULT gst_encode_bin_debug

G_DEFINE_TYPE (GstEncodeBin, gst_encode_bin, GST_TYPE_BIN);

static void gst_encode_bin_dispose (GObject * object);

static void gst_encode_bin_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec);

static void gst_encode_bin_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * pspec);

static GstStateChangeReturn gst_encode_bin_change_state (GstElement * element,

    GstStateChange transition);

static GstPad *gst_encode_bin_request_new_pad (GstElement * element,

    GstPadTemplate * templ, const gchar * name, const GstCaps * caps);

static void gst_encode_bin_release_pad (GstElement * element, GstPad * pad);

static gboolean

gst_encode_bin_set_profile (GstEncodeBin * ebin, GstEncodingProfile * profile);

static void gst_encode_bin_tear_down_profile (GstEncodeBin * ebin);

static gboolean gst_encode_bin_setup_profile (GstEncodeBin * ebin,

    GstEncodingProfile * profile);

static StreamGroup *_create_stream_group (GstEncodeBin * ebin,

    GstEncodingProfile * sprof, const gchar * sinkpadname, GstCaps * sinkcaps,

    gboolean * encoder_not_found);

static void stream_group_remove (GstEncodeBin * ebin, StreamGroup * sgroup);

static void stream_group_free (GstEncodeBin * ebin, StreamGroup * sgroup);

static GstPad *gst_encode_bin_request_pad_signal (GstEncodeBin * encodebin,

    GstCaps * caps);

static GstPad *gst_encode_bin_request_profile_pad_signal (GstEncodeBin *

    encodebin, const gchar * profilename);

static inline GstElement *_get_formatter (GstEncodeBin * ebin,

    GstEncodingProfile * sprof);

static void _post_missing_plugin_message (GstEncodeBin * ebin,

    GstEncodingProfile * prof);

static void

gst_encode_bin_class_init (GstEncodeBinClass * klass)

{

  GObjectClass *gobject_klass;

  GstElementClass *gstelement_klass;

  gobject_klass = (GObjectClass *) klass;

  gstelement_klass = (GstElementClass *) klass;

  gobject_klass->dispose = gst_encode_bin_dispose;

  gobject_klass->set_property = gst_encode_bin_set_property;

  gobject_klass->get_property = gst_encode_bin_get_property;

  /* Properties */

  /**

   * GstEncodeBin:profile:

   *

   * The #GstEncodingProfile to use. This property must be set before going

   * to %GST_STATE_PAUSED or higher.

   */

  g_object_class_install_property (gobject_klass, PROP_PROFILE,

      g_param_spec_object ("profile", "Profile",

          "The GstEncodingProfile to use", GST_TYPE_ENCODING_PROFILE,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_klass, PROP_QUEUE_BYTES_MAX,

      g_param_spec_uint ("queue-bytes-max", "Max. size (kB)",

          "Max. amount of data in the queue (bytes, 0=disable)",

          0, G_MAXUINT, DEFAULT_QUEUE_BYTES_MAX,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_klass, PROP_QUEUE_BUFFERS_MAX,

      g_param_spec_uint ("queue-buffers-max", "Max. size (buffers)",

          "Max. number of buffers in the queue (0=disable)", 0, G_MAXUINT,

          DEFAULT_QUEUE_BUFFERS_MAX,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_klass, PROP_QUEUE_TIME_MAX,

      g_param_spec_uint64 ("queue-time-max", "Max. size (ns)",

          "Max. amount of data in the queue (in ns, 0=disable)", 0, G_MAXUINT64,

          DEFAULT_QUEUE_TIME_MAX, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_klass, PROP_AUDIO_JITTER_TOLERANCE,

      g_param_spec_uint64 ("audio-jitter-tolerance", "Audio jitter tolerance",

          "Amount of timestamp jitter/imperfection to allow on audio streams before inserting/dropping samples (ns)",

          0, G_MAXUINT64, DEFAULT_AUDIO_JITTER_TOLERANCE,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_klass, PROP_AVOID_REENCODING,

      g_param_spec_boolean ("avoid-reencoding", "Avoid re-encoding",

          "Whether to re-encode portions of compatible video streams that lay on segment boundaries",

          DEFAULT_AVOID_REENCODING,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**

   * GstEncodeBin:flags

   *

   * Control the behaviour of encodebin.

   */

  g_object_class_install_property (gobject_klass, PROP_FLAGS,

      g_param_spec_flags ("flags", "Flags", "Flags to control behaviour",

          GST_TYPE_ENCODEBIN_FLAGS, DEFAULT_FLAGS,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /* Signals */

  /**

   * GstEncodeBin::request-pad

   * @encodebin: a #GstEncodeBin instance

   * @caps: a #GstCaps

   *

   * Use this method to request an unused sink request #GstPad that can take the

   * provided @caps as input. You must release the pad with

   * gst_element_release_request_pad() when you are done with it.

   *

   * Returns: A compatible #GstPad, or %NULL if no compatible #GstPad could be

   * created or is available.

   */

  gst_encode_bin_signals[SIGNAL_REQUEST_PAD] =

      g_signal_new ("request-pad", G_TYPE_FROM_CLASS (klass),

      G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GstEncodeBinClass,

          request_pad), NULL, NULL, g_cclosure_marshal_generic,

      GST_TYPE_PAD, 1, GST_TYPE_CAPS);

  /**

   * GstEncodeBin::request-profile-pad

   * @encodebin: a #GstEncodeBin instance

   * @profilename: the name of a #GstEncodingProfile

   *

   * Use this method to request an unused sink request #GstPad from the profile

   * @profilename. You must release the pad with

   * gst_element_release_request_pad() when you are done with it.

   *

   * Returns: A compatible #GstPad, or %NULL if no compatible #GstPad could be

   * created or is available.

   */

  gst_encode_bin_signals[SIGNAL_REQUEST_PROFILE_PAD] =

      g_signal_new ("request-profile-pad", G_TYPE_FROM_CLASS (klass),

      G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GstEncodeBinClass,

          request_profile_pad), NULL, NULL, g_cclosure_marshal_generic,

      GST_TYPE_PAD, 1, G_TYPE_STRING);

  klass->request_pad = gst_encode_bin_request_pad_signal;

  klass->request_profile_pad = gst_encode_bin_request_profile_pad_signal;

  gst_element_class_add_static_pad_template (gstelement_klass,

      &muxer_src_template);

  gst_element_class_add_static_pad_template (gstelement_klass,

      &video_sink_template);

  gst_element_class_add_static_pad_template (gstelement_klass,

      &audio_sink_template);

  /* gst_element_class_add_static_pad_template (gstelement_klass, &text_sink_template); */

  gst_element_class_add_static_pad_template (gstelement_klass,

      &private_sink_template);

  gstelement_klass->change_state =

      GST_DEBUG_FUNCPTR (gst_encode_bin_change_state);

  gstelement_klass->request_new_pad =

      GST_DEBUG_FUNCPTR (gst_encode_bin_request_new_pad);

  gstelement_klass->release_pad =

      GST_DEBUG_FUNCPTR (gst_encode_bin_release_pad);

  gst_element_class_set_static_metadata (gstelement_klass,

      "Encoder Bin",

      "Generic/Bin/Encoder",

      "Convenience encoding/muxing element",

      "Edward Hervey <edward.hervey@collabora.co.uk>");

}

static void

gst_encode_bin_dispose (GObject * object)

{

  GstEncodeBin *ebin = (GstEncodeBin *) object;

  if (ebin->muxers)

    gst_plugin_feature_list_free (ebin->muxers);

  ebin->muxers = NULL;

  if (ebin->formatters)

    gst_plugin_feature_list_free (ebin->formatters);

  ebin->formatters = NULL;

  if (ebin->encoders)

    gst_plugin_feature_list_free (ebin->encoders);

  ebin->encoders = NULL;

  if (ebin->parsers)

    gst_plugin_feature_list_free (ebin->parsers);

  ebin->parsers = NULL;

  gst_encode_bin_tear_down_profile (ebin);

  if (ebin->raw_video_caps)

    gst_caps_unref (ebin->raw_video_caps);

  ebin->raw_video_caps = NULL;

  if (ebin->raw_audio_caps)

    gst_caps_unref (ebin->raw_audio_caps);

  ebin->raw_audio_caps = NULL;

  /* if (ebin->raw_text_caps) */

  /*   gst_caps_unref (ebin->raw_text_caps); */

  G_OBJECT_CLASS (gst_encode_bin_parent_class)->dispose (object);

}

static void

gst_encode_bin_init (GstEncodeBin * encode_bin)

{

  GstPadTemplate *tmpl;

  encode_bin->muxers =

      gst_element_factory_list_get_elements (GST_ELEMENT_FACTORY_TYPE_MUXER,

      GST_RANK_MARGINAL);

  encode_bin->formatters =

      gst_element_factory_list_get_elements (GST_ELEMENT_FACTORY_TYPE_FORMATTER,

      GST_RANK_SECONDARY);

  encode_bin->encoders =

      gst_element_factory_list_get_elements (GST_ELEMENT_FACTORY_TYPE_ENCODER,

      GST_RANK_MARGINAL);

  encode_bin->parsers =

      gst_element_factory_list_get_elements (GST_ELEMENT_FACTORY_TYPE_PARSER,

      GST_RANK_MARGINAL);

  encode_bin->raw_video_caps = gst_caps_from_string ("video/x-raw");

  encode_bin->raw_audio_caps = gst_caps_from_string ("audio/x-raw");

  /* encode_bin->raw_text_caps = */

  /*     gst_caps_from_string ("text/x-raw"); */

  encode_bin->queue_buffers_max = DEFAULT_QUEUE_BUFFERS_MAX;

  encode_bin->queue_bytes_max = DEFAULT_QUEUE_BYTES_MAX;

  encode_bin->queue_time_max = DEFAULT_QUEUE_TIME_MAX;

  encode_bin->tolerance = DEFAULT_AUDIO_JITTER_TOLERANCE;

  encode_bin->avoid_reencoding = DEFAULT_AVOID_REENCODING;

  encode_bin->flags = DEFAULT_FLAGS;

  tmpl = gst_static_pad_template_get (&muxer_src_template);

  encode_bin->srcpad = gst_ghost_pad_new_no_target_from_template ("src", tmpl);

  gst_object_unref (tmpl);

  gst_pad_set_active (encode_bin->srcpad, TRUE);

  gst_element_add_pad (GST_ELEMENT_CAST (encode_bin), encode_bin->srcpad);

}

static void

gst_encode_bin_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec)

{

  GstEncodeBin *ebin = (GstEncodeBin *) object;

  switch (prop_id) {

    case PROP_PROFILE:

      gst_encode_bin_set_profile (ebin,

          (GstEncodingProfile *) g_value_get_object (value));

      break;

    case PROP_QUEUE_BUFFERS_MAX:

      ebin->queue_buffers_max = g_value_get_uint (value);

      break;

    case PROP_QUEUE_BYTES_MAX:

      ebin->queue_bytes_max = g_value_get_uint (value);

      break;

    case PROP_QUEUE_TIME_MAX:

      ebin->queue_time_max = g_value_get_uint64 (value);

      break;

    case PROP_AUDIO_JITTER_TOLERANCE:

      ebin->tolerance = g_value_get_uint64 (value);

      break;

    case PROP_AVOID_REENCODING:

      ebin->avoid_reencoding = g_value_get_boolean (value);

      break;

    case PROP_FLAGS:

      ebin->flags = g_value_get_flags (value);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

  }

}

static void

gst_encode_bin_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * pspec)

{

  GstEncodeBin *ebin = (GstEncodeBin *) object;

  switch (prop_id) {

    case PROP_PROFILE:

      g_value_set_object (value, (GObject *) ebin->profile);

      break;

    case PROP_QUEUE_BUFFERS_MAX:

      g_value_set_uint (value, ebin->queue_buffers_max);

      break;

    case PROP_QUEUE_BYTES_MAX:

      g_value_set_uint (value, ebin->queue_bytes_max);

      break;

    case PROP_QUEUE_TIME_MAX:

      g_value_set_uint64 (value, ebin->queue_time_max);

      break;

    case PROP_AUDIO_JITTER_TOLERANCE:

      g_value_set_uint64 (value, ebin->tolerance);

      break;

    case PROP_AVOID_REENCODING:

      g_value_set_boolean (value, ebin->avoid_reencoding);

      break;

    case PROP_FLAGS:

      g_value_set_flags (value, ebin->flags);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

  }

}

static inline gboolean

are_raw_caps (const GstCaps * caps)

{

  GstCaps *raw = gst_static_caps_get (&default_raw_caps);

  gboolean res = gst_caps_can_intersect (caps, raw);

  gst_caps_unref (raw);

  return res;

}

/* Returns the number of time a given stream profile is currently used

 * in encodebin */

static inline guint

stream_profile_used_count (GstEncodeBin * ebin, GstEncodingProfile * sprof)

{

  guint nbprofused = 0;

  GList *tmp;

  for (tmp = ebin->streams; tmp; tmp = tmp->next) {

    StreamGroup *sgroup = (StreamGroup *) tmp->data;

    if (sgroup->profile == sprof)

      nbprofused++;

  }

  return nbprofused;

}

static inline GstEncodingProfile *

next_unused_stream_profile (GstEncodeBin * ebin, GType ptype,

    const gchar * name, GstCaps * caps, GstEncodingProfile * previous_profile)

{

  GST_DEBUG_OBJECT (ebin, "ptype:%s, caps:%" GST_PTR_FORMAT,

      g_type_name (ptype), caps);

  if (G_UNLIKELY (ptype == G_TYPE_NONE && caps != NULL)) {

    /* Identify the profile type based on raw caps */

    if (gst_caps_can_intersect (ebin->raw_video_caps, caps))

      ptype = GST_TYPE_ENCODING_VIDEO_PROFILE;

    else if (gst_caps_can_intersect (ebin->raw_audio_caps, caps))

      ptype = GST_TYPE_ENCODING_AUDIO_PROFILE;

    /* else if (gst_caps_can_intersect (ebin->raw_text_caps, caps)) */

    /*   ptype = GST_TYPE_ENCODING_TEXT_PROFILE; */

    GST_DEBUG_OBJECT (ebin, "Detected profile type as being %s",

        g_type_name (ptype));

  }

  if (GST_IS_ENCODING_CONTAINER_PROFILE (ebin->profile)) {

    const GList *tmp;

    if (name) {

      /* If we have a name, try to find a profile with the same name */

      tmp =

          gst_encoding_container_profile_get_profiles

          (GST_ENCODING_CONTAINER_PROFILE (ebin->profile));

      for (; tmp; tmp = tmp->next) {

        GstEncodingProfile *sprof = (GstEncodingProfile *) tmp->data;

        const gchar *profilename = gst_encoding_profile_get_name (sprof);

        if (profilename && !strcmp (name, profilename)) {

          guint presence = gst_encoding_profile_get_presence (sprof);

          GST_DEBUG ("Found profile matching the requested name");

          if (!gst_encoding_profile_is_enabled (sprof)) {

            GST_INFO_OBJECT (ebin, "%p is disabled, not using it", sprof);

            return NULL;

          }

          if (presence == 0

              || presence > stream_profile_used_count (ebin, sprof))

            return sprof;

          GST_WARNING ("Matching stream already used");

          return NULL;

        }

      }

      GST_DEBUG

          ("No profiles matching requested pad name, carrying on with normal stream matching");

    }

    for (tmp =

        gst_encoding_container_profile_get_profiles

        (GST_ENCODING_CONTAINER_PROFILE (ebin->profile)); tmp;

        tmp = tmp->next) {

      GstEncodingProfile *sprof = (GstEncodingProfile *) tmp->data;

      /* Pick an available Stream profile for which:

       * * either it is of the compatible raw type,

       * * OR we can pass it through directly without encoding

       */

      if (G_TYPE_FROM_INSTANCE (sprof) == ptype) {

        guint presence = gst_encoding_profile_get_presence (sprof);

        GST_DEBUG ("Found a stream profile with the same type");

        if (!gst_encoding_profile_is_enabled (sprof)) {

          GST_INFO_OBJECT (ebin, "%p is disabled, not using it", sprof);

        } else if (presence == 0

            || (presence > stream_profile_used_count (ebin, sprof))) {

          if (sprof != previous_profile)

            return sprof;

        }

      } else if (caps && ptype == G_TYPE_NONE) {

        GstCaps *outcaps;

        gboolean res;

        outcaps = gst_encoding_profile_get_input_caps (sprof);

        GST_DEBUG ("Unknown stream, seeing if it's compatible with %"

            GST_PTR_FORMAT, outcaps);

        res = gst_caps_can_intersect (outcaps, caps);

        gst_caps_unref (outcaps);

        if (res && sprof != previous_profile)

          return sprof;

      }

    }

  }

  return NULL;

}

static GstPad *

request_pad_for_stream (GstEncodeBin * encodebin, GType ptype,

    const gchar * name, GstCaps * caps)

{

  StreamGroup *sgroup = NULL;

  GList *not_found_encoder_profs = NULL, *tmp;

  GstEncodingProfile *sprof = NULL;

  GST_DEBUG_OBJECT (encodebin, "name:%s caps:%" GST_PTR_FORMAT, name, caps);

  while (sgroup == NULL) {

    gboolean encoder_not_found = FALSE;

    /* Figure out if we have a unused GstEncodingProfile we can use for

     * these caps */

    sprof = next_unused_stream_profile (encodebin, ptype, name, caps, sprof);

    if (G_UNLIKELY (sprof == NULL))

      goto no_stream_profile;

    sgroup = _create_stream_group (encodebin, sprof, name, caps,

        &encoder_not_found);

    if (G_UNLIKELY (sgroup))

      break;

    if (encoder_not_found) {

      not_found_encoder_profs = g_list_prepend (not_found_encoder_profs, sprof);

      if (name) {

        GST_DEBUG ("Could not create an encoder for %s", name);

        goto no_stream_group;

      }

    } else {

      break;

    }

  }

  if (!sgroup)

    goto no_stream_group;

  g_list_free (not_found_encoder_profs);

  return sgroup->ghostpad;

no_stream_profile:

  {

    GST_WARNING_OBJECT (encodebin, "Couldn't find a compatible stream profile");

    return NULL;

  }

no_stream_group:

  {

    for (tmp = not_found_encoder_profs; tmp; tmp = tmp->next)

      _post_missing_plugin_message (encodebin, tmp->data);

    g_list_free (not_found_encoder_profs);

    GST_WARNING_OBJECT (encodebin, "Couldn't create a StreamGroup");

    return NULL;

  }

}

static GstPad *

gst_encode_bin_request_new_pad (GstElement * element,

    GstPadTemplate * templ, const gchar * name, const GstCaps * caps)

{

  GstEncodeBin *ebin = (GstEncodeBin *) element;

  GstPad *res = NULL;

  GST_DEBUG_OBJECT (element, "templ:%s, name:%s", templ->name_template, name);

  /* Identify the stream group (if name or caps have been provided) */

  if (caps != NULL || name != NULL) {

    res = request_pad_for_stream (ebin, G_TYPE_NONE, name, (GstCaps *) caps);

  }

  if (res == NULL) {

    GType ptype = G_TYPE_NONE;

    if (!strcmp (templ->name_template, "video_%u"))

      ptype = GST_TYPE_ENCODING_VIDEO_PROFILE;

    else if (!strcmp (templ->name_template, "audio_%u"))

      ptype = GST_TYPE_ENCODING_AUDIO_PROFILE;

    /* else if (!strcmp (templ->name_template, "text_%u")) */

    /*   ptype = GST_TYPE_ENCODING_TEXT_PROFILE; */

    /* FIXME : Check uniqueness of pad */

    /* FIXME : Check that the requested number is the last one, and if not,

     * update the last_pad_id variable so that we don't create a pad with

     * the same name/number in the future */

    res = request_pad_for_stream (ebin, ptype, name, NULL);

  }

  return res;

}

static GstPad *

gst_encode_bin_request_pad_signal (GstEncodeBin * encodebin, GstCaps * caps)

{

  GstPad *pad = request_pad_for_stream (encodebin, G_TYPE_NONE, NULL, caps);

  return pad ? GST_PAD_CAST (gst_object_ref (pad)) : NULL;

}

static GstPad *

gst_encode_bin_request_profile_pad_signal (GstEncodeBin * encodebin,

    const gchar * profilename)

{

  GstPad *pad =

      request_pad_for_stream (encodebin, G_TYPE_NONE, profilename, NULL);

  return pad ? GST_PAD_CAST (gst_object_ref (pad)) : NULL;

}

static inline StreamGroup *

find_stream_group_from_pad (GstEncodeBin * ebin, GstPad * pad)

{

  GList *tmp;

  for (tmp = ebin->streams; tmp; tmp = tmp->next) {

    StreamGroup *sgroup = (StreamGroup *) tmp->data;

    if (G_UNLIKELY (sgroup->ghostpad == pad))

      return sgroup;

  }

  return NULL;

}

static void

gst_encode_bin_release_pad (GstElement * element, GstPad * pad)

{

  GstEncodeBin *ebin = (GstEncodeBin *) element;

  StreamGroup *sgroup;

  /* Find the associated StreamGroup */

  sgroup = find_stream_group_from_pad (ebin, pad);

  if (G_UNLIKELY (sgroup == NULL))

    goto no_stream_group;

  /* Release objects/data associated with the StreamGroup */

  stream_group_remove (ebin, sgroup);

  return;

no_stream_group:

  {

    GST_WARNING_OBJECT (ebin, "Couldn't find corresponding StreamGroup");

    return;

  }

}

/* Create a parser for the given stream profile */

static inline GstElement *

_get_parser (GstEncodeBin * ebin, GstEncodingProfile * sprof)

{

  GList *parsers1, *parsers, *tmp;

  GstElement *parser = NULL;

  GstElementFactory *parserfact = NULL;

  GstCaps *format;

  format = gst_encoding_profile_get_format (sprof);

  GST_DEBUG ("Getting list of parsers for format %" GST_PTR_FORMAT, format);

  /* FIXME : requesting twice the parsers twice is a bit ugly, we should