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