ext/flac/gstflacenc.c

   1 /* GStreamer
   2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19 /**
  20  * SECTION:element-flacenc
  21  * @see_also: #GstFlacDec
  22  *
  23  * flacenc encodes FLAC streams.
  24  * <ulink url="http://flac.sourceforge.net/">FLAC</ulink>
  25  * is a Free Lossless Audio Codec.
  26  *
  27  * <refsect2>
  28  * <title>Example launch line</title>
  29  * |[
  30  * gst-launch audiotestsrc num-buffers=100 ! flacenc ! filesink location=beep.flac
  31  * ]|
  32  * </refsect2>
  33  */
  34
  35 /* TODO: - We currently don't handle discontinuities in the stream in a useful
  36  *         way and instead rely on the developer plugging in audiorate if
  37  *         the stream contains discontinuities.
  38  */
  39
  40 #ifdef HAVE_CONFIG_H
  41 #include "config.h"
  42 #endif
  43 #include <stdlib.h>
  44 #include <string.h>
  45
  46 #include <gstflacenc.h>
  47 #include <gst/audio/audio.h>
  48 #include <gst/audio/multichannel.h>
  49 #include <gst/tag/tag.h>
  50 #include <gst/gsttagsetter.h>
  51
  52 /* Taken from http://flac.sourceforge.net/format.html#frame_header */
  53 static const GstAudioChannelPosition channel_positions[8][8] = {
  54   {GST_AUDIO_CHANNEL_POSITION_FRONT_MONO},
  55   {GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
  56       GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT}, {
  57         GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
  58         GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
  59       GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER}, {
  60         GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
  61         GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
  62         GST_AUDIO_CHANNEL_POSITION_REAR_LEFT,
  63       GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT}, {
  64         GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
  65         GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
  66         GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER,
  67         GST_AUDIO_CHANNEL_POSITION_REAR_LEFT,
  68       GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT}, {
  69         GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
  70         GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
  71         GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER,
  72         GST_AUDIO_CHANNEL_POSITION_LFE,
  73         GST_AUDIO_CHANNEL_POSITION_REAR_LEFT,
  74       GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT},
  75   /* FIXME: 7/8 channel layouts are not defined in the FLAC specs */
  76   {
  77         GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
  78         GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
  79         GST_AUDIO_CHANNEL_POSITION_REAR_LEFT,
  80         GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT,
  81         GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER,
  82         GST_AUDIO_CHANNEL_POSITION_LFE,
  83       GST_AUDIO_CHANNEL_POSITION_REAR_CENTER}, {
  84         GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
  85         GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
  86         GST_AUDIO_CHANNEL_POSITION_REAR_LEFT,
  87         GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT,
  88         GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER,
  89         GST_AUDIO_CHANNEL_POSITION_LFE,
  90         GST_AUDIO_CHANNEL_POSITION_SIDE_LEFT,
  91       GST_AUDIO_CHANNEL_POSITION_SIDE_RIGHT}
  92 };
  93
  94 #define FLAC_SINK_CAPS \
  95   "audio/x-raw-int, "               \
  96   "endianness = (int) BYTE_ORDER, " \
  97   "signed = (boolean) TRUE, "       \
  98   "width = (int) 8, "               \
  99   "depth = (int) 8, "               \
 100   "rate = (int) [ 1, 655350 ], "    \
 101   "channels = (int) [ 1, 8 ]; "     \
 102   "audio/x-raw-int, "               \
 103   "endianness = (int) BYTE_ORDER, " \
 104   "signed = (boolean) TRUE, "       \
 105   "width = (int) 16, "              \
 106   "depth = (int) { 12, 16 }, "      \
 107   "rate = (int) [ 1, 655350 ], "    \
 108   "channels = (int) [ 1, 8 ]; "     \
 109   "audio/x-raw-int, "               \
 110   "endianness = (int) BYTE_ORDER, " \
 111   "signed = (boolean) TRUE, "       \
 112   "width = (int) 32, "              \
 113   "depth = (int) { 20, 24 }, "      \
 114   "rate = (int) [ 1, 655350 ], "    \
 115   "channels = (int) [ 1, 8 ]"
 116
 117 static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE ("src",
 118     GST_PAD_SRC,
 119     GST_PAD_ALWAYS,
 120     GST_STATIC_CAPS ("audio/x-flac")
 121     );
 122
 123 static GstStaticPadTemplate sink_factory = GST_STATIC_PAD_TEMPLATE ("sink",
 124     GST_PAD_SINK,
 125     GST_PAD_ALWAYS,
 126     GST_STATIC_CAPS (FLAC_SINK_CAPS)
 127     );
 128
 129 enum
 130 {
 131   PROP_0,
 132   PROP_QUALITY,
 133   PROP_STREAMABLE_SUBSET,
 134   PROP_MID_SIDE_STEREO,
 135   PROP_LOOSE_MID_SIDE_STEREO,
 136   PROP_BLOCKSIZE,
 137   PROP_MAX_LPC_ORDER,
 138   PROP_QLP_COEFF_PRECISION,
 139   PROP_QLP_COEFF_PREC_SEARCH,
 140   PROP_ESCAPE_CODING,
 141   PROP_EXHAUSTIVE_MODEL_SEARCH,
 142   PROP_MIN_RESIDUAL_PARTITION_ORDER,
 143   PROP_MAX_RESIDUAL_PARTITION_ORDER,
 144   PROP_RICE_PARAMETER_SEARCH_DIST,
 145   PROP_PADDING,
 146   PROP_SEEKPOINTS
 147 };
 148
 149 GST_DEBUG_CATEGORY_STATIC (flacenc_debug);
 150 #define GST_CAT_DEFAULT flacenc_debug
 151
 152 #define gst_flac_enc_parent_class parent_class
 153 G_DEFINE_TYPE_WITH_CODE (GstFlacEnc, gst_flac_enc, GST_TYPE_AUDIO_ENCODER,
 154     G_IMPLEMENT_INTERFACE (GST_TYPE_TAG_SETTER, NULL));
 155
 156 static gboolean gst_flac_enc_start (GstAudioEncoder * enc);
 157 static gboolean gst_flac_enc_stop (GstAudioEncoder * enc);
 158 static gboolean gst_flac_enc_set_format (GstAudioEncoder * enc,
 159     GstAudioInfo * info);
 160 static GstFlowReturn gst_flac_enc_handle_frame (GstAudioEncoder * enc,
 161     GstBuffer * in_buf);
 162 static GstCaps *gst_flac_enc_getcaps (GstAudioEncoder * enc, GstCaps * filter);
 163 static gboolean gst_flac_enc_sink_event (GstAudioEncoder * enc,
 164     GstEvent * event);
 165
 166 static void gst_flac_enc_finalize (GObject * object);
 167
 168 static gboolean gst_flac_enc_update_quality (GstFlacEnc * flacenc,
 169     gint quality);
 170 static void gst_flac_enc_set_property (GObject * object, guint prop_id,
 171     const GValue * value, GParamSpec * pspec);
 172 static void gst_flac_enc_get_property (GObject * object, guint prop_id,
 173     GValue * value, GParamSpec * pspec);
 174
 175 static FLAC__StreamEncoderWriteStatus
 176 gst_flac_enc_write_callback (const FLAC__StreamEncoder * encoder,
 177     const FLAC__byte buffer[], size_t bytes,
 178     unsigned samples, unsigned current_frame, void *client_data);
 179 static FLAC__StreamEncoderSeekStatus
 180 gst_flac_enc_seek_callback (const FLAC__StreamEncoder * encoder,
 181     FLAC__uint64 absolute_byte_offset, void *client_data);
 182 static FLAC__StreamEncoderTellStatus
 183 gst_flac_enc_tell_callback (const FLAC__StreamEncoder * encoder,
 184     FLAC__uint64 * absolute_byte_offset, void *client_data);
 185
 186 typedef struct
 187 {
 188   gboolean exhaustive_model_search;
 189   gboolean escape_coding;
 190   gboolean mid_side;
 191   gboolean loose_mid_side;
 192   guint qlp_coeff_precision;
 193   gboolean qlp_coeff_prec_search;
 194   guint min_residual_partition_order;
 195   guint max_residual_partition_order;
 196   guint rice_parameter_search_dist;
 197   guint max_lpc_order;
 198   guint blocksize;
 199 }
 200 GstFlacEncParams;
 201
 202 static const GstFlacEncParams flacenc_params[] = {
 203   {FALSE, FALSE, FALSE, FALSE, 0, FALSE, 2, 2, 0, 0, 1152},
 204   {FALSE, FALSE, TRUE, TRUE, 0, FALSE, 2, 2, 0, 0, 1152},
 205   {FALSE, FALSE, TRUE, FALSE, 0, FALSE, 0, 3, 0, 0, 1152},
 206   {FALSE, FALSE, FALSE, FALSE, 0, FALSE, 3, 3, 0, 6, 4608},
 207   {FALSE, FALSE, TRUE, TRUE, 0, FALSE, 3, 3, 0, 8, 4608},
 208   {FALSE, FALSE, TRUE, FALSE, 0, FALSE, 3, 3, 0, 8, 4608},
 209   {FALSE, FALSE, TRUE, FALSE, 0, FALSE, 0, 4, 0, 8, 4608},
 210   {TRUE, FALSE, TRUE, FALSE, 0, FALSE, 0, 6, 0, 8, 4608},
 211   {TRUE, FALSE, TRUE, FALSE, 0, FALSE, 0, 6, 0, 12, 4608},
 212   {TRUE, TRUE, TRUE, FALSE, 0, FALSE, 0, 16, 0, 32, 4608},
 213 };
 214
 215 #define DEFAULT_QUALITY 5
 216 #define DEFAULT_PADDING 0
 217 #define DEFAULT_SEEKPOINTS 0
 218
 219 #define GST_TYPE_FLAC_ENC_QUALITY (gst_flac_enc_quality_get_type ())
 220 static GType
 221 gst_flac_enc_quality_get_type (void)
 222 {
 223   static GType qtype = 0;
 224
 225   if (qtype == 0) {
 226     static const GEnumValue values[] = {
 227       {0, "0 - Fastest compression", "0"},
 228       {1, "1", "1"},
 229       {2, "2", "2"},
 230       {3, "3", "3"},
 231       {4, "4", "4"},
 232       {5, "5 - Default", "5"},
 233       {6, "6", "6"},
 234       {7, "7", "7"},
 235       {8, "8 - Highest compression", "8"},
 236       {9, "9 - Insane", "9"},
 237       {0, NULL, NULL}
 238     };
 239
 240     qtype = g_enum_register_static ("GstFlacEncQuality", values);
 241   }
 242   return qtype;
 243 }
 244
 245 static void
 246 gst_flac_enc_class_init (GstFlacEncClass * klass)
 247 {
 248   GObjectClass *gobject_class;
 249   GstElementClass *gstelement_class;
 250   GstAudioEncoderClass *base_class;
 251
 252   gobject_class = (GObjectClass *) klass;
 253   gstelement_class = (GstElementClass *) klass;
 254   base_class = (GstAudioEncoderClass *) (klass);
 255
 256   GST_DEBUG_CATEGORY_INIT (flacenc_debug, "flacenc", 0,
 257       "Flac encoding element");
 258
 259   gobject_class->set_property = gst_flac_enc_set_property;
 260   gobject_class->get_property = gst_flac_enc_get_property;
 261   gobject_class->finalize = gst_flac_enc_finalize;
 262
 263   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_QUALITY,
 264       g_param_spec_enum ("quality",
 265           "Quality",
 266           "Speed versus compression tradeoff",
 267           GST_TYPE_FLAC_ENC_QUALITY, DEFAULT_QUALITY,
 268           G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
 269   g_object_class_install_property (G_OBJECT_CLASS (klass),
 270       PROP_STREAMABLE_SUBSET, g_param_spec_boolean ("streamable-subset",
 271           "Streamable subset",
 272           "true to limit encoder to generating a Subset stream, else false",
 273           TRUE,
 274           G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
 275   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_MID_SIDE_STEREO,
 276       g_param_spec_boolean ("mid-side-stereo", "Do mid side stereo",
 277           "Do mid side stereo (only for stereo input)",
 278           flacenc_params[DEFAULT_QUALITY].mid_side,
 279           G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
 280   g_object_class_install_property (G_OBJECT_CLASS (klass),
 281       PROP_LOOSE_MID_SIDE_STEREO, g_param_spec_boolean ("loose-mid-side-stereo",
 282           "Loose mid side stereo", "Loose mid side stereo",
 283           flacenc_params[DEFAULT_QUALITY].loose_mid_side,
 284           G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
 285   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_BLOCKSIZE,
 286       g_param_spec_uint ("blocksize", "Blocksize", "Blocksize in samples",
 287           FLAC__MIN_BLOCK_SIZE, FLAC__MAX_BLOCK_SIZE,
 288           flacenc_params[DEFAULT_QUALITY].blocksize,
 289           G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
 290   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_MAX_LPC_ORDER,
 291       g_param_spec_uint ("max-lpc-order", "Max LPC order",
 292           "Max LPC order; 0 => use only fixed predictors", 0,
 293           FLAC__MAX_LPC_ORDER, flacenc_params[DEFAULT_QUALITY].max_lpc_order,
 294           G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
 295   g_object_class_install_property (G_OBJECT_CLASS (klass),
 296       PROP_QLP_COEFF_PRECISION, g_param_spec_uint ("qlp-coeff-precision",
 297           "QLP coefficients precision",
 298           "Precision in bits of quantized linear-predictor coefficients; 0 = automatic",
 299           0, 32, flacenc_params[DEFAULT_QUALITY].qlp_coeff_precision,
 300           G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
 301   g_object_class_install_property (G_OBJECT_CLASS (klass),
 302       PROP_QLP_COEFF_PREC_SEARCH, g_param_spec_boolean ("qlp-coeff-prec-search",
 303           "Do QLP coefficients precision search",
 304           "false = use qlp_coeff_precision, "
 305           "true = search around qlp_coeff_precision, take best",
 306           flacenc_params[DEFAULT_QUALITY].qlp_coeff_prec_search,
 307           G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
 308   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_ESCAPE_CODING,
 309       g_param_spec_boolean ("escape-coding", "Do Escape coding",
 310           "search for escape codes in the entropy coding stage "
 311           "for slightly better compression",
 312           flacenc_params[DEFAULT_QUALITY].escape_coding,
 313           G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
 314   g_object_class_install_property (G_OBJECT_CLASS (klass),
 315       PROP_EXHAUSTIVE_MODEL_SEARCH,
 316       g_param_spec_boolean ("exhaustive-model-search",
 317           "Do exhaustive model search",
 318           "do exhaustive search of LP coefficient quantization (expensive!)",
 319           flacenc_params[DEFAULT_QUALITY].exhaustive_model_search,
 320           G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
 321   g_object_class_install_property (G_OBJECT_CLASS (klass),
 322       PROP_MIN_RESIDUAL_PARTITION_ORDER,
 323       g_param_spec_uint ("min-residual-partition-order",
 324           "Min residual partition order",
 325           "Min residual partition order (above 4 doesn't usually help much)", 0,
 326           16, flacenc_params[DEFAULT_QUALITY].min_residual_partition_order,
 327           G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
 328   g_object_class_install_property (G_OBJECT_CLASS (klass),
 329       PROP_MAX_RESIDUAL_PARTITION_ORDER,
 330       g_param_spec_uint ("max-residual-partition-order",
 331           "Max residual partition order",
 332           "Max residual partition order (above 4 doesn't usually help much)", 0,
 333           16, flacenc_params[DEFAULT_QUALITY].max_residual_partition_order,
 334           G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
 335   g_object_class_install_property (G_OBJECT_CLASS (klass),
 336       PROP_RICE_PARAMETER_SEARCH_DIST,
 337       g_param_spec_uint ("rice-parameter-search-dist",
 338           "rice_parameter_search_dist",
 339           "0 = try only calc'd parameter k; else try all [k-dist..k+dist] "
 340           "parameters, use best", 0, FLAC__MAX_RICE_PARTITION_ORDER,
 341           flacenc_params[DEFAULT_QUALITY].rice_parameter_search_dist,
 342           G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
 343
 344   /**
 345    * GstFlacEnc:padding
 346    *
 347    * Write a PADDING block with this length in bytes
 348    *
 349    * Since: 0.10.16
 350    **/
 351   g_object_class_install_property (G_OBJECT_CLASS (klass),
 352       PROP_PADDING,
 353       g_param_spec_uint ("padding",
 354           "Padding",
 355           "Write a PADDING block with this length in bytes", 0, G_MAXUINT,
 356           DEFAULT_PADDING,
 357           G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
 358
 359   /**
 360    * GstFlacEnc:seekpoints
 361    *
 362    * Write a SEEKTABLE block with a specific number of seekpoints
 363    * or with a specific interval spacing.
 364    *
 365    * Since: 0.10.18
 366    **/
 367   g_object_class_install_property (G_OBJECT_CLASS (klass),
 368       PROP_SEEKPOINTS,
 369       g_param_spec_int ("seekpoints",
 370           "Seekpoints",
 371           "Add SEEKTABLE metadata (if > 0, number of entries, if < 0, interval in sec)",
 372           -G_MAXINT, G_MAXINT,
 373           DEFAULT_SEEKPOINTS,
 374           G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
 375
 376   gst_element_class_add_pad_template (gstelement_class,
 377       gst_static_pad_template_get (&src_factory));
 378   gst_element_class_add_pad_template (gstelement_class,
 379       gst_static_pad_template_get (&sink_factory));
 380
 381   gst_element_class_set_details_simple (gstelement_class, "FLAC audio encoder",
 382       "Codec/Encoder/Audio",
 383       "Encodes audio with the FLAC lossless audio encoder",
 384       "Wim Taymans <wim.taymans@chello.be>");
 385
 386   base_class->start = GST_DEBUG_FUNCPTR (gst_flac_enc_start);
 387   base_class->stop = GST_DEBUG_FUNCPTR (gst_flac_enc_stop);
 388   base_class->set_format = GST_DEBUG_FUNCPTR (gst_flac_enc_set_format);
 389   base_class->handle_frame = GST_DEBUG_FUNCPTR (gst_flac_enc_handle_frame);
 390   base_class->getcaps = GST_DEBUG_FUNCPTR (gst_flac_enc_getcaps);
 391   base_class->event = GST_DEBUG_FUNCPTR (gst_flac_enc_sink_event);
 392 }
 393
 394 static void
 395 gst_flac_enc_init (GstFlacEnc * flacenc)
 396 {
 397   GstAudioEncoder *enc = GST_AUDIO_ENCODER (flacenc);
 398
 399   flacenc->encoder = FLAC__stream_encoder_new ();
 400   gst_flac_enc_update_quality (flacenc, DEFAULT_QUALITY);
 401
 402   /* arrange granulepos marking (and required perfect ts) */
 403   gst_audio_encoder_set_mark_granule (enc, TRUE);
 404   gst_audio_encoder_set_perfect_timestamp (enc, TRUE);
 405 }
 406
 407 static void
 408 gst_flac_enc_finalize (GObject * object)
 409 {
 410   GstFlacEnc *flacenc = GST_FLAC_ENC (object);
 411
 412   FLAC__stream_encoder_delete (flacenc->encoder);
 413
 414   G_OBJECT_CLASS (parent_class)->finalize (object);
 415 }
 416
 417 static gboolean
 418 gst_flac_enc_start (GstAudioEncoder * enc)
 419 {
 420   GstFlacEnc *flacenc = GST_FLAC_ENC (enc);
 421
 422   GST_DEBUG_OBJECT (enc, "start");
 423   flacenc->stopped = TRUE;
 424   flacenc->got_headers = FALSE;
 425   flacenc->last_flow = GST_FLOW_OK;
 426   flacenc->offset = 0;
 427   flacenc->channels = 0;
 428   flacenc->depth = 0;
 429   flacenc->sample_rate = 0;
 430   flacenc->eos = FALSE;
 431   flacenc->tags = gst_tag_list_new_empty ();
 432
 433   return TRUE;
 434 }
 435
 436 static gboolean
 437 gst_flac_enc_stop (GstAudioEncoder * enc)
 438 {
 439   GstFlacEnc *flacenc = GST_FLAC_ENC (enc);
 440
 441   GST_DEBUG_OBJECT (enc, "stop");
 442   gst_tag_list_free (flacenc->tags);
 443   flacenc->tags = NULL;
 444   if (FLAC__stream_encoder_get_state (flacenc->encoder) !=
 445       FLAC__STREAM_ENCODER_UNINITIALIZED) {
 446     flacenc->stopped = TRUE;
 447     FLAC__stream_encoder_finish (flacenc->encoder);
 448   }
 449   if (flacenc->meta) {
 450     FLAC__metadata_object_delete (flacenc->meta[0]);
 451
 452     if (flacenc->meta[1])
 453       FLAC__metadata_object_delete (flacenc->meta[1]);
 454
 455     if (flacenc->meta[2])
 456       FLAC__metadata_object_delete (flacenc->meta[2]);
 457
 458     g_free (flacenc->meta);
 459     flacenc->meta = NULL;
 460   }
 461   g_list_foreach (flacenc->headers, (GFunc) gst_mini_object_unref, NULL);
 462   g_list_free (flacenc->headers);
 463   flacenc->headers = NULL;
 464
 465   return TRUE;
 466 }
 467
 468 static void
 469 add_one_tag (const GstTagList * list, const gchar * tag, gpointer user_data)
 470 {
 471   GList *comments;
 472   GList *it;
 473   GstFlacEnc *flacenc = GST_FLAC_ENC (user_data);
 474
 475   /* IMAGE and PREVIEW_IMAGE tags are already written
 476    * differently, no need to store them inside the
 477    * vorbiscomments too */
 478   if (strcmp (tag, GST_TAG_IMAGE) == 0
 479       || strcmp (tag, GST_TAG_PREVIEW_IMAGE) == 0)
 480     return;
 481
 482   comments = gst_tag_to_vorbis_comments (list, tag);
 483   for (it = comments; it != NULL; it = it->next) {
 484     FLAC__StreamMetadata_VorbisComment_Entry commment_entry;
 485
 486     commment_entry.length = strlen (it->data);
 487     commment_entry.entry = it->data;
 488     FLAC__metadata_object_vorbiscomment_insert_comment (flacenc->meta[0],
 489         flacenc->meta[0]->data.vorbis_comment.num_comments,
 490         commment_entry, TRUE);
 491     g_free (it->data);
 492   }
 493   g_list_free (comments);
 494 }
 495
 496 static void
 497 gst_flac_enc_set_metadata (GstFlacEnc * flacenc, guint64 total_samples)
 498 {
 499   const GstTagList *user_tags;
 500   GstTagList *copy;
 501   gint entries = 1;
 502   gint n_images, n_preview_images;
 503
 504   g_return_if_fail (flacenc != NULL);
 505   user_tags = gst_tag_setter_get_tag_list (GST_TAG_SETTER (flacenc));
 506   if ((flacenc->tags == NULL) && (user_tags == NULL)) {
 507     return;
 508   }
 509   copy = gst_tag_list_merge (user_tags, flacenc->tags,
 510       gst_tag_setter_get_tag_merge_mode (GST_TAG_SETTER (flacenc)));
 511   n_images = gst_tag_list_get_tag_size (copy, GST_TAG_IMAGE);
 512   n_preview_images = gst_tag_list_get_tag_size (copy, GST_TAG_PREVIEW_IMAGE);
 513
 514   flacenc->meta =
 515       g_new0 (FLAC__StreamMetadata *, 3 + n_images + n_preview_images);
 516
 517   flacenc->meta[0] =
 518       FLAC__metadata_object_new (FLAC__METADATA_TYPE_VORBIS_COMMENT);
 519   gst_tag_list_foreach (copy, add_one_tag, flacenc);
 520
 521   if (n_images + n_preview_images > 0) {
 522     GstBuffer *buffer;
 523 #if 0
 524     GstCaps *caps;
 525     GstStructure *structure;
 526     GstTagImageType image_type = GST_TAG_IMAGE_TYPE_NONE;
 527 #endif
 528     gint i;
 529     guint8 *data;
 530     gsize size;
 531
 532     for (i = 0; i < n_images + n_preview_images; i++) {
 533       if (i < n_images) {
 534         if (!gst_tag_list_get_buffer_index (copy, GST_TAG_IMAGE, i, &buffer))
 535           continue;
 536       } else {
 537         if (!gst_tag_list_get_buffer_index (copy, GST_TAG_PREVIEW_IMAGE,
 538                 i - n_images, &buffer))
 539           continue;
 540       }
 541
 542       flacenc->meta[entries] =
 543           FLAC__metadata_object_new (FLAC__METADATA_TYPE_PICTURE);
 544
 545 #if 0
 546       caps = gst_buffer_get_caps (buffer);
 547       structure = gst_caps_get_structure (caps, 0);
 548
 549       gst_structure_get (structure, "image-type", GST_TYPE_TAG_IMAGE_TYPE,
 550           &image_type, NULL);
 551       /* Convert to ID3v2 APIC image type */
 552       if (image_type == GST_TAG_IMAGE_TYPE_NONE)
 553         image_type = (i < n_images) ? 0x00 : 0x01;
 554       else
 555         image_type = image_type + 2;
 556 #endif
 557
 558       data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
 559       FLAC__metadata_object_picture_set_data (flacenc->meta[entries],
 560           data, size, TRUE);
 561       gst_buffer_unmap (buffer, data, size);
 562
 563 #if 0
 564       /* FIXME: There's no way to set the picture type in libFLAC */
 565       flacenc->meta[entries]->data.picture.type = image_type;
 566       FLAC__metadata_object_picture_set_mime_type (flacenc->meta[entries],
 567           (char *) gst_structure_get_name (structure), TRUE);
 568       gst_caps_unref (caps);
 569 #endif
 570
 571       gst_buffer_unref (buffer);
 572       entries++;
 573     }
 574   }
 575
 576   if (flacenc->seekpoints && total_samples != GST_CLOCK_TIME_NONE) {
 577     gboolean res;
 578     guint samples;
 579
 580     flacenc->meta[entries] =
 581         FLAC__metadata_object_new (FLAC__METADATA_TYPE_SEEKTABLE);
 582     if (flacenc->seekpoints > 0) {
 583       res =
 584           FLAC__metadata_object_seektable_template_append_spaced_points
 585           (flacenc->meta[entries], flacenc->seekpoints, total_samples);
 586     } else {
 587       samples = -flacenc->seekpoints * flacenc->sample_rate;
 588       res =
 589           FLAC__metadata_object_seektable_template_append_spaced_points_by_samples
 590           (flacenc->meta[entries], samples, total_samples);
 591     }
 592     if (!res) {
 593       GST_DEBUG_OBJECT (flacenc, "adding seekpoint template %d failed",
 594           flacenc->seekpoints);
 595       FLAC__metadata_object_delete (flacenc->meta[1]);
 596       flacenc->meta[entries] = NULL;
 597     } else {
 598       entries++;
 599     }
 600   } else if (flacenc->seekpoints && total_samples == GST_CLOCK_TIME_NONE) {
 601     GST_WARNING_OBJECT (flacenc, "total time unknown; can not add seekpoints");
 602   }
 603
 604   if (flacenc->padding > 0) {
 605     flacenc->meta[entries] =
 606         FLAC__metadata_object_new (FLAC__METADATA_TYPE_PADDING);
 607     flacenc->meta[entries]->length = flacenc->padding;
 608     entries++;
 609   }
 610
 611   if (FLAC__stream_encoder_set_metadata (flacenc->encoder,
 612           flacenc->meta, entries) != true)
 613     g_warning ("Dude, i'm already initialized!");
 614
 615   gst_tag_list_free (copy);
 616 }
 617
 618 static void
 619 gst_flac_enc_caps_append_structure_with_widths (GstCaps * caps,
 620     GstStructure * s)
 621 {
 622   GstStructure *tmp;
 623   GValue list = { 0, };
 624   GValue depth = { 0, };
 625
 626
 627   tmp = gst_structure_copy (s);
 628   gst_structure_set (tmp, "width", G_TYPE_INT, 8, "depth", G_TYPE_INT, 8, NULL);
 629   gst_caps_append_structure (caps, tmp);
 630
 631   tmp = gst_structure_copy (s);
 632
 633   g_value_init (&depth, G_TYPE_INT);
 634   g_value_init (&list, GST_TYPE_LIST);
 635   g_value_set_int (&depth, 12);
 636   gst_value_list_append_value (&list, &depth);
 637   g_value_set_int (&depth, 16);
 638   gst_value_list_append_value (&list, &depth);
 639
 640   gst_structure_set (tmp, "width", G_TYPE_INT, 16, NULL);
 641   gst_structure_set_value (tmp, "depth", &list);
 642   gst_caps_append_structure (caps, tmp);
 643
 644   g_value_reset (&list);
 645
 646   tmp = s;
 647
 648   g_value_set_int (&depth, 20);
 649   gst_value_list_append_value (&list, &depth);
 650   g_value_set_int (&depth, 24);
 651   gst_value_list_append_value (&list, &depth);
 652
 653   gst_structure_set (tmp, "width", G_TYPE_INT, 32, NULL);
 654   gst_structure_set_value (tmp, "depth", &list);
 655   gst_caps_append_structure (caps, tmp);
 656
 657   g_value_unset (&list);
 658   g_value_unset (&depth);
 659 }
 660
 661 static GstCaps *
 662 gst_flac_enc_getcaps (GstAudioEncoder * enc, GstCaps * filter)
 663 {
 664   GstCaps *ret = NULL, *caps = NULL;
 665   GstPad *pad;
 666
 667   pad = GST_AUDIO_ENCODER_SINK_PAD (enc);
 668
 669   GST_OBJECT_LOCK (pad);
 670
 671   if (gst_pad_has_current_caps (pad)) {
 672     ret = gst_pad_get_current_caps (pad);
 673   } else {
 674     gint i, c;
 675
 676     ret = gst_caps_new_empty ();
 677
 678     gst_flac_enc_caps_append_structure_with_widths (ret,
 679         gst_structure_new ("audio/x-raw-int",
 680             "endianness", G_TYPE_INT, G_BYTE_ORDER,
 681             "signed", G_TYPE_BOOLEAN, TRUE,
 682             "rate", GST_TYPE_INT_RANGE, 1, 655350,
 683             "channels", GST_TYPE_INT_RANGE, 1, 2, NULL));
 684
 685     for (i = 3; i <= 8; i++) {
 686       GValue positions = { 0, };
 687       GValue pos = { 0, };
 688       GstStructure *s;
 689
 690       g_value_init (&positions, GST_TYPE_ARRAY);
 691       g_value_init (&pos, GST_TYPE_AUDIO_CHANNEL_POSITION);
 692
 693       for (c = 0; c < i; c++) {
 694         g_value_set_enum (&pos, channel_positions[i - 1][c]);
 695         gst_value_array_append_value (&positions, &pos);
 696       }
 697       g_value_unset (&pos);
 698
 699       s = gst_structure_new ("audio/x-raw-int",
 700           "endianness", G_TYPE_INT, G_BYTE_ORDER,
 701           "signed", G_TYPE_BOOLEAN, TRUE,
 702           "rate", GST_TYPE_INT_RANGE, 1, 655350,
 703           "channels", G_TYPE_INT, i, NULL);
 704       gst_structure_set_value (s, "channel-positions", &positions);
 705       g_value_unset (&positions);
 706
 707       gst_flac_enc_caps_append_structure_with_widths (ret, s);
 708     }
 709   }
 710
 711   GST_OBJECT_UNLOCK (pad);
 712
 713   GST_DEBUG_OBJECT (pad, "Return caps %" GST_PTR_FORMAT, ret);
 714
 715   caps = gst_audio_encoder_proxy_getcaps (enc, ret);
 716   gst_caps_unref (ret);
 717
 718   return caps;
 719 }
 720
 721 static guint64
 722 gst_flac_enc_query_peer_total_samples (GstFlacEnc * flacenc, GstPad * pad)
 723 {
 724   gint64 duration;
 725
 726   GST_DEBUG_OBJECT (flacenc, "querying peer for DEFAULT format duration");
 727   if (gst_pad_query_peer_duration (pad, GST_FORMAT_DEFAULT, &duration)
 728       && duration != GST_CLOCK_TIME_NONE)
 729     goto done;
 730
 731   GST_DEBUG_OBJECT (flacenc, "querying peer for TIME format duration");
 732
 733   if (gst_pad_query_peer_duration (pad, GST_FORMAT_TIME, &duration)
 734       && duration != GST_CLOCK_TIME_NONE) {
 735     GST_DEBUG_OBJECT (flacenc, "peer reported duration %" GST_TIME_FORMAT,
 736         GST_TIME_ARGS (duration));
 737     duration = GST_CLOCK_TIME_TO_FRAMES (duration, flacenc->sample_rate);
 738
 739     goto done;
 740   }
 741
 742   GST_DEBUG_OBJECT (flacenc, "Upstream reported no total samples");
 743   return GST_CLOCK_TIME_NONE;
 744
 745 done:
 746   GST_DEBUG_OBJECT (flacenc,
 747       "Upstream reported %" G_GUINT64_FORMAT " total samples", duration);
 748
 749   return duration;
 750 }
 751
 752 static gboolean
 753 gst_flac_enc_set_format (GstAudioEncoder * enc, GstAudioInfo * info)
 754 {
 755   GstFlacEnc *flacenc;
 756   guint64 total_samples = GST_CLOCK_TIME_NONE;
 757   FLAC__StreamEncoderInitStatus init_status;
 758   GstCaps *caps;
 759
 760   flacenc = GST_FLAC_ENC (enc);
 761
 762   /* if configured again, means something changed, can't handle that */
 763   if (FLAC__stream_encoder_get_state (flacenc->encoder) !=
 764       FLAC__STREAM_ENCODER_UNINITIALIZED)
 765     goto encoder_already_initialized;
 766
 767   flacenc->channels = GST_AUDIO_INFO_CHANNELS (info);
 768   flacenc->width = GST_AUDIO_INFO_WIDTH (info);
 769   flacenc->depth = GST_AUDIO_INFO_DEPTH (info);
 770   flacenc->sample_rate = GST_AUDIO_INFO_RATE (info);
 771
 772   caps = gst_caps_new_simple ("audio/x-flac",
 773       "channels", G_TYPE_INT, flacenc->channels,
 774       "rate", G_TYPE_INT, flacenc->sample_rate, NULL);
 775
 776   if (!gst_pad_set_caps (GST_AUDIO_ENCODER_SRC_PAD (enc), caps))
 777     goto setting_src_caps_failed;
 778
 779   gst_caps_unref (caps);
 780
 781   total_samples = gst_flac_enc_query_peer_total_samples (flacenc,
 782       GST_AUDIO_ENCODER_SINK_PAD (enc));
 783
 784   FLAC__stream_encoder_set_bits_per_sample (flacenc->encoder, flacenc->depth);
 785   FLAC__stream_encoder_set_sample_rate (flacenc->encoder, flacenc->sample_rate);
 786   FLAC__stream_encoder_set_channels (flacenc->encoder, flacenc->channels);
 787
 788   if (total_samples != GST_CLOCK_TIME_NONE)
 789     FLAC__stream_encoder_set_total_samples_estimate (flacenc->encoder,
 790         MIN (total_samples, G_GUINT64_CONSTANT (0x0FFFFFFFFF)));
 791
 792   gst_flac_enc_set_metadata (flacenc, total_samples);
 793
 794   /* callbacks clear to go now;
 795    * write callbacks receives headers during init */
 796   flacenc->stopped = FALSE;
 797
 798   init_status = FLAC__stream_encoder_init_stream (flacenc->encoder,
 799       gst_flac_enc_write_callback, gst_flac_enc_seek_callback,
 800       gst_flac_enc_tell_callback, NULL, flacenc);
 801   if (init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK)
 802     goto failed_to_initialize;
 803
 804   /* no special feedback to base class; should provide all available samples */
 805
 806   return TRUE;
 807
 808 encoder_already_initialized:
 809   {
 810     g_warning ("flac already initialized -- fixme allow this");
 811     gst_object_unref (flacenc);
 812     return FALSE;
 813   }
 814 setting_src_caps_failed:
 815   {
 816     GST_DEBUG_OBJECT (flacenc,
 817         "Couldn't set caps on source pad: %" GST_PTR_FORMAT, caps);
 818     gst_caps_unref (caps);
 819     gst_object_unref (flacenc);
 820     return FALSE;
 821   }
 822 failed_to_initialize:
 823   {
 824     GST_ELEMENT_ERROR (flacenc, LIBRARY, INIT, (NULL),
 825         ("could not initialize encoder (wrong parameters?)"));
 826     gst_object_unref (flacenc);
 827     return FALSE;
 828   }
 829 }
 830
 831 static gboolean
 832 gst_flac_enc_update_quality (GstFlacEnc * flacenc, gint quality)
 833 {
 834   flacenc->quality = quality;
 835
 836 #define DO_UPDATE(name, val, str)                                               \
 837   G_STMT_START {                                                                \
 838     if (FLAC__stream_encoder_get_##name (flacenc->encoder) !=                   \
 839         flacenc_params[quality].val) {                                          \
 840       FLAC__stream_encoder_set_##name (flacenc->encoder,                        \
 841           flacenc_params[quality].val);                                         \
 842       g_object_notify (G_OBJECT (flacenc), str);                                \
 843     }                                                                           \
 844   } G_STMT_END
 845
 846   g_object_freeze_notify (G_OBJECT (flacenc));
 847
 848   if (flacenc->channels == 2 || flacenc->channels == 0) {
 849     DO_UPDATE (do_mid_side_stereo, mid_side, "mid_side_stereo");
 850     DO_UPDATE (loose_mid_side_stereo, loose_mid_side, "loose_mid_side");
 851   }
 852
 853   DO_UPDATE (blocksize, blocksize, "blocksize");
 854   DO_UPDATE (max_lpc_order, max_lpc_order, "max_lpc_order");
 855   DO_UPDATE (qlp_coeff_precision, qlp_coeff_precision, "qlp_coeff_precision");
 856   DO_UPDATE (do_qlp_coeff_prec_search, qlp_coeff_prec_search,
 857       "qlp_coeff_prec_search");
 858   DO_UPDATE (do_escape_coding, escape_coding, "escape_coding");
 859   DO_UPDATE (do_exhaustive_model_search, exhaustive_model_search,
 860       "exhaustive_model_search");
 861   DO_UPDATE (min_residual_partition_order, min_residual_partition_order,
 862       "min_residual_partition_order");
 863   DO_UPDATE (max_residual_partition_order, max_residual_partition_order,
 864       "max_residual_partition_order");
 865   DO_UPDATE (rice_parameter_search_dist, rice_parameter_search_dist,
 866       "rice_parameter_search_dist");
 867
 868 #undef DO_UPDATE
 869
 870   g_object_thaw_notify (G_OBJECT (flacenc));
 871
 872   return TRUE;
 873 }
 874
 875 static FLAC__StreamEncoderSeekStatus
 876 gst_flac_enc_seek_callback (const FLAC__StreamEncoder * encoder,
 877     FLAC__uint64 absolute_byte_offset, void *client_data)
 878 {
 879   GstFlacEnc *flacenc;
 880   GstEvent *event;
 881   GstPad *peerpad;
 882   GstSegment seg;
 883
 884   flacenc = GST_FLAC_ENC (client_data);
 885
 886   if (flacenc->stopped)
 887     return FLAC__STREAM_ENCODER_SEEK_STATUS_OK;
 888
 889   gst_segment_init (&seg, GST_FORMAT_BYTES);
 890   seg.start = absolute_byte_offset;
 891   seg.stop = GST_BUFFER_OFFSET_NONE;
 892   seg.time = 0;
 893   event = gst_event_new_segment (&seg);
 894
 895   if ((peerpad = gst_pad_get_peer (GST_AUDIO_ENCODER_SRC_PAD (flacenc)))) {
 896     gboolean ret = gst_pad_send_event (peerpad, event);
 897
 898     gst_object_unref (peerpad);
 899
 900     if (ret) {
 901       GST_DEBUG ("Seek to %" G_GUINT64_FORMAT " %s",
 902           (guint64) absolute_byte_offset, "succeeded");
 903     } else {
 904       GST_DEBUG ("Seek to %" G_GUINT64_FORMAT " %s",
 905           (guint64) absolute_byte_offset, "failed");
 906       return FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED;
 907     }
 908   } else {
 909     GST_DEBUG ("Seek to %" G_GUINT64_FORMAT " failed (no peer pad)",
 910         (guint64) absolute_byte_offset);
 911   }
 912
 913   flacenc->offset = absolute_byte_offset;
 914   return FLAC__STREAM_ENCODER_SEEK_STATUS_OK;
 915 }
 916
 917 static void
 918 notgst_value_array_append_buffer (GValue * array_val, GstBuffer * buf)
 919 {
 920   GValue value = { 0, };
 921
 922   g_value_init (&value, GST_TYPE_BUFFER);
 923   /* copy buffer to avoid problems with circular refcounts */
 924   buf = gst_buffer_copy (buf);
 925   /* again, for good measure */
 926   GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_IN_CAPS);
 927   gst_value_set_buffer (&value, buf);
 928   gst_buffer_unref (buf);
 929   gst_value_array_append_value (array_val, &value);
 930   g_value_unset (&value);
 931 }
 932
 933 #define HDR_TYPE_STREAMINFO     0
 934 #define HDR_TYPE_VORBISCOMMENT  4
 935
 936 static GstFlowReturn
 937 gst_flac_enc_process_stream_headers (GstFlacEnc * enc)
 938 {
 939   GstBuffer *vorbiscomment = NULL;
 940   GstBuffer *streaminfo = NULL;
 941   GstBuffer *marker = NULL;
 942   GValue array = { 0, };
 943   GstCaps *caps;
 944   GList *l;
 945   GstFlowReturn ret = GST_FLOW_OK;
 946
 947   caps = gst_caps_new_simple ("audio/x-flac",
 948       "channels", G_TYPE_INT, enc->channels,
 949       "rate", G_TYPE_INT, enc->sample_rate, NULL);
 950
 951   for (l = enc->headers; l != NULL; l = l->next) {
 952     GstBuffer *buf;
 953     guint8 *data;
 954     gsize size;
 955
 956     /* mark buffers so oggmux will ignore them if it already muxed the
 957      * header buffers from the streamheaders field in the caps */
 958     l->data = gst_buffer_make_writable (GST_BUFFER_CAST (l->data));
 959
 960     buf = GST_BUFFER_CAST (l->data);
 961     GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_IN_CAPS);
 962
 963     data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
 964
 965     /* find initial 4-byte marker which we need to skip later on */
 966     if (size == 4 && memcmp (data, "fLaC", 4) == 0) {
 967       marker = buf;
 968     } else if (size > 1 && (data[0] & 0x7f) == HDR_TYPE_STREAMINFO) {
 969       streaminfo = buf;
 970     } else if (size > 1 && (data[0] & 0x7f) == HDR_TYPE_VORBISCOMMENT) {
 971       vorbiscomment = buf;
 972     }
 973
 974     gst_buffer_unmap (buf, data, size);
 975   }
 976
 977   if (marker == NULL || streaminfo == NULL || vorbiscomment == NULL) {
 978     GST_WARNING_OBJECT (enc, "missing header %p %p %p, muxing into container "
 979         "formats may be broken", marker, streaminfo, vorbiscomment);
 980     goto push_headers;
 981   }
 982
 983   g_value_init (&array, GST_TYPE_ARRAY);
 984
 985   /* add marker including STREAMINFO header */
 986   {
 987     GstBuffer *buf;
 988     guint16 num;
 989     guint8 *bdata;
 990     gsize bsize, slen;
 991
 992     /* minus one for the marker that is merged with streaminfo here */
 993     num = g_list_length (enc->headers) - 1;
 994
 995     slen = gst_buffer_get_size (streaminfo);
 996     buf = gst_buffer_new_and_alloc (13 + slen);
 997
 998     bdata = gst_buffer_map (buf, &bsize, NULL, GST_MAP_WRITE);
 999     bdata[0] = 0x7f;
1000     memcpy (bdata + 1, "FLAC", 4);
1001     bdata[5] = 0x01;            /* mapping version major */
1002     bdata[6] = 0x00;            /* mapping version minor */
1003     bdata[7] = (num & 0xFF00) >> 8;
1004     bdata[8] = (num & 0x00FF) >> 0;
1005     memcpy (bdata + 9, "fLaC", 4);
1006     gst_buffer_extract (streaminfo, 0, bdata + 13, slen);
1007     gst_buffer_unmap (buf, bdata, bsize);
1008
1009     notgst_value_array_append_buffer (&array, buf);
1010     gst_buffer_unref (buf);
1011   }
1012
1013   /* add VORBISCOMMENT header */
1014   notgst_value_array_append_buffer (&array, vorbiscomment);
1015
1016   /* add other headers, if there are any */
1017   for (l = enc->headers; l != NULL; l = l->next) {
1018     GstBuffer *buf = GST_BUFFER_CAST (l->data);
1019
1020     if (buf != marker && buf != streaminfo && buf != vorbiscomment) {
1021       notgst_value_array_append_buffer (&array, buf);
1022     }
1023   }
1024
1025   gst_structure_set_value (gst_caps_get_structure (caps, 0),
1026       "streamheader", &array);
1027   g_value_unset (&array);
1028
1029 push_headers:
1030
1031   /* push header buffers; update caps, so when we push the first buffer the
1032    * negotiated caps will change to caps that include the streamheader field */
1033   for (l = enc->headers; l != NULL; l = l->next) {
1034     GstBuffer *buf;
1035
1036     buf = GST_BUFFER (l->data);
1037     GST_LOG_OBJECT (enc, "Pushing header buffer, size %u bytes",
1038         gst_buffer_get_size (buf));
1039 #if 0
1040     GST_MEMDUMP_OBJECT (enc, "header buffer", GST_BUFFER_DATA (buf),
1041         GST_BUFFER_SIZE (buf));
1042 #endif
1043     ret = gst_pad_push (GST_AUDIO_ENCODER_SRC_PAD (enc), buf);
1044     l->data = NULL;
1045   }
1046   g_list_free (enc->headers);
1047   enc->headers = NULL;
1048
1049   gst_caps_unref (caps);
1050
1051   return ret;
1052 }
1053
1054 static FLAC__StreamEncoderWriteStatus
1055 gst_flac_enc_write_callback (const FLAC__StreamEncoder * encoder,
1056     const FLAC__byte buffer[], size_t bytes,
1057     unsigned samples, unsigned current_frame, void *client_data)
1058 {
1059   GstFlowReturn ret = GST_FLOW_OK;
1060   GstFlacEnc *flacenc;
1061   GstBuffer *outbuf;
1062
1063   flacenc = GST_FLAC_ENC (client_data);
1064
1065   if (flacenc->stopped)
1066     return FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
1067
1068   outbuf = gst_buffer_new_and_alloc (bytes);
1069   gst_buffer_fill (outbuf, 0, buffer, bytes);
1070
1071   /* we assume libflac passes us stuff neatly framed */
1072   if (!flacenc->got_headers) {
1073     if (samples == 0) {
1074       GST_DEBUG_OBJECT (flacenc, "Got header, queueing (%u bytes)",
1075           (guint) bytes);
1076       flacenc->headers = g_list_append (flacenc->headers, outbuf);
1077       /* note: it's important that we increase our byte offset */
1078       goto out;
1079     } else {
1080       GST_INFO_OBJECT (flacenc, "Non-header packet, we have all headers now");
1081       ret = gst_flac_enc_process_stream_headers (flacenc);
1082       flacenc->got_headers = TRUE;
1083     }
1084   } else if (flacenc->got_headers && samples == 0) {
1085     /* header fixup, push downstream directly */
1086     GST_DEBUG_OBJECT (flacenc, "Fixing up headers at pos=%" G_GUINT64_FORMAT
1087         ", size=%u", flacenc->offset, (guint) bytes);
1088 #if 0
1089     GST_MEMDUMP_OBJECT (flacenc, "Presumed header fragment",
1090         GST_BUFFER_DATA (outbuf), GST_BUFFER_SIZE (outbuf));
1091 #endif
1092     ret = gst_pad_push (GST_AUDIO_ENCODER_SRC_PAD (flacenc), outbuf);
1093   } else {
1094     /* regular frame data, pass to base class */
1095     GST_LOG ("Pushing buffer: ts=%" GST_TIME_FORMAT ", samples=%u, size=%u, "
1096         "pos=%" G_GUINT64_FORMAT, GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (outbuf)),
1097         samples, (guint) bytes, flacenc->offset);
1098     ret = gst_audio_encoder_finish_frame (GST_AUDIO_ENCODER (flacenc),
1099         outbuf, samples);
1100   }
1101
1102   if (ret != GST_FLOW_OK)
1103     GST_DEBUG_OBJECT (flacenc, "flow: %s", gst_flow_get_name (ret));
1104
1105   flacenc->last_flow = ret;
1106
1107 out:
1108   flacenc->offset += bytes;
1109
1110   if (ret != GST_FLOW_OK)
1111     return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR;
1112
1113   return FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
1114 }
1115
1116 static FLAC__StreamEncoderTellStatus
1117 gst_flac_enc_tell_callback (const FLAC__StreamEncoder * encoder,
1118     FLAC__uint64 * absolute_byte_offset, void *client_data)
1119 {
1120   GstFlacEnc *flacenc = GST_FLAC_ENC (client_data);
1121
1122   *absolute_byte_offset = flacenc->offset;
1123
1124   return FLAC__STREAM_ENCODER_TELL_STATUS_OK;
1125 }
1126
1127 static gboolean
1128 gst_flac_enc_sink_event (GstAudioEncoder * enc, GstEvent * event)
1129 {
1130   GstFlacEnc *flacenc;
1131   GstTagList *taglist;
1132   gboolean ret = FALSE;
1133
1134   flacenc = GST_FLAC_ENC (enc);
1135
1136   GST_DEBUG ("Received %s event on sinkpad", GST_EVENT_TYPE_NAME (event));
1137
1138   switch (GST_EVENT_TYPE (event)) {
1139     case GST_EVENT_SEGMENT:{
1140       GstSegment seg;
1141       gint64 start, stream_time;
1142
1143       if (flacenc->offset == 0) {
1144         gst_event_copy_segment (event, &seg);
1145         start = seg.start;
1146         stream_time = seg.time;
1147       } else {
1148         start = -1;
1149         stream_time = -1;
1150       }
1151
1152       if (start > 0) {
1153         if (flacenc->offset > 0)
1154           GST_DEBUG ("Not handling mid-stream newsegment event");
1155         else
1156           GST_DEBUG ("Not handling newsegment event with non-zero start");
1157       } else {
1158         GstEvent *e;
1159
1160         gst_segment_init (&seg, GST_FORMAT_BYTES);
1161         e = gst_event_new_segment (&seg);
1162         ret = gst_pad_push_event (GST_AUDIO_ENCODER_SRC_PAD (enc), e);
1163       }
1164
1165       if (stream_time > 0) {
1166         GST_DEBUG ("Not handling non-zero stream time");
1167       }
1168
1169       /* don't push it downstream, we'll generate our own via seek to 0 */
1170       gst_event_unref (event);
1171       ret = TRUE;
1172       break;
1173     }
1174     case GST_EVENT_EOS:
1175       flacenc->eos = TRUE;
1176       break;
1177     case GST_EVENT_TAG:
1178       if (flacenc->tags) {
1179         gst_event_parse_tag (event, &taglist);
1180         gst_tag_list_insert (flacenc->tags, taglist,
1181             gst_tag_setter_get_tag_merge_mode (GST_TAG_SETTER (flacenc)));
1182       } else {
1183         g_assert_not_reached ();
1184       }
1185       break;
1186     default:
1187       break;
1188   }
1189
1190   return ret;
1191 }
1192
1193 static GstFlowReturn
1194 gst_flac_enc_handle_frame (GstAudioEncoder * enc, GstBuffer * buffer)
1195 {
1196   GstFlacEnc *flacenc;
1197   FLAC__int32 *data;
1198   gsize bsize;
1199   gint samples, width;
1200   gulong i;
1201   FLAC__bool res;
1202   gpointer bdata;
1203
1204   flacenc = GST_FLAC_ENC (enc);
1205
1206   /* base class ensures configuration */
1207   g_return_val_if_fail (flacenc->depth != 0, GST_FLOW_NOT_NEGOTIATED);
1208
1209   width = flacenc->width;
1210
1211   if (G_UNLIKELY (!buffer)) {
1212     if (flacenc->eos) {
1213       FLAC__stream_encoder_finish (flacenc->encoder);
1214     } else {
1215       /* can't handle intermittent draining/resyncing */
1216       GST_ELEMENT_WARNING (flacenc, STREAM, FORMAT, (NULL),
1217           ("Stream discontinuity detected. "
1218               "The output may have wrong timestamps, "
1219               "consider using audiorate to handle discontinuities"));
1220     }
1221     return flacenc->last_flow;
1222   }
1223
1224   bdata = gst_buffer_map (buffer, &bsize, NULL, GST_MAP_READ);
1225   samples = bsize / (width >> 3);
1226
1227   data = g_malloc (samples * sizeof (FLAC__int32));
1228
1229   if (width == 8) {
1230     gint8 *indata = (gint8 *) bdata;
1231
1232     for (i = 0; i < samples; i++)
1233       data[i] = (FLAC__int32) indata[i];
1234   } else if (width == 16) {
1235     gint16 *indata = (gint16 *) bdata;
1236
1237     for (i = 0; i < samples; i++)
1238       data[i] = (FLAC__int32) indata[i];
1239   } else if (width == 32) {
1240     gint32 *indata = (gint32 *) bdata;
1241
1242     for (i = 0; i < samples; i++)
1243       data[i] = (FLAC__int32) indata[i];
1244   } else {
1245     g_assert_not_reached ();
1246   }
1247   gst_buffer_unmap (buffer, bdata, bsize);
1248
1249   res = FLAC__stream_encoder_process_interleaved (flacenc->encoder,
1250       (const FLAC__int32 *) data, samples / flacenc->channels);
1251
1252   g_free (data);
1253
1254   if (!res) {
1255     if (flacenc->last_flow == GST_FLOW_OK)
1256       return GST_FLOW_ERROR;
1257     else
1258       return flacenc->last_flow;
1259   }
1260
1261   return GST_FLOW_OK;
1262 }
1263
1264 static void
1265 gst_flac_enc_set_property (GObject * object, guint prop_id,
1266     const GValue * value, GParamSpec * pspec)
1267 {
1268   GstFlacEnc *this = GST_FLAC_ENC (object);
1269
1270   GST_OBJECT_LOCK (this);
1271
1272   switch (prop_id) {
1273     case PROP_QUALITY:
1274       gst_flac_enc_update_quality (this, g_value_get_enum (value));
1275       break;
1276     case PROP_STREAMABLE_SUBSET:
1277       FLAC__stream_encoder_set_streamable_subset (this->encoder,
1278           g_value_get_boolean (value));
1279       break;
1280     case PROP_MID_SIDE_STEREO:
1281       FLAC__stream_encoder_set_do_mid_side_stereo (this->encoder,
1282           g_value_get_boolean (value));
1283       break;
1284     case PROP_LOOSE_MID_SIDE_STEREO:
1285       FLAC__stream_encoder_set_loose_mid_side_stereo (this->encoder,
1286           g_value_get_boolean (value));
1287       break;
1288     case PROP_BLOCKSIZE:
1289       FLAC__stream_encoder_set_blocksize (this->encoder,
1290           g_value_get_uint (value));
1291       break;
1292     case PROP_MAX_LPC_ORDER:
1293       FLAC__stream_encoder_set_max_lpc_order (this->encoder,
1294           g_value_get_uint (value));
1295       break;
1296     case PROP_QLP_COEFF_PRECISION:
1297       FLAC__stream_encoder_set_qlp_coeff_precision (this->encoder,
1298           g_value_get_uint (value));
1299       break;
1300     case PROP_QLP_COEFF_PREC_SEARCH:
1301       FLAC__stream_encoder_set_do_qlp_coeff_prec_search (this->encoder,
1302           g_value_get_boolean (value));
1303       break;
1304     case PROP_ESCAPE_CODING:
1305       FLAC__stream_encoder_set_do_escape_coding (this->encoder,
1306           g_value_get_boolean (value));
1307       break;
1308     case PROP_EXHAUSTIVE_MODEL_SEARCH:
1309       FLAC__stream_encoder_set_do_exhaustive_model_search (this->encoder,
1310           g_value_get_boolean (value));
1311       break;
1312     case PROP_MIN_RESIDUAL_PARTITION_ORDER:
1313       FLAC__stream_encoder_set_min_residual_partition_order (this->encoder,
1314           g_value_get_uint (value));
1315       break;
1316     case PROP_MAX_RESIDUAL_PARTITION_ORDER:
1317       FLAC__stream_encoder_set_max_residual_partition_order (this->encoder,
1318           g_value_get_uint (value));
1319       break;
1320     case PROP_RICE_PARAMETER_SEARCH_DIST:
1321       FLAC__stream_encoder_set_rice_parameter_search_dist (this->encoder,
1322           g_value_get_uint (value));
1323       break;
1324     case PROP_PADDING:
1325       this->padding = g_value_get_uint (value);
1326       break;
1327     case PROP_SEEKPOINTS:
1328       this->seekpoints = g_value_get_int (value);
1329       break;
1330     default:
1331       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1332       break;
1333   }
1334
1335   GST_OBJECT_UNLOCK (this);
1336 }
1337
1338 static void
1339 gst_flac_enc_get_property (GObject * object, guint prop_id,
1340     GValue * value, GParamSpec * pspec)
1341 {
1342   GstFlacEnc *this = GST_FLAC_ENC (object);
1343
1344   GST_OBJECT_LOCK (this);
1345
1346   switch (prop_id) {
1347     case PROP_QUALITY:
1348       g_value_set_enum (value, this->quality);
1349       break;
1350     case PROP_STREAMABLE_SUBSET:
1351       g_value_set_boolean (value,
1352           FLAC__stream_encoder_get_streamable_subset (this->encoder));
1353       break;
1354     case PROP_MID_SIDE_STEREO:
1355       g_value_set_boolean (value,
1356           FLAC__stream_encoder_get_do_mid_side_stereo (this->encoder));
1357       break;
1358     case PROP_LOOSE_MID_SIDE_STEREO:
1359       g_value_set_boolean (value,
1360           FLAC__stream_encoder_get_loose_mid_side_stereo (this->encoder));
1361       break;
1362     case PROP_BLOCKSIZE:
1363       g_value_set_uint (value,
1364           FLAC__stream_encoder_get_blocksize (this->encoder));
1365       break;
1366     case PROP_MAX_LPC_ORDER:
1367       g_value_set_uint (value,
1368           FLAC__stream_encoder_get_max_lpc_order (this->encoder));
1369       break;
1370     case PROP_QLP_COEFF_PRECISION:
1371       g_value_set_uint (value,
1372           FLAC__stream_encoder_get_qlp_coeff_precision (this->encoder));
1373       break;
1374     case PROP_QLP_COEFF_PREC_SEARCH:
1375       g_value_set_boolean (value,
1376           FLAC__stream_encoder_get_do_qlp_coeff_prec_search (this->encoder));
1377       break;
1378     case PROP_ESCAPE_CODING:
1379       g_value_set_boolean (value,
1380           FLAC__stream_encoder_get_do_escape_coding (this->encoder));
1381       break;
1382     case PROP_EXHAUSTIVE_MODEL_SEARCH:
1383       g_value_set_boolean (value,
1384           FLAC__stream_encoder_get_do_exhaustive_model_search (this->encoder));
1385       break;
1386     case PROP_MIN_RESIDUAL_PARTITION_ORDER:
1387       g_value_set_uint (value,
1388           FLAC__stream_encoder_get_min_residual_partition_order
1389           (this->encoder));
1390       break;
1391     case PROP_MAX_RESIDUAL_PARTITION_ORDER:
1392       g_value_set_uint (value,
1393           FLAC__stream_encoder_get_max_residual_partition_order
1394           (this->encoder));
1395       break;
1396     case PROP_RICE_PARAMETER_SEARCH_DIST:
1397       g_value_set_uint (value,
1398           FLAC__stream_encoder_get_rice_parameter_search_dist (this->encoder));
1399       break;
1400     case PROP_PADDING:
1401       g_value_set_uint (value, this->padding);
1402       break;
1403     case PROP_SEEKPOINTS:
1404       g_value_set_int (value, this->seekpoints);
1405       break;
1406     default:
1407       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1408       break;
1409   }
1410
1411   GST_OBJECT_UNLOCK (this);
1412 }