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 /* TODO: - We currently don't handle discontinuities in the stream in a useful
  21  *         way and instead rely on the developer plugging in audiorate if
  22  *         the stream contains discontinuities.
  23  */
  24
  25 #ifdef HAVE_CONFIG_H
  26 #include "config.h"
  27 #endif
  28 #include <stdlib.h>
  29 #include <string.h>
  30
  31 #include <gstflacenc.h>
  32 #include <gst/audio/audio.h>
  33 #include <gst/audio/multichannel.h>
  34 #include <gst/tag/tag.h>
  35 #include <gst/gsttagsetter.h>
  36
  37 /* Taken from http://flac.sourceforge.net/format.html#frame_header */
  38 static const GstAudioChannelPosition channel_positions[8][8] = {
  39   {GST_AUDIO_CHANNEL_POSITION_FRONT_MONO},
  40   {GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
  41       GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT}, {
  42         GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
  43         GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
  44       GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER}, {
  45         GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
  46         GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
  47         GST_AUDIO_CHANNEL_POSITION_REAR_LEFT,
  48       GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT}, {
  49         GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
  50         GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
  51         GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER,
  52         GST_AUDIO_CHANNEL_POSITION_REAR_LEFT,
  53       GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT}, {
  54         GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
  55         GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
  56         GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER,
  57         GST_AUDIO_CHANNEL_POSITION_LFE,
  58         GST_AUDIO_CHANNEL_POSITION_REAR_LEFT,
  59       GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT},
  60   /* FIXME: 7/8 channel layouts are not defined in the FLAC specs */
  61   {
  62         GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
  63         GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
  64         GST_AUDIO_CHANNEL_POSITION_REAR_LEFT,
  65         GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT,
  66         GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER,
  67         GST_AUDIO_CHANNEL_POSITION_LFE,
  68       GST_AUDIO_CHANNEL_POSITION_REAR_CENTER}, {
  69         GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
  70         GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
  71         GST_AUDIO_CHANNEL_POSITION_REAR_LEFT,
  72         GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT,
  73         GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER,
  74         GST_AUDIO_CHANNEL_POSITION_LFE,
  75         GST_AUDIO_CHANNEL_POSITION_SIDE_LEFT,
  76       GST_AUDIO_CHANNEL_POSITION_SIDE_RIGHT}
  77 };
  78
  79 #define FLAC_SINK_CAPS \
  80   "audio/x-raw-int, "               \
  81   "endianness = (int) BYTE_ORDER, " \
  82   "signed = (boolean) TRUE, "       \
  83   "width = (int) 8, "               \
  84   "depth = (int) 8, "               \
  85   "rate = (int) [ 1, 655350 ], "    \
  86   "channels = (int) [ 1, 8 ]; "     \
  87   "audio/x-raw-int, "               \
  88   "endianness = (int) BYTE_ORDER, " \
  89   "signed = (boolean) TRUE, "       \
  90   "width = (int) 16, "              \
  91   "depth = (int) { 12, 16 }, "      \
  92   "rate = (int) [ 1, 655350 ], "    \
  93   "channels = (int) [ 1, 8 ]; "     \
  94   "audio/x-raw-int, "               \
  95   "endianness = (int) BYTE_ORDER, " \
  96   "signed = (boolean) TRUE, "       \
  97   "width = (int) 32, "              \
  98   "depth = (int) { 20, 24 }, "      \
  99   "rate = (int) [ 1, 655350 ], "    \
 100   "channels = (int) [ 1, 8 ]"
 101
 102 static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE ("src",
 103     GST_PAD_SRC,
 104     GST_PAD_ALWAYS,
 105     GST_STATIC_CAPS ("audio/x-flac")
 106     );
 107
 108 static GstStaticPadTemplate sink_factory = GST_STATIC_PAD_TEMPLATE ("sink",
 109     GST_PAD_SINK,
 110     GST_PAD_ALWAYS,
 111     GST_STATIC_CAPS (FLAC_SINK_CAPS)
 112     );
 113
 114 enum
 115 {
 116   PROP_0,
 117   PROP_QUALITY,
 118   PROP_STREAMABLE_SUBSET,
 119   PROP_MID_SIDE_STEREO,
 120   PROP_LOOSE_MID_SIDE_STEREO,
 121   PROP_BLOCKSIZE,
 122   PROP_MAX_LPC_ORDER,
 123   PROP_QLP_COEFF_PRECISION,
 124   PROP_QLP_COEFF_PREC_SEARCH,
 125   PROP_ESCAPE_CODING,
 126   PROP_EXHAUSTIVE_MODEL_SEARCH,
 127   PROP_MIN_RESIDUAL_PARTITION_ORDER,
 128   PROP_MAX_RESIDUAL_PARTITION_ORDER,
 129   PROP_RICE_PARAMETER_SEARCH_DIST
 130 };
 131
 132 GST_DEBUG_CATEGORY_STATIC (flacenc_debug);
 133 #define GST_CAT_DEFAULT flacenc_debug
 134
 135
 136 #define _do_init(type)                                                          \
 137   G_STMT_START{                                                                 \
 138     static const GInterfaceInfo tag_setter_info = {                             \
 139       NULL,                                                                     \
 140       NULL,                                                                     \
 141       NULL                                                                      \
 142     };                                                                          \
 143     g_type_add_interface_static (type, GST_TYPE_TAG_SETTER,                     \
 144                                  &tag_setter_info);                             \
 145   }G_STMT_END
 146
 147 GST_BOILERPLATE_FULL (GstFlacEnc, gst_flac_enc, GstElement, GST_TYPE_ELEMENT,
 148     _do_init);
 149
 150 static void gst_flac_enc_finalize (GObject * object);
 151
 152 static gboolean gst_flac_enc_sink_setcaps (GstPad * pad, GstCaps * caps);
 153 static GstCaps *gst_flac_enc_sink_getcaps (GstPad * pad);
 154 static gboolean gst_flac_enc_sink_event (GstPad * pad, GstEvent * event);
 155 static GstFlowReturn gst_flac_enc_chain (GstPad * pad, GstBuffer * buffer);
 156
 157 static gboolean gst_flac_enc_update_quality (GstFlacEnc * flacenc,
 158     gint quality);
 159 static void gst_flac_enc_set_property (GObject * object, guint prop_id,
 160     const GValue * value, GParamSpec * pspec);
 161 static void gst_flac_enc_get_property (GObject * object, guint prop_id,
 162     GValue * value, GParamSpec * pspec);
 163 static GstStateChangeReturn gst_flac_enc_change_state (GstElement * element,
 164     GstStateChange transition);
 165
 166 #ifdef LEGACY_FLAC
 167 static FLAC__StreamEncoderWriteStatus
 168 gst_flac_enc_write_callback (const FLAC__SeekableStreamEncoder * encoder,
 169     const FLAC__byte buffer[], unsigned bytes,
 170     unsigned samples, unsigned current_frame, void *client_data);
 171 static FLAC__SeekableStreamEncoderSeekStatus
 172 gst_flac_enc_seek_callback (const FLAC__SeekableStreamEncoder * encoder,
 173     FLAC__uint64 absolute_byte_offset, void *client_data);
 174 static FLAC__SeekableStreamEncoderTellStatus
 175 gst_flac_enc_tell_callback (const FLAC__SeekableStreamEncoder * encoder,
 176     FLAC__uint64 * absolute_byte_offset, void *client_data);
 177 #else
 178 static FLAC__StreamEncoderWriteStatus
 179 gst_flac_enc_write_callback (const FLAC__StreamEncoder * encoder,
 180     const FLAC__byte buffer[], size_t bytes,
 181     unsigned samples, unsigned current_frame, void *client_data);
 182 static FLAC__StreamEncoderSeekStatus
 183 gst_flac_enc_seek_callback (const FLAC__StreamEncoder * encoder,
 184     FLAC__uint64 absolute_byte_offset, void *client_data);
 185 static FLAC__StreamEncoderTellStatus
 186 gst_flac_enc_tell_callback (const FLAC__StreamEncoder * encoder,
 187     FLAC__uint64 * absolute_byte_offset, void *client_data);
 188 #endif
 189
 190 typedef struct
 191 {
 192   gboolean exhaustive_model_search;
 193   gboolean escape_coding;
 194   gboolean mid_side;
 195   gboolean loose_mid_side;
 196   guint qlp_coeff_precision;
 197   gboolean qlp_coeff_prec_search;
 198   guint min_residual_partition_order;
 199   guint max_residual_partition_order;
 200   guint rice_parameter_search_dist;
 201   guint max_lpc_order;
 202   guint blocksize;
 203 }
 204 GstFlacEncParams;
 205
 206 static const GstFlacEncParams flacenc_params[] = {
 207   {FALSE, FALSE, FALSE, FALSE, 0, FALSE, 2, 2, 0, 0, 1152},
 208   {FALSE, FALSE, TRUE, TRUE, 0, FALSE, 2, 2, 0, 0, 1152},
 209   {FALSE, FALSE, TRUE, FALSE, 0, FALSE, 0, 3, 0, 0, 1152},
 210   {FALSE, FALSE, FALSE, FALSE, 0, FALSE, 3, 3, 0, 6, 4608},
 211   {FALSE, FALSE, TRUE, TRUE, 0, FALSE, 3, 3, 0, 8, 4608},
 212   {FALSE, FALSE, TRUE, FALSE, 0, FALSE, 3, 3, 0, 8, 4608},
 213   {FALSE, FALSE, TRUE, FALSE, 0, FALSE, 0, 4, 0, 8, 4608},
 214   {TRUE, FALSE, TRUE, FALSE, 0, FALSE, 0, 6, 0, 8, 4608},
 215   {TRUE, FALSE, TRUE, FALSE, 0, FALSE, 0, 6, 0, 12, 4608},
 216   {TRUE, TRUE, TRUE, FALSE, 0, FALSE, 0, 16, 0, 32, 4608},
 217 };
 218
 219 #define DEFAULT_QUALITY 5
 220
 221 #define GST_TYPE_FLAC_ENC_QUALITY (gst_flac_enc_quality_get_type ())
 222 GType
 223 gst_flac_enc_quality_get_type (void)
 224 {
 225   static GType qtype = 0;
 226
 227   if (qtype == 0) {
 228     static const GEnumValue values[] = {
 229       {0, "0 - Fastest compression", "0"},
 230       {1, "1", "1"},
 231       {2, "2", "2"},
 232       {3, "3", "3"},
 233       {4, "4", "4"},
 234       {5, "5 - Default", "5"},
 235       {6, "6", "6"},
 236       {7, "7", "7"},
 237       {8, "8 - Highest compression", "8"},
 238       {9, "9 - Insane", "9"},
 239       {0, NULL, NULL}
 240     };
 241
 242     qtype = g_enum_register_static ("GstFlacEncQuality", values);
 243   }
 244   return qtype;
 245 }
 246
 247 static void
 248 gst_flac_enc_base_init (gpointer g_class)
 249 {
 250   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
 251
 252   gst_element_class_add_pad_template (element_class,
 253       gst_static_pad_template_get (&src_factory));
 254   gst_element_class_add_pad_template (element_class,
 255       gst_static_pad_template_get (&sink_factory));
 256
 257   gst_element_class_set_details_simple (element_class, "FLAC audio encoder",
 258       "Codec/Encoder/Audio",
 259       "Encodes audio with the FLAC lossless audio encoder",
 260       "Wim Taymans <wim.taymans@chello.be>");
 261
 262   GST_DEBUG_CATEGORY_INIT (flacenc_debug, "flacenc", 0,
 263       "Flac encoding element");
 264 }
 265
 266 static void
 267 gst_flac_enc_class_init (GstFlacEncClass * klass)
 268 {
 269   GObjectClass *gobject_class;
 270   GstElementClass *gstelement_class;
 271
 272   gobject_class = (GObjectClass *) klass;
 273   gstelement_class = (GstElementClass *) klass;
 274
 275   gobject_class->set_property = gst_flac_enc_set_property;
 276   gobject_class->get_property = gst_flac_enc_get_property;
 277   gobject_class->finalize = gst_flac_enc_finalize;
 278
 279   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_QUALITY,
 280       g_param_spec_enum ("quality",
 281           "Quality",
 282           "Speed versus compression tradeoff",
 283           GST_TYPE_FLAC_ENC_QUALITY, DEFAULT_QUALITY,
 284           G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 285   g_object_class_install_property (G_OBJECT_CLASS (klass),
 286       PROP_STREAMABLE_SUBSET, g_param_spec_boolean ("streamable_subset",
 287           "Streamable subset",
 288           "true to limit encoder to generating a Subset stream, else false",
 289           TRUE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 290   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_MID_SIDE_STEREO,
 291       g_param_spec_boolean ("mid_side_stereo", "Do mid side stereo",
 292           "Do mid side stereo (only for stereo input)",
 293           flacenc_params[DEFAULT_QUALITY].mid_side,
 294           G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 295   g_object_class_install_property (G_OBJECT_CLASS (klass),
 296       PROP_LOOSE_MID_SIDE_STEREO, g_param_spec_boolean ("loose_mid_side_stereo",
 297           "Loose mid side stereo", "Loose mid side stereo",
 298           flacenc_params[DEFAULT_QUALITY].loose_mid_side,
 299           G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 300   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_BLOCKSIZE,
 301       g_param_spec_uint ("blocksize", "Blocksize", "Blocksize in samples",
 302           FLAC__MIN_BLOCK_SIZE, FLAC__MAX_BLOCK_SIZE,
 303           flacenc_params[DEFAULT_QUALITY].blocksize,
 304           G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 305   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_MAX_LPC_ORDER,
 306       g_param_spec_uint ("max_lpc_order", "Max LPC order",
 307           "Max LPC order; 0 => use only fixed predictors", 0,
 308           FLAC__MAX_LPC_ORDER, flacenc_params[DEFAULT_QUALITY].max_lpc_order,
 309           G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 310   g_object_class_install_property (G_OBJECT_CLASS (klass),
 311       PROP_QLP_COEFF_PRECISION, g_param_spec_uint ("qlp_coeff_precision",
 312           "QLP coefficients precision",
 313           "Precision in bits of quantized linear-predictor coefficients; 0 = automatic",
 314           0, 32, flacenc_params[DEFAULT_QUALITY].qlp_coeff_precision,
 315           G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 316   g_object_class_install_property (G_OBJECT_CLASS (klass),
 317       PROP_QLP_COEFF_PREC_SEARCH, g_param_spec_boolean ("qlp_coeff_prec_search",
 318           "Do QLP coefficients precision search",
 319           "false = use qlp_coeff_precision, "
 320           "true = search around qlp_coeff_precision, take best",
 321           flacenc_params[DEFAULT_QUALITY].qlp_coeff_prec_search,
 322           G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 323   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_ESCAPE_CODING,
 324       g_param_spec_boolean ("escape_coding", "Do Escape coding",
 325           "search for escape codes in the entropy coding stage "
 326           "for slightly better compression",
 327           flacenc_params[DEFAULT_QUALITY].escape_coding,
 328           G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 329   g_object_class_install_property (G_OBJECT_CLASS (klass),
 330       PROP_EXHAUSTIVE_MODEL_SEARCH,
 331       g_param_spec_boolean ("exhaustive_model_search",
 332           "Do exhaustive model search",
 333           "do exhaustive search of LP coefficient quantization (expensive!)",
 334           flacenc_params[DEFAULT_QUALITY].exhaustive_model_search,
 335           G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 336   g_object_class_install_property (G_OBJECT_CLASS (klass),
 337       PROP_MIN_RESIDUAL_PARTITION_ORDER,
 338       g_param_spec_uint ("min_residual_partition_order",
 339           "Min residual partition order",
 340           "Min residual partition order (above 4 doesn't usually help much)", 0,
 341           16, flacenc_params[DEFAULT_QUALITY].min_residual_partition_order,
 342           G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 343   g_object_class_install_property (G_OBJECT_CLASS (klass),
 344       PROP_MAX_RESIDUAL_PARTITION_ORDER,
 345       g_param_spec_uint ("max_residual_partition_order",
 346           "Max residual partition order",
 347           "Max residual partition order (above 4 doesn't usually help much)", 0,
 348           16, flacenc_params[DEFAULT_QUALITY].max_residual_partition_order,
 349           G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 350   g_object_class_install_property (G_OBJECT_CLASS (klass),
 351       PROP_RICE_PARAMETER_SEARCH_DIST,
 352       g_param_spec_uint ("rice_parameter_search_dist",
 353           "rice_parameter_search_dist",
 354           "0 = try only calc'd parameter k; else try all [k-dist..k+dist] "
 355           "parameters, use best", 0, FLAC__MAX_RICE_PARTITION_ORDER,
 356           flacenc_params[DEFAULT_QUALITY].rice_parameter_search_dist,
 357           G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 358
 359   gstelement_class->change_state = gst_flac_enc_change_state;
 360 }
 361
 362 static void
 363 gst_flac_enc_init (GstFlacEnc * flacenc, GstFlacEncClass * klass)
 364 {
 365   flacenc->sinkpad = gst_pad_new_from_static_template (&sink_factory, "sink");
 366   gst_pad_set_chain_function (flacenc->sinkpad,
 367       GST_DEBUG_FUNCPTR (gst_flac_enc_chain));
 368   gst_pad_set_event_function (flacenc->sinkpad,
 369       GST_DEBUG_FUNCPTR (gst_flac_enc_sink_event));
 370   gst_pad_set_getcaps_function (flacenc->sinkpad,
 371       GST_DEBUG_FUNCPTR (gst_flac_enc_sink_getcaps));
 372   gst_pad_set_setcaps_function (flacenc->sinkpad,
 373       GST_DEBUG_FUNCPTR (gst_flac_enc_sink_setcaps));
 374   gst_element_add_pad (GST_ELEMENT (flacenc), flacenc->sinkpad);
 375
 376   flacenc->srcpad = gst_pad_new_from_static_template (&src_factory, "src");
 377   gst_pad_use_fixed_caps (flacenc->srcpad);
 378   gst_element_add_pad (GST_ELEMENT (flacenc), flacenc->srcpad);
 379
 380 #ifdef LEGACY_FLAC
 381   flacenc->encoder = FLAC__seekable_stream_encoder_new ();
 382 #else
 383   flacenc->encoder = FLAC__stream_encoder_new ();
 384 #endif
 385
 386   flacenc->offset = 0;
 387   flacenc->samples_written = 0;
 388   flacenc->channels = 0;
 389   gst_flac_enc_update_quality (flacenc, DEFAULT_QUALITY);
 390   flacenc->tags = gst_tag_list_new ();
 391   flacenc->got_headers = FALSE;
 392   flacenc->headers = NULL;
 393   flacenc->last_flow = GST_FLOW_OK;
 394 }
 395
 396 static void
 397 gst_flac_enc_finalize (GObject * object)
 398 {
 399   GstFlacEnc *flacenc = GST_FLAC_ENC (object);
 400
 401   gst_tag_list_free (flacenc->tags);
 402 #ifdef LEGACY_FLAC
 403   FLAC__seekable_stream_encoder_delete (flacenc->encoder);
 404 #else
 405   FLAC__stream_encoder_delete (flacenc->encoder);
 406 #endif
 407
 408   G_OBJECT_CLASS (parent_class)->finalize (object);
 409 }
 410
 411 static void
 412 add_one_tag (const GstTagList * list, const gchar * tag, gpointer user_data)
 413 {
 414   GList *comments;
 415   GList *it;
 416   GstFlacEnc *flacenc = GST_FLAC_ENC (user_data);
 417
 418   comments = gst_tag_to_vorbis_comments (list, tag);
 419   for (it = comments; it != NULL; it = it->next) {
 420     FLAC__StreamMetadata_VorbisComment_Entry commment_entry;
 421
 422     commment_entry.length = strlen (it->data);
 423     commment_entry.entry = it->data;
 424     FLAC__metadata_object_vorbiscomment_insert_comment (flacenc->meta[0],
 425         flacenc->meta[0]->data.vorbis_comment.num_comments,
 426         commment_entry, TRUE);
 427     g_free (it->data);
 428   }
 429   g_list_free (comments);
 430 }
 431
 432 static void
 433 gst_flac_enc_set_metadata (GstFlacEnc * flacenc)
 434 {
 435   const GstTagList *user_tags;
 436   GstTagList *copy;
 437
 438   g_return_if_fail (flacenc != NULL);
 439   user_tags = gst_tag_setter_get_tag_list (GST_TAG_SETTER (flacenc));
 440   if ((flacenc->tags == NULL) && (user_tags == NULL)) {
 441     return;
 442   }
 443   copy = gst_tag_list_merge (user_tags, flacenc->tags,
 444       gst_tag_setter_get_tag_merge_mode (GST_TAG_SETTER (flacenc)));
 445   flacenc->meta = g_malloc (sizeof (FLAC__StreamMetadata **));
 446
 447   flacenc->meta[0] =
 448       FLAC__metadata_object_new (FLAC__METADATA_TYPE_VORBIS_COMMENT);
 449   gst_tag_list_foreach (copy, add_one_tag, flacenc);
 450
 451 #ifdef LEGACY_FLAC
 452   if (FLAC__seekable_stream_encoder_set_metadata (flacenc->encoder,
 453           flacenc->meta, 1) != true)
 454 #else
 455   if (FLAC__stream_encoder_set_metadata (flacenc->encoder,
 456           flacenc->meta, 1) != true)
 457 #endif
 458     g_warning ("Dude, i'm already initialized!");
 459   gst_tag_list_free (copy);
 460 }
 461
 462 static void
 463 gst_flac_enc_caps_append_structure_with_widths (GstCaps * caps,
 464     GstStructure * s)
 465 {
 466   GstStructure *tmp;
 467   GValue list = { 0, };
 468   GValue depth = { 0, };
 469
 470
 471   tmp = gst_structure_copy (s);
 472   gst_structure_set (tmp, "width", G_TYPE_INT, 8, "depth", G_TYPE_INT, 8, NULL);
 473   gst_caps_append_structure (caps, tmp);
 474
 475   tmp = gst_structure_copy (s);
 476
 477   g_value_init (&depth, G_TYPE_INT);
 478   g_value_init (&list, GST_TYPE_LIST);
 479   g_value_set_int (&depth, 12);
 480   gst_value_list_append_value (&list, &depth);
 481   g_value_set_int (&depth, 16);
 482   gst_value_list_append_value (&list, &depth);
 483
 484   gst_structure_set (tmp, "width", G_TYPE_INT, 16, NULL);
 485   gst_structure_set_value (tmp, "depth", &list);
 486   gst_caps_append_structure (caps, tmp);
 487
 488   g_value_reset (&list);
 489
 490   tmp = s;
 491
 492   g_value_set_int (&depth, 20);
 493   gst_value_list_append_value (&list, &depth);
 494   g_value_set_int (&depth, 24);
 495   gst_value_list_append_value (&list, &depth);
 496
 497   gst_structure_set (tmp, "width", G_TYPE_INT, 32, NULL);
 498   gst_structure_set_value (tmp, "depth", &list);
 499   gst_caps_append_structure (caps, tmp);
 500
 501   g_value_unset (&list);
 502   g_value_unset (&depth);
 503 }
 504
 505 static GstCaps *
 506 gst_flac_enc_sink_getcaps (GstPad * pad)
 507 {
 508   GstCaps *ret = NULL;
 509
 510   GST_OBJECT_LOCK (pad);
 511
 512   if (GST_PAD_CAPS (pad)) {
 513     ret = gst_caps_ref (GST_PAD_CAPS (pad));
 514   } else {
 515     gint i, c;
 516
 517     ret = gst_caps_new_empty ();
 518
 519     gst_flac_enc_caps_append_structure_with_widths (ret,
 520         gst_structure_new ("audio/x-raw-int",
 521             "endianness", G_TYPE_INT, G_BYTE_ORDER,
 522             "signed", G_TYPE_BOOLEAN, TRUE,
 523             "rate", GST_TYPE_INT_RANGE, 1, 655350,
 524             "channels", GST_TYPE_INT_RANGE, 1, 2, NULL));
 525
 526     for (i = 3; i <= 8; i++) {
 527       GValue positions = { 0, };
 528       GValue pos = { 0, };
 529       GstStructure *s;
 530
 531       g_value_init (&positions, GST_TYPE_ARRAY);
 532       g_value_init (&pos, GST_TYPE_AUDIO_CHANNEL_POSITION);
 533
 534       for (c = 0; c < i; c++) {
 535         g_value_set_enum (&pos, channel_positions[i - 1][c]);
 536         gst_value_array_append_value (&positions, &pos);
 537       }
 538       g_value_unset (&pos);
 539
 540       s = gst_structure_new ("audio/x-raw-int",
 541           "endianness", G_TYPE_INT, G_BYTE_ORDER,
 542           "signed", G_TYPE_BOOLEAN, TRUE,
 543           "rate", GST_TYPE_INT_RANGE, 1, 655350,
 544           "channels", G_TYPE_INT, i, NULL);
 545       gst_structure_set_value (s, "channel-positions", &positions);
 546       g_value_unset (&positions);
 547
 548       gst_flac_enc_caps_append_structure_with_widths (ret, s);
 549     }
 550   }
 551
 552   GST_OBJECT_UNLOCK (pad);
 553
 554   GST_DEBUG_OBJECT (pad, "Return caps %" GST_PTR_FORMAT, ret);
 555
 556   return ret;
 557 }
 558
 559 static guint64
 560 gst_flac_enc_query_peer_total_samples (GstFlacEnc * flacenc, GstPad * pad)
 561 {
 562   GstFormat fmt = GST_FORMAT_DEFAULT;
 563   gint64 duration;
 564
 565   if (gst_pad_query_peer_duration (pad, &fmt, &duration)
 566       && fmt == GST_FORMAT_DEFAULT && duration != GST_CLOCK_TIME_NONE)
 567     goto done;
 568
 569   fmt = GST_FORMAT_TIME;
 570
 571   if (gst_pad_query_peer_duration (pad, &fmt, &duration) &&
 572       fmt == GST_FORMAT_TIME && duration != GST_CLOCK_TIME_NONE) {
 573     duration = GST_FRAMES_TO_CLOCK_TIME (duration, flacenc->sample_rate);
 574
 575     goto done;
 576   }
 577
 578   GST_DEBUG_OBJECT (flacenc, "Upstream reported no total samples");
 579   return GST_CLOCK_TIME_NONE;
 580
 581 done:
 582   GST_DEBUG_OBJECT (flacenc,
 583       "Upstream reported %" G_GUINT64_FORMAT " total samples", duration);
 584
 585   return duration;
 586 }
 587
 588 static gboolean
 589 gst_flac_enc_sink_setcaps (GstPad * pad, GstCaps * caps)
 590 {
 591   GstFlacEnc *flacenc;
 592   GstStructure *structure;
 593   guint64 total_samples = GST_CLOCK_TIME_NONE;
 594
 595 #ifdef LEGACY_FLAC
 596   FLAC__SeekableStreamEncoderState state;
 597 #else
 598   FLAC__StreamEncoderInitStatus init_status;
 599 #endif
 600   gint depth, chans, rate, width;
 601
 602   flacenc = GST_FLAC_ENC (gst_pad_get_parent (pad));
 603
 604 #ifdef LEGACY_FLAC
 605   if (FLAC__seekable_stream_encoder_get_state (flacenc->encoder) !=
 606       FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED)
 607 #else
 608   if (FLAC__stream_encoder_get_state (flacenc->encoder) !=
 609       FLAC__STREAM_ENCODER_UNINITIALIZED)
 610 #endif
 611
 612     goto encoder_already_initialized;
 613
 614   structure = gst_caps_get_structure (caps, 0);
 615
 616   if (!gst_structure_get_int (structure, "channels", &chans) ||
 617       !gst_structure_get_int (structure, "width", &width) ||
 618       !gst_structure_get_int (structure, "depth", &depth) ||
 619       !gst_structure_get_int (structure, "rate", &rate)) {
 620     GST_DEBUG_OBJECT (flacenc, "incomplete caps: %" GST_PTR_FORMAT, caps);
 621     return FALSE;
 622   }
 623
 624   flacenc->channels = chans;
 625   flacenc->width = width;
 626   flacenc->depth = depth;
 627   flacenc->sample_rate = rate;
 628
 629   caps = gst_caps_new_simple ("audio/x-flac",
 630       "channels", G_TYPE_INT, flacenc->channels,
 631       "rate", G_TYPE_INT, flacenc->sample_rate, NULL);
 632
 633   if (!gst_pad_set_caps (flacenc->srcpad, caps))
 634     goto setting_src_caps_failed;
 635
 636   gst_caps_unref (caps);
 637
 638   total_samples = gst_flac_enc_query_peer_total_samples (flacenc, pad);
 639
 640 #ifdef LEGACY_FLAC
 641   FLAC__seekable_stream_encoder_set_bits_per_sample (flacenc->encoder,
 642       flacenc->depth);
 643   FLAC__seekable_stream_encoder_set_sample_rate (flacenc->encoder,
 644       flacenc->sample_rate);
 645   FLAC__seekable_stream_encoder_set_channels (flacenc->encoder,
 646       flacenc->channels);
 647
 648   if (total_samples != GST_CLOCK_TIME_NONE)
 649     FLAC__seekable_stream_encoder_set_total_samples_estimate (flacenc->encoder,
 650         total_samples);
 651
 652   FLAC__seekable_stream_encoder_set_write_callback (flacenc->encoder,
 653       gst_flac_enc_write_callback);
 654   FLAC__seekable_stream_encoder_set_seek_callback (flacenc->encoder,
 655       gst_flac_enc_seek_callback);
 656   FLAC__seekable_stream_encoder_set_tell_callback (flacenc->encoder,
 657       gst_flac_enc_tell_callback);
 658
 659   FLAC__seekable_stream_encoder_set_client_data (flacenc->encoder, flacenc);
 660 #else
 661   FLAC__stream_encoder_set_bits_per_sample (flacenc->encoder, flacenc->depth);
 662   FLAC__stream_encoder_set_sample_rate (flacenc->encoder, flacenc->sample_rate);
 663   FLAC__stream_encoder_set_channels (flacenc->encoder, flacenc->channels);
 664
 665   if (total_samples != GST_CLOCK_TIME_NONE)
 666     FLAC__stream_encoder_set_total_samples_estimate (flacenc->encoder,
 667         total_samples);
 668 #endif
 669
 670   gst_flac_enc_set_metadata (flacenc);
 671
 672 #ifdef LEGACY_FLAC
 673   state = FLAC__seekable_stream_encoder_init (flacenc->encoder);
 674   if (state != FLAC__STREAM_ENCODER_OK)
 675     goto failed_to_initialize;
 676 #else
 677   init_status = FLAC__stream_encoder_init_stream (flacenc->encoder,
 678       gst_flac_enc_write_callback, gst_flac_enc_seek_callback,
 679       gst_flac_enc_tell_callback, NULL, flacenc);
 680   if (init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK)
 681     goto failed_to_initialize;
 682 #endif
 683
 684   gst_object_unref (flacenc);
 685
 686   return TRUE;
 687
 688 encoder_already_initialized:
 689   {
 690     g_warning ("flac already initialized -- fixme allow this");
 691     gst_object_unref (flacenc);
 692     return FALSE;
 693   }
 694 setting_src_caps_failed:
 695   {
 696     GST_DEBUG_OBJECT (flacenc,
 697         "Couldn't set caps on source pad: %" GST_PTR_FORMAT, caps);
 698     gst_caps_unref (caps);
 699     gst_object_unref (flacenc);
 700     return FALSE;
 701   }
 702 failed_to_initialize:
 703   {
 704     GST_ELEMENT_ERROR (flacenc, LIBRARY, INIT, (NULL),
 705         ("could not initialize encoder (wrong parameters?)"));
 706     gst_object_unref (flacenc);
 707     return FALSE;
 708   }
 709 }
 710
 711 static gboolean
 712 gst_flac_enc_update_quality (GstFlacEnc * flacenc, gint quality)
 713 {
 714   flacenc->quality = quality;
 715
 716 #ifdef LEGACY_FLAC
 717 #define DO_UPDATE(name, val, str)                                               \
 718   G_STMT_START {                                                                \
 719     if (FLAC__seekable_stream_encoder_get_##name (flacenc->encoder) !=          \
 720         flacenc_params[quality].val) {                                          \
 721       FLAC__seekable_stream_encoder_set_##name (flacenc->encoder,               \
 722           flacenc_params[quality].val);                                         \
 723       g_object_notify (G_OBJECT (flacenc), str);                                \
 724     }                                                                           \
 725   } G_STMT_END
 726
 727 #else
 728 #define DO_UPDATE(name, val, str)                                               \
 729   G_STMT_START {                                                                \
 730     if (FLAC__stream_encoder_get_##name (flacenc->encoder) !=                   \
 731         flacenc_params[quality].val) {                                          \
 732       FLAC__stream_encoder_set_##name (flacenc->encoder,                        \
 733           flacenc_params[quality].val);                                         \
 734       g_object_notify (G_OBJECT (flacenc), str);                                \
 735     }                                                                           \
 736   } G_STMT_END
 737
 738 #endif
 739
 740   g_object_freeze_notify (G_OBJECT (flacenc));
 741
 742   if (flacenc->channels == 2 || flacenc->channels == 0) {
 743     DO_UPDATE (do_mid_side_stereo, mid_side, "mid_side_stereo");
 744     DO_UPDATE (loose_mid_side_stereo, loose_mid_side, "loose_mid_side");
 745   }
 746
 747   DO_UPDATE (blocksize, blocksize, "blocksize");
 748   DO_UPDATE (max_lpc_order, max_lpc_order, "max_lpc_order");
 749   DO_UPDATE (qlp_coeff_precision, qlp_coeff_precision, "qlp_coeff_precision");
 750   DO_UPDATE (do_qlp_coeff_prec_search, qlp_coeff_prec_search,
 751       "qlp_coeff_prec_search");
 752   DO_UPDATE (do_escape_coding, escape_coding, "escape_coding");
 753   DO_UPDATE (do_exhaustive_model_search, exhaustive_model_search,
 754       "exhaustive_model_search");
 755   DO_UPDATE (min_residual_partition_order, min_residual_partition_order,
 756       "min_residual_partition_order");
 757   DO_UPDATE (max_residual_partition_order, max_residual_partition_order,
 758       "max_residual_partition_order");
 759   DO_UPDATE (rice_parameter_search_dist, rice_parameter_search_dist,
 760       "rice_parameter_search_dist");
 761
 762 #undef DO_UPDATE
 763
 764   g_object_thaw_notify (G_OBJECT (flacenc));
 765
 766   return TRUE;
 767 }
 768
 769 #ifdef LEGACY_FLAC
 770 static FLAC__SeekableStreamEncoderSeekStatus
 771 gst_flac_enc_seek_callback (const FLAC__SeekableStreamEncoder * encoder,
 772     FLAC__uint64 absolute_byte_offset, void *client_data)
 773 #else
 774 static FLAC__StreamEncoderSeekStatus
 775 gst_flac_enc_seek_callback (const FLAC__StreamEncoder * encoder,
 776     FLAC__uint64 absolute_byte_offset, void *client_data)
 777 #endif
 778 {
 779   GstFlacEnc *flacenc;
 780   GstEvent *event;
 781   GstPad *peerpad;
 782
 783   flacenc = GST_FLAC_ENC (client_data);
 784
 785   if (flacenc->stopped)
 786 #ifdef LEGACY_FLAC
 787     return FLAC__SEEKABLE_STREAM_ENCODER_SEEK_STATUS_OK;
 788 #else
 789     return FLAC__STREAM_ENCODER_SEEK_STATUS_OK;
 790 #endif
 791   event = gst_event_new_new_segment (TRUE, 1.0, GST_FORMAT_BYTES,
 792       absolute_byte_offset, GST_BUFFER_OFFSET_NONE, 0);
 793
 794   if ((peerpad = gst_pad_get_peer (flacenc->srcpad))) {
 795     gboolean ret = gst_pad_send_event (peerpad, event);
 796
 797     gst_object_unref (peerpad);
 798
 799     if (ret) {
 800       GST_DEBUG ("Seek to %" G_GUINT64_FORMAT " %s", absolute_byte_offset,
 801           "succeeded");
 802     } else {
 803       GST_DEBUG ("Seek to %" G_GUINT64_FORMAT " %s", absolute_byte_offset,
 804           "failed");
 805 #ifdef LEGACY_FLAC
 806       return FLAC__SEEKABLE_STREAM_ENCODER_SEEK_STATUS_ERROR;
 807 #else
 808       return FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED;
 809 #endif
 810
 811     }
 812   } else {
 813     GST_DEBUG ("Seek to %" G_GUINT64_FORMAT " failed (no peer pad)",
 814         absolute_byte_offset);
 815   }
 816
 817   flacenc->offset = absolute_byte_offset;
 818 #ifdef LEGACY_FLAC
 819   return FLAC__SEEKABLE_STREAM_ENCODER_SEEK_STATUS_OK;
 820 #else
 821   return FLAC__STREAM_ENCODER_SEEK_STATUS_OK;
 822 #endif
 823 }
 824
 825 static void
 826 notgst_value_array_append_buffer (GValue * array_val, GstBuffer * buf)
 827 {
 828   GValue value = { 0, };
 829
 830   g_value_init (&value, GST_TYPE_BUFFER);
 831   /* copy buffer to avoid problems with circular refcounts */
 832   buf = gst_buffer_copy (buf);
 833   /* again, for good measure */
 834   GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_IN_CAPS);
 835   gst_value_set_buffer (&value, buf);
 836   gst_buffer_unref (buf);
 837   gst_value_array_append_value (array_val, &value);
 838   g_value_unset (&value);
 839 }
 840
 841 #define HDR_TYPE_STREAMINFO     0
 842 #define HDR_TYPE_VORBISCOMMENT  4
 843
 844 static void
 845 gst_flac_enc_process_stream_headers (GstFlacEnc * enc)
 846 {
 847   GstBuffer *vorbiscomment = NULL;
 848   GstBuffer *streaminfo = NULL;
 849   GstBuffer *marker = NULL;
 850   GValue array = { 0, };
 851   GstCaps *caps;
 852   GList *l;
 853
 854   caps = gst_caps_new_simple ("audio/x-flac",
 855       "channels", G_TYPE_INT, enc->channels,
 856       "rate", G_TYPE_INT, enc->sample_rate, NULL);
 857
 858   for (l = enc->headers; l != NULL; l = l->next) {
 859     const guint8 *data;
 860     guint size;
 861
 862     /* mark buffers so oggmux will ignore them if it already muxed the
 863      * header buffers from the streamheaders field in the caps */
 864     l->data = gst_buffer_make_metadata_writable (GST_BUFFER (l->data));
 865     GST_BUFFER_FLAG_SET (GST_BUFFER (l->data), GST_BUFFER_FLAG_IN_CAPS);
 866
 867     data = GST_BUFFER_DATA (GST_BUFFER_CAST (l->data));
 868     size = GST_BUFFER_SIZE (GST_BUFFER_CAST (l->data));
 869
 870     /* find initial 4-byte marker which we need to skip later on */
 871     if (size == 4 && memcmp (data, "fLaC", 4) == 0) {
 872       marker = GST_BUFFER_CAST (l->data);
 873     } else if (size > 1 && (data[0] & 0x7f) == HDR_TYPE_STREAMINFO) {
 874       streaminfo = GST_BUFFER_CAST (l->data);
 875     } else if (size > 1 && (data[0] & 0x7f) == HDR_TYPE_VORBISCOMMENT) {
 876       vorbiscomment = GST_BUFFER_CAST (l->data);
 877     }
 878   }
 879
 880   if (marker == NULL || streaminfo == NULL || vorbiscomment == NULL) {
 881     GST_WARNING_OBJECT (enc, "missing header %p %p %p, muxing into container "
 882         "formats may be broken", marker, streaminfo, vorbiscomment);
 883     goto push_headers;
 884   }
 885
 886   g_value_init (&array, GST_TYPE_ARRAY);
 887
 888   /* add marker including STREAMINFO header */
 889   {
 890     GstBuffer *buf;
 891     guint16 num;
 892
 893     /* minus one for the marker that is merged with streaminfo here */
 894     num = g_list_length (enc->headers) - 1;
 895
 896     buf = gst_buffer_new_and_alloc (13 + GST_BUFFER_SIZE (streaminfo));
 897     GST_BUFFER_DATA (buf)[0] = 0x7f;
 898     memcpy (GST_BUFFER_DATA (buf) + 1, "FLAC", 4);
 899     GST_BUFFER_DATA (buf)[5] = 0x01;    /* mapping version major */
 900     GST_BUFFER_DATA (buf)[6] = 0x00;    /* mapping version minor */
 901     GST_BUFFER_DATA (buf)[7] = (num & 0xFF00) >> 8;
 902     GST_BUFFER_DATA (buf)[8] = (num & 0x00FF) >> 0;
 903     memcpy (GST_BUFFER_DATA (buf) + 9, "fLaC", 4);
 904     memcpy (GST_BUFFER_DATA (buf) + 13, GST_BUFFER_DATA (streaminfo),
 905         GST_BUFFER_SIZE (streaminfo));
 906     notgst_value_array_append_buffer (&array, buf);
 907     gst_buffer_unref (buf);
 908   }
 909
 910   /* add VORBISCOMMENT header */
 911   notgst_value_array_append_buffer (&array, vorbiscomment);
 912
 913   /* add other headers, if there are any */
 914   for (l = enc->headers; l != NULL; l = l->next) {
 915     if (GST_BUFFER_CAST (l->data) != marker &&
 916         GST_BUFFER_CAST (l->data) != streaminfo &&
 917         GST_BUFFER_CAST (l->data) != vorbiscomment) {
 918       notgst_value_array_append_buffer (&array, GST_BUFFER_CAST (l->data));
 919     }
 920   }
 921
 922   gst_structure_set_value (gst_caps_get_structure (caps, 0),
 923       "streamheader", &array);
 924   g_value_unset (&array);
 925
 926 push_headers:
 927
 928   gst_pad_set_caps (enc->srcpad, caps);
 929
 930   /* push header buffers; update caps, so when we push the first buffer the
 931    * negotiated caps will change to caps that include the streamheader field */
 932   for (l = enc->headers; l != NULL; l = l->next) {
 933     GstBuffer *buf;
 934
 935     buf = GST_BUFFER (l->data);
 936     gst_buffer_set_caps (buf, caps);
 937     GST_LOG ("Pushing header buffer, size %u bytes", GST_BUFFER_SIZE (buf));
 938     (void) gst_pad_push (enc->srcpad, buf);
 939     l->data = NULL;
 940   }
 941   g_list_free (enc->headers);
 942   enc->headers = NULL;
 943
 944   gst_caps_unref (caps);
 945 }
 946
 947 #ifdef LEGACY_FLAC
 948 static FLAC__StreamEncoderWriteStatus
 949 gst_flac_enc_write_callback (const FLAC__SeekableStreamEncoder * encoder,
 950     const FLAC__byte buffer[], unsigned bytes,
 951     unsigned samples, unsigned current_frame, void *client_data)
 952 #else
 953 static FLAC__StreamEncoderWriteStatus
 954 gst_flac_enc_write_callback (const FLAC__StreamEncoder * encoder,
 955     const FLAC__byte buffer[], size_t bytes,
 956     unsigned samples, unsigned current_frame, void *client_data)
 957 #endif
 958 {
 959   GstFlowReturn ret = GST_FLOW_OK;
 960   GstFlacEnc *flacenc;
 961   GstBuffer *outbuf;
 962
 963   flacenc = GST_FLAC_ENC (client_data);
 964
 965   if (flacenc->stopped)
 966     return FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
 967
 968   outbuf = gst_buffer_new_and_alloc (bytes);
 969   memcpy (GST_BUFFER_DATA (outbuf), buffer, bytes);
 970
 971   if (samples > 0 && flacenc->samples_written != (guint64) - 1) {
 972     guint64 granulepos;
 973
 974     GST_BUFFER_TIMESTAMP (outbuf) = flacenc->start_ts +
 975         GST_FRAMES_TO_CLOCK_TIME (flacenc->samples_written,
 976         flacenc->sample_rate);
 977     GST_BUFFER_DURATION (outbuf) =
 978         GST_FRAMES_TO_CLOCK_TIME (samples, flacenc->sample_rate);
 979     /* offset_end = granulepos for ogg muxer */
 980     granulepos =
 981         flacenc->granulepos_offset + flacenc->samples_written + samples;
 982     GST_BUFFER_OFFSET_END (outbuf) = granulepos;
 983     /* offset = timestamp corresponding to granulepos for ogg muxer
 984      * (see vorbisenc for a much more elaborate version of this) */
 985     GST_BUFFER_OFFSET (outbuf) =
 986         GST_FRAMES_TO_CLOCK_TIME (granulepos, flacenc->sample_rate);
 987   } else {
 988     GST_BUFFER_TIMESTAMP (outbuf) = GST_CLOCK_TIME_NONE;
 989     GST_BUFFER_DURATION (outbuf) = GST_CLOCK_TIME_NONE;
 990     GST_BUFFER_OFFSET (outbuf) =
 991         flacenc->samples_written * flacenc->width * flacenc->channels;
 992     GST_BUFFER_OFFSET_END (outbuf) = 0;
 993     GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_IN_CAPS);
 994   }
 995
 996   /* we assume libflac passes us stuff neatly framed */
 997   if (!flacenc->got_headers) {
 998     if (samples == 0) {
 999       GST_DEBUG_OBJECT (flacenc, "Got header, queueing (%u bytes)", bytes);
1000       flacenc->headers = g_list_append (flacenc->headers, outbuf);
1001       /* note: it's important that we increase our byte offset */
1002       goto out;
1003     } else {
1004       GST_INFO_OBJECT (flacenc, "Non-header packet, we have all headers now");
1005       gst_flac_enc_process_stream_headers (flacenc);
1006       flacenc->got_headers = TRUE;
1007     }
1008   } else if (flacenc->got_headers && samples == 0) {
1009     GST_WARNING_OBJECT (flacenc, "Got header packet after data packets");
1010   }
1011
1012   GST_LOG ("Pushing buffer: ts=%" GST_TIME_FORMAT ", samples=%u, size=%u, "
1013       "pos=%" G_GUINT64_FORMAT, GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (outbuf)),
1014       samples, bytes, flacenc->offset);
1015
1016   gst_buffer_set_caps (outbuf, GST_PAD_CAPS (flacenc->srcpad));
1017   ret = gst_pad_push (flacenc->srcpad, outbuf);
1018
1019   if (ret != GST_FLOW_OK)
1020     GST_DEBUG_OBJECT (flacenc, "flow: %s", gst_flow_get_name (ret));
1021
1022   flacenc->last_flow = ret;
1023
1024 out:
1025
1026   flacenc->offset += bytes;
1027   flacenc->samples_written += samples;
1028
1029   if (GST_FLOW_IS_FATAL (ret) || ret == GST_FLOW_NOT_LINKED)
1030     return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR;
1031
1032   return FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
1033 }
1034
1035 #ifdef LEGACY_FLAC
1036 static FLAC__SeekableStreamEncoderTellStatus
1037 gst_flac_enc_tell_callback (const FLAC__SeekableStreamEncoder * encoder,
1038     FLAC__uint64 * absolute_byte_offset, void *client_data)
1039 #else
1040 static FLAC__StreamEncoderTellStatus
1041 gst_flac_enc_tell_callback (const FLAC__StreamEncoder * encoder,
1042     FLAC__uint64 * absolute_byte_offset, void *client_data)
1043 #endif
1044 {
1045   GstFlacEnc *flacenc = GST_FLAC_ENC (client_data);
1046
1047   *absolute_byte_offset = flacenc->offset;
1048
1049 #ifdef LEGACY_FLAC
1050   return FLAC__SEEKABLE_STREAM_ENCODER_TELL_STATUS_OK;
1051 #else
1052   return FLAC__STREAM_ENCODER_TELL_STATUS_OK;
1053 #endif
1054 }
1055
1056 static gboolean
1057 gst_flac_enc_sink_event (GstPad * pad, GstEvent * event)
1058 {
1059   GstFlacEnc *flacenc;
1060   GstTagList *taglist;
1061   gboolean ret = TRUE;
1062
1063   flacenc = GST_FLAC_ENC (gst_pad_get_parent (pad));
1064
1065   GST_DEBUG ("Received %s event on sinkpad", GST_EVENT_TYPE_NAME (event));
1066
1067   switch (GST_EVENT_TYPE (event)) {
1068     case GST_EVENT_NEWSEGMENT:{
1069       GstFormat format;
1070       gint64 start, stream_time;
1071
1072       if (flacenc->offset == 0) {
1073         gst_event_parse_new_segment (event, NULL, NULL, &format, &start, NULL,
1074             &stream_time);
1075       } else {
1076         start = -1;
1077       }
1078       if (start != 0) {
1079         if (flacenc->offset > 0)
1080           GST_DEBUG ("Not handling mid-stream newsegment event");
1081         else
1082           GST_DEBUG ("Not handling newsegment event with non-zero start");
1083       } else {
1084         GstEvent *e = gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_BYTES,
1085             0, -1, 0);
1086
1087         ret = gst_pad_push_event (flacenc->srcpad, e);
1088       }
1089       if (stream_time != 0) {
1090         GST_DEBUG ("Not handling non-zero stream time");
1091       }
1092       gst_event_unref (event);
1093       /* don't push it downstream, we'll generate our own via seek to 0 */
1094       break;
1095     }
1096     case GST_EVENT_EOS:
1097 #ifdef LEGACY_FLAC
1098       FLAC__seekable_stream_encoder_finish (flacenc->encoder);
1099 #else
1100       FLAC__stream_encoder_finish (flacenc->encoder);
1101 #endif
1102       ret = gst_pad_event_default (pad, event);
1103       break;
1104     case GST_EVENT_TAG:
1105       if (flacenc->tags) {
1106         gst_event_parse_tag (event, &taglist);
1107         gst_tag_list_insert (flacenc->tags, taglist, GST_TAG_MERGE_REPLACE);
1108       } else {
1109         g_assert_not_reached ();
1110       }
1111       ret = gst_pad_event_default (pad, event);
1112       break;
1113     default:
1114       ret = gst_pad_event_default (pad, event);
1115       break;
1116   }
1117
1118   gst_object_unref (flacenc);
1119
1120   return ret;
1121 }
1122
1123 static gboolean
1124 gst_flac_enc_check_discont (GstFlacEnc * flacenc, GstClockTime expected,
1125     GstClockTime timestamp)
1126 {
1127   guint allowed_diff = GST_SECOND / flacenc->sample_rate / 2;
1128
1129   if ((timestamp + allowed_diff < expected)
1130       || (timestamp > expected + allowed_diff)) {
1131     GST_ELEMENT_WARNING (flacenc, STREAM, FORMAT, (NULL),
1132         ("Stream discontinuity detected (wanted %" GST_TIME_FORMAT " got %"
1133             GST_TIME_FORMAT "). The output will have wrong timestamps,"
1134             " consider using audiorate to handle discontinuities",
1135             GST_TIME_ARGS (expected), GST_TIME_ARGS (timestamp)));
1136     return TRUE;
1137   }
1138
1139   /* TODO: Do something to handle discontinuities in the stream. The FLAC encoder
1140    * unfortunately doesn't have any way to flush it's internal buffers */
1141
1142   return FALSE;
1143 }
1144
1145 static GstFlowReturn
1146 gst_flac_enc_chain (GstPad * pad, GstBuffer * buffer)
1147 {
1148   GstFlacEnc *flacenc;
1149   FLAC__int32 *data;
1150   gulong insize;
1151   gint samples, width;
1152   gulong i;
1153   FLAC__bool res;
1154
1155   flacenc = GST_FLAC_ENC (GST_PAD_PARENT (pad));
1156
1157   /* make sure setcaps has been called and the encoder is set up */
1158   if (G_UNLIKELY (flacenc->depth == 0))
1159     return GST_FLOW_NOT_NEGOTIATED;
1160
1161   width = flacenc->width;
1162
1163   /* Save the timestamp of the first buffer. This will be later
1164    * used as offset for all following buffers */
1165   if (flacenc->start_ts == GST_CLOCK_TIME_NONE) {
1166     if (GST_BUFFER_TIMESTAMP_IS_VALID (buffer)) {
1167       flacenc->start_ts = GST_BUFFER_TIMESTAMP (buffer);
1168       flacenc->granulepos_offset = gst_util_uint64_scale
1169           (GST_BUFFER_TIMESTAMP (buffer), flacenc->sample_rate, GST_SECOND);
1170     } else {
1171       flacenc->start_ts = 0;
1172       flacenc->granulepos_offset = 0;
1173     }
1174   }
1175
1176   /* Check if we have a continous stream, if not drop some samples or the buffer or
1177    * insert some silence samples */
1178   if (flacenc->next_ts != GST_CLOCK_TIME_NONE
1179       && GST_BUFFER_TIMESTAMP_IS_VALID (buffer)) {
1180     gst_flac_enc_check_discont (flacenc, flacenc->next_ts,
1181         GST_BUFFER_TIMESTAMP (buffer));
1182   }
1183
1184   if (GST_BUFFER_TIMESTAMP_IS_VALID (buffer)
1185       && GST_BUFFER_DURATION_IS_VALID (buffer))
1186     flacenc->next_ts =
1187         GST_BUFFER_TIMESTAMP (buffer) + GST_BUFFER_DURATION (buffer);
1188   else
1189     flacenc->next_ts = GST_CLOCK_TIME_NONE;
1190
1191   insize = GST_BUFFER_SIZE (buffer);
1192   samples = insize / (width >> 3);
1193
1194   data = g_malloc (samples * sizeof (FLAC__int32));
1195
1196   if (width == 8) {
1197     gint8 *indata = (gint8 *) GST_BUFFER_DATA (buffer);
1198
1199     for (i = 0; i < samples; i++)
1200       data[i] = (FLAC__int32) indata[i];
1201   } else if (width == 16) {
1202     gint16 *indata = (gint16 *) GST_BUFFER_DATA (buffer);
1203
1204     for (i = 0; i < samples; i++)
1205       data[i] = (FLAC__int32) indata[i];
1206   } else if (width == 32) {
1207     gint32 *indata = (gint32 *) GST_BUFFER_DATA (buffer);
1208
1209     for (i = 0; i < samples; i++)
1210       data[i] = (FLAC__int32) indata[i];
1211   } else {
1212     g_assert_not_reached ();
1213   }
1214
1215   gst_buffer_unref (buffer);
1216
1217 #ifdef LEGACY_FLAC
1218   res = FLAC__seekable_stream_encoder_process_interleaved (flacenc->encoder,
1219       (const FLAC__int32 *) data, samples / flacenc->channels);
1220 #else
1221   res = FLAC__stream_encoder_process_interleaved (flacenc->encoder,
1222       (const FLAC__int32 *) data, samples / flacenc->channels);
1223 #endif
1224
1225   g_free (data);
1226
1227   if (!res) {
1228     if (flacenc->last_flow == GST_FLOW_OK)
1229       return GST_FLOW_ERROR;
1230     else
1231       return flacenc->last_flow;
1232   }
1233
1234   return GST_FLOW_OK;
1235 }
1236
1237 static void
1238 gst_flac_enc_set_property (GObject * object, guint prop_id,
1239     const GValue * value, GParamSpec * pspec)
1240 {
1241   GstFlacEnc *this = GST_FLAC_ENC (object);
1242
1243   GST_OBJECT_LOCK (this);
1244
1245   switch (prop_id) {
1246     case PROP_QUALITY:
1247       gst_flac_enc_update_quality (this, g_value_get_enum (value));
1248       break;
1249     case PROP_STREAMABLE_SUBSET:
1250 #ifdef LEGACY_FLAC
1251       FLAC__seekable_stream_encoder_set_streamable_subset (this->encoder,
1252           g_value_get_boolean (value));
1253 #else
1254       FLAC__stream_encoder_set_streamable_subset (this->encoder,
1255           g_value_get_boolean (value));
1256 #endif
1257       break;
1258     case PROP_MID_SIDE_STEREO:
1259 #ifdef LEGACY_FLAC
1260       FLAC__seekable_stream_encoder_set_do_mid_side_stereo (this->encoder,
1261           g_value_get_boolean (value));
1262 #else
1263       FLAC__stream_encoder_set_do_mid_side_stereo (this->encoder,
1264           g_value_get_boolean (value));
1265 #endif
1266       break;
1267     case PROP_LOOSE_MID_SIDE_STEREO:
1268 #ifdef LEGACY_FLAC
1269       FLAC__seekable_stream_encoder_set_loose_mid_side_stereo (this->encoder,
1270           g_value_get_boolean (value));
1271 #else
1272       FLAC__stream_encoder_set_loose_mid_side_stereo (this->encoder,
1273           g_value_get_boolean (value));
1274 #endif
1275       break;
1276     case PROP_BLOCKSIZE:
1277 #ifdef LEGACY_FLAC
1278       FLAC__seekable_stream_encoder_set_blocksize (this->encoder,
1279           g_value_get_uint (value));
1280 #else
1281       FLAC__stream_encoder_set_blocksize (this->encoder,
1282           g_value_get_uint (value));
1283 #endif
1284       break;
1285     case PROP_MAX_LPC_ORDER:
1286 #ifdef LEGACY_FLAC
1287       FLAC__seekable_stream_encoder_set_max_lpc_order (this->encoder,
1288           g_value_get_uint (value));
1289 #else
1290       FLAC__stream_encoder_set_max_lpc_order (this->encoder,
1291           g_value_get_uint (value));
1292 #endif
1293       break;
1294     case PROP_QLP_COEFF_PRECISION:
1295 #ifdef LEGACY_FLAC
1296       FLAC__seekable_stream_encoder_set_qlp_coeff_precision (this->encoder,
1297           g_value_get_uint (value));
1298 #else
1299       FLAC__stream_encoder_set_qlp_coeff_precision (this->encoder,
1300           g_value_get_uint (value));
1301 #endif
1302       break;
1303     case PROP_QLP_COEFF_PREC_SEARCH:
1304 #ifdef LEGACY_FLAC
1305       FLAC__seekable_stream_encoder_set_do_qlp_coeff_prec_search (this->encoder,
1306           g_value_get_boolean (value));
1307 #else
1308       FLAC__stream_encoder_set_do_qlp_coeff_prec_search (this->encoder,
1309           g_value_get_boolean (value));
1310 #endif
1311       break;
1312     case PROP_ESCAPE_CODING:
1313 #ifdef LEGACY_FLAC
1314       FLAC__seekable_stream_encoder_set_do_escape_coding (this->encoder,
1315           g_value_get_boolean (value));
1316 #else
1317       FLAC__stream_encoder_set_do_escape_coding (this->encoder,
1318           g_value_get_boolean (value));
1319 #endif
1320       break;
1321     case PROP_EXHAUSTIVE_MODEL_SEARCH:
1322 #ifdef LEGACY_FLAC
1323       FLAC__seekable_stream_encoder_set_do_exhaustive_model_search
1324           (this->encoder, g_value_get_boolean (value));
1325 #else
1326       FLAC__stream_encoder_set_do_exhaustive_model_search (this->encoder,
1327           g_value_get_boolean (value));
1328 #endif
1329       break;
1330     case PROP_MIN_RESIDUAL_PARTITION_ORDER:
1331 #ifdef LEGACY_FLAC
1332       FLAC__seekable_stream_encoder_set_min_residual_partition_order
1333           (this->encoder, g_value_get_uint (value));
1334 #else
1335       FLAC__stream_encoder_set_min_residual_partition_order (this->encoder,
1336           g_value_get_uint (value));
1337 #endif
1338       break;
1339     case PROP_MAX_RESIDUAL_PARTITION_ORDER:
1340 #ifdef LEGACY_FLAC
1341       FLAC__seekable_stream_encoder_set_max_residual_partition_order
1342           (this->encoder, g_value_get_uint (value));
1343 #else
1344       FLAC__stream_encoder_set_max_residual_partition_order (this->encoder,
1345           g_value_get_uint (value));
1346 #endif
1347       break;
1348     case PROP_RICE_PARAMETER_SEARCH_DIST:
1349 #ifdef LEGACY_FLAC
1350       FLAC__seekable_stream_encoder_set_rice_parameter_search_dist
1351           (this->encoder, g_value_get_uint (value));
1352 #else
1353       FLAC__stream_encoder_set_rice_parameter_search_dist (this->encoder,
1354           g_value_get_uint (value));
1355 #endif
1356       break;
1357     default:
1358       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1359       break;
1360   }
1361
1362   GST_OBJECT_UNLOCK (this);
1363 }
1364
1365 static void
1366 gst_flac_enc_get_property (GObject * object, guint prop_id,
1367     GValue * value, GParamSpec * pspec)
1368 {
1369   GstFlacEnc *this = GST_FLAC_ENC (object);
1370
1371   GST_OBJECT_LOCK (this);
1372
1373   switch (prop_id) {
1374     case PROP_QUALITY:
1375       g_value_set_enum (value, this->quality);
1376       break;
1377     case PROP_STREAMABLE_SUBSET:
1378 #ifdef LEGACY_FLAC
1379       g_value_set_boolean (value,
1380           FLAC__seekable_stream_encoder_get_streamable_subset (this->encoder));
1381 #else
1382       g_value_set_boolean (value,
1383           FLAC__stream_encoder_get_streamable_subset (this->encoder));
1384 #endif
1385       break;
1386     case PROP_MID_SIDE_STEREO:
1387 #ifdef LEGACY_FLAC
1388       g_value_set_boolean (value,
1389           FLAC__seekable_stream_encoder_get_do_mid_side_stereo (this->encoder));
1390 #else
1391       g_value_set_boolean (value,
1392           FLAC__stream_encoder_get_do_mid_side_stereo (this->encoder));
1393 #endif
1394       break;
1395     case PROP_LOOSE_MID_SIDE_STEREO:
1396 #ifdef LEGACY_FLAC
1397       g_value_set_boolean (value,
1398           FLAC__seekable_stream_encoder_get_loose_mid_side_stereo
1399           (this->encoder));
1400 #else
1401       g_value_set_boolean (value,
1402           FLAC__stream_encoder_get_loose_mid_side_stereo (this->encoder));
1403 #endif
1404       break;
1405     case PROP_BLOCKSIZE:
1406 #ifdef LEGACY_FLAC
1407       g_value_set_uint (value,
1408           FLAC__seekable_stream_encoder_get_blocksize (this->encoder));
1409 #else
1410       g_value_set_uint (value,
1411           FLAC__stream_encoder_get_blocksize (this->encoder));
1412 #endif
1413       break;
1414     case PROP_MAX_LPC_ORDER:
1415 #ifdef LEGACY_FLAC
1416       g_value_set_uint (value,
1417           FLAC__seekable_stream_encoder_get_max_lpc_order (this->encoder));
1418 #else
1419       g_value_set_uint (value,
1420           FLAC__stream_encoder_get_max_lpc_order (this->encoder));
1421 #endif
1422       break;
1423     case PROP_QLP_COEFF_PRECISION:
1424 #ifdef LEGACY_FLAC
1425       g_value_set_uint (value,
1426           FLAC__seekable_stream_encoder_get_qlp_coeff_precision
1427           (this->encoder));
1428 #else
1429       g_value_set_uint (value,
1430           FLAC__stream_encoder_get_qlp_coeff_precision (this->encoder));
1431 #endif
1432       break;
1433     case PROP_QLP_COEFF_PREC_SEARCH:
1434 #ifdef LEGACY_FLAC
1435       g_value_set_boolean (value,
1436           FLAC__seekable_stream_encoder_get_do_qlp_coeff_prec_search
1437           (this->encoder));
1438 #else
1439       g_value_set_boolean (value,
1440           FLAC__stream_encoder_get_do_qlp_coeff_prec_search (this->encoder));
1441 #endif
1442       break;
1443     case PROP_ESCAPE_CODING:
1444 #ifdef LEGACY_FLAC
1445       g_value_set_boolean (value,
1446           FLAC__seekable_stream_encoder_get_do_escape_coding (this->encoder));
1447 #else
1448       g_value_set_boolean (value,
1449           FLAC__stream_encoder_get_do_escape_coding (this->encoder));
1450 #endif
1451       break;
1452     case PROP_EXHAUSTIVE_MODEL_SEARCH:
1453 #ifdef LEGACY_FLAC
1454       g_value_set_boolean (value,
1455           FLAC__seekable_stream_encoder_get_do_exhaustive_model_search
1456           (this->encoder));
1457 #else
1458       g_value_set_boolean (value,
1459           FLAC__stream_encoder_get_do_exhaustive_model_search (this->encoder));
1460 #endif
1461       break;
1462     case PROP_MIN_RESIDUAL_PARTITION_ORDER:
1463 #ifdef LEGACY_FLAC
1464       g_value_set_uint (value,
1465           FLAC__seekable_stream_encoder_get_min_residual_partition_order
1466           (this->encoder));
1467 #else
1468       g_value_set_uint (value,
1469           FLAC__stream_encoder_get_min_residual_partition_order
1470           (this->encoder));
1471 #endif
1472       break;
1473     case PROP_MAX_RESIDUAL_PARTITION_ORDER:
1474 #ifdef LEGACY_FLAC
1475       g_value_set_uint (value,
1476           FLAC__seekable_stream_encoder_get_max_residual_partition_order
1477           (this->encoder));
1478 #else
1479       g_value_set_uint (value,
1480           FLAC__stream_encoder_get_max_residual_partition_order
1481           (this->encoder));
1482 #endif
1483       break;
1484     case PROP_RICE_PARAMETER_SEARCH_DIST:
1485 #ifdef LEGACY_FLAC
1486       g_value_set_uint (value,
1487           FLAC__seekable_stream_encoder_get_rice_parameter_search_dist
1488           (this->encoder));
1489 #else
1490       g_value_set_uint (value,
1491           FLAC__stream_encoder_get_rice_parameter_search_dist (this->encoder));
1492 #endif
1493       break;
1494     default:
1495       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1496       break;
1497   }
1498
1499   GST_OBJECT_UNLOCK (this);
1500 }
1501
1502 static GstStateChangeReturn
1503 gst_flac_enc_change_state (GstElement * element, GstStateChange transition)
1504 {
1505   GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
1506   GstFlacEnc *flacenc = GST_FLAC_ENC (element);
1507
1508   switch (transition) {
1509     case GST_STATE_CHANGE_NULL_TO_READY:
1510     case GST_STATE_CHANGE_READY_TO_PAUSED:
1511       flacenc->stopped = FALSE;
1512       flacenc->start_ts = GST_CLOCK_TIME_NONE;
1513       flacenc->next_ts = GST_CLOCK_TIME_NONE;
1514       flacenc->granulepos_offset = 0;
1515       break;
1516     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
1517     default:
1518       break;
1519   }
1520
1521   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
1522
1523   switch (transition) {
1524     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
1525       break;
1526     case GST_STATE_CHANGE_PAUSED_TO_READY:
1527 #ifdef LEGACY_FLAC
1528       if (FLAC__seekable_stream_encoder_get_state (flacenc->encoder) !=
1529           FLAC__STREAM_ENCODER_UNINITIALIZED) {
1530         flacenc->stopped = TRUE;
1531         FLAC__seekable_stream_encoder_finish (flacenc->encoder);
1532       }
1533 #else
1534       if (FLAC__stream_encoder_get_state (flacenc->encoder) !=
1535           FLAC__STREAM_ENCODER_UNINITIALIZED) {
1536         flacenc->stopped = TRUE;
1537         FLAC__stream_encoder_finish (flacenc->encoder);
1538       }
1539 #endif
1540       flacenc->offset = 0;
1541       flacenc->samples_written = 0;
1542       flacenc->channels = 0;
1543       flacenc->depth = 0;
1544       flacenc->sample_rate = 0;
1545       if (flacenc->meta) {
1546         FLAC__metadata_object_delete (flacenc->meta[0]);
1547         g_free (flacenc->meta);
1548         flacenc->meta = NULL;
1549       }
1550       g_list_foreach (flacenc->headers, (GFunc) gst_mini_object_unref, NULL);
1551       g_list_free (flacenc->headers);
1552       flacenc->headers = NULL;
1553       flacenc->got_headers = FALSE;
1554       flacenc->last_flow = GST_FLOW_OK;
1555       break;
1556     case GST_STATE_CHANGE_READY_TO_NULL:
1557     default:
1558       break;
1559   }
1560
1561   return ret;
1562 }